For our final, Jesse and I, instead of building a huge 11 x 25 pixel digital clock, we decided to create 5×5 pixel display.
While we now have all the materials to make a larger version, we learned early on that a smaller scale prototype would represent the foundation on which the larger display would be built on. The smaller display was built using the same principals: acrylic rod for pixels, multiplexing of an LED matrix, controlling an array of solenoids. The only thing the small scale model does not possess is controlling a large array of solenoids using the 74HC595 shift register.
Once we had nailed down our idea to creating a display using a matrix of illuminated acrylic rod actuated to create a 3 dimensional effect, we had to create a plan to keep us on track, and make a list of techniques and challenges to overcome.
As we started looking into hardware for the project, we had a pretty clear idea that we would be using transparent acrylic rod (not tube) for the pixels, and that each rod would be drilled for an LED. This really left three unknowns for us to work through: Rod diameter, rod spacing, LED selection. After playing with a few Illustrator sketches to determine spacing we settled on 7/8” W x 2.5” H acrylic rod for each pixel, 10mm ultra bright LEDs for illumination, and 6mm spacing between pixels.
The next challenge was the actuation hardware and mechanism, this was where we really started to get out in the weeds. We looked at a number of mechanisms for pixel actuation:
- Gear driven servo actuation
- Linear actuators
- Individual solenoids
- Solenoid on gantry
We eventually settled on individual solenoid actuation because of mechanism simplicity and cost. Using the solenoids would cut out the need for a complex gear assembly, and low voltage solenoids were less expensive than linear actuators across the board.
The first solenoid we used ended up being perfect for our purposes, the JF-0520B. This solenoid uses 5v, possesses .35N of force, features push / pull operation and has a long stroke length (7mm) compared to many solenoids of similar size and voltage. The push / pull operation also ensures that the pixels will not only be pushed out, but also pulled back in as part of the operation. Once we had the solenoid, the next step we took was building a prototype chassis, fixing the solenoid to it and testing the operation. As you can see below, we built this chassis by cutting three acrylic sheets on the laser cutter. Each had holes in the corner for mounting. The first two sheets used large round center holes to house our acrylic pixels. The third sheet used square openings for the solenoids to seat into.
We learned how to wire the solenoid using the schematic linked here and here. Using the labs from class to guide us, we learned that the transistor is used to “allow us to control the flow of a high-current circuit from a low-current source.” Meaning control the solenoid circuit which runs on bench power using our Arduino. The other component we learned about in this circuit was the protection diode (1N4004) to protect from problems caused by any reverse flow of current.
With our mechanism working we felt we had a good proof of concept for moving forward. At this point we set our sights on fabrication, preparing for the eventual scaling of our project.
After cutting and drilling a whole mess of acrylic rods, it was time to tackle another large technical hurdle we were facing. Multiplexing the LEDs. For those familiar with Arduino boards, you know there are a finite amount of digital pins for addressing LEDs or any other on / off component. In order to essentially expand the number of digital pins you have to drive LEDs you must learn a technique called multiplexing. This technique requires three things:
- Creating an LED matrix
- Wiring the chip
- Using the code
Soldering together an LED matrix is simple enough, essentially you wire all of the anodes into rows, and cathodes into columns — creating a common cathode matrix. The result looks something like this.
You can check if you’re doing it right as you go by touching one of the cathode (+) column leads to the 3.3v out on your Arduino, and one of the anode (-) rows to ground. If you’ve wired the matrix correctly the LED at the intersection of the column and row should light up like this.
Actually wiring the LED matrix to the chip proved to be much more of a challenge than I had originally estimated. For availability and documentation reasons, we chose to use the MAX7219 LED driver chip to multiplex our LEDs. There was a fair amount of documentation on this chip online, a friend of mine and fellow LED matrix enthusiast Gustavo Abbot also had used these in the past, and offered his assistance.
In the end, the chip worked wonderfully. However, there was a fair amount of info that threw us off as well along the way. We began on this Arduino forum which was aimed at explaining how to use this chip, and even included a schematic. We learned however through the MAX7219 product data sheet that there were a few issues with this page. First, the digits and segments were mislabeled in the Arduino forum’s breakdown of the 7219’s pin layout. The second issue was with the wiring schematic to the chip. The schematic includes decoupling capacitors of 10 micro farads and 100 nano farads to suppress noise signals caused by the power supply lines. However, after speaking with Tom Igoe, we learned that all that was required for the circuit was a 100 nano farad decoupling capacitor. Changing this component out made the illumination of our LEDs much more consistent. I have included below an annotated page of the MAX7219 data sheet to show exactly how to wire it to your arduino, as well as the full data sheet here.
Finally, once we had the chip wired up all that was left was the code. Gustavo was a great help here, pointing us towards the pertinent libraries we would have to include in our IDE to get this to work. The libraries you will need in order to multiplex LEDs on your Arduino using the MAX7219 are:
- Adafruit GFX: Core graphics library for Arduino – must be paired with hardware-specific library
- Max72xxPanel: Hardware specific library
- SPI: Allows you to communicate with Serial Peripheral Interface Devices with the Arduino as the master. — Excerpt from Arduino reference
We started here by first going through the libraries and the example sketches that came with them and pulling out the pertinent lines of code to get this working.
What you see above is the code for scrolling 0 – 9 on a 5×5 pixel display. The persistence of vision phenomenon present in LED matrices made hard coding this an interesting learning experience. You couldn’t just call up a digit at once. You have to do a row or column of the digit, use a very short delay, then proceed to the next. Because the mux pulses the LEDs quicker than the eye can tell, rows and columns of the digit are flashing on and off so quickly your eye cannot tell and you brain just perceives a full digit. The wonderful thing about the Max72xxPanel library is it provides ints for you to plug in the number of horizontal and / or vertical multiplexes for easy scaling of LED matrices. As you can see above I have hardcoded the x,y coordinates which make up each number. While I am only using 1 5×5 matrix. If I was using the full extent of the chip (8×8) and had a second horizontal display, writing to the next matrix is as simple as this:
matrix.drawPixel(8, 1); // top right of first matrix
matrix.drawPixel(9, 1); //top left of second matrix
For the full version, we would like to try a clock display and will be using code adapted from a clock display programmed in p5.js
The last ‘how it works’ related items I’d like to cover are the solenoid array, and the 5×5 matrix we presented. For this prototype, because of its size, there were enough digital pins for the multiplex, as well as a 15 solenoid array. Therefore, we did not have to address the solenoids using the 74HC595 shift register. When we scale up however, we will have to address the solenoids using shift registers to help us economize on digital pins. — although scaling up will still necessitate multiple Arduinos running a single sketch, syncing them using I2C. While I have not yet been able to address multiple solenoids using a shift register, this forum seems to provide some nice first steps. One consideration we made while creating even the 5×5 was power for the solenoids. By switching them on and off quickly in sequence to create a snake effect tracing out each digit, we only use the voltage and current requirements of one solenoid. If we wanted to actuate multiples at a time, the power requirements would scale by the number of solenoids being actuated.
With respect to the 5×5 we presented in class, one major design change we had to make as we entered our latter prototyping phases was the LED matrix. As you saw above the earlier matrices we created were rigid, created using solid core wire. Because of the actuation of pixels that was going to happen behind the matrix, for the final we had to create a sort of ‘soft matrix’ using stranded cable. The stranded cable allowed for easy actuation of the pixels, but looked a bit messy at the end of things. In the future, we will examine how to create this matrix to be as robust as possible, while also remaining as neat and flexible as we can allow.
In terms of the scalability of the project, as mentioned above we are already prepared to scale up on the number of pixels physically and technologically, we have already laser cut our second board as well as created the acrylic pixels for it. I plan to spend my time during the break learning to control a larger array of solenoids using the shift register, as well as experiment multiplexing with RGB LEDs as well. In terms of the fabrication challenges associated with adding a large number of solenoids I believe we need to revisit our method of joining the solenoids to the pixels. Currently we are using hot glue as the shielding as well as the method of joining the pixel to the solenoid. In the interest of creating a robust final product, we will need to replace this with some kind of mechanical link I believe.
For me this idea turned into much more than just a final project. I think combining the concepts of building your own displays, challenging what a pixel is, and experimentation with topographies has potential to be something not only very artistic, but also presents interesting opportunities for data visualization / message augmentation. Some of my ideas for future display projects are:
- Creating mirrors
- Music / FFT analysis
- Scrolling brail below text
- Interactive displays using RGB LEDs
Please stay tuned for further pixel pushers updates. We will be continuing to experiment with expanding this display through the winter — both of us are incredibly excited to see where this goes.
Finally, we’d like to thank Gustavo de Campos Abbot for pointing us in the right direction with the multiplexing work. To see Gustavo’s amazing work, just give the link above a click. We’d also like to thank Tom Igoe for lending some of his time to help us defrag our MAX7219 circuit. You’ve made it this far, please take some time to look through Tom’s work, here. He is one of the fathers of the Arduino and has oh so much knowledge to give.
Marcela & Jesse
Now, time for my little photoshoot: