What have you built with ESPHome, ESP8266 or similar hardware

I've built a bunch of things:

A snapcast client, which can play audio synchronized on multiple rooms

https://github.com/DavidVentura/esp-snapcast

An stratum-1 NTP _server_ (read: gets its time from GPS), and displays time with unreasonable precision (not necessarily accuracy!)

https://github.com/DavidVentura/esp-ntp

A few HUB75 signs which display public transport status (the public transport bits are not published anywhere yet)

https://github.com/DavidVentura/hub75-esp

An "on-air" sign that turns on/off if my wife or I join a meeting (based on camera/mic usage, for Linux and Mac)

https://github.com/DavidVentura/on-air

A purely decorative sign that looks like a pixelated fire

https://github.com/DavidVentura/matrix-fire

A kindle-controlled bedside lamp (just mqtt, but functionality is priceless - blogpost is unrelated but it's the only video I've got)

https://blog.davidv.dev/building-an-mqtt-client-for-the-kind...

An HDMI switcher (just a GPIO toggle) & a full-house blinds controller (just a relay hooked to the central, manual system)

https://blog.davidv.dev/extending-the-capabilities-of-dumb-d...

I’ve built a small scale ‘flat’ that is meant to act as a ‘living’ object that is a bed side companion for sick children that are lying in a hospital.

The idea is that you give a certain floor to family or friends so that they can control the lights (and color). The child can see if parents, grandparents or friends are home or not (based on a schedule or manual action). It gives a sense of reassurance and closeness of the relatives. Also very fun to see a living object next to your bed.

See it here: https://imgur.com/gallery/4ZOYdH5 And here (colors): https://imgur.com/gallery/z0yZJ7d

The hardware is a Atom Lite from M5Stack (see: https://shop.m5stack.com/products/atom-lite-esp32-developmen...) and a led stripe with addressable leds.

The software on the atom is micropython and the neopixel module. It connects to a webapp (through wifi) and listens to a JSON endpoint that gives the states of the leds (aka floors).

The webapp is a django app with a main user for the flat and he or she can invite others to control certain floors. All mobile friendly (no native app).

We have 4 live and deployed flats and are in the process of making more for our local hospitals.

The flat (wood) is custom made and pretty labour intensive.

A very fun project and learned a lot about hardware (and the deployment) coming from a saas background.

I've built tons of things. Most usefully, I built presence/motion/light/temperature sensors for my home, along with IR transmitter so I can control my TV/AC. They're about the size of two matchboxes, they cost about $10 each and they're amazing for my home automation:

https://gitlab.com/stavros/sensor-board/

I've built cat toys for my blind cat, toy planes, a CNC, a cat feeder, a back-scratching robot, and more stuff that I can't remember. I love the ESP8266.

Also, an e-ink display that shows my calendar:

https://www.stavros.io/posts/making-the-timeframe/

A house with a tiny person living in it:

https://www.youtube.com/watch?v=1RUqTN-7_gU

A way to project images in mid-air, for long exposure photography:

https://www.stavros.io/posts/behold-ledonardo/

A button that I can press to get food:

https://www.stavros.io/posts/emergency-food-button/

A drone that blows bubbles:

https://www.youtube.com/watch?v=xk99zrlAp9U

A toy bus that shows you when the next actual bus will come:

https://www.stavros.io/posts/bus-stop-bus/

A rotary mobile phone:

https://www.youtube.com/watch?v=fSkdWQswpc8

An alarm clock with the weather so I know whether it's worth waking up for tennis:

https://www.stavros.io/posts/do-not-be-alarmed-clock/

My GPT-powered e-Ink newspaper uses an esp32: https://imgur.com/a/NoTr8XX

I have forty dutch buckets in four zones with cucumbers, tomatoes, eggplants, and peppers hooked up to two thirty gallon reservoirs and four ten gallon drainage tanks via a series of pumps and valves (using ESPhome sprinkler controller module). The first reservoir is pure RO water fed by a valve connected to the tap and the second is connected to a series of peristaltic pumps and sensors. They pump pH up and down as well as nutrients from concentrate into the reservoir and the concentrate bottles sit on DIY magnetic stirrers that run daily to prevent precipitation. Six ESP32s in waterproof Sockitboxes control all of this via a bunch of relays. The pH controller ESP32 gets mqtt messages via Atlas Scientific pH sensor while most of the other pumps are either on a schedule or respond to mqtt messages from Vegetronix water level sensors. I also have several Vegetronix liquid flow sensors that are hooked up to an ESP32 with solar and a battery that acts as a watchdog and alerts me via text message and indoor alarm if water doesnt flow for 12 or more hours.

The outdoor tap is also hooked up via valve to a drip irrigation loop that waters some roses and pots full of herbs, cabbage, etc.

The indoor setup is similar but much smaller with metal halide lamp and LEDs in a grow tent for out of season growing and seedlings. Protip: never put vining plants like cucumbers in a grow tent. Its a huge pain.

A set of cheap temperature sensors out of D1 minis that report data over MQTT. Just a simple piece of code, not using any fancy stuff like ESPHome or Tasmota as there was no need for it. In the end they are supposed to guide the gas boiler heating over OpenTherm, but haven't done that part yet.

I've also made an e-ink calendar with bin collection schedule with Inkplate (ESP32) [0] and now I'm making a Frets on Fire-compatible rhythm game based on ESP32-S3 [1] (initially made for the CCCamp's flow3r badge, now designing a simplified board for it [2][3])

[0] https://social.librem.one/@dos/106014037294005493

[1] https://social.librem.one/@dos/111478238181935805

[2] https://social.librem.one/@dos/112008114803722974

[3] https://social.librem.one/@dos/112179746918615110

Last year I built a balcony watering system using an 8x ESP32 relay system from Lilygo, paired with mini submersible pumps. To monitor plant health, I integrated MiFlora sensors over BLE. Managing minimum soil moisture and pump duration has been 'configured' by hosting a configuration files on Pastebin.

This year, I'm taking it a step further by developing a management front-end. Instead of the hacker GUI using Pastebin, I'm implementing an extra M5 Atom running MicroPython with a web GUI. This interface allows me to configure the sensors, visualize sensor data with charts, and send notifications via NTFY to my phone.

I am considering open-sourcing the project.

https://www.lilygo.cc/products/t-relay-5v-8-channel-relay

https://de.aliexpress.com/item/1005006100423471.html.

https://shop.m5stack.com/products/atoms3-lite-esp32s3-dev-ki...

I built a little robot that props open a door when the av cabinet gets too hot. It has a temperature sensor, two fans and a linear actuator. It even has a small webui so I can manually enable/disable cooling. Been working for several years.

My first contact with ESPHome revived an old ESP32 sunrise alarm clock project of mine whose hardware was all complete but software was half-baked shoddy C++. It has adjustable color temperature (to wake me up with blue light) and can play arbitrary MP3s as an alarm.

After discovering this power I also threw together an ESP32 timelapse device that plugs into the remote shutter port on my DSLR, configurable over Home Assistant of course. Was thinking of using the camera on the ESP32-CAM to take automatic photos of planes (computer vision??), but haven't gotten round to that yet.

ESPHome really is great for replacing the code I can't be bothered to write - it's hard to do after just having put together the hardware. The next project on the list is an environmental sensor and curtain opener for my room, using an ESP8266 and RS-232 controlled servo module (what I have laying around).

A remote control for a ham radio antenna rotator: https://dk1mi.radio/remote-control-hygain-antenna-rotator/

I put together an esp32 + accelerometer in a little 3d printed box. Made two sets and taped one of each on my washer and dryer, now they detect the start and end of a cycle and send me a notification through home assistant. The tablet in the kitchen get a notification too and makes a special sound when the clothes are done!

I want to build a house-positioning system, but time, energy, and skill are lacking.

My wife, who has pretty extreme ADD, loses stuff like her wallet, keys, etc. We have Tiles on most stuff that gets lost, but sometimes the volume of the alert is lacking. I'd like something that uses multiple ESP32 or Pi receivers in known locations to triangulate the position of the bluetooth beacon in 3D space.

It's probably a bad idea, there might not be accurate enough timings or data to pinpoint the location. I've read somewhere that UWB will be much better at this.

EDIT: Another project idea: Sensor Light Switches. Would add sensors like occupancy, noise, pressure, temp, etc etc to the standard light switch plate/box. Then have that lovely data slurped up by something pretty to display it all.

https://github.com/antirez/Freakwan

I once built an Arduino project that monitored one room to an sd card while we were on holidays. That allowed me (in principle) to know if the heating could be lowered a bit more during absence. The results were not conclusive.

Another thingy tried to determine where the mouse that sometimes came into another room came from, by using infrared distance sensors. Never caught anything.

What did work was a two op fm synth with midi in and audio out. I was satisfied when it worked, so I didn't go all the way of making a 4 or 6 op version with pots and buttons (or one of those horrible deep menu systems).

So nothing practical. Just toying around, trying to get a bit of knowledge about how things work and having fun at the same time.

Hi, Ive made an e-paper wrist watch:

https://github.com/multipolygon/esphome-for-watchy/blob/main...

and an RFID-card mp3-player music box for a toddler:

https://blog22.multipolygon.net/rfid-music-box.html

This is sort of on topic, except I haven’t finished.

I’ve been working on making a magnetic stirrer with an integrated scale and heating. It isn’t specific to esp or esphome stuff, but I happen to be using an esp32 to power it.

I wanted to buy a stirrer and discovered even the most basic equipment is extremely expensive. Once you add heat, let alone heat control that’s accurate with a digital readout, or a scale, prices are in the multiple thousands.

I know the one I make isn’t going to be as precise or accurate, the build quality won’t be as good, but it’ll be good enough for my purposes.

I’ve found very cheap models online, but oddly a lot of them can’t be shipped here and not surprisingly, the reviews are reliably terrible anyways.

I’ve been having a hard time figuring out the stirring part, ironically. The heat and scale part struck me as the trickiest initially, but I’m not smart enough to know how to protect the magnets from the heat.

My intuition at this point is that maybe I can accomplish this using electromagnets since they won’t be permanently damaged by heat, but I have no idea how to program this to work with a stirrer at a distance. It might be the completely wrong path to take, too.

In any case it’ll be worth it. I’ve been wanting a proper stirrer for quite a while, and the one I’m using at the moment is a computer fan hooked up to a potentiometer and an nmos, glued into a 3d printed platform.

I built a CO2 sensor that activates a fan in my office room to pull in fresh air if the CO2 levels go above 700ppm

Don't have a git repo or pictures up; but I've built:

1) a fridge door monitoring system. We have a fridge in our garage that doesn't see frequent traffic, and it does NOT have an alarm on the door if it's left open too long. an esp8266 Watches 2 reed switches and transmits the status to home assistant. I 3d-Printed a case for the MCU + 2 holders for the reed switches (for the freezer + fridge)

2) A passive LIDAR based sensor for watching our oil burner's tank's gauge. I have to finish this up into home assistant, but I've been collecting the position into a log file. I 3d-printed another cylinder that fits over the transparent gauge, and positions the sensor in just the right place so it can reflect over the opaque float inside the sensor. Even though it's external, this one I have to be careful so the main ESP8266 is a bit aways from the sensor + tank, and I should add more protection to the lines going to the sensor. Electronic devices near fuel can get ... spicey if you are not careful.

Does a raspberry zero count? I replaced the dubiously secure Chinese box that came with my solar panels with a home grown energy monitoring solution, hooked up to HomeAssistant. And I made a full color eInk photo frame that displays seasonally appropriate, generated images from a stable diffusion like-algo.

I made my standing desk "smart": https://community.home-assistant.io/t/desky-standing-desk-es...

I built a toilet occupancy light for the office. We had a long office with a single toilet, so built a battery powered closed-door detector on one side, and a mains-powered sign that indicated whether the toilet was free or not.

Very reliable, ESPHome was never an issue. This was circa 2018.

I have three strings of ws2812b LEDs on my kitchen controlled by two ESP8266s with PIR sensors, providing various under-cupboard lighting. It sounds over-engineered and was quite a lot of work to set up, but I chose to 'roll my own' because I couldn't find anything pre-made with the right combination of features without being too bulky. (Honestly, I'd happily have bought someone's product instead.)

A nice bonus is that I can program different patterns to suit moods or events. (For example, my partner requested scrolling red and green stripes for Christmas.)

(Tangent: pretty sure that despite having followed online guidance very closely, the power supplies I bought were vastly over-specced.)

This.

https://wandel.ca/pic.cgi?8a39449d

Being a bit old school and also unskilled at writing smartphone apps, wanted a universal control box for all kinds of homemade IOT things. It's just a dumb terminal that sends shaft encoder rotates/clicks to a server, and displays pixels sent to it. Based on an ESP-03 in a near ridiculous effort to use the minimum microcontroller to make this work. That also dates it. If I made this now it would have a better LCD than one of those old Nokia flip-phone ones.

The controller for this: https://www.secretbatcave.co.uk/projects/stock-ticker-machin... is an esp of somesort (I think 8266)

I used ESPhome last month to measure how warm/cold the fish pond was (it was cold). That was a simple breadboard/Dallas one wire thing: https://esphome.io/components/sensor/dallas.html

There's something called a "Wandering Hour Clock" that, well, displays the current time in an interesting way. When I ran across a 3d printable version online, I knew I had to build one. A picture (or two) is worth a thousand words: https://www.printables.com/model/327198-improved-wandering-h...

Someone upgraded that project to use a stepper motor controlled with an ESP32: https://www.printables.com/model/688154-mounting-plate-and-e...

Of course once you have an ESP32, you might as well put the clock on the network and get time over NTP. So the above project includes that.

I added some features, such as fractional time zones, and being able to set the time zone and DST from the web interface rather than in code. My software changes have been upstreamed, so the above project now has them. I also added a few small 3d printable covers to make the back of the clock look a little cleaner: https://www.printables.com/model/688154-mounting-plate-and-e...

I built a weather dashboard using an M5Paper from M5Stack. The M5Paper has an E-ink touch display, is the size of a small smart phone, and only needs to be charged every week or so.

https://speechcode.com/blog/weather-dashboard/

I feel sheepish mentioning this project because there are so, so many weather displays like this. But this is mine, and not only was it fun to put together, but I use it every day.

I built a series of iot sensors and actuators for home heating. All based around the same modular firmware and hardware concept [0].

We have 3 of those boards scattered around the house and one sitting outside reporting external temperature, humidity, pressure and air quality. The 3 boards inside measure the same values as well but also control the heating system.

Finally, all the data is sent to a raspberry pi over mqtt for logging. Data is presented over a web interface which also allows to set the desired temperature.

Oh, and also a clock with date and time synchronized over NTP showing the external temperature and humidity. Super useful to get dressed in the morning ;) [1]

[0] https://github.com/broken-giobbe/ceci [1] https://github.com/electricant/ESP8266_NTP_clock

Built an add on to my Pacman machine that “inserts coins” when I ask Siri to “Show me the money” :)

I tend to roll my own with rp-picos for no good reason other than they're easy.

1) Wattmeter for a toy solar installation - broadcasts a UDP packet every few seconds, which I then record into a staging JSON log that gets ingested into DuckDB.

2) Little pico-w wifi temperature sensor that feeds into the raspberry pi zero that controls my boiler.

Thread about the boiler: https://hachyderm.io/deck/@dave_andersen/111579107766689328

github with some really crappy rust code: https://github.com/dave-andersen/boiler

The boiler control is the fun one but it's not entirely embedded stuff. Runs a little control loop that turns down the boiler modulation based upon the difference between target and current temperature. Improves operating efficiency by a fair bit and reduces temperature swings. Makes me wish residential HVAC systems were more sophisticated - these are things any good industrial control system can do.

3) Made an "ok to wake" light for my son -- added a controllable LED strip to his clock with a pico-w in it that changes from orange to multicolored at 6:30am as a non-intrusive "yes, you can come bug your parents" signal.)

https://hachyderm.io/deck/@dave_andersen/112091315519210298

I use homeassistant, so the esphome integration makes esp32s priceless.

- integrated my projector via RS232 to esp32

- integrated my projector screen via IR module

- ir receiver lets me use an old tv remote as a universal whole house remote

- motion sensors everywhere so I never have to touch a light switch again

- several wled units for accent lighting, night lights etc

- built a laser maze with esp32s and light detectors for my kid's birthday.

- I've played around with BLE based room detection, but it's not really useful yet (or maybe ever).

I love em!

Brought an inactive home security system onto Home Assistant using the below repository, so I can track everything from smoke alarms to motion, doors, and windows. I swear there's a niche business opportunity in retrofitting all these deactivated systems!

https://github.com/taligentx/dscKeybusInterface

I setup an LED strip with an ESP8266 and ESPHome for my 3d printer enclosure. I recently took it apart and integrated it into my 3d printer itself, but planning to set it up again to light my figure collection instead.

I also built a set of inertial full body trackers for VR usage with them. Although they could use some redesigning, probably with lower power MCUs, current ones are a bit too large for my liking.

I built the controller for my wood gasification boiler, https://github.com/DusteDdk/boilerController

it sits in series with the regular controls, but allows me to start the fire and leave without needing to come back "after a while" to set the "turn off" temperature, it also fixes the issue of hysteresis where, after the furnace is empty of fuel, it will shut off due to cold air being drawn through, cooling the sensor enough to shut off, only to have the thermal mass of the boiler itself make the temperature rise above the turn-on threshold, which adds tens of power on/off cycles to the motor, on top of being annoying to listen to.

The wireless part is optional, but I use it to draw a temperature curve, so I can see when the right time to refuel is, if needed.

I turned a light-up Pac Ghost into an indicator lamp for my Uptime Kumar instances.

https://github.com/psitem/uptime-kuma-pacman-ghost-light

I've been working on a replacement controller for the Omlet automatic chicken coop door. They've recently released their own connected controller but given the shortcomings of the original I'm not sure I trust it to be reliable enough to leave my feathered friends unsupervised for days at a time.

Next in the queue is replacing my ATHOM garage door controller with my own that will add a second reed switch to detect that the door is fully open.

And I'm mulling over ways I could monitor the feed level in my chicken feeders. And maybe close them off at night to keep other critters out. But it's tricky because I don't want to replace what I have with a design that might be easier to automate, as they've held up well against the rain and I'm lazy.

I built an automated apparatus to convert water, yeast and starch into sanitizer in April/May of 2020.

I used ESP32s for individual sensing components (mostly temperature at various parts of the process but also a load cell for weight). I used the Tasmota firmware and tied them all together using MQTT over wifi. I drove it with node-red on a raspberry pi to build several PID loops and process controls and if I were to do anything similar again I would use the same architecture except I would add network booting for the ESP32s so I could swap them out as needed.

Screenshot from a node-red dashboard from very early in the process.

https://imgur.com/a/so7iZJX

I ended up with 7 temp sensors and two load cells running on four ESP32s. By the time I had it optimized my job was to swap containers out every time it said to replace container over a speaker.

As a joke, I built a jar that would call a phone number to inform them the status of the jar. Thing looked like a bomb.

I'm monitoring and automating my solar charge controllers, battery management systems and my inverter using 3 separate esp32 boards. 3 Victron chargers, 4 Chinese BMS boards with BLE serial connections, one MPP Solar hybrid inverter and some inductive choke energy monitoring interfaces.

I'm really not proud of any of this code, and it's mostly based on other people's work so not much original here.

https://github.com/20after4/esphome-energy-monitor/

Maybe useful as an example of a moderately complex setup and decently reusable components, for example in bms.yaml

That and some crappy C++ Graphics code to draw some parameters on the M5Stack's lcd.

I connected an ESP8266 via serial protocol to the extra programming pins on a QMK based keypad (https://www.crowdsupply.com/anavi-technology/anavi-macro-pad...) so that it can have layers that directly trigger actions via Home Assistant API.

Also use the Bee Motion ESP32-S3 (https://www.crowdsupply.com/smart-bee-designs/bee-motion-s3) for their PIR motion sensing and running other sensors around the house.

And I have an old Wemos D1 mini connected to my Arduino based smart garage door that helps automate things like lock/unlocking the front door or triggering other presence based actions.

I lived in an old apartment with a heater thats pilot light would regularly die. I connected a thermoprobe to an ESP8266, connected it to the heater. If it detected the pilot went out it would spam a Telegram chat that me and my roommate were in. Super cheap fix that saved me from waking up frozen.

I made a glowy box that takes up 1U in my homelab rack and represents my home internet reliability - an esp32c3 (risc-v, experimenting with the rust support) which pings 8.8.8.8 every minute and shows the past 30 minutes of results on a strip of 30 LEDs (green -> red for ping time, blue for errors)

Back during the pandemic, hardware-based contract tracers were an idea. I built one using the ESP32; see https://github.com/tbensky/npct. In a nutshell, everyone generates a (non-centralized) hash for themselves based on local entropy. This hash is set to the BLE name of the ESP32. Turn it on and throw it in your backpack as you go out. When two ESP32s pass by each other, they both log the other's BLE name (hence hash). Later on, hash logs could be inspected and uploaded to a central server so you can see who encountered who. Seems like there's still some (non-Covid) applications for this (but I can't think of any). Fun project. Learned a lot about Bluetooth.

I've used ESPHome to:

Control my garage doors (thanks ratgdo!) Control my front gate (already had gate controls, this just triggers open/close) Control various appliances (ESPHome can be installed on "smart plugs")

I definitely have additional things I'd like to do, but I've a dearth of time.

I have not built anything novel — just utilizing community projects have been a wonderful improvement at home: 1. Ratgdo for the garage door 2. Esphome EcoNet for my water heater 3. Off the shelf Sonoff switches for some holiday lighting.

All of this is tied with a bow via Home Assistant.

Controlling Mitsubishi mini split heat pumps instead of paying hundreds for Mitsubishis solution: https://github.com/geoffdavis/esphome-mitsubishiheatpump

Bluetooth repeaters - BLE to WiFI so I can use them in Home Assistant

Button Bot - SwitchBot alternative

Wifi Calling Bell - Relay control calling bell with auto shut-off

Cameras - Uses ESPEye and ESP32 Cam, low res, low latency and does NOT hang Standing Desk - Turns on and off linear actuators

Water controllers - Relays attached to solenoids to automate my plants drip-watering and turn on sprinklers

PIR Sensors - A bit noisy, still not satisfied with performance

RF Transmitter - To replay RF signals

RF Receiver - To receive RF signals

The BLE Repeater has been really useful as it has helped me make many BLE devices available in Home Assistant making automations easy. The nRF connect app has been really helpful to make this happen.

Hot Tub Wi-Fi remote controller from https://github.com/visualapproach/WiFi-remote-for-Bestway-La...

I reverse-engineered how my adjustable bed base works, then built (and sell) a hub for controlling it from Home Assistant. See https://blog.laplante.io/2019/01/11/reverse-engineering-the-... and https://www.tindie.com/products/cplaplante/temperbridge/

A few years ago I made a temperature/humidity/barometric pressure sensor.

https://www.tindie.com/products/arantius/wi_ther-wireless-th... https://arantius.com/wi-ther/

As per the manual, it's ESPHome compatible if you prefer that, but I'm semi proud of the built in functionality.

I have a very old rotary phone that you “dial” how bright to make the lights. esp8266 detects dial pulses, sends mqtt message to home assistant, home assistant sets zigbee can/recessed lights to requested setting

I made one of the prototypes of a shooting target for a wacky wheels-inspired buggy racing project with esp and a pressure sensor (bmp something) enclosed in a plastic tank. Had some fun shooting at it from a paintball gun and looking at the graphs, but real conditions were too noisy for the most mechanical prototypes. The project was abandoned. I believe I fried one esp due to the lack of electrical experience and burned few fingers. I also remember having some arduino in the loop, but can’t tell why (or if, tried few setups in process).

I have a power meter that sits in front of my kettle (that I also use as a teapot) that notifies me when the tea has finished brewing (i.e. when it finished boiling + a fixed delay).

I've built a bunch of things over the years, but currently I have my own gateway for cheap BLE sensors, and shipping data directly to InfluxDB: http://jpdias.me/iot/2022/10/03/a-not-so-smart-smart-home.ht...

A battery powered doorlock (pretty proud of that) https://www.youtube.com/watch?v=4-wtu9toda0

A video doorbell with display and fingerprint reader: https://www.youtube.com/watch?v=3w_xTNuditQ

Also smart meter readers, BLE Trackers... I just love it!

This is a simple temperature sensor that runs on four AAA batteries and POSTS measurements via wifi: https://github.com/jcalvinowens/tempsensor

This is a LED wall clock that synchronizes time over NTP: https://github.com/jcalvinowens/wallclock

I'm just starting a project with some other people at my local maker space to add an ESPHome monitor for our industrial air compressor to monitor leak down on the various main lines going to areas of the shop and to monitor the compressor working time for maintenance checks and such. The end result will get open sourced, hopefully along with a nice DIN mount to also be used in CNC controller enclosures and the like.

I got kind of petty and wanted to avoid the $40-50/month my wife spends on Pura scent refills. We also have multiple units in house, and I think they’re ugly (look like smoke alarms on wall). So I made a device to add scent juice in our HVAC system directly. It’s not as controllable, which hasn’t been a problem for us, but it is a more true full home experience which has been really nice actually.

Haven't done it yet but I'm making a booknook for my gf of the verandah in a particular Guatemalan hostel on the river where we stayed on our Central American holiday a few years ago. When a button is pressed it plays a looping mp3 of the jungle ambiance (ripped from a video I took on the actual holiday), together with a rippling light effect on the resin "river".

I use it to monitor my water meter in Home Assistant and have one sensor that reads various values (e.g. water temperature) from our domestic water heat pump via Modbus. The latter one could also be controlled with the ESP, however writing to Modbus makes me feel a little uneasy (that is mostly due to lacking documentation by the manufacturer, who apparently outsourced the firmware part).

I only got a proof-of-concept working, but I made a board that would allow payment for arcade games and pinball machines over wi-fi without disabling the coin slot. Free-play can be enabled by sensing the P1 and P2 start buttons. Security was an interesting puzzle because the 8266 ran out of memory when trying to host an SSL stack, so I went with HMAC signed messages.

I built a meter so I can see at a glance how many people are on the Minecraft server where I play:

https://imgur.com/a/QHpVbY1

White dots at the bottom are WS2812 LEDs that light up when specific players are online.

I built my own personal weather station when Wunderground was destroyed by TWC and IBM. It has continued to grow over the last two years. With each new idea I have, I have been adding additional functionality to it. It's fun and I've learnt a lot because multiple programming languages are needed to get everything to function.

I've built a hardware monitoring screen for my main/gaming PC, that displays CPU/GPU usage and temperature, RAM/VRAM usage etc. It has been very useful for me to be able to see all those stats at a glance while in game, to see where my computer is bottlenecked. Oh and also it doubles as a desk clock. :)

My AI chat thing: https://imgur.com/a/cxR8KpM (WIP). Connects to openai transcription, completion and tts APIs. Refactoring to use assistants, to use it to feed it my fridge's manual and have it think it's my fridge.

Battery powered home front gate sensor using an ESP-01s and MQTT.

It's simple and I'm impressed that a single CR123A battery has lasted now 7+ months and still reading >= 3.1V.

https://www.idatum.net/remote-front-gate-sensor.html

I used an ESP8266 to build an air conditioning "remote" that I can control with my Home Assistant setup. I was pretty surprised when I moved and it still worked at the new apartment.

I also bought some LED matrix displays that I'm going to use to display information about when trains are due at my nearby station.

I'm helping our local Fablab to manage physical access with a series of ESP8266 and esp-rfid https://github.com/esprfid/esp-rfid/ (of which I became maintainer. If you want to use it as well I can help!)

I have a Casino machine addon that connects to the cloud with json/websockets in production. And I have a vertical light controller for indoor farming. These arent with ESPHome. With ESPHome I have a water pump to recharge a big water container when gov sends water at certain times everyday.

I have an ESP8266 with motor controller opening and closing my chicken coop door at sunup and sundown. Also has a button to manually open or close.

It also monitors the temperature with a DS18B sensor, and uploads it via REST to a receiver that logs it to a database.

And it emaila me when the door opens or closes.

I built this once:

https://foundrytechnologies.com/relay.php

It didn't sell in large volumes but it's fun to see the units that did sell checking in every 5 minutes from around the world to this day.

I have one that I attached to an old antenna rotator so I can control it from the network. And another that monitors Github's status API and lights an LED when they're down.

Got a nice pair of Github socks at re:invent for showing a pic of that last one at their booth!

I didn't build anything yet with it, but I want to do something like this project:

https://www.instructables.com/ESP32-Bluetooth-Reflow-Oven/

I built out a remote sensing platform using ESP32 + LoRa. The attempt was to hit the sweet spot between cheap, easy, and reliable:

https://github.com/alexose/dorothy

A web interface for infrared remote controls https://www.instructables.com/Web-IR-Remote-With-Esp8266-Nod...

I built this weather forecast / todo list with the weather.gov and todoist APIs https://harrystern.net/halldisplay.html

OTA firmware updater and remote for my coffee maker

https://stonegray.ca/blog/coffee/

E Ink Todo list on my wall that pulls from Todoist, which I can update from my watch.

https://blog.praccu.com/

A tomato clock: https://github.com/harry75369/ESP8266_Tomato

I built a live programmable led string using micropython on esp32. Just connect to its wireless AP, type some python code and see the result in the led string.

I want to automate some window blinds to open/close, based on time of day, and maybe sunny-ness. Anyone try this? They came with a Velux remote control.

Currently building accurate presence detection with 24ghz radar. It’s so much more accurate than those crappy infrared sensors.

Home sensor network based on ESP8266s that collects data from around the house and sends it to my Raspberry Pi.

An esphome thingy that allows my Home Assistant to control my VP without it's ir remote

with esp8266 specifically, an ultrasonic mister for hydroponics, i even get the 8266 to generate the waveform while serving a control web page.

I installed a custom firmware on my ESP32-powered smart kettle and made it respond with the HTTP status code "418 I'm a teapot". [1]

I used an ESP32 to automate my kitchen rangehood light and fan [2].

I've flashed ESPHome on few smart outlets and powerboards. A lot of WiFi enabled devices that you buy in stores are actually white-labelled "Tuya" products, and there's a big community effort to hack the ESP32 chips and run your own custom firmware, such as ESPHome and Tasmota. Most off-the-shelf WiFi products don't work without the manufacturer's cloud services and apps. ESPHome means that everything works locally and it doesn't need to make any requests to the public internet.

I have KC868-AG IR/RF hubs in every room [3]. I found an awesome supplier on AliExpress who builds products specifically for ESPHome. They're quite expensive but they work really well. I mainly use them to control our air conditioners. I use one in my workshop to control an old CRT TV. And I also use them as "Bluetooth Proxies" [4] for Home Assistant. This means that I don't have to worry about range for bluetooth devices (temp/humidity sensors, switchbot, and LPG gas tank sensor.)

I run WLED [5] to control a few LED strips. I like using QuinLED controllers [6], which have an ESP32 chip plus some extra hardware for powering LEDs. I have one behind my desk in my office, and one on a board gaming table. I use Zigbee LED controllers for most of my LED lighting, but I like all the effects and patterns you can do with WLED.

I have a lot of ESP32 boards around my house running ESPresense [7]. They track the signals from our phones and watches and try to figure out which rooms are occupied, so the timers don't automatically turn off the lights. I use the ESPresense-companion app, which works ok, but I've been wanting to experiment with AI to make it more reliable.

[1] https://madebynathan.com/2021/08/19/kogan-smart-kettle/

[2] https://madebynathan.com/posts/2022-09-30-automating-my-kitc...

[3] https://www.aliexpress.com/item/1005003833775634.html?spm=a2...

[4] https://esphome.io/components/bluetooth_proxy.html

[5] https://kno.wled.ge/

[6] https://quinled.info/

[7] https://espresense.com/

[8] https://github.com/ESPresense/ESPresense-companion