Well all know deep sleep method with uc.

But reality is not the theory! Few mA when sleeping, depending on the board design.

I published a first post a few hours ago.

And if, together, we could find your solution for your problem?

What is your project? What would you like to do exactly?

Monthes on a single 18650... It can give other perspectives...

Let's talk about it?

https://www.youtube.com/@Enduro-ioT

Hey all, I’m new to this sub, but it feels like the best place to finally share something I’ve been building on an ESP Vocat for a while now.

What it is

JARVIS Desk Bot is a small desk robot you talk to. It’s a voice gateway for Hermes, an open-source AI agent framework. You say the wake word, ask it to do something, and it talks back while the agent works. Everything on the speech side runs locally.

It’s MIT licensed, and the setup steps are in the README: https://github.com/dreamhunter02/jarvis-desk-bot

Here’s how the pieces connect:

ESP Vocat (ESP32) → xiaozhi-server (Parakeet for ASR, Kokoro for TTS, both self-hosted) → any Hermes agent

Why I built it

I wanted a fully local voice agent on my desk and assumed it would mostly be plumbing. It wasn’t:

• Hermes isn’t built to be a speech gateway. It’s designed around text chat. Long-running agent tasks don’t map cleanly to a voice session, where silence feels broken and timeouts kill the conversation mid-task.
• ESP Vocat wasn’t ready for local AI deployment out of the box. Pointing it at a self-hosted xiaozhi-server instead of the cloud backend was the easy part. The firmware put the robot to sleep 10 seconds after I stopped talking, even while the agent was still working, so I had to patch its wake timers. On the server side, replies were split into sentences for Chinese punctuation, so English came out in long, choppy chunks. The model would also drift into Chinese replies until I filtered them out.
• Voice UX is its own problem. Without a screen, you need audio cues for everything: did it hear me, is it still working, is it done, is it waiting on me?

What I ended up adding

• Wake and end chimes, so you know when it’s listening and when it’s done
• Spoken progress updates while the agent works (“Searching the web…”, “Still on it”)
• Google Tasks and reminders by voice
• Background helpers and long-running goal agents that report back when they finish
• Spoken approval before the agent runs risky shell commands
• Stays in the conversation until you say “bye”, with no timeouts mid-task

The current pipeline is ASR → agent → TTS. It works, but it has unavoidable latency and turn-taking limits. I’m planning to extend it toward fully local, full-duplex speech-to-speech models: ones that can listen and talk at the same time and handle interruptions naturally.

If you’ve worked on any of these, lets collaborate:

• ESP32 audio streaming and low-latency I/O
• Echo cancellation and barge-in on small devices
• Running duplex speech models locally

Happy to answer questions about the build. Feedback and roasts welcome.

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'd like to introduce gsp32-httpd (screenshots in the link):

• https://genereese.github.io/gsp32-install/

Want to try it out?

1. Plug in your board to your computer
2. Install the firmware via the web flasher, above
3. Configure your WiFi and access the UI

I'm a 23-year veteran python developer and have worked with microcontrollers for several years now - exclusively with micropython on various ESP32 boards. I teach microcontroller classes at a local makerspace and have countless projects I've made over the years.

I've been working with AI to create this tool to make the process of deploying, accessing, and maintaining these projects as easy as possible.

^{DISCLAIMER: This is a beta software/firmware that changes daily. I've done my best to ensure that it's reliable and stable, but I'm just one guy with an AI. If you ever want to stop using it, just download your program files, reflash your board to standard micropython, and re-upload your code. It should still work without GSP32 with the exception of remote pairing to other boards.}

WHAT IS IT?

It's a micropython firmware with a custom web-based user interface for uploading and managing your programs directly on your device. Whenever you want to change or update your code, there's no resetting, no re-uploading changed files, and no physically connecting to the board via USB cable (unless you want to).

Your main.py runs concurrently in the background as something akin to a virtual machine. You can change it and restart it in real-time and your changes take effect immediately without having to reboot the board.

When users are not actively accessing the web UI, the overhead is almost nothing aside from RAM usage.

Additionally, the web UI framework that runs this system can be used to make your own web-based user interface, populating your HTML with values directly from your python program that can be viewed or updated from that interface as you see fit. The default home page (above) is a fully commented, working version of this for your reference.

WHY DID I MAKE IT/HAVE IT MADE?

For several reasons.

ESP32 boards are usually overkill in terms of specs; so why are we still interacting with them like other older/inferior boards? I wanted to put those specs to good use and make my life easier in the process.

In addition to that, I found that bridging the gap from something like microblocks to micropython is very difficult for most of my students, so I wanted to create a system that would make setup, accessibility, and maintainability as easy, simple, and expandable as possible.

For me, personally, I wanted the fastest level of iteration possible, wireless access to my projects to configure and maintain them, easier file management, and an easy way to deploy and backup code.

WHAT DOES IT DO?

Well, reiterating a bit here, but it does a lot - and it does it surprisingly quickly. I had the AI focus heavily on optimization, caching, memory management, and GSP32's overhead. Basically, if you're not actively browsing the web UI, there's almost no overhead for your programs (aside from the memory usage).

It provides a framework for your own web pages that can be filled with live data from your micropython program. So, you can write your own HTML and use it to host web interfaces for your project for control, monitoring, etc.

It uses that same framework to run itself and includes password protection.

It includes a full-featured file management system that is drag and drop compatible with bulk uploads and downloads divided into two sections - one for your code, and one for your html.

It includes an onboard file editor with autocompletion and code inserting for many commonly used components as well as a pairing wizard that automatically exchanges encryption keys to make secured pairing with other GSP32 systems trivial.

Additionally, and this is one of my favorite features, it wraps your main.py with its code, so you can reload your project almost instantly without rebooting your board, which results in iteration rates that I don't know if any other system can beat.

It includes a mip package manager for quickly downloading micropython libraries.

It includes a backup and restore system for taking snapshots of your deployments.

It also includes a pin panel for real-time debugging of your physical pins based on the board you're flashing to.

Finally, it has a host of performance settings that can be toggled on or off.

WHAT BOARDS DOES IT WORK WITH?

It's compatible with most classic ESP32 (32S, 32C, etc.) and ESP32-S3 boards and there is a web flasher to take care of installing the firmware and configuring the WiFi.

Once configured, you may access the web UI.

^{Not supported: ESP32-S2 | C2 | C3 | C5 | C6 | H2 | P4}

WHAT'S NEXT?

I'm still adding new features almost daily. In general, I just want a highly polished, easy/fun to use micropython system that's not a pain in the ***.

If you try it out, please feel free to let me know your thoughts.

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

Hi! I was inspired by the thermal printer projects on here and bought one on Ali Express. It was advertised as a TTL connection, along with RS232 and USB. I am able to power the printer, print the test page, print via USB, but NOT print via TTL connected to my ESP32. I have used a multimeter and confirmed the wires are making connection to the printer, and that voltages are ok. I have tried looking up code from online and Claude (to see if its a software issue) and it still wont print anything. Any help would be appreciated! I am concerned that when the test page printed, it says Interface USB&RS232, and not TTL? weird. Defected printer maybe?

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++);
        }