Réutiliser les anciennes télécommandes

À propos de ce projet

Ce projet vous permet de réutiliser les télécommandes excédentaires d'anciens magnétoscopes, téléviseurs, lecteurs DVD, etc.

Vous pouvez utiliser les télécommandes pour allumer des appareils tels que des lampes, des radiateurs, etc. avec des relais, des transistors de puissance ou tout autre élément qu'un signal de 5 volts peut contrôler. Comme indiqué ici, il ne fait que basculer jusqu'à 6 LED. L'idée est de fournir le croquis et la maquette pour que les signaux envoyés aux LED puissent être envoyés en parallèle à tout ce que l'utilisateur imagine !

Tel que conçu, il lit 6 codes IR à partir de n'importe quelle télécommande et les « mémorise ». J'aime utiliser les dights 1, 2, 3, 4, 5, 6 -- mais n'importe quelles six touches fonctionneront. Notez que toute autre touche avec un code IR autre que les 6 codes connus agit comme une réinitialisation et désactive toutes les sorties. J'y parviens en écrivant les codes sous forme d'entiers longs dans la mémoire EEPROM de la carte Ardunio. Chacun prend 4 octets, mais comme l'UNO et le NANO ont chacun 1024 octets de mémoire EEPROM, il y a beaucoup de place. Cette mémoire est conservée pendant les réinitialisations et les mises hors tension, comme on pourrait s'y attendre. Le tout tiendrait sur une seule planche à pain, à l'exception de l'interrupteur à bascule. Des broches peuvent être soudées à ce commutateur pour l'inclure sur la maquette. J'étais paresseux et j'ai utilisé du ruban adhésif pour le maintenir sur mon bureau pendant le développement.

Je l'ai essayé avec cinq anciens excédents différents, et ils fonctionnent tous de la même manière. Le " piège " avec lequel j'ai eu du mal était la lumière parasite ou les signaux plus faibles de certaines télécommandes. Pour résoudre ce problème, j'ai soigneusement plié le récepteur "LED" vers le bas à environ 45 degrés et j'ai placé une petite boîte en carton et en ruban adhésif faite maison par-dessus, avec une extrémité ouverte. Il semble attraper les codes de manière cohérente et à une distance de 5 à 8 pieds ou plus. Je n'ai rien raté en plus de cinq jours de test et de peaufinage du programme.

Pour le programmer, utilisez la position "apprendre". Vous passez du mode « exécuter » au mode « apprendre » en actionnant un interrupteur à bascule. Cette bascule allume un indicateur LED de mode rouge, indiquant qu'il est prêt à écouter. Il fait clignoter la LED 1, et vous appuyez sur une touche de votre télécommande. La LED clignotante 1 est programmée pour réagir à ce code. Dès qu'il reconnaît le code, il fait clignoter rapidement la LED indicateur de mode pendant une seconde ou deux (si vite qu'on dirait qu'elle vibre !) et passe à la LED suivante. Cela continue jusqu'à ce que les six soient programmés. Ensuite, le voyant de mode clignote lentement à des intervalles d'une seconde, indiquant que le système doit être basculé en mode de fonctionnement.

J'ai découvert lors de la programmation que l'erreur la plus courante était d'oublier de déplacer votre doigt sur le chiffre suivant de la télécommande. Ainsi, il est facile de programmer deux sorties avec le même code. Chaque fois qu'il démarre, il recherche de tels doublons. S'il les trouve, il fait clignoter les LED "offensives" plusieurs fois pour suggérer qu'une reprogrammation pourrait être nécessaire. Cependant, une personne peut vouloir que plusieurs touches fassent la même chose, cela ne force donc pas la reprogrammation.

L'état du mode, les erreurs, etc. sont indiqués par la vitesse de clignotement de la LED d'état ROUGE. Toutes les informations indiquées par les LED clignotantes, etc., sont envoyées au moniteur série. Je l'ai configuré pour utiliser des séquences de clignotements LED afin qu'un utilisateur puisse le configurer sans ordinateur. Les messages envoyés au moniteur série sont plus faciles à suivre que de mémoriser la signification des LED clignotantes à différentes vitesses. Comme cela ne serait généralement programmé que quelques fois, il est probablement plus naturel de le connecter à votre PC et de regarder le texte sur le moniteur série.

Il y a beaucoup de freins et contrepoids dans le sketch code. Ils sont bien documentés (j'espère !), donc je ne donnerai pas les détails ici. Les utilisateurs familiers avec C, C++ et l'IDE Arduino devraient facilement pouvoir suivre le code et apporter des modifications si désiré.

Avenant : J'ai testé cela avec 5 relais en parallèle avec les LED 1 à 5 et cela fonctionne comme prévu. Ils basculent tous vers une lampe de table 120 VAC, de sorte que le circuit fonctionne comme prévu. Je n'ai plus de relais, il faut donc supposer que le 6ème signal fonctionnera également. Notez qu'il ne s'agit que d'une preuve de concept. J'ai dû inverser les signaux des quatre premières sorties avec une porte NAND quad CD4011 car elles se ferment sur 0 volt au lieu de 5 volts. Le relais unique fonctionne sur un signal de + 5 volts, donc aucune inversion de signal n'était nécessaire. Veuillez être prudent lors de la commutation des tensions secteur. Ils sont à haute tension et ont le potentiel de donner un mauvais choc ou même de tuer !

Rappelez-vous, ceci n'est qu'un exemple. Utilisez votre imagination pour savoir quels appareils connecter aux 6 sorties. Profitez-en !

Code

• Esquisse de réutilisation à distance IR

Esquisse de réutilisation à distance IRArduino

/* Basculez 6 LED à l'aide d'une télécommande IR pour illustrer comment réutiliser les télécommandes surpulus afin qu'elles puissent être utilisées pour contrôler presque n'importe quel appareil. Ce croquis apprend les codes du fabricant pour les boutons 1,2,3,4,5,6 et 0 sur n'importe quelle télécommande IR lorsque l'interrupteur à bascule est en position "Learn" ou programme. Ces valeurs sont enregistrées dans l'EEPROM de l'Arduino Nano. Lorsque l'interrupteur à bascule est mis en mode « Exécuter », ces valeurs sont utilisées pour déterminer quelle touche est enfoncée. Les 6 LED associées sont ensuite allumées et éteintes par la télécommande. Il s'agit de montrer comment apprendre et connaître les codes quel que soit le type de télécommande IR. En plus des LED, les sorties peuvent être étendues pour allumer ou éteindre des appareils avec des relais, des transistors haute puissance, etc. Paul M Dunphy VE1DX Mars 2020 */ // Inclut la bibliothèque à distance IR développée par Ken Shirriff#include // Donne la possibilité de lire/écrire sur les 1024 octets d'EEPROM#include long unsigned int intIRCode;long non signé int saveIRCodes[6];long non signé int dupeCheck[6]; // Définir la broche pour le capteur IRconst int Recv_Pin =2; // Définir les constantes de broche pour basculer le LEDsconst int PinOne =12; const int PinTwo =11; const int PinTrois =10; const int PinFour =9; const int PinFive =8; const int PinSix =7 ; // Définir les constantes de broche pour lire et indiquer le// l'état du commutateur à bascule Run/Learn.const int switchPin =4 ; const int statusPin =5; const unsigned long int repeatKeyPress =0xFFFFFFFF;boolean learnMode; // Utilisé pour garder une trace du // mode dans lequel nous nous trouvons selon le commutateur à bascule.boolean first_iteration; // Définir des entiers pour mémoriser les états de basculement de chaque LEDint togglestate1;int togglestate2;int togglestate3;int togglestate4;int togglestate5;int togglestate6;int current_remote_code;int remote_code_1;int remote_code_2;int remote_code_3;int remote_code_4;int remote_code_5;int remote_code_5 // Définir le récepteur IR et les objets de résultatsIRrecv irrecv(Recv_Pin);decode_results results;void EEPROMWritelong(int address, long value)// Écrire un entier long de 4 octets (32 bits) dans l'EEPROM// Comme ils font 4 octets, ils sont stocké à // adresse à adresse + 3 { // Décompose un entier long en 4 octets en utilisant bitshift. // Un =Le plus significatif -> Quatre =Octet le moins significatif octet quatre =(valeur &0xFF); octet trois =((valeur>> 8) &0xFF); octet deux =((valeur>> 16) &0xFF); octet un =((valeur>> 24) &0xFF); EEPROM.write(adresse, quatre); EEPROM.write(adresse + 1, trois); EEPROM.write(adresse + 2, deux); EEPROM.write(adresse + 3, un); }long EEPROMReadlong(long address)// Lire un entier long de 4 octets (32 bits) à partir de l'EEPROM.// Puisqu'ils font 4 octets, ils ont été stockés à // adresse à adresse + 3 { long four =EEPROM.read( adresse); long trois =EEPROM.read (adresse + 1); long deux =EEPROM.read(adresse + 2); un long =EEPROM.read(adresse + 3); //Assemble les octets en un entier long et renvoie return ((quatre <<0) &0xFF) + ((trois <<8) &0xFFFF) + ((deux <<16) &0xFFFFFF) + ((un <<24) &repeatKeyPress); }int Flip_LED(int led, int toggle_state) { if(toggle_state==0) { digitalWrite(led, HIGH); toggle_state=1 ; } else { digitalWrite(led, LOW); toggle_state=0 ; } return toggle_state; }void Reset() { // Éteignez toutes les LED et désactivez // les drapeaux à bascule (0) digitalWrite(PinOne, LOW); digitalWrite(PinTwo, LOW); digitalWrite(PinThree, LOW); digitalWrite (PinFour, LOW); digitalWrite(PinFive, LOW); digitalWrite (PinSix, LOW); togglestate1 =0 ; togglestate2 =0 ; togglestate3 =0 ; togglestate4 =0 ; togglestate5 =0 ; togglestate6 =0 ; }void guessType() { Serial.print("La télécommande semble être un "); switch (results.decode_type){ case NEC:Serial.println("NEC "); Pause; case SONY :Serial.println("SONY "); Pause; case RC5 :Serial.println("RC5 "); Pause; case RC6 :Serial.println("RC6 "); Pause; case DISH :Serial.println("DISH "); Pause; case SHARP:Serial.println("SHARP "); Pause; case JVC :Serial.println("JVC "); Pause; case SANYO :Serial.println("SANYO "); Pause; case MITSUBISHI:Serial.println("MITSUBISHI "); Pause; cas SAMSUNG :Serial.println("SAMSUNG "); Pause; cas LG :Serial.println("LG "); Pause; case POURQUOI :Serial.println("WHYNTER "); Pause; cas AIWA_RC_T501 :Serial.println("AIWA_RC_T501 "); Pause; case PANASONIC:Serial.println("PANASONIC "); Pause; case DENON :Serial.println("DENON "); Pause; par défaut :case UNKNOWN :Serial.println("UNKNOWN "); Pause; } } int learnCodeRead(int pinCode) { if (irrecv.decode(&results)) { pinCode =results.value; } renvoie le code PIN ; } void Confirm() { int i; for(i=0; i<=20; i++) { digitalWrite(statusPin, HIGH); retard (50); digitalWrite(statusPin, LOW); retard (50); } digitalWrite(statusPin, HIGH); // Laisse la LED "Learn" élevée } void learn_Mode() { boolean goodCode; int i, j; emplacement int; broches int[6] ={12,11,10,9,8,7} ; // Commence à écouter chacun dans l'ordre if (first_iteration) { Serial.println(); Serial.println("Entrer en mode d'apprentissage"); Serial.println(); } intIRCode =0; emplacement =0 ; bonCode =vrai; j =0 ; while ((goodCode=true) et (j<=5)) { for(i=0; i<=25; i++) { digitalWrite(pins[j], HIGH); retard (200); intIRCode =learnCodeRead(intIRCode); digitalWrite(broches[j], LOW); retard (200); intIRCode =learnCodeRead(intIRCode); goodCode =((intIRCode !=repeatKeyPress) et (intIRCode !=0)); if (bonCode) { i=30; // Astuce pour sortir de la boucle car 'break' // ne fonctionne pas sur les boucles } irrecv.resume(); // Recommencer l'écoute } goodCode =(intIRCode !=repeatKeyPress and intIRCode !=0); if (goodCode) { if (j==0) { devinezType(); } Serial.print("Ecriture dans l'emplacement EEPROM ");Serial.print(emplacement); Serial.print(" IR code =");Serial.println(intIRCode,HEX); EEPROMWritelong(emplacement, intIRCode); emplacement =emplacement + 4 ; j++; Confirmer(); intIRCode =0 ; irrecv.resume(); // Recommencer l'écoute } } Serial.println(); Serial.println("Remettez Arduino en mode exécution."); while (digitalRead(switchPin) ==HIGH) { digitalWrite(statusPin, HIGH); retard(1000); digitalWrite(statusPin, LOW); retard(1000); } Serial.println(); Serial.println("Retour en mode exécution."); // Il n'est probablement pas nécessaire d'être aussi drastique ici, mais // Ceci est une "réinitialisation" pour être sûr de sortir du mode // d'apprentissage et de redémarrer correctement. Il est *probablement* OK de // supprimer les 4 lignes suivantes. retard (50); Serial.flush(); retard (50); asm volatile (" jmp 0"); } void run_Mode() { if (first_iteration) { Serial.println("Entrée en mode d'exécution"); } if (irrecv.decode(&results)) { if (results.value!=repeatKeyPress) { current_remote_code =results.value; Serial.print ("Appuyez sur la touche détecté, code IR ="); Serial.println(current_remote_code,HEX); if (current_remote_code ==remote_code_1) { togglestate1 =Flip_LED(PinOne,togglestate1) ; } else if (current_remote_code ==remote_code_2) { togglestate2 =Flip_LED(PinTwo,togglestate2) ; } else if (current_remote_code ==remote_code_3) { togglestate3 =Flip_LED(PinThree,togglestate3) ; } else if (current_remote_code ==remote_code_4) { togglestate4 =Flip_LED(PinFour,togglestate4) ; } else if (current_remote_code ==remote_code_5) { togglestate5 =Flip_LED(PinFive,togglestate5) ; } else if (current_remote_code ==remote_code_6) { togglestate6 =Flip_LED(PinSix,togglestate6) ; } else { Réinitialiser(); } } délai (500); // Utilisé pour contourner la chaîne de données rapide // si un bouton est maintenu enfoncé. Ralentit le temps de réponse // en introduisant un décalage dans la boucle. irrecv.resume(); // Recommencer l'écoute } } void setup() { first_iteration =true; entier i,j,k; emplacement int; int dupeFlash[6] ={12,11,10,9,8,7} ; // Numéros de broche à flasher // si des doublons sont trouvés Serial.begin (9600); irrecv.enableIRIn(); // Activer le récepteur IR /* La section de code suivante ne devrait jamais avoir besoin d'être réinitialisée sur l'EEPROM. * Cependant, certains nouveaux NANO "prêts à l'emploi" apparaissent avec leurs EEPROM réglées * sur FFFFFFFF. Il se trouve qu'il s'agit du code envoyé par de nombreuses télécommandes IR lorsque * une touche est enfoncée. Cette esquisse vérifie ce code à plusieurs endroits * et cela ne fonctionnera pas correctement si une "clé" est affectée d'un hexadécimal FFFFFFFF. Pour * empêcher ce piège, nous recherchons les FFFFFFFF et si nous en trouvons un, nous définissons * les 6 emplacements clés sur les codes Sony RM-YD104. Si cela se produit, à moins que vous n'utilisiez * cette télécommande particulière, vous devrez exécuter l'esquisse en mode "apprendre" * pour l'initialiser. */// =============Commencer un nouvel Arduino ==================booléen defaultToSony =false; IRCode long non signé =0 ; emplacement =0 ; for(i=0; i<=5; i++) { IRCode =EEPROMReadlong(location); if (IRCode==repeatKeyPress) { defaultToSony =true; } emplacement =emplacement + 4; } if (defaultToSony) { Serial.println("HEX FFFFFFFF trouvé dans la mémoire EEPROM. Codes de réglage"); Serial.println("pour une télécommande Sony RM-YD104. Exécution du mode 'apprendre' maintenant"); Serial.println("est recommandé sauf si c'est la télécommande que vous avez."); EEPROMWritelong(0, 0x10) ; retard (50); EEPROMWritelong(4, 0x810); retard (50); EEPROMWritelong (8, 0x410); retard (50); EEPROMWritelong(12, 0xC10) ; retard (50); EEPROMWritelong (16, 0x210); retard (50); EEPROMWritelong (20, 0xA10) ; retard (50); } // =============Fin du nouvel Arduino ==================// Définir les broches LED comme sorties pinMode (PinOne, OUTPUT); pinMode(PinDeux, SORTIE); pinMode(PinThree, SORTIE); pinMode(PinFour, SORTIE); pinMode(PinFive, SORTIE); pinMode(PinSix, SORTIE); Réinitialiser(); // Commencer avec eux tous hors pinMode(statusPin, OUTPUT); pinMode(switchPin, INPUT); //Obtenir les codes de la dernière télécommande Serial.println(); Serial.println("Lecture des codes distants IR stockés . . . "); emplacement =0 ; for(j=0; j<=5; j++) { saveIRCodes[j] =EEPROMReadlong(location); Serial.print("Lecture à partir de l'emplacement EEPROM ");Serial.print(emplacement); Serial.print(" IR code =");Serial.println(savedIRCodes[j],HEX); emplacement =emplacement + 4 ; dupeCheck[j]=savedIRCodes[j] ; // Enregistrer une copie pour la vérification des doublons } // Rechercher les codes dupliqués consécutifs affectés aux // sorties. Nous ne recherchons pas les doublons globaux car // il est peu probable qu'ils se produisent. L'expérience a montré que // lors de la programmation, l'erreur la plus probable est d'appuyer // deux fois sur la même touche sur des LED dos à dos. Si des doublons // sont trouvés, signalez-le en faisant clignoter les LED suspectes. // Il n'y a que 6 LED, il suffit donc de 21 comparaisons // pour trouver des doublons (6 + 5 + 4 + 3 + 2 + 1 =21). Cette section // pourrait être améliorée pour rechercher les doublons en // triant d'abord le tableau, etc. for (i =0; i <5 - 1; i++) { for (j =i + 1; j <6; j++ ) { if (dupeCheck[i] ==dupeCheck[j]) { Serial.println("Codes en double trouvés. Suggérer de relancer le mode d'apprentissage"); for(k=0; k<=5; k++) { digitalWrite(dupeFlash[i],HIGH); digitalWrite(dupeFlash[j],HIGH); retard(1000); digitalWrite(dupeFlash[i],LOW); digitalWrite(dupeFlash[j],LOW); retard(1000); } } } } remote_code_1 =saveIRCodes[0]; remote_code_2 =IRCodes enregistrés[1] ; remote_code_3 =IRCodes enregistrés[2] ; remote_code_4 =saveIRCodes[3] ; remote_code_5 =IRCodes enregistrés[4] ; remote_code_6 =IRCodes enregistrés[5] ; retard(1000); Serial.println("Codes stockés lus."); Serial.println(); } void loop() { // Vérifie si la bascule est activée ou désactivée. S'il est activé (en mode d'apprentissage) // le switchPin est HIGH :learnMode =(digitalRead(switchPin) ==HIGH); if (learnMode) { first_iteration =true; Réinitialiser(); digitalWrite(statusPin, HIGH); // Allumez le voyant du mode d'apprentissage :learn_Mode(); Réinitialiser(); première_itération =faux ; } else { digitalWrite(statusPin, LOW); // Éteignez le voyant du mode d'apprentissage :run_Mode(); première_itération =faux ; } }

Schémas