Introduction: How to Build a Light-up Ukulele!

I play the Ukulele. Kinda mediocre-ly (if that's a word) so I thought, "if you really want to impress the ladies, you need a means to distract them from the disaster that's playing on stage." Hence the "Light-up Ukulele" was born.

This project takes a Concert Ukulele kit and adds an Arduino controlled LED at each string and fret position. It also adds a fancy OLED display and rotary encoder based user interface to select the mode and intensity of the LED string.

The completed uke hardware features:

  1. Arduino MICRO to interface to the LED string, display and input device.
  2. 48 individually programmable full color LEDs
  3. An OLED display
  4. A rotary encoder for user input
  5. USB interface for external power and Arduino programming

The uke software has:

  1. Basic light control modes that run the LEDs through their paces
  2. A nifty theater marquee mode (very handy for performances!)
  3. LED intensity control
  4. A full chord library of all first position Ukulele chords (chord value and character)
  5. Ability to display running text (vertically) using a unique 4 x 6 pixel character set

This instructable describes the completed prototype. The full development saga is available HERE, including some educational (painful) mistakes and a valuable lesson in why you MUST finish your first design to completion (no matter how ugly things get). You never know all the things you really don't know until you get to the end (and then you still don't!), but you're a lot better off and a lot smarter for the next design.

I built the prototype around a Grizzly Concert Ukulele kit. Starting with a kit relieves the worry about the body of the uke (well, mostly), and eliminates most of the real luthier-type work. These kits are pretty complete and not that expensive in the grand scheme of things (and less painful since you will make mistakes).

Step 1: Make a Plan

The fretboard (or fingerboard)included in some kits already have the frets attached. That's good/bad. It's nice as a time saver, but in terms of laying out a drill pattern and holding it in place while milling, it's a little bit of a pain. After destroying the one provided in the kit, I opted (well, I had no choice other than buying another kit) to buy a new fretboard.

When designing the fretboard, we need to calculate the increase in the thickness required to embed the PCB and the LEDs (and don't forget the passive components), but not so much that the LEDs are too far from the fretboard surface.

The LED printed circuit board (PCB) is designed as a simple 2 layer board. This helps a lot with the hand assembly of the LED string and provides some mechanical strength (it's fiberglass and epoxy) to the Ukulele neck. I started the layout in Eagle, but ended up using Altium Designer due to board size limitations. The Altium schematic and PCB files are here.

The kit fretboard was a mere 0.125 inches thick. So, assuming an 0.062 inch thick PCB and allowing an additional 0.062 inch for the LEDs, means we'd have to cut a lot out (as in all) of the fretboard. To compensate we can either partially cut pockets for the LEDs in the fretboard with a corresponding pocket in the neck for the PCB, or we could replace the entire fretboard (the option I went with) with a thicker version from Luther Mercantile International (LMII), which are 0.25 inches to start.

BUT, remember that you'll still have to machine the neck to compensate for the increase in thickness in the fretboard. The other advantage you get is cosmetic, since the PCB is now completely embedded inside the fretboard which makes the edges far easier to finish (and look far nicer!) and simplifies milling the neck.

Engineering stuff (ignore if you want):

By the way, this doesn't really compromise the stiffness of the neck that much. The PCB material is far stiffer than the original fretboard wood (Mahogany modulus: 10.6 GPa versus FR4 modulus: 24 GPa), plus since we're building a Ukulele, there isn't a huge amount of string tension that could otherwise distort (twist or warp) the neck.

One very interesting consideration (that I probably should still calculate) is what happens over temperature. Generically for wood, parallel to the grain, the thermal coefficient of expansion is roughly 3 x 10^-6/K, and for FR4 it's 14×10^−6/K. So, there is quite a significant difference. The concern is that tension is created in the neck as temperature varies, which in turn de-tunes the strings. That's something that could be compensated by applying a similar layer on the opposite side of the neutral axis or by getting the FR4 as close as possible to the neutral axis. But that will be left for 2.0...Something to model up and evaluate.

The electronics are housed in the body of the uke. Holes are cut in the sidewall (not the soundboard!) of the UKE to make room for the display and rotary encoder, plus an access plate to hold the Arduino Micro and provide access to the USB interface. The access plate/mount design and location could likely be improved to make the USB connection come out in a more convenient location, but as it stands, it's not all that bad, since it's not in the way when you're playing.

The outline of steps are as follows:

    1. Gather materials
    2. Get the tools you need
    3. Mill the neck to accommodate the thicker fretboard
    4. Mill the fretboard to make holes at the required locations and to create pockets for the board and LEDs
    5. Obtain and construct the PCB holding the LEDs
    6. Mill access holes in the Ukulele body for the OLED display, Rotary encoder, and access panel
    7. Make cover plates
    8. Attach wires to the PCB; connect and test the electronics
    9. Attach the neck to the Ukulele body
    10. Drill an access hold to pass the PCB wires into the body
    11. Align and glue the PCB and fretboard to the neck
    12. Level the fretboard edges to the neck (remove the excess material)
    13. Install the fret wires
    14. Apply masking and apply finish to the Ukulele
    15. Align and attach the bridge
    16. Install electronics and test.
    17. Install tuners and string the instrument
    18. Program the Uke controller
    19. Amaze the world with your Ukulele awesomeness!

    Step 2: Gather Materials

    Our materials list looks like this:

    1. Ukulele kit - I used a Grizzly Concert Ukulele kit (Grizzly Uke Kit at Amazon), but that looks to be discontinued. Zimo makes a similar model (Zimo Uke Kit @ Amazon) which looks like it will do the job
    2. Ukulele fretboard, pre-slotted (LMII Uke Fingerboards). They'll slot the fretboard to your scale, which saves a mess of trouble
    3. Epoxy - for gluing the fretboard to the neck. I chose epoxy since it is compatible with the PCB material. Look for something with at least 60 minutes of work life. DO NOT use 5 minute types, you need time to make adjustments
    4. Fret wires - also available from LMII
    5. Custom PCB - Altium files are here. I opted for normal FR4 type material. Flex (polyimide) boards would be an interesting (if more pricey) alternative, since they can be much thinner
    6. 48x Neopixel (SK6812) LEDs. Available from Adafruit and Digikey
    7. 48x 0.1uF 0402 caps - larger is acceptable, but you have to watch placement
    8. Hookup wire - at least 4 to 6 colors to avoid confusion, I used primarily 28 gauge wire. Watch the DC drop on the LED power connections (both VCC and GROUND...that current has to return to the source!)
    9. Rotary encoder - PEC16-4220F-S0024
    10. Fancy wooden knob - for the rotary encoder (I got mine from LMII)
    11. OLED display - from 4D systems OLED displays
    12. External USB battery - cheaper all the time, plus you can carry spares!
    13. Arduino MICRO
    14. Sheet brass - to make the plate to hold the arduino and bezel for the display
    15. Miscellaneous consumables including: sandpaper, urethane finish, popsicle sticks, rubber bands, solder, flux, brushes, double sided tape (I like the UHC tape by 3M) and small brass woodscrews (for the plate)
    16. Optional Ukulele enhancements - better tuners, better strings, better nut and saddle, inlay if you want to show off your luthier prowess)

    Step 3: Get the Tools You Need

    Sooner or later you're going to need to obtain or get access to these:

    Our tools list includes:

    1. Milling machine - CNC preferred, but you might even get by with a router and a lot of luck. I used a combo CNC mill/router
    2. Router bits - carbide preferred. Router bits chosen over end mills since we're machining wood, not metal
    3. Clamps - lots of 'em. Mostly needed to hold parts while gluing
    4. Soldering iron - small tip for surface mount soldering
    5. Microscope or magnifier - you can try to solder with only you eyes, but I wouldn't recommend it, 10x minimum
    6. Tweezers (for putting parts in place)
    7. Fretting tools (see proper tools on LMII here, but I used what I had at home and made do; hammers, files and cutters)
    8. Assorted hand tools such as wood chisels, screwdrivers, soft blow or rawhide hammer (for fretting), etc.
    9. Abrasives - various grits of sandpaper

    Our software tools include (some are optional depending on your budget/ingenuity):

    1. Arduino software
    2. The Ukulele source code (
    3. PCB layout package - I used Altium because the free version of Eagle did not support the board size I wanted. Altium is a full featured layout package and not really in a hobbyist price range. I've included the Gerber files on my site for the prototype, but these definitely need an update
    4. 3D modeling software - I used SolidWorks, but one free alternative is FreeCAD (
    5. CAM software - like FeatureCAM from Autodesk for creating the NC mill file.

    The combination of 3D step file export from Altium along with a 3D model of the fretboard eliminates much of the difficulty in making sure everything lines up, but it's not a requirement. Careful layout will achieve the same result.

    Now that we know what we want to do, and what we need to do it, let's build a Ukulele.

    Step 4: Mill the Neck to Accomodate the Thicker Fretboard.

    Before milling, note that the original fretboard mounting surface flatness MUST be maintained, or you're going to have a twisted fretboard, which leads to all sorts of issues with fret leveling.

    Just don't go there, take your time and carefully and rigidly clamp the neck and check the alignment to the router bit across the entire neck before cutting. Time spent here will save you much grief later.

    One reason I opted for a thicker fretboard over an inlay in the neck was the increased mounting (gluing) surface area. Another reason is that it simplifies the milling of the neck. You simply buzz cut the entire surface to the required height.

    Step 5: Obtain and Construct the PCB Holding the LEDs

    I hand soldered the entire assembly. The LED packages are especially easy to melt, so take care to avoid damaging them. I suggest wearing a static strap, since the string is dependent on every LED working.

    The Fretboard design is based around the WS2812B LEDs. I decided to only do the first octave of the fretboard (48 LEDs!!). Each LED can be thought of as one bit in a shift register. The shift register is clocked at 800 kHz. I used the Adafruit library (see the programming section) to get things up and running quickly.

    I started the design in Eagle, but the board size is limited to like 4 x 5 inches, so I had to (or more correctly, I opted to) switch over to Altium. I use Altium at work, so in reality, it made things faster for me. The Altium project, schematic and pcb files (and library parts) are on my site. The board is trapezoidal in shape and about 10 inches long. I think I should have tried to compress the outline a bit more (next spin!) Assembly wasn't bad, but if you can afford it, I really really recommend a decent soldering iron (JBC Soldering Irons) and a good microscope. Yeah, I'm spoiled and no, I don't have that kind of stuff in my home lab. I'm cheap.

    I had the boards made at Sunstone. $129 for two boards. Guaranteed one week turn. Don't scrimp on the shipping though. I didn't notice that I used UPS ground and I ended up waiting an extra week for my boards to arrive. Total assembly time was about 2 hours (98 parts).

    Step 6: Mill the Fretboard

    We need to mill the fretboard to make holes at the required locations and to create pockets for the board and LEDs.

    I created a 3D model of the completed fretboard in Solidworks and created the CNC milling routine using FeatureCAM.

    The bottom part of the fretboard (closest to the soundhole) will need to be made thinner to account for the step change in height between the neck and body. Definitely worth test fitting several times to be sure that it's a reasonably snug fit.

    In retrospect, I should have cut off the unused parts of the fretboard to make it fit the mill better (my cheap mill only had a 12" X-axis travel). The order of operations should be set up to first mill thickness adjustments before milling pockets, which should lead to less breakouts between pockets.

    Make manual adjustments as needed to add space for wiring. One important thing to note is that in some of the pockets, I broke through into the slot where the fret wire will go. Given that's a conductor, make sure that it doesn't end up shorting anything important. It also decreases the strength of the material holding the fret in place. The design should be modified to never intersect with a fret slot.

    Step 7: Mill Access Holes in the Ukulele Body

    I manually milled the access holes in the body. The hardest part is finding the "flattest" region of what is a very curved surface. Mark the outline in pencil and gradually mill away material until you get a snug fit for the OLED display. I obtained a machined a brass bezel and attached it using 3M VHB bonding tape.

    Since neither require great precision, the rotary encoder and access panel holes are far easier to create.

    Step 8: Make Cover Plates

    You also need to fab the cover plates for the display bezel and acess panel. The access panel needs a hole (rectangular) for the USB (micro) connector. Just use the existing connector on the Arduino, since there aren't many panel mount options for micro USB. (although if I was designing from scratch, then I'd give one of these a look)

    To hold the board in place, fashion L brackets out of brass and solder them to the back of the access plate. This allows you some latitude in positioning. To get the positioning right, first create a perfboard mounting board (with mounting holes) for the Arduino MICRO and attach the L brackets to it using 2-56 machine screws. You can then tweak the location to line up the usb port and accurately mark the locations for the brackets on the plate. Remove the brackets from the perfboard and solder them in place. Finally mount the perfboard assembly.

    I used four small brass wood screws to hold the brass access panel in place.

    At this point I recommend a test fit before final assembly begins. This step is optional but recommended. It's far easier to make adjustments before gluing.

    Step 9: ​Attach Wires to the PCB; Connect and Test the Electronics

    Don't permanently attach the electronics yet. Attach wires to the PCB, making sure you leave enough slack to route out the access hole. These eventually need to be permanently attached to the Arduino MICRO board (the photos show an Arduino UNO, which I used for code development)

    Step 10: ​Attach the Neck to the Ukulele Body

    Attach the neck to the Ukulele body following the instructions included with the Ukulele kit. Particularly watch the alignment of the fretboard surface to the body of the uke.

    Step 11: Drill an Access Hole to Pass the PCB Wires Into the Body.

    Once the glue is dry, drill a ~1/4" (10mm) hole at an angle to allow the wires from the PCB to route into the Ukulele body. Be sure not to damage the soundboard.

    You may need to create a small pocket as well to allow for the thickness of the wires under the board (or optionally put the connections on the top and include relief in the fretboard.)

    Another test fit wouldn't hurt at this point.

    Step 12: ​Align and Glue the PCB and Fretboard to the Neck

    I suggest thinking through the clamping (and trying it out!) before gluing. You may want to fashion a block shaped to the underside of the neck to give you a flat clamping surface. The fretboard is larger than the neck at this point, so you need to allow for that.

    Be very careful not to get epoxy on any surface that you want to finish later. Better yet apply masking to all non-glued surfaces before you glue to make sure it only goes where you intended.

    Use epoxy with a minimum of 60 minutes work'll need all of it.

    Glue the PCB in place first, making sure excess glue does not extrude into the fretboard gluing surface. This provides a method to align the fretboard to the neck. The PCB has a smooth solder mask finish, so I roughed it up with a bit of sandpaper to give the epoxy a slightly improved surface finish.

    Align and glue the fretboard to the neck. Be careful to leave no pockets that may later become resonant (buzz!). Also be careful not to get glue on the LED surfaces.

    Once the glue is dry you may want to wire and test the electronics one more time. One bad LED will make you hate life. I had one bad LED (the first!) on the prototype and I had to do some creative woodwork to access the defective LED and patch it cleanly.

    Step 13: Level the Fretboard Edges to the Neck and Add Fret Wires

    Once the glue is dry, you can start finishing the edges. I carefully cut away the excess fretboard material (using a mill) and finished the last millimeter by hand sanding.

    Adding the fret wires can be simply done with a hammer (with a plastic face to avoid marring). Just don't hammer too hard. If you've matched the fret wire to the slots, they should go in without much difficulty.

    The thing you need to watch for is breaking the thin surface of the LED pocket. On the prototype, I allowed the some LED pockets (near the 12th fret, where space gets tight) to extend into the fret slot. That's a bad idea, since that creates a weak spot that may (and did) crack once the fret wire is inserted.

    Step 14: Apply Masking and Apply Finish to the Ukulele

    Mask the fretboard (it doesn't get finish) and the bridge gluing area and begin applying finish.

    When masking the bridge area, read the instructions with your kit, then double check the scale length just to be sure. The kit I used for the prototype used the wrong scale length and hence provided the wrong dimensions for locating the bridge (but it did have a note to check the website for the latest instructions!). My gut told me it was wrong, but I blindly accepted authority.

    It's always better to understand WHY you're doing something, rather than blindly following the instructions.

    For the finish, there are lots of tutorials from Luthiers who know what they're doing on the web, so I recommend consulting them before jumping into the finishing process.

    I, of course, didn't do that, so I ended up using the wrong sealer, resulting in a very grainy surface. Don't do that.

    Do your homework.

    Step 15: ​Align and Attach the Bridge

    This step is pretty straightforward, but again, plan out your clamping method and try it out in advance before gluing. I used a standard wood glue to attach the bridge.

    Step 16: Install Electronics and Test

    Now is the time to make your wiring pretty. Plus you don't want it flopping around inside the body and making buzzing noises or worse yet breaking on stage.

    The Arduino code can be updated through the USB port, so there's really no need to take it apart unless you want to tinker.

    Step 17: Install Tuners and String the Instrument.

    You will also likely need to level the frets and play with the setup a bit, but why worry now, when you're so close to the end?

    I upgraded the tuners and used nice Aquila strings, which didn't help the sound whatsoever. So keep that in mind while you're shelling out money into a project ukulele...

    Step 18: Programming the Uke

    The final Arduino code is on Github. There are some lines in the code to support future enhancements (like a metronome function and "sliders" for the display (a UI element that looks like a slider)

    This code uses a Rotary Encoder Library (Rotary Encoder Arduino Library) to handle user input from the Rotary Encoder.

    It also uses the Adafruit Neopixel library and example code located here. The theater and rainbow modes are derived from examples provided with the library. (see strandtest.ino).

    The display driver is provided by 4D systems and found on Github here.

    There are two unique functions implemented for the Ukulele project. The first implements the chord library, and the second displays a scrolling text message using a custom character set.

    The attached diagram shows the fretboard LED locations and how they are connected. LED 0 is located in the upper right hand corner.

    Step 19: How to Display a Chord

    The displayChord function displays the finger positions (first position only for now) for each chord. Chords selected by the user (root note and quality) are stored as a pair of indices. These in turn are used to look up the fingerings for each chord.

    I used "GCEA" notation to store chords (e.g. "A" is "2100"). The chords are pre-calculated for each root note and stored in a variable corresponding to the quality of the chord. (so, A major, is stored in the first location of the array "majorChords", corresponding to "2100").

    char* majorChords[] = {"2100\n", "3211\n", "4322\n", "0003\n", "1114\n", "2220\n", "3331\n", "4442\n", "2010\n", "3121\n", "0232\n", "5343\n"};

    Note that since this is a text string each digit could also represent a hex value to account for fret positions greater than 9. That is, A and B would represent LEDs 10 and 11. For first position chords, this wasn't an issue).

    The LED string is wired lengthwise in rows of 12 (an octave) along each string (starting with the A string), the subsequent run of 12 starts at the first fret of the next string (see the diagram in step 18). This is important for the algorithm to determine which lights to turn on for a given chord. That means that pixels 0 through 11 are the A string LEDs, 12 through 23 are the E string LEDs, and so on. When parsing an A = "2100" (stored as a string, there's also a null terminator "\n" in the code), we interpret it as: no pixels on the A string are lit, nor on the E string, pixel 0 (fret 1) on the C string is lit and pixel 1 (fret 2) on the G string. Note that a "0" is off, not the first LED. Based on the wiring, we want to light up LEDs 24 and 37. The code to display a chord is shown below.

    <p>for (int i = 0; i < 4; i++) {  <br>   if (int(chord[i] - '0')) {     
       //algorithm to parse the chord string
          int ledNumber = int(chord[i] - '0') + (3 - i) * 12 - 1; //see above discussion, the (3-i) is to reverse the index
          strip.setPixelColor(ledNumber, 0, 125, 125);    //setPixelColor(ledNumber, red value, green value, blue value)
     }  </p>

    The if statement checks if led is off. If it isn't then it takes the ascii value of the character, chord[i], and subtracts the ascii value for '0' to get the ledNumber to light up.

    strip is an instance of the Adafruit_NeoPixel class. The setPixelColor function sets the color for the calculated pixel (fixed at (0,125,125) in this case.

    Step 20: How to Display a Scrolling Message

    So we have a 12 x 4 array of LEDs... why not make it display something other than pretty random light patterns!

    The first issue is that the display height (4) is rather limited due to the number of strings on a Uke. Horizontal scrolling would be mostly illegible, but in a vertical orientations, we can support 4 x 5 characters running vertically.

    Organizing characters as five "vertical" rows means that two characters can be displayed simultaneously allowing a one line space between each character.

    The difficulty was that there was no standard 4 x 5 character set. I made my own using the attached spreadsheet. I assigned each row to a single hex value (4 bits representing which pixel is on or off). The combination of the five hex values constitute a character (e.g. "0" is 0x69996).

    The values for each character are stored in an array in ASCII order. The character set makes some compromises with certain letters, but the majority a reasonably clear. (the scribbling at the bottom of the spreadsheet are ideas I was playing with since we have color as an option, we can add "depth" to the character and possibly get some additonal resolution.

    The string to displayed is contained in the string variable, message.

    A buffer is created to represent the character display. I guess I could have simply created a large buffer with the entire translated message sequence, especially since most messages will be less than 20 characters or so. However, I opted instead to create a fixed three character (18 bytes) buffer. Only two of the characters are actively being displayed, and the third is a look ahead, where the next character is loaded. The LED string (think of it as a big shift register) is loaded with the 48 bits for the string. I wasted some memory space to make this easier to conceptualize. Each nibble gets it's own memory location, doubling the memory requirement, but it's not much given the buffer size.

    The buffer is loaded with the next character when the output index (pointer) gets to a character boundary (outputPointer at 5, 11, or 17).

    To load the buffer, we grab the first character in "message" as an ASCII value and subtract 48 to get the index in the asciiFont array. The value at that index is stored in codedChar.

    The first part of the message shifted out correspond to LEDs 47,35,23, and 11 (the bottom of the display). So for the number zero 0x0F999F, the F (left one) is shifted in first, 9 second and so on.

    The next character is loaded by masking each nibble and shifting it to the right. For the above example, the algorithm gives (0x0F999F & 0xF00000) >> 20, then (0x0F999F & 0x0F0000) >> 16, etc.

    <p>int index; <br>if (outputPointer == 17 || outputPointer == 5 || outputPointer == 11 ) { 
       char displayChar = message.charAt(messagePointer); //grab the first character of the message 
       long codedChar = asciiFont[displayChar - 48]; 
       if (displayChar == 32) codedChar = 0x000000; 
       messageBuffer[bytePointer+5]=byte((codedChar & 0xF00000) >> 20); //mask all but the last nibble and shift it over by 20 (and so on)
       messageBuffer[bytePointer+4]=byte((codedChar & 0x0F0000) >> 16); //this should put one nibble per memory location
       messageBuffer[bytePointer+3]=byte((codedChar & 0x00F000) >> 12); //all six represent on character 
       messageBuffer[bytePointer+2]=byte((codedChar & 0x000F00) >> 8); 
       messageBuffer[bytePointer+1]=byte((codedChar & 0x0000F0) >> 4); 
       messageBuffer[bytePointer] =byte((codedChar & 0x00000F));
       if(bytePointer ==0) {  //handle the loop around on the bytePointer 
          bytePointer = 12; 
       else { 
          bytePointer -= 6; //we are filling from the bottom up ; NOTE: need to look at reversing this to see if it makes it easier 
       if (messagePointer == message.length()-1) {  //handle the loop around on the message 
          messagePointer = 0; 
       else { 
          messagePointer +=1; //move to the next character

    Once the buffer is loaded, it becomes a matter of tracking where the output pointer is at and loading the LED string with the correct 48 bits (the current 4 and the previous 44). As mentioned previously, strip is an instance of the NeoPixel class and setPixelColor sets the color (RGB) of each pixel. The show() function shifts out the display values to LED string.

    // loop to continually shift out the buffer
    // want to write out the entire strip on each pass through the loop, only the starting location changes
    for (int row=12;row > 0;row--) {    
       index = outputPointer + (12-row);    
       if (index > 17) index = outputPointer+(12-row)-18;  //loop if greater than 17    
       for (int column=4; column > 0; column--) {           
          strip.setPixelColor(uint16_t(12*(column-1)+(row-1)),uint8_t(RedLED*(bitRead(messageBuffer[index], column-1))),uint8_t(GreenLED*(bitRead(messageBuffer[index], column-1))),uint8_t(BlueLED*(bitRead(messageBuffer[index], column-1))));  //at each location light up the LED if the bit is a one      
    //outputPointer points to the current lowest byte in the display string  
    if (outputPointer == 0) outputPointer=17;  
    else outputPointer -= 1;;

    Step 21: Amaze the World With Your Ukulele Awsomeness!

    The final Ukulele prototype took about 6 months of starts and stops to pull off.

    Lots of new tech to learn and maybe some woodworking and musical theory to boot!

    What to do for the next version?

    1. Get rid of the display and rotary encoder. Replace them with a Bluetooth module attached to the arduino. Control it remotely using an phone or tablet. Everything is better with Bluetooth.
    2. Remotely update chord patterns in real time. Something best left for the app.
    3. LED covers. The current version does nothing to prevent gunk from getting in the LED holes. A friend made a bunch of small lenses, but I never could figure out how to get them to stay in place properly.
    4. Alternate fretboard materials, maybe something clear as long as the frets hold.
    5. More lights! Eliminate the constraint on text by adding more "rows". This is really a limitation caused by the size of the fretboard and the LED bodies.

    Again, see the companion Instructable which describes the character set I had to create to allow scrolling text.

    Thanks so much for making it this far! Mahalo!

    First Time Authors Contest 2016

    Participated in the
    First Time Authors Contest 2016

    Arduino Contest 2016

    Participated in the
    Arduino Contest 2016

    Make it Glow Contest 2016

    Participated in the
    Make it Glow Contest 2016