Arduino IRremote
Support for ESP 3.0 core
Une bibliothèque permettant l'envoi et la réception de signaux infrarouges.
Disponible en bibliothèque Arduino "IRremote".
? Google Traduction
Protocoles IR pris en charge
Caractéristiques
Nouvelles fonctionnalités avec la version 4.x
Nouvelles fonctionnalités avec la version 3.x
Conversion de votre programme 2.x vers la version 4.x
Comment convertir les anciens codes de données IR 32 bits MSB en nouveaux codes de données IR 32 bits LSB
Erreurs lors de l'utilisation des versions 3.x pour les anciens didacticiels
Rester sur 2.x
Pourquoi *.hpp au lieu de *.cpp
Utilisation des nouveaux fichiers *.hpp
Tutoriels
3 façons de spécifier un code IR
Brochage du récepteur IR
Réception des codes IR
Clause de non-responsabilité
Autres bibliothèques, qui peuvent couvrir ces protocoles
Protocole=PULSE_DISTANCE
Protocole=INCONNU
Comment gérer les protocoles non pris en charge par IRremote
decodedIRStructure des données
Des protocoles ambigus
Utilisation de la RAM de différents protocoles
Gestion des protocoles inconnus
Envoi de codes IR
Liste des bases de données publiques de codes IR
Envoi de codes IR IRDB
Envoyer le code PIN
Petit récepteur et émetteur NEC
Le protocole FAST
FAQ et conseils
La réception s'arrête après analogWrite() ou Tone() ou après avoir fait tourner un moteur
Indicateur de débordement des ensembles de réception
Problèmes avec Neopixels, FastLed etc.
Ne fonctionne pas/compile avec une autre bibliothèque
Plusieurs instances de récepteur et d'expéditeur IR
Augmenter la force du signal de sortie envoyé
Fréquence d'horloge minimale du processeur
Protocole Bang & Olufsen
Exemples pour cette bibliothèque
Exemples en ligne WOKWI
Contrôle IR d'une voiture robot
Problèmes et discussions
Compiler les options/macros pour cette bibliothèque
Modification des fichiers d'inclusion (*.h) avec l'IDE Arduino
Modification des options de compilation avec Sloeber IDE
Cartes prises en charge
Utilisation de la minuterie et des broches
Incompatibilités avec d'autres bibliothèques et commandes Arduino comme Tone() et analogWrite()
Génération de signal matériel-PWM pour l'envoi
Pourquoi utilisons-nous un cycle de service de 30 % pour l'envoi
Comment nous décodons les signaux
Diagrammes de codage NEC
Comparaison rapide de 5 bibliothèques de réception Arduino IR
Histoire
Liens utiles
Contributeurs
Licence
Droit d'auteur
NEC / Onkyo / Apple Denon / Sharp Panasonic / Kaseikyo
JVC LG RC5 RC6 Samsung Sony
Universal Pulse Distance Universal Pulse Width Universal Pulse Distance Width
Hash Pronto
BoseWave Bang & Olufsen Lego FAST Whynter MagiQuest
Les protocoles peuvent être activés et désactivés en définissant des macros avant la ligne #include <IRremote.hpp> comme ici :
#define DECODE_NEC//#define DECODE_DENON#include <IRremote.hpp>
Beaucoup de tutoriels et d'exemples.
Activement entretenu.
Permet la réception et l'envoi de données de synchronisation brutes .
Puisque la version 4.3, IrSender.begin(DISABLE_LED_FEEDBACK) ne fonctionnera plus , utilisez plutôt IrSender.begin(DISABLE_LED_FEEDBACK, 0) .
Ajout d'un nouveau décodeur universel Distance d'impulsion/Largeur d'impulsion/Largeur de distance d'impulsion , qui couvre de nombreux protocoles inconnus précédents.
Impression du code comment envoyer la commande reçue par IrReceiver.printIRSendUsage(&Serial) .
Le type RawData est désormais de 64 bits pour les plates-formes 32 bits et donc decodedIRData.decodedRawData peut contenir des informations de trame complètes pour plus de protocoles qu'avec 32 bits comme auparavant.
Rappel après réception d'une commande - Il appelle votre code dès qu'un message a été reçu.
Gestion améliorée des protocoles PULSE_DISTANCE + PULSE_WIDTH .
Nouveau protocole FAST.
Impression automatique de la fonction d'envoi correspondante avec printIRSendUsage() .
Vous devez remplacer #define DECODE_DISTANCE par #define DECODE_DISTANCE_WIDTH (uniquement si vous avez explicitement activé ce décodeur).
Le paramètre bool hasStopBit n'est plus requis et supprimé par exemple pour la fonction sendPulseDistanceWidth() .
N'importe quelle broche peut être utilisée pour la réception et si SEND_PWM_BY_TIMER n'est pas défini également pour l'envoi.
La LED de retour peut être activée pour l'envoi/la réception.
Une valeur de commande 8/16 bits ** ainsi qu'une adresse 16 bits et un numéro de protocole sont fournis pour le décodage (au lieu de l'ancienne valeur 32 bits).
Les valeurs du protocole sont conformes aux normes du protocole .
NEC, Panasonic, Sony, Samsung et JVC décodent et envoient d'abord le LSB.
Prend en charge le protocole Universal Distance , qui couvre de nombreux protocoles inconnus précédents.
Compatible avec la bibliothèque Tone() . Voir l'exemple de RecevoirDemo.
Envoi et réception simultanés. Voir l'exemple SendAndReceive.
Prend en charge plus de plates-formes .
Permet la génération d'un signal non PWM pour simplement simuler un signal de récepteur actif faible pour une connexion directe aux appareils de réception existants sans utiliser d'IR.
Configuration facile du protocole, directement dans votre code source .
Réduit l’empreinte mémoire et diminue le temps de décodage.
Contient un très petit décodeur NEC uniquement, qui ne nécessite aucune ressource de minuterie .
-> Comparaison des fonctionnalités de 5 bibliothèques Arduino IR.
À partir de la version 3.1, la génération de PWM pour l'envoi est effectuée par logiciel , économisant ainsi le minuteur matériel et permettant des broches de sortie arbitraires pour l'envoi .
Si vous utilisez un (ancien) noyau Arduino qui n'utilise pas l'indicateur -flto pour la compilation, vous pouvez activer la ligne #define SUPPRESS_ERROR_MESSAGE_FOR_BEGIN dans IRRemote.h, si vous obtenez de faux messages d'erreur concernant begin() lors de la compilation.
Les objets IRreceiver et IRsender ont été ajoutés et peuvent être utilisés sans les définir, comme l'objet bien connu Arduino Serial .
Supprimez simplement la ligne IRrecv IrReceiver(IR_RECEIVE_PIN); et/ou IRsend IrSender; dans votre programme et remplacez toutes les occurrences de IRrecv. ou irrecv. avec IrReceiver et remplacez tous IRsend ou irsend par IrSender .
Étant donné que les valeurs décodées sont désormais dans IrReceiver.decodedIRData et plus dans results , supprimez la ligne decode_results results ou similaire.
Comme pour l'objet Serial, appelez IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK) ou IrReceiver.begin(IR_RECEIVE_PIN, DISABLE_LED_FEEDBACK) au lieu de IrReceiver.enableIRIn() ou irrecv.enableIRIn() dans setup().
Pour l'envoi, appelez IrSender.begin(); dans configuration().
Si IR_SEND_PIN n'est pas défini (avant la ligne #include <IRremote.hpp> ), vous devez utiliser par exemple IrSender.begin(3, ENABLE_LED_FEEDBACK, USE_DEFAULT_FEEDBACK_LED_PIN);
L'ancienne fonction decode(decode_results *aResults) est remplacée par une simple decode() . Donc, si vous avez une instruction if(irrecv.decode(&results)) remplacez-la par if (IrReceiver.decode()) .
Le résultat décodé est maintenant dans IrReceiver.decodedIRData et plus dans results , remplacez donc toutes les occurrences de results.value et results.decode_type (et similaire) par IrReceiver.decodedIRData.decodedRawData et IrReceiver.decodedIRData.protocol .
Les indicateurs de débordement, de répétition et autres sont désormais dans IrReceiver.receivedIRData.flags .
Rarement utilisé : results.rawbuf et results.rawlen doivent être remplacés par IrReceiver.decodedIRData.rawDataPtr->rawbuf et IrReceiver.decodedIRData.rawDataPtr->rawlen .
Les 5 protocoles NEC, Panasonic, Sony, Samsung et JVC ont été convertis en LSB dans un premier temps. Les fonctions d'envoi pour l'envoi d'anciennes données MSB ont été renommées sendNECMSB , sendSamsungMSB() , sendSonyMSB() et sendJVCMSB() . Les anciennes fonctions MSB sendSAMSUNG() et sendSony() sont toujours disponibles. L'ancienne version MSB de la fonction sendPanasonic() a été supprimée, car elle contenait des bugs que personne n'a reconnus et était donc supposée ne jamais être utilisée.
Pour convertir les codes MSB en LSB, voir ci-dessous.
#include <IRremote.h>#define RECV_PIN 2IRrecv irrécv(RECV_PIN);
résultats decode_results ; configuration nulle ()
{
...
Série.begin(115200); // Établir une communication série
irrécv.enableIRIn(); // Démarrez le récepteur}void loop() { if (irrecv.decode(&results)) {
Serial.println(results.value, HEX);
...
irrécv.resume(); // Reçoit la valeur suivante
}
...
} #include <IRremote.hpp>#define IR_RECEIVE_PIN 2void setup()
{
...
Série.begin(115200); // // Établir une communication série
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK); // Démarre le récepteur}void loop() { if (IrReceiver.decode()) {
Serial.println (IrReceiver.decodedIRData.decodedRawData, HEX); // Imprimer les "anciennes" données brutes
IrReceiver.printIRResultShort(&Serial); // Imprimer les données complètes reçues sur une seule ligne
IrReceiver.printIRSendUsage(&Serial); // Imprime l'instruction requise pour envoyer ces données
...
IrReceiver.resume(); // Active la réception de la valeur suivante
}
...
} Pour les nouveaux décodeurs de NEC, Panasonic, Sony, Samsung et JVC , le résultat IrReceiver.decodedIRData.decodedRawData est désormais LSB-first , comme le suggère la définition de ces protocoles !
Pour convertir l'un en l'autre, vous devez inverser les positions d'octet/quartet, puis inverser toutes les positions de bits de chaque octet/quartet ou l'écrire sous la forme d'une chaîne binaire et l'inverser/le mettre en miroir.
Exemple : 0xCB 34 01 02
0x20 10 43 BC après quartet inversé
0x40 80 2C D3 après inversion de bit de chaque quartet
0->0 1->8 2->4 3->C 4->2 5->A 6->6 7->E 8->1 9->9 A->5 B->D C->3 D->B E->7 F->F
0xCB340102 est binaire 1100 1011 0011 0100 0000 0001 0000 0010 .
0x40802CD3 est binaire 0100 0000 1000 0000 0010 1100 1101 0011 .
Si vous lisez la première séquence binaire à l’envers (de droite à gauche), vous obtenez la deuxième séquence. Vous pouvez utiliser bitreverseOneByte() ou bitreverse32Bit() pour cela.
L'envoi d'anciens codes MSB sans conversion peut être effectué en utilisant sendNECMSB() , sendSonyMSB() , sendSamsungMSB() , sendJVCMSB() .
Si vous souffrez d'erreurs avec l'ancien code du didacticiel, notamment IRremote.h au lieu de IRremote.hpp , essayez simplement de revenir à la version 2.4.0.
Il est fort probable que votre code s'exécutera et que vous ne manquerez pas les nouvelles fonctionnalités.
Pensez à utiliser la version originale 2.4 de 2017 ou la dernière version 2.8 rétrocompatible pour votre projet.
Cela peut suffire et gère parfaitement les codes IR 32 bits.
Si cela ne correspond pas à votre cas, soyez assuré que 4.x essaie au moins d'être rétrocompatible, donc vos anciens exemples devraient toujours fonctionner correctement.
Seuls les décodeurs suivants sont disponibles :
NEC Denon Panasonic JVC LG
RC5 RC6 Samsung Sony
L'appel de irrecv.decode(&results) utilise les anciens premiers décodeurs MSB comme dans 2.x et définit les codes 32 bits dans results.value .
Pas de décodage vers une adresse 8/16 bits plus significative (constante) et une commande 8 bits.
Chaque fichier *.cpp est compilé séparément par un appel du compilateur exclusivement pour ce fichier cpp. Ces appels sont gérés par le système IDE/make. Dans l'IDE Arduino, les appels sont exécutés lorsque vous cliquez sur Verify ou Upload .
Et maintenant notre problème avec Arduino est le suivant :
Comment définir les options de compilation pour tous les fichiers *.cpp, en particulier pour les bibliothèques utilisées ?
Les IDE comme Sloeber ou PlatformIO prennent en charge cela en permettant de spécifier un ensemble d'options par projet. Ils ajoutent ces options à chaque appel du compilateur, par exemple -DTRACE .
Mais Arduino n'a pas cette fonctionnalité. La solution de contournement ne consiste donc pas à compiler toutes les sources séparément, mais à les concaténer en un seul énorme fichier source en les incluant dans votre source.
Cela se fait par exemple via #include "IRremote.hpp" .
Mais pourquoi ne pas #include "IRremote.cpp" ?
Essayez-le et vous verrez des tonnes d'erreurs, car chaque fonction du fichier *.cpp est maintenant compilée deux fois, d'abord en compilant l'énorme fichier et ensuite en compilant le fichier *.cpp séparément, comme décrit ci-dessus.
Ainsi, utiliser l'extension cpp n'est plus possible, et une solution consiste à utiliser hpp comme extension, pour montrer qu'il s'agit d'un fichier *.cpp inclus.
Toute autre extension, par exemple cinclude, ferait l'affaire, mais hpp semble relever du bon sens.
Afin de prendre en charge les options de compilation plus facilement, vous devez utiliser l'instruction #include <IRremote.hpp> au lieu de #include <IRremote.h> dans votre programme principal (alias fichier *.ino avec setup() et loop()).
Dans tous les autres fichiers, vous devez utiliser les éléments suivants, pour éviter les erreurs de l'éditeur de liens multiple definitions :
#define USE_IRREMOTE_HPP_AS_PLAIN_INCLUDE#include <IRremote.hpp>
Assurez-vous que toutes les macros de votre programme principal sont définies avant tout #include <IRremote.hpp> .
Dans le cas contraire, les macros suivantes seront définitivement remplacées par les valeurs par défaut :
RAW_BUFFER_LENGTH
IR_SEND_PIN
SEND_PWM_BY_TIMER
Une introduction très élaborée aux télécommandes IR et à la bibliothèque IRremote de DroneBot Workshop.
Il existe 3 manières différentes de spécifier un code IR particulier.
Le timing de chaque marque/impulsion et espace/distance_between_pulses est spécifié dans une liste ou un tableau. Cela permet de spécifier tous les codes IR , mais nécessite beaucoup de mémoire et n'est pas du tout lisible . Une définition formelle d'un tel tableau de synchronisation, incluant la spécification de la fréquence et des répétitions, est le format Pronto .
La mémoire peut être économisée en utilisant une résolution temporelle inférieure. Pour IRremote, vous pouvez utiliser une résolution de 50 µs qui réduit de moitié les besoins en mémoire en utilisant des valeurs d'octets au lieu de valeurs int16. À des fins de réception, vous pouvez utiliser le hachage du timing fourni par le décodeur decodeHash() .
Il existe 3 schémas de codage principaux qui codent un flux binaire binaire/une valeur hexadécimale :
PULSE_DISTANCE . La distance entre les impulsions détermine la valeur du bit. Cela nécessite toujours un peu d'arrêt ! Des exemples sont les protocoles NEC et KASEIKYO. La largeur d'impulsion est constante pour la plupart des protocoles.
PULSE_WIDTH . La largeur d'une impulsion détermine la valeur du bit, la distance des impulsions est constante. Cela ne nécessite aucun bit d'arrêt ! Le seul exemple connu est le protocole SONY.
Codage phase/Manchester. Le temps de transition impulsion/pause (phase) par rapport à l'horloge détermine la valeur du bit. Des exemples sont les protocoles RC5 et RC6.
Le codage de phase a une longueur de bit constante , PULSE_DISTANCE avec une largeur d'impulsion constante et PULSE_WIDTH n'a pas de longueur de bit constante !
Un exemple bien connu de PULSE_DISTANCE avec un codage à largeur d'impulsion non constante est le codage série RS232 . Ici, la largeur d'impulsion non constante est utilisée pour permettre une longueur de bit constante .
La plupart des signaux IR ont un en-tête spécial pour faciliter le réglage du gain automatique du circuit récepteur. Cet en-tête ne fait pas partie du codage, mais il est souvent significatif pour un protocole particulier et doit donc être reproductible.
Sachez qu'il existe des codes utilisant un codage PULSE_DISTANCE dans lequel plus d'un 0/1 binaire est placé dans une combinaison impulsion/pause. Cela nécessite plus de 2 combinaisons différentes de durées d’impulsion ou de pause. Le protocole HobToHood utilise un tel encodage.
L'utilisation de schémas de codage réduit la spécification d'un code IR à une valeur de flux binaire/hexadécimal, qui est LSB par défaut et aux timings d'impulsion/pause de l'en-tête, 0 et 1. La valeur hexadécimale est tout à fait lisible . Ces schémas ne peuvent mettre aucune sémantique comme une adresse, une commande ou une somme de contrôle sur ce flux binaire.
Il existe quelques protocoles courants qui sont implémentés directement dans IRremote. Ils spécifient la fréquence, les timings de l'en-tête, 0 et 1 ainsi que d'autres valeurs comme la somme de contrôle, la distance de répétition, le codage de répétition, le basculement de bits, etc. La sémantique de la valeur hexadécimale est également spécifiée, permettant l'utilisation de seulement 2 paramètres d'adresse. et commande pour spécifier un code IR. Cela économise de la mémoire et est très lisible . Souvent, l'adresse est également constante, ce qui réduit encore les besoins en mémoire.
Tutoriel sur le capteur IR Adafruit
Dans votre programme, vous recherchez une trame IR entièrement reçue avec :
if (IrReceiver.decode()) {}
Cela décode également les données reçues.
Après un décodage réussi, les données IR sont contenues dans la structure IRData, disponible sous le nom IrReceiver.decodedIRData .
struct IRData {protocole decode_type_t ; // Adresse INCONNUE, NEC, SONY, RC5, PULSE_DISTANCE, ... uint16_t ; // Adresse décodée, commande uint16_t ; // Commande décodée uint16_t extra ; // Utilisé pour l'ID de fournisseur inconnu Kaseikyo. Tiques utilisées pour décoder le protocole Distance. uint16_t nombre de bits ; // Nombre de bits reçus pour les données (adresse + commande + parité) - pour déterminer la longueur du protocole si différentes longueurs sont possibles. indicateurs uint8_t ; // IRDATA_FLAGS_IS_REPEAT, IRDATA_FLAGS_WAS_OVERFLOW etc. Voir les définitions de IRDATA_FLAGS_*
IRRawDataType decodedRawData ; // Jusqu'à 32 (64 bits pour les architectures CPU 32 bits) données brutes décodées, utilisées pour les fonctions sendRaw. uint32_t decodedRawDataArray[RAW_DATA_ARRAY_SIZE]; // Données brutes décodées 32 bits, à utiliser pour la fonction d'envoi.
irparams_struct *rawDataPtr; // Pointeur des données de timing brutes à décoder. Principalement le tampon de données rempli par la réception d'ISR.}; Il s'agit de la liste des drapeaux contenus dans le champ des drapeaux.
Vérifiez-le avec par exemple if(IrReceiver.decodedIRData.flags & IRDATA_FLAGS_IS_REPEAT) .
| Nom du drapeau | Description |
|---|---|
| IRDATA_FLAGS_IS_REPEAT | L'écart entre l'image précédente est aussi petit que l'écart maximum attendu pour une répétition. !!!Nous ne vérifions pas les modifications de commande ou d'adresse, car il est presque impossible d'appuyer sur 2 boutons différents de la télécommande en 100 ms environ !!! |
| IRDATA_FLAGS_IS_AUTO_REPEAT | La trame de répétition actuelle est une répétition, qui est toujours envoyée après une trame normale et ne peut être évitée. Uniquement spécifié pour les protocoles DENON, et LEGO. |
| IRDATA_FLAGS_PARITY_FAILED | La trame actuelle (répétition automatique) a violé le contrôle de parité. |
| IRDATA_FLAGS_TOGGLE_BIT | Est activé si le bit à bascule RC5 ou RC6 est activé. |
| IRDATA_FLAGS_EXTRA_INFO | Il existe des informations supplémentaires non contenues dans l'adresse et les données (par exemple, ID de fournisseur inconnu Kaseikyo ou dans decodedRawDataArray). |
| IRDATA_FLAGS_WAS_OVERFLOW | Trop de marques et d'espaces pour le RAW_BUFFER_LENGTH spécifié. Pour éviter un signalement sans fin de débordement, irparams.rawlen est défini sur 0 dans ce cas. |
| IRDATA_FLAGS_IS_MSB_FIRST | Cette valeur est principalement déterminée par le protocole (connu). |
auto myRawdata= IrReceiver.decodedIRData.decodedRawData ;
Les définitions des IrReceiver.decodedIRData.flags sont décrites ici.
IrReceiver.printIRResultShort(&Serial);
IrReceiver.printIRResultRawFormatted(&Serial, true);`
Les données brutes dépendent de l'état interne du timer Arduino par rapport au signal reçu et peuvent donc être légèrement différentes à chaque fois. (problème de résolution). Les valeurs décodées sont celles interprétées qui tolèrent de si légères différences !
IrReceiver.printIRSendUsage(&Serial);
Le protocole NEC est défini comme une adresse 8 bits et une commande 8 bits. Mais l'adresse physique et les champs de données ont chacun une largeur de 16 bits. Les 8 bits supplémentaires sont utilisés pour envoyer l'adresse inversée ou la commande pour le contrôle de parité.
Le protocole NEC étendu utilise les 8 bits de parité supplémentaires de l'adresse pour une adresse de 16 bits, désactivant ainsi le contrôle de parité de l'adresse.
Le protocole ONKYO utilise à son tour les 8 bits de parité supplémentaires d'adresse et de commande pour une adresse et une commande de 16 bits.
Le décodeur réduit les valeurs de 16 bits à celles de 8 bits si la parité est correcte. Si la parité n'est pas correcte, il ne suppose aucune erreur de parité, mais prend les valeurs comme des valeurs de 16 bits sans parité en supposant un protocole NEC étendu ou un protocole NEC étendu.
Mais maintenant nous avons un problème lorsque nous voulons recevoir par exemple l'adresse 16 bits 0x00FF ou 0x32CD ! Le décodeur interprète cela comme une adresse NEC 8 bits 0x00 / 0x32 avec une parité correcte de 0xFF / 0xCD et la réduit à 0x00 / 0x32.
Une façon de gérer cela consiste à forcer la bibliothèque à toujours utiliser l'interprétation du protocole ONKYO en utilisant #define DECODE_ONKYO . Une autre façon consiste à vérifier si IrReceiver.decodedIRData.protocol est NEC et non ONKYO et d'annuler la réduction de parité manuellement.
Lors d'un appui long, le protocole NEC ne répète pas sa trame, il envoie une trame de répétition courte spéciale. Cela permet de distinguer facilement les appuis longs et les appuis répétés et d'économiser un peu d'énergie de la batterie. Ce comportement est tout à fait unique pour NEC et ses protocoles dérivés comme LG et Samsung.
Mais bien sûr, il existe également des systèmes de contrôle à distance, qui utilisent le protocole NEC mais ne répètent la première image que lorsqu'un appui long est effectué au lieu d'envoyer la trame de répétition courte spéciale. Nous l'avons nommé protocole NEC2 et il est envoyé avec sendNEC2() .
Mais attention, le protocole NEC2 ne peut être détecté par le décodeur de la bibliothèque NEC qu'après la première image et si vous faites un appui long !
Lors d'un appui long, le protocole SamsungLG ne répète pas sa trame, il envoie une trame de répétition courte spéciale.
Le RAW_BUFFER_LENGTH détermine la longueur du tampon d'octets dans lequel les données de synchronisation IR reçues sont stockées avant le décodage.
100 est suffisant pour les protocoles standard jusqu'à 48 bits , avec 1 bit composé d'une marque et d'un espace. Nous avons toujours besoin de 4 octets supplémentaires, 1 octet pour l'espace initial, 2 octets pour l'en-tête et 1 octet pour le bit d'arrêt.
Les protocoles 48 bits sont PANASONIC, KASEIKYO, SAMSUNG48, RC6.
Les protocoles 32 bits comme NEC, SAMSUNG, WHYNTER, SONY(20), LG(28) nécessitent une longueur de tampon de 68 .
Les protocoles 16 bits comme BOSEWAVE, DENON, FAST, JVC, LEGO_PF, RC5, SONY(12 ou 15) nécessitent une longueur de tampon de 36 .
MAGIQUEST nécessite une longueur de tampon de 112 .
Les climatiseurs envoient souvent un flux de données de protocole plus long, jusqu'à 750 bits .
Si l'intervalle d'enregistrement déterminé par RECORD_GAP_MICROS passe de 8 ms par défaut à plus de 20 ms, le tampon n'est plus un octet mais un tampon uint16_t, nécessitant deux fois plus de RAM.
Cette bibliothèque a été conçue pour s'intégrer dans des MCU avec des niveaux de ressources relativement faibles et était destinée à fonctionner comme une bibliothèque avec d'autres applications qui nécessitent également certaines ressources du MCU pour fonctionner.
Utilisez l' exemple ReceiverDemo pour imprimer toutes les informations sur votre protocole IR.
L' exemple de ReceiverDump vous donne plus d'informations mais a une mauvaise détection de répétition en raison du temps requis pour imprimer les informations.
Si votre protocole ne semble pas être pris en charge par cette bibliothèque, vous pouvez essayer la bibliothèque IRMP, qui prend en particulier bien mieux en charge les protocoles de Manchester.
Pour les climatiseurs , vous pouvez essayer la bibliothèque IRremoteESP8266, qui prend en charge un ensemble impressionnant de protocoles et de nombreux climatiseurs et fonctionne également sur ESP32.
Raw-IR-decoder-for-Arduino n'est pas une bibliothèque, mais un exemple de croquis Arduino, qui fournit de nombreuses méthodes de décodage, en particulier les protocoles de climatiseur . L'envoi de ces protocoles peut être effectué par la librairie Arduino HeatpumpIR.
Si vous obtenez quelque chose comme ceci :
PULSE_DISTANCE: HeaderMarkMicros=8900 HeaderSpaceMicros=4450 MarkMicros=550 OneSpaceMicros=1700 ZeroSpaceMicros=600 NumberOfBits=56 0x43D8613C 0x3BC3BC
alors vous avez un code composé de 56 bits , qui provient probablement d'une télécommande de climatiseur.
Vous pouvez l'envoyer avec sendPulseDistanceWidth() .
uint32_t tRawData[] = { 0xB02002, 0xA010 } ;
IrSender.sendPulseDistance(38, 3450, 1700, 450, 1250, 450, 400, &tRawData[0], 48, false, 0, 0); Vous pouvez l'envoyer en appelant sendPulseDistanceWidthData() deux fois, une fois pour les 32 premiers bits et ensuite pour les 24 bits restants.
Le décodeur PULSE_DISTANCE / PULSE_WIDTH décode simplement un flux de synchronisation en un flux binaire stocké sous forme de valeurs hexadécimales. Ces décodeurs ne peuvent mettre aucune sémantique comme une adresse, une commande ou une somme de contrôle sur ce flux binaire. Mais le flux binaire est bien plus lisible qu’un flux temporel. Ce flux binaire est lu en premier LSB par défaut . Si le LSB ne convient pas à des recherches ultérieures, vous pouvez le modifier ici.
Si la RAM ne dépasse pas 2 Ko, le décodeur n'accepte que des durées de marquage ou d'espace jusqu'à 2 500 microsecondes pour économiser de l'espace RAM, sinon il accepte des durées jusqu'à 10 ms.
Si vous voyez quelque chose comme Protocol=UNKNOWN Hash=0x13BD886C 35 bits received en sortie de, par exemple, l'exemple de ReceiverDemo, vous avez soit un problème de décodage d'un protocole, soit un protocole non pris en charge.
Si vous recevez un nombre impair de bits , votre circuit récepteur a probablement des problèmes. Peut-être parce que le signal IR est trop faible.
Si vous voyez des timings comme + 600,- 600 + 550,- 150 + 200,- 100 + 750,- 550 alors un espace de 450 µs a été divisé en deux espaces de 150 et 100 µs avec un signal de pointe/erreur de 200 µs entre. Peut-être à cause d'un récepteur défectueux ou d'un signal faible en conjonction avec une autre source électroluminescente à proximité.
Si vous voyez des timings comme + 500,- 550 + 450,- 550 + 450,- 500 + 500,-1550 , alors les marques sont généralement plus courtes que les espaces et donc MARK_EXCESS_MICROS (spécifié dans votre fichier ino) devrait être négatif pour compenser cela. au décodage.
Si vous voyez Protocol=UNKNOWN Hash=0x0 1 bits received il se peut que l'espace après la marque initiale soit plus long que RECORD_GAP_MICROS . Cela a été observé pour certains protocoles de climatiseurs LG. Réessayez avec une ligne par exemple #define RECORD_GAP_MICROS 12000 avant la ligne #include <IRremote.hpp> dans votre fichier .ino.
Pour voir plus d'informations vous aidant à trouver la raison de votre protocole INCONNU, vous devez activer la ligne //#define DEBUG dans IRremoteInt.h.
Si vous ne savez pas quel protocole utilise votre émetteur IR, vous avez plusieurs choix.
Utilisez simplement la valeur de hachage pour décider quelle commande a été reçue. Voir l'exemple SimpleReceiverForHashCodes.
Utilisez l’exemple IRreceiveDemo ou IRreceiveDump pour extraire la synchronisation IR. Vous pouvez ensuite reproduire/envoyer ce timing avec l'exemple SendRawDemo.
L'exemple IRMP AllProtocol imprime le protocole et les données pour l'un des 40 protocoles pris en charge . La même bibliothèque peut être utilisée pour envoyer ces codes.
Si vous disposez d'une carte Arduino plus grande (> 100 Ko de mémoire programme), vous pouvez essayer l'exemple IRremoteDecode de la bibliothèque Arduino DecodeIR.
Utilisez IrScrutinizer. Il peut générer automatiquement un croquis d'envoi pour votre protocole en l'exportant sous "Arduino Raw". Il prend en charge IRremote, l'ancien IRLib et Infrared4Arduino.
Si vous disposez d'un appareil capable de générer les codes IR avec lesquels vous souhaitez travailler (c'est-à-dire une télécommande IR), il est recommandé de recevoir les codes avec l'exemple ReceiverDemo, qui vous indiquera sur la sortie série comment les envoyer.
Protocol=LG Address=0x2 Command=0x3434 Raw-Data=0x23434E 28 bits MSB first Send with: IrSender.sendLG(0x2, 0x3434, <numberOfRepeats>);
Vous découvrirez que l'adresse est une constante et que les commandes sont parfois judicieusement regroupées.
Si vous n'êtes pas sûr du nombre de répétitions à utiliser pour l'envoi, 3 est un bon point de départ. Si cela fonctionne, vous pouvez vérifier les valeurs inférieures par la suite.
Si vous avez activé DECODE_DISTANCE_WIDTH , le code imprimé par printIRSendUsage() diffère entre les plates-formes 8 et 32 bits , il est donc préférable d'exécuter le programme de réception sur la même plate-forme que le programme d'envoi.
Toutes les fonctions d'envoi prennent en charge l'envoi de répétitions si cela est judicieux. Les trames répétées sont envoyées à une période fixe déterminée par le protocole. par exemple 110 ms du début au début pour NEC.
Gardez à l’esprit qu’il n’y a aucun délai après la dernière marque envoyée . Si vous gérez vous-même l'envoi de trames répétées, vous devez insérer des délais raisonnables avant les trames répétées pour permettre un décodage correct.
L'envoi d'anciens codes MSB sans conversion peut être effectué en utilisant sendNECMSB() , sendSonyMSB() , sendSamsungMSB() , sendJVCMSB() .
Les codes trouvés dans la base de données Flipper-IRDB sont assez simples à convertir, car ils utilisent également le schéma adresse/commande.
La correspondance de protocole est NECext -> NECext (ou Onkyo), Samsung32 -> Samsung, SIRC20 -> Sony avec 20 bits, etc.
Les codes trouvés dans la base de données irdb spécifient un périphérique , un sous-périphérique et une fonction . La plupart du temps, le périphérique et le sous-périphérique peuvent être considérés comme octets supérieurs et inférieurs du paramètre d'adresse et la fonction est le paramètre de commande pour les nouvelles fonctions structurées avec des paramètres d'adresse, de commande et de comptage de répétitions comme par exemple IrSender.sendNEC((device << 8) | subdevice, 0x19, 2) .
Un mappage exact peut être trouvé dans les fichiers de définition IRP pour les protocoles IR. "D" et "S" désignent l'appareil et le sous-appareil et "F" désigne la fonction.
N'importe quelle broche peut être choisie comme broche d'envoi, car le signal PWM est généré par défaut avec un bit banging logiciel, puisque SEND_PWM_BY_TIMER n'est pas actif.
Sur l'ESP32 LEDC, le canal 0 est utilisé pour générer l'IR PWM.
Si IR_SEND_PIN est spécifié (en tant que macro c), cela réduit la taille du programme et améliore le timing d'envoi pour AVR. Si vous souhaitez utiliser une variable pour spécifier le code PIN d'envoi, par exemple avec setSendPin(uint8_t aSendPinNumber) , vous devez désactiver cette macro IR_SEND_PIN . Ensuite, vous pouvez modifier la broche d'envoi à tout moment avant d'envoyer une trame IR. Voir aussi Options de compilation/macros pour cette bibliothèque.
http://www.harctoolbox.org/IR-resources.html
Base de données Flipper IRDB
| Décodage flipper | Décodage à distance |
|---|---|
| Samsung32 | Samsung |
| NEC | NEC |
| NECuivant | ONKYO |
| <bit de démarrage><VendorID:16><VendorID parité:4><Genre1:4><Genre2:4><Command:10><ID:2><Parité:8><stop bit> et l'ID est le MSB de l'adresse. adresse : 8A 02 20 00 commande : 56 03 00 00 -> IRtélécommande : Adresse 0x6A8, sendPanasonic (pour 02 20) et commande 0x35 | <bit de démarrage><VendorID :16><Parité de l'ID du fournisseur :4><Adresse :12><Commande :8><Parité de la parité de l'ID du fournisseur, de l'adresse et de la commande :8><bit d'arrêt> |
Pour les applications nécessitant uniquement le protocole NEC, les variantes NEC ou FAST -voir ci-dessous-, un récepteur/expéditeur spécial est inclus, qui a une très petite taille de code de 500 octets et ne nécessite AUCUNE minuterie .
Au lieu d'échantillonner l'entrée toutes les 50 µs comme le fait IRremote, le récepteur TinyReceiver utilise une interruption de changement de broche pour le décodage à la volée, ce qui limite le choix des protocoles.
A chaque changement de niveau, le niveau et le temps écoulé depuis le dernier changement sont utilisés pour décoder progressivement le protocole.
Avec ce principe de fonctionnement, on ne peut pas attendre un timeout puis décoder le protocole comme le fait IRremote.
Au lieu de cela, nous devons savoir quel est le dernier bit (changement de niveau) d'un protocole pour effectuer le décodage final et l'appel de la fonction de rappel facultative fournie par l'utilisateur handleTinyReceivedIRData() .
Cela signifie que nous devons connaître le nombre de bits d'un protocole et donc le protocole (famille).
Consultez les exemples TinyReceiver et IRDispatcherDemo.
Veillez à inclure TinyIRReceiver.hpp ou TinyIRSender.hpp au lieu de IRremote.hpp .
//#define USE_ONKYO_PROTOCOL // Comme NEC, mais prenez l'adresse et la commande 16 bits chacune comme une valeur de 16 bits et non comme une valeur normale de 8 bits et une valeur inversée de 8 bits.//#define USE_FAST_PROTOCOL // Utiliser le protocole FAST au lieu de NEC / ONKYO#include "TinyIRReceiver.hpp"void setup() { initPCIInterruptForTinyReceiver(); // Permet la génération d'interruptions lors du changement du signal d'entrée IR}void loop() { if (TinyReceiverDecode()) { printTinyReceiverResultMinimal(&Serial);
} // Aucun CV requis :-)} #include "TinyIRSender.hpp"void setup() { sendNEC(3, 0, 11, 2); // Envoie l'adresse 0 et la commande 11 sur la broche 3 avec 2 répétitions.}void loop() {}Un autre petit récepteur et expéditeur prenant en charge davantage de protocoles peut être trouvé ici.
Le protocole FAST est un protocole propriétaire JVC modifié sans adresse, avec parité et avec un en-tête plus court . Il est censé avoir une réponse rapide à l'événement qui a envoyé la trame de protocole sur une autre carte. FAST prend 21 ms pour l'envoi et est envoyé toutes les 50 ms . Il a une parité complète de 8 bits pour la détection des erreurs.
Le timing des bits est comme JVC
L'en-tête est plus court, 3 156 µs contre 12 500 µs
Aucune adresse et données 16 bits, interprétées comme une commande 8 bits et une commande inversée 8 bits, conduisant à une longueur de protocole fixe de (6 + (16 * 3) + 1) * 526 = 55 * 526 = 28930 microsecondes ou 29 ms.
Les répétitions sont envoyées sous forme de trames complètes mais dans une période de 50 ms / avec une distance de 21 ms.
#define IR_SEND_PIN 3#include <IRremote.hpp>void setup() { sendFAST(11, 2); // Envoie la commande 11 sur la broche 3 avec 2 répétitions.}void loop() {} #define USE_FAST_PROTOCOL // Utiliser le protocole FAST. Aucune adresse et données 16 bits, interprétées comme une commande 8 bits et une commande inversée 8 bits#include "TinyIRSender.hpp"void setup() { sendFAST(3, 11, 2); // Envoie la commande 11 sur la broche 3 avec 2 répétitions.}void loop() {}Le protocole FAST peut être reçu par IRremote et TinyIRReceiver.
L'intervalle d'échantillonnage du récepteur de 50 µs est généré par une minuterie. Sur de nombreuses planches, cela doit être une minuterie matérielle. Sur certaines planches où un temporisateur de logiciel est disponible, le temporisateur du logiciel est utilisé.
Sachez que la minuterie matérielle utilisée pour la réception ne doit pas être utilisée pour analogWrite() .
En particulier, le contrôle du moteur utilise souvent la fonction analogWrite() et arrêtera donc la réception si elle est utilisée sur les broches indiquées ici.
Sur l'UNO et d'autres planches AVR, le temporisateur du récepteur est le même que le temporisateur de tonalité. Ainsi, la réception s'arrêtera après une commande tone() . Voir EXEMPLE RESOINSEMO Comment y faire face, c'est-à-dire comment utiliser IrReceiver.restartTimer() .
L'indicateur IRDATA_FLAGS_WAS_OVERFLOW est défini, si RAW_BUFFER_LENGTH est trop petit pour toutes les marques et espaces du protocole. Cela peut se produire sur de longs cadres de protocole comme ceux du climatiseur. Cela peut également se produire, si RECORD_GAP_MICROS est plus petit que l'écart réel entre une trame et un cadre de répétition THR, interprétant ainsi les deux comme un cadre consécutif. Le meilleur est de vider le timing alors, pour voir quelle raison est valable.
Iremote ne fonctionnera pas correctement lorsque vous utilisez des néopixels (aka WS2811 / WS2812 / WS2812B) ou d'autres bibliothèques bloquant les interruptions plus longtemps (> 50 µs).
Que vous utilisiez la LIB Adafruit Neopixel ou Fastled, les interruptions sont désactivées sur de nombreux processeurs de base comme les arduinos de base pendant plus de 50 µs. À son tour, cela empêche le gestionnaire d'interruption IR de fonctionner quand il en a besoin. Voir aussi cette vidéo.
Une solution de contournement consiste à attendre que le récepteur IR soit inactif avant d'envoyer les données de néopixels avec if (IrReceiver.isIdle()) { strip.show();} .
Cela empêche le moins de briser une transmission IR et de détendre le taux de mise à jour du néopixel - peut très bien fonctionner.
Il y a d'autres solutions à cela sur des processeurs plus puissants, voir cette page de Marc Merlin
Une autre bibliothèque ne fonctionne / compilation que si vous désactivez la ligne IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK); .
Cela est souvent dû à des conflits de ressources de temporisation avec l'autre bibliothèque. Veuillez voir ci-dessous.
Cette bibliothèque ne prend en charge qu'un seul récepteur IR et un objet Sender IR (IRRECV et IRSEND) par CPU.
Cependant, comme l'envoi est une tâche série, vous pouvez utiliser setSendPin() pour changer le broche à envoyer, émulant ainsi plusieurs expéditeurs.
Le récepteur utilise une fonction déclenchée de minuterie spéciale, qui lit la valeur du signal IR numérique à partir d'une broche tous les 50 µs.
Ainsi, plusieurs récepteurs IR ne peuvent être utilisés qu'en connectant les broches de sortie de plusieurs récepteurs IR ensemble. Les modules du récepteur IR utilisent en interne un transistor NPN comme dispositif de sortie avec seulement une résistance de 30K à VCC. Il s'agit essentiellement d'un "collecteur ouvert" et permet à plusieurs broches de sortie d'être connectées à une broche d'entrée Arduino.
Cependant, gardez à l'esprit que tout signal faible / perturbé de l'un des récepteurs interférera également avec un bon signal d'un autre récepteur.
La meilleure façon d'augmenter la puissance IR gratuitement est d'utiliser 2 ou 3 diodes IR en série. Une diode nécessite 1,2 volt à 20 mA ou 1,5 volt à 100 mA afin que vous puissiez fournir jusqu'à 3 diodes avec une sortie de 5 volts.
Pour alimenter 2 diodes avec 1,2 V et 20 mA et une alimentation 5 V, définissez la résistance à: (5 V - 2,4 V) -> 2,6 V / 20 mA = 130 Ω .
Pour 3 diodes, il nécessite 1,4 v / 20 mA = 70 Ω .
Le courant réel pourrait être plus faible car la perte à la broche AVR . Par exemple 0,3 V à 20 mA.
Si vous n'avez pas besoin de plus de courant que 20 Ma, il n'est pas nécessaire d'utiliser un transistor externe (au moins pour les puces AVR).
Sur mes nanos Arduino, j'utilise toujours une résistance de la série de 100 Ω et une LED IR ?.
Pour la réception, la fréquence minimale de l'horloge du CPU est de 4 MHz , car la minuterie ISR de 50 µs (routine de service d'interruption) prend environ 12 µs sur un atmga de 16 MHz.
Le Tinyreceiver, qui ne nécessite aucun sondage, fonctionne avec 1 MHz.
Pour l'envoi, le logiciel par défaut PWM a des problèmes sur AVR en cours d'exécution avec 8 MHz . La fréquence PWM est d'environ 30 au lieu de 38 kHz et RC6 n'est pas fiable. Vous pouvez passer à la génération PWM de Timer par #define SEND_PWM_BY_TIMER .
Le décodeur de protocole Bang & Olufsen n'est pas activé par défaut, c'est-à-dire si aucun protocole n'est activé explicitement par #define DECODE_<XYZ> . Il doit toujours être activé explicitement par #define DECODE_BEO . En effet, il a une fréquence de transmission IR de 455 kHz et nécessite donc un matériel récepteur différent (TSOP7000).
Et parce que la génération d'un signal PWM de 455 kHz n'est actuellement implémentée que pour SEND_PWM_BY_TIMER , l'envoi ne fonctionne que si SEND_PWM_BY_TIMER ou USE_NO_SEND_PWM est défini.
Pour plus d'informations, voir ir_bangolufsen.hpp.
Les exemples sont disponibles dans le fichier> Exemples> Exemples des bibliothèques personnalisées / INMEMOTE.
Afin d'adapter les exemples au Flash 8K d'Attiny85 et Attiny88, la bibliothèque Arduino ATtinySerialout est requise pour ce processeur.
Voir aussi DroneBot Workshop Simplereceiver et SimpleSender.
Les exemples Simplereceiver et SimpleSender sont un bon point de départ. Un exemple simple peut être testé en ligne avec Wokwi.
Les SimplereCeiverForHashcodes utilisent uniquement le décodeur de hachage. Il convertit tous les trames IR de plus de 6 en un code de hachage 32 bits, permettant ainsi la réception de protocoles inconnus.
Voir: http://www.righto.com/2010/01/using-arbitrary-remotes-with-arduino.html
Si la taille du code ou l'utilisation de la minuterie compte, regardez ces exemples.
L'exemple TinyReceiver utilise la bibliothèque TinyirReceiver qui ne peut recevoir que des protocoles NEC, NEC, onkyo et rapides étendus, mais ne nécessite aucune minuterie . Ils utilisent une interruption de changement de broche pour le décodage de la mouche, ce qui est la raison du choix du protocole restreint.
Tinyreceiver peut être testé en ligne avec Wokwi.
L'exemple TinySender utilise la bibliothèque TinyirSender qui ne peut envoyer que des protocoles NEC, Onkyo et Fast .
Il envoie des codes de protocole NEC en format standard avec une adresse 8 bits et une commande 8 bits comme dans un exemple simpleder. Il a des options à envoyer en utilisant des protocoles NEC, Onkyo et Fast Extended NEC et Fast. Économise 780 octets de la mémoire du programme et 26 octets RAM par rapport à SimpleSender, qui fait de même, mais utilise la bibliothèque Intemote (et est donc beaucoup plus flexible).
Si le protocole n'est pas NEC et que la taille du code compte, regardez cet exemple.
Resenemo reçoit tous les protocoles et génère un bip avec la fonction Arduino Tone () sur chaque paquet reçu.
Une longue pression sur un bouton IR (réception de plusieurs répétitions pour une commande) est détectée.
AllProtoColSonlcd affiche en outre le résultat court sur un LCD 1602 . L'écran LCD peut être connecté parallèle ou en série (I2C).
En connectant la broche de débogage à la terre, vous pouvez forcer l'impression des valeurs brutes pour chaque cadre. Le numéro de broche de la broche de débogage est imprimé lors de la configuration, car il dépend à bord et au type de connexion LCD.
Cet exemple sert également d' exemple comment utiliser Intremote et Tone () ensemble .
Reçoit tous les protocoles et vide le signal reçu dans différentes saveurs, y compris le format pronto. Étant donné que l'impression prend beaucoup de temps, les signaux répétés peuvent être ignorés ou interprétés comme inconnus.
Envoie tous les protocoles disponibles au moins une fois.
Démontre la réception lors de l'envoi .
Enregistrer et lire le dernier signal IR a reçu à Button Appuyer. Les cadres IR des protocoles connus sont envoyés par le codeur de protocole approprié. Les cadres de protocole UNKNOWN sont stockés sous forme de données brutes et envoyés avec sendRaw() .
Essayez de décoder chaque trame IR avec le décodeur Universal Distancewidth, stockez les données et envoyez-les sur le bouton Appuyez sur sendPulseDistanceWidthFromArray() .
Si la RAM n'est pas supérieure à 2k, le décodeur accepte uniquement les durées de marque ou d'espace jusqu'à 2500 microsecondes pour économiser l'espace RAM, sinon il accepte des durées jusqu'à 10 ms.
Le stockage des données pour la largeur de distance du protocole nécessite 17 octets. L'exemple de reçue-effectif nécessite 16 octets pour les données de protocole connues et 37 octets pour les données brutes du protocole EGNEC.
Sert d' expanseur macro distant IR. Reçoit le protocole SAMSUNG32 et lors de la réception d'une trame d'entrée spécifiée, il envoie plusieurs trames Samsung32 avec des retards appropriés entre les deux. Cela sert d'émulation à clé Netflix pour mon ancien téléviseur Samsung H5273.
Framework pour appeler différentes fonctions de votre programme pour différents codes IR.
Contrôlez un relais (connecté à une broche de sortie) avec votre télécommande.
Exemple pour une classe définie par l'utilisateur, qui utilise elle-même la classe IrreCV à partir d'irremote.
Exemple pour l'envoi de codes IR de climatiseur LG contrôlés par entrée série.
En utilisant simplement la fonction bool Aircondition_LG::sendCommandAndParameter(char aCommand, int aParameter) vous pouvez contrôler le climatiseur par toute autre source de commande.
Le fichier ACLG.h contient la documentation de commande du protocole IR Air Conditionneur LG. Basé sur l'ingénierie inverse de la télécommande LG AKB73315611.
Ireceivertiminganysis peut être testé en ligne avec Wokwi Cliquez sur le récepteur pendant que la simulation est en cours d'exécution pour spécifier les codes IR individuels.
Exemple pour recevoir et envoyer un protocole AEG / Elektrolux Hob2hood.
Cet exemple analyse le signal délivré par votre module de récepteur IR. Les valeurs peuvent être utilisées pour déterminer la stabilité du signal reçu ainsi qu'un indice pour déterminer le protocole.
Il calcule également la valeur MARK_EXCESS_MICROS , qui est l'extension de la durée de marque (impulsion) introduite par le module du récepteur IR.
Il peut être testé en ligne avec Wokwi. Cliquez sur le récepteur pendant que la simulation est en cours d'exécution pour spécifier les codes IR NEC individuels.
Resenemo + Senddemo dans un seul programme. Démontre la réception lors de l'envoi . Ici, vous voyez le retard de la sortie du récepteur (bleu) de l'entrée de la diode IR (jaune). 
Récepteur simple
Togue simple par IR Key 5
Tinyreceiver
Réception de l'analyse
Récepteur avec sortie LCD et instruction Switch
Cet exemple de la bibliothèque Arduino PWMmotorControl contrôle les fonctions de base d'une voiture de robot à l'aide de la bibliothèque Iremote.
Il contrôle 2 canaux de moteur PWM, 2 moteurs à chaque canal.
Ici, vous pouvez trouver l'instructable pour l'assemblage et le code de la voiture.
IR_ROBOTCAR avec le récepteur IR TL1838 branché sur la carte d'extension. 
N'ouvrez pas de problème sans tester d'abord certains des exemples!
Si vous avez un problème, veuillez publier le MCVE (exemple complet de vérifiable complet) montrant ce problème. Mon expérience est que la plupart du temps vous trouverez le problème lors de la création de ce MCVE ?.
Utiliser des blocs de code; Cela nous aide à vous aider lorsque nous pouvons lire votre code!
Pour personnaliser la bibliothèque à différentes exigences, certaines options de compilation / macros sont disponibles.
Ces macros doivent être définies dans votre programme avant la ligne #include <IRremote.hpp> pour prendre effet.
Les modifier en leur activant / désactivant ou modifiez les valeurs le cas échéant.
| Nom | Valeur par défaut | Description |
|---|---|---|
RAW_BUFFER_LENGTH | 200 | Taille du tampon de l'entrée brute Uint16_t tampon. Doit être uniforme! S'il est trop petit, un drapeau de débordement sera défini. 100 est suffisant pour des protocoles réguliers allant jusqu'à 48 bits, mais pour la plupart des protocoles de climatiseur, une valeur allant jusqu'à 750 est nécessaire. Utilisez l'exemple Reçuump pour trouver la plus petite valeur pour vos exigences. Une valeur de 200 nécessite 200 octets RAM. |
EXCLUDE_UNIVERSAL_PROTOCOLS | désactivé | Exclut le décodeur universel pour les protocoles de largeur de distance d'impulsion et le décode de décode (décodeur spécial pour tous les protocoles) de decode() . Économise jusqu'à 1000 octets de la mémoire du programme. |
DECODE_<Protocol name> | tous | Sélection du ou des protocoles individuels à décoder. Vous pouvez spécifier plusieurs protocoles. Voir ici |
DECODE_STRICT_CHECKS | désactivé | Vérifiez les caractéristiques supplémentaires requises de la synchronisation du protocole comme la longueur de la marque pour un protocole de marque constante, où la longueur de l'espace détermine la valeur du bit. Nécessite jusqu'à 194 octets supplémentaires de la mémoire du programme. |
IR_REMOTE_DISABLE_RECEIVE_COMPLETE_CALLBACK | désactivé | Économise jusqu'à 60 octets de la mémoire du programme et 2 octets RAM. |
MARK_EXCESS_MICROS | 20 | Mark_Excess_micros est soustrait de toutes les marques et ajouté à tous les espaces avant le décodage, pour compenser la formation de signal de différents modules de récepteur IR. |
RECORD_GAP_MICROS | 5000 | Écart minimum entre les transmissions IR, pour détecter la fin d'un protocole. Doit être supérieur à tout espace de protocole, par exemple l'espace d'en-tête NEC de 4500 µs. Doit être plus petit que n'importe quel écart entre une commande et une répétition; Par exemple, l'écart de retransmission de Sony est d'environ 24 ms. Gardez à l'esprit que c'est le retard entre la fin de la commande reçue et le début du décodage. |
DISTANCE_WIDTH_DECODER_DURATION_ARRAY_SIZE | 50 Si RAM <= 2K, sinon 200 | Une valeur de 200 permet de décoder des durées de marque ou d'espace jusqu'à 10 ms. |
IR_INPUT_IS_ACTIVE_HIGH | désactivé | Activez-le si vous utilisez un récepteur RF, qui a un signal de sortie élevé actif. |
IR_SEND_PIN | désactivé | S'il est spécifié, il réduit la taille du programme et améliore l'envoi de timing pour AVR. Si vous souhaitez utiliser une variable pour spécifier d'envoyer la broche, par exemple avec setSendPin(uint8_t aSendPinNumber) , vous ne devez pas utiliser / désactiver cette macro dans votre source. |
SEND_PWM_BY_TIMER | désactivé | Désactive la génération de PWM de l'opérateur dans les logiciels et utilisez du matériel PWM (par minuterie). A l'avantage d'une génération de PWM plus exacte, en particulier le service CYC
Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes
Tout
|
