Partage
  • Partager sur Facebook
  • Partager sur Twitter

Aide programme Arduino

Allumer ou eteindre led avec potentiomètre

Sujet résolu
    29 avril 2012 à 10:38:14

    Bonjour, à tous

    Je me présente: élevé de terminale S SI
    Dans le cas d'un projet scolaire, je voudrais pouvoir éteindre/allumer une led à l'aide d'un capteur potentimétrique dans un cas bien précis.
    Or je me suis mis à apprendre le début du C, mais cependant mes connaissances ne me permettent pas encore d'arriver à mes fins.
    C'est pour cela que je vous demande de l'aide.

    Nous sommes dans le cas d'une maquette d'un volet roulant (domotique) d'une maison ou l'on symbolise l'action de monté du moteur su volet par une led pareillement pour la descente.
    Ce programme doit éteindre ces leds (afin de montré que le volet est bien monté ou bien descendu) qui aurait été allumées préalablement par ordre donné par un flux rss.

    J'ai poster l'ébauche de mon programme, et j'aimerais que quand le micro contrôleur lit "1023" il eteigne une led : "la led de montée"
    et que quand il lit 0, il éteigne la led de descente.

    Le tout sans que cela ne bloque les led dans cet état (afin que l'on puisse renvoyer un nouvel ordre par flux rss par exemple s'il est en bas qu'il puisse monté donc que la led se rallume)

    Je m'explique, enfaîte j aimerais intégrer ce programme dans un autre ou l'on récupère un commande: "un flux" sur le web qui fait allume la led monté ou descente selon la position du volet donnée par le capteur potentimétrique.

    Enfin, je dispose d'un capteur potentiométrique (linéaire) 10kohm

    Je vous remercie par avance d'une eventuelle aide .

    *
    * Potentiometre contrôlant l'extinction ou non d'une/des leds
    * Si 1023 alors la LED de montée s'eteind
    * Si 0 alord LED de descente s'éteind
    * Broche 0 connectée au potentiomètre
    * Broche 5 connectée à la LED de monter
    * Broche 6 connectée à la LED de descente
    *
    
    int potPin = 0;    // select the input pin for the potentiometer
    int ledPin2 = 5;   // select the pin for the LED de montée
    int ledPin3 = 6;   // select the pin for the LED de descente
    int val = 0;       // variable to store the value coming from the sensor
    
    void setup() {
      pinMode(ledPin, OUTPUT);  // declare the ledPin as an OUTPUT
      pinMode(ledPin2, OUTPUT); // Met la broche numérique en sortie 
      pinMode(ledPin3, OUTPUT); // Met la broche numérique en sortie 
    }
    
    void loop() {
      val = analogRead(potPin);    // read the value from the sensor
      digitalWrite(ledPin, LOW);   // turn the ledPin off
    }
    
    • Partager sur Facebook
    • Partager sur Twitter
      29 avril 2012 à 10:55:45

      Et si une led est éteinte, l'autre est allumée ?
      si oui essaye sa :
      /*
      * Potentiometre contrôlant l'extinction ou non d'une/des leds
      * Si 1023 alors la LED de montée s'eteind
      * Si 0 alord LED de descente s'éteind
      * Broche 0 connectée au potentiomètre
      * Broche 5 connectée à la LED de monter
      * Broche 6 connectée à la LED de descente
      */
      
      int potPin = 0;    // select the input pin for the potentiometer
      int ledPin2 = 5;   // select the pin for the LED de montée
      int ledPin3 = 6;   // select the pin for the LED de descente
      int val = 0;       // variable to store the value coming from the sensor
      
      void setup() {
       // pinMode(ledPin, OUTPUT);  // declare the ledPin as an OUTPUT
        pinMode(ledPin2, OUTPUT); // Met la broche numérique en sortie 
        pinMode(ledPin3, OUTPUT); // Met la broche numérique en sortie 
      }
      
      void loop() {
        val = analogRead(potPin);    // read the value from the sensor
        if( val >= 1000)//pour avoir de la marge
        {
          digitalWrite(ledPin2, LOW);// turn the ledPin2 off
          digitalWrite(ledPin3, HIGH);// turn the ledPin3 on
        } 
        else if( val <= 23)//pour avoir de la marge
        {
          digitalWrite(ledPin2, HIGH);// turn the ledPin2 on
          digitalWrite(ledPin3, LOW);// turn the ledPin3 off
        }
        else//sinon on éteint tout
        {
          digitalWrite(ledPin2, LOW);// turn the ledPin2 off
          digitalWrite(ledPin3, LOW);// turn the ledPin3 off
        }
       // digitalWrite(ledPin, LOW);   // turn the ledPin off
      }
      

      En espérant que sa réponde a tes attentes :)

      EDIT : tu sais brancher ton potentiomètre ?
      • Partager sur Facebook
      • Partager sur Twitter
      2b||!2b   sqrt(4b²)
        29 avril 2012 à 12:29:41

        Je suis pas bien sur d'avoir compris... Ton potentiomètre représente ton volet c'est ca ? Autrement dit en le tournant tu symbolises le "déroulement/enroulement" du volet. C'est ca ?
        Donc si le potar vaut 0 le volet est en bas, s'il vaut 1023 il est en haut.
        Donc tu ne cherches pas une action (descente/montée) mais plutôt un état (fermée, ouvert, entre les deux).

        Le code de diode permettra de représenter cet état...
        Si tu veux symboliser le mouvement du volet (en descente, en montée) il te faut regarder la différence de valeur du potentiomètre entre deux instants.

        Si à t1 la valeur du potard est plus grande qu'a t0, alors le volet monte (allume une troisième LED "en montée")
        Si à t1 la valeur du potard est plus petite qu'a t0, alors le volet descend (allume une quatrième LED "en descente")

        C'est ca ?
        • Partager sur Facebook
        • Partager sur Twitter
          29 avril 2012 à 12:36:22

          dans ce cas :
          (réfléchi avant :p )
          /*
          * Potentiometre contrôlant l'extinction ou non d'une/des leds
          * Si 1023 alors la LED de montée s'eteind
          * Si 0 alord LED de descente s'éteind
          * Broche 0 connectée au potentiomètre
          * Broche 5 connectée à la LED de monter
          * Broche 6 connectée à la LED de descente
          */
          
          int potPin = 0;    // select the input pin for the potentiometer
          int ledPin2 = 5;   // select the pin for the LED de montée
          int ledPin3 = 6;   // select the pin for the LED de descente
          int val = 0;       // variable to store the value coming from the sensor
          int ancVal = 0;
          
          void setup() {
           // pinMode(ledPin, OUTPUT);  // declare the ledPin as an OUTPUT
            pinMode(ledPin2, OUTPUT); // Met la broche numérique en sortie 
            pinMode(ledPin3, OUTPUT); // Met la broche numérique en sortie 
            ancVal = analogRead(potPin);
          }
          
          void loop() {
            val = analogRead(potPin);    // read the value from the sensor
            if( val < ancVal)//on monte
            {
              digitalWrite(ledPin2, HIGH);// turn the ledPin2 on
              digitalWrite(ledPin3, LOW);// turn the ledPin3 off
            } 
            else if( val > ancVal)//on descend
            {
              digitalWrite(ledPin2, LOW);// turn the ledPin2 off
              digitalWrite(ledPin3, HIGH);// turn the ledPin3 on
            }
            else//sinon on éteint tout
            {
              digitalWrite(ledPin2, LOW);// turn the ledPin2 off
              digitalWrite(ledPin3, LOW);// turn the ledPin3 off
            }
            ancVal = val;
           // digitalWrite(ledPin, LOW);   // turn the ledPin off
          }
          
          • Partager sur Facebook
          • Partager sur Twitter
          2b||!2b   sqrt(4b²)
            29 avril 2012 à 13:11:56

            Lol je voulais justement éviter de poster le code pour rester pédagogique (vu que c'est pour un cours à l'école) XD
            • Partager sur Facebook
            • Partager sur Twitter
              29 avril 2012 à 13:37:02

              Je le met en secret
              • Partager sur Facebook
              • Partager sur Twitter
              2b||!2b   sqrt(4b²)
                29 avril 2012 à 13:55:00

                Tout d'abord je tiens à vous remercier grandement pour l'aide que vous m'apportez.
                Je vous remercie pour votre code, cependant, j'ai un problème une fois le programme uploader, j’allume le micro contrôleur j'ai les deux led éteintes, puis je tourne le potentiomètre et les deux leds s'allument et que si je le tourne dans l'autre sens elles ne s'éteignent pas, alors que si une était allumée (par le programme ci dessous) elle devrait s’éteindre si le volet était arrivé en haut par exemple .

                Aussi pour répondre à Eskimon, c'est exactement cela: le capteur représente le volet qui monte ou qui descend.

                potentiomètre et led


                Comme je vous l'avait dit, enfaîte les leds changent d’état en fonction de l'ordre que récupère le programme :

                #include <SPI.h>       // Librairie SPI pour la communication hardware
                #include <Ethernet.h>  // Librairie Ethernet
                
                byte mac[] = {  // Adresse MAC (n'importe quelle adresse fait l'affaire)
                  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
                
                IPAddress server(213, 186, 33, 4);  // Adresse IP du serveur distant (ici notre serveur web local)
                
                EthernetClient client;  // Création d'un objet EthernetClient 
                
                const byte alimcapteur = 2;  // Mettre alimcapteur en entrée (LED jaune d'alimentation)
                
                const byte ledPin = 6;   // Mettre ledPin en entrée (LED verte de montée)
                const byte ledPin2 = 7;  // Mettre ledPin2 en entrée (LED rouge de descente)
                const byte ledPin3 = 5;  // Mettre ledPin3 en entrée (LED rouge d'erreur)
                
                // setup()
                void setup() {
                  pinMode(alimcapteur, OUTPUT);  // Met alimcapteur en sortie (LED jaune d'alimentation)
                  
                  pinMode(ledPin, OUTPUT);  // Met ledPin en sortie (LED verte de montée)
                  pinMode(ledPin2, OUTPUT); // Met ledPin2 en sortie (LED rouge de descente)
                  pinMode(ledPin3, OUTPUT); // Met ledPin3 en sortie (LED rouge d'erreur)
                
                  Serial.begin(9600);       // Initialisation du port série
                
                  if (!Ethernet.begin(mac)) {  // Obtention d'une adresse IP par DHCP
                    Serial.println("Erreur DHCP");
                    for(;;);                   // En cas d'erreur, on bloque le programme dans une boucle infinie
                  }
                  Serial.println("DHCP OK");
                  
                  digitalWrite(alimcapteur, HIGH);  // Alimenter le capteur (tension)
                }
                
                // loop()
                void loop()
                { 
                  
                  String str;  // Chaine de char contenant une ligne de la réponse HTTP
                  char c;
                
                  delay(10000);  // Délai entre deux requêtes
                
                  if (client.connect(server, 80)) {            // Connexion au serveur web
                    client.println("GET /flux.xml HTTP/1.0");  // Demande de flux.xml en HTTP 1.1
                    client.println("Host: housecontrol.e-wok.fr");  // Virtual Host 
                    client.println("Accept: */*");  // */
                    // A cause d'un bug de l'ide arduino tout /* d'ou avoir son */ même dans une chaine de char
                    client.println();
                    client.println();
                  } 
                  else {
                    Serial.println("Erreur TCP");  // Si erreur lors de la connexion
                    return;                        // Quitter loop()
                  }
                
                  for(;;) {  // Boucle infinie
                    if(client.available()) {  // Si des données sont disponibles sur l'objet EthernetClient
                      c = client.read();      // Lecture d'un octet
                      if(c == '\n') {         // Si fin de ligne atteinte
                        // (Pensez à mettre une ligne vide à la fin de flux.xml)
                        if(str.startsWith("<action>")) {  // Si la ligne commence par <action>
                          Serial.println(str);
                          str.replace("<action>", "");   // 
                          str.replace("</action>", "");  // Enlève les balises XML
                
                          if(str == "1")  // Si le flux contient "1", on ouvre le volet (Allumer ledPin LED verte de montée)
                          {
                            digitalWrite(ledPin3, LOW);  // Réinitialisation de ledPin3 (LED rouge d'erreur)
                            digitalWrite(ledPin2, LOW);  // Réinitialisation de ledPin2 (LED rouge de descente)
                            
                            digitalWrite(ledPin, HIGH);  // Allumer ledPin (LED verte de montée)
                            delay(1000);                 // Attendre une seconde
                          }
                          else if(str == "2")  // Si le flux contient "2", on ferme le volet (Allumer ledPin2 LED rouge de descente)
                          {
                            digitalWrite(ledPin3, LOW);  // Réinitialisation de ledPin3 (LED rouge d'erreur)
                            digitalWrite(ledPin, LOW);   // Réinitialisation de ledPin (LED verte de montée)
                            
                            digitalWrite(ledPin2, HIGH);  // Allumer ledPin2 (LED rouge de descente)
                            delay(1000);                  // Attendre une seconde
                          }
                          else  // Si le flux contient autre chose, c'est qu'il y a un problème, on fait clignoter ledPin3 (LED rouge d'erreur)
                          {
                            digitalWrite(ledPin, LOW);   // Réinitialisation de ledPin (LED verte de montée)
                            digitalWrite(ledPin2, LOW);  // Réinitialisation de ledPin2 (LED rouge de descente)
                            
                            digitalWrite(ledPin3, HIGH);  // Allumer ledPin3 (LED rouge d'erreur)
                            delay(1000);                  // Attendre une seconde
                            digitalWrite(ledPin3, LOW);   // Eteindre ledPin3 (LED rouge d'erreur)
                            delay(1000);  
                            digitalWrite(ledPin3, HIGH);  // Allumer ledPin3 (LED rouge d'erreur)
                            delay(1000);                  // Attendre une seconde
                            digitalWrite(ledPin3, LOW);   // Eteindre ledPin3 (LED rouge d'erreur)
                            delay(1000);  
                            digitalWrite(ledPin3, HIGH);  // Allumer ledPin3 (LED rouge d'erreur)
                            delay(1000);                  // Attendre une seconde
                            digitalWrite(ledPin3, LOW);   // Eteindre ledPin3 (LED rouge d'erreur)
                            delay(1000);                  // Attendre une seconde
                          }
                          break;  // Sortir de la boucle infinie
                        } 
                
                        str = "";  // Vidage de la ligne
                      } 
                      else
                        str += c;  // Concaténation de l'octet recu dans la chaine de char
                    }
                
                    if(!client.connected())  // Si la connexion a été perdue
                      break;                 // Sortir de la boucle infinie
                  }
                
                  client.stop();  // Fermeture de la connexion avec le serveur
                }
                


                • Partager sur Facebook
                • Partager sur Twitter
                  29 avril 2012 à 14:39:13

                  Tu a testé juste mon code ? (sa se trouve je me suis trompé qq part)
                  Et le code que tu donne, il est complet ? parce que je ne voie pas la partit de contrôle du potard ;)
                  • Partager sur Facebook
                  • Partager sur Twitter
                  2b||!2b   sqrt(4b²)
                    29 avril 2012 à 16:04:07

                    Merci beaucoup pour ton code,

                    En effet je l'ai testé et j'ai rencontré le problème suivant:
                    j’allume le micro contrôleur j'ai les deux led éteintes, puis je tourne le potentiomètre et les deux leds s'allument et que si je le tourne dans l'autre sens elles ne s'éteignent pas.
                    potentiomètre et led

                    Alors que si une était allumée (par le programme ci dessus) elle devrait s’éteindre si le volet était arrivé (capteur potentiométrique) en haut par exemple.

                    De plus je ne sais pas à quel endroit incorporer ton code dans le grand code ci dessus, aurait tu une idée?

                    Je te remercie par avance.
                    • Partager sur Facebook
                    • Partager sur Twitter
                      29 avril 2012 à 16:20:02

                      Tout d'abord, tu utilise quelle code, le premier ou le deuxième ?
                      Puis, je croit bien que tu a court-circuité tes résistances (un détail).
                      Et pour placer mon code, met le avant ou après celui pour récupérer le flux, aucune importance (j'ai pas trop regarder, ton code prend du temps ou pas ?)
                      • Partager sur Facebook
                      • Partager sur Twitter
                      2b||!2b   sqrt(4b²)
                        29 avril 2012 à 16:26:07

                        Merci de ta réponse,

                        J'ai testé ton deuxième code car pour le premier l'ide arduino m'indiquais des problèmes en bas en orange (erreus?).
                        Pour les résistances devrais je les mettre avant plutôt ?
                        Du temps à lire ? A mon avis toi qui t'y connait pas mal ça devrait pas être très long c'est surtout la longueur mais sinon je dirais qu'il n'est pas trop long.

                        Je te remercie de ton aide

                        PS: l'ide m'indiquais un problème à cette ligne pour le 1er code au niveau du 1000:
                        if( val => 1000)//pour avoir de la marge
                        
                        • Partager sur Facebook
                        • Partager sur Twitter
                          29 avril 2012 à 16:41:10

                          Je sais, je tester mes code et je l'ai vu, corrigé.
                          if( val >= 1000)//pour avoir de la marge
                          

                          Et pour le deuxième code, théoriquement il marche, mais en pratique ...
                          C'est a cause de la mauvaise qualité du potentiomètre, il "grésille" :
                          Imaginons que sa valeur est à 500, sans que l'on touche le potentiomètre, elle va bouger, l'arduino croit que le volet monte et descend très rapidement, donc les LEDs s'allument (mais pas en même temps tu connait la POV ?).

                          Niveau programme, tu peut rajouter une marge (je te laisse faire, je t'aiderais si tu y arrive pas ;) )

                          EDIT : j'y suis arriver en rajoutant 1 ligne :
                          un delay

                          et du code aux if
                          je te conseille aussi de faire une constante marge, pour modifier plus facilement :)
                          constante :
                          const int marge = 0;

                          EDIT2 : Merci à toi, tu m'a donné une super idée de jeu !
                          • Partager sur Facebook
                          • Partager sur Twitter
                          2b||!2b   sqrt(4b²)
                            29 avril 2012 à 16:57:06

                            Merci encore de ton aide,

                            Comme le le potentiomètre gresille il est préférable d'utiliser le 1 er code c'est cela ?
                            Qu'est ce que la POV, peut tu m'éclairer s'il te plait ?

                            Enfin si je l'incorpore croit tu que si je suis sur le site:
                            -je clique sur le bouton (icone) "montée" cela allume la led verte de monté et je tourne le potentiomètre qui simule la montée du volet et une fois en haut il éteint la led verte (de montée)

                            - pareillement pour la descente je clique sur le boutn (l'icone) descendre ça (éteint la led verte qui était déjà éteinte par le capteur potentiométrique) ça et allume led rouge celle de descente et en fois le potentiometre tourné (simulant la descente du volet) celui ci éteint la led rouge pour dire qu'il est en bas

                            ainsi de suite
                            ?

                            const byte alimcapteur = 2; // Broche 2 connectée à la LED jaune d'erreur
                            
                            const byte ledPin = 5;  // Broche 5 connectée à la LED verte de monter
                            const byte ledPin2 = 6; // Broche 6 connectée à la LED rouge de descente
                            const byte ledPin3 = 7; // Broche 7 connectée à la LED  rouge d'erreur
                            


                            PS: Je viens de retester le programme il marche très bien et je t'en remercie, cependant je ne saurais pas apporter deux modifications je voudrais quand quand la led verte est allumé par le programmable (flux rss)le potentiomètre l’éteigne quand le volet arrive en haut. Et que quand la led rouge est allumée par le flux rss (descente) elle soit éteinte par le potentiomètre quand le volet arrive en bas.

                            Je te remercie infiniment pour ton aide
                            • Partager sur Facebook
                            • Partager sur Twitter
                              29 avril 2012 à 17:05:58

                              Tu na vus mes EDITs ? Et normalement ton code marche
                              Pour le potentiomètre, comme dit en haut, tu peut modifier légèrement le code pour l'utiliser.
                              Et la POV( c'est un detail) c'est Persistence Of Vision, tu croit que les LEDs sont allumé en même temps, mais non !
                              • Partager sur Facebook
                              • Partager sur Twitter
                              2b||!2b   sqrt(4b²)
                                29 avril 2012 à 17:49:07

                                Oups mon commentaire n'est pas passé on dirait...
                                Je disait un peu plus tôt que pour limiter le phénomène de grésillement, on peut ajouter un condensateur comme expliqué dans le tuto sur le bouton...
                                Il agira un peu comme un "amortisseur" de la tension.
                                • Partager sur Facebook
                                • Partager sur Twitter
                                  29 avril 2012 à 17:53:57

                                  je trouve quand même plus simple (et moins couteux) que le fait de changer le programme
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                  2b||!2b   sqrt(4b²)
                                    29 avril 2012 à 18:26:43

                                    Les deux solutions se valent en fait... Le condensateur fait un filtre physique et le delay (attention fonction bloquante) est un filtre virtuel/logiciel. (Et pour le prix que coûte un condensateur...)
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      29 avril 2012 à 18:30:06

                                      + les frais de port si on commande que sa, :)
                                      Sinon attention pas qu'un delay !
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                      2b||!2b   sqrt(4b²)
                                        29 avril 2012 à 23:46:59

                                        Le programme marche parfaitement, cependant je ne saurais pas apporter les trois modifications suivantes:

                                        J'aimerais
                                        - Quand la led verte est allumé par le programmable (flux rss)que le potentiomètre l’éteigne quand le volet arrive en haut.
                                        - Et quand la led rouge est allumée par le flux rss (descente) elle soit éteinte par le potentiomètre quand le volet arrive en bas.

                                        Enfin, je n'arrive pas intégrer le code dans le mien je n'ai pas très bien compris le delay et la marge pourrait tu m'éclairer s'il te plait ?
                                        Je ne sais pas si pour le debut je laisse laisse les étoile ou si je les met tout en haut ou bien à l'endroit ou je souhaite insérer ton code ?

                                        Je te remercie d'avance
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          30 avril 2012 à 17:45:25

                                          Bon, je comprend que tu n’ai rien comprit ( :D ), j'explique 3 truc en même temps, sa a dut t'embrouiller ^^
                                          Donc, pour le deuxième code :
                                          Il faut rajouter une marge pour enlever le grésillement, voilà le code :
                                          /*
                                          * Potentiometre contrôlant l'extinction ou non d'une/des leds
                                          * Si 1023 alors la LED de montée s'eteind
                                          * Si 0 alord LED de descente s'éteind
                                          * Broche 0 connectée au potentiomètre
                                          * Broche 5 connectée à la LED de monter
                                          * Broche 6 connectée à la LED de descente
                                          */
                                          const int marge = 1;
                                          int potPin = 0;    // select the input pin for the potentiometer
                                          int ledPin2 = 5;   // select the pin for the LED de montée
                                          int ledPin3 = 6;   // select the pin for the LED de descente
                                          int val = 0;       // variable to store the value coming from the sensor
                                          int ancVal = 0;
                                          
                                          void setup() {
                                           // pinMode(ledPin, OUTPUT);  // declare the ledPin as an OUTPUT
                                            pinMode(ledPin2, OUTPUT); // Met la broche numérique en sortie 
                                            pinMode(ledPin3, OUTPUT); // Met la broche numérique en sortie 
                                            ancVal = analogRead(potPin);
                                          }
                                          
                                          void loop() {
                                            val = analogRead(potPin);    // read the value from the sensor
                                            if( val < ancVal-marge)//on monte
                                            {
                                              digitalWrite(ledPin2, HIGH);// turn the ledPin2 on
                                              digitalWrite(ledPin3, LOW);// turn the ledPin3 off
                                            } 
                                            else if( val > ancVal+marge)//on descend
                                            {
                                              digitalWrite(ledPin2, LOW);// turn the ledPin2 off
                                              digitalWrite(ledPin3, HIGH);// turn the ledPin3 on
                                            }
                                            else//sinon on éteint tout
                                            {
                                              digitalWrite(ledPin2, LOW);// turn the ledPin2 off
                                              digitalWrite(ledPin3, LOW);// turn the ledPin3 off
                                            }
                                            ancVal = val;
                                            delay(100);
                                           // digitalWrite(ledPin, LOW);   // turn the ledPin off
                                          }
                                          
                                          Essaye de le comprendre, compare-le avec le 1er 2éme code (sa y est tu suis plus ;) )

                                          Puis pour assembler ton code au mien :
                                          #include <SPI.h>      // Librairie SPI pour la communication hardware
                                          #include <Ethernet.h> // Librairie Ethernet
                                          
                                          byte mac[] = { // Adresse MAC (n'importe quelle adresse fait l'affaire)
                                            0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
                                          
                                          IPAddress server(213, 186, 33, 4); // Adresse IP du serveur distant (ici mon serveur web local)
                                          
                                          EthernetClient client; // Création d'un objet EthernetClient 
                                          
                                          const int marge = 1;
                                          
                                          int val = 0;       // variable to store the value coming from the sensor
                                          int ancVal = 0;
                                          long temps =0;
                                          
                                          const byte potPin = A0;    // select the input pin for the potentiometer
                                          const byte alimcapteur = 2; // Broche 2 connectée à la LED d'erreur
                                          const byte ledPin = 5;  // Broche 5 connectée à la LED de monter
                                          const byte ledPin2 = 6; // Broche 6 connectée à la LED de descente
                                          const byte ledPin3 = 7; // Broche 7 connectée à la LED d'erreur
                                          
                                          String str;   // Chaine de char contenant une ligne de la réponse HTTP
                                          char c;
                                          
                                          // setup()
                                          void setup() {
                                            pinMode(alimcapteur, OUTPUT);  // Met la broche numérique en sortie 
                                            
                                            pinMode(ledPin, OUTPUT);  // Met la broche numérique en sortie 
                                            pinMode(ledPin2, OUTPUT); // Met la broche numérique en sortie 
                                            pinMode(ledPin3, OUTPUT); // Met la broche numérique en sortie 
                                          
                                            Serial.begin(9600);       // Initialisation du port série
                                          
                                            if (!Ethernet.begin(mac)) { // Obtention d'une adresse IP par DHCP
                                              Serial.println("Erreur DHCP");
                                              for(;;);                  // En cas d'erreur on bloque le programme dans une boucle infini
                                            }
                                            Serial.println("DHCP OK");
                                            
                                            digitalWrite(alimcapteur, HIGH);   // fourni la tension au capteur
                                            
                                            ancVal = analogRead(potPin);
                                          }
                                          
                                          // loop()
                                          void loop()
                                          { 
                                            val = analogRead(potPin);    // read the value from the sensor
                                            if( val < ancVal-marge)//on monte
                                            {
                                              digitalWrite(ledPin, HIGH);// turn the ledPin2 on
                                              digitalWrite(ledPin2, LOW);// turn the ledPin3 off
                                            } 
                                            else if( val > ancVal+marge)//on descend
                                            {
                                              digitalWrite(ledPin, LOW);// turn the ledPin2 off
                                              digitalWrite(ledPin2, HIGH);// turn the ledPin3 on
                                            }
                                            else//sinon on éteint tout
                                            {
                                              digitalWrite(ledPin, LOW);// turn the ledPin2 off
                                              digitalWrite(ledPin2, LOW);// turn the ledPin3 off
                                            }
                                            ancVal = val;
                                            delay(100);
                                            
                                            if(millis()-temps >= 10000)
                                            {
                                              if (client.connect(server, 80)) {           // Connexion au serveur web
                                                client.println("GET /flux.xml HTTP/1.0"); // Demande de flux.xml en HTTP 1.1
                                                client.println("Host: housecontrol.e-wok.fr");     // Virtual Host 
                                                client.println("Accept: */*"); // */
                                                // A cause d'un bug de l'ide arduino tout /* d'ou avoir son */ même dans une chaine de char
                                                client.println();
                                                client.println();
                                              } 
                                              else {
                                                Serial.println("Erreur TCP"); // Si erreur lors de la connexion
                                                return;                       // Quitte loop()
                                              }
                                            
                                              for(;;) { // Boucle infini
                                                if(client.available()) { // Si des données son disponible sur l'objet EthernetClient
                                                  c = client.read();     // Lecture d'un octet
                                                  if(c == '\n') {        // Si fin de ligne atteinte
                                                    // (Pensez à mettre une ligne vide à la fin de flux.xml)
                                                    if(str.startsWith("<action>")) { // Si la ligne commence par <action>
                                                      Serial.println(str);
                                                      str.replace("<action>", "");   // 
                                                      str.replace("</action>", "");  // Enléve les balises XML
                                            
                                                      if(str == "1") // Si le flux contient "1" on ouvre le volet. (allumage de la LED du pin 5)
                                                      {
                                                        digitalWrite(ledPin3, LOW);    // Reinitialisation
                                                        digitalWrite(ledPin2, LOW);    // Reinitialisation
                                                        
                                                        digitalWrite(ledPin, HIGH);   // Allume la LED
                                                        delay(1000);                  // Attend une seconde
                                                      }
                                                      else if(str == "2") // Si le flux contient "2" on ferme le volet. (allumage de la LED du pin 6)
                                                      {
                                                        digitalWrite(ledPin3, LOW);    // Reinitialisation
                                                        digitalWrite(ledPin, LOW);    // Reinitialisation
                                                        
                                                        digitalWrite(ledPin2, HIGH);   // Allume la LED
                                                        delay(1000);                   // Attend une seconde
                                                      }
                                                      else           // Si le flux contient autre chose il ya un un probleme, on fait clignoter la LED de probleme. (LED du pin 7)
                                                      {
                                                        digitalWrite(ledPin, LOW);     // Reinitialisation
                                                        digitalWrite(ledPin2, LOW);    // Reinitialisation
                                                        
                                                        digitalWrite(ledPin3, HIGH);   // Allume la LED
                                                        delay(1000);                   // Attend une seconde
                                                        digitalWrite(ledPin3, LOW);    // Eteint la LED
                                                        delay(1000);  
                                                        digitalWrite(ledPin3, HIGH);   // Allume la LED
                                                        delay(1000);                   // Attend une seconde
                                                        digitalWrite(ledPin3, LOW);    // Eteint la LED
                                                        delay(1000);  
                                                        digitalWrite(ledPin3, HIGH);   // Allume la LED
                                                        delay(1000);                   // Attend une seconde
                                                        digitalWrite(ledPin3, LOW);    // Eteint la LED
                                                        delay(1000);              // Attend une seconde
                                                      }
                                                      break;  // Sort de la boucle infini
                                                    } 
                                            
                                                    str = ""; // Vidage de la ligne
                                                  } 
                                                  else
                                                    str += c; // Concaténation de l'octet recu dans la chaine de char
                                                }
                                            
                                                if(!client.connected()) // Si la connexion a été perdu
                                                  break;                // Sorti de la boucle infini
                                              }
                                            
                                              client.stop(); // Fermeture de la connexion avec le serveur
                                              
                                              temps = millis();
                                            }
                                          }
                                          
                                          Bien sûr, essaye de comprendre ce code.

                                          Après, c'est moi qui te comprend pas :

                                          Citation : belions

                                          - Quand la led verte est allumé par le programmable (flux rss)que le potentiomètre l’éteigne quand le volet arrive en haut.
                                          - Et quand la led rouge est allumée par le flux rss (descente) elle soit éteinte par le potentiomètre quand le volet arrive en bas.


                                          Je peut avoir un dessin ? :p

                                          Citation : belions

                                          Je ne sais pas si pour le debut je laisse laisse les étoile ou si je les met tout en haut ou bien à l'endroit ou je souhaite insérer ton code ?

                                          Dans "étoile", tu entend ça : /* */ ?


                                          [HS]Pour mon idée de jeu, tu augmente la marge, et le but est de tourner lentement le potentiomètre pour ne pas allumer les LEDs[/HS]
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                          2b||!2b   sqrt(4b²)
                                            30 avril 2012 à 20:52:25

                                            Bonjour Diode, tout d’abord merci pour ton aide d'hier puis celle d'aujourd'hui.
                                            Je m'excuse je n'ai peut être pas été très clair je vais essayer de rendre les chose plus claires, je ne sais pas si un dessins serait mieux ;)

                                            Donc le long programme que je t'ai montré sert à "contrôler un volet à distance" cependant ce volet n'existe pas, il est dans notre cas représenté par deux diodes (une rouge pour la descente et un verte pour la monté) qui symbolisent respectivement l'action de monté ou de descente du moteur.

                                            De plus, le potentiomètre serait dans notre cas un capteur permettant de nous indiquer la position du volet (en fonction de la résistance si elle est nulle ou non), si elle nulle cela nous indiquerait que le volet est en haut et dans le cas contraire si elle est max cela nous indiquerait qu'il est en bas.

                                            Dans le long programme tu as pu voir que l'allumage (et extinction de l'autre led par conséquent) d'une ou l'autre led était contrôlé via un flux XML depuis un site web ou l'on choisit de monter ou de descendre le volet.

                                            Interface de contrôle


                                            Donc imaginons que l'on clique sur la flèche verte de montée, la led verte va se mettre à s'allumer et va rester allumé (même si le volet est arrivé en haut) jusqu’à ce que l'on clique sur la flèche (rouge) de descente qui dans ce cas va éteindre la led verte puis allumer la led rouge, ainsi de suite.

                                            C'est ainsi que j'aimerai installer un capteur potentiométrique (potentiomètre) qui lui à échelle réduite va simuler la montée ou la descente du volet. Ainsi lorsque l'on clique sur la flèche de montée verte (par exemple)la led verte s'allume jusqu'à ce que le capteur soit arrivé en haut l'éteigne pour montrer que le volet est arrivé en haut, de même pour la descente.

                                            Enfin, pour les étoiles c'est bien de cela que je parlais :)
                                            Et j'ai bien regardé pour ton programme mais je n'ai pas très bien compris par rapport à ton second programme, je ne trouve pas la valeur comme 23 ou 1000 pour le potentiomètre. Je l'ai testé mais il me fait clignoté les led mais je ne trouve pas de lien entre les tours du potentiomètre.

                                            Je te remercie par avance :)
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              30 avril 2012 à 21:57:22

                                              J'ai comprit !
                                              D'abord, le premier et le second programme n’ont rien a voir, donc ne t’inquiète pas pour sa (essaye les 2 tu verrat la différence).
                                              Pour le étoiles se son des commentaire, sa équivalut à sa : //blabla, donc tu le met ou tu veut.
                                              La résistance du potentiomètre est convertit en nombre de 0 à 1023, j'ai donc pris c'est nombre pour avoir les extrêmes.
                                              Et je vais essayer de faire ce que j'ai comprit, j’éditerai en bas

                                              Par contre pour être sûr que tu ne mélange pas les codes, voici les 2 versions :
                                              1er :
                                              /*
                                              * Potentiometre contrôlant l'extinction ou non d'une/des leds
                                              * Si 1023 alors la LED de montée s'eteind
                                              * Si 0 alord LED de descente s'éteind
                                              * Broche 0 connectée au potentiomètre
                                              * Broche 5 connectée à la LED de monter
                                              * Broche 6 connectée à la LED de descente
                                              */
                                              
                                              int potPin = 0;    // select the input pin for the potentiometer
                                              int ledPin2 = 5;   // select the pin for the LED de montée
                                              int ledPin3 = 6;   // select the pin for the LED de descente
                                              int val = 0;       // variable to store the value coming from the sensor
                                              
                                              void setup() {
                                               // pinMode(ledPin, OUTPUT);  // declare the ledPin as an OUTPUT
                                                pinMode(ledPin2, OUTPUT); // Met la broche numérique en sortie 
                                                pinMode(ledPin3, OUTPUT); // Met la broche numérique en sortie 
                                              }
                                              
                                              void loop() {
                                                val = analogRead(potPin);    // read the value from the sensor
                                                if( val >= 1000)//pour avoir de la marge
                                                {
                                                  digitalWrite(ledPin2, LOW);// turn the ledPin2 off
                                                  digitalWrite(ledPin3, HIGH);// turn the ledPin3 on
                                                } 
                                                else if( val <= 23)//pour avoir de la marge
                                                {
                                                  digitalWrite(ledPin2, HIGH);// turn the ledPin2 on
                                                  digitalWrite(ledPin3, LOW);// turn the ledPin3 off
                                                }
                                                else//sinon on éteint tout
                                                {
                                                  digitalWrite(ledPin2, LOW);// turn the ledPin2 off
                                                  digitalWrite(ledPin3, LOW);// turn the ledPin3 off
                                                }
                                               // digitalWrite(ledPin, LOW);   // turn the ledPin off
                                              }
                                              

                                              2éme :
                                              /*
                                              * Potentiometre contrôlant l'extinction ou non d'une/des leds
                                              * Si 1023 alors la LED de montée s'eteind
                                              * Si 0 alord LED de descente s'éteind
                                              * Broche 0 connectée au potentiomètre
                                              * Broche 5 connectée à la LED de monter
                                              * Broche 6 connectée à la LED de descente
                                              */
                                              const int marge = 1;
                                              int potPin = 0;    // select the input pin for the potentiometer
                                              int ledPin2 = 5;   // select the pin for the LED de montée
                                              int ledPin3 = 6;   // select the pin for the LED de descente
                                              int val = 0;       // variable to store the value coming from the sensor
                                              int ancVal = 0;
                                              
                                              void setup() {
                                               // pinMode(ledPin, OUTPUT);  // declare the ledPin as an OUTPUT
                                                pinMode(ledPin2, OUTPUT); // Met la broche numérique en sortie 
                                                pinMode(ledPin3, OUTPUT); // Met la broche numérique en sortie 
                                                ancVal = analogRead(potPin);
                                              }
                                              
                                              void loop() {
                                                val = analogRead(potPin);    // read the value from the sensor
                                                if( val < ancVal-marge)//on monte
                                                {
                                                  digitalWrite(ledPin2, HIGH);// turn the ledPin2 on
                                                  digitalWrite(ledPin3, LOW);// turn the ledPin3 off
                                                } 
                                                else if( val > ancVal+marge)//on descend
                                                {
                                                  digitalWrite(ledPin2, LOW);// turn the ledPin2 off
                                                  digitalWrite(ledPin3, HIGH);// turn the ledPin3 on
                                                }
                                                else//sinon on éteint tout
                                                {
                                                  digitalWrite(ledPin2, LOW);// turn the ledPin2 off
                                                  digitalWrite(ledPin3, LOW);// turn the ledPin3 off
                                                }
                                                ancVal = val;
                                                delay(100);
                                               // digitalWrite(ledPin, LOW);   // turn the ledPin off
                                              }
                                              


                                              Voilà :
                                              #include <SPI.h>      // Librairie SPI pour la communication hardware
                                              #include <Ethernet.h> // Librairie Ethernet
                                              
                                              byte mac[] = { // Adresse MAC (n'importe quelle adresse fait l'affaire)
                                                0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
                                              
                                              IPAddress server(213, 186, 33, 4); // Adresse IP du serveur distant (ici mon serveur web local)
                                              
                                              EthernetClient client; // Création d'un objet EthernetClient 
                                              
                                              long temps =0;
                                              
                                              boolean monter = false;
                                              boolean descendre = false;
                                              
                                              const byte potPin = A0;    // select the input pin for the potentiometer
                                              const byte alimcapteur = 2; // Broche 2 connectée à la LED d'erreur
                                              const byte ledPin = 5;  // Broche 5 connectée à la LED de monter
                                              const byte ledPin2 = 6; // Broche 6 connectée à la LED de descente
                                              const byte ledPin3 = 7; // Broche 7 connectée à la LED d'erreur
                                              
                                              String str;   // Chaine de char contenant une ligne de la réponse HTTP
                                              char c;
                                              
                                              // setup()
                                              void setup() {
                                                pinMode(alimcapteur, OUTPUT);  // Met la broche numérique en sortie 
                                                
                                                pinMode(ledPin, OUTPUT);  // Met la broche numérique en sortie 
                                                pinMode(ledPin2, OUTPUT); // Met la broche numérique en sortie 
                                                pinMode(ledPin3, OUTPUT); // Met la broche numérique en sortie 
                                              
                                                Serial.begin(9600);       // Initialisation du port série
                                              
                                                if (!Ethernet.begin(mac)) { // Obtention d'une adresse IP par DHCP
                                                  Serial.println("Erreur DHCP");
                                                  for(;;);                  // En cas d'erreur on bloque le programme dans une boucle infini
                                                }
                                                Serial.println("DHCP OK");
                                                
                                                digitalWrite(alimcapteur, HIGH);   // fourni la tension au capteur
                                                
                                              }
                                              
                                              // loop()
                                              void loop()
                                              { 
                                                if(monter)//si on doit monter
                                                {
                                                  if(analogRead(potPin) < 23)//si on est en haut
                                                  {
                                                    digitalWrite(ledPin, LOW);    // Reinitialisation
                                                    monter = false;
                                                  }
                                                }
                                                if(descendre)//si on doit descendre
                                                {
                                                  if(analogRead(potPin) > 1000)//si on est en bas
                                                  {
                                                    digitalWrite(ledPin2, LOW);    // Reinitialisation
                                                    descendre = false;
                                                  }
                                                }
                                                if(millis()-temps >= 10000)
                                                {
                                                  if (client.connect(server, 80)) {           // Connexion au serveur web
                                                    client.println("GET /flux.xml HTTP/1.0"); // Demande de flux.xml en HTTP 1.1
                                                    client.println("Host: housecontrol.e-wok.fr");     // Virtual Host 
                                                    client.println("Accept: */*"); // */
                                                    // A cause d'un bug de l'ide arduino tout /* d'ou avoir son */ même dans une chaine de char
                                                    client.println();
                                                    client.println();
                                                  } 
                                                  else {
                                                    Serial.println("Erreur TCP"); // Si erreur lors de la connexion
                                                    return;                       // Quitte loop()
                                                  }
                                                
                                                  for(;;) { // Boucle infini
                                                    if(client.available()) { // Si des données son disponible sur l'objet EthernetClient
                                                      c = client.read();     // Lecture d'un octet
                                                      if(c == '\n') {        // Si fin de ligne atteinte
                                                        // (Pensez à mettre une ligne vide à la fin de flux.xml)
                                                        if(str.startsWith("<action>")) { // Si la ligne commence par <action>
                                                          Serial.println(str);
                                                          str.replace("<action>", "");   // 
                                                          str.replace("</action>", "");  // Enléve les balises XML
                                                
                                                          if(str == "1") // Si le flux contient "1" on ouvre le volet. (allumage de la LED du pin 5)
                                                          {
                                                            digitalWrite(ledPin3, LOW);    // Reinitialisation
                                                            digitalWrite(ledPin2, LOW);    // Reinitialisation
                                                            digitalWrite(ledPin, LOW);    // Reinitialisation
                                                            descendre = false;             // Reinitialisation
                                                            
                                                            monter = true;
                                                            if(analogRead(potPin) < 23)//si il est déjà en haut
                                                              monter = false;
                                                            else
                                                              digitalWrite(ledPin, HIGH);   // Allume la LED
                                                            //delay(1000);                  // Attend une seconde
                                                          }
                                                          else if(str == "2") // Si le flux contient "2" on ferme le volet. (allumage de la LED du pin 6)
                                                          {
                                                            digitalWrite(ledPin3, LOW);    // Reinitialisation
                                                            digitalWrite(ledPin2, LOW);    // Reinitialisation
                                                            digitalWrite(ledPin, LOW);    // Reinitialisation
                                                            monter = false;             // Reinitialisation
                                                            
                                                            descendre = true;
                                                            if(analogRead(potPin) > 1000)//si il est déjà en bas
                                                              descendre = false;
                                                            else
                                                              digitalWrite(ledPin2, HIGH);   // Allume la LED
                                                            //delay(1000);                   // Attend une seconde
                                                          }
                                                          else           // Si le flux contient autre chose il ya un un probleme, on fait clignoter la LED de probleme. (LED du pin 7)
                                                          {
                                                            digitalWrite(ledPin, LOW);     // Reinitialisation
                                                            digitalWrite(ledPin2, LOW);    // Reinitialisation
                                                            
                                                            digitalWrite(ledPin3, HIGH);   // Allume la LED
                                                            delay(1000);                   // Attend une seconde
                                                            digitalWrite(ledPin3, LOW);    // Eteint la LED
                                                            delay(1000);  
                                                            digitalWrite(ledPin3, HIGH);   // Allume la LED
                                                            delay(1000);                   // Attend une seconde
                                                            digitalWrite(ledPin3, LOW);    // Eteint la LED
                                                            delay(1000);  
                                                            digitalWrite(ledPin3, HIGH);   // Allume la LED
                                                            delay(1000);                   // Attend une seconde
                                                            digitalWrite(ledPin3, LOW);    // Eteint la LED
                                                            delay(1000);              // Attend une seconde
                                                          }
                                                          break;  // Sort de la boucle infini
                                                        } 
                                                
                                                        str = ""; // Vidage de la ligne
                                                      } 
                                                      else
                                                        str += c; // Concaténation de l'octet recu dans la chaine de char
                                                    }
                                                
                                                    if(!client.connected()) // Si la connexion a été perdu
                                                      break;                // Sorti de la boucle infini
                                                  }
                                                
                                                  client.stop(); // Fermeture de la connexion avec le serveur
                                                  
                                                  temps = millis();
                                                }
                                              }
                                              


                                              Normalement aucuns bug ;)
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                              2b||!2b   sqrt(4b²)
                                                30 avril 2012 à 23:35:20

                                                Merci beaucoup

                                                Cependant, jai rencontrer quelques problèmes (je remet en situation):

                                                - lorsqu'on a 1 en XML cela doit ouvrir le volet donc on allume ledPin (donc led verte allumée)(jusqu’à ce que le potentiomètre arrive en haut)
                                                - lorsqu'on a 2 en XML cela doit fermer le volet donc on allume ledPin2 (donc led rouge allumée)(jusqu’à ce que le potentiomètre arrive en bas)

                                                je viens de tester et rencontrer les problemes suivants:

                                                Lorsque je met "2" en XML la led de descente s'allume (donc ledPin)2 à importe quel moment et le potentiomètre n'a pas d'incidence sur son extinction ou son allumage.

                                                Lorsque je met "1" en XML la led de montée la verte ne s'allume pas et le potentiomètre n'a pas non plus d'incidence pour l'allumer ou non.

                                                J'ai mis au claire les commentaires du programmes peut être que cela peut t'aider:


                                                #include <SPI.h>      // Librairie SPI pour la communication hardware
                                                #include <Ethernet.h>  // Librairie Ethernet
                                                
                                                byte mac[] = {  // Adresse MAC (n'importe quelle adresse fait l'affaire)
                                                  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
                                                
                                                IPAddress server(213, 186, 33, 4);  // Adresse IP du serveur distant (ici notre serveur web local)
                                                
                                                EthernetClient client;  // Création d'un objet EthernetClient 
                                                
                                                long temps =0;
                                                
                                                boolean monter = false;
                                                boolean descendre = false;
                                                
                                                const byte potPin = A0;      // Mettre potPin en entrée (potentiomètre)
                                                const byte alimcapteur = 2;  // Mettre alimcapteur en entrée (LED jaune d'alimentation)
                                                const byte ledPin = 6;       // Mettre ledPin en entrée (LED verte de montée)
                                                const byte ledPin2 = 7;      // Mettre ledPin2 en entrée (LED rouge de descente)
                                                const byte ledPin3 = 5;      // Mettre ledPin3 en entrée (LED rouge d'erreur)
                                                
                                                String str;  // Chaine de char contenant une ligne de la réponse HTTP
                                                char c;
                                                
                                                // setup()
                                                void setup() {
                                                  pinMode(alimcapteur, OUTPUT);  // Mettre alimcapteur en sortie (LED jaune d'alimentation)
                                                  
                                                  pinMode(ledPin, OUTPUT);   // Mettre ledPin en sortie (LED verte de montée)
                                                  pinMode(ledPin2, OUTPUT);  // Mettre ledPin2 en sortie (LED rouge de descente)
                                                  pinMode(ledPin3, OUTPUT);  // Mettre ledPin3 en sortie (LED rouge d'erreur)
                                                
                                                  Serial.begin(9600);        // Initialisation du port série
                                                
                                                  if (!Ethernet.begin(mac)) {  // Obtention d'une adresse IP par DHCP
                                                    Serial.println("Erreur DHCP");
                                                    for(;;);                   // En cas d'erreur, on bloque le programme dans une boucle infinie
                                                  }
                                                  Serial.println("DHCP OK");
                                                  
                                                  digitalWrite(alimcapteur, HIGH);  // Alimenter le capteur (en tension)(LED jaune d'alimentation)
                                                  
                                                }
                                                
                                                // loop()
                                                void loop()
                                                { 
                                                  if(monter)  // Si on doit monter
                                                  {
                                                    if(analogRead(potPin) < 23)  // Si on est en haut
                                                    {
                                                      digitalWrite(ledPin, LOW);  // Réinitialisation de ledPin (LED verte de montée)
                                                      monter = false;
                                                    }
                                                  }
                                                  if(descendre)  // Si on doit descendre
                                                  {
                                                    if(analogRead(potPin) > 1000)  // Si on est en bas
                                                    {
                                                      digitalWrite(ledPin2, LOW);  // Réinitialisation ledPin2 (LED rouge de descente)
                                                      descendre = false;
                                                    }
                                                  }
                                                  if(millis()-temps >= 10000)
                                                  {
                                                    if (client.connect(server, 80)) {  // Connexion au serveur web
                                                      client.println("GET /flux.xml HTTP/1.0");  // Demande de flux.xml en HTTP 1.1
                                                      client.println("Host: housecontrol.e-wok.fr");  // Virtual Host 
                                                      client.println("Accept: */*");  // */
                                                      // A cause d'un bug de l'ide arduino tout /* d'ou avoir son */ même dans une chaine de char
                                                      client.println();
                                                      client.println();
                                                    } 
                                                    else {
                                                      Serial.println("Erreur TCP");  // Si erreur lors de la connexion
                                                      return;                        // Quitter loop()
                                                    }
                                                  
                                                    for(;;) {  // Boucle infinie
                                                      if(client.available()) {  // Si des données sont disponibles sur l'objet EthernetClient
                                                        c = client.read();      // Lecture d'un octet
                                                        if(c == '\n') {         // Si fin de ligne atteinte
                                                          // (Pensez à mettre une ligne vide à la fin de flux.xml)
                                                          if(str.startsWith("<action>")) {  // Si la ligne commence par <action>
                                                            Serial.println(str);
                                                            str.replace("<action>", "");   // 
                                                            str.replace("</action>", "");  // Enlève les balises XML
                                                  
                                                            if(str == "1")  // Si le flux contient "1", on ouvre le volet (Allumer ledPin LED verte de montée)
                                                            {
                                                              digitalWrite(ledPin3, LOW);  // Réinitialisation ledPin3 (LED rouge d'erreur)
                                                              digitalWrite(ledPin2, LOW);  // Réinitialisation ledPin2 (LED rouge de descente)
                                                              digitalWrite(ledPin, LOW);   // Réinitialisation ledPin (LED verte de montée)
                                                              descendre = false;           // Réinitialisation
                                                              
                                                              monter = true;
                                                              if(analogRead(potPin) < 23)  // Si il est déjà en haut
                                                                monter = false;
                                                              else
                                                                digitalWrite(ledPin, HIGH);  // Allumer ledPin (LED verte de montée)
                                                              //delay(1000);                 // Attend une seconde
                                                            }
                                                            else if(str == "2")  // Si le flux contient "2", on ferme le volet. (Allumer ledPin2 LED rouge de descente)
                                                            {
                                                              digitalWrite(ledPin3, LOW);  // Réinitialisation ledPin3 (LED rouge d'erreur)
                                                              digitalWrite(ledPin2, LOW);  // Réinitialisation ledPin2 (LED rouge de descente)
                                                              digitalWrite(ledPin, LOW);   // Réinitialisation ledpin (LED verte de montée)
                                                              monter = false;              // Réinitialisation
                                                              
                                                              descendre = true;
                                                              if(analogRead(potPin) > 1000)  // Si il est déjà en bas
                                                                descendre = false;
                                                              else
                                                                digitalWrite(ledPin2, HIGH);   // Allumer ledPin2 (LED rouge de descente)
                                                              //delay(1000);                   // Attendre une seconde
                                                            }
                                                            else  // Si le flux contient autre chose, il y a un probleme, on fait clignoter la LED d'erreur ledPin3 (LED rouge d'erreur)
                                                            {
                                                              digitalWrite(ledPin, LOW);     // Réinitialisation ledPin (LED verte de montée)
                                                              digitalWrite(ledPin2, LOW);    // Réinitialisation ledPin2 (LED rouge de descente)
                                                              
                                                              digitalWrite(ledPin3, HIGH);   // Allumer ledPin3 (LED rouge d'erreur)
                                                              delay(1000);                   // Attendre une seconde
                                                              digitalWrite(ledPin3, LOW);    // Eteindre ledPin3 (LED rouge d'erreur)
                                                              delay(1000);  
                                                              digitalWrite(ledPin3, HIGH);   // Allumer ledPin3 (LED rouge d'erreur)
                                                              delay(1000);                   // Attendre une seconde
                                                              digitalWrite(ledPin3, LOW);    // Eteindre ledPin3 (LED rouge d'erreur)
                                                              delay(1000);  
                                                              digitalWrite(ledPin3, HIGH);   // Allumer ledPin3 (LED rouge d'erreur)
                                                              delay(1000);                   // Attendre une seconde
                                                              digitalWrite(ledPin3, LOW);    // Eteindre ledPin3 (LED rouge d'erreur)
                                                              delay(1000);              // Attendre une seconde
                                                            }
                                                            break;  // Sortir de la boucle infinie
                                                          } 
                                                  
                                                          str = ""; // Vidage de la ligne
                                                        } 
                                                        else
                                                          str += c; // Concaténation de l'octet recu dans la chaine de char
                                                      }
                                                  
                                                      if(!client.connected()) // Si la connexion a été perdue
                                                        break;                // Sortir de la boucle infinie
                                                    }
                                                  
                                                    client.stop(); // Fermeture de la connexion avec le serveur
                                                    
                                                    temps = millis();
                                                  }
                                                }
                                                



                                                En tous cas merci beaucoup de ton aide

                                                EDIT: Aussi, quand on marque "//delay" est ce que les "//" sont pour le commentaire ?
                                                EDIT 2: Autre question :) , je me demandais aussi si le saut de ligne était indispensable dans ce cas ? :

                                                pinMode(alimcapteur, OUTPUT);  // Mettre alimcapteur en sortie (LED jaune d'alimentation)
                                                  
                                                  pinMode(ledPin, OUTPUT);   // Mettre ledPin en sortie (LED verte de montée)
                                                  pinMode(ledPin2, OUTPUT);  // Mettre ledPin2 en sortie (LED rouge de descente)
                                                  pinMode(ledPin3, OUTPUT);  // Mettre ledPin3 en sortie (LED rouge d'erreur)
                                                
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  1 mai 2012 à 0:26:23

                                                  Je vais voir ça, et oui j'ai mit delay en commentaire (je ne vois pas son utilité), et le C/C++/Java et autre c'est très flexible, alors tant qu'il y a des pts virgules, tu peux tout coller, tout espacer, sa changeras rien :)

                                                  EDIT : je ne vois pas du tout, je vais voir ça demain (enfin aujourd'hui dans 7H) je testerais sur mon arduino ;)

                                                  EDIT2 : j'ai enlever le système de flux, et j'ai mit la communication port série à la place, et bien sa marche ! (vérifie coté hardware, on ne sais jamais ;) )

                                                  Voilà mon code (test-le)
                                                  long temps =0;
                                                  
                                                  boolean monter = false;
                                                  boolean descendre = false;
                                                  
                                                  const byte potPin = A0;      // Mettre potPin en entrée (potentiomètre)
                                                  const byte ledPin = 6;       // Mettre ledPin en entrée (LED verte de montée)
                                                  const byte ledPin2 = 7;      // Mettre ledPin2 en entrée (LED rouge de descente)
                                                  
                                                  char c;
                                                  
                                                  // setup()
                                                  void setup() {
                                                    pinMode(ledPin, OUTPUT);   // Mettre ledPin en sortie (LED verte de montée)
                                                    pinMode(ledPin2, OUTPUT);  // Mettre ledPin2 en sortie (LED rouge de descente)
                                                  
                                                    Serial.begin(9600);        // Initialisation du port série
                                                  }
                                                  
                                                  // loop()
                                                  void loop()
                                                  { 
                                                    if(monter)  // Si on doit monter
                                                    {
                                                      if(analogRead(potPin) < 23)  // Si on est en haut
                                                      {
                                                        digitalWrite(ledPin, LOW);  // Réinitialisation de ledPin (LED verte de montée)
                                                        monter = false;
                                                      }
                                                    }
                                                    if(descendre)  // Si on doit descendre
                                                    {
                                                      if(analogRead(potPin) > 1000)  // Si on est en bas
                                                      {
                                                        digitalWrite(ledPin2, LOW);  // Réinitialisation ledPin2 (LED rouge de descente)
                                                        descendre = false;
                                                      }
                                                    }
                                                    if(Serial.available() > 0)
                                                    {
                                                      c = Serial.read();
                                                      
                                                      if(c == '1')  // Si le flux contient "1", on ouvre le volet (Allumer ledPin LED verte de montée)
                                                      {
                                                        digitalWrite(ledPin2, LOW);  // Réinitialisation ledPin2 (LED rouge de descente)
                                                        digitalWrite(ledPin, LOW);   // Réinitialisation ledPin (LED verte de montée)
                                                        descendre = false;           // Réinitialisation
                                                        
                                                        monter = true;
                                                        if(analogRead(potPin) < 23)  // Si il est déjà en haut
                                                          monter = false;
                                                        else
                                                          digitalWrite(ledPin, HIGH);  // Allumer ledPin (LED verte de montée)
                                                        //delay(1000);                 // Attend une seconde
                                                      }
                                                      else if(c == '2')  // Si le flux contient "2", on ferme le volet. (Allumer ledPin2 LED rouge de descente)
                                                      {
                                                        digitalWrite(ledPin2, LOW);  // Réinitialisation ledPin2 (LED rouge de descente)
                                                        digitalWrite(ledPin, LOW);   // Réinitialisation ledpin (LED verte de montée)
                                                        monter = false;              // Réinitialisation
                                                        
                                                        descendre = true;
                                                        if(analogRead(potPin) > 1000)  // Si il est déjà en bas
                                                          descendre = false;
                                                        else
                                                          digitalWrite(ledPin2, HIGH);   // Allumer ledPin2 (LED rouge de descente)
                                                        //delay(1000);                   // Attendre une seconde
                                                      }
                                                    }
                                                  }
                                                  
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                  2b||!2b   sqrt(4b²)
                                                    1 mai 2012 à 12:42:12

                                                    Bonjour diode,

                                                    Je viens de voir ton post, merci
                                                    Cependant, j'utilise avec le arduino uno avec l'ethernet shield qui connecté via ethernet récupérait le flux rss via un site distant ou selon ce que contenait le flux "1" ouvrir le volet; ou "2" fermer le volet, la diode de montée s'allumait ou inversement.

                                                    Je viens de voir que tu as mis le port série et je me demandais comment faire le contact en le flux rss du site le l'arduino + ethernet shield si j'utilise le port série.

                                                    Enfin je ne parvient pas à changer d'état avec le terminal sait tu quel commende dois je entrée?

                                                    Je te remercie par avance
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      1 mai 2012 à 12:57:56

                                                      Le port série, je l'ai mit pour moi, pour tester.
                                                      Et la commande à entrée est 1 ou 2 (monter/descendre)
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                      2b||!2b   sqrt(4b²)
                                                        1 mai 2012 à 13:21:16

                                                        Voila j'ai retesté le programme mais je rencontre le même problème:

                                                        j'ai toujours que la led rouge qui s'allume quand je fait "2"
                                                        mais rien quand je fait "1"

                                                        Image utilisateur


                                                        et je ne constate pas de différence si le potentiomètre est tourné dans un sens ou dans l'autre
                                                        pourtant je vois bien que dans le programme cela y figure.

                                                        EDIT: Je ne sais pas si pour toi cela fonctionnait bien ?
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                          1 mai 2012 à 14:07:34

                                                          Moi, ça marchais, vérifie que ta LED soit bien branché/pas grillée
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                          2b||!2b   sqrt(4b²)
                                                            1 mai 2012 à 18:45:37

                                                            Je m'excuse, j'ai fais une grossière erreur, après avoir retesté plusieurs fois je me suis aperçu d'un mauvais branchement qui ne m'avait pas sauté aux yeux !!

                                                            Ton programme marche à merveille et je suis vraiment désolé de t'avoir tant dérangé :)
                                                            J'ai testé avec le flux et sa marche tout aussi merveilleusement !

                                                            Je te remercie beaucoup, pour tout ce que tu a fait, tu m'a énormément aidé !!
                                                            Je te tiendrais au courant de ce projet.

                                                            Merci encore infiniment
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                              1 mai 2012 à 18:46:41

                                                              Okok, de rien :)
                                                              Si tu veux d'autre fonctionnalités, demande moi ^^
                                                              • Partager sur Facebook
                                                              • Partager sur Twitter
                                                              2b||!2b   sqrt(4b²)

                                                              Aide programme Arduino

                                                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                              × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                              • Editeur
                                                              • Markdown