Sistema de Alerta de Lluvia de Frecuencia Modulada (SARFM)

Este artículo presenta un proyecto de electrónica que transforma la detección de lluvia y su intensidad en una alerta acústica progresiva. El Sistema de Alerta de Lluvia de Frecuencia Modulada (SARFM) utiliza un microcontrolador Arduino para modular la velocidad de un zumbador, comunicando la urgencia de la precipitación. Entre más intenso sea el aguacero, más rápido y estridente será el pulso de la alarma.

🔩Funcionamiento

La clave de este proyecto reside en la interconexión entre un fenómeno físico (la conductividad del agua) y una técnica de procesamiento digital (el mapeo de datos).

El Principio del Sensor Resistivo (DGZZI)

El Sensor de Lluvia DGZZI es, en esencia, un divisor de voltaje resistivo dependiente de la humedad. La placa sensora es una matriz de cobre con pistas entrelazadas.

• Estado Seco: Sin agua, las pistas están separadas por aire (un excelente aislante). La resistencia es extremadamente alta (cercana al infinito). El módulo electrónico asociado (que a menudo utiliza un comparador LM393 o similar) traduce esta alta resistencia a una salida de voltaje alto (cercano a 5V).
• Estado Húmedo: Al caer el agua (un electrolito débil debido a iones y sales disueltas), se crean puentes conductivos entre las pistas. La resistencia disminuye drásticamente. Esto provoca una caída en el voltaje de salida del módulo.

Conversión Analógica-Digital (ADC)

El Arduino Uno lee este voltaje variable a través de su pin Analógico A0. Su Convertidor Analógico-Digital (ADC) de 10 bits traduce el rango de 0V a 5V en un valor discreto de 0 a 1023.

• 5V (Máxima Resistencia, Seco) → Valor 1023.
• 0V (Mínima Resistencia, Saturado) → Valor 0.

El núcleo del SARFM es el uso de este valor proporcional para determinar la velocidad del pulso. Una lectura de 100 indica una lluvia mucho más fuerte que una lectura de 800.

El Actuador: Buzzer Activo

Se elige un buzzer activo sobre uno pasivo por su simplicidad en este tipo de alarma.

• Funcionamiento: El buzzer activo contiene un oscilador interno. A diferencia del buzzer pasivo que requiere una señal de frecuencia (PWM) para generar tono, el activo solo necesita ser alimentado con 5V (mediante una señal HIGH) para emitir inmediatamente un sonido agudo y continuo a una frecuencia fija.
• Ventaja en Alarmas: Su simplicidad se traduce en un código binario: si hay gas, HIGH (Alarma); si no hay gas, LOW (Silencio).

_🔨Componentes

🔌Conexiones

Conexión del DGZZI

Conexión del Buzzer activo(KY-012)

0️⃣Código

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

#include <Arduino.h>
// Definición de Pines de E/S
const int pinBuzzer = 8;        // Pin digital para controlar el buzzer activo
const int pinSensorLluvia = A0; // Pin analógico para leer la intensidad de la lluvia

// Variables de Calibración
// El valor del sensor de lluvia es proporcional a la humedad:
// SensorSeco (lectura baja) -> Buzzer Lento
// SensorMojado (lectura alta) -> Buzzer Rápido
const int valorMinLluvia = 100; // Calibración: Valor sensor para 'poca' lluvia (cerca de 0)
const int valorMaxLluvia = 1200; // Calibración: Valor sensor para 'mucha' lluvia (cerca de 1023)

// Variables de Control del Pulso (Tiempo de Retardo)
const int retardoMinMs = 50;  // Mínimo retardo (ms) = Pulso más RÁPIDO (mucha lluvia)
const int retardoMaxMs = 1500; // Máximo retardo (ms) = Pulso más LENTO (poca lluvia)

void setup() {
  // Inicializa el pin del buzzer como una salida digital
  pinMode(pinBuzzer, OUTPUT);

  // Inicializa la comunicación serial para la depuración y monitoreo
  Serial.begin(9600);
  Serial.println("Alarma de Lluvia Iniciada. Monitoreando...");
}

void loop() {
  // 1. Lectura del Sensor Analógico
  int valorSensor = analogRead(pinSensorLluvia);

  // 2. Mapeo del Valor (Conversión a Tiempo de Pulso)
  /*
   * Usamos la función map() para escalar la lectura del sensor a un valor de retardo
   * de manera INVERSA, cumpliendo la regla:
   * - Lectura Baja (Mucha Agua)  -> Mapeado a Retardo Mínimo (Pulso Rápido)
   * - Lectura Alta (Poca Agua) -> Mapeado a Retardo Máximo (Pulso Lento)
   * 
   * EN LA MAYORIA DE LOS CASOS EL MODULO VIENE INVERTIDO, ESE NO ES NUESTRO CASO, SI VIENE INVERTIDO
   * LA LINEA DE CÓDIGO ES LA SIGUIENTE   
   */
  /*int tiempoRetardo = map(valorSensor,
                          valorMinLluvia, retardoMaxMs, // Rango de entrada del sensor (invertido)
                          valorMaxLluvia, retardoMinMs);   // Rango de salida del retardo (ms)
  */
  int tiempoRetardo = map(valorSensor,
                          valorMinLluvia, retardoMinMs, // Rango de entrada del sensor
                          valorMaxLluvia, retardoMaxMs);   // Rango de salida del retardo (ms)


  // 3. Clampeo del Valor
  // La función constrain() garantiza que el valor del retardo siempre se mantenga
  // dentro de los límites definidos, evitando valores extremos fuera de rango.
  tiempoRetardo = constrain(tiempoRetardo, retardoMinMs, retardoMaxMs);

  // Monitoreo (Depuración)
  Serial.print("Sensor: ");
  Serial.print(valorSensor);
  Serial.print(" | Retardo: ");
  Serial.print(tiempoRetardo);
  Serial.println(" ms");

  // 4. Lógica de Activación del Pulso
  // El buzzer solo se activa si la lectura está por arriba del umbral de 'poca lluvia' (valorMaxLluvia)
  if (valorSensor > valorMinLluvia) {
    // Generar el Pulso (Ciclo de Trabajo 50% para claridad)
    
    // Buzzer ON
    digitalWrite(pinBuzzer, HIGH);
    delay(tiempoRetardo); // Duración del sonido (t_ON)

    // Buzzer OFF
    digitalWrite(pinBuzzer, LOW);
    delay(tiempoRetardo); // Duración del silencio (t_OFF)
    
    // El periodo total (T) del pulso es: T = t_ON + t_OFF = 2 * tiempoRetardo
  } else {
    // Si está muy seco, el buzzer permanece apagado y se espera un breve momento
    digitalWrite(pinBuzzer, LOW);
    delay(100); 
  }
}

🖌️Diseños

🎬Videos

📑Conclusión

El verdadero poder del SARFM radica en su escalabilidad y el uso eficiente de los recursos del Arduino Uno.

El código base es lo suficientemente robusto para integrar futuras mejoras sin comprometer el rendimiento de la alarma principal:

• Conectividad (IoT): El formato de datos CSV implementado en el monitoreo serial permite una fácil migración a módulos Wi-Fi (como el ESP8266) para enviar datos de precipitación a servicios en la nube (ej. ThingSpeak o Blynk), transformando el SARFM en un nodo de Internet de las Cosas (IoT) meteorológico.
• Optimización Energética: Las técnicas de alimentación pulsada y la posibilidad de incorporar modos de suspensión profunda (Sleep Modes) del microcontrolador lo preparan para funcionar durante meses o incluso años con una fuente de poder autónoma, ideal para estaciones meteorológicas remotas.

En resumen, el SARFM es un sistema completo que valida la potencia del mapeo de datos y la programación eficiente, proporcionando una base sólida para futuros proyectos de detección ambiental y automatización.