Atualmente, diversos dispositivos estão sendo desenvolvidos a fim de oferecer bem-estar às pessoas, através de pequenos sistemas de automação. Entre eles, desenvolveremos nesse artigo, o controle remoto de ventilador com Arduino, que permite ao usuário controlar o ventilador em sua cama.
Algumas empresas já oferecem ventiladores com essa funcionalidade.
Baseado nisto, esse artigo tem o objetivo de criar um controle remoto com Arduino para um ventilador, a fim de permitir controlá-lo por meio de comandos enviados pelo Arduino. Os dados de controle serão copiados do controle original.
Portanto, por meio deste artigo, você aprenderá:
1 – Reconhecer o padrão de código do controle IR;
2 – Realizar a leitura do código RAW;
3 – Enviar o código RAW de cada tecla e controlar as funcionalidades do ventilador;
4 – Desenvolver o controle remoto do ventilador com Arduino.
A seguir, apresentaremos o ventilador e seu controle remoto.
Ventilador comandado por Controle Remoto
Diversas empresas de eletrodomésticos estão trazendo inovações diariamente, com o objetivo de diferenciar seus produtos e impactar no bem-estar dos seus usuários.
Entre os diversos equipamentos, apresentamos este ventilador, que é apresentado na Figura 1. Ele possui funções de controle manual e, também, pode ser controlado através de um controle remoto infravermelho, conforme apresentado na figura a seguir.
O ventilador apresentado e utilizado neste projeto, possui 5 características de controle:
- Botão para desligar;
- Velocidade 1;
- Velocidade 2;
- Velocidade 3;
- Temporizador de Desligamento.
Cada função de controle apresentada acima está presente no controle no ventilador e no controle remoto. Portanto, para cada tecla, haverá um código de controle que será responsável por comandar o ventilador.
Portanto, para que você possa criar o seu controle, é necessário realizar a leitura do código de cada tecla enviada pelo controle infravermelho (IR) do ventilador.
Para isto, necessitaremos conhecer o padrão de código do controle remoto e, caso seja necessário, determinaremos seu código RAW.
Agora, apresentaremos a lista completa de materiais, para que você desenvolva seu projeto.
Lista de Componentes Eletrônicos
- Arduino Nano;
- Kit Infravermelho + Controle Remoto IR;
- Botões 6×6 mm;
- Protoboard;
- Resistor 10kR;
- Resistor 330R.
A seguir, apresentaremos o processo para detecção do padrão de código.
Detecção do Padrão de Código do Controle IR
Primeiramente, devemos detectar o padrão de código do nosso controle. Para isto, devemos montar o seguinte circuito, conforme apresentado na Figura a seguir.
Por meio do circuito apresentado, devemos utilizar o seguinte código, a fim de detectar o padrão e o código RAW, caso o padrão seja desconhecido. Este código pode ser encontrado nos exemplos da biblioteca IRremote.h.
<code>#include <IRremote.h>
/*
* Default is Arduino pin D11.
* You can change this to another available Arduino Pin.
* Your IR receiver should be connected to the pin defined here
*/
int RECV_PIN = 4;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Start the receiver
}
void dump(decode_results *results) {
// Dumps out the decode_results structure.
// Call this after IRrecv::decode()
int count = results->rawlen;
if (results->decode_type == UNKNOWN) {
Serial.print("Unknown encoding: ");
}
else if (results->decode_type == NEC) {
Serial.print("Decoded NEC: ");
}
else if (results->decode_type == SONY) {
Serial.print("Decoded SONY: ");
}
else if (results->decode_type == RC5) {
Serial.print("Decoded RC5: ");
}
else if (results->decode_type == RC6) {
Serial.print("Decoded RC6: ");
}
else if (results->decode_type == PANASONIC) {
Serial.print("Decoded PANASONIC - Address: ");
Serial.print(results->address, HEX);
Serial.print(" Value: ");
}
else if (results->decode_type == LG) {
Serial.print("Decoded LG: ");
}
else if (results->decode_type == JVC) {
Serial.print("Decoded JVC: ");
}
else if (results->decode_type == AIWA_RC_T501) {
Serial.print("Decoded AIWA RC T501: ");
}
else if (results->decode_type == WHYNTER) {
Serial.print("Decoded Whynter: ");
}
Serial.print(results->value, HEX);
Serial.print(" (");
Serial.print(results->bits, DEC);
Serial.println(" bits)");
Serial.print("Raw (");
Serial.print(count, DEC);
Serial.print("): ");
for (int i = 1; i < count; i++) {
if (i & 1) {
Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
}
else {
Serial.write('-');
Serial.print((unsigned long) results->rawbuf[i]*USECPERTICK, DEC);
}
Serial.print(" ");
}
Serial.println();
}
void loop() {
if (irrecv.decode(&results)) {
Serial.println(results.value, HEX);
dump(&results);
irrecv.resume(); // Receive the next value
}
}</code>
Após a gravação do código no Arduino, aponte o controle e pressione uma tecla por vez, a fim de realizar a leitura do código e o padrão de controle. Os dados serão lidos e apresentados conforme mostrado na Figura 3.
Para a tecla de desligar é apresentado o código 39D41DC6. Em seguida, é apresentado o padrão como desconhecido. Dessa forma, como não temos um padrão conhecido, necessitamos utilizar o código RAW.
Conforme apresentado na linha a seguir, temo um código RAW com tamanho de 24 blocos. Logo, utilizaremos esse código quando desejarmos realizar o desligamento do ventilador.
Porém, é importante realizar várias leituras de um código RAW para cada tecla. Muitas vezes, ocorrem alguns ruídos indesejados na leitura e isso pode prejudicar os comandos de controle do dispositivo.
Dessa forma, realize diversas medidas e verifique a que mais se repete, a fim de ser utilizada em seu projeto. Portanto, repita esse processo para obter o código RAW para tecla.
A seguir, apresentaremos o processo de construção do circuito do controle remoto com Arduino.
Desenvolvimento do Controle Remoto de Ventilador com Arduino
A partir da leitura dos códigos, iniciaremos desenvolvendo nosso próprio controle remoto com Arduino. Desse modo, construiremos o circuito a seguir.
A partir do circuito apresentado na Figura 4, foi desenvolvido o seguinte código apresentado abaixo.
<code>//Declaracao da Biblioteca IR Remote
#include <IRremote.h>
//Definicao de nome para cada pino
#define BotDesl 2
#define BotTemp 4
#define BotV1 5
#define BotV2 6
#define BotV3 7
//Declaracao das variaveis do programa
bool BotDesliga = 0, BotTempo = 0, BotVel1 = 0, BotVel2 = 0, BotVel3 = 0;
unsigned int CMDdesliga[] = {1050,550,1150,550,300,1450,1050,650,1050,600,250,1450,200,1450,1150,450,350,1450,250,1400,250,1500,200};
unsigned int CMDtempo[] = {1050,550,1150,550,300,1450,1050,650,1050,600,250,1450,200,1450,1150,450,350,1450,250,1400,250,1500,200};
unsigned int CMDvel1[] = {1250,400,1300,400,450,1250,1250,400,1250,450,400,1300,400,1250,450,1250,450,1250,400,1250,1300,400,450};
unsigned int CMDvel2[] = {1250,450,1250,400,450,1250,1300,400,1250,450,400,1250,450,1250,400,1300,400,1250,1300,400,400,1300,400};
unsigned int CMDvel3[] = {1250,400,1300,400,400,1300,1250,450,1250,400,450,1250,400,1300,400,1250,400,1300,400,1300,400,1250,1250};
//Criacao do Objeto IRsend
IRsend irsend;
void setup()
{
pinMode(BotDesliga, INPUT);
pinMode(BotTempo, INPUT);
pinMode(BotVel1, INPUT);
pinMode(BotVel2, INPUT);
pinMode(BotVel3, INPUT);
}
void loop()
{
BotDesliga = digitalRead(BotDesl);
BotTempo = digitalRead(BotTemp);
BotVel1 = digitalRead(BotV1);
BotVel2 = digitalRead(BotV2);
BotVel3 = digitalRead(BotV3);
if(BotDesliga == 1)
{
irsend.sendRaw(CMDdesliga, 24, 38);//Desliga o Ventilador
}
if(BotTempo == 1)
{
irsend.sendRaw(CMDtempo, 24, 38);//Controla o tempo de desligar o ventilador
}
if(BotVel1 == 1)
{
irsend.sendRaw(CMDvel1, 24, 38);//Liga o Ventilador na Velocidade 1
}
if(BotVel2 == 1)
{
irsend.sendRaw(CMDvel2, 24, 38);//Liga o Ventilador na Velocidade 2
}
if(BotVel3 == 1)
{
irsend.sendRaw(CMDvel3, 24, 38);//Liga o Ventilador na Velocidade 3
}
delay(1000);
}</code>
Agora, a partir do código apresentado, desenvolveremos a discussão completa da lógica desenvolvida.
Dicussão da Lógica Desenvolvida para o Controle com Arduino
Primeiramente, realizamos todas as inclusões de bibliotecas, definições de nomes para cada pino e declaração de novas variáveis, conforme apresentado abaixo.
<code>//Declaracao da Biblioteca IR Remote #include <IRremote.h> //Definicao de nome para cada pino #define BotDesl 2 #define BotTemp 4 #define BotV1 5 #define BotV2 6 #define BotV3 7 //Declaracao das variaveis do programa bool BotDesliga = 0, BotTempo = 0, BotVel1 = 0, BotVel2 = 0, BotVel3 = 0;</code>
Em seguida, criamos 5 vetores. Cada vetor será utilizado para armazenar a sequência de código RAW de cada tecla do controle. Na porção de código abaixo, apresentamos todos os vetores criados.
<code>unsigned int CMDdesliga[] = {1050,550,1150,550,300,1450,1050,650,1050,600,250,1450,200,1450,1150,450,350,1450,250,1400,250,1500,200};
unsigned int CMDtempo[] = {1050,550,1150,550,300,1450,1050,650,1050,600,250,1450,200,1450,1150,450,350,1450,250,1400,250,1500,200};
unsigned int CMDvel1[] = {1250,400,1300,400,450,1250,1250,400,1250,450,400,1300,400,1250,450,1250,450,1250,400,1250,1300,400,450};
unsigned int CMDvel2[] = {1250,450,1250,400,450,1250,1300,400,1250,450,400,1250,450,1250,400,1300,400,1250,1300,400,400,1300,400};
unsigned int CMDvel3[] = {1250,400,1300,400,400,1300,1250,450,1250,400,450,1250,400,1300,400,1250,400,1300,400,1300,400,1250,1250};</code>
Posteriormente, foi criado o objeto IR Send. Ele é será responsável por enviar os comandos IR. Em seguida, todos os pinos dos botões foram configurados como entrada, conforme apresentado na porção de código abaixo.
<code>//Criacao do Objeto IRsend
IRsend irsend;
void setup()
{
pinMode(BotDesliga, INPUT);
pinMode(BotTempo, INPUT);
pinMode(BotVel1, INPUT);
pinMode(BotVel2, INPUT);
pinMode(BotVel3, INPUT);
}</code>
Finalmente, temos a estrutura do código principal na função loop. O código será responsável por realizar a leitura dos botões e enviar os sinais de controle para o Ventilador.
<code>void loop()
{
BotDesliga = digitalRead(BotDesl);
BotTempo = digitalRead(BotTemp);
BotVel1 = digitalRead(BotV1);
BotVel2 = digitalRead(BotV2);
BotVel3 = digitalRead(BotV3);
if(BotDesliga == 1)
{
irsend.sendRaw(CMDdesliga, 24, 38);//Desliga o Ventilador
}
if(BotTempo == 1)
{
irsend.sendRaw(CMDtempo, 24, 38);//Controla o tempo de desligar o ventilador
}
if(BotVel1 == 1)
{
irsend.sendRaw(CMDvel1, 24, 38);//Liga o Ventilador na Velocidade 1
}
if(BotVel2 == 1)
{
irsend.sendRaw(CMDvel2, 24, 38);//Liga o Ventilador na Velocidade 2
}
if(BotVel3 == 1)
{
irsend.sendRaw(CMDvel3, 24, 38);//Liga o Ventilador na Velocidade 3
}
delay(1000);
}</code>
Primeiramente, são realizadas as leituras de cada botão. Caso um botão esteja pressionado, será enviado um comando com o seu respectivo código RAW.
Para exemplificar, utilizaremos o botão de Velocidade 1. Caso ele esteja pressionado, será executado o comando a seguir.
<code>if(BotVel1 == 1)
{
irsend.sendRaw(CMDvel1, 24, 38);//Liga o Ventilador na Velocidade 1
}</code>
O comando utilizado (irsend.sendRaw) para enviar o código RAW possui 3 parâmetros:
- O primeiro CDMvel1 é referente ao vetor que armazena o código RAW da velocidade 1;
- O segundo comando (24), representa a quantidade de bloco de dados que será enviado. Este valor é obtido na leitura do código RAW na Figura 3.
- Finalmente, temos a frequência de envio, que é de 38 kHz. Em grande parte dos controles remotos IR é utilizado o valor de 38 kHz como padrão.
Após o envio desse comando, o ventilador será ligado na velocidade 1. Esse processo é repetido para qualquer botão pressionado. Porém, será enviado um código RAW de acordo com a tecla acionada.
Por fim, o sistema aguarda 1 segundo e retorna ao início do loop, a fim de ler, novamente, o estado dos botões.
Conclusão
Finalmente, por meio do sistema desenvolvido, foi possível copiar todos os códigos do controle e comandar o ventilador com o Arduino.
O sistema apresentou-se útil e, além disso, em aplicações futuras podemos integrá-lo com um aplicativo no celular. Dessa forma, você poderá controlar o ventilador pelo seu próprio celular.
Além disso, com o objetivo de utilizar os pinos do Arduino, você pode implementar um sistema de controle de iluminação do quarto e incluir novas funcionalidades ao seu projeto.
Portanto, realize a leitura de outros artigos em nosso Blog AutoCore Robótica e desenvolva novas ideias a partir do artigo apresentado.