Control remoto por IR con Arduino.

Hola a todos.

En este artículo voy a explicar como con una placa de Arduino y un mando de infrarrojos sencillo, poder controlar dicha placa y por mediación de esta y un relé,  poder encender/apagar un dispositivo como por ejemplo un ventilador de los de antes.

El diseño utiliza como control el mando de un ventilador de torre que se estropeó y ahora lo utilizo para controlar uno de los económicos que no tiene control remoto.

El software de la placa de Arduino distingue entre los cinco botones del mando, ya que cada uno de ellos envía una serie de pulsos diferentes. Estos pulsos se pueden tratar de capturar con un osciloscopio por ejemplo o mejor aún con un analizador lógico, pero gracias a las bondades de Arduino se puede ver que hay en la placa en un pin de lectura en concreto. De esta forma he obtenido los códigos del mando genérico.

Para facilitar las cosas capturo tres bytes (48 bits) de cada tecla pulsada y leo tres veces cada bit para asegurarme de que todo es correcto.

Lo que capturo del pin digital proviene de un circuito receptor de IR que funciona con una portadora de 38 kilo-hercios. Si no detectásemos los códigos, se encendería o apagaría con cualquier mando a distancia que transmita una señal modulada a esta frecuencia o una cercana.

El circuito integrado foto detector es el TSOP-22. Ojo a la alimentación de las patas. Si no tenéis cuidado, se podría estropear.

Este circuito integrado en reposo a la salida esta a nivel alto, con lo que nuestro programa debería ser capas de contar los ceros para averiguar que tecla se ha pulsado.

Al realizar el programa he podido apreciar que a pesar de utilizar un reloj (cristal de cuarzo) de 16 mega-hercios, las instrucciones afectan a la hora de leeré los datos que el mando envía vía IR.

Una vez haya identificado la placa de Arduino el código de encendido, se saca un uno lógico por un pin que haga uso de un relé de los que están pensados para utilizarse con Arduino (son de cinco voltios). Podéis pensar en usar un transistor en conmutación con un relé de cinco voltios, pero deberíais usar otra fuente externa para hacer funcionar el relé.

Este relé de Arduino se puede configurar para ser activado por unos o ceros, y tiene un circuito de conmutación, que lo usaremos para encender como por ejemplo en mi caso como ya os he dicho, un ventilador sin mando. OJO CON LA TENSIÓN DE LA RED — 230 VAC — QUE PUEDE TRAER UN DISGUSTO SI NO TENEMOS CUIDADO.

El programa es mejorable (estoy en ello) y es el siguiente:

const int IR=11;
const int LED = 13;
const int RELE=12;

int leer()
{
    int valor = digitalRead(IR);
    return valor;
}

void escribir(int valor)
{
    Serial.print(valor,» «);
}

void encender()
{
    digitalWrite(LED, HIGH);
    digitalWrite(RELE, LOW);
}

void apagar()
{
    digitalWrite(LED, LOW);
    digitalWrite(RELE, HIGH);
}

void setup()
{
    pinMode(LED, OUTPUT);
    pinMode(RELE, OUTPUT);
    apagar();
    Serial.begin(38400); //Para verlo en el monitor serie
}

void loop()
{
  int datos [3];
  int datosTemp [3];
  bool encendido = false;

  const int datosBR[3] = {26, 109, 159};
  const int datosB1[3] = {26, 101, 191};
  const int datosB2[3] = {26, 105, 191};
  const int datosB3[3] = {26, 108, 191};
  const int datosB4[3] = {26, 109, 63};

  do
  {
    int valor0 = 0, valor1 = 0, valor2 = 0;
    int valor = leer();

    if (valor == 0)
    {
      for (int j=0; j<=2; j++)
      {
        int multiplicador = 128;
        int numeroDecimal = 0;

        valor0 = 0; valor1 = 0; valor2 = 0;

        for (int i=1; i<=8; i++)
        {
          valor0 = leer();
          valor1 = leer();
          valor2 = leer();

          if ((valor0 == valor1) && (valor0 == valor2))
          {
            escribir(valor0);
            numeroDecimal += valor0 * multiplicador;
            multiplicador = multiplicador / 2;
            delay(1);
          }
        }
        Serial.print(» -=> «);
        Serial.println(numeroDecimal);
        datos[j]=numeroDecimal;
      }

      Serial.println();
      delay (200);

      bool teclaRoja = true;
      bool teclaB1 = true;
      bool teclaB2 = true;
      bool teclaB3 = true;
      bool teclaB4 = true;

      for (int j=0; j<=2; j++)
      {
        if (datos[j] != datosBR[j])
        {
          encendido = false;
          teclaRoja = false;
        }

        if (datos[j] != datosB1[j])
        {
          teclaB1 = false;
        }

        if (datos[j] != datosB2[j])
        {
          teclaB2 = false;
        }

        if (datos[j] != datosB3[j])
        {
          teclaB3 = false;
        }

        if (datos[j] != datosB4[j])
        {
          teclaB4 = false;
        }
      }

      /************************************************************/

      if ((encendido == false) && (teclaRoja == true))
      {
        Serial.println(» ENCENDIDO «);
        encendido = true;
        encender();
      }
      else if ((encendido == true) && (teclaRoja == true))
      {
        Serial.println(» APAGADO «);
        encendido = false;
        apagar();
      }

      /************************************************************/

      if (teclaB1 == true)
      {
        Serial.println(» BOTON1 «);
      }

      if (teclaB2 == true)
      {
        Serial.println(» BOTON2 «);
      }

      if (teclaB3 == true)
      {
        Serial.println(» BOTON3 «);
      }

      if (teclaB4 == true)
      {
        Serial.println(» BOTON4 «);
      }
      delay (100);
    }

  } while (true);
}

Os comento que si usáis otro mando, los códigos serán diferentes. También os recomiendo que elijáis un mando lo mas sencillo posible, ya que los que disponen de muchas funciones transmiten mucha información y si hay un pequeño error en la transmisión no recibiréis el mismo código mas de una vez.

Lo ideal sería que el fabricante nos dijera como es el protocolo del mando o que nosotros tuviéramos un analizador lógico. También se podría hacer un mando a nuestro aire. Quizás sería un tema interesante para un próximo artículo.

Las instrucciones influyen en el programa y esto es así debido a que la velocidad del programa de la placa de Arduino está limitada por el cristal de cuarzo que tiene, que en la mía es de 16 mega-hercios.

En la siguiente imagen se muestra la ventana de donde he obtenido los códigos de control del mando a distancia:

Como podéis observar, el programa reconoce los códigos de manera correcta.

A continuación os dejo unas fotos del proyecto:

En esta foto se ve a la izquierda el agujero que permite que el receptor de IR pueda captar los infrarrojos del mando.  Los dos conectores del Arduino, USB y alimentación. Y a la derecha un diodo led verde que indica que el relé esta activado.

En la siguiente foto se ve con mas detalle el interior:

A la izquierda podéis apreciar el circuito impreso que alberga el relé que usaremos para encender/apagar los dispositivos que queramos. el cable de red negro es una entrada y el blanco una salida que va a una base hembra bifilar aérea.

Y esto es todo, hasta el siguiente artículo.