ESP32

Rock-Ona 507

I have always loved audio as a medium, I don’t know why. Starting with playing around with an old stack stereo growing up; learning I can record a record onto a tape blew my young mind. I have done several projects around audio. Continuing on that, I love the classic Jukeboxes. They come from an era before microprocessors. Before you could just put a chip in something. When real mechanical and electrical engineering made things work. To pay homage to that I have been working on a similar looking device to an old Rock-Ola 507, but… I just put a microprocessor in it…

All 3D Models and ESP32 code is on Github.

Design

The Rock-Ola 507 was a table side music player for diners and restaurants. Rock-Ola had many models of “wallboxes” that connected to jukeboxes. I always liked the older 1548 models, but those have a lot of moving parts and many buttons. Instead, I opted for the simpler 507. I called mine the Rock-Ona 507.

The idea is you could walk up to it, see a list of songs, and type in the numbers to queue it up. I could have my favorite songs available, and then also have a Bluetooth option for when you just want to stream from your phone.

(Photo from Rock-Ola 507 wallbox jukebox flyer | #102562020)

With this project I wanted to expand working with the ESP32 Audio board I did in the History Phone project. But also wanted a bit more of an old school vibe. To make the system feel more retro, one idea was to have the song list be an E-Ink screen. I thought that gave the system a softer feeling than an LCD screen. I have not used E-Ink in a project before; it turns out E-Ink panels need a special driver board. E-Ink is also not cheap, a 9.7″ panel will be $70, then you need the driver board. There are not standard boards out there to do what I wanted to, then I found an awesome open-source project!

Circuit Board Ordering with PCBWay

EPDiy (e-paper diy) is an open-source project on its 7th version of a universal E-Ink driver board! This introduced a new challenge for me; how do I get the boards made. I have not made circuit boards before, and while I have thought about making boards before, it seemed like an uphill battle. I had heard about PCBWay from Youtube videos and podcasts. I knew they had a shared projects area and hoped someone had done the heavy lifting here. Turns out someone had already uploaded the design and had it ready to go! I was not ready to push forward with the project yet and shelved the project for a bit. A few weeks later, PCBWay reached out after seeing the blog and asked if they could help pay for some of the boards to be made if I spoke about the process. It was a great match!

I went back to the shared project and added it to my cart. With the board needing a bunch of small capacitors and the ESP32 soldered to the board, I opted to also have them do full assembly. I submitted the order. A few hours later I got a message on the website and email. The shared project hadn’t set the PCB layer count, and I had accepted whatever was default (incorrect). I flagged https://vroland.github.io/epdiy-hardware/ as the source of the project and said I wasn’t sure how many layers it was. They came back quickly saying the board was a 4-layer board with 1oz for each copper layer, and it was resubmitted for approval. I was very glad someone who knew what they were doing was reviewing the board before sending it off. Later, I got another message from someone double checking the polarity of a LED on the board, and I was able to look up from the design and verify it with them.

Boards have to be ordered in sets of at least 5, I got 5. I planned to pay to have 4 assembled; I would have extras and would be able to use them in future projects. 5 boards were $25.97 + shipping and took 4 days or so to build. Then 4 boards, assembly and parts all came to $110.59, that part took about 20 days. Most of that cost was the parts (which they handle). Then shipping was around $50 at the time. All together this put each PCB at around $40. I got updates along the way, and this let me work on other aspects of the project while I followed the boards’ progress.

I plan to use PCBWay again in the future for circuit boards I may need created since 5 for ~$26 seemed like a great deal on these complicated ones. I am also curious about using them for CNC on some future projects where parts may need to be made out of metal. 3D printing works for a lot of my needs but a few parts may need to be metal.

Controller Design

The EPDiy was great for handling the E-Ink screen and uses an ESP32 that I knew how to program for; the issue was it doesn’t have enough ports for everything I need, and I need something to drive the audio as well. I returned to the ESP32 Audio board I used in the History Phone project. As I said before, its documentation is bad, but I now know how it works… so the devil you know…

The idea was to connect these two controllers, EPDiy in charge of user input and output, I called this one the IO Board; then the audio board in charge of SD card full of music, organizing the music, and playback, I called this the jukebox board. They share a serial link. The audio board comes online, checks an index of audio on an SD card. Then after reading the table of contents, sends over what to display to the IO Board. The IO Board sends back button presses as they occur. I haven’t done a project with two ESP32s working together yet, but Claude helped me get the code set up.

Quick Rust Interlude: I was interested in trying to use Rust as the ESP32 controller language instead of C, except when I looked all the libraries that make the audio board work are C, and then the EPDiy libraries are C. I either would need to do a ton of inter-language linking, or I could just do the project in C; which I did instead. Also to use Rust, I couldn’t easily use Platformio which I have been using for ESP32 projects. Platformio allows you to use Visual Studio Code to build out your Arduino / ESP32 projects, and I like it much more than the Arduino IDE or other command line tools.

This was a project I was playing with Claude Code to throw together some of the C. The code is straight forward, and Claude put together a python script which let me manage the songs I was loading on the SD card, setting up the metadata correctly for the audio board to parse. I also was able to add Bluetooth audio support. I set one of the song selections to a special setting, and that puts the device into Bluetooth pairing mode! Once a song is selected, that mode disables itself.

3D Model

I have been trying several different 3D modeling systems recently. For years now I have used Solidworks, and it works well other than it’s a giant Windows app that periodically gets hours of patching done to it. I tried OnShape, a web-based 3D modeling tool, after I ran into someone from the company and they recommended it. You get to use all their standard tools for free, as long as your designs are public. I gave it a spin. It worked decently well. My normal keyboard shortcuts didn’t all work, but that is from years of using Solidworks, not their fault. The main issue I kept having was the mating system. Theirs is MUCH different from what I am used to (again from years of Solidworks) and I kept stumbling.

This holiday season Solidworks for hobbyists was on sale, including the standard Desktop version AND the web version. I had to pay twice but got a year of each for the normal $49 price. I want to love the web version. My models aren’t that complex, and honestly Solidworks is one of the last things that keeps my desktop computer on Windows. I will keep experimenting with it, but I did find it slower and more cumbersome than the desktop version of Solidworks. In the end I made an early render in each but did the majority of the work in Solidworks Professional, the desktop version.

The original version of the Rock-Ola 507 was large, larger than a photo may let on. It was 18 inches wide, by 15 inches tall, and 6 inches deep. It was also 30 pounds… It was BIG. Here is a screenshot of OnShape with a 15.6″ screen put into a version where I had already shrunk down 2 inches.

Quick aside: One neat feature of OnShape is git-like versioning of your models. You can see on the left I tried different sizes and different screen ideas.

Here was another attempt at fitting different screens, this time I had 3 x 7.5″ (kindle like) screens in the device. Still way too big and would require 3 EPDiy boards working together (I did get 4 in case I went that route) greatly increasing the cost. This would be good for hanging in a garage or basement, but I wanted something a bit more compact.

I ended up shrinking the whole thing to ~9 inch across, about 50% the original one. This also allowed me to easily fit in on my 3D printer in one piece. I got a Sovol SV08 a bit ago, its 350mm by 350mm print bed made easy work of this.

This is a closer to finished Solidworks model. I am not showing the screen. I had an idea of using cloth for the speakers to give it a more warm feeling. I did try this on the first unit I made of two, sewing is not my thing.

I got a 9.7″ E-Ink screen off amazon, that turned out to be around the same price I saw at places like eBay and could come quickly. At $68.99, this was the largest expense of the project for one item.

Much later I realized I had one place for the USB C power to go into the side of the case, but I didn’t have anywhere for the SD card. This would mean I had to open the unit every time I wanted to change the songs on it. I got a SD card extension cable, and already had a Dremel… so I made another hole in the side…

Part of this build was figuring out a way to make the buttons feel nice. I tried several iterations and different designs. I wanted a longer throw, but something electrically simple, and could fit in the case.

I ended up with this 3-layer design. Big button with a stem, that goes through a guide that has a spring, that clicks a little push button. You get the nice throw of the switch, a good click, then it bounces back.

Part Selection

I have mentioned selecting the audio board, selecting the screen, selecting the buttons. One important thing I haven’t mentioned for an audio system is selecting the speakers. The documentation for this board mentions that it can drive 3W, 4Ohm speakers. I tried 3 different ones in different sizes thinking how different could 3W speakers’ sound. Apparently very different. The small ones had a very hollow sound. I went with the bigger speakers. The audio board needed JST-XH 2.54mm connectors in male, which I couldn’t find documented anywhere.

For filament, I did most of the prototypes parts in black. I knew I wanted a silver front from the start, and that led me to trying silver spray paint, more on that in a second. The second big personality piece is the glowing red front buttons. I got transparent PLA filament and put a strip of lights behind the buttons. This worked well. I may have instead put just a few LEDs behind the buttons instead though, because right now the LED strip is tied into the same power source as the front LEDs, and I want to increase the brightness to the buttons but not the front lights. Something to fix in future versions, or a small upgrade. Splitting the button lighting control would also allow interesting effects for if the system is left on for a while with nothing playing, dimming the screen and buttons separately.

Assembly

With boards in hand, Claude helping to put the code for them together, and the simple buttons, the hardest part of this whole project was printing it out and putting the pieces together. I will readily admit I am not the best spray painter. It also didn’t help that the chrome-looking spray paint wants 65F-90F degrees and 60%+ humidity to properly paint. Being winter around NY left me limited days where I could attempt different spray-painting techniques. I tried the whole proper 3D printing, sanding, filling, sanding, priming, sanding, spray painting for the first unit. It came out, meh. I think I over sprayed. I ended up making two units, one where I tried a few front plates, with different sanding and spray-painting techniques, then one that I just got silver filament and 3D printed it, calling it a day.

Button Assembly

I assembled the front. Soldering the buttons to a PCF8575 IO Expander, this helped give me more buttons over I2C to the EPDiy board. I created a version 1.1 of the button board. The first version had wires going everywhere which made it hard to put into the case. The updated version I put the chip on the same 3D printed part, greatly shortening the runs and making it much cleaner inside. I did get one of those PCF8575 that was bad, and that took me a bit to track down, it would spray out random buttons being hit. I thought it was my circuit. One great upside to the PCF8575, it uses 2 wires for power, and 2 for data, making the whole button assembly very self-contained.

An important note about EPDiy and PCF8575. The E-Ink part of the panel uses 0x20 ID on I2C to communicate. I had to solder on the back of the PCF8575 to change its ID to 0x21.

I got the final front panel and installed the full button assembly. I put the EPDIY onto the bracket for the screen. Then installed the E-Ink screen and its backing bracket. I had put LEDs from an LED strip I got on the front below the screen, and above, then another short strip behind the transparent buttons. Soldering the wires onto the “easy to cut” LED strip was not fun. I soldered all the LED strip positive wires together, and then the negative wires; connecting them into one of the quick connect connectors I had. The front panel was done now. I wrote the IO Board code to the ESP32 (which I ended up doing multiple times), and it was good to go. I did originally want to have text with lights behind it in the top cut out area of the front, and above the buttons, but this was added complexity for a small nice visual thing. I may add that in another iteration.

I made wide use of one of my more recent favorite 3D printing tools, heat set inserts. They are tiny metal screw points you melt into your print with a soldering iron. They give great M3, M4, or M5 mount holes that you can use in a project and not worry about wearing out the plastic. They are also $10 for 120 of them.

Electronics

Time to wire the body. I put a USB C port in the side of the case which allowed one power plug for the device. I didn’t want to have one of those devices that had USB C but not actually USB C Power Delivery negotiations. I got a little chip that allows you to declare which voltage you want over USB C. I set that to 5V.

Power goes from that board, into a USB mini cable for the jukebox board, a USB C cable for the IO Board, and a pair of wires into a MOSFET. I haven’t worked with MOSFETs to control LEDs before, but I needed it to drive the LED strips I put around the screen, and behind the buttons. This actually gave me issues because (I learned later) MOSFETs are good to regulate power but also are noisy on power lines turning on and off. They caused chaos on the power line, and I ended up putting a 1000uF capacitor on the input side of the MOSFET to help smooth out the power line. Without that, the IO and jukebox boards power was so dirty they kept blinking on and off.

*Prepare for Rookie lvl 101 Circuit Design!*

I had a bunch of quick connectors that usually are for LED lights, but I used them anywhere I may need to often connect and disconnect sub-components. If one component has more than one connector going to it, I will reverse the male/female side of the connectors to make it clear which one plugs into where. Things like PCF8575 -> IO Board, IO Board -> Jukebox board, LEDs on front panel -> MOSFET. This allowed me to quickly remove things when needed. I soldered an extra pair for the serial connection that would go between the two ESP32s.

The speakers had 4 metal anchor points around them, and I was having a hard time fitting them, so I just cut off one and it fit perfectly. The heavier speakers also helped the system stand upright, bringing a good lower point of gravity to the unit.

With the speakers in, and wired up, I used the heat sets and put the jukebox board in and programmed it. Then I wired that into the power sub system and connected the two ESP32s. And crazy enough, it worked! I did some tweaking from there around the buttons, and screen output, but overall, we were good!

I did have a moment where I had the IO Board ESP32 connected to my laptop, and jukebox on the normal power system, and I couldn’t get the serial line to come up. That’s when I remembered serial communication really needs 3 wires, RX, TX, and ground. I had originally planned for both ESP32s to be in the case and they would be sharing a common ground. Once I put both of them on the power from inside the case, the serial line came up!

With the project working, I went into one of the hardest parts: selecting music to add. While selecting music, I would let it play in the background. Working hands on with it I realized I wanted to add features like a queue to the screen and some feedback about which buttons you have pressed.

Wrapping Up

This project had me using a bunch of engineering things I hadn’t done before. Two ESP32s working together, working with a PCF8575 port expander, 3D printing then priming, and painting to try to get good chrome, MOSFETs, E-Ink; it was a lot of fun.

I also had ideas that could go into another version down the line: a knob on the side like the original to have more than one page of songs, a web interface for uploading songs and showing the queue, Spotify connect support (somehow). Possibly a cheaper version where you print out the song list and don’t need an E-Ink screen. I want to use these units for a while in my office and in the workshop, and then see what makes sense to add over time.

If anyone has any questions or is interested in making one and needs more information than I have here and in the repo let me know!

History Phone

Periodically I enjoy doing more artistic electronics projects. I wanted to capture more of the family stories I hear but aren’t recorded or written down. I had the idea to get an old rotary phone, remove the parts inside, and replace them with an ESP32. When this phone is dialed, it looks for a year that is close to the number dialed, and then plays the audio file from a family member telling a story of that year. Along with hearing the story, a companion tablet website would allow you to see photos and get more information about the story. As all my “quick projects” go, this has been going on for a while, partially because I grew the scope some, partially because getting recordings can take a while.

Along with everything below, here is the github repo that contains controller code, 3D models, scripts, and more information. I have had three hardware revisions; the first was a prototype, the second was the first phone that was overly complex, the third was a simple phone with an all in one ESP32 audio board. This project was a great way for me to play with the ESP32 using SD cards, audio, and even Wifi.

General Design

All the different versions of hardware have an ESP32, SD card reader, and an audio chip. The main inputs are on/off hook, and the rotary piece itself. Then for output we have the speaker in the handset. When the handset is picked up, we play a dial tone.

Historically I have used the Arduino IDE to develop embedded code, for this project I moved to PlatformIO. As a more advanced user its MUCH nicer. You can easily add libraries, and do all your development within VSCode.

Outside of the dialing a year, I wanted some fun features that also helped with discovery. Dialing 0 runs an Operator audio file. This file is generated by a python script that scans the SD card contents, then creates an audio file stating which years can be dialed. Dialing 9 plays a random file from the SD card, this helps with random story discovery. Dialing 8 gives the option to change the volume, this prompt is created via another python script.

The rest of the numbers will try to find a year with a fuzzy matching a decade up and down. If no audio is found, it plays a busy signal. If the user doesn’t enter a number within 10 seconds or so, it plays a busy signal.

A quick tangent: the way the rotary dials work on these old phones is interesting. There are two pairs of wires that come off the rotary. Code for it is here. The first opens once the dial moves at all, this pair goes from a closed circuit to open and remains there till it rests at the start again. That’s when you start tracking the rotary. Next the second pair will pulse every time it passes a digit. The flow for reading this is once the movement starts, clear a counter and start counting pulses. It’s shockingly and happily simple.

Pinout

Other than V1 which had all the buttons and front LEDs hooked up, the wiring is fairly simple. There is the SD Card, which is internal on the all the boards; I have done external SD cards before but I prefer to have my ESP32 boards have a SD card reader on them. Audio – headphone amp, internal on V2 board. Then the two wires mentioned for rotary, and 1 for hook on/off. That’s it!

Iterations

Prototype V0

This was my first test, I 3D Printed a holder for a rotary dial I got off eBay for about $10, and wired up all the parts I would need. For the hook I used a simple switch you could toggle on and off. I did not touch things like Wifi in this iteration, this was just to see if I could get the basics working. The rotary was around $10, then a $17 ESP32 with built in SD card reader, then a few extra dollars for a switch, audio amp, and speaker. Total cost was around $30. This was built in a weekend or so.

Phone V1

After I had the prototype working, I moved onto to getting a real phone, and trying to get everything working within that. I got this phone that had several lines, and I thought I would use those buttons for different functions. Over time this seemed like overkill and kept me from making more progress. I also needed more IO ports, and had to start using MUXes to do this, which further discouraged me. I wired up all the front buttons to have a LED behind them, and could read if they were open or closed. All I ended up doing was lighting up line 1 when the handset was picked up. The buttons do have a great tactile feel though.

I did do most of the development with this phone. I got the web interface working, and push many versions; which involved doing a static build, and then coping it to the SD card. I cut a hole in the side of this phone to allow me to externally mount the SD card. When the web pages need updated or I needed to load more content I need the SD card, and that is buried very deep in this version of the phone.

To get the hook signal, I connected to the old phones terminals that close when the phone is on the hook. This worked decently, except I added some code to take several readings and average them. I think the old contacts weren’t the cleanest leading to periodic bad readings.

I tried to do clean wiring on this one. With the ESP32 I used for this version, Freenove CAM Board, it came with headers. I used those below through this mounting plate that swiveled to connect to a MUX and audio amp, a MAX98357.

This version of the phone, was an actual phone… That cost $59 on eBay (ones with all the lines were extra), then same $17 ESP32. I installed a few LEDs, MUXes, and an audio amp. This version probably cost closer to $75, and I used this as my test bench for… Almost a year as I on and off worked on this.

Fancy Phone V2

After how complex (see wiring photos, scream in horror) V1 became, I wanted to go back to the start and make a simpler one with the core phone functions. I also found this board that included an SD card reader, and audio amp all for $20, meaning I could use a phone, and this card for everything.

At this point I am doing my normal eBay scouring, and come across this nice executive desk phone. It’s simple, and the seller accepted my low offer! (I think eBay sellers just want to get rid of these phones) I wired everything up and I had a difficult time recreating V1. The main reason is what several reviews on Amazon said about this board (EC Buying ESP32-Audio-Kit Audio Development Board, ESP32-A1S); it has basically no documentation. Luckily, one person mentioned a repo that had a ton of information on the pinout, and that worked for me.

I probably would use this board again, because now I know how to make it work; but it was not forgiving to get working. There appear to be a bunch of companies that have this same board with different names on Amazon. There are different revisions and you don’t really know which one with which pinout you will get till you get it. The company has a github repo that has SOME information, but not all.

For this phones hook signal, I had to remove the piece that would usually be triggered to fit in the ESP32. I modeled and then 3D printed a bracket that holds the ESP32 in the bottom, and at the same time it has spots for two switches that get contact when the handset is put down.

This version of the phone I got (all these prices are with shipping) for $35, its a nice solid unit. The new ESP32 board was $22. Then I added 2 switches because I needed the hook signal, and some terminals. This version of the phone was closer to $60, and I spent about a month here and there on it.

File Structure

The SD Card has 2 main folders, content and web. Within content, there are some of the stock tones like a dial tone, then there are folders for each year. Within each year: photos, txt files, and mp3 files can live. The system will select at random an MP3 file if there is more than one. The files are supposed to be named starting at 1.mp3 and increment. The idea was you would have 1.mp3 and 1.txt, which would match up and have content matching with the audio. This wouldn’t be hard to make it not that way, but that’s how I was doing it. This is all documented more in the README, on the github page.

The web folder contains a Next.js React app that is built into a static site (a great Next.js feature!).

Web Interface

One feature that was an added on stretch goal was to have a companion website for the phone, allowing for photos and other media while stories were being told. The ESP32 can host a Wifi access point and web app, and I have been learning React, so this was a great place to keep learning! I used Next.js because I have used it before, and I know it can create a static HTML version of your site. I had to overcome some CORS and api issues, then it was smooth sailing. I used the next.config.mjs file to add redirects while doing development.

Adding features like volume control on the web page, and currently playing was helpful to learn how to properly do POST requests with an ESP32. I also added the ability to click a audio file in the web app, and then that will queue up on the phone.

Conclusion

Having my family play with the end product has been fun. One of the hardest parts of the project has been getting audio, cutting it down, and finding accompanying photos.

I had a bunch more ideas for the project. Adding a Bluetooth audio output option, photos overlaid on AI-generated period artwork, family tree generator integration, on-device recording capability, support for phone buttons and indicator lights, and standardized metadata schema. I already have spent far longer than I thought on this project, so those ideas will wait for another day.

In the end this was a fun project that I learned a lot of about web servers and audio processing on an ESP32. These chips continue to amaze me in what they can do for under $20. I will probably use that same audio board again, the documentation is bad but now I know how to get it to work. Here is the repo with even more information, the supporting 3D models, and files. If anyone has questions or recreates this, please leave a comment!

Shadow Box

I enjoy working on projects that can mix a bit of art with tech/electronics. I was playing around with the idea of doing something with a shadow box which could go up on the wall. Something to do with lighting and an ESP32 came to mind. The eventual goal was to get the ESP32 onto the Wi-Fi, allowing you to control the lights and mode of a device from your phone and perhaps HomeKit. I got part of the way there, adding a button to change modes; but then I got off on another project as I am to do. I wanted to document my progress, and state for later; as well as put the code and designs up online before I go off and work on a more ambitious project.

General Design

I started playing around with 3D designs, so that a light could shine through; the designs were really 2D, but I used SolidWorks to do all the modeling, then adjusted the heights until the light came through well. I glanced around online at artwork people had, as well as periodically looking at Dribbble.com. I came around to the idea of a skyline; a city at night where the different buildings could light up, and blink. Then the idea added on; the buildings could blink to music, adding a microphone onto the controller would allow the lights to reflect the volume of audio.

I at first tried to print out individual, large, buildings and this proved to be too much and take a very long time. If you look at some of the below early renders, you can see how complex those buildings are.

I decided on the New York city skyline and started modeling the buildings. I needed a mix of decent sized windows, so the 3D print did not take forever; and small enough that the light effect came across well. I modeled several buildings, a few different ways, and did test prints. A few times I printed them taller than the printer could go, and that made me split the buildings in half. I did not like how putting them back together looked and decided to shrink the buildings a bit. I currently have a Creality Ender 3 Pro, making my bed size roughly 200mmx200mm.

Electronics

The plan was always to use an ESP32; I had not used them before and for a few dollars getting the capability to use the Arduino IDE along with Wi-Fi and Bluetooth made me interested. I also had not done much with LED strips before either. I dabbled with both on my workbench, and decided for this purpose an LED grid would be easier than working with strips. Those can be had for a few dollars online. I also got a diffusion sheet, a thick sheet of plastic that softens the light from the LED.

I worked on the Arduino code for a little while. I ended up writing a bit of code that averages the volume over time from the tiny microphone I hooked up to the ESP32, and then uses that to equate to a light level on the LED grid. The different columns in the grid matched different frequency ranges; this ended up giving a neat lighting effect with distinct types of music triggering different buildings. I need to calm it down a bit, but I didn’t put enough time into the code to get it exactly where I want it. Another code the box offers currently does a much much slower fade across the LED grid, but its sensitivity is too low, and the only way I got it to react was tapping the box; this can be seen in the video below.

I also used this as an opportunity to use KiCad for my wiring diagrams. The diagrams for this are not that complex, but I wanted to be able to quickly reference what went where. All these files are in the Github for the project. There is a button on the side of the box which cycles modes the system is in. There is an always on light, a mode to go to the music/audio in the room, slow light effects from audio (but not sensitive to the mic enough), and last was going to be a Wi-Fi mode (but I never got that working). I was going to mount an SD card for longer storage of assets for the Wi-Fi network; with the Wi-Fi not being implemented, this needed up not being needed, but a good learning experience.

There were small issues along the way, like how I wanted to make a power bus come in, and 3D printing little risers to hold everything off the back of the shadow box enough to get a good effect through the front window. Those were slowly overcome, mostly by trial and error, and I worked through the project. I fed the whole thing from a 5V wall plug. This would give power to the LED grid, and the ESP32.

I ended up simplifying the building models to speed up prints, and it generally looked nicer. The bigger windows were easier to print, and the effect functioned better. I attempted to make a mount for the LED light grid, that would have a front snap onto it to lock in the grid. I at first made the mounts too small for this, then got lazy and used hot glue over pushing forward small snapping plastic pieces.

In the end, I think the project came out well. I thought I may make more of them, for different cities, and then have a wall of them; and get the controller to the point where you could Wi-Fi control it. Except I have another project idea that has taken me away. Perhaps I will one day return to this, until then here is a video of it running (actually 3 videos spliced together), and the files will be on Github. I don’t have a ton of photos from putting it together, but here are a few.