Afficher des informations de température (Led fusion et sécurité)

[SGRmetrage]

Bonjour;
je travail sur un projet (Le stylo 3D) et une des choses à réaliser est afficher des infromations de température. En fait il s'agira de faire allumer une led verte lorsque la température de fusion est atteinte, et clignoter une led rouge lorsque la température de sécurité est dépassé.
Pour faire allumer les led pas de soucis un programme Arduino s'en chargera, mais comment faire allumer ces leds à la température voulu ?
Avant on aura mesurer la température du stylo, et elle sera stocker sur une case mémoire.
merci
-----

[minioim]

salut,

euh que je comprenne bien...

tu as une case mémoire de ton arduino qui aura la température stylo (donc la mesure de la température ne pose pas de soucis right?)
tu as un programme pour allumer les leds (si on peut parler de programme ^^)

et tu veux savoir comment lancer le "programme" qui allume la led quand la variable température a dépassé une certaine valeur?

[SGRmetrage]

Oui en gros c'est ça et je ne sais pas trop comment faire.

[SGRmetrage]

Pour ètre plus clair j'ai une case mémoire de ton arduino qui aura la température stylo, c'est température sera converti en tension, et j'aimerais savoir comment faire pour que en fonction de la tension la led s'allume ou non.
Merci.

[A voir en vidéo sur Futura]

[minioim]

au contraire je trouve ça moins clair ^^ j'te jure que j'essaie de comprendre...
bon reprenons.

déjà niveau sens de fonctionnement, est ce que ça ressemble à ça:

capteur de température (qui sort une tension variable)-->Arduino(qui transforme la tension en valeur numérique et en déduit la température) -->led (allumée par l'arduino)?



parce que là un coup tu dis dans ton premier message que tu mesures la température qui est ensuite envoyée à l'arduino (et stockée en mémoire) et qu'ensuite tu veux allumer la led. bon c'est ce que j'ai représenté juste au dessus.

mais dans ton dernier message tu dis que t'as une case mémoire qui a DÉJÀ une température en mémoire, qu'ensuite elle est convertie en tension et qu'en fonction de cette tension qui sort donc de ton arduino, la led s'allume ou non....

dans les 2 cas il y a une solution assez simple mais je vois pas bien l'intérêt de la seconde technique.


mais si tu nous dis un peu plus clairement comment ça fonctionne... quel type de capteur tu utilises, comment l'info est envoyée, si ton arduino doit commander directement les led ou seulement produire une tension qui servira ensuite à savoir si la led doit s'allumer ou non etc...

bref détail nous le projet et on pourra t'aider

t'as un capteur de température je suppose (genre thermistance) qui te donne une tension en fonction de la température. jusque là ok?
cette tension

[SGRmetrage]

Bonjour;
Je me présente étudiant en Terminale STI2D et notre projet et de réaliser un stylo 3D (Pour plus d'informations faites une recherche c'est vraiment un projet passionnant) ce n'est pas la première fois que je viens sur ce forum pour ce projet j'ai de nouveau besoin de votre aide.
Voici ce que je dois réaliser : Explorer les solutions pour afficher l'information tête à changer et réinitialiser le temps de fonctionnement.
Je m'explique, à l'aide d'une RTC (DS1302 ou DS1307) nous allons estimer le temps de fonctionnement du stylo pour prévoir la maintenance du stylo en changeant la tète. Nous voulons donc mémoriser ce temps de fonctionnement lorsque l'on arrête le stylo et le cumuler ce temps lorsqu'on le rallume. Imaginons qu'on a fixé un seuil à 100h d'utilisation, le but serait de faire allumer une led qui indiquerais que les 100h sont dépassé.
Mais comment réaliser cela ? J'ai trouvé un tp : http://www.sonelec-musique.com/elect...v_bat_002.html dont je pense me servir mais je suis vraiment pas doué.. ce projet est vraiment compliqué pour mon niveau, alors j'aurais besoin d'aide et de conseil.
Merci.

[SGRmetrage]

Bonjour;
Tout d'abord désolé pour le temps de réponse j'ai eu de gros problème d'internet.
Je suis vraiment désolé de ne pas ètre clair...
Je reprend votre schéma : capteur de température (qui sort une tension variable, pour cela on va utiliser une Thermistance Pt100, La PT100 en entrée de deux comparateurs, mais avec un seuil différent (Seuil de température atteinte, seuil de sécurité) que l'on règles grâce à un potentiomètre.)-->Arduino(qui transforme la tension en valeur numérique et en déduit la température) --> La température est comparé au seuil et si elle le dépasse la led s'allume (allumée par l'arduino) C'est à peut prèt cela que je veux réaliser.

[invite03481543]

Bonsoir,

à mon avis tu peux prendre un petit µC, il te faut de l'I2C pour ta RTC.
Ou mieux encore prendre un µC dans lequel tu gères une RTC, tu n'as pas besoin de dater mais de compter 100h.
Il te faut de l'EEPROM.
Comment ton stylo est alimenté?
Il faudrait que j'en sache plus sur ton projet, indique moi un lien vers celui-ci ou post un pdf.
@+

[SGRmetrage]

Bonsoir;
Merci de votre réponse.
I2C oui si c'est une RTC DS1307 mais j'hésite avec la DS1302 dans ce cas ce serais un protocole SPI.
µC ? Qu'est ce que c'est ? Oui je n'ai pas besoin de dater en fin de compte.
Oui je pensais effectivement prendre l'EEPROM d'arduino.
On ne sait pas vraiment encore pour l'alimentation, de plus ce n'est pas moi qui gère cette partie..

Oui pas de soucis, que voulez-vous savoir ? Qu'est ce que le stylo3D exactement (Voici une brève vidéo pour avoir une idée : http://www.koreus.com/video/3doodler.html ) ? Ou voir mon cahier des charges ?

[SGRmetrage]

Voici le cahier des charges du groupe entier : http://www.partage-facile.com/J1CNVS...drage.pdf.html
Et plus précisément le mien : http://www.partage-facile.com/TFU2LR..._n__4.pdf.html

[SGRmetrage]

Pour avoir plus d'informations sur notre projet voici le cahier des charges :
le cahier des charges du groupe entier : http://www.partage-facile.com/J1CNVS...drage.pdf.html
Et plus précisément le mien : http://www.partage-facile.com/TFU2LR..._n__4.pdf.html

[invite03481543]

µC pour microcontrôleur

A moins que tu aies des choses imposées... l'usage d'une RTC dans ton cas n'est absolument pas nécessaire, un simple timer peut suffire.

100h, c'est 360000 secondes, donc voilà ce que tu dois compter avant d'allumer ta led.
Il te faut détecter la mise sous tension, puis incrémenter ton compteur, puis à l'arrêt du stylo tu stoppes ton compteur.
Le principe est donc très simple.
Un petit µC à 8 pattes peut très bien te faire ça, en gros moins de 10 composants et 40 lignes de code.
Sais-tu programmer?

[SGRmetrage]

Oui c'est vrai que je suis entrain de réaliser que c'est vraiiment pas utile... un timer serait relativement plus simple!
Dans la théorie oui... mais en vrai non pas vraiment, je suis supposer savoir programmé sur ARDUINO mais je galère vraiment..

[invite03481543]

As-tu répondu aux questions que tu dois explorer?
Comment as-tu estimé la durée de la tête?

Tu as également la température à gérer, ton µC peut s'en charger également.

Pour t'accompagner dans ta tâche, il va falloir que tu travailles un peu, donc que tu nous expliques ce que tu as déjà fait et/ou ce que tu ne comprends pas.
Nous t'aiderons mais nous ne ferons pas ce devoir à ta place

[invite03481543]

Arduino?

En effet, pourquoi faire simple quand on peut faire compliqué.
Peu importe le tout est que tu comprennes le principe général, ensuite tu adapteras à ton Nazuino.
@+

[invite03481543]

Attention tu as déjà ouvert une discussion par ailleurs sur le même sujet, il va falloir attendre la fusion des 2 discussions, les doublons sont interdits ici.

[SGRmetrage]

Bonjour;
Comme je l'avais dis dans mon premier poste nous voulions utiliser une RTC mais vous m'avez conseiller d'utiliser un simple timer ce que je trouve aussi relativement plus simple.
Oui oui bien sur je n'ai jamais demandé bune seconde qu'on me face le travail à ma place non en aucun cas. Je suis juste dans une phase de recherche de solutions donc en gros rien n'ai fait pour l'instant hormis l'analyse fonctionnel etc. Je viens justement sur ce forum pour avoir des idées de solutions que je pourrais envisager et tant qu'à faire les comprendre ça me sera toujours utile.
Merci d'avance.

[SGRmetrage]

Ah pardon veillez m'excuser... j'ai créé un autre sujet encore comme ça tretais de partie différentes je pensais qu'il fallait créer un une partie par poste.
Toutes mes excuses.

[Tropique]

Discussions fuisionnées

[SGRmetrage]

Merci beaucoup et désolé pour le dérangement occasionné.
Je résume :
- Mon premier problème : "Afficher une informations temps de fonctionnement atteint par une led"
Je m'explique, à l'aide d'une RTC (DS1302 ou DS1307) nous allons estimer le temps de fonctionnement du stylo pour prévoir la maintenance du stylo en changeant la tète. Nous voulons donc mémoriser ce temps de fonctionnement lorsque l'on arrête le stylo et le cumuler ce temps lorsqu'on le rallume. Imaginons qu'on a fixé un seuil à 100h d'utilisation, le but serait de faire allumer une led qui indiquerais que les 100h sont dépassé.
Mais comment réaliser cela ? J'ai trouvé un tp : http://www.sonelec-musique.com/elect...v_bat_002.html dont je pense me servir mais je suis vraiment pas doué.. ce projet est vraiment compliqué pour mon niveau, alors j'aurais besoin d'aide et de conseil.
D'après ce que vous m'avez dis il serait plus simple d'utiliser un timer car en fin de compte nous avons besoin que le nombre d'heures!

- Mon second problème : "Afficher des infromations de température (Led fusion et sécurité) "
Je reprend votre schéma : capteur de température (qui sort une tension variable, pour cela on va utiliser une Thermistance Pt100, La PT100 en entrée de deux comparateurs, mais avec un seuil différent (Seuil de température atteinte, seuil de sécurité) que l'on règles grâce à un potentiomètre.)-->Arduino(qui transforme la tension en valeur numérique et en déduit la température) --> La température est comparé au seuil et si elle le dépasse la led s'allume (allumée par l'arduino) C'est à peut prèt cela que je veux réaliser.

Voilà pour résumer! Je le répète je ne cherche pas à qu'on me face min projet non je suis juste dans une phase de recherche de solutions possibles je me renseigne donc.
Merci à vous

[SGRmetrage]

Après quelques recherche j'en ai tiré ces conclusions :
- Pour les deux leds de controle température : Je peux utiliser des comparateur style LM311 pour allumé les deux DEL de contrôle de température.
- Pour la led du temps de fonctonnement : je peux faire un oscillateur (NE555;CD4060 etc qui sont des timer si j'ai bien bien compris), contrôler par la mise en marche de la tête chauffante qui alimente un compteur qui, quand il atteint la bonne valeur, allume la DEL de temps écoulé..
Pour controler tout cela un micro controleur du type pic à 5 pattes ( 10Fxxx CMS ).

Que pensez-vous de tout cela ? Merci.

[SGRmetrage]

Voila ce que nous avons tiré comme solutions:
- Pour les deux leds de contrôle température : La PT100 en entrée de deux comparateurs style LM311, mais avec un seuil différent (Seuil de température atteinte, seuil de sécurité) que l'on règles grâce à un potentiomètre.-Arduino qui transforme la tension en valeur numérique et en déduit la température --> La température est comparé au seuil et si elle le dépasse la led s'allume (allumée par l'arduino)
- Pour la led du temps de fonctionnement : a la place d'un oscillateur nous allons utiliser une RTC style DS1307 ou DS1302 car de toutes façons nous allons devoir stocker le temps de fonctionnement sur la case mémoire de la RTC, elle sera contrôler par la mise en marche de la tête chauffante(le problème sera comment réaliser cela) qui alimente un compteur qui, quand il atteint la bonne valeur, allume la DEL de temps écoulé.

Que pensez-vous de tout cela ? Merci.

[SGRmetrage]

Me revoila encore une fois oui... mais j'aurais aussi besoin d'avis encore une fois.

Si je comprends bien :
Dans la carte arduino on a un microcontrôleur type ATMEGA328, et un timer y es intégré. C'est bien cela ou est-ce un module à part ?

Ensuite avec ceci on va pouvoir mesurer une durée. Mais pour la stocker ? On peut faire cela dans l'eeprom interne d'arduino non ?

Pour finir, pour allumer les leds en fonction (du temps pour la première led) j'aurais juste à faire un programme arduino, qui lorsque le temps fixé sera atteint déclenchera une led ?
pour les leds de contrôle de température, plutôt que des comparateurs externes il est plus simple d'utiliser une (seule) entrée analogique du contrôleur et d'effectuer la comparaison à des seuils (à l'aide pareille d'un programme).

Tout cela n'est-il pas trop compliqué ? étant donné mon faible niveau en language arduino.
J'essaie d'envisager les meilleurs solutions possibles.



Après quelques recherche je suis tombé sur ceci :
ICI
Le kit velleman MK138, qui permet de faire une action (pour moi ce serais d'allumer une led) lorsque l'on est au dessus d'une température, d'après vous serait-ce une bonne solution ?

Merci infiniment pour toutes votre aide, et le temps que vous prenez.

[invite03481543]

Si tu as un arduino comme µC imposé il faut que tu fasses avec.
D'autant qu'il comporte tout ce dont tu as besoin, un timer, un convertisseur analogique-numérique, des ports TOR (Tout Ou Rien) pour piloter des leds par exemple.

Je ne sais pas comment tu as été formé et informé, mais la base et le principe sont toujours les mêmes.
Dans toute recherche de solution il faut établir clairement les besoins et en face faire des propositions de solutions sous forme par exemple de diagrammes ou de synoptiques fonctionnels.
Ensuite il te faut établir un ordinogramme ou flowchart selon ta préférence linguistique.

C'est ni plus ni moins qu'un descriptif séquentiel de ce que tu dois établir pour réaliser tes fonctions.

Le choix de la mémoire que tu vas utiliser dépend directement des conditions de ton alimentation, soit elle est permanente soit non, si c'est non il te faut stocker tes infos dans une mémoire non volatile de type flash ou EEPROM par exemple.
Quant au fonctionnement d'un ADC (Analog to Digital Conversion) c'est assez simple à comprendre, ta valeur mesurée va être convertie en poids binaire selon la résolution de l'ADC, par exemple 10 bits veut dire que le pas élémentaire (quantum) vaudra q=5V/1024 = 4.88mV 1024 car 2^10=1024
Si tu fais 1024*4.88mV tu obtiens bien tes 5V.
Si ta valeur en entrée de l'ADC (ce qui arrive sur ton entrée de mesure) vaut 2.75V ton ADC contiendra la valeur numérique 2.75*1024/5V soit 563.
Donc si tu ne connais pas ta valeur analogique qui entre sur ta patte de mesure, le simple fait de savoir lire le contenu de ton ADC te permet de retrouver cette valeur inconnue:

563*5/1024=2.75V

Comprends tu ce principe?

[SGRmetrage]

Merci beaucoup pour votre réponse !
Il n'est pas forcément imposé mais comme vous le dites "'il comporte tout ce dont tu as besoin, un timer, un convertisseur analogique-numérique, des ports TOR (Tout Ou Rien) pour piloter des leds par exemple."
Oui nous avons commencé par l'analyse fonctionnel (donc les diagrammes, définitions des besoins etc, mais rien de très concret sur ce que l'on devait réaliser..) malgré tout avec cela nous avons établit nos cahiers des charges qui on été validées par le prof.

Mon alimentation ne sera pas permanente donc nous devons utiliser une mémoire non volatile sur L'EEPROM d'arduino par exemple (La carte Arduino contient un EEPROM de 1 kio. 1024 octet c'est peu mais on peut déjà avoir beaucoup d'applications (ça correspond à un millier de caractères, soit plus de six SMS complets). Chacun des 1024 octets a son adresse. )
Ah oui l'ADC que vous parlez est en fait un CAN ? Convertiseur Analogique Numérique, je connais le fonctionnement de ce système (comme celui du CNA d'ailleurs) mais que dans la "théorie" ce qui est compliqué pour moi (ça va vous paraître bète) c'est à mettre en place...

Merci beaucoup pour votre réponse.

[invite03481543]

Préfère l'appellation ADC, ça évite la confusion avec le CAN qui est un bus de communication.
Dans les PIC tu trouveras parfois les 2 donc...
Je n'aime pas trop les anglicismes mais en l'occurrence ici ça se justifie pleinement par ces abréviations dont l'usage est généralisé et communément employé dans note secteur d'activité qu'est l'électronique, sauf par l'éducation nationale évidemment.

[SGRmetrage]

Oui oui il n'y a pas de soucis, c'était simplement pour être sur que je comprenais bien de quoi il s'agissait.

[SGRmetrage]

Bonjour,
Après de multiple débats avec notre professeur nous avons été obligé de prendre une RTC plutôt qu'un Timer.
Pour allumer une led au bout d'un certain temps de fonctionnement voila ce que j'ai compris :

Avec la RTC (Grove ou DS1307) contrôler par la mise en marche de la tête chauffante qui alimente un compteur qui, quand il atteint la bonne valeur, allume la DEL de temps écoulé.

Nous allons mesurer le temps avec la RTC, ce temps sera stocké dans la mémoire internet de la RTC. Dans le principe est-ce cela ?
Mais je ne comprends pas vraiment comment allumer une led au bout d'un certain temps à l'aide d'une rtc... merci de votre aide.

[SGRmetrage]

Je ne fais parcourir que forum sur forum... je n'arrive pas à trouver de solutions. Beaucoup vienne ici en attendant qu'on leur donne la réponse mais ce n'est pas de mon cas. J'ai de grosse lacune en électronique, c'est d'ailleurs le cas de tout le monde dans notre classe mais nous devons faire avec et nous avons ce projet coefficient 12 au bac! Je passe des heures et des heures à bosser chaque soir dessus... je sais que beaucoup pense que je dois le faire exprès car je n'y comprends rien mais ce n'est vraiment pas voulu.
J'ai fais beaucoup de recherche sur les timers, j'en ai parlé à mon prof qui finalement m'a imposé une RTC sauf que c'est bien plus compliqué, le fonctionnement n'est pas le mème. N'ayant pas le niveau je l’avoue, je n'ai aucun autre moyens que de chercher sur internet sauf que répondant à mon problème je ne trouve rien...

Je vais essayer de tout synthétiser pour être clair.
Voici la fonction à laquelle je dois répondre dans un premier temps (on va faire par étape) : Explorer les solutions pour afficher l'information tête à changer (C'est à dire allumer une led au bout d'un certain temps, ex : 100h pour prévenir l'utilisateur qu'il faut changer la buse par exemple)

Pour compter le temps je dois utilier une Horloge en temps réel (RTC)
L'horloge fournit secondes, minutes, heures, jour, date, mois et année. La fin de la date de mois est automatiquement ajustée pour les mois de moins de 31 jours, y compris les corrections pour les années bissextiles. L'horloge fonctionne soit en format 24 heures ou 12 heures avec indicateur AM / PM. Et il est valable jusqu'en 2100.

Pourquoi prendre une RTC ?

le choix d'une d'une RTC n'etait pas sans intérêt par rapport à un timer. Lorsque l'on utilise un timer pour allumer une LED, une erreur de quelques milli secondes ne pose absolument aucun problème. Par contre, comme notre but est de calculer un temps total d'utilisation (donc plusieurs centaines d'heures) on devras accumuler plusieurs milliers ou millions de fois le timer. Une erreur systématique sur le temps va donc s'accumuler et les erreurs de mesure aléatoires s'accumulent.
De plus une RTC fait un chronométrage qui fournit secondes, minutes, heures, jour, date, mois et année , un timer lui ne fait que compter.
Une Real Timer Clock à l'avantage d'ètre plus simple d'utilisation, au contraire on peut remarquer une somme importante de précautions à prendre lors de l'utilisation d'un timer, dont certaines peuvent être gênantes pour l'exécution de l'application (arrêt momentané des interruptions), et d'autres difficilement contrôlables (garantie d'une tension d'alimentation minimal).
De plus... et c'est surement la seule raison qui compte c'est que la RTC est imposé par le prof donc pas le choix ^^"

Mais voila mon problème... comment allumer une led lorsque ce temps est atteint ? Dans mes recherches j'ai trouvé beaucoup de chose sur les compteurs (style CD4060) mais je ne comprends pas si ça marche ave une RTC. En faite je l'avoue, je suis perdu je ne comprends pas le fonctionnement... comment réaliser cela..
Nos solutions sont à présenter dans deux jours, j'ai bosser sur toutes mes autres solutions mais celle-ci je bloque et il faut vraiment que je m'y mette.

merci à vous de prendre tout ce temps.

[SGRmetrage]

Je dis surement des bêtises mais mais on détecte l'allumage et l'extinction et à l'allumage et à l'extinction, on lis les valeurs dans le DS1307. On soustrait et on accumules en mémoire.
Après faut le faire... L'allumage c'est pas vraiment un problème, par contre l'extinction se sera plus délicat puisqu'il faut détecter l'extinction et lancer une procédure pour sauvegarder le temps écoulé.

- Je pourrais utiliser ce bout de code pour lire, écrire, et sauvegarder :

#define DS1307_ADDRESS 0x68

typedef struct {
uint8_t secondes;
uint8_t minutes;
uint8_t heures; // format 24h
uint8_t jourDeLaSemaine; // 0~7 = lundi, mardi, ...
uint8_t jour;
uint8_t mois;
uint8_t annee; // format yy (ex 2012 -> 12)
} Date;
// Ps uint8_t est un synonyme de byte, byte ne pouvant etre utilise dans un structure contenu dans un .h externe

// Fonction configurant le DS1307 avec la date/heure fourni
void ecrire(Date *date) {
Wire.beginTransmission(DS1307_ ADDRESS); // Début de transaction I2C
Wire.send(0); // Arrête l'oscillateur du DS1307
Wire.send(dec2bcd(date->secondes)); // Envoi des données
Wire.send(dec2bcd(date->minutes));
Wire.send(dec2bcd(date->heures));
Wire.send(dec2bcd(date->jourDeLaSemaine));
Wire.send(dec2bcd(date->jour));
Wire.send(dec2bcd(date->mois));
Wire.send(dec2bcd(date->annee));
Wire.send(0); // Redémarre l'oscillateur du DS1307
Wire.endTransmission(); // Fin de transaction I2C
}

// Fonction récupérant l'heure et la date courante à partir du DS1307
void lire(Date *date) {
Wire.beginTransmission(DS1307_ ADDRESS); // Début de transaction I2C
Wire.send(0); // Demande les info à partir de l'adresse 0 (soit toutes les info)
Wire.endTransmission(); // Fin de transaction I2C

Wire.requestFrom(DS1307_ADDRES S, 7); // Récupère les info (7 octets = 7 valeurs correspondant à l'heure et à la date courante)

date->secondes = bcd2dec(Wire.receive()); // stockage et conversion des données reçu
date->minutes = bcd2dec(Wire.receive());
date->heures = bcd2dec(Wire.receive() & 0b111111);
date->jourDeLaSemaine = bcd2dec(Wire.receive());
date->jour = bcd2dec(Wire.receive());
date->mois = bcd2dec(Wire.receive());
date->annee = bcd2dec(Wire.receive());

- Pour détecter l'allumage/Extinction.
Je sais que ma RTC 1307 ou Grove communique par I2C ( l'I2C est un protocole de bus de données en série qui permet à plusieurs dispositifs pour relier les uns aux autres avec assez lentes vitesses de transfert de données.Ces taux de transfert des données lentes sont suffisamment rapides pour de nombreux appareils permettent de bus et d'être très simple à mettre en oeuvre. La vraie beauté de ce protocole est que l'on peut contrôler jusqu'à 112 dispositifs avec seulement deux fils à partir d'un microcontrôleur. Donc si j'ai bien compris la RTC 1307 ou Grove communique par I2C mais pas toutes... la RTC1302 communique par protocole SPI il me semble)

La question que je me pose justement c'est comme détecter l'allumage/Extinction, comment communique la RTC avec Arduino (Oui par I2C, mais il n'y a pas de module entre, tout ce fera simplement dans le programme ?)
J'ai trouvé qu'il fallait faire une interragation NTP (L'interrogation NTP retourne l'heure UTC, exprimée en secondes écoulées depuis le 01/01/1900 00:00, en binaire sur 4 octets.
Mon problème est donc de passer ce format au format étendu pour le DS1307.
Dans mon cas, j'utilise la RAM du DS1307 pour stocker des informations :
- la dernière date/heure lue du DS1307, pour détecter les coupures électriques, au redémarrage de l'arduino
- la date/heure de dernière synchronisation NTP, pour gérer le délai entre les demandes de synchronisation, sans être influencé par les coupures électriques.
Et accessoirement, cela me permet aussi de détecter, au démarrage de l'arduino, que la pile du DS1307 est morte (quand je ne retrouve pas en RAM les données attendues). )
Mais c'est toujours compliqué pour moi de comprendre tout ça... et de comment le mettre en place