r/esp32 • • Mar 18 '25 Bravo

Please read before posting, especially if you are on a mobile device or using an app.

252 Upvotes

Welcome to /r/esp32, a technical electronic and software engineering subreddit covering the design and use of Espressif ESP32 chips, modules, and the hardware and software ecosystems immediately surrounding them.

Please ensure your post is about ESP32 development and not just a retail product that happens to be using an ESP32, like a light bulb. Similarly, if your question is about some project you found on an internet web site, you will find more concentrated expertise in that product's support channels.

Your questions should be specific, as this group is used by actual volunteer humans. Posting a fragment of a failed AI chat query or vague questions about some code you read about is not productive and will be removed. You're trying to capture the attention of developers; don't make them fish for the question.

If you read a response that is helpful, please upvote it to help surface that answer for the next poster.

We are serious about requiring a question to be self-contained with links, correctly formatted source code or error messages, schematics, and so on.

Show and tell posts should emphasize the tell. Don't just post a link to some project you found. If you've built something, take a paragraph to boast about the details, how ESP32 is involved, link to source code and schematics of the project, etc.

Please search this group and the web before asking for help. Our volunteers don't enjoy copy-pasting personalized search results for you.

Some mobile browsers and apps don't show the sidebar, so here are our posting rules; please read before posting:

https://www.reddit.com/mod/esp32/rules

Take a moment to refresh yourself regularly with the community rules in case they have changed.

Once you have done that, submit your acknowledgement by clicking the "Read The Rules" option in the main menu of the subreddit or the menu of any comment or post in the sub.

https://www.reddit.com/r/ReadTheRulesApp/comments/1ie7fmv/tutorial_read_this_if_your_post_was_removed/


r/esp32 • • 19h ago Bravo Heartwarming

I made a thing! Testing the LD2450 radar outdoors for human movement tracking.

818 Upvotes

I was curious to see how the LD2450 radar performs with an ESP32, so I decided to build a prototype.

I designed and 3D-printed a custom enclosure for this project. The plastic wall in front of the radar antennas is just 1 mm thick.

The actual detection range was approximately 6–7 meters.

The radar performed quite well, tracking up to 3 targets simultaneously.

For reliable operation, it's best to power the radar with a stable 5V supply with minimal voltage ripple. Unstable power can significantly affect detection accuracy.

If you'd like to try it yourself, here's the project link!


r/esp32 • • 3h ago

Advertisement esp32sim 0.4.0: open-source ESP32 emulator now runs the ESP32-P4 and the new ESP32-S31 (ESP-Mosaico), also in the browser

18 Upvotes

esp32sim is an open-source emulator for Espressif chips. It boots unmodified ESP-IDF firmware images through the chips' own mask ROMs, with boards around them: displays, touch, sensors, audio, WiFi. It runs on the command line (macOS and Linux) or in a browser tab.

What's new in 0.4.0:

  • ESP32-P4: both RISC-V cores, SD card, USB-OTG, and WiFi through an emulated ESP32-C6 co-processor running the unmodified ESP-Hosted firmware. Board: Waveshare ESP32-P4 LCD-3.5.
  • ESP32-S31 on Espressif's ESP-Mosaico: the round 480x480 AMOLED, touch, IMU and magnetometers, audio, the vibration motor and WiFi. The board's factory firmware runs to its home screen.
  • esptool flashes the S3, C3, C6 and P4 through the ROM's download mode, as on a real board.
  • WiFi: several virtual access points, pcap capture, and a live network panel on the web page.
  • Speed: RISC-V code runs about 3x faster.
  • More classic ESP32 boards: the Cheap Yellow Display, the Ulanzi TC001 pixel clock and the ESP32-CAM.

Try the Mosaico compass demo (and the others) in your browser, nothing to install: https://mikroverk.github.io/esp32sim/

Release notes and downloads: https://github.com/mikroverk/esp32sim/releases/tag/v0.4.0 Source: https://github.com/mikroverk/esp32sim

The P4 and S31 support is still marked draft. 80 pull requests went into this release, many from contributors. Bug reports and firmware that doesn't run are very welcome as issues.


r/esp32 • • 2h ago

I made a thing! I moved the ESP32-S3 module onto my climate controller PCB. Here's what works so far.

Thumbnail
gallery
14 Upvotes

A while back I posted my ESP32 climate controller here. Several of you asked why I was still plugging a dev board into a custom PCB. The new GROVA Core boards are on my bench now, with the ESP32-S3 module soldered directly onto the board.

Why the ESP32-S3-WROOM-1-N16R8. The S3 gives me Wi-Fi for the local interface, native USB for flashing, and enough usable GPIO for the sensor bus, fan channels, and control outputs. The N16R8 module gives me 16 MB of flash and 8 MB of PSRAM for room to grow.

Working on the bench. Automated Wi-Fi setup works, and an SHT4x on channel 3 of the TCA9548A reports temperature and humidity in the local web UI. (tested all channels with that sensor) I picked the mux so sensors with the same I²C address can sit on different channels. So far I've tested one SHT4x on this revision.

Library choices. The local pages and HTTP API fit Arduino-ESP32’s built-in WebServer. An async server would add another dependency for those routes. ArduinoJson gives the API and configuration backups one way to parse and write JSON. I use Arduino Wire with a small TCA9548A wrapper so each transaction stays on its selected channel. The Founder firmware reads the SHT4x directly and checks the CRC on the returned data.

What the board is designed for. It has eight I²C ports, two PWM fan headers, two 12 V outputs, one 5 V output, and two 0–10 V control signals for compatible external drivers. In the browser I can assign devices from the board map and choose manual control, a schedule, or a sensor rule. One example I want to test is increasing fan speed when humidity rises above a set point. Physical output and load tests are still pending.

Hardware lessons. Toggling a MOSFET output made the first PCB buzz and reset. I traced that to reversed flyback diodes and reworked them. That experience is one reason I’m checking the new outputs on the bench before connecting loads. I ran into trouble with a 1.5-inch OLED that the manufacturer listed as I²C-compatible. I couldn’t get the display working over I²C on this board.

What I'm working toward. I'm planning plug-in sensor modules with an ID and calibration data stored in an EEPROM on each module. I'd like to add CO₂ and light sensing alongside temperature and humidity. The PCB already has 1-Wire and RS485 connections. I’ll test them in a later bring-up phase. Support for the on-device display and knob is also planned.

If you've built a small greenhouse or terrarium controller, which sensor or control rule ended up being most useful in practice?

Open-source firmware and build notes


r/esp32 • • 19h ago

I made a thing! I built a Pokémon virtual pet for my daughter that grows when she plays real chess games (ESP32-S3 round AMOLED, open source)

234 Upvotes

My daughter plays chess, so I turned a Waveshare ESP32-S3-Touch-AMOLED-1.75 into a small virtual pet that lives on her real games. Every night the board reads her public games from the chess.com Published-Data API: a finished rapid or daily game is 1 point, a win is 10. Points buy berries, eggs and little adventures for her Pokémon.

What it does:

- No battles: Pokémon compete in 11 sports events and in gyms played as 3-on-3 team sports, scored from their species stats, type and training
- All 1025 species in 9 regions that unlock in order; sprites from PMD SpriteCollab on the SD card
- A second board for her best friend: two boards pair over ESP-NOW (4-digit code check), play side by side, and send postcards and gifts through an encrypted mailbox when apart
- A parent's iPhone shortcut can give points for chores or reading (small HTTP endpoint on the board)
- English and Simplified Chinese, web installer (Chrome/Edge), website with a player's guide

Why this chip: the ESP32-S3 on this board has 8 MB of octal PSRAM and 16 MB of flash. The whole 466x466 screen is drawn into a ~430 KB RGB565 canvas in PSRAM and flushed to the CO5300 panel over QSPI, and Wi-Fi plus ESP-NOW are built in. The Waveshare board also puts the round AMOLED, touch, AXP2101 battery charging, RTC, IMU and SD slot on one PCB, so another parent can build one without soldering.

Libraries: I kept the original project's stack (Arduino core 3.3, Arduino_GFX, and Lewis He's SensorLib and XPowersLib, which cover every chip on the board) instead of moving to ESP-IDF or LVGL, so fixes can still go back upstream. On top of that: ArduinoJson for the chess.com and weather responses, arduinoWebSockets for the XiaoZhi MCP link, U8g2 font data for Chinese, and ESP Web Tools for the browser installer.

Hurdles:

- TLS out of memory: with chess sync, weather, mail and the XiaoZhi WebSocket all running, mbedTLS handshakes failed for lack of internal RAM. Pointing mbedTLS's calloc/free at PSRAM (mbedtls_platform_set_calloc_free) fixed it.
- Battery: the screen kept waking itself on battery. An I2C read error (-1) from the AXP2101 IRQ register was being treated as a PWR-key press. Now the screen turns off after 5 idle minutes on battery and only a real PWR press wakes it; light sleep only runs with the radio off, and steps keep counting in the QMI8658 FIFO while the CPU sleeps.
- Save data: when the points book gained a category, the loader detects the old NVS blob by its size and converts it instead of wiping a kid's progress.

It's a fork of socquique/TamaPoke, which did the hard part (display, case, the original game). I tested every build on the two real boards, and 372 host-side unit tests run in CI.

Website and guide: https://mu-muu.github.io/TamaPoke/
Source: https://github.com/Mu-Muu/TamaPoke

English isn't my first language, so I used AI to help with the wording and grammar of this post. Happy to answer questions about the hardware or the code.


r/esp32 • • 1d ago

I made a thing! ESP32-S3 that presses every button on an Xbox controller: 15 PhotoMOS relays, 3 SPI digipots, 60 Hz over UDP

Post image
49 Upvotes

I wanted a whole livestream to share one physical Xbox controller for the GTA 6 launch, so I built a rig where an ESP32-S3 does everything a pair of hands would: 15 buttons, two sticks and two triggers.

WHY THE ESP32-S3-DEVKITC-1 (N8R8)

Pin count. I wanted one GPIO per button relay with no expander, plus SPI with three chip selects. On the S3 that still works after you avoid the strapping pins (GPIO0, 3, 45, 46), native USB (19, 20), the UART (43, 44) and GPIO33 to 37. I also had two ESP32-C6 boards, but they would have needed an expander like MCP23017 for the buttons.

LIBRARIES

Arduino-ESP32 2.x with PlatformIO (espressif32 6.13.0), and only uses: WiFi, WiFiUDP, ArduinoOTA, SPI and the task watchdog.

No digipot library. The MCP4261 takes 16-bit commands, so the driver is a few lines of SPI.transfer16 at 1 MHz. Writing it myself gave me read-back checks (a missing chip reads all zeros or all ones) and access to the EEPROM wiper, which I wrote to always start in the controllers neutral position.

UDP, not WebSocket or MQTT. The server sends the full controller state as one 16-byte datagram at 60 Hz. A lost frame is replaced 16 ms later. Retransmits would only add delay. If no frame arrives for 250 ms, a watchdog releases every button and centres every axis.

ArduinoOTA, because why not? Wi-Fi updates are just a great invention and with PlatformIO it's also very easy

HARDWARE PROBLEMS

  1. I assumed the stick rail was 3.3 V and never measured it. It was the controller's 1.8 V stick rail. The MCP4261 needs at least 2.7 V, so nothing worked at first power-up. The fix was to tap the real 3.3 V rail for the chips' supply and leave the pot ends on 1.8 V, since that is the range the controller's ADC expects. Measure the pad before you rely on it.
  2. The triggers have no potentiometer, only a magnet and a hall sensor, and the controller reportedly powers that sensor for about 1.5 ms out of every 8 ms. I removed the sensors and feed the output pad from a digipot wiper through 2 kOhm.
  3. The controller is and the ESP32 powered by the console. There is 1 kOhm in series with every SPI line, and the firmware stops SPI and drives the lines low when the controller's rail is down.
  4. Buttons are AQY212EH PhotoMOS relays across the contacts, so there is no shared ground or polarity to get wrong. Each GPIO has a 10 kOhm pull-down so nothing is pressed while the ESP32 is in reset or being flashed.

It is built by hand on perfboard, which I would not recommend.

Build video with the failures: https://youtu.be/ZZRu91Y7XxU

Viewers control it from a website or with Twitch chat commands. It goes live Wednesday 18 November at 19:00 CET. What would you have done differently?


r/esp32 • • 12h ago

Hardware help needed Help with robotic arm

3 Upvotes

So I am just starting out with ESP32 projects. I have done a bunch of projects already but this one requires me to use some stronger servos. I'm using 2 x MG996R for the base and the shoulder and then 2 x SG90 for the claw and elbow. I keep on spiraling down into a hole and seeing others use lab bench power supplies, some use regular power bricks plugged into a wall or some use batteries. I'm lowkey confused on what to use. If someone can help that would be nice:)


r/esp32 • • 1d ago

I made a thing! PAC-MAN ON ESP32🕹️

147 Upvotes

DIY ESP32 Arcade Emulator

This Arcade Emulator can run the these games:

Galaga, Pac-Man, Donkey Kong, Frogger, Digdug and 1942

Hardware setup:

💻 ESP32 WROOM

🖥️ 2.8" ILI9341 SPI TFT (240×320)

🔊 MAX98357A I2S Digital Audio Amp

🕹️ 7x Tactile Buttons

I just changed code

to use "MAX98357A I2S" instead of "PAM8302A"

and disabled LED support in the configuration.

GitHub: harbaum/galagino


r/esp32 • • 1d ago

Hardware help needed Need help with hardware as a beginner.

9 Upvotes

Hi,

I am totally new to hardware stuff. I know basic coding (can write code in python, did some gamedev in pico8-lua and unity-c#, even learnt basic iOS dev). I want to make a cute desk device /desk buddy where in i can build chatbot, virtual pet, timers and basic games - this kind of stuff.

Where should i start? The device must have a small display, microphone, battery, button/touch for interaction. So, instead of soldering components to a board, Im thinking of getting something readymade that has all these basic components in a casing, so that I can focus on development. Saw this: https://robu.in/product/waveshare-esp32-s3-154inch-240x240-262k-color-lcd-display-development-board-with-touch-control-no-battery/

Is this right approach? or should i start with separate components to understand things fundamentally?

Please guide.


r/esp32 • • 1d ago

I made a thing! [Firmware] GeekMagic SmallTV-PRO Custom Firmware v3.12.0: Korean Font Engine, Multi-Line Card Mode, Timers & Screen Wiper

Thumbnail
gallery
39 Upvotes

Custom firmware for the **GeekMagic SmallTV-PRO** (ESP32, 8MB Flash, 240×240 ST7789 IPS LCD).

- **GitHub Repository**: https://github.com/twoarchi/smalltv-pro-mod

- **Release v3.12.0**: https://github.com/twoarchi/smalltv-pro-mod/releases/tag/v3.12.0

---

### Features in v3.12.0

#### 1. Korean Font Support & Multi-Line Card Mode

- **Korean Bitmap Font**: Embedded KS X 1001 2,350 syllables + ASCII + symbols based on GalmuriMono.

- **22px Render Size**: 11px base glyphs scaled 2× integer (22×22px Korean, 12×22px Latin) with 1px letter spacing and 12px line gap. Fits 10 Korean characters per line on the 240×240 panel.

- **Multi-Line Card Mode (`wrap: true`)**: Formats incoming text as a card (header, horizontal divider line, and 5~6 lines of wrapped text) instead of 1-line marquee scrolling. Supports `\n` linebreaks and literal `\n` strings from JSON payloads. Useful for forwarding SMS notifications from Android Tasker or Home Assistant.

- **Marquee Fix**: Replaced per-pixel background erasing with a 1ms single-burst SPI fill to prevent character smearing and bus lockups during 1-line scrolling.

#### 2. App Scheduler (Timer Mode)

- Configure up to 4 time slots (HH:MM) to display specific apps (Stock 1, Stock 2, Weather) based on time of day.

- Alternatively, select Carousel mode to rotate apps on an interval timer.

#### 3. IPS LCD Screen Wiper (Image Retention Prevention)

- Periodic or scheduled full-screen pixel cycling routine to mitigate IPS liquid crystal static charge buildup.

- 7 patterns available: digital rain, SMPTE color bars, starfield, pure black, pure white, static noise, and animated sprite.

- Tapping the top capacitive touch button immediately cancels the wiper and returns to the active dashboard.

#### 4. Dual Stock Candlestick Charts

- **Stock 1 (KRX / Naver Finance)**: 08:00~09:00 pre-market handling with daily candle fallback; transitions to real-time intraday minute candles at 09:00.

- **Stock 2 (US / Yahoo Finance)**: Shows full closed sessions during daytime, and adds a vertical session divider line `[yesterday close] | [today pre-market]` starting at 18:00 KST pre-market open.

#### 5. HTTP Notification API (`POST /api/notify`)

- **Card Mode Payload (SMS / Multi-line)**:

```json

{

"type": "sms",

"title": "SMS [Sender]",

"label": "First line\nSecond line of message",

"ttl": 20,

"wrap": true

}

```

- **Classic Animated Icon Mode**:

Omitting `"wrap"` displays hand-tuned 80×80 animations scaled 2× (160×160px) with single-line scrolling (`phone`, `mailbox`, `sms`, `telegram`, etc.).

---

### Installation (Web OTA)

  1. Download `firmware_v3.12.0_public_release.bin` from the GitHub release page.
  2. In the device WebUI, navigate to **System** → **Update**.
  3. Upload the `.bin` file. Existing Wi-Fi credentials and ticker settings are preserved across the reboot.

r/esp32 • • 1d ago

AI Content SMP NoMMU Linux

13 Upvotes

I have been fiddling for quite something with Paulneja's fork bank linux build (Github) for the ESP32S3. Its pretty good on its own, but it was single core linux and the other core runs ESP-IDF with WiFI and flash functions. So with a lot of AI efforts and references from Apache Nuttx for ESP32S3 I was able to get SMP Linux working on ESP32S3 with fork bank along with WiFi. Will be putting up a release link soon once I am done with all the testing. I have also got USB Host working. GDMA is in progress but still remains pending for peripherals. Here's a small snippet:

root@arduino:# uname -a
Linux arduino 7.2.4-forkbank #1 SMP Sat Sep 5 00:00:00 UTC 2026 xtensa GNU/Linux
root@arduino:# lscpu
Architecture:        xtensa
  Byte Order:        Little Endian
CPU(s):                2
  On-line CPU(s) list:  0,1
Vendor ID:             Tensilica
  Model name:          -
    Model:             Xtensa LX7.0.12
    Thread(s) per core: 1
    Core(s) per socket: 1
    Socket(s):         2
    BogoMIPS:          480.00
    Flags:             nmi debug ocd trax perf density boolean loop nsa minmax 
                       sext clamps mac16 mul16 mul32 mul32h fpu s32c1i
root@arduino:# free
             total        used        free      shared  buff/cache   available
Mem:          7768        4776        2016           0         976        1928
root@arduino:# ifconfig
espsta0   Link encap:Ethernet  HWaddr 34:85:18:7B:81:B8  
          inet addr:192.168.1.54  Bcast:192.168.1.255  Mask:255.255.255.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:499 errors:0 dropped:63 overruns:0 frame:0
          TX packets:132 errors:0 dropped:2 overruns:0 carrier:0
          collisions:0 txqueuelen:1000  
          RX bytes:50350 (49.1 KiB)  TX bytes:7369 (7.1 KiB)

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000  
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

root@arduino:# ping google.com 
PING google.com (142.251.221.206): 56 data bytes
64 bytes from 142.251.221.206: seq=0 ttl=114 time=67.180 ms
64 bytes from 142.251.221.206: seq=1 ttl=114 time=196.730 ms
64 bytes from 142.251.221.206: seq=2 ttl=114 time=60.430 ms
64 bytes from 142.251.221.206: seq=3 ttl=114 time=63.869 ms
64 bytes from 142.251.221.206: seq=4 ttl=114 time=68.288 ms
^C
--- google.com ping statistics ---
5 packets transmitted, 5 packets received, 0% packet loss
round-trip min/avg/max = 60.430/91.299/196.730 ms
root@arduino:# cat /proc/cpuinfo 
CPU count       : 2
CPU list        : 0-1
vendor_id       : Tensilica
model           : Xtensa LX7.0.12
core ID         : LX7_ESP32_S3_MP
build ID        : 0x90f1f
config ID       : c2f0fffe:23090f1f
byte order      : little
cpu MHz         : 240.00
bogomips        : 480.00
flags           : nmi debug ocd trax perf density boolean loop nsa minmax sext clamps mac16 mul16 mul32 mul32h fpu s32c1i 
physical aregs  : 64
misc regs       : 4
ibreak          : 2
dbreak          : 2
perf counters   : 2
num ints        : 32
ext ints        : 26
int levels      : 6
timers          : 3
debug level     : 6
icache line size: 4
icache ways     : 1
icache size     : 0
icache flags    : 
dcache line size: 16
dcache ways     : 1
dcache size     : 0
dcache flags    : 
load/store exceptions   : 6202204
load/store clock count  : 854516361
root@arduino:# espctl system info
kernel:    Linux 7.2.4-forkbank
machine:   xtensa
board:     Arduino Nano ESP32
vendor:    Arduino
soc:       Espressif ESP32-S3
uptime:    685 s
mem total: 7768 KB
mem free:  2044 KB
gpio:      /dev/gpiochip2 (esp32s3-gpio, 49 lines)
pins:      30 names (built-in)
cpu freq:  240.00 MHz
temp:      30.4 C
root@arduino:#

r/esp32 • • 2d ago

I made a thing! Made an ESP32-controlled mock telescope for an AI-powered autonomous telescope project

Thumbnail
gallery
51 Upvotes

This project was actually made for a hackathon hosted by my college. I was solely responsible for the hardware component of the project, my teammates handled the software aspect.

The ultimate goal of this project is to automate telescope pointing and calibration so that a user can simply ask an AI agent to point towards a particular celestial object, and the system handles the movement.

Since we don't currently have access to an actual telescope, I decided to build a mock telescope mount to demonstrate and test the hardware-software integration.

The project consists of three main components:

  1. AI Agent: The user tells the agent which celestial object they want to observe.
  2. MCP connection: The agent communicates with the hardware through an MCP connection, allowing it to issue movement commands.
  3. Hardware: An ESP32 controls the pan and tilt servos, physically moving the mock telescope towards the requested direction

The telescope's field of view is simulated using Stellarium, allowing me to demonstrate the intended pointing behaviour without needing an actual optical telescope.

Essentially, I want the entire process to work from a natural-language instruction to the physical movement of the telescope, with the corresponding view simulated in Stellarium.

Hardware

The current prototype consists of:

- ESP32 DevKit as the main microcontroller.

- Two MG90S servo motors for horizontal (pan) and vertical (tilt) movement.

- 3.7 V, 1800 mAh LiPo battery.

- TP4056 charging module.

- MT3608 boost converter to provide a 5 V supply for the servos.

A custom-built pan-tilt mechanism representing the telescope mount.

Why I chose the ESP32

I chose the ESP32 because it's affordable, has sufficient GPIO pins for servo control, and fits in the form factor i need for the model.

Libraries used and why I chose them

- Arduino.h: Provides the core Arduino functionality, including serial communication, GPIO control and timing. I chose the Arduino framework over ESP-IDF because it's simpler for rapid hardware prototyping.

- ArduinoJson: Handles incoming JSON commands and generates JSON responses. I chose it over manual string parsing for easier and more reliable command handling.

- ESP32Servo: Controls the two servo motors using PWM signals. It simplifies servo configuration and angle control without requiring me to implement PWM generation manually.

I also implemented software-based movement smoothing using low-pass filtering, a deadband and rate limiting to prevent abrupt movements and reduce unnecessary servo corrections.

The AI agent communicates with the ESP32 through the external software layer using MCP, while the ESP32 receives and processes JSON commands over serial.

Challenges so far

Since this was my first ever hardware project, i had to figure out/learn a lot of new things like soldering, and how to actually program the ESP32.

Some of the challenges I've encountered include:

- initially i used SG90 servos, and powered them directly via the vin pin on the ESP32. which obviously didn't work, and i had to figure out why.

- i also had to learn 3D design software in order to design and 3D print the telescope

- finding the correct connector for the battery i used. To be specific i needed a JST 2-pin connector, but could not find one in time so had to DIY a solution using two dupont jumper wires.

- adjusting the MT3608 booster to output 5v, since i do not have a multimeter i had to use another ESP32 and a voltage divider (47kOhm and 10kOhm) circuit to measure the output of the booster.

I'd particularly appreciate suggestions regarding:

Whether MG90S servos are suitable for a lightweight telescope mount.

Better mechanical designs for accurate pan and tilt movement.

How I could improve pointing precision and reduce mechanical backlash.

Recommendations for a more reliable power supply.

Any ideas for eventually transitioning from this mock setup to an actual telescope.

Thank you for reading.


r/esp32 • • 2d ago

I made a thing! Porch skeleton that holds a conversation: ReSpeaker Lite + ESP32-S3-CAM, radar-triggered, servo jaw synced to the voice

Post image
19 Upvotes

I built a talking Halloween skeleton for my porch and set it out on Halloween. This was my very first significant ESP32 project, first time I had ever soldered anything, and took me around a month to do. (I'm sure you could do it better, let me know if you do! 😄 ) First time poster trying to follow the sub's rules, so sorry if this post is too long or missing anything.

Demo (first outdoor test, no costume): https://youtu.be/BNor4MIeyNo
Code, firmware, wiring, and enclosure: https://github.com/cwinget/ai-talking-skeleton

When someone walks up, it greets them, snaps a few photos to figure out their costume, and holds a short live voice conversation in a pitch-shifted spooky voice. The jaw and LED eyes move with the audio. Family-friendly persona early in the evening, creepier after 8:30. I ended up skipping the family-friendly persona because it was too cheesy and kept the creepy persona the whole time.

The Gemini Live API worked way better than expected, and conversations felt natural.

Hardware

  • ReSpeaker Lite (XIAO ESP32-S3): audio board. Streams the XMOS noise-suppressed mic up and plays audio down. The microphones worked incredibly well, especially for a noisy outdoor event like Halloween.
  • ESP32-S3-CAM (N16R8, OV3660): body board. LD2410C radar, camera, servo jaw, transistor-switched LED eyes. The little camera was a fun experiment, but ended up being a little too low-quality to detect costumes. I would probably switch to an externally mounted camera if I do this next year.
  • Both are thin WebSocket clients to a Python server I self-host. The server does a lot of the logic heavy lifting. (Gemini Live for the conversation, a vision model for the costume, custom low-latency pitch shift + reverb).
  • 3D-printed box (OpenSCAD) holding both boards, the radar on a slide-in rail behind the lid, and panel connectors.

Technical hurdles:

I had never soldered anything before this project, and I found out I completely suck at crimping JST-XH connectors. I probably broke like a hundred little cables and had to re-solder things multiple times.

I somehow burned out two radar sensors. I'm not really sure what I did, but I'm sure I shorted it out. I learned how to use a multimeter, which was incredibly useful for finding shorts or badly crimped cables.

I built a small web UI with a bunch of settings to change, and configured the ESPs to receive them via the wss. This way I didn't have to re-flash firmware every time I tweaked an audio level, servo position, or LED power level. Once I screwed the box closed and attached it to the skeleton body I really didn't want to open it up anymore, so I hacked around some of my problems using the server.

I had a lot of problems in the beginning with the timing for the mic and speakers when I was testing on my Mac, but the Re-speaker handled a lot of this out of the box. I got complete garbage audio at first, but figured out that i2s_std mode fixed it.

Lots more hurdles that I can't remember!

Disclosure: I wrote a lot of the code with heavy AI assistance (Claude), then debugged it on real hardware. I have a computer programming background, but I'm a complete novice with microcontrollers. The problems above were all very much hands-on. The conversation runs on Google’s Gemini API, so it’s cloud-based and costs money. The server is self-hosted.

Halloween is over, so now it's time to pivot to fun Christmas projects! 🎄


r/esp32 • • 2d ago

I made a thing! I published my first video guide covering ESP32 firmware Flash Encryption, complete with scripts to automate the process for your own projects

Thumbnail
youtu.be
18 Upvotes

https://github.com/UsableLoki8221/GUIDE---ESP32_Flash_Encryption

Regarding that things can now be easily reverse-engineered directly from dumped binary files I figure its really helpful to make this guide for others.

It was initially pretty tricky for me to get everything working correctly. Most sources would point that it can only be done from ESP-IDF when your project is built off espressif's framework. I spent a few weeks trying to convert my project to espressif from arduino without any luck. I found that it's irrelevant, it can be done wherever :)

The SPI_BOOT_CRYPT_CNT fuse (and FLASH_CRYPT_CONFIG on original ESP32) needs to be set and a key gets burnt in with purpose XTS_AES. App0, bootloader, partition, and firmware binaries need to be encrypted for upload.

The app0 binary is pulled directly from espressif's package files, the other binaries (bootloader, partition, firmware) get made when your project is built. To encrypt use a key with regard to their partition placement using espsecure tool and then they can all be uploaded to your chip. So by following this scheme it can be done on any environment.

One big issue I had was that platformio's espsecure tool was not encrypting the binaries correctly (constantly getting 'invalid header' error message). I eventually tried running the espsecure tool directly from my esp-idf install folder where it can also be found and it actually worked correctly. This issue did not occur on a new computer when I made the demo for this guide so it probably got updated but it's good to point it out in case someone encounters the error.

I tried my best to write the scripts so that they can generally work on anyone's environment configurations.

I'd really appreciate feedback from anyone who gives the guide and scripts a try! I'd love to hear whether they worked correctly on your setup or if there were any adjustments you had to make to get it working correctly.


r/esp32 • • 1d ago

Hardware help needed Looking for an e-paper display for a DIY desk calendar (ESP32), EU shipping

6 Upvotes

I built a desk calendar on an ESP32-S3 (LaskaKit ESPink) with a 7.4" 800×480 Pervasive panel (full refresh only). For the next version I’d like:

  • partial/fast refresh (for a clock or a scrolling line), grayscale is a bonus
  • 6–8" size, good contrast/white background
  • or two ~4" panels side by side, both driven from one ESP32 (e.g. on a shared SPI bus with separate CS pins): one for the calendar, one for time and weather with fast refresh
  • driveable from an ESP32 (SPI panel with controller, or a parallel panel via EPDiy)
  • buyable in the EU or from AliExpress with EU delivery

r/esp32 • • 2d ago

I made a thing! I made an open-source Desk Buddy for ESP32-S3 touchscreen Desk buddy and PC monitor.

Thumbnail
gallery
357 Upvotes

Hey, so ClawPal is a little ESP32 that sits on my desk. Decided to make it a little cuter by adding a pixel crab to it that I drew. Basically it acts like a PC monitor - it shows stats, whatever media is playing plus controls, a volume mixer, weather, and shortcut buttons that run stuff on my PC. It works through a PC companion app that feeds the ESP32 all the info over Wi-Fi (in my case a Waveshare ESP32-S3-Touch-LCD-4.3B, 800x480).

Why this board? I actually wanted to use the ESP32-C6-Touch-AMOLED-2.16 at first, because I found a similar project that was using it, but realised its much for what I wanted to do, so 4.3 it is lol. But i decided to go with s3 since it can drive a big RGB screen directly, it has 8MB of PSRAM so two full framebuffers fit. WI-Fi's built in which is perfect for my case, and the native USB means my installer can find and flash the board on its own.

Sadly the version with the case was unavaliable in my local shop, so I had to 3D print it myself!

Libraries: ESP-IDF instead of Arduino, since i needed the RPG LCD driver, custom partitions and OTA updates with rollback, and that was all easier in IDF. LVGL 8.4 for the UI, since the demo came with 8.x and i didn't want to mess with 9. esp_lcd_touch for the touch chips.

At the start I had some issues where LVGL ate all the internal RAM at boot, so Wi-Fi had nothing left for TLS and the weather just broke. Moved all of LVGL into PSRAM with a custom allocator and it's fine now.

Code is open source(GPLv3): https://github.com/Kaayoos/clawpal
Waveshare ESP32-S3-Touch-LCD-4.3B, 800x480 3D model Case: https://makerworld.com/en/models/3546648-esp32-s3-pc-monitor-spotify-weather-desk-buddy#profileId-4057099

Would love some feedback! Thanks :)


r/esp32 • • 2d ago

I made a thing! I made a device to stop smoking

Post image
17 Upvotes

Hey, just wanted to share my non smoking tamagotchi device that helps me do breathing exercices and keeps track of the days since i've stopped smoking. It's my very first ESP32 projet so i'm using the devkit1, an IIC OLED display and an analog joystick, it is also completely vibecoded (oops) and uses the Adrafuit GFX library. One of the challenges was that there is only one 3.3V pin on the ESP32, but both the display and the joystick need 3.3V, so I've diyed a little Y Dupont Cable. Next step is learning how to solder I guess °-°, from one toxic smoke to an other. Any ideas of features i could add to ease in the non smoking life ?


r/esp32 • • 3d ago

I made a thing! I made a 7-inch touchscreen macro deck on an ESP32-P4 (LVGL 9.6, open source, board about $35-42)

Thumbnail
gallery
358 Upvotes

I made a Stream Deck style macro deck for Windows on the GUITION JC1060P470C, an ESP32-P4 board with a 7 inch 1024 x 600 touchscreen that costs about $35-42 on AliExpress. No soldering: the board, a USB-C cable and a Windows PC.

How it works

  • LVGL 9.6 on ESP-IDF 6.1, JD9165 over MIPI-DSI, GT911 touch.
  • Two 1024 x 240 draw buffers in PSRAM. A full redraw takes about 55 ms.
  • The panel draws, reports touches and keeps the last layout when the PC is off. A small Python host on Windows runs the actions and talks to it over USB with a line protocol.
  • Icons arrive run-length compressed with a CRC32 and are kept in an 8 MiB LRU cache in PSRAM.
  • Watchdog and update rollback, both tested on the panel.
  • The UI also builds on the PC, so a test can tap through it and render frames before I flash.

What it does

18 keys per page, Keys, Agents, Mixer and Status screens, a clock screen, widgets, live PC gauges and a browser editor on 127.0.0.1. The panel has no network.

The console (191 x 124 mm, about 180 g of PLA or PETG if printed solid) is designed to print without supports. STL and STEP are in the repo.

New in v1.1.0

An experimental build for two 7 inch ESP32-S3 boards (800 x 480): the Waveshare ESP32-S3-Touch-LCD-7 and the Sunton ESP32-8048S070 from the Cheap Yellow Display family. I don't own either, so it's untested on real hardware. If you have one, I'd love to hear how it goes.

Code (MIT): https://github.com/catorendal-a11y/tessera-deck

Website: https://catorendal-a11y.github.io/tessera-deck/

Feedback on the in-place UI updates and the icon cache is welcome, and so is help porting it to other displays.


r/esp32 • • 2d ago

I made a thing! ESP32 water heater controller (solar surplus + off-peak + forecast) with an ESP32-C3 as independent watchdog: design choices and what went wrong

Thumbnail
gallery
19 Upvotes

Why I built it

My 300 L / 3 kW water heater was heating at the wrong times: during peak hours, and not when my panels had surplus. I wanted a local, reliable controller with no cloud on the control side and no Home Assistant dependency. A Raspberry Pi + Home Assistant setup was my first idea, but I dropped it for cost reasons.

What it does

The ESP32 decides when to switch the heater using:

  • real-time solar surplus from an Ecojoko energy monitor
  • the French off-peak window (HC) vs. peak (HP) pricing
  • a forecast based on Open-Meteo weather data and past usage, to anticipate the next day’s heating need

It also keeps daily/monthly/yearly history of what I actually paid vs. what the same heating would have cost entirely at night.

Chip choices

  • Main board: classic dual-core ESP32. It has enough RAM and flash for repeated TLS connections to the cloud API, a web server, the forecast and the history store running together.
  • Watchdog: ESP32-C3 SuperMini. The main board can’t reliably watch itself. A second, independent chip listens to a heartbeat line (HB) and an error line (ERR) from the main board, and drives a buzzer if something goes wrong. I picked the C3 because it’s cheap and the job needs very little power. I first planned a supervisor on a single ESP32, then moved to a separate C3, because a supervisor that shares the failure modes of the main firmware isn’t a real watchdog.

Libraries

I’ll be honest: I mostly took the first libraries that were suggested to me and they worked, so I didn’t benchmark alternatives.

  • WebServer.h for the UI. I started with the synchronous server because it was the simplest way to get something running. It turned out to be my biggest limitation (see below).
  • LittleFS for the web UI, history and learned forecast data. Writes are throttled (at most every 10 min) to limit flash wear, and there’s a guard that purges old history first when space is low.
  • WiFiClientSecure + HTTPClient for the Ecojoko HTTPS API and the relay’s local HTTP/RPC calls. The Ecojoko endpoints are unofficial and come from the Little Monkey Home Assistant integration (jmcruvellier/little_monkey), so credit to them.
  • LEDC (PWM) on the C3 to drive a passive buzzer at its resonant frequencies (about 3.2 and 4.1 kHz), because a passive buzzer needs a tone, not a simple HIGH/LOW.
  • NTP for the time and the HC/HP schedule, instead of wiring the Linky meter.

Problems and edge cases

  • Cloud API timeout: I spent a while suspecting gzip decompression. The real cause was a 2.5 s timeout on an endpoint that needs up to 8 s.
  • Blocking calls freezing the web UI: with the synchronous server, an 8 s cloud call (or 3×2 s relay retries) stops handleClient(). Opening the UI from a PC and a tablet at once could block the loop for 91 s and trigger my stall detector. Mitigations so far: lazy loading of tabs, pausing when the page is hidden, backoff on network failures, and non-blocking relay calls. A move to ESPAsyncWebServer or a FreeRTOS web task is still on my list.
  • “Wi-Fi bug” that wasn’t firmware: repeated reconnections turned out to be RF/placement (RSSI around -55 dBm), not code.
  • Relay overheating alert: my first relay raised an overtemp alert during a night heating cycle. I replaced it with a 25 A module with a Shelly-compatible RPC API, logged the relay’s internal temperature, and added a thermal cutoff plus an SOS log.
  • Watchdog UX: an alarm at midnight that you can’t diagnose is awful. Now each alarm stores its reason and context in persistent memory, and the buzzer can be snoozed remotely from the UI or with the button.

Credits and transparency

I used AI coding assistants (Codex, Claude) for parts of the implementation. The architecture, wiring, hardware, testing and all design decisions are mine.

Repo (source, firmware and web UI): https://github.com/Timbambi/Smart-water-heater-thanks-to-ecojoko

Feedback welcome, especially on moving the web server off the main loop.


r/esp32 • • 2d ago

Board Review ESP32-P4 HMI: 336 mA down to 97 mA with peripheral shutdown and Light-sleep

9 Upvotes

I've been experimenting with power consumption on a 7-inch CrowPanel Advanced ESP32-P4 HMI. The idea was to see how practical battery operation could be, ideally with the panel waking up on touch.

My first multimeter reading was around 600 mA at 60% backlight brightness. A 1000 mAh battery wouldn't last two hours at that rate.

I started with CPU frequencies, sleep modes and peripheral shutdown. Eventually I ended up looking at the board's power circuitry too.

For the main measurements, I used a Nordic PPK2 in Source Meter mode at 4.0 V, connected in place of the battery. All numbers below are for the entire board, not just the ESP32-P4.

1. Light-sleep and peripheral shutdown

With the UI running, a small animation on screen and the backlight at 20%, the board drew 335.9 mA.

I stopped the DSI display pipeline, turned off the backlight and controllable peripherals (including the ESP32-C6 and audio amplifiers), held the LCD controller in reset, and put the ESP32-P4 into Light-sleep.

Current dropped to 96.7 mA (-71.2%).

That's the combined result of all those steps, not Light-sleep alone.

2. Deep-sleep

This one was unexpected: 139.3 mA in Deep-sleep, compared with 96.7 mA in Light-sleep with similar peripheral preparation.

The ESP32-P4 revision 1.3 has limitations on GPIO state retention in Deep-sleep, so some external circuits can end up powered again.

There's another issue with wake-up. The GT911 touch interrupt is connected to GPIO42, which can't directly wake the chip from Deep-sleep.

3. CPU frequency

With the display disabled, reducing CPU frequency from 360 to 40 MHz lowered current under synthetic load from 149.6 to 120.1 mA (19.7%).

With the actual UI running, though, I only saved 2-4 mA.

And the display started showing corrupted frames. The DSI driver reported underruns because framebuffer data wasn't being fetched from PSRAM fast enough.

So I dropped the 40 MHz idea for this application.

4. Tracking down the remaining current

I tested peripheral shutdown step by step: the touch controller, ESP32-C6, LCD controller, and finally putting the ESP32-P4 into Light-sleep.

But the board was still drawing around 97 mA. I started checking the power circuits.

With the LCD and touch FPC cables physically disconnected, the board drew 78.5 mA in Light-sleep.

After disabling the LCD bias converter (U16, MT3608), that dropped to 9.1 mA.

A difference of 69.4 mA. That's the contribution of the disabled power circuit as a whole, not the MT3608's own quiescent current.

5. Further hardware changes

I isolated additional power rails, added pull-down resistors to regulator enable pins, and removed a few components that allowed unwanted power paths to remain active.

Eventually I measured 6.5 mA in Light-sleep.

That was a single 30-second measurement on a heavily modified board with peripheral cables disconnected. It wasn't a usable touch-to-wake configuration.

What surprised me most was the LCD bias circuit. Even with the LCD and touch cables disconnected, that power circuit accounted for almost 70 mA.

To get much lower standby current while keeping touch wake-up, the LCD and touch controller need separate power control. On this board, they share the LCD_VDD rail.

Full article with measurements and hardware details:

https://medium.com/@nikkicat/firmware-can-only-take-you-so-far-esp32-p4-power-experiments-d29e7e3f69de

Has anyone run into something similar with ESP32-P4 HMI boards? I'm curious how others handle display power shutdown while keeping touch wake-up working.


r/esp32 • • 2d ago

Hardware help needed Battery ESP32-S3-Touch-LCD-1.85B-EN

4 Upvotes

Hello, I bought an ESP32-S3-Touch-LCD-1.85B-EN board and they don't provide the battery for some reason.
I'm trying to figure out which battery is compatible with this item.
is DC 3.7v 500mah 502535 with jst 1.25 correct?
Can I mount a battery with more mah?

Thanks a lot


r/esp32 • • 3d ago

I made a thing! Showing off my esp32 project

Thumbnail
gallery
845 Upvotes

Well, since my previous post was removed for violating the rules I'm posting it again with more information:

This is my esp32/8266 based home assistant gateway, from electronic conmection, reverse engineering, programming, all the way to case design:

Source code at https://github.com/HclX/wyzesenserelay, case design at https://makerworld.com/models/3615364.

The work started by reverse engineering a deprecated home automation sensor system, and trying to increase its range and improve battery life. ESP8266 and ESP32 boards are chosen simply because I have quite some in my drawer and they are capable of all the handling. This entire project is more about fun and challenge, not for cost saving purpose. While AI is heavily involved for reverse engineering and programming part, idea and content are genuinely my own, and hardware soldering, case design and printing was done by myself manually.

A couple things I think it can benefit people here:

  1. If anyone happen to used wyzesense ecosystem, they can now use this project for already deprecated sensors.
  2. If anyone is designing their own cases, they can take my design directly, or refer to its idea for making a compact case
  3. I'm also like to share ideas and thoughts.

I hope this proves my post is serious not simply spam to others.


r/esp32 • • 3d ago

I made a thing! I built an ESP32 self-balancing robot using NEMA 17 stepper motors

131 Upvotes

I've been working on this self-balancing robot for a while. I previously shared a video of it here, and now I've finally decided to share the project and source code.

The hardware is an ESP32, 2 × NEMA 17 stepper motors, 2 × DRV8825 drivers, and an MPU6050, running at 16× microstepping.

For the balancing algorithm, I'm using the MPU6050 for angle estimation and a PID control approach. Step pulses are generated using hardware timer interrupts, with direct GPIO register access to keep things efficient, and found it to be realy helpful while tunning. I also added wireless control and a web interface for adjusting the PID parameters and angle offset.

I learned a lot from studying the YARB and B-ROBOT EVO2 self-balancing robot projects, and benefited from their work when building my own robot.

I've tested it with two different robot body sizes, and I'm pretty happy with how it's working so far.

Here's the source code:
https://github.com/xamechanics/xabalancing

I also have a longer YouTube video showing the robot, its assembly, and a walkthrough of the code. Check it out!

I'd be happy to hear your feedback or suggestions.


r/esp32 • • 1d ago

Software help needed burning text

1 Upvotes

i am using a esp32 p4 and a ST7701S Display... I am probably very new to this, but am aware about SoftWare for over 15 years..

i was hoping to show burning text animation, like ghost rider burning effect, but for text and individual letters..

is it possible somehow?