Connexion Arduino de l'horloge temps réel DS3231. Synchronisation de l'heure du module DS3231 avec l'ordinateur

Caractéristiques distinctives:

Précision ±2 ppm sur une plage de température de 0°C à +40°C
Précision ±3,5 ppm sur la plage de température -40°C à +85°C
Entrée pour connecter une source d'alimentation autonome pour assurer un fonctionnement continu
Plage de température de fonctionnement commercial : de 0°C à +70°C industriel : -40°C à +85°C
Faible consommation
Horloge en temps réel comptant les secondes, les minutes, les heures, les jours de la semaine, les jours du mois, le mois et l'année avec correction des années bissextiles jusqu'à 2100
Deux alarmes quotidiennes
Sortie onde carrée avec fréquence programmable
Interface I2C rapide (400 kHz)
Alimentation 3,3 V
Capteur de température numérique avec précision de mesure ±3°C
Registre contenant des données sur l'ajustement requis
entrée/sortie de réinitialisation non RST

Application:

Les serveurs
Compteurs d'électricité électroniques
Équipement télématique
Systèmes GPS

Schéma de connexion typique pour DS3231 :

Description générale:

Le DS3231 est une horloge temps réel (RTC) de haute précision avec interface I 2 C intégrée, oscillateur à cristal compensé en température (TCXO) et résonateur à quartz. L'appareil dispose d'une entrée pour connecter une source d'alimentation autonome de secours, qui permet le chronométrage et la mesure de la température même lorsque la tension d'alimentation principale est coupée. Le résonateur à quartz intégré augmente la durée de vie de l'appareil et réduit le nombre requis d'éléments externes. Le DS3231 est disponible en versions de température commerciale et industrielle et est conditionné dans un boîtier SO à 16 broches de 300 mil.

RTC permet de compter les secondes, les minutes, les heures, les jours de la semaine, les jours du mois et de l'année. La date de fin de mois est déterminée automatiquement en tenant compte des années bissextiles. L'horloge en temps réel fonctionne au format 24 ou 12 heures avec indication de la moitié de la journée en cours (AM/PM). L'appareil dispose de deux alarmes quotidiennes et d'une sortie d'onde carrée avec une fréquence programmable. L'échange de données avec l'appareil s'effectue via l'interface compatible série I 2 C intégrée.

De nombreux appareils nécessitent un enregistrement constant des données chronométriques (date, heure) ; cette fonction est réalisée par des circuits électroniques, appelée horloge en temps réel. Actuellement, une horloge en temps réel est réalisée sous la forme d'un microcircuit séparé, auquel il faut ajouter un résonateur à quartz et une alimentation autonome. Dans certains microcircuits, un résonateur à quartz est intégré à l'intérieur. Une de ces horloges sur une puce DS3231SN je l'ai acheté pour le mien projets . Dans l'exemple, je vais connecter une horloge en temps réel à un analogique chinois Arduino UNO.

Il s'agit d'un module ZS-042 complet qui peut être connecté à divers appareils, pas seulement à la plateforme Arduino.

Le module est construit sur un microcircuit DS3231SN qui est essentiellement une horloge en temps réel. Contrairement à l'ancien modèle de montre, par exemple sur la puce DS1307, cette montre contient un résonateur à quartz interne, grâce auquel la montre a une heure précise.

Vous pouvez implémenter une horloge sur Arduino sans DS3231SN, mais en cas de coupure de courant, les valeurs de la minuterie sont réinitialisées.Ces mêmes horloges disposent d’une alimentation de secours, donc en cas de panne de courant, elles continuent de fonctionner.

La montre peut compter les heures, les minutes, les secondes, les dates, les mois, les années (les années bissextiles sont prises en compte jusqu'en 2100). Ils fonctionnent en mode 12 ou 24 heures, contiennent deux réveils et disposent également d'un thermomètre interne avec une plage de -40°C à + 85°C. Pour se connecter à divers appareils, l'horloge se connecte via Interface I2C.

Emplacement et fonction des broches sur le module ZS-042 :

S.Q.W.- Sortie de signal à onde carrée programmable.

SCL– Grâce à cette broche, les données sont échangées avec l'horloge via l'interface I2C.

S.D.A.– Les données de la montre sont transmises via cette broche.

VCC– Alimentation pour horloge temps réel, 5 volts requis. Si aucune tension n’est fournie à cette broche, la montre passe en mode veille.

GND- Terre.

Pour se connecter à Arduino UNO, Nous connectons la broche SDA de l'horloge à la broche A4 et la broche SCL à A5. Les broches GND(-) et VCC(+5v) sont utilisées pour l'alimentation.

Broches SDA et SCL sur différentes cartes Arduino :

	S.D.A.	SCL
ONU	A4	A5
Mini	A4	A5
Nano	A4	A5
Méga2560	20	21
Léonard	2	3

Installons une pile CR2032 dans la montre ; ces éléments sont utilisés pour alimenter le BIOS des ordinateurs.

À Connexion USB câble à l'Arduino, la LED de l'horloge doit s'allumer " POUVOIR" (LED rouge).

Pour programmer l'horloge via EDI Arduino vous devez installer des bibliothèques.

Télécharger la bibliothèque Temps et DS1307RTC.

La dernière bibliothèque a été écrite pour une horloge sur la puce DS1307, mais ses protocoles d'interaction sont compatibles avec le DS3231, la bibliothèque s'adaptera donc à notre horloge.

Les bibliothèques doivent être téléchargées, décompressées et placées dans le dossier "bibliothèques" Au démarrage de l'IDE Arduino, ils avec des exemples devraient apparaître dans " Échantillons».

Réglez la date et l'heure.

Pour ce faire, copiez ce code dans l'IDE Arduino.

Pour des paramètres corrects, vous devez modifier les données dans la ligne

setTime(13,35,0,22,12,2016);

Entre parenthèses, séparées par des virgules, définissez les bonnes : heures, minutes, secondes, jour, mois, année. Dans mon exemple, il est réglé sur 13 heures 35 minutes 0 seconde, le 22 décembre 2016. Téléchargez le croquis sur Arduino.

Maintenant, pour lire les lectures de l'horloge, vous pouvez utiliser l'exemple : " Déposer» - « Échantillons» - « DS1307RTC» - « LireTest" Et derrière téléchargez-le sur Arduino.

La fenêtre qui s'ouvre affichera la date et l'heure actuelles. Si vous coupez l'alimentation du module d'horloge de l'Arduino, l'Arduino ne pourra pas suivre les valeurs et après un certain temps le message " ...erreur de lecture! "(surligné en rouge). Une fois le courant rétabli, la date et l'heure continueront à décompter. La date et l'heure n'ont pas été réinitialisées car la montre était alimentée par sa pile CR2032.

Dans de nombreux projets Arduino, il est nécessaire de surveiller et d'enregistrer l'heure d'apparition de certains événements. Module horloge temps réel équipé de piles supplémentaires, permet de stocker date actuelle, quelle que soit la disponibilité de l'alimentation sur l'appareil lui-même. Dans cet article, nous parlerons des modules RTC DS1307, DS1302, DS3231 les plus courants pouvant être utilisés avec la carte Arduino.

Le module d'horloge est une petite carte contenant, en règle générale, l'un des microcircuits DS1307, DS1302, DS3231. De plus, sur la carte, vous pouvez pratiquement trouver un mécanisme d'installation de batterie. Ces tableaux sont souvent utilisés pour suivre l'heure, la date, le jour de la semaine et d'autres paramètres chronométriques. Les modules fonctionnent sur alimentation autonome - piles, accumulateurs et continuent de compter même si l'alimentation de l'Arduino est coupée. Les modèles de montres les plus courants sont DS1302, DS1307, DS3231. Ils sont basés sur un module RTC (real time clock) connecté à Arduino.

L'horloge compte dans des unités pratiques à une personne ordinaire– minutes, heures, jours de la semaine et autres, contrairement aux compteurs et générateurs d'horloge classiques qui lisent des « ticks ». Arduino a fonction spéciale millis(), qui peut également lire différents intervalles de temps. Mais le principal inconvénient de cette fonction est qu'elle se remet à zéro lorsque la minuterie est activée. Avec son aide, vous ne pouvez lire que l'heure ; il est impossible de régler la date ou le jour de la semaine. Des modules d'horloge en temps réel sont utilisés pour résoudre ce problème.

Le circuit électronique comprend un microcircuit, une alimentation, un résonateur à quartz et des résistances. Le résonateur à quartz fonctionne à une fréquence de 32 768 Hz, ce qui est pratique pour un compteur binaire classique. Le circuit DS3231 est doté d'un quartz et d'une stabilisation thermique intégrés, ce qui permet d'obtenir des valeurs très précises.

Comparaison des modules RTC populaires DS1302, DS1307, DS3231

Dans ce tableau, nous avons fourni une liste des modules les plus populaires et leurs principales caractéristiques.

Nom	Fréquence	Précision	Protocoles pris en charge
DS1307	1 Hz, 4,096 kHz, 8,192 kHz, 32,768 kHz	Cela dépend du quartz - généralement la valeur atteint 2,5 secondes par jour, il est impossible d'obtenir une précision supérieure à 1 seconde par jour. La précision dépend également de la température.	I2C
DS1302	32,768 kHz	5 secondes par jour	I2C, SPI
DS3231	Deux sorties - la première à 32,768 kHz, la seconde programmable de 1 Hz à 8,192 kHz	±2 ppm à des températures de 0C à 40C. ±3,5 ppm à des températures de -40 C à 85 C. Précision de la mesure de la température – ±3С	I2C

ModuleDS1307

DS1307 est un module utilisé pour la synchronisation. Il est assemblé sur la base de la puce DS1307ZN, l'alimentation provient d'une batterie au lithium pour la mise en œuvre vie de la batterie sur une longue période. La batterie sur la carte est montée au verso. Le module dispose d'une puce AT24C32 - il s'agit d'une mémoire EEPROM non volatile de 32 Ko. Les deux microcircuits sont connectés par un bus I2C. Le DS1307 a une faible consommation d'énergie et contient une horloge et un calendrier pour l'année 2100.

Le module a les paramètres suivants :

Alimentation – 5V ;
Plage de température de fonctionnement de -40 °C à 85 °C ;
56 octets de mémoire ;
Batterie au lithium LIR2032 ;
Met en œuvre les modes 12 et 24 heures ;
Prise en charge des interfaces I2C.

Le module est justifié dans les cas où les données sont lues assez rarement, à intervalles d'une semaine ou plus. Cela vous permet d'économiser de l'énergie, car une utilisation ininterrompue nécessitera plus de tension, même avec une batterie. La présence de mémoire vous permet d'enregistrer divers paramètres (par exemple, mesure de température) et de lire les informations reçues du module.

L'interaction avec d'autres appareils et l'échange d'informations avec eux s'effectuent à l'aide de l'interface I2C à partir des broches SCL et SDA. Le circuit contient des résistances qui vous permettent de fournir le niveau de signal requis. La carte dispose également d'un emplacement spécial pour le montage du capteur de température DS18B20. Les contacts sont répartis en 2 groupes, pas de 2,54 mm. Le premier groupe de contacts contient les broches suivantes :

DS – sortie pour capteur DS18B20 ;
SCL – ligne d'horloge ;
SDA – ligne de données ;
VCC – 5 V ;

Le deuxième groupe de contacts contient :

SQ – 1 MHz ;
BAT – entrée pour batterie au lithium.

Pour vous connecter à la carte Arduino, vous avez besoin de la carte elle-même (dans ce cas, nous envisageons l'Arduino Uno), d'un module d'horloge temps réel RTC DS1307, de fils et d'un câble USB.

Pour connecter le contrôleur à Arduino, 4 broches sont utilisées - VCC, masse, SCL, SDA.. Le VCC de l'horloge est connecté à 5V sur l'Arduino, la masse de l'horloge est connectée à la masse de l'Arduino, SDA - A4, SCL -A5.

Pour commencer à travailler avec le module d'horloge, vous devez installer les bibliothèques DS1307RTC, TimeLib et Wire. Vous pouvez également utiliser RTCLib pour le travail.

Vérification du module RTC

Lorsque vous exécutez le premier code, le programme lira les données du module une fois par seconde. Tout d'abord, vous pouvez voir comment le programme se comporte si vous retirez la batterie du module et la remplacez par une autre alors que la carte Arduino n'est pas connectée à l'ordinateur. Vous devez attendre quelques secondes et retirer la batterie, la montre finira par redémarrer. Ensuite, vous devez sélectionner un exemple dans le menu Exemples → RTClib → ds1307. Il est important de régler correctement la vitesse de transmission à 57 600 bps.

Lorsque vous ouvrez la fenêtre Serial Monitor, les lignes suivantes doivent apparaître :

L'heure affichera 0:0:0. En effet, la montre perd de la puissance et cesse de compter le temps. C'est la raison pour laquelle la batterie ne doit pas être retirée pendant que le module fonctionne.

Pour régler l'heure sur le module, vous devez trouver la ligne dans le croquis

RTC.adjust(DateTime(__DATE__, __TIME__));

Cette ligne contiendra les données de l'ordinateur utilisé pour flasher le module d'horloge en temps réel. Pour bon fonctionnement Vous devez d'abord vérifier que la date et l'heure sur l'ordinateur sont correctes, puis commencer à faire clignoter le module d'horloge. Après la configuration, le moniteur affichera les données suivantes :

La configuration est effectuée correctement et il n'est pas nécessaire de reconfigurer davantage l'horloge temps réel.

Lecture du temps. Une fois le module configuré, les demandes de temps peuvent être envoyées. Cela se fait à l'aide de la fonction now(), qui renvoie un objet DateTime contenant des informations sur l'heure et la date. Il existe un certain nombre de bibliothèques utilisées pour lire l’heure. Par exemple, RTC.year() et RTC.hour() - ils obtiennent séparément des informations sur l'année et l'heure. En travaillant avec eux, un problème peut survenir : par exemple, une demande d'affichage de l'heure sera faite à 1:19:59. Avant d’afficher l’heure 1:20:00, l’horloge affichera l’heure 1:19:00, ce qui signifie qu’en substance, une minute sera perdue. Par conséquent, il est conseillé d'utiliser ces bibliothèques dans les cas où la lecture est peu fréquente - une fois tous les quelques jours. Il existe d'autres fonctions pour appeler l'heure, mais si vous devez réduire ou éviter les erreurs, il est préférable d'utiliser now() et d'en extraire les lectures nécessaires.

Exemple de projet avec module d'horloge et affichage i2C

Le projet est une horloge ordinaire ; l'indicateur affichera heure exacte, et les deux points entre les chiffres clignoteront à intervalles d'une seconde. Pour mettre en œuvre le projet, vous aurez besoin d'une carte Arduino Uno, d'un indicateur numérique, d'une horloge en temps réel (dans ce cas, le module ds1307 décrit ci-dessus), d'un blindage pour la connexion (dans ce cas, Troyka Shield est utilisé), une pile pour l'horloge et les fils.

Le projet utilise un simple indicateur à quatre chiffres sur la puce TM1637. L'appareil dispose d'une interface à deux fils et fournit 8 niveaux de luminosité du moniteur. Utilisé uniquement pour afficher l'heure au format heures:minutes. L'indicateur est facile à utiliser et à connecter. Il est avantageux de l'utiliser pour les projets où la vérification des données minute ou heure n'est pas requise. En avoir plus information complète Les moniteurs LCD sont utilisés pour indiquer l’heure et la date.

Le module d'horloge est connecté aux broches SCL/SDA, qui appartiennent au bus I2C. Vous devez également connecter la terre et l'alimentation. Il est connecté à Arduino de la même manière que décrit ci-dessus : SDA – A4, SCL – A5, masse du module à la masse d'Arduino, VCC -5V.

L'indicateur est connecté simplement - ses broches CLK et DIO sont connectées à toutes les broches numériques de la carte.

Esquisser. Pour écrire du code, utilisez la fonction de configuration, qui vous permet d'initialiser l'horloge et l'indicateur et d'enregistrer l'heure de compilation. L'impression de l'heure à l'écran se fera en boucle.

#inclure #include "TM1637.h" #include "DS1307.h" //vous devez inclure toutes les bibliothèques nécessaires pour travailler avec l'horloge et l'affichage. char compileTime = __TIME__; //temps de compilation. #define DISPLAY_CLK_PIN 10 #define DISPLAY_DIO_PIN 11 //numéros des sorties Arduino auxquelles l'écran est connecté ; void setup() ( display.set(); display.init(); //connecter et configurer l'écran. clock.begin(); //allumer l'horloge. byte hour = getInt(compileTime, 0); byte minute = getInt( compileTime, 2); byte second = getInt(compileTime, 4); //obtention de l'heure.fillByHMS(heure, minute, seconde) //préparation de l'écriture dans le module horaire clock.setTime(); reçu dans mémoire interne, début de la lecture du temps. ) void loop() ( int8_t timeDisp; //affichage sur chacun des quatre chiffres. clock.getTime(); //requête pour obtenir l'heure. timeDisp = clock.hour / 10; timeDisp = clock.hour % 10; timeDisp = clock .minute / 10; timeDisp = clock.minute % 10; //diverses opérations pour obtenir des dizaines, des unités d'heures, de minutes, etc. display.display(timeDisp); (clock.second %). 2 ? POINT_ON: POINT_OFF);//activer et désactiver les deux points après une seconde) char getInt(const char* string, int startIndex) ( return int(string - "0") * 10 + int(string) - "0"; //actions pour écrire correctement l'heure dans un entier à deux chiffres Sinon, seuls quelques caractères seront affichés à l'écran.

Après cela, le croquis doit être chargé et l'heure sera affichée sur le moniteur.

Le programme pourrait être légèrement modernisé. Lorsque l'alimentation est coupée, le croquis écrit ci-dessus fera afficher à l'écran l'heure qui a été définie lors de la compilation après la mise sous tension. Dans la fonction de configuration, à chaque fois l'heure écoulée entre 00:00:00 et le début de la compilation sera calculée. Ce hachage sera comparé à ce qui est stocké dans l'EEPROM, qui est conservé lorsque l'alimentation est coupée.

Pour écrire et lire l'heure vers ou depuis la mémoire non volatile, vous devez ajouter les fonctions EEPROMWriteInt et EEPROMReadInt. Ils sont nécessaires pour vérifier si le hachage correspond/ne correspond pas au hachage enregistré dans l'EEPROM.

Le projet peut être amélioré. Si vous utilisez un moniteur LCD, vous pouvez créer un projet qui affiche la date et l'heure à l'écran. La connexion de tous les éléments est illustrée sur la figure.

De ce fait, vous devrez préciser dans le code nouvelle bibliothèque(pour les écrans LCD, il s'agit de LiquidCrystal) et ajoutez des lignes à la fonction loop() pour obtenir la date.

L'algorithme de fonctionnement est le suivant :

Connecter tous les composants ;
Vérifiez - l'heure et la date sur l'écran du moniteur doivent changer chaque seconde. Si l'heure à l'écran est incorrecte, vous devez ajouter la fonction RTC.write (tmElements_t tm) au croquis. Les problèmes d'heures incorrectes sont dus au fait que le module d'horloge réinitialise la date et l'heure à 00:00:00 le 01/01/2000 lorsqu'il est éteint.
La fonction d'écriture vous permet d'obtenir la date et l'heure de l'ordinateur, après quoi les paramètres corrects seront indiqués à l'écran.

Conclusion

Les modules d'horloge sont utilisés dans de nombreux projets. Ils sont nécessaires pour les systèmes d'enregistrement de données, lors de la création de minuteries et de dispositifs de contrôle fonctionnant selon un horaire donné, dans les appareils électroménagers. Avec des modules largement disponibles et bon marché, vous pouvez créer des projets tels qu'un réveil ou un enregistreur de données de capteur, enregistrer des informations sur une carte SD ou afficher l'heure sur un écran d'affichage. Dans cet article, nous avons examiné des scénarios d'utilisation typiques et des options de connexion pour les types de modules les plus populaires.

Le module DS3231 (RTC, ZS-042) est une carte à faible coût dotée d'une horloge en temps réel (RTC) extrêmement précise, avec compensation de température de l'oscillateur à cristal et du cristal. Le module comprend une batterie au lithium qui maintient un fonctionnement ininterrompu même lorsque l'alimentation est coupée. Un générateur intégré améliore la précision de l'appareil et réduit le nombre de composants.

Spécifications techniques

Tension d'alimentation : 3,3 V et 5 V
Puce mémoire : AT24C32 (32 Ko)
Précision : ±0,432 seconde par jour
Fréquence des quartz : 32,768 kHz
Protocole pris en charge : I2C
Dimensions : 38 mm x 22 mm x 15 mm

informations générales

La plupart des microcircuits, tels que le DS1307, utilisent un oscillateur à quartz externe avec une fréquence de 32 kHz, mais ils présentent un inconvénient important : lorsque la température change, la fréquence du quartz change, ce qui entraîne une erreur de synchronisation. Ce problème est éliminé dans la puce DS3231, qui contient un oscillateur à cristal et un capteur de température qui compense les changements de température afin que l'heure reste précise (les données de température peuvent être lues si nécessaire). La puce DS3231 prend également en charge les informations sur les secondes, les minutes, les heures, le jour de la semaine, la date, le mois et l'année, et surveille également le nombre de jours dans un mois et effectue des ajustements pour les années bissextiles. Il prend en charge les horloges en deux formats : 24 et 12, et il est également possible de programmer deux alarmes. Le module fonctionne sur un bus I2C à deux fils.

Parlons maintenant un peu du module lui-même : il est construit sur la puce DS3231N. Un ensemble de résistances RP1 (4,7 kOhm) est nécessaire pour remonter les lignes 32K, SQW, SCL et SDA (d'ailleurs, si plusieurs modules avec un bus I2C sont utilisés, il est nécessaire de dessouder les résistances de rappel sur les autres modules) . Le deuxième ensemble de résistances est nécessaire pour resserrer les lignes A0, A1 et A2 ; elles sont nécessaires pour changer l'adressage de la puce mémoire AT24C32N ; La résistance R5 et la diode D1 servent à recharger la batterie ; en principe, elles peuvent être retirées, puisqu'une batterie SR2032 ordinaire dure des années. Une puce mémoire AT24C32N est également installée, c'est comme un bonus il n'est pas nécessaire que l'horloge RTC DS3231N fonctionne. La résistance R1 et la LED d'alimentation signalent que le module est allumé. Comme mentionné, le module fonctionne sur le bus I2C ; pour plus de commodité, ces bus ont été acheminés vers deux connecteurs J1 et J2 ; l'affectation des contacts restants est visible ci-dessous ; Objet J1
32K : sortie, fréquence 32 kHz
SQW : sortie
SDA : ligne de données (Serial Dфta)
VCC : alimentation du module « + »
GND : alimentation du module « - » Objet J2
SCL : horloge série
SDA : ligne de données série
VCC : alimentation du module « + »
GND : alimentation du module « - »

Je vais vous parler un peu de la puce AT24C32N, il s'agit d'une puce de 32k mémoire (EEPROM) du constructeur Atmel, assemblée dans un boîtier SOIC8, fonctionnant sur un bus I2C bifilaire. L'adresse du microcircuit est 0x57 ; si nécessaire, elle peut être facilement modifiée à l'aide des cavaliers A0, A1 et A2 (cela permet d'augmenter le nombre de microcircuits AT24C32/64 connectés). Puisque la puce AT24C32N possède trois saisie d'adresse(A0, A1 et A2), qui peuvent être dans deux états, soit log « 1 » soit log « 0 », huit adresses sont à la disposition du microcircuit. de 0x50 à 0x57.

Connexion du DS3231 à Arduino

Pièces requises :
Arduino UNO R3 x 1 pièce.
Horloge temps réel sur DS3231, RTC, SPI, AT24C32 x 1 pc.
Fil DuPont, 2,54 mm, 20 cm, F-M (Femelle - Mâle) x 1 pc.
cable USB 2,0 A-B x 1 pièce.

Connexion:
DANS dans cet exemple Je n'utiliserai que le module DS3231 et l'Arduino UNO R3, toutes les données seront transférées vers « Port Monitoring ». Le circuit n'est pas compliqué, seulement quatre fils sont nécessaires, on connecte d'abord le bus I2C, SCL en A4 (Arduino UNO) et SDA en A5 (Arduino UNO), il ne reste plus qu'à connecter l'alimentation GND à GND et VCC à 5V (peut être écrit à partir de 3,3V), circuit assemblé, il faut maintenant préparer la partie logicielle.

Il n'y a pas de bibliothèque qui fonctionne avec le DS3231 dans l'IDE Arduino, vous devez télécharger « DS3231 » et l'ajouter à l'environnement de développement Arduino.

Réglage de l'heure du DS3231
Lorsque vous l'allumez pour la première fois, vous devez programmer l'heure, ouvrir l'exemple de la bibliothèque DS3231 « Fichier » -> « Exemples » -> « DS3231 » -> « Arduino » -> « DS3231_Serial_Easy », ou copier le code d'en bas

/* Les tests ont été effectués sur Arduino IDE 1.8.0 Date du test 31/08/2018. */ #inclure // Connectez la bibliothèque Wire DS3231 rtc(SDA, SCL); // Initialisation du DS3231 void setup() ( Serial.begin(115200); // Installation connexion série rtc.begin(); // Initialiser rtc // Définir l'heure rtc.setDOW(FRIDAY); // Définit le jour de la semaine rtc.setTime(16, 29, 0); // Réglez l'heure sur 16:29:00 (format 24 heures) rtc.setDate(31, 8, 2018); // Fixe la date au 31 août 2018) void loop() ( Serial.print(rtc.getDOWStr()); // Envoie le jour-semaine Serial.print(" "); Serial.print(rtc.getDateStr( )); // Envoie la date Serial.print(" -- "); Serial.println(rtc.getTimeStr()); // Envoie le délai (1000); // Délai en une seconde)

Les tests ont été effectués sur Arduino IDE 1.8.0

Date de l'essai : 31/08/2018

#inclure // Inclut la bibliothèque Wire

DS3231 rtc (SDA, SCL); // Initialise DS3231

void setup()

En série. commencer(115200); // Établit une connexion série

RTC. commencer(); // Initialise rtc

// Régler l'heure

RTC. setDOW(VENDREDI); // Définir le jour de la semaine

RTC. setTime(16, 29, 0); // Réglez l'heure sur 16:29:00 (format 24 heures)

boucle vide()

En série. print (rtc . getDOWStr () ) ; // Envoi jour-semaine