Code source autonome

Code source - Modèle - Arduino Uno

Bonjour,

Ce tutoriel explique comment monter un circuit qui utilise :

 Une carte Arduino Uno
 Une planche d'expérimentation "Solderless Breadboard"
 Un capteur infrarouge TSOP1838 (VS1838B)
 Une mini télécommande style MP3
 Un bouton-poussoir "Push Button Switches" à 4 pattes

Le code source est le modèle de base pour tout montage avec une carte contrôleur Arduino Uno.

En soi, le code source est très explicite et donne tous les détails requis pour son utilisation et le montage du circuit à réaliser.

Faites un copier-coller de ce code source dans l'éditeur Arduino et prenez le temps de le lire avant de l'exécuter, vous serez à même d'en apprécier toute la richesse et cela vous évitera bien des écueils.

Notez que le code source est plus lisible une fois copié dans l'éditeur Arduino. Ici la largeur d'une ligne de code n'est que de 40 à 50 caractères et le code source est mis en page pour une présentation sur 80 colonnes. Aussi, la coloration et la tabulation du code sont plus conforment et intéressantes dans l'éditeur Arduino. De ces faits, ici plusieurs lignes sont très difficiles a interpréter.


//*****************************************************************************
// Programme Arduino : ArduinoUnoBoutonTeleMP3
//*****************************************************************************
/*
Écrit par : René Ross

Date : 2013-08-25

Bibliothèques :
https://github.com/shirriff/Arduino-IRremote
*/

//*****************************************************************************
// Matériel requis :
//*****************************************************************************
/*
1 x Contrôleur Arduino Uno :
http://arduino.cc/en/Main/ArduinoBoardUno
http://dx.com/p/funduino-uno-r3-mega328p-board-for-hw-sw-engineers-development-tools-150802
http://dx.com/p/robotale-uno-atmega8u2-development-board-with-usb-cable-blue-178262
http://dx.com/p/uno-r3-development-board-microcontroller-mega328p-atmega16u2-compat-for-arduino-blue-black-215600

1 x Planche d'expérimentation Circuit-Test MB-102J « BreadBoard » :
http://www.circuittest.com/mb-102j-breadboard-166x54x9mm-830-holes-with-70pc-wiring-kit.html

1 x Petit transformateur 110V à 9V, 1A pour Arduino :
http://dx.com/p/arduino-9v-1a-power-adapter-black-2-flat-pin-plug-100cm-cable-126288

1 x Mini télécommande type MP3 :
http://dx.com/p/ir-remote-control-diy-kit-for-arduino-1-x-cr2025-136284

1 x Capteur infra-rouge VS1838B :
http://www.dipmicro.com/store/VS1838B
http://dx.com/s/1838

1 x Condensateur 100uF 10V
1 x Condensateur 104
1 x Résistance 100 Ohm
1 x Résistance 20 KOhm

1 x Bouton-poussoir "Push Button Switches" a 4 pattes :
http://dx.com/p/square-style-electrical-power-control-4-pin-push-button-switches-10-pcs-158030

Et des petits câbles électriques et connecteurs appropriés (mâle mâle, femelle
femelle et mâle femelle). Pour référence : MB-940, MB-910, MB-900, MB-102J,
LS-MMPJ-6, LS-FFPJ-6, etc. :
http://www.circuittest.com/mb-102j-breadboard-166x54x9mm-830-holes-with-70pc-wiring-kit.html
http://dx.com/p/breadboard-jumper-cables-wires-for-electronic-diy-100-male-to-male-40-female-to-female-203948
http://dx.com/p/breadboard-jumper-wires-for-electronic-diy-65-cable-pack-118826
http://dx.com/p/male-to-female-dupont-breadboard-jumper-wires-for-arduino-40-piece-pack-20cm-length-146935
http://dx.com/p/dupont-line-1p-1p-40-pack-20cm-length-121338
http://dx.com/p/30cm-breadboard-wires-for-electronic-diy-40-cable-pack-80207
http://dx.com/p/2-54mm-1x40-pin-breakaway-straight-male-header-10-piece-pack-144191
http://dx.com/p/breadboard-jumper-wire-cord-kit-for-arduino-diy-140-piece-pack-138220
*/

//*****************************************************************************

//*****************************************************************************
// Circuit à réaliser.
//*****************************************************************************
/*
Dans cette section, toutes les connexions des composantes du montage sont
listé, qu'ils soient utilisés ou non, et cela pour éviter tout oublie et
rendre le copier / coller par bloc complet pour une pièce plus facile d'un
montage à l'autre. Le plus souvent possible le libelle de la pièce précédé du
nom court de la pièce est utilisé, par exemple « ARDUINO_A3 », pour la broche
analogique A3 d'une carte contrôleur Arduino Uno R3.

Plaque d'expérimentation « BreanBoard » :

Pour identifier les broches d'une plaque d'expérimentation « BreanBoard »,
comme dans le jeu de bataille navale "Battle Ship", les lignes sont identifiées
pas des numéro (ici, de 1 a 63) et les colonnes sont identifiées par lettre des
lettres (ici, de a a j) et des signes (+) et (-). Donc (i10) indique
l'intersection de la colonne "i" avec la ligne numéro "10". Pour une broche
des colonnes négatives (-) ou GND et positives (+) ou Vcc, c'est le
signe de la colonne « + » ou « - », suivi du numéro de la rangée (de 1 a 63),
et suivit du côté de la plaque en majuscule, gauche « G » ou droite « D ».
Donc pour la colonne positive de la rangée 3, côté gauche, cela donne (+3G).
Le tout entre parenthèse « ( » et « ) » pour bien spécifier une position de la
planche d'expérimentation et pour éviter toutes confusions.
*/

/*
Câblage de l'Arduino Uno sur une planche d'expérimentation MB-104 :

ARDUIBO_USB    : Câble USB à l'ordinateur
ARDUIBO_PWR12V : Transformateur 110V à 9V ou batteries de 6V~12V

ARDUIBO_RECET  : câble à ARDUIBO_12
ARDUIBO_3_3V   :
ARDUIBO_5V_1   : (+52D) et câble de (+54D) à (+54G)
ARDUIBO_GND1   : (-53D) et câble de (-55D) à (-55G)
ARDUIBO_GND2   :
ARDUIBO_VIN    :

ARDUIBO_A0     :
ARDUIBO_A1     :
ARDUIBO_A2     :
ARDUIBO_A3     :
ARDUIBO_A4_SDA :
ARDUIBO_A5_SCL :

ARDUIBO_0_RX0  :
ARDUIBO_1_TX0  :
ARDUIBO_2      : (i63), l'état du bouton
ARDUIBO_3_PWM  : (j57), la sortie du capteur infrarouge
ARDUIBO_4      :
ARDUIBO_5_PWM  :
ARDUIBO_6_PWM  :
ARDUIBO_7      :

ARDUIBO_8      :
ARDUIBO_9_PWM  :
ARDUIBO_10_PWM :
ARDUIBO_11_PWM :
ARDUIBO_12     : câble à ARDUIBO_RECET
ARDUIBO_13     :
ARDUIBO_GND3   :
ARDUIBO_AREF   :

Câblage pour le capteur infra-rouge utiliser avec la télécommande, sur la
planche d'expérimentation  :

CAPTEUR_IR_1_SORTIE broche 1 : (f57) et câble de (j57) à ARDUIBO_3_PWM
CAPTEUR_IR_1_GND broche 2    : (f58) et câble de (j58) à (-58D)
CAPTEUR_IR_1_VIN broche 3    : (f59)
Condensateur 104 broche 1    : (g58)
Condensateur 104 broche 2    : (g59)
Condensateur 100uF 10V-      : (h58)
Condensateur 100uF 10V+      : (h59)
Résistance 100 Ohm 1         : (j59)
Résistance 100 Ohm 2         : (+59D)
Résistance 20 KOhm 1         : (i57)
Résistance 20 KOhm 2         : (i59)

Câblage pour le gros bouton sur la planche d'expérimentation  :

BOUTON_1Broche_1     : (d61)
BOUTON_1Broche_2     : (d63)
BOUTON_1Broche_3     : (g63) et câble de (i63) à ARDUIBO_2
BOUTON_1Broche_4     : (g61) et câble de (j61) à (+61D)
Résistance 100 Ohm 1 : (j63)
Résistance 100 Ohm 2 : (-61D)
*/

//*****************************************************************************

//*****************************************************************************
// Inclusion des librairies utilisées.
//*****************************************************************************
/*
Il s'agit de la bibliothèque irRemote pour l'Arduino.

Pour télécharger depuis github :

http://github.com/shirriff/Arduino-IRremote

Cliquez sur le lien "Télécharger" en haut à droite, cliquez sur « Télécharger
au format Zip", pour obtenir un fichier zip. Décompressez-le et renommez le
répertoire « Shirriff-Arduino-irRemote-NNN » pour « irRemote ». Pour
l'installer, déplacer le répertoire de irRemote téléchargée dans votre dossier
des bibliothèque Arduino « ~/Arduino/libraries/IRremote ». Pour avoir accès à la
nouvelle bibliothèque, vous devez redémarrer l'éditeur Arduino. Pour plus de
détails sur la bibliothèque voir le wiki sur github ou le poste :

http://arcfn.com/2009/08/multi-protocol-infrared-remote-library.html blog

Copyright 2009-2012 Ken Shirriff

Merci à cette personne pour sa contribution !
*/

#include <IRremote.h>
// ...
//*****************************************************************************

//*****************************************************************************
// Déclaration des constantes.
//*****************************************************************************
/*
Par convention, pour nommer une constante, nous utiliserons des noms écrits
tout en majuscule, en capitale, ce qui facilitera leur repérage et rendra le
code plus facilement compréhensible. Le mot devant notre nom de constante
indique à l'Arduino l'espace mémoire à réserver pour stocker cette donnée.
Après le nom de notre constante, on lui attribue sa valeur.
*/

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « ENTREE » est l'équivalent du paramètre « INPUT ». Ce paramètre
est pour prépare l'Arduino a recevoir une tension électrique pour ce
connecteur, sur ce port de communication, sur ce "pin".
*/

const byte ENTREE = INPUT;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « ENTREE_ET_RESISTENCE_INTERNE » est l'équivalent du paramètre
« INPUT_PULLUP ». Ce paramètre est pour prépare l'Arduino en activant sa
résistance interne et a recevoir une tension électrique pour ce connecteur,
sur ce port de communication, sur ce "pin".
*/

const byte ENTREE_ET_RESISTENCE_INTERNE = INPUT_PULLUP;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « SORTIE » est l'équivalent du paramètre « OUTPUT ». Ce paramètre
est pour prépare l'Arduino a émettre une tension électrique pour ce connecteur,
sur ce port de communication, sur ce "pin".
*/

const byte SORTIE = OUTPUT;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « HAUT » est l'équivalent du paramètre « HIGH ». Ce paramètre fait
que l'Arduino maintiendra un voltage haut sur ce connecteur, soit 3.3 Volts,
soit 5 Volts, selon sa propre tension d'alimentation. En électronique, cela
correspondra aux valeurs logiques « 1 », « Oui », ou « Vrai », etc.
*/

const byte HAUT = HIGH;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « BAS » est l'équivalent du paramètre « LOW ». Ce paramètre fait
que l'Arduino maintiendra un voltage bas sur ce connecteur, soit 0 Volt. En
électronique, cela correspondra aux valeurs logiques « 0 », « Non », ou
« Faut », etc.
*/

const byte BAS = LOW;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « NON » est l'équivalent du paramètre « false », cela
correspondra aux valeurs logiques « 0 », « Non », ou « Faut », etc.
*/

const byte NON = false;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « OUI » est l'équivalent du paramètre « true », cela
correspondra aux valeurs logiques « 1 », « Oui », ou « Vrai », etc.
*/

const byte OUI = true;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « FAUX » est l'équivalent du paramètre « false », cela
correspondra aux valeurs logiques « 0 », « Non », etc.
*/

const byte FAUX = false;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « VRAI » est l'équivalent du paramètre « true », cela
correspondra aux valeurs logiques « 1 », « Oui », etc.
*/

const byte VRAI = true;

// Pour la fonction « delay », qui compte le temps en milliseconde.
const int UneSeconde = 1000;
// ...
//*****************************************************************************

//*****************************************************************************
// Constantes des connecteurs.
//*****************************************************************************
// Pour Activer et Déactiver la DEL sur le contrôleur Arduino.
const int ARDUINO_DEL = 13;

// Pour gérer l'action d'humains le bouton de la planche d'expérimentation.
const int BOUTON_1_SORTIE = 2;

// Broche d'Arduino pour recevoir le signale du capteur infrarouge.
const int CAPTEUR_IR_1_SORTIE = 3;

// En prévision d'un ARDUINO_RESET par télécommande.
const int ARDUINO_RESET = 12;
//*****************************************************************************

//*****************************************************************************
// Déclaration des variables globales.
//*****************************************************************************
/*
Par convention, pour nommer une variable, nous utiliserons des noms écrits
avec un majuscule pour la première lettre de chaque mot composant le nom de la
variable, ce qui facilitera leur repérage et rendra le code plus facilement
compréhensible. Le mot devant notre nom de variable indique à l'Arduino l'espace
mémoire à réserver pour stocker cette donnée. Après le nom de notre variable, on
lui attribue sa valeur.
*/

/*
Ici, nous définissons la variable qui contrôlera la grande boucle principale,
qui s'active avec le bouton « Power » de la télécommande. Par défaut, le robot
ne fait rien a l’exception d'initialiser ses périphériques.
*/

boolean Boucler;

/*
Définition de la valeur retourné par les boutons de la télécommande.
*/

const unsigned long TelecommandeBoutonPower     = 16753245;
const unsigned long TelecommandeBoutonMode      = 16736925;
const unsigned long TelecommandeBoutonSon       = 16769565;
const unsigned long TelecommandeBoutonPlayPause = 16720605;
const unsigned long TelecommandeBoutonDebut     = 16712445;
const unsigned long TelecommandeBoutonFin       = 16761405;
const unsigned long TelecommandeBoutonEQ        = 16769055;
const unsigned long TelecommandeBoutonMoins     = 16754775;
const unsigned long TelecommandeBoutonPlus      = 16748655;
const unsigned long TelecommandeBouton0         = 16738455;
const unsigned long TelecommandeBoutonRecycle   = 16750695;
const unsigned long TelecommandeBoutonU_SD      = 16756815;
const unsigned long TelecommandeBouton1         = 16724175;
const unsigned long TelecommandeBouton2         = 16718055;
const unsigned long TelecommandeBouton3         = 16743045;
const unsigned long TelecommandeBouton4         = 16716015;
const unsigned long TelecommandeBouton5         = 16726215;
const unsigned long TelecommandeBouton6         = 16734885;
const unsigned long TelecommandeBouton7         = 16728765;
const unsigned long TelecommandeBouton8         = 16730805;
const unsigned long TelecommandeBouton9         = 16732845;
// Pour contenir la valeur du dernier bouton pressé.
      unsigned long TelecommandeBoutonValeur = 0;
//*****************************************************************************

//*****************************************************************************
// Création en mémoire des objet pour les interfaces des périphériques.
//*****************************************************************************
// Pour le capteur infrarouge crée un objet sur la broche voulue.
IRrecv         Capteur_IR_1 (CAPTEUR_IR_1_SORTIE);
decode_results Capteur_IR_1_Results;
// ...
//*****************************************************************************

//*****************************************************************************
// FONCTION SETUP = Code d'initialisation.
//*****************************************************************************
/*
La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du
programme. Pour éviter de mettre des composantes sous tension avec la dernière
version du programme chargé dans l'Arduino, Nous utilisant une boucle « while »,
tant qu'une première action n'est pas accompli par l'utilisateur, on ne fait
rien (Télécommande, bouton, etc.).

L'activation du rappel au + interne des connecteurs en entrée si nécessaire.
L'instruction « digitalWrite (pin, HIGH); » écrit la valeur HIGH, qui vaux 1
sur le connecteur en entrée, ce qui active la résistance de "rappel au +"
(pullup) au plus de ce connecteur. L'utilisation de cette résistance interne
est une protection minimale pour l'intégrité physique pour la puce principale.
*/

void setup ()
{
  // Ici les instructions à exécuter au démarrage.
  // IMPORTANT : régler le terminal côté PC avec la même valeur de
  // transmission. Ici c'est 115200.
  Serial.begin (115200);
  Serial.print ("********************************************************");
  Serial.println ();
  Serial.print ("* Debut de la procedure d'initialisation du systeme... *");
  Serial.println ();
  Serial.print ("********************************************************");
  Serial.println ();
  Serial.print ("*    Attente du bouton (Power) de la telecommande...   *");
  Serial.println ();
  Serial.print ("********************************************************");
  Serial.println ();
  Serial.println ();

  // Connecteurs en entrées et sorties.

  // Pour le bouton Marche/Arrêt sur la planche d'expérimentation.
  // Configurer le port Arduino en entrée pour le bouton.
  pinMode (BOUTON_1_SORTIE, ENTREE);
  // Activer la résistance au plus PULLUP.
  digitalWrite (BOUTON_1_SORTIE, HAUT);

  // Configurer le port Arduino en entrée pour le capteur infrarouge.
  pinMode (CAPTEUR_IR_1_SORTIE, ENTREE);
  // Initialisation et début de la réception du capteur infrarouge.
  Capteur_IR_1.enableIRIn ();

  // Boucle pour éviter qu'un ancien programme chargé ne s'exécute avec un
  // nouveau montage installé, en attente du chargement du nouveau programme.
  // Jusqu'ici, c'est le minimum qui est activé, le reste des connexions
  // seront activé après la boucle d'attente.
  Boucler = NON;
  while (Boucler != OUI)
  {
    GererBoutonMarcheArret ();
    GererBoutonTeleCommande ();
  }
  // Active la DEL de l'Arduino.
  pinMode (ARDUINO_DEL, SORTIE);
  digitalWrite (ARDUINO_DEL, Boucler);

// ...
  Serial.print ("********************************************************");
  Serial.println ();
  Serial.print ("*  Fin de la procedure d'initialisation du systeme...  *");
  Serial.println ();
  Serial.print ("********************************************************");
  Serial.println ();
  Serial.println ();
}
//*****************************************************************************

//*****************************************************************************
// FONCTION LOOP = Boucle sans fin = coeur du programme.
//*****************************************************************************
/* La fonction loop() s'exécute sans fin en boucle aussi longtemps que
l'Arduino est sous tension.
*/


void loop()
{
  // Ici les instructions à exécuter par le programme principal.
  GererBoutonTeleCommande ();
  GererBoutonMarcheArret ();
  if (Boucler == OUI)
  {
    // C'est ici que vous ajoutez le code spécifique a votre montage.
    Serial.print ("Une boucle a OUI...");
    Serial.println ();
    delay (UneSeconde);
  }
}
//*****************************************************************************

//*****************************************************************************
//*****************************************************************************
//***************************** Fin du programme. *****************************
//*****************************************************************************
//*****************************************************************************

//*****************************************************************************
// FONCTION GererBoutonMarcheArret
//*****************************************************************************
/*
Gestion de l'utilisation d'un bouton sur la planche d'expérimentation.
*/

void GererBoutonMarcheArret ()
{
  int EtatBouton = digitalRead (BOUTON_1_SORTIE);
  if (EtatBouton == HAUT)
  {
    Serial.print ("Le bouton Marche Arret enclenche");
    Serial.println ();
    if (Boucler == OUI)
    {
      Boucler = NON;
      // Éteindre la DEL de l'Arduino.
      digitalWrite (ARDUINO_DEL, Boucler);
      Serial.print ("En attente d'une action d'humaine");
      Serial.println ();
    }
    else
    {
      Boucler = OUI;
      // Allumer la DEL de l'Arduino.
      digitalWrite (ARDUINO_DEL, Boucler);
      Serial.print ("Poursuite du programme");
      Serial.println ();
    }
    while (EtatBouton == HAUT)
    {
      delay (5);// Pour absorber les micro-coupures des rebonds (5 ms).
      EtatBouton = digitalRead (BOUTON_1_SORTIE);
    }
  }
}
//*****************************************************************************

//*****************************************************************************
// FONCTION GererBoutonTeleCommande
//*****************************************************************************
/*
Gérer l'utilisation d'une télécommande type MP3 avec capteur infrarouge.

Ici tous les boutons de la télécommande sont listés et la majorité ont un
effet sur le déroulement de de la boucle principale ou sur les paramètres de
fonctionnement du moteur ou les deux  la fois et la touche « Mode » est
l'actionneur de la broche RESET de la carte Arduino, donc du redémarrage du
Système complet.

En synthèse les boutons font :

Power     : Active/désactive la boucle principale du programme, arrêt moteur.
Mode      : Bouton kamikaze qui utilise la broche RESET de la carte Arduino.
Son       :
PlayPause :
Debut     :
Fin       :
EQ        :
Moins     :
Plus      :
0         :
Recycle   :
U_SD      :
1         :
2         :
3         :
4         :
5         :
6         :
7         :
8         :
9         :
default   : Une télécommande génère beaucoup d'autres codes qui sont inutiles ici.
*/

void GererBoutonTeleCommande ()
{
  if (Capteur_IR_1.decode (&Capteur_IR_1_Results))
  {
    Capteur_IR_1.resume (); // Récupérer la valeur suivante.
    TelecommandeBoutonValeur = Capteur_IR_1_Results.value;
    switch (TelecommandeBoutonValeur)
    {
      case TelecommandeBoutonPower:
        Serial.print (" TelecommandeBoutonPower : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        if (Boucler == OUI)
        {
          Boucler = NON;
          digitalWrite (ARDUINO_DEL, Boucler);
          Serial.print ("En attente d'une action d'humaine");
          Serial.println ();
          digitalWrite (ARDUINO_DEL, Boucler);
        }
        else
        {
          Boucler = OUI;
          digitalWrite (ARDUINO_DEL, Boucler);
          Serial.print ("Poursuite du programme");
          Serial.println ();
          digitalWrite (ARDUINO_DEL, Boucler);
        }
        break;
      case TelecommandeBoutonMode:
        Serial.print (" TelecommandeBoutonMode : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Serial.print (" Redemarrage du controleur Arduino!! ");
        Serial.println ();
        delay (UneSeconde);
        // Configurer le port Arduino pour un RESET par télécommande.
        pinMode (ARDUINO_RESET, SORTIE);
        // Activer la broche ARDUINO_RESET.
        digitalWrite (ARDUINO_RESET, BAS);
        delay (UneSeconde);
        break;
      case TelecommandeBoutonSon:
        Serial.print (" TelecommandeBoutonSon : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonPlayPause:
        Serial.print (" TelecommandeBoutonPlayPause : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonDebut:
        Serial.print (" TelecommandeBoutonDebut : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonFin:
        Serial.print (" TelecommandeBoutonFin : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonEQ:
        Serial.print (" TelecommandeBoutonEQ : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonMoins:
        Serial.print (" TelecommandeBoutonMoins : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonPlus:
        Serial.print (" TelecommandeBoutonPlus : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton0:
        Serial.print (" TelecommandeBouton0 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonRecycle:
        Serial.print (" TelecommandeBoutonRecycle : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonU_SD:
        Serial.print (" TelecommandeBoutonU_SD : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton1:
        Serial.print (" TelecommandeBouton1 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton2:
        Serial.print (" TelecommandeBouton2 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton3:
        Serial.print (" TelecommandeBouton3 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton4:
        Serial.print (" TelecommandeBouton4 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton5:
        Serial.print (" TelecommandeBouton5 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton6:
        Serial.print (" TelecommandeBouton6 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton7:
        Serial.print (" TelecommandeBouton7 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton8:
        Serial.print (" TelecommandeBouton8 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton9:
        Serial.print (" TelecommandeBouton9 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      default:
        Serial.print (" Code inconnu : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
    }
  }
  while (Capteur_IR_1.decode (&Capteur_IR_1_Results))
  {
    delay (5);// Pour absorber les micro-coupures des rebonds (5 ms).
    Capteur_IR_1.resume (); // Récupéré la valeur suivante.
    TelecommandeBoutonValeur = Capteur_IR_1_Results.value;
  }
}
//*****************************************************************************
 


En souhaitant que vous y trouviez ce que vous cherchiez !

Bon montage !

L'ami René

Un pour tous, et tous pour un !

Share