Code source autonome

Capteur - Infrarouges et télécommandes - Recyclez vos vielles télécommandes et appareils à capteur infrarouge

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 télécommande quelconque

Que fait ce programme :

Ce programme utilise un capteur à infrarouge et une quelconque télécommande pour identifier les codes transmis par la télécommande au capteur infrarouge et affiche le code transmis dans le moniteur série de l'éditeur Arduino. Ce qui permet de programmer l'action de chacun des boutons de la télécommande dans le présent code source pour le personnaliser pour cette télécommande. Pour gérer les touche de la télécommande, nous utilisons une boucle et une liste de cas de valeur de bouton. Cette boucle « GererBoutonTeleCommande () » peut-être appeler de n'importe ou dans le reste du programme et en modifiera les paramètres selon vos propres besoins.

Le contrôle est fait dans une boucle principale dans la section « loop () ». Dans notre exemple, le taux de rafraîchissement entre deux lectures de valeur d'un bouton d'une télécommande est par défaut de 1 seconde et cela est modifier avec les boutons « Vol- » et « Vol+ » de la télécommande par pas de 0.1 seconde.

Pour chaque nouveau bouton que vous voulez paramétrer dans vos programmes, vous devez modifier deux sections du présent code source, la section :

« Définition des valeurs retournées par les boutons de la télécommande. » « GererBoutonTeleCommande () »

Dans c'est deux sections vous n'avez qu'a copier/coller une ligue existante et en adapter les valeurs pour un nouveau bouton de télécommande.

Par exemple, dans la section « Définition... » copier/coller la ligne :

const unsigned long TelecommandeBoutonInconnu = 00000000;

et transformez-la en :

const unsigned long TelecommandeBoutonPause = 00000000;

Vous remplacez la valeur « 00000000 » par ce que vous a donné l'appui du bouton « PAUSE » de la télécommande dans le moniteur série de l'éditeur Arduino, utilisez la aussi le copier/coller.

Et dans la « GererBoutonTeleCommande () », a la fin du présent code source, vous copier/coller un "case...":

«

      case TelecommandeBoutonInconnu:
        Serial.print (" TelecommandeBoutonInconnu : ");
        Serial.print (TelecommandeBoutonInconnu);
        Serial.println ();
        break;

»

et transformez-la en :

«

      case TelecommandeBoutonPause:
        Serial.print (" TelecommandeBoutonPause : ");
        Serial.print (TelecommandeBoutonPause);
        Serial.println ();
        break;

»

Et voilà, vous avez un nouveau bouton prêt a vous servir !

Pour ce qui est des capteurs infrarouges, vous pourriez en récupérer dans les vieil appareil désuet ou pour ceux que vous auriez perdu la télécommande et que bien sûr vous n'utilisez plus. Pour voir à quoi ressemble un capteur infrarouche, a fin de le démonter d'un appareil, faite la recherche d'image Google « transistor infrarouche » : https://www.google.com/search?q=transistor+infrarouge&safe=off&source=lnms&tbm=isch&sa=X&ei=rHMbUtaeE46yqAGDnoGYCw&ved=0CAkQ_AUoAQ&biw=1198&bih=822

Le code source :

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 : ArduinoUnoRecyclerTelecommande
//*****************************************************************************
/*
Écrit par : René Ross

Date : 2013-08-26
*/

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

//*****************************************************************************
// Que fait ce programme :
//*****************************************************************************
/*
Ce programme utilise un capteur à infrarouge et une quelconque télécommande
pour identifier les codes transmis par la télécommande au capteur infrarouge
et affiche le code transmis dans le moniteur série de l'éditeur Arduino. Ce
qui permet de programmer l'action de chacun des boutons de la télécommande
dans le présent code source pour le personnaliser pour cette télécommande. Pour
gérer les touche de la télécommande, nous utilisons une boucle et une liste
de cas de valeur de bouton. Cette boucle « GererBoutonTeleCommande () »
peut-être appeler de n'importe ou dans le reste du programme et en modifiera
les paramètres selon vos propres besoins.

Le contrôle est fait dans une boucle principale dans la section « loop () ».
Dans notre exemple, le taux de rafraîchissement entre deux lectures de
valeur d'un bouton d'une télécommande est par défaut de 1 seconde et cela
est modifier avec les boutons « Vol- » et « Vol+ » de la télécommande par
pas de 0.1 seconde.

Pour chaque nouveau bouton que vous voulez paramétrer dans vos programmes,
vous devez modifier deux sections du présent code source, la section :

« Définition des valeurs retournées par les boutons de la télécommande. »
« GererBoutonTeleCommande () »

Dans c'est deux sections vous n'avez qu'a copier/coller une ligue existante
et en adapter les valeurs pour un nouveau bouton de télécommande.

Par exemple, dans la section « Définition... » copier/coller la ligne :

const unsigned long TelecommandeBoutonInconnu     = 00000000;

et transformez-la en :

const unsigned long TelecommandeBoutonPause     = 00000000;

Vous remplacez la valeur « 00000000 » par ce que vous a donné l'appui du
bouton « PAUSE » de la télécommande dans le moniteur série de l'éditeur
Arduino, utilisez la aussi le copier/coller.

Et dans la « GererBoutonTeleCommande () », a la fin du présent code source,
vous copier/coller un "case...":

«
      case TelecommandeBoutonInconnu:
        Serial.print (" TelecommandeBoutonInconnu : ");
        Serial.print (TelecommandeBoutonInconnu);
        Serial.println ();
        break;
»

et transformez-la en :

«
      case TelecommandeBoutonPause:
        Serial.print (" TelecommandeBoutonPause : ");
        Serial.print (TelecommandeBoutonPause);
        Serial.println ();
        break;
»

Et voilà, vous avez un nouveau bouton prêt a vous servir !

Pour ce qui est des capteurs infrarouges, vous pourriez en récupérer dans les
vieil appareil désuet ou pour ceux que vous auriez perdu la télécommande et
que bien sûr vous n'utilisez plus. Pour voir à quoi ressemble un capteur
infrarouche, a fin de le démonter d'un appareil, faite la recherche d'image
Google « transistor infrarouche » :
https://www.google.com/search?q=transistor+infrarouge&safe=off&source=lnms&tbm=isch&sa=X&ei=rHMbUtaeE46yqAGDnoGYCw&ved=0CAkQ_AUoAQ&biw=1198&bih=822
*/

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

//*****************************************************************************
// Matériel requis :
//*****************************************************************************
/*
Bibliothèques utilisées :
https://github.com/shirriff/Arduino-IRremote

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 Télécommande infrarouge quelconque :
1 x Capteur infrarouges 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

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

Autres télécommandes :
http://dx.com/p/ir-remote-control-diy-kit-for-arduino-1-x-cr2025-136284

Mais vous pourriez utiliser la télécommande de votre télévision du de votre
système de son, etc.
*/

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

//*****************************************************************************
// 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  :
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      :
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     :
ARDUIBO_13     :
ARDUIBO_GND3   :
ARDUIBO_AREF   :

Câblage pour le capteur infrarouge 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)
*/

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

//*****************************************************************************
// Inclusion des librairies utilisées.
//*****************************************************************************
#include <IRremote.h>
/*
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èques 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 !
*/

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

//*****************************************************************************
// 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;
//*****************************************************************************

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

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

//*****************************************************************************
// Déclaration des variables globales.
//*****************************************************************************
/*
Par convention, pour nommer une variable, nous utiliserons des noms écrits
avec une 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 = OUI;// Dans vos programmes vous remplacez ce OUI par NON;

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

// Délai pour réduire la vitesse de réaction entre les lectures des boutons.
int TempsRebonBouton = 5;

/*
Définition des valeurs retournées par les boutons de la télécommande.
*/

const unsigned long TelecommandeBoutonPower     = 1637937167;
const unsigned long TelecommandeBoutonInconnu   = 00000000;
const unsigned long TelecommandeBoutonPause     = 1637908862;
const unsigned long TelecommandeBoutonVolMoins  = 1637920847;
const unsigned long TelecommandeBoutonVolPlus   = 1637888207;
const unsigned long TelecommandeBouton0         = 1637912687;
const unsigned long TelecommandeBouton1         = 1637875967;
const unsigned long TelecommandeBouton2         = 1637908607;
const unsigned long TelecommandeBouton3         = 1637892287;
const unsigned long TelecommandeBouton4         = 1637924927;
const unsigned long TelecommandeBouton5         = 1637884127;
const unsigned long TelecommandeBouton6         = 1637916767;
const unsigned long TelecommandeBouton7         = 1637900447;
const unsigned long TelecommandeBouton8         = 1637933087;
const unsigned long TelecommandeBouton9         = 1637880047;
// Pour contenir la valeur du dernier bouton pressé.
      unsigned long TelecommandeBoutonValeur = 0;

int DelaiEntre2Lecture = 1000;// En milliseconde, ici 1000 font 1 seconde.
//*****************************************************************************

//*****************************************************************************
// Création en mémoire des objets 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 utilisons une boucle « while »,
tant qu'une première action n'est pas accomplie 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 (9600);
  // Pour affichage dans le moniteur série de l'éditeur Arduino.
  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.

  // 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.
  while (Boucler != OUI)
  {
    GererBoutonTeleCommande ();
  }
  // Activer la DEL de l'Arduino.
  pinMode (ARDUINO_DEL, SORTIE);
  digitalWrite (ARDUINO_DEL, Boucler);

  // Pour affichage dans le moniteur série de l'éditeur Arduino.
  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 ();
  if (Boucler == OUI)
  {
    // C'est ici que vous ajoutez le code spécifique a votre montage.
    delay (DelaiEntre2Lecture);
  }
}
//*****************************************************************************

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

//*****************************************************************************
// 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.
PlayPause :
VolMoins  :
VolPlus   :
0         :
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 TelecommandeBoutonInconnu:
        Serial.print (" TelecommandeBoutonInconnu : ");
        Serial.print (TelecommandeBoutonInconnu);
        Serial.println ();
        break;
      case TelecommandeBoutonVolMoins:
        Serial.print (" TelecommandeBoutonVolMoins : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        DelaiEntre2Lecture = DelaiEntre2Lecture - 100;
        // Pour éviter un plantage du programme avec  une valeur négative.
        if (DelaiEntre2Lecture < 0)
        {
          DelaiEntre2Lecture = 0;
        }
        Serial.print (" DelaiEntre2Lecture : ");
        Serial.print (DelaiEntre2Lecture);
        Serial.print ("(ms)");
        Serial.println ();
        break;
      case TelecommandeBoutonVolPlus:
        Serial.print (" TelecommandeBoutonVolPlus : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        DelaiEntre2Lecture = DelaiEntre2Lecture + 100;
        Serial.print (" DelaiEntre2Lecture : ");
        Serial.print (DelaiEntre2Lecture);
        Serial.print ("(ms)");
        Serial.println ();
        break;
      case TelecommandeBouton0:
        Serial.print (" TelecommandeBouton0 : ");
        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))
  {
    // Pour absorber les microcoupures des rebonds (minimum 5 ms).
    delay (TempsRebonBouton);
    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