ESP32 WebRTC Voorbeeld - Tutorial Real-Time Klok Interface
Overzicht
Het WebRTC voorbeeld biedt een uitgebreide real-time klok interface voor uw ESP32 projecten. Ontworpen voor het ESP32 educatieve platform met ingebouwde RTC-mogelijkheden, verbeterde tijdbeheerfuncties en naadloze integratie met het educatieve ecosysteem. U kunt realtime klokinformatie tonen, tijd synchroniseren van de webbrowser naar Arduino, en tijdsverschillen monitoren via een intuïtieve webinterface.
Functies
- Real-time Klok Weergave: Toont huidige ESP32 RTC-tijd met automatische updates
- Vergelijking Apparaten Tijd: Toont webbrowser-/apparaatstijd naast ESP32-tijd
- Tijdsynchronisatie met één klik: Synchroniseer direct de ESP32 RTC met de webbrowser tijd
- Visuele Tijd Verschil Indicator: Toont tijdafwijking tussen apparaten in minuten
- Twee-regelige Tijdweergave: 12-uurs AM/PM formaat met volledige datumaanduiding
- Moderne Gradient UI: Kaartstijl-layout met responsief ontwerp
- WebSocket Communicatie: Real-time bidirectionele updates zonder pagina verversen
- Tijdzone-bewuste Synchronisatie: Gebruikt lokale apparaatstijd voor nauwkeurige synchronisatie
- Connectie Status Monitoring: Visuele indicatoren voor WebSocket verbindingsstatus
- Automatische Tijdaanvragen: Vraagt huidige ESP32 tijd op bij pagina laden
Benodigde Hardware
Of u kunt de volgende kits kopen:
| 1 | × | DIYables Sensorkit (30 sensoren/displays) | |
| 1 | × | DIYables Sensorkit (18 sensoren/displays) |
Openbaarmaking: Sommige van de links in deze sectie zijn Amazon-affiliate links. We kunnen een commissie ontvangen voor aankopen die via deze links worden gedaan, zonder extra kosten voor u. We waarderen uw steun.
Bedrading Schema
This image is created using Fritzing. Click to enlarge image
Als u niet weet hoe u ESP32 en andere componenten van stroom moet voorzien, vindt u instructies in de volgende tutorial: Hoe ESP32 van stroom te voorzien.
ESP32 - DS3231 RTC Module
| DS1307 RTC Module | ESP32 |
|---|---|
| Vin | 3.3V |
| GND | GND |
| SDA | GPIO21 |
| SCL | GPIO22 |
Snelle Stappen
Volg deze instructies stap voor stap:
- Als dit uw eerste keer is met ESP32, volg dan de handleiding voor het opzetten van de ESP32-omgeving in de Arduino IDE.
- Verbind de ESP32-ontwikkelmodule met uw computer via een USB-kabel.
- Start de Arduino IDE op uw computer.
- Selecteer het juiste ESP32 board (bijv. ESP32 Dev Module) en de juiste COM-poort.
- Ga naar het Libraries-icoon in de linkerzijbalk van de Arduino IDE.
- Zoek op "DIYables ESP32 WebApps" en vind de DIYables ESP32 WebApps Library van DIYables.
- Klik op de Install-knop om de bibliotheek te installeren.
- U wordt gevraagd om enkele andere bibliotheekafhankelijkheden te installeren.
- Klik op de Install All-knop om alle afhankelijkheden te installeren.
- Zoek op “RTClib” en vind de RTC-library van Adafruit.
- Klik op de Install-knop om de RTC-library te installeren.
- U wordt mogelijk gevraagd om afhankelijkheden voor de bibliotheek te installeren.
- Installeer alle afhankelijkheden door te klikken op de Install All-knop.
- In de Arduino IDE, ga naar File Examples DIYables ESP32 WebApps WebRTC voorbeeld, of kopieer de bovenstaande code en plak deze in de editor van Arduino IDE
/*
* DIYables WebApp Library - Web RTC Example
*
* This example demonstrates the Web RTC feature:
* - Real-time clock display for both ESP32 and client device
* - One-click time synchronization from web browser to ESP32
* - Hardware RTC integration for persistent timekeeping
* - Visual time difference monitoring
*
* Hardware Required:
* - ESP32 development board
* - DS3231 RTC module (connected via I2C)
*
* Required Libraries:
* - RTClib library (install via Library Manager)
*
* Setup:
* 1. Connect DS3231 RTC module to ESP32 I2C pins (SDA/SCL)
* 2. Install RTClib library in Arduino IDE
* 3. Update WiFi credentials below
* 4. Upload the sketch to your ESP32
* 5. Open Serial Monitor to see the IP address
* 6. Navigate to http://[IP_ADDRESS]/web-rtc
*/
#include <DIYables_ESP32_Platform.h>
#include <DIYablesWebApps.h>
#include <RTClib.h>
// RTC object
RTC_DS3231 rtc;
char daysOfWeek[7][12] = {
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday"
};
// WiFi credentials - UPDATE THESE WITH YOUR NETWORK
const char WIFI_SSID[] = "YOUR_WIFI_SSID";
const char WIFI_PASSWORD[] = "YOUR_WIFI_PASSWORD";
// Create WebApp server and page instances
ESP32ServerFactory serverFactory;
DIYablesWebAppServer webAppsServer(serverFactory, 80, 81);
DIYablesHomePage homePage;
DIYablesWebRTCPage webRTCPage;
void setup() {
Serial.begin(9600);
delay(1000);
Serial.println("DIYables ESP32 WebApp - Web RTC Example");
// Initialize RTC
if (!rtc.begin()) {
Serial.println("RTC module is NOT found");
Serial.flush();
while (1);
}
// Check if RTC lost power and if so, set the time
if (rtc.lostPower()) {
Serial.println("RTC lost power, setting time!");
// When time needs to be set on a new device, or after a power loss, the
// following line sets the RTC to the date & time this sketch was compiled
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
// This line sets the RTC with an explicit date & time, for example to set
// January 21, 2021 at 3am you would call:
// rtc.adjust(DateTime(2021, 1, 21, 3, 0, 0));
}
// Print initial RTC time
DateTime initialTime = rtc.now();
Serial.print("Initial RTC Time: ");
Serial.print(initialTime.year(), DEC);
Serial.print("/");
Serial.print(initialTime.month(), DEC);
Serial.print("/");
Serial.print(initialTime.day(), DEC);
Serial.print(" (");
Serial.print(daysOfWeek[initialTime.dayOfTheWeek()]);
Serial.print(") ");
if (initialTime.hour() < 10) Serial.print("0");
Serial.print(initialTime.hour(), DEC);
Serial.print(":");
if (initialTime.minute() < 10) Serial.print("0");
Serial.print(initialTime.minute(), DEC);
Serial.print(":");
if (initialTime.second() < 10) Serial.print("0");
Serial.print(initialTime.second(), DEC);
Serial.println();
// Add pages to server
webAppsServer.addApp(&homePage);
webAppsServer.addApp(&webRTCPage);
// Optional: Add 404 page for better user experience
webAppsServer.setNotFoundPage(DIYablesNotFoundPage());
// Set callback for time sync from web
webRTCPage.onTimeSyncFromWeb(onTimeSyncReceived);
// Set callback for time request from web
webRTCPage.onTimeRequestToWeb(onTimeRequested);
// Start the WebApp server
if (!webAppsServer.begin(WIFI_SSID, WIFI_PASSWORD)) {
while (1) {
Serial.println("Failed to connect to WiFi");
delay(1000);
}
}
}
void loop() {
// Handle web server
webAppsServer.loop();
// Send current time to web clients and print to Serial every 1 second
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 1000) {
lastUpdate = millis();
// Get current RTC time
DateTime currentTime = rtc.now();
// Send time to web clients in human readable format
webRTCPage.sendTimeToWeb(currentTime.year(), currentTime.month(),
currentTime.day(), currentTime.hour(),
currentTime.minute(), currentTime.second());
// Print time to Serial Monitor
Serial.print("RTC Time: ");
Serial.print(currentTime.year(), DEC);
Serial.print("/");
Serial.print(currentTime.month(), DEC);
Serial.print("/");
Serial.print(currentTime.day(), DEC);
Serial.print(" (");
Serial.print(daysOfWeek[currentTime.dayOfTheWeek()]);
Serial.print(") ");
if (currentTime.hour() < 10) Serial.print("0");
Serial.print(currentTime.hour(), DEC);
Serial.print(":");
if (currentTime.minute() < 10) Serial.print("0");
Serial.print(currentTime.minute(), DEC);
Serial.print(":");
if (currentTime.second() < 10) Serial.print("0");
Serial.print(currentTime.second(), DEC);
Serial.println();
}
delay(10);
}
// Callback function called when web client sends time sync command
void onTimeSyncReceived(unsigned long unixTimestamp) {
Serial.print("Time sync received: ");
Serial.println(unixTimestamp);
// Convert Unix timestamp to DateTime and set RTC time
DateTime newTime(unixTimestamp);
rtc.adjust(newTime);
Serial.println("ESP32 RTC synchronized!");
}
// Callback function called when web client requests current ESP32 time
void onTimeRequested() {
// Get current RTC time and send to web in human readable format
DateTime currentTime = rtc.now();
webRTCPage.sendTimeToWeb(currentTime.year(), currentTime.month(),
currentTime.day(), currentTime.hour(),
currentTime.minute(), currentTime.second());
}
- Configureer WiFi-inloggegevens in de code door deze regels aan te passen:
const char WIFI_SSID[] = "YOUR_WIFI_NETWORK";
const char WIFI_PASSWORD[] = "YOUR_WIFI_PASSWORD";
- Klik op de Upload-knop in de Arduino IDE om de code naar de ESP32 te uploaden.
- Open de Serial Monitor in Arduino IDE.
- Wacht tot de verbinding met WiFi is gemaakt en WiFi-informatie wordt weergegeven in de Serial Monitor.
- Controleer het resultaat in de Serial Monitor. Dit ziet er als volgt uit:
COM6
DIYables ESP32 WebApp - Web RTC Example
Initial RTC Time: 2025/8/28 (Thursday) 12:00:08
INFO: Added app /
INFO: Added app /web-rtc
DIYables WebApp Library
Platform: ESP32
Network connected!
IP address: 192.168.0.2
HTTP server started on port 80
Configuring WebSocket server callbacks...
WebSocket server started on port 81
WebSocket URL: ws://192.168.0.2:81
WebSocket server started on port 81
==========================================
DIYables WebApp Ready!
==========================================
📱 Web Interface: http://192.168.0.2
🔗 WebSocket: ws://192.168.0.2:81
📋 Available Applications:
🏠 Home Page: http://192.168.0.2/
🕐 Web RTC: http://192.168.0.2/web-rtc
==========================================
Autoscroll
Clear output
9600 baud
Newline
- Als u niets ziet, herstart dan uw ESP32 board.
Gebruik van de Webinterface
- Open een webbrowser op uw computer of mobiele apparaat dat verbonden is met hetzelfde WiFi-netwerk.
- Typ het IP-adres dat in de Serial Monitor wordt weergegeven in de webbrowser.
- Bijvoorbeeld: http://192.168.1.100
- U ziet de startpagina zoals hieronder afgebeeld:
- Klik op de Web RTC-link, u ziet dan de UI van de Web RTC app zoals hieronder:
- U kunt de pagina ook direct bereiken door het IP-adres te gebruiken gevolgd door /web-rtc. Bijvoorbeeld: http://192.168.1.100/web-rtc
- De Web RTC interface toont dan:
- Arduino Tijd: Huidige tijd van de Arduino RTC
- Uw Apparaat Tijd: Huidige tijd van uw webbrowser/apparaat
- Tijdverschil: Verschil tussen de twee tijden in minuten
- Sync ESP32 Tijd Knop: Klik om ESP32 tijd te synchroniseren met uw apparaat
Tijdsynchronisatie
- Klik op de knop "Sync ESP32 Time" om de Arduino RTC te synchroniseren met de lokale tijd van uw apparaat.
- Het synchronisatieproces verloopt als volgt:
- Leest de huidige lokale tijd van uw apparaat (niet UTC)
- Past de tijdzone-offset aan om nauwkeurige lokale tijdsynchrone te garanderen
- Stuurt een tijdstempel naar Arduino via WebSocket
- Arduino werkt zijn RTC bij met de ontvangen tijd
- Webinterface wordt bijgewerkt om de gesynchroniseerde tijd te tonen
Na synchronisatie zou het tijdsverschil minimaal moeten zijn (gewoonlijk 0-1 minuten)
De ESP32 behoudt een nauwkeurige tijd, zelfs nadat de webinterface gesloten is
Code Uitleg
Sleutelelementen
#include <DIYablesWebApps.h>
#include <RTClib.h>
// Initialiseer RTC-object en webserver
RTC_DS3231 rtc;
DIYablesWebAppServer server;
DIYablesWebRTCPage rtcPage;
// Array voor dagen van de week voor weergave
char daysOfWeek[7][12] = {
"Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday"
};
Setup Functie
void setup() {
Serial.begin(9600);
// Initialiseer DS3231 RTC module
if (!rtc.begin()) {
Serial.println("RTC module is NIET gevonden");
Serial.flush();
while (1);
}
// Controleer of RTC stroom verloor en zet tijd indien nodig
if (rtc.lostPower()) {
Serial.println("RTC stroom verloren, tijd instellen!");
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}
// Setup WiFi verbinding
server.setupWiFi(WIFI_SSID, WIFI_PASSWORD);
// Voeg RTC pagina toe aan server
server.addWebApp(rtcPage);
// Stel callback functies in
rtcPage.onTimeSyncFromWeb(onTimeSyncReceived);
rtcPage.onTimeRequestToWeb(onTimeRequested);
// Start de server
server.begin();
}
Callback Functies
Tijdsynchronisatie Callback:
// Wordt aangeroepen wanneer de webinterface een tijdsync commando stuurt
void onTimeSyncReceived(unsigned long unixTimestamp) {
Serial.print("Tijdsync ontvangen: ");
Serial.println(unixTimestamp);
// Converteer Unix-timestamp naar DateTime en stel RTC in
DateTime newTime(unixTimestamp);
rtc.adjust(newTime);
Serial.println("ESP32 RTC gesynchroniseerd!");
}
Tijd Aanvraag Callback:
// Wordt aangeroepen wanneer webinterface huidige ESP32 tijd opvraagt
void onTimeRequested() {
DateTime currentTime = rtc.now();
// Verstuur huidige tijd naar webinterface
rtcPage.sendTimeToWeb(
currentTime.year(),
currentTime.month(),
currentTime.day(),
currentTime.hour(),
currentTime.minute(),
currentTime.second()
);
}
Hoofdlus
void loop() {
server.handleClient();
// Verstuur elke seconde de huidige tijd naar webclients
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 1000) {
lastUpdate = millis();
DateTime currentTime = rtc.now();
// Verstuur tijd naar webclients
rtcPage.sendTimeToWeb(currentTime.year(), currentTime.month(),
currentTime.day(), currentTime.hour(),
currentTime.minute(), currentTime.second());
// Print tijd naar Serial Monitor
Serial.print("RTC Tijd: ");
Serial.print(currentTime.year(), DEC);
Serial.print("/");
Serial.print(currentTime.month(), DEC);
Serial.print("/");
Serial.print(currentTime.day(), DEC);
Serial.print(" (");
Serial.print(daysOfWeek[currentTime.dayOfTheWeek()]);
Serial.print(") ");
if (currentTime.hour() < 10) Serial.print("0");
Serial.print(currentTime.hour(), DEC);
Serial.print(":");
if (currentTime.minute() < 10) Serial.print("0");
Serial.print(currentTime.minute(), DEC);
Serial.print(":");
if (currentTime.second() < 10) Serial.print("0");
Serial.print(currentTime.second(), DEC);
Serial.println();
}
delay(10);
}
API Methoden
DIYablesWebRTCPage Klasse Methoden
onTimeSyncFromWeb(callback)
- Stelt de callback-functie in die tijdsynchronisatie vanuit de webbrowser afhandelt
- Parameter: void (*callback)(unsigned long unixTimestamp)
- Gebruik: Wordt aangeroepen wanneer gebruiker op "Sync ESP32 Time" knop klikt
onTimeRequestToWeb(callback)
- Stelt de callback-functie in die tijdaanvragen vanuit de webbrowser afhandelt
- Parameter: void (*callback)()
- Gebruik: Wordt aangeroepen wanneer webinterface de huidige ESP32 tijd opvraagt
sendTimeToWeb(year, month, day, hour, minute, second)
- Stuurt de huidige ESP32 tijd naar de webinterface
- Parameters:
- year: Huidig jaar (bijv. 2025)
- month: Huidige maand (1-12)
- day: Huidige dag van de maand (1-31)
- hour: Huidig uur (0-23)
- minute: Huidige minuut (0-59)
- second: Huidige seconde (0-59)
WebSocket Communicatie
Berichten van Web naar Arduino
- RTC:GET_TIME - Vraag de huidige ESP32 tijd op
- RTC:SYNC:[timestamp] - Synchroniseer ESP32 tijd met Unix timestamp
Berichten van ESP32 naar Web
- DATETIME:YYYY,MM,DD,HH,MM,SS - Stuur huidige ESP32 tijd-componenten
Problemen Oplossen
Veelvoorkomende Problemen
1. Tijdverschil van enkele uren
- Probleem: ESP32 toont een tijd die meerdere uren afwijkt van de apparaattijd
- Oorzaak: Doorgaans een tijdzoneprobleem of RTC niet goed geïnitialiseerd
- Oplossing:
- Klik op de knop "Sync ESP32 Time" om opnieuw te synchroniseren
- Controleer of RTC correct is geïnitialiseerd in setup()
- Zorg voor een stabiele WiFi-verbinding
- Probleem: RTC-module wordt niet gedetecteerd tijdens initialisatie
- Oorzaak: DS3231-module is slecht aangesloten of defect
- Oplossing:
- Controleer I2C bedrading (SDA naar GPIO21, SCL naar GPIO22)
- Controleer voedingsaansluitingen (VCC naar 3.3V/5V, GND naar GND)
- Test met een I2C-scanner om moduleadres te detecteren
- Probeer een andere DS3231-module indien beschikbaar
- Probleem: Fout bij WebSocket-verbinding
- Oorzaak: Verbindingsfout
- Oplossing:
- Controleer of ESP32 IP-adres correct is
- Vernieuw de webpagina
- Controleer of ESP32 verbonden is met hetzelfde WiFi-netwerk
- Controleer firewallinstellingen
- Probleem: Tijdweergave bevriest of wordt niet bijgewerkt
- Oorzaak: WebSocket-verbinding verbroken of RTC is gestopt
- Oplossing:
- Vernieuw de webpagina
- Controleer de status van de WebSocket-verbinding
- Herstart de ESP32 als de RTC niet meer reageert
- Probleem: Tijdverschil toont duizenden minuten verschil
- Oorzaak: RTC was niet goed ingesteld of is aanzienlijk gedrift
- Oplossing: Klik meerdere keren op sync-knop en verifieer of callback-functies werken
2. Foutmelding "RTC module is NOT found"
3. Foutmelding "Not connected to Arduino" bij klik op synchroniseerknop
4. Tijd stopt met bijwerken
5. Grote tijdsverschillen (dagen/maanden)
Debug Tips
Enable Serial Debugging:
void onTimeSyncReceived(unsigned long unixTimestamp) {
Serial.print("Tijdsync ontvangen: ");
Serial.println(unixTimestamp);
// ... rest van functie
}
void onTimeRequested() {
Serial.println("Tijdaanvraag ontvangen van web");
// ... rest van functie
}
Controleer RTC Initialisatie:
void setup() {
// ... overige setup code
if (!rtc.begin()) {
Serial.println("RTC module is NIET gevonden");
Serial.println("Controleer I2C bedrading:");
Serial.println("SDA -> GPIO 21");
Serial.println("SCL -> GPIO 22");
Serial.println("VCC -> 3.3V of 5V");
Serial.println("GND -> GND");
while (1);
}
Serial.println("DS3231 RTC succesvol geïnitialiseerd");
if (rtc.lostPower()) {
Serial.println("RTC stroom verloren, wordt ingesteld op compileertijd");
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}
}
Geavanceerd Gebruik
Data Logging met Timestamps
void logSensorData(float temperature, float humidity) {
DateTime currentTime = rtc.now();
String logEntry = String(currentTime.year()) + "-" +
String(currentTime.month()) + "-" +
String(currentTime.day()) + " " +
String(currentTime.hour()) + ":" +
String(currentTime.minute()) + ":" +
String(currentTime.second()) + " (" +
String(daysOfWeek[currentTime.dayOfTheWeek()]) + ") - " +
"Temp: " + String(temperature) + "°C, " +
"Vochtigheid: " + String(humidity) + "%";
Serial.println(logEntry);
// Opslaan op SD-kaart, verzenden naar database, etc.
}
Geplande Acties
void checkScheduledActions() {
DateTime currentTime = rtc.now();
// Zet LED elke dag om 6:00 uur aan
if (currentTime.hour() == 6 && currentTime.minute() == 0 && currentTime.second() == 0) {
digitalWrite(LED_BUILTIN, HIGH);
Serial.print("Ochtended LED geactiveerd! Tijd: ");
Serial.print(daysOfWeek[currentTime.dayOfTheWeek()]);
Serial.print(" ");
Serial.print(currentTime.hour());
Serial.print(":");
Serial.println(currentTime.minute());
}
// Zet LED elke dag om 22:00 uur uit
if (currentTime.hour() == 22 && currentTime.minute() == 0 && currentTime.second() == 0) {
digitalWrite(LED_BUILTIN, LOW);
Serial.println("Avond LED gedeactiveerd!");
}
}
Integratie van Meerdere Web Apps
// Combineer WebRTC met andere webapps
server.addWebApp(rtcPage); // Real-time klok
server.addWebApp(monitorPage); // Serial monitor met timestamps
server.addWebApp(plotterPage); // Data plotting met tijdas
Toepassingen en Gebruiksscenario’s
Educatieve Projecten
- Leren over Tijdbeheer: Studenten leren over RTC, tijdsregistratie en synchronisatie
- IoT Tijdconcepten: Demonstreren van netwerksynchronisatie in IoT-systemen
- Data Logging Projecten: Timestamps toevoegen aan sensorwaarden en experimenten
- Planningssystemen: Tijdgebaseerde automatisering en besturingssystemen creëren
Praktische Toepassingen
- Home Automation: Verlichten, irrigatie of andere apparaten op schema zetten
- Data Acquisitie: Sensorwaarden voorzien van tijdstempel voor analyse
- Event Logging: Registreren wanneer gebeurtenissen plaatsvinden met accurate tijd
- Remote Monitoring: Controle van apparaatstatus en laatste update tijden op afstand
Voordelen voor STEM-onderwijs
- Tijdzoneconcepten: Begrijpen van lokale tijd vs. UTC en tijdzonebeheer
- Netwerkcommunicatie: Leren over WebSocket communicatie en real-time updates
- Hardware Integratie: Combineren van webinterfaces met hardware RTC functionaliteit
- Probleemoplossing: Debuggen van timingproblemen en synchronisatie-uitdagingen
Technische Specificaties
Geheugen Gebruik
- Flash Memory: ~8KB voor WebRTC-functionaliteit
- SRAM: ~2KB tijdens werking
- WebSocket Buffer: ~1KB voor berichtafhandeling
Prestatiekenmerken
- Update Frequentie: Real-time updates via WebSocket
- Synchronisatie Nauwkeurigheid: Meestal binnen 1-2 seconden
- Netwerk Overhead: ~50 bytes per tijdupdatebericht
- Reactietijd: <100ms voor tijdsync-operaties
Compatibiliteit
- ESP32 boards: ESP32, ESP32 Web Apps
- Browsers: Alle moderne browsers met WebSocket ondersteuning
- Apparaten: Desktop, tablet en mobiele apparaten
- Netwerken: WiFi-netwerken met internettoegang
Samenvatting
Het WebRTC voorbeeld toont aan hoe u:
- Een webgebaseerde real-time klokinterface maakt
- De ESP32 RTC synchroniseert met de webbrowser tijd
- Tijdinformatie in een gebruikersvriendelijk formaat toont
- Tijdverschillen en verbindingsstatus monitort
- Tijdfunctionaliteit integreert met andere webapplicaties
- Educatieve IoT-projecten bouwt met tijdbeheerfuncties
Dit voorbeeld is perfect voor projecten die nauwkeurige tijdregistratie, data logging met timestamps, geplande automatisering en educatieve demonstraties van tijdsynchronisatieconcepten in IoT-systemen vereisen.