In Part 1, I built a proof-of-concept using an ESP8266 and vibration sensors to detect washer and dryer activity. The breadboard prototype had proved the idea worked, but it looked more like a science fair project than a laundry automation device. It was time to make it permanent. That meant dragging out the soldering iron, wrestling with too-thick wires, and learning to use heat shrink tubing along the way.

Of course, once the wiring was done, I needed a proper home for the controller and sensors. My 3D printer got a workout as I iterated through case designs — some good, some cracked, and some that never quite fit.

This part of the project was all about turning a fragile prototype into something that could survive real use, and as usual, the process wasn’t as straightforward as I first imagined.

Soldering

The Controller

With the breadboard test behind me, it was time to make things permanent. The ESP8266 D1 Mini only has one 5V pin and one ground pin, but I needed power for both sensors. My first thought was to try cramming two wires into a single hole — turns out, they were too thick for that.

So I improvised: I soldered one wire in normally, then cut the excess and attached another wire from the backside. Not the prettiest solution, but it worked.

Once everything was connected, I looked over the joints. Most were fine, but the extra wires I tacked onto the back left exposed sections that I wasn’t happy with. At first, I figured I’d just leave them — but the more I looked, the more it bothered me. This was the perfect excuse to try out some heat shrink tubing.

A quick Amazon order later, I slipped the tubing on, heated it up with the side of my soldering iron, and the results looked so much cleaner. Definitely worth the extra step.

It wasn’t flawless, but at least now the controller wiring looked sturdy enough to move on to the next stage.

The Sensors

Next up were the SW-420 vibration sensors. These modules came with header pins pre-soldered, which was convenient for breadboarding but not ideal for my ultimate use case. I considered removing the headers, but they were stubbornly attached, and I didn’t want to risk damaging the board.

So instead, I decided to solder the wires directly onto the existing headers. This worked, but it was fiddly; the joints ended up with more exposed metal than I liked, and the connections didn’t look as neat as I wanted. Once again, heat shrink tubing came to the rescue. Sliding it over the messy joints and shrinking it down made everything look far cleaner — and much sturdier.

The sensors were now wired up solidly and ready to be paired with the controller.

3D Printing

The ESP Case

With the wiring done, I needed a proper case for the controller. I dug up an old model I had lying around and modified it with a few cutouts for the wires. Version 1 came off the printer looking decent… until I tried fitting the ESP inside.

The holes were too small, the support platform blocked the bottom wires, and the cover clips pressed right on top of my solder joints. In short: it didn’t fit.

So I started over. For Version 2, I rebuilt the case from scratch. I fixed the tilt in the model, added full-height holes for the wires, moved the clips away from the solder joints, and even added some lettering to the cover.

The new case worked better and I was able to fit the D1 mini and cables, but the cover gave me headaches. I printed it with supports, which fused too tightly, and I ended up cracking it while trying to pry it apart. Not ideal. The ESP also did not sit as deep and snugly as I had hoped due to the wire underneath not allowing it to go all the way down but it was good enough.

I wasn’t ready to give up on the lettering, though. For Version 3, I changed the design so the text was cut into the cover instead of raised, and I printed it without support. This time, it came off cleanly without cracking.

The lettering was subtle, but it worked, and the case finally felt solid enough to house the controller.

The Sensor Case

After finishing the controller case, I turned my attention to the vibration sensors. I found a case model on Thingiverse that looked promising, with cutouts for the adjustment screw and indicator LEDs.

I printed it out… and the sensor didn’t fit. Too tight, wrong alignment, and no room to slide it in cleanly. So, back to the design software. I stretched the model, shifted the pillar that holds the sensor, and shortened the height a bit so it would sit snug. The first reprint was better, but still not quite right. It took one more iteration to finally get the case fitting the SW-420 modules properly.

The result was a simple but sturdy enclosure that kept the sensors secure while still exposing the adjustment screw. It wasn’t fancy, but it worked — and the sensors finally had a proper home.

Finishing Touches

With the controller and sensors each in their own cases, the last step was cleaning up the wiring. At this point, I had a jumble of wires sticking out in all directions, and I didn’t want to leave them loose.

So, I twisted the wires together into neat bundles, then crimped on JST connectors. That way, the sensors could be easily plugged in or disconnected without having to resolder anything.

It was a small detail, but it made the whole project feel much more polished. The wiring was tidy, modular, and finally looked like something I could install next to the washer and dryer.

Ready to Install

After plenty of soldering, shrinking, printing, and re-printing, the hardware was finally taking shape. The ESP had a case that fit, the sensors had snug enclosures, and the wiring was cleaned up with connectors.

What started as a breadboard full of loose jumpers now looked like a real device. It was finally ready to move out of the workshop and into the laundry room.

In the next part, I’ll tackle the final configuration, mounting the sensors to the machines, and getting the system up and running in Home Assistant.

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.