Switch WiFi para eletrodomésticos com ESP8266

Aprenda como construir seu próprio switch WiFi com o módulo ESP e como controlar qualquer eletrodoméstico do seu local preferido.

O que são interruptores WiFi?

Hoje em dia vivemos na era da Internet das Coisas e os switches WiFi são basicamente a base dela. São dispositivos que podem ligar, desligar ou diminuir a intensidade de eletrodomésticos como luzes, ventiladores, etc., de forma remota ou autônoma, controlados por nossos celulares, nossa voz, a temperatura ambiente ou até boletins meteorológicos.

Como eles funcionam?

Baseiam-se em comunicação sem fio (comumente conhecida como WiFi) que permite conectar-se à internet e processar dados, para que possam agir de acordo com determinadas condições estabelecidas pelo usuário.

Requisitos de aplicação:

• Módulo ESP8266 (ESP-01)
• Placa PCB
• Tábua de ensaio
• Cabos de fiação
• Conta Ubidots
• Arduino Nano

1. Esquema:

Materiais:

3x resistores de 1k ohm 1/4w

2x resistores de 470 ohms 1/2w

1x conector fêmea duplo em linha (U3)

1x MOC3010 (Opto-triac)

1x Triac BTA24

1x capacitor 100nf 400v

1 fonte de alimentação Hi-Link 3.3v

1x Bloco Terminal 2p

1x Bloco Terminal 3p

PCB: Link para download do arquivo Gerber!

PCB feito com PCBGOGO (indústria de fabricação de PCB)

2. Dispositivo Ubidots e criação de variáveis.

Vá para a seção Dispositivo da sua Ubidots e crie um novo dispositivo chamado " wifiswitch ".

Dentro do seu dispositivo “ wifiswitch ”, crie uma variável chamada “ light ”.

3. Criação Dashboard e widget Ubidots .

Depois que nosso dispositivo e variável forem criados, podemos criar um dashboard dashboard web ou móvel . Para criar um novo dashboard , pressione o botão “ Dados > Dashboard ”. Em seguida, pressione o ícone de adição e conclua a dashboard conforme desejado.

Agora, crie um widget de controle para definir o status da lâmpada associada à variável “light”. Para criar o widget de controle, selecione o ícone de adição localizado no canto superior direito da página. Em seguida pressione “Switch” conforme tipo de widget, selecione a variável que deseja controlar e complete a configuração do widget conforme desejar.

Então você está pronto para programar e testar seu projeto.

4. Programação com o Arduino IDE.

1. Se ainda não tiver feito isso, baixe o IDE do Arduino.

1a. Abra o Arduino IDE e selecione Arquivos -> Preferências

1b. Adicione o URL abaixo no URLs adicionais do gerente do conselho . Você pode adicionar vários URLs separando-os com vírgulas.

http: //arduino.esp8266.com/stable/package_esp8266com_index.json

2. Abra e instale a placa ESP8266 no Boards Manager: Ferramentas -> Placa -> Boards Manager

2a. Você pode encontrar a placa facilmente digitando “ESP8266” na barra de pesquisa.

3. Agora, selecione a placa ESP8266 genérica no menu Ferramentas -> Placa

4. Defina ou verifique novamente a porta do seu PC com a qual o dispositivo está se comunicando. Vá em Ferramentas -> Porta: -> Selecione a porta

4b. Certifique-se de que a velocidade de upload do seu IDE seja 115200 acessando Ferramentas -> Velocidade de upload -> 115200

5. Baixe a Ubidots ESPMQTT, caso ainda não o tenha feito. Agora clique em Sketch -> Incluir Biblioteca -> Adicionar Biblioteca .ZIP e escolha a Ubidots ESP8266 MQTT

Se carregado corretamente, você receberá a resposta: "Biblioteca adicionada às suas bibliotecas".

8. Feche e abra novamente o Arduino IDE.

Programando o ESP8266:

Assim que seu ESP8266 estiver configurado, podemos começar a publicar e assinar dados de/para Ubidots para controlar o Wifi Switch.
1. Copie e cole o seguinte código no Arduino IDE. Não se esqueça de personalizar o SSID e a senha do Wi-Fi e seu Ubidots .

/************************************* * Bibliotecas ******* *******************************/ #include " Ubidots ESPMQTT.h" /******* ********************************* * Definir constantes ************** **************************/ #define TOKEN "................... .........." // Seu TOKEN Ubidots #define WIFINAME "........." //Seu SSID #define WIFIPASS "........." // Seu Wifi Pass #define DEVICE_LABEL "wifiswitch" // Nome do dispositivo #define VARIABLE_LABEL1 "light" // Nome da variável Ubidots const int ERROR_VALUE = 65535; // Valor do erro const uint8_t NUMBER_OF_VARIABLES = 2; // Quantidade de variáveis ​​​​até que o programa foi inscrito char * variable_labels[NUMBER_OF_VARIABLES] = {"light"}; // Nomes das variáveis ​​#define luz 0 #define boton 2 int seguro=0; int ledState = BAIXO; // o estado atual do pino de saída int buttonState; // a leitura atual do pino de entrada int lastButtonState = HIGH; // a leitura anterior do pino de entrada int reading; não assinado longo lastDebounceTime = 0; // a última vez que o pino de saída foi alternado unsigned long debounceDelay = 50; flutuador estadoluz; // Variável a ser utilizada no código float value; // Variável para armazenar dados de entrada uint8_t variável; // Para usar com o switch case Ubidots ubiClient(TOKEN); Cliente WiFiClient; /************************************** * Funções auxiliares ****** **********************************/ void callback(char* topic, byte* payload, unsigned int length) { char* rótulo_variável = (char *) malloc(sizeof(char) * 30); get_variable_label_topic(tópico, variável_label); valor = btof(carga útil, comprimento); set_state(rótulo_variável); execute_cases(); grátis(rótulo_variável); ////////////////Light /////////////////// digitalWrite(luz, estadoluz); /////////////////Light /////////////////// } // Analisar tópico para extrair o rótulo da variável que mudou valor void get_variable_label_topic(char * tópico, char * variável_label) { Serial.print("tópico:"); Serial.println(tópico); sprintf(rótulo_variável, ""); for (int i = 0; i < NUMBER_OF_VARIABLES; i++) { char * result_lv = strstr(tópico, rótulos_variáveis[i]); if (resultado_lv! = NULO) {uint8_t len ​​= strlen(resultado_lv); resultado de caractere[100]; uint8_t i = 0; for (i = 0; i < len - 3; i++) { resultado[i] = resultado_lv[i]; } resultado[i] = '\0'; Serial.print("O rótulo é: "); Serial.println(resultado); sprintf(rótulo_variável, "%s", resultado); quebrar; } } } // converte de um array de caracteres para um valor flutuante. float btof(byte * carga útil, comprimento int não assinado) { char * demo = (char *) malloc(sizeof(char) * 10); for (int i = 0; i < comprimento; i++) { demo[i] = carga útil[i]; } valor flutuante = atof(demonstração); grátis(demonstração); valor de retorno; } // Máquina de estado para usar switch case void set_state(char* variable_label) { variable = 0; for (uint8_t i = 0; i < NUMBER_OF_VARIABLES; i++) { if (strcmp(variable_label, variable_labels[i]) == 0) { break; } variável++; } if (variável >= NUMBER_OF_VARIABLES) variável = ERROR_VALUE; // Não é válido } // Função com switch case para determinar qual variável foi alterada e atribuído o valor de acordo com o código variável void execute_cases() { switch (variável) { case 0: estadoluz = valor; Serial.print("Luz: "); Serial.println(estadoluz); Serial.println(); quebrar; caso ERROR_VALUE: Serial.println("erro"); Serial.println(); quebrar; padrão: Serial.println("padrão"); Serial.println(); } } /****************************************** * Função principal **** ************************************/ void setup() { // coloque seu código de configuração aqui, para executar uma vez: pinMode(luz, OUTPUT); pinMode(botão, INPUT); ubiCliente. ubidots SetBroker("industrial.api. ubidots .com"); // Define o corretor corretamente para a conta comercial ubiClient.setDebug(true); // Passa um valor bool verdadeiro ou falso para ativar mensagens de depuração Serial.begin(115200); ubiClient.wifiConnection(WIFINAME, WIFIPASS); ubiClient.begin(retorno de chamada); if(!ubiClient.connected()){ ubiClient.reconnect(); } char* deviceStatus = obter dispositivo Ubidots (DEVICE_LABEL); if (strcmp(deviceStatus, "404") == 0) { ubiClient.add("light", 0); //Insira sua variável Labels e o valor a ser enviado ubiClient. Publicação ubidots (DEVICE_LABEL); ubiClient.loop(); } ubiCliente. ubidots Assinar(DEVICE_LABEL,VARIABLE_LABEL1); //Inserir os rótulos do dispositivo e da variável Serial.println(variable_labels[1]); } void loop() { // coloque seu código principal aqui, para ser executado repetidamente: if(!ubiClient.connected()){ ubiClient.reconnect(); ubiCliente. ubidots Assinar(DEVICE_LABEL,VARIABLE_LABEL1); //Inserir os rótulos do dispositivo e da variável } ubiClient.loop(); leia(); debounce(); //salva a leitura. Na próxima vez no loop, será lastButtonState: lastButtonState = reading; } void readit(){ // lê o estado do switch em uma variável local: reading = digitalRead(boton); if (reading != lastButtonState) { // zera o temporizador de rebote lastDebounceTime = millis(); } } void debounce(){ if ((millis() - lastDebounceTime) > debounceDelay) { // qualquer que seja a leitura, ela está lá há mais tempo que o // atraso de debounce, então tome-a como o estado atual real: readit2 (); } } void readit2(){ // se o estado do botão mudou: if (reading != buttonState) { buttonState = reading; alternar(); } } void toggle(){ // só alterna o LED se o novo estado do botão for LOW if (buttonState == LOW) { ledState = !ledState; // configura o LED: digitalWrite(luz, ledState); ubiClient.add("luz", ledState); //Insira sua variável Labels e o valor a ser enviado ubiClient. Publicação ubidots (DEVICE_LABEL); } } char* obter dispositivo Ubidots (char* deviceLabel) { char* dados = (char *) malloc(sizeof(char) * 700); char* resposta = (char *) malloc(sizeof(char) * 400); sprintf(dados, "GET /api/v1.6/devices/%s/", deviceLabel); sprintf(dados, "%s HTTP/1.1\r\n", dados); sprintf(dados, "%sHost: industrial.api. ubidots .com\r\nUser-Agent:wifiswitch/1.0\r\n", dados); sprintf(dados, "%sX-Auth-Token: %s\r\nConexão: fechamento\r\n\r\n", dados, TOKEN); grátis(dados); if (client.connect("industrial.api. ubidots .com", 80)) { client.println(dados); } else { grátis(dados); grátis(resposta); retorne "e"; } int tempo limite = 0; while(!client.available() && tempo limite < 5000) { tempo limite++; if (tempo limite >= 4999){ grátis(dados); grátis(resposta); retorne "e"; } atraso(1); } int i = 0; while (client.available()) { resposta[i++] = (char)client.read(); if (i >= 399){ quebra; } } char * pch; char * código de status; int j = 0; pch = strtok (resposta, " "); while (pch!= NULL) { if (j == 1 ) { statusCode = pch; } pch = strtok(NULL, " "); j++; } grátis(resposta); retornar statusCode; }

2. Carregando o código para o ESP8266:

Para fazer o upload do código para o ESP8266 precisamos de uma interface serial para comunicar (Programador) o módulo com o PC, podemos usar conversores USB para TTL, mas neste caso vamos usar a serial do Arduino que faz um trabalho muito bom trabalho.

Para fazer upload do código no ESP8266 você deve seguir as conexões abaixo.

NOTA: Tenha cuidado com o VCC do ESP8266, ele funciona apenas com alimentação de 3,3V.

Agora, verifique se seu código está correto clicando no botão de verificação no IDE do Arduino acima do editor.

Assim que o código for verificado, você receberá uma resposta semelhante à abaixo, indicando que ele está configurado corretamente.

Em seguida, você deve fazer upload do código em seu NodeMCU. Para fazer isso, escolha o ícone de seta para a direita ao lado do ícone de verificação.

Assim que o código for carregado, você receberá a mensagem abaixo no Arduino IDE:

5. Configure comandos de voz usando o Google Assistant:

Para controlar o seu “ WiFi Switch ” com o Google Home, primeiro precisamos configurar uma plataforma intermediária chamada IFTTT , isso nos permitirá emparelhar nosso Switch com o Google Assistant. Para configurar corretamente, siga os passos mostrados abaixo.

Se você não tem uma conta, cadastre-se.

Clique em “Meus miniaplicativos”.

Em seguida, clique em “Novo miniaplicativo”.

Clique em “ + isto ” para configurar o gatilho da sua condição.

Procure o serviço “Google Assistant” e clique nele.

Clique em “Diga uma frase simples”.

Preencha os campos do gatilho com as frases que deseja usar para controlar a luz, a resposta e o idioma e clique em “ Criar gatilho ”.

Em seguida, clique em “ +that ” para configurar a ação.

Procure o serviço de ação “ Webhooks ”.

Clique em “ Fazer uma solicitação web ”.

Campos de ação completos:

Por fim, clique em Concluir.

NOTA: Repita tudo para configurar o miniaplicativo “ Desligar a luz ”, com a instrução Body

6. Sessão de teste:

Devido ao diagrama mostrado na imagem, conecte corretamente o módulo ao seu aparelho AC.

Adicione um botão momentâneo de sua preferência no bloco de terminais chamado SW.

Identifique os cabos de Linha, Neutro e Luz:

Faça as conexões e coloque o botão, aperte os parafusos e teste.

Caso você seja um aprendiz visual, confira o seguinte tutorial em vídeo. Você pode encontrar todas as etapas que executei para construir este projeto cuidadosamente explicadas:

Resumo:

Neste guia, acabamos de aprender como construir um switch WiFi que pode ser controlado pela internet pela sua voz, aplicativo do celular ou PC, que permite controlar a lâmpada de um quarto ou de qualquer outro lugar. Este dispositivo funciona baseado no módulo WiFi ESP8266, que é um pequeno módulo que permite que o projeto fique online facilmente. E este dispositivo pode ser aplicado no controle de diversos dispositivos como ventiladores, motores, cortinas, luzes, fitas de led e muito mais.

Comece a desenvolver suas soluções IoT com Ubidots hoje mesmo.