En el código, logicamente, deben modificar las variables correspondientes al nombre y clave de la red "WifiNaylamp" y "123456789", por los que cada cual tenga disponibles.#include <ESP8266WiFi.h> const char* ssid = "WifiNaylamp"; const char* password = "123456789"; WiFiServer server(80); void setup() { Serial.begin(9600); delay(10); //Configuración del GPIO2 pinMode(2, OUTPUT); digitalWrite(2,LOW); Serial.println(); Serial.println(); Serial.print("Conectandose a red : "); Serial.println(ssid); WiFi.begin(ssid, password); //Conexión a la red while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.println("WiFi conectado"); server.begin(); //Iniciamos el servidor Serial.println("Servidor Iniciado"); Serial.println("Ingrese desde un navegador web usando la siguiente IP:"); Serial.println(WiFi.localIP()); //Obtenemos la IP } void loop() { WiFiClient client = server.available(); if (client) //Si hay un cliente presente { Serial.println("Nuevo Cliente"); //esperamos hasta que hayan datos disponibles while(!client.available()&&client.connected()) { delay(1); } // Leemos la primera línea de la petición del cliente. String linea1 = client.readStringUntil('r'); Serial.println(linea1); if (linea1.indexOf("LED=ON")>0) //Buscamos un LED=ON en la 1°Linea { digitalWrite(2,HIGH); } if (linea1.indexOf("LED=OFF")>0)//Buscamos un LED=OFF en la 1°Linea { digitalWrite(2,LOW); } client.flush(); Serial.println("Enviando respuesta..."); //Encabesado http client.println("HTTP/1.1 200 OK"); client.println("Content-Type: text/html"); client.println("Connection: close");// La conexión se cierra después de finalizar de la respuesta client.println(); //Pagina html para en el navegador client.println("<!DOCTYPE HTML>"); client.println("<html>"); client.println("<head><title>Naylam Mechatronics</title>"); client.println("<body>"); client.println("<h1 align='center'>Test ESP8266</h1>"); client.println("<div style='text-align:center;'>"); client.println("<br />"); client.println("<button onClick=location.href='./?LED=ON'>LED ON</button>"); client.println("<button onClick=location.href='./?LED=OFF'>LED OFF</button>"); client.println("<br />"); client.println("</div>"); client.println("</body>"); client.println("</html>"); delay(1); Serial.println("respuesta enviada"); Serial.println(); } }
Nota importante: cuando utilizamos la comunicación Wifi la placa ESP32Plus STEAMakers deshabilita internamente el ADC2, por lo que no funcionan las entradas A0 (potenciómetro) y A1 (LDR) como entradas analógicas. Si queremos conectar en la Imagina TDR STEAM un sensor analógico más lo deberemos conectar en A3.
1. WiFi/IoT.
o HTTP Cliente.o HTTP Servidor.o MQTT Cliente.o Blynk App.
2. WiFi-Mesh
Con nuestra tarjeta ESP32 Plus STEAMakers solamente podemos conectarnos a redes de 2.4GHz y no nos podemos conectar a las nuevas redes de 5GHZ.
Tenemos diferentes bloques para poder trabajar con redes Wifi:
1. Conectarse a una red Wifi como cliente (modo cliente/estación): esta opción es la más habitual. Con este bloque conectamos la placa ESP32 Plus STEAMakers a una red Wifi existente. Para ello necesitamos el nombre de la red Wifi (SSID) y la clave (WEP, WPA, etc.).
Por defecto, una vez conectados a la red obtendremos la configuración de red (IP, puerta de enlace, etc.) de forma automática (suponiendo que hay un router que lo hace de forma correcta en nuestra red). Si todo es correcto, tendremos acceso a nuestra red WLAN y conexión a internet a través del router.
Este es el caso más simple (y el más habitual). Después de este bloque ya podremos usar cualquiera de los servicios explicados más adelante (Blynk, MQTT, etc.).
2. Crear una red Wifi propia (modo punto de acceso): en algún caso, si no tenemos una red Wifi donde conectarnos, el ESP32 Plus STEAMakers es capaz de crear su propia red Wifi. Significa que crea un punto de acceso donde nos podemos conectar con otros dispositivos de red (portátil, Tablet, móvil, otros ESP32 Plus STEAMakers, etc.).
Hay que tener en cuenta que al crear un punto de acceso Wifi de esta forma, podemos conectar, por ejemplo, nuestro móvil al nuevo Wifi creado, pero no tendrá conexión a internet con esta conexión, simplemente es una forma de enlazar de forma inalámbrica a dos (o más) dispositivos para intercambiar información.
Cambiar el nombre del dispositivo en la red (Nombre del host - hostname): tenemos un bloque que nos permite cambiar el hostname del dispositivo para la red:
Dirección IP estática (en vez de usar la configuración automática por defecto): en algunos casos nos puede interesar que nuestro dispositivo tenga una IP fija dentro de la red y no depender del router (servidor DHCP) para que nos asigne cada vez una IP distinta en cada conexión a la red.
Por ejemplo, en casos en los que nuestro dispositivo vaya a ser un servidor web y necesitemos conectarnos a él desde otros dispositivos, o para redes donde el servicio DHCP de IP automática no está activado. Para ello usamos el bloque de configuración de IP estática que permite asignarle al dispositivo una IP y configuración básica de red de forma manual:
Dirección IP: La dirección que queremos dentro de la red a la que nos vamos a conectar. En un router doméstico uno de los rangos de IP más habituales es 192.168.0.X o 192.168.1.X, siendo la dirección 192.168.0.1 la del router por defecto, y el rango DHCP (las IPs de los dispositivos a los que se les asigna automático) suele empezar en la 192.168.0.100 en adelante (101, 102, …). Por eso, es recomendable en primer lugar saber si hay otros dispositivos con IP fija en la red y hacer un listado de dispositivos e IPs para evitar duplicados de IPs (error en la red). Y, por tanto, las IPs fijas por seguridad deberían estar fuera del rango del DHCP (menor que la 100). Recomendación en este ejemplo: poner una IP entre la 2 y las 99 para no tener conflicto con la IP del router ni con el rango de IPs asignadas automáticamente a otros dispositivos con el DHCP.
Máscara de subred: Es la máscara que nos separa la parte de la red y los dispositivos dentro de la dirección IP. En el ejemplo he dejado la máscara de 24 bits de red y 8 bits de dispositivos por defecto en la mayoría de redes LAN domésticas.
Puerta de enlace: Es la IP a través la cual podemos acceder a otras redes (internet), en nuestro caso debemos poner la IP del router.
DNS: Son dos direcciones IP de servidores DNS en internet para resolver nombres de dominios. Podríamos usar la dirección IP del router, aunque en el ejemplo he puesto las IPs públicas de los servidores DNS de Google.
Realizaremos una breve explicación de qué es una dirección IP y sus características principales.
Una dirección IP son una serie de números que se asignan a un determinado dispositivo tipo ordenador, impresora, teléfono móvil, Tablet o router, etc. que se conecta a una red. Esta dirección sirve para identificar la identidad y ubicación de cualquier dispositivo que sea capaz de utilizar una red en concreto, es decir, una especie de dirección virtual donde enviar y recibir información. Existen dos tipos de direcciones IP como son IPv4 y IPv6. Las IPv4 constan de una serie de cuatro números que van de 0 al 255, separados por puntos, mientras que las IPV6 son de ocho grupos de cuatro dígitos hexadecimales y se representan separados por los dos puntos. En una dirección IP vemos dos partes, los tres primeros números que son el identificador (ID) de red y el último que es el identificador de host.
Existen dos tipos de IP: públicas y privadas.
IP Pública: aquella que un dispositivo tiene al conectarse a un router y es la misma para todos los que estén en esa misma red.
IP Privada: la que tiene cada dispositivo dentro de una red local y con la que se le puede identificar para saber quién es.
También existen las direcciones IP estáticas y dinámicas:
IP dinámicas: aquellas que se asignan de manera aleatoria a nuestro equipo cada vez que se conecta. Es decir, no siempre vamos a tener la misma dirección IP, siendo diferentes cada vez que conectemos. Se suelen utilizar en redes domésticas. El inconveniente es que no es posible saber a quién pertenece realmente una IP y es difícil encontrar un determinado equipo desde fuera de la red local.
IP estáticas: suelen ser las que se instalan en empresas y se le asigna la misma IP para cada puesto, sabiendo que equipo está utilizando esa dirección y teniendo siempre la misma dirección.
Con todo lo visto hasta ahora podemos conectarnos a una red Wifi o crear nuestra propia red Wifi. Pero también podemos conectarnos a Blynk, MQTT, un servidor HTTP (web), etc. A continuación, vamos a trabajar con algunos de estos recursos.
Conexión a una red Wifi
El primer programa que vamos a realizar es un sencillo programa que nos permitirá conectarnos a una red Wifi y comprobar si se ha realizado la conexión enviando por el puerto serie (Consola) la dirección IP asignada.
Podemos observar la dirección IP y, por lo tanto, que se ha establecido la comunicación.
También podemos obtener otra serie de datos de nuestra conexión. Como podemos ver en el menú desplegable del bloque, podemos obtener los siguientes datos:
1. Dirección IP.
2. Máscara de subred.
3. Puerta de enlace.
4. Nombre del host.
Servidor HTTP (Web) I
La placa ESP32 Plus STEAMakers permite implementar un servidor web de forma sencilla y potente. Un servidor web es un servicio de red que está esperando conexiones. Cuando un dispositivo se conecta le hará una petición en formato HTTP (Hiper Text Transfer Protocol) que normalmente será una página web (documento HTML) o un archivo de otro tipo: CSV, texto, imagen, etc. No siempre el servidor debe retornar datos útiles, el servidor web puede utilizarse como una interfaz para control remoto, permitiendo intercambiar datos y ejecutar acciones remotas.
Vamos a crear un servidor web como interfaz de control remoto.
Consultamos la IP asignada desde la Consola, en este caso 192.168.1.58:
En el explorador, indicamos la dirección IP y nos mostrará el mensaje.
En este ejemplo, la respuesta se compone de 3 partes importantes:
Código: 200 - Código de respuesta HTTP OK.
Content-Type: tipo de contenido que se va a enviar, normalmente text/html, pero podría ser text/CSV, text/xml, etc.
Contenido: el contenido tal cual que se envía, para hacerlo correcto debería ser texto formateado en HTML de forma correcta. Abusando de la capacidad de los navegadores actuales para procesar casi cualquier tipo de contenido “mal formateado” le enviamos un sencillo texto de saludo.
Las peticiones HTTP las haremos normalmente desde un navegador, poniendo la IP de nuestro dispositivo en la barra de direcciones con el protocolo http.
Por ejemplo, si nuestro dispositivo tiene la dirección IP 192.168.1.58: El formato de la URL que podemos solicitar a nuestra ESP32 Plus STEAMakers es:
http://direccionip/accion?parametros
La dirección IP es la que tenga el dispositivo, como hemos visto anteriormente en este ejemplo en mi red doméstica la IP es 192.168.0.155 (variará en cada red, y según el DHCP asigne en cada momento o si la ponemos de forma fija)
La acción (opcional) será la web o comando que queremos pedirle al servidor. En un servidor web real (este es real, me refiero a uno tradicional tipo Apache, etc…) sería el documento del servidor que estamos solicitando (ejemplo: index.html, index.php, guardardatos.jsp, etc.).
Los parámetros (en este caso parámetros tipo GET) son datos adicionales que le damos al servidor normalmente como información extra a la acción solicitada. Los parámetros GET son opcionales, siempre van después del símbolo “?” y se forman con pares “clave=valor” separados entre ellos por “&”.
Desde el navegador encenderemos y apagaremos el led azul, utilizando los comandos que hemos creado en la Solicitud.
Por otro lado, deberíamos añadir otra respuesta para cuando se solicite una acción no válida. Por ejemplo, si pido la acción parpadear cuando sólo tengo implementadas la acción de encender y apagar debería indicar un error.
El programa definitivo será:
Servidor HTTP (Web) III
Basándonos en la idea del ejemplo anterior, vamos a hacer uso de los parámetros GET para permitir que nuestro servidor web sea capaz de encender o apagar cualquier led conectado a cualquiera de los pines disponibles.
Iniciar servidor web (80) y detectaremos que dirección IP tenemos asignada, igual que en la actividad anterior.
Realizaremos las funciones para encender y apagar cualquier led (probaremos con un led conectado en D3 – pin IO25).
Con los bloques “valor del parámetro” obtenemos parámetros de la URL.
En el ejemplo usaremos la versión del bloque que obtiene el parámetro y lo procesa automáticamente como un valor numérico.
Vamos a realizar las dos funciones que nos permitirán encender y apagar cualquier led. La función para encender el led sería:
La petición correcta para encender el led anterior, conectado al pin 19 (GPIO 19 o D12-Led Rojo) sería:
http://192.168.1.58/encender?PIN=19
Y así podríamos indicar cualquiera de los pines GPIO disponibles para activarlo a ON.
La función para apagar el led sería:
La petición correcta para apagar el led anterior, conectado al pin 19 (GPIO 19 o D12-Led Rojo) sería:
Y así podríamos indicar cualquiera de los pines GPIO disponibles para activarlo a OFF.
Servidor HTTP (Web) IV
Con lo aprendido hasta ahora realizar el control de varios servos vía peticiones HTTP desde un navegador.
El bucle Inicializar seguirá igual que en las actividades anteriores.
Vamos a conectar 2 servos simulando un brazo robótico con una base, un brazo y una pinza. En D3 conectaremos la base y en D5 el brazo (no lo podemos conectar en A3 porque es un pin sólo de entradas). Definiremos la acción mover en la que introduciremos 2 parámetros:
servo: para indicar el servo (a cada uno le hemos puesto un nombre)
grados: para indicar la posición a donde mover ese servo indicado.
Para mover los servos utilizaremos comando del tipo:
http://192.168.1.58/mover?servo=brazo&grados=45
Contenido HTML
Podemos generar contenido HTML con ArduinoBlocks. Disponemos de una serie de bloques específicos que nos permiten generar texto con formato HTML especialmente pensado para devolver contenido en formato web desde el servidor HTTP de la placa ESP32 Plus STEAMakers, o de cualquier otra placa ESP32.
Conectar a una red Wifi.Configuraremos el Puerto serie a 115200 baudios.Enviaremos la IP por el puerto serie para poder verla por la Consola.Iniciaremos el servidor web.Crearemos una variable de tipo texto que llamamos html_inicio donde introduciremos eldocumento HTML (HTML Document).
Después crearemos las tres funciones para encender y apagar el led azul, y la página de inicio.
Subimos el programa a la placa y abrimos la Consola para ver la IP asignada:
A continuación vamos a ver un programa que lo mezcla todo, el contenido HTML de este último ejemplo y las solicitudes GET de los anteriores, de forma que podemos encender y apagar el led pulsando un enlace en un documento HTML (de esta forma podemos encender y apagar el led del pin 18) o introduciendo los comandos GET en la barra de direcciones (de esta forma podemos encender o apagar un led conectado a cualquier pin).
Un programa similar al anterior realizado con SteamakersBlocks para encender y apagar el led rojo de la placa Imagina 3DBot tiene un código equivalente para el IDE de Arduino como el que se muestra a continuación.#include "WiFi.h"#include <WebServer.h>#include <analogWrite.h>
String s_html_inicio;String espwifi_ssid="";String espwifi_pass="";WebServer http_server;
void espwifi_check(){if (WiFi.status() != WL_CONNECTED){WiFi.reconnect();delay(2000);}}
void espwifi_setup(String _ssid, String _pass){WiFi.mode(WIFI_STA);espwifi_ssid=_ssid;espwifi_pass=_pass;WiFi.begin(_ssid.c_str(),_pass.c_str());while (WiFi.status() != WL_CONNECTED) delay(500);}
void http_server_on_(){http_server.send(200,String("text/html"),s_html_inicio);
}
void http_server_on_ON(){analogWrite(27,(uint16_t)(255));http_server.send(200,String("text/html"),s_html_inicio);
}
void http_server_on_OFF(){analogWrite(27,(uint16_t)(0));http_server.send(200,String("text/html"),s_html_inicio);
}
void setup(){
Serial.begin(115200);Serial.flush();while(Serial.available()>0)Serial.read();
pinMode(27, OUTPUT);
espwifi_setup(String("MOVISTAR"),String("F769C6CC"));Serial.println(WiFi.localIP().toString());http_server.begin(80);s_html_inicio = String("<!DOCTYPE html><HTML><HEAD>")+String("<META ")+String("charset=\"ISO-8859-1\" name=\"viewport\" content=\"width=device-width, initial-scale=1.0\"")+String(" >")+String("<STYLE>")+String("body {background-color: #ffffff;}")+String("</STYLE>")+String("<TITLE>")+String("ArduinoBlocks")+String("</TITLE>")+String("</HEAD><BODY>")+String("<H1>")+String("CONTROL LED")+String("</H1>")+String("<A href=\"")+String("ON")+String("\" target=\"")+String("_self")+String("\">")+String("Pulsa aquí para encender")+String("</A>")+String("<BR>")+String("<A href=\"")+String("OFF")+String("\" target=\"")+String("_self")+String("\">")+String("Pulsa aquí para apagar")+String("</A>")+String("</BODY></HTML>");
http_server.on("/",HTTP_GET,http_server_on_);http_server.on("/ON",HTTP_GET,http_server_on_ON);http_server.on("/OFF",HTTP_GET,http_server_on_OFF);}
void loop(){
yield();
espwifi_check();
http_server.handleClient();
}
Este es otro programa para ESP32 Steamakers e Imagina 3DBot y el IDE de Arduino. Los dos botones de la página web permiten encender y apagar los leds amarillo y rojo de la Imagina 3DBot. LED1pin es el GPI16 del ESP32, equivalente al D5 de Arduino y corresponde al led amarillo. LED2pin es el GPI27 del ESP32, equivalente al D6 de Arduino y corresponde al led rojo./** Servidor web con ESP32* Librerias necesarias para conectarnos a un entorno Wifi y poder configurar* un servidor WEB*/#include <WiFi.h>#include <WebServer.h>/* Añade tu SSID & Clave para acceder a tu Wifi */const char* ssid = "MOVISTAR"; // Tu SSIDconst char* password = "F769C6CC"; //Tu Clave/*Declaramos un objeto de la libreria WebServer para poder acceder a sus funcionesY como parametro 80, que es el puerto estandar de todos los servicios WEB HTTP*/WebServer server(80);/*Declaramos el estado inicial de los LEDs del ESP32*/uint8_t LED1pin = 16;bool LED1Estado = LOW;uint8_t LED2pin = 27;bool LED2Estado = LOW;/*Todos las siguientes funciones ejecutan tres tareas:1 Cambian de estado las variables de los LED2 Muestran por el monitor Serial de Arduino IDE, informacion relevante al estado de los LED3 Actualizan la vista de la pagina del servidor WEB con ESP32, envia al navegador un codigo 200 indican el exitode la conexion y llama a otra funcion SendHTML con dos parametros que modificaran la paginadel servidor WEB con Arduino.*/void handle_OnConnect() {LED1Estado = LOW; // 1LED2Estado = LOW; // 1Serial.println("GPIO4 Estado: OFF | GPIO5 Estado: OFF"); // 2server.send(200, "text/html", SendHTML(LED1Estado, LED2Estado)); // 3}void handle_led1on() {LED1Estado = HIGH; //1Serial.println("GPIO4 Estado: ON"); // 2server.send(200, "text/html", SendHTML(true, LED2Estado)); //3}void handle_led1off() {LED1Estado = LOW;Serial.println("GPIO4 Estado: OFF");server.send(200, "text/html", SendHTML(false, LED2Estado));}void handle_led2on() {LED2Estado = HIGH;Serial.println("GPIO5 Estado: ON");server.send(200, "text/html", SendHTML(LED1Estado, true));}void handle_led2off() {LED2Estado = LOW;Serial.println("GPIO5 Estado: OFF");server.send(200, "text/html", SendHTML(LED1Estado, false));}void handle_NotFound() {server.send(404, "text/plain", "La pagina no existe");}/*Aqui esta definido todo el HTML y el CSS del servidor WEB con ESP32*/String SendHTML(uint8_t led1stat, uint8_t led2stat) {// Cabecera de todas las paginas WEBString ptr = "<!DOCTYPE html> <html>\n";// <meta> viewport. Para que la pagina se vea correctamente en cualquier dispositivoptr += "<head><meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0, user-scalable=no\">\n";ptr += "<title>Control LED</title>\n";/** El estilo de la pagina WEB, tipo de letra, tamaño, colores,* El estilos de los botones (las clases en CSS) y la definicion de como van a cambiar dependiendo de como* cambien los estado de los LEDs, color fondo etc*/ptr += "<style>html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";ptr += "body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;} h3 {color: #444444;margin-bottom: 50px;}\n";ptr += ".button {display: block;width: 80px;background-color: #3498db;border: none;color: white;padding: 13px 30px;text-decoration: none;font-size: 25px;margin: 0px auto 35px;cursor: pointer;border-radius: 4px;}\n";ptr += ".button-on {background-color: #3498db;}\n";ptr += ".button-on:active {background-color: #2980b9;}\n";ptr += ".button-off {background-color: #34495e;}\n";ptr += ".button-off:active {background-color: #2c3e50;}\n";ptr += "p {font-size: 14px;color: #888;margin-bottom: 10px;}\n";ptr += "</style>\n";ptr += "</head>\n";ptr += "<body>\n";/** Encabezados de la pagina*/ptr += "<h1>ESP32 Servidor WEB</h1>\n";ptr += "<h3>Usando Modo Estacion</h3>\n";/** Aqui esta la inteligencia del servidor WEB con ESP32, dependiento de los parametros de la funcion SendHTML* modificara la vista de la pagina WEB, llamaran a las clases "button-on y button-off" que cambian como* se muestran los datos en la pagina WEB*/if (led1stat){ptr += "<p>LED1 Estado: ON</p><a class=\"button button-off\" href=\"/led1off\">OFF</a>\n";}else{ptr += "<p>LED1 Estado: OFF</p><a class=\"button button-on\" href=\"/led1on\">ON</a>\n";}if (led2stat){ptr += "<p>LED2 Estado: ON</p><a class=\"button button-off\" href=\"/led2off\">OFF</a>\n";}else{ptr += "<p>LED2 Estado: OFF</p><a class=\"button button-on\" href=\"/led2on\">ON</a>\n";}ptr += "</body>\n";ptr += "</html>\n";return ptr;}void setup() {/** Declaracion de la velocidad de comunicacion entre Arduino IDE y ESP32* Configura el comportamiento de los pines*/Serial.begin(115200);pinMode(LED1pin, OUTPUT);pinMode(LED2pin, OUTPUT);/** Configuracion de la conexion a la Wifi de tu casa*/WiFi.mode(WIFI_STA);WiFi.begin(ssid, password);Serial.println("");// Wait for connectionwhile (WiFi.status() != WL_CONNECTED) {delay(500);Serial.print(".");}Serial.println("");Serial.print("Conectado a ");Serial.println(ssid);Serial.print("Direccion IP: ");Serial.println(WiFi.localIP());/** Para procesar las solicitudes HTTP necesitamos definir el codigo que debe de ejecutar en* cada estado. Para ello utilizamos el metodo "on" de la libreria WebServer que hemos* habilitador en la linea 13 de este codigo* 1 El primero se ejecuta cuando te conectas al Servidor WEB con ESP32 http://la_ip_del_esp32/* 2 Los 4 siguientes procesan los 2 estados que puede tener cada LED ON/OFF* 3 El ultimo gestiona los errores por ejemplo si pones http://la_ip_del_esp32/holaquetal* esta pagina no existe, por lo tanto actualizara la pagina WEB con un mensaje de error*/server.on("/", handle_OnConnect); // 1server.on("/led1on", handle_led1on); // 2server.on("/led1off", handle_led1off); // 2server.on("/led2on", handle_led2on); // 2server.on("/led2off", handle_led2off); // 2server.onNotFound(handle_NotFound); // 3/** Arrancamos el Servicio WEB*/server.begin();Serial.println("Servidor HTTP iniciado");}/** Para gestionar las la peticiones HTTP es necesario llamar al metodo "handleClient"* de la libreria WebServer que se encarga de recibir las peticiones y lanzar las fuciones* de callback asociadas tipo "handle_led1on()" "handle_led2on()" etc* Tambien ejecutan el cambio de estado de los pines y por lo tanto hacen que los* LEDs se enciendan o apaguen*/void loop() {server.handleClient();if (LED1Estado){digitalWrite(LED1pin, HIGH);}else{digitalWrite(LED1pin, LOW);}if (LED2Estado){digitalWrite(LED2pin, HIGH);}else{digitalWrite(LED2pin, LOW);}}
Y los datos mostrados:
Servidor HTTP (Web) VI
Podemos mejorar el programa anterior con nuevos bloques existentes en ArduinoBlocks que nos permiten modificar directamente la programación HTML de nuestra web.
Cambiaremos el color de fondo y haremos que se actualice automáticamente cada 3 segundos.
La página web que aparecerá y se recargará automáticamente cada 3 segundos será la siguiente:
Servidor HTTP (Web) – AppInventor2
Las peticiones HTTP con parámetros GET son muy fáciles de probar y usar con el navegador. Pero no siempre usamos un navegador, si no que implementamos esta opción para comunicar y controlar desde otros sistemas más personalizados. Por ejemplo, podríamos hacer una aplicación móvil con AppInventor2 que envía peticiones HTPP (de forma transparente) desde la aplicación.
Haremos el programa en ArduinoBlocks para encender y apagar el led.
Podremos elegir el led que queremos encender.
Podemos diseñar una sencilla aplicación en Appinventor2 para probar el ejemplo anterior. Crearemos dos botones y un componente web que es lo único que necesitamos.
En los bloques de código de Appinventor2 definimos las peticiones HTTP al servidor de nuestra ESP32 Plus STEAMakers con los parámetros para encender o apagar.
Descargamos la aplicación en el teléfono móvil, la instalamos y ya la podemos probar.
Entramos en la aplicación nuestra dirección IP y el pin de conexión (en el ejemplo el GPIO19 que es el D12 – Led Rojo).
No hay comentarios:
Publicar un comentario