Répondre à la discussion
Affichage des résultats 1 à 10 sur 10

Allumer une led au bout d'un certains temps



  1. #1
    SGRmetrage

    Allumer une led au bout d'un certains temps


    ------

    Bonjour;
    Je poste une nouvelle fois mon sujet sur ce forum... Je me permet de recréer un sujet étant donné que l'ancien était un gros foutoir mélangé avec deux autres problèmes que j'avais. 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. Si ça pose un problème veillez me le signalez je supprimerais ou demanderais qu'on transfère mon post. Excusez-moi d'avance.

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

    Plus précisément nous allons utiliser un capteur ILS, qui lorsque l'on retirera 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(C'est donc ça que je veux réaliser). Une fois reposer, le comptage s’arrêtera et mettra en mémoire le temps d'utilisation dans la ram de la rtc(Mon prof m'a parlé de stocker de l'EEPROM d'arduino car c'est plus simple mais ce qui m’embête c'est tout de mème la limitation de 100 000 écritures). Voila les directives de mon prof j'avoue que je suis un peu perdu dans la réalisation de cette seconde partie..

    Je voulais donc continuer dans l'idée de mon prof en stockant sur l'EEPROM d'arduino.
    • Pour commencer mon programme pour faire fonctionner ma RTC grove (qui marche) :

    #include "DS1307.h"

    DS1307 clock;//define a object of DS1307 class
    void setup()
    {
    Serial.begin(9600);
    clock.begin();
    clock.fillByYMD(2014,2,6);// 06 Fevrier,2014
    clock.fillByHMS(17,50,30);//13:53 30"
    clock.fillDayOfWeek(THU);//Jeudi
    // clock.setTime();//write time to the RTC chip
    }
    void loop()
    {
    printTime();
    }


    /*--------------------------------------------------*
    * Fonction: Affiche le temps sur le moniteur série *
    *--------------------------------------------------*/
    void printTime()
    {
    clock.getTime();

    Affiche_JOUR();
    Serial.print(" ");

    Affiche_JMA();
    Serial.println(" ");

    Affiche_HMS();
    Serial.print(" ");

    delay(500);

    }

    void Affiche_HMS()
    {
    Serial.print(clock.hour, DEC);
    Serial.print(":");
    Serial.print(clock.minute, DEC);
    Serial.print(":");
    Serial.print(clock.second, DEC);
    }

    void Affiche_JOUR()
    {
    switch (clock.dayOfWeek)// Friendly printout the weekday
    {
    case MON:
    Serial.print("LUNDI ");
    break;
    case TUE:
    Serial.print("MARDI ");
    break;
    case WED:
    Serial.print("MERCREDI ");
    break;
    case THU:
    Serial.print("JEUDI ");
    break;
    case FRI:
    Serial.print("VENDREDI ");
    break;
    case SAT:
    Serial.print("SAMEDI ");
    break;
    case SUN:
    Serial.print("DIMANCHE ");
    break;
    }
    }

    void Affiche_JMA()
    {
    Serial.print(clock.dayOfMonth, DEC);
    Serial.print("/");
    Serial.print(clock.month, DEC);
    Serial.print("/");
    Serial.print(clock.year+2000, DEC);
    Serial.print(" ");

    }
    • Dans l'hypothèse ou j'utiliserais l'EEPROM je pense partir de ce programme :
    Code:
    #include 
    
    // the current address in the EEPROM (i.e. which byte
    // we're going to write to next)
    int addr = 0;
    
    void setup()
    {
    }
    
    void loop()
    {
      // need to divide by 4 because analog inputs range from
      // 0 to 1023 and each byte of the EEPROM can only hold a
      // value from 0 to 255.
      int val = analogRead(0) / 4;
      
      // write the value to the appropriate byte of the EEPROM.
      // these values will remain there when the board is
      // turned off.
      EEPROM.write(addr, val);
      
      // advance to the next address.  there are 512 bytes in 
      // the EEPROM, so go back to 0 when we hit 512.
      addr = addr + 1;
      if (addr == 512)
        addr = 0;
      
      delay(100);
    }


    Vous allez me prendre pour un abrutis mais dois-je le remplir de cette manière ?
    "EEPROM.write(clock.hour,hour) ;
    EEPROM.write(clock.minute,minu );
    EEPROM.write(clock.second,sec) ;"

    J'ai beaucoup de mal justement dans la programmation.. je tâtonne donc pour essayer .
    Merci d'avance de votre aide et du temps que vous prenez pour répondre à mes messages(qui doivent parfois vous rendre dingue), pour les explications et j'en passe! Merci infiniment.

    -----

  2. Publicité
  3. #2
    azad

    Re : Allumer une led au bout d'un certains temps

    Si l' EEPROM est limitée aux environs de 100 000 écritures, ce n'est pas une idée judicieuse d'écrire dedans à l'intérieur d'une boucle void loop !
    Je n'ai pas regardé le reste de ton programme mais il me semble que tu devrais lire le contenu de trois adresses seulement de la ROM. Celle correspondant aux heures, celle des minutes et celle des secondes. Pas la peine de remplir la ROM puisque trois adresses suffisent. Tu fais cela dans la zone d'initialisation des variables et ensuite tu incrémentes ces variables et seulement elles dans ta boucle. Elles te permettront de connaître le temps d'utilisation sans écrire dans la ROM. Ce n'est que quand tu interrompt le programme ( en posant ton stylo) que tu transfères heures, minutes et secondes dans la ROM. Ainsi tu auras droit à 100 000 poses de ton stylo.
    Sinon, même avec une tempo de 100mS ton EEProm sera hors d'usage en trois heures à peu près.

  4. #3
    SGRmetrage

    Re : Allumer une led au bout d'un certains temps

    Ah oui merci c'est ce dont je pensais sans trouver les termes techniques pour l'expliquer!
    Bon maintenant il faut que je comprenne comment le faire..

    merci de ta réponse.

  5. #4
    azad

    Re : Allumer une led au bout d'un certains temps

    Hé bien il suffit d'utiliser la fonction millis() qui fait partie du jeu d'instruction de l'Arduino.
    Tu divises la valeur qu'elle retourne par 1000 et tu as ainsi un nombre en secondes que tu n'as plus qu'à convertir en H/M/S. Tu ranges ces trois valeurs dans les trois variables Hnew, Mnew et Snew
    Au début de ton projet, l' EEPROM est vide de toute données.
    Quand le projet débute et dans la zone de déclaration des variables tu vas lire trois adresses (1,2 et 3 par exemple)de ton EEPROM. Tu ranges ces trois valeurs dans trois variables H, M et S qui sont toutes égales à zéro.
    Tu sors ton stylo de son support et quelques instant plus tard, tu l'y repose. La fonction millis() contient alors le temps en millisecondes pendant lequel le stylo était utilisé. Tu calcules les nouvelles Hnew, Mnew et Snew que tu ajoutes respectivement à H, M et S avant de les ranger dans l' EEPROM avec write (1, H) write (2, M) et write (3, S) … et c'est tout.
    Quand tu sortiras à nouveau ton stylo tu retrouveras les valeurs stockées dans l'EEPROM. Ces valeurs seront H , M et S de la précédente utilisation. Même si celle-ci remonte à plusieurs jours.
    Ta boucle void loop peut-être entièrement vide.
    Ce n'est qu'en remettant le stylo à sa place que l'état de ton ILS va changer et tu profites de ce changement d'état pour ajouter respectivement à H, M et S les nouvelles valeurs que la fonction millis() va te retourner et écrire ces valeurs dans les trois adresses de l' EEPROM. Ensuite tu interrompt le programme. Ainsi, tu n'écris qu'une seule fois par utilisation du stylo dans l' EEPROM
    Le programme n'est pas difficile à écrire, on pourrait même te l'envoyer ici mais ce serait gâcher ton plaisir.
    Notes que tu peux LIRE l'EEPROM autant de fois que tu le souhaites, c'est seulement le nombre d' ECRITURES qui est limitée à quelques 100 000.
    Bon, mon message est en fait bien plus long que ne le sera ton programme, j'espère que tu as tout compris.

  6. #5
    SGRmetrage

    Re : Allumer une led au bout d'un certains temps

    Oui mais je dois utiliser une RTC et non la comptage du temps écoulé avec millis()...

    Je bloque sur cette partie de mon programmme :
    // Sauvegarde
    EEPROM.write(clock_hour,hour);
    EEPROM.write(clock_minute,minu );
    EEPROM.write(clock_second,sec) ;

    // advance to the next address. there are 512 bytes in
    // the EEPROM, so go back to 0 when we hit 512.
    clock_hour = clock_hour + 1;
    if (clock_hour == 512)
    clock_hour = 0;

    delay(100);

    Je comprends pas la partie

    // advance to the next address. there are 512 bytes in
    // the EEPROM, so go back to 0 when we hit 512.
    clock_hour = clock_hour + 1;
    if (clock_hour == 512)
    clock_hour = 0;

    delay(100);
    Enfaite je suis réellement totalement perdu... je comprends vraiment plus..

  7. A voir en vidéo sur Futura
  8. #6
    azad

    Re : Allumer une led au bout d'un certains temps

    Désolé, je ne comprends plus rien.
    Si tu as a ta disposition un module équipé d'un RTC 1302, alors on peut supposer que tu es autorisé de l'équiper d'une pile de sauvegarde. Ton unique travail consiste alors à lire, et à traiter, les bits correspondants aux trois données qui t' intéressent. Tu ignores totalement date, mois, année et tu ne récolte que H, M et S. Quand tu as ces trois données, la suite reste identique à ce que je t'ai donné.
    Tu consulte la doc de ton TRC pour savoir quels sont les bits à conserver.

    Et tiens, pendant que j'y suis, piqué par la curiosité, je sors à l'instant de Google qui m'a appris que l' Arduino possède une bibliothèque dédiée au DS1302. Autant dire que ton problème est quasiment un problème public… sans intérêt donc.

  9. Publicité
  10. #7
    SGRmetrage

    Re : Allumer une led au bout d'un certains temps

    Bonsoir;
    Alors voila quelques avancées cette semaine, des idées un peu de programmation ^^"

    J'ai déja repris mon programme de la RTC, j'y ai ajouté un bouton qui lorsque l'on appuis dessus fais le calcul du nombre d'heures, de minutes et de secondes et converti tout en secondes et affiche le total sur el moniteur série.
    Voila la bète :

    Code:
    #include <TinkerKit.h>
    
    #include <Wire.h>
    #include "DS1307.h"
    
    double SEC;
    const int buttonPin = A2;
    int buttonState = 0;  
    
    
    
    DS1307 clock;//define a object of DS1307 class
    void setup()
    {
    	Serial.begin(9600);
    	clock.begin();
    	clock.fillByYMD(2014,3,27);// 06 Fevrier,2014
    	clock.fillByHMS(17,50,30);//13:53 30"
    	clock.fillDayOfWeek(THU);//Jeudi
      	clock.setTime();//write time to the RTC chip
    }
    void loop()
    {
    	printTime();
            calcul_SEC();
            buttonState = digitalRead(buttonPin);
    }
    
    
    /*--------------------------------------------------* 
     * Fonction: Affiche le temps sur le moniteur série *
     *--------------------------------------------------*/
    void printTime()
    {
    	clock.getTime();
            
            Affiche_JOUR();
    	Serial.print("	");        
    
            Affiche_JMA();
    	Serial.println(" ");
           
            Affiche_HMS();
    	Serial.println(" ");
            
            delay(500);
            
    }
    
    void Affiche_HMS()
        {
         Serial.print(clock.hour, DEC);
         Serial.print(":");
         Serial.print(clock.minute, DEC);
         Serial.print(":");
         Serial.print(clock.second, DEC);
        }
    
    void Affiche_JOUR()
        {
       	switch (clock.dayOfWeek)// Friendly printout the weekday
    	     {
    		case MON:
    		  Serial.print("LUNDI ");
    		  break;
    		case TUE:
    		  Serial.print("MARDI ");
    		  break;
    		case WED:
    		  Serial.print("MERCREDI ");
    		  break;
    		case THU:
    		  Serial.print("JEUDI ");
    		  break;
    		case FRI:
    		  Serial.print("VENDREDI ");
    		  break;
    		case SAT:
    		  Serial.print("SAMEDI ");
    		  break;
    		case SUN:
    		  Serial.print("DIMANCHE ");
    		  break;
                 }
        }
        
    void Affiche_JMA()	
        {
         Serial.print(clock.dayOfMonth, DEC);
         Serial.print("/");
         Serial.print(clock.month, DEC);
         Serial.print("/");
         Serial.print(clock.year+2000, DEC);
         Serial.print(" ");
        }
        
     void calcul_SEC()
         {
        buttonState = digitalRead ( buttonPin ) ; 
         if (buttonState == HIGH) 
         {
           SEC= ((clock.hour)*36E2)+((clock.minute)*60)+ (clock.second);
           Serial.println(SEC);
         
         }
         }

    Il faudrait donc que lorsque j'appuie sur le bouton il stocke le temps en seconde dans l'EEPROM. En fait plus précisément nous allons utiliser un capteur ILS, qui lorsque l'on retirera 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(C'est donc ça que je veux réaliser). Une fois reposer, le comptage s’arrêtera et mettra en mémoire le temps d'utilisation dans la ram de la rtc.
    Pour le moment le capteur ILS est remplacé par le bouton, il faudrait donc lorsque j'appuie que ça stocke en mémoire sur l'EEPROM et à chaque nouvelle utilisation que ça face un cumule du temps... je sais pas si vous arrivez à me suivre.

    Voila le programme de l'EEPROM que j'ai commencé à remplir mais je sais pas trop comment..

    Code:
    /*
     * EEPROM Write
     *
     * Stores values read from analog input 0 into the EEPROM.
     * These values will stay in the EEPROM when the board is
     * turned off and may be retrieved later by another sketch.
     */
    #include <EEPROM.h>
    
    int clock_hour=0;
    int clock_minute=0;
    int clock_second=0;
    
    byte sec,minu,hour;
    
    /* the current address in the EEPROM (i.e. which byte
     we're going to write to next)*/
    
    void setup()
    {
    }
    
    void loop()
    {
      // need to divide by 4 because analog inputs range from
      // 0 to 1023 and each byte of the EEPROM can only hold a
      // value from 0 to 255.
      int val = analogRead(0) / 4;
      
      // write the value to the appropriate byte of the EEPROM.
      // these values will remain there when the board is
      // turned off.
       
       // Sauvegarde
       EEPROM.write(clock_hour,hour);
       EEPROM.write(clock_minute,minu);
       EEPROM.write(clock_second,sec);
    
      // advance to the next address.  there are 512 bytes in 
      // the EEPROM, so go back to 0 when we hit 512.
    addr = addr + 1;
      if (addr == 512)
        addr = 0;
      
      delay(100);
    }
    Merci d'avance pour votre patience et votre aide.

  11. #8
    azad

    Re : Allumer une led au bout d'un certains temps

    Tu es vraiment têtu !!!
    Pourquoi t'obstines-tu à vouloir écrire dans toute la ROM ?
    Pour stoker (et cumuler) heures, minutes et secondes, tu n'as besoin que de TROIS adresses dans cette ROM.
    Je t'ai tout expliqué plus haut.

  12. #9
    SGRmetrage

    Re : Allumer une led au bout d'un certains temps

    Bonjour;
    Impossible de retrouver mon sujet avant de comprendre qu'on pouvait le retrouver sur notre profile... fin bon.
    Oui excuse moi je ne comprenais pas vraiment ce que tu voulais me dire, j'ai donc enlevé tout ce qui était date, année, moi etc. Et je ne garde que les Heures, minutes, secondes, de toutes façon je converti tout en seconde.
    J'ai travaillé depuis mais je suis face à quelques soucis. Je tiens à rappeler avant que je suis OBLIGE d'utiliser une RTC et un EEPROM c'est imposé.

    je vais vous donner quelques explications sur mon programme :
    - J'ai tout d'abord fait mon programme pour utiliser une RTC grove( basé sur la RTC 1307)
    => Je n'ai gardé que les informations d'heures, minutes et secondes (le reste n'étant pas utile dans mon cas.)
    => Et j'ai fais en sorte que l'heure soit en secondes (c'est plus simple pour la suite)

    - Deuxième étape, j'ai fait en sorte que le programme compte combien de temps s'écoule entre deux appuie sur le bouton.
    => Et j'ai fais en sorte que ce temps soit affichée en secondes donc pour cela j'ai réaliser mon petit calcul et le résultat porte le nom de variable "resultatfinal"
    => J'ai ajouté au temps entre deux appuis 995 s (Pour pouvoir atteindre plus rapidement 1000s, OUI je sais 1000s n'est pas égale à 1000h mais pour ne pas m'embèter avec 50 variables pour le moment j'ai fait comme cela. Donc disons la dans ce cas je veux atteindre 1000s donc environ 16min36s si je me trompe pas)

    - Ensuite troisième étape j'ai "préparé" ma donné à être stocker dans l'eeprom d'arduino" comme le max peut être 1000 secondes j'ai découpé la donné en deux morceau pour la stocker : 1) millième et centième (dans le programme variable "mc") 2) dizaine et unité centième (dans le programme variable "du" )
    => J'ai par la suite affiché toutes ces données dans le port série pour tester.

    Le voici :

    Code:
    #include <EEPROM.h>
    
    #include <TinkerKit.h>
    
    #include <Wire.h>
    #include "DS1307.h"
    
    double SEC;
    const int buttonPin = A2;
    int buttonState = 0;
    double result1; 
    double result2;
    int comptage=0;
    int resultfinal;   // millieme et centaine  +  dizaine et unite
    int resultat_mc;  // nombre partie millieme et centaine 
    int resultat_du;  // nombre partie dizaine et unite
    byte dueeprom,mceeprom;
    
    byte valuedu;
    byte valuemc;
    const int adresse_epromdu= 0;
    const int adresse_eprommc= 1;
    
    
    DS1307 clock;//define a object of DS1307 class
    void setup()
    {
    	Serial.begin(9600);
    	clock.begin();
    	clock.fillByYMD(2014,3,27);// 06 Fevrier,2014
    	clock.fillByHMS(17,50,30);//13:53 30"
    	clock.fillDayOfWeek(THU);//Jeudi
      	clock.setTime();//write time to the RTC chip
    }
    void loop()
    {
    	printTime();
            calcul_SEC();
            buttonState = digitalRead(buttonPin);
             resultat_mc=round(resultfinal/100);
      
      Serial.print("nombre avant decomposition : ");
      Serial.println(resultfinal);
      
      Serial.print("nombre partie centaine et millieme : ");
      Serial.println(resultat_mc);
      
      resultat_du=(resultfinal-(100*resultat_mc));
      
      Serial.print("nombre partie dizaine et unite : ");
      Serial.println(resultat_du);
    
         delay(1000);
    
    		// sauvegarde
    	  EEPROM.write(adresse_epromdu, resultat_du);
    
       
    	  EEPROM.write(adresse_eprommc, resultat_mc);
    
    	  delay(200); //  1 sec
    
    
              
              
    // Lecture 
    
       valuedu = EEPROM.read(adresse_epromdu);
      Serial.print("nombre partie dizaine et unite sauvegarde  : ");
      Serial.println(valuedu, DEC);
      Serial.println("\t");
       
    
         valuemc = EEPROM.read(adresse_eprommc);
      Serial.print("nombre partie centaine et millieme sauvegarde: ");
      Serial.println(valuemc, DEC);  
      Serial.println("\t");
     
          
              
    }
    
    
    
    
    
    /*--------------------------------------------------* 
     * Fonction: Affiche le temps sur le moniteur série *
     *--------------------------------------------------*/
    void printTime()
    {
    	clock.getTime();
            
           
            Affiche_HMS();
    	Serial.println(" ");
            
            delay(500);
            
    }
    
    void Affiche_HMS()
        {
         Serial.print(clock.hour, DEC);
         Serial.print(":");
         Serial.print(clock.minute, DEC);
         Serial.print(":");
         Serial.print(clock.second, DEC); 
        }
    
    
        
     void calcul_SEC()
         {
        buttonState = digitalRead ( buttonPin ) ; 
         if (buttonState == HIGH) 
         {
           SEC= ((clock.hour)*36E2)+((clock.minute)*60)+ (clock.second);
           Serial.println(SEC);
           comptage++;
           if (comptage==1)
           {
             result1= SEC;
           }
           if (comptage==2)
           {
            result2 = SEC;
            resultfinal=(result2-result1)+995; //// le ajout de 995 secondes pour les tests
            comptage=0;
         
           }
         
         }
         }
    Donc la pas de soucis tout marche parfaitement il me stocke bien le nombre de seconde dans l'eeprom et me l'affiche comme je le veux.
    Mais j'aimerais cumuler ce temps, avec toutes les utilisations.
    Je n'aurais jamais plus de 3h d'utilisation soit : 10800 secondes, donc il me faudra trois variable pour pouvoir découpé mon nombre (Une dizaine et unité, Une millième et centième et une dernière dizaine de millième) pour le comptage du temps d'utilisation, inutile d'en mettre une 4ième déja 3h d'utilisation c'est très très long pour cette utilisation.
    Par contre au niveau du stockage si puisque qu'on veut attendre 1000h soit 3600000 secondes.
    Est-ce que ça marcherais de dire que lorsque l'on atteint 99999 secondes (environ 27,7 heures) il faut incrémenté la variable suivante pour avoir 1000000 ?
    Dans ce model la (ici c'est fait avec les minutes et secondes) :

    Code:
    if (sec==60) // + de 60s -> +1min
     	  {
    		sec=0;
    		minu++;
    	  }
        	  if (minu==60) // + de 60min -> +1h
    	  {
    		minu=0;
    		heu++;
    	  }
      	  if (heu==100)  // + de 100h -> +1centaine d'heure
    	  {
    		heu=0;
    		cen++;
    	  }
    Dans la théorie il faudrait à chaque nouvelle utilisation lire en mémoire le temps d'utilisation, et rajouté le nouveau, le cumuler quoi. Mais après comment faire..
    Merci beaucoup de votre aide et je vais essayer de ne pas perdre le sujet cette fois.
    Dernière modification par SGRmetrage ; 09/04/2014 à 13h27.

  13. #10
    azad

    Re : Allumer une led au bout d'un certains temps

    Salut
    Je n'ai pas décortiqué tout ton listing, mais déjà on voit une amélioration.
    Il reste un point a corriger très vite, avant que ton EPROM, ne baisse les bras : l'écriture dans cette EPROM ne doit pas être située dans le MainLoop, car même si tu fait une temporisation d'une seconde (qui par ailleurs, risque de fausser les résultats) tu vas pendant la période d'essais risquer de voir le nombre d'écriture maximum dans l'EPROM, atteint. Et puis, même si ce n'était pas le cas, cela ne ce fait pas, simplement par élégance.
    Pour le cumul des temps, ne te fais pas de soucis, cela viendra tout naturellement et très simplement quand ton programme sera bien structuré.

Sur le même thème :

Discussions similaires

  1. Panne ecran lcd, met du temps à s'allumer
    Par mryoshi dans le forum Dépannage
    Réponses: 15
    Dernier message: 24/02/2013, 15h07
  2. [Divers] Transformateur 12 V : met du temps à s'allumer !
    Par Peeddrroo dans le forum Dépannage
    Réponses: 4
    Dernier message: 11/09/2011, 05h55
  3. [Brun] LCD: plus d'image au bout d'un certain temps, son ok??
    Par christfair dans le forum Dépannage
    Réponses: 1
    Dernier message: 02/03/2011, 08h23
  4. dc4060 : montage pour allumer une led au bout de 10minutes
    Par Non inscrit dans le forum Électronique
    Réponses: 35
    Dernier message: 27/03/2008, 01h30
  5. dc4060 : montage pour allumer une led au bout de 5h
    Par galipac dans le forum Électronique
    Réponses: 34
    Dernier message: 07/03/2008, 23h11