Introduction: LED Matrix Glasses: First Prototype
UPDATE: https://www.instructables.com/id/Rave-Shades-The-Self-Assembly-LED-Glasses-Kit/
Introduction:
I came up with this idea after seeing similar videos on the internet. I however have improved on the design. What separates my glasses from the others out there, is that mine use an external matrix driver and battery. What this means is, for the cost of having a cable down your back when wearing the device, you get a greatly improved battery life. This also allows the device to use ultra-bright 1210 LED's. Not only that, a full sized arduino can be used if you have one. This project uses cheap and easy to gain parts to allow you to create a one of a kind fancy dress party piece. These glasses do not obstruct your vision any more than the original shutter shades. Even with the glasses on turned on, no glare from the LEDs can be seen.
For me the most important thing about making these glasses has been, increasing my knowledge and attaining new skills. Here are some of the things I have learnt.
• Solder Surface mounted LEDs.
• Write my own C program and optimize it to store more visual effects.
• Using data arrays to store patterns and frames.
• Create an algorithm to shift out the data from a 3D array.
• Correctly control the chips of the driver circuit.
• Cascade shift registers.
• Use Microsoft Excel to my advantage to create many shortcuts whilst programming the on-screen visuals.
• Efficiently place components on vero board.
Step 1: Parts Bin:
- 200 pcs 1210 SMD LEDs, blue ones can be found here
- 1 pcs Black shutter shades, use these as I have provided a template for use with these glasses.
- 2 pcs PCB vero board, 90x127mm, found here
- Arduino nano, or alternative.
- 3 pcs 74HC595 8-Bit Shift Register, a pack of 10 can be found here
- 1 pcs HCF4017 Decade counter with 10 decoded output, a pack of 5 found here
- 8pcs BC337, a pack of 10 can be found here
- 24 pcs 1/4W resistors, 82ohms if using white, blue or green leds, or 150ohms if using red, orange or yellow leds. A pack of 100 resistors can be found here
- 8 pcs 1K 1/4W resistor can also be found via the above link
- 2 Meters of 40 way IDC 0.05 pitch multi-strand cable, found here
- 1 IDE hardrive cable, found here
- 1 project enclosure, it may be better to choose one after you have finished the driver and chosen your power supply.
- 1 pcs 4 x AA battery pack*
- 4 pcs AA batteries*
- Hot Glue sticks*
- SuperGlue*
- Solid core wire*
Step 2: Tool Box:
- Soldering Iron, preferable an adjustable one with a fine tip.
- Hot melt glue gun
- Side cutters
- Wire strippers
- Philips head screw driver
- Tweezers
- Scissors
- Drill
- Selection of drill bits
- Small rectangular file
- Small round file
- PC
- Sewing needle or bobby pin
- Pen
Step 3: Marking the Positions of the LED's:
- Download the attached pdf file and print it out.
- Remove both arms from the glasses using a small Philips screw driver.
- Center the glasses on one of the grids. There are two grids just in case you get something wrong later on.
- Draw an outline of the glasses in pen. (Image 2)
- Cut along your markings. (Image 3)
- Cut down the middle line of the grid to seperate each side.
- Lay down some tape with the sticky side up and place one of the half grids face down on the tape. (Image 4)
- Try to position the cut-out grid on the corresponding side of the glasses, making sure the the the horizontal lines are in the center of the slats of the glasses. (Image 5&6)
- Repeat steps 7 and 8 for the other side.
- When you are sure all is lined up, grab a sewing needle and press the tip on to each crossover of the grid, creating a small hole on the surface of the glasses at every point. (Image 8&9)
Attachments
Step 4: Attaching the LEDs:
- Use sticky tape to hold the glasses securely in place on, on your work surface.
- Drip some cooking oil onto a paper towel and wipe the prongs of your tweezers with a thin layer of oil. This will stop the LEDs from sticking to the tweezers when you carry out step 6.
- Clean the glasses with washing-up liquid and allow to dry. Do not touch the front of the glasses as grease from your hands will stop the superglue from working properly.
- Take an LED and locate the cathode, this can be determined by the recessed corner.
- Position several LEDs on your desk at a time with the recessed corner ie the cathode, away from you. Keep them close to the glasses to make transportation to the glasses quick and easy.
- Pick up one LED at a time and carefully blob some superglue onto the base and then place it on one of the dots made earlier with the pin.
- The superglue will not set immediately, so place the LED as quickly as possible and take the tweezers away. Then continue with the next one. The glue will start to set within a minute, so do not place another LED in a neighbouring spot for a couple of minutes so as not to disturb an unset LED.
- Repeat until LEDs cover every pin hole you made earlier.
- Allow the glue to cure for 24 hours in a dry, but ventilated area.
- Check that all LEDs are up the right way. The side with the recessed corner at the top of the glasses when worn* check the last photo of this segment.
- Have a good night sleep before attempting this.
- Do not consume any caffeine that day. I cannot emphasize how much of a difference this made.
- Make sure you work in a well-lit area.
Step 5: Soldering the LEDs: Cathode Rows & Anode Columns
WARNING: Work in a well ventilated space with eye protection when soldering the LEDs as the superglue will emit a toxic vapour.
Cathode Rows:
- Strip some multi-strand wire to reveal the individual strands of wire. You will need 8 of these strands and they should be approximately 7 inches long.
- Starting on the top row with the LED furthest to your right as you look at them take an individual strand of wire and solder it to the cathode (recessed corner).
- Solder this wire along the cathodes of the LED’s in that particular row and leave any excess wire attached. (Image 1)
- Repeat this for the next 2 rows and you should be left with 5 more rows with a gap between for the wearer's nose.
- Repeat steps 2&3 for the next 5 rows but this time cut off the excess wire when you get to nose gap and keep for later.
- The 5 bottom rows require an electrical bridge to be made around the gap for your nose using insulated wire. I used IDE cable as the individual wires are insulated and flexible. When bridging the gap follow the shape of the nose cut out otherwise they can't be worn.
- Use the excess wire that you had previously cut off and put to one side, to continue connecting the cathodes of the LEDs on that particular row.
- Visually check connections for errors. (Image 2)
Now it is time to solder the anodes together to create 24 columns of anodes. Once again follow these steps and use the diagrams and photos to help you:
- Take some IDE cable, seperate out 24 wires, each 7 inches long.
- Strip ~1 inch off one end of all 24 wires. (image 3)
- Strip a further N pieces of insulation, where N is 1 less than the number of LEDs in that particular column. Each piece of insulation should be 0.25 inch long. Remember to keep them on the strand of wire. (image 4)
- Solder the wire on to the anode (the side opposite to the one with the recessed corner) of the bottom LED of that column. (image 5)
- To help you in the next step bend a stiff piece of wire to roughly match that shown in image 6.
- Use the tool you just made to bend the rest of the wire around the other LEDs, soldering each one as you go. (images 7,8,9)
- Visually check connections for errors. It should look like Image 10.
Step 6: Glasses Data Cable:
- Take your 40 way IDC cable and take off 8 wires to leave a 32 way cable leaving the red indicator strip on the cable. Note: I have used IDC cable as it has more than one strand of metal per wire. This will have an increased life over an IDE cable. That is why I have only used IDE cable where it doesn't need to be flexed
- Stick the cable onto the outside of the glasses using hot melt glue, being sure to leave around 7 inches of cable ahead of the joint and the other 6 foot arrears of it. (Image 1)
- Start with the rows and split the cable down to 8 separate wires all the way to the glue joint.
- Solder the wires to the corresponding row. Use hot melt glue to hold in in place. (Image 2,3,4 & 5)
- TIP: lick your finger to shape the hot glue to a more streamline shape.
- Strip the remaining 24 wires.
- Solder the wire to the correct LED column. (Image 6)
- Hold the wires in place with more, hot melt glue using the same technique mentioned above to create a durable frame.
- Bulk up the joint where the cable meets the glasses. (Image 7)
Step 7: Securing the Head Strap:
- Remove the head strap from an old dust / voc mask but don't tear the elastic. I got mine from a 3M 4000 series mask
- Use some steel wire to attach the elastic to the side without the cable (Image 2 & 3)
- Bend the excess wire and hot glue it in place
- Put some wire around the elastic and then around the middle slat.
- Twist it tight but make sure you are not touching any LEDs wires or solder blobs (Image 4 & 5)
- Using duct tape or equivalent, bend and tape the data cable in a vertical position, to allow it down the back of your shirt when worn. (Image 7)
Step 8: Schematic Diagrams:
The first schematic is the matrix driver. This will allow the Arduino to control all 162 LEDs and with slight modification up to 192 LEDs. If you want to view the Schematic of the whole system download the PDF below, as the image here is a little pixelated.
Attachments
Step 9: Assembling the Matrix Driver: Shift Registers
- Take your vero board and lay it, copper side down with the copper strips in a horizontal position.
- Solder in a 74HC595 Chip with the indicator notch facing up. (image 1)
- Solder in a current limiting resistor from pin 15. I put some solid core wire insulation over the leg from pin 15 to save hassle later on. (image 2)
- Solder in the rest of the resistors ensuring they all straddle one hole. (image 3)
- Solder in a 74HC595 chip in the same orientation as before but leave 6 holes between each chip. (image 4)
- Repeat steps 3&4 for chip 2. (image 5)
- Solder in a 74HC595 chip as you did for chip 2 (same orientation + 6 hole gap)
- Repeat steps 3&4 for chip 3. (image 6)
Step 10: Assembling the Matrix Driver: Shift Registers Continued...
- Connect pins 10 and 16 together on each chip. (image 1)
- Connect pins 8 and 13 together on each chip. (image 2)
- Connect pin 9 of chip 1 to pin 14 of chip 2.
- Connect pin 9 of chip 2 to pin 14 of chip 3. (image 3)
- Connect pin 11 of chips 1, 2 & 3 together. I did this on the back of the board.
- Connect pin 12 of chips 1, 2 & 3 together. I did this on the back of the board.
- Look at image 6, it shows 8 connecting wires taking the output from chip 2 over to an area close to the output of chip 1.
- Now look at image 7, it shows where the output of all 3 shift chips and transistors could be.
- Using a small drill bit make 3 vertical lines of breaks in the 8 copper tracks, this is to separate each output. They have to be at least two holes apart.
- Strip and solder 16 pieces of wire to each output from chips 2 and 3.
- Route each wire neatly on the board and then solder it to the corresponding location in the output region. See image 8 for details.
- You should be left with 2 sets of connecting cables, one is for chip 2 and the other is for chip 3.
Step 11: Assembling the Matrix Driver: Decade Counter
- Solder in the 4017 decade counter, in line with the other chips and with the notch facing up. However it only needs a 3 hole, gap between it and chip 3.
- Connect pins 8 and 13 together on the decade / chip 4.
- Connect pin 13 of chip 4, to pin 8 of chip 3.
Step 12: Assembling the Matrix Driver: Decade Counter Continued......
- Find space on the board to put all 8 BC337s in line with each other. You will need 3 adjacent copper tracks and should start by soldering transistors along them. All tracks should have a like pin type, ie all collectors, or all base's or all emitters. This can be achieved by maintaining the same orientation of all transistors. You will need to leave 2 sets of holes before inserting the next transistor. This is because one of the holes on each track is required to isolate each transistor and the other is to insert the wires and the resistors. Image 1 shows a top view however you can also see an x-ray of the tracks and any required breaks in the tracks.
- Using a drill bit break the copper track that the collector and bases run on, leaving one hole for any wires or resistors to be soldered to. DO NOT DRILL THE TRACK THAT THE EMITTERS ARE ON, as this will be used to ground the transistors in the next step.
- Solder a wire from the track that the emitters are on, to pin 8 of any one of the chips. This will ground the transistors.
- Solder a 1K resistor into each of the 8 bases.
- Solder the other end of the resistor to an isolated section of track that has a minimum length of 2 holes.
- Solder a wire into the other hole on the above mentioned section of track and route it to the corresponding output of the decade counter. DO NOT FORGET OUTPUT 0 IS BEFORE OUTPUT 1. (Image 2, where Q is the output)
- Solder a wire from the collector of each transistor, to the output area. (Image 3)
Step 13: Assembling the Matrix Driver: Arduino Hook-Up
- Score a piece of board and snap it over an edge of a table.
- Insert the arduino.
- Solder the arduino in place.
- Connect pin 14 of shift chip 1 to pin 11 on the arduino.
- Connect pin 12 of any shift register to pin 10 on the arduino.
- Connect pin 11 of any shift register to pin 13 on the arduino.
- Connect pin 14 of the decade counter to pin 9 on the arduino.
- Connect pin 15 of the decade counter to pin 8 on the arduino.
Step 14: Housing the Matrix Driver:
- Work out where you are going to install everything in the box.
- Place the driver circuit inside the housing and mark up the location of the arduino's USB port.
- Drill 2 small holes for the USB port and file them into a single rectangular hole.
- Mark up the location of the power switch.
- Drill a hole for your power switch. If you do not have a larger enough drill bit you will have to file it out with a round file.
- Mark up the location of where the glasses cable will enter the box.
- Chain Drill a line for your ribbon cable and then file it out into a slit.
- Cut a length of PVC tube twice the length of the slit.
- Slice the tube down the middle and use it to make a grommet for the slit.
- If you have used ribbon cable for the glasses cable, spit the unused end into sections of 8. i.e. one for each chip.
- Thread it through the slit you made in the enclosure.
- Strip each of the 32 wires.
- Insert and solder one wire at a time into the correct section of the output region. (Image 15, the last one)
- Insert some plastic sheet if using a metal box and tack it and the driver in place with some hot melt glue. (Image 12&13)
- Glue the battery holder in place with hot melt glue
- Solder the black wire of the battery holder to GND on the arduino
- Insert the power switch.
- Solder a wire from the VIN on the arduino to the switch.
- Solder the red wire from the battery holder to the switch
- Insert some batteries and test to see if the arduino lights up. If the arduino has no lights review your wiring.
- Only hot glue wires in place after a test run with code.
Step 15: Upload the Code:
- Download the test code and open it.
- Paste the text into the arduino IDE
- Upload the test code.
- A sparkling rain pattern will fall down the screen.
- Start by opening the arduino IDE and pasting the attached code below into it..
- Look for the grey section of code with: // e.g. unsigned char your_new_animation [][8][3] {
- Remove the // e.g. from it and it should turn black.
- Right click on the Array Calculator v1 link below and select save link as.
- Open the downloaded file in Microsoft Excel.
- Copy the light blue box titled "on".
- Paste this where you would like a particular LED to be on, you can have any combination of LEDs just make sure you only paste inside the glasses silhouette.
- It does not work from color so you can't just fill the boxes with that color, you do have to copy either an on, or off box.
- When you have finished, copy the number below the glasses and paste it into the code below the "unsigned char [][8][3] {" line you just modified.
- This is the first frame of your animation. Repeat steps 5 to 8 for your other frames.
- When you get to your last frame replace the comma, with };
- Scroll down to the bottom of the code and you will find a grey "//e.g. run_animation(8,your_new_animation,11,12);"
- Remove //e.g. and again it should turn black.
- Change the number 11 to the number of frame your animation has.
- Change the number 12 to the number of loops you want to do.
- Decrease the number 8 to speed up your animation.
- You can rename your animation as long as you change it in the array at the top and down here.

Grand Prize in the
LED Contest with Elemental LED

Finalist in the
Hurricane Lasers Contest

Participated in the
Halloween Props Contest
116 Comments
10 years ago on Introduction
Hey everyone!
As some of you may remember, I brought up the possibility of using program memory to store animations a while back. Well, now I've completed my LED glasses and they're working, I've been able to work on this modification, and am happy to say I have it working now!
Currently, the frames are stored in static RAM, which is only 1024 bytes on the Arduino Nano. This modified code uses FLASH memory instead (with a much larger capacity of up to 32768 bytes, minus code space) using the PROGMEM command. This increases the animation frames you can store from about 40 frames (using SRAM) to a whopping 1000 frames (which is what I estimate you should be able to get using this FLASH program memory technique).
I've modified the original code provided by eXtreme Something and here it is. I've also added a little animation I put together.
Just copy and paste this code into the Arduino application developer, Verify it, and then Upload it to your Arduino and it should work.
Here it is:
/////////////////////////////////////////////////////////////////////////////////////////////
// LED Glasses code by Lok H. Wong
// ===============================
//
// Written 11/18/2012, based on code originally obtained from www.instructables.com.
//
// Code has been modified to take advantage of the PROGMEM command, which allows animations
// to be stored in program memory, instead of static Random Access Memory (SRAM). SRAM is
// limited to only 1024 bytes on Arduino Nano. Program memory, on the other hand, has up to
// a roomy 32768 bytes, minus the space your code takes, allowing for many more animation
// frames.
//
/////////////////////////////////////////////////////////////////////////////////////////////
int DataPin = 11; //shift input
int LatchPin = 10; //rstclk on shift
int ClockPin = 13; //srclk on shift
int clock = 9; //decade clk
int Reset = 8; //reset
unsigned char rain_P [][8][3] PROGMEM = { //In this example the animation is called rain,
{{0,2,4},{32,0,0},{1,0,16},{0,0,0},{0,0,64},{2,0,0},{0,0,4},{8,0,0}}, //Paste the array values you got from excel here
{{4,0,32},{0,2,4},{32,0,1},{1,0,16},{0,0,0},{0,0,64},{2,0,0},{0,0,0}},
{{0,0,0},{4,0,32},{0,2,4},{32,0,1},{1,0,16},{0,0,0},{0,0,64},{2,0,0}},
{{8,0,0},{0,0,0},{4,0,32},{0,2,4},{32,0,1},{1,0,16},{0,0,0},{0,0,64}},
{{0,0,0},{8,0,0},{0,0,0},{4,0,32},{0,2,4},{32,0,0},{1,0,16},{0,0,0}},
{{0,0,4},{8,0,0},{0,0,0},{4,0,32},{0,2,4},{32,0,0},{1,0,16},{0,0,0}},
{{2,0,0},{0,0,4},{8,0,0},{0,0,0},{4,0,32},{0,2,4},{32,0,0},{0,0,16}},
{{0,0,64},{2,0,0},{0,0,4},{8,0,0},{0,0,0},{4,0,32},{0,0,4},{0,0,0}},
{{1,0,16},{0,0,64},{2,0,0},{0,0,4},{8,0,0},{0,0,0},{4,0,32},{0,0,0}},
{{32,0,0},{1,0,16},{0,0,64},{2,0,0},{0,0,4},{8,0,0},{0,0,0},{4,0,32}},
{{0,0,0},{32,0,0},{1,0,16},{0,0,64},{2,0,0},{0,0,4},{8,0,0},{0,0,0}}
}; //When you get to the last frame of your animation, you need to replace the comma with };
unsigned char rotatebox_P [][8][3] PROGMEM = {
{{0,0,0},{63,0,252},{33,0,132},{33,0,132},{33,0,132},{33,0,132},{63,0,252},{0,0,0}},
{{24,0,96},{22,0,88},{33,128,134},{32,128,130},{65,1,4},{97,1,132},{26,0,104},{6,0,24}},
{{12,0,48},{18,0,72},{33,0,132},{64,129,2},{64,129,2},{33,0,132},{18,0,72},{12,0,48}},
{{6,0,24},{26,0,104},{97,1,132},{65,1,4},{32,128,130},{33,128,134},{22,0,88},{24,0,96}}
};
// unsigned char your_new_animation [][8][3] PROGMEM = {
//}; //When you get to the last frame of your animation, you need to replace the comma with };
//You can only have a limited amount of frames even if they are in different animations.
//If you have too many frames, the code won't start on the arduino, so you will have to reduce the amount of frames.
//An animation can be played an unlimited amount of times.
void setup()
{
pinMode(DataPin,OUTPUT); //Basic setup of pins etc
pinMode(ClockPin,OUTPUT);
pinMode(LatchPin,OUTPUT);
pinMode(clock,OUTPUT);
pinMode(Reset,OUTPUT);
digitalWrite(Reset,HIGH); //Reseting the decade to 0 as it can be at a random stage on start up
delayMicroseconds(5);
digitalWrite(Reset,LOW);
}
void run_animation_P (unsigned char frame_time,unsigned char frames[][8][3],unsigned char num_frames,unsigned char num_loops)
{ //My function called run_animation_P - this has been modified to use PROGMEM data
int i, x, y, z;
byte datasegment;
//The display algorithm shifts out the 3 numbers in the array to display row 1 and then drops down a line....
//and continues to output the data for that line. It drops down through each of the 8 rows then resets. It then does the next frame.
for(i=0; i < num_loops; i++){ //number of times to play full animation
for(x=0; x < num_frames; x++){ //number of frames in the animation
for(z=0; z < frame_time; z++){ //times to display each frame (why do we need this?)
for(y=0; y < 8; y++){ //cycle through each layer (controlled by the decade counter)
//write the LED row data to the shift registers for the current layer
digitalWrite(LatchPin, 0);
datasegment = pgm_read_byte(&(frames[x][y][2]));
shiftOut(DataPin, ClockPin, LSBFIRST, datasegment);
datasegment = pgm_read_byte(&(frames[x][y][1]));
shiftOut(DataPin, ClockPin, LSBFIRST, datasegment);
datasegment = pgm_read_byte(&(frames[x][y][0]));
shiftOut(DataPin, ClockPin, LSBFIRST, datasegment);
digitalWrite(LatchPin, 1);
delayMicroseconds(700); //wait
//zero out the shift registers
digitalWrite(LatchPin, 0);
shiftOut(DataPin, ClockPin, MSBFIRST, 0);
shiftOut(DataPin, ClockPin, MSBFIRST, 0);
shiftOut(DataPin, ClockPin, MSBFIRST, 0);
digitalWrite(LatchPin, 1);
//reset decade counter
digitalWrite(clock, 1);
digitalWrite(clock, 0);
}
digitalWrite(Reset, 1);
digitalWrite(Reset, 0);
}
}
}
}
void loop()
{
//Fill in this to call each of your animations: run_animation(frame time, animation title, number of frames in the animation, number of loops);
//e.g. run_animation_P(8, your_new_animation, 11, 12);
run_animation_P(12, rotatebox_P, 4, 30);
run_animation_P(4, rain_P, 11, 150);
}
Reply 7 years ago
sorry... i have built this fantastic project but with the command PROGMEM in arduino is not working... I have pasted in arduino the entire program... but not work.
The program is running if I delete the command PROGMEM. May be is it necessary to put a new library in arduino program?... May you help me pls?
sergho@libero.it
Ciao
Sergio
Reply 10 years ago on Introduction
Fantastic, I would test it but I sold them :D I am making another pair though
cheers
10 years ago on Introduction
Reply 10 years ago on Introduction
The test code will only work if your wiring is the same as mine, ie. by using the schematic. Unfortunately its not a universal code and won't work with a 12x9. Send me schematic diagram of your exact circuit and i might be able to help.
Reply 9 years ago on Introduction
hey man after 8 months later until today i finally got around to fixing my problem. i ended up making a new led matrix board and a new board for the decade counter, transistors and shift registers. The problem i had at first was that i connected the wires to the wrong pins on the arduino, but when i fixed that problem i encontered another problem which was atleast 4 or 5 rows wouldn't turn on. so i gave up on it. a couple of days ago i ended up figuring out that the reason to why those rows wouldn't turn on was because my dumb self wired the transistors all wrong. instead of connecting each row of l.e.d's to the connector node i ended up connecting it to the emitter node. -_- Anyhow thanks for a superb tutorial and trying to help me!
10 years ago on Introduction
COOL!!!!!
I want one, also brilliant
10 years ago on Introduction
Just another question, will this code work on an arduino uno as wel?
Thank you
10 years ago on Introduction
Hey nice work:)
I'm currently making this but there is one thing on the schematic that's a too little pixelated to read :( Just to be sure, row 1 is the top layer of the glasses and row 8 is the bottom layer of the glasses???
Cheers :)
10 years ago on Introduction
How difficult would this be for someone who has little experience in electronics? I've done basic wiring and soldering before but thats about it.
Scale from 1 to 10 with 1 being easy and 10 being extremely difficult.
Reply 10 years ago on Introduction
Its a little hard and really fiddly but I've done the electronics for you, so all you have to do is glue and solder it. Give it a try, whats the worst that can happen? so I would say 4
10 years ago on Introduction
Excellent tutorial! I'm in the process of soldering the leds now. Are there any tips on testing the soldered connections during the process? I'm concerned about my bridged connections over the nose (and the cathode rows)! Thank you!
Reply 10 years ago on Introduction
Try checking it with a continuity tester or resistance meter against the schematic diagram.
10 years ago on Introduction
Hi, I am so excited to make my own pair! I am just wondering what gauge the solid core wire must be? Thank you for making this awesome tutorial and sparking my interest in Electrical Engineering :)
Reply 10 years ago on Introduction
That's great to here! The solid core wire is 0.6 mm standard breadboard wire. Thank you for your interest and good luck !!!
10 years ago on Introduction
How would i be able to expand the matrix driver to control a 40x8 led matrix?
Reply 10 years ago on Introduction
Using more powerful transistors, so 40* 20mA is 800mA so they should be able to handle 800mA. You would have to have 5 shift registers and cascade them like be for, it pin 9 on chip 1 goes to pin 14 on chip 2 and you would need a different code. Also it will have a frame rate that is slower than my one. And you won't be able to store as many programs. Are you making a message board or a daft punk helmet or something because there are different ways of doing a matrix: http://www.youtube.com/watch?v=wTQM6VPTsQo , http://www.youtube.com/watch?v=mDXlQFcbWhA
Reply 10 years ago on Introduction
im interested in doing a daft punk helmet and thanks
10 years ago on Introduction
Hy please I'm from Argentina and I want to buy some of them, contact me
10 years ago on Introduction
Ah. A bit, but not badly.