### 4.3.6 Surveillance des eaux de pluie

#### 4.3.6.1 Aperçu

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

Lorsque le capteur d'eau détecte de la pluie, il envoie un signal à la carte micro:bit pour déclencher différentes actions. Par exemple, le haut-parleur de la micro:bit peut émettre une alarme pour avertir les utilisateurs qu'il pleut, et la quantité de pluie actuelle sera affichée en temps réel sur l'écran OLED. Cela est particulièrement utile en extérieur pour la météo ou l'environnement, permettant aux utilisateurs de prendre les mesures préventives nécessaires. De plus, un système de surveillance des eaux de pluie, comprenant le capteur d'eau, l'affichage OLED et la carte micro:bit, peut détecter des fuites sur des toits ou des bâtiments afin de prévenir les dommages causés par les infiltrations d'eau.

Dans l'ensemble, il s'agit d'un outil multifonctionnel et efficace qui peut détecter la présence d'eau de pluie dans diverses applications.

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

#### 4.3.6.2 Connaissances des composants

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

**Capteur d'eau**

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

Le capteur d'eau peut détecter la présence d'eau et est donc généralement utilisé dans les systèmes de détection des eaux de pluie. Lorsque l'eau de pluie entre en contact avec la plaque conductrice (zone de détection) sur le capteur, il enverra un signal à la carte de développement (micro:bit, etc.) pour déclencher diverses actions. Plus il y a d'eau dans la zone de détection, plus la valeur analogique sera élevée.

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

**Schéma électrique :**

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

Il détecte la quantité d'eau par les lignes parallèles exposées sur le circuit imprimé. Plus il y a d'eau, plus de fils seront mis en contact. À mesure que la surface de contact pour la conduction augmente, la tension de sortie à la broche 2 de la zone de détection augmentera progressivement, et plus la valeur analogique détectée sur la borne de signal S sera élevée. En plus de l'eau, il peut également détecter la vapeur d'eau dans l'air.

**Paramètres :**

- Tension de fonctionnement : DC 3.3V~5V
- Courant de fonctionnement : (Max)1.5mA@5V
- Puissance maximale : 0.075W
- Type de signal : Signal analogique

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

#### 4.3.6.3 Composants requis

| ![Img](./media/microbitV2.png)| ![Img](./media/ExpansionBoard.png)  |![Img](./media/OLED.png) |
| :--: | :--: | :--: |
|   Carte principale micro:bit V2 ×1   |        micro:bit shield ×1         |           Écran OLED ×1           |
|![Img](./media/steam1.png)|![Img](./media/usb.png) |![Img](./media/4pin.png)|
|        capteur d'eau ×1         |         câble micro USB ×1         |  Câble 4 broches ×1 |
|![Img](./media/3pin.png)|![Img](./media/batterycase.png)|![Img](./media/AAbattery.png)|
|         Câble 3 broches ×1          |         porte-piles ×1          |  Piles AA(**à fournir par l'utilisateur**) ×6   |

#### 4.3.6.4 Schéma de câblage

⚠️ **Lorsque vous effectuez le câblage, veuillez faire attention à la couleur des fils.**

| 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 Flux du code

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

#### 4.3.6.6 Code de test

⚠️ **<span style="color: rgb(255, 76, 65);">Astuce 1 : Avant de télécharger le code sur la carte Microbit, veuillez importer le fichier de bibliothèque “oled_ssd1306\.py” en vous référant à </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)

⚠️ **Astuce 2 : Le seuil dans la condition “if()...elif()...” peut être modifié en fonction de la situation réelle.**

**Code complet :**

```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

# Initialize OLED
initialize()
clear_oled()

# Configuration parameters
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)

    # Display on 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()

    # Display on the LED matrix and speaker plays different tones
    if percentage >= 10 and percentage < 20:
        display.show(Image("00000:00000:00900:00000:00000"))  # dot
        music.play("C3:1")  # speaker plays C3 tone
    elif percentage >= 20 and percentage < 40:
        display.show(Image("00000:00900:09990:00900:00000"))  # small circle
        music.play("C4:1")  # speaker plays C4 tone
    elif percentage >= 40 and percentage < 60:
        display.show(Image("00900:09990:99999:09990:00900"))  # middle circle
        music.play("C5:1")  # speaker plays C5 tone
    elif percentage >= 60:
        display.show(Image("09990:90009:90009:90009:09990"))  # large circle
        music.play("B5:1")  # speaker plays B5 tone
    else:
        display.show(Image("00000:00000:00000:00000:00000"))  # do not display any patterns
        music.reset()  # no tone
    sleep(1000)  # Update every second
```

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

**Brève explication :**

① Importer les bibliothèques microbit, oled_ssd1306, music et math.

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

② Initialiser les pixels de l'OLED, effacer l'OLED.

```Python
initialize()  # initialiser l'OLED
clear_oled()  # effacer l'OLED
```

③ Initialiser la broche, la valeur maximale et minimale du capteur d'eau.

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

④ Définir une sous-fonction map (pour mapper n'importe quelle plage de nombres sur une autre).

```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
```

⑤ Définir une sous-fonction pour obtenir le pourcentage de pluie.

```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 
```

⑥ Définir une sous-fonction pour obtenir le niveau de pluie.

```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
```

⑦ Définir une sous-fonction pour afficher les informations de pluie sur l'OLED.

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

    # Display on 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
```

⑧ Assigner les valeurs affichées sur l'OLED aux variables percentage et status.

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

⑨ Instruction conditionnelle : if()...elif()...elif()...elif()...else...

Lorsque le volume de pluie détecté est supérieur ou égal à 10 % mais inférieur à 20 %, la matrice LED 5×5 affiche ![Img](./media/ab7.png) et le haut-parleur joue la note C3 comme avertissement.

```Pytho
if percentage >= 10 and percentage < 20:
    display.show(Image("00000:00000:00900:00000:00000"))  # dot
    music.play("C3:1")  # speaker plays C3 tone
```

Si le volume de pluie détecté est supérieur ou égal à 20 % mais inférieur à 40 %, la matrice LED 5×5 affiche ![Img](./media/ab8.png) et le haut-parleur joue la note C4 comme avertissement.

```Python
elif percentage >= 20 and percentage < 40:
    display.show(Image("00000:00900:09990:00900:00000"))  # small circle
    music.play("C4:1")  # speaker plays C4 tone
```

Si le volume de pluie détecté est supérieur ou égal à 40 % mais inférieur à 60 %, la matrice LED 5×5 affiche ![Img](./media/ab9.png), et le haut-parleur joue la note C5 comme avertissement.

```Python
elif percentage >= 40 and percentage < 60:
    display.show(Image("00900:09990:99999:09990:00900"))  # middle circle
    music.play("C5:1")  # speaker plays C5 tone
```

Si le volume de pluie détecté est supérieur ou égal à 60 %, la matrice LED 5×5 affiche ![Img](./media/ab10.png), et le haut-parleur joue la note B5 comme avertissement.

```Python
elif percentage >= 60:
    display.show(Image("09990:90009:90009:90009:09990"))  # large circle
    music.play("B5:1")  # speaker plays B5 tone
```

Sinon, la matrice 5×5 n'affiche rien et le haut-parleur reste silencieux.

```Python
display.show(Image("00000:00000:00000:00000:00000"))  # do not display any patterns
music.reset()  # no tone
```

④ Délai de 1000 ms (1 s).

```Python
sleep(1000)  # Update every second
```

#### 4.3.6.7 Résultat du test

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

Après le câblage et la mise sous tension via le câble micro USB, connectez une alimentation externe (6 piles AA) pour garantir une alimentation suffisante, puis cliquez sur “<span style="color: rgb(255, 76, 65);">Flash</span>” pour télécharger le code sur la carte micro:bit.

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

Après avoir téléchargé le code de test, appuyez sur le bouton reset au dos de la micro:bit.

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

L'écran OLED affiche en temps réel le volume de pluie détecté. (**<span style="color: rgb(255, 76, 65);">Par exemple : utilisez une main humide pour toucher la zone de détection du capteur d'eau afin de simuler la chute de pluie</span>**).

Si le volume de pluie détecté est supérieur ou égal à 10 % mais inférieur à 20 %, la matrice LED 5×5 affiche ![Img](./media/ab7.png) et le haut-parleur joue la note C3 comme avertissement.

Si le volume de pluie détecté est supérieur ou égal à 20 % mais inférieur à 40 %, la matrice LED 5×5 affiche ![Img](./media/ab8.png) et le haut-parleur joue la note C4 comme avertissement.

Si le volume de pluie détecté est supérieur ou égal à 40 % mais inférieur à 60 %, la matrice LED 5×5 affiche ![Img](./media/ab9.png), et le haut-parleur joue la note C5 comme avertissement.

Si le volume de pluie détecté est supérieur ou égal à 60 %, la matrice LED 5×5 affiche ![Img](./media/ab10.png), et le haut-parleur joue la note B5 comme avertissement.

Si le volume de pluie détecté est inférieur à 10 %, la matrice 5×5 n'affiche rien et le haut-parleur reste silencieux.

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

⚠️ **Remarque : Les blocs de construction utilisés dans l'expérience ne sont pas inclus dans ce kit.**

<span style="color: rgb(0, 209, 0);">(**Astuce :**) Si aucun résultat n'est observé, veuillez appuyer sur le bouton reset de la carte micro:bit.</span>

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