Allumer une led au bout d'un temps donné.

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 sur : http://www.lestylo3d.com/ c’est vraiment un projet passionnant). Nous sommes dans une phase de recherche de solutions et je suis face à quelques problèmes…
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 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.

Effectivement c'est un peu le cafouillage (dur dur de te suivre ^^')

Bon on reprend : oublie le NTP pour le moment à mon avis, j'ai même envie de dire que pour ce genre d'appli c'est un peu inutile mais bon, en fait ça va l'être mais pas pour cette raison. En effet ce que je vois comme problématique c'est comment stocker en mémoire le temps écoulé même arduino éteinte (et oui si on suit ton résonnement, si je débranche la prise de l'arduino, tout est perdu). on pourrait songer à utiliser la mémoire EEPROM du micro mais elle est limitée en nombre d'écriture. Non la vu que tu as un DS1307, tu peux utiliser sa RAM pour stocker le compteur en permanence. Y'a plusieurs tuto sur le net à ce sujet.

Ensuite détecter l'utilisation :y'a pas beaucoup d'info sur le site mais visiblement il marche en continu ? Si c'est bien ça, tu peux intercaler sur le connecteur d'alim une toute petite résistance qui permettra de visualiser la consommation et donc de détecter l'utilisation.

pour déterminer le compteur c'est simple : - dès la détection d'utilisation : mise en mémoire de la date - toute les secondes : mise à jour de compteur = date - date de départ - si compteur > 100h ==> allumage led - si plus d'utilisation on enregistre plus compteur

Oui veillez m'excusez c'est autant le cafouillage dans ma tète alors je vous laisse imaginer le désastre.. ^^" Merci en tout qu'a de m'aider.

Oui pour la mémoire j'ai trouvé de nombreux tutos, j'ai évité de le mettre ici pour ne pas en rajoute une couche disons... mais nous allons utiliser la mémoire Ram de la RTC.

Si c'est bien ça, tu peux intercaler sur le connecteur d'alim une toute petite résistance qui permettra de visualiser la consommation et donc de détecter l'utilisation.

Une petite résistance de quelle style ? Pouvez-vous m'en dire plus à ce sujet ? Je n'avais jamais encore entendu de parlé de ça.

pour déterminer le compteur c'est simple : - dès la détection d'utilisation : mise en mémoire de la date - toute les secondes : mise à jour de compteur = date - date de départ - si compteur > 100h ==> allumage led - si plus d'utilisation on enregistre plus compteur

Oui c'est exactement ce que je voulais mettre en place, le soucis c'est la réalisation de cela... c'est ici que ça bloque.

merci pour votre réponse et votre patience.

SGRmetrage: Une petite résistance de quelle style ? Pouvez-vous m'en dire plus à ce sujet ? Je n'avais jamais encore entendu de parlé de ça.

Bah on t'as jamais fait étudier la loi d'ohm au lycée ??! ;)

Une résistance de valeur 0.1 ohm par exemple : la tension au borne est donc V = I x 0.1 Donc si utilisation => consommation de courant => apparition d'une tension image du courant. Pourquoi 0,1 ohm ? Alors il faudra peaufiner la valeur suivant le courant consommé, il ne faut pas que + de 5V arrive sur l'arduino sinon elle va pas aimer ... Mais c'est l'ordre d'idée, ça permet d'obtenir une tension détectable, qui ne "dérange" pas le pistolet et ça permet qu'elle même ne crame pas par effet joule (P= RxI²)

Sinon dis nous où tu bloques exactement : visiblement tu arrives à récupérer la date, faire la différence entre deux date ça devrait pas être bien compliqué ;)

Je te donne les "briques" nécessaires :

http://arduino.cc/en/Reference/analogRead millis() et les interruption temporelles => http://battomicro.wordpress.com/2013/06/07/tutorial-les-interruptions-temporelles-avec-arduino/ http://arduino.cc/en/Reference/If http://arduino.cc/en/Reference/DigitalWrite

Ah ben bien sur que si il suffisait d'y penser... tel est mon problème. :)

il ne faut pas que + de 5V arrive sur l'arduino sinon elle va pas aimer

Ahah oui je suis bien au courant de cela, pas plus tard que hier un générateur à merder (on ne sait toujours pas pourquoi) et c'est mis à allimenter une carte Arduino en 30V au lieu de 5V, le condensateur à exploser.

Pour revenir sur le sujet, donc il faut mettre une petite résistance 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. (je reprends ce que vous m'avez dis) qui sera envoyé sur l'arduino. 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..

Oui tout est bon.

Pour la résistance il va falloir procéder ainsi : mesurer avec un amperemétre la consommation, ça permetra de savoir quelle valeur ne pas dépasser par rapport à l’effet joule. Si 0.1 ohm et 10A ça fait 10² * 0.1 ohm = 100 *0.1 = 10W => outch, soit il faut en prendre une grosse et elle va chauffer soit faut trouver une autre solution … Et la tension image sera 10 x 0.1 = 1V

Après il faudra surement un circuit de sécurité avec une diode zener pour protéger la nono.

En attendant, si tu as le matos, tu peux t’exercer avec un potentiomètre pour simuler la détection de consommation. D’abord allumer la led suivant un seuil, puis réaliser ton compteur

Jette un oeil là-dessus http://www.maximintegrated.com/datasheet/index.mvp/id/2756/t/al. Comptage du nombre de mises sous tension. Cumul du temps de fonctionnement. Alarme au bout d'un certain temps de fonctionnement. A la limite tu n'as besoin de rien d'autre.

Comment vous remercier pour toutes cette aide ?

Pour la résistance il va falloir procéder ainsi : mesurer avec un amperemétre la consommation, ça permetra de savoir quelle valeur ne pas dépasser par rapport à l'effet joule. Si 0.1 ohm et 10A ça fait 10² * 0.1 ohm = 100 *0.1 = 10W => outch, soit il faut en prendre une grosse et elle va chauffer soit faut trouver une autre solution .... Et la tension image sera 10 x 0.1 = 1V

Oui oui tout cela me parait totalement logique. Merci pour la petite précision :)

Après il faudra surement un circuit de sécurité avec une diode zener pour protéger la nono.

C'est obligatoire ? C'est par mesure de sécurité si je comprends bien.

Une petite question : La on a vu pour détecter l'utilisation, mais comment détecter l'arrèt ? C'est le mème principe je suppose lorsque la résistance ne fournit plus de tension le compteur ne sera pas alimenter ? il reprendra lors du prochain démarrage si je me trompe pas.

Merci pour le lien. Mais ce n'est pas la mème RTC. Nous utilisons une RTC Grove (Encore une fois imposé par notre professeur..) mais qui est basé sur la RTC Ds1307 plus connu c'est pourquoi que je parle de celle-ci. Mais si je comprends bien je peu me servir du fonctionnement d'une alarme ? Sauf qu'a la place d'un signal sonore, ce serait une led.

Bonjour Il existe un shield mesure de courant pour Arduino avec une sortie analogique de 185 mv par A qu'on raccorde à une entrée analogique de l'Arduino. Voir capteur de courant pour Arduino sur le net. A+

Si je comprends bien son but est de divisé une grosse tension pour en donner une petite et n’avoir aucun risque sur la carte.
Ce qui remplacerais le montage que nous avons vu avant ?

Exact, c'est une bobine qui entoure le cable et fait une sorte de transformateur : http://www.gotronic.fr/art-capteur-de-courant-asm10-11526.htm http://www.gotronic.fr/art-capteur-de-courant-grove-sen23931p-18986.htm

Ce qui serait beaucoup plus simple. C'est parfait comme ça j'ai plusieurs solutions. Merci beaucoup :)

Je crois que je n'ai plus de questions à ce sujet merci à vous tous de m'avoir aidé... je retournerais sur ce forum on trouve beaucoup plus de personne aimable et prètent à prendre de leur temps pour les autres.

Dans un autre domaine (Pas si différent que celui si en fin de compte) j'aurais une autre question finalement. Comment faire cette fois allumer DEUX leds pour indiquer la température de chauffe atteinte et celle de sécurité ? Je m'explique : - Pour la premiere Led notre stylo 3D va chauffer pour faire fondre le fil d'ABS, une fois que nous avons atteint la température pour faire fondre le fil la chauffe va s'arrèter (Ce n'est pas moi qui gère cela) et une led va s'allumer (cette fois c'est moi^^) indiquant à l'utilisateur qu'il peut utiliser le stylo. - Une second led elle sera la pour prévenir l'utilisateur si la température du stylo dépasse un seuil qui pourrais occasionné des brulures. La mesure de température ce fera à l'aide d'une Pt100 ou d'un Termocouples (Celui qui s'occupe de cette partie penche plus sur le Thermocouples, seul problème : l'accord du prof^^).

Après quelques recherche(Pour allumer ces deux leds, parce que en fin de compte seulement le seuil changera) j'ai trouvé que l'on pouvait procéder de cette manière : La Pt100 (Ou thermocouples) 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 (En fin de compte la ça reviens à la mème chose que le système de ma led qui s'allume au bout d'un certain temps)

Je tenais vraiment à vous remercier pour toutes l'aide que vous m'avez apporté, vous avez pu remarquer que je ne suis vraiment pas doué dans ce domaine... je fais de mon mieux. Merci à vous.

Je précise que je pense utiliser un comparateur LM311 à deux seuils ça éviterais d'en mettre deux. Après je ne sais pas si c'est possible..

Excusez moi pour les “multi-post” je venais seulement mettre à jour mes recherches sur ce sujet.
En ce qui concerne mes LEDs pour indiquer la température de chauffe atteinte et celle de sécurité.
Le principe :
Les réglages des différents seuil de température ce fera par un potentiomètre.

  • Pour le premier seuil(Lorsque la chauffe de l’ABS est suffisante pour commencer l’utilisation) : Tant que la température est inférieure à 230°, le chauffage fonctionne.
    Passé 230°, le chauffage s’arrête. Et la led s’allume.
  • Pour le second seuil (De sécurité, pour éviter toutes brulures) : Tant que la température est inférieur au seuil de température de sécurité la led reste éteinte
    Passé ce seuil, la led s’allume.
    Lorsque la température redescend en dessous du seuil, la led s’éteint .

Ensuite dans la pratique (plus compliqué) :
Pour cela on va utiliser un comparateur à hystérésis, il est intéressant car il permet d’avoir 2 seuils: Un pour l’activation l’autre pour la désactivation.
D’autant plus que le schéma est très simple, il suffit d’avoir 2 résistances et 1 AOP(amplificateur opérationnel, il permet d’effectuer des opérations mathématiques.)
l’AOP: Vs = +Vcc lorsque V+ > V- => Tension de Sortie = + Courant continue lorsque V+ > V-
Vs = -Vcc lorsque V+ < V- => Tension de Sortie = - Courant continue lorsque V+ < V-
Il faut donc calculer V+, pour cela on utilise un pont diviseur ( un montage électronique simple qui permet de diviser une tension d’entrée )
On a V+ = (R1Vs + R2 Ve) / (R1 + R2)
Si on pour de l’état de sortie bas, donc Vs = -Vcc
on a V+ = (R1*(-Vcc) + R2* Ve) / (R1 + R2)

Bonjour / Bonsoir;

Je reviens sur ce topic après quelques temps car de nouvelle problématique ce sont posées. Je rappel "l'idée" : - Dès la détection d'utilisation : mise en mémoire de la date. - Toutes les secondes : mise à jour du compteur = date - date de départ - Si compteur > au seuil ==> allumage LED. - Si plus d'utilisation on enregistre plus compteur.

  • Premièrement pour détecter l'utilisation de la tète on m'avait dit d'utiliser un capteur de courant, seul bémol c'est que ce celui que je pensais utiliser est que pour du courant alternatif et j'ai du continu... on m'en a proposer un second celui-ci : http://www.gotronic.fr/art-capteur-de-courant-asm10-11526.htm mais je n'arrive pas à savoir si il fait pour du continu ou pas.

  • Secondo, je crois que j'ai un petit soucis de compréhension... Mon but est au bout d'un certain temps d'utilisation une led s'allumer. J'ai donc une RTC qui va me faire un comptage du temps, mais elle va le faire en permanence en fait ? Et lorsque l'on détecte l'utilisation ça viendra lire les valeurs dans le module RTC. On soustrait et on accumules en mémoire. En soit nous allons compter les impulsions de la RTC, et y incrémenter dans le compteur qui lorsqu'il atteint un seuil déclenche une action, qui sera ici "Allumer la LED". Voila ce que j'avais compris mais j'arrive pas vraiment à réellement comprendre le principe... si quelqu'un pourrait m'expliquer ce serait vraiment sympa. ps : Sinon il y a aussi ça mais je sais pas si dans mon cas ça marche : http://www.maximintegrated.com/datasheet/index.mvp/id/2756/t/al

Merci d'avance

SGRmetrage: on m'en a proposer un second celui-ci : http://www.gotronic.fr/art-capteur-de-courant-asm10-11526.htm mais je n'arrive pas à savoir si il fait pour du continu ou pas.

La doc indique "Fréquence: 50/60 Hz " et ça fonctionne sur le principe du transformateur, donc en alternatif.

Ah merci... J'ai cherché et je n'arrive vraiment pas à trouver ça n'existe donc pas pour du continu ?

Bonsoir,

SGRmetrage: Ah merci... J'ai cherché et je n'arrive vraiment pas à trouver ça n'existe donc pas pour du continu ?

Si Par exemple , http://www.gotronic.fr/art-capteur-de-courant-30-a-1122-12096.htm ou http://www.gotronic.fr/art-capteur-de-courant-5a-mr361-20839.htm Mais ils existent beaucoup d'autres fournisseurs @+

Bonjour; GROS CHANGEMENT !!!!! Mon prof à décidé une toute autre manière.

Nous allons utiliser un capteur ILS, qui lorsque l'on rettirera le stylo de son socle le mettra en marche (Mais ça ce n'est pas ma partie) et qui déclenchera le comptage du temps avec la RTC grove. Une fois reposer ça arrétera le comptage et mettra en mémoire le temps d'utilisation dans la ram de la rtc. Voila les directives de mon prof j'avoue que je suis un peu perdu...

merci.

je comprends le principe mais le plus dur pour moi est de le réaliser étant totalement nul en électronique et programmation je suis vraiment perdu on va dire.. .