r/Esphome

AI Disclaimer: This was a fun little weekend ai-assisted project, inspired by the sound_level sensor and my own love of the fourier transform (which I later dropped in favour of the Goertzel algorithm). I'm a software engineer by trade with a background in physics. My C++ is incredibly rusty and I wanted to see how doable this was using local AI models. Concept, planning and design by me, code itself was written by assorted local models with a quick human eyeball of the output to make sure it was largely sane at each stage.

Flip a binary sensor when your Samsung washing machine sings its jaunty tune, or when your fridge door alarm starts going off!

Needs quite a bit of calibration for more complex tunes, but was perfectly competent at distinguishing between different telephone error tones in my tests: https://en.wikipedia.org/wiki/Special_information_tone

Repo here and subject to change as I comb through Qwen's dubious parameter names: https://github.com/lJaffy/esphome-tone-tools

I'm constantly searching for one of my cats in my house. She's deaf so she's not responding to my calls and I get confused on where she is. She loves to sleep in places out of sight. So I want to use Bermuda but since I never did any real ESP projects, I thought I'd ask here.

The Bermuda BLE project is using ESPhome inside Home Assistant to find out what bluetooth device is in what room. That seems like the right thing for my situation. Attach a BLE device to my cat, and Home Assistant knows where my cat is.

Here is the project I found:

https://github.com/agittins/bermuda/wiki

I'm just confused on what ESP to get.

I found these that aren't that expensive. I think that might work. I'm not sure.

ESP-32S ESP32 ESPWROOM32 

aliexpress com item 1005007059457759

The problem is that it comes in several different versions and from googling, it appears that these are USB to serial conversions inside the ESP32.

CH9102 Micro

CP2102 Micro

CP2102 Type-C

CP2102 Micro

CH340 Type-C

I want Type-C because it's 2026 and I don't even have any Micro cables. But what else should I look for?

I'm planning on putting one in each room and only use it for Bermuda BLE.

I tried Googling it but couldn't find a site that's explaining it to me. My employer blocked AI on all computers so I can't ask that.

I tried using a couple of existing ESPHome MCP add-ons recently, but ran into some startup errors with them. Instead of running extra container infrastructure, I created a direct Python MCP server that interfaces right with ESPHome and works seamlessly with AI coding tools like Claude Code, Antigravity, and Cursor.

The nice part about this setup is that it does not require installing any extra Home Assistant add-ons. It just connects over your local network to the ESPHome dashboard you already have running.

Once connected, it lets your AI assistant:

• List your devices and see what is online
• Read and edit your device YAML files
• Check configs for errors
• Send Over-The-Air (OTA) updates over Wi-Fi

A few examples of things you can ask it in chat:

• "Check which of my ESPHome devices are currently online"
• "Show me the YAML file for esp32-shelf.yaml"
• "Update esp32-shelf.yaml so pressing the door button flashes my LED lights for half a second as feedback, check for syntax errors, and push the OTA update over Wi-Fi"

The project is completely open source (MIT license). If you'd like to try it out, open issues, or suggest features, check out the GitHub repo: https://github.com/saihgupr/esphome-mcp

I struggled with this for hours yesterday. Tried swapping XY, tried mirroring. I could never get the corners to align properly. I had Claude make me a grid of 10x10 rectangles where each one would be colorized as tapped. Tapping the bottom right corner and the upper left corner filled them properly. When I tapped the lower left corner, the upper right corner would colorize.

This also helped me find a dead spot. So at least I'm going to return it for that.

Anybody seen this before?

Does Carlos drink enough water? Seeed Studio sent me their human presence detecting kit, and I decided to use it on my cat. I'm sure that's not what they intended, but that's their problem, not mine. I'm using an ultrasonic sensor and PIR motion detector in a 3D printed enclosure to sense when my cat drinks, and roughly how much.

This was also an excuse to experiment with ESPHome on battery power, over OpenThread. It didn't go perfectly, but that's what experiments are for. The video covers the build, and the blog posts cover the software side also.

https://elvinhome.io/blog/articles-3/does-my-cat-drink-enough-making-a-smart-water-bowl-17

Hey everyone,

I want to share a synchronized multi-room wireless audio system I built entirely on ESP32s. The main motivations were to get sub-30ms audio distribution without the cost of running a Raspberry Pi/Snapcast at every endpoint, and to keep the setup incredibly simple. It’s designed to be plug-and-play: the system can run completely off-grid by generating its own Wi-Fi network, or it can seamlessly integrate into your existing home router. Additionally, I built in the flexibility for the slave nodes to switch roles and act as independent, standalone Bluetooth receivers if you just want to connect to a single speaker.

Repo (code, schematics, docs): https://github.com/chagoguila/SonicStream

I ran into several architectural bottlenecks while building this, so I wanted to share how the system handles them under the hood:

1. Solving BT/Wi-Fi Radio Contention If you've tried running an A2DP sink and a Wi-Fi server on a single ESP32, you know antenna timesharing causes massive packet jitter. To fix this, the system splits the ingress gateway into two microcontrollers:

• BT Ingress Node (ESP32 WROOM): Acts as a dedicated A2DP sink. I tuned the I2S DMA buffers down to 4x512 bytes, which cut the hardware transport delay to about 12ms. It sends raw PCM over a physical I2S cable (BCK, WS, DATA) to the Master.
• Master Controller (ESP32 WROVER): Receives the PCM stream via I2S, runs the DSP pipeline on Core 1, encodes it, and blasts it out over Wi-Fi.

2. Network Transport & Fault Tolerance Standard streaming protocols had too much overhead for the latency I wanted. The system supports two custom modes:

• UDP Multicast (239.0.0.1): This is the ultra-low latency mode. To survive 2.4GHz RF burst interference, the Master sends time-separated twin-packet redundancy (broadcasting a duplicate packet with a 1ms micro-delay).
• TCP Mode: For congested Wi-Fi environments. It uses non-blocking socket polling with slow-client pruning. If one receiver drops its connection or falls behind, its socket is dropped to prevent backpressure on the healthy nodes.

On the receiver side (WROOM or C3 slaves), there's a 5-second TCP inactivity watchdog to handle silent network drops (like router reboots) and a 500ms idle auto-reset on the jitter buffer to prevent decoder stalls after you pause the music. As mentioned, the stereo slave nodes can also be toggled to drop off the multi-room network and function as standard, independent Bluetooth A2DP receivers.

3. DSP Pipeline & Encoding Since the Master is a WROVER, I threw the DSP workload onto Core 1 prior to SBC encoding, meaning the slave nodes incur zero extra CPU overhead.

• Encoding: SBC at Bitpool 53 (~328 kbps stereo).
• EQ: 5-band parametric EQ using cascaded Direct Form I Biquad IIR filters (60Hz, 230Hz, 910Hz, 3.6kHz, 14kHz) with real-time gain adjustment.
• Anti-clipping: Instead of fixed linear attenuation, I wrote a soft-knee peak limiter. Signals below 85% peak amplitude pass through untouched. Anything above triggers a 2:1 compression ratio capped at 95% to eliminate intersample clipping.

4. Web UI & Wi-Fi Management The Master runs an async web server with a dark-mode dashboard. You can configure AP/STA Wi-Fi modes (switching between isolated network or home router), toggle UDP/TCP, adjust system-wide playout delay, set individual speaker delays, assign L/R/Stereo roles to slaves, and tweak the 5-band EQ live. Slaves send UDP announcement packets so the dashboard shows real-time online/offline status.

If you are interested in the code, I'd love to hear your thoughts on the DSP pipeline or the I2S DMA config. I'm currently looking into adding Opus encoding and AAC passthrough for the next update.

Hey all, hoping for some fresh eyes on this one.
I’m using an ESP32-C6 to remotely trigger my PC’s power button instead of the case power button.

The signal path is:
ESP32-C6 GPIO pin -> PC817 4 channel optocoupler board (only using 1 of the 4 channels) -> motherboard PWR header

So it’s 4 wires total on that one channel: two on the input side going to the ESP32 GPIO 4 and ground, and two on the output side going to the two PWR pins on the motherboard.

The idea is the ESP32 pulses the GPIO briefly, which switches the optocoupler’s output transistor on for that same brief moment, which closes the PWR circuit just like a normal button press would.

Then I used Esphome in Home Assistant to write the firmware (which seems to be fine, showing the device connected and popped up in integration and added correctly)

esphome:
  name: pc-power-control
  friendly_name: PC Power Control
  area: Living Room

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

api:
  encryption:
    key: !secret pc_power_api_key

ota:
  platform: esphome
  password: !secret pc_power_ota_password

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  power_save_mode: NONE


  ap:
    ssid: "PC-Power-Control Fallback"
    password: !secret pc_power_fallback_password

logger:
  level: INFO

switch:
  - platform: gpio
    pin: GPIO4
    id: power_button_relay
    internal: true 

button:
  - platform: template
    name: "PC Power Button"
    icon: "mdi:power"
    on_press:
      - switch.turn_on: power_button_relay
      - delay: 300ms
      - switch.turn_off: power_button_relay

However, i believe the problem is on hardware level.

When I plug in the PSU cable, the PC powers on for a second or two, then shuts itself off. Clicking the power on button in home assistant doesn’t do anything. Nothing in the logs as well.

All the wires are properly screwed into the terminal blocks on the optocoupler board, nothing loose.

Appreciate any help, I’m still learning this thing

I built an AI-powered smart irrigation system using an ESP32 + ML

I've been working on this project for a while, and I finally finished the main AI/ML pipeline.

The system uses an ESP32, a capacitive soil-moisture sensor, and a DHT11 to collect environmental data. I then built a machine-learning model that uses these readings to predict whether irrigation is required.

The interesting part for me was getting the different pieces to actually work together.

The pipeline is basically:

ESP32 sensors → dashboard → Flask API → ML model → irrigation prediction

In the video, I walk through the whole project, including:

• Collecting soil moisture, temperature, and humidity data
• Building the web dashboard
• Preparing the data for ML
• Training the model
• Evaluating it with a confusion matrix
• Looking at feature importance
• Deploying the model through a Flask server
• Connecting the dashboard to the ML model through an API
• Testing the final live prediction

One thing I found particularly interesting was seeing how the model's predictions changed once the inference server was running and the dashboard could communicate with the model.

This started as a simple ESP32 soil-moisture monitoring project, but I gradually expanded it into a complete IoT + AI system.

I'm still planning improvements, especially collecting more real-world data and adding additional environmental inputs such as light intensity.

I'd really appreciate feedback on the project, especially on the ML approach, system architecture, and what I could improve next.

🎥 Full project walkthrough attached.

Github Repository:

https://github.com/aqib-ai-ml/ai-powered-smart-irrigation

There's a slick project called **[Marquee](https://github.com/Jamisonfitz/marquee)\*\* (by Jamisonfitz) that turns a Google Nest Hub into a beautiful "now playing" card for Plex/Emby/Jellyfin — poster, plot, ratings, progress bar, clock.

For those who don't own a Nest Hub, or are moving away from them, or just love ESP projects, I wanted to expand the project to support ESP32 displays. I bought the first, most popular disoplay on Amazon compatible with ESPhome, a **7" Elecrow CrowPanel** (an ESP32-S3 touch screen). So I made it show the *exact same card* using **ESPHome**. It's on my wall now and I wrote it all up so others can build one.

**Repo:** https://github.com/TRusselo/marquee-esp32

### How it works (the whole trick)

The ESP32 is intentionally dumb. All the layout happens on my server:

```

Plex/Emby/Jellyfin → Marquee (renders a web card)

→ marquee-shot (screenshots the card to a JPEG)

→ ESP32 panel downloads the JPEG and shows it full-screen

```

`marquee-shot` is a tiny container that opens Marquee's real card in headless Chromium and serves it at `/card.jpg`. The panel just downloads that image — so it looks **pixel-identical** to the Nest Hub version, and the ESP config stays dead simple (no on-device layout code). It's a decoupled add-on: it never modifies Marquee, so it works against the plain upstream image too.

### What you need

- Elecrow CrowPanel "Basic" 7" (ESP32-S3-WROOM-1-N4R8, 800×480, GT911 touch). Other panels work — just swap the display pins.

- Marquee running on your LAN (Docker; one-click template on Unraid).

- The `marquee-shot` sidecar: `ghcr.io/trusselo/marquee-shot`.

- ESPHome.

### Quick start

Run the sidecar:

docker run -d --name marquee-shot --network host --restart unless-stopped \

-e MARQUEE_URL=http://127.0.0.1:8084 \

-e PANEL_WIDTH=800 -e PANEL_HEIGHT=480 -e SERVE_PORT=8088 \

ghcr.io/trusselo/marquee-shot:latest

Check `http://your-server:8088/card.jpg\`, then flash `marquee-crowpanel-shot.yaml` in ESPHome (set the sidecar IP up top; first flash over USB, then OTA). Play something → card shows up in a few seconds.

It also taps-to-wake + brightens on a new episode, goes full-bright when paused, dims during playback, and turns the backlight fully off when nothing's playing.

### The RGB-panel gotchas I hit (the actually-useful part)

- **Console on UART0** — ESPHome 2026.7 defaults logs to USB-Serial-JTAG, but those pins are this board's touch i2c bus, so the default kills your logs. `logger: hardware_uart: UART0`. (Cost me an evening of "why no logs?")

- **PSRAM mandatory** — 800×480 framebuffer won't fit in internal RAM. `psram: mode: octal`, keep the `CONFIG_SPIRAM_*` flags or a fresh flash hangs at `entry`.

- **LVGL `buffer_size: 5%`** — the 25% default eats the DMA RAM Wi-Fi needs on an RGB panel, so **Wi-Fi silently won't associate**. Looked like a Wi-Fi bug; was really out-of-RAM. (Screenshot mode skips LVGL entirely.)

- **Pin the ESP-IDF version** if Wi-Fi drops with "Association Expired" — recent IDF had a Wi-Fi regression.

- **GT911 touch: polled, no interrupt pin** (reset is behind a GPIO expander; wiring the IRQ crashed boot). Address `0x5D`.

- **Elecrow's docs for this board are wrong in places.** The reference that actually worked: https://www.espboards.dev/blog/esphome-configuring-elecrow-7-inch-display/

All of this is already handled in the repo's YAML — sharing it because it applies to any RGB ESP32-S3 panel.

Big credit to **[Jamisonfitz/marquee](https://github.com/Jamisonfitz/marquee)\*\* for the actual card — go star it. My repo just adds the ESP32 path on top.

Happy to help anyone adapting it to a different panel. Photos welcome if you build one.

I'm trying to remove this RTL8720 component from this board (It's a Govee recessed light), but the whole thing is a giant heat sink and even after adding low melt solder to the chip it doesn't even melt under a hot air gun (680F). Maybe i need to crank the temp up or just wait longer, but it seemed like I was making zero progress even getting the low melt solder to do anything.

Is there a better way to remove this component? I don't need it, so grinding it off isn't unrealistic as long as I don't damage the pads to replace it. There is a ground pad under the chip itself - so still need enough heat to melt that leaded solder even after adding low melt to the castilated pins.

Just finished the enclosure design for the keypad.

I am the author of Ava Pro, a fully self-contained voice satellite and kiosk project for Android 5–16, built around ESPHome. First of all, I would like to thank everyone for every recommendation, share, and piece of honest feedback. Without the long-term testing by community members and the frank discussions and comments on Reddit, there would be no Ava Pro today. By continuously pointing out those small but impactful issues in daily use, everyone has gradually given me the confidence to seriously introduce this project to more people.

I have been developing Ava Pro for over half a year. Since it is called a voice assistant, the voice experience has always been its most important focus. To ensure it runs smoothly on older phones, low-spec tablets, and smart displays, I restructured the wake-word detection, echo cancellation, noise reduction, gain control, and voiceprint functions, and rewrote many performance-sensitive paths in C/C++.

For this reason, I restructured the dual wake-word engine. The first engine retains the lightweight and mature microWakeWord; the second engine, vsWakeWord, offers capabilities significantly different from the original Ava Pro. It follows the ONNX/openWakeWord model approach but does not cram the complete ONNX Runtime, training tools, and general-purpose operators into the device. Those components are powerful but contain many capabilities that are completely unnecessary for wake-word detection. Packaging them as-is would not only significantly increase the installation size but also waste the limited memory and processing resources of older devices. Therefore, I reimplemented a lightweight ONNX model reader in C++, parsing only the structures and operators truly needed by the wake-word model, and rewrote the related feature extraction and model execution functions.

Furthermore, Ava Pro combines a custom-tuned software echo cancellation system, intelligent noise reduction, intelligent gain control, and lightweight 16-dimensional voiceprint matching. It can reduce playback bleed during voice interactions, suppress persistent background noise, and perform speaker matching without requiring high-performance hardware. Many performance-sensitive speech paths have also been rewritten in C/C++. The open-source components used were not simply bundled into the installation package; instead, they were individually refactored, trimmed, recompiled, and compressed according to how Ava Pro actually uses them. This is why the Lite APK has remained below 20 MB for a long time.

Therefore, even with voice, dashboard, music, Bluetooth, calling, and numerous expansion capabilities, the official Ava Pro Lite APK remains below 20 MB and is currently around 18 MB. This makes it considerably smaller than many similar kiosk and voice-panel applications. The 20 MB limit is not a random number; it is a long-term boundary I have set for Ava Pro. We cannot keep adding features at the expense of the already limited storage on older devices. After installing Ava Pro, these devices should still have enough room for Home Assistant, music players, and other genuinely useful Android apps.

Ava Pro has gradually grown to fit real-world home environments, including a Quick Entity panel, home screen, widgets, browser, Bluetooth proxy, presence detection, LAN voice and video calls, and Music Assistant/Sendspin multi-room synchronization, with per-device sync delay, a five-band equalizer, and lyric timing adjustments. Every feature can be disabled individually, and even the voice pipeline is optional.

The screen experience has also been refined: Smart AOD, pixel shift, and background load reduction work together to reduce the risk of burn-in and unnecessary power consumption during extended screen use. The redesigned Dawn Wallpaper brings together wallpaper, time, weather, and Home Assistant status to create a more comfortable experience when viewed from across the room. I especially encourage existing Ava Pro users to experience these changes firsthand, as many features cannot be fully covered in a single introduction.

Integration for beginners is straightforward: install Ava Pro, grant the microphone and overlay permissions, and then enable General Services. Next, in Home Assistant, go to Settings → Devices & Services → Add Integration, search for ESPHome, and select the automatically discovered Ava Pro device. No MQTT or HACS is required. You can also install HA STT and HA Edge TTS from the Mod Store to create your own voice pipeline through Wyoming.

Special thanks to video creator Lone Baggie.

Without his long-term hands-on use, recordings, and feedback, there would be no Ava Pro today.

You can first watch his real-world usage video.

Then use his shared Home Assistant Blueprints and HTML Views.

Together, they can help you quickly build your own Ava Pro kiosk.

Bluetooth proxy and LAN video calling are distinctive extensions, but they are not Ava Pro’s main focus. Its true and ongoing focus remains on how voice, dashboards, and everyday interactions can be naturally integrated into the home.

If you encounter any problems or find something unclear, please leave a comment and let me know. I genuinely want to hear what still needs improvement, and I will do my best to address it.