Reaproveitar controles remotos antigos

Sobre este projeto

Código

• Desenho de reaproveitamento remoto IR

Esboço de reaproveitamento remoto IR Arduino

 / * Alterne 6 LEDs usando um controle remoto IR para ilustrar como redefinir os controles remotos Surpulus para que possam ser usados ​​para controlar quase todos os dispositivos. Este esboço aprende os códigos do fabricante para os botões 1,2,3,4,5,6 e 0 em qualquer controle remoto IR quando a chave seletora está na posição "Aprender" ou programa. Esses valores são salvos na EEPROM do Arduino Nano. Quando a chave seletora é colocada no modo "Executar", esses valores são usados ​​para determinar qual tecla é pressionada. 6 LEDs associados são então ligados e desligados pelo controle remoto. Isso é para demonstrar como aprender e interpretar os códigos, independentemente do tipo de controle remoto infravermelho. Além dos LEDs, as saídas podem ser expandidas para ligar ou desligar dispositivos com relés, transistores de alta potência, etc. Paul M Dunphy VE1DX março de 2020 * / // Incluir Biblioteca Remota IR desenvolvida por Ken Shirriff # include  // Permite ler / escrever para 1024 bytes de EEPROM # include  long unsigned int intIRCode; long unsigned int savedIRCodes [6]; long unsigned int dupeCheck [6]; // Define o pino para o sensor de IR int Recv_Pin =2; // Define as constantes de pin para alternar os LEDsconst int PinOne =12; const int PinTwo =11; const int PinThree =10; const int PinFour =9; const int PinFive =8; const int PinSix =7; // Definir constantes de pin para ler e indicar o // status da chave de alternância Executar / Aprender.const int switchPin =4; const int statusPin =5; const unsigned long int repeatKeyPress =0xFFFFFFFF; boolean learnMode; // Usado para acompanhar em qual // modo estamos de acordo com o switch.boolean first_iteration; // Definir inteiros para lembrar os estados de alternância 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_3; int remote_code_3; int remote_code_3; // Definir receptor de IR e objetos de resultadosIRrecv irrecv (Recv_Pin); decode_results results; void EEPROMWritelong (endereço interno, valor longo) // Grava um inteiro longo de 4 bytes (32 bits) na EEPROM // Como eles têm 4 bytes de comprimento, eles são armazenado em // endereço para endereço + 3 {// Decompor um inteiro longo em 4 bytes usando bitshift. // Um ​​=Mais significativo -> Quatro =Byte menos significativo byte quatro =(valor &0xFF); byte três =((valor>> 8) &0xFF); byte dois =((valor>> 16) &0xFF); byte um =((valor>> 24) &0xFF); EEPROM.write (endereço, quatro); EEPROM.write (endereço + 1, três); EEPROM.write (endereço + 2, dois); EEPROM.write (endereço + 3, um); } long EEPROMReadlong (long address) // Lê um inteiro longo de 4 bytes (32 bits) da EEPROM.// Como eles têm 4 bytes de comprimento, eles foram armazenados no // endereço para o endereço + 3 {long four =EEPROM.read ( Morada); três longos =EEPROM.read (endereço + 1); dois longos =EEPROM.read (endereço + 2); um longo =EEPROM.read (endereço + 3); // Monte os bytes em um inteiro longo e retorne return ((quatro <<0) &0xFF) + ((três <<8) &0xFFFF) + ((dois <<16) &0xFFFFFF) + ((um <<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 () {// Desligue todos os LEDs e defina os sinalizadores // de alternância para desligados (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 ("O remoto parece ser um"); switch (results.decode_type) {case NEC:Serial.println ("NEC"); pausa; case SONY:Serial.println ("SONY"); pausa; caso RC5:Serial.println ("RC5"); pausa; caso RC6:Serial.println ("RC6"); pausa; case DISH:Serial.println ("DISH"); pausa; case SHARP:Serial.println ("SHARP"); pausa; case JVC:Serial.println ("JVC"); pausa; case SANYO:Serial.println ("SANYO"); pausa; case MITSUBISHI:Serial.println ("MITSUBISHI"); pausa; caso SAMSUNG:Serial.println ("SAMSUNG"); pausa; caso LG:Serial.println ("LG"); pausa; case WHYNTER:Serial.println ("WHYNTER"); pausa; case AIWA_RC_T501:Serial.println ("AIWA_RC_T501"); pausa; case PANASONIC:Serial.println ("PANASONIC"); pausa; case DENON:Serial.println ("DENON"); pausa; padrão:case UNKNOWN:Serial.println ("UNKNOWN"); pausa; }} int learnCodeRead (int pinCode) {if (irrecv.decode (&results)) {pinCode =results.value; } return pinCode; } void Confirm () {int i; para (i =0; i <=20; i ++) {digitalWrite (statusPin, HIGH); atraso (50); digitalWrite (statusPin, LOW); atraso (50); } digitalWrite (statusPin, HIGH); // Deixe o LED "Aprendizado" alto} void learn_Mode () {boolean goodCode; int i, j; localização interna; pinos internos [6] ={12,11,10,9,8,7}; // Comece a escutar cada um em sequência if (first_iteration) {Serial.println (); Serial.println ("Entrando no modo de aprendizagem"); Serial.println (); } intIRCode =0; localização =0; goodCode =true; j =0; while ((goodCode =true) and (j <=5)) {for (i =0; i <=25; i ++) {digitalWrite (pins [j], HIGH); atraso (200); intIRCode =learnCodeRead (intIRCode); digitalWrite (pinos [j], LOW); atraso (200); intIRCode =learnCodeRead (intIRCode); goodCode =((intIRCode! =repeatKeyPress) e (intIRCode! =0)); if (goodCode) {i =30; // Truque para sair do loop porque 'break' // não funciona em loops} irrecv.resume (); // Comece a ouvir novamente} goodCode =(intIRCode! =RepeatKeyPress e intIRCode! =0); if (goodCode) {if (j ==0) {guessType (); } Serial.print ("Gravando no local da EEPROM"); Serial.print (local); Serial.print ("código IR ="); Serial.println (intIRCode, HEX); EEPROMWritelong (localização, intIRCode); localização =localização + 4; j ++; Confirme(); intIRCode =0; irrecv.resume (); // Comece a ouvir novamente}} Serial.println (); Serial.println ("Colocar o Arduino de volta no modo de execução."); while (digitalRead (switchPin) ==HIGH) {digitalWrite (statusPin, HIGH); atraso (1000); digitalWrite (statusPin, LOW); atraso (1000); } Serial.println (); Serial.println ("Retornando ao modo de execução."); // Provavelmente não precisa ser tão drástico aqui, mas // Isso é uma "redefinição" para ter certeza de que sairemos do // modo de aprendizagem e reiniciaremos corretamente. É * provável * OK // remover as 4 linhas a seguir. atraso (50); Serial.flush (); atraso (50); asm volatile ("jmp 0"); } void run_Mode () {if (first_iteration) {Serial.println ("Entrando no modo de execução"); } if (irrecv.decode (&results)) {if (results.value! =repeatKeyPress) {current_remote_code =results.value; Serial.print ("Tecla pressionada detectada, código 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 {Reset (); }} atraso (500); // Usado para contornar a sequência rápida de dados // se um botão for pressionado. Retarda o tempo de resposta // introduzindo um atraso no loop. irrecv.resume (); // Comece a ouvir novamente}} void setup () {first_iteration =true; int i, j, k; localização interna; int dupeFlash [6] ={12,11,10,9,8,7}; // Fixar números no flash // se duplicatas encontradas Serial.begin (9600); irrecv.enableIRIn (); // Habilite o receptor IR / * A seção de código a seguir nunca deve precisar ser redefinida a EEPROM. * No entanto, alguns NANOs novos, prontos para uso, aparecem com seus EEPROMs configurados * para FFFFFFFFs. Acontece que este é o código enviado por muitos controles remotos IR quando * uma tecla é mantida pressionada. Este esboço verifica esse código em vários lugares * e não funcionará corretamente se uma "chave" for atribuída a um FFFFFFFF hexadecimal. Para * evitar esse problema, verificamos se há FFFFFFFFs e, se encontrarmos um, definimos * os 6 locais principais para os códigos Sony RM-YD104. Se isso acontecer, a menos que você * esteja usando aquele controle remoto em particular, você precisará executar o esboço no modo "aprender" * para inicializá-lo. * /// =============Começar Novo Arduino ==================boolean defaultToSony =false; long unsigned int IRCode =0; localização =0; para (i =0; i <=5; i ++) {IRCode =EEPROMReadlong (localização); if (IRCode ==repeatKeyPress) {defaultToSony =true; } localização =localização + 4; } if (defaultToSony) {Serial.println ("HEX FFFFFFFF encontrado na memória EEPROM. Códigos de configuração"); Serial.println ("para um controle remoto Sony RM-YD104. Executando o modo 'aprender' agora"); Serial.println ("é recomendado, a menos que seja o controle remoto que você possui."); EEPROMWritelong (0, 0x10); atraso (50); EEPROMWritelong (4, 0x810); atraso (50); EEPROMWritelong (8, 0x410); atraso (50); EEPROMWritelong (12, 0xC10); atraso (50); EEPROMWritelong (16, 0x210); atraso (50); EEPROMWritelong (20, 0xA10); atraso (50); } // =============Fim do novo Arduino ==================// Definir pinos de LED como saídas pinMode (PinOne, OUTPUT); pinMode (PinTwo, OUTPUT); pinMode (PinThree, OUTPUT); pinMode (PinFour, OUTPUT); pinMode (PinFive, OUTPUT); pinMode (PinSix, OUTPUT); Redefinir(); // Comece com todos eles desligados pinMode (statusPin, OUTPUT); pinMode (switchPin, INPUT); // Obter códigos do último remoto usado Serial.println (); Serial.println ("Lendo códigos remotos IR armazenados..."); localização =0; para (j =0; j <=5; j ++) {savedIRCodes [j] =EEPROMReadlong (localização); Serial.print ("Leitura da localização da EEPROM"); Serial.print (localização); Serial.print ("código IR ="); Serial.println (saveIRCodes [j], HEX); localização =localização + 4; dupeCheck [j] =salvosIRCodes [j]; // Salve uma cópia para verificação de duplicata} // Procure por códigos duplicados consecutivos atribuídos às // saídas. Não procuramos duplicatas gerais porque // é improvável que aconteçam. A experiência tem mostrado que // durante a programação, o erro mais provável é pressionar // a mesma tecla duas vezes em LEDs bacl-to-back. Se duplicatas // forem encontradas, indique isso piscando os LEDs suspeitos. // Existem apenas 6 LEDs, portanto, são necessárias apenas 21 comparações // para encontrar quaisquer duplicatas (6 + 5 + 4 + 3 + 2 + 1 =21). Esta // seção pode ser aprimorada para procurar qualquer duplicata // classificando o array primeiro, etc. for (i =0; i <5 - 1; i ++) {for (j =i + 1; j <6; j ++ ) {if (dupeCheck [i] ==dupeCheck [j]) {Serial.println ("Códigos duplicados encontrados. Sugerir nova execução do modo de aprendizagem"); para (k =0; k <=5; k ++) {digitalWrite (dupeFlash [i], ALTO); digitalWrite (dupeFlash [j], HIGH); atraso (1000); digitalWrite (dupeFlash [i], LOW); digitalWrite (dupeFlash [j], LOW); atraso (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]; atraso (1000); Serial.println ("Códigos armazenados lidos."); Serial.println (); } void loop () {// Verifique se a alternância está ligada ou desligada. Se estiver ligado (no modo de aprendizagem) // o switchPin é HIGH:learnMode =(digitalRead (switchPin) ==HIGH); if (learnMode) {first_iteration =true; Redefinir(); digitalWrite (statusPin, HIGH); // Liga o LED do modo de aprendizagem:learn_Mode (); Redefinir(); first_iteration =false; } else {digitalWrite (statusPin, LOW); // Desligue o LED do modo de aprendizagem:run_Mode (); first_iteration =false; }} 

Esquemas