### 4.3.6 Monitorización de agua de lluvia

#### 4.3.6.1 Descripción general

![Img](./media/top1.png)

Cuando el sensor de lluvia detecta lluvia, envía una señal a la placa micro:bit para activar varias acciones. Por ejemplo, el altavoz de la micro:bit puede emitir una alarma para avisar a los usuarios de que está lloviendo, y la cantidad actual de lluvia se mostrará en tiempo real en la OLED. Esto es especialmente útil en entornos o condiciones meteorológicas exteriores, permitiendo a los usuarios tomar las medidas preventivas necesarias. Además, un sistema de monitorización de agua de lluvia, que incluye el sensor de lluvia, la pantalla OLED y la placa micro:bit, puede detectar filtraciones en techos o edificios para prevenir daños causados por la entrada de agua.

En general, es una herramienta multifuncional y eficaz que puede detectar la presencia de agua de lluvia en diversas aplicaciones.

![Img](./media/bottom1.png)

#### 4.3.6.2 Conocimientos sobre el componente

![Img](./media/2top.png)

**Sensor de lluvia**

![Img](./media/steam.png)

El sensor de lluvia puede detectar la presencia de agua, por lo que se emplea típicamente en sistemas de detección de agua de lluvia. Cuando el agua de lluvia entra en contacto con la almohadilla conductora (área de detección) del sensor, enviará una señal a la placa de desarrollo (micro:bit, etc.) para activar diversas acciones. Cuanta más agua haya en el área de detección, mayor será el valor analógico.

![Img](./media/cou41.png)

**Diagrama esquemático:**

![Img](./media/couy41.png)

Detecta la cantidad de agua mediante las líneas paralelas expuestas en la placa de circuito. Cuanta más agua haya, más hilos quedarán conectados. A medida que aumenta el área de contacto para la conducción, la tensión de salida en el pin 2 del área de detección aumentará gradualmente, y mayor será el valor analógico detectado en el terminal de señal S. Además del agua, también puede detectar vapor de agua en el aire.

**Parámetros:**

- Voltaje de funcionamiento: DC 3.3V~5V
- Corriente de funcionamiento: (Máx)1.5mA@5V
- Potencia máxima: 0.075W
- Tipo de señal: Señal analógica

![Img](./media/2bottom.png)

#### 4.3.6.3 Componentes requeridos

| ![Img](./media/microbitV2.png)| ![Img](./media/ExpansionBoard.png)  |![Img](./media/OLED.png) |
| :--: | :--: | :--: |
|   micro:bit V2 main board ×1   |        micro:bit shield ×1         |           OLED display ×1           |
|![Img](./media/steam1.png)|![Img](./media/usb.png) |![Img](./media/4pin.png)|
|        steam sensor ×1         |         micro USB cable ×1         | 4 pin wire ×1 |
|![Img](./media/3pin.png)|![Img](./media/batterycase.png)|![Img](./media/AAbattery.png)|
|         3 pin wire ×1          |         battery holder ×1          |  AA battery(**self-prepared**) ×6   |

#### 4.3.6.4 Diagrama de conexiones

⚠️ **Al realizar el cableado, preste atención al color de los cables.**

| OLED display | wire color | micro:bit shield pin | micro:bit board pin |
| :----------: | :--------: | :------------------: | :-----------------: |
|     GND      |   black    |          G           |          G          |
|     VCC      |    red     |          V2          |          V          |
|     SDA      |    blue    |          20          |         P20         |
|     SCL      |   green    |          19          |         P19         |

| steam sensor | wire color | micro:bit shield pin | micro:bit board pin |
| :----------: | :--------: | :------------------: | :-----------------: |
|      G       |   black    |          G           |          G          |
|      V       |    red     |          V1          |          V          |
|      S       |   yellow   |          1           |         P1          |

![Img](./media/couj6.png)

#### 4.3.6.5 Flujo del código

![Img](./media/flow-chart-06.png)

#### 4.3.6.6 Código de prueba

⚠️ **<span style="color: rgb(255, 76, 65);">Consejo 1: Antes de descargar el código a la placa Microbit, importe el archivo de la biblioteca “oled_ssd1306\.py” haciendo referencia a </span>** “[Import Library on MU](https://docs.keyestudio.com/projects/KS4050/en/latest/docs/MicroPython/MU_development_environment.html#import-library-on-mu)” .

![Img](./media/WPSA1.png)

⚠️ **Consejo 2: El umbral en la condición “if()...elif()...” puede modificarse según la situación real.**

**Código completo:**

```Python
'''
Theme: Rainwater monitoring
Function: OLED displays the amount of rainwater and the steam sensor controls the fan and atomization module
Compiling IDE: MU 1.2.0
Author: https://docs.keyestudio.com
'''
from microbit import *
from oled_ssd1306 import *
import math
import music

# Inicializar OLED
initialize()
clear_oled()

# Parámetros de configuración
RAIN_PIN = pin1
WET_VALUE = 1023
DRY_VALUE = 0

def map_value(value, in_min, in_max, out_min, out_max):
    """Linearly map the input values to the output range"""
    if in_max - in_min == 0:
        return out_min
    return (value - in_min) * (out_max - out_min) // (in_max - in_min) + out_min

def get_rain_percentage():
    raw_value = RAIN_PIN.read_analog()
    percentage = map_value(raw_value, DRY_VALUE, WET_VALUE, 0, 100)
    return max(0, min(100, percentage)), raw_value

def get_rain_level(percentage):
    if percentage < 10:
        return "dry", 0
    elif percentage >= 10 and percentage < 20:
        return "slightly wet", 1
    elif percentage >= 20 and percentage < 40:
        return "wet", 2
    elif percentage >= 40 and percentage < 60:
        return "Very wet", 3
    else:
        return "hydrops", 4

def display_rain_info():
    percentage, raw_value = get_rain_percentage()
    level_text, level = get_rain_level(percentage)

    # Mostrar en OLED
    clear_oled()
    add_text(0, 0, "Rainfall Monitor")
    add_text(0, 1, "Analog: {}".format(raw_value))
    add_text(0, 2, "Humidity: {}%".format(percentage))
    add_text(0, 3, "State: {}".format(level_text))
    add_text(0, 4, "Class: {}".format(level))
    draw_screen()

    return percentage, level_text

while True:
    percentage, status = display_rain_info()

    # Mostrar en la matriz LED y el altavoz reproduce diferentes tonos
    if percentage >= 10 and percentage < 20:
        display.show(Image("00000:00000:00900:00000:00000"))  # punto
        music.play("C3:1")  # el altavoz reproduce tono C3
    elif percentage >= 20 and percentage < 40:
        display.show(Image("00000:00900:09990:00900:00000"))  # círculo pequeño
        music.play("C4:1")  # el altavoz reproduce tono C4
    elif percentage >= 40 and percentage < 60:
        display.show(Image("00900:09990:99999:09990:00900"))  # círculo mediano
        music.play("C5:1")  # el altavoz reproduce tono C5
    elif percentage >= 60:
        display.show(Image("09990:90009:90009:90009:09990"))  # círculo grande
        music.play("B5:1")  # el altavoz reproduce tono B5
    else:
        display.show(Image("00000:00000:00000:00000:00000"))  # no mostrar ningún patrón
        music.reset()  # sin tono
    sleep(1000)  # Actualizar cada segundo
```

![Img](./media/line1.png)

**Explicación breve:**

① Importar las bibliotecas microbit, oled_ssd1306, music y math.

```Python
from microbit import *
from oled_ssd1306 import *
import music
import math
```

② Inicializar los píxeles de la OLED, borrar la OLED.

```Python
initialize()  # inicializar oled
clear_oled()  # borrar oled
```

③ Inicializar la variable del pin, valor máximo y mínimo del sensor de lluvia.

```Python
RAIN_PIN = pin1
WET_VALUE = 1023
DRY_VALUE = 0
```

④ Definir una subfunción map (para mapear cualquier rango de número a otro).

```Python
def map_value(value, in_min, in_max, out_min, out_max):
        """Linearly map the input values to the output range"""
    if in_max - in_min == 0:  
        return out_min
    return (value - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
```

⑤ Definir una subfunción para obtener la intensidad del volumen de lluvia.

```Python
def get_rain_percentage():
    raw_value = RAIN_PIN.read_analog()
    percentage = map_value(raw_value, DRY_VALUE, WET_VALUE, 0, 100)
    return max(0, min(100, percentage)), raw_value 
```

⑥ Definir una subfunción para obtener el nivel del volumen de lluvia.

```Python
def get_rain_level(percentage):
    if percentage < 10:
        return "dry", 0
    elif percentage >= 10 and percentage < 20:
        return "slightly wet", 1
    elif percentage >= 20 and percentage < 40:
        return "wet", 2
    elif percentage >= 40 and percentage < 60:
        return "Very wet", 3
    else:
        return "hydrops", 4
```

⑦ Definir una subfunción para mostrar en la OLED la información del volumen de lluvia.

```Python
def display_rain_info():
    percentage, raw_value = get_rain_percentage()
    level_text, level = get_rain_level(percentage)

    # Mostrar en OLED
    clear_oled()
    add_text(0, 0, "Rainfall Monitor")
    add_text(0, 1, "Analog:: {}".format(raw_value))
    add_text(0, 2, "Humidity: {} %".format(percentage))
    add_text(0, 3, "State: {}".format(level_text))
    add_text(0, 4, "Class: {}".format(level))
    draw_screen()

    return percentage, level_text
```

⑧ Asignar los valores en la OLED a las variables percentage y status.

```Python
percentage, status = display_rain_info()
```

⑨ Sentencia de juicio: if()...elif()...elif()...elif()...else...

Cuando el volumen de lluvia detectado es mayor o igual al 10% pero menor que el 20%, la matriz LED 5×5 muestra ![Img](./media/ab7.png) y el altavoz reproduce el tono C3 como advertencia.

```Pytho
if percentage >= 10 and percentage < 20:
    display.show(Image("00000:00000:00900:00000:00000"))  # punto
    music.play("C3:1")  # el altavoz reproduce tono C3
```

Si el volumen de lluvia detectado es mayor o igual al 20% pero menor que el 40%, la matriz LED 5×5 muestra ![Img](./media/ab8.png) y el altavoz reproduce el tono C4 como advertencia.

```Python
elif percentage >= 20 and percentage < 40:
    display.show(Image("00000:00900:09990:00900:00000"))  # círculo pequeño
    music.play("C4:1")  # el altavoz reproduce tono C4
```

Si el volumen de lluvia detectado es mayor o igual al 40% pero menor que el 60%, la matriz LED 5×5 muestra ![Img](./media/ab9.png), y el altavoz reproduce el tono C5 como advertencia.

```Python
elif percentage >= 40 and percentage < 60:
    display.show(Image("00900:09990:99999:09990:00900"))  # círculo mediano
    music.play("C5:1")  # el altavoz reproduce tono C5
```

Si el volumen de lluvia detectado es mayor o igual al 60%, la matriz LED 5×5 muestra ![Img](./media/ab10.png), y el altavoz reproduce el tono B5 como advertencia.

```Python
elif percentage >= 60:
    display.show(Image("09990:90009:90009:90009:09990"))  # círculo grande
    music.play("B5:1")  # el altavoz reproduce tono B5
```

De lo contrario, la 5×5 LED no muestra nada y el altavoz permanece en silencio.

```Python
display.show(Image("00000:00000:00000:00000:00000"))  # no mostrar ningún patrón
music.reset()  # sin tono
```

④ Retardo 1000ms(1s).

```Python
sleep(1000)  # Actualizar cada segundo
```

#### 4.3.6.7 Resultado de la prueba

![Img](./media/4top.png)

Después de conectar y encender mediante el cable micro USB, conecte la alimentación externa (6 pilas AA) para asegurar un suministro de energía suficiente, y haga clic en “<span style="color: rgb(255, 76, 65);">Flash</span>” para descargar el código a la placa micro:bit.

![Img](./media/A128.png)

Después de subir el código de prueba, pulse el botón de reinicio en la parte trasera de la micro:bit.

![Img](./media/A455.png)

La OLED muestra el volumen de lluvia detectado en tiempo real. (**<span style="color: rgb(255, 76, 65);">Por ejemplo: use una mano húmeda para tocar el área de detección del sensor de lluvia para simular la caída de lluvia</span>**).

Si el volumen de lluvia detectado es mayor o igual al 10% pero menor que el 20%, la matriz LED 5×5 muestra ![Img](./media/ab7.png) y el altavoz reproduce el tono C3 como advertencia.

Si el volumen de lluvia detectado es mayor o igual al 20% pero menor que el 40%, la matriz LED 5×5 muestra ![Img](./media/ab8.png) y el altavoz reproduce el tono C4 como advertencia.

Si el volumen de lluvia detectado es mayor o igual al 40% pero menor que el 60%, la matriz LED 5×5 muestra ![Img](./media/ab9.png), y el altavoz reproduce el tono C5 como advertencia.

Si el volumen de lluvia detectado es mayor o igual al 60%, la matriz LED 5×5 muestra ![Img](./media/ab10.png), y el altavoz reproduce el tono B5 como advertencia.

Si el volumen de lluvia detectado es inferior al 10%, la 5×5 LED no muestra nada y el altavoz permanece en silencio.

![Img](./media/dongtu-06.gif)

⚠️ **Nota: Los bloques de construcción del experimento no están incluidos en este kit.**

<span style="color: rgb(0, 209, 0);">(**Consejo:** Si no se observa ningún resultado, por favor presione el botón de reinicio de la placa micro:bit.)</span>

![Img](./media/4bottom.png)