Início / Projetos Arduino / Projetos Squids / Intermediário / I13 - Como usar o Controle Remoto Infravermelho com Arduino

---

I13 - Como usar o Controle Remoto Infravermelho com Arduino

Angelo Luis Ferreira | 29/07/2021 Acessos: 7.590

Objetivo

Utilizar o Controle Remoto Infravermelho junto com o Arduino e um fotorreceptor IR para controlar 6 leds de acordo com cada tecla pressionada. Para isso, primeiro vamos identificar os códigos hexadecimais correspondentes para cada tecla do nosso controle remoto e depois definir uma função específica para cada código.

Nesse projeto vamos utilizar o kit controle remoto IR formado pelo dispositivo de controle remoto com teclado e bateria, o módulo receptor infravermelho, um led infravermelho (não utilizado) e jumpers. Obs.: Antes de usar o seu controle remoto, retire a proteção de plástico transparente que fica inserida dentro do suporte da bateria. Após usar, coloque novamente a proteção.

Referência:

I03 - Utilizando leds infravermelhos como sistema de alarme - Arduino

Definições

Controle Remoto Infravermelho é um dispositivo utilizado para controlar de forma remota algum componente eletrônico ou aparelho compatível. O controle remoto IR é formado por um dispositivo com teclado e um receptor infravermelho. Quando um dos botões do teclado é pressionado, ocorre a emissão de pulsos luminosos por um led infravermelho. Essa sequência de pulsos luminosos corresponderá a um único número hexadecimal para cada tecla do controle, gerando um código específico. Assim, os equipamentos ou componentes a serem controlados deverão possuir um receptor infravermelho para traduzir essas sequências, identificar qual tecla do controle foi pressionada e gerar uma ação pré-programada correspondente, como ligar ou desligar uma televisão, por exemplo.

Modulação de sinal é uma técnica utilizada para evitar que outras fontes de radiação infravermelha, como a luz natural ou a iluminação por lâmpadas, possam interferir no sinal transmitido entre o controle remoto e o receptor. Para isso existe um modulador dentro do controle remoto que transforma o código hexadecimal correspondente de cada botão em um sinal modulado único dentro da frequência de 38Khz quando pressionado. Esse sinal então é enviado pelo led IR emissor que fica acoplado na extremidade do controle.

Depois, o módulo receptor que recebe esse sinal modulado irá transformá-lo o novamente em um sinal digital, recuperando a informação original e identificando qual tecla foi pressionada. No nosso projeto a identificação será feita pelo Arduino:

Led Emissor Infravermelho (IR): Led que emite um sinal IR (infrared ou infravermelho) que pode ser reconhecido por um componente receptor IR. Projetado para emitir sinais infravermelhos em dispositivos remotos e se conectarem em uma placa microcontroladora. A faixa de luz emitida pelo led emissor, cujo comprimento de onda é de aproximadamente 940nm, não é perceptível ao olho humano. O led emissor IR utilizado no nosso projeto já vem acoplado no controle remoto.

Módulo Receptor IR (AX-1838Hs) - Componente eletrônico formado por um fotototransistor e circuito integrado necessário para demodular os pulsos enviados pelo led emissor, transformando-os em um sinal binário. O módulo que utilizaremos também possui um led indicador para avisar quando um sinal está sendo transmitido e recebido corretamente.

Aplicação

Para fins didáticos e projetos onde é necessário acionamento remoto de algum tipo de carga ou envio de informação a partir de teclas pressionadas, como: Controle remoto de lâmpadas (liga/desliga ou até controle de brilho), Acionamento remoto de aparelhos, Controle remoto de alarmes, Controle remoto de câmera fotográfica, Controle remoto de dispositivos móveis, etc.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Protoboard	Protoboard 830 pontos	1		No mínimo utilizar protoboard com 400 pontos
Jumpers	Kit cabos ligação macho / macho	1
Kit Controle Remoto	Controle remoto e módulo receptor IR	1		- Frequência de Transmissão 38KHz - Bateria (Controle Remoto) 160mAh - Ângulo Efetivo 60º - Alcance Transmissão 8m - Corrente de Operação 3 á 5mA Obs.: Pode ser utilizado qualquer kit controle remoto para Arduino
Led 5mm	Led 5mm	6		Utilizar led de qualquer cor
Resistor	Resistor	6		Resistor de 150Ω ou superior
Arduino UNO	Arduino UNO R3	1		Você poderá utilizar uma placa Arduino UNO original ou similar

Observação: Você poderá adquirir os componentes acima na loja: Baú da Eletrônica.

Montagem do Circuito

Conecte os componentes no Protoboard como mostra a figura abaixo. Verifique cuidadosamente os cabos de ligação antes de ligar seu Arduino. O Arduino deve estar totalmente desconectado da fonte de energia enquanto você monta o circuito.

Atenção

1. Lembre-se que o LED tem polaridade: O terminal maior tem polaridade positiva e o lado do chanfro tem polaridade negativa.

2. Determinamos o valor do resistor através da tabela prática: Tabela prática de utilização de leds 3mm e 5mm. Entretanto, o mais correto é sempre verificar o datasheet do fabricante do LED para você ter os exatos valores de tensão e corrente do mesmo - leia Leds ligados em série e em paralelo.

3. Monte o módulo receptor IR conectando o pinos de alimentação GND e VCC. Depois conecte o pino OUT na porta digital 2 do Arduino.

4. A montagem do nosso projeto foi realizada em um protoboard de 830 pontos com linhas de alimentação separadas. Verifique se o seu protoboard possui linhas de alimentação contínuas ou separadas.

Incluindo a biblioteca IRremote no IDE do Arduino

a) Para utilizar o controle remoto IR corretamente vamos incluir a biblioteca IRremote. Esta biblioteca, por aceitar vários tipos de protocolos, permitirá a interação do receptor IR com o Arduino UNO de forma adequada.

Download dos arquivos da biblioteca IRremote.h

 DOWNLOAD - IRremote.zip

Para saber detalhes desta biblioteca clique aqui.

Após fazer o download dos arquivos das bibliotecas com todos os arquivos compactados no formato zip, abra o IDE do Arduino e siga o tutorial: Como incluir uma biblioteca no IDE do Arduino.

Para conhecer outras bibliotecas veja a Tabela Biblioteca para Módulos e Tabela Bibliotecas para Sensores.

Mapeamento das teclas do Controle Remoto IR

Antes de iniciarmos o nosso projeto, vamos precisar primeiro identificar os códigos hexadecimais das teclas do controle remoto que vamos usar. Para isso, utilizaremos o programa abaixo para clonar o código de cada tecla do controle quando pressionada:

1. Copie e cole o código abaixo no IDE do Arduino e execute o programa.

/*******************************************************************************
*
*    Controle Remoto IR - Identificador teclas
*    29/07/2021
*    http://squids.com.br/arduino
*
*******************************************************************************/
#include                          // inclui a biblioteca IRremote

const byte receptorPin = 2;                   // define a conexão do receptor IR no pino 2 do Arduino
IRrecv receptor(receptorPin);                 // cria o objeto receptor
decode_results resultado;                     // declara a variável resultado
 
void setup() {
  Serial.begin(9600);                        // inicializa a comunicação serial
  receptor.enableIRIn();                     // inicializa a recpção sinais do controle remoto
}

void loop() {
  if (receptor.decode(&resultado))   {      // se exite algum código recebido
    Serial.println(resultado.value, HEX);   // exibe o código hexadecimal da tecla 
    receptor.resume();                      // reinicializa o receptor e aguarda novo sinal
  }
  delay(500);                               // espera 500ms
}

2. Abra o Monitor Serial e digite todas as teclas do controle, uma de cada vez. O controle remoto deverá estar apontando para o receptor. Não esqueça de retirar o protetor plástico transparente que fica inserido dentro do suporte da bateria. 

Obs: O códigos FFFFFFFF correspondem aos "Repeat Codes" e devem ser desprezados. Os "Repeat Codes" aparecem quando você fica segurando a tecla pressionada por um tempo maior que o delay utilizado no programa.

3. Monte uma tabela relacionando os códigos hexadecimais clonados com as respectivas teclas do controle remoto que você pressionou:

Obs.: A coluna nome é a referência que utilizaremos para definir os nomes das constantes que indicarão as teclas no nosso programa. Você poderá nomeá-los da forma que desejar.

4. Agora que já temos a identificação de todas as teclas do controle, podemos criar a nossa própria biblioteca (header file) com os códigos hexadecimais clonados.

4.1. Utilizando qualquer editor, como o Bloco de Notas do Windows por exemplo, copie o código abaixo e salve como control.h, ou se desejar faça o download do arquivo aqui.

4.1.1. Atenção: Não esqueça de alterar os códigos hexadecimais de acordo como os valores clonados do seu controle remoto.

/*******************************************************************************
*
*          Biblioteca "control.h" - Mapeamento teclado Controle Remoto
*                   http://squids.com.br/arduino
*
*******************************************************************************/
#define tk1 0xFD00FF
#define tk2 0xFD807F
#define tk3 0xFD40BF 
#define tk4 0xFD20DF
#define tk5 0xFDA05F
#define tk6 0xFD609F
#define tk7 0xFD10EF
#define tk8 0xFD906F
#define tk9 0xFD50AF
#define tk_ast 0xFD30CF
#define tk0 0xFDB04F
#define tk_hash 0xFD708F
#define tk_up 0xFD8877
#define tk_left 0xFD28D7
#define tk_ok 0xFDA857
#define tk_right 0xFD6897
#define tk_down 0xFD9867

4.2. Observe no código acima que declaramos os valores hexadecimais utilizando o prefixo "0x". O uso de prefixos (modificadores) são necessários para declararmos números inteiros com bases: binário, octal ou hexadecimal. Leia mais em constantes inteiras (referência Arduino).

5. Faça o teste para verificar se as teclas do controle remoto estão sendo reconhecidas corretamente.

5.1. Copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************
*
*    Controle Remoto IR - Verificador de teclas
*    Autor: Angelo Luis Ferreira
*    29/07/2021
*    http://squids.com.br/arduino
*
*******************************************************************************/
#include 
#include "control.h"
 
IRrecv receptor(2);
 
decode_results resultado;
 
void setup() {
  Serial.begin(9600);
  receptor.enableIRIn(); 
}

void loop() {
  if (receptor.decode(&resultado))   {
    switch (resultado.value) {
      case (tk1): 
        Serial.println("Tecla 1");
        break;
      case (tk2): 
        Serial.println("Tecla 2");
        break; 
      case (tk3): 
        Serial.println("Tecla 3");
        break;
      case (tk4): 
        Serial.println("Tecla 4");
        break;
      case (tk5): 
        Serial.println("Tecla 5");
        break;
      case (tk6): 
        Serial.println("Tecla 6");
        break; 
      case (tk7): 
        Serial.println("Tecla 7");
        break;
      case (tk8): 
        Serial.println("Tecla 8");
        break;
      case (tk9): 
        Serial.println("Tecla 9");
        break;
      case (tk0): 
        Serial.println("Tecla 0");
        break; 
      case (tk_ast): 
        Serial.println("Tecla *");
        break;
      case (tk_hash): 
        Serial.println("Tecla #");
        break;
      case (tk_up): 
        Serial.println("Tecla seta para cima");
        break;
      case (tk_left): 
        Serial.println("Tecla seta esquerda");
        break; 
      case (tk_right): 
        Serial.println("Tecla seta direita");
        break;
      case (tk_ok): 
        Serial.println("Tecla OK");
        break;
      case (tk_down): 
        Serial.println("Tecla para baixo");
        break;                 
    } 
    receptor.resume(); 
  }
  delay(500);
}

 5.2. Coloque o arquivo control.h na mesma pasta do código Arduino acima. Observe que denominamos o nosso código Arduino de "verificadorTecalsIR", mas você poderá optar por qualquer outro nome.

 5.3. Observe que no IDE do Arduino deverá aparecer uma aba com o header file control.h, como mostra a figura abaixo. Para visualizar ou alterar o código control.h no IDE basta clicar sobre a aba.

5.4. Rode o programa e abra o Monitor Serial. Digite as teclas do controle remoto e verifique se elas correspondem com o que aparece no Monitor Serial. Caso haja alguma inconsistência, corrija o arquivo control.h.

Código do Projeto (Sketch)

1. Faça o download e abra o arquivo projetoI13.ino no IDE do Arduino: DOWNLOAD - projetoI13.ino

2. Coloque o arquivo control.h na mesma pasta do projeto.

3. Se preferir, copie e cole o código abaixo no IDE do Arduino. Depois, coloque o arquivo control.h na mesma pasta do arquivo do projeto.

/*******************************************************************************
*
*    I13 - Usando o controle remoto IR com leds
*    Autor: Angelo Luis Ferreira
*    29/07/2021
*    http://squids.com.br/arduino
*
*******************************************************************************/
// inclui bibliotecas
#include 
#include "control.h"
 
// controle remoto - cria objeto e variável resultado 
IRrecv receptor(2); // pino 2 do Arduino
decode_results resultado; //declaração variável resultado

// conexões leds pinos Arduino
const byte led[] = {8,9,10,11,12,13}; 

// variáveis leds (1 - ligado ou 0 - desligado);
boolean onOff[] = {0,0,0,0,0,0};

// variável espera (delay)
int espera = 800; // 800 milissegundos
 
void setup() {
  // inicialização
  Serial.begin(9600);
  receptor.enableIRIn();

  // define pinMode leds (saída do Arduino)
  for (byte i=0;i<6;i++) {
    pinMode(led[i], OUTPUT); 
  }

  // acende todos leds
  allLedsOn();
  delay(espera);
  // apaga todos leds
  allLedsOff();
}

void loop() {
  // menu controle remoto
  if (receptor.decode(&resultado))   {
    switch (resultado.value) {
      case (tk1): 
        Serial.println("Tecla 1");
         ledOnOff(0);      
        break;
      case (tk2): 
        Serial.println("Tecla 2");
        ledOnOff(1);
        break; 
      case (tk3): 
        Serial.println("Tecla 3");
        ledOnOff(2);
        break;
      case (tk4): 
        Serial.println("Tecla 4");
        ledOnOff(3);
        break;
      case (tk5): 
        Serial.println("Tecla 5");
        ledOnOff(4);
        break;
      case (tk6): 
        Serial.println("Tecla 6");
        ledOnOff(5);
        break; 
      case (tk7): 
        Serial.println("Tecla 7");
        doubleLedsOnOff(0,1);
        break;
      case (tk8): 
        Serial.println("Tecla 8");
        doubleLedsOnOff(2,3);
        break;
      case (tk9): 
        Serial.println("Tecla 9");
        doubleLedsOnOff(4,5);
        break;
      case (tk0): 
        Serial.println("Tecla 0");
        allLedsOff();
        break; 
      case (tk_ast): 
        Serial.println("Tecla *");
        threeLedsOnOff(0,1,2);
        break;
      case (tk_hash): 
        Serial.println("Tecla #");
        threeLedsOnOff(3,4,5);
        break;
      case (tk_up): 
        Serial.println("Tecla seta para cima");
         threeBlinkLeds(0,1,2);
        break;
      case (tk_left): 
        Serial.println("Tecla seta esquerda");
        rightLeftLeds(5);
        break; 
      case (tk_right): 
        Serial.println("Tecla seta direita");
        rightLeftLeds(0);
        break;
      case (tk_ok): 
        Serial.println("Tecla OK");
        allLedsOn();
        break;
      case (tk_down): 
        Serial.println("Tecla para baixo");
        threeBlinkLeds(3,4,5);
        break;                 
    } 
    receptor.resume(); 
  }
  delay(100);
}

// função para acender/apagar led único
void ledOnOff(byte index) {
  onOff[index] = !onOff[index];
  digitalWrite(led[index], onOff[index]); 
}

// função para acender/apagar 2 leds únicos
void doubleLedsOnOff(byte index1, byte index2) {
  if (!digitalRead(led[index1]) || !digitalRead(led[index2])) {
    onOff[index1] = 1;
    onOff[index2] = 1;
  } else {
    onOff[index1] = 0;
    onOff[index2] = 0;
  }
  digitalWrite(led[index1], onOff[index1]);
  digitalWrite(led[index2], onOff[index2]); 
}

// função para acender/apagar 3 leds únicos
void threeLedsOnOff(byte index1, byte index2, byte index3) {
  if (!digitalRead(led[index1]) || !digitalRead(led[index2]) || !digitalRead(led[index2])) {
    onOff[index1] = 1;
    onOff[index2] = 1;
    onOff[index3] = 1;
  } else {
    onOff[index1] = 0;
    onOff[index2] = 0;
    onOff[index3] = 0;
  }
  digitalWrite(led[index1], onOff[index1]);
  digitalWrite(led[index2], onOff[index2]);
  digitalWrite(led[index3], onOff[index3]);
}

// função acender todos leds
void allLedsOn() {
  for (byte i=0; i<6; i++) {
    onOff[i] = 1;
    digitalWrite(led[i], HIGH);
  }
}

// função apagar todos leds
void allLedsOff() {
  for (byte i=0; i<6; i++) {
    onOff[i] = 0;
    digitalWrite(led[i], LOW);
  }
}

// função sequência right ou left
void rightLeftLeds(const byte j) {
  allLedsOff();
  delay(espera);
  for (byte i=0;i<=6;i++) {
    onOff[abs(j-i)] = 1;   
    digitalWrite(led[abs(j-i)], HIGH);
    delay(espera);
  }
}

// função piscar 3 leds
void threeBlinkLeds(byte index1, byte index2, byte index3) {
  allLedsOff();
  for(byte i=0;i<3;i++) {
    digitalWrite(led[index1], HIGH);
    digitalWrite(led[index2], HIGH);
    digitalWrite(led[index3], HIGH);
    delay(espera);
    digitalWrite(led[index1], LOW);
    digitalWrite(led[index2], LOW);
    digitalWrite(led[index3], LOW);
    delay(espera); 
  }
    digitalWrite(led[index1], HIGH);
    digitalWrite(led[index2], HIGH);
    digitalWrite(led[index3], HIGH);
    onOff[index1] = 1;
    onOff[index2] = 1;
    onOff[index3] = 1;
}

Vídeo

Como o projeto deve funcionar

1. Ao iniciar o programa, aguarde os leds acenderem e apagarem todos de uma vez.

2. Acione os botões do controle remoto IR para gerar as respectivas ações. Veja abaixo quais as funções definidas para cada tecla que propomos neste tutorial.

Obs.: Não esqueça de retirar a película protetora que fica inserida no compartimento da bateria.

Desafios

Com base neste projeto, resolva o seguinte desafio: Desafio 89

Comentários