Aucun produit dans le panier.
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
- Télécommande IR et récepteur
- Arduino uno
- Fils
- Écran LCD 16 × 2 caractères
- Breadbord
- Potentiomètre 10 kΩ (type breadboard)
- Résistances
- LED
- 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é.
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.
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.
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?
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!
Les connexions sont également donné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 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.
Vous pouvez rechercher «IRremote» et rechercher la bibliothèque par shirriff et z3to. Sélectionnez la dernière version, puis cliquez sur Installer.
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:
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.
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:
| Clé | Code |
|---|---|
| PUISSANCE | 0xFD00FF |
| VOL + | 0xFD807F |
| FUNC / STOP | 0xFD40BF |
| │◄◄ | 0xFD20DF |
| ►││ | 0xFDA05F |
| ►►│ | 0xFD609F |
| ▼ | 0xFD10EF |
| VOL- | 0xFD906F |
| ▲ | 0xFD50AF |
| 0 | 0xFD30CF |
| EQ | 0xFDB04F |
| ST / REPT | 0xFD708F |
| 1 | 0xFD08F7 |
| 2 | 0xFD8877 |
| 3 | 0xFD48B7 |
| 4 | 0xFD28D7 |
| 5 | 0xFDA857 |
| 6 | 0xFD6897 |
| 7 | 0xFD18E7 |
| 8 | 0xFD9867 |
| 9 | 0xFD58A7 |
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
}
}
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 .
#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.
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
| Épingler | Connexion |
|---|---|
| Broche LCD 1 (GND) | Arduino GND |
| Broche LCD 2 (VCC) | Arduino 5 V |
| Broche LCD 3 (VO) | Potentiomètre à broche centrale |
| Potentiomètre broche gauche | Arduino 5 V |
| Potentiomètre à broche droite | Arduino 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.
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:
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 .
8 Comments