Sistema de Monitoreo de Humedad Basado en STM32

Este sistema se centra en la adquisición de datos ambientales, su procesamiento local y la transmisión remota para un monitoreo inteligente. Su arquitectura modular permite su despliegue en entornos como invernaderos, almacenes o laboratorios.

1. Descripción de Módulos Principales

El sistema integra sensores de alta precisión para capturar variables ambientales. Un microcontrolador STM32 gestiona la lógica, filtrando la información y determinando si se superan umbrales predefinidos. Los datos pueden visualizarse en una pantalla OLED, almacenarse en memoria no volátiles y transmitirse a través de módulos inalámbricos como Wi-Fi o Bluetooth. La gestión de energía permite operar con baterías durante largos períodos.

2. Esquema del Hardware

Selección de Componentes

• Microcontrolador: STM32F103C8T6 (Cortex-M3, 72MHz).
• Sensor Ambiental: SHT30, comunicado vía bus I2C.
• Interfaz de Usuario: Pantalla OLED 128x64 píxeles (I2C).
• Almacenamiento: Memoria EEPROM tipo AT24C256 (I2C).
• Conectividad: Módulo ESP8266 para conexión Wi-Fi (UART).
• Alimentación: Circuito con carga de batería de litio y reguladores de tensión.

Diseño del Circuito

El bus I2C (pines PB6 y PB7) es compartido por el sensor, la pantalla y la EEPROM, utilizando resistencias pull-up de 4.7kΩ. Cada dispositivo en el bus tiene una dirección única asignada. Se incluyen capacitores de desacoplamiento en los pines de alimentación de cada módulo. El módulo ESP8266 se alimenta a través de un regulador LDO independiente y se comunica con el STM32 mediante los pines UART (PA9 y PA10).

3. Implementación del Software

El firmware está estructurado alrededor del sistema operativo en tiempo real FreeRTOS, con tareas concurrantes para la adquisición, procesamiento, visualización, almacenamiento y comunicación de datos.

3.1 Driver para el Sensor SHT30

El siguiente código inicializa y lee los datos del sensor a través del protocolo I2C, aplicando un cálculo de temperatura y humedad relativa a partir de los valores brutos recibidos.

// Archivo: sht30_driver.c
#include "stm32f1xx_hal.h"

#define SHT30_I2C_ADDR  (0x44 << 1)
#define CMD_MEASURE     0x2400
#define CMD_SOFT_RESET  0x30A2

I2C_HandleTypeDef hi2c1;

void SHT30_Iniciar(void) {
    uint8_t reset_cmd[2] = {CMD_SOFT_RESET >> 8, CMD_SOFT_RESET & 0xFF};
    HAL_I2C_Master_Transmit(&hi2c1, SHT30_I2C_ADDR, reset_cmd, 2, 100);
    HAL_Delay(50);
}

uint8_t SHT30_ObtenerDatos(float *temperatura, float *humedad) {
    uint8_t buffer_rx[6];
    uint8_t buffer_tx[2] = {CMD_MEASURE >> 8, CMD_MEASURE & 0xFF};

    HAL_I2C_Master_Transmit(&hi2c1, SHT30_I2C_ADDR, buffer_tx, 2, 100);
    HAL_Delay(20); // Espera para la medición de alta precisión

    if (HAL_I2C_Master_Receive(&hi2c1, SHT30_I2C_ADDR, buffer_rx, 6, 100) != HAL_OK) {
        return 1; // Error de comunicación
    }

    uint16_t raw_temp = (buffer_rx[0] << 8) | buffer_rx[1];
    uint16_t raw_hum = (buffer_rx[3] << 8) | buffer_rx[4];

    *temperatura = -45.0f + (175.0f * (float)raw_temp / 65535.0f);
    *humedad = 100.0f * (float)raw_hum / 65535.0f;

    // Omitiendo verificación CRC8 por brevedad.
    return 0; // Éxito
}

3.2 Procesamiento de Datos y Filtrado

Se aplica un filtro de media móvil exponencial (EMA) para suavizar las lecturas del sensor, reduciendo el impacto de picos de ruido.

// Archivo: data_processing.c
typedef struct {
    float temperatura_filtrada;
    float humedad_filtrada;
    float factor_suavizado; // e.g., 0.1
} ProcesadorDatos_t;

void ProcesadorDatos_Init(ProcesadorDatos_t *proc, float factor) {
    proc->temperatura_filtrada = 0.0f;
    proc->humedad_filtrada = 0.0f;
    proc->factor_suavizado = factor;
}

void ProcesadorDatos_Actualizar(ProcesadorDatos_t *proc, float temp_nueva, float hum_nueva) {
    proc->temperatura_filtrada = proc->factor_suavizado * temp_nueva + 
                                (1.0f - proc->factor_suavizado) * proc->temperatura_filtrada;
    proc->humedad_filtrada = proc->factor_suavizado * hum_nueva + 
                            (1.0f - proc->factor_suavizado) * proc->humedad_filtrada;
}

uint8_t ProcesadorDatos_VerificarAlarmas(float temperatura, float humedad, float lim_inf_temp, float lim_sup_temp, float lim_inf_hum, float lim_sup_hum) {
    uint8_t alarma = 0;
    if (temperatura < lim_inf_temp || temperatura > lim_sup_temp) alarma |= 0x01;
    if (humedad < lim_inf_hum || humedad > lim_sup_hum) alarma |= 0x02;
    // La función retorna una máscara de bits indicando qué variable está fuera de rango.
    return alarma;
}

3.3 Tarea Principal del Sistema (Main)

El código principal configura el sistema y crea las tareas de FreeRTOS para el ciclo operativo completo.

// Archivo: main.c
#include "FreeRTOS.h"
#include "task.h"
#include "sht30_driver.h"
#include "data_processing.h"

ProcesadorDatos_t miProcesador;
float lectura_temp, lectura_hum;

void TareaAdquisicion(void *params) {
    SHT30_Iniciar();
    ProcesadorDatos_Init(&miProcesador, 0.2f);
    for (;;) {
        if (SHT30_ObtenerDatos(&lectura_temp, &lectura_hum) == 0) {
            ProcesadorDatos_Actualizar(&miProcesador, lectura_temp, lectura_hum);
            // Enviar datos procesados a otras tareas mediante colas o flags
        }
        vTaskDelay(pdMS_TO_TICKS(5000)); // Lee cada 5 segundos
    }
}

int main(void) {
    HAL_Init();
    SystemClock_Config();
    // ... Inicialización de periféricos (I2C, UART, GPIO) ...

    xTaskCreate(TareaAdquisicion, "ADC_Task", 512, NULL, 3, NULL);
    // Crear otras tareas para display, almacenamiento y comunicación...

    vTaskStartScheduler();
    while(1) {}
}

4. Consideraciones de Diseño y Optimización

Precisión y Calibración

El correcto funcionamiento del bus I2C es crítico. Se debe evitar superar los 400 kHz en la frecuencia del reloj (SCL). Para una precisión a largo plazo, es recomendable realizar calibraciones periódicas utilizando un instrumento de referencia, almacenando los parámetros de corrección en la EEPROM.

Eficiencia Energética

Para maximizar la vida de la batería, el microcontrolador debe entrar en modos de bajo consumo (STOP) entre ciclos de adquisición. Los módulos de alta corriente, como la pantalla OLED y el transmisor Wi-Fi, deben desconectarse físicamente cuando no están en uso, por ejemplo, utilizando un transistor MOSFET controlado por un pin GPIO.

Fiabilidad de los Datos

La verificación CRC incluida en las tramas del sensor SHT30 debe implementarse para descartar lecturas corruptas. Los datos críticos, como los límites de alarma, deben guardarse en memoria no volátil para sobrevivir a un reinicio del sistema.

5. Pruebas y Extensibilidad

Procedimiento de Verificación

1. Validación de Señales: Usar un osciloscopio para verificar la integridad de las señales I2C y UART.
2. Prueba del Sensor: Comparar las lecturas crudas del sensor con un termohigrómetro calibrado.
3. Prueba de Integración: Verificar el flujo completo de datos desde la adquisición hasta su visualización en una aplicación remota.

Potenciales Mejoras

• Integrar sensores adicionales como luminosidad (BH1750) o presión atmosférica (BMP280).
• Desarrollar una aplicación web o móvil para la visualización de datos históricos y la configuración remota.
• Implementar un sistema de alimentación híbrida con un panel solar y un cargador de batería inteligente.