CONTROL REMOTO IR.
Introducción.
No es nuevo el tema de los controles remotos, incluso los que veremos aquí, los de rayos infrarrojos (IR), se utilizan en muchas aplicaciones diferentes, en muchos campos, como es la comunicación, que utilizan tecnología infrarroja para control remoto en dispositivos domésticos, como los mandos de los TV. El funcionamiento del control remoto, se basa en la emisión de secuencias de pulsos de luz IR, con un código que identifica la tecla pulsada. Este es el tipo de control remoto que vamos a desarrollar en este artículo.
En el caso de utilizar un Arduino, el trabajo más duro se le encomienda a la librería que podemos descargar de aquí. Esta librería nos permite enviar y recibir códigos con los que podremos manejar cualquier circuito con un control remoto de TV. La biblioteca referida, es compatible con Philips RC5, RC6 Philips, NEC, Sony SIRC y protocolos en bruto, se puede utilizar incluso para copiar los códigos de su mando a distancia y volver a transmitirlos, como un control remoto universal. Si no lo ha hecho ya, empiece por descargar la mencionada librería para utilizarla y, siga las instrucciones de instalación que vienen en el archivo «readme».
Consideraciones sobre códigos IR.
Un mando a distancia IR funciona conmutando el LED encendido y apagado en una secuencia particular. Sin embargo, para evitar interferencias a partir de fuentes de IR tales como la luz del sol o las luces, el LED no está encendido de forma permanente, pero se enciende y se apaga a una frecuencia de modulación (típicamente 36 a 40 KHz). En el momento en que se está enviando una señal modulada se llama marca (1) y, cuando el LED está apagado se llama espacio (0).
Naturalmente, en el mando a distancia, cada tecla tiene un código asociado a ella (por lo general de 12 a 32 bits), y transmite este código cuando se pulsa esa tecla. Si la tecla se mantiene pulsada, el mando a distancia normalmente transmite repetidamente el código clave. En los controles remotos de Philips RC5 o RC6, el código activa un bit cada vez que se pulsa una tecla, el receptor utiliza este bit de conmutación para determinar cuando se pulsa una tecla por segunda vez.
El mecanismo de funcionamiento de una transmisión por infrarrojos es bastante «simple»; un haz de luz, de alta frecuencia de 38 kHz (típico de los mandos a distancia para la TV) se proyecta frente a un receptor. Este haz de luz no es más que una secuencia de bits (0 y 1) que son codificados por el receptor, a través de la polarización del foto-transistor. Veamos este caso simple; el control remoto, es el cifrado de los distintos impulsos con diversos bits y secuencias, por ejemplo, el botón de encendido/apagado es:
Fig. 1
En el extremo receptor, el detector IR desmodula esta señal, y emite una señal de nivel lógico que indica si se está recibiendo una señal o no. El detector de infrarrojos, funciona mejor cuando su frecuencia coincide con la frecuencia del emisor, pero en la práctica no importa mucho.
En mi caso, algunos de los botones del mando a distancia del TV, no los uso nunca, entonces, ¿por qué no usarlos para manejar otros dispositivos electrónicos del hogar?. Este proyecto, trata de demostrar como utilizar el habitual Arduino, para decodificar la señal de dicho mando utilizándolo como un interruptor, para el encendido y apagado de un electrodoméstico.
Los materiales.
Estos son los materiales que necesitaremos para este proyecto:
 |
 |
 |
 |
 |
 |
  |
||
Emisor y Receptor IR.
A día de hoy, existe una página en donde es posible encontrar las señales de Controles Remotos conocidos. Veremos el proceso de obtención de las señales de un Control remoto o Mando, luego analizaremos el protocolo, para capturar las señales provenientes del control o mando en el PC, se requiere de un Receptor de Infrarrojo. Estos receptores constan de un fotodiodo y normalmente se conectan en la entrada de micrófono de la tarjeta de Sonido del PC, y son capaces de detectar los pequeños niveles de voltaje producidos por el fotodiodo. Abajo una foto y su representación.
Fig. 2
La librería que se ha descargado, admite cualquier señal digital para leer la entrada de un módulo receptor de IR. Estos productos, son sistemas receptores de infrarrojos miniaturizados. Si usted no tiene un receptor de este tipo, no hay problema, usted puede fabricar su propio receptor, con un fotodiodo barato y corriente y un cable (apantallado) adaptador de micrófono.
El circuito en principio es muy simple. Para la salida, conectar el diodo LED IR y la resistencia adecuada al pin 3 (PWM), la distancia es de unos 4,5m para un alcance mayor puede amplificar la salida con un transistor. Como se ha comentado, un mando a distancia conmuta el LED entre encendido y apagado con un patrón exclusivo, para evitar interferencias procedentes de fuentes como la luz o el sol, el LED se enciende a una frecuencia de modulación (entre 36k y 40 kHz). Cuando está enviando una señal modulada se llama marca y cuando está apagado se llama espacio.
En un mando a distancia, cada tecla tiene un código único asociado a él (generalmente 12 a 32 bits): Si se mantiene pulsada la tecla, se transmite repetidamente el código.
Fig. 3
El receptor se diferencia de un transistor común, por que, su base ha sido sustituida por un fotodiodo que, de acuerdo a la luz incidente sobre él, regula el flujo de corriente colector–emisor, con una resistencia de un 1kΩ obtendremos una salida, este tipo de señales son las que se deben procesar en el PC.
Si ya disponemos de nuestro receptor de Infrarrojos, podemos empezar a visualizar las señales del «Mando», capturadas con el receptor de infrarrojos, mediante un software adecuado. Además, usando la cámara del móvil (celular), podemos saber si nuestro emisor está funcionando. La imagen que sigue muestra un ejemplo.
Fig. 4
Cuando no disponemos de un osciloscopio (no siempre, pero en este caso), podemos utilizar el PC, para ver e identificar las diferentes formas de onda utilizadas para comandar dispositivos por medio de controles remoto de infrarrojos. Puede utilizar cualquier software de osciloscopio o editor de ondas, como por ejemplo, el programa: GoldWave (editor de audio digital con osciloscopios en tiempo real personalizables), o utilizando un programa que lea los impulsos que reciba del emisor. Veremos un ejemplo de este software, para comprenderlo mejor.
El Software GoldWave.
El protocolo de SIRC utiliza una codificación de anchura de impulso de los bits. El pulso que representa un «1» lógico es una ráfaga larga de 1.2ms de la portadora de 40kHz, mientras que el ancho de la ráfaga por un «0» lógico es 0.6ms de largo.
No obstante, el código RC-5 de Philips (son económicos, debido a la amplia disponibilidad de estos mandos a distancia), es posiblemente, el protocolo más utilizado por los aficionados. El protocolo está bien definido para los diferentes tipos de dispositivos que garantizan la compatibilidad con su sistema de mantenimiento en general. Hace algunos años, Philips comenzó a utilizar el nuevo protocolo llamado RC-6, que tiene más características.
La imagen de abajo, muestra un tren de pulsos típico de un mensaje de RC-5. En este ejemplo se transmite el comando $35 para la dirección $05, según indica el fabricante.
La librería que se ha descargado, admite cualquier señal digital para leer la entrada de un módulo receptor de IR a 38KHz. Estos productos, son sistemas receptores de infrarrojos miniaturizados para control remoto. Hay una extensa variedad de modelos en el mercado para elegir, sin embargo todos tienen en común, un diodo y un preamplificador, están montados en un bastidor de conexión, el paquete de epoxi actúa como un filtro IR. Estos receptores proporcionan señal de salida de nivel lógico invertido, filtrada y demodulada que puede ser decodificada directamente por un microprocesador.
La librería para control remoto por infrarrojos consta de dos partes: IRsend transmite paquetes IR, mientras IRrecv recibe y decodifica el mensaje de IR. IRsend utiliza un LED a infrarrojos conectado al pin 3 de salida.
Enviar un código.
Para enviar un mensaje, llama al método de envío del protocolo deseado con los datos a enviar y el número de bits a enviar. El siguiente es un boceto de ejemplo que proporciona la librería para saber como enviar los códigos:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#include // #include IRremote.h IRsend irsend; void setup() { Serial.begin(9600); } void loop() { if (Serial.read() != -1) { for (int i = 0; i < 3; i++) { irsend.sendSony(0xa90, 12); // Sony TV power code delay(40); } } } |
Este programa envía al receptor Sony, un código de encendido/apagado cada vez que se envía un carácter al puerto serie, permitiendo que el Arduino active el encendido o apagado del televisor. (Tengamos en cuenta que, los códigos de Sony deben enviarse 3 veces de acuerdo con el protocolo.)
Recibir un código.
El detector de infrarrojos conectado a cualquier pin de entrada digital, mediante IRrecv decodificará la señal recibida. El siguiente es el boceto que proporciona de ejemplo la librería, para leer los códigos.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
#include // #include IRremote.h int RECV_PIN = 11; IRrecv irrecv(RECV_PIN); decode_results results; void setup() { Serial.begin(9600); irrecv.enableIRIn(); // Start the receiver } void loop() { if (irrecv.decode(&results)) { Serial.println(results.value, HEX); irrecv.resume(); // Receive the next value } } |
La clase IRrecv realiza la decodificación y se inicializa con enableIRIn(). El bucle (loop), llama a irrecv.decode(&results) para ver si se ha recibido un código, si es así, devuelve un valor distinto de cero y coloca los resultados en el registro decode_results. Recomiendo consultar el ejemplo IRrecvDump de la librería para comprender esta estructura. De esta forma se decodifica el código, el método resume() debe ser llamado para reanudar la recepción de códigos. Una cuestión a tener en cuenta es que, el método decode(), no bloquea el desarrollo del programa que, puede realizar otras tareas mientras espera un nuevo código, debido a que los códigos son recibidos por una rutina de interrupción.
Fig. 5
Para el siguiente ejemplo, recurriremos al montaje de abajo, en el que vemos el receptor de IR, cuando no se manda ningún pulso al receptor, la salida de éste, tendría que dar 5V, lo que encenderá el LED. Y cuando pulsamos un botón de un mando a distancia, el led debería parpadear por unos instantes, ya que cuando recibe un pulso, la salida se pone a 0V, lo que apagará el LED. Si ocurre esto, nuestro receptor funciona correctamente. Con un transistor, se puede invertir la señal, si es necesario y aplicar la señal para manejar un relé.
Fig. 6
Realizar este montaje y aplicar el programa de captura que sigue, con él podremos registrar (ver) los impulsos que se producen cuando pulsamos un botón de un mando a distancia.
Presencia del código IR de un emisor.
Este es el código del programa para la detección de código de infrarrojos. Con él podemos ver las señales que emite un mando a distancia.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 |
/* irdeco.pde Boceto decodificador IR ! Este boceto, utiliza el Arduno y un PNA4602, para decodificar lo recibido. Esto puede ser utilizado para hacer un receptor de infrarrojos (En busca de un código especial) o transmisor (por pulsos de un LED IR a ~ 38KHz para las señales detectadas. Código de dominio público. */ //Tenemos que utilizar los métodos de lectura del PIN en "bruto" Debido // a que el tiempo es muy importante aquí y el procedimiento // digitalRead() es más lento! // Digital pin #3 es el pin digital D2, ver //http://arduino.cc/en/Hacking/PinMapping168 para asignar el pin 'en bruto' #define IRpin_PIN PIND #define IRpin 3 // el pulso máximo a leer - 65 milisegundos es un tiempo largo #define MAXPULSE 65000 // cuál debe ser nuestra resolución de tiempo, más grande es mejor // más 'preciso' - pero demasiado grande y no encontraremos // la sincronización exacta #define RESOLUTION 20 // vamos a almacenar hasta 100 pares de impulsos (esto es-mucho-) uint16_t pulses[100][2]; // pair is high and low pulse uint8_t currentpulse = 0; // index for pulses we're storing void setup(void) { Serial.begin(9600); Serial.println("Ready to decode IR!"); } void loop(void) { uint16_t highpulse, lowpulse; // temporary storage timing highpulse = lowpulse = 0; // start out with no pulse length // while (digitalRead(IRpin)) { // this is too slow! while (IRpin_PIN & (1 << IRpin)) { // pin is still HIGH // count off another few microseconds highpulse++; delayMicroseconds(RESOLUTION); // Si el pulso es demasiado largo, tenemos 'Tiempo de espera // agotado '- o nada se ha recibido o ha terminado el código, // por lo que imprimimos lo que hemos agarrado hasta el momento // y, a continuación reiniciamos if ((highpulse >= MAXPULSE) && (currentpulse != 0)) { printpulses(); currentpulse=0; return; } } // we didn't time out so lets stash the reading pulses[currentpulse][0] = highpulse; // same as above while (! (IRpin_PIN & _BV(IRpin))) { // pin is still LOW lowpulse++; delayMicroseconds(RESOLUTION); if ((lowpulse >= MAXPULSE) && (currentpulse != 0)) { printpulses(); currentpulse=0; return; } } pulses[currentpulse][1] = lowpulse; // we read one high-low pulse successfully, continue! currentpulse++; } void printpulses(void) { Serial.println("\n\r\n\rReceived: \n\rOFF \tON"); for (uint8_t i = 0; i < currentpulse; i++) { Serial.print(pulses[i][0] * RESOLUTION, DEC); Serial.print(" usec, "); Serial.print(pulses[i][1] * RESOLUTION, DEC); Serial.println(" usec"); } // print it in a 'array' format Serial.println("int IRsignal[] = {"); Serial.println("// ON, OFF "); for (uint8_t i = 0; i < currentpulse-1; i++) { //Serial.print("\t"); // tab Serial.print("pulseIR("); Serial.print(pulses[i][1] * RESOLUTION , DEC); Serial.print(");"); Serial.println(""); //Serial.print("\t"); Serial.print("delayMicroseconds("); Serial.print(pulses[i+1][0] * RESOLUTION , DEC); Serial.println(");"); } //Serial.print("\t"); // tab Serial.print("pulseIR("); Serial.print(pulses[currentpulse-1][1] * RESOLUTION, DEC); Serial.print(");"); } |
¿Que hace este programa?
Cuando se presiona un botón de un mando a distancia, el led debería parpadear por unos instantes (como se aprecia en la imagen de arriba), generando una serie de impulsos. Este código permite decodificar y registrar dicha sucesión de pulsos y además, nos muestra el código para que lo podamos implementar. Vamos a lo practico. Carguemos el boceto en Arduino, tenemos que abrir el monitor serie y con esto ya estamos en condiciones de decodificar los comandos del mando a distancia que tengamos a mano, cuando pulsemos uno de sus botones.
Básicamente emite un pulso largo para indicar el comienzo de un dato. Luego emite pulsos de 500µS o pulsos de 1,6mS según corresponda un uno o cero lógico. Así emite 32 bits después del pulso inicial. No es importante en este caso saber a qué pulso corresponde el uno o el cero. Vamos a considerar que los pulsos a 600us sean unos y los menores a 1,8mS sean ceros, en base a este criterio se desarrolló este programa que como veremos, nos permite decodificar las teclas presionadas de un mando.
Para este tipo de proyectos sería muy práctico tener un osciloscopio, se trata de un instrumento que no es fácil de adquirir. (Soy consciente que, todo el mundo no tiene ese privilegio, por eso veremos, el modo de realizar ciertas pruebas). Este es el momento de verificar la recepción de los impulsos remitidos por el codificador o mando.
A modo de ejemplo, debajo vemos lo que mostrará el monitor Serial, una vez ejecutado el programa, los datos son similares a estos:
Fig. 7
Estos datos los podemos utilizar para realizar la copia de un mando a distancia que tengamos o también podemos copiar solamente alguna de las funciones del mando a distancia del TV. Por ejemplo, copiar el botón de encendido, el de volumen y el de canal, así, el programa al que aplicamos estos códigos, será capaz de realizar estas funciones de encendido/apagado, subir una persiana o acelerar un motor, etc.
Leer el código de un mando IR.
Este código sirve para la captura del código de un mando.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 |
/* Boceto decodificador IR crudo! Este programa utiliza Arduino y un receptor IR decodificador PNA4602. Esto se puede utilizar para hacer un receptor IR (mediante la búsqueda de un código particular) o transmisor (por pulsación de un LED IR a ~ 38KHz por los retardos detectados. Código de dominio público */ // Tenemos que utilizar los métodos de lectura pin "en crudo", porque // el tiempo es muy importante aquí y el procedimiento digitalRead() // es más lento! // uint8_t IRpin = 2; // Pin digital #2 es el mismo que el Pin D2 ver // Http://arduino.cc/en/Hacking/PinMapping168 para el mapeado de pin 'en crudo' #define IRpin_PIN PIND #define IRpin 2 // el pulso máximo a escuchar - 65 milisegundos es mucho tiempo #define MAXPULSE 65000 // cuál debe ser nuestra resolución de tiempo; más grande es mejor, // ya que es más 'precisa' - pero si es demasiado grande, no vamos // a encontrar la sincronización exacta. #define RESOLUTION 20 // almacenamos hasta 100 pares de impulsos (este es -mucho-) uint16_t pulses[100][2]; // par es pulso de alto y bajo uint8_t currentpulse = 0; // índice de impulsos almacenados void setup(void) { Serial.begin(9600); Serial.println("Listo para decodificar IR!"); } void loop(void) { uint16_t highpulse, lowpulse; // tiempo de almacenamiento temporal highpulse = lowpulse = 0; // empezar con longitud cero del pulso // while (digitalRead(IRpin)) { // esto es demasiado lento! while (IRpin_PIN & (1 << IRpin)) { // pin es todavía HIGH // Contarás unos pocos microsegundos highpulse++; delayMicroseconds(RESOLUTION); // Si el pulso es demasiado largo, agotaremos //'Tiempo de espera' - o no se ha recibido nada // o se termino el código, por lo que se imprime lo que // hemos cogido hasta ahora y, a continuación, restablezca (reset) if ((highpulse >= MAXPULSE) && (currentpulse != 0)) { printpulses(); currentpulse=0; return; } } // no tienen tiempo de espera así que vamos a esconder la lectura pulses[currentpulse][0] = highpulse; // Igual que el anterior while (! (IRpin_PIN & _BV(IRpin))) { // pin is still LOW lowpulse++; delayMicroseconds(RESOLUTION); if ((lowpulse >= MAXPULSE) && (currentpulse != 0)) { printpulses(); currentpulse=0; return; } } pulses[currentpulse][1] = lowpulse; // leímos un pulso alto-bajo con éxito, continúe! currentpulse++; } void printpulses(void) { Serial.println("\n\r\n\rReceived: \n\rOFF \tON"); for (uint8_t i = 0; i < currentpulse; i++) { Serial.print(pulses[i][0] * RESOLUTION, DEC); Serial.print(" usec, "); Serial.print(pulses[i][1] * RESOLUTION, DEC); Serial.println(" usec"); } // print it in a 'array' format Serial.println("int IRsignal[] = {"); Serial.println("// ON, OFF "); for (uint8_t i = 0; i < currentpulse-1; i++) { //Serial.print("\t"); // tab Serial.print("pulseIR("); Serial.print(pulses[i][1] * RESOLUTION , DEC); Serial.print(");"); Serial.println(""); //Serial.print("\t"); Serial.print("delayMicroseconds("); Serial.print(pulses[i+1][0] * RESOLUTION , DEC); Serial.println(");"); } //Serial.print("\t"); // tab Serial.print("pulseIR("); Serial.print(pulses[currentpulse-1][1] * RESOLUTION, DEC); Serial.print(");"); } |
Copie el código, guárdelo (por ejemplo) como decoder_ir.pde y cárguelo en su Arduino, el circuito para realizar este boceto, es el mismo descrito más arriba, pruebe lo comentado en las líneas anteriores, obtendrá su propia experiencia.
Ahora usted puede tener todos los mandos a distancia de su casa en un dispositivo que cabe en su mano con Arduino, no se peleará por quién tiene el control remoto del TV.
Antes de crear un control remoto funcional, tendremos que reunir los códigos de todos los mandos a distancia que queremos usar. Vamos a utilizar un sensor infrarrojo para hacerlo. Para configurar el circuito, podemos seguir el boceto en las imágenes, la conexión de la señal pines del sensor al pin 2 y los otros pines a 5V y masa.
Como se ha comentado, la biblioteca proporciona soporte para el envío y la recepción de las tramas en bruto. Este se destina principalmente para la depuración, pero también se puede utilizar para los protocolos que la biblioteca no implementa, o para proporcionar la funcionalidad de control remoto universal. No sólo se usa para control remoto, también tiene otras aplicaciones, como detector de proximidad.
Los detalles de la biblioteca receptora.
La biblioteca IRrecv consta de dos partes. Una rutina de interrupción que se llama cada 50 microsegundos, mide la longitud de las marcas y espacios, y guarda las duraciones en un búfer. El usuario llama a una rutina de decodificación para decodificar las mediciones almacenadas en el búfer con el valor de código que se envió (típicamente 11 a 32 bits).
La biblioteca de decodificación intenta decodificar protocolos diferentes en la serie, parando si uno tiene éxito. Devuelve una estructura que contiene los datos brutos, los datos decodificados, el número de bits en los datos decodificados, y el protocolo utilizado para descodificar los datos.
Para la decodificación, la macro, determina si la marca o el espacio de tiempo medido es aproximadamente igual al tiempo previsto.
La decodificación RC5/6 es un poco diferente de los demás porque los bits RC5/6 codifican con marca + espacio + espacio o marca, más que por la duración de marcas y espacios. El método auxilia getRClevel divide las duraciones y consigue el nivel de marca/espacio de un único intervalo de tiempo.
Para las transmisiones repetidas (botón pulsado), el código de decodificación devolverá el mismo valor decodificado una y otra vez. La excepción es NEC, que envía un código de repetición especial en lugar de repetir la transmisión del valor. En este caso, la rutina de decodificación devuelve un valor especial REPEAT.
Como detector de proximidad.
También se puede utilizar para el control de un robot, la forma para detectar obstáculos en su proximidad es por chocar sus parachoques en ellos y comprobar los sensores de contacto. Si implementamos el detector de proximidad tendrá una forma de saber que hay algo ahí fuera, incluso antes de que se alcance realmente el obstáculo.
Al igual que con la luz visible, la luz infrarroja es reflejada por todo. Si usted pone algo en frente del emisor de infrarrojos (como una pared o algo así) se reflejará el infrarrojo y el sensor de luz será capaz de verlo parpadear, así es cómo funciona un detector de proximidad.
Para detectar obstáculos reflejados, tenemos que buscar en la lectura del sensor de luz los cambios rápidos. Una forma de lograr esto, es muestrear el sensor con bastante frecuencia y comparar dos lecturas entre sí. Si la diferencia entre ellas es mayor que un umbral pre-establecido (100 unidades, es aceptable), – el detector de proximidad se ha disparado – lo contamos como un impulso. Esto es muy fiable, detecta casi cualquier cosa desde paredes blancas a objetos oscuros o botellas transparentes. Poner una pequeña visera sobre el sensor de luz, para protegerlo de la luz de arriba mejorará mucho el rango de trabajo del sensor.
Las librerías utilizadas en este artículo las puedes obtener en este enlace.
ANEXO.
Han pasado unos años y ha habido cambios a mejor en las librerías que se utilizan en este artículo y debido a algunos correos en los que me indican que hay errores en los códigos mostrados, es el motivo por el cual he realizado esta ampliación al artículo inicial.
El propio autor de las librerías se ha visto en la necesidad de presentar una aclaración que es la que se presenta en las siguientes líneas.
Esta es una wiki bastante antigua pero quizás útil para esta biblioteca.
Conversión de su programa a la versión 3.1
Esto debe hacerse también para todas las versiones> 3.0.1 si USE_NO_SEND_PWM está definido. A partir de esta versión, la generación de PWM se realiza mediante software , ahorrando así el temporizador de hardware y habilitando pines de salida arbitrarios .
Por lo tanto, debes cambiar todo IrSender.begin(true); por IrSender.begin(IR_SEND_PIN, ENABLE_LED_FEEDBACK);. Si usa un núcleo que no usa la -fltobandera para compilar, puede activar la línea #define SUPPRESS_ERROR_MESSAGE_FOR_BEGIN en IRRemote.h, si recibe mensajes de error falsos con respecto a begin () durante la compilación.
CONVERSIÓN DE SU PROGRAMA 2.X A LA VERSIÓN 3.X
- Ahora hay un objeto IRreceiver y IRsender como el conocido objeto Arduino Serial .
- Simplemente elimine la línea IRrecv IrReceiver(IR_RECEIVE_PIN); y / o IRsend IrSender; en su programa, y
reemplace todas las apariciones de IRrecv. o irrecv. con IrReceiver. - Dado que los valores decodificados están ahora IrReceiver.decodedIRData y ya no results,
elimine la línea decode_results results o similar. - Como para el objeto Serial, llame a IrReceiver.begin(IR_RECEIVE_PIN, ENABE_ED_FEEDBACK); o
IrReceiver.begin(IR_RECEIVE_PIN, - DISABLE_LED_FEEDBACK); en lugar de IrReceiver.enableIRIn(); o irrecv.enableIRIn(); en setup ().
- La función decode (decode_results *aResults) anterior se reemplaza por simple decode().
Entonces, si tiene una declaración, if(irrecv.decode(&results)) reemplácela con if (IrReceiver.decode()). - El resultado decodificado está ahora en in IrReceiver.decodedIRData y no más en results, por lo tanto,
reemplace cualquier ocurrencia de results.value y / o results.decode_type y similar a
IrReceiver.decodedIRData.decodedRawData y / o IrReceiver.decodedIRData.decodedRawData. - Overflow, Repeat y otras banderas ahora están disponibles IrReceiver.receivedIRData.flags.
- Rara vez usado: results.rawbuf y results.rawlen debe ser reemplazado por
IrReceiver.decodedIRData.rawDataPtr->rawbufy IrReceiver.decodedIRData.rawDataPtr->rawlen. - Las funciones sendNEC() y sendJVC() están en desuso y renombraron a sendNECMSB() y sendJVCMSB()
para hacerlo más claro que envían datos con MSB primero, que no es el estándar para NEC y JVC.
Úselos para enviar sus antiguos códigos de datos IR de 32 bits . En la nueva versión, enviará comandos NEC
no mediante códigos de 32 bits, sino mediante una dirección (constante) de 8 bits y un comando de 8 bits.
Para una mayor información al respecto, es aconsejable acudir a la descripción del autor de las librerías.
Esta es la nueva librería: Arduino-IRremote-master
Esto es todo por este momento respecto de este viejo tema.
hola amigos, estos códigos funcionan con un notebook que corre con 64 bits??…la pregunta es porque he tenido muchos problemas para decodificar los códigos de teclas de cualquier control remoto, en simple….no puedo hacer funcionar ninguno de los códigos ejemplo y los que se muestran en este foro..
Me podrán ayudar, por favor.
Saludos.
Hola hugo escobar.
En parte tienes razón. He revisado el artículo y después de comprobar la actualización de las librerías que se indican en él, he visto que el autor de las librerías ha actualizado las mismas y ese es el motivo por el que he añadido un anexo al artículo, en el que se indica los cambios que tienes que hacer para que funcionen bien los códigos (no lo he comprobado).
Estas cosas suelen ocurrir debido a que se actualizan con más opciones algunas librerías, por ese motivo hay que revisar el estado de las mismas.
Saludos y cuídate.
quiero controlar un motor dc con un mando a distancia de tv, pero veo que arduino no me deja utilizar el pin del motor de forma analogica, solo funciona de forma digital. Quiero saber si lo que deceo es posible en primera y como
#include
int MOTOR=3;
int SENSOR=11;
int LED=13;
boolean activo=false;
int i;
IRrecv irrecv(SENSOR);
decode_results codigo;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
pinMode(LED,OUTPUT);
analogWrite(MOTOR,0);
irrecv.enableIRIn();
pinMode(MOTOR,OUTPUT);
}
void loop() {
// put your main code here, to run repeatedly:
if(irrecv.decode(&codigo)){
irrecv.resume();
Serial.println(codigo.value,HEX);
seleccion();
delay(500);
// irrecv.resume();
}
//
}
/////////////////AUXILIARES////////////////
void seleccion(){
digitalWrite(LED,HIGH);
switch(codigo.value){
case 0x481:{
motorON();
activo=true;
break;
};
case 0xFE00FF:{
motorOF();
activo=false;
digitalWrite(LED,LOW);
break;
};
}
}
void motorON(){
for(i=0;i=0;i–){
analogWrite(MOTOR,i);
Serial.println(i);
delay(500);
}
}
void motorOF(){
analogWrite(MOTOR,0);
Serial.println(0);
delay(500);
}
Hola José.
Naturalmente que no puedes manejar un motor desde un pin de Arduino, suponiendo que utilizas un transistor como driver tampoco será posible. Necesitas utilizar la opción PWM para ese cometido ya que es más sencillo poder controlar al motor.
Saludos.
Hola, muy buen post fue bueno leerlo aunque no entendiera el 80% de lo que dices porque soy ignorante en el tema de electrónica. Llegue hasta aquí buscando la manera de agregar un software de control remoto a mi celular ya que el posee infrarrojo, por si alguna casualidad sabes sobre el tema o alguna página que me pueda ayudar, mil gracias
Hola, muchas gracias muy buen aporte, solo tengo una duda.
Tengo un Arduino Mega con un sketch que emite varios códigos infrarrojos de un control remoto, pero todos los saca por el pin 9 predeterminado que configura la librería IRremote.
Ahora lo que necesito es que pueda sacar la mitad de los códigos por un pin a mi elección y la otra mitad de los códigos por otro pin también a mi elección sin tomar en cuenta el pin 9.
Mi pregunta es ¿como le puedo hacer?
Parte del código es:
valor_button = digitalRead(pinButton);
if (digitalRead(22) == HIGH)
if (digitalRead(24) == HIGH) { // pulsado el botón
irsend.sendNEC(0xFF08F7,32); // codigo del boton 1
Serial.println(«Señal Enviada de BOTON 1»); // para ver en el monitor serial
delay(500);
}
Hola Leopoldo.
Lo que pretendes es algo más complejo de realizar, no digo que no sea posible, pero tendrás que utilizar algunos if’s y un par de while para cambiar de un pin a otro.
Ya tiene tarea por delante.
Saludos.
Hola, gracias por el aporte solo tengo una consulta al compilar me sale el error amp was not declared, no se el motivo, gracias por su ayuda
Hola Juan.
Tendrás que disculparme en este punto, ya que los errores que se presentan en el código son debidos a una mala configuración del plug-in para el código. En definitiva, donde dice ‘&’ realmente debe decir ‘&’ , en ‘<‘ es ‘<' y en '&tg;=' le corresponde '>=’
Esto no lo había visto, estoy tratando de resolver este problema.
Gracias por el aviso.
P.D. 25/08/2016 13:49 Rectificado el plug-in. Ya se muestra correctamente.
por favor el enlace de descarga de la librería no funciona, y creo que este proyecto me puede servir en algo que estoy trabajando, seria de mucha utilidad , de antemano agradezco
Hola Danier.
Los dos enlaces que aparecen en el artículo están funcionando bien.
En cuanto a las librerías no tienes que bajar ninguna librería ya que se usa la del IDE de Arduino.
Observa que en los códigos no aparece referencia a las librerías como es habitual cuando son necesarias.
Espero haber dado respuesta adecuada a tu consulta.