Nous avons déjà fait un tutoriel sur Interface DS1307 avec le module ESP32 . Aujourd'hui, nous allons discuter des bases du capteur RTC DS3231 et vérifier comment l'interfacer avec la carte ESP32.
Table des matières:
1. Qu'est-ce que le module RTC DS3231 ?
2. Comment interfacer DS3231 avec ESP32
6. Comment afficher l'heure RTC DS3231 sur un écran OLED à l'aide de ESP32
1. Qu'est-ce que le module RTC DS3231
Le module DS3231 offre une chronométrage très précis. Il comprend un oscillateur à cristal compensé en température (TCXO) intégré pour nous donner l'heure avec une grande précision. Le module fonctionne sur le protocole I2C en utilisant la configuration maître-esclave. Il peut conserver l'heure et la date avec une batterie de secours même en l'absence d'alimentation principale. Il est couramment utilisé dans les appareils dépendants de l’heure et de la date.
Le DS3231 garde un œil sur les secondes, les minutes et les heures. Il peut également conserver un enregistrement des dates et des jours de la semaine. Lorsqu’il s’agit d’années bissextiles, il ajuste automatiquement l’heure en conséquence. En outre, il peut afficher l’heure au format 12 heures ou 24 heures, avec un indicateur AM/PM.
1.1. DS3231 contre DS1307
Le DS3231 et le DS1307 sont tous deux des modules de chronométrage avec prise en charge par batterie de secours. Cependant, le DS3231 est plus précis que le DS1307. La raison principale est que le DS1307 dépend d'un cristal externe de 32 kHz pour le chronométrage.
Cependant, le RTC DS3231 dispose d'un oscillateur à cristal interne à compensation de température (TCXO). Cela le rend moins affecté par la température extérieure et, par conséquent, il présente un avantage en termes de précision de quelques minutes par an par rapport au DS1307.
1.2. Brochage DS3231
Le DS3231 fonctionne en utilisant le protocole I2C. Au cœur de ce module RTC, nous avons la puce RTC précise conçue par Maxim. Cette puce gère toutes les fonctions temporelles et communique en utilisant la carte I2C avec ESP32 ou Arduino.
Les broches principales des modules RTC DS3231 sont :
- VCC : Connectez cette broche à la borne positive de votre source d'alimentation.
- GND : Connexion à la terre.
- SDA : Broche de données série (utilisée pour la communication I2C).
- SCL : Broche d'horloge série (fait également partie de l'interface I2C).
- QW : Broche de sortie Square Wave (peut générer un signal périodique, par exemple pour des alarmes ou à d'autres fins de synchronisation).
- 32K : Sortie d'oscillateur 32 kHz (utile pour les applications de synchronisation précise).
Voici les principaux composants embarqués du module RTC DS3231 :
- Support de batterie: Il permet au module de continuer à fonctionner lorsque l'alimentation externe est absente.
- Puce RTC : Cette puce conserve l'heure et la date.
- EEPROM AT24C32 : Il fournit un stockage non volatile pour l'enregistrement des données et à d'autres fins avec 1 000 000 de cycles d'écriture.
- TCXO : Oscillateur compensé en température pour fournir l'heure correcte pour une plage variable de températures.
- Capteur de température: Il prend des mesures de température et les fournit dans le cadre des fonctionnalités du module.
2. Comment interfacer DS3231 avec ESP32
Pour interfacer DS3231 avec ESP32, vous devez installer le Bibliothèque RTClib d'abord. Après avoir installé cette bibliothèque Adafruit RTC, vous pouvez connecter votre carte ESP32 au DS3231 en utilisant le protocole I2C. Pour connecter l'ESP32 I2C au module RTC DS3231, vous pouvez utiliser les broches ESP32 D21 et D22.
2.1. Schéma de câblage de l'ESP32 avec RTC DS3231
Tout d'abord, vous devez câbler l'ESP32 avec votre module I2C RTC DS3231. Suivez la configuration des broches ci-dessous pour le câblage :
Après avoir connecté l'ESP32 au RTC DS3231, votre schéma de câblage devrait ressembler à ceci. Vous pouvez également alimenter le DS3231 à partir de la broche VIN de l'ESP32. Les tensions de fonctionnement du DS3231 sont de 3,3 à 5,5 VDC.
2.2. Installation des bibliothèques requises
Une fois le circuit prêt, l'étape suivante consiste à configurez votre carte ESP32 avec l'IDE Arduino . Pour interfacer le DS3231, vous devrez installer le Bibliothèque RTClib . Vous pouvez l'installer en utilisant le gestionnaire de bibliothèque Arduino IDE.
3. Matériel
Vous aurez besoin du matériel suivant pour concevoir l'horloge RTC basée sur DS3231 avec ESP32 :
- Carte de développement ESP32
- Module RTC DS3231
- Pile CR2032
- Fils de liaison
- Planche à pain
4. Coder
Après avoir installé la bibliothèque RTC, la partie suivante consiste à écrire le code du DS3231 et à le télécharger sur la carte ESP32. Tout d’abord, vous devez écrire le code pour régler votre heure actuelle. Après avoir réglé l'heure dans DS3231, il se souviendra de l'heure et continuera à fonctionner même si votre carte ESP32 est éteinte.
Ouvrez maintenant l'IDE Arduino, compilez et gravez le code sur la carte ESP32.
#include#include
RTC_DS3231 rtc ; // Initialise une instance de la classe RTC_DS3231
vide installation ( ) {
En série. commencer ( 115200 ) ;
Fil. commencer ( ) ;
si ( ! RTC. commencer ( ) ) {
En série. imprimer ( 'RTC non détecté' ) ;
alors que ( 1 ) ; // Se bloque indéfiniment si RTC n'est pas trouvé
}
// Décommentez la ligne ci-dessous pour définir la date et l'heure initiales
//rtc.adjust(DateTime(__DATE__, __TIME__));
}
vide boucle ( ) {
// Lire l'heure actuelle du capteur (DS3231)
DateHeure maintenant = RTC. maintenant ( ) ;
// Imprime la date et l'heure sur la même ligne avec deux chiffres pour les heures, les minutes et les secondes
En série. imprimer ( 'Date actuelle: ' ) ;
En série. imprimer ( maintenant. année ( ) , DÉC ) ;
En série. imprimer ( '/' ) ;
imprimerDeuxChiffres ( maintenant. mois ( ) ) ;
En série. imprimer ( '/' ) ;
imprimerDeuxChiffres ( maintenant. jour ( ) ) ;
En série. imprimer ( ' Heure actuelle: ' ) ;
imprimerDeuxChiffres ( maintenant. heure ( ) ) ;
En série. imprimer ( ':' ) ;
imprimerDeuxChiffres ( maintenant. minute ( ) ) ;
En série. imprimer ( ':' ) ;
imprimerDeuxChiffres ( maintenant. deuxième ( ) ) ;
En série. imprimer ( ) ;
retard ( 1000 ) ; // Mise à jour toutes les 1 seconde
}
vide imprimerDeuxChiffres ( int nombre ) {
si ( nombre < dix ) {
En série. imprimer ( '0' ) ; // Ajout d'un zéro non significatif pour les nombres à un chiffre
}
En série. imprimer ( nombre ) ;
}
4.1. Explication du code
Le code commence par initialiser la communication série I2C à l'aide d'une bibliothèque de fils. Après cela, nous avons inclus la bibliothèque RTC d'Adafruit pour l'interface avec le module DS3231. Cette bibliothèque fournit une fonction pour interagir avec le module RTC DS3231.
Dans le installation partie, le bus I2C est démarré et vérifié pour les périphériques I2C disponibles. S'il n'est pas trouvé, le programme se bloque indéfiniment. Le débit en bauds est également défini afin que vous puissiez vérifier la sortie sur le moniteur série Arduino IDE.
Régler l'horloge pour la première fois
Lors de la programmation du DS3231, vous devez décommenter cette ligne . Cela obtiendra l'heure de votre système et la stockera dans la mémoire RTC. En faisant cela, l'horloge du module RTC est synchronisée avec l'horloge de votre système.
//rtc.adjust(DateTime(__DATE__, __TIME__)); 
Une fois l'heure définie, vous devez télécharger à nouveau le code ci-dessus, mais cette fois, vous devez commentez la ligne de fonction rtc.adjust() . Sinon, cela écrasera votre heure réglée précédente et lorsque votre ESP32 sera éteint, le RTC redémarrera à partir du moment où vous avez téléchargé le code.
En faisant cela, votre heure restera présente en arrière-plan du module RTC tant que le module RTC sera alimenté dans sa cellule CR2032.
Dans le boucle En partie, la date et l'heure actuelles sont lues à partir du module DS3231 à l'aide de la fonction rtc.now(). Les composants de date et d'heure sont extraits et la date formatée est imprimée sur le moniteur série Arduino IDE toutes les secondes.
5. Sortie
Après avoir téléchargé le code sur la carte ESP32, vous verrez l'heure commencer à s'imprimer sur le moniteur série Arduino IDE.
6. Comment afficher l'heure RTC DS3231 sur l'écran OLED à l'aide de ESP32
Vous pouvez également aller plus loin et afficher l'heure sur votre écran OLED après l'avoir lue depuis le DS3231. Pour cela, vous devez installer le Bibliothèque Adafruit GFX SSD1306 dans l'IDE Arduino.
Une fois installé, connectez l'ESP32 avec le module OLED et RTC dans la configuration suivante.
Après avoir connecté votre capteur, vous verrez le circuit ressembler au schéma ci-dessous.
Téléchargez maintenant le code DS3231 suivant sur la carte ESP32.
#include#include
#include
#include 'RTClib.h'
RTC_DS3231 rtc ;
carboniser jours [ 7 ] [ 12 ] = { 'Dimanche' , 'Lundi' , 'Mardi' , 'Mercredi' , 'Jeudi' , 'Vendredi' , 'Samedi' } ;
Affichage Adafruit_SSD1306 = Adafruit_SSD1306 ( 128 , 64 , & Fil , - 1 ) ;
vide installation ( ) {
En série. commencer ( 115200 ) ;
afficher. commencer ( SSD1306_SWITCHCAPVCC , 0x3C ) ;
si ( ! RTC. commencer ( ) ) {
En série. imprimer ( 'Impossible de trouver RTC ! Vérifiez le circuit.' ) ;
alors que ( 1 ) ;
}
// décommentez la ligne ci-dessous lors du réglage de l'heure pour la première fois
//rtc.adjust(DateTime(__DATE__, __TIME__));
afficher. effacerAfficher ( ) ;
afficher. définirTextColor ( BLANC ) ;
afficher. setTextSize ( 2 ) ;
afficher. définirCurseur ( 0 , vingt ) ;
afficher. imprimer ( 'HORLOGE RTC' ) ;
afficher. afficher ( ) ;
retard ( 5000 ) ;
}
vide boucle ( ) {
DateHeure maintenant = RTC. maintenant ( ) ;
afficher. effacerAfficher ( ) ;
afficher. setTextSize ( 2 ) ;
afficher. définirCurseur ( 75 , 0 ) ;
afficher. imprimer ( maintenant. deuxième ( ) , DÉC ) ;
afficher. setTextSize ( 2 ) ;
afficher. définirCurseur ( 25 , 0 ) ;
afficher. imprimer ( ':' ) ;
afficher. setTextSize ( 2 ) ;
afficher. définirCurseur ( 65 , 0 ) ;
afficher. imprimer ( ':' ) ;
afficher. setTextSize ( 2 ) ;
afficher. définirCurseur ( 40 , 0 ) ;
afficher. imprimer ( maintenant. minute ( ) , DÉC ) ;
afficher. setTextSize ( 2 ) ;
afficher. définirCurseur ( 0 , 0 ) ;
afficher. imprimer ( maintenant. heure ( ) , DÉC ) ;
afficher. setTextSize ( 2 ) ;
afficher. définirCurseur ( 0 , 25 ) ;
afficher. imprimer ( maintenant. jour ( ) , DÉC ) ;
afficher. imprimer ( jours [ maintenant. jour de la semaine ( ) ] ) ;
afficher. setTextSize ( 2 ) ;
afficher. définirCurseur ( vingt , 25 ) ;
afficher. imprimer ( '-' ) ;
afficher. setTextSize ( 2 ) ;
afficher. définirCurseur ( 35 , 25 ) ;
afficher. imprimer ( maintenant. mois ( ) , DÉC ) ;
afficher. setTextSize ( 2 ) ;
afficher. définirCurseur ( 60 , 25 ) ;
afficher. imprimer ( '-' ) ;
afficher. setTextSize ( 2 ) ;
afficher. définirCurseur ( 75 , 25 ) ;
afficher. imprimer ( maintenant. année ( ) , DÉC ) ;
afficher. afficher ( ) ;
}
Explication du code
Le code a commencé avec quelques bibliothèques importantes requises pour les écrans RTC et OLED. L'écran OLED est configuré à l'aide de la bibliothèque Adafruit SSD1306.
Dans la partie boucle, la date et l'heure actuelles sont obtenues à l'aide de rtc.now(). Après cela, l'écran OLED est effacé et les composantes de l'heure sont affichées au format d'horloge numérique. Vous pouvez également modifier le code pour ajuster le format de la date et de l'heure.
Une fois le code téléchargé sur votre tableau, vous obtiendrez l'heure actuelle sur l'écran OLED.
Note: Le code ci-dessus utilise le 0x3C Adresse I2C pour OLED. Il s'agit de l'adresse I2C la plus courante disponible sur les écrans OLED SSD1306. Si vous souhaitez trouver l'adresse I2C de votre écran OLED, vous pouvez exécuter le Code du scanner I2C .
Conclusion
DS3231 est un capteur RTC qui peut être utilisé pour le chronométrage. Il dispose d'une batterie de secours qui peut maintenir l'heure exacte même si votre carte microcontrôleur est éteinte. Pour interfacer ESP2 avec DS3231, vous devez installer la bibliothèque RTClib dans votre IDE Arduino. Après cela, vous devez connecter le module RTC via le protocole I2C à l'aide de la broche numérique de l'ESP32. Une fois connecté, téléchargez simplement le code et réglez l’heure. Désormais, le capteur RTC conservera l'heure et vous pourrez la lire sur votre moniteur série sur les projets basés sur le temps de conception.