Donc ça en quelques sortes ce serait "la procédure pour sauvegardé le temps écoulé" si je me trompe pas ? 

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

Merci de répondre à mes questions... de prendre ce temps, merci beaucoup.  

Donc ça en quelques sortes ce serait "la procédure pour sauvegardé le temps écoulé" si je me trompe pas ?

Non, ca c'est deux fonctions, une pour lire et l'autre pour écrire dans la RTC.

c'est comme détecter l'allumage

tu as vraiment réfléchi ?

c'est comme détecter Extinction

C'est là le plus délicat, as tu fait une recherche ?

comment communique la RTC avec Arduino

Par I2C, tu l'as dit, maintenant t'es tu renseigné sur l'I2C ?

Mais ce bout de code ne permet pas de stocker :

 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());

"tu as vraiment réfléchi ?"

On a  déjà dans le code ci-dessus les fonctions qu permettent de lire ou d'écrire l'heure du DS1307. Deja c'est ce qui est sur! 

J'ai trouvé sur le site arduino d'interrogation 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).

 "Par I2C, tu l'as dit, maintenant t'es tu renseigné sur l'I2C ? "

Oui oui, 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 communique par I2C

-
Edité par SGR-métrage 11 février 2014 à 22:05:26

Je récapitule avec toutes mes données. 

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.

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

-
Edité par SGR-métrage 12 février 2014 à 14:35:02

Je pensais que tu avais compris mais en fait non, tu ne fais que copier des choses sans les lire et les comprendre... Du coup je repose ma question de hier :

Fais abstraction du microcontrolleur, si je te donne une montre et un cahier et que je te demande combien de temps tu es resté éveillé pendant un mois, tu feras comment ?

Si j'ai lu et essayer de comprendre. J'ai essayé de résumé tout ce que j'avais appris, après apparament ce n'est pas correct...

Et bien comme je l'ai dis 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.
Pour détecter l'utilisation après quelques recherche voila ce que j'ai trouvé : il faut mettre une petite résistance (Par exemple 0.1 ohm) sur le connecteur d'alimentation qui nous permettra de détecter l'utilisation. Parce la tension au borne sera donc V = I x 0.1 Donc si utilisation => on a une consommation de courant => ce qui donne l'apparition d'une tension image du courant qui sera envoyé sur l'arduino.
Dans le programme avec Analogread() va lire les tensions d'entrée comprises entre 0 et 5 volts et va les convertir en des valeurs entières comprises entre 0 et 1023. 

Après je ne sais pas comment le dire... mais suivant la tension (0v ou 5v) à l'aide de DigitalWrite() un niveau logique HAUT ou BAS  sur une broche numérique. Si la broche a été configurée en SORTIE avec l'instruction pinMode(), sa tension est mise à la valeur correspondante : 5V  pour le niveau HAUT, 0V  pour le niveau BAS.

Dans le cas de 5V ça allume ma led. 

je ne suis pas du tout sur de mon raisonnement mais en attendant merci infiniment pour toute l'aide.. 

-
Edité par SGR-métrage 12 février 2014 à 16:17:23

Bonjour, je suis éléve en premiere SI et mon projet est le stylo 3D mais je bloque par rapport a:

-quel microcontroleur faut il utiliser ?

-quel est le programme qu'il faut pour réguler la température ?

merci d'avance!