Control de Bomba de Agua con ESP32
Control de una bomba de agua mediante un ESP32 programado en C
Ejemplo del proyecto una vez acabado
Este proyecto consiste en controlar una bomba de agua mediante un ESP32 conectado a la red local de tu hogar. Manejando la apertura de la bomba desde cualquier punto de tu casa.
Los materiales necesarios:
- Placa ESP32
- Bomba de agua de 5V
- Protoboard
A continuación se conectará el cable rojo de la bomba de agua al pin 2 del ESP32 y el cable negro al GND. Utilizaremos el IDE de Espressif para escribir el código y se compilará y ejecutará utilizando el CMD de ESP-IDF. Debemos ir al Administrador de Dispositivos para conocer el número de puerto COM al que está conectado nuestro ESP32.
Una vez conectado, se implementará el siguiente código:
#include <stdio.h>
#include <string.h>
#include “FreeRTOSConfig.h”
#include “freertos/FreeRTOS.h”
#include “freertos/task.h”
#include “esp_wifi.h”
#include “esp_event.h”
#include “nvs_flash.h”
#include “esp_log.h”
#include “esp_http_server.h”
#include “esp_netif.h”
#include “esp_system.h”
#include “driver/gpio.h” // Biblioteca necesaria para GPIO
#include “lwip/err.h”
#include “lwip/sys.h”
// Definiciones y constantes
#define WIFI_SSID “SSID de tu WiFi”
#define WIFI_PASSWORD “Contraseña de tu WiFi”
#define GPIO_BOMBA 2 // Pin GPIO para la bomba
#define HTTPD_MAX_REQ_HDR_LEN 1024
#define HTTPD_MAX_URI_LEN 512
#define STACK_OVERHEAD_APPTRACE 8192
static const char *TAG = “WiFi_HTTP_Server”;
//Manejamos la ruta raíz “/”
esp_err_t root_get_handler(httpd_req_t *req) {
const char* resp_str = “<html><body><h1>Control de Bomba</h1>”
“<a href=\”/bomba/abierta\”><button>Abrir Bomba</button></a><br>”
“<a href=\”/bomba/cerrada\”><button>Cerrar Bomba</button></a><br>”
“</body></html>”;
httpd_resp_send(req, resp_str, HTTPD_RESP_USE_STRLEN);
return ESP_OK;
}
//Manejamos la apertura de la bomba
esp_err_t abrir_bomba_handler(httpd_req_t *req) {
gpio_set_level(GPIO_BOMBA, 1); // Configura el GPIO para abrir la bomba
const char* resp_str = “<html><body><h1>Bomba abierta</h1></body></html>”;
httpd_resp_send(req, resp_str, HTTPD_RESP_USE_STRLEN);
return ESP_OK;
}
//Manejamos la cerradura de la bomba
esp_err_t cerrar_bomba_handler(httpd_req_t *req) {
gpio_set_level(GPIO_BOMBA, 0); // Configura el GPIO para cerrar la bomba
const char* resp_str = “<html><body><h1>Bomba cerrada</h1></body></html>”;
httpd_resp_send(req, resp_str, HTTPD_RESP_USE_STRLEN);
return ESP_OK;
}
// Configuración del servidor HTTP
httpd_handle_t start_webserver(void) {
// Configuramos el servidor con tamaños más grandes para las URI y encabezados
httpd_config_t config = HTTPD_DEFAULT_CONFIG();
//HTTPD_MAX_URI_LEN =
// Iniciar el servidor HTTP
httpd_handle_t server = NULL;
if (httpd_start(&server, &config) == ESP_OK) {
// Ruta raíz “/”
httpd_uri_t root_uri = {
.uri = “/”,
.method = HTTP_GET,
.handler = root_get_handler,
.user_ctx = NULL
};
httpd_register_uri_handler(server, &root_uri);
// Ruta para abrir la bomba “/bomba/abierta”
httpd_uri_t abrir_bomba_uri = {
.uri = “/bomba/abierta”,
.method = HTTP_GET,
.handler = abrir_bomba_handler,
.user_ctx = NULL
};
httpd_register_uri_handler(server, &abrir_bomba_uri);
// Ruta para cerrar la bomba “/bomba/cerrada”
httpd_uri_t cerrar_bomba_uri = {
.uri = “/bomba/cerrada”,
.method = HTTP_GET,
.handler = cerrar_bomba_handler,
.user_ctx = NULL
};
httpd_register_uri_handler(server, &cerrar_bomba_uri);
}
return server;
}
//Manejamos el evento de obtención de IP
static void event_handler(void* arg, esp_event_base_t event_base,
int32_t event_id, void* event_data) {
if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
ESP_LOGI(TAG, “Dirección IP asignada: “ IPSTR, IP2STR(&event->ip_info.ip));
}
}
// Conexión a la red WiFi
void wifi_init_sta(void) {
esp_netif_init();
esp_event_loop_create_default();
esp_netif_create_default_wifi_sta();
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
esp_wifi_init(&cfg);
wifi_config_t wifi_config = {
.sta = {
.ssid = WIFI_SSID,
.password = WIFI_PASSWORD
},
};
esp_wifi_set_mode(WIFI_MODE_STA);
esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config);
esp_wifi_start();
// Registrar el manejador de eventos para obtener la IP
esp_event_handler_instance_t instance_any_id;
esp_event_handler_instance_t instance_got_ip;
esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL, &instance_any_id);
esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler, NULL, &instance_got_ip);
esp_wifi_connect();
ESP_LOGI(TAG, “Conectando al WiFi: %s“, WIFI_SSID);
}
// Configuración del pin GPIO
void setup_gpio(void) {
gpio_config_t io_conf;
io_conf.intr_type = GPIO_INTR_DISABLE; // Sin interrupciones
io_conf.mode = GPIO_MODE_OUTPUT; // Modo salida
io_conf.pin_bit_mask = (1ULL << GPIO_BOMBA); // Pin GPIO específico
io_conf.pull_down_en = 0; // Sin pull-down
io_conf.pull_up_en = 0; // Sin pull-up
gpio_config(&io_conf);
}
// Función principal de la aplicación
void app_main(void) {
// Inicializar NVS (almacenamiento no volátil)
esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
nvs_flash_erase();
nvs_flash_init();
}
// Configurar GPIO
setup_gpio();
gpio_set_level(GPIO_BOMBA, 0); // Bomba inicialmente cerrada
// Iniciar WiFi
wifi_init_sta();
// Iniciar servidor web
httpd_handle_t server = start_webserver();
if (server) {
ESP_LOGI(TAG, “Servidor web iniciado correctamente.”);
} else {
ESP_LOGE(TAG, “Error al iniciar el servidor web.”);
}
}
Con la implementación de este código en la comunicación serie obtendremos la dirección IP a la que debemos acceder para controlar la bomba de agua. Obteniendo las siguientes líneas en el terminal.
En este caso nos conectaremos a la dirección 192.168.1.198
El proyecto acabado quedará de está manera, adjuntamos video con el resultado. El proyecto se ampliará en el artículo: Sistema de riego controlado desde el móvil
Esperamos que os haya servido de ayuda para completar vuestro proyecto o al menos para aprender algo que desconocíais.