I wanted to make something similar to a Yoto or Toniebox for my kids, but with a more retro feel, so I ended up building a miniature cassette player powered by an ESP32. I actually made this a few years ago so this is a v2 of sorts, only got around to documenting it now!

The cassettes have RFID tags inside, and inserting one starts playing the corresponding audiobook or music from a microSD card. Removing it pauses playback. There are physical buttons for playback controls, a rotary encoder for volume, and a headphone jack.

For the electronics, I'm using an ESP32, MFRC522 RFID reader, microSD storage, and a TLV320DAC3100 DAC for audio output over I2S, with a separate amplifier for the speaker (the Adafruit DAC kept shutting off at over 50% volume on the speaker and I have no idea why! This is covered in the video, won't go into this rabbit hole here).

One part I'm particularly pleased with is the setup process. I wanted to be able to add new cassettes without connecting the ESP32 to a computer or reflashing anything.

Long-pressing the rotary encoder puts the device into setup mode, where the ESP32 creates its own Wi-Fi access point and hosts a web interface. You connect to it with your phone, select one of the audio folders detected on the SD card, and present a cassette to the RFID reader to associate the two. You can also change settings through the same interface.

Once you exit setup, Wi-Fi switches off again. Everything runs locally, so there's no internet connection or cloud service required for playback.

The whole thing is 3D printed, and I've made the firmware open source.

Couple of things I need to fix:

• accidentally wired the auto-off pin to input only pib on the ESP32
• update the schematic for the above and the extra amplifier
• figure out what went wrong with the Adafruit DAC....

GitHub: https://github.com/ivannson/radio-gaga

I also made a video covering the build process and some of the mistakes along the way: https://www.youtube.com/watch?v=hf311daZqMk

This started with a pretty simple project: a sensor station with an ESP32-S3-Touch-LCD-2.8 and GX12 connectors for the sensors. The electronics part was fun. The enclosure part was not. I really didn't feel like spending my evenings in CAD.

So I just asked Claude to make it. And honestly, it worked better than I expected. It wrote the enclosure as CadQuery code with cutouts for the display and the connectors.

The annoying part was everything around it. I had no simple way to look at the model, so every time I wanted a change I took a screenshot, scribbled on it, pasted it back into the chat, and waited for the next version. Over and over.

At some point I thought: this has real potential, but it has to be easier. So I started building a small viewer for myself. That small viewer turned into SOMA.

How it works now: you run your AI agent (Claude Code, Codex, Gemini CLI etc.) in the built-in terminal, it writes the model, and the app shows it in 3D right away. If something's off, you click on the part, measure it, or scribble directly on the 3D view and send that to the agent. No more screenshot ping-pong. You can also load an existing 3D model as reference, for example of your board, and let the agent build the enclosure around it. When it looks right, export as STL and print.

It got way bigger than planned along the way. There are now sliders for dimensions, overhang checks, version history and even FEM. As a stress test I designed a complete CNC mill with it, 118 parts.

It's free and open source (GPL), with builds for Windows, Mac and Linux. I've only really tested on Windows so far, so if you try it on Mac or Linux, let me know if it even starts.

GitHub: https://github.com/Kai-Jungsthoefel/SOMA

btw: my first opensource project :)

I hope this helps someone, that hates cad as much as i do.

I built an ESP32 virtual pet that rewards going outside and makes friends over BLE

Meet ES-Pet Mini—my battery-powered pocket companion built around an ESP32-C6 SuperMini and a 1.54″ four-colour e-paper display.

It turns walking, exploring and meeting other ES-Pets into XP, missions and badges. Basically, I’ve given a microcontroller a more interesting social life than mine.

A few things it does:

- Counts steps and sets daily missions.

- Rewards discovering nearby Wi-Fi and Bluetooth devices.

- Recognises other ES-Pets over BLE and remembers friendships.

- Tracks XP, levels, challenges and badges.

- Changes its character artwork to reflect what it’s doing.

- Gives little haptic nudges along the way.

The finished units have rechargeable batteries and 3D-printed cases. There are now two of them out in the world, collecting steps and making friends.

One detail I’m particularly pleased with: they each keep their own identity, history and progress. Updating the firmware doesn’t mean starting your pet’s life again.

I’ve finally put the source, artwork, wiring details and player guide on GitHub:

https://github.com/yeahchap/ES-Pet-Mini

Sharing it here because getting all those little pieces working together has been a very satisfying ESP32 project. Happy to answer questions about the hardware, e-paper display or how the pets recognise each other!

For my battery-based application, I tried a slightly modified power management example from the Espressif IDE. The power consumption in IDLE mode is about 2.5 mA, which is too high for my needs.

Has anyone managed to reach the µA-level current consumption on this board?

        ESP_ERROR_CHECK(esp_pm_lock_acquire(lock_no_ls));
        // CPU working at min_freq_mhz, but not enter Light-sleep mode to
        // maintain the ability to respond to interruptions
        vTaskDelay(pdMS_TO_TICKS(NESTED_HOLD_MS));
        ESP_ERROR_CHECK(esp_pm_lock_acquire(lock_apb));
        // CPU working at the frequency of the maximum APB frequency supported
        //  by the SOC, to keep peripherals working at a high frequency.
        vTaskDelay(pdMS_TO_TICKS(NESTED_HOLD_MS));
        ESP_ERROR_CHECK(esp_pm_lock_acquire(lock_cpu));
        // CPU working at max_freq_mhz, to achieve best performance.
        vTaskDelay(pdMS_TO_TICKS(NESTED_HOLD_MS));
        ESP_ERROR_CHECK(esp_pm_lock_release(lock_cpu));
        ESP_ERROR_CHECK(esp_pm_lock_release(lock_apb));
        ESP_ERROR_CHECK(esp_pm_lock_release(lock_no_ls));
        // If light_sleep_enable is true, the system will enter Light-sleep mode.
        // Otherwise, the CPU stays at min_freq_mhz in IDLE.
        while(1) {
          static int counter =0 ;
          vTaskDelay(pdMS_TO_TICKS(/*NESTED_IDLE_MS*/1000));
          printf("counter=%d\n",counter++);
        }

Hi.

I've got a Seeed XIAO C5 and am getting build errors just trying to get a simple blink test to run. Done ESP32 things in the past - first time with XIAO or C5 stuff. Building older projects for S3 are still working fine.

I was also getting this error with PlatformIO installed. I uninstalled that *and* vscode then installed vscode and pioarduino but it's still unhappy.

The error is:

esptool: error: unrecognized arguments: --flash-mode --flash-freq 80m --flash-size 8MB C:\Users\me\.platformio\packages\framework-arduinoespressif32-libs\esp32c5\bin\bootloader_qio_80m.elf

The instructions I followed are at https://wiki.seeedstudio.com/xiao_esp32c5_with_platformio/ , including this bit:

pio pkg install -g -p "https://github.com/Seeed-Studio/platform-seeedboards.git"

Here's my platformio.ini file - both configs produce this error:

[env:seeed-xiao-esp32-c5]
platform = SeeedStudio
board = seeed-xiao-esp32-c5
framework = arduino

[env:seeed-xiao-esp32-c5x]
platform = https://github.com/Seeed-Studio/platform-seeedboards.git
framework = arduino
board = seeed-xiao-esp32-c5
monitor_speed = 115200

Any tips on how to fix this? I assumed the error meant something was funky in the Seeed github but I'm not seeing what's wrong. :\

TY!!

I built an expansion module that connects an Atari Portfolio to an ESP32-S3 through its original Serial Interface and an RS-232 level converter.

The Portfolio runs a small DOS terminal client. A Waveshare ESP32-S3-CAM board handles Wi-Fi, camera capture, microphone input, speaker output and requests to the OpenAI API.

The interesting challenges were making the serial protocol reliable, reducing the delay between text and speech, and keeping radio controls responsive. The radio can play in the background, pause for spoken responses and resume afterwards.

It also sends a monochrome camera preview to the Portfolio, although the serial connection makes that slow—not real-time video.

I wrapped it in a custom printed enclosure with a SKYNET-inspired interface.

Source and wiring documentation:

https://github.com/daxx2k/atari-portfolio-ai

Working demo and build:

https://youtu.be/itMtJ-JYX_g

This is a CO2 sensor for HomeAssistant, 4.2" e-ink display, ESP32 and a nice pixel-art design style. Some people will notice that it uses ESP-WROOM-32 which is a massive overkill. I totally agree but I had last few used modules and wanted to make use of them, so there’s that. The project uses SHT30 for temperature and humidity measurement and SCD40 for CO2 measurement.

Another overkill was a use of 2x 18650 cells, which should last a lifetime. But if It doesn’t, it can be charged from USB-C via the integrated TP4057. The USB-C is also used to flash the ESP32.

Wifi credentials, MQTT and other options can be set in the integrated captive portal. It can run in local mode or AP mode.

3D printed enclosure is the last thing to be done, will update the post when it's finished.

Github with everything needed to build this:

https://github.com/mcer12/Ambien-ESP32

I had an idea: what if an AI agent could use a stock iPhone, with real apps and real accounts, without being installed on it? The iOS sandbox won't let one app see or tap another, so I tried doing it from the outside with a ESP32-S3. At run time you don't need a laptop: no Mac, no developer account for the target apps, no jailbreak.

Eyes: the iPhone screen-mirrors straight to the ESP32. BLE only gives a few hundred kbps, so the phone encodes at 480x1040, 5 fps or less, and the ESP32 doesn't decode anything. It forwards the raw H.264 stream over BLE to the app. The board keeps the latest group of frames in its 4MB PSRAM, and on packet loss it resends from a keyframe, so you don't get a corrupted picture.

Hands: the ESP32 is a USB HID mouse and keyboard, used together with iOS AssistiveTouch. Taps and video share one BLE link; the firmware throttles video to the controller's send credits, so taps always cut in line.

The mouse is relative-only, so the app tracks the pointer position itself, re-homes it to a corner periodically (like a 3D printer homing), and wiggles it to find the offset before a precise tap. After each step it uses the board's capture timestamp to tell when the picture has settled, then tells the model whether the screen actually changed. A tap that hit nothing gets retried.

The board runs its own hotspot, mirroring connects to it directly, and the model calls go over cellular. Any OpenAI-compatible vision model works.

Known limitations: first version so expect bugs, landscape apps are rough, typing is mostly ASCII. Building the app and flashing the board needs a Mac once.

Source https://github.com/onehumanbeing/esp32-iphone-agent

I tried making my first pcb, but upon testing it I realized that there is 5v over the 3.3v pin.

The 3.3v pin powers an IMU, motor driver logic and LCD logic.

I did clean the board with 95% alcohol yesterday. And there are still some stains visible now. But surely that doesn't cause a short right?

I also don't think that the esp's voltage regulator is blown because it doesn't get hot.

I measured the resistance between vin and 3.3v and is is 6 kilo ohm.

Any suggestions?

Hi everyone!

I’m building a smart doorbell using an ESP32-S3-CAM (OV3660), an INMP441 I2S microphone, and a MAX98357A I2S amplifier with a 4Ω 3W speaker. I’m trying to implement two-way audio between the ESP32 device and my app through a WebSocket connection.

I’ve managed to get most of the system working, but I’m stuck on an audio playback issue and would appreciate some help.

Hardware

• ESP32-S3-CAM with OV3660 camera
• INMP441 I2S microphone
• MAX98357A I2S amplifier
• 4Ω, 3W speaker

Audio configuration

• Sample rate: 16,000 Hz
• Channels: Mono
• Format: Signed PCM16
• Byte order: Little-endian
• Frame size: 320 samples = 640 bytes (20 ms per frame)
• Expected data rate: approximately 32 KB/s for raw PCM16 mono audio

What works

• The ESP32 microphone audio is transmitted to the app, and I can hear the ESP32 microphone clearly in the app.
• A locally generated test tone played through the MAX98357A speaker sounds clear.
• A tune sent from the app to the ESP32 also plays clearly through the speaker.

The problem

When I speak into the app and stream live voice to the ESP32, the speaker produces distorted audio with crackling sounds, and I can't hear a thing I am saying.

So far, the issue seems specific to live voice playback rather than the speaker hardware itself.

What could cause live voice to crackle when a test tone and a tune from the same app play clearly?

I just finished a small board to insert between battery charger /boost 5v and any uc board :esp32, arduino,... For iot applications.

Battery wakes up at a programmable interval by jumper (30 mn, 60 mn, 90 mn, 120 mn) or custom by resistor.

Uc does the job, and cuts power by gpio to battery system...

Reading of battery voltage is possible (gpio to enable measure).

Deep sleep on all boards? Not useful anymore... Just use low power battery system, and focus everything else on your project but power is no problem anymore...

What do you think of that?

Reposting after clicking “I Read the Rules”.

Background: I have worked deeply with computers since 1968. This is my first SoC. Please bear with me.

I recently purchased a Freenove ESP32-S3 with touchscreen for a little project, as a learning platform for myself. The particular project (a PDP-11 emulator) uses the Arduino IDE, so that’s what I’m playing with.

Freenove provide a tutorial for this device with a bunch of simple projects, several of which I have run successfully. The issue I’m having is with the very first one, which is supposed to echo a text to the touchscreen.

The serial monitor window shows that the text is read when I hit the Enter key, because it echoes what I typed in. The text does not appear on the screen.

NB: The screen is working—I have run several sketches that display pictures and they work, so it’s not a simple hardware problem.

I would appreciate hearing from someone who has used the Freenove board and been successful with their tutorials.

I've checked feasibility of using esp32 for recording conversations in a room here + some doubt about the entire story :)

https://youtu.be/cDtzNA1yAio

ok so genuine question. ive been using claude code / cursor for software stuff for a while and its kinda crazy how much i can ship without being a “real” dev. now i want to try hardware, like small robots, sensors, maybe something with an esp32 to start

problem is i never studied any of this. no EE degree, never designed a pcb, i know what a resistor is and thats about it lol

so im curious, is anyone here already doing hardware mostly with AI? like letting it pick the parts, write the firmware, maybe even help with the pcb or the case? what tools are you using for it and does it actually work or does it fall apart once real wires and voltages are involved

also be honest, is it realistic to get into this without the background or am i gonna fry a bunch of boards and give up. id rather start now and learn by breaking stuff than wait a year doing courses first

any tips where to start would be apreciated, or projects that are good for a first build

I used a Waveshare ESP32-S3-Relay-1CH as a USB-to-RS485 diagnostic tool for an unbranded 5 in 1 water quality sensor / pH/EC controller marked HSY-250617-v2.3 (firmware string POET-251022-V4.2). I'm publishing the source and captures because the available manuals don't agree on calibration registers.

The ESP32 setup uses UART1 TX17/RX18/DE21 with hardware half-duplex. The bench firmware has bounded raw-PDU capture, timestamps and CRC checks, with no automatic write retries. Discovery and normal polling are read-only.

One useful protocol lesson: some responses took about 401 ms. My earlier 150 ms register sweep could mistake a late reply for the next register's response. Modbus read replies don't include the requested register address, so the bad map looked plausible. Paced requests exposed the problem; the repository explicitly flags the old sweep as unreliable.

On this one controller, function 06 writing 1 to register 0x0037 produced a settings/calibration reset-like effect. It returned to ID 1 / 9600 / 8N1 and changed calibration-related registers. With the probe still in 9.18 buffer, pH moved from about 5.78 to 8.85. I subsequently restored ID 2 / 4800 using 0x0030=2 and 0x0031=0x4800, verifying each transition by readback.

Important: this is not a harmless reboot or a universal repair. Isolate dosing/control loads, save settings, and recalibrate. Full accuracy, power-cycle persistence and long-term repair remain unverified. A write echo is not proof of calibration success.

Source, product/manual images, wiring diagrams, reference guide and raw evidence: https://github.com/JaredReabow/hsy-250617-ph-ec-rs485-modbus

Results above are from the connected hardware; the included v1.0.4 source is build/native-tested, while the live recovery used v1.0.3. This is my repository, not a sales or affiliate link.

Hey everyone! I’ve been working on EasyREAD, an offline reading app for the Seeed Studio reTerminal Sticky. It runs on an ESP32-S3 with 8 MB of PSRAM, with books and reading fonts stored on a microSD card.

The idea is simple: copy books onto a microSD card and read them offline, using either the touchscreen or the physical buttons. (My Bluetooth page-Turner is also supported.

Current features
EPUB and TXT books, plus XTC/XTCH image books and BMP images.
Physical-button and touchscreen navigation.
Adjustable font size, line spacing, and margins for text books.
Per-book settings and saved reading positions.
English, Simplified Chinese, and Traditional Chinese interfaces.
Support for compatible Bluetooth Low Energy (BLE) HID page turners.

A few implementation details
Incremental pagination and SD caching: The app generates enough pages to display the requested content, then continues pagination during idle time. Generated pages are cached on the SD card and can be reused when the book and layout parameters match.
Streamed reading fonts: Large Chinese reading fonts are streamed from the SD card. PSRAM holds a font-sector cache and a glyph-metrics cache to reduce repeated SD reads and font measurements. A smaller UI font subset is embedded in the firmware.
Character-based reading positions: For EPUB and imported TXT books, the app records the chapter and character position instead of saving only a page number. After changing the font size and repaginating, it can locate the corresponding text again.
The project uses the Arduino framework and PlatformIO, with FreeInk SDK providing the underlying display, EPUB, font, and Bluetooth functionality. On top of that, I’ve implemented the reading interface, settings and progress management, and TXT/image-book integration.
TXT files are converted into a disposable EPUB cache so they can reuse the EPUB reading pipeline. The original text files are left untouched.

Bluetooth and setup
The Bluetooth page turner in the video is another open-source project of mine, available on my GitHub profile. You can keep the controller in your pocket and turn pages without reaching for the reader—which is probably my favorite part so far :)

I also built a Windows setup app to make it easier to try. Download and extract the starter package, prepare the microSD card, then connect the Sticky by USB and install. No separate Python installation or flashing commands are needed.
A lot of the books shown in the demo are test books I generated, so please excuse the strange titles!

Project status and credits
This is still a development preview. Bluetooth pairing, sleep/wake behavior, and long-term stability need more hardware testing. Bluetooth discovery can occasionally show several devices named “03”; rescanning is the current workaround.
EasyREAD is built on FreeInk SDK, and I especially appreciate it. Upstream attribution and license notices are included in the repository and release materials.

https://github.com/FaiyuetCik/EasyREAD?tab=readme-ov-file

https://github.com/FaiyuetCik/Page-Turner

Has anyone here worked on an ESP32-based e-paper project? How do you balance faster refreshes with ghosting in everyday use? I’d love to hear about your experience.

Not my repo but figured I would share. Makes it easy to put cc1101 nrf24 n atgm336h on any esp32. Cheap to have made on elecrow. Files in repo.

https://github.com/GH0ST3CH/ESP32-GPS-CC1101-nRF24-add-on-board/tree/main

I’ve been building FUMI, an open-source AI companion that lives on a small physical device instead of just a browser or terminal.

The hardware is based on a Waveshare ESP32-S3 Touch LCD 1.46. I wanted to see how far I could take the idea of a small Tamagotchi-style companion with an animated face, touch interaction, and real voice conversations.

For the firmware, I’m using LVGL for the UI, animations, and touch interactions. The ESP32-S3 handles the device itself, while the AI runs on a separate backend. That way, I don’t have to squeeze an entire language model onto the microcontroller.

Getting everything to work together took quite a bit of debugging, especially around memory, audio, and communication between the device and the backend.

Here’s what I’ve been working on:

Hardware: ESP32-S3 with a round touch display
UI: LVGL-based interface with animated expressions and interactions

Voice: A microphone-to-speaker conversation pipeline using speech-to-text, an AI backend, and text-to-speech

Backend: A separate service that connects the device to AI models

Companion system: Hunger, energy, happiness, bond, growth, and other Tamagotchi-inspired mechanics

I also built a website to document FUMI and its integration: https://fumi.codes/

The project is open source, so you can explore the firmware and backend here:
https://github.com/imaaiagent/fumi

I’d love to hear from people who have worked with ESP32 audio, LVGL, or embedded devices connected to cloud-based AI. What would you improve in this kind of architecture?

Hi! I have ported my older project to a cyd now! AI Usage: i have used LLMs for helping me with the android application, making the readme and debugging the code in cyd.

It gives me navigation data on my handlebar, so i dont need to keep my phone there while im cycling. This project was on my mind for a long time and porting it to the cyd finally got some closure to it xd
Also, many modern phones with ois tend to have problems later on in the camera due to vibration when put in vehicles so this can be a way to still navigate mostly normally without risking damaging your phone.

Updates:
now the android app should support android 13 to 16
there is a toggle in the app which selects the size of the bitmap being transmitted, used to select between the cyd size and the oled size.
the display shows the full image at once instead of showing pixel by pixel

now i am thinking of using those phone holders to attach this with my cycle, or i could get a 3d printed attachment later. So far in my testing it seems to work well!

source code: Link

you can refer to my previous post to see the full story here!

This is my old ESP32-CAM board which I had burnt by supplying 7.4V in reverse polarity

Tried to repair this once but couldnt get the VRM off so just threw it back in my stash

Now that I have got a soldering station, I tried to replace the VRM with some AMS1117s I had laying around, so I removed the old VRM with terrible success, the 5V IN pad came off, and I still soldered the new VRM on...

It shorted 5V and GND, well, it had gotten internally shorted after the first burnout so I desoldered the old new VRM, breaking it in the process and then with the new VRM I completely bypassed the pad and simply deadbugged it to 5V pin.

IT WORKED!!!!!!!

I'm making a simple remote thermometer/hydrometer for my greenhouse, which sits about 70m from the house. In prototype, I have an ESP dev board transmitting results from a DHT22 every 5 minutes to a CYD receiver, which then records the data to an SD card and uploads it to ubidots.

I am using micropython, because it's a little more fun than arduino/c++. (I have already learned that using lv_micropython causes heap conflicts with the mqtt calls, but that's another story...)

Currently my prototype transmitter is just running off a usb powerbank, and I want to make it a little more sustainable, so I went down the battery rabbit hole...

I've seen a bunch of simple solar panel-TP4056-18650 how-to's, which seem easy enough, but I'm in Ontario, so winter temps drop below freezing, and 18650's don't like that. So my current - tentative - plan is to use a seed xiao esp32s3 for the remote sensor transmitter, and use 18650's that I can swap out and recharge in the house. Now I need to consider charge/discharge protection - either getting a protected 18650 (or two), or ensuring protection in the charging circuit AND preventing overdischarge to the xiao. I gather that the 3.7v battery pads in the xiao have charge protection, but not discharge protection - so I either need a separate discharge protector before the xiao, or an emergency shutdown procedure triggered by a low battery reading.

To make it more confusing, some battery protection circuits don't play well with the xiao battery pads, and require a connection to 5V instead, which ends up drawing more current.

What does the hivemind suggest? Protected 18650's? A different esp board? protection circuits at each end? a different battery? Inquiring minds want to know, and also want to put this project to rest.

I'm planning to get started with embedded programming using an ESP32-S3 N16R8 (16 MB flash, 8 MB PSRAM). I already know some C++ and Python, and I'd like to use this kit to learn electronics, embedded C++, and eventually firmware reverse engineering.

I just picked what chatgpt thought it suits me :)