El protocolo de los controles remotos: Philips RC-5

Transcripción

1 El protocolo de los controles remotos: Philips RC-5 A menudo en la etapa de desarrollo de algún proyecto pensamos en que sería útil la utilización de un control a distancia. El control de este tipo más comúnmente utilizado es el control remoto mediante infrarrojos, como el usado en cualquier televisor o equipo de audio. Tenemos dos alternativas: o desarrollamos desde cero nuestro protocolo de comunicaciones (y el hardware del emisor) o bien adoptamos alguno de los existentes en el mercado. Quizás el más difundido y sobre el que más información se puede encontrar es el empleado por Philips, llamado "RC-5". Este protocolo ha sido adoptado por muchos otros fabricantes, por lo que es posible encontrar controles remotos "genéricos" por muy poco dinero. Este documento contiene la información necesaria para que podamos decodificar los mensajes enviados por estos controles remotos en nuestros proyectos. > Características: Las características más sobresalientes de este protocolo están resumidas en las siguientes líneas: - 5 bits de dirección y 6 bits para el comando (7, en el caso del RC5X) - Codificación tipo Manchester (Bi-phase coding) - Frecuencia portadora de 36KHz. - Tiempo constante para cada bit, de 1.778ms (64 ciclos a 36KHz.) La mayoría de los controles remotos implementan este protocolo. > El protocolo: El protocolo consiste en un tren de pulsos cuadrados de 36Khz (la denominada "portadora"). Cada "1" esta codificado como 889 microsegundos de pulsos, y 889 microsegundos de "silencio". El "0" se codifica como 889 microsegundos de "silencio" y 889 microsegundos de pulsos. La longitud total del "0" y del "1" es idéntica, y son 1778 microsegundos (o 1,778 milisegundos). El grafico siguiente ilustra claramente esto:

2 Dentro de un bit "caben" exactamente 64 pulsos, si la portadora es de 36KHz. Es decir, el periodo de una señal de 36KHz es de 1/ = µs, que multiplicado por 64 da exactamente 1778 µs. Este es un buen dato para tener en cuenta el diseño del software de nuestro receptor. Para que el receptor sepa que le está "diciendo" el emisor remoto, debe poder interpretar las "tramas" de ceros y unos que este le envía. Cada trama es un comando, y está compuesto por 14 bits (15 en el caso del RC5X). De esos 14 bits, los primeros 2 bits son de "start" (arranque): siempre son "1". El tercer bit se invierte cada vez que una tecla se pulsa y se suelta nuevamente, para poder distinguir si una tecla permanece presionada o se ha presionado más de una vez. Los siguientes 5 bits corresponden a la dirección del dispositivo receptor, y los últimos 6 al comando trasmitido. Esto permite utilizar un mismo control remoto para comandar diferentes equipos, simplemente asignando a cada uno un código de dirección diferente. Una trama RC5 completa. Hay una variación del código RC5 llamada RC5X que dispone de 7 bits para determinar el comando (lo que permite 128 comandos diferentes vs. los 64 comandos del RC5 tradicional). La forma de la trama es la misma, pero el segundo bit de start (S2) es utilizado como el bit 7 del comando. Tanto en la dirección como en el comando, primero se transmite el bit mas significativo (MSB) y por ultimo el menos significativo (LSB) La longitud completa de la trama es igual a 14 * us = us. Si la tecla se mantiene presionada, la trama se reenvía continuamente, pero con una pausa de equivalente a 50 bits ( 50 x us = us) entre una y otra transmisión. Como dijimos antes, viendo el estado del tercer bit podemos determinar si se trata de pulsaciones sucesivas de la misma tecla (el bit cambiaria) o de una misma pulsación "larga" (el bit permanece en el mismo estado) Diagramas de tiempo para una transmisión completa.

3 > Comandos pre-definidos Si estamos creando nuestro propio control remoto, podemos adoptar cualquier dirección y comando para las funciones que implementemos. Pero lo más posible es que queramos utilizar un control remoto de algún aparato en desuso o incluso un control remoto "genérico" nuevo, que seguramente nos costara menos que armarnos uno. En ese caso, deberíamos consultar las siguientes tablas para saber cuales son los comandos predefinidos por Philips: Direcciones. Las que figuran en blanco no están asignadas, y es buena idea utilizarlas para nuestros proyectos. Lista de comandos asignados para TV y VCR por Philips.

4 Partimos de esta parte teórica para programar la recepción de un mando y el envío con protocolo RC-5 > Análisis de un 0 lógico o de un 1 lógico TRAMA RC Primer bit Siempre a 1. Bit de inicio de RC5 y RC5X Segundo bit Bit de inicio de RC5 (a 1 ). En RC5X se usa como 7 bit de comando. Tercer bit Se invierte su valor cada vez que se pulsa una tecla. ( ) 4º, 5º, 6º, 7º y 8º (5 bits) Direcciones. En este caso vale = 5 HEX VCR 9º, 10º, 11º, 12º, 13º y 14º (6 bits) Comando. En este caso = 1 HEX Tecla 1 En hexadecimal sería: 0x Ejemplo de uso de TV1 y Tecla PROG+ 0x Si pulso otra vez la tecla PROG+ 0x (En azul bit que cambia) Si mantenemos pulsada una tecla se emite la misma trama a intervalos de unos 114 microsegundos. > Diseño del circuito emisor de infrarrojos Conectamos: GND Resistencia de 220 Ohmios Cátodo Diodo infrarrojos Anodo pin 5 PWM. Ponemos dos pulsadores y un diodo EMISOR de infrarrojos como se ve en la gráfica.

5 Pulsador de la izquierda (pin 12) Manda una ráfaga para subir un canal (prog+). Pulsador de la derecha (pin 11) Manda una ráfaga para bajar un canal (prog-) FUNDAMENTO Subir o bajar canal al pulsar un botón u otro, enviando la información mediante el LED de infrarrojos emisor. CÓMO PROGRAMAR EL ARDUINO? La mayor dificultad es mandar una ráfaga (trama) de información, con protocolo RC5, para que un TV o VCR, lo interprete correctamente. Vamos a crear una función llamada pulsos para generar los 32 ciclos de impulsos. Cada impulso tiene unos microsegundos de nivel alto y unos 9.26 microsegundos de nivel bajo. OJO: Cada instrucción del programa tarda sobre unos 8 microsegundos en ejecutarse, por lo que habrá que tenerlo en cuenta a la hora de hacer nuestra función. La duración total tiene que ser de unos 889 microsegundos. void pulsos() // long tiempo = micros(); for (int i=0; i < 32; i++) digitalwrite(pinirsalida, HIGH); // Ponemos a nivel alto el pinirsalida (pin 5)

6 delaymicroseconds(11); // Lo mantenemos 18,52 µs = 11 + tiempo que tarda una instrucción digitalwrite(pinirsalida, LOW); // Ponemos a nivel alto el pinirsalida (pin 5) delaymicroseconds(3); // Lo mantenemos 9,26 µs = 3 + tiempo que tarda una instrucción // tiempo = micros() - tiempo; // mide el tiempo en µs que tarda en ejecutarse el bucle. //Serial.println(tiempo); El texto en rojo, usado para depurar, nos saca en pantalla el tiempo total de los 32 impulsos, que debe dar aproximadamente unos 889 µs. Cuando se usa para la trama hay que volver a poner los // de comentario, para evitar pérdida de tiempo. Esto haría que la trama en vez de 25 ms pase a ser mayor, lo que implica que el receptor no lo interpretaría bien. Los retardos de 11 y 3 los conseguí midiendo el tiempo de nivel alto y de nivel bajo (con el texto en rojo, pero entre las dos líneas de cada nivel). A continuación va el programa comentado. Está programado para un TV. Subir y bajar de canal. Nombre del programa: emisor_infrarrojos_rc5_subir_bajar_programa.pde // inicializo variables globales int pinirsalida = 5; int pulsador1 = 12; int pulsador2 = 11; int conmuta = 0; // Establezco como van a ser los pines void setup() Serial.begin(9600); // Usado para ir comprobando los datos. Se puede QUITAR cuando funcione. pinmode(pinirsalida, OUTPUT); // pin a través del cual mando las tramas. pinmode(pulsador1, INPUT); // pulsador para subir de canal (prog+) pinmode(pulsador2, INPUT); // pulsador para bajar de canal (prog-) // función para enviar un dato (trama) al receptor (TV o VCR) void enviardato(unsigned long dato) int bits_a_enviar[14]; // variable local. Para dividir el dato en bits unsigned long compara = 0x2000; // (14 digitos) Serial.print(" Dato a enviar: "); // QUITAR Serial.println(dato, BIN); for (int i=0; i < 14; i++) // trama de 14 bits. bits_a_enviar[i] = (dato & compara)? 1:0; // Hace la función "and" (&) entre dato y compara // Si el bit 14 de dato es uno, almacena 1 en bits_a_enviar[i] // Si el bit 14 de dato es cero, almacena 0 en bits_a_enviar[i] Serial.print(bits_a_enviar[i]); // QUITAR Serial.print(" "); Serial.println(compara,BIN);

7 compara = compara >> 1; // desplaza un bit hacia la derecha: // Va repiendo el proceso con el bit 13, 12, 11, etc. /* Resultado en pantalla al pulsar el pulsador 2 (pin 11) por 2ª vez. Dato a enviar: */ long tiempo_trama = micros(); // Vamos a medir la trama, que debe ser de unos 25 ms (25000 µs) // Se podría QUITAR // long tpo2 = micros(); // tpo2 mide el tiempo de envio de los 2 bits de inicio (1,5 en realidad) // MANDO los 2 bits de inicio (La 1ª parte seria mandar un cero durante 889 µs. No haría nada (no hace falta)) pulsos(); // 2ª parte del primer bit de inicio. Tren de impulsos 889 µs espacio(); // 1ª parte 2º bit de inicio. Nivel bajo 889 microsegundos pulsos(); // 2ª parte del 2º bit de inicio. Fin envio dos bits de inicio. Tren de impulsos 889 µs // tpo2 = micros() - tpo2; // Serial.println(tpo2); // Resultado = 2667 aproximadamente. // Empezamos a mandar desde el tercer bit hasta el 14. for (int i=2; i < 14; i++) //tpo2 = micros(); // tpo 2 mide el envio de un bit completo. Unos 1778 µs if (bits_a_enviar[i] == 1) nivelalto(); else nivelbajo(); // tpo2 = micros() - tpo2; // Serial.println(tpo2); tiempo_trama = micros() - tiempo_trama; Serial.print("Tiempo de la trama = "); Serial.println(tiempo_trama); // Resultado aproximado: Tiempo de la trama = void loop() if (digitalread(pulsador1))

8 if (conmuta) //dato_uno(); enviardato(0x3020); // 0x3160 prog+ VCR conmuta = 0; // 0x3020 prog+ TV else enviardato(0x3820); // 0x3960 prog+ 2ª pulsacion VCR conmuta = 1; // 0x3820 prog+ 2 pul TV delay(100); if (digitalread(pulsador2)) if (conmuta) //dato_uno(); enviardato(0x3021); // 0x3161 prog- VCR conmuta = 0; // 0x3021 prog+ TV else enviardato(0x3821); // 0x3961 prog- 2ª pulsacion VCR conmuta = 1; // 0x3821 prog+ 2 puls TV delay(100); void pulsos() // Deducido de un programa: dos tiempos en alto y uno en bajo. //long tiempo = micros(); for (int i=0; i < 32; i++) digitalwrite(pinirsalida, HIGH); // Ponemos a nivel alto el pinirsalida (pin 5). Impulso. delaymicroseconds(11); // Lo mantenemos 18,52 µs = 11 + tiempo que tarda una instrucción digitalwrite(pinirsalida, LOW); // Ponemos a nivel alto el pinirsalida (pin 5). Descanso delaymicroseconds(3); // Lo mantenemos 9,26 µs = 3 + tiempo que tarda una instrucción // tiempo = micros() - tiempo; //Serial.println(tiempo); void espacio() digitalwrite(pinirsalida,low); // Pone el pin 5 a nivel bajo. No envía datos. delaymicroseconds(870); // Retardo de 889 µs = tiempo instrucción void nivelalto() // Mandamos un 0 y 1

9 espacio(); pulsos(); void nivelbajo() // Mandamos un 1 y 0 pulsos(); espacio(); > Diseño del circuito receptor de infrarrojos Necesitamos un diodo RECEPTOR de infrarrojos, que trabaje bien sobre los 36KHz. GND Ánodo del receptor de infrarrojos Cátodo Resistencia de unos 300K Vcc (5v) Del cátodo sacamos una conexión al pin 2 PWM Corresponde con la interrupción 0 del Arduino. En primer lugar vamos a ver un ejemplo de uso de las interrupciones. attachinterrupt(nº interrupción, nombre de la función, modo) Arduino tiene dos interrupciones externas. Interrupción 0 en el pin 2. Interrupción 1 en el pin 3.

10 El Arduino MEGA tiene 4 mas: interrupción 2 (pin 21), 3 (pin 20), 4 (pin 19) y 5 (pin 18). modo: CHANGE se dispara cuando el valor del pin cambia. LOW se dispara cuando el pin esta en nivel bajo (LOW) RISING se dispara cuando el pin pasa desde nivel bajo a alto (LOW HIGH) FALLING se dispara cuando el pin pasa desde nivel alto a bajo (HIGH LOW) int pin = 13; volatile int state = LOW; void setup() pinmode(pin, OUTPUT); attachinterrupt(0, blink, CHANGE); // Ejecuta la función blink cuando cambia el // nivel en el pin 2 void loop() digitalwrite(pin, state); // se ejecuta continuamente, pero solo cambia cuando se // produce un cambio de nivel en el pin 2 (interrupción 0) void blink() // función que se ejecuta cuando se produce la interrupción state =!state; // cambia de bajo a alto y viceversa Desactiva la interrupción que le indiquemos. detachinterrupt(interrupción) El uso de las interrupciones es muy bueno para controlar datos de entrada que no deben esperar en el bucle loop y ejecutar una función que no está en el loop. En nuestro caso la función de decodificar una señal de un mando solo se ejecutará cuando se haya producido la interrupción, que provoca la llegada de un nivel alto en el pin 2 (interrupción 0). A continuación el programa para recibir los datos de un mando con protocolo RC5 (Philips). (Leemos datos cada 100 microsegundos aproximadamente, cuando se produce una interrupción en el pin2) El programa va comentado y en pantalla saca los datos recibidos de tal forma que vayamos entendiendo las líneas de código). Nombre del programa: recibir_datos_infrarrojos_arduino.pde int pulsador1 = 12; long resultado = 0; // Almaceno el resultado obtenido de la pulsación de un tecla del mando int contador = 1; // Cuenta las veces que activo el pulsador1 void setup() Serial.begin(9600); pinmode(pulsador1, INPUT); // INTERRUPCIÓN. Ejecuta la función "recibir" cuando el pin 2 pase a nivel HIGH attachinterrupt(0, recibir, HIGH);

11 void loop() // Cuando se activa el pulsador1 sacamos el resultado en pantalla if (digitalread(pulsador1) == HIGH) Serial.print(" PULSADO "); // Veces pulsadas Serial.println(contador); Serial.print(" RESULTADO = "); Serial.println(resultado, HEX); contador++; // Se mantiene en este bucle hasta que se suelta el pulsador1 while (digitalread(pulsador1) == HIGH) delay(300); void recibir() long tiempos[28]; boolean desbordamiento = 0; boolean error = 0; int nb = 2; int nbtotal = 0; boolean cambia_nivel = 1; // Inicializo los tiempos a cero. for (int i=0; i < 28; i++) tiempos[i] = 0; // Cuando recibamos un impulso positivo if (!digitalread(2)) // Detectamos el primer nivel alto. Guardamos el dato tiempos[1], sobre 7 while (!digitalread(2)) tiempos[1]++; delaymicroseconds(100); // Si algun tiempo es menor de 700 (7*100) microsegundos da ERROR. // Cada nivel como minimo son 889 microsegundos. if (tiempos[1] < 6) desbordamiento = 1; error = 1; // Si el primer dato es correcto, o sea, nivel alto. Tiempo sobre 7. if (!error) // Hasta que un dato sea mayor que 25, indica un nivel bajo // Vamos guardando tiempo bajo, alto, bajo, alto, etc while (!desbordamiento) while(digitalread(2)==cambia_nivel)

12 tiempos[nb]++; delaymicroseconds(100); if (tiempos[nb] < 6) desbordamiento = 1; error = 1; nb = 2; if (tiempos[nb] > 25) desbordamiento = 1; nbtotal = nb - 1; cambia_nivel =!cambia_nivel; nb++; /* while(!digitalread(2)) tiempos[nb]++; delaymicroseconds(100); nb++; if (tiempos[nb] > 25) desbordamiento = 1; nbtotal = nb - 1; */ if (nb < 14) error = 1; // No se han recibido la trama completa // Si no ha habido más errores guardamos los datos en res[i] // if (!error) // tiempos[1] sobre 7 indica nivel alto // tiempos pares indican nivel bajo sobre 7,8,9 "0" y 15,16,17,18 "00" // tpos impares indican nivel alto sobre 7,8,9 "1" y 15,16,17,18 "11" cambia_nivel = 1; int res[50]; int bit_totales = 0; for (int i=2; i < nb; i++) Serial.print(i); Serial.print(" "); Serial.println(tiempos[i]); res[bit_totales] = cambia_nivel; bit_totales++; if (tiempos[i] > 12) res[bit_totales] = cambia_nivel; bit_totales++; cambia_nivel =!cambia_nivel; //Serial.println(bit_totales); // Tomamos los bits pares que guardamos en el resultado (variable global) resultado = 1; for (int i = 0; i < bit_totales-1; i++) Serial.print(res[i]); if (i % 2) if (res[i] == 1) resultado = resultado <<= 1; else resultado = (resultado <<=1) 1; // Comprobamos que el resultado es el deseado en pantalla. Serial.println(" Resultado obtenido "); Serial.println(resultado, BIN); Serial.println(resultado, HEX); char data_word = resultado & 0x3F; // Nos quedamos con los 6 ultimos bits (comando) Serial.println(data_word, HEX);

13 Se puede hacer de varias formas, probadas, pero creo que esta está mejor depurada. Aconsejo que probéis con otras posibilidades que se os ocurran. Objetivo: poder hacer los emisores y detectores de otros protocolos como el RC6, NEC, SONY, NOKIA, etc Resultados en pantalla al pulsar el canal 1 de un mando de video VCR Resultado obtenido El 0 y 1 son el primer bit de inicio que es 1, sino no sacaríamos esta pantalla. El 22 vale 834 *100 = 83400, que corresponde con el tiempo de reposo entre ráfaga y ráfaga Le falta el 0 inicial. Cogemos como resultado final los impares Resultado en binario = 0x3941 en Hexadecimal 3941 resultado en hexadecimal. 1 Canal pulsado.