IOT hecho simple: jugando con el ESP32 en Arduino IDE

Exploremos en este tutorial, el ESP32, la fantástica placa de kit de desarrollo más nueva para uso de IoT. Esta placa, desarrollada por Espressif, debería ser la sucesora de NodeMCU, debido a su bajo precio y excelentes características.

Pero también es importante señalar que NO TODAS las bibliotecas o funciones a las que está acostumbrado a trabajar con ESP8266 y / o Arduino todavía son funcionales en esta nueva placa. Probablemente sea pronto, así que verifíquelo regularmente en ESP 32 Forum WebPage.

Aquí aprenderemos cómo programar el ESP32 en Arduino IDE, explorando sus funciones y bibliotecas más comunes, señalando algunas de las diferencias importantes y las nuevas características introducidas con este gran chip.

En resumen, exploraremos:

  • Salida digital: parpadeando un LED
  • Entrada digital: lectura de un sensor táctil
  • Entrada analógica: lectura de un voltaje variable desde un potenciómetro
  • Salida analógica: control de un brillo LED
  • Salida analógica: control de una posición de servo
  • Lectura de datos de temperatura / humedad con un sensor digital
  • Conectarse a Internet y obtener la hora local
  • Recibir datos de una página web local simple, encender / apagar un LED
  • Transmitiendo datos a una simple página web local

Paso 1: Las características principales de ESP32

El ESP32 es un tablero de menos de US $ 10 con grandes ventajas sobre tableros IoT similares en el mercado.

Esta placa tiene un microprocesador de doble proceso que ayuda mucho, porque cuando un procesador maneja la comunicación, el otro está a cargo del control de E / S, por ejemplo. Esta característica evitará algunos problemas que suceden con ESP8266, donde la única CPU necesita dejar de controlar las E / S cuando se maneja con Comm. Además, el ESP32 tiene WIFI integrado, BLUETOOTH, DAC, varios ADC (no solo uno como el ESP8266), sensores táctiles capacitivos, etc. (eche un vistazo al diagrama de bloques anterior). Y la buena noticia es que el consumo de energía es casi lo mismo que ESP8266.

Debajo de un cuadro que puede mostrarnos sus características principales y sus diferencias en comparación con ESP8266:

Señalemos sus propiedades principales con más detalles:

Características clave

  • Microcontrolador Tensilica LX6 de doble núcleo a 240 MHz con 600 DMIPS
  • Integrado 520 KB SRAM
  • Transceptor Wi-Fi integrado 802.11 b / g / n HT40, banda base, pila y LwIP
  • Bluetooth de modo dual integrado (clásico y BLE)
  • Memoria flash de 16 MB, asignada en memoria al espacio de código de la CPU
  • Voltaje de operación de 2.3V a 3.6V
  • Temperatura de funcionamiento de -40 ° C a + 125 ° C
  • Antena PCB integrada / conector IPEX para antena externa

Sensores:

  • Amplificador analógico de ultra bajo ruido
  • sensor de pasillo
  • 10x interfaces táctiles capacitivas
  • Oscilador de cristal de 32 kHz

34 x GPIO:

  • 3 x UART, incluido el control de flujo de hardware
  • 3 x SPI
  • 2 x I2S
  • 18 x canales de entrada ADC
  • 2 x DAC
  • 2 x I2C
  • Entrada / salida PWM / timer disponible en cada pin GPIO
  • Interfaz de depuración OpenOCD con búfer TRAX de 32 kB
  • SDIO maestro / esclavo 50 MHz
  • Admite flash SPI externo de hasta 16 MB
  • Soporte de interfaz de tarjeta SD

Seguridad relacionada:

  • WEP, WPA / WPA2 PSK / Enterprise
  • Cifrado acelerado por hardware: AES / SHA2 / Criptografía de curva elíptica / RSA-4096

Actuación:

  • Admite el modo directo sniffer, Station, SoftAP y Wi-Fi
  • Velocidad de datos máxima de 150 HT40, 72 HT20, 54 y 11
  • Potencia de transmisión máxima de 19.5, 16.5, 15.5
  • Sensibilidad mínima del receptor de -97 dBm
  • Rendimiento sostenido UDP de 135 Mbps
  • Consumo de energía de 5 μA en sueño profundo

Paso 2: BoM - Lista de materiales

  • Kit de desarrollo ESP32: placa de desarrollo ESP32 (US $ 8, 52)
  • Micro Servo: TowerPro SG90 9G Mini Servo (US $ 3.80)
  • Sensor de temperatura / humedad Sensor digital de temperatura y humedad DHT22 / AM2302 (US $ 9.99)
  • LED
  • 2 x resistencias: 330 ohmios y 10K ohmios
  • Potenciómetro: 10K ohmios
  • Protoboards

Paso 3: instalación de ESP32 Arduino IDE

Usaremos el IDE Arduino para programar nuestro ESP32, de la misma manera que lo hacemos con la familia ESP8266.

Instalar controladores:

Es importante que haya instalado en su computadora el controlador CP210x USB a UART actualizado. Ingrese en este enlace: usb-to-uart-bridge-vcp-drivers e instale el controlador adecuado para su sistema operativo.

Instalar biblioteca:

La novedad aquí es que Expressif en su GitHub nos dará las instrucciones adecuadas para la instalación de la biblioteca: arduino-esp32. Siga las instrucciones para su sistema operativo. En mi caso (MacOS), la instalación es muy simple:

Abra la Terminal y ejecute el siguiente comando (copiar-> pegar y presionar enter):

 mkdir -p ~ / Documentos / Arduino / hardware / espressif && \ cd ~ / Documentos / Arduino / hardware / espressif && \ git clone //github.com/espressif/arduino-esp32.git esp32 && \ cd esp32 / tools / && \ python get.py 

Después de eso, reinicie Arduino IDE y ¡listo! Debe ver varios tableros en el menú "HERRAMIENTAS". Seleccione el apropiado para usted. En general, el MÓDULO DEV ESP32 "genérico" funciona bien.

Cuando abra el IDE de Arduino por primera vez, notará que la velocidad de carga predeterminada es de 921, 600 baudios. Esto puede provocar inestabilidad. ¡Cámbielo a 115.200 baudios !

Paso 4: ¡Hola mundo! Parpadeando un LED

Como de costumbre, lo primero que debemos hacer cuando comenzamos a explorar un nuevo HW es parpadear un LED.

Vaya al menú de ejemplos en el IDE y abra el boceto Blink.

El ESP32 DevKit tiene un LED incorporado que está conectado a su GPIO 02. Es importante verificar si IDE reconoce automáticamente " LED_BUILTIN ". Si no, debe agregar al código de la línea:

 int LED_BUILTIN = 2; 
Cada placa ESP32 tiene un LED interno conectado a un GPIO diferente
 / * ESP 32 Blink Enciende un LED durante un segundo y luego lo apaga durante un segundo, repetidamente. El ESP32 tiene un LED azul interno en D2 (GPIO 02) * / int LED_BUILTIN = 2; configuración nula () {pinMode (LED_BUILTIN, OUTPUT); } void loop () {digitalWrite (LED_BUILTIN, HIGH); // enciende el LED (HIGH es el nivel de voltaje) delay (1000); // espera un segundo digitalWrite (LED_BUILTIN, LOW); // apaga el LED haciendo que el voltaje LOW delay (1000); // Espera un segundo } 

Debajo del LED interno parpadeando (observe la luz azul) junto con uno externo conectado a GPIO 2:

Hay varios tableros diferentes con diferentes mapas de pin en el mercado. El diagrama de arriba muestra el tablero que estoy usando. Puede encontrarlo aquí: / ESP32-Development-Board

¡Perfecto! Entonces, DigitalWrite () funciona perfectamente, de la misma manera con ESP8266 y Arduino. Por cierto, DigitalRead () también funciona de la misma manera para leer una entrada digital, como un botón, por ejemplo.

Paso 5: el sensor táctil

¡Pasemos a una nueva característica genial, el sensor táctil !

El ESP32 tiene 10 sensores táctiles capacitivos internos. Puede usarlo como botones, por ejemplo.

Esos sensores están conectados con varios GPIO:

  • T0: GPIO 4
  • T1: GPIO 0
  • T2: GPIO 2
  • T3: GPIO 15
  • T4: GPIO 13
  • T5: GPIO 12
  • T6: GPIO 14
  • T7: GPIO 27
  • T8: GPIO 33
  • T9: GPIO 32

Para leerlos debe usar la función: touchRead (Touch Pin #);

Por ejemplo, para leer el Sensor táctil 0 (T0), debe hacer algo como:

 valor int = touchRead (4); 

Creemos un código, donde si tocamos el sensor T0 (GPIO4), el LED estará encendido.

Use el monitor en serie para verificar los valores leídos por el sensor y ajuste el código correctamente.

Debajo del código completo:

 / ************************************************* **** * ESP32 Touch Test y LED Ctrl * Touch pin ==> Touch0 es T0 que está en GPIO 4 (D4). * LED pin ==> D2 * * MJRoBot.org 6Sept17 ************************************* **************** / #define TOUTCH_PIN T0 // ESP32 Pin D4 #define LED_PIN 2 int touch_value = 100; configuración nula () {Serial.begin (115200); retraso (1000); // dame tiempo para que aparezca el monitor serie Serial.println ("Prueba táctil ESP32"); pinMode (LED_PIN, SALIDA); digitalWrite (LED_PIN, BAJO); } void loop () {touch_value = touchRead (TOUTCH_PIN); Serial.println (touch_value); // obtener valor usando T0 if (touch_value <50) {digitalWrite (LED_PIN, HIGH); } else {digitalWrite (LED_PIN, LOW); } retraso (1000); } 

Y debajo del ESP32 funcionando:

Paso 6: entrada analógica

Veamos ahora cómo ingresar señales de valores analógicos.

En total hay canales de entrada ADC de 18 x 12 bits, en comparación con solo 1 X 10 bits ADC en NodeMCU.

Canal GPIO ADC

  • GPIO 0 ==> ADC2_CH1
  • GPIO 2 ==> ADC2_CH2
  • GPIO 4 ==> ADC2_CH0
  • GPIO 12 => ADC2_CH5
  • GPIO 13 => ADC2_CH4
  • GPIO 14 => ADC2_CH6
  • GPIO 15 => ADC2_CH3
  • GPIO 25 => ADC2_CH8
  • GPIO 26 => ADC2_CH9
  • GPIO 27 => ADC2_CH7
  • GPIO 32 => ADC1_CH4
  • GPIO 33 => ADC1_CH5
  • GPIO 34 => ADC1_CH6
  • GPIO 35 => ADC1_CH7
  • GPIO 36 => ADC1_CH0
  • GPIO 37 => ADC1_CH1
  • GPIO 38 => ADC1_CH2
  • GPIO 39 => ADC1_CH3

Para leer la entrada analógica, hará lo mismo que hizo con Arduino y ESP8266:

 int analog_value = analogRead (36); 

Es muy importante tener en cuenta que los ADC ESP32 tienen 12 bits de resolución (frente a 10 bits en ESP8266 y Arduino), por lo que el rango total de lectura de ADC es de 4.095 (en lugar de 1.027 en Arduinos y ESP8266) cuando se aplica un máximo de 3.3V a sus entradas

Para la entrada, usemos un potenciómetro de 10K ohmios, conectándolo desde 3.3V y GND. Usemos su salida variable para ser la entrada de los pines ESP32 ADC. El diagrama de arriba muestra el potenciómetro conectado al GPIO 36 que es el canal 0. ADC1. Pruebe también otras entradas en su placa.

Ejecute el código simple a continuación:

 / ************************************************* ***** * Prueba de entrada analógica ESP32 * Entrada analógica: ADC_1_0 pin ==> GPIO36 (VP). * * MJRoBot.org 6Sept17 ******************************************** ********* / // Entrada analógica #define ANALOG_PIN_0 36 int analog_value = 0; configuración nula () {Serial.begin (115200); retraso (1000); // dame tiempo para que aparezca el monitor serie Serial.println ("Prueba ESP32 Analog IN"); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (analog_value); retraso (500); } 

Gire su potenciómetro y observe en el monitor serial IDE las mediciones que van de cero a 4, 095.

Paso 7: Atenuar un LED: Salida analógica usando PWM

Si queremos "Atenuar un LED" en ESP8266 o un Arduino, simplemente podemos usar un comando como analogWrite (), que variará el valor PWM de su salida, simulando un valor analógico. Desafortunadamente, todavía no tenemos ese tipo de comando desarrollado para ESP32 en Arduino IDE. pero la muy buena noticia es que los 36 GPIO ESP32 tienen una capacidad PWM, ¡qué bueno! Solo debemos usar un código más complejo para alcanzar el mismo resultado.

Entonces, programemos uno de esos GPIO con una señal de salida PWM.

Puede encontrar un muy buen tutorial en detalles sobre cómo funciona PWM en este enlace: esp32-arduino-led-pwm-fading.

Lo primero que debe pensar en una señal PWM que se generará es su frecuencia. Usaremos un valor de 5000 Hz, que funciona bien con el LED. También debemos especificar el canal LED PWM y la resolución del ciclo de trabajo PWM, en bits. Podemos elegir un canal de 0 a 15 y una resolución entre 1 y 16 bits. Usaremos el canal 0 y una resolución de 8 bits.

 int freq = 5000; int ledChannel = 0; resolución int = 8; 

Usemos GPIO2, donde tenemos nuestro LED externo conectado (y el interno).

 #define LED_PIN 2 

Esos parámetros deben definirse durante la fase de configuración (), utilizando las siguientes funciones:

 configuración nula () {ledcSetup (ledChannel, freq, resolución); ledcAttachPin (LED_PIN, ledChannel); } 

Para encender el LED con un brillo específico, debemos definir el "ciclo de trabajo".

Por ejemplo, para apagar el LED, el ciclo de trabajo debe ser cero y la función ledcWrite (ledChannel, dutyCycle) utilizada para enviar el valor a través de un canal PWM específico:

 int dutyCycle = 0; ledcWrite (ledChannel, dutyCycle); 

Los diferentes valores de la variable dutyCycle encenderán el LED con diferente brillo. Esta variable, dutyCycle, variará de 0 a 255, una vez que la resolución utilizada sea de 8 bits.

Podemos usar el potenciómetro (conectado a la variable analog_value ) para configurar manualmente la variable dutyCycle, pero una vez que su rango de valores sea diferente, usemos una función de mapa para hacer coincidir la entrada y la salida:

 dutyCycle = map (analog_value, 0, 4095, 0, 255); 

Debajo del código completo:

 ************************************************** *** * Prueba de entrada / salida analógica ESP32 * Entrada analógica: ADC_1_0 pin ==> GPIO36 (VP). * PWM LED pin ==> GPIO 02 * * MJRoBot.org 6Sept17 *********************************** ****************** / // Entrada analógica #define ANALOG_PIN_0 36 int analog_value = 0; // PMW LED #define LED_PIN 2 int freq = 5000; int ledChannel = 0; resolución int = 8; int dutyCycle = 0; configuración nula () {Serial.begin (115200); retraso (1000); // dame tiempo para que aparezca el monitor serial Serial.println ("Prueba ESP32 Analog IN / OUT"); ledcSetup (ledChannel, freq, resolución); ledcAttachPin (LED_PIN, ledChannel); ledcWrite (ledChannel, dutyCycle); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.println (analog_value); dutyCycle = map (analog_value, 0, 4095, 0, 255); ledcWrite (ledChannel, dutyCycle); retraso (500); } 

¡Eso es!

Paso 8: Servo Control

Controlemos un servomotor usando la capacidad PWM de nuestro ESP32. El código será básicamente el mismo que se usó para controlar el brillo del LED.

Primero, es importante recordar que la frecuencia para trabajar con un Micro Servo es de 50Hz, por lo que debemos cambiar el parámetro de frecuencia a 50 (en lugar de 5, 000 utilizados con LED). También debemos especificar el canal LED PWM y la resolución del ciclo de trabajo PWM, en bits. Usaremos nuevamente el canal 0 y una resolución de 8 bits.

 int freq = 50; int canal = 0; resolución int = 8; 

El Servo se conectará a GPIO 5 (consulte el diagrama eléctrico anterior).

 #define SERVO_PIN 5 

Al igual que con el LED, esos parámetros deben definirse durante la fase de configuración (), utilizando las siguientes funciones:

 configuración nula () {ledcSetup (canal, frecuencia, resolución); ledcAttachPin (SERVO_PIN, canal); } 

Para colocar el servo en un ángulo específico, debemos definir el "ciclo de trabajo" (consulte el diagrama anterior).

Por ejemplo, para colocar el servo alrededor de 90 grados, el ciclo de trabajo debe ser alrededor de 21 y la función ledcWrite (ledChannel, dutyCycle) debe usarse para enviar el valor a través del canal PWM:

 int dutyCycle = 21; ledcWrite (channel, dutyCycle); 

Los diferentes valores de la variable dutyCycle posicionarán el servo con diferentes ángulos. Esta variable, dutyCycle, debe variar de 10 a 32 (este rango se obtuvo manualmente).

Al igual que lo hicimos con el LED, el potenciómetro (conectado a la variable de valor analógico ) se puede usar para configurar manualmente la variable dutyCycle y así cambiar la posición del servo. Una vez que sus rangos de valores son diferentes, usemos una función de mapa para hacer coincidir la entrada y la salida:

 dutyCycle = map (analog_value, 0, 4095, 10, 33); 

Debajo del código completo:

 / ************************************************* **** * ESP32 Servo Control * Entrada analógica: ADC_1_0 pin ==> GPIO36 (VP). * PWM SERVO pin ==> GPIO 05 * * MJRoBot.org 6Sept17 *********************************** ****************** / // Entrada analógica #define ANALOG_PIN_0 36 int analog_value = 0; // PMW SERVO #define SERVO_PIN 5 int freq = 50; int canal = 0; resolución int = 8; int dutyCycle = 21; configuración nula () {Serial.begin (115200); retraso (1000); // dame tiempo para que aparezca el monitor serie Serial.println ("ESP32 Servo Control"); ledcSetup (canal, frecuencia, resolución); ledcAttachPin (SERVO_PIN, canal); ledcWrite (channel, dutyCycle); } void loop () {analog_value = analogRead (ANALOG_PIN_0); Serial.print (analog_value); Serial.print ("Ciclo de trabajo ==>"); Serial.println (dutyCycle); dutyCycle = map (analog_value, 0, 4095, 10, 33); ledcWrite (channel, dutyCycle); retraso (50); } 

¡Ahora podemos trabajar con el sensor ultrasónico en la parte superior del servo y construir un radar IoT !. ¡Pero este será otro tutorial! ;-)

Paso 9: Conexión a Internet: marca de hora local

Después de probar algunas de las capacidades digitales / analógicas y de entrada / salida de GPIO, ¡conectemos nuestro ESP32 en Internet!

Con la familia ESP8266 estábamos usando la biblioteca esp8266wifi.h para eso. Con el ESP32, la biblioteca a utilizar será:

Un ejemplo muy simple sería programar nuestra placa para capturar desde Internet la hora local. Esta es una característica muy buena para tener a la mano en proyectos. El siguiente código lo hará por nosotros:

 / ************************************************* ************* * Marca de hora local con ESP32 * Desarrollado por Marcelo Rovai - 8 de septiembre de 2017 ********************** **************************************** / #include #include #include #define NTP_OFFSET -3 * 60 * 60 // En segundos #define NTP_INTERVAL 60 * 1000 // En milisegundos #define NTP_ADDRESS "europe.pool.ntp.org" WiFiUDP ntpUDP; NTPClient timeClient (ntpUDP, NTP_ADDRESS, NTP_OFFSET, NTP_INTERVAL); configuración nula () {Serial.begin (115200); timeClient.begin (); } 

Puede ver en el monitor de serie la hora local que se estampa.

Paso 10: servidor WiFi simple

Probemos ahora nuestro ESP32 como un simple servidor WiFi.

  • Abra el menú EJEMPLOS en su Arduino IDE y obtenga el boceto ESP32 WiFi / SimpleWiFiServer.ino:

Sobre este programa:

Parpadeo de LED del servidor web WiFi

  • Creado para arduino el 25 de noviembre de 2012 por Tom Igoe
  • Portado para sparkfun esp32 31.01.2017 por Jan Hendrik Berlin

Un servidor web simple que le permite parpadear un LED a través de la web. Este boceto imprimirá la dirección IP de su red WiFi ESP32 en el monitor de serie. Desde allí, puede abrir esa dirección en un navegador web para encender y apagar el LED en el pin 5.

Si la dirección IP de su placa es, por ejemplo, 10.0.1.40 :

  • //10.0.1.40/H enciende el LED
  • //10.0.1.40/L

    apaga el LED

Este ejemplo está escrito para una red que usa encriptación WPA. Para WEP o WPA, cambie la llamada Wifi.begin () en consecuencia.

Circuito: LED conectado al pin 5

Entonces, usemos el programa sin modificaciones significativas. Cambie el pin LED externo a GPIO5

Por supuesto, si prefiere cambiar el código para GPIO2 sin cambiar el HW.

Primero, ingrese sus credenciales de red:

 const char * ssid = "tuyo"; const char * contraseña = "yourpasswd"; 

Y cárguelo en su ESP32.

Lo primero que verá en su monitor serie será la información de que su ESP32 está conectada y cuál es su dirección IP:

 WiFi conectado. Dirección IP: 10.0.1.40 

Abra su navegador favorito, escribiendo esta dirección IP. Obtendrá una página web como la de arriba. Allí puede encender o apagar el LED de forma remota.

Paso 11: DHT 22 - Temperatura y humedad de lectura

Un sensor muy útil para usar en proyectos de IoT es el DHT 11 o 22. Son muy baratos y fáciles de incluir en sus proyectos.

Primero, necesita tener la Biblioteca Adafrut instalada en su IDE. Vaya a su GitHub y descargue la versión actualizada de esta biblioteca: DHT-sensor-library

Descomprima el archivo, cámbiele el nombre a DHT y mueva la carpeta completa a su directorio de la Biblioteca Arduino

Cuando lo usé por primera vez, recibí un mensaje:

error fatal: Adafruit_Sensor.h: No existe tal archivo o directorio

Después de investigar un poco, descubrí que también es necesario tener instalada la Biblioteca de sensores unificados de Adafruit . Entonces, lo hice desde Arduino IDE Library Manager (ver imagen de arriba). Después de eso, todo funcionó bien, igual que solíamos hacer con Arduino y NodeMCU.

Hagamos algunas pruebas con este sensor. Siga el diagrama eléctrico anterior e instale el DHT22 como se muestra (mirando el sensor con la "rejilla" hacia usted, cuente las 4 patas de izquierda a derecha):

  1. Pin VCC ==> 3.3V
  2. Pin Data ==> GPIO 23
  3. CAROLINA DEL NORTE
  4. PIN GND ==> GND

Además, conecte una resistencia de 10K ohmios entre VCC y Datos.

¡Eso es!

Puede usar el boceto de ejemplo "DHT tester.ino" que está incluido en la biblioteca, o hacer el suyo.

Escribí un código simple para probar el sensor como se muestra a continuación:

 / ************************************************* **** * ESP32 Lectura DHT * Entrada DHT: ==> GPIO23. * * MJRoBot.org 9Sept17 ******************************************** ********* / / * DHT * / #include "DHT.h" #define DHTPIN 23 #define DHTTYPE DHT22 DHT dht (DHTPIN, DHTTYPE); flotante localHum = 0; flotante localTemp = 0; configuración nula () {Serial.begin (115200); retraso (1000); // dame tiempo para que aparezca el monitor serie Serial.println (""); Serial.println ("ESP32 DHT Temperatura y Humedad"); Serial.println (""); dht.begin (); } void loop () {getDHT (); Serial.print ("Temp: ==>"); Serial.print (localTemp); Serial.print ("Hum ==>"); Serial.println (localHum); retraso (2000); } / ************************************************ *** * Obtenga datos de temperatura / zumbido en interiores **************************************** ************ / void getDHT () {float tempIni = localTemp; flotador humIni = localHum; localTemp = dht.readTemperature (); localHum = dht.readHumidity (); if (isnan (localHum) || isnan (localTemp)) // Verifique si alguna lectura falló y salga temprano (para volver a intentarlo). {localTemp = tempIni; localHum = humIni; regreso; }} 

Puede ver el resultado en la PrintScreen de Monitor serie anterior.

Paso 12: Enviar y recibir datos de una página web local

Revisando lo que cubrimos hasta ahora en este tutorial:

  • Salida digital: parpadeando un LED
  • Entrada digital: lectura de un sensor táctil
  • Entrada analógica: lectura de un voltaje variable desde un potenciómetro
  • Salida analógica: control de un brillo LED
  • Salida analógica: control de una posición de servo
  • Lectura de datos de temperatura / humedad con un sensor digital
  • Conectarse a Internet y obtener la hora local
  • Crear una página web simple para encender / apagar un LED (recibir datos)

Nos damos cuenta de que aún debemos intentar enviar datos a una página web. ¡Hagamoslo!

Tomaremos los datos generados por nuestro sensor DHT y el valor analógico proporcionado por el potenciómetro y los enviaremos a la página web creada para controlar los LED.

Comencé con el código SimpleWiFiServer utilizado en el paso 10 y agregué las líneas de código pertinentes para obtener el potenciómetro y los datos DHT.

Tenga en cuenta que moví el LED a GPIO 2 como puede ver en el diagrama eléctrico.

Descargue el código completo de mi GitHub: ESP32_WiFi_Server_Sending_Receiving_Data.ino

Tenga en cuenta que organicé mejor el código y ahora, el loop () es solo:

 void loop () {analog_value = analogRead (ANALOG_PIN_0); getDHT (); WiFiLocalWebPageCtrl (); } 

La novedad aquí es la función "WiFiLocalWebPageCtrl ()". Pero, esta es exactamente la función setup () original utilizada en SimpleWebServer. Lo que incluí dentro de esta función, es lo que debería aparecer en la página web (vea la pantalla de impresión anterior para la página web).

 // el contenido de la respuesta HTTP sigue el encabezado: // WiFiLocalWebPageCtrl (); client.print ("La temperatura ahora es:"); client.print (localTemp); client.print ("oC 
"); client.print (" La humedad ahora es: "); client.print (localHum); client.print ("%
"); client.print ("
"); client.print (" Datos analógicos: "); client.print (analog_value); client.print ("
"); client.print ("
"); client.print (" Haga clic aquí para encender el LED.
"); client.print (" Haga clic aquí para apagar el LED.
");
Tenga en cuenta que la temperatura, la humedad y los valores analógicos se actualizarán cada vez que haga clic en los enlaces utilizados para el control LED o cuando actualice la página.

Paso 13: conclusión

Podríamos seguir y seguir aquí, pero nunca cubriríamos todas las funciones o potencialidades de ESP32. Queda mucho por explorar con este gran dispositivo IoT y en mi próximo tutorial, aprenderá cómo agregar una pantalla OLED en su ESP32:

Pantalla ESP32 y OLED: Reloj de Internet - DHT22

¡Volveremos pronto con nuevos tutoriales ESP32!

¡Como siempre, espero que este proyecto pueda ayudar a otros a encontrar su camino en el emocionante mundo de la electrónica, la robótica y el IoT!

Visite mi GitHub para ver los archivos actualizados: Jugar con ESP32 y Arduino IDE

Para más proyectos, visite mi blog: MJRoBot.org

¡Saludos del sur del mundo!

¡Nos vemos en mi próximo instructable!

Gracias,

Marcelo

Artículos Relacionados