Dans ce tutoriel, vous allez apprendre à utiliser une IR télécommande 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 IR (comme celle de votre TV) pour contrôler des appareils connectés à l’Arduino.
Dans les exemples de code ci-dessous, nous allons utiliser la bibliothèque IRremote Arduino . Cette bibliothèque est assez simple à utiliser et prend en charge de nombreux protocoles de communication IR différents. Avec les deux premiers exemples, vous pourrez identifier le protocole IR de votre télécommande et déterminer quel code elle envoie lorsque vous appuyez sur une touche/bouton. Ensuite, je vous montrerai comment associer le code reçu aux valeurs des touches et afficher ces informations dans le Serial Monitor ou sur un écran LCD. Enfin, nous verrons comment contrôler les sorties de l’Arduino avec une télécommande et un récepteur IR.
Matériel nécessaire
Composants matériels
| IR remote and receiver | × 1 | Amazon |
| Arduino Uno | × 1 | Amazon |
| Jumper wires | × 15 | Amazon |
| 16×2 character LCD display | × 1 | Amazon |
| Breadboard | × 1 | Amazon |
| 10 kΩ potentiometer (type breadboard) | × 1 | Amazon |
| Resistor assortment | × 1 | Amazon |
| LED assortment | × 1 | Amazon |
| USB cable type A/B | × 1 | Amazon |
Logiciel
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Comment fonctionne une télécommande et un récepteur infrarouge (IR) ?
Une télécommande IR et un récepteur communiquent entre eux en transmettant et en décodant un signal sous forme de rayonnement IR pulsé.
Le rayonnement infrarouge (IR), ou lumière infrarouge, est un type de rayonnement électromagnétique dont la longueur d’onde varie de 700 nm à 1 mm. Comme l’œil humain ne perçoit que la lumière dont la longueur d’onde est comprise entre environ 400 (violet) et 700 (rouge) nanomètres, le rayonnement IR est invisible pour nous.
Comme la transmission IR est un protocole sans fil basé sur la lumière, il faut une ligne de visée dégagée entre l’émetteur (la télécommande) et le récepteur. Cela signifie qu’il ne peut pas traverser 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 ayant une température émet également dans le spectre infrarouge. Ce phénomène est d’ailleurs utilisé par les caméras thermiques pour détecter la chaleur.
Toute cette IR ambiante 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 : la modulation du signal.
Avec la modulation du signal, la source de lumière IR à l’extrémité de la télécommande clignote à 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 rare dans la nature et peut donc être distinguée de l’IR ambiante.
Le récepteur est conçu de façon à ne laisser passer que l’IR arrivant à 38 kHz. Cela est réalisé grâce à un filtre passe-bande et un amplificateur. Le signal binaire démodulé est ensuite envoyé au microcontrôleur (l’Arduino) où il est décodé.
Protocole de signal IR
À quoi ressemble réellement un signal IR ?
Sur l’image ci-dessus, l’axe vertical représente la tension appliquée à la LED IR de la télécommande et l’axe horizontal le temps. Donc, lorsque la LED IR est allumée, elle clignote (est 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 reste à l’état haut ou bas (allumée ou éteinte). Dans le protocole NEC, l’un des plus populaires, les bits (« 1 » ou « 0 ») sont représentés comme suit :
Chaque bit consiste en une impulsion de 560 µs à 38 kHz (environ 21 cycles) suivie d’une pause. Un « 1 » logique a une durée totale de transmission de 2,25 ms, tandis qu’un « 0 » logique ne dure 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 varient selon les protocoles IR. Dans le protocole NEC, le message complet 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, existent généralement sous deux formats. Vous pouvez acheter les diodes seules ou montées sur une petite carte breakout.
Ils fonctionnent exactement de la même manière, donc peu importe lequel vous utilisez. La seule différence est que la carte breakout contient souvent une petite LED qui clignote à chaque fois que le récepteur détecte un signal, ce qui peut être pratique pour le débogage.
Connexion d’un récepteur IR à l’Arduino
Il est très facile de brancher un récepteur IR à l’Arduino, car il suffit de connecter trois fils. Le fil de sortie peut être relié à n’importe quelle broche numérique 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 au 5 V et la broche centrale de masse à GND. Si vous utilisez un récepteur monté sur une carte breakout, vérifiez bien les indications sur le PCB car l’ordre des broches peut être différent !
Les connexions sont également indiquées dans le tableau ci-dessous
Connexions du récepteur IR
| Récepteur IR | Arduino |
|---|---|
| OUT (gauche) | Broche 2 |
| GND (milieu) | GND (-) |
| Vcc (droite) | 5 V (+) |
Installation de la bibliothèque IRremote pour Arduino
Pour ce tutoriel, nous allons utiliser la célèbre bibliothèque IRremote. Cette bibliothèque est assez simple à utiliser et prend en charge de nombreux types de télécommandes IR.
Pour installer la bibliothèque, allez dans Tools > Manage Libraries (Ctrl + Shift + I sous Windows) dans le Arduino IDE. Le Library Manager s’ouvrira et mettra à jour la liste des bibliothèques installées.
Vous pouvez rechercher ‘IRremote’ et chercher la bibliothèque de shirriff et z3to. Sélectionnez la dernière version puis cliquez sur Install.
Déterminer le protocole IR utilisé par votre télécommande
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 appareils électroniques grand public fabriqués au Japon. Cependant, il existe de nombreux autres types de protocoles. Il peut être utile de connaître le type de protocole IR utilisé par votre télécommande si vous souhaitez réaliser des projets plus avancés. Ou vous êtes peut-être simplement curieux.
En septembre 2023, la bibliothèque IRremote prend en charge les protocoles IR suivants :
- PulseWidth
- PulseDistance
- Apple
- Denon
- JVC
- LG
- LG2
- NEC
- NEC2
- Onkyo
- Panasonic
- Kaseikyo
- Kaseikyo Denon
- Kaseikyo Sharp
- Kaseikyo JVC
- Kaseikyo Mitsubishi
- RC5
- RC6
- Samsung
- Samsung48
- SamsungLG
- Sharp
- Sony
- Bang&Olufsen
- BoseWave
- Lego
- MagiQuest
- Whynter
- FAST
Avec le petit code ci-dessous, vous pouvez identifier le protocole utilisé par votre télécommande. Vous pouvez aussi essayer d’autres télécommandes que vous avez chez vous pour voir si le protocole est détecté.
Détecteur de protocole de télécommande IR
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 2
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
IrReceiver.printIRResultShort(&Serial);
IrReceiver.resume();
}
}
J’ai testé trois télécommandes chez moi : deux ont été détectées comme NEC, tandis que la troisième (pour un climatiseur) était marquée comme UNKNOWN :
Cependant, il existe une excellente bibliothèque appelée IRremoteESP8266, qui prend en charge les protocoles de divers climatiseurs. Donc, si vous souhaitez contrôler votre climatiseur en IR, c’est la bibliothèque à utiliser, mais ce n’est pas celle que nous utilisons ici.
Remarque : pour les télécommandes avec des protocoles inconnus, vous verrez également l’erreur « Overflow » en plus des infos sur le protocole. Cela signifie simplement que la fin de la commande IR n’a pas pu être détectée, car le protocole était inconnu.
Trouver les codes des touches de votre télécommande
Comme il existe de nombreux types de télécommandes sur le marché (avec un nombre de touches et des fonctions différentes), nous devons déterminer quel signal reçu correspond à quelle touche.
La bibliothèque IRremote lit le signal et renvoie toutes les informations à propos du signal dans la structure suivante Data Structure:
struct IRData {
decode_type_t protocol; // UNKNOWN, NEC, SONY, RC5, PULSE_DISTANCE, ...
uint16_t address; // Decoded address
uint16_t command; // Decoded command
uint16_t extra;
uint16_t numberOfBits; // Number of bits received for data
uint8_t flags; // IRDATA_FLAGS_IS_REPEAT, IRDATA_FLAGS_WAS_OVERFLOW
IRRawDataType decodedRawData; // Up to 32 bit decoded raw data,
uint32_t decodedRawDataArray[RAW_DATA_ARRAY_SIZE]; // 32 bit decoded raw data for send function.
irparams_struct *rawDataPtr; // Pointer of the raw timing data to be decoded.
};
Nous nous intéressons particulièrement à la partie command de cette structure. Elle contient le code envoyé par la télécommande selon la touche pressée. En affichant la valeur de la commande dans le Serial Monitor, nous pouvons créer un tableau de correspondance.
Le code ci-dessous fait exactement cela. Notez que nous ajoutons un délai de 100 ms pour ralentir l’affichage si une touche est maintenue appuyée, ce qui éviterait un affichage répété en continu.
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 2
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
Serial.println(command);
delay(100); // wait a bit
IrReceiver.resume();
}
}
Après avoir téléversé le code, ouvrez le Serial Monitor. Appuyez ensuite sur chaque touche de la télécommande et notez la valeur correspondante affichée dans le Serial Monitor.
Pour ma télécommande qui contrôle un lecteur audio, j’ai obtenu les codes suivants :
| Touche | Code |
|---|---|
| Lecture | 7 |
| Stop | 3 |
| Muet | 20 |
| Piste suivante | 8 |
| Piste précédente | 2 |
| Volume + | 31 |
| Volume – | 23 |
Votre tableau sera probablement différent ! Vous devrez créer le vôtre pour utiliser les exemples de code ci-dessous.
Afficher le nom des touches dans le Serial Monitor
Maintenant que nous savons quel code correspond à quelle touche, nous pouvons modifier le code pour afficher le nom de la touche pressée dans le Serial Monitor.
Pour cela, nous allons utiliser une structure de contrôle switch case. Cela permet d’exécuter un code différent selon la touche pressée.
L’exemple de code ci-dessous affiche le nom de la touche dans le Serial Monitor au lieu de la valeur entière comme dans l’exemple précédent. Notez que nous gardons le délai pour ne pas saturer le récepteur avec des signaux répétés si une touche est maintenue appuyée.
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 2
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
Serial.println("PLAY");
break;
case 3:
Serial.println("STOP");
break;
case 20:
Serial.println("MUTE");
break;
case 8:
Serial.println("NEXT");
break;
case 2:
Serial.println("PREV");
break;
case 31:
Serial.println("VOL+");
break;
case 23:
Serial.println("VOL-");
break;
default:
Serial.println("UNDEFINED");
}
delay(100);
IrReceiver.resume();
}
}
Voici ce que j’obtiens dans le Serial Monitor en appuyant sur certaines touches de ma télécommande :
Si votre télécommande a des touches différentes et envoie des codes différents de ceux du tableau ci-dessus, il suffit de remplacer la valeur et le nom des lignes dans l’instruction switch case qui ressemble à ceci :
case 31:
Serial.println("VOL+");
Ces lignes signifient : lorsque la valeur de commande est égale à 31, affichez « VOL+ » dans le Serial Monitor. S’il n’y a pas de case pour une valeur de commande, la clause default est activée et « UNDEFINED » est affiché.
Comment fonctionne le code
La première ligne du code inclut la bibliothèque IRremote.hpp. Cette bibliothèque fournit les fonctions nécessaires pour interagir avec les signaux IR.
#include "IRremote.hpp"
Ensuite, nous définissons la broche qui recevra les signaux IR. Dans ce cas, nous utilisons la broche 2.
#define IR_RECEIVE_PIN 2
Dans la fonction setup(), nous démarrons la communication série à un débit de 9600 bauds. Nous initialisons aussi le récepteur IR sur la broche définie précédemment, avec le retour LED activé. Cela signifie qu’à chaque réception d’un code, une LED sur l’Arduino (et sur le module récepteur IR) clignotera, ce qui est pratique pour le débogage.
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
Dans la fonction loop(), nous vérifions si le récepteur IR a décodé un signal. Si c’est le cas, nous récupérons la valeur de commande à partir des données décodées.
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
Nous utilisons ensuite une instruction switch pour interpréter la commande. Chaque case correspond à une commande différente envoyée par la télécommande. Par exemple, si la commande est 7, l’Arduino affiche « PLAY » dans le Serial Monitor.
switch (command) {
case 7:
Serial.println("PLAY");
break;
case 3:
Serial.println("STOP");
break;
...
case 23:
Serial.println("VOL-");
break;
default:
Serial.println("UNDEFINED");
}
Après avoir interprété la commande, nous attendons 100 millisecondes puis nous réactivons le récepteur IR. Cela lui permet de décoder le signal suivant.
delay(100);
IrReceiver.resume();
}
}
Ce code fournit une base pour lire et interpréter les signaux d’une télécommande IR. Vous pouvez le modifier selon vos besoins.
Exemple : télécommande IR et récepteur avec Arduino et écran LCD
L’exemple suivant permet d’afficher les valeurs des touches pressées sur un écran LCD à caractères. J’ai rédigé un tutoriel détaillé sur l’utilisation des écrans LCD à caractères que vous pouvez trouver ici :
Si vous préférez utiliser un écran LCD I2C qui nécessite moins de connexions, consultez le tutoriel ci-dessous :
Pour cet exemple, j’ai connecté la sortie du récepteur IR à la broche numérique 8 au lieu de 2. Les connexions pour l’écran LCD à caractères sont indiquées dans le schéma de câblage ci-dessous. Notez que vous aurez aussi besoin d’un potentiomètre de 10 kΩ pour régler le contraste de l’affichage et d’une résistance de 220 Ω pour contrôler la luminosité du rétroéclairage.
Les connexions sont également indiquées dans le tableau ci-dessous. La broche la plus à gauche du LCD est la broche 1 (GND).
Connexions LCD et récepteur IR
| Broche | Connexion |
|---|---|
| LCD broche 1 (GND) | Arduino GND |
| LCD broche 2 (VCC) | Arduino 5 V |
| LCD broche 3 (VO) | Broche centrale du potentiomètre |
| Broche gauche du potentiomètre | Arduino 5 V |
| Broche droite du potentiomètre | Arduino GND |
| LCD broche 4 (RS) | Arduino broche 2 |
| LCD broche 5 (RW) | Arduino GND |
| LCD broche 6 (E) | Arduino broche 3 |
| LCD broche 11 (DB4) | Arduino broche 4 |
| LCD broche 12 (DB5) | Arduino broche 5 |
| LCD broche 13 (DB6) | Arduino broche 6 |
| LCD broche 14 (DB7) | Arduino broche 7 |
| LCD broche 15 (LED-anode) | Arduino 5 V via résistance de 220 Ω |
| LCD broche 16 (LED-cathode) | Arduino GND |
| Sortie récepteur IR OUT (gauche) | Arduino broche 8 |
| Récepteur IR GND (milieu) | Arduino GND |
| Récepteur IR Vcc (droite) | Arduino 5 V |
Si vous rencontrez des problèmes avec l’affichage LCD, consultez le tutoriel How to use a 16×2 character LCD with Arduino pour plus de détails.
Avec l’exemple de code ci-dessous, vous pouvez afficher la touche pressée sur le LCD. Encore une fois, si votre télécommande envoie des codes différents, il suffit de remplacer les valeurs de commande et les noms de touches correspondants dans le switch case.
Exemple de code : télécommande IR et récepteur avec Arduino et écran LCD
Vous pouvez copier le code en cliquant sur le bouton en haut à droite du champ de code.
#include "IRremote.hpp"
#include "LiquidCrystal.h"
// LCD object with pin parameters (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);
#define IR_RECEIVE_PIN 8
void setup() {
lcd.begin(16, 2); // LCD with 16 columns and 2 rows
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
lcd.print("PLAY");
break;
case 3:
lcd.print("STOP");
break;
case 20:
lcd.print("MUTE");
break;
case 8:
lcd.print("NEXT");
break;
case 2:
lcd.print("PREV");
break;
case 31:
lcd.print("VOL+");
break;
case 23:
lcd.print("VOL-");
break;
default:
lcd.print("UNDEFINED");
}
delay(100);
IrReceiver.resume();
}
}
Vous devriez voir le résultat suivant sur le LCD si vous appuyez sur la touche VOL+. Notez que vous devrez peut-être ajuster le potentiomètre pour augmenter le contraste de l’affichage.
Contrôler des LEDs (sorties Arduino) avec une télécommande IR et un récepteur
Même si c’est amusant de voir les valeurs des touches dans le Serial Monitor ou sur un écran LCD, vous voudrez sûrement utiliser la télécommande pour quelque chose de plus utile, c’est-à-dire contrôler réellement quelque chose. Dans l’exemple suivant, je vais vous montrer comment allumer et éteindre des LEDs avec la télécommande. Vous pouvez aussi utiliser ce type de code pour contrôler des relais, des lumières ou des moteurs.
Le code ressemble beaucoup aux exemples précédents, mais j’ai ajouté des fonctionnalités pour contrôler les LEDs.
Vous devrez réaliser le circuit suivant pour contrôler les LEDs :
Les LEDs 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 LEDs. Le courant de fonctionnement habituel des LEDs de 3 et 5 mm est d’environ 20 mA. Vous pouvez déterminer la valeur de la résistance nécessaire avec un online calculateur.
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 6
#define RED_LED_PIN 2
#define YELLOW_LED_PIN 3
#define GREEN_LED_PIN 4
#define BLUE_LED_PIN 5
void toggleLED(int pin) {
digitalWrite(pin, digitalRead(pin) == HIGH ? LOW : HIGH);
}
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
pinMode(RED_LED_PIN, OUTPUT);
pinMode(YELLOW_LED_PIN, OUTPUT);
pinMode(GREEN_LED_PIN, OUTPUT);
pinMode(BLUE_LED_PIN, OUTPUT);
digitalWrite(RED_LED_PIN, LOW);
digitalWrite(YELLOW_LED_PIN, LOW);
digitalWrite(GREEN_LED_PIN, LOW);
digitalWrite(BLUE_LED_PIN, LOW);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
Serial.println("PLAY-BLUE");
toggleLED(BLUE_LED_PIN);
break;
case 3:
Serial.println("STOP-YELLOW");
toggleLED(YELLOW_LED_PIN);
break;
case 20:
Serial.println("MUTE-GREEN");
toggleLED(GREEN_LED_PIN);
break;
default:
Serial.println("UNDEFINED-RED");
toggleLED(RED_LED_PIN);
}
delay(100);
IrReceiver.resume();
}
}
Explication du code
Tout d’abord, nous incluons à nouveau la bibliothèque IRremote.hpp, qui fournit les fonctions pour travailler avec les télécommandes IR.
#include "IRremote.hpp"
Ensuite, nous définissons les numéros de broches pour le récepteur IR et les LEDs. Notez que nous utilisons une broche différente (PIN 6) pour le récepteur par rapport à avant (PIN 2).
#define IR_RECEIVE_PIN 6 #define RED_LED_PIN 2 #define YELLOW_LED_PIN 3 #define GREEN_LED_PIN 4 #define BLUE_LED_PIN 5
Puis, nous définissons une fonction appelée toggleLED qui change l’état d’une broche LED. Elle prend un paramètre int pin, qui représente le numéro de la broche de la LED. Si la broche est à HIGH, on la met à LOW et inversement.
void toggleLED(int pin) {
digitalWrite(pin, digitalRead(pin) == HIGH ? LOW : HIGH);
}
Dans la fonction setup, nous initialisons la communication série à 9600 bauds. Nous initialisons aussi le récepteur IR et configurons les broches des LEDs en sortie. Enfin, nous éteignons toutes les LEDs.
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
pinMode(RED_LED_PIN, OUTPUT); // set the LED pins as output
pinMode(YELLOW_LED_PIN, OUTPUT);
pinMode(GREEN_LED_PIN, OUTPUT);
pinMode(BLUE_LED_PIN, OUTPUT);
digitalWrite(RED_LED_PIN, LOW); // turn all the LEDs off
digitalWrite(YELLOW_LED_PIN, LOW);
digitalWrite(GREEN_LED_PIN, LOW);
digitalWrite(BLUE_LED_PIN, LOW);
}
Dans la fonction loop, nous vérifions si le récepteur IR a reçu un signal. Si un signal est reçu, nous extrayons la commande à partir des données IR décodées. Selon la commande, nous effectuons différentes actions.
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
Serial.println("PLAY-BLUE");
toggleLED(BLUE_LED_PIN);
break;
case 3:
Serial.println("STOP-YELLOW");
toggleLED(YELLOW_LED_PIN);
break;
case 20:
Serial.println("MUTE-GREEN");
toggleLED(GREEN_LED_PIN);
break;
default:
Serial.println("UNDEFINED-RED");
toggleLED(RED_LED_PIN);
}
delay(100);
IrReceiver.resume();
}
}
Dans cet extrait de code, nous avons trois cas pour différentes commandes reçues de la télécommande IR. Si la commande est 7, nous affichons « PLAY-BLUE » dans le Serial Monitor et nous basculons la LED bleue. Pour la commande 3, nous affichons « STOP-YELLOW » et basculons la LED jaune. Et pour la commande 20, nous affichons « MUTE-GREEN » et basculons la LED verte. Pour toute autre commande, nous affichons « UNDEFINED-RED » et basculons la LED rouge.
Après avoir effectué les actions nécessaires, nous ajoutons un délai de 100 millisecondes et réactivons le récepteur IR pour écouter le signal suivant.
Conclusion
Dans ce tutoriel, je vous ai montré comment utiliser une télécommande IR et un récepteur avec Arduino. Nous avons vu plusieurs exemples de code pour déterminer le protocole IR et identifier les codes des touches de votre télécommande.
Nous avons ensuite vu comment afficher les valeurs des touches/boutons dans le Serial Monitor et sur un écran LCD 16×2. Enfin, je vous ai montré comment contrôler les sorties de l’Arduino avec la télécommande pour allumer ou éteindre des LEDs. Il existe de nombreuses autres applications pour les récepteurs et télécommandes IR, alors n’hésitez pas à laisser vos suggestions en commentaire.
Si vous avez des questions, des suggestions ou si vous pensez qu’il manque des choses dans ce tutoriel, laissez un commentaire ci-dessous.
Autres liens utiles sur le web
- Arduino-IRremote
- IRremote – Arduino Reference
- Arduino Infrared Remote Tutorial : 7 Steps
- How to Set Up an IR Remote and Receiver on an Arduino
- Arduino IR Remote Controller Tutorial
- Arduino – Control LED’s with IR Remote Control
- IR Remote Control | Arduino Tutorial
