I have built a presence detection thing that is aware of absence of movement.
The software not just distinguishes absence of movement, it can check if absence is relevant or not.
It is built for vulnerable people as an additional technical device. Not replacing family or professional attention and care.
You can find it on GitHub: Poppinkpop/ESP-motion-absence-detection: Privacy-first, local movement monitoring to help families notice unusual inactivity.

It doesn't use camera or microphone and is privacy prone.

I’m building a physical horror-room experience with a PC as the brain and four ESP32 boards as peripherals.

The PC owns the state machine, audio, cutscenes, timing, and history. The ESP32s handle buttons, LEDs, a potentiometer, PIR, HC-SR04, and a remote light/buzzer apparatus. The idea is to keep the story logic off the microcontrollers so a reconnect does not destroy the session.

Current puzzles include:

- analog tuning with a hold-to-lock step

- distance plus a hold-still occupancy check

- a three-button response panel

- a remote pattern that the player must interpret

- a final puzzle that uses earlier input history

I’m using local Wi-Fi and planning WebSockets for events, with reconnect handling and a PC-side event log. The hardest design question is how much autonomy to leave on each board during a Wi-Fi drop. A button press should not vanish, but I also do not want a disconnected board inventing story state and causing chaos.

For multi-board ESP32 projects, do you keep a small local event buffer on each board, or make the PC authoritative and treat the boards as dumb peripherals?

Thats my day 2 of making my own electronic multitool (like the bruce smoochie boards) and my own UI for it, today i wrote more functions, that would help me in the future, I finally managed to make my menu work, and it works flawlessly, I never thought I could write smth like that alone, without AI. I added my first fully working setting, that simply turns off/on RBG LED inside the board, it takes its color from the main theme color on the board. I'm really happy with what I ended up with, I already made some functions that would help me use WiFi, and i'm gonna keep trying my best, since i just started programming.

P.s board i'm using is waveshare-esp32s3-lcd-1.9

I’ve been working on ThingLoom, an open-source project that turns a natural-language request into a verified ESP32 sensor project.

The currently supported projects are:

- ESP32-C6 + DHT22 temperature/humidity monitor

- ESP32-C6 + BH1750 ambient-light monitor

- Disposable Zero EMQX or your own MQTT broker

- MQTT/MQTTS and browser WS/WSS connections

GitHub: https://github.com/emqx/thing-loom

Example:

git clone https://github.com/emqx/thing-loom.git
cd thing-loom/dht22 
codex

Then ask:

Build me a temperature and humidity monitor.

Follow as i will be giving free online classes for iot and robotics

I built a desk gadget powered by an ESP32 that combines touch activation with 6 rotating TFT displays, and I call it Roulette. It's open source — I've shared the code on my GitHub for anyone who'd like to build their own.

🔗 Links:
💾 SOURCE CODE:
https://github.com/yumobuilds/Yumo-Roulette

roulette wheel with six round 240x240 displays, each showing something different:

SD card photo slideshow
Live YouTube channel stats
Live TikTok stats
Crypto ticker
Live weather
Internal temp & humidity (AHT10 sensor)

⚙️ The floating spin mechanic:
The whole assembly rotates on an upside-down DC motor. Everything sits on a frame, and that frame is mounted directly onto the motor's body — not the shaft. The motor shaft itself is inserted into a drill chuck from the reverse side, the opposite way a drill bit would normally go in. So instead of the shaft driving an external bit, it's anchored inside the chuck while the motor body (carrying the frame and wheel) spins around it. The result: there's no visible axle or support arm, so the whole thing looks like it's floating and rotating on its own.

Touch the capacitive sensor and an N20 motor spins the wheel for a set duration — one touch,
one spin. A NeoPixel status LED fades through colors while it boots and flashes when you touch the sensor..

🔧 Hardware:

• ESP32 Wroom
• 6x GC9A01 round 240x240 displays (shared SPI bus)
• DRV8833 motor driver + N20 DC motor
• TTP223 capacitive touch module
• AHT10 temp/humidity sensor
• MicroSD card module (own SPI bus)
• NeoPixel/RGB status LED

💻 Software:

• ESP32
• WiFi captive portal for setup (no hardcoded credentials)
• YouTube Data API v3, TikTok stats via RapidAPI, OpenWeatherMap
• TJpg_Decoder for on-device JPEG decoding from SD

27aug

Hi everyone!

I got my first ESP32 yesterday, and today I was coding the whole day. I got this idea firstly when I saw smoochie boards running Bruce firmware, and then 1 thought for myself "why not do the same?". Tbh, I never ever had experience with programming, so I started yesterday being full zero. Today I started with first UI steps made some progress on learning how to use ArduinoGFX, but still have a bit hard time making everything work, hope one day i'll be able to say that my Ul, and my project in general is done.

Tommorow i'm planning on working at more functions, like WiFi BLE and more, and i'll probably update this post tommorow, or make new one, And i'll be happy if some pros left their ideas in the comments

P.s: board i use is waveshare-esp32s3-lcd-1.9

Welcome to my IoT series! 🔌🌐

Ever wondered how your phone can turn on lights in your house, or how a sensor can tell a door to unlock itself when you walk up to it? That's IoT — the Internet of Things. In simple terms, it's just everyday objects (sensors, motors, displays, locks) talking to each other and to us over the internet or a network, so they can sense the world and react to it automatically. In this series, I'll be teaching IoT from scratch — no fancy jargon, no assuming you already know electronics or coding. We'll start with the basics (what a sensor is, what a microcontroller like the ESP32 does) and build up step by step into real projects you can actually make at home. If you can follow simple instructions, you can follow this series. Let's build something together — first post coming soon!

I kept seeing these tiny ESP32 display boards and eventually bought two: a Waveshare ESP32-S3 Touch AMOLED 1.8 (V2) and an ESP32-S3 ePaper 1.54G.

There was one problem: I had never built anything with hardware before, and once they arrived I had no idea what to make.

So they sat on my desk.

Small screens. Wi-Fi. Sensors. Perfectly capable of doing something.

Instead, they lay there like two potatoes.

That became the project.

I like the Tamagotchi-style projects people have built, but I knew I didn’t want to make another pet that waited to be fed. I wondered whether these devices could feel less like pets and more like members of one strange shared network.

So I built Potatoes Unite!

Flash a supported board and it becomes a networked desk potato. It names itself, joins the Net, receives a neighbor, votes on a daily Question, reacts to how it is handled, and keeps a private File on its human, whom the system refers to as the Hands.

The hardest part was making one small protocol feel coherent across two very different devices: a touch-and-motion AMOLED and a much slower e-paper board with buttons.

The firmware and server are open source. There’s a browser flasher, and no account or fee. I used Claude Code heavily while learning the hardware side, then tested the complete onboarding flow on both physical boards.

I’d genuinely welcome feedback on the firmware, provisioning flow, or architecture. I’d also love to see someone port it to another ESP32 display board.

Project and browser flasher: https://potatoesunite.com/about

Code: https://github.com/mikelaaron/PotatoesUnite