NEW LED Software and Hardware Platform that YOU need to know about!

Are you ready to spark your imagination? Hold  onto your keyboards and prepare to have your mind illuminated as we turn the spotlight onto  the future of LED technology! [Cut] Greetings, Light Hackers! Welcome back to Dave's Garage!  Today is not just another episode - It's a game changer that's been five years in the making.  We're going to unveil an amazing new LED hardware board and an open-source software project that  promise to revolutionize the way we use LEDs. This could be the key to cr

eating the most compelling,  mesmerizing, and practical LED effects you've ever seen. Coming up, I'll tell you how you can get  me to send you one for free. [Cut] So buckle up folks! Grab your gear, summon your inner tinkerer,  and let's dive into this photon-filled adventure together. Join me today in Dave's Garage,  where darkness fears to tread. [Intro] Hey I'm Dave, welcome to my shop! I'm Dave  Plummer, a retired operating systems engineer from Microsoft going back to the MS-DOS and  Window

s 95 days, and today in Dave's Garage we're going to explore the NightDriverLED system as  we focus on one of its most compelling projects, the Mesmerizer. This is a project I've been  working on since 2018, learning as I went. I'm going to take you on that journey as I look  back on my LED adventures and then show you the culmination of those efforts, the Mesmerizer  itself. We'll even walk through the creation of the custom PCB using JLCPCB's EasyEDA editor  so you can see how to order turnkey

surface mount PCBs that arrive at your door fully assembled  and ready to run. This all began about 5 years ago when I decided that after spending an entire  career writing software, it was time to improve my hardware skills. Naturally, I was most interested  in digital electronics, so I grabbed myself some breadboards and an Arduino Uno. [Arduino Blink  Sketch] I started where most of you do as well when you first pick up an Arduino - with a single  LED, and then I made it blink. It's trivial,

of course, but seeing a real world manifestation  of my code was something of a rush. It was kind of like the first time one of my programs made the  computer do something useful - the same dopamine reward. Next, I wanted to control the color of  the LED and extend it to many LEDs, so I grabbed an LED strip off Amazon and set about learning  how MOSFETs work so that I could control the red, green, and blue channels of the strip and pretty  soon, I had a board with a dial that would allow me to

change the color of the entire strip at  will. Setting the whole strip to one color is all well and good, but it doesn't allow you to  do anything interesting in terms of effects, so I investigated and soon ordered an individually  addressable LED strip. That's where you control the color and brightness of every LED on the strip  independently. There are a few different types, but the most common is the WS2812B style,  and that's what we'll be using today. They're also sold under the NeoPixel br

and. About  that time, I moved to the ESP32 chip as well, which has Wi-Fi and Bluetooth built in as well  as two powerful processing cores and 520K of RAM. It still supports the Arduino IDE, and almost  everything you know about Arduino programming still applies, it's just a much more capable  chip than most of the AVR lineup. An individually addressable LED only has three wires: power,  ground, and data. The data line carries a square wave signal that contains the color data  for the LEDs. It's

simply three bytes per LED, one each for the red, green, and blue. It's up  to whatever chip you're using to create and send that signal to the strip. Keeping that information  in the dark where it belongs is up to the FastLED library. After linking your project with FastLED,  you can just hand it an array of color objects and it immediately sends them out to the LEDs without  you needing to know anything about how it's done under the covers. It just works. I used it to  build a project that pu

t an LED strip up on the ceiling edge of my workbench in the shop. And in  fact, that was my very first YouTube video of all time! I set it to the flame effect and the video  title was "Help, my Shop's on Fire with LEDs". The project is still running today and it has  a wall-mounted control box with a rotary dial that lets you enable and disable effects and  select the active one and so on. A smarter man would have used a touchscreen, but the rotary dial  works well enough. The next big project

I wanted to tackle was my patio umbrella. The fact that it  had 8 spokes and I that the ESP32 has 8 parallel LED channels meant it was predestined, I figure.  I updated the code to draw to multiple channels at once, while also allowing me to write different  effects to each spoke. Each spoke gets connected to a different ESP32 pin, and the FastLED code  draws them in hardware using the RMT signal support of the chip. Pretty soon I had flames and  fancy effects running on all the spokes, and it's

become one of the most talked about features of my  back yard. Everybody wants one, but no one wants to build one on their own, it seems! If you  can manage the wiring, the code's on Github! Drawing to multiple channels wasn't going to be  limited to the great outdoors, however. I bought an LED chandelier off eBay, turned it upside  down, added a stand and a base, and stripped out the factory white LEDs in favor of a short  individually addressable strip in each of the four arms. Each arm is co

nnected to a different  pin on the ESP32. The Atomic Fire Lamp was born, naturally with flame effects but a host of other  interesting visualizations as well, many of which are also music-reactive. What could be more  fun than an LED strip? Why, an array of them of course! And that was my next step. I ordered two  16x16 LED panels and as soon as they arrived, sat down to write code to scroll a message across them  as a first test. I'm going to teach you a new word today: the boustrophedon. That'

s because in the  interest of simpler wiring, most 2D matrices that are made up of individually addressable LEDs are  woven back and forth, so that as you go down the matrix, each second row is backwards. This creates  a pattern that resembles the efficient manner in which you might plow a field, and hence the name  derives from the phrase "as the ox plows". And now you know what boustrophedon is! I decided  at that point that I wanted to make a spectrum analyzer - one of those fancy bar graph d

isplays  that breaks the music down into bands and shows you the relative sound level in each band. I'd  seen a friend make one out of discrete electronics back in the 80s, but I figured I might be able to  do it in software, so I got a microphone module, hooked it up to one of the input pins on the  ESP32, and started hacking. I didn't know anything about the ESP32's I2S capability at the time, so  I just did the na ve thing - I sampled the value of the ADC pin in a loop and used that to build

a  sample buffer. Then I ran an FFT on the buffer to break it into frequency buckets, and used those  buckets to calculate how tall the bars should be. Some quick rectangle draw code, and  I had a working spectrum analyzer. The only problem was my na ve sampling kept the  CPU busy half the time. Thanks to hardware support on the ESP32, you can use the I2S protocol to DMA  the sample results right from the DAC into memory, allowing the CPU to continue on its  merry way doing other productive work

. That freed up enough CPU cycles that I could  spend my time writing some more graphics effects. Adding music reactivity to other effects was  fairly simple - I just kept a weighted average of the VU, or volume units, that I was already  sampling in the spectrum analyzer code. But even better would be beat detection, where the chip  listened to the content of the music and decided which loud transients were true music beats. The  whole process is beyond the scope of this video, but the basics a

re that it watches for transitions  from a low to high volume and then isolates the ones that occur a sufficient distance apart  with some regularity. I used a set of clear glass power line transformers that my grandfather  had collected to make a beat-reactive light organ. I put an LED ring in each one and added code to  make NightDriver aware of drawing to circular canvases, and it all worked really nicely.   And you know what else is round and has LEDs? PC Fans! When I made that realization,

I bought  a Lian Li PC XL case and equipped it with 10 fans that each had individually addressable LEDs.  I decided to wire their data lines so as to cascade from one to the next, making them a long  sequence of LEDs rather than 10 short segments. I then added code that could draw to any clock  position on any individual fan, and was able to create a number of cool fan effects for my PC  case. One of my favorites is the Tape Reel effect, which recalls the old IBM tape drives of the 60s  and 70s.

By virtue of picking up the sound code that was already in the project, many of the PC  Fan effects are also sound and beat reactive. The next big feature I wanted to add was remote  drawing over WiFi. I wanted to be able to write effects on my PC, Mac, or a Linux box and send the  results directly to the matrix over WiFi, whether it was a strip or a matrix. To that end the first  thing I did was set the clock of all of the client devices from a local or remote NTP server, which  would normally

get the clocked synced within a few milliseconds. Now that every device had a  consistent view of time, the PC could break up the work into multiple segments, each to be sent out  to its own ESP32 over WiFi. It would compress the color data, stream it to the ESP32s over a socket,  and run a dashboard to display what was going on. The ESP32 buffers a few seconds worth of color  data, so any blips in the WiFi shorter than that is smoothed out, and because each chip has the  same clock, and the fr

ames are timestamped, they all play in perfect unison. This synchronization  allows me to have effects where the drawing spans multiple different, completely wireless ESP32s.   The code to send color data to the ESP32 can be written in pretty much any language that supports  arrays. I've done it in C, C#, and Python. I even made a Unity project that visualized the LEDs  on the PC side as it sent the packets out. If you'd be interested in writing some  test code to drive the matrix in Python, p

lease stay tuned for information on how you can  get started! Here's a quick example of the hidden Christmas lights I added to my Cabana. The effects  range from twinkling lights to ambient light to fireworks. This is the firework effect, generated  in C# and running across 5 different strips of up to 8 meters each. The control software runs in  a VM on a machine in my shop, and it in turn controls about 15 different installations around  the property. In any event, about that time I stumbled ac

ross the technology used in jumbotrons  and Las Vegas billboards - the HUB75 matrix. The matrix has a 16-pin input connector on the  back and rather than having a single data line, it basically operates like a big shift  register. You give it a chunk of DMA memory and when combined with the SmartMatrix 4 library,  it will dutifully draw whatever is in the buffer. The hardware support in the ESP32 means it can all  be drawn via DMA, which keeps the processor free from the heavy load of drawing th

e display on its  own. In addition to power and ground, connecting the matrix requires about twelve GPIO lines and  so it's quite a mess if you have to hand-wire your matrix to the ESP32, which is what I'd been doing  up to this point. Soon enough I found a small hardware board from AZSMZ on Tindie that contained  an ESP32 chip, a power connector for the matrix, and a connector that allows it to plug into the  matrix's back connector with no manual wiring. I had to add my microphone to the circu

it somehow,  so I hacked the board and wired that in on a spare pin, and then I added a second input to receive  commands from an infra-red remote control. The remote would allow you to change colors,  switch effects, and so on. I cobbled all of that together and it worked, but I still had a wishlist  of features that were missing. For one, I wanted the microphone and IR pickup built in, not hanging  off by wires. Second, I wanted to make it USB-C. Third, I wanted to use what's known as a dual 

UART so that when plugged in, you'd actually see two serial ports, not just one. Even though you  connected to them over the same cable, you could then use one port for debugging and the other  for programming and serial logging. That gives you the ability to do single-step source debugging  in Visual Studio Code. And finally, I wanted some additional 8 PSRAM on the board for a total of at  least 4 megabytes. The problem is that nobody made a board with all these features, and certainly  not wit

h a HUB75 connector built right in. And that's when I got the big idea that I'd make  my own. But before I tell you that story, let's have a look at what the Mesmerizer is capable  of. First, we'll do the hardware installation: all we need to do is plug the PCB directly into  the matrix and connect the power lead. The only wiring you have left is to plug it into a USB  port. We would normally customize things like your zip code for the weather and join it to your  wifi, but even without those st

eps the Mesmerizer starts working as soon as you plug it in. Here's  a quick tour of just a few of the capabilities. The board continually samples digital audio  using the built-in mic, or you can plug a 1/8th inch audio jack in directly, which will  automatically disable the mic in hardware. The first effect that comes up is the classic  spectrum analyzer. There are a half dozen variants of it with varying numbers of bars  and color schemes, and I was truly impressed by the ESP32's ability to n

ot only sample and  process the audio at 50 frames per second, but to draw the spectrum at up to 100 frames  per second. The two cores are only 240MHz, but that's really quite fast for a microcontroller,  and it really shows in the snappy performance. The next effect is a clock, but with a twist.  It's a Pong Clock where two AI players battle, and the score display is the current time of day.  It's not rocket science perhaps, but I'm still proud of the code I wrote to predict the ball path  whil

e taking into account any number of bounces. They play quite well, but the ball accelerates  periodically ensuring that eventually, someone will miss. Next comes a YouTube subscriber  counter, set by default to my own channel. I'm probably sitting at home staring at this  display right now as you're watching this, so do me a solid and make sure you're subscribed  to the channel. You can imagine me watching the number change as you click the button! With this  effect, I'll be the first to know ab

out it! Next, we have your local weather, which is  based on your Zip code that you can optionally set through the web interface. It displays  the current temperature, the day's forecast, and the forecast for tomorrow as well. Right  now, it has some child-like drawings of weather patterns, but if you have the artistic skill to  draw great weather icons at 16x16 resolution, please get in touch and you can contribute  your art to the project at NightDriverLED.com Next comes the Ghostwave effect a

nd a couple  of other waveform effects that visualize the current audio waveform in different ways. I'm  pretty happy with how these turned out and they can be really entertaining to watch, kind of like  seeing Laser Floyd at the Pacific Science Center. After that we have Conway's Game of Life.  In case you're not familiar with it, it's a simulation of organisms that are born, grow, and  die depending on how many neighbors each one has. The board is randomly seeded to start, and then  the game p

lays out by the set rules. If you watch long enough, you might see the evolution of  creatures ranging from simple walkers up to projectile-hurling cannons. Because the board  supports buffering of WiFi frames, I can even stream video to it. Here's a quick Python app  that I wrote in order to push video from YouTube out to the matrix, and if you watch closely,  you'll see that you've just been Rickrolled! As long as the module you're using has  PSRAM, the system buffers up to about 10 seconds of

fill screen video, so the playback  is perfectly smooth even on imperfect WiFi. While there are a solid 30 different effects built  in, there's not time to cover them all today, so here's the last one we'll look at for now,  the Circuit effect. It simulates electrons flowing on a PCB that is built on the fly as the  particles travel around. And speaking of PCBs, as I mentioned earlier, I really wanted to create  my own ESP32 system that plugged directly into the matrix and included all of the f

eatures from  my wish list. The big complication was that the board would be all tiny surface mount stuff, it  would have something like 37 components on it, and I had no interest in hand-soldering them if  I was going to provide them in any quantity. I looked around the marketplace, and after trying  a number of options, I finally settled on JLCPCB. While I could wax on at some length about their  great production services and stellar customer service, the main reason I picked them was because 

the offer a great online piece of circuit design software known as EasyEDA. Not only was it my  favorite editor at this point, but it had one killer feature that I couldn't find elsewhere. You  can actually order the board you're working on, completely assembled and turnkey, ready to go from  within the editor. You don't even have to know what a Gerber file is or make a bill of materials  or anything - the software does it all for you, and JLCPSB does all the production and assembly in  house.

For someone like me who's afraid of trying to make a surface mount PCB, it's a perfect fit.   Let's go on a little tour of EasyEDA so that I can show you how you can go about it. Once I load up  the EasyEDA website and log in, I'm taken to my projects. I'll open one of the schematic projects  I've worked on in the past and we'll zoom into a random resistor. Laying out a schematic is the  same basic procedure as any other EDA you might have seen in the past - you place components,  rotate them, a

nd link them with wire connections. The one thing that makes the EasyEDA process so  compelling - that ability to single-click order a finished product - is predicated on you taking  the time to select the actual physical part that your schematic symbol represents. That way,  when it comes time to actually make the board, the bill of materials and the pick and place files  and drill files are all generated automatically for you and you don't have to worry about  them. Choosing a part also usuall

y includes the component footprint, and so your PCB design is  also predicated on the selections you make here. We can see with this resistor that when we  select it, the component properties come up in the right-hand column. In this case the footprint  of the resistor - which defines what its place on the PCB should look like - is an R0805. That  means it's a resistor that is 80 mils by 50 mils. For our metric viewers, that's a 2012 as  in 2.0 millimeters by 1.2 millimeters. We can also see tha

t the supplier part number  has been set. This takes just a few seconds to do and is what enables your project's automated  production. EasyEDA is tightly integrated with the LCSC catalog, including real-time inventory,  and so it makes finding your part quite painless. You can also specify parts from Mouser, Digi-Key,  and a few others. In this case, it's a part from LCSC with part number C17414. When your  schematic is ready, and you're about move on to the EasyEDA PCB editor, you should run

the  Design Rules Checker before doing so - it's very thorough and will prevent you from building the  PCB for a broken schematic. Once the Design Rule Checker passes, you can launch the PCB editor.   When you do so, all of your component footprints will be shown along with blue lines that connect  the pads that you need to route. There's also a reasonably capable autorouter, and if you need  more power than the online version provides, you can download a copy of the autorouting  engine and run

it locally on your PC. Either way, once your component arrangement and routing are  done, and your silkscreen layer says whatever you want it to say, it's time to order your boards.   From the Fabrication menu, we click One-Click Order PCB. This is where the magic happens. The  EasyEDA software will create the gerber fills, bill of materials, pick and place files, and  everything else needed to produce a PCB and assemble it based on the information you provided  at design time. It will then aut

omatically upload that info to the JLCPCB system so that you can  review pricing and options. Once it's uploaded, we can click on the Gerber Viewer link to see  what our produced board will actually look like. There's even a 3D viewer and it incorporates  models of the most common parts, so you get a fairly good rendition of the board that you can  spin around in place and inspect to your heart's content. Back on the PCB order page, I'll accept  the defaults for most everything, but let's set th

e PCB to be purple just for something different.  I do have to pick Standard PCB instead of Economy PCB assembly style because my board requires  assembly on both sides. I could likely save a lot of money by hand-soldering the single backside  connector, but I'm trying to keep it turnkey and easy, so today I'll pay for the privilege of  having it delivered complete. When I click next, I'm taken to a preview of the PCB, and from there,  I can click Next again to proceed to the Bill of Materials.

I click Process and it will show you  the list of components your board needs and where they. If any of the parts you've ordered are out  of stock, you're given the option of browsing their catalogs for an alternative or leaving the  parts out, if you absolutely need to. Next, we get a component layout preview, and finally after that  you'll be given the pricing and delivery window. When you check out of the cart, you initiate  a process that includes the PCB production, parks picking, assembly,

soldering, packaging  and shipping. All you need to do is wait for the yellow DHL van to show up about a week later,  and there are also a few expedited options if you need it sooner. Here's an example of the board  as it comes out of the packaging. It's completely ready to go out of the box with no hand assembly,  other than connecting your power wire, required. You can simply plug it in and enjoy. JLCPCB has  agreed to sponsor this episode, but rather than pay for the privilege, what I negoti

ated is that  JLCPCB will produce a batch of the hardware boards for me to distribute to viewers who want  to contribute to the open-source codebase. Priority will be given to contributors on GitHub  that have React experience and are willing to tackle the embedded user interface that allows you  to configure effects and settings. But even if you just want to work on the C++ side with the ESP32,  or write a Python client program for the PC, or create cool new effects, please do get in touch  wit

h me at NightDriverLED.com. The more folks we have working with the JLCPCB board, the better!  Remember you'll need to source a HUB75 matrix, and it should be a 64x32 and ideally 3mm pitch. You  can find them on Amazon and eBay and Ali Express, and I'll put a link in the description as well.   If there's sufficient interest in this episode, I'll look at doing a code introduction  for the NightDriverLED codebase next. In the meantime and in between time, I hope to  see you next time, right here i

n Dave's Garage.