Kitabı oxu: «Desarrollo de aplicaciones IoT en la nube para Arduino y ESP8266», səhifə 5

Şrift:

2.3.3.3 Obtención del estado de los pines del ESP-01 desde un navegador

En la práctica anterior se ha utilizado un formulario HTML para asignar un valor alto o bajo a los dos pines digitales del ESP-01. Dicho formulario contenía dos listas desplegables en las que se seleccionaba el GPIO y el valor que deseaban asignarle. En este caso, el objetivo es conocer el valor de cada uno de dichos pines. Usarán de nuevo un formulario HTML, pero esta vez solo tendrá una lista desplegable, la correspondiente al GPIO del que desea saber si está en nivel alto o bajo. Su aspecto será el siguiente.

El circuito que utilizarán para realizar las pruebas consistirá en dos interruptores que conectarán el GPIO0 y el GPIO2 a GND a través de una resistencia de 4.7 K Ω (imprescindible para no provocar un cortocircuito y estropear el ESP-01). En el programa se habrá activado la resistencia de pull up de dichos pines para que estén a nivel alto, por lo que, cuando un interruptor se desplace hacia la derecha, pondrá a nivel bajo el GPIO al que esté conectado.

Esta práctica se ha hecho con interruptores para hacerla de carácter general, pero valdría para cualquier dispositivo que pudiera dar una salida digital (detectores infrarrojos de proximidad, detectores de movimiento, sensores de lluvia, de sonido, de vibraciones por impacto, etc.).

Puesto que lo que se desea es recuperar información, se enviará al servidor web una petición HTTP con el método GET. De esta forma, los datos de la consulta viajarán en el propio URL, por lo que será de allí de donde deban extraerlos para generar la respuesta que muestre en su navegador la información solicitada.

En primer lugar, observen el código HTML del formulario utilizado en esta ocasión.

<form method=”GET”> <fieldset style=»width:200px»> <legend> Control GPIOs ESP-01 </legend> GPIO: <select name=»GPIO»> <option value=»0»>GPIO0</option> <option value=»2»>GPIO2</option> </select> <br><br> <input type=»submit» value=»Enviar»> </fieldset> </form>

La principal diferencia con el usado en la práctica anterior es que el atributo method de la etiqueta form ahora toma el valor “GET”. Naturalmente, ahora solo es necesario la lista desplegable que contiene los GPIO de los que desea obtener su valor, por lo que únicamente aparece una etiqueta select con name=”GPIO”.

Ya disponen del conocimiento necesario para entender el funcionamiento del programa con el que conseguirán los objetivos propuestos en esta práctica.

#include <ESP8266WiFi.h> // SSID de la red WIFI a la que desea conectarse const char* ssid = “*********”; //contraseña de dicha red const char* password = “ *********”; //dirección IP elegida dentro de la red IPAddress ip(192, 168, 1, 99); //dirección IP del gateway IPAddress gateway(192, 168, 1, 1); //mascara de red IPAddress subnet(255, 255, 255, 0); WiFiServer servidorWeb(80); WiFiClient clienteWeb; String resultadoEjecucion; void setup() { Serial.begin(115200); pinMode(0, INPUT_PULLUP); pinMode(2, INPUT_PULLUP); //Se inicia la conexión WiFI Serial.print(“Conectando a “ + String(ssid) + “ “); WiFi.config(ip, gateway, subnet); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED){ delay(500); Serial.print(“.”); } Serial.println(“ Conectado”); //Se arranca el servidor Web servidorWeb.begin(); Serial.println(“Servidor web arrancado”); } void loop() { resultadoEjecucion = “”; clienteWeb = servidorWeb.available(); //Se espera que llegue un cliente if (clienteWeb) { boolean lineaEnBlanco = true; String encabezado = “”; // petición HTTP String cuerpo = “”; //cuerpo de la petición int tamanioCuerpo = -1; //tamaño del cuerpo de la petición //El cliente está conectado while (clienteWeb.connected()) { //el cliente ha transmitido datos if (clienteWeb.available()) { char c = clienteWeb.read(); Serial.write(c); // Se muestra en el monitor serie encabezado += c; if (c == ‘\n’ && lineaEnBlanco && encabezado.startsWith(“GET”)){ controlGPIOs(encabezado); enviarMensajeRespuesta(); break; } else if (c == ‘\n’ && lineaEnBlanco && encabezado.startsWith(“POST”)) { //Se obtiene el tamaño de cuerpo String temp = encabezado.substring(encabezado.indexOf(“Content-Length:”) + 15); temp.trim(); tamanioCuerpo = temp.toInt(); //se obtiene el cuerpo de la petición while(tamanioCuerpo-- > 0) { c = clienteWeb.read(); Serial.write(c); cuerpo += c; } Serial.write(“\n\n”); enviarMensajeRespuesta(); break; } if (c == ‘\n’) lineaEnBlanco = true; else if (c != ‘\r’) lineaEnBlanco = false; } } //Se cierra la conexión para asegurar que los datos se envían delay(10); clienteWeb.stop(); } } void controlGPIOs(String encabezado){ int gpio = encabezado.substring(encabezado.indexOf(“GPIO=”)+5, encabezado.indexOf(“GPIO=”)+6).toInt(); int valor = digitalRead(gpio); if (valor == 1) resultadoEjecucion = “El GPIO” + String(gpio) + “ tiene un valor ALTO”; else resultadoEjecucion = “El GPIO” + String(gpio) + “ tiene un valor BAJO”; } //Devuelve un mensaje de respuesta con una página HTML void enviarMensajeRespuesta(){ clienteWeb.println(“HTTP/1.1 200 OK”); clienteWeb.println(“Content-Type: text/html”); clienteWeb.println(“Connection: close”); clienteWeb.println(); clienteWeb.println(“<!DOCTYPE HTML>”); clienteWeb.println(“<head>”); clienteWeb.println(“<meta charset=‘UTF-8’>”); clienteWeb.println(“<title>Servidor Web ESP8266</title>”); clienteWeb.println(“</head>”); clienteWeb.println(“<html>”); clienteWeb.println(“<body>”); clienteWeb.println(“<form method=‘GET’>”); clienteWeb.println(“<fieldset style=‘width:200px’>”); clienteWeb.println(“<legend>Control GPIOs ESP-01</legend>”); clienteWeb.println(“GPIO: “); clienteWeb.println(“<select name=‘GPIO’>”); clienteWeb.println(“<option value=‘0’>GPIO0</option>”); clienteWeb.println(“<option value=‘2’>GPIO2</option>”); clienteWeb.println(“</select>”); clienteWeb.println(“<br><br>”); clienteWeb.println(“<input type=‘submit’ value=‘Enviar’>”); clienteWeb.println(“</fieldset>”); clienteWeb.println(“</form>”); clienteWeb.println(“<br>”); clienteWeb.println(resultadoEjecucion); clienteWeb.println(“</body>”); clienteWeb.println(“</html>”); }

Solo se analizarán los cambios realizados respecto del programa utilizado de base, que será, de nuevo, el servidor web avanzado. El primer cambio lo encontrarán en el bloque setup(), donde los pines GPIO0 y GPIO2 se inician como entrada y se les asigna un valor alto habilitando su resistencia de pull up interna.

pinMode(0, INPUT_PULLUP); pinMode(2, INPUT_PULLUP);

El cambio principal está en la parte del código en la que se ha confirmado que la petición HTTP utiliza el método GET. Será ahí donde ahora incluirán la función controlGPIOs(), que será la responsable de obtener el parámetro de consulta, conseguir la información demandada y devolver el resultado al navegador. Para identificar el parámetro de consulta, recuerden que en las peticiones de tipo GET viaja en el propio URL con el siguiente formato:

URL?parámetro=valor

Como el nombre del parámetro es “GPIO”, únicamente será necesario buscarlo en el encabezado del mensaje (formará parte de la línea de solicitud), utilizando la siguiente sentencia:

int gpio = encabezado.substring(encabezado.indexOf(“GPIO=”)+5, encabezado.indexOf(“GPIO=”)+6).toInt();

Una vez obtenido el GPIO, es fácil obtener su estado.

int valor = digitalRead(gpio);

Finalmente, se compone el texto que mostrará al usuario dicha información, y que se almacenará en la variable resultadoEjecucion.

if (valor == 1) resultadoEjecucion = “El GPIO” + String(gpio) + “ tiene un valor ALTO”; else resultadoEjecucion = “El GPIO” + String(gpio) + “ tiene un valor BAJO”;

Para entender los cambios realizados en la función enviarMensajeRespuesta(), solo tienen que recordar el código HTML del nuevo formulario.

Compilen el código del programa y cárguenlo en el ESP-01. Después, introduzcan la dirección IP de su servidor web (192.168.1.99) en un navegador. Abran el monitor serie y luego seleccionen la opción “GPIO2”. Finalmente, pulsen el botón “Enviar”. En el navegador obtendrán el estado de dicho pin y en el monitor serie aparecerá la siguiente información.

La primera línea indica que se ha realizado una solicitud GET con un parámetro cuya clave es “GPIO” y su valor “2”.

GET /?GPIO=2 HTTP/1.1

Las siguientes líneas son las que contienen las cabeceras que ya conocen. Además, al tratarse de una petición GET, esta no tiene cuerpo.

Ahora muevan el interruptor para que el GPIO2 quede conectado a GND. Vuelvan a seleccionar dicho GPIO en el menú desplegable del navegador y pulsen el botón “Enviar”. El resultado que obtendrán en el monitor serie es el mismo, porque la petición es la misma. Lo que cambia es el texto que se muestra en el navegador, que ahora indicará que: “El GPIO2 tiene un valor BAJO”.

Como ya saben, el hecho de utilizar el método GET supone que los datos de la consulta viajan en el propio URL, algo que pueden ver ustedes mismos en la barra de direcciones del propio navegador.

En efecto, separado por el carácter ‘?’, aparece la pareja clave-valor con los parámetros de consulta, en este caso el GPIO número 2. Si la consulta tuviera más parámetros, estos quedarían separados por el carácter ‘&’.

Abran otra pestaña en el navegador e introduzcan directamente en la barra de direcciones: 192.168.1.99/?GPIO=2. No solo habrán accedido al servidor web del ESP-01, sino que también habrán realizado la consulta del estado del GPIO2 sin necesidad de usar el formulario.

El envío de peticiones HTTP con el método GET no es patrimonio exclusivo de los formularios. También se pueden utilizar botones. De esta forma, podrán conseguir el mismo objetivo cambiando drásticamente el aspecto de la interfaz de usuario. Miren la siguiente imagen.

Ahora, en vez de un formulario, se muestran dos botones que, al pulsarse, devuelven el estado del GPIO correspondiente. Se propone que lo hagan ustedes mismos como práctica adicional. Lo único que deben hacer para conseguir este resultado es modificar la página web que genera el ESP-01, sustituyendo el código HTML del formulario por el siguiente:

Las etiquetas <button> y </button> indican al navegador que muestre un botón con el texto contenido entre ellas (en el primer botón “GPIO0” y en el segundo “GPIO2”). Cuando se pulsen, estos se comportarán de la misma forma que un enlace de una página web, y los dirigirán a la dirección “192.168.1.99/?GPIO=0” en el primer caso y a la dirección“192.168.1.99/?- GPIO=2” en el segundo. La clave está en el uso del atributo onClick, en el que el valor de la variable location.href es sustituido por el URL de la página actual, es decir, la 192.168.1.99. Por lo tanto, este código seguirá funcionando independientemente de la IP que haya asignado a su servidor.

Añadan también un subtítulo de nivel 4 que indique claramente en la página web lo que deben hacer.

<h4>Pulse sobre el botón cuyo GPIO desea conocer su estado</h4>

Para dotar de mejor apariencia a la nueva interfaz de usuario, incluyan las etiquetas anteriores dentro de las indicadas a continuación para que todo aparezca centrado en la ventana.

2.3.3.4 Asignación de valores a los pines PWM de Arduino desde un navegador

Es esta última práctica podrán controlar desde un navegador el valor de cada uno de los pines PWM de Arduino. Para ello, deberán conectarlo a un ESP-01 por el puerto serie, desde el que recibirán el número del pin y el valor que deberán asignarle.

PWM (Pulse Width Modulation) es una técnica de modulación por ancho de pulsos que permite que Arduino pueda generar salidas analógicas por los pines digitales. De todos ellos, solo pueden usarse el 3, 5, 6, 9, 10 y 11, a los que se les deben asignar valores en el rango 0-255 para variar la tensión a su salida entre 0 y 5 V.

La interfaz web que utilizarán es de nuevo un formulario, pero, esta vez, contendrá una lista desplegable y un deslizador con el que podrán asignar un valor al pin PWM seleccionado. Su aspecto será el que aparece a continuación.

El código HTML que deberá devolver el ESP-01, con el que se mostrará dicho formulario en el navegador, es el siguiente.

<!DOCTYPE html> <head> <meta charset=»UTF-8»> <title>Servidor Web ESP8266</title> </head> <html> <body> <form method=»POST»> <fieldset style=»width:300px»> <legend>Control leds Arduino</legend> GPIO: <select name=»GPIO»> <option value=»3”>GPIO3</option> <option value=”5”>GPIO5</option> <option value=»6”>GPIO6</option> <option value=”9”>GPIO9</option> <option value=”10”>GPIO10</option> <option value=”11”>GPIO11</option> </select> <br><br> <input type=»range» min=»0» max=»255» value=»0” id=”Valor”> <br><br> <input type=»submit» value=»Enviar»> </fieldset> </form> </body> </html>

Como se ha comentado anteriormente, se utilizará un formulario HTML para realizar una petición HTTP POST. En la lista desplegable podrán seleccionar las opciones GPIO3, GPIO5, GPIO6, GPIO9, GPIO10 y GPIO11, que son los pines PWM de Arduino. Con la barra de desplazamiento (slider) podrán escoger un valor en el rango 0-255. El código HTML de este último componente de entrada es:

La etiqueta HTML utilizada es input, cuyo tipo (atributo type) es range, lo que indica que se trata de una barra de desplazamiento. Los atributos min, max y value especifican el valor mínimo, máximo e inicial de dicha barra de desplazamiento. Finalmente, el atributo id es el identificador de este componente gráfico.

En las prácticas realizadas hasta el momento, solo se han utilizado dos tipos de etiquetas input de entrada de datos: submit y range. Existen muchos más, como los que permiten la introducción de texto (text), números (number), contraseñas (password), fechas (date), checkbox (checkbox), radio buttons (radio), etc. Se anima al lector interesado en HTML a investigar todos ellos y utilizar el más adecuado en sus proyectos.

Para comprobar su funcionamiento, conectarán un led a cada uno de los pines PWM de Arduino a través de una resistencia de 220 Ω, que se iluminará con mayor o menor intensidad según el valor asignado desde el navegador web. El esquema eléctrico que deberán montar se muestra a continuación.

En dicho circuito pueden observar que los pines Rx/Tx del ESP-01 se han conectado con los pines 13/12 de Arduino. Como verán más adelante, estos últimos son los configurados con la librería SoftwareSerial como puerto serie de comunicaciones con el ESP-01.

En primer lugar, vean el código del ESP-01.

#include <ESP8266WiFi.h> // SSID de la red WIFI a la que desea conectarse const char* ssid = “*********”; //contraseña de dicha red const char* password = “ *********”; //dirección IP elegida dentro de la red IPAddress ip(192, 168, 1, 99); //dirección IP del gateway IPAddress gateway(192, 168, 1, 1); //mascara de red IPAddress subnet(255, 255, 255, 0); WiFiServer servidorWeb(80); WiFiClient clienteWeb; String resultadoEjecucion; void setup() { Serial.begin(9600); //Se inicia la conexión WiFI WiFi.config(ip, gateway, subnet); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED){ delay(500); } //Se arranca el servidor Web servidorWeb.begin(); } void loop() { resultadoEjecucion = “”; clienteWeb = servidorWeb.available(); //Se espera que llegue un cliente if (clienteWeb) { // El encabezado de una petición HTTP finaliza con una linea en blanco boolean lineaEnBlanco = true; String encabezado = “”; // petición HTTP String cuerpo = “”; //cuerpo de la petición int tamanioCuerpo = -1; //tamaño del cuerpo de la petición //El cliente está conectado while (clienteWeb.connected()) { //el cliente ha transmitido datos if (clienteWeb.available()) { char c = clienteWeb.read(); encabezado += c; if (c == ‘\n’ && lineaEnBlanco && encabezado.startsWith(“GET”)){ enviarMensajeRespuesta(); break; } else if (c == ‘\n’ && lineaEnBlanco && encabezado.startsWith(“POST”)) { //Se obtiene el tamaño de cuerpo String temp = encabezado.substring(encabezado.indexOf(“Content-Length:”) + 15); temp.trim(); tamanioCuerpo = temp.toInt(); //se obtiene el cuerpo de la petición while(tamanioCuerpo-- > 0) { c = clienteWeb.read(); Serial.write(c); //se envía el cuerpo del mensaje a Arduino cuerpo += c; } controlGPIOs(cuerpo); enviarMensajeRespuesta(); break; } if (c == ‘\n’) lineaEnBlanco = true; else if (c != ‘\r’) lineaEnBlanco = false; } } //Se cierra la conexión para asegurar que los datos se envían delay(10); clienteWeb.stop(); } } //Envía los parámetros POST a Arduino void controlGPIOs(String cuerpo){ int gpio = cuerpo.substring(cuerpo.indexOf(“GPIO=”)+5, (cuerpo.indexOf(“&”))).toInt(); int valor = cuerpo.substring(cuerpo.indexOf(“Valor=”)+6).toInt(); resultadoEjecucion = “El GPIO” + String(gpio) + “ se ha puesto a nivel “ + String(valor); } //Devuelve un mensaje de respuesta con una página HTML void enviarMensajeRespuesta(){ clienteWeb.println(“HTTP/1.1 200 OK”); clienteWeb.println(“Content-Type: text/html”); clienteWeb.println(“Connection: close”); clienteWeb.println(); clienteWeb.println(“<!DOCTYPE HTML>”); clienteWeb.println(“<head>”); clienteWeb.println(“<meta charset=‘UTF-8’>”); clienteWeb.println(“<title>Servidor Web ESP8266</title>”); clienteWeb.println(“</head>”); clienteWeb.println(“<html>”); clienteWeb.println(“<body>”); clienteWeb.println(“<form method=‘POST’>”); clienteWeb.println(“<fieldset style=‘width:300px’>”); clienteWeb.println(“<legend>Control GPIOs PWM Arduino</legend>”); clienteWeb.println(“GPIO: “); clienteWeb.println(“<select name=‘GPIO’>”); clienteWeb.println(“<option value=‘3’>GPIO3</option>”); clienteWeb.println(“<option value=‘5’>GPIO5</option>”); clienteWeb.println(“<option value=‘6’>GPIO6</option>”); clienteWeb.println(“<option value=‘9’>GPIO9</option>”); clienteWeb.println(“<option value=‘10’>GPIO10</option>”); clienteWeb.println(“<option value=‘11’>GPIO11</option>”); clienteWeb.println(“</select>”); clienteWeb.println(“<br><br>”); clienteWeb.println(“<input type=‘range’ min=‘0’ max=‘255’ value=‘0’ name=‘Valor’>”); clienteWeb.println(“<br><br>”); clienteWeb.println(“<input type=‘submit’ value=‘Enviar’>”); clienteWeb.println(“</fieldset>”); clienteWeb.println(“</form>”); clienteWeb.println(“<br>”); clienteWeb.println(resultadoEjecucion); clienteWeb.println(“</body>”); clienteWeb.println(“</html>”);

El programa utilizado de base es el de la práctica de ejecución de peticiones con el método POST. Lo primero que les llamará la atención es que se han eliminado todas las sentencias que escribían información en el monitor serie, excepto una. El motivo es que ahora se utiliza el puerto serie (empleado también por el propio monitor) para la transmisión de datos con Arduino. Si se mantuvieran dichos mensajes informativos, Arduino los recibiría de forma innecesaria. La única sentencia que se conserva es la que escribía en el monitor serie, carácter a carácter, el contenido del cuerpo del mensaje POST. Esa misma sentencia es la que ahora enviará dichos caracteres hacia Arduino. Como saben, allí es donde el formulario sitúa el número del GPIO y el nivel seleccionado por el usuario al pulsar el botón “Enviar” del formulario.

Serial.write(c);

El puerto serie no solo lo utiliza el monitor serie, sino también el IDE para cargar el programa en el ESP-01. Por ese motivo, no conecten nada a los pines Rx/Tx hasta no haber compilado y cargado el programa. Por la misma razón, no abran tampoco el monitor serie.

Se ha bajado la velocidad de transmisión a 9600 baudios porque la utilizada habitualmente en las prácticas (115 200 baudios) provoca errores de transmisión.

Además de la eliminación de las sentencias de escritura de mensajes informativos en el monitor serie, se ha modificado la función enviarMensajeRespuesta(), para que ahora genere un formulario con una lista desplegable y una barra de desplazamiento cuyo código HTML ya conocen.

El último cambio está en la función controlGPIOs(), que únicamente compondrá el texto de la variable resultadoEjecucion con el que se confirma al usuario la acción realizada.

El código que deben cargar en Arduino es el siguiente.

#include <SoftwareSerial.h> SoftwareSerial puertoESP01(12, 13); // RX | TX char caracter; String orden; void setup() { Serial.begin(115200); puertoESP01.begin(9600); pinMode(3, OUTPUT); pinMode(5, OUTPUT); pinMode(6, OUTPUT); pinMode(9, OUTPUT); pinMode(10, OUTPUT); pinMode(11, OUTPUT); } void loop() { orden = “”; while(puertoESP01.available() > 0){ caracter = puertoESP01.read(); orden = orden + caracter; } if (orden != “”){ int gpio = orden.substring(orden.indexOf(“GPIO=”)+5, (orden.indexOf(“&”))).toInt(); int valor = orden.substring(orden.indexOf(“Valor=”)+6).toInt(); Serial.println(“GPIO: “ + String(gpio) + “ Valor: “ + String(valor)); analogWrite(gpio, valor); } }

A la hora de compilar y cargar el programa, no olviden seleccionar en el IDE la tarjeta Arduino/Genuino UNO y el puerto correspondiente, ya que, al haber cargado el programa anterior en el ESP-01, estos no tendrán los valores adecuados.

Lo primero que se hace es importar la librería SoftwareSerial, que permite utilizar otros pines diferentes a los predeterminados para la recepción/ envío de datos en las comunicaciones serie. Esto también posibilitará ver los mensajes de trazas de Arduino mientras depuran los posibles errores que pudieran haber cometido durante el desarrollo.

Por lo tanto, lo primero que harán es importar dicha librería y crear el objeto puertoESP01, de la clase SoftwareSerial, mediante el que establecerán que la recepción de datos se realice por el pin 12 y el envío por el 13.

#include <SoftwareSerial.h> SoftwareSerial puertoESP01(12, 13); // RX | TX

En el bloque setup() se inician las comunicaciones, tanto del monitor serie como de la comunicación con el ESP-01 (recuerden que la velocidad de transmisión con el ESP-01 es de 9600 baudios). Además, se configuran como salida todos los pines PWM.

Serial.begin(115200); puertoESP01.begin(9600); pinMode(3, OUTPUT); pinMode(5, OUTPUT); pinMode(6, OUTPUT); pinMode(9, OUTPUT); pinMode(10, OUTPUT); pinMode(11, OUTPUT);

En el bloque loop() esperarán a que el ESP-01 haya enviado información y, de ser así, procederán a su lectura con el comando read(), almacenando el cuerpo de la petición HTTP en la variable orden.

while(puertoESP01.available() > 0){ caracter = puertoESP01.read(); orden = orden + caracter; }

Como seguramente recordarán, el contenido del cuerpo del mensaje de petición tiene el siguiente formato:

GPlO= n° del pin&Valor=n° en el rango 0-255

Cuando se haya recibido esta información, solo queda extraer el n.° del GPIO y su valor para, posteriormente, proceder a llevar a cabo la orden con el comando analogWrite().

if (orden != “”){ int gpio = orden.substring(orden.indexOf(“GPIO=”)+5, (orden.indexOf(“&”))).toInt(); int valor = orden.substring(orden.indexOf(“Valor=”)+6).toInt(); Serial.println(“GPIO: “ + String(gpio) + “ Valor: “ + String(valor)); analogWrite(gpio, valor); }

Al haber utilizado la librería SoftwareSerial, en este caso sí puede abrir el monitor serie de Arduino (no así el del ESP-01) y ver los mensajes informativos que aparecen con los números del GPIO y valor recibidos.

Para probar que todo funciona, compilen y carguen cada programa en su correspondiente plataforma. Recuerden que no podrán conectar entre sí ambas plataformas hasta no haber hecho esto antes. Después abran el navegador e introduzcan la dirección 192.168.1.99 en la barra de direcciones. Seleccionen un pin de la lista desplegable del formulario y muevan el deslizador a la posición deseada. Al pulsar el botón “Enviar”, deberán observar cómo el led conectado a dicho pin PWM se enciende con la intensidad elegida.

Pulsuz fraqment bitdi.