Interruptor de luz wifi inteligente



Buen día, querido lector.

Un poco de letra al principio. La idea de un interruptor de luz "inteligente" no es nueva en absoluto y, probablemente, esto es lo primero que se les ocurre a aquellos que comenzaron a conocer la plataforma Arduino y los elementos de IoT. Y no soy una excepción a esto. Después de experimentar con elementos de circuito, motores y LED, quiero hacer algo más aplicado, que se exige en la vida cotidiana y, lo que es más importante, será conveniente de usar y no seguirá siendo una víctima del experimento en aras de la comodidad.

En este artículo, le contaré cómo hice un interruptor que funcionará como uno normal (es decir, que generalmente está montado en una pared) y al mismo tiempo permitirá que se controle a través de WiFi (o Internet, como se hace en este caso).

Entonces, haremos una lista de lo que se necesitará para implementar el plan. Debo decir de inmediato que tenía la intención de no derrochar mucho en los componentes y elegir componentes basados ​​en los comentarios de los foros y la relación calidad-precio. Por lo tanto, algunos componentes pueden parecer inapropiados aquí para aficionados eléctricos experimentados, pero no juzgue estrictamente, porque Solo soy nuevo en electromecánica y agradecería mucho los comentarios de profesionales más experimentados.
NoNombreDescripciónPrecio
1HLK-PM01Adaptador de 220VAC a 5VDC4,02 €
2SSR-40DARelé de estado sólido para control de corriente de circuito3,35 €
3AMS1117-3.3Supresor de voltaje de 5V a 3V1,29 €
4 4ESP8266-01Microcontrolador con WiFi2,35 €
Total:11,01 €

También necesitaba: un servidor con el que el interruptor se controlará a través de Internet, Arduino Uno, con el que programé ESP, un enrutador y consumibles como cables, terminales, etc., todo esto puede variar según el gusto y no afectará hasta el resultado final.

Los precios se toman de Ebay, donde los compré.

Y así es como se ven los elementos de la tabla:



ahora puede dibujar un diagrama de conexión:



Como probablemente haya notado, el esquema es muy simple. Todo se ensambla fácilmente, rápidamente y sin soldaduras. Una especie de prototipo funcional, que no necesita ser molestado por mucho tiempo. Todo está conectado por cables y terminales. Lo único negativo es que el relé no encaja en el zócalo del interruptor. Sí, inicialmente planeé meterlo todo en la pared detrás del interruptor para que se viera estéticamente agradable. Pero para mi pesar, no había suficiente espacio en el zócalo y el relé simplemente no encajaba ni de lado ni al otro lado: por lo



tanto, temporalmente saqué el relé del zócalo hasta que encontré una caja de interruptores adecuada con un zócalo para ocultar la plancha dentro. Pero no hay nada más permanente que temporal, ¿no? Por lo tanto, todo esto ahora se ve así: la



cinta aislante evitará una descarga eléctrica ... espero.

Ahora hablemos de la parte del software.

Y antes de continuar con el análisis del código y los detalles, daré un diagrama general de la implementación del control de la lámpara.



Espero que algún día reescriba todo y la conexión se base en un protocolo más rápido que HTTP, pero para empezar lo hará. De forma remota, la bombilla cambia su estado en aproximadamente 1-1.5 segundos, y desde el interruptor al instante, como corresponde a un interruptor decente.

Programación ESP8266-01


La forma más fácil de hacer esto es con Arduino. Puede descargar las bibliotecas necesarias para Arduino IDE desde GitHub . Hay todas las instrucciones de instalación y configuración.

Luego, necesitamos conectar el ESP a la computadora, para esto necesitamos un adaptador USB a serie (como FTDi , CH340 , FT232RL ) o cualquier plataforma Arduino (tenía Arduino Uno) con salidas RX y TX.

Vale la pena señalar que el ESP8266-01 está alimentado por 3.3 voltios, lo que significa que en ningún caso no lo conecte al Arduino, que (a menudo) está alimentado por 5 voltios, directamente de lo contrario todo se irá al infierno. Puede usar el reductor de voltaje, que se muestra en la tabla anterior.

El esquema de conexión es simple: conectamos TX ,Adaptador RX y GND ESP a RX, TX y GND / Arduino respectivamente. Después de eso, de hecho, la conexión está lista para usar. El microcontrolador se puede programar utilizando el IDE de Arduino.

Un par de matices al usar Arduino Uno:
  • Uno tiene una salida de 3.3V, pero no fue suficiente. Cuando conecta un ESP a él, todo parece funcionar, los indicadores están encendidos, pero se pierde la comunicación con el puerto COM. Así que usé una fuente de alimentación de 3.3V diferente para ESP.
  • Además, UNO no tuvo problemas para comunicarse con ESP, dado que UNO funcionaba con 5V y ESP de 3V.

Después de varios experimentos con ESP8266-01, resultó que los ESP son sensibles a los voltajes conectados a GPIO0 y GPIO2. En el momento del lanzamiento, en ningún caso deben estar conectados a tierra si tiene la intención de iniciarlo en modo normal. Más detalles sobre el inicio del microcontrolador aquí . No sabía esto y tuve que cambiar ligeramente el circuito, porque en la versión ESP-01, solo estos 2 pines están presentes y ambos se usan en mi circuito.

Y aquí está el programa para ESP en sí:

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;
  }
}


Un par de comentarios sobre el código:
  • Es muy importante declarar el pin GPIO0 como pinMode (botón, INPUT_PULLUP ), porque En el circuito no usamos una resistencia para este botón. Y ESP tiene su propio "cosido" para estos mismos propósitos.
  • .

WEB


Aquí puede dar rienda suelta a su imaginación y utilizar cualquier medio disponible para crear un servicio que procesará las solicitudes enviadas por el conmutador y enviará solicitudes para activar / desactivar. Usé Yii

para este propósito . Elegí este marco por varias razones, necesitaba autorización (ya que el portal está disponible en Internet) y gestión de roles (para futuros experimentos), y simplemente me gusta. Y ahora mi portal de administración se ve así: para controlar la bombilla en la zona de alcance de la red, el servidor en sí en el ESP sería suficiente. Pero realmente desea tener registros, lógica y otros dispositivos en el futuro, por lo que es mejor utilizar un servidor separado para la administración.





Esto es todo sobre el portal, creo que no tiene sentido escribir más sobre él, pero si tiene preguntas, con gusto las responderé en los comentarios.

En lugar de una conclusión


Gracias si leyó el artículo hasta el final y, tal vez, encontró algo útil para usted en él. Estaré encantado de consejos y críticas. En general, todavía me parece que el cuello de botella en el circuito es el adaptador de 5V y me alegrará si comparte su experiencia en la solución de tales problemas. En cuanto al ESP8266-01, hasta ahora no ha presentado ninguna queja de mí, excepto por el uso especial de los pines GPIO. Ha estado trabajando de manera estable durante la segunda semana. Éxito en los proyectos.

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


All Articles