Para este ejemplo utilizo una tarjeta Nodemcu con ESP32, una protoboard, un rele optoacoplador, fuente de alimentación MB102, sensor de humedad capacitivo y una minibomba.
Codigo del primer ejemplo:
#include <Arduino.h>
const int sensor = 12;
int valorsensor;
const int bomba=14;
void setup()
{
Serial.begin(9600);
pinMode(sensor, INPUT_PULLDOWN);
pinMode(bomba, OUTPUT);
}
void loop()
{
digitalWrite(bomba, LOW);
valorsensor = analogRead(sensor);
if(valorsensor>=2100){
digitalWrite(bomba, HIGH);
delay(500);
digitalWrite(bomba, LOW);
}
esp_sleep_enable_timer_wakeup(20000000);
esp_deep_sleep_start();
}Este código es para una placa ESP32 y está escrito en lenguaje C++. El código se divide en dos partes principales: la función setup() y la función loop().
La función setup() se encarga de configurar los pines del ESP32 para su uso posterior. En este caso, se establece que el pin 12 será utilizado como entrada con resistencia pull-down, lo que significa que cuando no hay voltaje en el pin, la resistencia interna de la placa tirará del voltaje a tierra. El pin 14 se establece como salida, lo que significa que se puede usar para enviar señales a otros componentes.
La función loop() es el bucle principal del programa. En primer lugar, se establece el pin 14 (la bomba) en LOW (bajo) para asegurarse de que esté apagada. Luego, se lee el valor del sensor conectado al pin 12 (valorsensor) usando la función analogRead(). Si el valor del sensor es mayor o igual a 2100, lo que puede indicar un nivel de agua alto, se enciende la bomba (digitalWrite(bomba, HIGH)) durante medio segundo (delay(500)) y luego se apaga de nuevo (digitalWrite(bomba, LOW)).
Finalmente, el código utiliza una función específica para el módulo ESP32 (esp_sleep_enable_timer_wakeup) para establecer una interrupción de tiempo y entrar en modo de sueño profundo (esp_deep_sleep_start). Este modo de sueño profundo consume muy poca energía, lo que lo hace útil para proyectos de bajo consumo de energía, como sensores alimentados por baterías. La interrupción de tiempo significa que el ESP32 despertará después de 20 millones de microsegundos (20 segundos) y se repetirá el bucle.
Codigo del segundo ejemplo mostrando en pantalla de un navegador:
#include <Arduino.h>
#include <WiFi.h>
const char *ssid = "ESP32";
const char *password = "12345678";
WiFiServer server(80);
String header;
int humedad;
const int bomba = 14;
const int sensor = 12;
void resetear(void *arg)
{
esp_restart();
}
void setup()
{
humedad = 0;
pinMode(bomba, OUTPUT);
digitalWrite(bomba, LOW);
pinMode(sensor, INPUT_PULLDOWN);
humedad = analogRead(sensor);
if (humedad >= 2100)
{
digitalWrite(bomba, HIGH);
delay(500);
digitalWrite(bomba, LOW);
}
esp_timer_create_args_t restart_timer_args = {
.callback = &resetear,
.name = "restart_timer"};
esp_timer_handle_t restart_timer;
esp_timer_create(&restart_timer_args, &restart_timer);
esp_timer_start_once(restart_timer, 120000000);
Serial.begin(9600);
WiFi.mode(WIFI_AP);
WiFi.softAP(ssid, password);
IPAddress IP = WiFi.softAPIP();
Serial.print("AP IP address: ");
Serial.println(IP);
server.begin();
}
void loop()
{
WiFiClient client = server.available();
if (client)
{
Serial.println("New Client.");
String currentLine = "";
while (client.connected())
{
if (client.available())
{
char c = client.read();
Serial.write(c);
header += c;
if (c == '\n')
{
if (currentLine.length() == 0)
{
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println("Connection: close");
client.println();
client.println("<!DOCTYPE html><html>");
client.println("<head><meta http-equiv=\"refresh\" name=\"viewport\" content=\"30,
width=device-width, initial-scale=1\">");
client.println("</style></head>");
client.println("<body><h1>ESP32 Humedad</h1>");
client.print("<h2>");
client.print(humedad);
client.println("</h2>");
client.println("</body></html>");
client.println();
break;
}
else
{
currentLine = "";
}
}
else if (c != '\r')
{
currentLine += c;
}
}
}
header = "";
client.stop();
Serial.println("Client disconnected.");
Serial.println("");
}
}
Este código es para una placa ESP32 y utiliza la biblioteca WiFi.h para crear un punto de acceso Wi-Fi y establecer una conexión con un cliente.
En la función setup(), se establece el pin 14 (la bomba) como salida y se configura el pin 12 como entrada con resistencia pull-down. Luego, se lee el valor del sensor conectado al pin 12 (humedad) usando la función analogRead(). Si el valor del sensor es mayor o igual a 2100, se enciende la bomba (digitalWrite(bomba, HIGH)) durante medio segundo (delay(500)) y luego se apaga de nuevo (digitalWrite(bomba, LOW)).
Después, se crea un temporizador que reinicia la placa cada 2 minutos. Se utiliza la función esp_timer_create_args_t para crear una estructura de argumentos para el temporizador, que incluye un puntero a la función resetear() y un nombre para el temporizador. Se crea un manejador de temporizador (restart_timer) y se inicia una cuenta regresiva de 2 minutos usando esp_timer_start_once().
A continuación, se establece una conexión Wi-Fi en modo de punto de acceso utilizando las funciones de la biblioteca WiFi.h. Se establece un SSID (nombre de red) y una contraseña, y se utiliza WiFi.softAP() para crear un punto de acceso Wi-Fi. Se imprime la dirección IP del punto de acceso en el puerto serie.
Finalmente, se inicializa un objeto server de la clase WiFiServer en el puerto 80, que se utilizará para recibir solicitudes de clientes.
En resumen, este código establece una conexión Wi-Fi en modo de punto de acceso, enciende una bomba si la humedad es demasiado alta y reinicia la placa cada 2 minutos. Además, crea un servidor web en el puerto 80 para recibir solicitudes de clientes.
A continuación tenemos el código que pertenece a la función loop() y se encarga de manejar las solicitudes de clientes que se conectan al servidor creado anteriormente.
Primero, se utiliza la función server.available() para verificar si hay un cliente disponible para conectarse. Si un cliente está disponible, se crea un objeto WiFiClient llamado «client».
A continuación, se utiliza un bucle while para leer los datos enviados por el cliente. Se utiliza la función client.connected() para comprobar si el cliente sigue conectado. Dentro del bucle, se utiliza la función client.available() para comprobar si hay datos disponibles para leer.
Si hay datos disponibles, se lee un carácter usando la función client.read() y se almacena en la variable «c». Se utiliza la función Serial.write() para enviar el carácter leído a través del puerto serie, lo que permite monitorear las solicitudes del cliente.
Se utiliza la variable «header» para almacenar los datos de la solicitud del cliente. Si se encuentra un carácter de nueva línea («\n»), se verifica la longitud de la línea actual. Si la longitud es cero, significa que se ha leído toda la solicitud del cliente y se procede a enviar una respuesta.
Se envía una respuesta HTTP 200 OK con encabezados de tipo de contenido y conexión. Luego se envía una página HTML que muestra el valor de humedad leído anteriormente. La página HTML también incluye una etiqueta meta que refresca la página cada 30 segundos.
Finalmente, se utiliza la función client.stop() para cerrar la conexión con el cliente y se limpia la variable «header». Se imprime un mensaje en el puerto serie indicando que el cliente se ha desconectado.
