Switch WiFi para electrodomésticos con ESP8266

Aprende cómo construir tu propio interruptor WiFi con el módulo ESP y cómo controlar cualquier electrodoméstico de tu lugar favorito.

¿Qué son los conmutadores WiFi?

Hoy en día vivimos en la era del Internet de las cosas y los conmutadores WiFi son básicamente su base. Son dispositivos que pueden encender, apagar o atenuar electrodomésticos como luces, ventiladores, etc. de forma remota o autónoma, controlados por nuestro móvil, nuestra voz, la temperatura ambiente o incluso los informes meteorológicos.

¿Cómo funcionan?

Se basan en una comunicación inalámbrica (comúnmente conocida como WiFi) que les permite conectarse a Internet y procesar datos, para poder actuar ante determinadas condiciones establecidas por el usuario.

Requisitos de solicitud:

• Módulo ESP8266 (ESP-01)
• placa PCB
• Tablero de circuitos
• cables de cableado
• Cuenta Ubidots
• arduino nano

1. Esquema:

Materiales:

3x resistencias de 1k ohmios 1/4w

2x resistencias de 470 ohmios 1/2w

1 conector hembra doble en línea (U3)

1x MOC3010 (Opto-triac)

1x Triac BTA24

1 condensador de 100 nf y 400 V.

1 fuente de alimentación Hi-Link de 3,3 V.

1x bloque de terminales 2p

1x bloque de terminales 3p

PCB: ¡Enlace para descargar el archivo Gerber!

PCB fabricado con PCBGOGO (Industria de fabricación de PCB)

2. Dispositivo Ubidots y creación de variables.

Vaya a la sección Dispositivo de su Ubidots y cree un nuevo dispositivo llamado " wifiswitch ".

Dentro de tu dispositivo " wifiswitch ", crea una variable llamada " luz ".

3. Creación de widgets y Dashboard Ubidots .

Una vez creados nuestro dispositivo y variable, podemos crear un dashboard y un widget para controlar la luz desde un dashboard . Para crear un nuevo dashboard , presione " Datos > Dashboard ". Luego presione el ícono más y complete la dashboard como desee.

Ahora, cree un widget de control para establecer el estado de la bombilla asociada con la variable "luz". Para crear el widget de control, seleccione el ícono más ubicado en la parte superior derecha de la página. Luego presione "Cambiar" como tipo de widget, seleccione la variable que desea controlar y complete la configuración del widget como desee.

Entonces estará listo para programar y probar su proyecto.

4. Programación con el IDE de Arduino.

1. Si aún no lo has hecho, descarga el IDE de Arduino.

1a. Abra el IDE de Arduino y seleccione Archivos -> Preferencias

1b. Agregue la siguiente URL en el URL adicionales del administrador de tableros . Puede agregar varias URL separándolas con comas.

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

2. Abra e instale la placa ESP8266 en el Administrador de placas: Herramientas -> Placa -> Administrador de placas

2a. Puede encontrar fácilmente el tablero escribiendo "ESP8266" en la barra de búsqueda.

3. Ahora, seleccione la placa genérica ESP8266 en el menú Herramientas -> Placa

4. Defina o verifique nuevamente el puerto de su PC con el que se comunica el dispositivo. Vaya a Herramientas -> Puerto: -> Seleccione el puerto

4b. Asegúrese de que la velocidad de carga de su IDE sea 115200 yendo a Herramientas -> Velocidad de carga -> 115200

5. Descargue la biblioteca Ubidots si aún no lo ha hecho. Ahora, haga clic en Sketch -> Incluir biblioteca -> Agregar biblioteca .ZIP y elija la Ubidots ESP8266 MQTT

Si se carga correctamente, obtendrá la respuesta: "Biblioteca agregada a sus bibliotecas".

8. Cierra y abre nuevamente el IDE de Arduino.

Programando el ESP8266:

Una vez que su ESP8266 esté configurado, podemos comenzar a publicar y suscribir datos desde/hacia Ubidots para controlar el conmutador Wifi.
1. Copie y pegue el siguiente código en el IDE de Arduino. No olvides personalizar el SSID y la contraseña de Wi-Fi y tu Ubidots .

/*************************************** * Bibliotecas ******* ********************************/ #include " Ubidots ESPMQTT.h" /******* ********************************** * Definir constantes ************** **************************/ #definir TOKEN "................. .........." // Tu TOKEN Ubidots #define WIFINAME "........." //Tu SSID #define WIFIPASS "........." // Tu pase Wifi #define DEVICE_LABEL "wifiswitch" // Nombre del dispositivo #define VARIABLE_LABEL1 "light" // Nombre de la variable Ubidots const int ERROR_VALUE = 65535; // Valor de error const uint8_t NUMBER_OF_VARIABLES = 2; // Cantidad de variables a las que el programa se va a suscribir char * variable_labels[NUMBER_OF_VARIABLES] = {"light"}; // Nombres de las variables #define luz 0 #define boton 2 int seguro=0; int ledState = BAJO; // el estado actual del pin de salida int buttonState; // la lectura actual del pin de entrada int lastButtonState = HIGH; // la lectura anterior del pin de entrada int Reading; último tiempo de rebote largo sin firmar = 0; // la última vez que se activó el pin de salida unsigned long debounceDelay = 50; flotador estadoluz; // Variable que se utilizará en el código valor flotante; // Variable para almacenar datos de entrada uint8_t variable; // Para usar con el caso de cambio Ubidots ubiClient(TOKEN); Cliente WiFiClient; /**************************************** * Funciones auxiliares ****** ********************************/ devolución de llamada nula (tema char*, carga útil byte*, longitud int sin signo) { char* variable_label = (char *) malloc(sizeof(char) * 30); get_variable_label_topic(tema, variable_label); valor = btof(carga útil, longitud); set_state(variable_label); ejecutar_casos(); gratis(etiqueta_variable); /////////////////Luz//////////////////// digitalWrite(luz, estadoluz); /////////////////Light//////////////////// } // Analizar el tema para extraer la etiqueta de la variable que cambió valor void get_variable_label_topic(char * tema, char * variable_label) { Serial.print("tema:"); Serial.println(tema); sprintf(variable_label, ""); for (int i = 0; i < NÚMERO_DE_VARIABLES; i++) { char * result_lv = strstr(tema, variables_labels[i]); if (result_lv != NULL) { uint8_t len ​​= strlen(result_lv); resultado de carácter carbónico[100]; uint8_t yo = 0; for (i = 0; i < len - 3; i++) { resultado[i] = resultado_lv[i]; } resultado[i] = '\0'; Serial.print("La etiqueta es: "); Serial.println(resultado); sprintf(variable_label, "%s", resultado); romper; } } } // conversión desde una matriz de caracteres a valor flotante. float btof(byte * carga útil, longitud int sin signo) { char * demo = (char *) malloc(sizeof(char) * 10); for (int i = 0; i < longitud; i++) { demostración[i] = carga útil[i]; } valor flotante = atof(demostración); gratis (demostración); 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 < NÚMERO_DE_VARIABLES; i++) { if (strcmp(variable_label, variable_labels[i]) == 0) { break; } variables++; } if (variable >= NUMBER_OF_VARIABLES) variable = ERROR_VALUE; // No válido } // Función con switch case para determinar qué variable cambió y asignó el valor de acuerdo a la variable de código void ejecutar_cases() { switch (variable) { case 0: estadoluz = valor; Serial.print("Luz: "); Serial.println(estadoluz); Serie.println(); romper; caso ERROR_VALUE: Serial.println("error"); Serie.println(); romper; predeterminado: Serial.println("predeterminado"); Serie.println(); } } /**************************************** * Función principal **** ***********************************/ void setup() { // pon tu código de configuración aquí, para ejecutar una vez: pinMode(luz, SALIDA); pinMode(botón, ENTRADA); ubiCliente. ubidots SetBroker(" ubidots "); // Configura el corredor correctamente para la cuenta comercial ubiClient.setDebug(true); // Pasa un valor bool verdadero o falso para activar los mensajes de depuración Serial.begin(115200); ubiClient.wifiConnection(WIFINAME, WIFIPASS); ubiClient.begin(devolución de llamada); if(!ubiClient.connected()){ ubiClient.reconnect(); } char* estado del dispositivo = obtener dispositivo Ubidots (DEVICE_LABEL); if (strcmp(deviceStatus, "404") == 0) { ubiClient.add("light", 0); //Inserta las etiquetas de tus variables y el valor que se enviará a ubiClient. Publicación ubidots (DEVICE_LABEL); ubiClient.loop(); } ubiCliente. ubidots Suscribirse(DEVICE_LABEL,VARIABLE_LABEL1); //Inserte las etiquetas del dispositivo y de la variable Serial.println(variable_labels[1]); } void loop() { // coloca tu código principal aquí, para ejecutarlo repetidamente: if(!ubiClient.connected()){ ubiClient.reconnect(); ubiCliente. ubidots Suscribirse(DEVICE_LABEL,VARIABLE_LABEL1); //Inserte las etiquetas del dispositivo y de la variable } ubiClient.loop(); leer(); rebote(); // guarda la lectura. La próxima vez que pase por el bucle, será lastButtonState: lastButtonState = Reading; } void readit(){ // lee el estado del conmutador en una variable local: lectura = digitalRead(boton); if (reading != lastButtonState) { // restablecer el temporizador antirrebote lastDebounceTime = millis(); } } void debounce(){ if ((millis() - lastDebounceTime) > debounceDelay) { // cualquiera que sea la lectura, ha estado ahí por más tiempo que el // retraso del rebote, así que tómalo como el estado actual real: readit2 (); } } void readit2(){ // si el estado del botón ha cambiado: if (lectura! = estado del botón) { estado del botón = lectura; palanca(); } } void toggle(){ // solo alterna el LED si el nuevo estado del botón es BAJO if (buttonState == BAJO) { ledState = !ledState; // configura el LED: digitalWrite(luz, ledState); ubiClient.add("luz", ledState); //Inserta las etiquetas de tus variables y el valor que se enviará a ubiClient. Publicación ubidots (DEVICE_LABEL); } } char* obtener Dispositivo Ubidots (char* etiquetadeldispositivo) { char* datos = (char *) malloc(sizeof(char) * 700); char* respuesta = (char *) malloc(sizeof(char) * 400); sprintf(datos, "GET /api/v1.6/devices/%s/", deviceLabel); sprintf(datos, "%s HTTP/1.1\r\n", datos); sprintf(datos, "%sHost: industrial.api. ubidots .com\r\nUser-Agent:wifiswitch/1.0\r\n", datos); sprintf(datos, "%sX-Auth-Token: %s\r\nConexión: cerrar\r\n\r\n", datos, TOKEN); gratis(datos); if (cliente.connect("industrial.api. ubidots .com", 80)) { cliente.println(datos); } más { gratis(datos); gratis(respuesta); devolver "e"; } int tiempo de espera = 0; while(!client.available() && tiempo de espera < 5000) { tiempo de espera++; if (tiempo de espera >= 4999){ gratis(datos); gratis(respuesta); devolver "e"; } retraso(1); }intyo = 0; while (cliente.disponible()) { respuesta[i++] = (char)cliente.read(); si (i >= 399){ descanso; } } char * pch; char * código de estado; int j = 0; pch = strtok (respuesta, " "); while (pch! = NULL) { if (j == 1) { código de estado = pch; } pch = strtok (NULL, " "); j++; } gratis(respuesta); devolver código de estado; }

2. Subiendo el código al ESP8266:

Para cargar el código al ESP8266 necesitamos una interfaz serial para comunicar (Programador) el módulo con la PC, podemos usar conversores USB a TTL, pero en este caso vamos a usar el serial del Arduino que hace un buen trabajo.

Para cargar el código en el ESP8266, debe seguir las conexiones a continuación.

NOTA: Tenga cuidado con el VCC del ESP8266, solo funciona con una fuente de 3.3V.

Ahora, verifique que su código sea correcto haciendo clic en el botón de verificación en el IDE de Arduino encima del editor.

Una vez verificado el código, recibirá una respuesta similar a la siguiente, indicando que está configurado correctamente.

A continuación, debes cargar el código en tu NodeMCU. Para hacer esto, elija el ícono de flecha hacia la derecha al lado del ícono de verificación.

Una vez cargado el código, recibirá el siguiente mensaje en el IDE de Arduino:

5. Configure los comandos de voz con el Asistente de Google:

Para controlar tu “ WiFi Switch ” con Google Home, primero necesitamos configurar una plataforma intermediaria llamada IFTTT , esto nos permitirá emparejar nuestro Switch con el Asistente de Google. Para configurarlo correctamente, siga los pasos que se muestran a continuación.

Si no tienes una cuenta, Regístrate.

Haga clic en "Mis subprogramas".

Luego, haga clic en "Nuevo subprograma".

Haga clic en " + esto " para configurar el desencadenante de su condición.

Busque el servicio "Asistente de Google" y haga clic en él.

Haz clic en “Di una frase sencilla”.

Complete los campos del disparador con las frases que desea usar para controlar la luz, la respuesta y el idioma, luego haga clic en “ Crear disparador ”.

Luego, haz clic en “ +eso ” para configurar la acción.

Busque el servicio de acciones “ Webhooks ”.

Pulsa en “ Realizar una solicitud web ”.

Campos de acción completos:

Finalmente, haga clic en Finalizar.

NOTA: Repita todo para configurar el subprograma " Apagar la luz de cuerpo correcta .

6. Sesión de prueba:

Debido al diagrama que se muestra en la imagen, conecte correctamente el módulo a su aparato de CA.

Agrega un botón momentáneo de tu preferencia en la regleta llamado SW.

Identifique los cables de Línea, Neutro y Luz:

Realizar las conexiones y colocar el botón, apretar los tornillos y probar.

En caso de que seas un aprendiz visual, mira el siguiente video tutorial. Puede encontrar todos los pasos que seguí para construir este proyecto explicados cuidadosamente:

Resumen:

En esta guía, acabamos de aprender cómo construir un interruptor WiFi que se puede controlar a través de Internet mediante la voz, la aplicación del teléfono celular o la PC, y que le permite controlar una bombilla de un dormitorio o de cualquier otro lugar. Este dispositivo funciona según el módulo WiFi ESP8266, que es un módulo pequeño que permite que el proyecto se conecte fácilmente. Y este dispositivo se puede aplicar al control de muchos dispositivos diferentes, como ventiladores, motores, cortinas, luces, tiras de LED y mucho más.

Comience a desarrollar sus soluciones IoT con Ubidots hoy.