Interruptor Wi-Fi para eletrodomésticos com ESP8266
Aprenda como construir seu próprio interruptor Wi-Fi com o módulo ESP e como controlar qualquer aparelho do seu lugar favorito.
O que são switches Wi-Fi?
Hoje em dia vivemos na era da Internet das Coisas, e os interruptores Wi-Fi são a base disso. São dispositivos que podem ligar, desligar ou controlar a intensidade de eletrodomésticos como luzes, ventiladores, etc., remotamente ou de forma autônoma, controlados por nossos celulares, nossa voz, a temperatura ambiente ou até mesmo previsões meteorológicas.
Como eles funcionam?
Eles são baseados em comunicação sem fio (comumente conhecida como Wi-Fi) que lhes permite conectar-se à internet e processar dados, para que possam tomar medidas de acordo com determinadas condições estabelecidas pelo usuário.
Requisitos para a candidatura:
- Módulo ESP8266 (ESP-01)
- placa de circuito impresso
- Placa de ensaio
- Cabos de fiação
- Conta Ubidots
- Arduino nano
1. Esquema:
Materiais:
1 conector fêmea duplo em linha (U3)
1x Triac BTA24
1x Fonte de alimentação Hi-Link 3.3v
PCB: Link para baixar o arquivo Gerber!
Placa de circuito impresso fabricada com PCBGOGO (Indústria de fabricação de PCBs)
2. Criação de dispositivos e variáveis Ubidots .
Acesse a seção Dispositivos 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 widgets Ubidots .
Após criarmos nosso dispositivo e variável, podemos criar um dashboard e um widget para controlar a luz a partir de um dashboard . Para criar um novo dashboard , pressione " Dados > Dashboard ". Em seguida, pressione o ícone de mais (+) e conclua a dashboard conforme desejado.
Agora, crie um widget de controle para definir o estado da lâmpada associada à variável "luz". Para criar o widget de controle, selecione o ícone de mais (+) localizado no canto superior direito da página. Em seguida, clique em "Interruptor" como tipo de widget, selecione a variável que deseja controlar e conclua a configuração do widget conforme desejado.
Então você estará pronto para programar e testar seu projeto.
4. Programação com a IDE do Arduino.
1. Se ainda não o fez, faça o download da IDE do Arduino.
1a. Abra a IDE do Arduino e selecione Arquivo -> Preferências.
1b. Adicione o URL abaixo no "URLs adicionais do Gerenciador de Quadro" . Você pode adicionar vários URLs, separando-os por vírgulas.
http://arduino.esp8266.com/stable/package_esp8266com_index.json
2. Abra e instale a placa ESP8266 no Gerenciador de Placas: Ferramentas -> Placa -> Gerenciador de Placas
2a. Você pode encontrar facilmente a placa digitando “ESP8266” na barra de pesquisa.
3. Agora, selecione a placa Generic ESP8266 no menu Ferramentas -> Placa.
4. Defina ou verifique a porta do seu computador 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 biblioteca Ubidots , caso ainda não a tenha feito. Agora, clique em Sketch –> Incluir Biblioteca –> Adicionar Biblioteca .ZIP e escolha a biblioteca Ubidots
Se o upload for feito corretamente, você receberá a resposta: "Biblioteca adicionada às suas bibliotecas."
8. Feche e abra novamente o Arduino IDE.
Programando o ESP8266:
Após configurar o seu ESP8266, podemos começar a publicar e receber dados do/para o Ubidots para controlar o interruptor Wi-Fi.
1. Copie e cole o seguinte código na IDE do Arduino. Não se esqueça de personalizar o SSID e a senha do Wi-Fi, bem como o seu Ubidots .
/**************************************** * Bibliotecas ****************************************/ #include "UbidotsESPMQTT.h" /**************************************** * Define constantes ****************************************/ #define TOKEN "............................." // Seu TOKEN Ubidots #define WIFINAME "........." // Seu SSID #define WIFIPASS "........." // Sua senha de Wi-Fi #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 às quais o programa irá se inscrever char * variable_labels[NUMBER_OF_VARIABLES] = {"light"}; // Nomes das variáveis #define luz 0 #define botão 2 int seguro=0; int ledState = LOW; // 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; unsigned long lastDebounceTime = 0; // a última vez que o pino de saída foi alternado unsigned long debounceDelay = 50; float estadoluz; // Variável a ser usada no código float value; // Variável para armazenar dados de entrada uint8_t variable; // Para usar com o switch case Ubidots ubiClient(TOKEN); WiFiClient client; /**************************************** * Funções auxiliares ****************************************/ void callback(char* topic, byte* payload, unsigned int length) { char* variable_label = (char *) malloc(sizeof(char) * 30); get_variable_label_topic(topic, variable_label); value = btof(payload, length); set_state(variable_label); execute_cases(); free(variable_label); /////////////////Luz///////////////////// digitalWrite(luz, estadoluz); /////////////////Luz///////////////////// } // Analisa o tópico para extrair o rótulo da variável que mudou de valor void get_variable_label_topic(char * topic, char * variable_label) { Serial.print("tópico:"); Serial.println(topic); sprintf(variable_label, ""); for (int i = 0; i < NUMBER_OF_VARIABLES; i++) { char * result_lv = strstr(topic, variable_labels[i]); if (result_lv != NULL) { uint8_t len = strlen(result_lv); char result[100]; uint8_t i = 0; for (i = 0; i < len - 3; i++) { result[i] = result_lv[i]; } result[i] = '\0'; Serial.print("O rótulo é: "); Serial.println(result); sprintf(variable_label, "%s", result); break; } } } // Converte um array de caracteres para um valor float. float btof(byte * payload, unsigned int length) { char * demo = (char *) malloc(sizeof(char) * 10); for (int i = 0; i < length; i++) { demo[i] = payload[i]; } float value = atof(demo); free(demo); return value; } // Máquina de estados 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 >= NÚMERO_DE_VARIÁVEIS) variável = VALOR_DE_ERRO; // Não é válido } // Função com switch case para determinar qual variável mudou e atribuiu o valor de acordo com a variável de código void executar_casos() { switch (variável) { case 0: estadoluz = valor; Serial.print("Luz: "); Serial.println(estadoluz); Serial.println(); break; case VALOR_DE_ERRO: Serial.println("erro"); Serial.println(); break; default: 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(boton, INPUT); ubiClient.ubidotsSetBroker("ubidots"); // Define o broker corretamente para a conta comercial ubiClient.setDebug(true); // Passe um valor booleano verdadeiro ou falso para ativar as mensagens de depuração Serial.begin(115200); ubiClient.wifiConnection(WIFINAME, WIFIPASS); ubiClient.begin(callback); if(!ubiClient.connected()){ ubiClient.reconnect(); } char* deviceStatus = getUbidotsDevice(DEVICE_LABEL); if (strcmp(deviceStatus, "404") == 0) { ubiClient.add("light", 0); // Insira seus rótulos de variáveis e o valor a ser enviadoubidotsPublish(DEVICE_LABEL); ubiClient.loop(); } ubiClient.ubidotsSubscribe(DEVICE_LABEL,VARIABLE_LABEL1); //Insere 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();ubidotsSubscribe(DEVICE_LABEL,VARIABLE_LABEL1); //Insere os rótulos do dispositivo e da variável } ubiClient.loop(); readit(); debounce(); // salva a leitura. Na próxima iteração do loop, será o lastButtonState: lastButtonState = reading; } void readit(){ // lê o estado do botão em uma variável local: reading = digitalRead(botão); if (reading != lastButtonState) { // reinicia o temporizador de debounce lastDebounceTime = millis(); } } void debounce(){ if ((millis() - lastDebounceTime) > debounceDelay) { // seja qual for a leitura, ela está lá há mais tempo do que o atraso de debounce, // então a considere como o estado atual real: readit2(); } } void readit2(){ // se o estado do botão mudou: if (reading != buttonState) { buttonState = reading; toggle(); } } void toggle(){ // alterna o LED somente se o novo estado do botão for BAIXO if (buttonState == LOW) { ledState = !ledState; // define o LED: digitalWrite(luz, ledState); ubiClient.add("light", ledState); // Insira seus rótulos de variáveis e o valor a ser enviado para o ubiClient.ubidotsPublish(DEVICE_LABEL); } } char* getUbidotsDevice(char* deviceLabel) { char* data = (char *) malloc(sizeof(char) * 700); char* response = (char *) malloc(sizeof(char) * 400); sprintf(data, "GET /api/v1.6/devices/%s/", deviceLabel); sprintf(data, "%s HTTP/1.1\r\n", data); sprintf(data, "%sHost:ubidots\r\nUser-Agent:wifiswitch/1.0\r\n", data); sprintf(data, "%sX-Auth-Token: %s\r\nConnection: close\r\n\r\n", data, TOKEN); free(data); if (client.connect("ubidots", 80)) { client.println(data); } else { free(data); free(response); return "e"; } int timeout = 0; while(!client.available() && timeout < 5000) { timeout++; if (timeout >= 4999){ free(data); free(response); return "e"; } delay(1); } int i = 0; while (client.available()) { response[i++] = (char)client.read(); if (i >= 399){ break; } } char * pch; char * statusCode; int j = 0; pch = strtok (response, " "); while (pch != NULL) { if (j == 1 ) { statusCode = pch; } pch = strtok (NULL, " "); j++; } free(response); return statusCode; }
2. Carregando o código para o ESP8266:
Para carregar o código no 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 porta serial do Arduino, que funciona muito bem.
Para carregar o código no ESP8266, você precisa seguir as conexões abaixo.
| Arduino Nano | ESP8266 |
|---|---|
| TXD | TXD |
| RXD | RXD |
| 3,3V | VCC |
| GND | GND |
| 3,3V | CH_PD |
| GND | GPIO0 |
NOTA: Tenha cuidado com a tensão VCC do ESP8266, ele funciona apenas com uma fonte de alimentação de 3,3 V.
Agora, verifique se o seu código está correto clicando no botão de verificação na IDE do Arduino, acima do editor.
Após a verificação do código, você receberá uma resposta semelhante à abaixo, indicando que a configuração foi feita corretamente.
Em seguida, você precisa carregar o código no seu NodeMCU. Para fazer isso, selecione o ícone de seta para a direita ao lado do ícone de confirmação.
Após o upload do código, você receberá a seguinte mensagem na IDE do Arduino:
5. Configure os comandos de voz usando o Google Assistente:
Para controlar seu " Interruptor Wi-Fi " com o Google Home, primeiro precisamos configurar uma plataforma intermediária chamada IFTTT . Isso nos permitirá emparelhar nosso interruptor com o Google Assistente. Para configurar corretamente, siga os passos abaixo.
Se você não tem uma conta, cadastre-se.
Clique em “Meus Applets”.
Em seguida, clique em “Novo Applet”.
Clique em “ + isto ” para configurar o gatilho da sua condição.
Pesquise pelo serviço "Google Assistant" e clique nele.
Clique em “Diga uma frase simples”.
Preencha os campos de gatilho com as frases que deseja usar para controlar a luz, a resposta e o idioma e, em seguida, clique em “ Criar gatilho ”.
Em seguida, clique em “ +isso ” para configurar a ação.
Procure pelo serviço de ação Webhooks
Clique em “ Fazer uma solicitação web ”.
Preencha os campos de ação:
| Campo | Argumento |
|---|---|
| URL | http://things.ubidots.com/api/v1.6/devices/wifiswitch?token= ubidots vai o seu Ubidots Ubidots ) |
| Método | PUBLICAR |
| Tipo de conteúdo | aplicativo/json |
| Corpo | Para acender {“light”:1}, para apagar {“light”:0} |
Por fim, clique em Concluir.
NOTA: Repita todo o processo para configurar o applet “ Desligar a luz ”, com a Body .
6. Sessão de Teste:
Conforme o diagrama mostrado na imagem, conecte corretamente o módulo ao seu aparelho de corrente alternada.
| Início | Módulo |
|---|---|
| Linha | L |
| Neutro | N |
| Linha de luz' | B |
Adicione um botão momentâneo de sua preferência no bloco de terminais chamado SW.
Identifique os cabos de fase, neutro e luz:
Faça as conexões, coloque o botão, aperte os parafusos e teste.
Caso você seja uma pessoa que aprende melhor visualmente, confira o seguinte tutorial em vídeo. Nele, você encontrará todas as etapas que segui para construir este projeto, explicadas detalhadamente:
Resumo:
Neste guia, aprendemos como construir um interruptor Wi-Fi que pode ser controlado pela internet por voz, aplicativo de celular ou computador, permitindo controlar uma lâmpada no quarto ou em qualquer outro lugar. Este dispositivo funciona com base no módulo Wi-Fi ESP8266, um módulo pequeno que facilita a conexão do projeto à internet. Ele pode ser usado para controlar diversos aparelhos, como ventiladores, motores, cortinas, luzes, fitas de LED e muito mais.
Comece a desenvolver suas soluções IoT com Ubidotshoje mesmo.
