This is an example of the lengths to which Network Time Protocol aficionados will go in search of slightly better performance from their NTP servers. [Folkert van Heusden], having heard that thermal stability keeps NTP servers happy, used a picnic cooler as an environmental chamber for his Pi- and GPS-based NTP rig. Heat is added to the chamber thanks to seven Block Erupter ASIC miner dongles, which are turned on by a Python script when a microcontroller sends an MQTT message that the temperature has dropped below the setpoint.
Each dongle produces about 2.5 Watts of heat when it’s working, making them pretty effective heaters. Alas, heat is all they produce at the moment — [Folkert] just has them working on the same hash over and over. He does say that he has plans to let the miners do useful work at some point, not so much for profit but to at least help out the network a bit.
This seems like a bit of a long way around to solve this problem, but since the mining dongles are basically obsolete now — we talked about them way back in 2013 — it has a nice hacky feeling to it that we appreciate.
Finnish software engineer [Toni] is on a quest to modernize his 1991 house, and his latest project was to automate the window blinds and control them using Home Assistant. Unless your blinds have built-in motors, most of the effort of such a project centers around how to integrate and attach the motor — and as [Toni] points out, there are tons of different blinds with all kinds of operating mechanisms. But once you solve that issue, half the battle is over.
These particular blinds require less than one turn of the control rod to go from fully open to fully closed, and [Toni] selects a 270-degree range-of-motion, 20 kg*cm torque servo motor to drive them. He really wanted to install the motor inside the window, but it just wouldn’t fit. Instead, each servo motor is mounted in a custom 3D-printed case installed on the window frame just below the operating rod. An ESP8266-based controller box is installed above the window, hidden behind curtains, and operates all three servos.
On the software side of things, the project is coded in C++ and uploaded using the Ardiono IDE. The blinds communicate to [Toni]’s Home Assistant network using MQTT. All the software is available on the project’s GitHub repository, and the 3D-printed case design is posted on Thingiverse. Even though your blinds may be of a completely different design, we think many parts of [Toni]’s project are still useful — do check out this project if you’re thinking about doing something similar. The notion of motorized window blinds has been around for a some time — we covered one project way back in 2013 and another in 2016. If you have added automation to your window blinds, let us know how it went down in the comments section.
Smart homes are becoming an increasingly popular way to automate one’s home, whether it’s turning on lights, closing blinds, or even feeding pets. But the commercial offerings often rely on an internet connection to reach servers in order to work, which invites a lot of privacy concerns for a large percentage of us as well as being inconvenient when the internet is down. Essentially the only way to have a privacy-respecting, self-sufficient smart home is to build one on your own from the ground up, which is exactly what [Xasin] has done with this project.
This build is based on ESP32 modules with a Raspberry Pi as a hub, but it’s not as simple as a MQTT implementation. Not only does the self-contained home automation setup not rely on any outside services, but a failure of the central Pi server will not impact the nodes either as they are configured to continue operating independently even without central control. This allows for a robust home automation implementation without a single point of failure, and also includes some other features that are helpful as well including voice control, all while retaining a core design philosophy that makes it relatively easy to build.
Not only is the build technologically impressive for its standalone capabilities and its elimination of privacy concerns, but [Xasin] also did an excellent job with the physical design as well, adding plenty of RGB and a hexagonal enclosure that gives it a unique look wherever its is placed. If you’re renting right now or otherwise unable to interface any automation with your current home, be sure to take a look at some projects that do home automation without making any permanent changes.
The size and price of the ESP wifi modules have quickly made them into one of the preferred building blocks for IoT devices. Unfortunately they are not particularly well suited for very low power applications. [LittlePetieWheat] wanted to add MQTT to a cheap PIR solar light, so he paired an ESP with an Attiny85 to hold it to a strict power budget.
Most of these lights contain some sort of no-name microcontroller that monitors the analog PIR sensor, and turns on the LEDs as required. [LittlePetieWheat] replaced the PIR sensor with one that gives a digital output for simpler interfacing. The Attiny serves as the low power brains of the project. Its tasks include reading the solar panel and battery voltages, and PIR output. When movement is detected by the sensor, it activates a clever little latching power circuit to power on the ESP01 just long enough to send a MQTT message. The LEDs are only turned on if there is no power coming from the solar panel. The solar power is stored in a 18650 battery.
Hamsters are great pets, especially for those with limited space or other resources. They are fun playful animals that are fairly easy to keep, and are entertaining to boot. [Kim]’s hamster, [Mr. Fluffbutt], certainly fits this mold as well but [Kim] wanted something a little beyond the confines of the habitat and exercise wheel and decided to send him on a virtual journey every time he goes for a run.
The virtual hamster journey is built on an ESP32 microcontroller which monitors the revolutions of the hamster wheel via a hall effect sensor and magnet. It then extrapolates the distance the hamster has run and sends the data to a Raspberry Pi which hosts a MQTT and Node.js server. From there, it maps out an equivalent route according to a predefined GPX route and updates that information live. The hamster follows the route, in effect, every time it runs on the wheel. [Mr Fluffbutt] has made it from the Netherlands to southeastern Germany so far, well on his way to his ancestral home of Syria.
This project is a great way to add a sort of augmented reality to a pet hamster, in a similar way that we’ve seen self-driving fish tanks. Adding a Google Streetview monitor to the hamster habitat would be an interesting addition as well, but for now we’re satisfied seeing the incredible journey that [Mr Fluffbutt] has been on so far.
We have all been stuck inside for too long, and maybe that’s why we have recently seen a number of projects attempting to help humans take better care of their housemates from Kingdom Plantae. To survive, plants need nutrients, light, and water. That last one seems tricky to get right; not too dry and not drowning them either, so [rbaron’s] green solder-masked w-parasite wireless soil monitor turns this responsibility over to your existing home automation system.
Like this low-power soil sensor project and the custom controller for six soil sensors, [rbaron’s] w-parasite uses a “parasitic capacitive” moisture sensor to determine if it’s time to water plants. This means that unlike resistive soil moisture sensors, here the copper traces are protected from corrosion by the solder mask. For those wondering how they work, [rbaron]’s Twitter thread has a great explanation.
The “w” in the name is for WiFi as the built-in ESP-32 module then takes the moisture reading and sends an update wirelessly via MQTT. Depending on the IQ of your smart-home setup, you could log the data, route an alert to a cellphone, light up a smart-bulb, or even switch on an irrigation system.
[rbaron] has shared a string of wireless hacks, controlling the A/C over Slack and a BLE Fitness Tracker that inspired more soldering than jogging. We like how streamlined this solution is, with the sensor, ESP-32 module, and battery all in a compact single board design. Are you asking yourself, “but how is a power-hungry ESP-32 going to last longer than it takes for my geraniums to dry out?” [rbaron] is using deep sleep that only consumes 15uA between very quick 500ms check-ins. The rechargeable LIR2450 Li-Ion coin cell shown here can transmit a reading every half hour for 90 days. If you need something that lasts longer than that, use [rbaron]’s handy spreadsheet to choose larger batteries that last a whole year. Though, let’s hope we don’t have to spend another whole year inside with our plant friends.
We may never know why the weeds in the cracks of city streets do better than our houseplants, but hopefully, we can keep our green roommates alive (slightly longer) with a little digital nudge.
Five years ago, I wrote a series on getting started with your own MQTT-based home information/automation network. Five years is a long while in Hackaday time. Back then, the ESP8266 was a lot newer, and the 8266 Arduino port wasn’t fully in shape yet, and the easiest software framework to get MQTT up and running was NodeMCU; so that’s what I used for the article series, and as a consequence a handful of devices around my house run minor modifications of that basic “hello world”, but doing useful stuff.
Since then, NodeMCU has changed a bunch of its libraries and the ESP32 has replaced the ESP8266 in my parts drawer. If you tried to run my code, you’d find that it won’t run on an ESP8266 without porting or compiling an old version of NodeMCU for yourself anyway, and it won’t run on an ESP32 at all. When [Chris Lott] tried to follow my guide, he discovered that Micropython is probably a better language choice in 2021. To minimize lines of code, I’d agree, although the Arduino and Espressif’s own native IDF have grown into the job just about as well. In short, anything but NodeMCU.
Built in an hour, survived for five years.
But my home automation system doesn’t care. Those little guys are running 24/7, flipping bits like it was still 2016. Thermometers, light sensors, and power meters haven’t changed much in five years, and although I’ve revamped the databasing, display, and user control a number of times since then, using a fixed communication transport protocol means that they’re still talking the same language. Indeed, even if NodeMCU is dead to me, the MQTT content of my original series is all still valid, and installing a broker on a Raspberry Pi has only become easier in the intervening five years.
So I’ve got a bunch of legacy code running within the walls of my own home, and it makes me nervous. If the devices fail, or maybe when they eventually fail, it’s not going to be “just flash another ESP8266 and replace it”, because even though I have some ancient NodeMCU binaries sitting around, I know when to throw in the towel. But there’s no good reason to pull them down and start reflashing either. Except that it makes me a little bit itchy, just knowing that there’s orphaned, dead-end code running all around me. Surrounding me. Staring deep into my hacker’s heart.
I know better than to tear down a running system, even though I could do it one device at a time, and each module would surely be a simple, independent fix; even though I’d love the excuse to play around with Micropython and its MQTT implementation on the ESP8266, or maybe even swap some of them out for ESP32s; even though these were all temporary quick hacks that have somehow served for five (5!) years. I certainly know better, right? (Right?)
This article is part of the Hackaday.com newsletter, delivered every seven days for each of the last 200+ weeks. It also includes our favorite articles from the last seven days that you can see on the web version of the newsletter.
Want this type of article to hit your inbox every Friday morning? You should sign up!
[rbaron] has shared a string of wireless hacks, 
