The original PELLETINO only played PacMan. I'm pleased to announce version 2.xx, which has grown by quite a bit.

It's a launcher for the Waveshare ESP32-C6-LCD-1.69. You get a wheel of game logos with a screenshot behind each one. Tap to spin, hold to pick, and it boots straight into that game from then on. You play by tilting the board, since the accelerometer is the controller. No SD card, no PSRAM, just the 16 MB of flash on the board.

The lineup is 27 games: Pac-Man, Ms. Pac-Man, Galaga, Galaxian, Space Invaders, Donkey Kong, Mario Bros., Frogger, Dig Dug, Mr. Do!, Burger Time, Root Beer Tapper, Joust, Moon Patrol, Rally-X, Centipede, Missile Command, Asteroids, Tempest, Lunar Lander, Gyruss, Time Pilot, Arkanoid, Pole Position, Star Wars, Empire Strikes Back and Street Fighter II.

PR's are welcome if you want to add your own favorite game.

How it works:

- Every game is its own firmware. Each one sits in its own flash slot and the launcher chain-boots it, so a game gets the whole chip while it runs. Hold the middle button five seconds and you're back at the menu.

- ESP-IDF allows 16 app slots. That makes the limit 17 games per build, because Pac-Man and Ms. Pac-Man share one image. You pick which ones go on.

- Everything is generated from the ROMs you have. The partition table, the artwork and the menu all come out of that. Drop zips in `roms/`, run `./install.sh`, and it builds and flashes the lot.

- Plus the stuff that makes it feel finished. There's an attract mode when nobody's touching it and high scores that survive power-off. The screen dims instead of turning off, and there are three volume levels.

Street Fighter II was the hard one. For a long time it was just a video of the attract mode, because I figured a CPS-1 on this chip was out of reach. Turns out it isn't, mostly.

- It's a lot of machine. A 10 MHz 68000, a Z80 for sound, a YM2151, an OKI MSM6295, three tile layers and 256 sprites. All on one 160 MHz RISC-V core with 512 KB of RAM.

- Musashi wanted 576 KB of RAM just to start. That's its opcode tables, which it builds at boot, and it's more RAM than the board has. I worked them out at build time instead and packed them into 30 KB, mostly in flash.

- The 68000 spends most of its time waiting. Skipping the game's idle loop took the 68000 from 671 ms of every second to about 300. Putting the 147 instruction handlers the game actually uses in RAM got the rest.

- The ROM is 7.6 MB. It gets read in place from its own flash partition, memory mapped. The C6 can only map 8 MB at once, and that has to include the program. So everything that has to be mapped goes first, and the sound samples come after and get read as needed.

- RAM is still tight. The machine's own work RAM and graphics RAM are 256 KB together. With sound on there's about 45 KB of heap left. Moving the Z80 core into RAM would have helped, but then the graphics RAM doesn't fit. It was short by 4 KB.

- Sound is the expensive part. With sound off it holds full speed easily. With sound on it draws 1 frame in 4 and runs at 99% of real time at 11 kHz. Even reading the accelerometer cost 84 ms a second, so SF2 doesn't read it.

It runs its attract mode. The top button drops a coin and the middle button is a jab, but a six-button fighter isn't happening on two buttons and a tilt sensor. It's a showpiece. I measured all 56 combinations of video mode, frame skip and sound on the board, and they're all in the project's README if you're into that.

The catch is flash. That 7.6 MB partition means a build with SF2 fits about 13 games instead of 17. Mine has Ms. Pac-Man, Pac-Man, Donkey Kong, Galaga, Star Wars, Frogger, Centipede, Burger Time, Joust, Pole Position, Dig Dug, Mario Bros. and Street Fighter II.

Why would I put Street Fighter II on this medal if it's attract-mode only? Cause it's awesome, that's why. Also, this is meant to be a wearable first, so something just for looks fits into the mission statement nicely.

No ROMs, artwork or music are included, you bring your own. The code written for it is 0BSD, but most games use a non-commercial Z80 core, so the bundle is free to share and not to sell.

Repo: https://github.com/aedile/PELLETINO

Hi guys so basically im building something and i i have this esp 32 s3 super mini and it has battery pads named "B+" and "B-" behind it ... one small question i have is that if i connect the battery directl y into the pads then i can charge it with the esp's own usb .... but chatgpt is not particularly good with answering this and i dont see proper docs with this ... im in the software industry and tracking the pin and battery circuit diagram for this board is too tough of a process for me rather ask to the "WISE PEOPLE OF REDDIT" so pls . help me yalllll .

I built an agent chat interface into ESP32. It has tools and functions connected to it. So you can plug things in and ask questions. It's designed to be as a starting point for your projects. I can't do electronics anymore my eyesight isn't what it used to be. But I think ESP32 is great.

https://github.com/8perezm/esuyo-esp32-agent

Hey guys, I'm just sharing a project I've been working on over the last couple weeks.

Why I Built It: To be honest just to see if I could, this is my first device I've really ever built, it just started off by me seeing this waveshare device at microcenter and started thinking about things I could do with it, and decided on this. I 3D printed the backpack enclosure, used a wave share ESP32-S3 with a 1.47inch Display Connected to a battery back inside the backpack.

What it Does: Three Things

-Live Now Playing Display: It connects to your phone using BLE with an android Companion app. It takes your now playing metadata (Spotify, Apple Music, Plex, Youtube Music etc.) and displays it on the screen (Album Art, Track, Artist, Progress Bar)
-QR code / Contact Card: You can display a QR code instantly that connects to your Instagram, Website, Venmo/CashApp, Wifi, Your Personal Contact Card Or you can customize your own QR code.
-Gif Player: You can display any gif you want by beaming it to the device and playing.

What Challenged Me:

1. The enclosure and fit: Honestly this was the hardest part for me. I don't own a 3D printer nor am I very good at designing devices, had a little help at the library where I did get the enclosures printed as well as AI. Basically I took an enclosure on the maker world website used those measurements and designed something a little more natural for a backpack. My sizing was off and I didn't account for the buttons that stick out on the PCB, I finally got it taken care of and got the print.
2. Streaming Album Art over BLE: Honestly another stumper here, track names worked but was having trouble with the web app timing out and stopped streaming after a couple minutes, Java solved the problem. Now it's able to download high-res art from media session, downscales it and and streams the jpeg to the device.

Hardware:

-Waveshare ESP32-S3 with 1.47 Inch Display
-4x M2 10mm Screws
-PLA Printed Enclosure
-External Battery Back

Github:
https://github.com/Erock002/Patchi

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?

I have this: https://www.waveshare.com/esp32-touch-lcd-3.5.htm

I've delevoped a small product on it that has buttons you can touch and screens you can swipe through.

During my testing I thought I was going crazy in that screens appeared to change by themselves. I asked Claude Code to spin up a test rig which it's run over the last two nights, unattended, for seven hours each and lo and behold it's finding both swipes and touches are happening whilst I'm asleep.

What's strange is they all fit within the 150-160 pixel range in the vertical direction (bars on the right), and seem to be concentrated in two patches to the left and the right of the screen (bars at the top).

Coincidentally (or maybe not) if you draw an imaginary line through the USB port it appears to fall exactly on this "ghost line".

Has anyone ever experienced this and/or have a fix? Is this just hardware noise you have to come to expect with these boards?

I am going through the tutorials for the Freenove board described in my first post, and have encountered a run-time error. I would like to look up the error message myself, but I cannot find a manual for the Arduino IDE and e-mail to the address [support@freenove.com](mailto:support@freenove.com) gets refused as spam!

The particular tutorial is for manipulating an SD card. On running the sketch, I get the following message in the Serial Monitor:

E (3206) vfs_fat_sdmmc: mount_to_vfs failed (0xffffffff).
Card Mount Failed
mkdir failed
Failed to open file for writing
Failed to open file for appending
Failed to open file for reading
�Rename failed
Failed to open file for reading
�
SD card info:
Total space: 0MB
Used space: 0MB

The error presumably comes from the line of code

// Initialize the SDMMC interface with the specified pins
sdmmc_init(SD_MMC_CLK, SD_MMC_CMD, SD_MMC_D0, SD_MMC_D1, SD_MMC_D2, SD_MMC_D3);

The pins are #defined as

SD_MMC_CMD 40
SD_MMC_CLK 38
SD_MMC_D0  39
SD_MMC_D1  41
SD_MMC_D2  48
SD_MMC_D3  47

(If I leave the define in front of one of these, "Clippy" gets in the way and won't allow me to post.)

My question is, where do I look up that error number to see what is being complained about???

Hello everyone. I am currently working on a project to read data from a Yamaha motorcycle ECU. I’ve spent a week trying to figure out the exact method to "wake up" the ECU—specifically the wake-up frame/code and the data request frame—but I haven’t had any success yet. I don’t have access to any professional debugging tools, so I’ve been relying on research and reference materials.

The ECU is from a 2017 model; I’m still investigating whether it uses the K-line protocol based on ISO 9141 or KWP2000. I’m posting this in hopes of getting some help. Below, you can see the hardware setup I’ve been using for some of my other projects.

Everything is running on an ESP32, and I’ve already built an interface, but I haven’t been able to get the data to load into it yet. :((

Hi everyone!

I recently started my very first electronics project with absolutely no prior experience. I'm using an ESP32-S3 along with a small display, an INMP441 microphone, a MAX98357A amplifier, and a speaker.

I've managed to put everything together, and so far, everything is working! The display, microphone, and speaker are all up and running. I'm honestly surprised I got this far as a complete beginner.

My goal is to turn this little setup into a talking AI robot that can have conversations, respond with a voice, show expressions on its display, and maybe even have its own personality.

Now I'd love to hear your advice!

Would you recommend running the AI locally/offline or connecting the ESP32 to an online AI API?

I'd also appreciate any tips on how to approach the next steps, what technologies I should look into, and what challenges I might run into.

I'm still learning everything from scratch, so even basic advice would be really helpful.

Thanks! I'd love to hear your thoughts and learn from your experience.

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 got tired of dealing with flaky Wake-on-LAN packets and smart plugs doing dirty shutdowns, so I built a small, fully isolated remote power and reset controller for my PC using an ESP32-C6-Zero and ESPHome.

It plugs directly into the motherboard's front-panel header (⁠F_PANEL⁠) and gives me reliable power-on, soft shutdown, 5-second forced power-off, hardware reset, and live power status inside Home Assistant - so I thought…

I built an optoisolated PC power switch for Home Assistant using a Waveshare ESP32-C6-Zero and LTV-816S optocouplers connected to the motherboard front panel ⁠PWR_SW⁠ header.

The issue: The PC randomly powers on or triggers a shutdown signal without any command sent from Home Assistant. It happens sporadically (sometimes seconds apart).

Current setup:
• MCU: ESP32-C6-Zero powered via 5VSB internal
USB header.
• Optocoupler: LTV-816S. ESP32 GPIO -> 330 ohm resistor > Optocoupler Pin 1 (Anode). Pin 2 (Cathode) to ESP GND.
• Motherboard Side: Pin 4 (Collector) to Motherboard PWR_SW (+), Pin 3 (Emitter) to Motherboard PWR_SW (-) / GND .
• Firmware: ESPHome with a standard GPIO momentary pulse output.

What I've already tried:
• Added a current-limiting resistor directly after the
ESP32 GPIO pin (in series to the optocoupler anode).
• Added a resistor directly before the
motherboard PWR_SW connection to limit leakage current / dampen ringing.
• Neither stopped the sporadic random triggers.

ESPHome snippet:

esphome:
name: pc-power-controller
friendly_name: PC Power Controller

esp32:
board: esp32-c6-devkitc-1
framework:
type: esp-idf

# Optocoupler triggers
output:
- platform: gpio
id: pwr_switch_pin
pin: GPIO2

- platform: gpio
id: rst_switch_pin
pin: GPIO3

# Momentary controls exposed to Home Assistant
button:
- platform: template
name: "PC Power"
icon: "mdi:power"
on_press:
- output.turn_on: pwr_switch_pin
- delay: 350ms
- output.turn_off: pwr_switch_pin

- platform: template
name: "PC Hard Power Off"
icon: "mdi:power-off"
on_press:
- output.turn_on: pwr_switch_pin
- delay: 5500ms
- output.turn_off: pwr_switch_pin

- platform: template
name: "PC Reset"
icon: "mdi:restart"
on_press:
- output.turn_on: rst_switch_pin
- delay: 350ms
- output.turn_off: rst_switch_pin

# Reads motherboard PWR_LED state
binary_sensor:
- platform: gpio
pin:
number: GPIO4
mode: INPUT_PULLDOWN
name: "PC Power State"
id: pc_power_state
filters:
- delayed_on: 100ms
- delayed_off: 100ms

What I'm wondering:
1. Could the ESP32-C6 GPIO be floating or pulsing
HIGH during an unlogged Wi-Fi reconnect or silent brownout reset?
2. Does the optocoupler anode need an explicit pull-down to GND (rather than just an inline series resistor to drain capacitive noise/EMI?
3. Are there specific GPIO strapping pin glitches on the
ESP32-C6 that default HIGH on boot/sleep wake?
Has anyone run into this with optocouplers on PC motherboard headers, and what was the actual fix?
Thanks!

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

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.

Hi all, I've been fighting a rotary encoder problem all day and I'm running out of ideas.
I'm using an ESP32-C3 SuperMini on a custom PCB with a brand new EC11 from AliExpress. A and B each have a 10k pull-up to 3V3, with no series resistors or caps, and I'm just reading them with digitalRead().
Originally A was on GPIO1 and B on GPIO0, and I made the dumb mistake of wiring the pull-ups to 5V instead of 3V3. B seemed fine, but A got stuck low and sometimes flipped between 0 and 1 without me touching anything. So I cut the trace to GPIO1 and moved A to GPIO21, which had never been used before. It worked for about 5 minutes and then got stuck low again. Now B is dropping too: its idle voltage went from 3.3V to 2.1V and then 1.6V.
What's weird is that everything looks fine with the board off, so I suspect something that only leaks when it's powered. Here's what I measured:

Board powered, encoder idle:
3V3 rail: 3.3V
A (GPIO21): ~0.6V
B (GPIO0): 1.6V (it was 2.1V earlier)

Board off:
A to GND: OL when idle, short when turning
A to 3V3: 10k when idle, ~4.9k when turning
B behaves the same way

No bridging between pins, no visible flux, and the old GPIO1 trace is cut and reads OL to A
My guesses are a bad encoder contact or damaged pins from the 5V mistake, but GPIO21 never saw 5V, so I'm not sure. Tomorrow I'll desolder just the encoder's middle leg to see if A and B go back to 3.3V.

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

edit: TY for the answers! moving to https://www.reddit.com/r/esp32/comments/1x20yit/signalsweep_pocket_countersurveillance_scanner_on/, which is the reason I got the C5 in the 1st place. It's having the same build error as my blink build.

edit2: solved! https://www.reddit.com/r/esp32/comments/1x20yit/comment/ph5qpqp/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button

-----

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!!

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

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?

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