Decodificando Controles Remotos Pretos ou Brancos com Arduino

Decodificando Controles Remotos Pretos ou Brancos com Arduino

Neste tutorial, aprenderemos como decifrar as teclas de controles remotos infravermelhos preto e branco usando um Arduino e um receptor IR. Ao final deste projeto, você será capaz de determinar qual tecla foi pressionada no controle remoto e exibir essa informação no monitor serial. Isso pode ser útil para controlar dispositivos com qualquer controle remoto que você tenha, como TVs ou outros aparelhos (no vídeo às 01:00).

Usaremos uma configuração simples que inclui um Arduino, um módulo receptor infravermelho e o código necessário para decodificar os sinais. O receptor infravermelho capturará os sinais do controle remoto, e o Arduino interpretará esses sinais para determinar qual botão foi pressionado. Este projeto é simples e pode ser adaptado para vários controles remotos.

Hardware Explicado

Os componentes principais para este projeto incluem a placa Arduino e um módulo receptor IR, tipicamente designado como VS1838B. O Arduino servirá como o controlador principal, executando o código que processa os sinais recebidos do controle remoto. O receptor IR captura os sinais infravermelhos emitidos pelo controle remoto e os converte em um formato que o Arduino pode entender.

O VS1838B opera em uma faixa de voltagem de 2,7V a 5,5V, tornando-o compatível com a maioria das placas Arduino. Ele pode detectar sinais a uma distância de 10 a 15 metros, dependendo das condições. O receptor infravermelho emite um sinal digital que indica qual botão no controle remoto foi pressionado, permitindo que o Arduino responda adequadamente.

Detalhes da Ficha Técnica

Fabricante	VS1838B
Número da peça	VS1838B
Tensão lógica/IO	2,7-5,5 V
Tensão de alimentação	5 V
Corrente de saída (por canal)	1,5 mA
Distância de recepção	10-15 m
Frequência de entrada	38 kHz
Corrente de repouso	0,8 mA (tip.)
Ângulo de operação	70 graus
Pacote	TO-220

Assegure o fornecimento adequado de voltagem para evitar danos ao receptor IR.
Mantenha o módulo receptor longe da luz solar direta ou de fontes fortes de infravermelho.
Use resistores pull-up se necessário para estabilizar as leituras de sinal.
As conexões de fiação devem ser seguras para evitar sinais intermitentes.
Teste diferentes controles remotos para ver como eles funcionam com a configuração.
Deconding-IR-remote-main-1

Instruções de Fiação

Para conectar o receptor IR ao Arduino, primeiro conecte o pino VCC do receptor IR ao pino 5V no Arduino. Em seguida, conecte o pino GND do receptor a um dos pinos GND no Arduino. Por fim, conecte o pino de sinal (geralmente marcado como SIG ou OUT) do receptor IR ao pino digital 11 no Arduino.

Certifique-se de que as conexões estão seguras, pois conexões soltas podem levar a leituras inconsistentes. Se você estiver usando uma versão PCB do receptor IR ou um módulo nu, a fiação permanece a mesma; apenas certifique-se de identificar corretamente os pinos de acordo com a rotulagem do módulo (no vídeo às 03:15).

Instale a biblioteca IRremote

Inicie o IDE do Arduino.Arduino.ccClique no ícone da biblioteca à esquerda e pesquise porIRremotee clique em "Instalar" para instalá-lo.

#include <IRremote.h>

Exemplos de Código e Guia passo a passo

int RECV_PIN = 11;
const char type ='W'; // W for white, B for black
const boolean PCB = 0; // 1 for PCB, 0 for bare module
IRrecv irrecv(RECV_PIN);

Neste trecho, definimos o número do pino para o receptor IR comRECV_PINdefinido para 11. Também especificamos o tipo de controle remoto que está sendo usado com otypevariável, onde 'W' indica um controle remoto branco e 'B' indica um controle remoto preto. OPCBa variável distingue entre usar uma versão de PCB do receptor ou um módulo nu.

void setup() {
  Serial.begin(9600);
  irrecv.enableIRIn(); // Start the receiver
}

No textosetup()função, inicializamos a comunicação serial a 9600 bauds e começamos o receptor IR. Isso é crucial para monitorar a saída no monitor serial, permitindo-nos ver qual tecla foi pressionada.

void loop() {
  if (irrecv.decode(&results)) {
    robojaxValidateCode(results.value); // Validate the received code
    irrecv.resume(); // Receive the next value
  }
  delay(100);
}

O principalloop()verifica se o receptor IR decodificou um sinal. Se o fez, chama orobojaxValidateCodefunção para processar o valor recebido e então retoma a escuta para o próximo sinal. Odelay(100)garante que o loop não execute muito rapidamente, o que pode ajudar no processamento de sinais.

Demonstração / O que Esperar

Depois que tudo estiver configurado e o código estiver carregado, abra o monitor serial para ver a saída. Quando você pressionar uma tecla no controle remoto, deverá ver o nome da tecla correspondente exibido no monitor. Se a tecla não for reconhecida, será exibido "Tecla desconhecida." Certifique-se de pressionar as teclas com firmeza, pois conexões soltas podem causar leituras incorretas (no vídeo em 05:40).

Se você pressionar uma tecla continuamente, a saída pode mostrar valores repetidos ou códigos hexadecimais. Esse comportamento é normal, e você pode modificar o código para filtrar esses sinais contínuos, se desejar. Além disso, você pode ajustar o código para realizar ações com base em pressionamentos específicos de teclas, como acender luzes ou controlar outros dispositivos.

Marcas de tempo do vídeo

00:00 Início
00:56 Hardware é Explicado
04:26 Explicação da Fiação
05:20 O código é explicado
12:27 Demonstração da decodificação de código

Imagens

Decodificando qualquer controle remoto preto ou controle remoto branco com Arduino

Pinos do receptor remoto IR VS1838B

Deconding-IR-remote-main

Deconding-IR-remote-main-1

Deconding-IR-remote-main-2

Por favor, visualize esta página em inglês se o código não estiver visível. Pedimos desculpas pelo transtorno.

137-Source code for decoding infrared remote controllers using Arduino

Idioma: C++

/*
 * Original code and library from - http://arcfn.com
 * 
 * This code decodes keys of Black IR remote and White IR remote
 * sold on eBay for Arduino. 
 * You have to select the type of your remote as Black or White in the code below
 * and also select your receiver 1838 either as PCB or bare module. See video for details
 * 
 * Modified/Written by Ahmad Shamshiri
 * on July 28, 2018 at 22:48 in Ajax, Ontario, Canada
 * for Robojax.com
 * Watch video instruction for this code:https://youtu.be/muAkBQb24NI
 * Get other Arduino codes from Robojax.com
 * 
 */

#include <IRremote.h>

int RECV_PIN = 11;

const char type ='W';// W for white, B for black. Must keep single quotes like 'B' or 'W'
const boolean PCB = 0;// if receiver is PCB set to 1, if not set to 0. See video for details

IRrecv irrecv(RECV_PIN);

// this is array holding codes for White Remote when used with PCB version of receiver
unsigned int whiteRemotePCB[] ={
            0xE318261B, // CH-
            0x511DBB,   // CH
            0xEE886D7F,  // CH+

            0x52A3D41F, // |<<
            0xD7E84B1B, // >>|
            0x20FE4DBB, // >||          

            0xF076C13B, // -
            0xA3C8EDDB, // +
            0x12CEA6E6, // EQ

            0xC101E57B, // 0
            0x97483BFB, // 100+
            0xF0C41643, // 200+

            0x9716BE3F, // 1
            0x3D9AE3F7, // 2
            0x6182021B, // 3           

            0x8C22657B, // 4 
            0x488F3CBB, // 5
            0x449E79F,  // 6

            0x32C6FDF7, // 7
            0x1BC0157B, // 8
            0x3EC3FC1B  // 9                          
            };

// this is array holding codes for White Remote when used with non-PCB version of receiver            
unsigned int whiteRemote[] ={
            0xFFA25D, // CH-
            0xFF629D,   // CH
            0xFFE21D,  // CH+

            0xFF22DD, // |<<
            0xFF02FD, // >>|
            0xFFC23D, // >||          

            0xFFE01F, // -
            0xFFA857, // +
            0xFF906F, // EQ

            0xFF6897, // 0
            0xFF9867, // 100+
            0xFFB04F, // 200+

            0xFF30CF, // 1
            0xFF18E7, // 2
            0xFF7A85, // 3           

            0xFF10EF, // 4 
            0xFF38C7, // 5
            0xFF5AA5,  // 6

            0xFF42BD, // 7
            0xFF4AB5, // 8
            0xFF52AD  // 9                          
            };
// key labels of white remote
String whiteRemoteKey[] ={
            "CH-",
            "CH",
            "CH+",

            "|<<",
            ">>|",
            ">||",

            "-",
            "+",
            "EQ",

            "0",
            "100+",
            "200+",

            "1",
            "2",
            "3",

            "4",
            "5",
            "6",

            "7",
            "8",
            "9"
            };

// this is array holding codes for Black Remote when used with non-PCB version of receiver
 unsigned int blackRemote[] ={
            0xFF629D, // ^
            0xFF22DD,   // <
            0xFF02FD,  // OK
            0xFFC23D, // >
            0xFFA857, // v

            0xFF6897, // 1
            0xFF9867, // 2
            0xF0C41643, // 3           

            0xFF30CF, // 4 
            0xFF18E7, // 5
            0xFF7A85,  // 6

            0xFF10EF, // 7
            0xFF38C7, // 8
            0xFF5AA5,  // 9 

            0xFF42BD, // *
            0xFF4AB5, // 0
            0xFF52AD  // #                                      
            };

// this is array holding codes for Black Remote when used with PCB version of receiver
 unsigned int blackRemotePCB[] ={
            0x511DBB, // ^
            0x52A3D41F,   // <
            0xD7E84B1B,  // OK
            0x20FE4DBB, // >
            0xA3C8EDDB, // v


            0xC101E57B, // 1
            0x97483BFB, // 2
            0xF0C41643, // 3           

            0x9716BE3F, // 4 
            0x3D9AE3F7, // 5
            0x6182021B,  // 6

            0x8C22657B, // 7
            0x488F3CBB, // 8
            0x449E79F,  // 9 

            0x32C6FDF7, // *
            0x1BC0157B, // 0
            0x3EC3FC1B  // #                                      
            };

// Black remote key names
String blackRemoteKey[] ={
            "^",
            "<",
            "OK",
            ">",
            "v",

            "1",
            "2",
            "3",

            "4",
            "5",
            "6",

            "7",
            "8",
            "9",
            
            "*",
            "0",
            "#"
            };

decode_results results;


void setup()
{
  Serial.begin(9600);
  // In case the interrupt driver crashes on setup, give a clue
  // to the user what's going on.
  Serial.println("Robojax Remote Decoder");
  irrecv.enableIRIn(); // Start the receiver

}

void loop() {

  if (irrecv.decode(&results)) {
     //Serial.println(results.value, HEX);
    robojaxValidateCode(results.value);// used the "robojaxValidateCode" below
    irrecv.resume(); // Receive the next value
  }
  delay(100);
}

/*
 * function: robojaxValidateCode
 * validates the remote code and prints correct key name
 * cd is code passed from the loop
 * Written by A. S. for Robojax
 */
void robojaxValidateCode(int cd)
{

  // Robojax IR Remote decoder
  int found=0;

 if(type =='W' && !PCB)
 {
    // Robojax IR White Remote decoder
    // if type is set to 'W' (white remote) and PCB=0 then check Black remote code
      for(int i=0; i< sizeof(whiteRemote)/sizeof(int); i++)
      {
        if(whiteRemote[i] ==cd)
        {
          
          Serial.print("Key pressed:");
          Serial.println(whiteRemoteKey[i]);
    
          found=1;
        }// if matched
      }// for
 }else if(type =='W' && PCB){
    // Robojax IR White Remote decoder
    // if type is set to 'W' (white remote) and PCB=1 then check Black remote code
      for(int i=0; i< sizeof(whiteRemotePCB)/sizeof(int); i++)
      {
        if(whiteRemotePCB[i] ==cd)
        {
          
          Serial.print("Key pressed:");
          Serial.println(whiteRemoteKey[i]);
    
          found=1;
        }// if matched
      }// for  
 }else if(type =='B' && PCB){
    // Robojax IR White Remote decoder
       // if type is set to 'B' (black remote) and PCB=1 then check Black remote code
       for(int i=0; i< sizeof(blackRemotePCB)/sizeof(int); i++)
      {
        // Robojax IR black Remote decoder
        if(blackRemotePCB[i] ==cd)
        {

          Serial.print("Key pressed:");
          Serial.println(blackRemoteKey[i]);
    
          found=1;
        }// if matched
      }// for   
 }else{

      // if type is set to 'B' (black remote) and PCB =0 then check Black remote code
       for(int i=0; i< sizeof(blackRemote)/sizeof(int); i++)
      {
        // Robojax IR black Remote decoder
        if(blackRemote[i] ==cd)
        {
          if(blackRemoteKey[i] == "OK"){
            digitalWrite(9,HIGH);
          }
          Serial.print("Key pressed:");
          Serial.println(blackRemoteKey[i]);
    
          found=1;
        }// if matched
      }// for  
 }// else
  if(!found){
    if(cd !=0xFFFFFFFF)
      {
    Serial.println("Key unknown");
      }
  }// found
}