### 4.3.9 Micro:bit Multi-sensor OLED Monitoring Platform
#### 4.3.9.1 Descripción general
En este proyecto, tomamos la placa micro:bit como unidad de procesamiento central para leer los valores de sus sensores integrados (incluyendo sensor de luz, sensor de temperatura, micrófono) así como sensores externos (como el sensor de polvo PM2.5, sensor de vapor y sensor solar de radiación ultravioleta), y luego estos valores se mostrarán en tiempo real en el OLED a través de la interfaz I2C.
Al mismo tiempo, la rotación del ventilador en el módulo motor 130 puede controlarse presionando el botón A en la placa Micro:bit, y la pulverización de niebla de agua desde el módulo de atomización puede controlarse presionando el botón B en la placa Micro:bit.
#### 4.3.9.2 Componentes requeridos
| |  ||
| :--: | :--: | :--: |
| placa micro:bit V2 ×1 | shield para micro:bit ×1 |Pantalla OLED ×1 |
| |||
| sensor de polvo PM2.5 ×1 |motor ×1 |sensor de vapor ×1 |
||| |
|sensor ultravioleta ×1|porta-pilas ×1|pila AA(**autopreparada**) ×6|
| |||
| cable micro USB ×1|cable de 4 pines ×3 |cable de 3 pines ×3 |
| |  | |
|módulo de atomización ×1|ventilador ×1| |
#### 4.3.9.3 Diagrama de conexiones
⚠️ **Cuando realice las conexiones, preste atención al color de los cables.**
| 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 Flujo del código
#### 4.3.9.5 Código de prueba
⚠️ **Consejo 1: Antes de descargar el código a la placa Microbit, por favor importe el archivo de la librería “oled_ssd1306\.py” refiriéndose a ** “[Import Library on MU](https://docs.keyestudio.com/projects/KS4050/en/latest/docs/MicroPython/MU_development_environment.html#import-library-on-mu)” .
⚠️ **Consejo 2: Si el archivo de librería "XHT11\.py" ya ha sido importado a la placa micro:bit anteriormente, debe eliminarse de la placa micro:bit. De lo contrario, puede causar memoria insuficiente en la placa Microbit, provocando que la descarga del código de ejemplo a la placa Microbit falle. **
Haga clic en el botón "Files", luego haga clic derecho en el archivo de la librería "XHT11\.py" en el recuadro izquierdo, aparece la opción "Delete (cannot be undone)", haga clic en la opción "Delete (cannot be undone)", de este modo se elimina el archivo de la librería "XHT11\.py".
**Código completo:**
```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
'''
# importar bibliotecas relacionadas
from microbit import *
from oled_ssd1306 import *
import math
import time
display.show(Image.HAPPY) # la matriz LED muestra un patrón feliz
# inicializar y limpiar el OLED
initialize()
clear_oled()
# Conexión de hardware: sensor de polvo PM2.5
out_Pin = pin2
led_Pin = pin9
# Conexión de hardware: sensor de vapor
Steam_PIN = pin1
WET_VALUE = 1023
DRY_VALUE = 0
# Inicializar el pin ADC (el sensor ultravioleta está conectado a pin0)
uv_sensor = pin0
# Parámetros de tiempo
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:
# secuencia de medición
led_Pin.write_digital(0) # LED APAGADO
microsecond_delay(delayTime) # 280μs
dustVal = out_Pin.read_analog() # Leer el sensor de polvo PM2.5
microsecond_delay(delayTime2) # 40μs
led_Pin.write_digital(1) # LED ENCENDIDO
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 button_a está presionado
sleep(200)
pin13.write_digital(1) # el ventilador está girando.
pin15.write_digital(0)
sleep(200)
else: # o
pin13.write_digital(0) # el ventilador no gira.
pin15.write_digital(0)
if button_b.is_pressed(): # si button_b está presionado
pin16.write_digital(0) # el módulo de atomización pulveriza niebla de agua.
sleep(200)
pin16.write_digital(1)
sleep(3000)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(1000)
else: # o
pin16.write_digital(1) # el módulo de atomización no pulveriza niebla.
add_text(0, 0, "Temper:")
add_text(7, 0, str(int(Temperature)) + "C") # Mostrar el valor de Temperatura en el OLED
add_text(0, 2, "UV:")
add_text(3, 2, str(int(uv))) # Mostrar el valor de UV en el OLED
add_text(5, 2, " | Rain:")
add_text(13, 2, str(int(rain_percent)) + "%") # Mostrar el porcentaje de lluvia en el OLED
add_text(0, 4, "Light:")
add_text(6, 4, str(Lightintensity)) # Mostrar la intensidad de luz en el OLED
add_text(9, 4, " | Sound:")
add_text(18, 4, str(soundLevel)) # Mostrar la intensidad de ruido en el OLED
# Cálculo y visualización
if dustVal > 36.455:
# La misma fórmula de cálculo exacta
voltage = dustVal / 1024.0
pm25 = (voltage - 0.0356) * 120000 * 0.035
# El OLED muestra información detallada del valor de PM2.5.
add_text(0, 6, "PM2.5dust:")
add_text(10, 6, str(round(pm25)) + "ug/m3")
else:
print("Low value:", dustVal)
sleep(500)
```
**Breve explicación:**
① Importar las librerías microbit, oled_ssd1306, math y time.
```Python
from microbit import *
from oled_ssd1306 import *
import math
import time
```
② La matriz LED 5×5 muestra .
```Python
display.show(Image.HAPPY)
```
③ Inicializar los píxeles del OLED, limpiar el OLED.
```Python
initialize()
clear_oled()
```
④ Inicializar los pines del sensor de polvo PM2.5.
```Python
out_Pin = pin2
led_Pin = pin9
```
⑤ Inicializar el pin y las variables del sensor de vapor.
```Python
Steam_PIN = pin1
WET_VALUE = 1023
DRY_VALUE = 0
```
⑥ Inicializar el pin del sensor solar ultravioleta.
```Python
uv_sensor = pin0
```
⑦ Establecer los valores iniciales de las variables de tiempo.
```Python
delayTime = 280
delayTime2 = 40
offTime = 9680
```
⑧ Definir una subfunción map (para mapear cualquier rango de números 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 el porcentaje de lluvia.
```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))
```
⑩ Definir una subfunción para obtener el valor de la intensidad ultravioleta detectada por el sensor solar ultravioleta.
```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)
```
⑪ Definir una subfunción de retardo en microsegundos.
```Python
def microsecond_delay(us):
"""Precise microsecond delay"""
start = time.ticks_us()
while time.ticks_diff(time.ticks_us(), start) < us:
pass
```
⑫ Establecer el control del tiempo de medición del sensor de polvo PM2.5, que se utiliza principalmente para detectar la concentración de polvo en el aire.
```Python
led_Pin.write_digital(0) # LED APAGADO
microsecond_delay(delayTime) # 280μs
dustVal = out_Pin.read_analog() # Leer el sensor de polvo PM2.5
microsecond_delay(delayTime2) # 40μs
led_Pin.write_digital(1) # LED ENCENDIDO
microsecond_delay(offTime) # 9680μs
```
⑬ Leer los valores de intensidad de luz, temperatura, volumen de sonido, volumen de lluvia y radiación ultravioleta.
```Python
Lightintensity = display.read_light_level()
Temperature = temperature()
soundLevel = microphone.sound_level()
rain_percent = get_rain_percentage()
uv = read_uv_index()
```
⑭ Sentencia condicional: if()...else...
Presione el botón A en la placa micro:bit, y el motor hará funcionar el ventilador. De lo contrario, el ventilador no girará.
```Python
if button_a.is_pressed(): # si button_a está presionado
sleep(200)
pin13.write_digital(1) # el ventilador está girando.
pin15.write_digital(0)
sleep(200)
else: # o
pin13.write_digital(0) # el ventilador no gira.
pin15.write_digital(0)
```
⑮ Sentencia condicional: if()...else...
Presione el botón B en la placa micro:bit, y el módulo de atomización rociará niebla de agua. De lo contrario, no funcionará.
```Python
if button_b.is_pressed(): # si button_b está presionado
pin16.write_digital(0) # el módulo de atomización pulveriza niebla de agua.
sleep(200)
pin16.write_digital(1)
sleep(3000)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(1000)
else: # o
pin16.write_digital(1) # el módulo de atomización no pulveriza niebla.
```
⑯ Mostrar los valores de radiación ultravioleta, temperatura, volumen de lluvia, intensidad de luz y volumen de sonido en el OLED.
```Python
add_text(0, 0, "Temper:")
add_text(7, 0, str(int(Temperature)) + "C") # Mostrar el valor de Temperatura en el OLED
add_text(0, 2, "UV:")
add_text(3, 2, str(int(uv))) # Mostrar el valor de UV en el OLED
add_text(5, 2, " | Rain:")
add_text(13, 2, str(int(rain_percent)) + "%") # Mostrar el porcentaje de lluvia en el OLED
add_text(0, 4, "Light:")
add_text(6, 4, str(Lightintensity)) # Mostrar la intensidad de luz en el OLED
add_text(9, 4, " | Sound:")
add_text(18, 4, str(soundLevel)) # Mostrar la intensidad de ruido en el OLED
```
⑰ Cuando el valor analógico de las partículas de polvo PM2.5 excede 36.455, se puede calcular su valor de concentración y mostrarlo en el OLED. De lo contrario, el monitor serie imprime los valores analógicos de polvo correspondientes.
```Python
if dustVal > 36.455:
# La misma fórmula de cálculo exacta
voltage = dustVal / 1024.0
pm25 = (voltage - 0.0356) * 120000 * 0.035
# El OLED muestra información detallada del valor de PM2.5.
add_text(0, 6, "PM2.5dust:")
add_text(10, 6, str(round(pm25)) + "ug/m3")
else:
print("Low value:", dustVal)
```
#### 4.3.9.6 Resultado de la prueba
Después de realizar las conexiones y encender mediante el cable micro USB, conecte la alimentación externa (6 pilas AA) para asegurar un suministro eléctrico suficiente, y haga clic en “Flash” para descargar el código a la placa micro:bit.
Después de subir el código de prueba, presione el botón de reinicio en la parte posterior de la micro:bit.
Lee los valores de sus sensores integrados (incluyendo sensor de luz, sensor de temperatura, micrófono) así como de sensores externos (como el sensor de polvo PM2.5, sensor de vapor y sensor solar ultravioleta), y a continuación puede mostrar la intensidad de luz, temperatura, intensidad de ruido, intensidad de lluvia, intensidad ultravioleta de la luz solar y concentración de polvo PM2.5 de forma intuitiva y en tiempo real a través de la pantalla OLED con interfaz I2C.
Sople aire (o genere un ruido muy fuerte) hacia el micrófono de la placa Microbit (⚠️ **recordatorio especial: soplar aire tiene un efecto más evidente**), y la pantalla OLED mostrará la intensidad del soplo de aire (o del ruido).
Cuando se presiona el botón A en la placa micro:bit, el ventilador en el módulo motor gira. Cuando se presiona el botón B en la placa, el módulo de atomización rocía niebla de agua.
⚠️ Recordatorio especial: A veces la tensión de la alimentación externa puede ser insuficiente. En tales casos, puede ser necesario presionar el botón dos veces en la placa micro:bit antes de que el ventilador comience a girar o el módulo de atomización empiece a pulverizar niebla.
⚠️ **Nota: Los bloques de construcción en el experimento no están incluidos en este kit.**
(**Consejo:** Si no se observa ningún resultado, por favor presione el botón de reinicio de la placa micro:bit.)
