Senseur IR Decodeur IR - Historique des versions

Admin le 4 avril 2019 à 17:17

2019-04-04T17:17:44Z

Admin le 4 avril 2019 à 17:08

2019-04-04T17:08:16Z

Admin le 4 avril 2019 à 16:54

2019-04-04T16:54:36Z

Admin le 4 avril 2019 à 16:38

2019-04-04T16:38:24Z

Admin le 4 avril 2019 à 16:32

2019-04-04T16:32:00Z

Admin le 25 août 2013 à 19:12

2013-08-25T19:12:30Z

Admin le 25 août 2013 à 19:11

2013-08-25T19:11:12Z

Admin le 30 juillet 2012 à 11:28

2012-07-30T11:28:39Z

Admin le 30 juillet 2012 à 11:22

2012-07-30T11:22:19Z

Admin : /* xxx */

2012-07-30T11:21:07Z

xxx

Voir les modifications

@@ Ligne 188 : / Ligne 188 : @@
 Il est généralement nécessaire d'adapter un peu les valeurs stockées pour obtenir 100% correspondance à chaque fois. Le signal infrarouge n'est pas un protocol qui s'appuie sur la précision temporelle (''not a precision-timed protocol''), par conséquent une marge d'erreur de 20% (FUZZINESS=20%) et plus n'est pas une mauvaise chose.
-Finally, we can turn the '''loop()''' into its own function which will retunr '''true''' or '''false''' depending on whether it matched the code we ask it to. We also commented out the printing functions
+Pour finir, Le contenu de {{fname|loop()}} est transformé en sa propre fonction qui retourne '''true''' ou '''false''' en fonction du code que nous luis avons demandé de vérifier. Les lignes {{fname|Serial.print()}} ont également été mises en commentaire.
   <nowiki>
@@ Ligne 230 : / Ligne 230 : @@
 </nowiki>
-We then took more IR command data for the 'rewind' and 'fastforward' buttons and put all the code array data into ircodes.h to keep the main sketch from being too long and unreadable ([http://github.com/adafruit/IR-Commander vous pouvez obtenir tout le code depuis le GitHib d'AdaFruit)
+Ensuite, nous capturons plus de données infrarouge comme 'précédent' (''rewind'') ou 'suivant' (''fastforward'') et plaçons ces informations dans des tableaux stockés dans le fichier {{fname|ircodes.h}} pour éviter que le croquis/sketch principal ne devienne trop long et illisible ([http://github.com/adafruit/IR-Commander vous pouvez obtenir tout le code depuis le GitHib d'AdaFruit)
-Finally, the main loop looks like this:
+A la fin, la boucle principale ressemble à ceci:
   <nowiki>
-    void loop(void) {
+void loop(void) {
      int numberpulses;
      numberpulses = listenForIR();
      Serial.print("Heard ");
      Serial.print(numberpulses);
      Serial.println("-pulse long IR signal");
      if (IRcompare(numberpulses, ApplePlaySignal)) {
-    Serial.println("PLAY");
+       Serial.println("PLAY");
+     }
      if (IRcompare(numberpulses, AppleRewindSignal)) {
-    Serial.println("REWIND");
+       Serial.println("REWIND");
+     }
      if (IRcompare(numberpulses, AppleForwardSignal)) {
-    Serial.println("FORWARD");
+       Serial.println("FORWARD");
+     }
 </nowiki>
-We check against all the codes we know about and print out whenever we get a match. You could now take this code and turn it into something else, like a robot that moves depending on what button is pressed.
+Nous vérifions les données réçues par rapport aux codes infrarouges que nous connaissons déjà et affichons un message avec ce que nous avons détecté.
-After testing, success!
+Voila, une fois nos tests réussis, il ne reste plus qu'a prendre ce code pour en faire quelque-chose de plus utile (en fonction du bouton pressé).
 {{ADFImage|mulitirbutton.jpg}}
 {{SenseurIR-TRAILER}}

@@ Ligne 183 : / Ligne 183 : @@
 {{ADFImage|IR-codecompareok.jpg}}
-This loop, as it goes through each pulse, does a little math. It compares the absolute ('''abs()''') difference between the code we heard and the code we're trying to match abs(oncode - ApplePlaySignal[i*2 + 0]) and then makes sure that the error is less than FUZZINESS percent of the code length (oncode * FUZZINESS / 100)
+Cette fonction {{fname|loop()}}, est exécutée pour chaque impulsion, fait quelques opérations mathématique. Elle compare la différence absolue ({{fname|abs()}}) entre ce que code réceptionne (IR reçu) et le code auquel nous essayons de le faire correspondre {{fname|abs(oncode - ApplePlaySignal[i*2 + 0])}} et ensuire s'assurer que l'erreur est inférieure FUZZINESS pourcent de la longueur du code
-We found we had to tweak the stored values a little to make them match up 100% each time. IR is not a precision-timed protocol so having to make the FUZZINESS 20% or more is not a bad thing
+Il est généralement nécessaire d'adapter un peu les valeurs stockées pour obtenir 100% correspondance à chaque fois. Le signal infrarouge n'est pas un protocol qui s'appuie sur la précision temporelle (''not a precision-timed protocol''), par conséquent une marge d'erreur de 20% (FUZZINESS=20%) et plus n'est pas une mauvaise chose.
 Finally, we can turn the '''loop()''' into its own function which will retunr '''true''' or '''false''' depending on whether it matched the code we ask it to. We also commented out the printing functions
   <nowiki>
-    boolean IRcompare(int numpulses, int Signal[]) {
+boolean IRcompare(int numpulses, int Signal[]) {
      for (int i=0; i< numpulses-1; i++) {
-    int oncode = pulses[i][1] * RESOLUTION / 10;
+        int oncode = pulses[i][1] * RESOLUTION / 10;
-    int offcode = pulses[i+1][0] * RESOLUTION / 10;
+        int offcode = pulses[i+1][0] * RESOLUTION / 10;
-    /*
-    Serial.print(oncode); // the ON signal we heard
+        /*
-    Serial.print(" - ");
+        Serial.print(oncode); // Le signal ON reçu
-    Serial.print(Signal[i*2 + 0]); // the ON signal we want
+        Serial.print(" - ");
-    */
+        Serial.print(Signal[i*2 + 0]); // Le signal ON attendu
-    // check to make sure the error is less than FUZZINESS percent
+        */
-    if ( abs(oncode - Signal[i*2 + 0]) <= (Signal[i*2 + 0] * FUZZINESS / 100)) {
+        // Vérifier que l'erreur est inférieure à FUZZINESS pourcent
-    //Serial.print(" (ok)");
+        if ( abs(oncode - Signal[i*2 + 0]) <= (Signal[i*2 + 0] * FUZZINESS / 100)) {
-    } else {
+            //Serial.print(" (ok)");
-    //Serial.print(" (x)");
+        } else {
-    // we didn't match perfectly, return a false match
+            //Serial.print(" (x)");
-    return false;
+            // Pas de correspondance parfaite, retourner false
+            return false;
      /*
-    Serial.print(" \t"); // tab
-    Serial.print(offcode); // the OFF signal we heard
+        /*
-    Serial.print(" - ");
+        Serial.print(" \t"); // tabulation
-    Serial.print(Signal[i*2 + 1]); // the OFF signal we want
+        Serial.print(offcode); // Le signal OFF reçu
-    */
+        Serial.print(" - ");
-    if ( abs(offcode - Signal[i*2 + 1]) <= (Signal[i*2 + 1] * FUZZINESS / 100)) {
+        Serial.print(Signal[i*2 + 1]); // Le signal OFF que nous attendons
-    //Serial.print(" (ok)");
+        */
-    } else {
+        if ( abs(offcode - Signal[i*2 + 1]) <= (Signal[i*2 + 1] * FUZZINESS / 100)) {
-    //Serial.print(" (x)");
+           //Serial.print(" (ok)");
-    // we didn't match perfectly, return a false match
+        } else {
-    return false;
+           //Serial.print(" (x)");
+           // Pas de correspondance parfaite, retourner false
-    //Serial.println();
+           return false;
+     }
-     // Everything matched!
+     // Tout correspond!
      return true;
-−
+}
 </nowiki>
 We then took more IR command data for the 'rewind' and 'fastforward' buttons and put all the code array data into ircodes.h to keep the main sketch from being too long and unreadable ([http://github.com/adafruit/IR-Commander vous pouvez obtenir tout le code depuis le GitHib d'AdaFruit)
@@ Ligne 251 : / Ligne 252 : @@
+     }
 </nowiki>
 We check against all the codes we know about and print out whenever we get a match. You could now take this code and turn it into something else, like a robot that moves depending on what button is pressed.

@@ Ligne 80 : / Ligne 80 : @@
 Nous allons essayer de détecter ce code. Essayons de démarrer un nouveau croquis appelé IR Commander ([http://github.com/adafruit/IR-Commander la version finale du code est disponible sur le GitHub d'AdaFruit]) qui utilisera une partie de notre précédent croquis.
-La première partie écourtera simplement le code Infrarouge et placera les temps d'impulsion dans le tableau pulses[]. Il retournera le nombre d'impulsions détecté comme valeur de retour.
+La première partie écourtera simplement le code Infrarouge et placera les temps d'impulsion dans le tableau {{fname|pulses[]}}. Il retournera le nombre d'impulsions détecté comme valeur de retour.
   <nowiki>
@@ Ligne 119 : / Ligne 119 : @@
 </nowiki>
-Our new '''loop()''' will start out just listening for pulses
+Notre nouvelle fonction {{fname|loop()}} ne fera qu' "écouter" après les impulsions.
   <nowiki>
-    void loop(void) {
+void loop(void) {
      int numberpulses;
      numberpulses = listenForIR();
@@ Ligne 128 : / Ligne 128 : @@
      Serial.print(numberpulses);
      Serial.println("-pulse long IR signal");
-−
+}
 </nowiki>
-When we run this it will print out something like...
+Lorsqu'il fonctionne, il affiche quelque chose comme ceci...
 {{ADFImage|IR-pulsecounter.jpg}}
-OK time to make the sketch compare what we received to what we have in our stored array:
+OK, il est maintenant temps de faire en sorte que notre croquis compare ce qu'il à reçu et ce qu'il a déjà dans le notre tableau de référence:
 {{ADFImage|IR-ircompare.jpg}}
-As you can see, there is some variation. So when we do our comparison we can't look for preciesely the same values, we have to be a little 'fuzzy'. We'll say that the values can vary by 20% - that should be good enough.
+Comme vous pouvez le voir, il y a quelques variations. Lorsque nous faisons la comparaison, nous ne pouvons malheureusement pas attendre d'avoir exactement les mêmes valeurs, nous devons opter pour une méthode un peu plus 'créative'.
   <nowiki>
 void loop(void) {
      int numberpulses;
      numberpulses = listenForIR();
@@ Ligne 152 : / Ligne 154 : @@
      Serial.println("-pulse long IR signal");
      for (int i=0; i< numberpulses-1; i++) {
-    int oncode = pulses[i][1] * RESOLUTION / 10;
+      int oncode = pulses[i][1] * RESOLUTION / 10;
-    int offcode = pulses[i+1][0] * RESOLUTION / 10;
+      int offcode = pulses[i+1][0] * RESOLUTION / 10;
-    Serial.print(oncode); // the ON signal we heard
-    Serial.print(" - ");
+      Serial.print(oncode); // le signal ON réceptionné
-    Serial.print(ApplePlaySignal[i*2 + 0]); // the ON signal we want
+      Serial.print(" - ");
-    // check to make sure the error is less than FUZZINESS percent
+      Serial.print(ApplePlaySignal[i*2 + 0]); // Le signal ON attendu
-    if ( abs(oncode - ApplePlaySignal[i*2 + 0]) <= (oncode * FUZZINESS / 100)) {
+      // Vérifier pour s'arrure que l'erreur est inférieure à FUZZINESS pourcent
-    Serial.print(" (ok)");
+      if ( abs(oncode - ApplePlaySignal[i*2 + 0]) <= (oncode * FUZZINESS / 100)) {
-    } else {
+        Serial.print(" (ok)");
-    Serial.print(" (x)");
+      } else {
+        Serial.print(" (x)");
-    Serial.print(" \t"); // tab
-    Serial.print(offcode); // the OFF signal we heard
+      Serial.print(" \t"); // tab
-    Serial.print(" - ");
-    Serial.print(ApplePlaySignal[i*2 + 1]); // the OFF signal we want
+      Serial.print(offcode); // Le signal OFF réceptionné
-    if ( abs(offcode - ApplePlaySignal[i*2 + 1]) <= (offcode * FUZZINESS / 100)) {
+      Serial.print(" - ");
-    Serial.print(" (ok)");
+      Serial.print(ApplePlaySignal[i*2 + 1]); // Le signal OFF attendu
-    } else {
+      if ( abs(offcode - ApplePlaySignal[i*2 + 1]) <= (offcode * FUZZINESS / 100)) {
-    Serial.print(" (x)");
+        Serial.print(" (ok)");
+      } else {
-    Serial.println();
+        Serial.print(" (x)");
-−
+      }
+     }
 </nowiki>
 {{ADFImage|IR-codecompareok.jpg}}
 This loop, as it goes through each pulse, does a little math. It compares the absolute ('''abs()''') difference between the code we heard and the code we're trying to match abs(oncode - ApplePlaySignal[i*2 + 0]) and then makes sure that the error is less than FUZZINESS percent of the code length (oncode * FUZZINESS / 100)

@@ Ligne 10 : / Ligne 10 : @@
   <nowiki>
-    void printpulses(void) {
+void printpulses(void) {
      Serial.println("\n\r\n\rReceived: \n\rOFF \tON");
      for (uint8_t i = 0; i < currentpulse; i++) {
-    Serial.print(pulses[i][0] * RESOLUTION, DEC);
+       Serial.print(pulses[i][0] * RESOLUTION, DEC);
-    Serial.print(" usec, ");
+       Serial.print(" usec, ");
-    Serial.print(pulses[i][1] * RESOLUTION, DEC);
+       Serial.print(pulses[i][1] * RESOLUTION, DEC);
-    Serial.println(" usec");
+       Serial.println(" usec");
+     }
      // print it in a 'array' format
@@ Ligne 22 : / Ligne 22 : @@
      Serial.println("// ON, OFF (in 10's of microseconds)");
      for (uint8_t i = 0; i < currentpulse-1; i++) {
-    Serial.print("\t"); // tab
+       Serial.print("\t"); // tab
-    Serial.print(pulses[i][1] * RESOLUTION / 10, DEC);
+       Serial.print(pulses[i][1] * RESOLUTION / 10, DEC);
-    Serial.print(", ");
+       Serial.print(", ");
-    Serial.print(pulses[i+1][0] * RESOLUTION / 10, DEC);
+       Serial.print(pulses[i+1][0] * RESOLUTION / 10, DEC);
-    Serial.println(",");
+       Serial.println(",");
+     }
      Serial.print("\t"); // tab
      Serial.print(pulses[currentpulse-1][1] * RESOLUTION / 10, DEC);
      Serial.print(", 0};");
-−
+}
 </nowiki>
-I uploaded the new sketch and pressed the Play button on the Apple remote and got the following:
+Le nouveau croquis téléversé sur notre Arduino, pressons le bouton "Jouer" de la télécommande et voyons le résutlat que nous allons obtenir:
   <nowiki>
 int IRsignal[] = { // ON, OFF (in 10's of microseconds)
 , 438,
 , 48,
@@ Ligne 77 : / Ligne 75 : @@
 , 3012,
 , 212,
-, 0};
+, 0 };
 </nowiki>
-We'll try to detect that code. Lets start a new sketch called IR Commander ([http://github.com/adafruit/IR-Commander la version finale du code est disponible sur le GitHub d'AdaFruit]) this will use parts of our previous sketch. The first part we'll do is to create a function that just listens for an IR code an puts the pulse timings into the pulses[] array. It will return the number of pulses it heard as a return-value.
+Nous allons essayer de détecter ce code. Essayons de démarrer un nouveau croquis appelé IR Commander ([http://github.com/adafruit/IR-Commander la version finale du code est disponible sur le GitHub d'AdaFruit]) qui utilisera une partie de notre précédent croquis.
   <nowiki>
-    int listenForIR(void) {
+int listenForIR(void) {
-    currentpulse = 0;
+currentpulse = 0;
-    while (1) {
+while (1) {
      uint16_t highpulse, lowpulse; // temporary storage timing
      highpulse = lowpulse = 0; // start out with no pulse length
      // while (digitalRead(IRpin)) { // this is too slow!
      while (IRpin_PIN & (1 << IRpin)) {
-    // pin is still HIGH
+       // pin is still HIGH
-    // count off another few microseconds
+       // count off another few microseconds
-    highpulse++;
+       highpulse++;
-    delayMicroseconds(RESOLUTION);
+       delayMicroseconds(RESOLUTION);
-    // If the pulse is too long, we 'timed out' - either nothing
+       // If the pulse is too long, we 'timed out' - either nothing
-    // was received or the code is finished, so print what
+       // was received or the code is finished, so print what
-    // we've grabbed so far, and then reset
+       // we've grabbed so far, and then reset
-    if ((highpulse >= MAXPULSE) && (currentpulse != 0)) {
+       if ((highpulse >= MAXPULSE) && (currentpulse != 0)) {
-    return currentpulse;
+          return currentpulse;
-−
+       }
+     }
      // we didn't time out so lets stash the reading
@@ Ligne 105 : / Ligne 105 : @@
      // same as above
      while (! (IRpin_PIN & _BV(IRpin))) {
-    // pin is still LOW
+       // pin is still LOW
-    lowpulse++;
+       lowpulse++;
-    delayMicroseconds(RESOLUTION);
+       delayMicroseconds(RESOLUTION);
-    if ((lowpulse >= MAXPULSE) && (currentpulse != 0)) {
+       if ((lowpulse >= MAXPULSE) && (currentpulse != 0)) {
-    return currentpulse;
+          return currentpulse;
-−
+       }
+     }
      pulses[currentpulse][1] = lowpulse;
@@ Ligne 116 : / Ligne 116 : @@
      currentpulse++;
+     }
-−
+}
 </nowiki>

@@ Ligne 3 : / Ligne 3 : @@
 {{ADFImage|IR-appleremote.jpeg|400px}}
-For our final project, we will use a remote control to send messages to a microcontroller. For example, this might be useful for a robot that can be directed with an IR remote. It can also be good for projects that you want to control from far away, without wires.
+Pour notre projet final, nous allons utiliser une commande à distance pour envoyer des messages à un microcontrôleur. Par exemple, cela peut être utile afin de pouvoir piloter un robot à distance. C'est également un technique intéressante pour contrôler un projet à distance, sans avoir besoin de fils.
-For a remote in this example we'll be using an Apple clicker remote. You can use any kind of remote you wish, or you can steal one of these from an unsuspecting hipster.
+En guise de télécommande, ce tuto utilise une télécommande Apple. Vous pouvez utiliser n'importe quelle type de télécommande, une déjà utilisée à la maison ou une de récupération.
-We'll use the code from our previous sketch for raw IR reading but this time we'll edit our printer-outer to have it give us the pulses in a C array, this will make it easier for us to use for pattern matching.
+Nous allons utiliser le code du croquis/sketch précédent pour lire les données en provenance de la télécommande mais cette fois, nous allons afficher le contenu des informations sous forme de tableau afin de détecter plus facilement un ''pattern'' (un patron).
   <nowiki>

← Version précédente		Version du 25 août 2013 à 19:12
Ligne 258 :		Ligne 258 :
	{{ADFImage\|mulitirbutton.jpg}}		{{ADFImage\|mulitirbutton.jpg}}

−	{{SenseurIR-~~Nav~~}}	+	{{SenseurIR-TRAILER}}

@@ Ligne 1 : / Ligne 1 : @@
 {{SenseurIR-Nav}}
-[[Fichier:IR-appleremote.jpeg|400px]]
+{{ADFImage|IR-appleremote.jpeg|400px}}
 For our final project, we will use a remote control to send messages to a microcontroller. For example, this might be useful for a robot that can be directed with an IR remote. It can also be good for projects that you want to control from far away, without wires.
@@ Ligne 133 : / Ligne 133 : @@
 When we run this it will print out something like...
-[[Fichier:IR-pulsecounter.jpg]]
+{{ADFImage|IR-pulsecounter.jpg}}
 OK time to make the sketch compare what we received to what we have in our stored array:
-[[Fichier:IR-ircompare.jpg]]
+{{ADFImage|IR-ircompare.jpg}}
 As you can see, there is some variation. So when we do our comparison we can't look for preciesely the same values, we have to be a little 'fuzzy'. We'll say that the values can vary by 20% - that should be good enough.
@@ Ligne 177 : / Ligne 177 : @@
 </nowiki>
-[[Fichier:IR-codecompareok.jpg]]
+{{ADFImage|IR-codecompareok.jpg}}
@@ Ligne 256 : / Ligne 256 : @@
 After testing, success!
-[[Fichier:mulitirbutton.jpg]]
+{{ADFImage|mulitirbutton.jpg}}
-{{ADF-Accord}}
+{{SenseurIR-Nav}}