Bonjour;
Je poste une nouvelle fois dans l'espoir que quelqu'un suis encore ce post... Je sais que c'est un peu du n'importe quoi dans les messages on y comprend plus grand chose alors je vais essayer de remettre tout ici clairement.

Je résume mon 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 ou en la nettoyant. 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é.

"L'idée" :
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.
En fait on compte les impulsions de la RTC, on y incrémente dans le compteur qui lorsqu'il atteint un seuil déclenche une action.


  • Pour lire et écrire dans la RTC.


Code:
#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_ADDRESS, 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 (Pour je pense déclencher l'incrémentation dans le compteur) :

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. )

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 ? Comment réaliser ce programme qui détectera cela... )
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. ) Mais je en sais pas du tout comment réaliser cela...


  • Pour ce qui concerne incrémenter le compteur pour qu'il déclenche une action :

Un compteur/timer est incrémenté (ou décrémenté) sur la base des impulsions de l'horloge de base du micro-contrôleur (il peut aussi l'être sur une impulsion fournie sur une broche du micro-contrôleur mais comme je n'ai pas assez d'informations sur ton projet je le suppose autonome).

Ces impulsions sont donc basées sur une fréquence rapide. Un pré-diviseur précède généralement le compteur pour que, au choix du concepteur, le compteur soit incrémenté à chaque impulsion d'horloge, ou toutes les 2, 4, 8, ...impulsions d'horloge.

Malgré ce pré-diviseur, selon les durées à mesurer, le compteur/timer risque fort de déborder avant d'avoir atteint la durée espérée. A chaque fois que le compteur déborde il positionne un signal qui peut déclencher l'exécution automatique d'une routine appelée interruption. (Je ne comprends pas trop ce point à vrai dire..)
  • Voila ce que l'on m'a proposé :


"Je propose d'utiliser cette routine qu'on pourrait imaginer déclenchée chaque seconde ou autre (en fonction de la fréquence d'horloge, de la valeur du pré-diviseur et de la valeur qu'on recharge dans le compteur/timer) pour d'une part incrémenter une variable mémoire (ou même une information en EEPROM), tester si cette variable a atteint le nombre correspondant à la durée limite pour allumer la LED"

Je sais que c'est un peu le cafouillage, je suis un peu perdu avec tout ça...
J'aimerais si c'est possible savoir si ma démarche est "juste"; Mon gros problème c'est que je comprends dans la théorie ce qu'il faut faire mais je n'arrive pas à le mettre en place...

Merci d'avance.