### 4.3.9 Micro:bit Multi-sensor OLED Monitoring Platform
#### 4.3.9.1 Aperçu
Dans ce projet, nous prenons la carte Micro:bit comme unité de traitement centrale pour lire les valeurs de ses capteurs intégrés (y compris le capteur de lumière, le capteur de température, le microphone) ainsi que des capteurs externes (comme le capteur de poussière PM2.5, le capteur d'humidité/bruine et le capteur ultraviolet solaire), puis ces valeurs seront affichées en temps réel sur l'OLED via l'interface I2C.
En même temps, la rotation du ventilateur sur le module moteur 130 peut être contrôlée en appuyant sur le bouton A sur la carte Micro:bit, et la pulvérisation de brume d'eau depuis le module d'atomisation peut être contrôlée en appuyant sur le bouton B de la carte Micro:bit.
#### 4.3.9.2 Composants requis
| |  ||
| :--: | :--: | :--: |
| Micro:bit V2 board ×1 | shield micro:bit ×1 |OLED display ×1 |
| |||
| PM2.5 dust sensor ×1 |motor ×1 |steam sensor ×1 |
||| |
|ultraviolet sensor ×1|battery holder ×1|AA battery(**à fournir**) ×6|
| |||
| Câble micro USB ×1|4 pin wire ×3 |3 pin wire ×3 |
| |  | |
|atomization module ×1|fan ×1| |
#### 4.3.9.3 Schéma de câblage
⚠️ **Lors du câblage, veuillez prêter attention à la couleur des fils.**
| ultraviolet sensor | wire color | micro:bit shield pin | micro:bit board pin |
| :----------------: | :--------: | :------------------: | :-----------------: |
| G | black | G | G |
| V | red | V2 | V |
| S | yellow | 0 | P0 |
| steam sensor | wire color | micro:bit shield pin | micro:bit board pin |
| :----------: | :--------: | :------------------: | :-----------------: |
| G | black | G | G |
| V | red | V1 | V |
| S | yellow | 1 | P1 |
| PM2.5 dust sensor | wire color | micro:bit shield pin | micro:bit board pin |
| :---------------: | :--------: | :------------------: | :-----------------: |
| GND | black | G | G |
| VCC | red | V2 | V |
| LED | blue | 9 | P9 |
| OUT | green | 2 | P2 |
| atomization module | wire color | micro:bit shield pin | micro:bit board pin |
| :----------------: | :--------: | :------------------: | :-----------------: |
| G | black | G | G |
| V | red | V2 | V |
| S | yellow | 16 | P16 |
| motor | wire color | micro:bit shield pin | micro:bit board pin |
| :---: | :--------: | :------------------: | :-----------------: |
| G | black | G | G |
| V | red | V2 | V |
| IN+ | blue | 13 | P13 |
| IN- | green | 15 | P15 |
| 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 |
#### 4.3.9.4 Flux du code
#### 4.3.9.5 Code de test
⚠️ **Astuce 1 : Avant de télécharger le code sur la carte Micro:bit, veuillez importer le fichier de bibliothèque “oled_ssd1306\.py” en vous référant à ** “[Import Library on MU](https://docs.keyestudio.com/projects/KS4050/en/latest/docs/MicroPython/MU_development_environment.html#import-library-on-mu)” .
⚠️ **Astuce 2 : Si le fichier de bibliothèque "XHT11\.py" a déjà été importé sur la carte Micro:bit auparavant, il doit être supprimé de la carte Micro:bit. Sinon, cela provoquera un manque de mémoire sur la carte Micro:bit, entraînant l'échec du téléchargement du code d'exemple sur la carte Micro:bit. **
Cliquez sur le bouton "Fichiers", puis faites un clic droit sur le fichier de bibliothèque "XHT11\.py" dans la boîte de gauche, l'option "Delete (cannot be undone)" apparaît, cliquez sur l'option "Delete (cannot be undone)". Ainsi, le fichier de bibliothèque "XHT11\.py" a été supprimé.
**Code complet :**
```Python
'''
Theme: A multi-sensor OLED monitoring platform based on Micro:bit
Function: OLED displays the values of multiple sensors
Compiling IDE: MU 1.2.0
Author: https://docs.keyestudio.com
'''
# importer les bibliothèques associées
from microbit import *
from oled_ssd1306 import *
import math
import time
display.show(Image.HAPPY) # la matrice LED affiche un motif heureux
# initialiser et effacer l'OLED
initialize()
clear_oled()
# Connexion matérielle : capteur de poussière PM2.5
out_Pin = pin2
led_Pin = pin9
# Connexion matérielle : capteur de vapeur
Steam_PIN = pin1
WET_VALUE = 1023
DRY_VALUE = 0
# Initialiser la broche ADC (le capteur ultraviolet est connecté à pin0)
uv_sensor = pin0
# Paramètre de temps
delayTime = 280
delayTime2 = 40
offTime = 9680
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():
"""Read the sensor and return the percentage of rainfall"""
raw_value = Steam_PIN.read_analog()
percentage = map_value(raw_value, DRY_VALUE, WET_VALUE, 0, 100)
return max(0, min(100, percentage))
def read_uv_index():
raw_value = uv_sensor.read_analog()
if raw_value > 1023:
raw_value = 1023
elif raw_value < 0:
raw_value = 0
uvi = raw_value * (15.0 / 1023)
return round(uvi, 1)
def microsecond_delay(us):
"""Precise microsecond delay"""
start = time.ticks_us()
while time.ticks_diff(time.ticks_us(), start) < us:
pass
while True:
# Séquence de mesure
led_Pin.write_digital(0) # LED ÉTEINTE
microsecond_delay(delayTime) # 280μs
dustVal = out_Pin.read_analog() # Lire le capteur de poussière PM2.5
microsecond_delay(delayTime2) # 40μs
led_Pin.write_digital(1) # LED ALLUMÉE
microsecond_delay(offTime) # 9680μs
Lightintensity = display.read_light_level()
Temperature = temperature()
soundLevel = microphone.sound_level()
rain_percent = get_rain_percentage()
uv = read_uv_index()
clear_oled()
if button_a.is_pressed(): # si le bouton A est pressé
sleep(200)
pin13.write_digital(1) # le ventilateur tourne.
pin15.write_digital(0)
sleep(200)
else: # sinon
pin13.write_digital(0) # le ventilateur ne tourne pas.
pin15.write_digital(0)
if button_b.is_pressed(): # si le bouton B est pressé
pin16.write_digital(0) # le module d'atomisation pulvérise de la brume d'eau.
sleep(200)
pin16.write_digital(1)
sleep(3000)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(1000)
else: # sinon
pin16.write_digital(1) # le module d'atomisation ne pulvérise pas de brume.
add_text(0, 0, "Temper:")
add_text(7, 0, str(int(Temperature)) + "C") # Display the Temperature value on the OLED
add_text(0, 2, "UV:")
add_text(3, 2, str(int(uv))) # Display the UV value on the OLED
add_text(5, 2, " | Rain:")
add_text(13, 2, str(int(rain_percent)) + "%") # Display the percentage of rainfall on the OLED
add_text(0, 4, "Light:")
add_text(6, 4, str(Lightintensity)) # Display the light intensity on the OLED
add_text(9, 4, " | Sound:")
add_text(18, 4, str(soundLevel)) # Display the noise intensity on the OLED
# Calcul et affichage
if dustVal > 36.455:
# Même formule de calcul exacte
voltage = dustVal / 1024.0
pm25 = (voltage - 0.0356) * 120000 * 0.035
# L'OLED affiche les informations détaillées de la valeur PM2.5.
add_text(0, 6, "PM2.5dust:")
add_text(10, 6, str(round(pm25)) + "ug/m3")
else:
print("Low value:", dustVal)
sleep(500)
```
**Brève explication :**
① Importer les bibliothèques microbit, oled_ssd1306, math et time.
```Python
from microbit import *
from oled_ssd1306 import *
import math
import time
```
② La matrice 5×5 LED affiche .
```Python
display.show(Image.HAPPY)
```
③ Initialiser les pixels de l'OLED, effacer l'OLED.
```Python
initialize()
clear_oled()
```
④ Initialiser les broches du capteur de poussière PM2.5.
```Python
out_Pin = pin2
led_Pin = pin9
```
⑤ Initialiser la broche et les variables du capteur de vapeur.
```Python
Steam_PIN = pin1
WET_VALUE = 1023
DRY_VALUE = 0
```
⑥ Initialiser la broche du capteur ultraviolet solaire.
```Python
uv_sensor = pin0
```
⑦ Définir les valeurs initiales des variables temporelles.
```Python
delayTime = 280
delayTime2 = 40
offTime = 9680
```
⑧ Définir une sous-fonction map (pour mapper n'importe quelle plage de nombres vers 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 (humidité détectée).
```Python
def get_rain_percentage():
"""Read the sensor and return the percentage of rainfall"""
raw_value = Steam_PIN.read_analog()
percentage = map_value(raw_value, DRY_VALUE, WET_VALUE, 0, 100)
return max(0, min(100, percentage))
```
⑩ Définir une sous-fonction pour obtenir la valeur de l'intensité ultraviolet détectée par le capteur solaire.
```Python
def read_uv_index():
raw_value = uv_sensor.read_analog()
if raw_value > 1023:
raw_value = 1023
elif raw_value < 0:
raw_value = 0
uvi = raw_value * (15.0 / 1023)
return round(uvi, 1)
```
⑪ Définir une sous-fonction de délai en microsecondes.
```Python
def microsecond_delay(us):
"""Precise microsecond delay"""
start = time.ticks_us()
while time.ticks_diff(time.ticks_us(), start) < us:
pass
```
⑫ Régler le contrôle du timing de mesure du capteur de poussière PM2.5, utilisé principalement pour détecter la concentration de poussière dans l'air.
```Python
led_Pin.write_digital(0) # LED ÉTEINTE
microsecond_delay(delayTime) # 280μs
dustVal = out_Pin.read_analog() # Lire le capteur de poussière PM2.5
microsecond_delay(delayTime2) # 40μs
led_Pin.write_digital(1) # LED ALLUMÉE
microsecond_delay(offTime) # 9680μs
```
⑬ Lire les valeurs d'intensité lumineuse, de température, de niveau sonore, d'humidité/bruine et d'ultraviolet.
```Python
Lightintensity = display.read_light_level()
Temperature = temperature()
soundLevel = microphone.sound_level()
rain_percent = get_rain_percentage()
uv = read_uv_index()
```
⑭ Instruction conditionnelle : if()...else...
Appuyez sur le bouton A de la carte Micro:bit, et le moteur entraînera le ventilateur. Sinon, le ventilateur ne tournera pas.
```Python
if button_a.is_pressed(): # si le bouton A est pressé
sleep(200)
pin13.write_digital(1) # le ventilateur tourne.
pin15.write_digital(0)
sleep(200)
else: # sinon
pin13.write_digital(0) # le ventilateur ne tourne pas.
pin15.write_digital(0)
```
⑮ Instruction conditionnelle : if()...else...
Appuyez sur le bouton B de la carte Micro:bit, et le module d'atomisation pulvérisera de la brume d'eau. Sinon, il ne fonctionnera pas.
```Python
if button_b.is_pressed(): # si le bouton B est pressé
pin16.write_digital(0) # le module d'atomisation pulvérise de la brume d'eau.
sleep(200)
pin16.write_digital(1)
sleep(3000)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(1000)
else: # sinon
pin16.write_digital(1) # le module d'atomisation ne pulvérise pas de brume.
```
⑯ Afficher les valeurs d'ultraviolet, de température, d'humidité/bruine, d'intensité lumineuse et de niveau sonore sur l'OLED.
```Python
add_text(0, 0, "Temper:")
add_text(7, 0, str(int(Temperature)) + "C") # Display the Temperature value on the OLED
add_text(0, 2, "UV:")
add_text(3, 2, str(int(uv))) # Display the UV value on the OLED
add_text(5, 2, " | Rain:")
add_text(13, 2, str(int(rain_percent)) + "%") # Display the percentage of rainfall on the OLED
add_text(0, 4, "Light:")
add_text(6, 4, str(Lightintensity)) # Display the light intensity on the OLED
add_text(9, 4, " | Sound:")
add_text(18, 4, str(soundLevel)) # Display the noise intensity on the OLED
```
⑰ Lorsque la valeur analogique des particules PM2.5 dépasse 36.455, sa concentration peut être calculée et affichée sur l'OLED. Sinon, le moniteur série affiche les valeurs analogiques correspondantes de poussière.
```Python
if dustVal > 36.455:
# The exact same calculation formula
voltage = dustVal / 1024.0
pm25 = (voltage - 0.0356) * 120000 * 0.035
# OLED displays detailed PM2.5dust value information.
add_text(0, 6, "PM2.5dust:")
add_text(10, 6, str(round(pm25)) + "ug/m3")
else:
print("Low value:", dustVal)
```
#### 4.3.9.6 Résultat du test
Après le câblage et l'alimentation via le câble micro USB, connectez une alimentation externe (6 piles AA) pour assurer une alimentation suffisante, puis cliquez sur “Flash” pour télécharger le code sur la carte Micro:bit.
Après avoir téléchargé le code de test, appuyez sur le bouton de réinitialisation au dos du Micro:bit.
Lire les valeurs de ses capteurs intégrés (y compris le capteur de lumière, le capteur de température, le microphone) ainsi que des capteurs externes (comme le capteur de poussière PM2.5, le capteur d'humidité/bruine et le capteur ultraviolet solaire), puis il peut afficher l'intensité lumineuse, la température, l'intensité sonore, l'intensité de pluie/bruine, l'intensité ultraviolet du soleil et la concentration de poussière PM2.5 en temps réel et de façon intuitive via l'écran OLED avec interface I2C.
Soufflez de l'air (ou produisez un bruit très fort) dans le microphone sur la carte Micro:bit (⚠️ **rappel spécial : souffler de l'air a un effet plus marqué**), et l'affichage OLED montrera l'intensité du souffle d'air (ou du bruit).
Lorsque le bouton A sur la carte Micro:bit est pressé, le ventilateur sur le module moteur tourne. Lorsque le bouton B sur la carte est pressé, le module d'atomisation pulvérise de la brume d'eau.
⚠️ Rappel spécial : Parfois, la tension d'alimentation externe peut être insuffisante. Dans ce cas, il peut être nécessaire d'appuyer deux fois sur le bouton de la carte Micro:bit avant que le ventilateur ne commence à tourner ou que le module de brumisation ne commence à pulvériser de la brume d'eau.
⚠️ **Remarque : Les blocs de construction utilisés dans l'expérience ne sont pas inclus dans ce kit.**
(**Astuce :** Si aucun résultat n'est observé, veuillez appuyer sur le bouton de réinitialisation de la carte Micro:bit.)
