Self Learning Clock (SLC)

The Self-Learning Clock (SLC) is a DIY clock that learns its own internal drift to maintain high accuracy with minimal NTP synchronizations.

It uses an ultra-low power development board, paired with a 4.2-inch, high-contrast e-paper display.

The watch is battery-operated, and thanks to its extremely low power consumption (<0.75 mAh on average), a single charge should last months; I'll provide precise battery life data in due time.

The Concept:

Traditional NTP-based clocks frequently check in with time servers, which drains power and relies on a continuous network connection. Their accuracy drifts until the next sync.

The Self-Learning Clock (SLC) takes a different approach: it observes its own timing errors and builds a software correction model for its internal oscillator's drift.

By applying this adaptive correction, it achieves excellent short-term accuracy and minimal long-term drift (the last gets fully compensated at NTP syncs).

After an initial learning period, the clock maintains an accuracy of approximately ±2 seconds over a 12-hour period, with just two NTP syncs per day.

The initial learning takes about two days, but the learning process never stops, allowing the SLC to continuously refine its corrections.

A high-level flowchart is attached, which better explains how the system works.

Why This Matters:

Microcontrollers like the ESP32 contain two types of oscillators:

1. High-power mode: Uses a stable and precise crystal oscillator.
2. Low-power mode (light sleep): Uses energy-efficient but imprecise RC oscillators that can accumulate minutes of error per day.

While external RTC modules with backup batteries can solve this problem, the SLC achieves similar precision using only the microcontroller itself.

This enables true, long-lasting battery operation without any additional hardware.

Why "Self-Learning" ?

In this context, "learning" refers to a deterministic self-calibration process. The clock models and compensates for its own hardware characteristics. It's not artificial intelligence, but a straightforward mathematical analysis.

The system compares the internal clock deviation (in PPM) against a trusted source (NTP servers) and applies a filtered correction to the displayed time.

Is this approach totally new ?

After researching online, I could not find any prior project with this specific approach.

Key Features:

1. Adaptive Drift Compensation:
2. Learns and corrects the microcontroller's oscillator drift through periodic NTP synchronization, creating an increasingly accurate internal timing model.
3. There is no need to manually calibrate the resonator; the code handles compensation automatically.
4. Ultra-Low Power Consumption (<0.75 mAh average):
5. Implements finely tuned light-sleep cycles with ultra-short wakeups (≈0.8 seconds active per minute).
6. Smart Time Management:
7. Automatically handles time zones and Daylight Saving Time (DST) with configurable rules for different regions (e.g., EU, US, Australia).
8. High-Contrast 4.2" E-Paper Display:
9. Features gigantic 110-point digits for excellent readability.
10. It uses partial refreshes for efficiency and a full refresh every 60 updates to prevent ghosting.
11. The display updates immediately after the minute changes (when seconds are between 0 and 5).
12. The display also shows useful status information:
13. Battery level (displayed in place of the colon between hours and minutes)
14. Residual timing error (in PPM)
15. Microprocessor temperature (°C/°F)
16. Time of the next NTP sync
17. Status of the last WiFi connection
18. Status of the last NTP synchronization
19. WiFi Connectivity:
20. The clock requires a WiFi network for NTP synchronization. While this is a limiting factor, WiFi is common in most modern homes.

Additional Notes:

The learning and correction process continuously adapts to variations that might arise from temperature changes or component aging.

The very small duty cycle (<1.5%) drastically limits the microprocessor's self-heating, allowing it to be 'sealed' in an enclosure. This isolation protects the processor from sudden room temperature fluctuations, leading to a more stable drift characteristic.

Long-term accuracy validation is an ongoing process: The more precise the clock becomes, the longer the test period required to characterize its performance fully.

So far, the longest continuous test run has been one week; I will provide more detailed long-term data as it becomes available.

About this Instructables

This Instructable provides all the key information to understand how the Self-Learning Clock (SLC) works, and to build one yourself.

Whether your interest lies in exploring the concept and functionality of the clock, or in replicating the device, the following steps will guide you through both aspects.

Here’s what you’ll find:

1. Supplies
2. Step 1: Flash the ESP32-S3
3. Step 2: Copy the SLC Files
4. Step 3: Adjust the Settings
5. Step 4: Prepare the Connections Board
6. Step 5: Set the EPD to 3V3 (much Lower Consumption)
7. Step 6: First Check
8. Step 7: 3D Print the Box
9. Step 8: Assembly of the SLC
10. Step 9: Display Fields
11. Step 10: Enabling and Disabling Autostart
12. Step 11: Result Evaluation
13. Step 12: Conclusions
14. Step 13: Future Tasks
15. Step 14: Credits

1. 1 x LiLyGO TTGO T8-S3 (v1.2) [https://tinyurl.com/3tyy9sea].
2. 1 x WaveShare 4.2 inches epaper display [https://www.waveshare.com/wiki/Pico-ePaper-4.2]
3. 1x Lithium Polymer Battery 3.7V 2200mAh (77mm x 35.5mm x 8.5mm) [https://tinyurl.com/2d88ehw4]
4. 1x 4056 breakout board with protection circuit [https://tinyurl.com/m7vyyh32]
5. 1 x USB C DIY socket [https://tinyurl.com/264trdkj]
6. 1x Connections board to drastically reduce wiring, otherwise wires :-). The board can be made out of a perfoboard, otherwise the Gerber files are provided to order ita at a PCB manufacturer.
7. 2.54mm female and male headers.
8. some screws: See Assembly for the types.

Rationale for some of the chosen components:

I couldn’t get this project to run with the standard RAM (about 320 KB of DRAM) of a regular ESP32-S3 board.

The chosen board (LilyGO TTGO T8) offers several useful features for this project: 8 MB of PSRAM, a battery connector, and an IPEX connector as an alternative to the built-in antenna.

Although the T8 board includes charging circuitry for a LiPo battery, it doesn’t integrate a protection system. For this reason, I decided to add a TP4056 breakout board with a built-in protection circuit.

The Waveshare 4.2″ e-paper display is large and very neat. In addition, it offers flexibility — it can be connected either via wires or directly through the header, resulting in a cleaner assembly. Not to mention, I could buy the Pico version at a very reasonable price (about 24 € in September 2025).

https://docs.espressif.com/projects/esptool/en/latest/esp32/

1. Install esptool in your PC [instructions at https://micropython.org/download/ESP32_GENERIC_S3/]
2. Download the Micropython v1.26.1 bin image [https://micropython.org/download/ESP32_GENERIC_S3/]
3. Move the binary file to the folder where you run the esptool.
4. Connect the board to a PC via the usb-C port.
5. Check on which COM port the device is detected (i.e. via Device manager in Windows).
6. Erase the flash memory (replace <COM> with the COM port your device is detected, i.e. --port COM6):

1. Flash the OS (note this board has 8Mb PSRAM):

The code is stored at https://github.com/AndreaFavero71/Self_Learning_Clock

Copy all the files, and the lib folder, to the root of ESP32-S3; The needed libraries are included.

An easy way to copy the file is :

1. Download the SLC files to a known folder on your PC.
2. Connect the LiLyGO T8 board to your PC and launch Thonny → [https://thonny.org/].
3. In the bottom-right corner, check if the board is detected.
4. If not, click that corner and select the device/COM port associated with your ESP32.
5. Press the STOP button to let Thonny connect to the T8 board.
6. Enable the Files view: go to View → Files.
7. In the top-left panel, browse to the local folder on your PC.
8. In the bottom-left panel, you’ll see the files on your ESP32 device (it should be empty).
9. Select all files from the local source (click the first file, then Shift + Click the last one).
10. Right-click on one of the selected files and choose “Upload to /”.
11. Confirm the overwriting of the boot.py file.

Files will be coopied on the root of the T8 board

All settings are located at /lib/config folder.

There is one python file (config.py) and two json files (secrets.json and dst_rules.json).

The content of these files is self-explanatory, anyhow below is provided some more information.

Regional related settings:

The SLC works with UTC (Universal Time Coordinated) but it doesn't know in which part of the word is located.

Settings must be applied at config.py, and include:

1. Time Zone
2. If the Day Saving Time (DST) is used
3. If the DST is used, which rule follow
4. DST rules as structured in the dst_rules.json file.; It includes those for EU, US and AU. Adding new rules is possible and straight forward.
5. Temperature in Celsius or Fahrenheit
6. Date format (DMY, MDY and YMD)
7. the NTP servers:

Notes about NTP servers:

1. default NTP servers in config.py: ['pool.ntp.org', 'nl.pool.ntp.org', 'europe.pool.ntp.org', 'time.nist.gov', 'time.google.com', 'time.windows.com']
2. The second and third servers are respectively the National and the Continetal one where I live. These icould could be conveniently exchanged with servers located in your region.
3. The server ''pool.ntp.org' is internation, and tipically the fastest one the SLC can reach via my home WiFi network.

WiFi settings:

The SLC requires a WiFi network to operate.

You can enter your SSID and password (or more than one) in the secrets.json file.

In case of multiple SSIDs, the set priority in the json file are used by the clock to fall back to the next network if the previous one does not respond.

Optional: In case of no WiFi settings, or all the set networks are failing, the clock will then scan for open networks: In case it finds one or more, it will use the one with the strongest signal.

System settings:

There are a number of system settings, mainly for learning and debugging purposes, like:

1. DEBUG --> enable/disable verbose printing to the Shell.
2. OPEN_NETWORKS --> enable/disable the usage of free networks.
3. BATTERY --> enable/disable the battery operation.
4. PUSH_FILE_ENABLED --> enable/disable data sharing toward a local server.
5. QUICK_CHECK --> enable/disable a fast test to test the overall code (inaccurate time).
6. WDT_ENABLED --> enable/disable the watch dog timer.

The Connections board can be built on a prototyping board (fairly simple), or you can have a PCB manufactured.

If you choose the second option, the Gerber files are available at: https://github.com/AndreaFavero71/Self_Learning_Clock

Note: The 6-pin header is reserved for future use (not needed for the current build).

The Connections board provides both the 3V3 and VSYS power rails to the EPD.

The EPD includes a 0 Ω resistor at J2 between the pads “VCC_INT” and “VSYS”, which defines its default power supply.

When VSYS is used, the EPD circuitry employs a level shifter that continuously draws about 1.5 mA, even when the display is in deep sleep.

To reduce power consumption, it is possible to move the 0 Ω resistor to bridge “3V3” with “VCC_INT” at J2 (or remove the resistor and apply a small droplet of solder between these two pads).

With this modification, the EPD draws less than 10 µA when in deep sleep — that is, for more than 99.1% of the time.

Attached is the schematic of the Waveshare 4.2" Pico e-Paper display.

The SLC can be powered directly from your PC through the USB-C port on the LiLyGO T8 board.

Connect to the T8 via Thonny or another IDE.

Run the slc.py file — after about 20 seconds, the display should show the SLC logo.

If Wi-Fi has been configured, the clock will continue operating normally; otherwise, it will likely show a Wi-Fi error.

Once the first test is successful, you can proceed with the 3D printing and assembly.

There are a total of 5 parts

Screw list:

1. 1× M3×8 mm (or M3×10 mm) → Clip holding the battery and TP4056 breakout board
2. 4× M2.5×10 mm → Frame to EPD (e-paper display)
3. 4× M3×18 mm → Back cover to Frame

Assembly notes:

1. When preparing the wiring, remove the battery connector by cutting one wire at a time to prevent short circuits.
2. The attached pictures are ordered according to the suggested assembly sequence.
3. The Front is connected to the Frame via snap hooks; it can be assembled as the final step.

Edit the file boot.py (for example, using Thonny) and uncomment the commands from lines 5 to 13.

Save the file.

From now on, when the board boots, the SLC will start automatically.

To reboot the board, simply switch it OFF and then ON using the small slider switch.

Important Notes – Stopping the Code After Auto-Start

When the SLC is running, it spends over 99% of the time in light-sleep mode.

While the ESP32-S3 microcontroller is in light sleep, it cannot handle serial communication, so your PC will not recognize it as a connected USB device.

If you need to modify a setting or re-edit the code, follow these steps:

1. Open Thonny on your PC.
2. Connect the T8 board to your PC.
3. Press and release the small push button located behind the slider switch — this is the one soldered on the back side of the board, facing upward.
4. Press the STOP button in Thonny.
5. In the bottom-right corner, select the board/COM port corresponding to your ESP32.
6. Press Ctrl + C to interrupt the SLC code running in the background.
7. Double-click boot.py in the lower-left file list.
8. Select all the code with Ctrl + A.
9. Comment out all lines with Alt + 3.
10. Save the file with Ctrl + S.
11. Press the STOP button again.
12. From step 3 onward, you have about 10 seconds to prevent the code from restarting automatically.

After commenting out boot.py, the SLC will no longer start automatically, allowing you to modify or upload new files.

Improvement factor

A simple way to quantify the result is through an improvement factor, defined as the absolute ratio between the original error and the residual error.

In the first chart, the latest nightly tests are shown, where the improvement factor is plotted against the test time. It essentially illustrates how the clock improves over time.

You’ll notice two main groups:

1. One showing faster but less stable improvement, originally based on shorter periods.
2. Another showing slower but more stable improvement, obtained with longer periods.

The second chart shows the longest test I’ve performed so far. This one resulted from a mistake — I accidentally typed an extra zero in the milliseconds value, extending a 6-hour interval to 60 hours.

Anyway, since I was busy modeling the box and monitoring power consumption, I decided to let the test run.

Residual Error Evaluation

Another way to evaluate the result is by observing the residual error shown on the display as “Error (ppm)”.

For this you can refer to the third chart: An error of 100 ppm corresponds to a potential drift of 8.64 seconds per day.

After the initial two days of learning, the SLC automatically compensates for any remaining error every 12 hours as part of the NTP synchronization process.

A residual error of 200 ppm is normally reached within the first day.

More detailed long-term data will be provided as it becomes available.

This approach is for sure not the most precise, when the ojective is time accuracy.

Differently, it might be a real option for an indoor clock, or as timekeeping in battery operated systems that can tollerate a few seconds of inacuracy.

While there are many accurate timekeeping solutions available, I wanted to see how far I could push the accuracy of a microcontroller's own hardware, in a battery-operated device, and I'm quite pleased with the results.

1. Collect more data from long-term tests to evaluate whether a better model is possible.
2. Measure the SLC’s power consumption when powered by the battery (I currently don’t have a proper instrument). This will improve the autonomy estimation.
3. Investigate the feasibility of a micro solar panel for achieving full energy autonomy.
4. Since there is some unused space on the display, adding a weather forecast would be a nice enhancement.

Credits to:

1. Hackaday One Hertz Contest → [https://hackaday.io/contest/203248-one-hertz-challenge] for hosting so many inspiring projects. I particularly liked the one based on a tuning fork:[https://hackaday.io/project/202971-a-more-precise-tuning-fork-clock].

1. Volodymyr Shymanskyy → for his excellent lightweight asynchronous DNS client for MicroPython:[https://github.com/vshymanskyy/aiodns/tree/main]