How to be a peacock engineer in the world of EDM with an outfit from a few LEDs to 148,032 LEDs while avoiding getting arrested by cops or airport security.
This story is about how wanting to participate to eye candy in other ways than my svelte looks, got slightly out of hands in the span of 5–6 years, with Burning Man and EDC Vegas being mostly to blame :)
Version 4 (2019) vs Version 5 (2021):
If you’d like build info on v5, you can go to this page: http://marc.merlins.org/perso/arduino/post_2022-01-09_LED-Pants-and-Shirt-v5-on-ESP32-and-Raspberry-Pi-with-P2-RGBPanels-and-Wifi.html
- Where did you buy it? => I didn’t
- How much did it cost? => A few hundred dollars in material but much more time than money (several months of work over 3 years). Well, v5 is now $300 just in panels (plus the spares), plus electronics and batteries, so it’s closer to $500.
- Can I have one/Will you make me/sell me one? => Sorry, no, but here is my page with build info and code if you’d like to make your own. You have to earn it :) Also, it’s somewhat fragile, requires some engineering skills to fix when it breaks, and programming (C++) to modify, which at this point includes adding pictures. Yes, it’s not user friendly, that takes even more time :) Everyone has a price, but honestly I wouldn’t want to have to support this for anyone else than myself and only encourage people who can understand it and support it themselves, to make their own.
- How long do the batteries last? => At least 14 to 16H with 160Wh for the single computer (ESP32) v4 outfit that ran 64x96. The newer v5 outfit has 4x more pixels (128x192), uses 2 computers (ESP32 + rPi) and a bit more power. I had to add a 3rd battery and now have around 240Wh of batteries for about 12H of runtime. 240Wh is enough power to run my entire house for 15 to 30mn :)
- Is it hot to wear? => Actually barely, which is good as heat is wasted energy (v5 is slightly warmer due to the rPi)
- How many pixels? => 12480 or 37440 LEDs (actually it’s not an FAQ, but it should be 😄). Actually V5 that is now rPi based has 148,032 LEDs total.
- No seriously, I want one! At least give me the code! => Sure, if this page is too long, skip to the end of the page with all the links, including the code.
But let’s rewind, every story has a beginning :)
How my LED outfit obsession started
So, I like EDM (Electronic Dance Music), and more specifically melodic Trance Music. Whether Trance is your thing or not, EDM festivals have become more fun over time as some people started coming with outfits
and in the US, totem poles started becoming popular in the early 2010’s. Some were utter crap and distasteful, while others were well done and/or funny
But personally, I didn’t exactly have any friends :) , and didn’t really want to be weighed down by a totem pole (the cooler ones can be big and heavy).
Being an engineer, I like blinkenlights, and most anyone who has gone to EDM festivals at night, never mind burning man, will say that lights are fun:
And then, I went to my first EDC in 2015 where I realized OMG, there is no limit (and EDC only got more crazy in the following years):
So, the gauntlet had been thrown, I couldn’t just show up naked like a peasant.
2016: LED shirt version 1
Conveniently, I had recently come back from Japan with an obligatory stop in Akihabara where I picked up a string of colored LEDs and an 18650 battery holder. Honestly, I had no idea what I’d use them for, but it felt like a good idea at the time :)
Because I fly RC planes, I had voltage regulators and only had to buy controllable dimmer for the LED strip. The LEDs were not controllable individually, all they did was flash on and off at controllable intervals (including pulsing).
4x 18650 batteries (3.0 to 4.1V each) would give 16.4V when full and go down to 12V. The voltage regulator made sure that I wouldn’t send more than 12V into the LEDs and burn them. This was way too much battery capacity for the LED draw (I never measured it, but it could have run for a few days), but worked well enough. For this version, a USB battery pack wouldn’t have been ideal as most deliver 5V and the led strip needed 12V. You can up-convert 5V to 12V, but this more or less triples the amps coming out of your pack, and most aren’t designed to delivery that many amps to start with. Starting with 16V and stepping it down was a simpler, and used hardware I already had.
This was also the time that you started to see LED shoes, but they were all cheap and had a poor runtime because of having batteries that were too small. Depending on what you found, they lasted 4 to 6H when I needed 12H for EDC and Burning Man. Not to worry, I used a small lipo battery I had from RC plane cameras, and added it in parallel with the stock battery to get 16H:
If you really want more LED shoes info, I have this blog post. That said, notes to others on LED shoes:
- do not take a brand new pair of shoes and go to EDC or Burning Man with them. You’ll walk a lot in them and if the fit isn’t good, you’ll end up with very unhappy feet or terrible blisters like I did once EDC when I swapped my LED shoes at the last minute
- LED shoes are a huge compromise, you end up bending them repeatedly and pounding on them. My little battery hack with flimsy wires didn’t last that long with all the flexing and pounding. Sadly the LED strips are also perpendicular to the direction of flex, so the strips themselves tend to break after a while.
- I so wish I could have spend $100 on a nice pair of LED shoes with a built in 12H battery and LED strips that don’t break, but so far I have 4 $40 pairs that have broken one after another because people are cheap and don’t want to pay more.
2016 Burning Man: LED shirt version 2
After EDC, as part of a monthly visit to my local electronics flea market, I picked up a strip of RGB LEDs. They were not individually controllable, but they could change colors (unlike the other ones that were of fixed color)
In the name of redundancy and flexibility in battery use, I built another power system that could use RC plane batteries which are similar electrically to 18650 (4.1V Li-Ion vs 4.2V Li-Polymer).
The problem with the controllable LED strip was that it was also too bright at full power (16V stepped down to 12V), so I used a 10V controllable step down converter you see on the bottom left with an LCD.
Most engineers will tell you that you want to limit current to limit LED brightness, which is true, and that’s why I got a fancy step down converter with current limiter, but turns out it’s not a good idea for tri color LEDs, as if you limit the total current to 50mA ahead of the tri color LED controller you can see sitting on top of the battery, you either get 15mA sent to a single color, making it very bright, but if the controller switches to white, the 15mA gets shared across 3 LEDs, giving them 5mA each, which is not bright at all.
The solution around this is actually to use a voltage converter (DC-DC step down) and when you give an LED less voltage that it needs, it self regulates the current it draws and becomes less bright. This scenario works out better though because all 3 color LEDs get the same reduced voltage and can draw whatever current they need as a result.
If you are curious to read more about power, amps, and volts, as well as issues of wire gauge that I won’t go into (and aren’t too relevant for my portable designs that have stayed under 10A and work with reasonable wires and simple JST connectors), I direct you to my good friend Afik’s project page that talks more about such things
So, that LED strip had issues, first is that it had to be somewhat glued to the shirt in many points, and the glue points didn’t like movement that much, but worse than that, dancing, people bumping into me, and folding the shirt for travel would bend the LED strip in ways that its internal copper traces would break. Over time I spent more and more time soldering jump wires over disconnected traces, and even with that, more parts of the strip would look different colors, not because it was supposed to, but because electrically some of the colors weren’t getting to all the LEDs anymore:
Addressable Pixels and Infrared Reading
So by now, the slope sure started to get slippery. An evil coworker ended up giving me some unused Neopixel (WS2812B) strips from a 64x64 array project he was working on.
So, well, I had to put them to use somehow, right? Right….
I went through the adafruit neopixel guide to get the basics working, but thankfully soon realized that FastLED was a better driver for them, that being said, with both drivers it was very clear that an arduino uno (or anything 328p based) was just not going to work with infrared reading.
Just like Afik found out while trying to read serial port input while outputting signals to neopixels was non trivial (albeit possible if you like pain :) ), 328p chips are just too underpowered for talking to Neopixels and doing something else time sensitive at the same time, so I quickly looked at other CPU options. At the time, I didn’t have ESP32 on a small chip yet as they were new, and the infrared reading driver hadn’t been written yet (I contributed one later to the arduino IRRemote library), so that left me with teensy 3.1 and ESP8266 as reasonable 32bit CPUs with good amounts of RAM.
I ended up picking the ESP8266 because it was cheaper ($5), had better debugging capabilities, and onboard flash that could be used to store stuff (ok, I lie, I didn’t quite know then that I’d take advantage of that later)
If you like gory details on how without using the dedicated DMA RMT device of a better chip like ESP32, you can do interrupt driven IR reading by repeated high speed sampling of an IR pin, and update neopixels constantly, this page explains the details (long story short the faster 32bit chips actually re-enable interrupts in between each pixel update and allow a fast ISR/Interrupt State Routine to run quickly in between, just enough for sampling infrared waveforms).
So, when this was all said and done, I had code that could update cool patterns on neopixels while responding to an infrared remote to change the patterns being displayed.
This now brings us to….
EDC 2017: LED shirt version 2.5: Neopixels on Arms and Legs
It seemed like an obvious improvement to add my addressable LEDs to the arms and legs
Wiring-wise it was a bit more complicated because I now had two power systems, one for dimmable 12V (center shirt non addressable LEDs), and one 5V for the neopixels (which are dimmable in software, not in hardware by lowering the voltage)
Maintenance LEDs was becoming a problem
I know that by now you probably feel truly sorry for my problems which are totally not self induced at all :)
I started having to smuggle a soldering iron in my carry on through TSA (it got through) and spending time to re-solder the strips as they broke.
While the center strips were fragile, the neopixels were actually even worse being on my arms and legs, and being flexed more. Those strips were harder to fix by soldering as the physical traces on the strip got broken inside and neopixels are harder to fix since each pixel is responsible for shifting the input signal and rebroadcasting to the next pixels.
There is a solution to this problem, it’s called WS2813. The newer strips have 2 data lines with one that allows skipping over a bad pixel and resynchronizing the signal so that the pixels aren’t offset by one if you have to skip a bad pixel. I found that the strips I actually bought with my own money this time, also had better copper traces that have not broken easily so far, even when bent repeatedly. Thankfully Afik doesn’t have this problem because his LED strips don’t have to keep bending back and forth.
This left me with the issue of the center LEDs on the shirt. Those kept getting broken too, and were more or less glued on the shirt, making it impossible to wash. I tried to treat the shirt with anti sweat sprays and so forth, but eventually after burning man, I had to wash it, which basically meant removing all the LED strips and replacing them.
This eventually led me to rethink my design and get rid of them.
EDC 2018: LED shirt version 3: 32x24 NeoPixel Matrix, 1728 RGB pixels, 5184 LEDs
So, the first step is that I got a new shirt, and I bought a special more expensive shirt that is water repellant for both sweat and random beer or whatever that others may end up spilling on me. It was only $80 or so, and given the use I have for it, well worth the money.
Next, the neopixel market had improved and you could find some pre-made matrices (I learned early on that making your own matrices by hand with strips is an exercise in pain and self loathing, although only after building first a 24x24 matrix that took a day of soldering and laying out, and much later a stupid 64x64 matrix that took over a week of solid work). Kids be smart, don’t do bad drugs like alcohol, and don’t make your own 64x64 neomatrix array:
But it’s actually reasonable enough to do 24x32 with pre-made matrices:
By 2018, I was able to find pre-made 16x16 matrices in P10 (1cm² per pixel), or 8x32. Turns out 3 times 8x32 gives 24cm across by 32cm height which is enough to fit on my chest and back (I made mirrored displays so that people behind me don’t miss out :-D), and used velcro so that it was easy to take the panel on and off and wash the shirt.
For the back, I actually put the panel inside the shirt and used the back of the shirt as a diffuser (doesn’t work in the front because of the buttons, so I used tracing paper instead):
So, equipped with the freshly built and barely tested shirt, I went to EDC2018, and it mostly worked except for a short that happened with one of my solder points on one of the two panels. Thankfully my fuse, redundant wiring and power systems allowed me to recover and keep running on a single panel for the 2 last days (finding the short was non trivial and took several hours after I got home).
EDC 2018 is when I ran into Afik who’s become a good friend of mine since then, and who also decided to use a lot of neopixels for his totem pole. Because he’s a glutton for punishment, he actually did that on a very underpowered Arduino Uno :)
The Uno aka Arduino 328p is the original underpowered arduino chip which in this case doesn’t even have enough RAM to hold all the pixel data in RAM (he has 840 pixels, at 3 bytes per pixel, or 2520 bytes of RAM on a board that only has 2KB of RAM), so he uses fancy code that generates the pixel data on the fly. From a software engineering standpoint, very cool.
However my shirt does a lot more than just displaying fonts and simple graphics and generating the pixel data on the fly would be unreasonable. The code I have uses a framebuffer (RAM that holds all the display data), that gets pushed to the pixels about 100 times per second for smooth animations. This in turn, also means I need a better CPU, and I picked the ESP8266 which turns out to actually be smaller and cheaper ($5) than an arduino Uno while being 32bits and having 96KB of RAM. While my framebuffer needs 2304 bytes per frame, some demos I run buffer a frame or two, and the animated gif decoder also uses some scratch space to decode animations, so the extra RAM was put to good use.
Without going into long details on Neopixels (aka WS2812B) require a very precisely controlled update signal that needs to be sent just at the right speed to update all the pixels one by one (you can only reach the last one after you’ve updated all the ones in front of it). Too slow (because your CPU is busy doing something else), and the display is garbled. Too fast, and things don’t work either. This means that the longer your LED strip is (and a matrix is really just a very long LED strip wired in zigzag), the longer it takes to update all the pixels one by one until you reach the last one in the chain because you can’t send the signal any faster to reach more LEDs.
Afik’s sign could actually use a single data line to drive all the neopixels and still have an acceptable refresh rate, but with 768 pixels, my shirt display would have had 36Hz refresh rate which was too low for my taste, so I went with 3 parallel lines, giving me a nice 108Hz refresh.
So, by now people were getting pretty impressed, I got to wear the shirt at a lot of events, including Burning Man 2018. I found a few people with pixels on their shirt too, but no one with an actual matrix and animations:
By now, a reasonable person would be happy enough, but I think we probably established by now that reasonable is a concept I haven’t quite grasped yet :)
Besides, I wanted more pixels, I thought 24x32 was a pitiful resolution for animations (and it is), which brings us to…
2019: LED shirt version 4: 64x96 flexible RGB Panels, 12480 RGB pixels, 37440 LEDs
This is where stuff got out of hands a bit. While you may think the matrix looked pretty cool, 32x24 pixels just isn’t enough for many animations or even most animated gifs. I had to dig out animations back from the 8bit computer days when then screens were small and every pixel counted. 64x64 is where things get more interesting.
The only solution was of course “more pixels”, but this wasn’t very feasible with neopixels for 2 reasons:
- Power: I made a 64x64 Neopixel array for Burning Man because I was lacking common sense and sunk a couple of weeks of solid work to build it after a coworker gave me the LED strips. At full power it used 160Amps at 5V. Even by knowing that you can get away with 1/4th or 1/8th of the power required for full white, that would still be 20A which is a bit over the top for a wearable system.
- Size: neopixels are 3 LEDs attached to a small computer chip. This makes them not so cheap and they can’t be that small. At that time, I couldn’t find a pre-made matrix at a size smaller than P10 (pitch 10mm, i.e. 1 pixel per centimeter), and even at P5 which I couldn’t buy, 64x64 would have been 32cm across, which is too wide for my body size (25cm was about the limit)
So what’s the solution? RGB Panels, which is what I had seen people using the previous year at EDC:
The problem with RGBPanels thus far had been that they were not only not flexible but also 1cm thick, and they were also annoying to drive. Those panels were meant to be used for bus signs and giant TVs, not to be worn on my shirt, which is why I had ignored them so far.
Also, the LEDs in them have no chip attached to them, so you have to constantly refresh them tens of thousands of times per second mixing the RGB component colors at different intensity to create the colors that you need (to get a hue or purple, you may flash the blue LED 134 times out of a 256 total possible (just over 50%) and maybe flash the red LED 58 times out of the 256 time slots before you start over for the next pixel).
By now you may wonder why you’re not seeing the flashing and that’s before of persistence of vision, our eyes can’t tell something is flashing at 100Hz or more, but our cell phones and camera can, and if you don’t refresh your panel quickly enough, you get unsightly things like this:
If you’re interested in more details on how refresh based matrices work, you can look at that simpler example I wrote a page and driver for.
During Xmas 2018, I ordered a few RGBPanels to play with during the holidays, because why not and I ended up writing SmartMatrix::GFX, an arduino library that supported the same 2D Graphics API I had been using for my code, but on a new hardware backend, RGBPanels driven by the SmartMatrix library written by Louis Beaudoin.
After a couple of months of work, I was able to run all my existing code on top of those new panels and while I was doing that, I found flexible P4 64x32 RGBPanels from Azerone, which allowed my new shirt to become reality, well, after countless weeks writing a lot of code that is :) I measured them and found that in P4 size, I could just fit 64x96 on my body (front and back) using 3 panels on each side.
But how about power? Do you need more power for that many more pixels? Well, the good news is that actually it uses slightly less power because with that technology the rows are only turned on one 16th of the time (they are ABCD panels with 4 address lines, meaning that you refresh one line out of 16, and then refresh the next one, until you loop back to the first).
If you rescan quickly enough, it looks like a continuous display even though it is not, but it also makes them a bit less bright and less power hungry. Also, the pixels being smaller, each pixel also emits less light. All in all the v4 shirt is a bit less bright than the v3 shirt, but that’s not a big deal as the v3 shirt was blinding at night and I had to run it at 1/4th power anyway.
The build details and code are on this page if you are interested with an overview below
Electronics-wise, I used an ESP32 dual-core arduino API compatible CPU, and you can see the 15 channel ribbon required to drive and refresh the RGBPanels. The back of the ESP32 board has a plug for the same IR receiver I’ve been using, and the same remote that came with my original tri color non addressable LED controllers which I stopped using a long time ago now since they kept breaking, but the remotes were great:
And finally, the end result is 96x64 pixels per side, 12288 pixels, plus 48 pixels per arm and leg, for a total of 12480 pixels with 3 RGB LEDs, or 37440 LEDs. Here is a video showing the animations:
And here is the end result. I think it’s ok for now, I don’t feel too ashamed :)
2021: LED shirt version 5: 128x192 P2 RGB Panels, 49344 RGB pixels or 148,032 LEDs
The next level version took close to 1.5 years to design. It’s based on a port of my code and the arduino environment on Raspberry Pi which is required to refresh 3 high resolution RGB Panels at high speed so that you don’t see refresh bars when you take pictures.
The ESP32 was upgraded to a Pro version with 4MB of PSRAM and 16MB of flash to hold a lot more animations, although the ESP32 now acts as the Wifi access point and web server, takes commands and forwards them to the rPi over USB serial, and the rPi renders the demo code locally and displays them at higher resolution
Find more details on this page:
Power-wise, I have 4 times more LEDs than version 4, but the LEDs are half the size, so the display size is the same and the power use only about 1.5x more. I now have 160Wh for 8.5H or 240Wh of batteries for about 13–14H. It’s big and heavy in my fanny pack (2 batteries in the box, and a 3rd optional battery connected on the outside of long festivals):
Here is a demo that shows outfit v4 vs v5, including the code emulation running on my linux computer
This other demo shows a slightly newer version where the rPi is now able to shift to 2 different panels (one front and one for my back). I did improve the refresh rate after this video, so the bars you see in that video. At 1:30, it shows the web interface I wrote and control through my phone (which is much better than IR when I now have over 200 demos). The other cool thing you can see at 3:30 is my same code running directly on my linux laptop, which make development and debugging a lot easier:
I had to wait until August 2021 to go to Europe for creamfields (where the bastards at security banned me from entering with my outfit, because it’s not a bomb, but it looks like one. Yeah for idiocy), but thankfully Untold in Romania was sooo much nicer, and I even ended up on national TV after day #1. This also shows how it looks when I’m wearing it, and I didn’t even have to film it myself, woot!
So airports must love all this stuff, right?
It’s been hit and miss. If the security agents happen to open my luggage and see the self made box full of wires, some freak out. I’ve actually started putting black tape over the LED digits because they look like countdown counters for bombs, and agents can tell they’re not, but don’t get over the initial “this seems unsafe” feeling.
The main issue is the lipo batteries that are a fire risk if you short or puncture them. Given that they were meant for my RC plane, they are optimized for weight, and do not have a heavy protective shell around them (but still some protective layers to avoid being punctured and self igniting).
For short-circuits, I do have a fuse in my circuit, and wires that honestly will just melt and act as a fuse if you put 50A or more through them (the batteries can deliver over 150A easily).
Airlines do want you to carry those batteries in your carry on so that they can deal with a fire in the cabin more easily than a fire in the cargo space for check in luggage. There is a limit of 100Wh per battery, which my batteries are under (16V x 5Ah = 80Wh), with occasional exemptions to 160Wh, but that’s airline dependent. You can however have 2x 80Wh, which is still 160Wh but stays under the 100Wh limit per battery, and that’s what I do.
New Zealand was the most annoying place for flying with this stuff, but that’s mostly because of their procedures and the machine learning model they use for their Xray machines. They detained me each time and let me go after 5 to 10mn and having verified that I’m under the allowed limits.
And what’s with the not getting arrested?
Oh yeah, that. So I designed my system to be modular. I can change the batteries, replace the dual battery system with a single bigger one, remove the in line power counter (it’s hard to estimate life left from measuring voltage, but I have a meter that measures how many mAh went through the wire and from that I know more or less how many Ah are left in the batteries and can easily calculate from the current battery use, how many hours I have left).
I also have backups because things fail, so the wiring is somewhat redundant, and I have a backup power system and backup microcontroller in case the primary one fails, wires break (not too hard to fix, but harder to fix at night without a soldering iron). This however means that I have a fanny pack full of wires and numbers that change, which obviously means a bomb, just like on TV (or something).
This video shows the mess of wires a bit. It’s not a mess to me, any more than your ugly baby is not ugly to you :) but yeah, it kind of is a mess to others at best, or a bunch of wires that look just like a bomb on TV to others.
On my 3rd day of EDC in 2018, an event security person freaked out and called the cops who detained me. One cop left with my ID to go run it to see if I wasn’t in any terrorist database, while another one went through all my stuff while I calmly explained that numbers changing didn’t have to mean timer, and besides the wires didn’t go to any TNT that he could see.
Eventually they let me go, but the security folks were still not sure if they wanted to let me into the event. After I pointed out to them that it was day #3 and showed them pictures of me inside on day #1 and #2, they still weren’t completely convinced, so they called a supervisor from Insomniac who was around, and thankfully he said “yeah, that’s fine”. To this day, I owe thank you to this person: thank you whoever you were.
After that, I learned a lesson that I should always wear my shirt with everything running when going through security so that the person was amused enough by the shirt that they’d forget the OMG wires fear response (I wasn’t wearing the shirt that day at EDC because it was super hot outside and I was only getting through security to get into a 1H bus to the event where I was planning to wear it then).
This bring us to Luminosity July 2019, where I flew all my stuff to Holland for a 4 day trance event, wore it without issues on day #1, and on day #2 some mall rent a cop freaked out anyway, escalated this and it was eventually denied as “unsafe” because I kid you not “ok, we’re ok with the fact that you’re not a bomber, but someone could rip the wires from your costume and use them to strangle someone else”. Good thing no one had shoe laces or else we’d all have died that day. Sigh…
It was a pretty sad moment for me to witness reptilian human fear and silliness and pay for it in having my outfit banned for the next 3 days as they felt they had to find a way to justify their initial reaction to save face, even when there was no real point anymore.
I took it as a learning experience though, and made a box for the batteries and a box for the electronics, so that all the scary stuff is hidden inside. I may put tape over the scary numbers if I feel that becomes necessary, and remove said tape after passing security… (actually I did, and added a switch to turn them off, because I got way too much feedback that such LED number displays truly trigger some bomb memories from old TV shows with “red wire or blue wire?”)
The boxes helped, but I found out later that removing the 3 segment LED displays was also necessary as they scream “bomb” to a lot of people. Outside of luminosity, creamfields in the UK was the only place where the security were complete dicks on a power trip, banned my entire outfit “because it looks like a bomb even though it’s not”, and for good measure, made me rip out all the LEDs on my arms and legs, because if you’re going to be a dick on a power trip, might as well be one all the way.
My pretty extensive demo collection was now over 70 different patterns that would give about 45mn before looping. This did include a fair amount of animated gifs, as well as demos that I wrote, or inherited from other people who were nice enough to open source their code (special credit goes to Jason Coon for his demos in Aurora, Mark Estes for his own demos, and Louis Beaudoin for his AnimatedGifs code that I modified a fair amount, but sure made my life easier).
Got to meet Louis Beaudoin in Cambridge during a UK trip between creamfields festival, and AGBT 450 in London. While my v5 outfit doesn’t rely on SmartMatrix anymore, his SmartMatrix driver powered my v4 outfit for close to 2 years and I’m very thankful for that:
Also got to meet Mark Estes at EDC Vegas 2021, he was super happy to see his code running on my outfit:
Also, none of my stuff would have happened without all the great libraries that adafruit has written, including the GFX library a lot of my code relies on and my new libraries were written for.
Similarly plenty of other libraries I use like FastLED, SmartMatrix, IRRemote, and more. Thank you to everyone who wrote those libraries and open sourced them. You inspired me to write my own and share with others just as well.
Ok, Version 4 of the shirt took an increasingly large amount of time setting up one of the first documented ESP32s running SmartMatrix on bigger displays and hitting memory limits that I had to fix one by one in the libraries and code that I was using.
I can add a few demos, but I’ve maxed out the FatFS space used by animated gifs and don’t really feel like adding an sdcard, especially as demos that generate patterns on the fly are cooler engineering-wise than just gifs animations.
It was fun, but I can’t quite keep growing in size and complexity each year like this. I’m hoping to ride this version for maybe a few years before I get bored and feel too inadequate again :)
That being said, my current platform, arduino, can’t really support many more pixels on current CPUs (teensy 3.6 and ESP32) due to memory limits, so I’m going to have to switch to Raspberry Pi if I want to drive more pixels, both for memory reasons and because of the processing power required to refresh those dump RGBPanels with more and more pixels at high enough speeds so that it doesn’t flash to the naked eye or look bad on camera.
This will require me to write yet another library and more glue code. It should be doable, but it won’t be trivial. As a bridge exercise, though, I wrote another library to run all my code on higher resolution TFTs and have run my code on 128x160 pixels so far.
Spoiler alert: it’s done, V5 does exactly that, see below.
What’s next? 2021 Update
Well, I did go bigger, that’s v5 running 128x192 using a dual computer setup (ESP32 + rPi with active3 board). Scroll back up and look for “version 5” for details.
But in a nutshell, v5 was even more unreasonable to design and so much more work than v4, which itself was already a lot more work than v3. Clearly the work has been exponential like, and I think stopping at v5 for now is probably not a bad thing. There is room for more graphics and demos without having to redo everything with something even bigger and more insane.
Great, please help me make my own
If you are motivated, did due diligence/reading, and need help, please let me know and I’ll try to help you, that said, please read the stuff below first:
If you are new to open source, please be mindful that people like me who share code and documentation for free, already donated a non trivial amount of their time in their process (including for me the many days spent to write this post, blog posts linked below, and of course code that I’m sharing with you).
If time allows, they may be able to answer questions and offer help, but please act as if that their time is more valuable than yours: if you ask for help, do proper homework, say what you tried, what worked, what didn’t work, and above all don’t just say “I want this, please help me build/write it”, unless you have negotiated a paid support contract :)
While it is long, if you are new at this, I do recommend you read http://www.catb.org/~esr/faqs/smart-questions.html
Now that this is out of the way, the biggest piece of advice I can give you is to start small and work your way up. You’ll get intermediate rewards for achieving each step, and you’ll be dealing with easier chunks to debug if things go wrong. This is another way to say that you shouldn’t just start with my full code and try to make it work. With that being said, here are some pointers:
- For FastLED based projects, please ask for help here: https://www.reddit.com/r/FastLED/
- For RGBPanel/SmartMatrix based projects, please go here: https://community.pixelmatix.com/
- For the GFX/FastLED FrameBuffer layer I wrote and that is common to both backends, go here and open github issues if needed: https://github.com/marcmerlin/Framebuffer_GFX https://github.com/marcmerlin/FastLED_NeoMatrix/ https://github.com/marcmerlin/SmartMatrix_GFX/
- Please read all the READMEs of the projects above, and try the example/sample code to get started. If you are going to use my software layer, please have a careful look at https://github.com/marcmerlin/FastLED_NeoMatrix_SmartMatrix_LEDMatrix_GFX_Demos
- As for the full combined demo code that runs my shirt, see https://github.com/marcmerlin/NeoMatrix-FastLED-IR . You should definitely not start with this, please get simpler examples working on whichever backend you have chosen (FastLED Matrix, RGBPanel, or TFT screen), first.
More help/blog posts with information:
- Dealing with Infrared and Neopixels
- Shirt v3 with FastLED::NeoMatrix
- Making a big 64x64 NeoMatrix (wiring/power considerations as well as 16 way parallel updates as well as a discussion of ESP32 vs teensy 3.6 and RGBPanels vs Neopixel arrays)
- Using SmartMatrix and SmartMatrix::GFX with RGBPanels
- Shirt v4 with RGBPanels
- Using diffusers for RGBPanels
- Running animated gifs on top of the different hardware backends
- FatFS instead of SPIFFS for storing your gifs on ESP32’s built in flash
See you at an EDM festival or Burning Man?
Come say hi, show me your work, I’ll shake your hand and we’ll take pictures :)
If you read that far, congratulations, this page took much longer to write than I had planned to, but hopefully the journey with intermediate steps, gives you a good idea on how to do this yourself now. You can clap for yourself for the reading you all did :) or to thank me for this page if you liked it, at the bottom of this page.