loading
Picture of Color changing display
Custom made Multiple color display.

Have you ever wanted a display that is a little larger then one you can buy?
Have you ever wanted to make a display the way you wanted it?

Me too!

This is how I made a custom multiple color display that I use for temperature.
 
Remove these adsRemove these ads by Signing Up

Step 1: Supplies and Tools

Picture of Supplies and Tools
Casting Epoxy.JPG
Supplies:
Safety Glasses, Gloves, Etc. ( Be safe )
Mold Putty
Clear casting epoxy
Epoxy
Pink Erasers
Graph paper
Mixing cups
Stirring sticks
Super glue
Wax paper
Black Enamel Model paint
.093 inch Acrylic sheeting
A bit of balsa wood
Tape
Stand offs

Electronics supplies:
1- Arduino or other microcontroller
9- 74HC374
72- 470 ohm resistors
46- Surface mount red/green leds
46- Surface mount blue leds
3- 0.1uf Capacitors
Proto board
Assorted size wires
5 volt power supply. I used a phone charger.

Tools:
Scissors
Solder Iron
Solder
Needle nose pliers
Wire cutter
Wire stripper
Pencil
Dremel/Cutter
Assorted Sand paper
Marker
Razor blade
Tweezers
Hot glue gun
Assorted other tools

Step 2: Style

Picture of Style
Graph paper layout.JPG
Eraser and razor.JPG
Eraser cut out 1.JPG
Decide what style of digit you like best.

This is easiest to lay out on a piece of graph paper.

You can draw a few different styles. Though there really are only two styles I know of.

Straight up and down and slightly angled.

I like the slightly angled look.

Draw it out on your graph paper and using a razor blade cut out the individual pieces.

The pieces of graph paper are then placed on a large eraser so the eraser can be cut to shape.

For the decimal placed I ripped the eraser off the back of a pencil.
Perfect circle : )

Step 3: Make the mold

Picture of Make the mold
Eraser glued and balsa.JPG
Mold made.JPG
Attach the cut pieces of eraser and the bit you pulled off the back of a pencil to a piece of card stock or poster board with some glue.

I used super glue and it held nicely but don’t get it on your fingers. That holds a little too nicely.

Then use some hot glue and a little balsa wood ( or whatever you have there ) to make an edging.

This all needs to be pretty sturdy because you will be pressing some silicone mold making material down into it with some force so make it strong.

Once you have it all glued down the way you want it mix up your silicone mold material and mash it to make a nice mold.

Step 4: Make the digits

Picture of Make the digits
Digit in mold 2.JPG
Place your mold on a piece of wax paper to make clean up of any spills much easier.

Using careful measurement and following the package instructions ( safety middle ) mix up some resin and pour it into the mold.

Wait for it to be set up and repeat until you have three digits.

Once you remove the pieces from the mold use a razor and some sand paper to clean them up.

Step 5: Digit plate

Once you have all of the digits trimmed and sanded, lay them out on a piece of graph paper so you can get them straight and spaced the way you want them.

Once you have that worked out draw lines on the graph paper where you want the pieces.

Trace the line with a marker that will bleed through to the back side.

Flip the graph paper.

This is where you will be gluing your pieces.

Place a piece of wax paper under the graph paper and glue the pieces down with super glue.

Cut a few lengths of acrylic sheet to the width height and length to match your digits.

Glue the acrylic sheet in place with hot glue but only on the outside.

You don’t want hot glue in the finished display.

Once the sides are secure mix up another batch of resin and add about five drops of black enamel modeling paint.

Mix it well so you don’t have any light spots.

Step 6: Digit plate finish up

Picture of Digit plate finish up
Looking thru graph paper 2.JPG
Plate dried with scale.JPG
Trim off hot glue.JPG
Sanded display.JPG
After all the resin has had time to set up and harden you need to get all the paper and extra stuff removed.

Remove the wax paper.

Cut off the extra graph paper and remove the no longer needed hot glue.

Use water to remove the graph paper that the resin has stuck to.

Finish cleaning off the paper with a few different grades of sand paper.

Step 7: Making an led testing tool

If you have an alternate way of testing your leds you can skip this step.

It is much easier to fix problems with your leds as they arise rather then finding out at the end when you are trying to power the display up.

For that purpose I made a special tool for testing my leds as I went.

Get a pair of tweezers place some electrical tape on the back to help insulate the battery.

Tape two short pieces of wire near the end of the tweezers.

Coil the negative wire on the tape at the top of the tweezers.

Place a 3 volt battery negative side down onto the negative wire.

Place the positive wire over the top of the battery and finish securing it with tape.

Trim and bend the ends of the wire so they come together nicely for testing your leds.

Test a led with your amazing new tool.

Step 8: Adding the LEDs

I used surface mount leds for this project because they are small and have a nice flat surface to glue them to the back of my digits.

Each segment of each digit has two leds of Red green and blue.

Glue each led in place using super glue and a pair of tweezers.

Once you have all the leds glued on test them with your testing tool to be sure they all work.

Solder a ground wire for each digit.

Solder a positive wire for each.

Remember the positive goes to both leds of the same color in each segment.

Once you have all the positive wires soldered check that both of your leds are working.

If all is good use some clear nail polish to insulate, secure and support your wires.

Grab a piece of paper and your tester to make note of where each color wire ends up on the edges of the digit plate.

Step 9: Schematic

Picture of Schematic
Check out my schematic.

It is only shown for one color.

Step 10: 374 board

Using some proto board layout the parts for the board with the 74HC374s and the resistors.

Decide where you want the mounting holes then trim and drill the board.

Check out the segment pattern I used.

Solder like a mad scientist. Lots of soldering.

Check out my pictures if you need some help.

Step 11: Arduino board

Picture of Arduino board
Arduino cut out.JPG
Arduino cut out bottom.JPG
The board for the Arduino will be mounted to the back of everything and connects to the 374 board with pin connectors.

Keep track of which clock and data pins are where off the 374 board so you can match them up properly on the Arduino board.

I used a dremel and cut a slice in the proto board to accommodate the odd pattern on the one side of the Arduino.

Step 12: Programs

Picture of Programs
If you don’t load any code and power the whole thing you may get something like what you see in the picture.

I wrote a few different programs to get this display working the way I wanted it.

I am including them however if you only need the finished program it is the last one.

The first two programs for testing are done in what I call long hand. They don’t use look up tables or anything like that.
First one runs through a number with each color then runs through a little flashing of individual segments before starting all over.
The second one is just segment flashing.

The last one is the code I am currently running in my finished display.
It uses an LM335 as the temperature sensor.

Step 13: Program 1

// serial output to 74hc374
// 2013
// Ray McQueen
// Used for testing custom color temp display
//
// Blanks display first
//
// Test color of each digit
//
// Some cool flashing and changing next
//
// Long hand. No tables used in this one.
//
// No temperature is displayed.
//
const int blue_data = 13; //74xx374 pin3
const int red_data = 12; //74xx374 pin3
const int green_data = 11; //74xx374 pin3
const int blue_clk3 = 10; // blue 3rd digit
const int blue_clk2 = 9; // blue 2nd digit
const int blue_clk1 = 8; // blue 1st digit
const int red_clk3 = 7; // red 3rd digit
const int red_clk2 = 6; // red 2nd digit
const int red_clk1 = 5; // red 1st digit
const int green_clk3 = 4; // green 3rd digit
const int green_clk2 = 3; // green 2nd digit
const int green_clk1 = 2; // green 1st digit
//
//
//
int Blank = 0; // Blanks 0
int All_on = 255; // All on 255
int Zero = 252; // Zero
int One = 12; // One
int Two = 182; // Two
int Three = 158; // Three
int Four = 78; // Four
int Five = 218; // Five
int Six = 122; // Six
int Seven = 140; // Seven
int Eight = 254; // Eight
int Nine = 206; // Nine
int DP = 1; // Decimal Place
int Top = 128; // Top center segment
int Ltop = 64; // Left side top segment
int Lbot = 32; // Left side bottom segment
int Bot = 16; // Bottom segment
int Rbot = 8; // Right side bottom segment
int Rtop = 4; // Right side top segment
int Mid = 2; // Middle segment

//
int val = 500; //used for the delay
int val2 = 200; //
//
void setup() {
  pinMode(blue_data, OUTPUT); //define pin12 as output
  pinMode(red_data, OUTPUT); //define pin12 as output
  pinMode(green_data, OUTPUT); //define pin12 as output
  pinMode(blue_clk3, OUTPUT); //define pin12 as output
  pinMode(blue_clk2, OUTPUT); //define pin12 as output
  pinMode(blue_clk1, OUTPUT); //define pin12 as output
  pinMode(red_clk3, OUTPUT); //define pin12 as output
  pinMode(red_clk2, OUTPUT); //define pin12 as output
  pinMode(red_clk1, OUTPUT); //define pin12 as output
  pinMode(green_clk3, OUTPUT); //define pin12 as output
  pinMode(green_clk2, OUTPUT); //define pin12 as output
  pinMode(green_clk1, OUTPUT); //define pin12 as output
  //
}

void loop() {
  //
  // BLANK ALL DIGITS
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Blank); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk1, LSBFIRST, Blank); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk2, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk1, LSBFIRST, Blank); //
  //
  delay(val); //delay the amount of time stored in val
  //
  //
  // CHECK EACH COLOR IN EACH DIGIT
  // Start with Blue
  //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Zero); //
  delay(val); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Zero); //
  delay(val); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Zero); //
  delay(val); //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, One); //
  delay(val); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, One); //
  delay(val); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, One); //
  delay(val); //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Two); //
  delay(val); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Two); //
  delay(val); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Two); //
  delay(val); //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Three); //
  delay(val); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Three); //
  delay(val); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Three); //
  delay(val); //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Four); //
  delay(val); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Four); //
  delay(val); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Four); //
  delay(val); //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Five); //
  delay(val); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Five); //
  delay(val); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Five); //
  delay(val); //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Six); //
  delay(val); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Six); //
  delay(val); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Six); //
  delay(val); //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Seven); //
  delay(val); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Seven); //
  delay(val); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Seven); //
  delay(val); //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Eight); //
  delay(val); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Eight); //
  delay(val); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Eight); //
  delay(val); //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Nine); //
  delay(val); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Nine); //
  delay(val); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Nine); //
  delay(val); //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, DP); //
  delay(val); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, DP); //
  delay(val); //
  //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Blank); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  delay(val); //
  //
  //
  // CHECK EACH COLOR IN EACH DIGIT
  // Red
  //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, Zero); //
  delay(val); //
  shiftOut(red_data, red_clk2, LSBFIRST, Zero); //
  delay(val); //
  shiftOut(red_data, red_clk1, LSBFIRST, Zero); //
  delay(val); //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, One); //
  delay(val); //
  shiftOut(red_data, red_clk2, LSBFIRST, One); //
  delay(val); //
  shiftOut(red_data, red_clk1, LSBFIRST, One); //
  delay(val); //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, Two); //
  delay(val); //
  shiftOut(red_data, red_clk2, LSBFIRST, Two); //
  delay(val); //
  shiftOut(red_data, red_clk1, LSBFIRST, Two); //
  delay(val); //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, Three); //
  delay(val); //
  shiftOut(red_data, red_clk2, LSBFIRST, Three); //
  delay(val); //
  shiftOut(red_data, red_clk1, LSBFIRST, Three); //
  delay(val); //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, Four); //
  delay(val); //
  shiftOut(red_data, red_clk2, LSBFIRST, Four); //
  delay(val); //
  shiftOut(red_data, red_clk1, LSBFIRST, Four); //
  delay(val); //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, Five); //
  delay(val); //
  shiftOut(red_data, red_clk2, LSBFIRST, Five); //
  delay(val); //
  shiftOut(red_data, red_clk1, LSBFIRST, Five); //
  delay(val); //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, Six); //
  delay(val); //
  shiftOut(red_data, red_clk2, LSBFIRST, Six); //
  delay(val); //
  shiftOut(red_data, red_clk1, LSBFIRST, Six); //
  delay(val); //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, Seven); //
  delay(val); //
  shiftOut(red_data, red_clk2, LSBFIRST, Seven); //
  delay(val); //
  shiftOut(red_data, red_clk1, LSBFIRST, Seven); //
  delay(val); //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, Eight); //
  delay(val); //
  shiftOut(red_data, red_clk2, LSBFIRST, Eight); //
  delay(val); //
  shiftOut(red_data, red_clk1, LSBFIRST, Eight); //
  delay(val); //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, Nine); //
  delay(val); //
  shiftOut(red_data, red_clk2, LSBFIRST, Nine); //
  delay(val); //
  shiftOut(red_data, red_clk1, LSBFIRST, Nine); //
  delay(val); //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, DP); //
  delay(val); //
  shiftOut(red_data, red_clk2, LSBFIRST, DP); //
  delay(val); //
  //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk1, LSBFIRST, Blank); //
  delay(val); //
  //
  //
  // CHECK EACH COLOR IN EACH DIGIT
  // Green
  //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Zero); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Zero); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Zero); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, One); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, One); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, One); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Two); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Two); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Two); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Three); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Three); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Three); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Four); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Four); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Four); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Five); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Five); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Five); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Six); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Six); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Six); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Seven); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Seven); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Seven); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Eight); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Eight); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Eight); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Nine); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Nine); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Nine); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, DP); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, DP); //
  delay(val); //
  //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk2, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk1, LSBFIRST, Blank); //
  delay(val); //
  //
  //
  // CHECK EACH COLOR IN EACH DIGIT
  // Yellow
  //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Zero); //
  shiftOut(red_data, red_clk3, LSBFIRST, Zero); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Zero); //
  shiftOut(red_data, red_clk2, LSBFIRST, Zero); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Zero); //
  shiftOut(red_data, red_clk1, LSBFIRST, Zero); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, One); //
  shiftOut(red_data, red_clk3, LSBFIRST, One); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, One); //
  shiftOut(red_data, red_clk2, LSBFIRST, One); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, One); //
  shiftOut(red_data, red_clk1, LSBFIRST, One); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Two); //
  shiftOut(red_data, red_clk3, LSBFIRST, Two); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Two); //
  shiftOut(red_data, red_clk2, LSBFIRST, Two); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Two); //
  shiftOut(red_data, red_clk1, LSBFIRST, Two); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Three); //
  shiftOut(red_data, red_clk3, LSBFIRST, Three); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Three); //
  shiftOut(red_data, red_clk2, LSBFIRST, Three); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Three); //
  shiftOut(red_data, red_clk1, LSBFIRST, Three); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Four); //
  shiftOut(red_data, red_clk3, LSBFIRST, Four); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Four); //
  shiftOut(red_data, red_clk2, LSBFIRST, Four); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Four); //
  shiftOut(red_data, red_clk1, LSBFIRST, Four); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Five); //
  shiftOut(red_data, red_clk3, LSBFIRST, Five); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Five); //
  shiftOut(red_data, red_clk2, LSBFIRST, Five); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Five); //
  shiftOut(red_data, red_clk1, LSBFIRST, Five); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Six); //
  shiftOut(red_data, red_clk3, LSBFIRST, Six); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Six); //
  shiftOut(red_data, red_clk2, LSBFIRST, Six); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Six); //
  shiftOut(red_data, red_clk1, LSBFIRST, Six); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Seven); //
  shiftOut(red_data, red_clk3, LSBFIRST, Seven); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Seven); //
  shiftOut(red_data, red_clk2, LSBFIRST, Seven); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Seven); //
  shiftOut(red_data, red_clk1, LSBFIRST, Seven); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Eight); //
  shiftOut(red_data, red_clk3, LSBFIRST, Eight); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Eight); //
  shiftOut(red_data, red_clk2, LSBFIRST, Eight); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Eight); //
  shiftOut(red_data, red_clk1, LSBFIRST, Eight); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Nine); //
  shiftOut(red_data, red_clk3, LSBFIRST, Nine); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, Nine); //
  shiftOut(red_data, red_clk2, LSBFIRST, Nine); //
  delay(val); //
  shiftOut(green_data, green_clk1, LSBFIRST, Nine); //
  shiftOut(red_data, red_clk1, LSBFIRST, Nine); //
  delay(val); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, DP); //
  shiftOut(red_data, red_clk3, LSBFIRST, DP); //
  delay(val); //
  shiftOut(green_data, green_clk2, LSBFIRST, DP); //
  shiftOut(red_data, red_clk2, LSBFIRST, DP); //
  delay(val); //
  //
  //
  shiftOut(green_data, green_clk1, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk1, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk2, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk3, LSBFIRST, Blank); //
  delay(val); //
  //
  //
  // CHECK EACH COLOR IN EACH DIGIT
  // Funky Flashing for fun.
  // Blue in a circle
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Top); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Top); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Blank); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Top); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  delay(val2); //
  //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Ltop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Lbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  delay(val2); //
  //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Bot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Bot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Blank); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Bot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  delay(val2); //
  //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Rbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Rtop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  delay(val2); //
  //
  //
  // *********
  //
  // CHECK EACH COLOR IN EACH DIGIT
  // Funky Flashing for fun.
  // Blue in a circle
  // Red in a small circle
  // Green in a small circle
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Top); //
  shiftOut(red_data, red_clk2, LSBFIRST, Top); //
  shiftOut(green_data, green_clk1, LSBFIRST, Top); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Ltop); //
  shiftOut(green_data, green_clk1, LSBFIRST, Ltop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Top); //
  shiftOut(red_data, red_clk2, LSBFIRST, Lbot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Lbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Bot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Bot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Top); //
  shiftOut(red_data, red_clk2, LSBFIRST, Rbot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Rbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Rtop); //
  shiftOut(green_data, green_clk1, LSBFIRST, Rtop); //
  delay(val2); //
  //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Ltop); //
  shiftOut(red_data, red_clk2, LSBFIRST, Top); //
  shiftOut(green_data, green_clk1, LSBFIRST, Top); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Ltop); //
  shiftOut(green_data, green_clk1, LSBFIRST, Ltop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Lbot); //
  shiftOut(red_data, red_clk2, LSBFIRST, Lbot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Lbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Bot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Bot); //
  delay(val2); //
  //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Bot); //
  shiftOut(red_data, red_clk2, LSBFIRST, Rbot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Rbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Rtop); //
  shiftOut(green_data, green_clk1, LSBFIRST, Rtop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Bot); //
  shiftOut(red_data, red_clk2, LSBFIRST, Top); //
  shiftOut(green_data, green_clk1, LSBFIRST, Top); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Ltop); //
  shiftOut(green_data, green_clk1, LSBFIRST, Ltop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Bot); //
  shiftOut(red_data, red_clk2, LSBFIRST, Lbot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Lbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Bot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Bot); //
  delay(val2); //
  //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Rbot); //
  shiftOut(red_data, red_clk2, LSBFIRST, Rbot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Rbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Rtop); //
  shiftOut(green_data, green_clk1, LSBFIRST, Rtop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Rtop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  delay(val2); //
  //
  //
  //
}

Step 14: Program 2

// serial output to 74hc374
// 2013
// Ray McQueen
// Used for testing custom color temp display
//
// Blanks display first
//
// Some cool flashing and changing
//
// Long hand. No tables used in this one.
//
// No temperature is displayed.
//
const int blue_data = 13; //74xx374 pin3
const int red_data = 12; //74xx374 pin3
const int green_data = 11; //74xx374 pin3
const int blue_clk3 = 10; // blue 3rd digit
const int blue_clk2 = 9; // blue 2nd digit
const int blue_clk1 = 8; // blue 1st digit
const int red_clk3 = 7; // red 3rd digit
const int red_clk2 = 6; // red 2nd digit
const int red_clk1 = 5; // red 1st digit
const int green_clk3 = 4; // green 3rd digit
const int green_clk2 = 3; // green 2nd digit
const int green_clk1 = 2; // green 1st digit
//
//
//
int Blank = 0; // Blanks 0
int All_on = 255; // All on 255
int Zero = 252; // Zero
int One = 12; // One
int Two = 182; // Two
int Three = 158; // Three
int Four = 78; // Four
int Five = 218; // Five
int Six = 122; // Six
int Seven = 140; // Seven
int Eight = 254; // Eight
int Nine = 206; // Nine
int DP = 1; // Decimal Place
int Top = 128; // Top center segment
int Ltop = 64; // Left side top segment
int Lbot = 32; // Left side bottom segment
int Bot = 16; // Bottom segment
int Rbot = 8; // Right side bottom segment
int Rtop = 4; // Right side top segment
int Mid = 2; // Middle segment

//
int val = 500; //used for the delay
int val2 = 150; //
int circle = 0; // used for number of times to loop
//
void setup() {
  pinMode(blue_data, OUTPUT); //define pin12 as output
  pinMode(red_data, OUTPUT); //define pin12 as output
  pinMode(green_data, OUTPUT); //define pin12 as output
  pinMode(blue_clk3, OUTPUT); //define pin12 as output
  pinMode(blue_clk2, OUTPUT); //define pin12 as output
  pinMode(blue_clk1, OUTPUT); //define pin12 as output
  pinMode(red_clk3, OUTPUT); //define pin12 as output
  pinMode(red_clk2, OUTPUT); //define pin12 as output
  pinMode(red_clk1, OUTPUT); //define pin12 as output
  pinMode(green_clk3, OUTPUT); //define pin12 as output
  pinMode(green_clk2, OUTPUT); //define pin12 as output
  pinMode(green_clk1, OUTPUT); //define pin12 as output
  //
}

void loop() {
  //
  // BLANK ALL DIGITS
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Blank); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  //
  shiftOut(red_data, red_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk1, LSBFIRST, Blank); //
  //
  shiftOut(green_data, green_clk3, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk2, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk1, LSBFIRST, Blank); //
  //
  delay(val); //delay the amount of time stored in val
  //
  //
  // Flashing for fun.
  //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Top); //
  shiftOut(red_data, red_clk3, LSBFIRST, Rtop); //
  shiftOut(green_data, green_clk3, LSBFIRST, Rbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk3, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk3, LSBFIRST, Blank); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Top); //
  shiftOut(red_data, red_clk3, LSBFIRST, Top); //
  shiftOut(green_data, green_clk3, LSBFIRST, Rtop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk3, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk3, LSBFIRST, Blank); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Top); //
  shiftOut(red_data, red_clk2, LSBFIRST, Top); //
  shiftOut(green_data, green_clk3, LSBFIRST, Top); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk3, LSBFIRST, Blank); //
  delay(val2); //
  //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Ltop); //
  shiftOut(red_data, red_clk1, LSBFIRST, Top); //
  shiftOut(green_data, green_clk2, LSBFIRST, Top); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk1, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk2, LSBFIRST, Blank); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Lbot); //
  shiftOut(red_data, red_clk1, LSBFIRST, Ltop); //
  shiftOut(green_data, green_clk1, LSBFIRST, Top); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk1, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk1, LSBFIRST, Blank); //
  delay(val2); //
  //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Bot); //
  shiftOut(red_data, red_clk1, LSBFIRST, Lbot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Ltop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk1, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk1, LSBFIRST, Blank); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Bot); //
  shiftOut(red_data, red_clk1, LSBFIRST, Bot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Lbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk1, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk1, LSBFIRST, Blank); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Bot); //
  shiftOut(red_data, red_clk2, LSBFIRST, Bot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Bot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk1, LSBFIRST, Blank); //
  delay(val2); //
  //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Rbot); //
  shiftOut(red_data, red_clk3, LSBFIRST, Bot); //
  shiftOut(green_data, green_clk2, LSBFIRST, Bot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk3, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk2, LSBFIRST, Blank); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Rtop); //
  shiftOut(red_data, red_clk3, LSBFIRST, Rbot); //
  shiftOut(green_data, green_clk3, LSBFIRST, Bot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk3, LSBFIRST, Blank); //
  shiftOut(green_data, green_clk3, LSBFIRST, Blank); //
  delay(val2); //
  //
  //
  // *********
  //
  // CHECK EACH COLOR IN EACH DIGIT
  // Funky Flashing for fun.
  // Blue in a circle
  // Red in a small circle
  // Green in a small circle
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Top); //
  shiftOut(red_data, red_clk2, LSBFIRST, Top); //
  shiftOut(green_data, green_clk1, LSBFIRST, Top); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Ltop); //
  shiftOut(green_data, green_clk1, LSBFIRST, Ltop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Top); //
  shiftOut(red_data, red_clk2, LSBFIRST, Lbot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Lbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Bot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Bot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Top); //
  shiftOut(red_data, red_clk2, LSBFIRST, Rbot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Rbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Rtop); //
  shiftOut(green_data, green_clk1, LSBFIRST, Rtop); //
  delay(val2); //
  //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Ltop); //
  shiftOut(red_data, red_clk2, LSBFIRST, Top); //
  shiftOut(green_data, green_clk1, LSBFIRST, Top); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Ltop); //
  shiftOut(green_data, green_clk1, LSBFIRST, Ltop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Lbot); //
  shiftOut(red_data, red_clk2, LSBFIRST, Lbot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Lbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Bot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Bot); //
  delay(val2); //
  //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Bot); //
  shiftOut(red_data, red_clk2, LSBFIRST, Rbot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Rbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Rtop); //
  shiftOut(green_data, green_clk1, LSBFIRST, Rtop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Bot); //
  shiftOut(red_data, red_clk2, LSBFIRST, Top); //
  shiftOut(green_data, green_clk1, LSBFIRST, Top); //
  delay(val2); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Ltop); //
  shiftOut(green_data, green_clk1, LSBFIRST, Ltop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Bot); //
  shiftOut(red_data, red_clk2, LSBFIRST, Lbot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Lbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Bot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Bot); //
  delay(val2); //
  //
  //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Rbot); //
  shiftOut(red_data, red_clk2, LSBFIRST, Rbot); //
  shiftOut(green_data, green_clk1, LSBFIRST, Rbot); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  shiftOut(red_data, red_clk2, LSBFIRST, Rtop); //
  shiftOut(green_data, green_clk1, LSBFIRST, Rtop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Rtop); //
  delay(val2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, Blank); //
  delay(val2); //
  //
  //
  //
  // loop 20 times here
  // This is my favorite one :)
  for (circle = 0; circle < 20; circle++) {
    //
    shiftOut(blue_data, blue_clk3, LSBFIRST, Top); //
    shiftOut(red_data, red_clk2, LSBFIRST, Top); //
    shiftOut(green_data, green_clk1, LSBFIRST, Top); //
    delay(val2); //
    shiftOut(blue_data, blue_clk3, LSBFIRST, Ltop); //
    shiftOut(red_data, red_clk2, LSBFIRST, Ltop); //
    shiftOut(green_data, green_clk1, LSBFIRST, Ltop); //
    delay(val2); //
    shiftOut(blue_data, blue_clk3, LSBFIRST, Lbot); //
    shiftOut(red_data, red_clk2, LSBFIRST, Lbot); //
    shiftOut(green_data, green_clk1, LSBFIRST, Lbot); //
    delay(val2); //
    shiftOut(blue_data, blue_clk3, LSBFIRST, Bot); //
    shiftOut(red_data, red_clk2, LSBFIRST, Bot); //
    shiftOut(green_data, green_clk1, LSBFIRST, Bot); //
    delay(val2); //
    shiftOut(blue_data, blue_clk3, LSBFIRST, Rbot); //
    shiftOut(red_data, red_clk2, LSBFIRST, Rbot); //
    shiftOut(green_data, green_clk1, LSBFIRST, Rbot); //
    delay(val2); //
    shiftOut(blue_data, blue_clk3, LSBFIRST, Rtop); //
    shiftOut(red_data, red_clk2, LSBFIRST, Rtop); //
    shiftOut(green_data, green_clk1, LSBFIRST, Rtop); //
    delay(val2); //
    shiftOut(blue_data, blue_clk3, LSBFIRST, Top); //
    shiftOut(red_data, red_clk2, LSBFIRST, Top); //
    shiftOut(green_data, green_clk1, LSBFIRST, Top); //
    //
    //
    shiftOut(blue_data, blue_clk2, LSBFIRST, Top); //
    shiftOut(red_data, red_clk1, LSBFIRST, Top); //
    shiftOut(green_data, green_clk3, LSBFIRST, Top); //
    delay(val2); //
    shiftOut(blue_data, blue_clk2, LSBFIRST, Ltop); //
    shiftOut(red_data, red_clk1, LSBFIRST, Ltop); //
    shiftOut(green_data, green_clk3, LSBFIRST, Ltop); //
    delay(val2); //
    shiftOut(blue_data, blue_clk2, LSBFIRST, Lbot); //
    shiftOut(red_data, red_clk1, LSBFIRST, Lbot); //
    shiftOut(green_data, green_clk3, LSBFIRST, Lbot); //
    delay(val2); //
    shiftOut(blue_data, blue_clk2, LSBFIRST, Bot); //
    shiftOut(red_data, red_clk1, LSBFIRST, Bot); //
    shiftOut(green_data, green_clk3, LSBFIRST, Bot); //
    delay(val2); //
    shiftOut(blue_data, blue_clk2, LSBFIRST, Rbot); //
    shiftOut(red_data, red_clk1, LSBFIRST, Rbot); //
    shiftOut(green_data, green_clk3, LSBFIRST, Rbot); //
    delay(val2); //
    shiftOut(blue_data, blue_clk2, LSBFIRST, Rtop); //
    shiftOut(red_data, red_clk1, LSBFIRST, Rtop); //
    shiftOut(green_data, green_clk3, LSBFIRST, Rtop); //
    delay(val2); //
    shiftOut(blue_data, blue_clk2, LSBFIRST, Top); //
    shiftOut(red_data, red_clk1, LSBFIRST, Top); //
    shiftOut(green_data, green_clk3, LSBFIRST, Top); //
    //
    //
    shiftOut(blue_data, blue_clk1, LSBFIRST, Top); //
    shiftOut(red_data, red_clk3, LSBFIRST, Top); //
    shiftOut(green_data, green_clk2, LSBFIRST, Top); //
    delay(val2); //
    shiftOut(blue_data, blue_clk1, LSBFIRST, Ltop); //
    shiftOut(red_data, red_clk3, LSBFIRST, Ltop); //
    shiftOut(green_data, green_clk2, LSBFIRST, Ltop); //
    delay(val2); //
    shiftOut(blue_data, blue_clk1, LSBFIRST, Lbot); //
    shiftOut(red_data, red_clk3, LSBFIRST, Lbot); //
    shiftOut(green_data, green_clk2, LSBFIRST, Lbot); //
    delay(val2); //
    shiftOut(blue_data, blue_clk1, LSBFIRST, Bot); //
    shiftOut(red_data, red_clk3, LSBFIRST, Bot); //
    shiftOut(green_data, green_clk2, LSBFIRST, Bot); //
    delay(val2); //
    shiftOut(blue_data, blue_clk1, LSBFIRST, Rbot); //
    shiftOut(red_data, red_clk3, LSBFIRST, Rbot); //
    shiftOut(green_data, green_clk2, LSBFIRST, Rbot); //
    delay(val2); //
    shiftOut(blue_data, blue_clk1, LSBFIRST, Rtop); //
    shiftOut(red_data, red_clk3, LSBFIRST, Rtop); //
    shiftOut(green_data, green_clk2, LSBFIRST, Rtop); //
    delay(val2); //
    shiftOut(blue_data, blue_clk1, LSBFIRST, Top); //
    shiftOut(red_data, red_clk3, LSBFIRST, Top); //
    shiftOut(green_data, green_clk2, LSBFIRST, Top); //
    //
    //
    //
  }
  //
  //
  //
  //
}

Step 15: Main Program

/*

   Used for custom color temp display
   November 2013
   Ray McQueen

   Serial output to 74hc374

   Blanks display
   Blank leading 0's
   Minimum Temp is 0
   Display temp several times then do a fun flash
   Temp leveling to prevent large temp jumps



*/
//
const int blue_data = 13; //74xx374 pin3
const int red_data = 12; //74xx374 pin3
const int green_data = 11; //74xx374 pin3
const int blue_clk3 = 10; // blue 3rd digit
const int blue_clk2 = 9; // blue 2nd digit
const int blue_clk1 = 8; // blue 1st digit
const int red_clk3 = 7; // red 3rd digit
const int red_clk2 = 6; // red 2nd digit
const int red_clk1 = 5; // red 1st digit
const int green_clk3 = 4; // green 3rd digit
const int green_clk2 = 3; // green 2nd digit
const int green_clk1 = 2; // green 1st digit
//
int dig_it1 = 0; // First digit of display
int dig_it2 = 0; // Second digit of display
int dig_it3 = 0; // Third digit of display
//
int data_1 = 0;// First data  100 count
int data_2 = 0;// Second data  10 count
int data_3 = 0;// Third data    1 count
//
int test_test = 0;// Store number for testing
int tmprtr = 0;// For the temperature reading
int tmprtr_old = 0;// Last temp reading
int tmprtr_new = 0;// This temp reading
float tmprtr_read = 0;// Initial reading to do the math
//
//
int digits[] = {
  252, 12, 182, 158, 78, 218, 122, 140, 254, 206, 0
}; // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, Blank
//
//
int segments[] = {
  255, 1, 128, 64, 32, 16, 8, 4, 2, 0
}; // All on, Decimal Place, Top Center, Left Top,
//    Left Bottom, Bottom Center, Right Bottom, Right Top,
//    Middle Center, Blank
//
//
int del_short = 75;// Short delay for circling leds
int del_long = 1000;// Long delay
int circle = 0;// Times for circling
//
void setup() {
  pinMode(blue_data, OUTPUT); //define as output
  pinMode(red_data, OUTPUT); //define as output
  pinMode(green_data, OUTPUT); //define as output
  pinMode(blue_clk3, OUTPUT); //define as output
  pinMode(blue_clk2, OUTPUT); //define as output
  pinMode(blue_clk1, OUTPUT); //define as output
  pinMode(red_clk3, OUTPUT); //define as output
  pinMode(red_clk2, OUTPUT); //define as output
  pinMode(red_clk1, OUTPUT); //define as output
  pinMode(green_clk3, OUTPUT); //define as output
  pinMode(green_clk2, OUTPUT); //define as output
  pinMode(green_clk1, OUTPUT); //define as output
  //
  //
  // BLANK ALL DIGITS
  //
  data_1 = 10;// First data 10=Blank
  data_2 = 10;// Second data 10=Blank
  data_3 = 10;// Third data 10=Blank
  //
  blue_shift();// When clearing entire display you only need
  // to call one color shift because all color shifts clear
  // any other color before displaying themself. blue_shift
  // is used here but it can be any of the color shifts.
  //
  //
}
//
void loop() {
  //
  //
  for (circle = 0; circle < 60; circle++) {
    get_tmprtr();// Read the LM335 and convert to temperature
    temp_lvlr();// Prevents large temp jumps
    convert();// Break the temp out for proper display
    color_2_display();// Choose which color to display
    delay(del_long);// Delay
  }
  fun_ky_flash();// Do some fun flashing before doing temp again.
  //
  //
  // **  END OF MAIN LOOP **
  //
  //
}
//
//
//
void blue_shift() {
  //
  // Clears all other color digits first ... justin case.
  // This is to shift out for blue on the entire display
  //
  dig_it1 = 0;// 0 = 0000 0000 No leds on
  dig_it2 = 0;// 0 = 0000 0000 No leds on
  dig_it3 = 0;// 0 = 0000 0000 No leds on
  //
  shiftOut(red_data, red_clk1, LSBFIRST, dig_it1); //
  shiftOut(red_data, red_clk2, LSBFIRST, dig_it2); //
  shiftOut(red_data, red_clk3, LSBFIRST, dig_it3); //
  shiftOut(green_data, green_clk1, LSBFIRST, dig_it1); //
  shiftOut(green_data, green_clk2, LSBFIRST, dig_it2); //
  shiftOut(green_data, green_clk3, LSBFIRST, dig_it3); //
  //
  dig_it1 = (digits[data_1]);
  dig_it2 = (digits[data_2]);
  dig_it3 = (digits[data_3]);
  shiftOut(blue_data, blue_clk1, LSBFIRST, dig_it1); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, dig_it2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, dig_it3); //
  //
}
//
//
void red_shift() {
  //
  // Clears all other color digits first ... justin case.
  // This is to shift out red on the entire display
  //
  dig_it1 = 0;// 0 = 0000 0000 No leds on
  dig_it2 = 0;// 0 = 0000 0000 No leds on
  dig_it3 = 0;// 0 = 0000 0000 No leds on
  //
  shiftOut(blue_data, blue_clk1, LSBFIRST, dig_it1); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, dig_it2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, dig_it3); //
  shiftOut(green_data, green_clk1, LSBFIRST, dig_it1); //
  shiftOut(green_data, green_clk2, LSBFIRST, dig_it2); //
  shiftOut(green_data, green_clk3, LSBFIRST, dig_it3); //
  //
  dig_it1 = (digits[data_1]);
  dig_it2 = (digits[data_2]);
  dig_it3 = (digits[data_3]);
  shiftOut(red_data, red_clk1, LSBFIRST, dig_it1); //
  shiftOut(red_data, red_clk2, LSBFIRST, dig_it2); //
  shiftOut(red_data, red_clk3, LSBFIRST, dig_it3); //
  //
}
//
//
void green_shift() {
  //
  // Clears all other color digits first ... justin case.
  // This is to shift out green on the entire display
  //
  dig_it1 = 0;// 0 = 0000 0000 No leds on
  dig_it2 = 0;// 0 = 0000 0000 No leds on
  dig_it3 = 0;// 0 = 0000 0000 No leds on
  //
  shiftOut(red_data, red_clk1, LSBFIRST, dig_it1); //
  shiftOut(red_data, red_clk2, LSBFIRST, dig_it2); //
  shiftOut(red_data, red_clk3, LSBFIRST, dig_it3); //
  shiftOut(blue_data, blue_clk1, LSBFIRST, dig_it1); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, dig_it2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, dig_it3); //
  //
  dig_it1 = (digits[data_1]);
  dig_it2 = (digits[data_2]);
  dig_it3 = (digits[data_3]);
  shiftOut(green_data, green_clk1, LSBFIRST, dig_it1); //
  shiftOut(green_data, green_clk2, LSBFIRST, dig_it2); //
  shiftOut(green_data, green_clk3, LSBFIRST, dig_it3); //
  //
}
//
//
void yellow_shift() {
  //
  // Clears all other color digits first ... justin case.
  // This is to shift out yellow on the entire display
  //
  dig_it1 = 0;// 0 = 0000 0000 No leds on
  dig_it2 = 0;// 0 = 0000 0000 No leds on
  dig_it3 = 0;// 0 = 0000 0000 No leds on
  //
  shiftOut(blue_data, blue_clk1, LSBFIRST, dig_it1); //
  shiftOut(blue_data, blue_clk2, LSBFIRST, dig_it2); //
  shiftOut(blue_data, blue_clk3, LSBFIRST, dig_it3); //
  //
  dig_it1 = (digits[data_1]);
  dig_it2 = (digits[data_2]);
  dig_it3 = (digits[data_3]);
  shiftOut(green_data, green_clk1, LSBFIRST, dig_it1); //
  shiftOut(red_data, red_clk1, LSBFIRST, dig_it1); //
  shiftOut(green_data, green_clk2, LSBFIRST, dig_it2); //
  shiftOut(red_data, red_clk2, LSBFIRST, dig_it2); //
  shiftOut(green_data, green_clk3, LSBFIRST, dig_it3); //
  shiftOut(red_data, red_clk3, LSBFIRST, dig_it3); //
  //
}
//
//
//
//
void color_2_display() {
  //
  // Sets up for the color to be displayed
  //
  if ( tmprtr <= 49 ) {
    blue_shift();// Display it in blue
  }
  //
  if ( tmprtr >= 50 && tmprtr <= 59 ) {
    yellow_shift();// Display it in yellow
  }
  //
  if ( tmprtr >= 60 && tmprtr <= 79 ) {
    green_shift();// Display it in green
  }
  //
  if ( tmprtr >= 80 && tmprtr <= 89 ) {
    yellow_shift();// Display it in yellow
  }
  //
  if ( tmprtr >= 90 ) {
    red_shift();// Display it in red
  }
  //
}
//
//
void get_tmprtr() {
  //
  // Measure the temperature and make it useful
  //
  tmprtr_read = analogRead(A0);
  tmprtr_read = (((((tmprtr_read * (5.0 / 1024.0)) *100) - 273) * 1.8) + 32);
  tmprtr = (tmprtr_read);
  //
  // If the temp is too low leave it at 0
  if ( tmprtr_read <= 0 ) {
    tmprtr = 0;
  }
  //
}
//
//
//
//
void temp_lvlr() {
  //
  // Levels out the temp readings a bit
  // A new reading is compared to the last reading
  // If they are different it is determined that the
  // temp may only increase or decrease by 1 degree
  // per reading.
  // This will stop large temp jumps
  //
  tmprtr_new = tmprtr;// Get a copy of the newest reading
  // Check to see if temp is higher
  if (tmprtr_new > tmprtr_old) {
    tmprtr = ( tmprtr_old +1 );//
    tmprtr_old = tmprtr;//
  }
  // Check to see if temp is lower
  if (tmprtr_new < tmprtr_old) {
    tmprtr = ( tmprtr_old -1 );//
    tmprtr_old = tmprtr;//
  }
  // If temp is too low make it 0
  if ( tmprtr <= 0 ) {
    tmprtr = 0;
  }
  //
}
//
//
//
//
void convert() {
  //
  // Convert the reading to something this display can use
  //
  test_test = tmprtr;//copy contents to test_test for testing
  // Test 100s
  data_1 = 0;// Clear first digit 0XX
  while (test_test >= 100) {
    test_test = test_test - 100;
    data_1++;// First digit
  }
  data_2 = 0;// Clear second digit X0X
  while (test_test >= 10) {
    test_test = test_test - 10;
    data_2++;// Second digit
  }
  data_3 = test_test;// Everything left over XX0
  // Test to see if leading 0's and Blank.
  if (data_1 == 0) {
    data_1 = 10;// 10 = Blank in table
  }
  if (data_2 == 0) {
    data_2 = 10;// 10 = Blank in table
  }
  //
  // End testing
  // The number stored in test_test is now broken
  // out into three registers
  // data_1 // 100
  // data_2 //  10
  // data_3 //   1
  //
}
//
//
//
//
void fun_ky_flash() {
  // loop here
  // This is my favorite one :)
  for (circle = 0; circle < 10; circle++) {
    //
    shiftOut(blue_data, blue_clk3, LSBFIRST, segments[2]); // Top
    shiftOut(red_data, red_clk2, LSBFIRST, segments[2]); // Top
    shiftOut(green_data, green_clk1, LSBFIRST, segments[2]); // Top
    delay(del_short); //
    shiftOut(blue_data, blue_clk3, LSBFIRST, segments[3]); // Left Top
    shiftOut(red_data, red_clk2, LSBFIRST, segments[3]); // Left Top
    shiftOut(green_data, green_clk1, LSBFIRST, segments[3]); // Left Top
    delay(del_short); //
    shiftOut(blue_data, blue_clk3, LSBFIRST, segments[4]); // Left Bottom
    shiftOut(red_data, red_clk2, LSBFIRST, segments[4]); // Left Bottom
    shiftOut(green_data, green_clk1, LSBFIRST, segments[4]); // Left Bottom
    delay(del_short); //
    shiftOut(blue_data, blue_clk3, LSBFIRST, segments[5]); // Bottom
    shiftOut(red_data, red_clk2, LSBFIRST, segments[5]); // Bottom
    shiftOut(green_data, green_clk1, LSBFIRST, segments[5]); // Bottom
    delay(del_short); //
    shiftOut(blue_data, blue_clk3, LSBFIRST, segments[6]); // Right Bottom
    shiftOut(red_data, red_clk2, LSBFIRST, segments[6]); // Right Bottom
    shiftOut(green_data, green_clk1, LSBFIRST, segments[6]); // Right Bottom
    delay(del_short); //
    shiftOut(blue_data, blue_clk3, LSBFIRST, segments[7]); // Right Top
    shiftOut(red_data, red_clk2, LSBFIRST, segments[7]); // Right Top
    shiftOut(green_data, green_clk1, LSBFIRST, segments[7]); // Right Top
    delay(del_short); //
    shiftOut(blue_data, blue_clk3, LSBFIRST, segments[2]); // Top
    shiftOut(red_data, red_clk2, LSBFIRST, segments[2]); // Top
    shiftOut(green_data, green_clk1, LSBFIRST, segments[2]); // Top
    //
    //
    shiftOut(blue_data, blue_clk2, LSBFIRST, segments[2]); // Top
    shiftOut(red_data, red_clk1, LSBFIRST, segments[2]); // Top
    shiftOut(green_data, green_clk3, LSBFIRST, segments[2]); // Top
    delay(del_short); //
    shiftOut(blue_data, blue_clk2, LSBFIRST, segments[3]); // Left Top
    shiftOut(red_data, red_clk1, LSBFIRST, segments[3]); // Left Top
    shiftOut(green_data, green_clk3, LSBFIRST, segments[3]); // Left top
    delay(del_short); //
    shiftOut(blue_data, blue_clk2, LSBFIRST, segments[4]); //Left Bottom
    shiftOut(red_data, red_clk1, LSBFIRST, segments[4]); // Left Bottom
    shiftOut(green_data, green_clk3, LSBFIRST, segments[4]); // Left Bottom
    delay(del_short); //
    shiftOut(blue_data, blue_clk2, LSBFIRST, segments[5]); // Bottom
    shiftOut(red_data, red_clk1, LSBFIRST, segments[5]); // Bottom
    shiftOut(green_data, green_clk3, LSBFIRST, segments[5]); // Bottom
    delay(del_short); //
    shiftOut(blue_data, blue_clk2, LSBFIRST, segments[6]); //Right Bottom
    shiftOut(red_data, red_clk1, LSBFIRST, segments[6]); // Right Bottom
    shiftOut(green_data, green_clk3, LSBFIRST, segments[6]); // Right Bottom
    delay(del_short); //
    shiftOut(blue_data, blue_clk2, LSBFIRST, segments[7]); // Right Top
    shiftOut(red_data, red_clk1, LSBFIRST, segments[7]); // Right Top
    shiftOut(green_data, green_clk3, LSBFIRST, segments[7]); // Right Top
    delay(del_short); //
    shiftOut(blue_data, blue_clk2, LSBFIRST, segments[2]); // Top
    shiftOut(red_data, red_clk1, LSBFIRST, segments[2]); // Top
    shiftOut(green_data, green_clk3, LSBFIRST, segments[2]); // Top
    //
    //
    shiftOut(blue_data, blue_clk1, LSBFIRST, segments[2]); // Top
    shiftOut(red_data, red_clk3, LSBFIRST, segments[2]); // Top
    shiftOut(green_data, green_clk2, LSBFIRST, segments[2]); // Top
    delay(del_short); //
    shiftOut(blue_data, blue_clk1, LSBFIRST, segments[3]); // Left Top
    shiftOut(red_data, red_clk3, LSBFIRST, segments[3]); // Left Top
    shiftOut(green_data, green_clk2, LSBFIRST, segments[3]); // Left Top
    delay(del_short); //
    shiftOut(blue_data, blue_clk1, LSBFIRST, segments[4]); // Left Bottom
    shiftOut(red_data, red_clk3, LSBFIRST, segments[4]); // Left Bottom
    shiftOut(green_data, green_clk2, LSBFIRST, segments[4]); // Left Bottom
    delay(del_short); //
    shiftOut(blue_data, blue_clk1, LSBFIRST, segments[5]); // Bottom
    shiftOut(red_data, red_clk3, LSBFIRST, segments[5]); // Bottom
    shiftOut(green_data, green_clk2, LSBFIRST, segments[5]); // Bottom
    delay(del_short); //
    shiftOut(blue_data, blue_clk1, LSBFIRST, segments[6]); // Right Bottom
    shiftOut(red_data, red_clk3, LSBFIRST, segments[6]); // Right Bottom
    shiftOut(green_data, green_clk2, LSBFIRST, segments[6]); // Right Bottom
    delay(del_short); //
    shiftOut(blue_data, blue_clk1, LSBFIRST, segments[7]); // Right Top
    shiftOut(red_data, red_clk3, LSBFIRST, segments[7]); // Right Top
    shiftOut(green_data, green_clk2, LSBFIRST, segments[7]); // Right Top
    delay(del_short); //
    shiftOut(blue_data, blue_clk1, LSBFIRST, segments[2]); // Top
    shiftOut(red_data, red_clk3, LSBFIRST, segments[2]); // Top
    shiftOut(green_data, green_clk2, LSBFIRST, segments[2]); // Top
    //
    //
  }
  //
}
//
Ian016 months ago

This is pretty cool. It inspired me to build my own large 7-segment display using a very different technique, and I will probably post an instructable when I finish.

What's the point of having differently colored segments if you can't control which color each segment is?

schoktra1 year ago

First, AWESOME.

Second,I had a bit of a thought, if anyone knows if this will work or won't, please chime in and let me know. But what during the segment molding process you only fill it half way with resin then put in a thin layer of white matte drafting film to diffuse the light, then behind that with the rest of the space instead of using surface mounted LEDs maybe just use standard RGB leds and actually place them inside of the resin as it cures making sure to leave some of the lead sticking out of the resin. This way it sort of cures everything in place for less gluing later.

Last, maybe instead of just posting all of the code directly into the instructable use an online resource such as http://www.codepad.org to post your code there and just drop links? This would make it a lot easier to scroll back up while typing a response. For arduino code you should be able to get by just fine using the C language option to color code the syntax to make it easier to read since arduino code is based off C anyways :D

ray74 (author)  schoktra1 year ago

Thank you

I did a few experiments while building this. One of them was very similar to your idea with the RGB led. The led was encased in the resin and it wasn't very diffused. I didn't use a layer of white matte material though and that would help a lot I'm sure. I am going to add a few drops of white to the resin for the digits on my next one to see what that does.

I will keep that in mind for the code on my next instructable. Thank you :)

okami7621 year ago
I must admit this is a Really nice tutorial, especially the part about using the molds and resin for creating your own custom 7 segment display :)
Hope you create more creative and innovating projects in the future !
Dimsml1 year ago
I think that you can avoid the effect when individual LEDs can be seen by rubbing it with rough sandpaper before applying diodes. Or adding something to the mix to make it rather matte than clear.

Still, a nice project! It just makes me wonder, whether one will be able to make a dot-matrix display with RGB leds using this technique?

Or a 3D (sort of) display by putting LEDs at different depths, maybe?
ray74 (author)  Dimsml1 year ago
I tried the roughing with sand paper thing but the super glue fills in the small lines.
I thought the look was kind of old school and I liked that so I left it :)
When I do another one of these I am going to try adding a drop or so of white to see what it does for diffusing. I have thought about a dot matrix but have not tried yet.
Lots of pencils missing erasers :D
The 3D display sounds interesting. Try it and let me know how it goes. I bet you could make a whole new breed of led cube.
First off, nice job! Second if you are doing another, try experimenting with the leds on the side of the segments. Edge lighting should help get the diffusion you want.
cincygeek1 year ago
Awesome project! I love the idea of making and using a mold, very nice. Here's a (bad) picture of the Arduino-powered clock I built last summer to use in road races. It's 6 digits, each 11" tall (case is 5 ft long). Had hoped it would be my first Instructable, but was stretched just to get the project done in time. I tried 5 or 6 different approaches, including potted epoxy, but found it was fairly heavy in my application, and it didn't diffuse as well as I had hoped. I'm using LED strip lighting, 2 strips of 6 LEDs, 12 LEDs total,for each segment to get good brightness (still not great in direct sunlight) set back about 1" from the front in a homemade "plastic shadowbox" to separate the segments. I use a layer of diffusing contact paper plus a layer of dark tinting film in front. Happy to share details if anyone is interested. I look forward to seeing you try something even bigger!
http://www.instructables.com/files/deriv/F1A/1LTH/HOW0IHN3/F1A1LTHHOW0IHN3.SQUARE.jpg
Clock.jpg
ray74 (author)  cincygeek1 year ago
Thank you.
That is very cool.
I like how big it is.
You should post an instructable on it I would love to see it.
Rifath1 year ago
Awesome
ray74 (author)  Rifath1 year ago
Thank you.
TheGreatS1 year ago
Marvelous! That is the first time I have seen someone mold their own seven segment display, with erasers none the less.
To make it a bit more pleasant to scroll through all that code you could utilize a scroll box. There's a little tutorial at http://www.quackit.com/html/codes/html_scroll_box.cfm You will need to use the edit source button when editing the instructable.
ray74 (author)  TheGreatS1 year ago
Thank you. The erasers worked out really well :)
Thanks for the tip on the scroll box. I probably wont change it on this one but that is a great idea for my next one.
Sweet!
profort1 year ago
Brilliant
ray74 (author)  profort1 year ago
Thank you.
TSJWang1 year ago
You, deserve a favorite!
ray74 (author)  TSJWang1 year ago
Thank you very much.
T-K1 year ago
Dude bro this is a great idea!
I love the mini instructable for the LED tweezer-tester thing, I shall make one as soon as possible.
ray74 (author)  T-K1 year ago
Thank you. The LED tweezers really help. Glad you liked it. Post some pics of what you make. I would love to see them.
dam thats alot of wires
ray74 (author)  crazyscottnb1 year ago
Yes it is a lot of wires. LOL. That is what makes it so much fun :)
Very cool.
ray74 (author)  rleddington1 year ago
Thanks.
That is amazing!
ray74 (author)  FoamboardRC1 year ago
Thank you.
sbbrain1 year ago
Looks Great! I love the idea of making your own large seven segment displays with professional look. Any Chance of a video showing the display off?
ray74 (author)  sbbrain1 year ago
Thank you.