Making an Accurate Stylish Clock With the Kitronik ZIP Halo HD and a BBC Micro:bit in MicroPython

The Kitronik ZIP Halo HD is an attractive battery-powered circular board with 60 "ZIP" multicolour LEDs and a real-time clock (RTC) for the BBC micro:bit. The board was originally designed for the micro:bit V1 with most of the example code in MakeCode. This article shows how to make an accurate clock and stopwatch with many colourful background modes in MicroPython on the micro:bit V2 (only). The backgrounds are implemented as classes and the plentiful examples should make it easy for you to make your own.

The ZIP HD LEDs are similar to Adafruit's 5050 NeoPixels but are smaller and use less power. The 60 LEDs sit on the board with a diameter of just 87mm. The program could easily be adapted for any RGB pixel ring.

The ZIP Halo HD uses the MicroChip MCP7940N RTC. This uses an external crystal oscillator for reasonably accurate time keeping similar to a quartz watch. The article shows how to do a simple measurement of the MicroPython and RTC clocks to improve their accuracy.

A subsequent article will cover converting the ZIP Halo HD from 3xAA battery power to USB power. Kitronik have a discontinued product, the Kitronik Alarm Clock Kit, without the AA battery pack and with a barrel jack and a small coin cell battery. The ZIP Halo HD uses the same underlying PCB - this has various solder pads/holes for power connections.

There are two unresolved issues under investigation, the ZIP LEDs can glitch occasionally often with very bright flashes and, more importantly, the clock program can halt with a 030 error after just half a day. The RTC continues to operate and keep time if the program stops. The switch can be used to power cycle the micro:bit to restart the clock program.

1. Kitronik ZIP Halo HD: Kitronik | Radio Spares (USA) | PiShop.us
2. BBC micro:bit V2: Kitronik | Radio Spares (USA) | PiShop.us - the V1 will not work for this size program, the V2 can be easily visually distinguished by its gold metal oval logo and the rippling of the bottom of the edge connector. The V1 has coloured logo and flat bottom.
3. 3 AA batteries, rechargeable can be used - unfortunately the LEDs on the ZIP Halo HD cannot be powered by USB power to the micro:bit as the micro:bit does not provide USB power on its edge connector.

The V1 and V2 micro:bits have external crystals, the V2.2.1 bill of materials (BOM) lists these as a pair of AEL Crystal 32MHz (32M000000S045). These are very good for time keeping and have +/- 10ppm tolerance for the desired frequency and +/- 10ppm stability with minimal variation over typical room temperatures in the home. The MCP7940N on the ZIP Halo HD is driven by a ubiquitous 32.768kHz crystal. For a mediocre crystal these might be out by ten seconds a day but this will be drift is likely to be fairly consistent and can easily be corrected.

The first test produced some surprising results.

1. MCP7940N RTC (red line): 18 seconds fast over a day (+210.4ppm).
2. MicroPython on micro:bit V2 (green line): 552 seconds slow over a day (-6386ppm).

The first value isn't terrible but it is outside of the range that can be corrected with the fine trim feature of the MCP7940N suggesting something is amiss. The second value is atrocious for a crystal. CircuitPython was used for an abbreviated comparison (blue line) and this (via extrapolation) was only going to lose 2 seconds over a day suggesting the micro:bit hardware is fine.

The red line for the RTC time difference is thicker due to the clock only having 1 second resolution.

This plot on the left shows the clocks corrected with a simple linear correction. For the oscillator cognoscenti this provides a clue as to what is going on with MicroPython being all over the place. This looks very similar to the Arduino UNO R4 WiFi clock testing in Instructables: Arduino Comparison in Detail: UNO R3, Leonardo, UNO R4 Minima and UNO R4 WiFi - that board is using an internal clock which is part of the microcontroller.

A check of the fine trim value on the RTC showed a surprising value of 127 in the relevant register. This may have been the value used in the original tests presented here. The datasheet appears to state this value should be 0 at POR (power-on reset), but 127 is clearly not 0. This could be a library bug or perhaps a datasheet error. The MCP7940N does not have EEPROM to preserve this value without power so this cannot be a value from Kitronik calibrating the board/crystal.

The testing was repeated for around ten hours (36000 seconds) with an explicit setting of the trim to 0. The new values extracted from line fitting are shown on the plot and below.

1. MCP7940N RTC: 7.003 seconds fast over a day (+81.05ppm).
2. MicroPython on micro:bit V2: 541.543 seconds slow over a day (-6268ppm).

The fine trim can correct for this value with a register value of -80. The third plot shows this correction with the clock now running slow by a mere 25 milliseconds a day (-0.29ppm).

The MicroPython program used to produce the previous plots can be run with the period set to six minutes** to provide an easy way to measure the clock drift of the micro:bit V2 and the MCP7940 RTC. The Arduino IDE's serial monitor has a convenient timestamping feature (ensure it's toggled on) with millisecond resolution. The program doesn't produce output for 6 minutes allowing time to copy the file onto the micro:bit, start the program in Thonny and then close that down and run the Arduino IDE. The screenshot above shows the Serial Monitor, this must be set to 115200 baud for the micro:bit V2. This particular micro:bit shows up as COM4, a dummy board (Adafruit Feather) has been selected, the board isn't important as it's not going to be programmed from the Arduino IDE.

Ten hours is a enough time to get a reasonable starting value for the calibration values to correct both of the clocks. The first few and last few lines of the output shown in the serial monitor for a ten hour run for a different micro:bit (in a room which varied between 23-25 degrees celsius) is shown below for a test run with all of the ZIP LEDs off.

The fields from left to right are described below.

1. Timestamp is created by the Arduino IDE from the host computer.
2. MicroPython's utime.ticks_us() after the period has passed plus a subsequent immediate call to ticks_us(). These values wrap around at 1073741824 (2^30).
3. The MCP7940N RTC adds year, month, day of the month, hour, minute, seconds, week day, day of the year..

The delay between each line is determined by the MicroPython implementation of a clock using the micro:bit hardware. The second and third lines are separated by 571648629 - 211648540 = 360000089 microseconds which is incredibly close to 360 seconds. If everything was perfect then the first Arduino IDE timestamp and the RTC time would advance by exactly 360 seconds for every line.

Here's some time maths in REPL to calculate the elapsed time from the perspective of the reference and RTC clocks.

The value here is different to the value derived from the Pi 4 data. This is probably because Linux with chrony is better at time keeping than Windows 10 and because of the shorter run with low time difference. If the RTC had just incremented from 36205 then using the 36205 value yields 84.88ppm.

The MicroPython clock is a bit of a pain to calculate as the values frequently wrap around 1073741824 (2^30). The easiest way is to count the number of lines, 101 lines in this test, and assume that the lines are separated by 360 (6*60) seconds. The assumption still allows for very good accuracy as the program is designed to avoid cumulative time issues.

This number is also significantly different to the previously calculated value. The MicroPython clock is poor due to an issue possibly with the low quality internal oscillator being used on the micro:bit's microcontroller. This difference could be attributable to the temperature difference.

The config.py file for these values is shown below.

In terms of measurement accuracy, the following factors will help for a better time reference.

1. Desktop > laptop (due to thermal management and perhaps power-saving features).
2. Wired ethernet > WiFi (low jitter network connection).
3. Linux with chrony or ntpd > macOS > Windows.
4. Lightly loaded > running many intensive applications.
5. Minimal USB traffic > bulk transfer over USB (some ports have shared resources).

Pausing operating system updates may help too to avoid highly undesirable reboots.

** One hour would be more desirable here for less voluminous output but the program is kept short and very simple intentionally and uses utime.ticks_diff() which has limits on its range.

MicroPython Installation

The MicroPython interpreter can be installed by going to https://python.microbit.org/ and installing the test program. This is also a useful check to ensure your micro:bit is working. This offers two techniques for installing the interpreter with program onto the micro:bit, saving a hex file to the MICROBIT drive or updating the micro:bit via the CMSIS-DAP protocol using WebUSB in the browser.

Clock Program Installation

There are many programs which can be used to copy files onto the micro:bit's internal file system. The Thonny editor is one of them.

1. Download the zhhclock-v1.1.zip from GitHub. These files are needed for the clock demonstrated in this article.
2. zhhclock.py
3. zc_comboclock.py
4. zc_utils.py
5. mcp7940.py
6. rainbow.py
7. zc_bg.py
8. zc_bg_blank.py
9. zc_bg_digitalrain.py
10. zc_bg_pendulum.py
11. zc_bg_flag.py
12. Create a config.py file, optional, see below.
13. Rename/copy/symbolic link the zhhclock.py file to main.py
14. Minify them with pyminify. There are pre-minified versions in the pyminify directory in the zip file.
15. Copy the files over to the micro:bit using Thonny. The screenshot above shows main.py being refreshed on the micro:bit with a right click and selecting the Upload to micro:bit menu entry.

The files for the other backgrounds are:

1. zc_bg_brightnesstest.py
2. zc_bg_fallingrainbow.py
3. zc_bg_larsonscanner.py
4. zc_bg_rotatingrainbow.py
5. zc_bg_temperature.py

Pyminify Installation

Daniel Flook's pyminify can be installed using pip.

Parameters for Clocks

An optional file called config.py can be used to set the drift values for the clocks to let the RTC and program correct for them. An example file with the values for the ZIP Halo HD and micro:bit in this article is shown below.

Do not copy these values for your devices, these will be specific to each board due to the variation in quartz crystals and a MicroPython bug. An empty template file is also available as sample.config.py

Modifying Backgrounds

It's best to check your choice of backgrounds fits in the file system first. Then edit the the import list near the top of zhhclock.py/main.py (don't forget this!) and the background tuple in the same file. An excerpt showing the latter follows.

Versions

1. Software
2. MicroPython: 2.1.2
3. MicroPython MCP7940 library: 3b89d6f
4. pyminify: 2.11.3
5. Hardware
6. BBC micro:bit V2.2.1
7. Kitronik ZIP Halo HD: V1.0

This is the V1.0 program with background classes: Blank, DigitalRain, Pendulum, and Flag loaded. The hour, minute and second hands are represented by red, green and blue, respectively.

1. 00:04 Power on using switch to go into clock mode with blank background.
2. 00:23 Digital rain background.
3. 00:55 Pendulum background.
4. 01:12 Stopwatch (background is disabled for this)
5. 01:37 Clock (back to the clock)
6. 01:48 Flag background.
7. 02:07 Ripple - this happens every minute.
8. 04:24 Brief ZIP LED glitch, two frames (265.34 265.38) at 04:25 (25fps).

The logo on the micro:bit V2 is touch sensitive and can be used as a button.

1. A short press changes the background.
2. A longer press toggles between stopwatch and clock mode (video shows t as there was a bug in V1.0).
3. A very long press puts the program in time set mode where the hour, minute and second can be set - this is not shown in the video. The display shows am or pm in this mode. A subsequent logo press exits the time set mode returning to clock mode.

The colour balance on the camera was set to daylight for this video.

Blank (zc_bg_blank.py)

This is just a blank background, nothing exciting here!

BrightnessTest (zc_bg_brightnesstest.py)

This illuminates the 60 ZIP LEDs in red with values between 0 and 255 and 10 of the micro:bit display (red) LEDs between 0 and 9 (maximum level).

DigitalRain (zc_bg_digitalrain.py)

This is a set of randomly appearing, variable speed, red dots with trails falling across the ZIP LEDs and the micro:bit's "The Matrix" LED display. The image above taken from the video in this article shows DigitalRain.

FallingRainbow (zc_bg_fallingrainbow.py)

This makes a "rainbow" fall through the ZIP LEDs slowly every minute.

Flag (zc_bg_flag.py)

This is an attempt at representing flags on the ZIP LEDs. Three designs are included. These change on the hour and ripple (an attempt to represent the wind) every minute. For one flag there's some use of the micro:bit display.

LarsonScanner (zc_bg_larsonscanner.py)

A traditional favourite.

Pendulum (zc_bg_pendulum.py)

A red pendulum using the small angle approximation. The simulated length is far beyond the real physical length on the ZIP Halo HD to make a seconds pendulum (2s period, 0.5Hz).

RotatingRainbow (zc_bg_rotatingrainbow.py)

The rainbow colours are used around the ZIP LEDs to indicate the second hand of a clock with a dark pixel. They rotate on the second.

Temperature (zc_bg_temperature.py)

This shows the temperature on the ZIP LEDs as a vertical level ranging from 5 degrees celsius at the bottom to 35 at the top coloured blue to red.

Python is an attractive language for novices compared to the low-level and often hostile world of C/C++. MicroPython and its derivative CircuitPython are small versions of Python intended for use on microcontrollers. They are very similar but when both are available on a microcontroller board it can be difficult to decide which one to use. CircuitPython's large set of libraries and consistency/portability between boards can make it appealing. Both typically need custom cutdown libraries as normal Python libraries tend to be too large for microcontrollers.

MicroPython is supported on both the micro:bit V1 and V2 but the memory is very limited on the V1. CircuitPython is only supported on the V2 but the port is not very stable at the moment making it unsuitable for this project. A CircuitPython library for the MCP7940 does not work at all.

MicroPython is attractive on the micro:bit for its

1. easy-to-use button handling functions with debounce,
2. efficient support for the variable brightness 5x5 matrix LED display,
3. light sensor feature using the display's LEDs "in reverse" and
4. larger userbase.

It does currently have a minor time-keeping bug demonstrated in Slow time on micro:bit V1 and V2 #225 but this slowness can be corrected in the program.

CircuitPython's CIRCUITPY drive is not visible over USB on the micro:bit V2 port due to a hardware limitation from the micro:bit V2's use of a separate microcontroller for the USB communication.

The DigitalRain class needs to keep track of the rain drops with five parameters per drop. A list of dicts is one way to do this. For what should be a more compact representation the dict can be replaced with a list with fields determined by index value. A single flattened array can be used if all the values have the same type. MIcroPython's REPL can be used to quickly examine the memory use of a range of alternatives like this, see below.

The average sizes per element can be calculated by the decrease in available memory as each data structure is created, for these data structures the sizes (in bytes) are:

1. list of dicts: 41.92,
2. list of lists: 38.4,
3. array: 8.96.

Using an array is certainly less elegant and less flexible and may be slightly slower to access but there is a considerable memory saving which may be important for large arrays or when memory is short. The code to use the "second" field from the fourth element is shown below.

The size of an array cannot be changed after creation in Python. In the case of the rain drops this limitation offers a benefit as an upper size limit caps the amount of processing and therefore time for each display update and means no garbage collection is required for additions and removals. An existing or new field is needed to indicate whether each element is valid. For rain drops a brightness of zero can be used to indicate an invalid (unused) element, i.e. a rain drop that does not exist.

The original implementation used a list of lists. There were a few MemoryError exceptions like the one below and one 030 "hardware" error from the CODAL layer on the micro:bit during casual testing.

The exceptions stopped after the conversion to a static array.

xkcd's Code Quality features above.

MicroPython is often used just with a single file called main.py which runs when the interpreter starts. The (non-hierarchical) file system on the micro:bit port supports multiple files in a single directory. A MicroPython program can read and write files to this file storage. The size of the Local Persistent File System is described in the documentation, quoted below.

However, since the micro:bit is a limited device in terms of both hardware and storage capacity MicroPython provides a small subset of the functions needed to persist data on the device. Because of memory constraints there is approximately 30k of storage available on the file system.

In tests from Thonny which can be used to copy files onto this it appears to be more like 18-19k.

The microcontroller on the V2 micro:bit has twice the amount of flash memory as the V1 but unfortunately the file system maintains the original small V1 file system size.

It's easy to accidentally wipe all of the files on a micro:bit. It's highly inadvisable to keep the only copy of a file on a micro:bit.

Python can be compiled into byte-code in pyc files to make it smaller. MicroPython has a similar compilation process and generates mpy files but these are unfortunately not supported on the micro:bit port.

An alternative approach is to make the code smaller by using techniques like very short variable names and removing white space and comments. This makes the code unreadable and difficult to maintain. A "minification" tool to process the MicroPython files to make them smaller as they are installed is the best approach.

The size of files in bytes before and after running pyminify --remove-literal-statements on them are listed below. These sizes may differ slightly from the current release of the code.

The use of pyminify is clearly attractive to allow larger MicroPython programs to be used on the micro:bit. In testing the option --remove-literal-statements worked perfectly but --rename-globals does not work as it does not maintain naming consistency across files.

The ZIP Halo HD datasheet states the Vcc voltage range as 3.5V-5V and the ZIP LEDs as 15mA each at full brightness. The total current will include the micro:bit and RTC, the latter is designed to be consume minimal current.

Here are some values measured with a multimeter using fresh alkaline batteries, recently charged NiMH batteries** and flat old alkaline batteries (voltage is out of spec. for ZIP Halo HD).

1. Three ZIP LEDs at low brightness levels: 42.1mA at 4.61V, 38.6mA at 4.15V, 30.4mA 2.99V.
2. All ZIP LEDs on at fairly low brightness levels: 63.9 at 4.57V, 60.5mA at 4.13V, 45.1mA at 2.87V.

The brightness levels were around 16 for this test, 255 is the highest value and considerably brighter.

For 1500mAh batteries, these are only going to last a day and a half for a basic clock (1500 / 42.1 / 24 = 1.5) or a day for more colourful backgrounds (1500 / 63.9 / 24 = 0.98). For (new) reputable*** 2500mAh NiMH rechargeable batteries these are still going to struggle to last three days. Rechargeable batteries could be swapped every 2 days but this isn't very practical and the ZIP Halo HD RTC might not keep the time during even a quick swap.

If the display looks yellowish and has dim blues this is likely to indicate the batteries are going flat. Flat alkaline batteries will have a low voltage where the blue LEDs which have a higher forward voltage than red and green are struggling to light.

The battery voltage could be monitored with a high value potential divider. A USB power connector could also be added for long-term use as a clock - this will be explored in a future article.

** It's interesting to note that these recently charged and lightly loaded rechargeable batteries total 4.13V with an average voltage of 1.38V, this is far higher than their nominal voltage of 1.2V (3.6V total).

*** Many lower-tier battery manufacturers blatantly lie about the capacity of their NiMH batteries, see Instructables: NiMH Rechargeable Battery Comparison Using Kitronik Inventor's Kit and Adafruit CLUE.

The video in this article was long enough to capture a rare glitch on the ZIP LEDs at 04:25. For two frames (at 25fps) the LEDs completely change colour probably with some relationship to previous/desired colours and they become very bright. This is some sort of hardware or software bug. The LEDs use the WS2812B one-wire protocol which transfers data in one continuous transmission and needs precise timing.

The program is updating the display continuously and these only occur every ten to fifteen minutes. With an update rate varying between 5 and 25 times a second this means it's occurring very roughly once every ten thousand updates.

The issue has been ticketed in GitHub: microbit-foundation / micropython-microbit-v2: Rare glitches on WS2812B pixels using neopixel library on micro:bit V2 #227.

Unlike the micro:bit V1, the port of MicroPython on the V2 (like MakeCode) uses the CODAL runtime to provide a hardware abstraction layer. The clock program (V1.1) with the digital rain background can halt after about half a day with an 030 (DEVICE_HEAP_ERROR) error - this appears as digits on the micro:bit display together with a sad face. This is highly problematic for a clock but the real-time clock continues to operate, power-cycling the micro:bit with the on/off switch will start the program afresh with the correct time.

Some ideas:

1. Add your own clock background. Adding your favourite flag is an easy place to start.
2. Find something attractive to mount your ZIP Halo HD on. It has two holes for M3 bolts to facilitate this.
3. Tweak the code which shows the hour, minute, second hands to make more readable on the more gaudy backgrounds.
4. Add an alarm function. The MCP7940N RTC has some alarm functionality but there is an errata entry for this functionality. Some caution should be applied here in terms of relying on this as the sole alarm clock for critical events - MicroPython on the micro:bit isn't really reliable enough for this.
5. Add a countdown timer with audible alarm.
6. Compare the volume from the micro:bit V2's tiny speaker and the one on the ZIP Halo HD. These speakers have certain frequency bands which are far louder typically near 2kHz.
7. Add support for daylight savings time changes. This requires the date to be set and the device to know the local rules for when to change the presented time.
8. Add a sound meter mode, both the micro:bit V2 and the ZIP Halo HD have microphones.
9. The micro:bit has an accelerometer. This could be used like a plumb line to determine which direction is down to orient graphics on the displays.
10. Add temperature correction for the RTC clock and the MicroPython clock.
11. Adjust brightness to ambient level.
12. The micro:bit LED display can be used in reverse to measure the light level, this is available in MicroPython as display.read_light_level().
13. A night mode could either go to very low LED values or could provide night light functionality.
14. Improve the brightness matching between the micro:bit display and the ZIP LEDs. The BrightnessTest background is intended to help with this.
15. Make the code work on an arbitrary number of RGB pixels. This would make it compatible with the original Kitronik ZIP Halo.
16. Check the trim values on various MCP7940 RTCs at power up to see if they are random or match the datasheet's statement of 0 at POR (power-on reset).
17. Do some long term testing (a month?) to see how stable the program and MicroPython are.
18. Use P1 and P2 pads as touch inputs by switching them to capacitive mode (available only on the V2 with its nRF52 series microcontroller).
19. Hardware additions for P1/P2 (take care not to exceed 3.3V)
20. Add battery voltage monitoring with a potential divider.
21. Add a PIR sensor to monitor human movement in the room. This must be compatible with supply voltage and output a 3.3V logic signal.
22. Add buttons or potentiometers for extra controls.
23. A phototransistor or light-dependent resistor as part of a potential divider for an alternative or comparison to the micro:bit's LED measurement of ambient light.
24. Check if ZIP LED brightness affects board temperature. The micro:bit temperature() function might be useful for this, i.e. leave board running in a room with constant temperature and then turn all LEDs on at full brightness (with a good USB power source) and check temperature over time to see if these heat up the ZIP Halo HD and micro:bit boards. The clock drift could also be checked again with all of the LEDs on at full brightness.
25. Complex
26. Investigate the ZIP LED glitches. Recording the signal on pin 8 with frequent ZIP LED updates using a logic analyzer over a long time (perhaps 10 minutes) with an accompanying video will eventually catch this. A high frame rate video might be useful in case the ZIP LED patterns help to show the nature of the bug. An analogue capture could also be useful to check how clean the signal is particularly in high frequency sections. If the GPIO drive strength (cf V2 Neopixel error - Was working prior Christmas #3825) is the issue then the supply (battery) voltage may have an impact on this as it could effect the low/high threshold voltage on ZIP LEDs.
27. Investigate the CODAL 030 errors.

Similar projects:

1. Kitronik's example projects for ZIP Halo HD - scroll down to Product resources / datasheet section.
2. GitHub: KitronikLtd / micropython-microbit-kitronik-halohd - "Example micro python (for BBC micro:bit) code for the Kitronik :VIEW [means ZIP] Halo HD. This code implements a simple clock, with an alarm using the buzzer which is cancelled by clapping detected by the microphone."
3. Kitronik Blog: Comparison Between ZIP Halo and ZIP Halo HD
4. ZIP Halo projects easily adapted for the HD
5. Kitronik Blog: Additional Online Resources For Kitronik Alarm Clock Kit
6. Kitronik: Day 3 - BBC microbit ZIP Halo Compass
7. Instructables: D4E1 - Visuele Timer Voor Kinderen - a stopwatch written in MakeCode, article is written in Dutch.
8. Adafruit Learn: NeoPixel 60 Ring Wall Clock - a clock made from a larger ring of NeoPixels using the Adafruit Trinket Mini Microcontroller (5V Logic) in Arduino C/C++ - this project was created many years ago, there will be many superior microcontroller boards for this now.
9. Instructables: NeoPixel NTP Clock Using ESP8266
10. Adafruit Playground: Digital / RGB-666 Moon Clock

Other interesting clock projects and products:

1. Hackaday IO: Remarkably Accurate Quartz Clock
2. IEEE Spectrum: Build the Most Accurate DIY Quartz Clock Yet & Hands On Extra: OCXO Clock
3. Instructables: Arduino Digital Clock Synchronized by the 60Hz Power Line
4. The Guardian: Clockmaker John Harrison vindicated 250 years after ‘absurd’ claims - the world's most accurate mechanical clock, John Harrison's design for Clock B implemented in modern materials by Martin Burgess tested over 100 days.
5. Bremont watches - traditional mechanical movement wristwatches including the MBI, "guaranteed to within -4 and +6 seconds per day".
6. Chris Dzombak blog: Building the atomic clock I’ve always wanted
7. Adafruit Learn: Simple Vertical Wordclock - uses the popular Analog Devices DS3231
8. Bad Dog Designs Nixie Clocks
9. Instructables: Paper Sundial Kits

Further reading:

1. DigiKey: Python, MicroPython, and CircuitPython: Similarities and Differences
2. Time
3. Altium: From RC to Atomic Clocks: All Clock Sources
4. Instructables: Making an Oscillator With LogicBoard From MH-EDU-Electronics - making a relaxation oscillator with a resistor, a capacitor and logic gates with schmitt trigger inputs.
5. CTS: Application Note: Crystal Basics
6. Steve Mould: How a quartz watch works - its heart beats 32,768 times a second (YouTube)
7. engineerguy: How an atomic clock works, and its use in the global positioning system (GPS) (YouTube)
8. StackExchange: Electrical Engineering:
9. Crystals, Oscillators, and Resonators. What the difference?
10. Internal or external oscillator
11. Why does usb have start of frame packets?
12. Andreas Spiess: Precise Time without Internet: NTP Server from GPS Satellites (YouTube) - a Swiss homage to Time Nuts, a practical look at using the Raspberry Pi with inexpensive GPS modules to provide an accurate "local" time source which can be distributed using the Network Time Protocol (NTP).
13. Jeff Geerling Blog: PTP and IEEE-1588 hardware timestamping on the Raspberry Pi CM4 - a look at the time-stamping features on the network interface of the Raspberry Pi Compute Module 4 for Precision Time Protocol (PTP), Compute Module 5 also gets a mention.
14. FSMLabs: Comparing NTP and PTP - a vendor showing the difference between Network Time Protocol (NTP) solutions like ntp and chrony vs their Precision Time Protocol (PTP) TimeKeeper system.
15. Wired: Amateur Time Hackers Play With Atomic Clocks at Home
16. The British Museum: Young explorers: a brief history of time telling (YouTube)
17. UW Space Place: A Brief History of Time(keeping): Optical Atomic Clocks and Their Applications (YouTube)
18. Bugs/feature requests
19. GitHub: microbit-foundation / micropython-microbit-v2: Slow time on micro:bit V1 and V2 #225
20. GitHub: microbit-foundation / micropython-microbit-v2: Increase file system size on V2 #226
21. GitHub: microbit-foundation / micropython-microbit-v2: Rare glitches on WS2812B pixels using neopixel library on micro:bit V2 #227
22. GitHub: kevinjwalters / micropython-examples: ZIP Halo HD clock (zhhclock) V1.1 occasional ZIP LED glitches and micro:bit 030 errors #3
23. GitHub: bbcmicrobit / micropython: Can microbit's micropython run mpy files? #524