Início / Projetos Arduino / Projetos Squids / Intermediário / I14 - Como usar qualquer controle remoto IR para acionar um menu - Arduino

---

I14 - Como usar qualquer controle remoto IR para acionar um menu - Arduino

Angelo Luis Ferreira | 27/09/2021 Acessos: 4.351

Objetivo

Neste tutorial vamos mostrar como utilizar qualquer Controle Remoto Infravermelho e um fotorreceptor IR para controlar uma carga qualquer (leds, motores, etc) com o Arduino. Nesse exemplo vamos utilizar algumas teclas de um controle remoto IR qualquer que você tenha em casa. Usaremos o controle remoto para controlar um menu exibido em um display LCD. Este menu então, irá fazer com que o led selecionado se apague ou acenda.

Referência:

I13 - Como usar o Controle Remoto Infravermelho com 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 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.

Receptor IR VS1838B Universal ou 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. Utilizaremos nesse projeto o Receptor IR Universal, mas se você desejar, poderá usar o módulo receptor IR.

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
Controle Remoto IR	Controle remoto IR usado em televisores, dvd, som, etc	1		Obs.: Pode ser utilizado qualquer controle remoto IR que você tenha em casa.
Receptor IR Universal	Receptor Universal Infravermelho VS1838B	1		Como opção, você poderá substituir o Receptor IR Universal por um Módulo Receptor IR (AX-1838Hs)
Led 5mm	Led 5mm	6		Utilizar led de qualquer cor
Resistor	Resistor	6		Resistor de 150Ω ou superior (uso com os leds)
Display LCD	Display LCD 16X2 com pinos soldados	1		LCD que utilize o controlador HD44780 (veja na descrição ou datasheet do componente) O display poderá ser de qualquer cor (fundo verde, azul ou vermelho)
Módulo I2C para display LCD	Módulo I2C com CI PCF8574	1		O módulo I2C poderá vir separado ou já soldado no display LCD (datasheet) Se você não possui um módulo I2C para display LCD, poderá adaptar o projeto para o display LCD sem o adaptador.
Arduino UNO	Arduino UNO	1		Você poderá utilizar uma placa Arduino UNO original ou similar

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.

2.1. Valores mínimos utilizados para nossos projetos (tensão igual ou inferior a 5V): LEDs difusos ou de alto brilho: Vermelho, Laranja e Amarelo: 150 Ω | Led Verde e Azul: 100 Ω

3. Monte o Receptor Infravermelho Universal ou o Módulo Receptor IR conectando o pinos de alimentação GND e VCC conforme a posição dos pinos do componente. Depois conecte o pino SIGNAL/OUT na porta digital 2 do Arduino.

Obs.: No nosso exemplo optamos pelo Receptor IR Universal, mas a utilização do Módulo Receptor IR não irá alterar o resultado do projeto. Ambos funcionam de forma similar. O módulo tem algumas vantagens como a adição de um led para indicar quando o receptor está recebendo o sinal (Veja o projeto I13 - Como usar o Controle Remoto Infravermelho com Arduino).

4. Neste projeto vamos utilizar um display LCD 16x2 com controlador HD44780, que se adapta aos mais diversos projetos com vários modelos de placas e microcontroladores. Este display possui 16 colunas por 2 linhas com backlight (luz de fundo) verde, azul ou vermelha e tem 16 pinos para a conexão.

5. Para a montagem do display com adaptador, entenda a estrutura do módulo I2C para display LCD 16x2 / 20X4:

5.1. Na lateral do adaptador encontramos 4 pinos, sendo: 2 pinos para alimentação (Vcc e GND) e 2 pinos para conexão com a interface I2C (SDA e SCL) que deverão estar conectados nos pinos analógicos A4 (SDA) e A5 (SCL) do Arduino Uno ou nos pinos A20 (SDA) e A21 (SCL) do Arduino Mega 2560. Veja a tabela abaixo com onde temos as principais placas Arduino e suas conexões com o I2C.

5.2. Para controlar o contraste do display, utilize o potenciômetro de ajuste de contraste. O jumper lateral, quando utilizado, permite que a luz do fundo (backlight) seja controlada pelo programa ou permaneça apagada.

5.3. A seleção de endereço do adaptador I2C para display LCD, na maioria dos módulos fornecidos no mercado já vêm configurados com o com o endereço 0x27. Se você não sabe qual endereço que o seu módulo I2C e/ou módulo RTC DS3231 está configurado, baixe o seguinte "sketch":

DOWNLOAD - I2C_scanner.ino

5.3.1 Após instalar e rodar o sketch acima, abra o monitor serial que mostrará qual é o endereço que o seu módulo I2C está configurado:

5.3.2 Nos casos em que módulo I2C estiver configurado com uma faixa de endereços diferente do endereço 0X27 altere a alinha de programação -> LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE); com o endereço correto.

5.4. Para saber mais sobre a montagem e utilização de display LCD com módulo I2C leia: Projeto 48 - Como controlar um display LCD com o módulo I2C.

6. No nosso exemplo testamos o controle remoto Pioneer (CXA7390), mas você utilizar qualquer controle remoto, desde que funcionando e com pilhas, é lógico.

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

Atenção: Caso você opte pela utilização do display de LCD sem o módulo I2C, siga os procedimentos do Projeto 38 - Controlando um display LCD (instalação e comandos básicos) e não instale a biblioteca abaixo.

Para que o módulo I2C funcione corretamente é necessário adicionarmos a biblioteca LiquidCrystal_I2C no IDE do Arduino. Uma das grandes vantagens das placas Arduino é a diversidade de bibliotecas disponíveis que podem ser utilizadas em seus programas. Estas bibliotecas podem ser criadas para a linguagem "C" ou especificamente para o Arduino, reduzindo drasticamente o tempo gasto com programação. Veja a tabela Coletânea de bibliotecas para módulos.

Download dos arquivos da biblioteca LiquidCrystal_I2C

 DOWNLOAD - NewliquidCrystal_1.3.4.zip

Para saber detalhes desta biblioteca clique aqui.

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

Para instalação e utilização da biblioteca para o módulo I2C como comunicação para um display LCD siga o tutorial: Projeto 48 - Como controlar um display LCD com o módulo I2C

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 do arquivo da biblioteca 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. No nosso projeto vamos utilizar apenas 7 teclas do controle remoto. Na imagem abaixo, identificamos quais as teclas que iremos usar para controlar o nossos leds e o nosso menu no display LCD.

Obs.: Você poderá utilizar quaisquer teclas do seu controle remoto, desde que as identifique com um nome para cada tecla.

3. Abra o Monitor Serial e digite as teclas definidas, uma de cada vez. O controle remoto deverá estar apontando para o receptor. .

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.

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

5. Agora que já temos a identificação de todas as teclas do controle, podemos criar a nossa estrutura com os códigos hexadecimais clonados. No nosso exemplo vamos usar a estrutura abaixo diretamente no código do projeto:

Obs.: Se desejar, crie um header file com os códigos hexadecimais clonados, como mostramos no projeto I13 - Como usar o Controle Remoto Infravermelho com Arduino. Desta forma, o código do projeto ficará mais organizado.

// definição do teclado do controle remoto Pioneer (CXA7390)
//CADA TECLA DO CONTROLE REMOTO POSSUI UM CÓDIGO HEXADECIMAL CORRESPONDENTE
//Tecla             Nome                Hexadecimal
//seta esquerda     tk1                    B54A42BD
//seta direita      tk2                    B54AC23D
//seta para cima    tk3                    B54A02FD
//seta para baixo   tk4                    B54A827D
//OK                tk5                    B54A7887
//menos             tk6                    B54AD02F
//mais              tk7                    B54A50AF
/*******************************************************************************/
#define tk1 0xB54A42BD
#define tk2 0xB54AC23D
#define tk3 0xB54A02FD
#define tk4 0xB54A827D
#define tk5 0xB54A7887
#define tk6 0xB54AD02F
#define tk7 0xB54A50AF

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

Código do Projeto (Sketch)

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

Obs. 1: Nos casos em que módulo I2C estiver configurado com um endereço diferente do endereço 0X27, altere a alinha de programação -> LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE); com o endereço correto. - Veja o tutorial Projeto 48 - Como controlar um display LCD com o módulo I2C .

Obs. 2: Se estiver utilizando um display de LCD 20 X 4, altere o comando da linha 71 para lcd.begin (20,4);

Obs. 3: Se não possuir o módulo I2C utilize apenas o display LCD conforme Projeto 38 - Controlando um display LCD (instalação e comandos básicos).

2. Atenção: Não esqueça de alterar os códigos hexadecimais correspondentes ao controle remoto que você está utilizando (linhas 27 a 44 do sketch).

3. Se preferir, copie e cole o código abaixo no IDE do Arduino.

/*******************************************************************************
*
*    I14 - Usando qualquer controle IR para acionar um menu
*    Autor: Angelo Luis Ferreira
*    24/09/2021
*    http://squids.com.br/arduino
*
*******************************************************************************/
#include                          // inclui a biblioteca IRremote
#include                 // inclui a biblioteca LCD com I2C

const byte receptorPin = 2;                   // define a conexão do receptor IR no pino 2 do Arduino
const byte led[] = {7,8,9,10,11,12};           // define as conexões dos leds nos pinos de 7 a 12 do Arduino

int nav;                                      // cria a variável nav que indica o item do menu (de 1 a 6)
byte display_position[] = {3,7,11,3,7,11};    // cria a variável display_position que indica as posições do cursor do display

byte position_c = 0;                          // cria variável posição display (horizontal - colunas)
byte position_l = 0;                          // cria variável posição display (vertical - linhas)

IRrecv receptor(receptorPin);                 // cria o objeto receptor
decode_results resultado;                     // declara a variável resultado

// Inicializa o display no endereco 0x27
LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE);

// definição do teclado do controle remoto Pioneer (CXA7390)
//CADA TECLA DO CONTROLE REMOTO POSSUI UM CÓDIGO HEXADECIMAL CORRESPONDENTE
//Tecla             Nome                Hexadecimal
//seta esquerda     tk1                    B54A42BD
//seta direita      tk2                    B54AC23D
//seta para cima    tk3                    B54A02FD
//seta para baixo   tk4                    B54A827D
//OK                tk5                    B54A7887
//menos             tk6                    B54AD02F
//mais              tk7                    B54A50AF
/*******************************************************************************/
#define tk1 0xB54A42BD
#define tk2 0xB54AC23D
#define tk3 0xB54A02FD
#define tk4 0xB54A827D
#define tk5 0xB54A7887
#define tk6 0xB54AD02F
#define tk7 0xB54A50AF

// definição dos itens customizados do menu (invertidos)
byte Bloco_Cheio[8] = {0b11111, 0b11111, 0b11111, 0b11111,
                        0b11111, 0b11111, 0b11111, 0b11111
                      };                       
byte Um_invertido[8] = {0b11011, 0b10011, 0b11011, 0b11011,
                        0b11011, 0b11011, 0b10001, 0b11111
                       };
byte Dois_invertido[8] = {0b10001, 0b01110, 0b11110, 0b11101,
                          0b11011, 0b10111, 0b00000, 0b11111
                         };
byte Tres_invertido[8] =  {0b00000, 0b11101, 0b11011, 0b11101,
                           0b11110, 0b01110, 0b10001, 0b11111
                          };
byte Quatro_invertido[8] = {0b11101, 0b11001, 0b10101, 0b01101,
                            0b00000, 0b11101, 0b11101, 0b11111
                           };
byte Cinco_invertido[8] = {0b00000, 0b01111, 0b00001, 0b11110,
                           0b11110, 0b01110, 0b10001, 0b11111
                          };
byte Seis_invertido[8] = {0b11001, 0b10111, 0b01111, 0b00001,
                          0b01110, 0b01110, 0b10001, 0b11111
                         };                       
                         
void setup() {
  Serial.begin(9600);                        // inicializa a comunicação serial
  lcd.begin (16,2);                          // inicializa o display LCD 16X2.
  receptor.enableIRIn();                     // inicializa a recpção sinais do controle remoto

// define pinMode leds - saída do Arduino (OUTPUT)
  for (byte i=0; i < 6; i++) {
    pinMode(led[i], OUTPUT);
  }
   
//Cria os caracteres customizados
  lcd.createChar(0, Bloco_Cheio);
  lcd.createChar(1, Um_invertido);
  lcd.createChar(2, Dois_invertido);
  lcd.createChar(3, Tres_invertido);
  lcd.createChar(4, Quatro_invertido);
  lcd.createChar(5, Cinco_invertido);
  lcd.createChar(6, Seis_invertido);
  
// Posição inicial do menu
  lcd.setCursor(0, 0);
  lcd.print("    1   2   3   ");   
  lcd.setCursor(0, 1);
  lcd.print("    4   5   6   ");
  //lcd.write((uint8_t)2);
}

void loop() {
  if (receptor.decode(&resultado))   {      // se exite algum código recebido            
    switch (resultado.value) {
      case (tk1):
        apaga_cursor();
        nav--;
        nav < 1 ? nav = 6 : nav;
        menu();
        break;
      case (tk2):
        apaga_cursor();
        nav++;
        nav > 6 ? nav = 1 : nav;
        menu();
        break;
      case (tk3):
        apaga_cursor();
        nav == 0 ? nav = 1: nav;
        nav > 3 ? nav = nav - 3 : nav;
        menu();
        break;
      case (tk4):
        apaga_cursor();
        nav == 0 ? nav = 4 : nav;      
        nav < 4 ? nav = nav + 3 : nav;
        menu();
        break;
      case (tk5):
        turnOnOffLed();
        break;
      case (tk6):
         apaga_cursor();
         turnOffAllLeds();
         break;
      case (tk7):
          apaga_cursor();
          turnOnAllLeds();
          break;     
    }
    indicador_led();                        // indica no menu quais leds estão acessos (blocos invertidos)
    controle_monitor();                     // abre monitor serial para verificação teclas / leds           
    delay(300);                             // espera 300ms
    receptor.resume();                      // reinicializa o receptor e aguarda novo sinal
  }                             
}

// apaga cursor anterior
void apaga_cursor() {
  // coloca cursor no item do menu
  lcd.setCursor(position_c, position_l);
  lcd.print(" ");
  lcd.setCursor(position_c+2, position_l);
  lcd.print(" ");
}

// navegação do menu no display lcd
void menu() {
  position_c = display_position[nav-1];          // define a coluna do cursor 
  nav > 3 ? position_l = 1 : position_l = 0;    // define a linha do cursor

  // coloca cursor no item do menu
  lcd.setCursor(position_c, position_l);
  lcd.write((uint8_t)0);
  lcd.setCursor(position_c+2, position_l);
  lcd.write((uint8_t)0);
}

// liga ou desliga led selecionado
void turnOnOffLed() {
  if (nav>0) digitalWrite(led[nav-1], !digitalRead(led[nav-1]));
}

// mostra indicador do led ligado no menu
void indicador_led() {
  for (byte j=0; j<6; j++) {
    byte indicador_c, indicador_l;
    if (digitalRead(led[j])) {      
      indicador_c = display_position[j]+1;           // define a coluna do indicador led
      j > 2 ? indicador_l = 1 : indicador_l = 0;     // define a linha do indicador led
      lcd.setCursor(indicador_c, indicador_l);
      lcd.write((uint8_t)j+1);
    } else {
       indicador_c = display_position[j]+1;             // define a coluna do indicador led
       j > 2 ? indicador_l = 1 : indicador_l = 0;       // define a linha do indicador led
       lcd.setCursor(indicador_c, indicador_l);
       lcd.print(j+1);
    }
  }
}

// desliga todos os leds
void turnOffAllLeds() {
  for (byte i=0;i<6;i++) {
    digitalWrite(led[i], LOW);
  }
  nav =0;
}

// liga todos os leds
void turnOnAllLeds() {
  for (byte i=0;i<6;i++) {
    digitalWrite(led[i], HIGH);
  }
  nav = 0;
}

void controle_monitor() {
  Serial.print(resultado.value, HEX);   // exibe o código hexadecimal da tecla
  Serial.print(" - ");
  Serial.print(nav);
  Serial.print(" - ");
  Serial.println(digitalRead(led[nav-1]));
}

Vídeo

Como o projeto deve funcionar

1. Ao iniciar o programa, o menu aparecerá no display de lcd.

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

Desafios

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

Comentários