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:
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/36.000 = 27.78125... µ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 * 1.778 us = 24.892 us. Si la tecla se mantiene

presionada, la trama se reenvía continuamente, pero con una pausa de equivalente a 50 bits ( 50 x
1.778 us = 88.900us) 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.

> 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 Lista de comandos asignados para TV y VCR por
asignadas, y es buena idea Philips.
utilizarlas para nuestros proyectos.
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 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 sería: 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.

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

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 18.52
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)
 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; // 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 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);
 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 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 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 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 = 870 + tiempo instrucción
}

void nivelAlto() // Mandamos un 0 y 1

{
 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.
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
}

detachInterrupt(interrupción)

Desactiva la interrupción 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 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);
}
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 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);
}
 }
}

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.

27
3 10
46
5 19
66
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 sacaríamos esta pantalla.

El 22 vale 834  *100 = 83400, que corresponde con el tiempo de reposo entre ráfaga y ráfaga.

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.