ESPHome

If there are people reading this and are excited to try out ESPHome: try it out without writing a single line of configuration by installing some of our ready-made projects: https://esphome.io/projects/

It allows you to turn a cheap microcontroller into a voice assistant, bluetooth proxy or media player directly from your browser.

No questions, only praise. This project is simply awesome, I've been astonished time and time again by the features. I had done a complete dive into the Espressif SDK trying to implement a wireless switch with temperature sensor and mqtt and had nearly finished the project when I stumbled on ESPHome obsoleting all of my work at once. It was just everything I had written so far plus many added features and obsoleted all my work at once.

I have one! ESPHome is awesome but I'm trying to steer away from Wifi IoT - a big reason is that I like the idea of self-healing meshes that can work entirely offline, without having to deal with a lot of configuration.

Espressif seems to have a few devices with ZigBee capabilities, think there will be a way of building our own ZigBee device in the future?

The ESPHome project is unusually competent, user-centric, and almost uncanny in how well it works.

I'll tell you what I want, though. I'm not sure this is in-scope for ESPHome, or how it's possible to even implement cleanly:

I want to be able to make devices which have tight feedback loops and more complex on-board algorithms

What I really want is e.g. a light sensor controlling lightbulbs. Here, I want the lightbulbs changing almost continuously by almost imperceptible amounts, things like Kalman filters, and similar, to keep a fixed light level and light temperature based on time-of-day.

I'd like to have my air filters, ventilation, heating, humidification, dehumidification, and cooling continuously controlled such that:

1) All run at the right level continuously to keep environmentals and power optimized.

2) Ventilation reduces CO2 / TVOC levels, but increase PM2.5 levels and lets in external temperature

3) Cooling / heating / ventilation impact humidity in complex ways

4) Space heaters cost a lot more than baseline heating, but are sometimes necessary on very cold days

5) This is all less important when I'm not home, and some things change. When I'm home, I want liveable humidity. When I'm not, I want to minimize humidity.

... and so on.

(A second thing I want is ESPHome to allow me to make Zigbee, rather than just wifi, devices)

Thank you! I've rarely been as impressed by how well software works. Flashing, compiling, logging and OTA updates were always a PITA and with ESPHome it's a breeze. Logging over wifi feels like it shouldn't be that simple. I've created a mini IR receiver / transmitter to control my sound system with my TV remote. It was super simple to set up, and the integration with Home Assistant is great!

I want to connect a temperature sensor to an esp, and trigger a radiator valve based in temperature range.

Valves are mostly zigbee. Can I somehow control one with ESPHome without Home Assistant or zigbee2mqtt?

I want to understand if I can avoid adding a full blown Linux server into the equation.

I’ve been using Home Assistant for about 3 years now, and talk about it to pretty much anyone who will listen. Thanks for keeping home automation open and focused on the users!

Are you not concerned the foundation will ever work against your interests?

First of all many thanks for helping to maintain such a great project!

The feedback I have right now is that for the ESP32-C3 chip, provisioning over USB (Improv_serial) is not supported. So then the only option is to do provisioning over BLE if you want to get the "Made for ESPHome" certification.

However, this blew up our partition size from 1.2 MB to 1.9 MB and basically prevented us to add any further code and we got stuck there (we now develop a native HA integration).

So my feedback would be to try and reduce the overhead for the provisioning.

ESPHome is awesome. Any chance you can get MQTT running on RP2040W?

It would be great to support more PoE devices and Ethernet-based provisioning. And also alternative wired buses, such as BACNET or a generic RS-485.

The other axis: Zigbee devices and battery power. ESPs can be used with batteries, but right now it's not a great fit.

And the last feature: better reuse support for custom devices. E.g. if I have 20 similar custom devices.

If my understanding is correct, ESPHome need to be re-compiled and uploaded every time the config yaml is changed. Is it possible to separate the binary and the config so that for some config changes, there is no need to re-compile and upload the binary? Thanks.

Question: On a typical ESPHome device, reporting temperature (say every 15 minutes) via wireless to HomeAssistant, what battery life is possible ?

You need to update your homepage, it still says it's owned by Nabu Casa at the bottom of the sidebar :).

Nothing but respect and gratitude for ESPhome.

I do have a question though, is there a way to use modbus-TCP with ESPhome?

I already got my ESP gadgets to tinker, what's missing is the time. It's super fun, and looking so forward for it, but my to-do list cannot give me a break. Great job what you guys are doing!

Same here, plus a dozen or so random ESP32 variants just sitting in my electronics parts box because they're so cheap. It's incredibly freeing to just have all that hardware available at arms reach whenever you have an idea. They're surprisingly reliable and with modules like the sprinkler controller, they can be programmed to be independent so that they keep running as long as they have power. It took me months to realize that HomeAssistant microSD card had failed last time because all of my hydroponics gear just kept running.

By far the biggest time consumer has been wiring them up to DC/DC converters to drive relays in a waterproof Sockitbox. Another really useful part to keep around are wire terminal breakout boards: https://www.amazon.com/whiteeeen-Development-Expansion-ESP-W...

Also CloudFree is great for off the shelf IoT parts that can be reprogrammed with ESPHome: https://cloudfree.shop/

Now you MUST share more details on the hardware (case, power etc) and process you followed for all of those devices.

How do you power them? I've used ESPHome previously to scrape my solar analytics for consumption in Home Assistant using $3 Wittycloud ESP8266's. But as yet I haven't found an elegant solution for powering them other than using a USB adapter. It would be nice to find an elegant battery solution for outside sensors.

I agree with everything here, except the $10 of hardware.

You must be running some very fancy chips!

For extra savings the ESP8266 might be as low as $4us. It really is amazing.

Could you recommend a good component for security purposes? Like if someone enters my flat without breaking in (I rent). The docs list a bunch of options... do I go for motion & presence or binary presence detector? Which sensor is better (and most cost effective)?

How do you monitor your rain tanks? I tried ultra sonic sensors but they invariably oxidize.

can you share details of the weather station please? ive been looking into gathering wind data on the cheap...

If you have a 3D printer, you can create stuff that passes my WAF.

Apollo does a decent job making their stuff more innocuous. https://apolloautomation.com/products/sensor-stand?pr_prod_s...

For things that need to be stand-alone I'd first check if there's an existing off-the-shelf option first which generally would be more cost-effective to buy and look better than anything I could make myself.

For temp sensors specifically I generally just go with whatever off-the-shelf stuff is supported by this firmware: https://github.com/pvvx/ATC_MiThermometer - as a bonus they can run on battery for a year or more.

I can recommend Tupperware containers. Come in all shapes and sizes and really cheap. If you get one with a glass bowl or transparent plastic you can even look inside without components getting dirty. When mounting to a wall screw your boards onto the inside of the lid and then the lid onto the wall. With this you can access it easily by removing the container from the lid. Only downside is that they can look ugly when in plain sight.

I 3D print enclosures for my projects. Usually I find an already designed one on Thingiverse that fits close enough. If you're using common components you're likely to find an exact match.

M5stack is the way to go here

> How do I monitor whether the contacts are closed or open? I assume with a GPIO pin, but I’ve never been able to google this question and find anything of use.

Without making assumptions about the microcontroller used, attach ground to one of the contacts, then attach a GPIO pin, the other contact, a 10k resistor (or 100k), and VCC together in series. The microcontroller should periodically read the GPIO pin. If it reads high, the contact is open and the alarm is not sounding; if it reads low then the contact is closed and the alarm is sounding.

The GPIO / contact / resistor / VCC arrangement acts to pull up that side of the circuit to the high logic level, and the resistor will limit the current that flows whenever the contacts close. If your microcontroller has an internal pull-up configuration for GPIO pins, you may be able to attach the pin directly to the contact without the extra hardware. (Conversely, if it has a pull-down configuration you can reverse things, attach VCC to the contact and the GPIO directly to the other. Read your microcontroller's documentation for available features and any current limitations.)

I use an ultrasonic sensor and ESPHome to monitor the water level in my sump pit. Depending on what you want out of your septic tank monitoring, this may be a useful option.

ESPHome is a good start, as it provides a great framework for layering components together. For example, you could assemble what you want out of:

* The display component that handles drawing into a grid of pixels (https://esphome.io/components/display/)

* The text renderer

* addressable_light platform (https://esphome.io/components/display/addressable_light) to create a display matrix on top of an addressable LED driver (https://esphome.io/components/light/neopixelbus)

* An inexpensive 8x32 LED panel (https://www.google.com/search?q=8x32+ws2812b)

* You can make multiples of these, or chain the panels together, for more space

Of course, rather than reinventing any wheels, you can follow guides like https://community.home-assistant.io/t/led-matrix-with-esphom...

There's not a lot of soldering needed, especially if you go the route of repurposing existing hardware like an Ulanzi. It's mostly about making the right data connections and providing the right power.

Since you're (seemingly) already familiar with Arduino, just use that as your framework. You can program the ESP32 in Arduino and access any library you're familiar with as well as handle Wifi.

You can buy an RGB matrix on Adafruit and they sell esp32 boards that can drive them directly,so it's essentially plug and play, no hardware knowledge necessary.

If you prefer to DIY but still need some guidance, check out this project that documents both hardware and software to achieve something similar to what you want to do (cool looking wifi-connected text display):

https://github.com/BlueAndi/esp-rgb-led-matrix

> I don't use this, personally, but it strikes me as a fantastic idea. I made a sensor board and wrote my own firmware for it, maybe I'll see if I can easily configure ESPhome to run on it.

I've done pretty much the same, but last I looked there were very few resources (other than reading the code for the ESPHome project) to help on creating custom firmware for a new board with multiple sensors. It seemed easier and faster to simply write the firmware to talk to a simple backend.

I'm also curious about how they get the code for esp32 devices to fit: on a device with 4MB flash, you effectively have a 1MB program limit if you want OTA (which you do). A simple program that does nothing but make calls to the libraries for GPIO, ADC, UART, Wifi, https, https server, interrupts, FreeRTOS, mqtt, nvs, chip info, logging, OTA and functions in the standard library (scanf alone uses 30kb) already takes you over the 1MB limit.

Compiling with all the logging turned off can get you a roughly 800kb program, which is still close to the limits considering that doesn't include program logic.

I'll have to look at this again when I next require some remote monitoring thing.

The web interface has an 'update all' button thats just as convenient. I find if theres ones i want to not update i just temp break their yaml file with an unexpected keyword and it fails to compile and then update.

Maybe fewer bugs and need to make changes with this?

I have a fair number of esp devices with temp probes around the house, and I’ve been meaning to switch to esp home so I have less code to maintain

You should give it a try. ESPHome is super convenient. Especially the fact that you can flash them from a browser initially and over the air after that

This is coming in the next release.

Use something like an Aube RC840T-240; it generates an isolated 24vac supply and has an isolated normally-open 24vac input for closing the contactor. Using anything else is liable to cause life-threatening spiciness if something goes wrong.

I use one for my addition's electric baseboard heat, and control it with a standard dry contact thermostat, but you could easily use a mosfet or relay controlled by an ESP32 or similar instead.

Some completele unrelated nitpick: you wrote "220v".

As a rule of thumb: any physical unit derived from a real persons name is not written in lower case. In this case, the unit honors https://en.wikipedia.org/wiki/Alessandro_Volta and so it's written "220 V" instead.

Applies to other units based on surnames, like Heinrich Hertz' "Hz", Lord Kelvin's "K", James Watt's "W", André-Marie_Ampère's "A" and so on.

Use a solid state relay with esphome.

https://en.wikipedia.org/wiki/Solid-state_relay

How do you control the heaters now? Can you use a 5/12v control wire?

Solid state relay is probably a bad idea with all the extra heat-sinking, extra cost, and chance of getting counterfeits.

I do this with ESPHome & a J115F21C12VDCS.9 relay (note only the NO side is rated for 40A resistive): https://i.imgur.com/MqqOkoY.png

Choose any of the temperature sensors here for air temperature sensing: https://esphome.io/

Configuration is so easy. For the sensor, just copy the config from here, for example: https://esphome.io/components/sensor/bme280. Add a gpio output (https://esphome.io/components/output/gpio) and a bang-bang climate controller (https://esphome.io/components/climate/bang_bang.html)

Here's the kicad footprint for that relay (Relay_SPDT_CIT-J115F2.kicad_mod) if you need it:

    (module Relay_SPDT_CIT-J115F2 (layer F.Cu) (tedit 611825E5)
      (descr https://www.citrelay.com/Catalog%20Pages/RelayCatalog/J115F2.pdf)
      (tags "Relay CIT J115F2 SPDT")
      (fp_text reference REF** (at 12.1666 -15.2) (layer F.SilkS)
        (effects (font (size 1 1) (thickness 0.15)))
      )
      (fp_text value Relay_SPDT_CIT-J115F2 (at 18.542 13.9 180) (layer F.Fab)
        (effects (font (size 1 1) (thickness 0.15)))
      )
      (fp_line (start -3.2 -14.1) (end 27.08 -14.1) (layer F.Fab) (width 0.1))
      (fp_line (start -3.96 -13.34) (end -3.96 11.94) (layer F.Fab) (width 0.1))
      (fp_line (start 27.84 -13.34) (end 27.84 11.94) (layer F.Fab) (width 0.1))
      (fp_line (start -3.2 12.7) (end 27.08 12.7) (layer F.Fab) (width 0.1))
      (fp_line (start -4.3 -14.3) (end 28.09 -14.3) (layer F.CrtYd) (width 0.05))
      (fp_line (start -4.3 -14.3) (end -4.3 12.95) (layer F.CrtYd) (width 0.05))
      (fp_line (start 28.09 -14.3) (end 28.09 12.95) (layer F.CrtYd) (width 0.05))
      (fp_line (start -4.3 12.95) (end 28.09 12.95) (layer F.CrtYd) (width 0.05))
      (fp_line (start 17.74 1.778) (end 19.304 1.778) (layer F.SilkS) (width 0.12))
      (fp_line (start 23.876 1.778) (end 25.34 1.778) (layer F.SilkS) (width 0.12))
      (fp_line (start 25.34 1.778) (end 25.34 6.604) (layer F.SilkS) (width 0.12))
      (fp_line (start 21.59 -8.9) (end 17.526 -8.9) (layer F.SilkS) (width 0.12))
      (fp_line (start 21.59 -2.54) (end 21.59 -8.9) (layer F.SilkS) (width 0.12))
      (fp_line (start 21.59 -2.54) (end 22.8092 2.032) (layer F.SilkS) (width 0.12))
      (fp_line (start 17.74 6.604) (end 17.74 1.778) (layer F.SilkS) (width 0.12))
      (fp_line (start 22.86 1.778) (end 23.876 1.016) (layer F.SilkS) (width 0.12))
      (fp_line (start 23.876 2.54) (end 22.86 1.778) (layer F.SilkS) (width 0.12))
      (fp_line (start 20.32 1.778) (end 19.304 1.016) (layer F.SilkS) (width 0.12))
      (fp_line (start 19.304 2.54) (end 20.32 1.778) (layer F.SilkS) (width 0.12))
      (fp_line (start 23.876 2.54) (end 23.876 1.016) (layer F.SilkS) (width 0.12))
      (fp_line (start 19.304 1.016) (end 19.304 2.54) (layer F.SilkS) (width 0.12))
      (fp_circle (center 21.59 -2.54) (end 21.59 -2.413) (layer F.SilkS) (width 0.12))
      (fp_line (start 4.064 -5.1054) (end 5.334 -5.1054) (layer F.SilkS) (width 0.12))
      (fp_line (start 5.334 5.1054) (end 4.064 5.1054) (layer F.SilkS) (width 0.12))
      (fp_line (start 5.334002 5.105397) (end 5.334002 1.777997) (layer F.SilkS) (width 0.12))
      (fp_line (start 5.334 -1.778) (end 5.334 -5.1054) (layer F.SilkS) (width 0.12))
      (fp_line (start -3.2 12.81) (end 27.08 12.81) (layer F.SilkS) (width 0.12))
      (fp_line (start 27.95 -13.34) (end 27.95 11.94) (layer F.SilkS) (width 0.12))
      (fp_line (start -4.07 -13.34) (end -4.07 11.94) (layer F.SilkS) (width 0.12))
      (fp_line (start -3.2 -14.21) (end 27.08 -14.21) (layer F.SilkS) (width 0.12))
      (fp_arc (start 27.08 -13.34) (end 27.84 -13.34) (angle -90) (layer F.Fab) (width 0.1))
      (fp_arc (start 27.08 11.94) (end 27.08 12.7) (angle -90) (layer F.Fab) (width 0.1))
      (fp_arc (start -3.2 11.94) (end -3.96 11.94) (angle -90) (layer F.Fab) (width 0.1))
      (fp_arc (start -3.2 -13.34) (end -3.2 -14.1) (angle -90) (layer F.Fab) (width 0.1))
      (fp_arc (start 5.334001 -0.381001) (end 5.842 -0.762001) (angle -286.3) (layer F.SilkS) (width 0.12))
      (fp_arc (start 5.334002 0.380998) (end 5.842001 -0.000002) (angle -286.3) (layer F.SilkS) (width 0.12))
      (fp_arc (start 5.334 -1.143) (end 5.334 -1.778) (angle -233.1) (layer F.SilkS) (width 0.12))
      (fp_arc (start 5.334002 1.142997) (end 5.334002 1.777997) (angle 233.1) (layer F.SilkS) (width 0.12))
      (fp_text user %R (at 12.3952 0) (layer F.Fab)
        (effects (font (size 1 1) (thickness 0.15)))
      )
      (fp_arc (start -3.2 -13.34) (end -3.2 -14.21) (angle -90) (layer F.SilkS) (width 0.12))
      (fp_arc (start -3.2 11.94) (end -4.07 11.94) (angle -90) (layer F.SilkS) (width 0.12))
      (fp_arc (start 27.08 -13.34) (end 27.95 -13.34) (angle -90) (layer F.SilkS) (width 0.12))
      (fp_arc (start 27.08 11.94) (end 27.08 12.81) (angle -90) (layer F.SilkS) (width 0.12))
      (pad A2 thru_hole circle (at 2.54 5.1 180) (size 2 2) (drill 1.1) (layers *.Cu *.Mask))
      (pad 14 thru_hole circle (at 17.74 8.9 180) (size 4 4) (drill 2.1) (layers *.Cu *.Mask))
      (pad 12 thru_hole circle (at 25.34 8.9 180) (size 4 4) (drill 2.1) (layers *.Cu *.Mask))
      (pad 11 thru_hole circle (at 15.2 -8.9 180) (size 4 4) (drill 2.1) (layers *.Cu *.Mask))
      (pad A1 thru_hole roundrect (at 2.54 -5.1 180) (size 2 2) (drill 1.1) (layers *.Cu *.Mask) (roundrect_rratio 0.25))
      (model ${KISYS3DMOD}/Relay_THT.3dshapes/Relay_SPDT_RAYEX-L90S.wrl
        (at (xyz 0 0 0))
        (scale (xyz 1 1 1))
        (rotate (xyz 0 0 0))
      )
    )

It is a lot more configurable than Tasmota, but a lot harder to do it.

The only problems I've had with AliExpress is the anxiety of choosing a seller where a cheaper one exists. All the hardware I've ever bought has been exactly what I ordered.

I buy stuff from them all the time. They are Amazon with longer shipping times and better prices.

It's harder to return stuff, sure, but just don't buy anything like that there.

I've never been ripped off by them. One time I bought some stuff and it wasn't being shipped so I cancelled my order and got my money back.

I've had good luck buying from the Wemos and Lilygo official stores on AX. Have had no problems in many years and dozens of orders. Other sellers are a gamble.

Not to be pedantic but it's ESPhome not ESPinthemiddleofnowhere. There are other solutions for far away sensors.

The Olimux ESP32-POE / wESP32 boards have a proper ethernet connection and PoE support. Means you don't need to worry about wifi coverage or power as long as you can get an ethernet cable to it - and those are cheap & easy to find in ludicrous lengths for outdoor use.

And the best part is that it allows you to write logic in C(++) if you want.

I tried Tasmota first but struggled with trying to get the rules to handle my slightly complex logic. Which was that when a water level sensor triggered, run a pump 15 seconds, wait 5 mins, run 15 sec and repeat for x times. But with the catch that if the sensor triggered before the run was done, it should ignore that.

After reflashing esphome I got it done in a few minutes in C.

I have one over complicated in floor heater that requires 2 signals to control, one for opening radiator valve and second to enable fan to blow air through it. there is only few thermostats dedicated for such setup that are extremely expensive and I decided to make my own that is also better. i have 2 temperature sensors connected, one to monitor room temperature and the second touching radiator inside, then I'm able to open valve when room temperature is below threshold and wait until radiator is hot enough and we are trying to heat for few minutes (without fan this will also work but less efficiently, but will be silent) then when temperature is reached I close valve and keep fans on until radiator cools down.

I also have temperature reported to home assistant where I have pyscript automation that controls AC based on multiple temperature sensors, open window sensors, humidity, presence, time, etc to most efficiently cool down my apartment

if you need to get signal on a wire, you can output it from the same device, from other esphome device or through home assistant using integration.

That's what I do at home. I have little Xiaomi LYWSD002MMC and LYWSD003MMC devices (the latter with custom firmware - pvvx) and my radiators are switched on or off (via their pilot wire) by an ESP device, using a few rules to lower the temperature when nobody's there. It works much better than the radiator's own thermostat.

I control my devices (I have a lot more than just for the radiators) through a kind of interface that I wrote myself (PHP and only very few, reliable dependencies) because I hate maintaining Home Assistant.

I have 7 Mitsubishi heat pump head units being controlled using ESPHome running on D1 mini clones (ESP8266). The D1 mini clones are powered by and interface with the head units with Mitsubishi's CN105, which is just 5 volt UART.

The total cost was maybe $30 of parts on AliExpress.

I use 433Mhz Acurite temperature sensors with a software defined radio (rtl433) running on my Home Assistant box to have remote temperature sensing. The 433MHz sensors are cheap, have good range, and have excellent battery life.

Actually I did exactly that :) I use ESPHome to control a gas boiler which heats my home. It's not without problems and required a lot of tinkering, but after the initial phase it required very little maintenance throughout the winter. This year I plan on adding an ability to control AC. https://news.ycombinator.com/item?id=40017176

If your HVAC supports OpenTherm, check out https://github.com/Alexwijn/SAT

You can have your thermostat in home assistant and make your HVAC run as efficiently as possible at the same time.

See https://news.ycombinator.com/item?id=40052824

I use this one and it works great: https://github.com/kbx81/ClimateSprinklerController

I'm baffled at how shallow some trigger happy downvoters can be. This was a legit question; I live in a reinforced concrete house surrounded by H shaped girders all around and using a star type topology with all external sensors talking to a AP would require placing one of them on each side of the house, plus the three I already have on the inside, because doing otherwise WiFi communications would be next to impossible.

Tasmota is firmware you can configure on-device[0] while ESPHome is a YAML-driven construction kit for compiling firmware specific to a device's configuration. Every change to the YAML is a compile-and-flash cycle.

Tasmota is only for Espressif platforms. ESPHome has expanded to support BK72xx, RTL87xx, and the Pico W, but good luck figuring out what's actually implemented on those platforms.

ESPHome supports more sensors/peripherals. Some ESPHome Components[1] simplify the combination of multiple sensors and peripherals to accomplish a task to basic YAML (check out the different Cover components).

Tasmota on ESP32 has an embedded scripting engine with REPL (Berry). ESPHome is... complicated[2]. Triggers, Actions, and Conditions can accomplish very simple automations in pure YAML. For more complicated tasks, you'll be writing C/C++ code.

ESPHome releases frequently. If you're using it with Home Assistant, it will constantly nag you to update ESPHome and all of your ESPHome devices. Tasmota releases every few months. Tasmota suggests not upgrading a device unless you have a particular need[3].

[0] Pre-compiled Tasmota binaries work for most purposes, but there are situations where you might need to compile your own to support less common features or devices.

[1] https://esphome.io/components/

[2] https://esphome.io/guides/automations

[3] https://tasmota.github.io/docs/Upgrading/