Arduino – Utilizando o Interruptor Módulo Relé com RF 433MHz para Automação

Na primeira postagem sobre o Interruptor Módulo Relé com RF 433MHz falei sobre suas aplicações, suas especificações e ensinei a utilizá-lo em seus diversos modos de funcionamento. Este módulo funciona muito bem de forma independente, permitindo que você possa fazer o acionamento de vários tipos de cargas através de controle remoto RF e por meio de interruptor comum, pulsador, three way ou four way. Contudo, você também pode utilizá-lo em conjunto com o Arduino, e é isso que pretendo ensinar nesta postagem.

Se ainda não conhece o Interruptor Módulo Relé com RF 433MHz, recomendo que acesse a postagem Conhecendo o Interruptor Módulo Relé com RF 433MHz para Automação, pois nela explico detalhadamente o uso deste módulo, tanto a versão de 1 canal quanto a de 2 canais.

Para que o Arduino possa enviar os comandos ao Interruptor Módulo Relé com RF 433MHz vai ser necessário o uso de um transmissor RF de 433MHz. Mesmo utilizando o Arduino e o transmissor RF, você ainda vai poder usar o controle remoto e o interruptor (caso já tenha um sendo utilizado) para acionamento do módulo.

Para demonstrar o uso do Interruptor Módulo Relé com RF 433MHz junto ao Arduino, utilizei o módulo de 1 canal e 1 lâmpada conectada à saída, contudo, o uso do módulo de 2 canais é feito da mesma forma.

Abaixo temos a lista dos itens necessários:

– Arduino c/ Cabo USB
– Módulo Transmissor Wireless RF 433MHz
– Chave Táctil (Push Button)
– Módulo Relé de 1 Canal com RF 433MHz para Automação – 127V (versão 220V / 2 Canais 127V / 2 Canais 220V)
– Protoboard
– Cabo Jumper Macho-macho
– Lâmpada
– Receptáculo (boquilha)
– Cabo paralelo de 1,5mm ou 2,5mm
– Tomada (Rede alternada de 127V)
– Interruptor liga/desliga

Primeiramente monte o esquema de ligação entre o Arduino, transmissor RF de 433MHz e os botões:

ATENÇÃO: FAÇA TODAS AS LIGAÇÕES COM SEU ARDUINO DESCONECTADO DA ALIMENTAÇÃO.

Em seguida monte o esquema de ligação do módulo com a lâmpada, interruptor e a rede alternada de alimentação:

OBS: o uso do interruptor é opcional caso queira controlar o módulo apenas pelo Arduino ou pelo controle remoto.

ATENÇÃO: MUITO CUIDADO AO EXECUTAR PRÁTICAS QUE ENVOLVAM TENSÃO / CORRENTE ALTERNADA! FAÇA TODAS AS LIGAÇÕES COM O CIRCUITO COMPLETAMENTE DESLIGADO E ANTES DE FAZER OS TESTES VERIFIQUE CADA UMA DAS LIGAÇÕES PARA ELIMINAR A POSSIBILIDADE DE CURTO ENTRE FASE / NEUTRO OU FASE / FASE.

Feito o esquema de ligação, conecte o Arduino ao computador através do cabo USB para envio do código a placa. Se você ainda não instalou a IDE do Arduino, acesse o link abaixo e em seguida retorne para continuar:

Arduino – Instalação e Configuração da IDE no Windows

Confira a placa e a porta selecionada na IDE e em seguida carregue o código abaixo:

byte out_rf = 12; //PINO CONECTADO AO DATA DO TRANSMISSOR RF
byte bt_1 = 10; //PINO REFERENTE AO BOTÃO 1
byte bt_2 = 9; //PINO REFERENTE AO BOTÃO 2

byte address_l = 0xF1; //VALOR ENTRE 0 E 255 OU 0 E FF EM HEXADECIMAL PARA O ENDEREÇO NA PARTE BAIXA (LOW)
byte address_h = 0xFE; //VALOR ENTRE 0 E 255 OU 0 E FF EM HEXADECIMAL PARA O ENDEREÇO NA PARTE ALTA (HIGH)

byte loop_rf = 4; //QUANTIDADE DE VEZES QUE O PACOTE SERÁ TRANSMITIDO A CADA VEZ QUE EXECUTAR A ROTINA DE ENVIO
unsigned int alpha = 370; //TEMPO DE DURAÇÃO EM MICROSEGUNDOS DE CADA CLOCK DA TRANSMISSÃO (PODE SER ALTERADO CASO APRESENTE ERRO AO RECONHECER OS DADOS)
byte aux1 = 0; //VARIÁVEL AUXILIAR
byte aux2 = 0; //VARIÁVEL AUXILIAR

void setup(){
  pinMode(out_rf,OUTPUT); //PINO DEFINIDO COMO SAÍDA
  pinMode(bt_1,INPUT_PULLUP); //PINO DEFINIDO COMO ENTRADA E PULL UP ATIVADO (GARANTE QUE O PINO NÃO IRÁ FICAR FLUTUANDO ENTRE LOW E HIGH)
  pinMode(bt_2,INPUT_PULLUP); //PINO DEFINIDO COMO ENTRADA E PULL UP ATIVADO (GARANTE QUE O PINO NÃO IRÁ FICAR FLUTUANDO ENTRE LOW E HIGH)
  digitalWrite(out_rf, LOW); //PINO INICIA DESLIGADO
  }
  
void loop(){
     if(digitalRead(bt_1)== 0){ //SE O BOTÃO 1 FOR PRESSIONADO, FAZ
        sendRF(0x01); //EXECUTA A FUNÇÃO "sendRF" E PASSA O PARÂMETRO "0x01"
        delay(200); //INTERVALO DE 200 MILISSEGUNDOS
       }
   
     if(digitalRead(bt_2)== 0){ //SE O BOTÃO 2 FOR PRESSIONADO, FAZ
        sendRF(0x02); //EXECUTA A FUNÇÃO "sendRF" E PASSA O PARÂMETRO "0x02"
        delay(200); //INTERVALO DE 200 MILISSEGUNDOS
       }
  }
//FUNÇÃO QUE ENVIA O PACOTE RF
void sendRF(byte dados){ //O PARÂMETRO "dados" É UM VALOR ENTRE 0 E 15 OU 0x00 e 0x0F QUE SÓ PERMITE OS 4 BITS MENOS SIGNIFICATIVOS E QUE RESULTA EM 16 POSSIBILIDADES
   digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO
   delay(10); //INTERVALO DE 10 MILISSEGUNDOS
   aux1 = 0; //VARIÁVEL RECEBE 0
   while(aux1 < loop_rf){ //ENQUANTO "aux1" FOR MENOR QUE "loop_rf", FAZ

digitalWrite(out_rf, HIGH); //COLOCA O PINO EM NÍVEL ALTO
     delayMicroseconds(alpha); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"
     digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO
     delayMicroseconds(alpha * 30); //INTERVALO COM O VALOR DA VARIÁVEL "alpha" 
     sendBit(0);sendBit(0);sendBit(0);sendBit(0); //INICIA ENVIANDO O ENDEREÇO MAIS BAIXO, CONTUDO ENVIA 4 BIT ZERO
     
     //INÍCIO DO BLOCO QUE ENVIA O BYTE MENOS SIGNIFICATIVO DO ENDEREÇO
     aux2 = 0;
     while(aux2 < 8){
       sendBit(bitRead(address_l, aux2));       
       aux2 = aux2 + 1;
       }
        //FIM DO BLOCO QUE ENVIA O BYTE MENOS SIGNIFICATIVO DO ENDEREÇO
        
     //INÍCIO DO BLOCO QUE ENVIA O BYTE MAIS SIGNIFICATIVO DO ENDEREÇO
     aux2 = 0;
     while(aux2 < 8){
       sendBit(bitRead(address_h, aux2));       
       aux2 = aux2 + 1;
       }
    //FIM DO BLOCO QUE ENVIA O BYTE MAIS SIGNIFICATIVO DO ENDEREÇO
       
    //INÍCIO DO BLOCO QUE ENVIA O BYTE DE DADOS
     aux2 = 0;
     while(aux2 < 4){
       sendBit(bitRead(dados, aux2));       
       aux2 = aux2 + 1;
       }
       //FIM DO BLOCO QUE ENVIA O BYTE DE DADOS
       
     aux1 = aux1 + 1; //VARIÁVEL RECEBE "aux1" MAIS 1
     }
   digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO
   }
    
//FUNÇÃO QUE ENVIA UM BIT
void sendBit(byte _bit){
  if(_bit == 0){ //SE "_bit" IGUAL A 0, FAZ
    digitalWrite(out_rf, HIGH); //COLOCA O PINO EM NÍVEL ALTO
    delayMicroseconds(alpha); //INTERVALO COM O VALOR DA VARIÁVEL "alpha" 
    digitalWrite(out_rf, LOW);  //COLOCA O PINO EM NÍVEL BAIXO
    delayMicroseconds(alpha * 3); //INTERVALO COM O VALOR DA VARIÁVEL "alpha" 
    }
    else //SENÃO, FAZ
      {
      digitalWrite(out_rf, HIGH); //COLOCA O PINO EM NÍVEL ALTO
      delayMicroseconds(alpha * 3); //INTERVALO COM O VALOR DA VARIÁVEL "alpha" 
      digitalWrite(out_rf, LOW);  //COLOCA O PINO EM NÍVEL BAIXO
      delayMicroseconds(alpha); //INTERVALO COM O VALOR DA VARIÁVEL "alpha" 
      }
  }

byte out_rf = 12; //PINO CONECTADO AO DATA DO TRANSMISSOR RF

byte bt_1 = 10; //PINO REFERENTE AO BOTÃO 1

byte bt_2 = 9; //PINO REFERENTE AO BOTÃO 2

byte address_l = 0xF1; //VALOR ENTRE 0 E 255 OU 0 E FF EM HEXADECIMAL PARA O ENDEREÇO NA PARTE BAIXA (LOW)

byte address_h = 0xFE; //VALOR ENTRE 0 E 255 OU 0 E FF EM HEXADECIMAL PARA O ENDEREÇO NA PARTE ALTA (HIGH)

byte loop_rf = 4; //QUANTIDADE DE VEZES QUE O PACOTE SERÁ TRANSMITIDO A CADA VEZ QUE EXECUTAR A ROTINA DE ENVIO

unsigned int alpha = 370; //TEMPO DE DURAÇÃO EM MICROSEGUNDOS DE CADA CLOCK DA TRANSMISSÃO (PODE SER ALTERADO CASO APRESENTE ERRO AO RECONHECER OS DADOS)

byte aux1 = 0; //VARIÁVEL AUXILIAR

byte aux2 = 0; //VARIÁVEL AUXILIAR

void setup(){

pinMode(out_rf,OUTPUT); //PINO DEFINIDO COMO SAÍDA

pinMode(bt_1,INPUT_PULLUP); //PINO DEFINIDO COMO ENTRADA E PULL UP ATIVADO (GARANTE QUE O PINO NÃO IRÁ FICAR FLUTUANDO ENTRE LOW E HIGH)

pinMode(bt_2,INPUT_PULLUP); //PINO DEFINIDO COMO ENTRADA E PULL UP ATIVADO (GARANTE QUE O PINO NÃO IRÁ FICAR FLUTUANDO ENTRE LOW E HIGH)

digitalWrite(out_rf, LOW); //PINO INICIA DESLIGADO

}

void loop(){

if(digitalRead(bt_1)== 0){ //SE O BOTÃO 1 FOR PRESSIONADO, FAZ

sendRF(0x01); //EXECUTA A FUNÇÃO "sendRF" E PASSA O PARÂMETRO "0x01"

delay(200); //INTERVALO DE 200 MILISSEGUNDOS

}

if(digitalRead(bt_2)== 0){ //SE O BOTÃO 2 FOR PRESSIONADO, FAZ

sendRF(0x02); //EXECUTA A FUNÇÃO "sendRF" E PASSA O PARÂMETRO "0x02"

delay(200); //INTERVALO DE 200 MILISSEGUNDOS

}

//FUNÇÃO QUE ENVIA O PACOTE RF

void sendRF(byte dados){ //O PARÂMETRO "dados" É UM VALOR ENTRE 0 E 15 OU 0x00 e 0x0F QUE SÓ PERMITE OS 4 BITS MENOS SIGNIFICATIVOS E QUE RESULTA EM 16 POSSIBILIDADES

digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO

delay(10); //INTERVALO DE 10 MILISSEGUNDOS

aux1 = 0; //VARIÁVEL RECEBE 0

while(aux1 < loop_rf){ //ENQUANTO "aux1" FOR MENOR QUE "loop_rf", FAZ

digitalWrite(out_rf, HIGH); //COLOCA O PINO EM NÍVEL ALTO

delayMicroseconds(alpha); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"

digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO

delayMicroseconds(alpha * 30); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"

sendBit(0);sendBit(0);sendBit(0);sendBit(0); //INICIA ENVIANDO O ENDEREÇO MAIS BAIXO, CONTUDO ENVIA 4 BIT ZERO

//INÍCIO DO BLOCO QUE ENVIA O BYTE MENOS SIGNIFICATIVO DO ENDEREÇO

aux2 = 0;

while(aux2 < 8){

sendBit(bitRead(address_l, aux2));

aux2 = aux2 + 1;

}

//FIM DO BLOCO QUE ENVIA O BYTE MENOS SIGNIFICATIVO DO ENDEREÇO

//INÍCIO DO BLOCO QUE ENVIA O BYTE MAIS SIGNIFICATIVO DO ENDEREÇO

aux2 = 0;

while(aux2 < 8){

sendBit(bitRead(address_h, aux2));

aux2 = aux2 + 1;

}

//FIM DO BLOCO QUE ENVIA O BYTE MAIS SIGNIFICATIVO DO ENDEREÇO

//INÍCIO DO BLOCO QUE ENVIA O BYTE DE DADOS

aux2 = 0;

while(aux2 < 4){

sendBit(bitRead(dados, aux2));

aux2 = aux2 + 1;

}

//FIM DO BLOCO QUE ENVIA O BYTE DE DADOS

aux1 = aux1 + 1; //VARIÁVEL RECEBE "aux1" MAIS 1

}

digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO

}

//FUNÇÃO QUE ENVIA UM BIT

void sendBit(byte _bit){

if(_bit == 0){ //SE "_bit" IGUAL A 0, FAZ

digitalWrite(out_rf, HIGH); //COLOCA O PINO EM NÍVEL ALTO

delayMicroseconds(alpha); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"

digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO

delayMicroseconds(alpha * 3); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"

}

else //SENÃO, FAZ

{

digitalWrite(out_rf, HIGH); //COLOCA O PINO EM NÍVEL ALTO

delayMicroseconds(alpha * 3); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"

digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO

delayMicroseconds(alpha); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"

}

No código há duas variáveis de endereço, sendo elas “address_l” e address_h. A variável “address_l” armazena um valor entre 0 e 255 ou 0 e FF em hexadecimal para o endereço na parte baixa (LOW) e a variável “address_h” também armazena um valor entre 0 e 255 ou 0 e FF em hexadecimal para o endereço, contudo na parte alta (HIGH). Com a combinação destes dois endereços é possível fazer 65536 possibilidades. Portanto, caso você queira montar uma rede de módulos para serem controlados através do Arduino, basta mudar apenas um único bit em um dos endereços. Por exemplo: 0x00, 0x01, 0x64 0xC8 e assim até 0xFF. Caso não queira mudar, basta criar novas variáveis para armazenar os novos endereços.

Note também que no código há as linhas “sendRF(0x01);” e “sendRF(0x02);”. Estas linhas fazem a chamada da função “sendRF” e passam um dado como parâmetro. Este parâmetro é um valor entre 0 e 15 ou 0x00 e 0x0F que só permite os 4 bits menos significativos e que resulta em 16 possibilidades. Portanto, se você quiser adicionar mais botões (respeitando a limitação do módulo), basta enviar através dos outros botões os dados 0x03, 0x04, 0x05… até 0x0F.

Considerando que você já tenha feito todas as ligações no Interruptor Módulo Relé com RF 433MHz, vamos proceder na seleção do modo de funcionamento e em seguida gravar os dois botões que estão conectados ao Arduino.

Selecionando o modo de funcionamento:

O Interruptor Módulo Relé com RF 433MHz possui 6 modos de funcionamento e você pode ver mais detalhes sobre cada um dos modos clicando AQUI. Para esta postagem optei por utilizar o modo 1 de funcionamento.

Para selecionar o modo 1 de funcionamento pressione e solte o botão CH1 do módulo e o LED irá acender, mostrando que o canal foi selecionado. Em seguida, mantenha pressionado o botão CH1 até que o LED se apague. Após o LED se apagar, solte o botão CH1. Neste instante, o LED irá piscar uma vez e apagar. Você terá 2 segundos para pressionar o botão CH1 e selecionar este modo de funcionamento.

Veja no vídeo a seguir como selecionar o modo 1 de funcionamento:

Abaixo temos a explicação da forma de funcionamento do interruptor e dos botões (tanto dos botões de um controle remoto, quanto os botões conectados ao Arduino) para o modo 1:

Interruptor de parede: quando a posição do interruptor é invertida o estado atual da lâmpada (ligada / desligada) é alterado. Independente se o interruptor está fechando ou abrindo o contato a lâmpada terá seu estado alterado.

Botões: o primeiro botão gravado irá acender a lâmpada e o segundo botão gravado irá apagar a lâmpada.

Gravando os dois botões:

Ao pressionar e soltar o botão CH1 do módulo o LED irá acender mostrando que o canal foi selecionado. O LED permanecerá aceso por 12 segundos, logo, durante este tempo você deve pressionar um dos botões que estão conectados ao Arduino para que o mesmo seja capturado pelo módulo e seja gravado. Após a gravação do primeiro botão, o LED irá piscar, se manter aceso e aguardar novamente por 12 segundos que o outro botão seja pressionado para gravação.

No vídeo abaixo você pode ver os procedimentos para gravar os dois botões conectados ao Arduino:

Caso você queira utilizar um controle remoto também, basta fazer a gravação dos botões do controle conforme explicado anteriormente.

Terminado a gravação dos botões, basta pressioná-los para fazer o acionamento da lâmpada conectada ao módulo. Lembre-se que o primeiro botão gravado vai acender a lâmpada e o segundo botão irá apagar.

Veja no vídeo abaixo o acionamento da lâmpada sendo feito através dos botões conectados ao Arduino, através do interruptor liga/desliga e do controle remoto que eu já havia adicionado ao módulo previamente:

Mesmo que o Interruptor Módulo Relé com RF 433MHz possa ser utilizado independente do Arduino, ainda assim você pode fazer projetos bem interessantes unindo ambos, como por exemplo, acoplar o Ethernet Shield W5100 ao Arduino, conectar o transmissor RF 433MHz e implementar o código para que você possa comunicar o Arduino com seu smartphone ou tablet através da internet e enviar os comandos para que eles sejam processados pelo Arduino e enviados ao Interruptor Módulo Relé com RF 433MHz através do transmissor RF. Desta forma, você poderá acionar o módulo através de uma conexão WiFi.

Gostou deste tutorial? Então deixa seu comentário, dúvida ou sugestão aí embaixo!

Loja online: https://www.masterwalkershop.com.br
Fan page no Facebook: https://www.facebook.com/masterwalkershop

Nos ajude a espalhar conhecimento clicando no botão de compartilhar (f Like) que está mais abaixo.

Obrigado e até a próxima!

Seu feedback é muito importante! Que tal dar uma nota para esta postagem?! Faça sua avaliação aqui embaixo.

Postagem anterior: Blynk – Automação Residencial de Lâmpadas com Arduino

Próxima postagem: Blynk – Como utilizar com ESP8266 ESP-01, NodeMCU e Wemos D1

Existem 7 comentários para esta postagem

Raimundo 9 de janeiro de 2021 às 16:13

Excelente artigo, obrigado. Uma dúvida. Como descubro o endereço de cada relé ? Pretendo usar mais de um.
Kleiton 9 de janeiro de 2019 às 19:26

Amigo, com faço pra ler essas msgs que são enviadas?
Sei que é só gravar no modulo que ele vai ler e atuar mas estou planejando um retorno onde ele vai receber a msg e vai enviar outra msg confirmando que foi recebido.
No caso você explica como enviar, e como receber com um receptor?
- Euler Oliveira Autor 9 de janeiro de 2019 às 21:10
  
  Olá Kleiton.
  
  Com este módulo não é possível implementar isto que deseja, pois o módulo em questão não possui transmissor, apenas o receptor.
Ary Felipe Ferreira Guimaraes 7 de junho de 2018 às 16:55

Da pra gravar varios comandos no Broadlink com esse circuito e assim dispensar controles RF ???
- Euler Oliveira Autor 7 de junho de 2018 às 19:17
  
  Olá Ary.
  
  Sim é possível.
  
  Veja o artigo abaixo:
  
  https://blogmasterwalkershop.com.br/automacao/conhecendo-o-interruptor-modulo-rele-com-rf-433mhz-para-automacao/
  - Fernanda 2 de novembro de 2019 às 11:14
    
    Gostaria de fazer um sistema em que o módulo se comunicasse com o arduino para enviar a informação do estado atual da lâmpada. Como poderíamos fazer isso? Precisamos usar alguma interface AC?
    - Euler Oliveira Autor 2 de novembro de 2019 às 11:18
      
      Olá Fernanda.
      
      Agradeço pelo comentário!
      
      Neste caso seria necessário utilizar um sensor de corrente AC ou sensor de tensão AC em conjunto com o módulo para fazer a detecção do estado atual e informar ao Arduino.
      
      Por exemplo:
      
      https://blogmasterwalkershop.com.br/arduino/arduino-utilizando-o-sensor-detector-de-tensao-ac/