We’ve seen a lot of custom clocks here at Hackaday, many of which have pushed the traditional definition of the timepiece to its absolute limit. But for all their wild designs, most of them do have something in common: they assume you can actually read a clock and understand the concept of time. But what if you’re developing a clock for a toddler who’s only just coming to terms with such heady ideas?
The answer, at least for [Riley Parish] is a set of 3D printed eyes that are illuminated with either yellow or green LEDs depending on whether or not it’s time to get out of bed. More than just the color of the light, the eye design (which is embedded into the rear of the front panel) switches between wide-open and tightly shut depending on the time of day.
Internally the device is very simple, with the 5 mm LEDs and their associated resistors connected directly to the digital out pins on an ESP32 development board. While the dual-core microcontroller is admittedly pretty overkill for flipping some LEDs every 12 hours or so, the firmware does at least pull the current time from NTP — plus the powerful MCU offers plenty of room to grow. A web front-end to configure the device or check its current status would only be a few more lines of code.
As it so happens, this isn’t the first toddler timepiece to grace these pages. Perhaps unsurprisingly, those previous examples also used changing color to help indicate the passage of time.
If there’s no circuitry on a printed circuit board, does it cease being a “PCB” and perhaps instead become just a “PB”?
Call them what you will, the fact that PCBs have become so cheap and easy to design and fabricate lends them to more creative uses than just acting as the wiring for a project. In this case, [Jeremy Cook] put one to work as the faceplate for his “742 Clock,” a name that plays on the fact that his seven-segment display is 42 mm tall, plus it’s “24/7” backward.
In addition to the actual circuit board that holds the Wemos ESP32 module and the LEDs, a circuit-less board was designed with gaps in the solder mask to act as light pipes. Sandwiched between the boards is a 3D printed mask, to control the light and direct it only through the light pipes. [Jeremy] went through a couple of iterations of diffuser and mask designs, finally coming up with a combination that works well and looks good. He mentions a possible redesign of the faceplate board to include a copper backplane for better opacity, which we think is a good idea. We’d also like to see how different substrates work; would boards of different thickness or using FR-4 with different glass transition temperatures work better? Check out the video below and see what you think.
We’re seeing more and more PCBs turn up as structural elements, from enclosures to control panels and even tools, and we approve of this trend. But what we really approve of is what [Jeremy] did here by making this clock just a dumb display that gets network time over NTP. Would that all three digital clocks in our kitchen did the same thing — maybe then they wouldn’t each be an infuriating minute out of sync with the others.
Continue reading “Circuit-less PCB Featured As Faceplate For A Digital Clock” →
[Jeff Geerling] has been following the various open source time projects for some time now, and is finally able to demonstrate a working and affordable solution for nanoseconds-accurate timekeeping in your local lab. The possibility of a low-cost time server came about with the introduction of the Raspberry Pi CM4 compute module back in Oct 2020, whose Broadcom network chip (BCM54210PE) supports PTP (Precision Time Protocol, IEEE-1588) 1PPS output and hardware-based time stamping. Despite the CM4 data sheet specifying PTP support, it wasn’t available in the kernel. An issue was raised in Feb last year, and Raspberry Pi kernel support was finally released this month.
[Jeff] demonstrates how easy it is to get two CM4 modules to synchronize to within a few tens of nanoseconds in the video below the break. That alone can be very useful on many projects. But if you want really stable and absolute time, you need a stratum 1 external source. These time servers, called grandmasters in PTP nomenclature, have traditionally been specialized pieces of kit costing tens of thousands of dollars, using precision oscillators for stability and RF signals from stratum 0 devices like navigation satellites or terrestrial broadcast stations to get absolute time. But as Lasse Johnsen, who worked on the kernel updates remarks in the video:
In 2022 these purpose-built grandmaster clocks from the traditional vendors are about as relevant as the appliance web servers like the Raq and Qube were back in 1998.
It is now possible to build your own low-cost stratum 1 time server in your lab from open source projects. Two examples shown in the video. The Open Time Server project’s Timecard uses a GNSS satellite receiver and a Microchip MAC-SA5X Rubidium oscillator. If that’s overkill for your projects or budget, the Time4Pi CM4 hat is about to be release for under $200. If accurate time keeping is your thing, the technology is now within reach of the average home lab. You can also add PTP to a non-CM4 Raspberry Pi — check out the Real-Time HAT that we covered last year.
Continue reading “Stratum 1 Grandmaster Time Server On A Budget” →
Network Time Protocol (NTP) is one of the best ways to keep networked computers synchronized to the same time. It’s simple, lightweight, and not only allows computers to maintain a time standard together, but it also allows some computer manufacturers to save some money on hardware costs. The Raspberry Pi is perhaps the most well-known example of a low-cost computer without the extra expense of a real-time clock (RTC). While the Pi sets up NTP essentially automatically, other microcontrollers like the ESP32 don’t, but it is possible to configure them to use this time standard with some work.
For this project the MicroPython implementation for the ESP32 is required. MicroPython is a way of running Python code on microcontrollers or other embedded systems without all of the overhead that Python would normally require. Luckily enough, the NTP libraries are built right in so once MicroPython is running on the ESP32 it’s nearly as easy as calling the library. Of course you will have to make sure there is an internet connection, and then grab the time, sync it to the machine, and then set the timezone.
For a bonus exercise, the project’s creator [Bhavesh] suggests attempting to configure Daylight Savings Time, although this can be a surprisingly difficult problem to solve. In the meantime, there are a few other ways of installing a clock on a microcontroller like this one. An RTC module is an obvious choice, but you can also get incredibly accurate time by using a GPS module as well.
They say time is money, but if that’s true, money must also be time. It’s all figurative, of course, but in the case of this NTP server heater powered by Bitcoin mining dongles, money actually does become time.
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.
Making a microcontroller perform as a frequency counter is a relatively straightforward task involving the measurement of the time period during which a number of pulses are counted. The maximum frequency is however limited to a fraction of the microcontroller’s clock speed and the accuracy of the resulting instrument depends on that of the clock crystal so it will hardly result in the best of frequency counters. It’s something [FrankBuss] has approached with an Arduino-based counter that offloads the timing question to a host PC, and thus claims atomic accuracy due to its clock being tied to a master source via NTP. The Rust code PC-side provides continuous readings whose accuracy increases the longer it is left counting the source. The example shown reaches 20 parts per billion after several hours reading a 1 MHz source.
It’s clear that this is hardly the most convenient of frequency counters, however we can see that it could find a use for anyone intent on monitoring the long-term stability of a source, and could even be used with some kind of feedback to discipline an RF source against the NTP clock with the use of an appropriate prescaler. Its true calling might come though not in measurement but in calibration of another instrument which can be adjusted to match its reading once it has settled down. There’s surely no cheaper way to satisfy your inner frequency standard nut.
Most Hackaday readers will be familiar with the idea of a network time server; a magical box nestled away in some distant data center that runs the Network Time Protocol (NTP) and allows us to conveniently synchronize the clocks in our computers and gadgets. Particularly eager clock watchers can actually rig up their own NTP server for their personal use, and if you’re a true time aficionado like [Cristiano Monteiro], you might be interested in the portable GPS-controlled time server he recently put together.
The heart of the build is a NEO-6M GPS module which features a dedicated pulse per second (PPS) pin. The ESP8266 combines the timestamp from the GPS messages and the PPS signal to synchronize itself with the atomic clock aboard the orbiting satellite. To prevent the system from drifting too far out of sync when it doesn’t have a lock on the GPS signal, [Cristiano] is using a DS3231 I2C real-time clock module that features a high accuracy temperature-compensated crystal oscillator (TCXO).
Continue reading “Portable GPS Time Server Powered By The ESP8266” →