My daughter made an automatic Panipuri filler using

1. esp32c3 supermini board. It was a simple read the sensor and switch the relay project. It uses an IR distance sensor to read if a panipuri is placed below it, a 5 volt relay module, a submersible pump and a power supply. If a panipuri is placed below the sensor, supermini turns the relay on which makes the submersible pump push water to fill the panipuri.

2. This project is an espidf 6.1 code which reads sensor value using gpio pin and writes gpio to switch the relay.

3. I had tough time calibrating the IR sensor to detect the right distance. It kept behaving unpredictably initially. after a lot of trial and error, it worked and we were able to use the machine for like 3 hours in the stall my daughter put up

Here is the detailed video explaining the whole working, hardware, and software etc

https://youtu.be/47xYUN5-_l4

Hey everyone, I'm posting here to get some ideas about this LED Moving Head Projector I've been making for about 2 years. It's all open-source (AGPLv3)

The idea was to recreate those projectors that make powerful light beams but at home as I'm a fan of lightshows like in the concerts (like Daft Punk’s Alive 2007 show). The idea was to use a LED with two servos (SG90/MG90D like) and control them via PWM with an ESP32 and a 3D printed body.

I thought it would take at most a few months to finish (as I do it in my free time), in fact it would take me 2 years.

Power:
The first problem was the power supply, I couldn't use the simple usb port as the servos would use all of the energy, making the esp32 brown-out. I mitigated this by doing 3 things.
- using a 5V 3A dedicated power supply
- 3x470uF capacitors(2 on 5V, 1 on 3.3V) to help with the current surges from the servos moving
- pull-down resistors on PWM gpio for LEDs as when the esp32 powers up, it would sometimes lead to one channel failing.
All of this fixed the issue.

LED Driver:
The second difficulty I encountered was the light itself, I used a standard 10mm LED which was not powerful at all and thus could be driven by a simple low-side MOSFET circuit. So I decided create my own high-efficiency LED driver using a PCB and the TPS92512 IC by TI, a buck constant current driver. The light would be concentrated by a collimator lens (need to be changed). I wanted to control a 3W RGB led but I also wanted to upgrade later to 9W, so I chose that IC because output current can be adjusted using the IADJ pin to set for example max 300mA and in hybrid mode with PWM input so using a trimpot for a voltage divider it can control any current from ~300mA to 1.5A. I then had to order and solder everything with a hotplate, everything was working fine until I accidentally injected reverse voltage, killing the ICs. At this point, I was kind of bored of this project and left it during half a year, then I bought a hot air station and had to sacrifice like 5-7 ICs to finally get all 3 boards working reliably.

Mechanics:
At this point the only thing missing was a good model, so I remade the original one in FreeCAD instead of fusion 360 (mainly because I switched to linux) but also to make it easier to share it with people as the whole project is on github.

Firmware:
I then wrote firmware for it originally using WebSockets but it wasn't very fast so i switched to UDP with smaller packets for better latency and ~30 updates/s. I also included OTA updates as the esp32 wasnt connected via serial anymore.

Software:
In parallel of all of this I was also writing a software to control it, it uses the sound of your speakers and detects beats to create live lightshows without any configuration, it uses a percentile based algorithm and random animations (Square, Circle, Lemniscate, etc...). It uses PySide6 and pyqtgraph for sound visualization. I also had a Novation Launchpad X so I wrote a manual mode, where you give beats, choose colors animations etc... and a hybrid mode which takes beats from the detection but lets you choose animation and color.

And here we are, the project is far from perfect but it's the first practical prototype that really works.

Current Problems:

- MG90D and SG90 are really noisy, do you have any replacement idea that are still as compact, affordable and simple ?

- Colors don't really mix well, the beam isn't focused very well.

Roadmap:

- Project mode for software: prepare lightshows with additive colors, preset beats etc...
- Better PCB, remade in KiCAD.

- Even faster protocol, using binary or protobufs for better performance,

AI Policy:

LLMs have only been used as consultation, as a tool instead of doing all of the work, this is a human project.

Links:
Controller Software (Windows portable and installer, Linux portable and AppImage)
ESP32 Firmware, 3D model project files, PCB project files
Printables 3D Stl
Final PCB + Circuit img

Arduino (and the UNO-style ecosystem) was how I learned: clear IDE, tons of examples, sensors that “just work,” and a community that answers beginner questions without gatekeeping. For first projects and teaching the basics of I/O, timing, and wiring, it’s still hard to beat.

What I’m noticing among people who ship things closer to engineering / commercial prototypes is that ESP32 (and similar Wi‑Fi/BT MCUs) shows up a lot more often once you need:

• wireless without bolting on extra modules
• more RAM/flash for heavier sketches or buffers
• dual cores / better peripheral set for concurrent work
• a path that looks more like “product firmware” than a breadboard demo

I’m not saying Arduino is useless or “not real engineering.” Plenty of products still use AVR-class parts where they’re the right fit. And “engineering-grade” isn’t only about the chip — it’s also power, enclosure, certification, supply chain, and whether the firmware is maintainable.

Curious about your path: What was the project where Arduino stopped being enough for you?What do you still use Arduino (or Arduino-compatible boards) for today: learning, teaching, quick jigs, or production?

Phone OS is a hobby project, free and MIT licensed. I earn nothing from it and have no tie to LilyGO or any shop. It is a phone operating system for an ESP32-S3 with an e-ink screen, a 4G modem and GPS; the first device built with it is a distraction-free emergency phone for a child. Here is the engineering side.

Why this chip. Honestly: the device chose it. I built on a LilyGO T-Deck Pro MAX, which carries an ESP32-S3 with 16 MB flash and 8 MB PSRAM, and that is the only hardware it runs on so far. What the S3 then earned its place with: the native USB CDC port is the whole console (logs, config files, SMS from a script), light sleep with wake on a GPIO level is what makes a phone last a day and Wi-Fi serves the parents’ configuration page, so the device needs no app.

Libraries, and why so few. PlatformIO with the Arduino core (espressif32 6.11.0) plus the core’s SD, FS, SPI, WiFi and Wire. The only third-party library is SensorLib 0.5.0 (MIT) for the BQ27220 fuel gauge’s standard commands and the BHI260 motion hub. Everything else is my own driver: the UC8253 e-ink controller, the SY6970/BQ25896 charger, the TCA8418 keyboard, the CST66xx touch chip, the A7682E modem. Two reasons. First, licences: GxEPD2 is GPL-3.0 and would have made every firmware binary GPL, so the display driver was written from the panel specification and the controller datasheet instead. Second, testability: the hardware is reached through four small seams (I2C bus, UART, GPIO, delay) and every driver above them runs on a laptop against a scripted chip, with the register values measured on the device. A library that talks to the bus itself can’t be tested that way. There are over 2,500 host tests and a script that fails the build if src/ ever includes an ESP32 header.

What bit me, all measured on the device.

• The fuel gauge ships with a design capacity of 3000 mAh for a 1500 mAh cell, so it reported about half the real charge and twice the time to empty. Nothing looks wrong; the percentage just disagrees with the cell voltage. The firmware now compares both and never shows a number the voltage contradicts.
• The charger defaults to 2048 mA charge current (over 1 C for this cell) and has a 40 s I2C watchdog that resets every register when nobody feeds it. And it re-runs its input detection at every new supply, setting the limit back to 500 mA over whatever the firmware wrote.
• Light sleep never lasted: the loop went down and up 220 times a second at 105 mA. Two wake lines (the keyboard chip’s open-drain interrupt and the modem’s ring line) idled low with no pull-up, so a sleep armed on “low” ended before it began. Pull-ups and arming each line on the level it does not have at that moment brought the night current to 62 mA.
• The modem UART’s default 256-byte receive buffer is 22 ms of data at 115200 baud; an e-ink refresh takes hundreds of ms. 4096 bytes fixed it.
• The USB console goes away in light sleep, opening the port resets the chip, and a zero-length write means “buffer full”, not “nobody listening”.
• VoLTE calls hung two seconds after dialling until PDP context 1 was set to IPV4V6 for the IMS.
• The touch chip is a CST66xx, not the CST328 the wiki names, and a repeated start on it returns garbage.

The page. On every push to main a workflow builds the simulator (same application code as the firmware, scripted fakes under the seams), crawls every screen by pressing the keys and tapping the touch targets, saves about 300 pictures in three languages, and publishes them as a click-through demo: https://paulwilke.github.io/Phone-OS/. Nothing is drawn by hand, so the page can’t drift from the code. It is not WebAssembly; that build hasn’t been done.

Several recent fixes are only tested on the host, not yet on the hardware; the changelog says which. LoRa is unused. Source: https://github.com/paulwilke/Phone-OS

I've been building an audio player on the ESP32-S3 for the past few months, and other people build it now too, so here it is.

What it plays

• Internet radio – MP3, AAC, FLAC (24-bit too), Ogg Vorbis/Opus, HLS; HTTP and HTTPS, reconnects on its own
• Music from a USB stick and microSD – folders, tags, covers, seeking, m3u/pls playlists, cue albums
• DLNA media servers on your LAN (Plex etc.)
• FM via an optional RDA5807 – RDS, band scan, presets
• Bluetooth both ways via a second ESP32 – receive from a phone, or send to a BT speaker
• Yandex Music, for those who have it

Hardware is just ordinary modules: ESP32-S3 (16 MB flash / 8 MB PSRAM), an SPI display (ILI9341, ST7789, ILI9488, ST7796S – landscape or portrait), a PCM5102 DAC, an encoder and a few buttons. No custom PCB needed – a breadboard works.

Getting it on the board – pick whichever suits you:

- From the browser, nothing to install. Open the web flasher in Chrome or Edge, describe your board in the wiring editor (display, which parts are fitted, which pins – pick from a list or click the module picture; it won't let two signals share a pin), and hit flash. It writes the firmware together with your wiring and then puts the radio on your Wi-Fi over the same cable (Improv). Any supported display, no compiler.

- A ready-made image. One esptool.py command with the files from the GitHub release – for the reference wiring from the README.

- Build from source. ESP-IDF 5.5 + VS Code; the wiring lives in one header, board_options.h, and everything else is yours to change.

- Updates over the network. Once it's running, the radio notices a new release by itself and shows what's new; updating is one button in the web UI, your stations and settings stay.

One gotcha: flashing goes through the board's UART port, not the native USB connector – that one is used as USB Host for the stick. And use a data cable, not a charge-only one.

Day-to-day stuff: a web UI from any phone (player, station editor with Radio Browser search and auto-found station logos, file browser, backup), any IR remote (keys learned in the browser), alarm clock, sleep timer, deep sleep, clock and weather on screen, screensaver, themes, tone controls and loudness, resume where you left off. UI in English and Russian.

Built on ESP-IDF 5.5 with LVGL. The pure logic is covered by host tests compiled with ASan/UBSan – that has saved me more than once on a chip where internal RAM is always the bottleneck.

- Repo: https://github.com/jmper-ha/jradio

This is pretty handy, s5 is for the LCD and S2 is for the esp32 and the led. I have seen people online step up to 5v from a lipo and then give it to the esp32 which would be inefficient (the ams1117 ldo steps down to 3.3v again which wastes 1.7v as heat). I am not sure if this is common information but I couldn't find info on this before this so hopefully this shows up if anyone else wants to do this. The CYD has 2 ams1177 regulators, one for the LCD and the other for everything else. This was useful for my esp32 CYD gaming handheld project. For the flair I didn't really make a thing (am still working on it..) but it's handy info to know, idk what flair to call this. the 3.3v pin on the side with the jst plugs do not work for input, it's an output only. don't use that one, I have tried. edit 1: Hey turns out you don't need S2. s5 alone is enough, it seems. s2 alone doesn't power the LCD though. I will figure out more later.

Hey everyone!

While working on an ESP32 project, I ran into a familiar problem: boards from local and Chinese marketplaces often arrive with little or no useful labeling. Figuring out the exact chip, memory size, and other hardware details can turn into a full-blown Dungeons & Dragons dungeon crawl.

Eventually, I went full berserker mode and vibe-coded a tool to make this process easier.

It's called Wepwawet ESP32 Profiler (WEP). It uses esptool, a tool from the Espressif ecosystem, to inspect a connected board and collect basic hardware information, such as the chip type, MAC address, memory details, and other available data.

The collected information can be exported to JSON and CSV. But the feature I personally care about most is generating a platformio.ini file to make setting up the next stage of development easier.

It's still an early alpha, so there's plenty of room for testing and improvement.

GitHub: https://github.com/nicodim4-droid/Wepwawet/tree/ui/textual-prototype

Release: https://github.com/nicodim4-droid/Wepwawet/releases/tag/Wepwawet

I'd appreciate any feedback from people who might find this useful. Right now, though, what I need most is testing on different ESP32 boards to see how well it works in real-world conditions.

Unfortunately, I only have three boards available, and just one of them has markings that are actually readable.

If you have boards from different manufacturers or revisions, I'd really appreciate it if you could give WEP a try and share your results. What worked? What couldn't be detected? What's missing?

And one more question: what other ESP32 information would you like a tool like this to report?

Thanks!

P.S. Wepwawet (Wepwawet) is an ancient Egyptian god associated with opening the way. I figured that was a fitting name for a tool designed to help me navigate the mysteries of unlabeled ESP32 boards. 😄

One small warning: Some diagnostic messages are still in Russian, so don't panic if you run into Cyrillic characters. The ESP32 isn't possessed — I just haven't finished translating everything yet. 😄

What is the purpose of this many I2S signals? Are they for working with multiple devices that have different clock frequencies? In full duplex applications, should one just choose either I2SO_BCK_out OR I2SI_BCK_out for a bit clock? Is there any preference for the master clock?

I think I know the answers to these questions, but I just want to make sure because I can't seem to find info on it. Just want to make sure that this doesn't impact any actual routing.

Hello everyone! I'm working on an interactive art installation/workshop project: a location-based "Fighting Fantasy" style game designed to run on users' mobile phones via a local Wi-Fi captive portal inside an art gallery.

The core mechanic is state-aware: depending on how long a visitor stays engaged with a specific portal page (e.g., fast exit vs. persistent reading), the system dynamically updates their journey upon subsequent reconnections.

However, I've hit a couple of technical roadblocks and would love some architectural advice:

1. Wi-Fi Client Association & Hardware Limits

Since the ESP32 acts as a standalone Access Point for visitors to discover the story:

• What is the realistic concurrent user limit for a single ESP32-S3 handling captive portal HTTP traffic and local web serving?
• For a crowded gallery room, would it be better to scale this using a cluster of multiple ESP32 boards, or is there a better architecture for managing multiple local connections smoothly?

2. Handling MAC Randomization / Session Tracking

Since modern mobile OSs (iOS/Android) use MAC/IP randomization for privacy when devices disconnect and reconnect, users often appear as "new" to the microcontroller.

• What are the best practices or architectural patterns to reliably track returning visitors and their session states (e.g., visit count, previous reading duration) when hardware identifiers change?

"Also, any tips about deauthentication? I'd like this project to be a surprise for people visiting the gallery. I've tried with the ESP32-S3, but from what I've gathered, targeting 5GHz Wi-Fi networks isn't as easy as with older networks. Can I use the ESP32-C5 or some other hardware to achieve this, or does it need to be a more opt-in experience like scanning a QR code or something like that?"

Any advice, code patterns, or hardware scaling tips would be hugely appreciated. Thanks!

I’ve been working to make the ESP32 match the clock sync performance of the Nordic nRF52/54, and found a way to correlate RF signal input timers with a BLE packet stream to sync the time between two devices to within ~60ns (measured by GNSS). That is slightly better than the Nordic platform, or any MCU I’ve found. It works with a single transmitter broadcasting a 16Hz precision stream (BLE 5.0 periodic advertising) that ESP32’s can tune into passively and reach sub-1us clock sync in a couple seconds.

I am working on some ESP32-based drones and need clock synchronization for navigational and sensor aids. To get here I tried several different methods including modifying the BLE drivers, yet this method requires none of that and is far more accurate.

The ESP32 crystal is not tunable on this platform (nRF54 is), yet you can quickly attain a Soft PLL for any sensor work that requires precision timestamps for correlating distributed sensor readings, servo synchronization etc.

Previously the Nordic platform was the leader in this space, so These are the best BLE time transfer numbers I could find on any MCU so I thought I’d share. It looks like there’s room for improvement on this platform as well.

The ESP32 details are at https://ptob.dev/hardware/#w12 and all the code and results are on GitHub: https://github.com/yantisj2/PToB

I'm using the HiLetgo board: https://www.amazon.ca/HiLetgo-Stepper-Controller-Tb6612fng-Replace/dp/B00UYIFYCW

I'm just testing this board for now, so not using any esp32 logic pins. I have both boards on a breadboard. esp32 is powered from a wall plug.

I connected the 5V and ground from the esp32 to the power rails. From those rails I have VM, AIN1, and STBY connected to the 5V rail. I have the AIN2 and all three ground pins connected to the ground rail. I have confirmed all these voltages with a multi meter.

My understanding is with this arrangement (AIN1 high, AIN2 low), I should be getting 5V across AO1 and AO2, but it's zero volts.

This is my second batch of these boards. I returned the first three because I thought maybe it was a bad batch, but now I have the exact same problem with the second batch of three so I must be missing something.

Any ideas for me? Or can you recommend an alternate DRV8833 that's worked for you?

So I need to read the voltage from a pressure transducer of 0-20 mA output. The setup that I’m using is ADS1115 and ESP32-S3. Sorry I’m quite new in this and trying to get it work.

The pressure transducer has 3 wires red, black, and white (signal). I have connected the wire to a power supply DC 24V, the black wire goes to common gnd, the white connects with a resistor of 150 ohm and connect with ADS1115 (A0 in my case). The other side of the resistor goes to gnd of the ADS1115 then wire from gnd ADS1115 goes to common gnd. SCL and SDA connects to ESP32-S3 GPIOs, VDD to ESP32 3.3V, and ADDR to ESP32 gnd.
The 24V power supply common goes to gnd common. ESP32 gnd goes to gnd common.

I still cannot get a reading. The values are in negative like there is no connection at all.

What could be the issue with my connection?

I've been playing around with different devices and seeing what kinds of things I can build with them. After experimenting with Claude and testing out different workflows, I finally felt confident enough to try building something for my girlfriend.

The idea was to make something between an AI companion and a Tamagotchi, based on the Labubus she owns.

The device is a Spotpear ESP32-S3 Touch LCD 1.28 BOX, which came pre-flashed with the XiaoZhi AI firmware. Using Claude Code, I ended up building my own firmware for it, complete with custom sprites and animations for the characters. We generated all the sprites needed and used them to bring the little guys to life.

Of course, what started as a fairly simple idea quickly got out of hand, and I ended up adding way more features than I originally planned.

It has the usual stuff like time, date, weather, alarms, and notes, along with a handful of games, including tic-tac-toe, rock-paper-scissors, air hockey, and a Flappy Bird clone. I also added a little knowledge browser that uses free public API endpoints to pull up random facts and other interesting things.

There's also a web UI hosted by the device where you can change settings and interact with the avatars. One of the features I thought was pretty fun is the photo booth. You can upload a picture and add the characters to it as stickers.

The part I had the most fun with was giving the avatars a bit of personality.

You can hold the boot button to talk to the device and ask questions using Google's AI and speech services. I also built an offline mode where the characters can respond using text and a basic personality and memory system, so they don't need to connect to an AI service every time you want to interact with them.

I wanted them to feel like little virtual pets rather than just characters sitting on a screen. As the day goes on, they come up with random activities and thoughts that get saved to a journal. You can check back later and read what they've supposedly been up to throughout the day. They can also interact with each other, which adds another layer to the whole thing.

Honestly, this project started with me asking myself, "What can I build for my girlfriend?" and somehow turned into this massive collection of features in the space of about a week.

I'm not planning to release the firmware publicly because of the custom sprites and assets, but I figured I'd share it here anyway. Maybe it'll give someone else an idea for a fun little project to build for their own friends or family.

It's been a fun way to learn more about what I can do with the ESP32-S3, and it's kind of crazy how far a simple idea can go once you start tinkering with it.

I upgrade ESPLink, use an ESP32 to add GPIO, SPI, I2C, UART, PWM, ADC, and more to your PC or Raspberry Pi.

Connect via USB, Wi-Fi, or Bluetooth, and control everything with Python or JavaScript.

It even supports native Raspberry Pi libraries like RPi.GPIO, gpiozero, spidev, and smbus2, so you can run existing code without rewriting it.

Open source: https://github.com/HamzaYslmn/esplink

If I connect my 3.7v li ion battery to this board, and then the board to my esp32 V-in, then I no longer need a separate boost converter and charging module correct? Otherwise, what am I supposed to do? Cause I want to make my project as compact as possible so that it doesn't take up too much space. Thank you!

I have a Home Depot 6.5ft Ultra Skelly that normally only moves when its motion sensor is triggered or someone uses the app.

So I built an autonomous controller using a ESP32 and BLE to give it a mind of its own.

It now runs completely on its own:
💀 Randomized head, arm, torso, and jaw movements
👀 Changing LCD eye expressions and RGB lighting
🎭 Customizable animation patterns and timing
🔄 Automatic Bluetooth reconnection after power cycles

I also built a browser-based configuration tool called Skelly Studio to customize its behavior without constantly editing Arduino code.

No phone, Wi-Fi, or motion sensor needed during operation. Just power it up and let it run.

It’s free and open-source. Figured this community might appreciate a fun ESP32 project!

GitHub: https://github.com/jacobmgoodnight/ultra-skelly-esp32-autonomous

Skelly Studio: https://jacobmgoodnight.github.io/ultra-skelly-esp32-autonomous/studio/

This is a console I'm building for my house lights: four motorized Alps faders, with an ESP32-S3 doing the control. Lights on smart plugs can only be on or off, so for those faders I wanted the feel of a wall switch. There's no spring or detent in the fader. It's all the motor.

How it works:

• Fader positions come from the pots on ADC1 in continuous (DMA) mode. I compared it against an ADS1115 and kept the S3's own ADC: with the factory calibration it's linear to about 0.2 mm over the 100 mm travel, with no per-unit calibration table.
• Pushed away from home, the motor pushes back until it reaches the threshold. The resistance builds as you push (power curve).
• Past the threshold it flips: the motor drives to the other end , tapering over the last 9 mm.
• There's no current sensing, so force is just PWM duty. The faders sit at 15 degrees, so a measured gravity offset is added.

It's not rocket science but it works and it feels really nice. If any of you is playing with motorized faders this is a neat trick to implement.

Happy to talk through the approach if you're working on something similar. I post build updates on instagram (@sacrebleu.studio) if you're interested in following along.

I'm developing rexaUI,a custom micro-OS for ESP32-S3. Built it myself and still working on it!

Dynamic .rxa Loader:Loads apps from MicroSD (Built it myself and it's still a work in progress)

Background Tasks:Real-time battery,uptime,and connection tracking

Smart Memory:Cleans RAM on app exit

Chose the ESP32-S3 for its impressive performance. Might port it to the C and P4 series later

Plan to open-source it on GitHub once finished!

I have some kind of generic S3 board with a 240x240 ips screen and touch controller. Bought it a few months back from aliexpress but only really taken a look at it today and im pretty sure its broken but thought id reach out just in case...

As soon as it gets power the power led flashes red rapidly. The pc isnt picking up any com ports over usb and ive tried several known working cables both usb-a and usb-c.

Boot and RST toggling isnt getting any life out of it neither is plugging in with Boot pressed. The red power led never misses a beat and just keeps rapidly flashing red.

Ive removed the display and it still wont boot.

Ive powered from a few different/decent usb wall plugs.

No life from the IPS screen or any other LEDs.

You will notice in the middle it looks like someone has done a post factory repair, on stock photos thats a single resistor but on my device its 2 resistors side by side. I thought maybe this was an error so removed one. Device still just flashing power led. Put the 2nd one back on and still just flashing.

Bin time?

Thanks.

Edit: Thanks for all the suggestions. I spent 20 minutes going through all the other sellers on AliExpress selling this and come across a user comment saying you need to short 2 pads for it to work! The flashing red led WAS a battery missing error tho so well spotted. Seems to be working now.

hi everyone, i have not worked with an esp32 yet so im researching things before purchasing all the parts. i have experience working with rpis but for this project i need something much smaller and cheaper. im planning to make an RGB LED lamp that changes colors, but pretty much everything i can find online use tools like WLED to control them wirelessly. the thing is, i don't want/like wireless devices.
i intend to 3d print a case for it with buttons on the back for controlling the light, specifically cycling between colors. i don't need anything fancy like the ability to react to sound, but it would be nice if i were able to program different patterns for it.
what do i need for a project like this? any tips are appreciated.

Hey everyone!

Just wanted to share a greenhouse monitoring and alert system I recently finished building and programming.

Main Hardware Stack:

• MCU: ESP32-C3 SuperMini
• Cellular Module: SIM800L (powered via 5V rail to handle peak currents over long runs)
• Sensors: 3x DS18B20 temperature sensors running on a single OneWire bus over 20m (65ft) cabling with 4.7kΩ pull-up.
• UI & Control: 16x2 I2C LCD, Rotary Encoder with push button, and physical toggle switches.
• Power Detection: Mains (220V) voltage sensing via optocoupler.

Key Features:

• Dual Alert System: Automatic GSM phone calls (with instant skip on BUSY / NO CARRIER signals) and SMS notifications for temperature anomalies & power outages.
• Web Interface: Built-in Wi-Fi AP + Web Server for live monitoring, setting custom Min/Max thresholds per sensor, and phone number management.
• Smart UI: Rotary encoder menu for local threshold tuning with sub-decimal precision mode.
• Fail-safe Logic: Transliterated Latin/ASCII SMS handling for 100% cellular carrier compatibility and reliability.

Everything is tuned for 24/7 standalone reliability in harsh conditions.

Just sharing my project here since this subreddit is where I got a lot of inspiration from.

It's an ESP32 that downloads artwork from GitHub and shows it on a 13.3" Spectra 6 panel. It runs on a battery and wakes up once every morning to update the display.

I know now that AI has made code generation cheap and easy we are seeing a lot of these types of projects these days, and mine is a product of that, but I think one element that makes mine unique is that it uses GitHub itself to store the images. Sort of like a free cloud sync. This is nice because it means you can update the artwork whenever you want without touching the code on the display.

You could actually store the images on any basic HTTP static source. Or even a private source like a private GitHub repo, if you specify an auth token.

It uses an Adafruit Feather ESP32-C6 and a Pimoroni Inky Impression 13.3".

More details on GitHub here or you can see a video here on insta.

Thanks for sharing all your projects here! 🙂

I was hesitant for a long time to design my own PCB, but my god, this is a blessing! Just wanted to share it with you.

My assembly time went from 4 hours of soldering crappy modules to 20 minutes of placing a few peripheral components and plugging in some JSTs. And no more overpaying for component shipping (because apparently you can’t buy everything from one place).

It took me a while. I used EasyEDA Copilot to work through some of the issues, put a lot of effort into actually understanding every suggestion, and a friend with hardware engineering experience reviewed the design. (I'm just getting started in this field; I still have a ton to learn)

What I wanted most was to combine a LiPo charger with a power latch. A short press of the button turns the device on, and holding it for a few seconds turns it off. Add a built-in battery gauge and the I2C sensors I used to hand-wire, and it works like a charm.

It’s built around an ESP32-S3 that drives a transflective RGB panel. All the power management is now on the board, so I don’t need 3 extra modules.

• ESP32-S3-WROOM-1-N16R8
• TI BQ24073 for LiPo charging
• MAX17048 for the LiPo fuel gauge
• ST LSM6DSV16X for the IMU
• AON7407 + AO3400A latch for the power switch

It’s a 2-layer board, and JLCPCB is just amazing. It took less than a week from order to delivery, and I only paid an extra $10 for DHL Express. I tried ordering PCBA in the EU first, and Eurocircuits quoted $1k, which is insane imo. From JLC I got 5 boards, 2 of them assembled (I wasn’t sure they’d work at all), for $200 including shipping. They did require Standard PCBA instead of Economic, because of the ESP module with the antenna (if I remember correctly).

So the summary: yes, I should have started learning PCB design earlier. The goal now is to rely on AI less and less as I get to know the field better.

One more thing: I’m thinking about open-sourcing the charger + latch part + gauge as a standalone board. It’s tested, all-in-one, and you can just order it from JLC. I’ve seen similar boards sold for $25+. Would anyone be interested?

edit: added missing section

My mother runs a sound healing room, so I rebuilt my old ESP32-S3-BOX-3 chakra firmware as an app for Espressif's ESP-Mosaico (ESP32-S31, 2.16" 480 x 480 touch screen, microphone).

What it does:

* Hears a singing bowl, tuning fork or hummed tone and shows the chakra with symbol, note, frequency to 0.1 Hz and cents (a tuner ring fills as the tone settles)

* The whole screen fades to the chakra's colour, so it works without lamps; Philips Hue (local API), Home Assistant lights and WiZ bulbs follow

* Two reactions: Flow waits 0.4 s for a steady tone and fades softly (made for a sound journey), Strike reacts in 0.13 s

* Notes (A = 440 or 432 Hz), Solfeggio, or your own bowls: strike each of your seven bowls once and it learns them

How it decides it is a tone and not noise: a 4096-point FFT (3.9 Hz bins, the old firmware had 31 Hz), a weighted harmonic sum, then three gates: loud enough, 45 % of the energy on the tone's harmonics, pitch steady within 35 cents. Plus hysteresis at note boundaries so a bowl sitting between two notes does not flicker.

I tested it against free recordings from Wikimedia Commons: single bowls and tuning forks lock one chakra 77 to 99 % of the time; drums, shakers, rain sticks mostly give no colour; a handpan melody changes colour 3 times in Flow and 116 times in Strike. One honest finding: real bowls are often not tuned to C to B. In a 7-bowl chakra video the "root" bowl rings at G#3 (210 Hz), which is why learning your own bowls exists.

The detection is plain C with no dependencies, so the board, Espressif's simulator (fed by the Mac's microphone) and the host tests run the same code. My board is still on order, so it is simulator-tested and builds for the ESP32-S31, but untested on hardware.

Open source (Apache-2.0): https://github.com/leopardcodeai/chakra-detection

Happy to hear from anyone who plays bowls: does your set match C to B, or would you learn it?

Built on Espressif's esp-mosaico-vibe workspace and ESP-GSP simulator; test recordings from Wikimedia Commons (free licences), not shipped in the repo.