Blynk – Acionamento via Interruptor Three Way (Paralelo) e App

Nesta postagem você vai aprender a fazer o acionamento de uma lâmpada através de um interruptor three way / paralelo e poderá também fazer o acionamento pelo app Blynk instalado em seu smartphone ou tablet. Independente de onde o acionamento esteja sendo feito (interruptor ou aplicativo) o status atual (ligada / desligada) da lâmpada será mostrado no app.

Caso ainda não conheça o Blynk, recomendo que leia a postagem Conhecendo o Blynk, pois nela apresentei a ferramenta, mostrei as opções de configurações, mostrei as funções básicas e ensinei a instalar o pacote de bibliotecas no IDE do Arduino.

Das tarefas diárias de uma residência, a primeira a ser inserida no projeto de automação residencial com Arduino, por exemplo, é a iluminação. O controle da iluminação através de uma página web, smartphone ou tablet é algo essencial no projeto, contudo, você deve se fazer a seguinte pergunta antes de começar:

“Se meu sistema de automação residencial ficar off-line, como eu vou controlar as lâmpadas?”

A resposta para esta pergunta é simples: através do interruptor. Para controle virtual da lâmpada basta utilizar o módulo relé junto ao Arduino. Porém, para fazer o controle da lâmpada externamente ao sistema, será necessário o uso de um interruptor em paralelo com o módulo relé. Neste caso, será necessário substituir o interruptor convencional (liga / desliga) por um Interruptor three way, que também é conhecido como interruptor paralelo.

O interruptor paralelo / three way permite ligar / desligar um dispositivo em um ponto e ligar / desligar em outro ponto. Este tipo de interruptor é utilizado em situações que é necessário controlar um dispositivo de dois pontos distintos. Um exemplo de utilização residencial de interruptores three way, é em uma escada, onde será possível acender / apagar a lâmpada tanto na parte inferior quanto na parte superior da escada:

A ligação entre dois interruptores three way e uma lâmpada é feita conforme a imagem abaixo:

A ligação entre um interruptor three way com o módulo relé e uma lâmpada não diferencia:

Na imagem acima, os contatos NF (NORMALMENTE FECHADO) e NA (NORMALMENTE ABERTO) do módulo relé ficam conectados aos retornos do interruptor three way e o borne comum do relé é ligado direto na lâmpada.

Esta implementação nos leva a outro questionamento:

“O relé está conectado diretamente ao Arduino e consigo facilmente identificar se a lâmpada está acesa ou apagada. Contudo, ao inserir o interruptor three way para fazer o acionamento da lâmpada manualmente e conectá-lo ao módulo relé, não consigo mais identificar o estado atual dela, pois estou controlando de dois pontos distintos e um deles é externo ao Arduino. Como resolver esta questão?”

A resposta para esta outra pergunta é: Sensor (Detector) de Tensão AC 127V / 220V. Ao utilizar este sensor, será possível capturar o estado atual da lâmpada independente se ela está sendo controlada virtualmente (app Blynk) ou pelo interruptor paralelo.

O Sensor (Detector) de Tensão AC 127V / 220V fabricado pela MasterWalker Shop aceita uma faixa de tensão de 0 a 220VAC e o mesmo suporta uma tensão de pico igual a 311VAC. Você pode utilizar o sensor para identificar o estado atual de outros tipos de cargas em rede alternada que operam dentro das limitações do mesmo.

Para esta prática utilizei o Ethernet Shield W5100 acoplado ao Arduino. Desta forma o Arduino vai estar conectado à internet através de um cabo de rede RJ45 e poderá se comunicar com app Blynk instalado no smartphone ou tablet.

Será necessário que tenha o Blynk instalado e configurado no seu smartphone ou tablet, e que tenha a biblioteca Blynk instalada no IDE do Arduino. Acesse a postagem Conhecendo o Blynk, pois nela explico tudo isso detalhadamente.

Além de um dispositivo móvel Android ou iOS, você vai precisar também dos seguintes itens:

01 – Arduino Uno R3 com Cabo USB
01 – Ethernet Shield W5100
01 – Módulo Relé 5V 1 Canal
01 – Sensor (Detector) de Tensão AC 127V / 220V
01 – Chave Gangorra KCD1-102 Preta 3T (Three Way)
06 – Cabos Jumper macho-fêmea
01 – Lâmpada
01 – Receptáculo (boquilha)
– Cabo paralelo de 1,5mm ou 2,5mm
– Tomada (Rede alternada de 127V)
– Cabo de rede RJ45

Utilizei a Chave Gangorra 3T nesta prática, contudo você pode utilizar qualquer interruptor three way.

Monte o seguinte esquema de ligação:

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.

Note que o Sensor de Tensão AC é ligado em paralelo com o circuito, logo, a corrente do circuito é irrelevante para o sensor. Além disso, o sensor foi instalado junto ao retorno da lâmpada, pois ali só vai existir presença de tensão quando o circuito estiver fechado através do módulo relé ou pelo interruptor paralelo.

Clique AQUI e veja como fazer a instalação do pacote de bibliotecas do Blynk no IDE do Arduino e em seguida retorne para continuar.

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

#include <SPI.h> //INCLUSÃO DE BIBLIOTECA
#include <Ethernet.h> //INCLUSÃO DE BIBLIOTECA
#include <BlynkSimpleEthernet.h> //INCLUSÃO DE BIBLIOTECA

int pinoRele = 8; //PINO DIGITAL UTILIZADO PELO MÓDULO RELÉ
int pinoSensor = A2; //PINO ANALÓGICO UTILIZADO PELO SENSOR
int statusAtual; //VARIÁVEL PARA REGISTRO DE STATUS DA LÂMPADA
int statusSalvo; //VARIÁVEL PARA REGISTRO DE STATUS DA LÂMPADA

char auth[] = "YourAuthToken"; //AUTH TOKEN (FORNECIDO PELO PROJETO NO BLYNK E POR E-MAIL)

BlynkTimer timer; //OBJETO DO TIPO BlynkTimer

#define W5100_CS  10 //DEFINIÇÃO DE PINO
#define SDCARD_CS 4 //DEFINIÇÃO DE PINO

void setup(){
  pinMode(SDCARD_CS, OUTPUT); //DEFINE O PINO COMO SAÍDA
  digitalWrite(SDCARD_CS, HIGH); //COLOCA O PINO EM SINAL ALTO
  Blynk.begin(auth);//INICIALIZA A COMUNICAÇÃO BLYNK
  pinMode(pinoRele, OUTPUT); //DEFINE O PINO COMO SAÍDA
  pinMode(pinoSensor, INPUT); //DEFINE O PINO COMO ENTRADA
  digitalWrite(pinoRele, HIGH); //MÓDULO RELÉ INICIA DESLIGADO
  timer.setInterval(500, verificaStatusLamp); //DEFINE O INTERVALO DE 500 MILISSEGUNDOS
}

void loop(){
  Blynk.run(); //INICIALIZA O BLYNK
  timer.run(); //INICIALIZA O TIMER
}

void verificaStatusLamp(){ //FUNÇÃO RESPONSÁVEL POR VERIFICAR A MUDANÇA DE STATUS DA LÂMPADA
  for (int i = 0; i < 250; i++){ //PARA "i" IGUAL A 0, ENQUANTO "i" MENOR QUE 250, INCREMENTA "i"
    statusAtual = analogRead(pinoSensor); //VARIÁVEL RECEBER A LEITURA DO PINO
  }   
  if(statusAtual > 200){ //SE LEITURA FOR MAIOR QUE 200, FAZ
      statusAtual = 1; //VARIÁVEL RECEBE 1
  }else{ //SENÃO, FAZ
      statusAtual = 0; //VARIÁVEL RECEBE 0
    }
    
  //SE statusAtual FOR DIFERENTE DE statusSalvo, O WIDGET INVERTE O ESTADO
  if (statusAtual != statusSalvo) Blynk.virtualWrite(V2, !statusAtual);
  statusSalvo = statusAtual; //statusSalvo RECEBE O VALOR DE statusAtual
}

//FUNÇÃO QUE VERIFICA QUANDO O WIDGET BUTTON É PRESSIONADO
BLYNK_WRITE(V2){
  digitalWrite(pinoRele, !digitalRead(pinoRele)); //ALTERNA O ESTADO DO RELÉ
}

#include <SPI.h> //INCLUSÃO DE BIBLIOTECA

#include <Ethernet.h> //INCLUSÃO DE BIBLIOTECA

#include <BlynkSimpleEthernet.h> //INCLUSÃO DE BIBLIOTECA

int pinoRele = 8; //PINO DIGITAL UTILIZADO PELO MÓDULO RELÉ

int pinoSensor = A2; //PINO ANALÓGICO UTILIZADO PELO SENSOR

int statusAtual; //VARIÁVEL PARA REGISTRO DE STATUS DA LÂMPADA

int statusSalvo; //VARIÁVEL PARA REGISTRO DE STATUS DA LÂMPADA

char auth[] = "YourAuthToken"; //AUTH TOKEN (FORNECIDO PELO PROJETO NO BLYNK E POR E-MAIL)

BlynkTimer timer; //OBJETO DO TIPO BlynkTimer

#define W5100_CS 10 //DEFINIÇÃO DE PINO

#define SDCARD_CS 4 //DEFINIÇÃO DE PINO

void setup(){

pinMode(SDCARD_CS, OUTPUT); //DEFINE O PINO COMO SAÍDA

digitalWrite(SDCARD_CS, HIGH); //COLOCA O PINO EM SINAL ALTO

Blynk.begin(auth);//INICIALIZA A COMUNICAÇÃO BLYNK

pinMode(pinoRele, OUTPUT); //DEFINE O PINO COMO SAÍDA

pinMode(pinoSensor, INPUT); //DEFINE O PINO COMO ENTRADA

digitalWrite(pinoRele, HIGH); //MÓDULO RELÉ INICIA DESLIGADO

timer.setInterval(500, verificaStatusLamp); //DEFINE O INTERVALO DE 500 MILISSEGUNDOS

}

void loop(){

Blynk.run(); //INICIALIZA O BLYNK

timer.run(); //INICIALIZA O TIMER

}

void verificaStatusLamp(){ //FUNÇÃO RESPONSÁVEL POR VERIFICAR A MUDANÇA DE STATUS DA LÂMPADA

for (int i = 0; i < 250; i++){ //PARA "i" IGUAL A 0, ENQUANTO "i" MENOR QUE 250, INCREMENTA "i"

statusAtual = analogRead(pinoSensor); //VARIÁVEL RECEBER A LEITURA DO PINO

}

if(statusAtual > 200){ //SE LEITURA FOR MAIOR QUE 200, FAZ

statusAtual = 1; //VARIÁVEL RECEBE 1

}else{ //SENÃO, FAZ

statusAtual = 0; //VARIÁVEL RECEBE 0

}

//SE statusAtual FOR DIFERENTE DE statusSalvo, O WIDGET INVERTE O ESTADO

if (statusAtual != statusSalvo) Blynk.virtualWrite(V2, !statusAtual);

statusSalvo = statusAtual; //statusSalvo RECEBE O VALOR DE statusAtual

}

//FUNÇÃO QUE VERIFICA QUANDO O WIDGET BUTTON É PRESSIONADO

BLYNK_WRITE(V2){

digitalWrite(pinoRele, !digitalRead(pinoRele)); //ALTERNA O ESTADO DO RELÉ

}

Vá até a linha char auth[] = “YourAuthToken”; apague o texto YourAuthToken e adicione o seu AuthToken (para mais detalhes sobre como obter o AuthToken, clique AQUI):

No menu “Ferramentas” selecione a opção “Placa” e selecione o modelo do seu Arduino. Ainda no menu “Ferramentas”, selecione a opção “Porta” e marque a porta COM em que seu Arduino foi alocado.

Clique no botão para enviar o código ao Arduino e aguarde o carregamento.

Abra o app Blynk em seu dispositivo móvel Android ou iOS, faça login e acesse o seu projeto. Se ainda não tem o projeto criado no Blynk, clique AQUI e leia a postagem para aprender a fazer as devidas configurações do projeto. Seu projeto deverá ser criado com as seguintes configurações:

Na tela principal do projeto, vá até a lista de widgets, selecione um “Button”:

Com o widget inserido no contêiner principal, clique sobre o “Button” para acessar as configurações. Em “OUTPUT” selecione o tipo de pino “Virtual” e V2. As configurações deverão ficar similar a imagem abaixo:

O Blynk pode controlar de forma direta os pinos digitais e analógicos da plataforma sem que seja necessário escrever uma linha de código. Contudo, controlar entradas e saídas da plataforma não é suficiente, logo, se faz necessário a troca de informação com qualquer tipo de dado.

Para possibilitar o envio de qualquer tipo de dado da plataforma (Arduino, por exemplo) para o aplicativo e do aplicativo para a plataforma, foram criados os pinos virtuais. A partir destes pinos, você pode trocar qualquer tipo de informação entre o app no dispositivo móvel e a plataforma. Logo, você pode processar algo na plataforma e em seguida enviar o resultado para o aplicativo. Veja que definimos o pino virtual V2 nas configurações do widget “Button” e este pino será responsável por controlar o acionamento do módulo relé e este mesmo pino irá receber a informação do status atual da lâmpada quando a mesma for acionada pelo interruptor three way.

Depois de efetuar as configurações do widget você terá uma tela similar a imagem abaixo:

Agora clique no botão de “Play” para iniciar a conexão e em seguida confira se o projeto está online:

Agora basta pressionar o botão no app Blynk para acender ou apagar a lâmpada. Pressione também o interruptor three way para acender ou apagar a lâmpada. Note que o estado atual da lâmpada é mostrado no app Blynk independentemente se o acionamento é feito pelo aplicativo ou pelo interruptor paralelo.

Veja no vídeo abaixo o resultado final:

Geralmente se utiliza o interruptor pulsador em projetos de automação residencial, pois o mesmo pode ser conectado diretamente a plataforma microcontrolada e desta forma a carga AC poderá ser acionada virtualmente (página web / smartphone / tablet) ou pelo interruptor pulsador. O uso do interruptor pulsador não irá exigir, por exemplo, o Sensor (Detector) de Tensão AC 127V / 220V para detectar o status atual da lâmpada, pois todo o acionamento está concentrado 100% em cima da plataforma microcontrolada. Porém, se por algum motivo o sistema de automação não iniciar ou parar, você não terá como fazer o acionamento da carga, nem mesmo pelo interruptor pulsador. Por este motivo, se utiliza o interruptor three way / paralelo, pois como ele é um meio externo de acionamento, seu funcionamento não depende de um sistema em execução.

Gostou desta postagem? 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
Página no Instagram: https://www.instagram.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: Utilizando o Controlador PWM 6V a 28V 3A para Motor DC

Próxima postagem: Arduino Nano – Vale a pena adquirir esta versão?

Existem 4 comentários para esta postagem

LUCIANO ROSA MAZETTO 26 de setembro de 2019 às 10:55

Queria saber par implementação de mais reles, qual seria aprogramação para esse caso, utilizando mais modulos de dectetor de tensão no projeto.

Responder ao comentário
- Euler Oliveira Autor 26 de setembro de 2019 às 11:21
  
  Olá Luciano.
  
  Agradeço pelo comentário!
  
  O projeto aqui compartilhado serve como base para que o usuário possa aprimorar e inserir outros módulos ou sensores em seu próprio projeto.
  
  Recomendo que leia a documentação do Blynk para entender como ele funciona e como adicionar outros dispositivos ao app:
  
  https://docs.blynk.cc/
  
  Responder ao comentário
adriano osmar de mello 23 de dezembro de 2020 às 16:23

Top o projeto amigo, mas fiquei com uma dúvida, se eu usar 4 reles para acionar 4 lampadas em parelelo, iei precisar tbm de 4 sensores de tensao?

Responder ao comentário
adriano 29 de dezembro de 2020 às 18:45

boa tarde amigo, como faço pra colocar um ldr no lugar do sensor de tensao?

Responder ao comentário

Deixe uma resposta Cancel comment reply