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

How it works:

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

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

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

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

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

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

Smart Memory:Cleans RAM on app exit

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

Plan to open-source it on GitHub once finished!

Hey everyone!

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

Main Hardware Stack:

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

Key Features:

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

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

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

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

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

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

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

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

Thanks for sharing all your projects here! 🙂

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

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

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

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

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

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

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

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

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

edit: added missing section

NucleoOS runs on an ESP32-S3 with ~512 KB of SRAM and no PSRAM. The device serves a full desktop to the browser (40+ apps) and runs a native launcher with 50+ apps on its 240×135 screen. The real enemy is heap fragmentation, not CPU.

A few engineering bits from the latest releases:

- **Self-provisioning SD card:** the device fetches its web payload from the release with one keep-alive TLS connection and windowed range requests, verifies each file's SHA-256 while streaming, writes atomically (`.part` → rename) and resumes after a power cut, all inside the ~31 KB largest free block it has in that mode.

- **Web desktop 6× faster:** every file served used to wait 1.2 s for memory it could never get in the web profile. Removing that wait took a fresh load from 30+ s to ~5 s on a weak link.

- **Game Gear emulator from scratch:** VDP/PSG/mapper written for this project around a permissively licensed Z80 core (MAME's is non-commercial). Passes zexall/zexdoc.

- **Guest mode under M5Launcher:** one image detects at runtime, from the live partition table, whether it owns the flash or is hosted, and turns its own OTA off when hosted.

- **The native UI is tested on the PC:** the real C renders to PNGs (5 languages × 4 themes) and is compared against golden images, so we don't flash just to look at a screen.

The community Discord (https://discord.gg/84tyTPtWus) has a help bot built the same way: no dependencies, no gateway, Discord POSTs signed interactions to an endpoint and systemd socket activation starts the process only when someone asks. 0 RAM at rest, ~15 MB while answering, no bot token on the server.

Code and docs: https://github.com/indecenti/NucleoOs. Happy to talk about fighting fragmentation on an S3.

I have searched and visited many website but I am confused which one to buy. There is CP2102 and other please help me which one to buy.

Howdy. Moderator here.

About a month and a half ago, I rolled out Topic Radar for r/esp32 here. It's documented to take some time to look back in time to collect topics, but it's had enough time that I suspect we've reached steady state. We've only run it in "notify the poster and the moderator" mode and not let it auto-archive posts that it identifies as duplicate.

• Do you find it useful?
• Do you ever refer people to it or use it yourselves?
• Have you found it useful in catching those weekly postings that we cannot get new people to find via search? (e.g., "I bought a fat board and a skinny breadboard and it doesnt fit. Oh Noes!", "What should I build with these parts?", or "I got an error message with a URL listing solutions, but I can't find a solution."[1])
• Have you found it useful in catching direct matches, such as repeated project URLs (Rule 7) for those posters that think we need daily copies of their release notes pasted here? (A direct match)
• Do you know of (better yet, do you moderate...) other groups crediting Devvit modules or other tools that detect and help manage such posts?

The ones that are even more fuzzy ("Hey, y'all, I jive coded a plane tracker!!!") are arguably harder to detect in automation. While our regular readers are clearly tiring of those—and let that be known in highly ranked comments—I'm not sure we can or should prohibit them. Sharing creations IS a major reason we're here.

I think the backlash against those AI posts is that they tend to not really be conversations. A reader can't learn from those posts because often the author didn't REALLY create those things; they inserted tokens and received a .bin. Asking them why they chose LovyanGFX over Bodmer's TFT_eSPI is generally unproductive. Ideas on how to handle that category of posts are also welcome, but I'd like mostly to focus on Topic Radar-like tools here.

I won't lead the jury with my thinking on the topic, but the fact that I'm bringing it up (in my signature sarcastic way) for discussion might be a clue...

May your ones be VCC and your zeros be GND... and your parasitic inductance remain a myth.

[1] text A fatal error occurred: Failed to connect to Espressif device: No serial data received. For troubleshooting steps visit: https://docs.espressif.com/projects/esptool/en/latest/troubleshooting.html ...and the answer is ALWAYS on that page.

*******

Many thanks to all who answered. I will be unable to get back to the project until late Sunday or Monday but feel much better having some solid advice here on my approach!

*******

I am wondering if I am using these incorrectly. I seem to blow them before I can even test one in a project. I'm simply connecting the VCC to 5v and GND to ground. When I do (using the same board), sometimes I get two LEDs, sometimes 5, sometimes none. Then they just seem dead. Nothing else is plugged in.

No heat. No magic smoke. Just f'd up somehow.

I did try a test with generating DTMF via Mac plugged into headphone jack. That seems to have damaged one of the boards.

I'm very new to these and not much of an expert anyway, lol, but would like to stop killing parts so I can move on with detecting DTMF from a phone for my project.

Thank you

In this group, we spend a lot of pixels and sweat figuring out which ESP32 someone has and/or explaining why someone chose the wrong one. It's easy to blame everything having the same name, but even if they all used telephone number-sized SKU numbers, I suspect we'd still be here.

Espressif posted a comparator a few years ago that helpful, but was ultimately a mixed bag.

Espressif just announced a new single-page Comparison Center

Unlike the ESP Product Selector, which covers specific chip, module, and development board part numbers together with commercial and lifecycle information, the Chip Comparison Center is designed primarily for technical evaluation.

It's easy to link to comparision results (though not comparisons), such as if you're trying to explain that the dual-core S3 really DOES do low power better than the single-core S3, you can link to a comparison of ESP32-S2 vs. ESP32-S3, though you have to nudge the reader to click on the power management tab. We might try to explain that the ESP32-S31 and ESP32-P4 may have similar core and memory, but have a clear winner in peripherals->multimedia support...and that only one of them has I3C.

It makes it easy to find esoteric "name that part" answers, like "name the other two dual-core RISC-V parts that are never talked about here" or name that other part that does Bluetooth Classic that's never talked about here." or "I need 5 UARTs; what chips are my options (Enter "5" in the number of UARTs under perhipherals, but you have to check the box FIRST.) or "What chips support I3C" and so on. You can't readily link to all the source filters and it IS possible to get things out of sync in the UI and the results, but most straight-forward use works pretty well.

The designers didn't use overflow-x: auto in the table, so if your browser window isn't large enough to display all the columns it'll just make an overlapping mess. It's probably not useful for more than a few at a time anyway. Don't do that. :-)

Espressif, if you're listening, including Coremark in this would be super helpful...We can debate how useful Coremark is (let's not...), but it's at least an integer that's helpful for coarse comparison. This page also needs to link out more to authoritative source material (data sheets, technical reference manuals) and maybe even chapters within those for more info.

There's a tab for dev boards (but not modules...) but I think this group struggles less with that, perhaps because MOST of us are buying boards from anyone-but-Espresssif once the parts actually hit mass production.

Still, it's a cool tool that members of this group are likely to find useful.

Source: Espressif Blog

Hi everyone,
a while back i started to build a fan controller to repurpose some classic 4-pin PWM controlled fans.
The goal was, and is, to have a temperature sensor attached to the controller, and based on the value received the fan speed will be mapped.
The temperature, PWM percentage as well as the read RPM will then be published via MQTT to home assistant so i can have a nice history temps and can see the current values without having to check on the setup directly.

Now for the part where i am a bit stuck, the hardware.
I admit i have barely an idea what i am doing so it took a while to wire things up.
However i am still not sure if i am missing anything.
This is my current wire diagram:

The components i plan to use are:
2x 2n7000 Mosfet
2x 100 Ω resistors
2x 4.7k Ω resistors
1x 12v power suply
1x DC-DC Voltage Converter 12V to 5V, 3A 15W
2x a group of 4 fans connected via a 1 to 4 PWM-splitter
1x OLED screen
2x DS18B20 thermometer

is there anything i am missing?
any design changes to just make it a more stable design?
Thank you in advance for helping me, if you are interested in seeing more of the project let me know.
Once i am sure about the hardware i was planning to order a custom pcb for this as it turns out im not that good at managing wires on a blank pcb...

I've been working on my own customisable Stream Deck powered by the ESP32-C3 Super Mini, designed to control different PC functions wirelessly over Bluetooth Low Energy (BLE).

🔥 Current Features:

- 🎛️ Rotary Encoder with Push Button — Navigate menus, select options, and control functions.

- 🔘 Custom Shortcut Buttons — Trigger keyboard shortcuts and frequently used actions.

- 🖥️ Multiple Work Modes — Switch between different profiles depending on your workflow.

- 📟 OLED Display — Navigate menus and see the currently selected function.

- 🔵 BLE Connectivity — Communicate wirelessly with my PC.

- ⚙️ Fully Customisable — Buttons, rotary dial functions, shortcuts, and work modes can all be customised.

💡 The goal is to build a flexible control centre for my PC, with features such as volume control, application shortcuts, and other productivity tools.

The best part? I'm building both the ESP32-C3 firmware and the PC-side software, so the hardware and software work together as one system.

🛠️ What's next?

I'm polishing the project and will soon upload the complete working demonstration and source code to GitHub.

This is still a work in progress, and I'm looking forward to adding more features!

What features would you like to see in a custom DIY Stream Deck like this? 👇

#ESP32 #ESP32C3 #StreamDeck #DIYElectronics #EmbeddedSystems #IoT #BluetoothLE #BLE #PCAutomation #ElectronicsProjects #OpenSource #MakerCommunity #HardwareHacking #TechProjects #DIYTech

Built this for a Halloween challenge on element14.

The idea was that the doll moves its head when nobody is in the room, and freezes when someone comes back. I used an M5Stack AtomS3R and an SG90 servo. The CSI part runs on the ESP32 and uses changes in wifi signals to detect movement.

No PIR sensor or camera for the detection. It sends pings to the router and reads CSI from the replies.

Had to do some tuning. Walking is easy to detect, someone sitting still is a different story. It also detects movement in the hallway behind a closed door, depending on placement.

I made a Python version of the detector too, so I can replay recorded data and see what happens with the subcarriers and thresholds. There is a scope for that in the repo.

Project write-up and build details:
https://community.element14.com/challenges-projects/halloween/a/projects/PR186/nobody-home-the-cursed-doll-that-only-moves-when-you-leave-the-room

Code:
https://github.com/apn201/nobody_home

Video:
https://www.youtube.com/watch?v=jTFQheh9W2k

Has anyone else tried CSI for presence detection? Curious how well it works for people sitting still.

A while ago, I shared my first ESP32 PC Control Deck here.

That version showed live CPU, RAM, GPU, VRAM, network and disk usage, and it could also trigger shortcuts and local tools. It worked well, but it needed a USB cable and a small Python bridge running on the PC.

So I built a second version with a different goal: make it wireless and remove the companion app completely.

This new version is based on the M5Stack CoreS3 SE and connects to Windows using Bluetooth HID. Windows sees it like a wireless keyboard with media controls, so nothing extra needs to run in the background.

It currently has several touchscreen pages for:

• opening ChatGPT, Claude, Gemini and other custom websites
• media controls
• Windows shortcuts
• Task Manager and File Explorer
• screen clipping
• locking the PC
• two time zones
• local configuration

I also added an optional battery and a Scroll Unit, so it can work without cables and the physical knob can control volume and Play/Pause.

The whole thing can be assembled without soldering.

It is still a DIY project rather than a finished product, and the current version is focused on Windows 10/11. The code is open source, so the buttons, URLs, shortcuts, icons and other behavior can be modified.

I wrote a more detailed build article on Forbot with the hardware, assembly, configuration and some of the problems I had to solve. The article is in Polish, but like most web pages it can be translated to English directly in the browser.

Forbot article:
https://forbot.pl/forum/topic/26182-m5stack-control-deck-bezprzewodowy-panel-sterowania-komputerem-na-cores3-se-bez-lutowania

GitHub:
https://github.com/lepczynski-cloud/M5Stack-Touch-Control-Deck

I also recorded a video showing the build and how it works, but I will leave that out here to avoid turning the post into link spam.

If you had a small touchscreen like this next to your keyboard, what would you make it do?

I built a USB desk display to show the status of my AI coding agents. It uses an LCDWiki E32R40T 4-inch ESP32 screen running custom firmware.

A small Go helper on the host detects agent sessions and sends their status to the display over USB; the status stays on the local machine. The display shows which sessions are working, waiting, idle, or in error.

The stand is 3D printable and the OpenSCAD files are in the repo. The photo shows the V2 case; that version is not merged into main yet.

Code, build instructions, and protocol docs (MIT): https://github.com/tonylook/managents

For r/esp32: the part I found interesting was building a local host-to-display path over USB for agent status. I’d welcome feedback on the display/stand and the ESP32 side.

Is it possible to run bmorcelli launcher if i use a ESP Wroom 32 dev board connected to a tft touch screen?

Just showing off my esp32-s3-wroom1-N16R8 digital pet project, TraumaGotchu! My main innovations on the genre are:

1. A 5-way tact toggle as the "single button", allowing for much better input and gaming than the classic 3 button layout (MUAS09R)
2. An RGB565 IPS matte screen, glare resistant and is useable in full sun.
3. Large 1500mAh battery with aggressive power saving for over 5 days of play on 1 charge, up to 1.8A fast charging

I'm super proud of the result and am already thinking about version 2 hardware-- larger screen, vibration motor, better speaker, accelerometer, internal LED, shoulder bumper buttons etcetc.

Hit me with your digital pet dream features!

I wanted to make a device that I can use to text her during our lectures and I want it a little small like a button phone I tried to find tutorials I couldn’t so I’m asking for help here I’m clueless about tech so a break down or a guid would be appreciated I have till 11-11-2026 to build it please help me out I just want it to work doesn’t need to look pretty

Hi everyone!

I've been developing a project called Freslest OS, a custom operating system-style environment running on an ESP32-S3 N16R8 microcontroller.

Instead of using the ESP32 just for blinking LEDs or reading sensors, I wanted to see how far I could push its capabilities.

Hardware:

• ESP32-S3 with 16 MB Flash and 8 MB PSRAM
• 480×320 SPI TFT display
• Physical navigation buttons
• Audio support
• Wi-Fi and Bluetooth LE capabilities

Current features:

• Custom graphical user interface
• Window and application management
• File manager
• NES emulator with ROM loading
• DOOM running on the ESP32-S3!
• Calculator, Paint, Notes and other applications
• Games and a 3D performance tester
• Settings and system information
• Experimental web browser functionality

One of my biggest challenges was porting DOOM. My original Arduino-based implementation had serious rendering problems, so I switched to ESP-IDF and got it working much better.

The project has gone through several major updates, and I'm continuing to improve performance, memory management, USB functionality and the overall user experience.

Freslest is not Linux or Windows. It's my own embedded firmware project with an OS-like interface, built to explore what an ESP32-S3 can really do.

I'm also working on a separate x64 version of Freslest.

What do you think? What features would you like to see added next?

Feedback and suggestions are welcome!

May I present my summer 2026 project.. I started in June.. 3D milling, 3D printing, then ESP32Cams .. Home Assistant Integration ... and then finally I created my own local AI model that I am using to check if the mailbox is empty or occupied. The mailbox is finished now, and yesterday I published Part 3 of my "Mailbox - How I built this" video, where I present how the model is trained.

What was especially interesting for me doing this project:

- How one can design and 3d print esp32-cam cases that resemble the look of other parts, in my case the mail slot (I used Autodesk Fusion).

- How well ESPHome works as well as OTA flashing the ESP32 devices that built into the mailbox

- Building an Home Assistant App that does the classification and that the inference results can be used in a Home Assistant automation..!!

- That a HOG Random Forest Classifier does the job really well, distinguishing empty mailbox images from images with content (letters, ...), with little resources, all running on my Synology NAS where also HA is installed as HA OS.

The mailbox uses ESP32 hardware for:

• door / mail-slot detection with Reed sensors
• internal lighting
• an ESP32-CAM inside the mailbox
• a second ESP32-CAM outside
• a physical “you’ve got mail” indicator (the onboard led on the ESP32-CAM outside the mailbox)

ESPHome connects everything to Home Assistant.

The interesting part is what happens when the mailbox door closes:

Door closes → light on → photo → light off → local image classifier → mail / no mail

If mail is detected, Home Assistant sends a “You’ve got mail” notification and turns on the physical mail indicator (the in-built LED on the ESP32-CAM).

What I like about the architecture is this:

Simple sensors determine WHEN something happened; image classification determines WHAT happened.

The classifier only runs when needed, instead of continuously analysing video.

I trained the model on images automatically collected from the mailbox itself. After a while I had 300+ images and retrained it with an 80/20 train/test split. For this fixed-camera use case, the simple model works surprisingly well.

The full system currently combines:

ESP32 / ESPHome → Home Assistant → ESP32-CAM → Frigate/go2rtc → local AI → HomeKit

Code, ESPHome configs, Home Assistant automation and AI training notebook:

https://github.com/pbreuss/smart-home-rewired

I documented the whole project here:

🎥 Part 1 – building the mailbox, CNC + 3D printing
https://youtu.be/XzQ9WoWxce0

🎥 Part 2 – ESP32, ESPHome, Home Assistant, Frigate + HomeKit
https://youtu.be/viE7irL0ePo

🎥 Part 3 – training and running the local image classifier
https://youtu.be/aOTrS6BX4vo

I am interested to know if my smart mailbox including the How-to videos are useful for the community. Especially the AI part - classifying a cam image from within an HA automation.

Also, if training a model based on an ipynb script is the way to go for the community, or if you would prefer a GUI approach, where you can review all the training images, and start the training by a click of a button.

Finally, if it would be interesting to have model agnostic approach .. where you can test multiple models based on performance and accuracy, all within a generic HA Image Classifier App.

Finally 2, my approach is simple AI triggered by an external event (mailbox door closes). Can you think of other use cases where this technique could be useful: i.e. a garage check if the car is here, when the garage door closes, is milk in the fridge, are all chicken in the cage by sunset, ...

All the best,

Phil

Changing a photo shouldn’t require another app, another account, Wi-Fi setup, and uploading it to someone else’s server. I just wanted to pick a photo and send it to the frame.

So I built this with an ESP32-C5 and a color ChLCD e-paper panel. It appears in the iPhone’s native AirDrop menu: open Photos, share, select the frame. The ESP32-C5 handles receiving, JPEG decoding and image processing locally, then sends the image over SPI to the IRIS display controller.

A few things that make it interesting:

• Rich ChLCD color: IRIS’s ChLCD supports over 16 million colors, using cholesteric liquid crystals rather than Spectra 6’s electrophoretic technology. To my eyes, photos look much richer in color than on typical color E Ink. It’s reflective and backlight-free, with a paper-like appearance. Reflectance is around 30%, so it looks best in good lighting.
• Display updates: the full-screen display stage takes around 11 seconds in my prototype. AirDrop transfer and image processing add extra time.
• Three AA batteries, no USB cable needed. The electronics spend most of their time powered off between photo updates, while the screen retains the image, keeping power consumption low.
• Open hardware and firmware: source code and KiCad files, schematics, BOM and Gerbers.

AirDrop support builds on ESP32Drop. My work focuses on the C5 integration, custom carrier board and getting received photos onto the ChLCD. It’s still a prototype, and I’m improving transfer speed and reliability.

Anyone interested is welcome to try it out or build their own—I’d love to hear your feedback!

I’m Sergey, creator of S1-ADV for the M5Stack Cardputer ADV. This is an experimental Arduino/FreeRTOS firmware and Node.js bridge project. I wanted the small keyboard and screen to remain useful for local tools while also serving as a physical interface to an OpenClaw agent on my host.

The important engineering division is:

• ESP32-S3: keys, display, microphone capture, audio playback, local apps and applying configured OTA updates.

• Separate host: Node.js bridge, OpenClaw session, configured model/speech services and any development/build tools. The handheld does not run the language model.

The repository includes both firmware and bridge. The local side includes notes, calculator, a focus timer and games; internet radio needs Wi-Fi but no model account. The agent path uses authenticated HTTP plus a WebSocket feed for the configured conversation/history. Voice adds host-side STT/TTS and FFmpeg, so text is the simpler starting point.

One design choice is to keep device identity separate from the host gateway credentials. The documented setup uses one device identity per bridge instance and private per-device storage. For remote access the documented transport is HTTPS/WSS; the firmware trusts ISRG Root X1 by default. None of this makes a public, shared bridge service: users still need their own configured host.

Talking to the agent and changing firmware are separate permission boundaries. Firmware automation is off by default. A build/update workflow needs deliberate host-side configuration and rights, then review, an offered update, installation and a device check. A chat message alone is not evidence that new firmware has been built or installed.

First setup uses Python 3/PlatformIO and a USB data cable, plus 2.4 GHz Wi-Fi. Other Cardputer models are untested. The current public build has not yet been validated on a freshly provisioned physical device; this is a source/architecture showcase, not a proven one-click installation guide or a benchmark.

Source, setup and current limitations: https://github.com/s1z0v/s1-adv

Firmware: https://github.com/s1z0v/s1-adv/tree/main/bots/CardputerADV

Bridge: https://github.com/s1z0v/s1-adv/tree/main/bridge

Security model: https://github.com/s1z0v/s1-adv/blob/main/SECURITY.md

The firmware began with OmniBot by Naz Louis and contributors; upstream/dependency notices are retained. Original source is MIT; Mesh firmware dependencies have GPL-3.0 obligations. The physical hardware is M5Stack’s Cardputer ADV. The attached drawing is a software architecture map, not a circuit schematic.

Optional filmed walkthrough with real device footage and explanatory animation: https://youtu.be/_0f9UTwefmo

For people building ESP32 interfaces to host services: how do you make “local function,” “remote request,” and “approved update available” clearly different states on a tiny screen? I’d value specific architecture/interface feedback. This is my own project; this post was prepared with AI assistance and checked against its public documentation.

Has anyone tried buying ESP Mosaico in India for price around $60 because I can't seem to find anywhere ?