### 4.3.7 Regulación de temperatura y humedad
#### 4.3.7.1 Visión general
En este proyecto, introduciremos cómo construir un sistema de regulación de temperatura y humedad con una placa micro:bit, el sensor de temperatura y humedad XHT11, un motor 130, un módulo de atomización y una pantalla OLED.
El sistema mide la temperatura y humedad ambiental mediante el sensor XHT11 y las ajusta controlando la rotación del ventilador y la pulverización de niebla de agua mediante el módulo de atomización según sea necesario. Cuando la temperatura o la humedad superan el umbral establecido, activará el ventilador y pulverizará niebla de agua desde el módulo de atomización. Mientras tanto, la pantalla OLED mostrará la temperatura y humedad actuales en tiempo real.
Como puede regular la temperatura y la humedad, se aplica ampliamente a proyectos que necesitan controlar estas variables.
#### 4.3.7.2 Conocimiento de los componentes
**Sensor de temperatura y humedad XHT11**
El sensor de temperatura y humedad XHT11 ofrece señales digitales. Adquiere y convierte señales analógicas, y detecta temperatura y humedad para asegurar su excelente estabilidad a largo plazo y alta fiabilidad. Además, contiene un sensor de humedad resistivo de alta precisión y un sensor termossensitivo resistivo de temperatura, y está conectado a un microcontrolador de 8 bits de alto rendimiento.
**Modo de comunicación del XHT11:**
El XHT11 adopta una comunicación simplificada de bus único. Un bus único significa que solo hay una línea de datos, por lo que el intercambio de datos y el control en el sistema se realizan ahí.
- Definición de transmisión de bits de datos por bus único:
- Formato de datos por bus único: se transmiten 40 bits de datos a la vez, saliendo primero los bits de mayor peso.
- 8 bits entero de humedad + 8 bits decimal de humedad + 8 bits entero de temperatura + 8 bits decimal de temperatura + 8 bits de paridad. **Tenga en cuenta que la parte decimal de la humedad es 0**.
- Definición del bit de paridad:
- 8 bits entero de humedad + 8 bits decimal de humedad + 8 bits entero de temperatura + 8 bits decimal de temperatura. El bit de paridad de 8 bits son los últimos 8 bits del resultado.
Diagrama de la secuencia temporal de datos:
Después de que el host (MCU) envía una señal de inicio una vez, el XHT11 cambia de modo de baja potencia a modo de alta velocidad. Una vez que la señal de inicio del host termina, el XHT11 envía una señal de respuesta, emite 40 bits de datos y realiza una adquisición de señal. La transmisión de la señal se muestra a continuación.
⚠️ **Nota:** Los datos de temperatura y humedad leídos por el host desde XHT11 siempre corresponden a la medición anterior. Si el intervalo entre dos medidas es largo, por favor léalos dos veces consecutivas y tome el segundo valor obtenido como el valor en tiempo real.
**Diagrama esquemático:**
**Parámetros:**
- Tensión de funcionamiento: DC 3.3V~5V
- Corriente de funcionamiento: (Max)2.5mA@5V
- Potencia máxima: 0.0125W
- Rango de temperatura: -25 ~ +60°C (±2℃)
- Rango de humedad: 5 ~ 95%R (precisión de ±5%RH alrededor de 25 °C)
- Señal de salida: bus único digital bidireccional
**Módulo de atomización**
El módulo de atomización está compuesto por un driver y una lámina atomizadora, que atomiza el agua. Puede ser controlado por un microcontrolador o por botones manuales.
**Principio de funcionamiento:** El módulo de atomización generalmente emplea tecnología ultrasónica para generar la niebla de agua. Contiene una placa cerámica piezoeléctrica, que comienza a vibrar cuando se aplica sobre ella una tensión de alta frecuencia. La vibración recoge pequeñas gotas de agua en la superficie y las dispersa formando finas nieblas de agua.
**Calidad de la niebla:** Este módulo puede convertir el agua en partículas muy finas, normalmente entre 1 y 5 micras. Esta fina niebla tiende a evaporarse y difundirse en el aire, actuando así como un humidificador eficaz.
⚠️ **Atención:**
**1. Después de encender, la lámina atomizadora debe colocarse en el agua. Si se deja al aire por mucho tiempo, la lámina se calentará y se quemará.**
**2. Coloque la lámina atomizadora suavemente sobre la superficie del agua. Si está sumergida en el agua, no generará niebla.**
**Parámetros:**
- Tensión de funcionamiento: DC 3.3 ~ 5V
- Orificio de instalación: diámetro de 4.8mm, separación de 16mm
- Dimensiones: 31mm de largo, 23mm de ancho y 8mm de alto
- Peso: 4.5g
- Temperatura de funcionamiento: -25°C a +60°C
- Interfaz del módulo: pines curvados de 3 pines, separación de 2.54
- Interfaz de la lámina atomizadora: conector PH2.0 hembra
- Función: utilizada para transformar el agua en fina niebla de agua y liberarla al aire
**Dimensiones de la lámina atomizadora:**
⚠️ **Nota: Evite tirar del cable de la lámina en la medida de lo posible, de lo contrario su punto de soldadura podría desprenderse.**
**Instrucciones de uso del módulo de atomización:**
Existen dos modos de control: por botones y por programación con MCU.
**Control por botón:** Presione el botón para encender el módulo de atomización. Presione de nuevo para apagarlo.
**Control por programación con MCU:** Simula la pulsación de un botón. Bajo condiciones normales emite alto y cuando se presiona emite bajo. Al soltar el botón vuelve a emitir un nivel alto.
Por lo tanto, al usar MCU solo necesitamos aplicar un breve nivel bajo al módulo, como si se pulsara el botón. Podemos controlar el tiempo de inicio o pausa del módulo de atomización ajustando el tiempo del nivel alto.
**Instalar la mecha de algodón:**
1\. Empape completamente la mecha de algodón en agua (encuentre un recipiente de gran capacidad que cubra toda la mecha con agua y sumérjala durante más de 5 minutos para asegurar que absorba bien el agua).
2\. Instale la lámina atomizadora dentro del soporte de plástico. Observe la dirección de la lámina. Coloque su cable en la ranura del soporte.
3\. Cierre el otro lado del soporte de plástico.
4\. Inserte la mecha de algodón en el centro del soporte. Debe introducirse hasta el fondo hasta tocar la lámina atomizadora.
5\. Conecte la lámina atomizadora al terminal hembra PH2.0 del módulo, como se muestra a continuación.
6\. Conecte el módulo de atomización al shield de micro:bit y conecte una fuente de alimentación externa.
7\. Sumerja la mecha de algodón en agua nuevamente durante más de 3 minutos. El agua debe cubrir la mecha en la medida de lo posible, pero no debe desbordarse.
8\. Presione el botón negro del módulo y podrá ver que comienza a pulverizar. La niebla de agua se pulveriza durante 3 segundos. Presione el botón de nuevo para apagarlo.
⚠️ **Atención: La lámina atomizadora no debe funcionar durante mucho tiempo; cada operación no debe exceder de 5 segundos. Es mejor detenerla durante 1 o 2 minutos hasta que la mecha de algodón esté llena de agua antes de continuar. De lo contrario, puede quemarse.**
#### 4.3.7.3 Componentes necesarios
| |  | |
| :--: | :--: | :--: |
| micro:bit V2 placa principal ×1 | shield de micro:bit ×1 | módulo de atomización ×1 |
||| |
| Sensor de temperatura y
humedad XHT11 ×1 | pantalla OLED ×1 | motor 130 ×1 |
| |||
| cable micro USB ×1 | 2 cables de 4 pines | 2 cables de 3 pines |
| || |
| ventilador ×1 | porta pilas ×1 | pilas AA (**proveídas por el usuario**) ×6 |
#### 4.3.7.4 Diagrama de conexiones
⚠️ **Al cablear, por favor preste atención al color de los cables.**
| 130 motor | color del cable | pin del shield micro:bit | pin de la placa micro:bit |
| :-------: | :--------: | :------------------: | :-----------------: |
| G | negro | G | G |
| V | rojo | V2 | V |
| IN+ | azul | 2 | P2 |
| IN- | verde | 13 | P13 |
| pantalla OLED | color del cable | pin del shield micro:bit | pin de la placa micro:bit |
| :----------: | :--------: | :------------------: | :-----------------: |
| GND | negro | G | G |
| VCC | rojo | V2 | V |
| SDA | azul | 20 | P20 |
| SCL | verde | 19 | P19 |
| módulo de atomización | color del cable | pin del shield micro:bit | pin de la placa micro:bit |
| :----------------: | :--------: | :------------------: | :-----------------: |
| G | negro | G | G |
| V | rojo | V2 | V |
| S | amarillo | 16 | P16 |
| Sensor de temperatura y
humedad XHT11 | color del cable | pin del shield micro:bit | pin de la placa micro:bit |
| :----------------------------------------: | :--------: | :------------------: | :-----------------: |
| G | negro | G | G |
| V | rojo | V1 | V |
| S | amarillo | 0 | P0 |
#### 4.3.7.5 Flujo del código
#### 4.3.7.6 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” y el archivo de la librería “DHT11\.py” siguiendo ** “[Import Library on MU](https://docs.keyestudio.com/projects/KS4050/en/latest/docs/MicroPython/MU_development_environment.html#import-library-on-mu)” .
⚠️ **Consejo 2: Los umbrales 30 y 70 en la condición if() se pueden modificar según la situación real.**
**Código completo:**
```Python
'''
Theme: Air temperature and humidity regulation
Function: OLED displays temperature and humidity, XHT11 sensor controls the motor and the atomization module to regulate the environment temperature and humidity
Compiling IDE: MU 1.2.0
Author: https://docs.keyestudio.com
'''
# importar bibliotecas relacionadas
from microbit import *
from oled_ssd1306 import *
from DHT11 import *
# inicializar y limpiar OLED
initialize()
clear_oled()
sensor = DHT11(pin0) # establecer pines de temperatura y humedad
# Añadir un tiempo de espera de inicialización
display.show(Image.ALL_CLOCKS, wait=False, loop=True)
sleep(3000) # Dar al sensor 3 segundos de tiempo de estabilización
display.clear()
pin16.write_digital(1) # poner el pin P16 en nivel alto
# Añadir un contador de lecturas
read_count = 0
last_valid_temp = 0
last_valid_humid = 0
while True:
# Intentar leer varias veces
for i in range(3):
sensor.read() # leer los valores de temperatura y humedad
if sensor.temp != 0 or sensor.humid != 0:
break
sleep(1000)
T = sensor.temp # almacenar los valores de temperatura en T
H = sensor.humid # almacenar los valores de humedad en H
# Comprobar la validez de los datos
if T == 0 and H == 0 and read_count < 5:
# Las primeras lecturas pueden ser 0. Seguir intentando
read_count += 1
add_text(0, 0, "Initializing...")
add_text(0, 2, "Attempt: " + str(read_count))
sleep(1000)
continue
# Si los datos son válidos, actualizar el último valor válido
if T != 0 or H != 0:
last_valid_temp = T if T != 0 else last_valid_temp
last_valid_humid = H if H != 0 else last_valid_humid
read_count = 10 # La lectura se ha realizado correctamente
# Usar datos válidos (si el valor actual es 0, usar el último valor válido
display_temp = T if T != 0 else last_valid_temp
display_humid = H if H != 0 else last_valid_humid
clear_oled()
add_text(0, 0, "Temper: " + str(display_temp) + " C") # Mostrar el valor de temperatura
add_text(0, 2, "Humid: " + str(display_humid) + " %RH") # Mostrar el valor de humedad
# lógica de control
if display_temp > 30 or display_humid > 70:
add_text(0, 4, "Cooling/Humidifying")
pin2.write_analog(500)
pin13.write_digital(0)
sleep(2000)
pin2.write_analog(0)
pin13.write_digital(0)
sleep(500)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(3000)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(1000)
else:
add_text(0, 4, "Normal State")
pin2.write_analog(0)
pin13.write_digital(0)
pin16.write_digital(1)
sleep(500)
```
**Breve explicación:**
① Importar las librerías microbit, oled_ssd1306 y DHT11.
```Python
from microbit import *
from oled_ssd1306 import *
from DHT11 import *
```
② Inicializar los píxeles del OLED, limpiar el OLED.
```Python
initialize()
clear_oled()
```
③ Inicializar el pin del sensor de temperatura y humedad XHT11.
```Python
sensor = DHT11(pin0) # establecer pines de temperatura y humedad
```
④ Definir variables y establecer sus valores iniciales a 0.
```Python
read_count = 0
last_valid_temp = 0
last_valid_humid = 0
```
⑤ Leer la temperatura y la humedad varias veces y asignar la temperatura leída a la variable T y la humedad a la variable H.
```Python
for i in range(3):
sensor.read() # leer los valores de temperatura y humedad
if sensor.temp != 0 or sensor.humid != 0:
break
sleep(1000)
T = sensor.temp # almacenar los valores de temperatura en T
H = sensor.humid # almacenar los valores de humedad en H
```
⑥ Comprobar la validez de los valores de temperatura y humedad.
```Python
if T == 0 and H == 0 and read_count < 5:
# Las primeras lecturas pueden ser 0. Seguir intentando
read_count += 1
add_text(0, 0, "Initializing...")
add_text(0, 2, "Attempt: " + str(read_count))
sleep(1000)
continue
```
⑦ Si son válidos, actualizar el último valor válido.
```Python
if T != 0 or H != 0:
last_valid_temp = T if T != 0 else last_valid_temp
last_valid_humid = H if H != 0 else last_valid_humid
read_count = 10 # La lectura se ha realizado correctamente
```
⑧ Usar los datos válidos (si el valor actual es 0, usar el último valor válido).
```Python
display_temp = T if T != 0 else last_valid_temp
display_humid = H if H != 0 else last_valid_humid
```
⑨ Mostrar en la OLED la temperatura y humedad detectadas por el sensor XHT11.
```Python
add_text(0, 0, "Temper: " + str(display_temp) + " C") # Mostrar el valor de temperatura
add_text(0, 2, "Humid: " + str(display_humid) + " %RH") # Mostrar el valor de humedad
```
⑩ Sentencia de decisión: if()...else...
Si la temperatura detectada supera 30℃ o la humedad supera 70%RH, el ventilador girará durante 2 segundos y luego se detendrá. A continuación, el módulo de atomización funciona y pulveriza niebla de agua para regular la temperatura y humedad ambiente. Mientras tanto, la OLED muestra “Cooling/Humidifying”.
```Python
if display_temp > 30 or display_humid > 70:
add_text(0, 4, "Cooling/Humidifying")
pin2.write_analog(500)
pin13.write_digital(0)
sleep(2000)
pin2.write_analog(0)
pin13.write_digital(0)
sleep(500)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(3000)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(1000)
```
De lo contrario, el ventilador y el módulo de atomización no funcionarán, y la OLED mostrará “Normal State”.
```Python
else:
add_text(0, 4, "Normal State")
pin2.write_analog(0)
pin13.write_digital(0)
pin16.write_digital(1)
```
⑪ Retardo de 500 ms (0.5 s)
```Python
sleep(500)
```
#### 4.3.7.7 Resultado de la prueba
Después de cablear y alimentar mediante el cable micro USB, conecte la alimentación externa (6 pilas AA) para asegurar un suministro 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 trasera de la micro:bit.
La matriz de LED 5×5 de la placa micro:bit muestra el patrón de puntero giratorio, la OLED muestra la información de inicialización del sensor de temperatura y humedad XHT11, y luego la OLED muestra en tiempo real el valor de temperatura y humedad detectado por el sensor XHT11.
Si la temperatura detectada supera 30℃ o la humedad supera 70%RH, el ventilador girará durante 2 segundos y luego se detendrá. A continuación, el módulo de atomización funcionará y pulverizará niebla de agua para regular la temperatura y humedad ambiente. Mientras tanto, la OLED mostrará “Cooling/Humidifying”. De lo contrario, el ventilador y el módulo de atomización no funcionarán, y la OLED mostrará “Normal State”.
⚠️ **Nota: Los bloques de construcción en el experimento no están incluidos en este kit.**
(**Consejo:** Si no observa ningún resultado, por favor presione el botón de reinicio de la placa micro:bit.)
