The Problem

For a while, I’ve wished there was a way to get reliable notifications when my washer and dryer finished. Both machines live in the basement, and the end-of-cycle beeps aren’t loud enough to reach upstairs.

The obvious solution was to plug them into a smart outlet and track power usage. But my dryer runs on a 240-volt outlet, and I couldn’t find a reasonably priced smart plug that could handle it.

That meant I’d need some sort of sensor. The two common options I kept coming across were:

• a sound sensor to listen for the end-of-cycle chime
• a vibration sensor that would detect the machine running and then stopping.

I didn’t like the idea of listening for sounds — it felt finicky and prone to mistakes — so vibration sensors it was. The hardware side seemed simple enough, but the thought of writing custom software to make sense of the readings had me procrastinating for months.

Choosing the Approach

The turning point came when I revisited ESPHome. I’d tried it a few years ago for a different project, but at the time the flashing process was confusing and I couldn’t quite get it working. I eventually gave up and went with Tasmota, which was easier back then.

Fast forward to today: ESPHome has grown up a lot. It integrates directly with Home Assistant, flashing devices is much smoother, and I’d recently had a good experience setting up an ESPHome Bluetooth proxy. That gave me the confidence to give it another shot.

Around that same time, I found a project on GitHub called LaundryBot, which was almost exactly what I’d been planning. The author used an ESP32, but since I had a pile of ESP8266 boards on hand (and I didn’t need Bluetooth anyway), I figured I’d adapt it.

So, the plan became: pair of SW-420 vibration sensors feeding into an ESP8266 running ESPHome, reporting washer and dryer status updates straight into Home Assistant. With the concept settled, it was time to see if I could actually get it working.

Materials

For this project, I mostly used parts I already had lying around, with a few extras picked up along the way:

• ESP8266 (Wemos D1 Mini clone) – pack of 10 from Amazon
• SW-420 vibration sensor modules – pack of 5 from Amazon
• 22 AWG solid core hookup wire – for sensor connections (from Amazon)
• Breadboard & jumper wires – for prototyping
• Soldering iron – to make permanent connections
• 3D printer (Creality CR-6 SE) – for controller and sensor cases

Optional but nice to have:

• Heat shrink tubing – to clean up exposed joints (from Amazon)
• JST connectors & crimping tool – for detachable, neat wiring (from Amazon)

Initial Setup

With the plan in place, I grabbed a Wemos D1 Mini (an ESP8266 clone) from my parts bin and started setting up ESPHome. The GitHub repo I found suggested wiring up the sensor to an LED on the board for testing, but since my board didn’t have that, I decided to skip ahead and just try flashing ESPHome directly.

At first, everything looked promising: I plugged in the D1 Mini, Windows recognized it, and the drivers installed without complaint. But when I tried flashing through the ESPHome Device Builder in Home Assistant, it refused to connect.

I thought maybe the board wasn’t in flash mode, so I tried all sorts of combinations: grounding D3, grounding D8, adding resistors, swapping cables, different USB ports, even trying different boards. Nothing. After a few hours of chasing advice from forums and blog posts, I was ready to call the board defective.

In a last-ditch attempt, I dusted off my old Windows 10 laptop, plugged the board in, and opened the ESP Home Web Flasher (link). To my complete surprise, it connected instantly and flashed on the first try. Just like that, the board came alive, connected to WiFi, and popped up in Home Assistant.

That was the breakthrough I needed to put the project back on track — and finally get me excited to see some real signals.

Proof of Concept

Setting Up the Software

With the firmware running, I wanted to see if the ESP could actually talk to Home Assistant. To start small, I added a few simple ESPHome sensors: device status, WiFi signal, and uptime. That way I’d know right away if the board was online and working.

binary_sensor:
  - platform: status
    name: "LaundryBot"
sensor:
  - platform: wifi_signal
    name: "WiFi Signal"
  - platform: uptime
    type: seconds
    name: "Uptime Sensor"

The first time those values popped up in Home Assistant, it felt like a small victory — proof that the setup was alive.

Next came the vibration sensors. I Googled which pins were safe on the D1 Mini (link) and picked GPIO4 (D2) and GPIO14 (D5). I added them as binary sensors for “Washer” and “Dryer,” then flashed the config again.

binary_sensor:
  - platform: status
    name: "LaundryBot"
  - platform: gpio
    pin: GPIO4 #D2
    name: "washer"
    device_class: vibration
    filters:
     - delayed_on: 10ms
     - delayed_off: 1sec
  - platform: gpio
    pin: GPIO14 #D5
    name: "dryer"
    device_class: vibration
    filters:
     - delayed_on: 10ms
     - delayed_off: 1sec

Seeing those two new entities appear in Home Assistant — even if they were still “unavailable” with nothing connected — felt like another big step forward.

Trying out the Hardware

With the software set, it was time for some hands-on testing. I set everything up on a breadboard: ESP resting on loose headers, sensors connected with jumper wires.

When I gave the sensors a shake… nothing. I thought I’d wired them wrong. After a little research, I learned the SW-420 is only sensitive along one axis. In other words, I’d been shaking them the wrong way.

Once I slid the breadboard back and forth along the sensor’s axis, the logs lit up with vibration events.

Not everything was perfect — sometimes a sensor would “stick” in the high state and needed another shake to reset — but seeing those signals show up in Home Assistant was the real proof I needed. The idea was solid, and it was time to start building it for real.

Ready to Build

After a few dead ends and plenty of trial and error, I had a working proof of concept: an ESP8266 on a breadboard, two vibration sensors, and signals flowing into Home Assistant. The setup was imperfect but it was enough to confirm the approach would work.

In the next part, I’ll take this breadboard prototype and turn it into proper hardware: soldered connections, 3D-printed cases for the controller and sensors, and wiring that can stand up to real use in the laundry room.