Controle Remoto Infravermelho Parte 4

Neste post vamos começar a brincar de usar um controle remoto IR para comandar um Arduino.

Vamos começar com algo bastante simples: acender um LED conforme a tecla pressionada no controle remoto. Para facilitar as coisas, vou usar a biblioteca que vimos no post anterior.

O primeiro passo é levantar quais os comandos gerados pelas teclas. Para isto basta conectar um módulo receptor IR no pino 11 de um Arduino e rodar o sketch IRrecvDemo. Para o controle remoto do meu tocador MP3 eu obtive os seguintes comandos:

O código é bastante simples:

view plaincopy to clipboardprint?

1. /* 
2.  * Exemplo de comando do Arduino via IR 
3.  */  
4.   
5. #include <IRremote.h>  
6.   
7. // variaveis para recepção dos comandos IR  
8. const int RECV_PIN = 11;  
9. IRrecv irrecv(RECV_PIN);  
10.   
11. // comandos  
12. typedef unsigned long dword;  
13. const dword addr = 0;  
14. const dword cmdPlay = 0x22;  
15. const dword cmdNext = 0xC2;  
16. const dword cmdPrev = 0x02;  
17. #define CMD_IR(cmd) ((addr << 24) | \  
18.                      ((~addr & 0xFF) << 16) | \  
19.                      (cmd << 8) | \  
20.                      (~cmd & 0xFF) )  
21.   
22. // pinos dos LEDs  
23. const int LED_R = 4;  
24. const int LED_Y = 3;  
25. const int LED_G = 2;  
26.   
27. void setup()  
28. {  
29.   // Configura conexões dos LEDS  
30.   pinMode (LED_G, OUTPUT);  
31.   pinMode (LED_Y, OUTPUT);  
32.   pinMode (LED_R, OUTPUT);  
33.   
34.   // Inicia recepção IR  
35.   irrecv.enableIRIn();  
36. }  
37.   
38. void loop() {  
39.   decode_results results;  
40.     
41.   if (irrecv.decode(&results) && results.decode_type==NEC) {  
42.     // recebeu um comando NEC  
43.     switch (results.value) {  
44.       case CMD_IR(cmdPlay):  
45.         digitalWrite(LED_G, HIGH);  
46.         digitalWrite(LED_Y, LOW);  
47.         digitalWrite(LED_R, LOW);  
48.         break;          
49.       case CMD_IR(cmdPrev):  
50.         digitalWrite(LED_G, LOW);  
51.         digitalWrite(LED_Y, HIGH);  
52.         digitalWrite(LED_R, LOW);  
53.         break;          
54.       case CMD_IR(cmdNext):  
55.         digitalWrite(LED_G, LOW);  
56.         digitalWrite(LED_Y, LOW);  
57.         digitalWrite(LED_R, HIGH);  
58.         break;          
59.     }  
60.     // decodificar o próximo comando  
61.     irrecv.resume();  
62.   }  
63. }  

/*
 * Exemplo de comando do Arduino via IR
 */

#include <IRremote.h>

// variaveis para recepção dos comandos IR
const int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);

// comandos
typedef unsigned long dword;
const dword addr = 0;
const dword cmdPlay = 0x22;
const dword cmdNext = 0xC2;
const dword cmdPrev = 0x02;
#define CMD_IR(cmd) ((addr << 24) | \
                     ((~addr & 0xFF) << 16) | \
                     (cmd << 8) | \
                     (~cmd & 0xFF) )

// pinos dos LEDs
const int LED_R = 4;
const int LED_Y = 3;
const int LED_G = 2;

void setup()
{
  // Configura conexões dos LEDS
  pinMode (LED_G, OUTPUT);
  pinMode (LED_Y, OUTPUT);
  pinMode (LED_R, OUTPUT);

  // Inicia recepção IR
  irrecv.enableIRIn();
}

void loop() {
  decode_results results;
  
  if (irrecv.decode(&results) && results.decode_type==NEC) {
    // recebeu um comando NEC
    switch (results.value) {
      case CMD_IR(cmdPlay):
        digitalWrite(LED_G, HIGH);
        digitalWrite(LED_Y, LOW);
        digitalWrite(LED_R, LOW);
        break;        
      case CMD_IR(cmdPrev):
        digitalWrite(LED_G, LOW);
        digitalWrite(LED_Y, HIGH);
        digitalWrite(LED_R, LOW);
        break;        
      case CMD_IR(cmdNext):
        digitalWrite(LED_G, LOW);
        digitalWrite(LED_Y, LOW);
        digitalWrite(LED_R, HIGH);
        break;        
    }
    // decodificar o próximo comando
    irrecv.resume();
  }
}

O único detalhe significativo é a macro CMD_IR, que monta o valor correspondente a cada comando, acrescentando o endereço e os complementos do endereço e comando, como vimos na parte 2.

O vídeo abaixo mostra o funcionamento:

No próximo post vamos fazer algo um pouco mais emocionante que acender LEDs.