Reutilizar controles remotos antiguos

Código

• Boceto de reutilización del mando a distancia por infrarrojos

Boceto de reutilización del mando a distancia por infrarrojos Arduino

 / * Cambie 6 LED usando un control remoto IR para ilustrar cómo reutilizar los controles remotos Surpulus para que puedan usarse para controlar casi cualquier dispositivo. Este boceto aprende los códigos del fabricante para los botones 1, 2, 3, 4, 5, 6 y 0 en cualquier control remoto IR cuando el interruptor de palanca está en la posición "Aprender" o programar. Estos valores se guardan en la EEPROM del Arduino Nano. Cuando el interruptor de palanca se coloca en el modo "Ejecutar", estos valores se utilizan para determinar qué tecla se presiona. Luego, el control remoto enciende y apaga los 6 LED asociados. Esto es para demostrar cómo aprender e identificar los códigos independientemente del tipo de control remoto por infrarrojos. Además de los LED, las salidas se pueden ampliar para encender o apagar dispositivos con relés, transistores de alta potencia, etc. Paul M Dunphy VE1DX Marzo de 2020 * / // Incluir la biblioteca remota IR desarrollada por Ken Shirriff # include  // Dar la capacidad de leer / escribir en los 1024 bytes de EEPROM # include  long unsigned int intIRCode; int sin firmar longIRCodes guardados [6]; int dupeCheck largo sin firmar [6]; // Definir pin para el sensor IRconst int Recv_Pin =2; // Defina las constantes de los pines para alternar los LEDsconst int PinOne =12; const int PinTwo =11; const int PinThree =10; const int PinFour =9; const int PinFive =8; const int PinSix =7; // Defina las constantes de los pines para leer e indicar el // estado del interruptor de palanca Ejecutar / Aprender. const int switchPin =4; const int statusPin =5; const unsigned long int repeatKeyPress =0xFFFFFFFF; boolean learnMode; // Se usa para realizar un seguimiento del // modo en el que estamos según el conmutador de palanca. Boolean first_iteration; // Definir números enteros para recordar los estados de alternancia de cada 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_6 // Definir el receptor de infrarrojos y los objetos de resultados IRrecv irrecv (Recv_Pin); decode_results results; void EEPROMWritelong (int address, long value) // Escribe un entero de 4 bytes (32 bits) en la EEPROM // Dado que tienen 4 bytes de longitud, son almacenado en // dirección a dirección + 3 {// Descomponer un entero largo en 4 bytes usando desplazamiento de bits. // Uno =Más significativo -> Cuatro =Byte menos significativo byte cuatro =(valor &0xFF); byte tres =((valor>> 8) &0xFF); byte dos =((valor>> 16) &0xFF); byte uno =((valor>> 24) &0xFF); EEPROM.write (dirección, cuatro); EEPROM.write (dirección + 1, tres); EEPROM.write (dirección + 2, dos); EEPROM.write (dirección + 3, uno); } long EEPROMReadlong (dirección larga) // Leer un entero largo de 4 bytes (32 bits) de la EEPROM.// Como tienen 4 bytes de longitud, se almacenaron en // dirección a la dirección + 3 {cuatro largos =EEPROM.read ( habla a); tres largos =EEPROM.read (dirección + 1); dos largos =EEPROM.read (dirección + 2); uno largo =EEPROM.read (dirección + 3); // Ensamblar los bytes en un entero largo y devolver return ((cuatro <<0) &0xFF) + ((tres <<8) &0xFFFF) + ((dos <<16) &0xFFFFFF) + ((uno <<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 () {// Apague todos los LED y configure los indicadores de alternancia // en apagado (0) digitalWrite (PinOne, LOW); digitalWrite (PinTwo, BAJO); digitalWrite (PinThree, BAJO); digitalWrite (PinFour, BAJO); digitalWrite (PinFive, BAJO); digitalWrite (PinSix, BAJO); togglestate1 =0; togglestate2 =0; togglestate3 =0; togglestate4 =0; togglestate5 =0; togglestate6 =0; } void guessType () {Serial.print ("Remoto parece ser un"); switch (results.decode_type) {caso NEC:Serial.println ("NEC"); descanso; caso SONY:Serial.println ("SONY"); descanso; caso RC5:Serial.println ("RC5"); descanso; caso RC6:Serial.println ("RC6"); descanso; caso DISH:Serial.println ("PLATO"); descanso; case SHARP:Serial.println ("SHARP"); descanso; caso JVC:Serial.println ("JVC"); descanso; caso SANYO:Serial.println ("SANYO"); descanso; caso MITSUBISHI:Serial.println ("MITSUBISHI"); descanso; caso SAMSUNG:Serial.println ("SAMSUNG"); descanso; caso LG:Serial.println ("LG"); descanso; case WHYNTER:Serial.println ("WHYNTER"); descanso; caso AIWA_RC_T501:Serial.println ("AIWA_RC_T501"); descanso; caso PANASONIC:Serial.println ("PANASONIC"); descanso; caso DENON:Serial.println ("DENON"); descanso; predeterminado:caso DESCONOCIDO:Serial.println ("DESCONOCIDO"); descanso; }} int learnCodeRead (int pinCode) {if (irrecv.decode (&resultados)) {pinCode =results.value; } return pinCode; } void Confirm () {int i; para (i =0; i <=20; i ++) {digitalWrite (statusPin, HIGH); retraso (50); digitalWrite (statusPin, BAJO); retraso (50); } digitalWrite (statusPin, ALTO); // Deje el LED "Aprender" alto} void learn_Mode () {boolean goodCode; int i, j; int ubicación; int pines [6] ={12,11,10,9,8,7}; // Empiece a escuchar cada uno en secuencia if (first_iteration) {Serial.println (); Serial.println ("Ingresando al modo de aprendizaje"); Serial.println (); } intIRCode =0; ubicación =0; goodCode =verdadero; j =0; while ((goodCode =true) y (j <=5)) {for (i =0; i <=25; i ++) {digitalWrite (pines [j], HIGH); retraso (200); intIRCode =learnCodeRead (intIRCode); digitalWrite (pines [j], BAJO); retraso (200); intIRCode =learnCodeRead (intIRCode); goodCode =((intIRCode! =repeatKeyPress) y (intIRCode! =0)); if (goodCode) {i =30; // Truco para salir del bucle porque 'break' // no funciona en bucles} irrecv.resume (); // Empiece a escuchar de nuevo} goodCode =(intIRCode! =RepeatKeyPress e intIRCode! =0); if (goodCode) {if (j ==0) {guessType (); } Serial.print ("Escritura en la ubicación EEPROM"); Serial.print (ubicación); Serial.print ("código IR ="); Serial.println (intIRCode, HEX); EEPROMWritelong (ubicación, intIRCode); ubicación =ubicación + 4; j ++; Confirmar(); intIRCode =0; irrecv.resume (); // Empiece a escuchar de nuevo}} Serial.println (); Serial.println ("Vuelve a poner Arduino en modo de ejecución"); while (digitalRead (switchPin) ==HIGH) {digitalWrite (statusPin, HIGH); retraso (1000); digitalWrite (statusPin, BAJO); retraso (1000); } Serial.println (); Serial.println ("Regresando al modo de ejecución."); // Probablemente no necesite ser tan drástico aquí, pero // Esto es un "reinicio" para asegurarnos de que salgamos del modo de aprendizaje // y reiniciemos correctamente. Es * probable * que esté bien // eliminar las siguientes 4 líneas. retraso (50); Serial.flush (); retraso (50); asm volatile ("jmp 0"); } void run_Mode () {if (first_iteration) {Serial.println ("Ingresando al modo de ejecución"); } if (irrecv.decode (&results)) {if (results.value! =repeatKeyPress) {current_remote_code =results.value; Serial.print ("Pulsación de tecla detectada, código IR ="); Serial.println (código_remoto_actual, HEX); if (código_remoto_actual ==código_remoto_1) {togglestate1 =Flip_LED (PinOne, togglestate1); } else if (código_remoto_actual ==código_remoto_2) {togglestate2 =Flip_LED (PinTwo, togglestate2); } else if (código_remoto_actual ==código_remoto_3) {togglestate3 =Flip_LED (PinThree, togglestate3); } else if (código_remoto_actual ==código_remoto_4) {togglestate4 =Flip_LED (PinFour, togglestate4); } else if (código_remoto_actual ==código_remoto_5) {togglestate5 =Flip_LED (PinFive, togglestate5); } más si (código_remoto_actual ==código_remoto_6) {togglestate6 =Flip_LED (PinSix, togglestate6); } else {Reset (); }} retraso (500); // Se usa para sortear la cadena rápida de datos // si se mantiene presionado un botón. Ralentiza el tiempo de respuesta // introduciendo un retraso en el ciclo. irrecv.resume (); // Empiece a escuchar de nuevo}} void setup () {first_iteration =true; int i, j, k; int ubicación; int dupeFlash [6] ={12,11,10,9,8,7}; // Números de pin para parpadear // si se encuentran duplicados Serial.begin (9600); irrecv.enableIRIn (); // Habilite el receptor de infrarrojos / * La siguiente sección de código nunca debería necesitar restablecer la EEPROM. * Sin embargo, algunos nuevos NANO "estándar" aparecen con sus EEPROM configuradas * en FFFFFFFF. Este es el código enviado por muchos controles remotos IR cuando * se mantiene presionada una tecla. Este boceto busca ese código en varios lugares * y no funcionará correctamente si a una "clave" se le asigna un FFFFFFFF hexadecimal. Para * evitar este problema, buscamos FFFFFFFF y, si encontramos uno, configuramos * las 6 ubicaciones clave para los códigos Sony RM-YD104. Si esto sucede, a menos que * esté usando ese control remoto en particular, necesitará ejecutar el boceto en modo "aprender" * para inicializarlo. * /// =============Comenzar nuevo Arduino ==================boolean defaultToSony =false; long unsigned int IRCode =0; ubicación =0; para (i =0; i <=5; i ++) {IRCode =EEPROMReadlong (ubicación); if (IRCode ==repeatKeyPress) {defaultToSony =true; } ubicación =ubicación + 4; } if (defaultToSony) {Serial.println ("HEX FFFFFFFF encontrado en la memoria EEPROM. Códigos de configuración"); Serial.println ("para un control remoto Sony RM-YD104. Ejecutando el modo 'aprender' ahora"); Serial.println ("se recomienda a menos que ese sea el control remoto que tiene"); EEPROMWritelong (0, 0x10); retraso (50); EEPROMWritelong (4, 0x810); retraso (50); EEPROMWritelong (8, 0x410); retraso (50); EEPROMWritelong (12, 0xC10); retraso (50); EEPROMWritelong (16, 0x210); retraso (50); EEPROMWritelong (20, 0xA10); retraso (50); } // =============End New Arduino ==================// Establecer pines LED como salidas pinMode (PinOne, OUTPUT); pinMode (PinTwo, SALIDA); pinMode (PinThree, SALIDA); pinMode (PinFour, SALIDA); pinMode (PinFive, SALIDA); pinMode (PinSix, SALIDA); Reiniciar(); // Comience con todos ellos fuera de pinMode (statusPin, OUTPUT); pinMode (switchPin, INPUT); // Obtener los códigos del último Serial.println () remoto utilizado; Serial.println ("Lectura de códigos remotos IR almacenados..."); ubicación =0; for (j =0; j <=5; j ++) {SavedIRCodes [j] =EEPROMReadlong (ubicación); Serial.print ("Lectura de la ubicación EEPROM"); Serial.print (ubicación); Serial.print ("código IR ="); Serial.println (Códigos IR guardados [j], HEX); ubicación =ubicación + 4; dupeCheck [j] =SavedIRCodes [j]; // Guarde una copia para la verificación de duplicados} // Busque códigos duplicados consecutivos asignados a las // salidas. No buscamos duplicados generales porque // es poco probable que ocurran. La experiencia ha demostrado que // durante la programación, el error más probable es presionar // la misma tecla dos veces en los LED de espalda a espalda. Si se encuentran // duplicados, indíquelo haciendo parpadear los LED sospechosos. // Solo hay 6 LED, por lo que solo se necesitan 21 comparaciones // para encontrar duplicados (6 + 5 + 4 + 3 + 2 + 1 =21). Esta // sección podría mejorarse para buscar cualquier duplicado // ordenando la matriz primero, etc. for (i =0; i <5 - 1; i ++) {for (j =i + 1; j <6; j ++ ) {if (dupeCheck [i] ==dupeCheck [j]) {Serial.println ("Se encontraron códigos duplicados. Sugerir volver a ejecutar el modo de aprendizaje"); para (k =0; k <=5; k ++) {digitalWrite (dupeFlash [i], HIGH); digitalWrite (dupeFlash [j], ALTO); retraso (1000); digitalWrite (dupeFlash [i], BAJO); digitalWrite (dupeFlash [j], BAJO); retraso (1000); }}}} remote_code_1 =SavedIRCodes [0]; remote_code_2 =SavedIRCodes [1]; remote_code_3 =SavedIRCodes [2]; remote_code_4 =SavedIRCodes [3]; remote_code_5 =SavedIRCodes [4]; remote_code_6 =SavedIRCodes [5]; retraso (1000); Serial.println ("Lectura de códigos almacenados"); Serial.println (); } void loop () {// Comprueba si el conmutador está activado o desactivado. Si está activado (en modo de aprendizaje) // el switchPin es HIGH:learnMode =(digitalRead (switchPin) ==HIGH); if (learnMode) {first_iteration =true; Reiniciar(); digitalWrite (statusPin, ALTO); // Enciende el LED del modo de aprendizaje:learn_Mode (); Reiniciar(); first_iteration =falso; } else {digitalWrite (statusPin, LOW); // Apaga el LED del modo de aprendizaje:run_Mode (); first_iteration =falso; }} 

Esquemas