Building An ESP32 Smart Power Strip From Scratch

June 10, 2020 by Tom Nardi 33 Comments

Surely the most straightforward way of creating a smart power strip would be to take an existing model and hack in some relays that you could fire with a WiFi-enabled microcontroller. But where’s the fun in that? Instead of repurposing a commercial power strip for his recent project, [Md Raz] decided to just build the whole thing himself.

The project started with a 3D printed enclosure that could hold the electronics and three panel mount sockets. The use of heat-set inserts makes it a bit more robust for future upgrade work, but otherwise it’s a fairly simple rectangular design. Nobody ever said a power strip had to be pretty, right? In addition to the panel mount sockets, there’s also a AC-DC converter to step mains voltage down to 5 VDC for the ESP32.

In addition to the microcontroller, the custom PCB in the power strip holds a trio of MOSFETs connected to AQH2223 solid state relay (SSR) chips. Once the ESP32 toggles the line attached to each MOSFET, the indicator LED above the outlet goes on and the appropriate SSR is thrown to turn on the power. With a simple web interface running on the microcontroller, all three outlets can be independently controlled from any device with a web browser.

If you’d like to limit your interaction with mains voltages, then we’ve seen some projects that commandeer the low-voltage side of a commercial smart power strip. But remember, putting a Raspberry Pi inside of a power strip might seem suspicious to some folks.

The Easiest Way To Put Your Doorbell On The Internet

June 1, 2020 by Tom Nardi 39 Comments

Thanks to low-cost WiFi enabled microcontrollers such as the ESP8266 and ESP32, it’s never been a better time to roll your own smart home system. But that doesn’t mean it isn’t daunting for new players. If you’re looking for an easy first project, putting your old school doorbell on the Internet of Things is a great start, but even here there’s some debate about how to proceed.

Most people stumble when they get to the point where they have to connect their low-voltage microcontroller up to the relatively beefy transformer that drives a standard doorbell. We’ve seen a number of clever methods to make this connection safely, but this tip from [AnotherMaker] is probably the easiest and safest way you’re likely to come across.

His solution only requires an inductive current sensor, which can be had for less than $1 from the usual overseas suppliers. One leg of the doorbell circuit is passed through the center of this sensor, and the sensor itself is connected up to your microcontroller of choice (here, and ESP32). The rest is software, which [AnotherMaker] explains in the video after the break. With the addition of a little debounce code, your microcontroller can reliably determine when somebody is out there jabbing the bell button; what you do with this information after that is up to you.

If you’re worried this method is too easy you could always try it with an optocoupler, or maybe convert the low-voltage AC to something your microcontroller can handle.

Continue reading “The Easiest Way To Put Your Doorbell On The Internet” →

Home Assistant Get Fingerprint Scanning

May 28, 2020 by Al Williams 13 Comments

Biometrics — like using your fingerprint as a password — is certainly convenient and are pretty commonplace on phones and laptops these days. While their overall security could be a problem, they certainly fit the bill to keep casual intruders out of your system. [Lewis Barclay] had some sensors gathering dust and decided to interface them to his Home Assistant setup using an ESP chip and MQTT.

You can see the device working in the video below. The code is on GitHub, and the only thing we worried about was the overall security. Of course, the security of fingerprint scanners is debatable since you hear stories about people lifting fingerprints with tape and glue, but even beyond that, if you were on the network, it would seem like you could sniff and fake fingerprint messages via MQTT. Depending on your security goals, that might not be a big deal and, of course, that assumes someone could compromise your network to start with.

Continue reading “Home Assistant Get Fingerprint Scanning” →

An ESP32 Home Automation Swiss Army Knife

May 14, 2020 by Tom Nardi 37 Comments

Thanks to the ESP8266 and the ESP32, we’ve seen an explosion in DIY home automation projects recently. When it only takes $3 and a few lines of code to bring your gadgets onto the network, that’s hardly a surprise. But hacking bare ESP modules onto devices will only get you so far. Eventually you’ll probably want to put together a slightly more mature home automation system, and that’s where things can get a little tricky.

Which is why [Alfredo] created the Maisken Homelay. This device is a one-stop-shop for your home automation needs that leverages the power of the ESP32. With the microcontroller slotted into this compact PCB, you’ll be able to trigger four relays for your high current or AC loads, and still have 8 GPIOs and the I2C bus for expansion. All while retaining compatibility with existing open source projects like Home Assistant and ESPHome.

What really sets this project apart is the attention to detail. [Alfredo] has included a HLK-PM01 power supply on the board which takes mains voltage and brings it down to 5 VDC for the ESP32, so won’t need a separate power cable. He’s also taken the time to add isolation slots to separate the potential high-voltage connected to the relays from the rest of the board, added current and thermal fuses for protection, and peppered the board with screw terminals so you can easily connect everything up.

Sure you could get a simple relay board shipped to your door for a few bucks from the usual suspects. But it’s not going to offer the kind of quality of life and safety features that the Maisken Homelay has. There’s even a 3D printed enclosure available to help tidy things up.

With some of the blatantly anti-consumer decisions big-name home automation companies have been making recently, there’s more reason than ever to roll your own smart home using open source hardware and software. It still takes more effort than buying a bunch of modules from the Big Box retailer, but projects like this one are certainly starting to blur the line between consumer and DIY.

Roll Your Own – Toilet Paper

May 9, 2020 by Jenny List 17 Comments

Toilet paper has become a hot button issue over the last month or so, and the pandemic prompted panic buying, and consequent shortages. Now there are adequate supplies, at least where this is being written, but sometimes one’s rolls aren’t the domestic items we’re all used to. This happened to [Ebenezer], who had some of the large size rolls suitable for toilet roll dispensers rather than a domestic bathroom. To solve this problem he made a makeshift toilet roll winder.

The adventures of small dogs aside, we all know that toilet rolls unroll themselves very easily indeed but are a significant pain to get back on the roll once they have done so. Rolling toilet paper must therefore be an exact science of velocity and tension, which he approached with a 3D printed shaft that mounts a toilet roll tube in a Ryobi drill. Getting the tension right was a bit tricky, but we’re extremely impressed with the result. Like him we’d have expected some side-to-side movement, but there was very little and a near perfect toilet roll was the result.

This is a simple hack, but one extremely well executed, and that it does something we might normally consider near-impossible is a bonus. Of course, should you wish to ration your toilet paper, you can always print it.

Ask Hackaday: Wink Hubs, Extortion As A Service?

May 7, 2020 by Elliot Williams 142 Comments

Wink Labs just announced that their home automation hub, the Wink Hub, is “transitioning to a $4.99 monthly subscription, starting on May 13, 2020.” Should you fail to pay the fiver every month, you will lose access to their app, voice control, and automations, which is everything it does as far as we can tell.

This is an especially bitter pill to swallow for Hub users, because the device was just that — a hub. It speaks Bluetooth, Z-Wave, ZigBee, WiFi, Kidde, and a couple other specific device protocols, interfaces with Amazon’s Alexa, has a handy Android master panel app, and had a nice “robot” system that made the automation side of “home automation” simple for normal people. In short, with its low one-time purchase price, compatibility with many devices, nice phone app, and multiple radios, it was a great centerpiece for a home-automation setup.

“Nice home automation system you’ve got there. Would be a shame if anything happened to it.”

Continue reading “Ask Hackaday: Wink Hubs, Extortion As A Service?” →

Three-Dollar Router Rebooter Has One Job

May 6, 2020 by Donald Papp 76 Comments

Sometimes connectivity problems go away by power cycling a router. It’s a simple but inconvenient solution to a problem that shouldn’t exist, but that didn’t stop [Mike Diamond] from automating it for a few bucks in parts. The three-dollar router rebooter may be a simple device with only one job, but it’s well documented and worth a look.

The device is an ESP8266 board configured to try to reach Google periodically via the local wireless network. If Google cannot be reached, the board assumes a reboot is needed and disconnects the 12 V power supply from the router by using a relay. Then, after a delay, power is re-connected and all of one’s problems are over until the next time it happens. [Mike] used a relay module that has built-in screw terminals and a socket for the ESP8266-01, so it looks like the whole device can be put together without soldering a thing.

While the code for making this happen may sound trivial, [Mike] nevertheless delves into documenting it. It makes a great example of how to implement a simple event-driven finite state machine in a way that’s clear and concise. By structuring the code so that there is a finite number of specific states the device can be in (router power on, router power off, and testing connection) and by defining exactly how and when the device switches between those states, operation and troubleshooting becomes a much more manageable job. Another great example is this IoT Garage Door Opener project. If you’re programming devices that interface to physical things, these techniques are definitely good practice.