Ces dernières années, la qualité de l'air que nous respirons est malheureusement devenue un problème non négligeable. Il en est ainsi depuis longtemps pour les environnements intérieurs, surtout en hiver, où nous sommes nombreux à rester enfermés dans une pièce mal ventilée. Mais également à l'extérieur, surtout dans les villes, dont l'air est de plus en plus contaminé par les émissions polluantes des véhicules à moteur, des centrales de chauffage (n'oublions pas que le gaz naturel n'est pas du méthane pur, mais qu'il contient d'autres gaz et des additifs pour l'odeur et la teinte de la flamme...), des usines et des centrales thermiques, etc. Là où la rareté de la végétation ne favorise pas l'oxygénation de l'air, la teneur en oxygène est donc faible et ne favorise pas les processus naturels de l'organisme humain et animal.

Dans les environnements intérieurs, la qualité de l'air est dégradée par des éléments tels que le dioxyde de carbone que nous expirons, mais aussi par les particules et les agents pathogènes que nous pouvons émettre en respirant ou en toussant, comme par exemple l'infection de la COVID 19, qui est depuis longtemps un problème avec lequel nous vivons, et dont l'une des principales voies de transmission est l'air intérieur. La propagation de ce virus ou d'autres dans les environnements clos, est essentiellement un problème de qualité de l'air. Plus l'air est « vicié » , et plus la concentration de gouttelettes (gouttelettes de salive et de liquides organiques provenant des muqueuses) potentiellement chargées d'agents pathogènes, capables de propager la maladie, est élevée. La solution pour atténuer la contagion est bien sûr d'opérer un renouvellement de l'air, afin de réduire la concentration de ces agents pathogènes. Mais quand faut-il aérer ? Car en été comme en hiver, nous avons tendance à garder nos fenêtres fermées pour réduire la consommation des systèmes de climatisation et de chauffage. 


Dans cet article, eh bien nous proposons un système simple ! En utilisant un capteur de CO2 et de COVT (c'est-à-dire la concentration de particules organiques en suspension dans l'air, également connue en Italie sous l'acronyme Volatile Organic Compounds, VOC), nous pouvons avoir une idée de la qualité de l'air d'une pièce. Et, avec des leds, nous savons quand il est temps d'opérer un renouvellement de l'air, ce qui nous permet de garder la qualité de l'air sous contrôle et de minimiser les pertes d’énergie.

La partie matérielle du projet

Pour réaliser cet équipement que nous avons décrit jusqu'à maintenant, nous avons décidé d'utiliser un module Heltec WiFi kit 32 comme unité de contrôle, un capteur SGP30 de Sensirion comme élément de détection de la concentration de CO2 et de COVT, et deux leds communes (l'une rouge et l'autre verte) comme éléments de signalisation. Le schéma théorique du système est proposé dans la Figure 1.

Figure 1 : Principe du système de mesure et de signalement de la qualité de l'air.

Module Heltec WiFi Kit 32

Le module Heltec WiFi Kit 32, qui est en fin de compte le cœur de notre système, est une petite carte électronique qui intègre un microcontrôleur ESP32 et un écran OLED de 0,96 pouces, comme montré dans la Figure 2. Les caractéristiques matérielles du module WiFi Kit 32, que nous utiliserons dans le cadre de ce projet, sont les suivantes :

  • Écran. OLED bleu de 0.96 pouces ;
  • Microcontrôleur 32-bit double coeur Tensilica LX6 ;
  • Fréquence d’horloge jusqu’à 240 MHz ;
  • SRAM interne de 520 kB ;
  • Mémoire flash de 32 MB ;
  • Émetteur-récepteur Wi-Fi 802.11 b/g/n intégré ;
  • Bluetooth mixte (classique et BLE) intégré ;
  • Alimentation : 3.3 V à 7 V ;
  • 28 ports GPIOs (certains utilisés pour gérer l'écran OLED) ;
  • Chargeur de batteries lithium-polymère intégré ;
  • Température de fonctionnement : -40 °C à +90 °C.


Ce module est idéal pour notre projet, car il intègre déjà un écran OLED, que nous utiliserons pour afficher les mesures de la qualité de l'air et les messages de l'utilisateur, ainsi que plusieurs ports GPIOs dont nous avons besoin pour contrôler nos éléments de signalisation. Dans cette première version, nous prévoyons d'utiliser seulement 2 leds, mais le nombre de GPIOs disponibles (28 au total) nous permettrait facilement d'ajouter d'autres éléments, comme un buzzer, pour produire un avertissement sonore. En plus de ces caractéristiques, le module possède 520 kB de RAM embarquée, et jusqu'à 32 Mb de mémoire Flash, des caractéristiques qui nous permettent d'être à l'aise au niveau des ressources en mémoire pour le programme de notre système.

Figure 2 : Le module Heltec WiFi Kit 32.

En plus de cela, le module intègre un émetteur-récepteur WiFi 802.11 standard, que nous pourrons utiliser pour les évolutions futures de ce système (par exemple, pour publier des données sur les concentrations de CO2 et de COVT directement sur une page web, ou pour envoyer des alarmes via Telegram), ainsi qu'une radio Bluetooth, que nous pourrons utiliser pour l'interfaçage avec des dispositifs externes comme les smartphones et les PCs, que nous pourrons éventuellement utiliser pour configurer le système lui-même. Pour finir, la carte intègre également un chargeur LiPo embarqué, qui nous permettrait d'associer un élément de batterie, ce qui est très utile pour alimenter l'appareil même en l'absence de tension secteur. La Figure 3 montre le brochage de notre module.

Figure 3 : Brochage du module Wi-Fi kit 32.

Le capteur SGP30 

Pour obtenir la concentration de dioxyde de carbone et de COVT dans l'air, nous avons décidé d'utiliser un circuit imprimé basé sur le capteur SGP30 de Sensirion. Ce petit capteur nous permet de connaître la concentration de CO2 (pour nous indiquer à quel point l'air d'un environnement clos est vicié) et de COVT (Total Volatile Organic Compounds, TVOC), c'est-à-dire la concentration en parties par milliard des particules en suspension. La Figure 4 montre une image de cette carte d'interface :

  • Capteur : Sensirion SGP30 (COVT et CO2) ;
  • COVT (Total Volatile Organic Compounds) détection : 0 à 60000 ppb (parties par milliard) ;
  •  
  • Détection de CO2 : 400 à 60,000 ppm (parties par million) ;
  • Fréquence d’échantillonnage : 1 Hz ;
  • Interface : I2C (adresse 0x58)
  • Alimentation : 3.3 V ou 5 V.
 
Figure 4 : La carte d’interface pour le capteur SGP30.

Câblage matériel

Voyons maintenant comment réaliser notre instrument de mesure en pratique, en commençant par la construction physique puis le câblage des composants. La connexion entre la carte du capteur et les leds est basique, à tel point qu'elle peut être réalisée par des fils de connexion mâle-femelle comme ceux pour Arduino, ou en s'appuyant sur une plaque d'essais, comme vous le voyez sur ces pages. Le capteur SGP30 est un breakout board interfacé via le bus I²C. Il a donc besoin d'un total de quatre connexions, car en plus des lignes d'horloge (SCL) et de données (SDA) du bus I²C, nous devons également connecter les deux lignes d'alimentation (GND et la ligne positive de 3,3 V).

Figure 5 : Schéma de câblage général de l'indicateur.

Les deux leds, par contre, sont interfacées par deux GPIOs standards du module WiFi Kit 32. Ces leds ne peuvent pas être pilotées directement par le module, pour éviter les surcharges aux broches GPIOs. Nous devons donc placer des résistances de limitation de courant adaptées en série avec elles, que nous avons calculées avec une valeur de 220 Ohm chacune. Pour faciliter les connexions, la Figure 5 présente le schéma de câblage à utiliser si l'on souhaite relier les différents éléments par des fils soudés ou des cavaliers mâle-femelle. En plus, le Tableau 1 montre les connexions entre le module WiFi Kit 32 et la carte d'interface SGP30. Alors que le Tableau 2 montre les broches du module WiFi kit 32 utilisées pour les deux leds de signalisation.

Tableau 1: Connections entre les cartes WiFi Kit 32 et SGP30.
Fonction Broche WiFi Kit 32  Broche SGP30 
SDA 19 sda
SCL 18 scl
Masse GND GND
3.3 V 3V3 Vcc

 

Tableau 2: Connections des leds.
LED Broche WiFi Kit 32
Verte 2
Rouge 17

 

Réalisation du programme

Après avoir examiné les détails matériels de notre système, nous passons au logiciel. Pour le développement du logiciel de contrôle, nous avons décidé d'utiliser MicroPython, et plus particulièrement le port pour ESP32. MicroPython est un système puissant pour le développement d'applications logicielles pour les microcontrôleurs modernes, orientés IdO, tels que l'ESP32. Cette étape du développement est rendue beaucoup plus facile par la grande quantité de bibliothèques existantes pour gérer les capteurs, les actionneurs et les interfaces.

Je m'abonne
Abonnez-vous à la balise thématique MicroPython pour être averti dès qu'une information relative à ce sujet sera publiée par Elektor !

Installation de MicroPython

Pour utiliser MicroPython sur le WiFi Kit 32, la première chose à faire est d'installer l'interpréteur, car le WiFi kit 32 ne le possède pas par défaut. La version utilisée pour le développement de cette application est la v1.19 (2022-06-18). Téléchargez le firmware et sauvegardez-le dans un dossier de votre PC. A ce stade, vous devez également vous équiper d'esptool, un outil utilisé pour écrire la mémoire flash de l'ESP32, distribué gratuitement par Espressif (la société qui fabrique l'ESP32 et l'ESP8266). A ce stade, vous devez effacer la mémoire de l'appareil et ensuite « flasher » (charger dans la mémoire flash) le binaire MicroPython.

Effacement de la mémoire

Connectez d'abord le WiFi kit 32 à votre PC à l'aide d'un câble micro USB. L'appareil doit être associé à un port COM virtuel (par exemple COM3, mais le chiffre exact dépend du nombre de ports que vous avez déjà sur votre système). Mettez ensuite la carte en mode programmation, en appuyant et en maintenant enfoncé le bouton PRG, puis en appuyant sur le bouton RST et en le relâchant. Ensuite il ne vous reste plus qu'à utiliser la fonction esptool.py pour effacer la mémoire. Vous pouvez placer le chemin du script dans le chemin de votre système, ou vous pouvez opérer directement à partir de ce dossier et effacer la mémoire avec la commande suivante (valable dans l'environnement Windows) :


python esptool.py --port <port_numb> erase_flash


Remplacez <port_numb> avec le port COM virtuel assigné à votre carte (par exemple, COM3).

Flashage de l'interpréteur MicroPython

A ce stade, vous pouvez flasher MicroPython (dans l'ESP32, l'interpréteur doit être flashé à l'adresse 0x1000). Vous pouvez utiliser l'invite de commande suivante, toujours sous Windows :


python esptool.py --chip esp32 --port <port_numb> --baud 460800 write_flash -z 0x1000 esp32.bin


Comme précédemment, remplacez <port_numb> avec le port COM virtuel assigné à votre carte et esp32.bin avec le nom (et éventuellement le chemin, s'il n'est pas le même que celui à partir duquel vous opérez), du binaire que vous avez téléchargé plus tôt. La Figure 6 montre le résultat de cette opération.

Figure 6 : Fenêtre de la console Windows après le flashage de MicroPython.

Logiciel de contrôle

A ce stade, nous pouvons passer à la gestion du logiciel de contrôle de notre carte. Comme nous l'avons mentionné, nous voulons acquérir les données concernant les valeurs de CO2 et de COVT fournies par le capteur SGP30, afficher ces données sur l'écran OLED, et lire à partir du système de fichiers les seuils d'utilisateur pour les valeurs limites de CO2 (avec l'hystérésis associé). Gérer deux diodes leds (rouge et verte) pour indiquer si le niveau de CO2 est supérieur au seuil maximum autorisé. Pour mettre en œuvre ce logiciel, nous avons d'abord besoin de pilotes appropriés pour gérer l'écran OLED et le capteur SGP30. Heureusement, les deux pilotes développés par Adafruit sont disponibles. Vous pouvez les obtenir en les téléchargeant sur les liens suivants :

 
Figure 7 : Architecture du logiciel.

Le schéma architectural du logiciel que nous proposons de mettre en œuvre est présenté dans la Figure 7. Le projet complet se traduit ainsi par les trois fichiers suivants :

  • air_quality.py (fichier principal de l’application) ;
  • ssd1306.py (pilote de l'écran OLED) ;
  • adafruit_sgp30.py (pilote du capteur SGP30).
Figure 8 : Configuration du port MicroPython’s pour l’ ESP32 avec Thonny.

Comme IDE de développement pour cette application, nous utiliserons Thonny, l'un des IDE les plus utilisés pour Python, qui permet de développer à la fois des applications Python standard et des applications MicroPython. Thonny peut être téléchargé gratuitement à l'adresse suivante. L'interface avec MicroPython est très simple, car après avoir connecté la carte WiFi Kit 32 au port USB du PC, ouvrez Thonny et cliquez sur le bord inférieur droit. Dans le menu déroulant qui s'ouvre après avoir cliqué, sélectionnez ESP32 parmi les différents interpréteurs disponibles, comme le montre la Figure 8. Si l'interpréteur ne s'affiche pas, sélectionnez Configurer l'interpréteur... et indiquez manuellement l'interpréteur et le port COM à utiliser, comme illustré en Figure 9. 

Figure 9 : Configuration manuelle de l'interpréteur et du port COM dans Thonny.


Nous passons maintenant aux détails du logiciel d'application, contenu entièrement dans le fichier air_quality.py, qui se décompose en deux étapes distinctes :

  • Configuration du système (System Setup)
  • Boucle principale (Main Loop)
 
// -------------------------------------------------
// - SYSTEM INIT
// -------------------------------------------------
// LEDs
led_green = Pin(2, Pin.OUT)
led_red = Pin(17, Pin.OUT)
led_green.on()
led_red.off()

// Initialize I2C buses
s_i2c = I2C(scl=Pin(18), sda=Pin(19), freq=100000)
d_i2c = SoftI2C(scl=Pin(15), sda=Pin(4), freq=100000)


// OLED enable pin
oled_sts = Pin(16, Pin.OUT)
oled_sts.on()


// OLED initialization
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, d_i2c)


// Air quality sensor init
sgp30 = adafruit_sgp30.Adafruit_SGP30(s_i2c)


// Initialize SGP-30 internal drift compensation algorithm.
sgp30.iaq_init()


// Wait 15 seconds for the SGP30 to properly initialize
user_message(‘Sensor Init...’)
time.sleep(SENS_INIT_DELAY_S)


// User threshold for LEDs indication
get_user_threshold()


// Sensor Calibration
get_sensor_baseline()


// Store the time at which last baseline has been saved
baseline_time = time.time()


La première étape, comme son nom l'indique, constitue la phase d'initialisation du système, tandis que la seconde est la boucle principale dans laquelle ont lieu les mesures, l'impression des valeurs sur l'écran OLED et la signalisation de l'état avec les leds. La première étape, dont le code est donné dans le Listing 1, est chargée d'initialiser tous les périphériques du système, comme les leds, les deux bus I²C (l'un utilisé pour interfacer l'écran OLED, l'autre pour gérer le capteur SGP30), et de récupérer dans le système de fichiers les valeurs de la ligne de référence du capteur SGP30 et du seuil de CO2 fixé par l'utilisateur. Ces fichiers sont des fichiers texte que le logiciel est censé trouver dans le système de fichiers. Les valeurs de référence du capteur sont des valeurs d'étalonnage qui améliorent la précision de la lecture, et sont automatiquement créées par le logiciel si elles ne sont pas présentes. Par contre, les fichiers contenant le seuil d'alarme pour la valeur de CO2 doivent être créés par l'utilisateur, et s'ils ne sont pas présents, des valeurs par défaut sont chargées. Les deux fichiers suivants doivent être créés pour définir ce seuil :

  • co2eq_th.txt = contiens le seuil d’alarme pour la lecture du CO2, en ppm (parties par million) ;
  • hist_th.txt = contiens l’hysteresis du seuil précédent, aussi en ppm.
 
Figure 10 : Accès à la mémoire de la carte depuis Thonny.

La création de ces fichiers est simple, car dans l'environnement Thonny, avec la carte connectée via USB, sélectionnez l'icône de fichier ou Fichier > Nouveau. Répétez cette opération deux fois pour créer deux fichiers et écrivez les valeurs à l'intérieur (par exemple, 450 dans le fichier co2eq_th.txt et 10 dans le fichier hist_th.txt, de sorte que vous avez un seuil de 450 ppm de CO2 et un hystérésis de 10 ppm). Cliquez maintenant sur l'icône de la disquette (ou sélectionnez Fichier > Sauvegarder) et dans le pop-up qui apparaît, sélectionnez Micropython Device, comme le montre la Figure 10. Cela vous permettra d'accéder au système de fichiers de la carte et d'enregistrer les fichiers que vous avez créés précédemment. Ceci vous permet de définir la valeur seuil de CO2 choisie. Une fois la phase d'initialisation terminée, le logiciel passe à la boucle principale, décrite dans le Listing 2. 

// ------------------------------------------------
// - MAIN LOOP
// ------------------------------------------------
while True:
    // Get CO2 and TVOC data
    co2eq, tvoc = sgp30.iaq_measure()
    
    // Print values on Display
    oled_data(co2eq, tvoc)
    
    // Manage LEDs
    if (co2eq > co2eq_th):
        led_green.off()
        led_red.on()
    elif (co2eq < (co2eq_th - hysteresis)):
        led_green.on()
        led_red.off()        
    
    // Update sensor baseline
    update_sensor_baseline()

   
// Wait for the new sampling time
    time.sleep(SAMPLING_TIME_S)


Ici, les opérations suivantes sont effectuées dans l’ordre. Grâce à la fonction iaq_measure() de la bibliothèque adafruit_sgp30 (sgp30_iaq_measure()), les valeurs de CO2 et de COVT sont relevées et sauvegardées dans les deux variables co2eq et tvoc, respectivement. A ce stade, dans la ligne suivante, les valeurs sont imprimées sur l'écran OLED, via la fonction oled_data(). Ensuite, une série d'instructions if...elif permet de gérer la signalisation de la LED. Plus concrètement, si la valeur stockée dans la variable co2eq est supérieure au seuil co2eq_th, fixé par l'utilisateur, la led rouge est allumée et la led verte est éteinte. À l'inverse, si la valeur est inférieure à la valeur du seuil moins l'hystérésis (co2eq_th - hysteresis), la led rouge est éteinte et la led verte est allumée. Une fois cette phase terminée, la fonction update_sensor_baseline() est appelée pour mettre à jour la ligne de référence du capteur.     

Pour assurer un fonctionnement optimal du capteur, le logiciel met à jour la ligne de référence la première fois après 12 heures de fonctionnement, puis toutes les heures, comme indiqué dans la fiche technique du fabricant du SGP30. À ce stade, la boucle se met en pause pendant 60 secondes avant de lancer un nouveau cycle d'acquisition de données. Le projet logiciel complet de cette application, avec la description et toutes les bibliothèques MicroPython nécessaires, peut être téléchargé à partir des dépôts GitHub suivants.

 

Pour tester le logiciel, vous devrez sauvegarder les deux fichiers contenant les pilotes dans la mémoire de la carte WiFi Kit 32, avec la même procédure que celle illustrée pour la sauvegarde des fichiers utilisateur, en faisant attention à garder les mêmes noms de fichiers, et à ne pas oublier l'extension .py. Le fichier principal peut être exécuté directement à partir de Thonny, ou sauvegardé sur la mémoire de la carte en le renommant main.py, un passage obligé si l'on veut faire fonctionner la carte en mode standalone, c'est-à-dire non connecté au PC. Car en effet, le fichier main.py est le fichier qui est automatiquement recherché par l'interpréteur MicroPython lors du démarrage. Une image de l'indicateur câblé sur une plaque d'essais pendant qu'il recueille des données sur la qualité de l'air et qu'il active les LED est proposée à la Figure 11.

Figure 11 : Le prototype, câblé sur une plaque d’essais pour les tests.

Configuration

Le logiciel comprend également des options de configuration qui peuvent être modifiées par l'utilisateur et qui se trouvent toutes dans le fichier air_quality.py. Plus précisément, il est possible de:

a. Changer les valeurs par défaut du seuil d'alarme de CO2 et de son hystérésis en modifiant les deux paramètres co2eq_th et hysteresis, qui sont fixés à 450 et 10 par défaut, comme illustré dans le Listing 3 (agir sur les valeurs par défaut ne nécessite pas de sauvegarder les valeurs de ces deux paramètres dans le système de fichiers).

b. Modifier le temps d'attente initial pour la stabilisation du capteur et le temps d'échantillonnage (SENS_INIT_DELAY_S et SAMPLING_TIME_S), fixés par défaut à 15 et 60 secondes, comme le montre également le Listing 3 (nous suggérons toutefois de ne pas modifier ces paramètres).

-------------------------------
// - USER TH DEFAULT VALUES
-------------------------------
co2eq_th = 450
hysteresis = 10
-------------------------------
// - TIMING CONST
// -------------------------------
SAMPLING_TIME_S = 60
SENS_INIT_DELAY_S = 15


Conclusion…

Dans cet article, nous avons décrit en détail la mise en œuvre d'un dispositif de surveillance de la qualité de l'air. En relevant un capteur de qualité de l'air (SGP30), il peut afficher les concentrations de CO2 et de COVT sur un écran. De plus, en lisant un fichier utilisateur contenant le seuil d'alarme pour la concentration de CO2, il peut signaler visuellement via une led la nécessité d'aérer la pièce. Compte tenu de la richesse des périphériques additionnels de la plateforme utilisée, il est possible d'étendre ce dispositif avec des fonctionnalités IdO, telles qu'une page web permettant la consultation des données à distance et des alertes par e-mail ou une notification par la plateforme Telegram.    


Liste de composants

Modules

  • 1 × Heltec WiFi Kit 32
  • 1 × Sensirion SGP30

LED

  • 1 × Rouge, 5 mm, Haute Éfficacité
  • 1 × Rouge, 5 mm, Haute Éfficacité

Resistances

  • 2 × 220 Ω, 0.25 W, 5%

Note de l'éditeur : Ce projet a été publié à l'origine dans Elettronica IN
 



Traduction : Laurent RAUBER