A Fiery Wi-Fi Lamp on ESP32 — How We Started Our Own Little Candle Factory

Our team is developing a cloud-based IoT platform, and to test its features we regularly build small projects: “smart” relays, outlets, string lights, and so on. Some projects turn out to be so interesting that they grow into full-fledged products. We decided to tell you about one such case.

Flame Wi-Fi lamp on ESP32 – how we started our own little candle factory

How the idea for a flame lamp came about – the backstory

We already had a Wi-Fi controller for addressable LED strips with several operating modes—a ready-made “smart” string light. The controller lets you switch modes, adjust brightness, and set the LEDs’ color. The string light connects to a mobile app, so you can control it from anywhere with an internet connection.



One of the engineers on the team brought a 16x16 addressable LED matrix to the office, and we decided to connect it to our controller. No problems there—all the basic modes worked. We could choose the LEDs’ color, start strobe mode, or switch to classic string-light mode.



We liked the matrix as a new playground for experiments. We started thinking about what we could make that would be genuinely interesting.

It had all been done before (but we found room for improvement)

Of course, the first thing we did was Google what other people were making with similar matrices. At the top of the search results was Gaiver’s lamp, along with lots of variations by other developers. It’s a pretty interesting product with plenty of potential—lots of possible operating modes, control methods, and enclosure designs. And most importantly, it looks really cool!

We didn’t spend long thinking about it—we decided to build one. We noticed that the original project used an ESP8266 microcontroller. We immediately decided to use the ESP32 as the more modern MCU. Besides, it was the basis for all the devices we’d built before.

We didn’t have to run around plumbing stores or places like Leroy Merlin looking for suitable pipes and lampshades, either—we already had our own 3D printer. We picked a suitable enclosure model on Thingiverse and started putting together our prototype.

By the way, if you don’t have your own 3D printer, we recommend makexyz—it helps you find a 3D printing service near you.



In the first version of the lamp, we made no changes other than switching to the ESP32. The enclosure was printed as-is, and we secured the matrix with zip ties—the second most versatile tool in our lab, after electrical tape.



We were delighted with the result, and the whole team loved it. It was clear the idea was worth developing further. We started experimenting with the operating modes and looking at what members of the original project’s community had come up with. And at some point, that very magic happened…. Although… wait. Magic outside Hogwarts is forbidden. Let’s just say something really cool happened.

Fire mode—the killer feature that blew everyone away

While experimenting with the lamp, our developer Seryozha added Fire mode, borrowed from this collection of effects in Alex Gaiver’s community. We simplified the mode’s logic a little—in the original, it varies depending on the matrix size and its orientation. We removed that complication and focused on a 16x16 matrix.

Once we had Fire mode, pairing it with a transparent lampshade produced a huge wow factor. The head of a parallel project at the company was so fired up that he immediately ordered a small batch of 50 units as New Year’s gifts for partners.



It became clear that the device had solid commercial potential. What’s more, we could offer advantages over the versions sold online or assembled by hobbyists: a well-designed mobile app, not one that looks like it’s from the early 2010s; additional control options (voice commands, phone calls, a Telegram bot); and shared access to lamp controls. These are all benefits of the IoT platform that we set out to test in the first place. We realized the device had market potential, so we started thinking about scaling the DIY idea into a commercial product.

What needed to be improved

After receiving an order for our first small batch of lamps, we came up with the following list of improvements:

• design a compact circuit board and make room in the enclosure to hide it;
  
• add a touch button to control the lamp—as an alternative to the mobile app and simply for added convenience;
  
• position the Reset button on the board beneath the ̶h̶o̶l̶e̶ manufacturing opening in the enclosure;
  
• decorate the enclosure with 2Smart logos;
  
• choose a power supply to make the kit complete;
  
• choose attractive packaging;
  
• include an instruction leaflet in the kit.
  

We seem to have thought through everything on the hardware and packaging side, but we’ll almost certainly keep refining the software. Firmware bugs may crop up, and new modes will definitely be added to the mobile app... This is where our platform’s update delivery feature comes in handy: all we’ll need to do is upload a new firmware file to the server, and all connected lamps will update over the air.

Production

Since we were short on time—the first 50 lamps had to be ready by early December—we started several processes in parallel:

• We ordered components from local stores (there wasn’t time to wait for delivery from AliExpress, even though prices there are lower).
  

• We looked for contractors who could quickly manufacture the circuit boards and assemble the devices. It’s straightforward: search online, call around, compare prices. If you have more time, you can use jlcpcb or a similar service, but we were up against a deadline.
  

• We kept the 3D printer running at full capacity to make the enclosures.
  

• We ordered kraft wooden boxes with our own logo.
  

• We ordered the instruction leaflets from a print shop.
  

In our case, the cost of making one lamp came to about $39 (1050 UAH). A few things are worth noting:

• we bought the components from regular online stores in Ukraine; ordering from AliExpress would have saved us a little;
  
• we printed the enclosure on our own 3D printer, counting only a small amount for equipment depreciation and the cost of materials. Having it printed by an outside service would make the enclosure more expensive;
  
• the total includes the box and printed leaflet—an extra $6 per lamp.
  

Here’s the full breakdown in dollars:



Finished lamps on the market start at $65, and that price doesn’t include a gift-ready kraft box. Even using that as our baseline, commercial production of these lamps could be quite profitable. Our version would also have several competitive advantages: a more advanced microcontroller, over-the-air firmware updates, and a modern mobile app.

How to build and set up the same lamp yourself

Our company is currently preparing to launch sales of the fire lamp. But just because we’re telling you about it doesn’t mean we insist you buy it from us if you find the device interesting. Anyone can build the lamp themselves—we’ve uploaded everything you need to a repository on GitHub: the board’s Gerber files, a parts list, and the firmware code.

What’s more, if you decide to add your own effect, we’ll show you how:

1. Fork the project.
   

1. Clone the project from your own GitHub account. You can do this with the git clone command, pasting in the copied link.
   

1. After cloning the project, create a branch and make your changes in it:
   

• add the effect method to lib/lenta/lenta.h:
  

• add the effect name to LedStripStates:
  

• in modes_, associate the effect name with the name to be displayed in the mobile app:
  

• In lib/lenta/lenta.cpp, add the method body describing the effect's full logic. Add helper methods if needed.
  

Attention! Remember that lighting the LEDs is also the mode's responsibility, so you need to use the LEDS.show(); command.

• In HandleCurrentState, add the mode to the switch:
  

1. Build the firmware by running pio run (from the Firmware folder).
   

The finished firmware file will be in the project folder at Firmware/.pio/build/esp32dev/firmware.bin (assuming the build completes without errors ;) )

To flash the lamp with your code:

1. Connect to the device's Wi-Fi access point, “2Smart Lamp”.
   
2. Enter the IP address 192.168.4.1 in your browser's address bar to open the device's web interface. Use the login and password “admin/admin” (thanks for not making it “qwerty”, right?).
   
3. Go to the System tab in the lamp's web interface:
   

1. Upload the firmware file, wait for the update to finish (about a minute), and make sure it completed successfully.
   

That's all for now. If you'd like to know how sales of the device are going, let us know in the comments. We'll write a separate post about it if there's enough interest. Our experience may be useful to anyone thinking of starting a small business making and selling IoT devices. And if you'd like to create your own device with us, come by and say hello.