Interruptor de luz wifi inteligente



Bom dia, querido leitor.

Um pouco de letra no começo. A idéia de um interruptor de luz “inteligente” não é nova e, provavelmente, é a primeira coisa que vem à mente daqueles que começaram a conhecer a plataforma Arduino e os elementos de IoT. E eu não sou exceção a isso. Tendo experimentado elementos de circuito, motores e LEDs, quero fazer algo mais aplicado, que é procurado na vida cotidiana e, o mais importante, será conveniente de usar e não será vítima do experimento por uma questão de conforto.

Neste artigo, mostrarei como fiz um comutador que funcionará como um normal (ou seja, geralmente montado em uma parede) e, ao mesmo tempo, permita que ele seja controlado via Wi-Fi (ou via Internet, como é feito neste caso).

Então, vamos fazer uma lista do que será necessário para implementar o plano. Devo dizer imediatamente que pretendia não gastar muito com componentes e escolhi componentes com base no feedback nos fóruns e na relação custo / benefício. Portanto, alguns componentes podem parecer inadequados aqui para amadores elétricos experientes, mas não julgue estritamente, porque Eu sou apenas novo em eletromecânica e gostaria muito de receber comentários de profissionais mais experientes.
Não.NomeDescrição do produtoPreço
1 1HLK-PM01Adaptador de 220VAC para 5VDC4,02 €
2SSR-40DARelé de estado sólido para controle de corrente de circuito3,35 €
3AMS1117-3.3Supressor de tensão de 5V a 3V1,29 €
4ESP8266-01Microcontrolador com WiFi2,35 €
Total:11,01 €

Eu também precisava: de um servidor com o qual o comutador fosse controlado via Internet, o Arduino Uno, com o qual programei o ESP, um roteador e consumíveis como fios, terminais, etc., tudo isso pode variar de gosto e não afetará para o resultado final.

Os preços são retirados do Ebay, onde eu os comprei.

E aqui está a aparência dos elementos da tabela:



Agora você pode criar um diagrama de conexão:



Como você provavelmente notou, o esquema é muito simples. Tudo é montado com facilidade, rapidez e sem solda. Um tipo de protótipo de trabalho, que não precisa ser incomodado por muito tempo. Tudo é conectado por fios e terminais. O único aspecto negativo é que o relé não se encaixou no soquete do interruptor. Sim, inicialmente planejei colocar tudo na parede atrás do interruptor para que parecesse esteticamente agradável. Mas, para meu pesar, não havia espaço suficiente no soquete e o relé simplesmente não se encaixava para cima ou para baixo:



portanto, retirei temporariamente o relé até encontrar uma caixa de interruptores adequada com um soquete para esconder o ferro dentro. Mas não há nada mais permanente que temporário, não é? Portanto, tudo isso agora se parece com isso:



Fita isolante vai economizar choque elétrico ... Espero.

Agora vamos falar sobre a parte do software.

E antes de prosseguir com a análise do código e detalhes, darei um diagrama geral da implementação do controle da lâmpada.



Espero que um dia eu reescreva tudo e a conexão seja baseada em um protocolo mais rápido que o HTTP, mas, para começar, será necessário. Remotamente, a lâmpada muda de estado em cerca de 1 a 1,5 segundos e, a partir da chave instantaneamente, como convém a uma chave decente.

Programação ESP8266-01


A maneira mais fácil de fazer isso é com o Arduino. Você pode baixar as bibliotecas necessárias para o IDE do Arduino no GitHub . Há todas as instruções de instalação e configuração.

Em seguida, precisamos conectar o ESP ao computador, para isso, precisamos de um adaptador USB para serial (como FTDi , CH340 , FT232RL ) ou qualquer plataforma Arduino (eu tinha o Arduino Uno) com saídas RX e TX.

Vale ressaltar que o ESP8266-01 é alimentado por 3,3 Volts, o que significa que, em nenhum caso, não o conecte ao Arduino, que (geralmente) é alimentado por 5 Volts, diretamente caso contrário, tudo irá para o inferno. Você pode usar o redutor de tensão, mostrado na tabela acima.

O esquema de conexão é simples: conectamos TX ,RX e GND ESP para adaptador RX, TX e GND / Arduino, respectivamente. Depois disso, de fato, a conexão está pronta para uso. O microcontrolador pode ser programado usando o Arduino IDE.

Algumas nuances ao usar o Arduino Uno:
  • O Uno possui uma saída para 3.3V, mas não foi suficiente. Quando você conecta um ESP a ele, tudo parece funcionar, os indicadores estão acesos, mas a comunicação com a porta COM é perdida. Então eu usei uma fonte de alimentação diferente de 3.3V para ESP.
  • Além disso, a ONU não teve nenhum problema de comunicação com o ESP, uma vez que o UNO era alimentado por 5V e ESP a partir de 3V.

Após várias experiências com o ESP8266-01, verificou-se que os ESPs são sensíveis a tensões conectadas ao GPIO0 e GPIO2. No momento do lançamento, eles nunca devem ser aterrados se você deseja iniciá-lo no modo normal. Mais detalhes sobre o início do microcontrolador aqui . Eu não sabia disso e tive que mudar um pouco o circuito, porque na versão ESP-01, apenas esses 2 pinos estão presentes e ambos são usados ​​no meu circuito.

E aqui está o programa para o próprio ESP:

Mostrar código
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>
#include <ESP8266HTTPClient.h>
extern "C" { //         initVariant
  #include "user_interface.h"
}

const char* ssid = "WIFISSID"; //  WiFi
const char* password = "***************"; //  WiFi
const String self_token = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; //     
const String serv_token = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; //     
const String name = "IOT_lamp"; //  ,  
const String serverIP = "192.168.1.111"; //  IP WEB  
bool lamp_on =  false;
bool can_toggle = false;
int button_state;

ESP8266WebServer server(80); //  
HTTPClient http; //  

const int lamp = 2; //    GPIO2
const int button = 0; // ""   GPIO0

//    
void handleRoot() { 
  server.send(200, "text/plain", "Hello! I am " + name);
}

//    
void handleNotFound(){
  String message = "not found";
  server.send(404, "text/plain", message);
}

//   
void turnOnLamp(){
  digitalWrite(lamp, LOW);
  lamp_on = true;
}

//   
void turnOffLamp(){
  digitalWrite(lamp, HIGH);
  lamp_on = false;
}

//     ./.
void sendServer(bool state){
  http.begin("http://"+serverIP+"/iapi/setstate");
  String post = "token="+self_token+"&state="+(state?"on":"off"); //         
  http.addHeader("Content-Type", "application/x-www-form-urlencoded");
  int httpCode = http.POST(post);
  http.end();  
}

//   
void toggleLamp(){
  if(lamp_on == true) {
    turnOffLamp();
    sendServer(false);
  } else {
    turnOnLamp();
    sendServer(true);
  }
}

//     
void handleOn(){
  String token = server.arg("token");
  if(serv_token != token) {
    String message = "access denied";
    server.send(401, "text/plain", message);
    return;
  }
  turnOnLamp();
  String message = "success";
  server.send(200, "text/plain", message);
}

//     
void handleOff(){
  String token = server.arg("token");
  if(serv_token != token) {
    String message = "access denied";
    server.send(401, "text/plain", message);
    return;
  }
  turnOffLamp();
  String message = "success";
  server.send(200, "text/plain", message);
}

//  MAC    IP
void initVariant() {
  uint8_t mac[6] = {0x00, 0xA3, 0xA0, 0x1C, 0x8C, 0x45};
  wifi_set_macaddr(STATION_IF, &mac[0]);
}

void setup(void){
  pinMode(lamp, OUTPUT);
  pinMode(button, INPUT_PULLUP); //   INPUT_PULLUP
  turnOffLamp();
  WiFi.hostname(name);
  WiFi.begin(ssid, password);

  //     WiFi
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }

  //    
  server.on("/", handleRoot);
  server.on("/on",  HTTP_POST, handleOn);
  server.on("/off", HTTP_POST, handleOff);
  server.onNotFound(handleNotFound);

  //  
  server.begin();
}

void loop(void){
  server.handleClient();

  //   
  button_state = digitalRead(button);
  if (button_state == HIGH && can_toggle) {
    toggleLamp();
    can_toggle = false;
    delay(500);
  } else if(button_state == LOW){
    can_toggle = true;
  }
}


Alguns comentários sobre o código:
  • É muito importante declarar o pino GPIO0 como pinMode (botão, INPUT_PULLUP ), porque No circuito, não usamos um resistor para este botão. E o ESP tem seu próprio "costurado" para esses mesmos fins.
  • .

WEB


Aqui você pode dar vazão à sua imaginação e usar todos os meios disponíveis para criar um serviço que processará solicitações enviadas pelo comutador e envia solicitações de ativação / desativação.

Eu usei o Yii para esse fim . Eu escolhi essa estrutura por vários motivos, precisava de autorização (já que o portal está disponível na Internet) e gerenciamento de funções (para futuras experiências), e gosto disso. E agora meu portal de gerenciamento fica assim:



Para controlar a lâmpada na zona de alcance da rede, o próprio servidor no ESP seria suficiente. Mas você realmente deseja ter logs, lógica e outros dispositivos no futuro, por isso é melhor ainda usar um servidor separado para gerenciamento.

Isso é tudo sobre o portal, acho que não faz sentido escrever mais sobre ele, mas se você tiver perguntas, terei prazer em respondê-las nos comentários.

Em vez de uma conclusão


Obrigado se você leu o artigo até o final e, talvez, tenha encontrado algo útil nele. Ficarei feliz em receber conselhos e críticas. Em geral, ainda me parece que o gargalo no circuito é o adaptador de 5V e ficarei feliz em compartilhar sua experiência na solução de tais problemas. Quanto ao ESP8266-01, até agora ele não apresentou nenhuma queixa minha, exceto pelo uso especial dos pinos GPIO. Ele está trabalhando de forma estável pela segunda semana. Sucesso nos projetos.

Source: https://habr.com/ru/post/pt393497/


All Articles