Estación Meteorológica IoT con TensorFlow Predice Intensidad de Lluvia con Precisión

Componentes y materiales

Componente	Cantidad	Notas
Kit estación meteorológica DFRobot (anemómetro, veleta, cubeta lluvia)	1
NodeMCU ESP8266 (ESP-12E)	1	WiFi
Shield SIM808 GPS/GPRS/GSM para Arduino (DFRobot)	1	GPRS
Arduino UNO	1
Raspberry Pi 3 Model B+ o 4	1	Servidor web / base de datos
Protoboard soldable mini (SparkFun)	2

Herramientas necesarias

• Pistola de pegamento caliente

Aplicaciones y servicios online

• Arduino IDE
• TensorFlow
• Microsoft Visual Studio 2017

Sobre el proyecto

En 2020, lluvias intensas y violentas causaron graves daños en invernaderos y cultivos en mi región. Estos eventos son más frecuentes por el cambio climático, mientras otras zonas sufren sequía. Más de 35 incidentes con pérdidas de cultivos y ganado por lluvias extremas se registraron. Para ayudar a prevenir estos efectos en la agricultura, creé esta estación meteorológica remota y económica que recolecta e interpreta datos locales para predecir la intensidad de la lluvia.

La lluvia excesiva causa: inundaciones (riesgo vidas), daños a infraestructuras, pérdida de cultivos/ganado, deslizamientos. Estudios muestran que afecta productividad igual que sequía: «datos de tres décadas sugieren que lluvia excesiva reduce rendimiento de maíz hasta 34 %; sequía y calor extremo hasta 37 %» (Univ. Illinois).

Los sistemas de alerta temprana no bastan sin datos locales preliminares por invernadero/granja. Mi estación recopila datos locales y usa una red neuronal artificial (ANN) de clasificación para predecir intensidad de lluvia.

Investigaciones previas usan redes neuronales para predecir cantidad de lluvia, fenómenos meteorológicos, tornados, niebla, etc. (Tailandia, Australia).

Recolecté datos en balcón y patio (radio 3 km) durante >3 meses con kit DFRobot y dos placas:

• NodeMCU ESP-12E (WiFi)
• Arduino Uno + SIM808 (GPRS)

Así transmito por WiFi en balcón o GPRS si está lejos del router.

Uso Google Sheets (hoja de cálculo cloud) para agrupar datos vía API. Desarrollé una app web en PHP que recibe datos de las placas (HTTP GET) y los añade a la hoja.

Tras >3 meses recopilando cada 5 min, construí una ANN con TensorFlow para predecir intensidad de lluvia. Escalé y normalicé datos, asigné clases teóricas:

• 0 – Sin lluvia
• 1 – Lluvia ligera
• 2 – Lluvia moderada
• 3 – Lluvia fuerte
• 4 – Lluvia violenta

Entrené el modelo para clasificar estas clases. ¡Este es el proyecto en pocas palabras! 😃

Gracias a DFRobot por patrocinar: Kit estación meteorológica y Shield SIM808.

Paso 1: Montar kit estación meteorológica (anemómetro, veleta, cubeta lluvia)

El kit incluye anemómetro, veleta, cubeta y placa conversora que envía datos por serie (37 bytes/seg, fin CR/LF). Formato: c000s000g000t086r000p000h53b10020

• c000: dirección viento (grados)
• s000: velocidad media (0.1 mph)
• g000: velocidad máx (0.1 mph)
• t086: temperatura (°F)
• r000: lluvia 1h (0.01 pulg)
• p000: lluvia 24h (0.01 pulg)
• h53: humedad % (00=100)
• b10020: presión 0.1 hPa

Montaje: atornillar anemómetro y veleta al puente, conectar veleta a anemómetro con cable RJ11, montar varilla inoxidable, instalar junta cubeta, colocar cubeta en varilla. La placa conversora no es weatherproof: añadí caja plástica para protegerla y el shield SIM808.

Paso 2: Recopilar datos en Google Sheets

Crear proyecto en Google Developer Console, habilitar Google Sheets API, crear cuenta de servicio y clave, configurar pantalla de consentimiento, crear OAuth Client ID (Desktop app), descargar credentials.json.

Crear hoja en Google Sheets llamada «Remote Weather Station», columnas: WD, Av_WS, Mx_WS, 1h_RF, 24h_RF, Tem, Hum, b_PR. Opcional: gráficos.

Paso 3: App web PHP para añadir datos a la hoja

La app PHP recibe datos por GET y los añade a la hoja con credenciales verificadas y token. Requiere Google Client Library for PHP.

Carpeta remote_weather_station en servidor con: index.php, account_verification_token.php, credentials.json, token.json.

index.php: obtiene variables GET, conecta con Google API, carga token previo o solicita autorización (guarda código verificación en account_verification_token.php), añade fila a hoja (range A1:H1).

account_verification_token.php: variable $account_verification_token con código tras autorizar.

Paso 3.1: Desplegar app en Raspberry Pi (o cualquier servidor PHP)

1. Mover carpeta a /var/www/html/ (requiere sudo).
2. Primera vez da error por falta token. Abrir URL de autorización generada, permitir acceso, copiar código verificación a account_verification_token.php.
3. Recargar: muestra «Successful! Refresh the page» y guarda token.json.
4. Probar: https://localhost/remote_weather_station/?wd=12&a_ws=8&m_ws=11&1_rf=14&24_rf=84&tem=24&hum=32&b_pr=57 → añade fila.

Paso 4: Leer y enviar datos con ESP8266 (WiFi)

NodeMCU ESP-12E programado para enviar cada 5 min. Incluye librerías WiFi, HTTPClient, SoftwareSerial (pines D6 RX, D5 TX). Función getBuffer() lee 35 bytes de la estación. Parsea campos y construye URL GET al servidor. Envía cada 300 seg. Monitor serie muestra datos y respuesta HTTP 200 + «8 cells appended».

Paso 4.1: Leer y enviar datos con SIM808 (GPRS)

Arduino Uno + SIM808 para patio (lejos del router). Código similar, pero usa librería DFRobot_sim808. Inicializa módulo, hace DHCP (APN «cmnet»), establece TCP al servidor, convierte petición GET a char array y envía con sim808.send(). Cierra conexión tras envío.

Paso 4.2: Dataset >3 meses

Datos recogidos cada 5 min: dirección viento (deg), vel. media/máx (m/s), lluvia 1h/24h (mm), temp (°C), humedad (%), presión (hPa). 32.219 filas en CSV. Siguiendo recopilando para mejorar modelo.

Paso 5: Construir ANN con TensorFlow

En Python: visualización, escalado, preprocesado, división datos. Clases según tasa precipitación (mm/h): ligera <2.5, moderada 2.5-7.6, fuerte 7.6-50, violenta >50. Asigno clase 0-4 a cada lectura.

Escalado: dirección+velocidad viento → vector viento (componentes X/Y). Resto columnas / valor típico (temp/25, hum/70, presión/1013, lluvia24h/24). Entradas finales: scaled_WX, scaled_WY, scaled_max_WX, scaled_max_WY, scaled_Tem, scaled_Hum, scaled_bPR, scaled_24h_RF (7 inputs).

Etiquetas: tasa aprox = (1h_RF + scaled_24h_RF)*100 → clase 0-4. Split 60/40 train/test. Red: Input(7) → Dense(16, relu) → Dense(32, relu) → Dense(64, relu) → Dense(128, relu) → Dense(5, softmax). Optimizador Adam, loss sparse_categorical_crossentropy, 19 epochs. Precisión train 0.83-0.85, test 0.72-0.73 (overfitting por pocos datos test). Sigo recopilando datos.

Predicción: model.predict() devuelve probabilidades 5 clases; argmax da clase. Ejemplos: entradas → salidas [None, Heavy Rain, Violent Rain, Violent Rain].

Conexiones y ajustes (ESP8266)

NodeMCU ESP-12E : Weather Station
VV --------------------------- 5V
D5 --------------------------- RX
D6 --------------------------- TX
G  --------------------------- GND

Conexiones y ajustes (SIM808)

Arduino Uno: SIM808 Shield
D0 --------------------------- RX
D1 --------------------------- TX
D12 --------------------------- POWER
Weather Station:
5V --------------------------- 5V
D5 --------------------------- RX
D6 --------------------------- TX
GND --------------------------- GND

Notas: pines D0,D1,D12 ocupados por SIM808. Batería externa 7-23V para SIM808. Antenas GPS/GSM, tarjeta SIM. Switch función: None (1) antes de subir código, luego Arduino (3). Boot hasta Net LED parpadeo 1 seg, luego registro red (parpadeo lento 3 seg).

Vídeos y conclusiones

Tras codificar y montar, recopilé datos >3 meses cada 5 min y construí modelo ANN con éxito. Sigo recopilando en balcón y patio para mejorar precisión 😊

Discusiones futuras

• Estaciones NN económicas en granjas/invernaderos para prevenir daños por lluvia extrema.
• Enjambre de estaciones comunicándose para pronóstico local preciso.
• Usar datos para evaluar recursos hídricos, agricultura, productividad cultivos, ecosistemas, hidrología.

Referencias

1. NIWA: Extreme weather - heavy rainfall.
2. Univ. Illinois: Excessive rainfall as damaging to corn yield as extreme heat, drought, ScienceDaily 2019.
3. Andrew Culclasure: Using Neural Networks to Provide Local Weather Forecasts, Georgia Southern Univ. 2013.

Código

• IoT_weather_station_neural_network.py (Python/TensorFlow/Keras)
• ESP12E_remote_weather_station.ino (Arduino/ESP8266)
• SIM808_remote_weather_station.ino (Arduino/SIM808)
• index.php y account_verification_token.php (app web PHP)

Código completo en el artículo original (muy extenso). Incluye clase Weather_Station con métodos: visualización, escalado, creación inputs/etiquetas, split, construcción/entrenamiento modelo, evaluación, predicción, guardado.

Piezas personalizadas

remote_weather_station_OobOCQNPSW.csv (dataset de ejemplo)

Esquemáticos