El protocolo de los controles remotos: Philips RC-5

A menudo en la etapa de desarrollo de algn proyecto pensamos en que sera til la utilizacin de un control a distancia. El control de este tipo ms comnmente 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.

Quizs el ms difundido y sobre el que ms informacin 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 "genricos" por muy poco dinero.

Este documento contiene la informacin necesaria para que podamos decodificar los mensajes enviados por estos controles remotos en nuestros proyectos.

> Caractersticas: Las caractersticas ms sobresalientes de este protocolo estn resumidas en las siguientes lneas:

- 5 bits de direccin y 6 bits para el comando (7, en el caso del RC5X) - Codificacin tipo Manchester (Bi-phase coding) - Frecuencia portadora de 36KHz. - Tiempo constante para cada bit, de 1.778ms (64 ciclos a 36KHz.)

La mayora 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 idntica, y son 1778 microsegundos (o 1,778 milisegundos). El grafico siguiente ilustra claramente esto:

Dentro de un bit "caben" exactamente 64 pulsos, si la portadora es de 36KHz. Es decir, el periodo de una seal de 36KHz es de 1/36.000 = 27.78125... s, que multiplicado por 64 da exactamente 1778 s. Este es un buen dato para tener en cuenta el diseo 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 enva. 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 ms de una vez. Los siguientes 5 bits corresponden a la direccin 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 cdigo de direccin diferente.

Una trama RC5 completa.

Hay una variacin del cdigo 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 direccin 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 * 1.778 us = 24.892 us. Si la tecla se mantiene presionada, la trama se reenva continuamente, pero con una pausa de equivalente a 50 bits ( 50 x 1.778 us = 88.900us) entre una y otra transmisin. 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 pulsacin "larga" (el bit permanece en el mismo estado)

Diagramas de tiempo para una transmisin completa.

> Comandos pre-definidos Si estamos creando nuestro propio control remoto, podemos adoptar cualquier direccin y comando para las funciones que implementemos. Pero lo ms posible es que queramos utilizar un control remoto de algn aparato en desuso o incluso un control remoto "genrico" nuevo, que seguramente nos costara menos que armarnos uno.

En ese caso, deberamos consultar las siguientes tablas para saber cuales son los comandos predefinidos por Philips:

Direcciones. Las que figuran en blanco no estn asignadas, y es buena idea

utilizarlas para nuestros proyectos.

Lista de comandos asignados para TV y VCR por Philips.

Partimos de esta parte terica para programar la recepcin de un mando y el envo con protocolo RC-5

> Anlisis de un 0 lgico o de un 1 lgico

TRAMA RC5

1 1 0 0 0 1 0 1 0 0 0 0 0 1

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. (0 1 0 1 )

4, 5, 6, 7 y 8 (5 bits) Direcciones. En este caso vale 00101 = 5 HEX VCR

9, 10, 11, 12, 13 y 14 (6 bits) Comando. En este caso 000001 = 1 HEX Tecla 1

En hexadecimal sera: 0x3141 11 0001 0100 0001

Ejemplo de uso de TV1 y Tecla PROG+ 0x3021 11 0000 0010 0001

1 1 0 0 0 0 0 0 1 0 0 0 0 1

Si pulso otra vez la tecla PROG+ 0x3821 11 1000 0010 0001 (En azul bit que cambia)

1 1 1 0 0 0 0 0 1 0 0 0 0 1

Si mantenemos pulsada una tecla se emite la misma trama a intervalos de unos 114 microsegundos.

> Diseo del circuito emisor de infrarrojos Conectamos:

GND Resistencia de 220 Ohmios Ctodo Diodo infrarrojos Anodo pin 5 PWM.

Ponemos dos pulsadores y un diodo EMISOR de infrarrojos como se ve en la grfica.

Pulsador de la izquierda (pin 12) Manda una rfaga para subir un canal (prog+).

Pulsador de la derecha (pin 11) Manda una rfaga para bajar un canal (prog-)

FUNDAMENTO

Subir o bajar canal al pulsar un botn u otro, enviando la informacin mediante el LED de infrarrojos emisor.

CMO PROGRAMAR EL ARDUINO?

La mayor dificultad es mandar una rfaga (trama) de informacin, con protocolo RC5, para que un TV o VCR, lo interprete correctamente.

Vamos a crear una funcin llamada pulsos para generar los 32 ciclos de impulsos. Cada impulso tiene unos 18.52 microsegundos de nivel alto y unos 9.26 microsegundos de nivel bajo.

OJO: Cada instruccin del programa tarda sobre unos 8 microsegundos en ejecutarse, por lo que habr que tenerlo en cuenta a la hora de hacer nuestra funcin.

La duracin 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)

delayMicroseconds(11); // Lo mantenemos 18,52 s = 11 + tiempo que tarda una instruccin digitalWrite(pinIRSalida, LOW); // Ponemos a nivel alto el pinIRSalida (pin 5) delayMicroseconds(3); // Lo mantenemos 9,26 s = 3 + tiempo que tarda una instruccin } // 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 prdida de tiempo. Esto hara que la trama en vez de 25 ms pase a ser mayor, lo que implica que el receptor no lo interpretara 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 lneas de cada nivel).

A continuacin 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 travs del cual mando las tramas. pinMode(pulsador1, INPUT); // pulsador para subir de canal (prog+) pinMode(pulsador2, INPUT); // pulsador para bajar de canal (prog-) } // funcin 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; // 10 0000 0000 0000 (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 funcin "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);

compara = compara >> 1; // desplaza un bit hacia la derecha: 1 0000 0000 0000 // 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: 11100000100001 1 10000000000000 1 1000000000000 1 100000000000 0 10000000000 0 1000000000 0 100000000 0 10000000 0 1000000 1 100000 0 10000 0 1000 0 100 0 10 1 1 */ } long tiempo_trama = micros(); // Vamos a medir la trama, que debe ser de unos 25 ms (25000 s) // Se podra 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 hara 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 889+889+889 = 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 = 23908 } void loop() { if (digitalRead(pulsador1)) {

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 instruccin digitalWrite(pinIRSalida, LOW); // Ponemos a nivel alto el pinIRSalida (pin 5). Descanso delayMicroseconds(3); // Lo mantenemos 9,26 s = 3 + tiempo que tarda una instruccin } // tiempo = micros() - tiempo; //Serial.println(tiempo); } void espacio() { digitalWrite(pinIRSalida,LOW); // Pone el pin 5 a nivel bajo. No enva datos. delayMicroseconds(870); // Retardo de 889 s = 870 + tiempo instruccin } void nivelAlto() // Mandamos un 0 y 1 {

espacio(); pulsos(); } void nivelBajo() // Mandamos un 1 y 0 { pulsos(); espacio(); }

> Diseo del circuito receptor de infrarrojos Necesitamos un diodo RECEPTOR de infrarrojos, que trabaje bien sobre los 36KHz.

GND nodo del receptor de infrarrojos Ctodo Resistencia de unos 300K Vcc (5v)

Del ctodo sacamos una conexin al pin 2 PWM Corresponde con la interrupcin 0 del Arduino.

En primer lugar vamos a ver un ejemplo de uso de las interrupciones.

attachInterrupt(n interrupcin, nombre de la funcin, modo)

Arduino tiene dos interrupciones externas.

Interrupcin 0 en el pin 2.

Interrupcin 1 en el pin 3.

El Arduino MEGA tiene 4 mas: interrupcin 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 funcin 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 (interrupcin 0) } void blink() // funcin que se ejecuta cuando se produce la interrupcin { state = !state; // cambia de bajo a alto y viceversa }

detachInterrupt(interrupcin)

Desactiva la interrupcin que le indiquemos.

El uso de las interrupciones es muy bueno para controlar datos de entrada que no deben esperar en el bucle loop y ejecutar una funcin que no est en el loop.

En nuestro caso la funcin de decodificar una seal de un mando solo se ejecutar cuando se haya producido la interrupcin, que provoca la llegada de un nivel alto en el pin 2 (interrupcin 0).

A continuacin el programa para recibir los datos de un mando con protocolo RC5 (Philips).

(Leemos datos cada 100 microsegundos aproximadamente, cuando se produce una interrupcin en el pin2)

El programa va comentado y en pantalla saca los datos recibidos de tal forma que vayamos entendiendo las lneas de cdigo). Nombre del programa: recibir_datos_infrarrojos_arduino.pde

int pulsador1 = 12; long resultado = 0; // Almaceno el resultado obtenido de la pulsacin de un tecla del mando int contador = 1; // Cuenta las veces que activo el pulsador1 void setup() { Serial.begin(9600); pinMode(pulsador1, INPUT); // INTERRUPCIN. Ejecuta la funcin "recibir" cuando el pin 2 pase a nivel HIGH attachInterrupt(0, recibir, HIGH); }

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 0000000... // Vamos guardando tiempo bajo, alto, bajo, alto, etc while (!desbordamiento) { while(digitalRead(2)==cambia_nivel) {

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 ms 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

} }

Se puede hacer de varias formas, probadas, pero creo que esta est mejor depurada.

Aconsejo que probis 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.

2 7 3 10 4 6 5 19 6 6 7 10 8 15 9 18 10 15 11 18 12 6 13 10 14 7 15 10 16 6 17 10 18 6 19 10 20 15 21 10 22 834 101001011001100101010101101 Resultado obtenido 11100101000001 3941 1

El 0 y 1 son el primer bit de inicio que es 1, sino no sacaramos esta pantalla.

El 22 vale 834 *100 = 83400, que corresponde con el tiempo de reposo entre rfaga y rfaga.

101001011001100101010101101 Le falta el 0 inicial. Cogemos como resultado final los impares. 11100101000001 Resultado en binario. 11 1001 0100 0001 = 0x3941 en Hexadecimal 3941 resultado en hexadecimal. 1 Canal pulsado.