Exemple Arduino UNO R4 WiFi Bluetooth RTC - Tutoriel de synchronisation de l'horloge en temps réel via BLE
Vue d'ensemble
L'exemple Bluetooth RTC fournit la synchronisation de l'horloge en temps réel via l'application DIYables Bluetooth STEM. Conçu pour l'Arduino UNO R4 WiFi utilisant BLE (Bluetooth Low Energy) pour synchroniser le RTC matériel intégré de la carte avec l'horloge de votre smartphone et afficher l'heure. L'Arduino UNO R4 WiFi dispose d'un module RTC intégré, ce qui en fait une solution idéale pour des projets de chronométrage sans besoin d'un matériel RTC externe. Parfait pour les horloges, l'enregistrement de données avec des horodatages, l'automatisation planifiée et les projets basés sur le temps.
Remarque : L'Arduino UNO R4 WiFi ne prend en charge que le BLE (Bluetooth Low Energy). Il ne prend pas en charge le Bluetooth classique. L'application Bluetooth DIYables prend en charge à la fois le BLE et le Bluetooth classique sur Android, et le BLE sur iOS. Puisque cette carte utilise le BLE, l'application fonctionne sur Android et iOS.
Fonctionnalités
- RTC matériel intégré: Utilise le RTC embarqué de l'Arduino UNO R4 WiFi — aucun module externe nécessaire
- Synchronisation de l'heure depuis le smartphone: Synchroniser l'heure depuis le smartphone via un horodatage Unix ou des composants de l'heure locale
- Affichage en temps réel: Afficher l'heure actuelle dans l'application, mise à jour toutes les secondes
- Demande d'heure: L'application peut demander l'heure actuelle à la carte
- Maintien du temps persistant: Le RTC garde l'heure tant que la carte est alimentée
- Fonctionne sur Android et iOS: BLE est pris en charge sur les deux plateformes
- Aucun appairage requis: BLE se connecte automatiquement sans appairage manuel
Préparation du matériel
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Démarrage DIYables STEM V4 IoT (Arduino inclus) | |
| 1 | × | Kit de Capteurs DIYables (30 capteurs/écrans) | |
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
Remarque : Aucun module RTC externe n'est nécessaire ! L'Arduino UNO R4 WiFi dispose d'un RTC matériel intégré accessible via la bibliothèque RTC.h.
Code Arduino UNO R4 WiFi
Étapes rapides
Suivez ces instructions étape par étape :
- Si c'est la première fois que vous utilisez l'Arduino UNO R4 WiFi, veuillez vous référer au Arduino UNO R4 - Installation du logiciel..
- Connectez la carte Arduino UNO R4 WiFi à votre ordinateur à l'aide d'un câble USB.
- Ouvrez l'IDE Arduino sur votre ordinateur.
- Sélectionnez la carte Arduino UNO R4 WiFi et le port COM approprié.
- Accédez à l'icône Libraries dans la barre de gauche de l'IDE Arduino.
- Recherchez "DIYables Bluetooth", puis trouvez la bibliothèque DIYables Bluetooth de DIYables.
- Cliquez sur le bouton Install pour installer la bibliothèque.
- Il vous sera demandé d'installer d'autres dépendances de bibliothèques
- Cliquez sur le bouton Tout installer pour installer toutes les dépendances des bibliothèques.
Code BLE
- Dans l'IDE Arduino, allez dans Fichier Exemples DIYables Bluetooth ArduinoBLE_RTC exemple, ou copiez le code ci-dessus et collez-le dans l'éditeur de l'IDE Arduino
/*
* DIYables Bluetooth Library - Bluetooth RTC Example
* Works with DIYables Bluetooth STEM app on Android and iOS
*
* This example demonstrates the Bluetooth RTC (Real-Time Clock) feature:
* - Real-time clock display for both Arduino and mobile app
* - One-click time synchronization from mobile app to Arduino
* - Hardware RTC integration for persistent timekeeping
* - Visual time difference monitoring
*
* Compatible Boards:
* - Arduino UNO R4 WiFi (with built-in RTC)
* Note: This example requires a board with hardware RTC.
* Other BLE boards can be used with an external RTC module (e.g., DS3231).
*
* Setup:
* 1. Upload the sketch to your Arduino
* 2. Open Serial Monitor to see connection status
* 3. Use DIYables Bluetooth App to connect and sync time
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothRTC.h>
#include <platforms/DIYables_ArduinoBLE.h>
#include "RTC.h"
// BLE Configuration
const char* DEVICE_NAME = "Arduino_RTC";
const char* SERVICE_UUID = "19B10000-E8F2-537E-4F6C-D104768A1214";
const char* TX_UUID = "19B10001-E8F2-537E-4F6C-D104768A1214";
const char* RX_UUID = "19B10002-E8F2-537E-4F6C-D104768A1214";
// Create Bluetooth instances
DIYables_ArduinoBLE bluetooth(DEVICE_NAME, SERVICE_UUID, TX_UUID, RX_UUID);
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create RTC app instance
DIYables_BluetoothRTC bluetoothRTC;
void setup() {
Serial.begin(9600);
delay(1000);
Serial.println("DIYables Bluetooth - RTC Example");
// Initialize RTC
RTC.begin();
// Check if RTC is running and set initial time if needed
RTCTime savedTime;
RTC.getTime(savedTime);
if (!RTC.isRunning() || savedTime.getYear() == 2000) {
Serial.println("RTC is NOT running, setting initial time...");
// Set a default time - you can modify this to match current time
RTCTime startTime(28, Month::AUGUST, 2025, 12, 0, 0, DayOfWeek::THURSDAY, SaveLight::SAVING_TIME_ACTIVE);
RTC.setTime(startTime);
Serial.println("RTC initialized with default time");
} else {
Serial.println("RTC is already running");
}
// Print initial RTC time
RTCTime initialTime;
RTC.getTime(initialTime);
Serial.print("Initial RTC Time: ");
Serial.print(initialTime.getYear());
Serial.print("/");
Serial.print(Month2int(initialTime.getMonth()));
Serial.print("/");
Serial.print(initialTime.getDayOfMonth());
Serial.print(" - ");
if (initialTime.getHour() < 10) Serial.print("0");
Serial.print(initialTime.getHour());
Serial.print(":");
if (initialTime.getMinutes() < 10) Serial.print("0");
Serial.print(initialTime.getMinutes());
Serial.print(":");
if (initialTime.getSeconds() < 10) Serial.print("0");
Serial.print(initialTime.getSeconds());
Serial.println();
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add RTC app to server
bluetoothServer.addApp(&bluetoothRTC);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
// Send current time to app on connection
sendCurrentTimeToApp();
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Set callback for time sync from mobile app (Unix timestamp)
bluetoothRTC.onTimeSync(onTimeSyncReceived);
// Set callback for local time sync from mobile app (date/time components)
bluetoothRTC.onLocalTimeSync(onLocalTimeSyncReceived);
// Set callback for time request from mobile app
bluetoothRTC.onTimeRequest(onTimeRequested);
Serial.println("Waiting for Bluetooth connection...");
Serial.println("Connect via app to sync time");
}
void loop() {
// Handle Bluetooth server communications
bluetoothServer.loop();
// Send current time to mobile app and print to Serial every 1 second
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 1000) {
lastUpdate = millis();
// Get current RTC time
RTCTime currentTime;
RTC.getTime(currentTime);
// Send time to mobile app in human readable format
bluetoothRTC.sendTime(currentTime.getYear(), Month2int(currentTime.getMonth()),
currentTime.getDayOfMonth(), currentTime.getHour(),
currentTime.getMinutes(), currentTime.getSeconds());
// Print time to Serial Monitor
Serial.print("RTC Time: ");
Serial.print(currentTime.getYear());
Serial.print("/");
Serial.print(Month2int(currentTime.getMonth()));
Serial.print("/");
Serial.print(currentTime.getDayOfMonth());
Serial.print(" - ");
if (currentTime.getHour() < 10) Serial.print("0");
Serial.print(currentTime.getHour());
Serial.print(":");
if (currentTime.getMinutes() < 10) Serial.print("0");
Serial.print(currentTime.getMinutes());
Serial.print(":");
if (currentTime.getSeconds() < 10) Serial.print("0");
Serial.print(currentTime.getSeconds());
Serial.println();
}
delay(10);
}
// Callback function called when mobile app sends time sync command
void onTimeSyncReceived(unsigned long unixTimestamp) {
Serial.print("Time sync received (Unix): ");
Serial.println(unixTimestamp);
// Convert Unix timestamp to RTCTime
RTCTime newTime;
newTime.setUnixTime(unixTimestamp);
// Set RTC time
RTC.setTime(newTime);
Serial.println("Arduino RTC synchronized from Unix timestamp!");
}
// Callback function called when mobile app sends local time sync with components
void onLocalTimeSyncReceived(int year, int month, int day, int hour, int minute, int second) {
Serial.print("Local time sync received: ");
Serial.print(year);
Serial.print("/");
Serial.print(month);
Serial.print("/");
Serial.print(day);
Serial.print(" ");
Serial.print(hour);
Serial.print(":");
Serial.print(minute);
Serial.print(":");
Serial.println(second);
// Create RTCTime from components (local time)
// Convert month integer to Month enum
Month monthEnum;
switch(month) {
case 1: monthEnum = Month::JANUARY; break;
case 2: monthEnum = Month::FEBRUARY; break;
case 3: monthEnum = Month::MARCH; break;
case 4: monthEnum = Month::APRIL; break;
case 5: monthEnum = Month::MAY; break;
case 6: monthEnum = Month::JUNE; break;
case 7: monthEnum = Month::JULY; break;
case 8: monthEnum = Month::AUGUST; break;
case 9: monthEnum = Month::SEPTEMBER; break;
case 10: monthEnum = Month::OCTOBER; break;
case 11: monthEnum = Month::NOVEMBER; break;
case 12: monthEnum = Month::DECEMBER; break;
default: monthEnum = Month::JANUARY; break;
}
RTCTime newTime(day, monthEnum, year, hour, minute, second, DayOfWeek::MONDAY, SaveLight::SAVING_TIME_ACTIVE);
// Set RTC time
RTC.setTime(newTime);
Serial.println("Arduino RTC synchronized from local time components!");
}
// Callback function called when mobile app requests current Arduino time
void onTimeRequested() {
Serial.println("Time requested by app");
sendCurrentTimeToApp();
}
// Helper function to send current time to mobile app
void sendCurrentTimeToApp() {
// Get current RTC time and send to app in human readable format
RTCTime currentTime;
RTC.getTime(currentTime);
bluetoothRTC.sendTime(currentTime.getYear(), Month2int(currentTime.getMonth()),
currentTime.getDayOfMonth(), currentTime.getHour(),
currentTime.getMinutes(), currentTime.getSeconds());
}
- Cliquez sur le bouton Upload dans l'IDE Arduino pour téléverser le code sur l'Arduino UNO R4 WiFi
- Ouvrez le Moniteur Série
- Vérifiez le résultat dans le Moniteur Série. Voici à quoi il ressemble :
COM6
DIYables Bluetooth - RTC Example
Waiting for Bluetooth connection...
RTC not running or year is 2000, waiting for time sync...
Autoscroll
Clear output
9600 baud
Newline
Application mobile
Note : L'application Bluetooth DIYables prend en charge à la fois BLE et Bluetooth classique sur Android, et BLE sur iOS. Comme l'Arduino UNO R4 WiFi utilise BLE, l'application fonctionne sur à la fois Android et iOS. Aucun appairage manuel n'est nécessaire pour BLE — il suffit de scanner et de se connecter.
- Ouvrez l'application Bluetooth DIYables
- Lors de la première ouverture de l'application, elle vous demandera les autorisations. Veuillez accorder les autorisations suivantes :
- Autorisation des appareils à proximité (Android 12+) / Autorisation Bluetooth (iOS) - nécessaire pour scanner et se connecter à des appareils Bluetooth
- Autorisation de localisation (Android 11 et versions antérieures uniquement) - requise par les anciennes versions d'Android pour scanner les appareils BLE
- Assurez-vous que le Bluetooth est activé sur votre téléphone
- À l'écran d'accueil, appuyez sur le bouton Connect. L'application va scanner les appareils BLE.
- Trouvez et appuyez sur "Arduino_RTC" dans les résultats du balayage pour vous connecter.
- Une fois connecté, l'application revient automatiquement à l'écran d'accueil. Sélectionnez l'application RTC dans le menu des applications.
Note : Vous pouvez appuyer sur l’icône des paramètres de l’écran d’accueil pour masquer/afficher les applications sur l’écran d’accueil. Pour plus de détails, consultez le Manuel d’utilisation de l’application Bluetooth DIYables.
- L'application affichera l'heure actuelle à partir du RTC de l'Arduino
- Utilisez le bouton Sync pour synchroniser l'heure du téléphone avec l'Arduino
- L'heure se met à jour chaque seconde
Revenez maintenant au moniteur série dans l'IDE Arduino. Vous verrez :
COM6
Bluetooth connected!
Time sync received (unix): 1719849600
RTC set to: 2025/07/01 12:00:00
Current time: 2025/07/01 12:00:01
Current time: 2025/07/01 12:00:02
Autoscroll
Clear output
9600 baud
Newline
Personnalisation créative - Adaptez le code à votre projet
Méthodes de synchronisation de l'heure
L'application peut synchroniser l'heure avec l'Arduino en utilisant deux méthodes :
// Method 1: Unix timestamp sync
bluetoothRTC.onTimeSync([](unsigned long unixTime) {
// Convert Unix timestamp and set RTC
Serial.print("Unix time: ");
Serial.println(unixTime);
});
// Method 2: Local time components sync
bluetoothRTC.onLocalTimeSync([](int year, int month, int day, int hour, int minute, int second) {
// Set RTC directly with components
Serial.print("Local time: ");
Serial.print(year);
Serial.print("/");
Serial.print(month);
Serial.print("/");
Serial.println(day);
});
Envoyer l'heure à l'application
// Send current time to the app
bluetoothRTC.sendTime(year, month, day, hour, minute, second);
Gestion des demandes de temps
bluetoothRTC.onTimeRequest([]() {
// App is requesting the current time
// Read RTC and send time back
RTCTime currentTime;
RTC.getTime(currentTime);
bluetoothRTC.sendTime(
currentTime.getYear(),
Month2int(currentTime.getMonth()),
currentTime.getDayOfMonth(),
currentTime.getHour(),
currentTime.getMinutes(),
currentTime.getSeconds()
);
});
Utilisation du RTC intégré
Le RTC intégré de l'Arduino UNO R4 WiFi est accessible via la bibliothèque RTC.h :
#include "RTC.h"
void setup() {
RTC.begin(); // Initialize the hardware RTC
}
// Set time on the RTC
RTCTime timeToSet;
timeToSet.setYear(2025);
timeToSet.setMonth(Month::JULY);
timeToSet.setDayOfMonth(1);
timeToSet.setHour(12);
timeToSet.setMinute(0);
timeToSet.setSecond(0);
RTC.setTime(timeToSet);
// Read time from the RTC
RTCTime currentTime;
RTC.getTime(currentTime);
int year = currentTime.getYear();
int month = Month2int(currentTime.getMonth());
int day = currentTime.getDayOfMonth();
int hour = currentTime.getHour();
int minute = currentTime.getMinutes();
int second = currentTime.getSeconds();
Exemples de programmation
Horloge avec affichage série
void loop() {
bluetoothServer.loop();
static unsigned long lastTime = 0;
if (millis() - lastTime >= 1000) {
lastTime = millis();
RTCTime currentTime;
if (RTC.getTime(currentTime)) {
char timeStr[20];
sprintf(timeStr, "%04d/%02d/%02d %02d:%02d:%02d",
currentTime.getYear(),
Month2int(currentTime.getMonth()),
currentTime.getDayOfMonth(),
currentTime.getHour(),
currentTime.getMinutes(),
currentTime.getSeconds());
Serial.println(timeStr);
// Also send to the app
bluetoothRTC.sendTime(
currentTime.getYear(),
Month2int(currentTime.getMonth()),
currentTime.getDayOfMonth(),
currentTime.getHour(),
currentTime.getMinutes(),
currentTime.getSeconds()
);
}
}
}
Enregistreur de données avec horodatages
void logSensorData() {
RTCTime currentTime;
RTC.getTime(currentTime);
float temperature = readSensor();
char logEntry[50];
sprintf(logEntry, "%04d/%02d/%02d %02d:%02d:%02d - Temp: %.1f°C",
currentTime.getYear(),
Month2int(currentTime.getMonth()),
currentTime.getDayOfMonth(),
currentTime.getHour(),
currentTime.getMinutes(),
currentTime.getSeconds(),
temperature);
Serial.println(logEntry);
}
Dépannage
Problèmes courants
- Impossible de trouver l'appareil dans l'application
- Assurez-vous que l'Arduino UNO R4 WiFi est alimenté et que le sketch est téléversé
- Assurez-vous que le Bluetooth de votre téléphone est activé
- Sur Android 11 et les versions antérieures, activez également les services de localisation
2. L'heure affichée est 2000/01/01 ou incorrecte
- La RTC doit être synchronisée au moins une fois après la mise sous tension.
- Utilisez le bouton de synchronisation dans l'application pour régler l'heure.
- La RTC perd du temps lorsque la carte est mise hors tension (pas de batterie de secours).
3. L'heure ne se synchronise pas depuis l'application
- Vérifiez que les callbacks onTimeSync et onLocalTimeSync sont configurés
- Vérifiez le moniteur série pour les messages de synchronisation
- Assurez-vous que la connexion BLE est stable
- L'horloge en temps réel dérive au fil du temps.
- Le cristal RTC intégré présente une précision limitée.
- Résynchroniser périodiquement via l'application.
- Pour les horodatages critiques, envisagez également d'utiliser NTP via le Wi‑Fi.
- Problèmes de conversion des mois
- L'Arduino UNO R4 WiFi RTC utilise une énumération Month, et non un entier
- Utilisez une fonction de conversion (comme Month2int() dans l'exemple) pour les mois sous forme d'entiers
- Les mois sont indexés à partir de 1 (janvier = 1)
- Échec du téléversement ou carte non reconnue
- Installer le dernier paquet de cartes Arduino UNO R4 via le Gestionnaire de cartes
- Essayez un autre câble USB ou un autre port
Idées de projets
- Horloge numérique avec synchronisation de l'heure BLE
- Enregistreur de données avec des horodatages précis
- Automatisation des tâches planifiées (allumer et éteindre à des heures spécifiques)
- Réveil avec contrôle par smartphone
- Enregistreur d'événements horodatés
Prochaines étapes
Après avoir maîtrisé l'exemple Bluetooth RTC, essayez :
- Moniteur Bluetooth - Pour l'affichage de l'état en texte avec des horodatages
- Tableau Bluetooth - Pour des données structurées avec des champs temporels
- Chat Bluetooth - Pour une communication bidirectionnelle
- Plusieurs Applications Bluetooth - En combinant RTC avec d'autres applications
Assistance
Pour obtenir une aide supplémentaire :
- Consultez la documentation de référence de l’API
- Visitez les tutoriels de DIYables (tutoriels de DIYables)
- Forums de la communauté Arduino