KY-005 Module transmetteur infrarouge
Une diode électroluminescente qui émet dans le domaine de l'infrarouge.
- Arduino
- Raspberry Pi
- Raspberry Pi Pico
- Micro:Bit

Une diode électroluminescente qui émet dans le domaine de l'infrarouge. En fonction de la tension d'entrée, des résistances en série sont nécessaires.
Données techniques
Vf | 1,1V |
If | 20mA |
Longueur d'onde d'émission | 940nm (lumière invisible) |
Les désignations (Vf et If) font référence à la tension directe et au courant direct de la diode électroluminescente.
Résistances de série:
Rf (3,3V) | 120Ω |
(par exemple, lorsqu'il est utilisé avec des microcontrôleurs basés sur un noyau de CPU ARM, comme le Raspberry-Pi).
Rf (5V) | 220Ω |
(par exemple, lorsqu'il est utilisé avec des microcontrôleurs basés sur Atmel Atmega comme Arduino).
La désignation (Rf) fait référence à la résistance en série requise devant la DEL en fonction de la tension appliquée.
*Sur la carte, il y a la possibilité de souder directement la résistance requise. **L'emplacement pour souder la résistance est directement au-dessus des broches de connexion sur le PCB. Dans ce cas, on peut utiliser la broche du milieu, qui contient alors la résistance.
Affectation des broches
Exemple de code Arduino
La vitesse de transmission de la sortie série doit être réglée sur 115200 sinon l'exemple de télécommande ne fonctionnera pas.
Exemple de code ON/OFF
Affectation des broches Arduino
Arduino | Récepteur |
---|---|
Pin 3 | Signal |
5V | +V |
GND | GND |
Cet exemple de code montre comment une LED peut être alternativement allumée pendant quatre secondes puis éteinte pendant deux secondes à l'aide d'une broche de sortie définissable.
int Led = 13;
void setup ()
{
pinMode (Led, OUTPUT); // Déclaration de la broche de sortie LED
}
void loop () //Boucle de programme principale
{
digitalWrite (Led, HIGH); // la LED est activée
delay (4000); // Temporisation de 4 secondes
digitalWrite (Led, LOW); // la LED est déactivée
delay (2000); // Temporisation de 2 secondes
}
Télécharger l'exemple de programme
Exemple de code de télécommande
Affectation des broches Arduino
Arduino | Émetteur |
---|---|
Pin 3 | Signal |
GND* | GND+Résistance |
GND | GND |
- *Uniquement si la résistance série a été soudée sur le module et n'est pas connectée devant le module.
En utilisant les deux modules capteurs KY-005 et KY-022, il est possible de construire un système télécommande infrarouge + récepteur infrarouge. Pour ce faire, deux Arduinos sont nécessaires en plus des deux modules. Ceux-ci agissent alors comme un émetteur et comme un récepteur des signaux. Il est seulement important de savoir ce que le récepteur des signaux de la console série émet et ce que l'émetteur envoie, car cela doit correspondre.
Pour l'exemple de code suivant, une bibliothèque supplémentaire est nécessaire :
Arduino-IRremote par Ken Shirriff | publié sous la licence MIT.
La bibliothèque n'est pas incluse dans le paquet et doit être copiée dans le dossier "library" avant de démarrer l'IDE Arduino.
Il se trouve par défaut dans le chemin suivant de votre installation Windows :
C:\User[nom d'utilisateur]\Documents\Arduino\Librairies
Avec les systèmes de transmission infrarouge, il existe différents protocoles dans lesquels les données peuvent être envoyées. Dans l'exemple suivant, le protocole NEC est utilisé pour l'envoi à l'aide de l'exemple SimpleSender modifié et de l'exemple SimpleReceiver modifié - la bibliothèque utilisée "Arduino-IRremote" s'occupe indépendamment de la conversion en séquence de données correcte. Cependant, il existe d'autres protocoles/encodages au sein de la bibliothèque - ceux-ci sont identifiés dans la documentation/code de la bibliothèque. Documentation.
Veuillez noter: Pour l'exécution de l'exemple de code, un fichier supplémentaire est nécessaire. Celui-ci s'ouvre automatiquement dès que vous ouvrez le code d'exemple de la bibliothèque Arduino-IRremote. Ouvrez donc d'abord le code d'exemple de la manière suivante : Fichier -> Exemples -> IRremote -> SimpleSender. Vous pouvez maintenant remplacer le code d'exemple par notre exemple modifié.
Code de l'émetteur
/*
SimpleSender.cpp
Demonstrates sending IR codes in standard format with address and command
An extended example for sending can be found as SendDemo.
Copyright (C) 2020-2021 Armin Joachimsmeyer
armin.joachimsmeyer@gmail.com
This file is part of Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote.
MIT License
*/
#include <Arduino.h>
/*
Define macros for input and output pin etc.
*/
#include "PinDefinitionsAndMore.h"
//#define SEND_PWM_BY_TIMER
//#define USE_NO_SEND_PWM
#include <IRremote.h>
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
Serial.begin(115200);
// Just to know which program is running on my Arduino
Serial.println(F("START " __FILE__ " from " __DATE__ "\r\nUsing library version " VERSION_IRREMOTE));
/*
The IR library setup. That's all!
*/
IrSender.begin(IR_SEND_PIN, ENABLE_LED_FEEDBACK); // Specify send pin and enable feedback LED at default feedback LED pin
Serial.print(F("Ready to send IR signals at pin "));
Serial.println(IR_SEND_PIN);
}
/*
Set up the data to be sent.
For most protocols, the data is build up with a constant 8 (or 16 byte) address
and a variable 8 bit command.
There are exceptions like Sony and Denon, which have 5 bit address.
*/
uint16_t sAddress = 0x0102;
uint8_t sCommand = 0x34;
uint16_t sAddress1 = 0x0101;
uint8_t sCommand1 = 0x35;
uint16_t sAddress2 = 0x0103;
uint8_t sCommand2 = 0x36;
uint8_t sRepeats = 0;
void loop() {
Serial.println(F("Send NEC with 16 bit address"));
Serial.flush();
// Results for the first loop to: Protocol=NEC Address=0x102 Command=0x34 Raw-Data=0xCB340102 (32 bits)
IrSender.sendNEC(sAddress, sCommand, sRepeats);
delay(1000);
IrSender.sendNEC(sAddress1, sCommand1, sRepeats);
delay(1000);
IrSender.sendNEC(sAddress2, sCommand2, sRepeats);
/*
If you cannot avoid to send a raw value directly like e.g. 0xCB340102 you must use sendNECRaw()
*/
// Serial.println(F("Send NECRaw 0xCB340102"));
// IrSender.sendNECRaw(0xCB340102, sRepeats);
delay(1000); // delay must be greater than 5 ms (RECORD_GAP_MICROS), otherwise the receiver sees it as one long signal
}
Télécharger l'exemple de programme

Une diode électroluminescente qui émet dans le domaine de l'infrarouge. En fonction de la tension d'entrée, des résistances en série sont nécessaires.
Données techniques
Vf | 1,1V |
If | 20mA |
Longueur d'onde d'émission | 940nm (lumière invisible) |
Les désignations (Vf et If) font référence à la tension directe et au courant direct de la diode électroluminescente.
Résistances de série:
Rf (3,3V) | 120Ω |
(par exemple, lorsqu'il est utilisé avec des microcontrôleurs basés sur un noyau de CPU ARM, comme le Raspberry-Pi).
Rf (5V) | 220Ω |
(par exemple, lorsqu'il est utilisé avec des microcontrôleurs basés sur Atmel Atmega comme Arduino).
La désignation (Rf) fait référence à la résistance en série requise devant la DEL en fonction de la tension appliquée.
*Sur la carte, il y a la possibilité de souder directement la résistance requise. **L'emplacement pour souder la résistance est directement au-dessus des broches de connexion sur le PCB. Dans ce cas, on peut utiliser la broche du milieu, qui contient alors la résistance.
Affectation des broches
Exemple de code Raspberry Pi
Deux exemples d'application de ce module de détection sont présentés ici. Un qui allume et éteint brièvement la diode de l'émetteur infrarouge (émettant une lumière non visible - peut être vu à travers la caméra d'un téléphone portable par exemple), et un exemple d'application directe pour le Raspberry Pi où il peut être programmé soit comme un récepteur infrarouge pour des télécommandes pour contrôler par exemple le logiciel de centre multimédia OpenElec, soit comme un émetteur infrarouge pour une télécommande contrôlée par logiciel.
Exemple de code ON/OFF
Affectation des broches Raspberry Pi
Raspberry Pi | Capteur |
---|---|
GPIO 15 [Pin 10] | Signal |
GND [Pin 6] | GND |
- *Uniquement si la résistance en série est soudée sur le module et non connectée devant le module.
#!/usr/bin/python
# coding=utf-8
# Les modules nécessaires sont importés et mis en place
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
# La broche d'entrée du capteur est déclarée. En outre la résistance de Pull-up est activée.
LED_PIN = 15
GPIO.setup(LED_PIN, GPIO.OUT, initial= GPIO.LOW)
print("LED-Test [Appuyez sur Ctrl + C pour terminer le test]")
# Boucle de programme principale
try:
while True:
print("LED 4 secondes ON")
GPIO.output(LED_PIN,GPIO.HIGH) #la LED est allumée
time.sleep(4) #Temporisation de 4 secondes
print("LED 2 secondes OFF")
GPIO.output(LED_PIN,GPIO.LOW) #La LED est éteinte
time.sleep(2) #Temporisation de 2 secondes
# remise en place de tous les GPIO en entrées
except KeyboardInterrupt:
GPIO.cleanup()
Exemple de téléchargement de programme
Pour commencer avec la commande :
sudo python3 KY005.py
Exemple de code de commande à distance
Brochage du Raspberry Pi :
Raspberry Pi | Récepteur |
---|---|
GPIO15 [Pin 10] | Signal |
3.3 V [Pin 1] | +V |
GND [Pin 6] | GND |
Raspberry Pi | émetteur |
---|---|
GPIO14 [Pin 8] | Signal |
GND [Pin 6] | GND |
Source des étapes suivantes.
Tout d'abord, ouvrez le fichier config.txt à l'aide de la commande suivante :
sudo nano /boot/config.txt
Ajoutez maintenant le contenu suivant à la fin du fichier :
dtoverlay=gpio-ir,gpio_pin=15
dtoverlay=gpio-ir-tx,gpio_pin=14
Avec la combinaison de touches [CTRL+O], vous pouvez enregistrer le fichier. Confirmez avec [Enter] et quittez l'éditeur avec la combinaison de touches [CTRL+X]. Redémarrez maintenant votre Raspberry Pi avec la commande suivante :
sudo reboot
Maintenant, installez le module ir-keytable :
sudo apt-get install ir-keytable -y
Avec la commande suivante, vous pouvez déterminer l'identification de l'appareil. Ceci est nécessaire pour pouvoir s'adresser au récepteur dans la suite de la procédure :
sudo ir-keytable
La première ligne de la sortie devrait ressembler à ceci :
Found /sys/class/rc/rc0/ (/dev/input/event0) with:
On peut y lire que nous pouvons adresser notre récepteur via l'identification rc0. Nous commençons donc la réception maintenant par la commande suivante :
ir-keytable -t -s rc0

Une diode électroluminescente qui émet dans le domaine de l'infrarouge. En fonction de la tension d'entrée, des résistances en série sont nécessaires.
Données techniques
Vf | 1,1V |
If | 20mA |
Longueur d'onde d'émission | 940nm (lumière invisible) |
Les désignations (Vf et If) font référence à la tension directe et au courant direct de la diode électroluminescente.
Résistances de série:
Rf (3,3V) | 120Ω |
(par exemple, lorsqu'il est utilisé avec des microcontrôleurs basés sur un noyau de CPU ARM, comme le Raspberry-Pi).
Rf (5V) | 220Ω |
(par exemple, lorsqu'il est utilisé avec des microcontrôleurs basés sur Atmel Atmega comme Arduino).
La désignation (Rf) fait référence à la résistance en série requise devant la DEL en fonction de la tension appliquée.
*Sur la carte, il y a la possibilité de souder directement la résistance requise. **L'emplacement pour souder la résistance est directement au-dessus des broches de connexion sur le PCB. Dans ce cas, on peut utiliser la broche du milieu, qui contient alors la résistance.
Affectation des broches
Exemple de code Micro:Bit
Exemple de code ON/OFF
Affectation des broches Micro:Bit :
Micro:Bit | Émetteur |
---|---|
Pin 0 | Signal |
- | +V |
GND | GND |
Ceci est un exemple MakeCode pour Micro:Bit qui fait essentiellement la même chose que les deux autres exemples. Cependant, cet exemple est plus proche de celui du Raspberry Pi que de celui de l'Arduino.

Téléchargement d'un exemple de programme
Exemple de code de télécommande
Pinout Micro:Bit :
Micro:Bit | Émetteur |
---|---|
Pin 0 | Signal |
- | +V |
GND | GND |
Micro:Bit | Récepteur |
---|---|
Pin 1 | Signal |
3V | +V |
GND | GND |
Ceci est un exemple MakeCode pour Micro:Bit qui fait essentiellement la même chose que les deux autres exemples. Cependant, cet exemple est plus proche de celui du Raspberry Pi que de celui de l'Arduino.
Deux bibliothèques supplémentaires sont nécessaires pour l'exemple de code suivant :
pxt-makerbit-ir-transmitter de 1010Technologies | publié sous la licence MIT
pxt-makerbit-ir-receiver de 1010Technologies | publié sous la licence MIT.
Vous devez d'abord ajouter ces bibliothèques à votre IDE avant d'utiliser le code.
Pour ce faire, allez dans Extensions dans votre IDE et utilisez les deux URL suivantes https://github.com/1010Technologies/pxt-makerbit-ir-transmitter.git et https://github.com/1010Technologies/pxt-makerbit-ir-receiver.git pour rechercher la bibliothèque et l'ajouter. Il convient de mentionner que, parfois, les bibliothèques n'apparaissent qu'après que vous ayez ajouté la deuxième bibliothèque.

Téléchargement d'un exemple de programme

Une diode électroluminescente qui émet dans le domaine de l'infrarouge. En fonction de la tension d'entrée, des résistances en série sont nécessaires.
Données techniques
Vf | 1,1V |
If | 20mA |
Longueur d'onde d'émission | 940nm (lumière invisible) |
Les désignations (Vf et If) font référence à la tension directe et au courant direct de la diode électroluminescente.
Résistances de série:
Rf (3,3V) | 120Ω |
(par exemple, lorsqu'il est utilisé avec des microcontrôleurs basés sur un noyau de CPU ARM, comme le Raspberry-Pi).
Rf (5V) | 220Ω |
(par exemple, lorsqu'il est utilisé avec des microcontrôleurs basés sur Atmel Atmega comme Arduino).
La désignation (Rf) fait référence à la résistance en série requise devant la DEL en fonction de la tension appliquée.
*Sur la carte, il y a la possibilité de souder directement la résistance requise. **L'emplacement pour souder la résistance est directement au-dessus des broches de connexion sur le PCB. Dans ce cas, on peut utiliser la broche du milieu, qui contient alors la résistance.
Affectation des broches
Exemple de code Raspberry Pi Pico
Affectation des broches Raspberryy Pi Pico
Raspberry Pi Pico | Expéditeur |
---|---|
GPIO17 | Signal |
3.3V | +V |
GND | GND |
A l'aide des deux modules capteurs KY-005 et KY-022 on peut construire un système avec télécommande infrarouge et récepteur infrarouge. Mais ici, nous n'utiliserons que l'émetteur avec un pico. Celui-ci fait alors office d'émetteur des signaux.
Pour l'exemple de code suivant, 4 bibliothèques supplémentaires sont nécessaires :
micropython-ir par Peter Hinch | publié sous la licence MIT.
micropython-async par Peter Hinch | publié sous la licence MIT.
Dans les systèmes de transmission infrarouge, il existe différents protocoles dans lesquels les données peuvent être envoyées. Dans l'exemple suivant, différents protocoles sont utilisés pour l'envoi. Documentation
Code pour l'émetteur
# Implémente une télécommande à 2 boutons sur un Pico avec répétition automatique.
# Chargement des bibliothèques
from machine import Pin
import uasyncio as asyncio
from primitives.switch import Switch
from primitives.delay_ms import Delay_ms
# Importation de toutes les classes implémentées
from ir_tx.nec import NEC
from ir_tx.sony import SONY_12, SONY_15, SONY_20
from ir_tx.philips import RC5, RC6_M0
######## **** DISPLAY GREETING **** ############################
s = '''Test for IR transmitter.
test() for NEC protocol
test(1) for Sony SIRC 12 bit
test(2) for Sony SIRC 15 bit
test(3) for Sony SIRC 20 bit
test(4) for Philips RC-5 protocol
test(5) for Philips RC-6 mode 0.
'''
srp2 = '''
IR LED gate on pin 17
Connect pin 18 to a ground pin to send addr 1 data 54
Connect pin 19 to a ground pin to send addr 0x10 data 0x34.'''
################################################################
loop = asyncio.get_event_loop()
# Si le "bouton" est maintenu enfoncé, le comportement normal est de retransmettre
# les données, mais la plupart des modèles NEC envoient un code REPEAT.
class Rbutton:
toggle = 1 # Le basculement est ignoré en mode NEC
def __init__(self, irb, pin, addr, data, proto):
self.irb = irb
self.sw = Switch(pin)
self.addr = addr
self.data = data
self.proto = proto
self.sw.close_func(self.cfunc)
self.sw.open_func(self.ofunc)
self.tim = Delay_ms(self.repeat)
def cfunc(self): # Appui sur un bouton : envoi de données
tog = 0 if self.proto < 3 else Rbutton.toggle # NEC, sony 12, 15: toggle==0
self.irb.transmit(self.addr, self.data, tog, True) # Test de validation
# Répétition automatique. Le protocole Sony spécifie 45 ms, mais c'est un peu juste.
# En mode 20 bits, une salve de données peut durer jusqu'à 39 ms.
self.tim.trigger(108)
def ofunc(self): # Button release: cancel repeat timer
self.tim.stop()
Rbutton.toggle ^= 1 # Toggle control
async def repeat(self):
await asyncio.sleep(0) # Let timer stop before retriggering
if not self.sw(): # Button is still pressed: retrigger
self.tim.trigger(108)
if self.proto == 0:
self.irb.repeat() # NEC special case: send REPEAT code
else:
tog = 0 if self.proto < 3 else Rbutton.toggle # NEC, sony 12, 15: toggle==0
self.irb.transmit(self.addr, self.data, tog, True) # Test validation
async def main(proto):
# Le test utilise une porteuse de 38KHz.
# Broche pour la porte LED IR
pin = Pin(17, Pin.OUT, value = 0)
# Liste de tous les protocoles possibles
classes = (NEC, SONY_12, SONY_15, SONY_20, RC5, RC6_M0)
irb = classes[proto](pin, 38000)
# Décommenter ce qui suit pour imprimer le temps de transmission
# irb.timeit = True
b = [] # Instances Rbutton
px3 = Pin(18, Pin.IN, Pin.PULL_UP)
px4 = Pin(19, Pin.IN, Pin.PULL_UP)
# modifier ces deux éléments pour obtenir l'effet, les données ou la commande souhaités #
b.append(Rbutton(irb, px3, 0x1, 0x36, proto))
b.append(Rbutton(irb, px4, 0x10, 0x34, proto))
#####################################################
led = Pin(25, Pin.OUT)
while True:
await asyncio.sleep_ms(500) # LED clignotante obligatoire.
led(not led())
# Fonction à appeler pour lancer l'envoi des données IR
def SendIRData(proto=0):
loop.run_until_complete(main(proto))
print(''.join((s, srp2)))
# Boucle sans fin pour un fonctionnement continu
while True:
SendIRData()