Mysterious Files PH

[Ayushmaan] states up front that most of his free time is spent “building things that probably didn’t need to exist”. Well, this one might be an anomaly, because it seems pretty useful to us.

HYDR8, as it says on the tin, is a wearable that knows when it’s time to hydrate. The impetus for this one was something we all chase: the flow state. [Ayushmaan] would sit down, get deep into work, and look up hours later to to find that he had a headache and a full water bottle. Phone reminders were soon swiped away in annoyance.

This wearable is based on a XIAO ESP32-C3. It reads heart rate, oxygenation, skin temperature, and both the ambient temperature and humidity. It also learns your personal resting numbers range.

Taking all of this into consideration, it generates a heat/hydration stress score between 0-100. The thing is, HYDR8 tells you specifically what to do; sometimes it’s ‘drink water’ and other times, it’s ‘find shade’.

The wearable itself, while somewhat chunky, is pretty simple: it only shows the time and a message when it matters. The ESP32 hosts a full dashboard on your phone.

Keep in mind that this is not a medical device, it’s an experiment, a prototype. It can’t measure how hydrated you are. Instead, it measure hydration stress.

If you don’t want to wear anything, here’s a smart straw that uses a tiny turbine flowmeter and a Hall effect sensor to record the volume sipped, and detect whether the sipper is low on fluids. And if you find yourself under the hot lights of a wet bulb event, here’s how to survive it.

Your desk or bench is a work area, so why not make it look the part? That’s the idea behind the miniature blinking traffic barrels that [Glen Akins] recently put together. Of course, just a single blinking light doesn’t really sell the idea of a busy construction zone, so he spent a somewhat surprising amount of time and effort optimizing the design for small-scale production.

The end result is a fascinating write-up that dives into the design decisions [Glen] made. Every aspect of this project, from the overhang of the “handle” on the 3D printed barrel to the number of passive components on the PCB was carefully considered. Critics may say [Glen] put too much thought into something that didn’t need to be so complex, but projects like these are an excellent way to keep your skills sharp — there’s no such thing as practicing too much.

Starting with the design of the barrel itself, we appreciate that [Glen] kept the capabilities of his desktop 3D printer in mind. By breaking the design up into multiple pieces and avoiding overly steep angles, he produced a design that prints cleanly without the need for support material. His step-by-step documentation and screenshots also serve as a great introduction to designing parts in Fusion if that’s something you’re interested in.

From there, things switch over to the electronics. Some in the audience will bemoan that he’s using a PIC12F1612 microcontroller to blink a single LED instead of a 555, but [Glen] brought the receipts on this one. Not only does the PIC offer more flexibility in terms of getting the blinking to look the way he wants, but it requires fewer passive components on the board and is considerably more energy efficient than the iconic timer IC. Even if you ignore all the other advantages, he calculates that going with a 555 would have cut the battery life of the finished product by approximately 15%.

This is one of those projects that’s difficult to summarize in such a terse format, as every time you think the write-up must be about over it takes a new turn on you. We were mildly bemused when the second iteration of the PCB popped up, but by the time he introduced the custom programming adapter board, we knew [Glen] wasn’t messing around.

Unsurprisingly, this isn’t the first time we’ve seen [Glen]’s handiwork. You may recall seeing his RP2040-powered sound board earlier this year, but his name has been popping up on these pages for more than a decade now.

Here’s a historical hack for you: you have a big, rolling pressurized kettle, also known as a steam locomotive. It needs water to make up for the steam constantly chuff-chuff-chuffing away, or bad things happen. How do you get water from an unpressurized tender into a high pressure boiler with no moving parts? What you need is a some way to inject steam with no moving parts — a steam injector, if you will. [Marc Flint] found that the steam injectors were the hardest part of a loco to understand, so he made a video for all of us once he’d figured it out.

The steam injector isn’t a new idea. [Henri Griffard] came up with it back in the 1850s to replace expensive and maintenance-hungry pumps. It’s rather ingenious and uses the fluid mechanics uncovered by another European bloke by the name of Bernoulli. First, the high-pressure steam from the boiler goes through a converging-diverging nozzle to drop its pressure and speed its flow up, just as you’d guess if you’ve seen Bernoulli’s laws. Even more vacuum-inducing is the presence of water: the steam, already cooled by its expansion, hits the water in the pipe open to the tender, and condenses into it, shrinking a couple of orders of magnitude, creating a vacuum that draws in no small quantity of feed water. That one we did not expect from Bernoulli, but it makes sense. So how to get from below atmospheric pressure to the 180-odd PSI or more in the boiler?

Well, the water is now moving at a good clip, between the Venturi effect and the momentum gained from absorbing that steam, so another converging nozzle is the trick. Bernoulli’s law, once more! A one-way valve lets the now-pressurized water into the boiler, with a gap in between to dump water while the pressure builds up. It’s a clever trick, and since the steam coming from the boiler makes it back inside along with at least some of its heat energy, it’s much more efficient in both coal and water than running a pump. It’s also a bit of a head scratcher how it works unless someone sits you down to explain it, so we’re glad [Marc] did.

Not many of us are likely to use this knowledge directly — unless we’re firing up a 90 year old boiler or building a new steam locomotive — but seeing how great engineers of years past made use of basic physical laws can serve both as education and inspiration.

Once upon a time a doorbell was little more than a button, a transformer, and a bell tucked somewhere around the house. These days, they get a little bit fancier. [Philipp Schweizer] has recently been exploring how to turn existing dumb doorbells into smarter ones.

The build is based around a wired doorbell setup, in particular, a Vistadoor ADV-100. [Philipp] was able to find a simple place to tap in to a signal that went to 5 V when the doorbell was rung. He wanted to hook this into his smart home system as easily as possible. Thus, he grabbed a rather unique part—the ESP32-H2. This is notable in the ESP32 family for having no WiFi connectivity. What it does have, however, is an 802.15.4 radio good for Thread and Zigbee communications.

[Phillip] explains that hooking the ESP32-H2 up to fire a notification to Home Assistant every time the doorbell goes off is easy—and it doesn’t mess with the standard doorbell’s chiming behavior one bit. He also explains how to set up neat automations, such as having a separate smart camera capture an image when the door bell is fired.

If you’re looking to integrate an existing doorbell into your Home Assistant setup, this project could be just what you need. We’ve featured some other neat doorbell builds too, like this touchless design from the dark days of the coronavirus pandemic.

If you are a regular reader, then the odds are you have taken apart an electronic gadget, either for a fix, or simply because your curiosity got the better of you. Once inside, it’s all but impossible to help yourself from doing at least a little reverse engineering. That’s what happened when [PRBS23] took a look inside a Gravity 800 Grill for a simple wire fix. But one thing led to the next, and now open source firmware for the grill is freely available!

The first order of business in creating the firmware is reverse engineering the original controller. Opening it up immediately reveals an ESP-32 and a well-labeled programming port. The rest of the control board is equally simple, including connectors for four thermistor temperature sensors, lid open/close switch, fan driver, 16 segment LCD, piezo buzzer, and some physical inputs.

The thermistor along with the physical inputs are connected to a 16 pin chip, interfacing with the MCU over a 9600 baud UART connection. [PRBS23] cannot determine an ADC chip meeting these specifications, so the most likely answer is a cheap MCU programmed to act as a simple analog fronted.

The neatly labeled programming header is used to quite easily dump the firmware with the espflash utility. Analyzing this dump reveals a rather strange ADC correction function used by the original firmware. The necessity and overall utility of this function remains unclear, as it only corrects by a maximum of two or three degrees Fahrenheit.

Most of the other features ended up being at least somewhat easier. The CS1621 segmented display driver is reasonably well documented with datasheets making its implementation far easier. Likewise, the other odds and ends were implemented in a far more normal manner compared to the thermistors.

All this reverse engineering work got tied together into a neat little firmware package. It comes with over the air updates PID controlled temperature, and a real-time web interface. This also isn’t the first time we have seen an IoT device liberated from proprietary firmware, and this remains one of our favorite uses of reverse engineering!

Although we personally have yet to see anyone brandishing an old digital point-and-shoot camera, we hear they’re back in vogue. Why, though? People are nostalgic for that image quality. While he certainly could have simply picked up a vintage model somewhere for a likely inflated price, [Arnov Sharma] decided to build his own version and call it the PolyShot.

The core of this project is the Unihiker K10 dev board, which uses an ESP32-S3, a whopping 2 megapixel camera, and a micro SD card to capture photos and display them back on the screen. The tricky part, if you can call it that, is the custom PCB. It’s a simple board with just three buttons: shutter, gallery, and next image. We do like that the position of the battery compartment creates a nice grip.

The biggest difference here is that there is a few-second delay between pressing the shutter button and actually capturing the image, which you can see in the short videos below. So if you’re trying to get a shot of a skink or something equally speedy, we wish you good luck.

In a future iteration, [Arnov] wants to address the issue of image quality, because this project ended up evolving into a more traditional digital camera. He would also improve the battery life, for which the current expectancy is around three hours on a charge. Ultimately, [Arnov] wants to ditch the Unihiker and design everything from the ground up, using an ESP32-S3 module.

What is it about retrocomputing? For some people, it’s nostalgia. For others, it’s the appeal of simplicity. For still others, it’s the chance to save old machines from the graveyard. Whatever your motivation, there’s no denying that we’ve seen a metric ton of retrocomputer projects here at Hackaday. And we’d like to see more!

We’re happy to announce the 2026 Hackaday Retrocomputing Challenge!

Now’s the chance to put your retrocomputer project up for all to see. Open up a Hackaday.io project that features your retrocomputer project, and we’ll pick our three favorites for a $150 gift certificate courtesy of this contest’s sponsor, DigiKey. You have until Tuesday, October 27th. So get hacking!

Honorable Mention Categories

• • Old Iron: Are you saving an old C64 from the scrapyard? Restringing the core memory of a PDP-8? Or working on even more esoteric ancient devices? If you’re restoring or running the old hardware itself, it’s an “Old Iron” project.
  • Modern Retro: Computing power is plentiful, but the nice interfaces of past computer made them a joy, or a terror, to use. This honorable mention category is for emulations, work-alikes, and all the other retrocomputers that are TRS-80 on the outside, but modern electronics on the inside.
  • Retro-Modern: You love your classic machine, but you also love reading Hackaday on the Internet Of The Future, so you built a web-modem to bring the old beast into the modern era. This category is for keeping old hardware relevant.
  • Coding Like It’s 1999: Retrocomputers don’t run without software, and it’s a continual source of amazement to us how programmers today can get more out of old machines than we could back in the day. Think of the demoscene, for instance. But it doesn’t have to be showy either. If you’re writing new code for old boxes, it fits in here.