Comment construire une télécommande IR universelle et programmable

Dans cet article de blog, vous apprendrez comment construire une télécommande IR universelle et programmable avec Arduino. Une télécommande infrarouge (IR) est un appareil courant utilisé pour contrôler divers appareils électroniques tels que les téléviseurs, les climatiseurs et les lecteurs DVD. Avec l’aide d’Arduino, nous pouvons créer notre propre télécommande IR programmable pour contrôler plusieurs appareils et regrouper plusieurs télécommandes en une seule.

À la fin de ce tutoriel, vous saurez comment utiliser des récepteurs et émetteurs infrarouges, et comment stocker des données dans une EEPROM non volatile. Vous disposerez également d’un prototype de télécommande IR programmable que vous pourrez modifier ou étendre à votre convenance. Cela vous permettra de prendre vos télécommandes IR existantes pour la TV, le ventilateur, etc., et de copier les fonctions de leurs touches sur la télécommande IR que nous construisons ici.

Alors, commençons et plongeons dans le monde passionnant d’Arduino et du contrôle par télécommande IR !

Composants requis

Voici les composants nécessaires pour construire la télécommande IR programmable. Vous aurez également besoin d’une télécommande IR, si vous n’en possédez pas déjà une.

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.

Connexion des composants

Dans cette section, je vais vous montrer comment connecter les composants à l’Arduino. L’image ci-dessous montre le câblage complet. Nous commencerons par connecter l’alimentation à la breadboard.

Alimentation

Reliez un fil bleu depuis la broche GND de l’Arduino à la ligne d’alimentation négative de la breadboard (marquée par une ligne bleue). Puis connectez la broche 5V de l’Arduino à la ligne d’alimentation positive (marquée par une ligne rouge) avec un fil rouge.

De plus, reliez les deux lignes d’alimentation positives de la breadboard avec un autre fil rouge. Cela garantit que les deux lignes ont l’alimentation positive.

Module récepteur IR

Ensuite, je vais vous montrer comment connecter le récepteur IR. Il reçoit les signaux infrarouges émis par une télécommande IR. Il transmet ensuite ces signaux à l’Arduino, où ils sont décodés.

Reliez un fil bleu et un fil rouge du récepteur aux lignes d’alimentation correspondantes de la breadboard. Le côté négatif est généralement marqué par un signe (-) sur le récepteur, tandis que la broche du milieu est souvent la broche positive. Ensuite, connectez la broche signal (S) du récepteur à la broche 2 de l’Arduino ; illustré ci-dessous avec un fil violet.

Après avoir connecté le récepteur, connectons le module émetteur.

Module émetteur IR

L’émetteur IR est le module avec la LED IR blanche/transparente. Ce module émet les signaux infrarouges utilisés pour contrôler les appareils.

Encore une fois, commencez par connecter l’alimentation (fil rouge et bleu). Ensuite, connectez la broche signal (S) de l’émetteur à la broche 3 de l’Arduino avec un fil blanc.

Puisque notre télécommande IR sera programmable, nous avons besoin d’une LED de statut. Elle nous indique si nous sommes en mode programmation ou en mode envoi. Voici comment câbler la LED de statut.

LED de statut

Placez une LED rouge sur la breadboard et connectez la cathode (la broche la plus courte) de la LED avec un fil bleu à la ligne d’alimentation négative de la breadboard. Puis connectez une résistance de 330 Ohms à l’anode de la LED (la broche la plus longue). Enfin, connectez la résistance avec un fil orange à la broche 11 de l’Arduino.

Boutons

Enfin, nous avons besoin de trois boutons. Un bouton pour basculer entre le mode programmation et le mode normal de la télécommande IR. Et deux autres boutons pour deux fonctions différentes de la télécommande. Par exemple, augmenter et diminuer le volume.

Comme vous pouvez le voir ci-dessous, les trois boutons sont câblés de la même manière. Une résistance de 10K Ohms sert de pull-up résistance de tirage (pull-up) et est connectée à la ligne d’alimentation positive. La broche de l’autre côté du bouton est connectée à une broche d’entrée de l’Arduino (plus de détails ci-dessous). L’autre broche est reliée avec un fil bleu à la ligne d’alimentation négative de la breadboard.

Dans l’état normal, ouvert, du bouton poussoir, l’entrée est connectée à 5V via la résistance et on lit un signal HIGH. Cependant, si vous appuyez sur un bouton, la ligne d’entrée est reliée à la masse et on lit un signal LOW sur l’entrée.

Le premier bouton en haut sera notre bouton de changement de mode. Connectez-le avec un fil jaune à la broche 4 de l’Arduino. Le bouton du milieu sera pour la première fonction. Connectez-le à la broche 5 (fil cyan). Et le dernier bouton est pour la deuxième fonction, connecté avec un fil vert à la broche 6.

Voilà, tout est connecté – espérons-le correctement. Dans la section suivante, nous allons examiner le logiciel.

Écriture du logiciel

Je vous montre d’abord le code complet, puis nous passerons en revue les différentes parties pour comprendre son fonctionnement. Jetez-y un coup d’œil rapide pour avoir une vue d’ensemble.

#include "EEPROM.h"
#include "IRremote.hpp"
#include "TinyIRSender.hpp"

const uint8_t irReceivePin = 2;
const uint8_t irSendPin = 3;
const uint8_t modePin = 4;
const uint8_t func1Pin = 5;
const uint8_t func2Pin = 6;
const uint8_t ledPin = 11;
const uint8_t sRepeats = 2;

uint8_t modeReceive = HIGH;

struct Code {
  uint16_t adr;
  uint16_t cmd;
} code;

bool isOn(int btn) {
  return btn == LOW;
}

bool pressed(int pin) {
  return isOn(digitalRead(pin));
}

int memadr(int btnId) {
  return (btnId - 1) * sizeof(Code);
}

void store_code(int btnId, IRData &irData) {
  digitalWrite(ledPin, LOW);
  code = { irData.address, irData.command };
  EEPROM.put(memadr(btnId), code);
  delay(200);
  digitalWrite(ledPin, HIGH);
}

void send_code(int btnId) {
  digitalWrite(ledPin, HIGH);
  EEPROM.get(memadr(btnId), code);
  sendNECMinimal(irSendPin, code.adr, code.cmd, sRepeats);
  delay(200);
  digitalWrite(ledPin, LOW);
}

void toggle_mode() {
  modeReceive = modeReceive == LOW ? HIGH : LOW;
  digitalWrite(ledPin, isOn(modeReceive) ? HIGH : LOW);
  isOn(modeReceive) ? IrReceiver.start() : IrReceiver.stop();
  delay(200);
}

void send() {
  if (pressed(func1Pin)) {
    send_code(1);
  } else if (pressed(func2Pin)) {
    send_code(2);
  }
}

void receive() {
  if (IrReceiver.decode()) {
    IRData &irData = IrReceiver.decodedIRData;
    IrReceiver.printIRResultShort(&Serial);
    if (pressed(func1Pin)) {
      store_code(1, irData);
    } else if (pressed(func2Pin)) {
      store_code(2, irData);
    }
    IrReceiver.resume();
  }
}

void setup() {
  Serial.begin(9600);
  IrReceiver.begin(irReceivePin, ENABLE_LED_FEEDBACK);
  pinMode(ledPin, OUTPUT);
  pinMode(modePin, INPUT);
  pinMode(func1Pin, INPUT);
  pinMode(func2Pin, INPUT);
  digitalWrite(ledPin, LOW);
}

void loop() {
  if (pressed(modePin)) toggle_mode();
  isOn(modeReceive) ? receive() : send();
  delay(100);
}

Bibliothèques incluses

Pour ce projet, vous devrez installer les bibliothèques suivantes. EEPROM est utilisée pour stocker les codes IR programmés. La IRremote bibliothèque sert à décoder les signaux IR reçus d’une télécommande IR. Et TinyIRSender fait partie de la bibliothèque IRremote et permet d’envoyer des signaux IR – bien que limité au NEC protocol .

#include "EEPROM.h"
#include "IRremote.hpp"
#include "TinyIRSender.hpp"

Constantes

Dans le bloc de code suivant, nous définissons quelles broches de l’Arduino sont utilisées pour quel composant. irReceivePin et irSendPin sont les broches connectées au récepteur et à l’émetteur IR. modePin, func1Pin et func2Pin sont connectés aux boutons. La LED de statut est contrôlée via la ledPin . Et sRepeats définit la fréquence de répétition d’un IR command lors de l’envoi.

const uint8_t irReceivePin = 2;
const uint8_t irSendPin = 3;
const uint8_t modePin = 4;
const uint8_t func1Pin = 5;
const uint8_t func2Pin = 6;
const uint8_t ledPin = 11;
const uint8_t sRepeats = 2;

Structures de données

En plus des constantes, nous avons besoin d’une variable pour stocker le mode actuel (programmation ou normal) de notre télécommande IR. modeReceive est HIGH lorsque nous sommes en mode programmation, et LOW sinon.

uint8_t modeReceive = HIGH;

struct Code {
  uint16_t adr;
  uint16_t cmd;
} code;

La Code struct stocke l’adresse ( adr ) et la commande ( cmd ) des codes IR que nous allons recevoir, stocker et envoyer. Par exemple, ma télécommande IR envoie l’adresse 0x20 et la commande 0x17 lorsque la touche VOL+ est pressée.

Pour plus de détails, consultez la documentation de la IRremote lib ou jetez un œil à notre tutoriel sur How to use an IR receiver and remote with Arduino .

Fonctions utilitaires

Pour garder le code simple et lisible, nous implémentons quelques fonctions utilitaires. La fonction isOn() renvoie True , si un bouton est LOW , ce qui signifie qu’il est enfoncé. Avec la fonction pressed() , nous lisons l’état d’une broche d’entrée puis utilisons isOn() pour déterminer si le bouton connecté est pressé.

bool isOn(int btn) {
  return btn == LOW;
}

bool pressed(int pin) {
  return isOn(digitalRead(pin));
}

Fonction d’adresse mémoire

Pour stocker les codes IR reçus en mémoire, nous avons besoin d’une fonction qui nous indique à quelle adresse stocker les données. La fonction memadr() sert à calculer à quelle adresse mémoire dans la EEPROM nous stockons et lisons les codes de commande IR.

int memadr(int btnId) {
  return (btnId - 1) * sizeof(Code);
}

Cette fonction prend un btnId , qui vaut 1 ou 2 (pour fonction 1 ou 2) et calcule l’adresse mémoire. Regardez l’image suivante pour mieux comprendre la relation entre btnId , la taille d’une struct Code et l’adresse mémoire.

Fonctions de code IR

Pour le stockage et l’envoi des codes IR, nous utilisons deux fonctions. La fonction store_code() prend un identifiant de bouton ( btnId ) et un bloc de données ( irData ) de données IR reçues.

Dans un premier temps, nous éteignons la LED de statut pour indiquer que nous stockons des données.

void store_code(int btnId, IRData &irData) {
  digitalWrite(ledPin, LOW);
  code = { irData.address, irData.command };
  EEPROM.put(memadr(btnId), code);
  delay(200);
  digitalWrite(ledPin, HIGH);
}

Ensuite, nous extrayons l’adresse du code et la commande du bloc de données et les stockons dans une struct Code . Nous écrivons cette struct dans l’EEPROM avec put() , en utilisant la fonction memadr() pour calculer l’adresse mémoire.

Nous devons stocker les données dans EEPROM car sinon, à chaque coupure de courant, l’Arduino perdrait toutes les données stockées. Avec les données dans l’EEPROM, les commandes/touches programmées restent enregistrées même lorsque l’Arduino est éteint.

Après le stockage, nous attendons 200 ms. Cela évite un stockage répété inutile lorsque la touche de programmation reste enfoncée. Enfin, nous rallumons la LED de statut pour indiquer que la programmation est terminée.

L’envoi des codes fonctionne essentiellement à l’inverse. Regardez la fonction send_code() ci-dessous. D’abord, nous allumons la LED de statut pour indiquer que nous envoyons. Puis nous get le code à envoyer depuis l’EEPROM pour le bouton pressé ( btnId ). La fonction sendNECMinimal() envoie l’adresse et la commande du code avec le nombre de répétitions donné ( sRepeats ).

void send_code(int btnId) {
  digitalWrite(ledPin, HIGH);
  EEPROM.get(memadr(btnId), code);
  sendNECMinimal(irSendPin, code.adr, code.cmd, sRepeats);
  delay(200);
  digitalWrite(ledPin, LOW);
}

Ensuite, nous attendons à nouveau 200 ms et éteignons la LED de statut pour indiquer que l’envoi est terminé.

Fonctions principales

Nous avons maintenant toutes les fonctions de base pour construire les fonctions principales. Nous commençons par une fonction toggle_mode() qui bascule notre télécommande entre le mode programmation/réception et le mode envoi. La première ligne effectue le basculement du mode. Dans la deuxième ligne, nous allumons la LED de statut si nous sommes en mode programmation. En mode normal, la LED de statut est éteinte.

void toggle_mode() {
  modeReceive = modeReceive == LOW ? HIGH : LOW;
  digitalWrite(ledPin, isOn(modeReceive) ? HIGH : LOW);
  isOn(modeReceive) ? IrReceiver.start() : IrReceiver.stop();
  delay(200);
}

Dans la troisième ligne, nous activons ou désactivons le IrReceiver selon le mode. Si nous sommes en mode réception, le IrReceiver est démarré, sinon il est arrêté. Enfin, nous avons notre délai habituel de 200 ms pour gérer les appuis longs sur les boutons.

La fonction send() ci-dessous utilise send_code() pour envoyer les codes IR stockés pour les boutons 1 et 2. En d’autres termes, selon le bouton pressé, elle envoie le code correspondant.

void send() {
  if (pressed(func1Pin)) {
    send_code(1);
  } else if (pressed(func2Pin)) {
    send_code(2);
  }
}

Enfin, la dernière des fonctions principales est receive() . Elle reçoit les données transmises par une télécommande IR et les stocke pour le bouton 1 ou 2, selon le bouton actuellement pressé. Pour plus de détails sur la réception des données IR, consultez notre tutoriel : How to use an IR receiver and remote with Arduino .

void receive() {
  if (IrReceiver.decode()) {
    IRData &irData = IrReceiver.decodedIRData;
    IrReceiver.printIRResultShort(&Serial);
    if (pressed(func1Pin)) {
      store_code(1, irData);
    } else if (pressed(func2Pin)) {
      store_code(2, irData);
    }
    IrReceiver.resume();
  }
}

Fonction setup

Nous y sommes presque ! Il ne reste que deux fonctions très simples à implémenter. Dans la fonction setup() , nous établissons la communication série, initialisons le IrReceiver et configurons les modes IO des broches. Nous veillons également à ce que la LED de statut soit éteinte, ce qui indique que nous sommes en mode envoi au démarrage.

void setup() {
  Serial.begin(9600);
  IrReceiver.begin(irReceivePin, ENABLE_LED_FEEDBACK);
  pinMode(ledPin, OUTPUT);
  pinMode(modePin, INPUT);
  pinMode(func1Pin, INPUT);
  pinMode(func2Pin, INPUT);
  digitalWrite(ledPin, LOW);
}

Fonction loop

Après tout ce travail, la boucle principale est maintenant très simple. Nous surveillons le bouton de mode connecté à la modePin et s’il est pressed , nous basculons le mode. Ensuite, nous vérifions si nous sommes en mode réception via isOn(modeReceive) . Si c’est le cas, nous recevons et stockons éventuellement les données IR. Sinon, nous envoyons les données.

void loop() {
  if (pressed(modePin)) toggle_mode();
  isOn(modeReceive) ? receive() : send();
  delay(100);
}

Et voilà ! Dans la section suivante, je vous expliquerai rapidement comment utiliser la télécommande que nous venons de construire.

Comment utiliser la télécommande

Dans cette section, je vous explique comment utiliser la télécommande. Nous avons trois boutons. Le bouton Mode sert à basculer entre le mode programmation ou réception et le mode envoi. Au démarrage, la télécommande est en mode envoi et la LED de statut est éteinte. Si vous appuyez brièvement sur le bouton Mode, la télécommande passe en mode programmation et la LED de statut s’allume.

Programmation

Pour programmer l’une des deux touches de fonction, vous devez pointer votre autre télécommande IR vers la diode réceptrice et appuyer simultanément sur deux touches : la touche de l’autre télécommande que vous souhaitez stocker et la touche de fonction de notre télécommande universelle. L’image suivante montre comment nous stockerions la touche Piste Suivante comme Fonction 1.

La LED de statut clignotera brièvement pour indiquer qu’une fonction a été enregistrée, vous pouvez alors relâcher les boutons.

Envoi

Pour envoyer des commandes IR, appuyez simplement sur le bouton Mode (la LED de statut doit être éteinte) puis sur l’une des touches de fonction que vous avez programmées. Là encore, la LED de statut clignotera pour indiquer que la commande a été envoyée.

Débogage

Certaines télécommandes IR ne sont pas supportées et vous ne pourrez pas les programmer. Vous pouvez vérifier cela en connectant le moniteur série, en passant en mode programmation (la LED de statut doit être allumée) et en vérifiant si la bibliothèque IRremote peut décoder le signal. La sortie devrait ressembler à ceci :

Ici, nous avons reçu avec succès une commande avec l’adresse 0x20 et le code commande 0x8 .

Pour déboguer la fonction d’envoi, un de ces testeurs de composants sera très utile. Sinon, vous devrez vous fier à la méthode essais/erreurs pour identifier le problème.

Le testeur de composants ci-dessus peut décoder les signaux IR et un signal reçu avec succès ressemble à ceci :

Conclusions

Dans ce tutoriel, vous avez appris à construire une télécommande IR universelle et programmable avec Arduino. En suivant les instructions étape par étape, vous pouvez facilement créer votre propre télécommande capable de piloter une large gamme d’appareils infrarouges.

Nous avons commencé par présenter les pièces nécessaires pour ce projet, incluant une carte Arduino, un module récepteur IR et un module émetteur IR. Nous avons décrit le câblage entre ces composants et fourni le code pour les contrôler. De plus, nous avons expliqué comment utiliser la télécommande pour programmer des commandes IR à partir d’autres télécommandes.

Si vous avez d’autres questions ou besoin d’aide supplémentaire, veuillez consulter la section FAQ ou explorer les liens fournis pour plus de ressources et d’inspiration.

Bon bricolage !

Foire aux questions

Voici quelques questions fréquemment posées sur la construction d’une télécommande IR universelle et programmable avec Arduino :

Puis-je avoir plus de boutons de fonction ?

Oui, il suffit de reproduire le câblage des boutons existants pour les nouveaux boutons et d’étendre le code. Plus précisément, les fonctions receive() et send() doivent être étendues pour gérer les boutons supplémentaires.

Comment augmenter la portée de la télécommande IR ?

Vous pouvez connecter des LED IR supplémentaires à d’autres broches de sortie. Ou faire fonctionner une LED IR à une tension plus élevée, mais cela nécessitera un transistor ou un MOSFET pour contrôler le signal d’entrée de la LED. Voici un exemple de circuit utilisant une pile 9V pour alimenter une diode émettrice IR :

Pour plus de détails et d’exemples concernant les MOSFET, consultez notre tutoriel sur Control Air-Conditioner via IR with ESP32 or ESP8266 et How To Control Fan using Arduino UNO .

Ma télécommande IR ne fonctionne pas ?

La bibliothèque IrRemote est excellente mais ne supporte pas tous les protocoles de communication IR existants. Pour l’envoi, nous avons utilisé TinyIRSender , qui est limité au protocole NEC, mais la bibliothèque IrRemote supporte aussi d’autres protocoles. Si cela ne suffit pas, regardez la IRremoteESP8266 comme alternative possible.

Je veux contrôler mon climatiseur avec la télécommande IR ?

Essayez la bibliothèque IRremoteESP8266 . Elle offre un excellent support pour de nombreuses unités de climatisation.

Puis-je utiliser n’importe quelle carte Arduino pour ce projet ?

Oui, vous pouvez utiliser n’importe quelle carte Arduino pour ce projet tant que vous pouvez connecter un récepteur et un émetteur infrarouges, et que les bibliothèques nécessaires sont supportées. Un ESP32, par exemple, serait une excellente alternative à un Arduino.

Comment savoir quels codes IR utiliser pour mes appareils ?

Vous pouvez trouver les codes IR pour vos appareils en cherchant en ligne ou en consultant le manuel d’utilisation de l’appareil. De nombreux fabricants fournissent des bases de données de codes IR compatibles avec les bibliothèques Arduino. Sinon, vous pouvez utiliser un module récepteur IR pour capturer les codes d’une télécommande existante. Voir notre tutoriel sur How to use an IR receiver and remote with Arduino .

Puis-je contrôler plusieurs appareils avec cette télécommande IR ?

Oui, vous pouvez contrôler plusieurs appareils avec cette télécommande IR. En programmant différents codes IR pour chaque appareil, vous pouvez basculer entre eux via des boutons ou un système de menu dans votre code Arduino. Notez cependant que le code ci-dessus ne supporte que le protocole NEC, mais heureusement la plupart des télécommandes IR l’utilisent.

Puis-je ajouter des fonctionnalités supplémentaires à la télécommande IR ?

Absolument ! La plateforme Arduino permet une personnalisation infinie. Vous pouvez ajouter des fonctionnalités comme un écran LCD rétroéclairé, un encodeur rotatif pour la navigation dans les menus, ou même l’intégrer à d’autres appareils domotiques via des protocoles de communication sans fil comme le Wi-Fi ou le Bluetooth.

Si vous avez d’autres questions ou besoin d’aide supplémentaire, n’hésitez pas à demander dans la section commentaires ci-dessous.

Liens

Voici quelques liens utiles pour des explications supplémentaires et des constructions alternatives.

• IR Remote and Receiver with Arduino Tutorial (4 Examples)
• ESP32 And IR Remote Interface – A Complete Tutorial
• How to Control a Servo with an IR Remote
• Universal Arduino Remote : 10 Steps (with Pictures)
• Arduino Infrared (IR) Control… The Universal Remote …
• Arduino based universal TV Remote
• Arduino IR Remote Controller Tutorial – Setup and Map …
• Arduino Infrared Remote Tutorial : 7 Steps