Comment utiliser un récepteur IR et une télécommande avec Arduino

Dans ce tutoriel, vous apprendrez à utiliser une télécommande IR et un récepteur avec l’Arduino. J’ai inclus des schémas de câblage et plusieurs exemples de codes pour vous aider à démarrer.

En suivant les instructions de ce tutoriel, vous pourrez utiliser pratiquement n’importe quelle télécommande infrarouge (comme celle de votre téléviseur) pour contrôler les éléments connectés à l’Arduino.

Dans les exemples de code ci-dessous, nous utiliserons la bibliothèque IRremote Arduino. Cette bibliothèque est assez facile à utiliser et prend en charge de nombreux protocoles de communication IR différents. Avec les deux premiers exemples, vous pouvez identifier le protocole IR de votre télécommande et déterminer quel code elle envoie lorsque vous appuyez sur une touche / un bouton. Ensuite, je vais vous montrer comment mapper le code reçu aux valeurs clés et les afficher dans le moniteur série ou sur un écran LCD. Enfin, nous examinerons le contrôle des sorties de l’Arduino avec une télécommande IR et un récepteur.

Si vous avez des questions, veuillez laisser un commentaire ci-dessous.

Composants matériels

  1. Télécommande IR et récepteur
  2. Arduino uno
  3. Fils
  4. Écran LCD 16 × 2 caractères
  5. Breadbord
  6. Potentiomètre 10 kΩ (type breadboard)
  7. Résistances
  8. LED
  9. Câble USB type A / B

Comment fonctionnent une télécommande infrarouge (IR) et un récepteur?

Une télécommande IR et un récepteur communiquent entre eux en émettant et en décodant un signal sous la forme d’un rayonnement IR pulsé.

ir signal transmission
Signal envoyé et détecté par l’émetteur IR (à gauche) et le récepteur (à droite) (Source: SB-Projects )

Le rayonnement infrarouge (IR), ou lumière infrarouge, est un type de rayonnement électromagnétique avec des longueurs d’onde allant de 700 nm à 1 mm. Parce que les humains ne peuvent voir la lumière qu’avec des longueurs d’onde d’environ 400 (violet) à 700 (rouge) nanomètres, le rayonnement infrarouge est invisible à l’œil humain.

1024px EM spectrumrevised
Spectre électromagnétique avec lumière visible en surbrillance (Source: Wikipedia )

La transmission infrarouge étant un protocole sans fil basé sur un type de lumière, elle nécessite une ligne de vue dégagée entre l’émetteur (la télécommande) et le récepteur. Cela signifie qu’il ne peut pas transmettre à travers les murs ou les plafonds, contrairement au WiFi ou au Bluetooth.

Bases de la communication IR

Malheureusement, la LED IR de votre télécommande n’est pas la seule source de rayonnement IR. Tout objet qui a une température rayonne également dans le spectre infrarouge. Ce phénomène est également utilisé par les caméras thermiques pour détecter la chaleur.

IR LED in remote
LED IR à l’extrémité d’une télécommande (Source: SparkFun )

Tout cet IR ambiant peut interférer avec la communication entre la télécommande et le récepteur. Alors, comment le récepteur détecte-t-il uniquement le signal IR provenant de la télécommande? La réponse est la modulation du signal.

Avec la modulation du signal, la source de lumière infrarouge à l’extrémité de la télécommande clignote avec une fréquence spécifique. Dans l’électronique grand public, cette fréquence porteuse est généralement d’environ 38 kHz.

Cette fréquence spécifique est utilisée pour la transmission IR commerciale car elle est de nature rare et, par conséquent, elle peut être distinguée de l’IR ambiant.

Le récepteur est construit de telle manière qu’il ne laisse passer que les IR qui arrivent à 38 kHz. Cela se fait à l’aide d’un filtre passe-bande et d’un amplificateur. Le signal binaire démodulé est ensuite envoyé au microcontrôleur (l’Arduino) où il est décodé.

Alors, à quoi ressemble réellement un signal IR?

necmodulation
Protocole NEC (Source: SB-Projects )

Dans l’image ci-dessus, l’axe vertical peut être vu comme la tension allant à la LED IR de la télécommande et l’axe horizontal est le temps. Ainsi, lorsque la LED est allumée, elle clignote (modulée) à 38 kHz et lorsqu’elle est éteinte, aucune tension n’est appliquée.

Ce qui est important, c’est la durée pendant laquelle la LED IR est maintenue haute ou basse (allumée ou éteinte). Dans le protocole NEC, qui est l’un des protocoles de transmission IR les plus courants, les bits («1» ou «0») sont représentés comme suit:

Chaque bit consiste en une rafale de porteuse de 38 kHz de 560 µs (environ 21 cycles) suivie d’une pause. Un «1» logique a un temps de transmission total de 2,25 ms, tandis qu’un «0» logique n’a que 1,125 ms.

La durée pendant laquelle le signal reste haut ou bas et le nombre de bits envoyés pour chaque commande est différent pour tous les protocoles IR. Dans le protocole NEC, le message total se compose généralement de quatre octets de 8 bits.

Types de récepteurs IR

Les récepteurs IR, parfois appelés capteurs IR ou diodes de détection IR, se présentent généralement sous deux facteurs de forme différents. Vous pouvez soit acheter les diodes séparément, soit les monter sur une petite carte de dérivation.

Ils fonctionnent exactement de la même manière, donc peu importe celui que vous utilisez. La seule différence est que la carte de dérivation contient souvent une petite LED qui clignote chaque fois que le récepteur détecte un signal qui peut être pratique pour le débogage.


Connexion d’un récepteur IR à l’Arduino

Il est très facile de connecter un récepteur IR à l’Arduino car il vous suffit de connecter trois fils. Le fil de sortie peut être connecté à l’une des broches numériques de l’Arduino. Dans ce cas, je l’ai connecté à la broche 2 pour les premiers exemples ci-dessous.

La broche d’alimentation est connectée à 5 V et la broche de masse du milieu à GND. Si vous utilisez un récepteur monté sur une carte de dérivation, vérifiez les étiquettes sur le PCB car l’ordre des broches peut être différent!

Télécommande IR et récepteur avec schéma de câblage Arduino tutoriel-circuit-schématique-1
La broche de sortie du récepteur IR est connectée à la broche 2

Les connexions sont également données dans le tableau ci-dessous

Connexions du récepteur IR

Récepteur IRArduino
OUT (gauche)Broche 2
GND (milieu)GND
Vcc (à droite)5 V

Installation de la bibliothèque IRremote Arduino

Pour ce didacticiel, nous utiliserons la bibliothèque IRremote populaire écrite par Rafi Khan et d’autres. Cette bibliothèque est assez facile à utiliser et prend en charge de nombreux types différents de télécommandes IR. Vous pouvez trouver le code source de cette bibliothèque ici sur GitHub .

Pour installer la bibliothèque, accédez à Outils> Gérer les bibliothèques (Ctrl + Maj + I sous Windows) dans l’ IDE Arduino . Le gestionnaire de bibliothèque ouvrira et mettra à jour la liste des bibliothèques installées.

Installation d'une bibliothèque Arduino Étape 1 Ouvrez Library Manager

Vous pouvez rechercher «IRremote» et rechercher la bibliothèque par shirriff et z3to. Sélectionnez la dernière version, puis cliquez sur Installer.

Installing the IRremote Arduino library

Déterminez le protocole IR utilisé par votre télécommande

Cette section est facultative

NEC est probablement le protocole de transmission IR le plus connu et le plus répandu car il est utilisé par la grande majorité des produits électroniques grand public de fabrication japonaise. Cependant, de nombreux autres types de protocoles existent. Il peut être utile de savoir quel type de protocole IR votre télécommande utilise si vous souhaitez travailler sur des projets plus avancés. Ou tu pourrais juste être curieux

La bibliothèque IRremote prend actuellement en charge 18 protocoles IR différents:

  • Aiwa
  • BoseWave
  • Denon
  • Plat
  • JVC
  • Lego
  • LG
  • MagiQuest
  • Mitsubishi
  • NEC
  • Panasonic
  • Philips RC5
  • Philips RC6,
  • Samsung
  • Sanyo
  • Pointu
  • Sony
  • Whynter

Bien que la bibliothèque soit assez ancienne, de nouveaux protocoles sont toujours ajoutés (voir le GitHub ).

Avec le code ci-dessous, vous pouvez identifier le protocole utilisé par votre télécommande. Vous pouvez également essayer d’autres télécommandes que vous avez chez vous et voir si elles peuvent détecter le protocole.

Recherche de protocole à distance IR

#include <IRremote.h> // include the IRremote library
#define RECEIVER_PIN 2 // define the IR receiver pin
IRrecv receiver(RECEIVER_PIN); // create a receiver object of the IRrecv class
decode_results results; // create a results object of the decode_results class
unsigned long key_value = 0; // variable to store the pressed key value
void setup() {
Serial.begin(9600); // begin serial communication with a baud rate of 9600
receiver.enableIRIn(); // enable the receiver
receiver.blink13(true); // enable blinking of the built-in LED when an IR signal is received
}
void loop() {
if (receiver.decode(&results)) {
if (results.value == 0XFFFFFFFF) {
results.value = key_value;
}
Serial.println(results.value, HEX);
switch (results.decode_type) {
case NEC:
Serial.println(“NEC”);
break;
case SONY:
Serial.println(“SONY”);
break;
case RC5:
Serial.println(“RC5”);
break;
case RC6:
Serial.println(“RC6”);
break;
case DISH:
Serial.println(“DISH”);
break;
case SHARP:
Serial.println(“SHARP”);
break;
case JVC:
Serial.println(“JVC”);
break;
case SANYO:
Serial.println(“SANYO”);
break;
case MITSUBISHI:
Serial.println(“MITSUBISHI”);
break;
case SAMSUNG:
Serial.println(“SAMSUNG”);
break;
case LG:
Serial.println(“LG”);
break ;
case WHYNTER:
Serial.println(“WHYNTER”);
break;
case AIWA_RC_T501:
Serial.println(“AIWA_RC_T501”);
break;
case PANASONIC:
Serial.println(“PANASONIC”);
break;
case DENON:
Serial.println(“DENON”);
break;
case BOSEWAVE:
Serial.println(“BOSEWAVE”);
break;
case LEGO_PF:
Serial.println(“LEGO_PF”);
break;
case MAGIQUEST:
Serial.println(“MAGIQUEST”);
break;
default:
case UNKNOWN:
Serial.println(“UNKNOWN”);
break ;
}
key_value = results.value;
receiver.resume();
}
}

J’ai expérimenté certaines télécommandes dans ma maison et j’ai pu détecter les protocoles suivants:

Serial Monitor output IR protocols
Protocoles IR détectés à partir de plusieurs télécommandes

Recherche des codes clés de votre télécommande

Comme il existe de nombreux types de télécommandes sur le marché (nombre de touches et valeurs différentes imprimées sur les touches), nous devons déterminer quel signal reçu correspond à quelle clé.

La bibliothèque IRremote lira le signal et sortira un code spécifique sous la forme d’un nombre hexadécimal en fonction de la touche enfoncée.

En imprimant cette sortie dans Serial Monitor, nous pouvons créer une table de conversion.

Vous pouvez copier le code ci-dessous en cliquant dans le coin supérieur droit du champ de code.

/* Finding the key codes for your remote. More info: https://www.makerguides.com */
#include <IRremote.h> // include the IRremote library
#define RECEIVER_PIN 2 // define the IR receiver pin
IRrecv receiver(RECEIVER_PIN); // create a receiver object of the IRrecv class
decode_results results; // create a results object of the decode_results class
void setup() {
Serial.begin(9600); // begin serial communication with a baud rate of 9600
receiver.enableIRIn(); // enable the receiver
receiver.blink13(true); // enable blinking of the built-in LED when an IR signal is received
}
void loop() {
if (receiver.decode(&results)) { // decode the received signal and store it in results
Serial.println(results.value, HEX); // print the values in the Serial Monitor
receiver.resume(); // reset the receiver for the next code
}
}

Après avoir téléchargé le code, ouvrez Serial Monitor (Ctrl + Maj + M sous Windows). Appuyez maintenant sur chaque touche de la télécommande et enregistrez la valeur hexadécimale correspondante que vous voyez dans Serial Monitor.

Serial monitor output key codes IR remote receiver Arduino tutorial
Sortie moniteur série

Notez que vous verrez le code FFFFFFFF lorsque vous appuyez sur une touche en continu. Il s’agit du code de répétition envoyé par la télécommande.

Pour ma télécommande, j’ai la table de conversion suivante:

remote
CléCode
PUISSANCE0xFD00FF
VOL +0xFD807F
FUNC / STOP0xFD40BF
│◄◄0xFD20DF
►││0xFDA05F
►►│0xFD609F
0xFD10EF
VOL-0xFD906F
0xFD50AF
00xFD30CF
EQ0xFDB04F
ST / REPT0xFD708F
10xFD08F7
20xFD8877
30xFD48B7
40xFD28D7
50xFDA857
60xFD6897
70xFD18E7
80xFD9867
90xFD58A7

Comme vous pouvez le voir dans le tableau, les valeurs hexadécimales sont indiquées par le préfixe «0x».

Notez que votre table sera probablement différente! Vous devrez créer le vôtre pour l’utiliser dans le reste des exemples de code ci-dessous.


Exemple de code Arduino à distance et récepteur IR – Imprimer les valeurs clés dans le moniteur série

Maintenant que nous savons quel code (valeur hexadécimale) correspond à quelle pression de touche, nous pouvons modifier le code pour imprimer la valeur de la touche enfoncée dans le moniteur série.

Pour cela, nous utiliserons une structure de contrôle de boîtier de commutation . Cela nous permet d’exécuter un morceau de code différent en fonction de la touche enfoncée.

L’exemple de code ci-dessous imprime la valeur de clé dans le moniteur série au lieu de la valeur hexadécimale comme nous l’avons fait dans l’exemple précédent. Après avoir téléchargé le code, vous pouvez lire l’explication ci-dessous pour savoir comment le code fonctionne.

/* IR remote and receiver Arduino example code. Print key values in the Serial Monitor. More info: https://www.makerguides.com */
#include <IRremote.h> // include the IRremote library
#define RECEIVER_PIN 2 // define the IR receiver pin
IRrecv receiver(RECEIVER_PIN); // create a receiver object of the IRrecv class
decode_results results; // create a results object of the decode_results class
unsigned long key_value = 0; // variable to store the key value
void setup() {
Serial.begin(9600); // begin serial communication with a baud rate of 9600
receiver.enableIRIn(); // enable the receiver
receiver.blink13(true); // enable blinking of the built-in LED when an IR signal is received
}
void loop() {
if (receiver.decode(&results)) { // decode the received signal and store it in results
if (results.value == 0xFFFFFFFF) { // if the value is equal to 0xFFFFFFFF
results.value = key_value; // set the value to the key value
}
switch (results.value) { // compare the value to the following cases
case 0xFD00FF: // if the value is equal to 0xFD00FF
Serial.println(“POWER”); // print “POWER” in the Serial Monitor
break;
case 0xFD807F:
Serial.println(“VOL+”);
break;
case 0xFD40BF:
Serial.println(“FUNC/STOP”);
break;
case 0xFD20DF:
Serial.println(“|<<“);
break;
case 0xFDA05F:
Serial.println(“>||”);
break ;
case 0xFD609F:
Serial.println(“>>|”);
break ;
case 0xFD10EF:
Serial.println(“DOWN”);
break ;
case 0xFD906F:
Serial.println(“VOL-“);
break ;
case 0xFD50AF:
Serial.println(“UP”);
break ;
case 0xFD30CF:
Serial.println(“0”);
break ;
case 0xFDB04F:
Serial.println(“EQ”);
break ;
case 0xFD708F:
Serial.println(“ST/REPT”);
break ;
case 0xFD08F7:
Serial.println(“1”);
break ;
case 0xFD8877:
Serial.println(“2”);
break ;
case 0xFD48B7:
Serial.println(“3”);
break ;
case 0xFD28D7:
Serial.println(“4”);
break ;
case 0xFDA857:
En série. println ( “5” ) ;
pause ;
cas 0xFD6897 :
En série. println ( “6” ) ;
pause ;
cas 0xFD18E7 :
En série. println ( “7” ) ;
pause ;
cas 0xFD9867 :
En série. println ( “8” ) ;
pause ;
cas 0xFD58A7 :
En série. println ( “9” ) ;
pause ;
}
key_value = résultats. valeur ; // stocke la valeur sous la forme key_value
destinataire. reprendre () ; // réinitialise le récepteur pour le code suivant
}
}
Serial Monitor output key values IR remote receiver Arduino tutorial
Sortie moniteur série

Si votre télécommande envoie des codes de clé différents de ceux indiqués dans le tableau ci-dessus, remplacez simplement la valeur hexadécimale et la valeur de clé dans chacune des lignes de l’instruction switch case qui ressemblent à ceci:

case 0xFD00FF : // si la valeur est égale à 0xFD00FF
En série. println ( “PUISSANCE” ) ; // imprime “POWER” dans le moniteur série

Ces lignes se traduisent par: lorsque results.value est égal à 0xFD00FF, affiche «POWER» dans le moniteur série. Notez à nouveau que vous devez ajouter «0x» avant les valeurs que vous avez vues dans Serial Monitor dans l’exemple précédent.

Pour éviter les doubles clics indésirables, vous pouvez ajouter un court délai (par exemple 500 ms) à la fin de la boucle.

Comment fonctionne le code

La première étape consiste à inclure la bibliothèque IRremote. Si vous obtenez le message d’erreur «IRremote.h: No such file or directory», vous avez probablement oublié d’  installer la bibliothèque .

IRremote error
#include <IRremote.h> // inclut la bibliothèque IRremote

Ensuite, j’ai défini à quelle broche Arduino la sortie du récepteur est connectée. L’instruction  #define est utilisée pour donner un nom à une valeur constante. Le compilateur remplacera toutes les références à cette constante par la valeur définie lors de la compilation du programme. Donc, partout où vous le mentionnez  RECEIVER_PIN, le compilateur le remplacera par la valeur 2 lorsque le programme sera compilé.

#define RECEIVER_PIN 2 // définir la broche du récepteur IR

Après cela, nous devons créer un objet de la  IRrecv classe et le lier à la broche de sortie du récepteur (broche 2). Dans ce cas, j’ai appelé l’objet «récepteur» mais vous pouvez également utiliser d’autres noms. Cet objet s’occupe du protocole IR et du traitement du signal du récepteur.

Récepteur IRrecv ( RECEIVER_PIN ) ; // crée un objet récepteur de la classe IRrecv

Ensuite, un objet appelé  results de la  decode_results classe est créé. Cet objet stocke les valeurs décodées de l’objet récepteur. Nous accèderons à ces valeurs dans le reste du code.

résultats decode_results; // crée un objet de résultats de la classe decode_results

Dans la dernière ligne avant la section de configuration, nous créons une variable pour stocker la valeur de clé.

unsigned long key_value = 0; // variable pour stocker la valeur de la clé

Dans la section de configuration du code, nous définissons d’abord le débit de données pour la communication série en bits par seconde (débit en bauds) à 9600. Assurez-vous que le moniteur série est également réglé sur le même débit en bauds.

Ensuite, nous initialisons le récepteur avec la fonction  enableIRIn(). La ligne suivante permet le clignotement de la LED intégrée de l’Arduino. La  blink13() fonction fera clignoter la LED connectée à la broche numérique 13 chaque fois que le récepteur reçoit un signal de la télécommande. Cela peut être très pratique pour le débogage.

void setup () {
En série. commencer ( 9600 ) ; // commence la communication série avec une vitesse de transmission de 9600
destinataire. enableIRIn () ; // activer le récepteur
destinataire. blink13 ( vrai ) ; // active le clignotement de la LED intégrée lorsqu’un signal IR est reçu
}

La section de boucle du code commence par une  instruction if  vérifie une condition et exécute l’instruction en cours ou l’ensemble d’instructions si la condition est «vraie». Lorsqu’un code est reçu, la condition  receiver.decode(&results) retourne true et le reste du code est exécuté.

Comme je l’ai déjà mentionné, lorsque vous appuyez continuellement sur une touche, nous commençons à recevoir 0xFFFFFFFF de la télécommande. Cela signifie une répétition de la clé précédente. Parce que je veux continuer à imprimer la valeur de la touche enfoncée, j’ai ajouté les lignes suivantes au code:

if ( results. value == 0xFFFFFFFF ) { // si la valeur est égale à 0xFFFFFFFF
résultats. valeur = valeur_clé; // définit la valeur sur la valeur clé
}

et

key_value = résultats. valeur ; // stocke la valeur sous la forme key_value

à la fin de la boucle. Lorsque le code de répétition 0xFFFFFFFF est reçu, nous le remplaçons par la valeur de clé précédente que nous avons stockée comme  key_value à la ligne 86.

Après cela, l’instruction de cas de commutation est utilisée pour vérifier le code reçu par rapport aux différents codes de clé que nous avons enregistrés dans l’exemple précédent. Les valeurs de clé correspondantes sont ensuite imprimées dans le moniteur série sur une nouvelle ligne avec la fonction  Serial.println().

À la fin de la section de boucle, la fonction  resume() est appelée, ce qui réinitialise le récepteur et le prépare à recevoir le code suivant.

destinataire. reprendre () ; // réinitialise le récepteur pour le code suivant

Télécommande IR et récepteur avec exemple Arduino et LCD

L’exemple suivant peut être utilisé pour imprimer les valeurs des touches enfoncées sur un  écran LCD à caractères . J’ai écrit un tutoriel détaillé sur l’utilisation des écrans LCD de caractères que vous pouvez trouver ici:

  • Comment utiliser un écran LCD 16 × 2 caractères avec Arduino

Si vous préférez utiliser un écran LCD I2C qui nécessite moins de connexions, consultez le tutoriel ci-dessous:

  • Comment contrôler un écran LCD I2C avec Arduino

Pour cet exemple, j’ai connecté la sortie du récepteur IR à la broche numérique 8 au lieu de 2. Les connexions de l’écran LCD à caractères sont indiquées dans le schéma de câblage ci-dessous. Notez que vous avez également besoin d’un  potentiomètre  de 10 kΩ pour régler le contraste de l’écran et d’une  résistance  de 220 Ω pour contrôler la luminosité du rétroéclairage.

Télécommande IR et récepteur avec Arduino et écran LCD à caractères exemple-schéma-câblage-schématique-circuit-didacticiel-1
Télécommande IR et récepteur avec Arduino Uno et schéma de câblage LCD 16 × 2 caractères

Les connexions sont également données dans le tableau ci-dessous. La broche la plus à gauche de l’écran LCD est la broche 1 (GND).

Connexions du récepteur LCD et IR

ÉpinglerConnexion
Broche LCD 1 (GND)Arduino GND
Broche LCD 2 (VCC)Arduino 5 V
Broche LCD 3 (VO)Potentiomètre à broche centrale
Potentiomètre broche gaucheArduino 5 V
Potentiomètre à broche droiteArduino GND
Broche LCD 4 (RS)Broche Arduino 2
Broche LCD 5 (RW)Arduino GND
Broche LCD 6 (E)Broche Arduino 3
Broche LCD 11 (DB4)Broche Arduino 4
Broche LCD 12 (DB5)Broche Arduino 5
Broche LCD 13 (DB6)Broche Arduino 6
Broche LCD 14 (DB7)Broche Arduino 7
Broche LCD 15 (LED-anode)Arduino 5 V via résistance 220Ω
Broche LCD 16 (cathode LED)Arduino GND
Récepteur IR OUT (gauche)Broche Arduino 8
Récepteur IR GND (milieu)Arduino GND
Récepteur IR Vcc (à droite)Arduino 5 V

Si vous rencontrez des problèmes avec l’écran LCD, consultez  ce didacticiel  pour plus de détails.

Avec l’exemple de code ci-dessous, vous pouvez imprimer la valeur de la touche enfoncée sur l’écran LCD. J’ai programmé le bouton d’alimentation pour qu’il efface l’affichage.

Encore une fois, si votre télécommande envoie des codes différents, remplacez simplement les valeurs hexadécimales et les valeurs de clé correspondantes dans l’instruction switch case.

Télécommande IR et récepteur avec Arduino et exemple de code d’affichage LCD

Vous pouvez copier le code en cliquant sur le bouton dans le coin supérieur droit du champ de code.

/ * Télécommande IR et récepteur avec Arduino et exemple de code LCD à caractères. Plus d’infos: https://www.makerguides.com/ * /
#include <IRremote.h> // inclut la bibliothèque IRremote
#include <LiquidCrystal.h> // inclut la bibliothèque LiquidCrystal
LiquidCrystal lcd = LiquidCrystal ( 2, 3, 4, 5, 6, 7 ) ; // créer un objet LCD avec des paramètres pin (RS, E, D4, D5, D6, D7)
#define RECEIVER_PIN 8 // définir la broche du récepteur IR
Récepteur IRrecv ( RECEIVER_PIN ) ; // crée un objet récepteur de la classe IRrecv
résultats decode_results; // crée un objet de résultats de la classe decode_results
unsigned long key_value = 0; // variable pour stocker la valeur de la clé
void setup () {
lcd. commencer ( 16, 2 ) ; // activer LCD avec 16 colonnes et 2 lignes
destinataire. enableIRIn () ; // activer le récepteur
destinataire. blink13 ( vrai ) ; // active le clignotement de la LED intégrée lorsqu’un signal IR est reçu
}
boucle void () {
if ( receiver. decode ( & results )) { // décode le signal reçu et le stocke dans les résultats
if ( results. value == 0xFFFFFFFF ) { // si la valeur est égale à 0xFFFFFFFF
résultats. valeur = valeur_clé; // définit la valeur sur la valeur clé
}
switch ( results. value ) { // comparer la valeur aux cas suivants
case 0xFD00FF : // si la valeur est égale à 0xFD00FF
lcd. clear () ; // efface l’affichage
pause ;
cas 0xFD807F :
lcd. imprimer ( “VOL +” ) ;
pause ;
cas 0xFD40BF :
lcd. impression ( “FUNC / STOP” ) ;
pause ;
cas 0xFD20DF :
lcd. imprimer ( “| <<” ) ;
pause ;
cas 0xFDA05F :
lcd. imprimer ( “> ||” ) ;
pause ;
cas 0xFD609F :
lcd. imprimer ( “>> |” ) ;
pause ;
cas 0xFD10EF :
lcd. print ( “DOWN” ) ;
pause ;
cas 0xFD906F :
lcd. imprimer ( “VOL-” ) ;
pause ;
cas 0xFD50AF :
lcd. imprimer ( “UP” ) ;
pause ;
cas 0xFD30CF :
lcd. imprimer ( “0” ) ;
pause ;
cas 0xFDB04F :
lcd. impression ( “EQ” ) ;
pause ;
cas 0xFD708F :
lcd. imprimer ( “ST / REPT” ) ;
pause ;
cas 0xFD08F7 :
lcd. imprimer ( “1” ) ;
pause ;
cas 0xFD8877 :
lcd. imprimer ( “2” ) ;
pause ;
cas 0xFD48B7 :
lcd. imprimer ( “3” ) ;
pause ;
cas 0xFD28D7 :
lcd. imprimer ( “4” ) ;
pause ;
cas 0xFDA857 :
lcd. imprimer ( “5” ) ;
pause ;
cas 0xFD6897 :
lcd. impression ( “6” ) ;
pause ;
cas 0xFD18E7 :
lcd. imprimer ( “7” ) ;
pause ;
cas 0xFD9867 :
lcd. imprimer ( “8” ) ;
pause ;
cas 0xFD58A7 :
lcd. imprimer ( “9” ) ;
pause ;
}
key_value = résultats. valeur ; // stocke la valeur sous la forme key_value
destinataire. reprendre () ; // réinitialise le récepteur pour le code suivant
}
}

Vous devriez voir la sortie suivante sur l’écran LCD si vous appuyez sur la touche VOL +. Notez que vous devrez peut-être ajuster le potentiomètre pour augmenter le contraste de l’écran.

lcd output
Sortie d’affichage LCD

LED de contrôle (sorties Arduino) avec télécommande IR et récepteur

Bien qu’il soit amusant de voir les valeurs clés dans le moniteur série ou sur un écran LCD, vous voudrez probablement utiliser la télécommande pour quelque chose de plus utile, c’est-à-dire de contrôler quelque chose. Dans l’exemple suivant, je vais vous montrer comment activer et désactiver les LED avec la télécommande. Vous pouvez également utiliser ce type de code pour contrôler les relais, les lumières et les moteurs.

Le code ressemble à peu près au même que les exemples précédents mais j’ai ajouté des fonctions supplémentaires pour contrôler les LED.

Vous devrez créer le circuit suivant pour contrôler les LED:

comment-contrôler-LED-avec-infrarouge-IR-télécommande-et-récepteur-Arduino-câblage-schéma-schématique-circuit-tutoriel-1
Schéma de câblage pour contrôler les LED avec télécommande IR, récepteur et Arduino

Les LED sont connectées aux broches 2 à 5 de l’Arduino et la sortie du récepteur IR à la broche 6. J’ai utilisé des résistances de 470 Ω pour limiter le courant traversant les LED. Le courant de fonctionnement habituel des LED de 3 et 5 mm est d’environ 20 mA. Vous pouvez déterminer la valeur de résistance dont vous avez besoin avec une calculatrice en ligne comme  celle-ci . J’aime acheter ces  assortiments de résistances sur Amazon,  donc j’ai toujours la bonne valeur sous la main.

/ * Exemple de code pour contrôler les LED avec une télécommande IR et un récepteur avec Arduino. Plus d’infos: https://www.makerguides.com/ * /
#include <IRremote.h>
#define RECEIVER_PIN 6 // définir les connexions
#define RED_LED_PIN 2
#define YELLOW_LED_PIN 3
#define GREEN_LED_PIN 4
#define BLUE_LED_PIN 5
Récepteur IRrecv ( RECEIVER_PIN ) ; // crée un objet récepteur de la classe IRrecv
résultats decode_results; // crée un objet de résultats de la classe decode_results
unsigned long key_value = 0;
void setup () {
En série. commencer ( 9600 ) ; // commence la communication série à un débit de 9600 bauds
destinataire. enableIRIn () ; // activer le récepteur
destinataire. blink13 ( vrai ) ; // active le clignotement de la LED intégrée lorsqu’un signal IR est reçu
pinMode ( RED_LED_PIN, OUTPUT ) ; // définit les broches LED comme sortie
pinMode ( YELLOW_LED_PIN, OUTPUT ) ;
pinMode ( GREEN_LED_PIN, SORTIE ) ;
pinMode ( BLUE_LED_PIN, OUTPUT ) ;
digitalWrite ( RED_LED_PIN, LOW ) ; // éteint toutes les LED
digitalWrite ( YELLOW_LED_PIN, LOW ) ;
digitalWrite ( GREEN_LED_PIN, LOW ) ;
digitalWrite ( BLUE_LED_PIN, LOW ) ;
}
boucle void () {
if ( receiver. decode ( & results )) {
if ( résultats. valeur == 0xFFFFFFFF ) {
résultats. valeur = valeur_clé;
}
switch ( résultats. valeur ) {
cas 0xFD00FF :
En série. println ( “PUISSANCE” ) ;
pause ;
cas 0xFD807F :
En série. println ( “VOL +” ) ;
pause ;
cas 0xFD40BF :
En série. println ( “FUNC / STOP” ) ;
pause ;
cas 0xFD20DF :
En série. println ( “| <<” ) ;
pause ;
cas 0xFDA05F :
En série. println ( “> ||” ) ;
pause ;
cas 0xFD609F :
En série. println ( “>> |” ) ;
pause ;
cas 0xFD10EF :
En série. println ( “DOWN” ) ;
pause ;
cas 0xFD906F :
En série. println ( “VOL-” ) ;
pause ;
cas 0xFD50AF :
En série. println ( “UP” ) ;
pause ;
cas 0xFD30CF :
En série. println ( “0” ) ;
pause ;
cas 0xFDB04F :
En série. println ( “EQ” ) ;
pause ;
cas 0xFD708F :
En série. println ( “ST / REPT” ) ;
pause ;
cas 0xFD08F7 :
En série. println ( “1” ) ;
toggleLED ( RED_LED_PIN ) ; // exécuter la fonction LED à bascule avec la broche LED rouge comme entrée
pause ;
cas 0xFD8877 :
En série. println ( “2” ) ;
toggleLED ( YELLOW_LED_PIN ) ;
pause ;
cas 0xFD48B7 :
En série. println ( “3” ) ;
toggleLED ( GREEN_LED_PIN ) ;;
pause ;
cas 0xFD28D7 :
En série. println ( “4” ) ;
toggleLED ( BLUE_LED_PIN ) ;
pause ;
cas 0xFDA857 :
En série. println ( “5” ) ;
pause ;
cas 0xFD6897 :
En série. println ( “6” ) ;
pause ;
cas 0xFD18E7 :
En série. println ( “7” ) ;
pause ;
cas 0xFD9867 :
En série. println ( “8” ) ;
pause ;
cas 0xFD58A7 :
En série. println ( “9” ) ;
pause ;
}
key_value = résultats. valeur ;
destinataire. reprendre () ;
}
}
void toggleLED ( int pin ) { // fonction pour allumer et éteindre la LED
if ( digitalRead ( pin ) == HIGH ) { // si la LED est allumée
digitalWrite ( broche, LOW ) ; // éteignez-le
}
else { // else
digitalWrite ( broche, HIGH ) ; // allume ça
}
}

Si vous appuyez sur les boutons 1 à 4 de la télécommande, vous pouvez allumer et éteindre les voyants correspondants.


Code

Ci-dessous, je vais rapidement souligner les différences de code par rapport aux exemples précédents.

Dans la première partie du code, j’ai défini les broches Arduino auxquelles les LED et le récepteur IR sont connectés. Dans la section de configuration, j’ai défini les broches LED comme sortie et éteint toutes les LED avec  digitalWrite(pin, value).

pinMode ( RED_LED_PIN, OUTPUT ) ; // définit les broches LED comme sortie
pinMode ( YELLOW_LED_PIN, OUTPUT ) ;
pinMode ( GREEN_LED_PIN, SORTIE ) ;
pinMode ( BLUE_LED_PIN, OUTPUT ) ;
digitalWrite ( RED_LED_PIN, LOW ) ; // éteint toutes les LED
digitalWrite ( YELLOW_LED_PIN, LOW ) ;
digitalWrite ( GREEN_LED_PIN, LOW ) ;
digitalWrite ( BLUE_LED_PIN, LOW ) ;

La section de boucle du code est essentiellement la même qu’avant, mais maintenant, au lieu de simplement imprimer les valeurs de clé dans le moniteur série, la  toggleLED(pin) fonction est appelée si vous appuyez sur les touches 0 à 4.

Cette fonction prend la broche LED spécifique comme entrée et active ou désactive la LED si vous appuyez sur la touche. Notez que si vous appuyez continuellement sur une touche, la LED continuera à s’allumer et à s’éteindre.

void toggleLED ( int pin ) { // fonction pour allumer et éteindre la LED
if ( digitalRead ( pin ) == HIGH ) { // si la LED est allumée
digitalWrite ( broche, LOW ) ; // éteignez-le
}
else { // else
digitalWrite ( broche, HIGH ) ; // allume ça
}

Puisque vous ne contrôlez que les 4 broches de sortie de l’Arduino, vous pouvez également utiliser cette fonction pour activer et désactiver les relais.

Maintenant, si vous écrivez simplement une fonction différente et que vous l’appelez lorsqu’un bouton spécifique est enfoncé, vous pouvez contrôler tout ce que vous voulez. J’aimerais savoir ce que vous contrôlez avec votre télécommande et ce serait formidable si vous pouviez partager avec les autres lecteurs comment vous l’avez implémentée.


Conclusion

Dans ce tutoriel, je vous ai montré comment utiliser une télécommande IR et un récepteur avec Arduino. Nous avons examiné plusieurs exemples de codes différents pour déterminer le protocole IR et identifier les codes de clé IR de votre télécommande. Nous avons ensuite examiné l’affichage des valeurs des touches / boutons dans le moniteur série et sur un écran LCD 16 × 2 caractères. Enfin, je vous ai montré comment contrôler les sorties de l’Arduino avec la télécommande pour activer et désactiver certaines LED. Il existe de nombreuses autres applications pour les récepteurs et télécommandes infrarouges, alors assurez-vous de laisser quelques suggestions dans les commentaires.

J’espère que vous avez trouvé cet article utile et instructif. Si c’est le cas,  partagez-le avec un ami  qui aime aussi l’électronique et la fabrication d’objets!

J’aimerais savoir quels projets vous prévoyez de construire (ou avez déjà construits) avec une télécommande IR et un récepteur. Si vous avez des questions, des suggestions ou si vous pensez que des éléments manquent dans ce tutoriel,  veuillez laisser un commentaire ci-dessous .

 

7 Comments

  1. Bonjour, Je cherche le moyen de communiquer avec un IR sur un appareil Cordialement Jean François
  2. merci pour vos expliquations !. malgrés tout j'ai un problème i :quand je veux mixer la lecture IR avec une lecture analogique (capteur de température) ,les actions se mélangent .et je nai plus rien de valable ?.
  3. Merci beaucoup pour l'exactitude de vos information et le temps passé. Grâce à vos explications et schémas j'ai réussi mon mini projet Peut être précisez de ne pas prendre la dernière version de bibliothèque IRremote sinon ça ne fonctionnera pas . J'ai réussi avec la version 2.7.0 maximum

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Rejoindre la liste d'attente Nous vous informerons lorsque le produit arrivera en stock. Veuillez laisser votre adresse E-mail et la quantité voulue.

Main Menu

بحاجة الى مساعدة ؟