//*****************************************************************************
// Programme Arduino : ArduinoNanoBoutonTeleMP3
//*****************************************************************************
/*
Écrit par : René Ross
Date : 2013-08-26
*/
//*****************************************************************************
//*****************************************************************************
// Que fait ce programme :
//*****************************************************************************
/*
Ce programme utilise un capteur à infrarouge et une mini télécommande type MP3
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 () ».
Les capteurs infrarouges et les télécommandes sont interchangeables.
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
De plus, une fonction équivalente « GererBoutonMarcheArret » gère
l'utilisation d'un bouton sur la planche d'expérimentation.
*/
//*****************************************************************************
//*****************************************************************************
// Matériel requis :
//*****************************************************************************
/*
Bibliothèques utilisées :
https://github.com/shirriff/Arduino-IRremote
1 x Contrôleur Arduino Nano :
https://arduino.cc/en/Main/ArduinoBoardNano
https://dx.com/p/nano-v3-0-avr-atmega328-p-20au-module-board-usb-cable-for-arduino-118037
1 x Planche d'expérimentation Circuit-Test MB-102J « BreadBoard » :
https://www.circuittest.com/mb-102j-breadboard-166x54x9mm-830-holes-with-70pc-wiring-kit.html
1 x Petit transformateur 110V à 9V, 1A pour Arduino :
https://dx.com/p/arduino-9v-1a-power-adapter-black-2-flat-pin-plug-100cm-cable-126288
1 x Module d'alimentation MB102 6.5V~12V, 3.3V et 5V :
https://dx.com/p/mb102-breadboard-power-supply-module-for-arduino-dc-6-5-12v-149664
1 x Mini télécommande type MP3 :
https://dx.com/p/ir-remote-control-diy-kit-for-arduino-1-x-cr2025-136284
1 x Capteur infrarouges VS1838B :
https://www.dipmicro.com/store/VS1838B
https://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 :
https://dx.com/p/square-style-electrical-power-control-4-pin-push-button-switches-10-pcs-158030
1 x Résistance 100 Ohm
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. :
https://www.circuittest.com/mb-102j-breadboard-166x54x9mm-830-holes-with-70pc-wiring-kit.html
https://dx.com/p/breadboard-jumper-cables-wires-for-electronic-diy-100-male-to-male-40-female-to-female-203948
https://dx.com/p/breadboard-jumper-wires-for-electronic-diy-65-cable-pack-118826
https://dx.com/p/male-to-female-dupont-breadboard-jumper-wires-for-arduino-40-piece-pack-20cm-length-146935
https://dx.com/p/dupont-line-1p-1p-40-pack-20cm-length-121338
https://dx.com/p/30cm-breadboard-wires-for-electronic-diy-40-cable-pack-80207
https://dx.com/p/2-54mm-1x40-pin-breakaway-straight-male-header-10-piece-pack-144191
https://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 :
ARDUINO_USB : Câblage mini-USB à l'ordinateur
ARDUINO_D13 :
ARDUINO_3_3V :
ARDUINO_AREF :
ARDUINO_A0 :
ARDUINO_A1 :
ARDUINO_A2 :
ARDUINO_A3 :
ARDUINO_A4_SDA :
ARDUINO_A5_SCL :
ARDUINO_A6 :
ARDUINO_A7 :
ARDUINO_5V :
ARDUINO_RST1 :
ARDUINO_GND1 : (d15) et câble de (a15) à (-15G)
ARDUINO_VIN : (d16) et câble de (a16) à (+16G)
ARDUINO_D1_TX0 :
ARDUINO_D0_RX0 :
ARDUINO_RST2 : (h14) et câble de (i14) à (i12), ARDUINO_D2
ARDUINO_GND2 :
ARDUINO_D2 : (h12) et câble de (i12) à (i14), ARDUINO_RST2
ARDUINO_D3_PWM : (h11) et câble de (j11) à (j53), CAPTEUR_IR_1_SORTIE
ARDUINO_D4 : (h10) et câble de (i10) à (i51), BOUTON_1Broche_3
ARDUINO_D5_PWM :
ARDUINO_D6_PWM :
ARDUINO_D7 :
ARDUINO_D8 :
ARDUINO_D9_PWM :
ARDUINO_D10_PWM :
ARDUINO_D11_PWM :
ARDUINO_D12 :
Câblage pour le capteur infrarouge utiliser avec la télécommande, sur la
planche d'expérimentation :
CAPTEUR_IR_1_SORTIE broche 1 : (c53) et câble de (e53) à (f53), ARDUINO_D3_PWM
CAPTEUR_IR_1_GND broche 2 : (c54) et câble de (a54) à (-54G)
CAPTEUR_IR_1_VIN broche 3 : (c55)
Condensateur 104 broche 1 : (d54)
Condensateur 104 broche 2 : (d55)
Condensateur 100uF 10V- : (e54)
Condensateur 100uF 10V+ : (e55)
Résistance 100 Ohm 1 : (a55)
Résistance 100 Ohm 2 : (+55G)
Résistance 20 KOhm 1 : (b53)
Résistance 20 KOhm 2 : (b55)
Câblage pour le gros bouton sur la planche d'expérimentation :
BOUTON_1Broche_1 : (d49)
BOUTON_1Broche_2 : (d51)
BOUTON_1Broche_3 : (g51) et câble de (i51) à (i10), ARDUINO_D4
BOUTON_1Broche_4 : (g49) et câble de (j49) à (+49D)
Résistance 100 Ohm 1 : (a51)
Résistance 100 Ohm 2 : (-48D)
Câblage pour le Module d'alimentation MB102 sur la planche d'expérimentation :
MB102_USB :
MB102_DC_IN : Transformateur 110V à 9V ou batteries de 6V~12V
MB102_V_1MOINS : (-57G)
MB102_V_1PLUS : (+57G)
MB102_V_2MOINS : (-63G)
MB102_V_2PLUS : (+63G)
MB102_V_3PLUS : (+63D)
MB102_V_3MOINS : (-63D)
MB102_V_4PLUS : (+57D)
MB102_V_4MOINS : (-57D)
MB102_J1_5V : Cavalier
MB102_J1_OFF :
MB102_J1_3V3 :
MB102_J2_5V1 :
MB102_J2_5V2 :
MB102_J2_3V1 :
MB102_J2_3V2 :
MB102_J3_5V : Cavalier
MB102_J3_OFF :
MB102_J3_3V3 :
*/
//*****************************************************************************
//*****************************************************************************
// Inclusion des librairies utilisées.
//*****************************************************************************
/*
Il s'agit de la bibliothèque irRemote pour l'Arduino.
Pour télécharger depuis github :
https://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 :
https://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;
//*****************************************************************************
//*****************************************************************************
// 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 = 4;
// 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 = 2;
//*****************************************************************************
//*****************************************************************************
// 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 = 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 de la valeur retournée 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 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.
// 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.
while (Boucler != OUI)
{
GererBoutonMarcheArret ();
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 ();
GererBoutonMarcheArret ();
if (Boucler == OUI)
{
// C'est ici que vous ajoutez le code spécifique a votre montage.
}
}
//*****************************************************************************
//*****************************************************************************
//*****************************************************************************
//***************************** 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)
{
// Pour absorber les microcoupures des rebonds (minimum 5 ms).
delay (TempsRebonBouton);
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 peuvent avoir 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 : Activer/désactiver 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))
{
// Pour absorber les microcoupures des rebonds (minimum 5 ms).
delay (TempsRebonBouton);
Capteur_IR_1.resume (); // Récupérer la valeur suivante.
TelecommandeBoutonValeur = Capteur_IR_1_Results.value;
}
}
//*****************************************************************************