Mesurez la qualité de l’air intérieur avec un Raspberry Pi Pico

5
(3)

Vous souhaitez mesurer la qualité de l’air à l’intérieur de votre maison et découvrir le Raspberry Pi Pico ? Ce tuto est fait pour vous ! Pour mesurer la qualité de l’air nous allons utiliser le capteur SGP30. Ce capteur mesure la concentration en H2 et en Ethanol. La concentration en Ethanol permet de mesurer le niveau de composés organiques volatils totaux (COVT). Le niveau de H2 est utilisé comme indicateur indirect et permet de deduire le taux de CO2 équivalent dit eCO2. Si le eCO2 ne peut pas servir de mesure de CO2 pour un laboratoire, il est largement suffisant pour mesurer la qualité de l’air de votre intérieur.

J’ai choisi d’utiliser le Starter Kit Pi Pico ainsi l’écran LCD pico display car je trouve que c’est une solution idéale pour prototyper les projets à base du Raspberry Pi Pico.

Le Raspberry Pi Pico

Le Raspberry Pi Pico est un micro-contrôleur conçu par la fondation Raspberry.Il intègre une puce RP040. Ce micro-contrôleur est particulièrement intéressant car il est à la frontière entre le monde de l’Arduino et celui du Raspberry Pi. Il possède un excellent rapport performance coût et est très simple à utiliser. Le Raspberry Pi Pico peut être programmé en langage Python ou en C/C++.

Dans ce tuto je vais utiliser le Python et l’IDE Thonny, mais sachez qu’il est possible d’utiliser l’IDE PlatformIO. PlatformIO est conçu pour les développements embarqués et les IoT. Une découverte intéressante pour les makers !

Avant de commencer…

Avant de commencer notre tuto, nous allons voir comment exécuter un programme en Python dans le Raspberry Pi Pico.

Il faut tout d’abord installer Thonny, un environnement de développement Python pour débutants. Par exemple sur Linux Mint (base Debian) il suffit de taper la commande suivante dans le terminal pour l’installer :

sudo apt install thonny

Il faut ensuite installer MicroPython sur le Raspberry Pi Pico :

  • Par défaut le Raspberry Pi Pico est vu comme un stockage de masse USB (i.e. comme une clé USB) par l’ordinateur. Il contient les deux fichiers « INDEX.HTM » et « INFO_UF2.TXT ». Si ce n’est pas le cas, débrancher le câble USB du Pico, appuyer sur le bouton BOOTSEL et rebrancher le câble USB du Pico.
  • Téléchargez le firmware MicroPython (fichier format uf2) pour Raspberry Pi Pico depuis la page téléchargement du site. Le format UF2 format est prévu pour flasher un microcontrôleur connecté comme un stockage de masse USB sur votre PC
  • Il suffit ensuite de copier ce fichier sur le stockage de masse « RPI-RP2 » pour flasher MicroPython sur le Raspberry Pi Pico.
  • Le stockage de masse disparaît, comme si il était éjecté de l’ordinateur. C’est normal, le Raspberry Pi Pico est maintenant vu comme un port série sur votre ordinateur. Cela lui permettra de communiquer avec l’environnement de développement Thonny.

Il est maintenant possible de connecter le Raspberry Pi Pico à l’IDE Thonny. Pour cela aller dans le menu « Run->Select Interpreter… » de Thonny et sélectionner le port qui vient d’être activé lors de l’installation du firmware MicroPython sur le Pico.

Nous allons maintenant pouvoir écrire notre premier programme Python.

Voici un petit programme qui fait clignoter la LED du Rspberry Pi Pico par exemple :

import machine
import utime

led_onboard = machine.Pin(25, machine.Pin.OUT)

while True:
    led_onboard.value(1)
    utime.sleep(1)
    led_onboard.value(0)
    utime.sleep(1)

Il faut ensuite sauvegarder ce programme sous le nom « main.py » sur le Pico en cliquant sur « File->Save as… » puis sur « MicroPython device » :

Note : si l’erreur « Device not connected » apparaît, il suffit de faire « Run->Stop/Restart backend ».

Le matériel

Pour réaliser ce tuto, j’utilise le matériel suivant :

Le capteur SGP30

Important! Le capteur est recouvert d’une membrane en PTFE (il ressemble à un film blanc légèrement translucide). Ne l’enlevez pas ! Il s’agit d’une membrane perméable aux gaz qui est nécessaire pour que le capteur fonctionne comme prévu.

Firmware MicroPython fourni par Pimoroni

Pimoroni met à disposition sur son GitHub le firmware MicroPython incluant toutes les librairies nécessaires pour ses produits. Il suffit donc de télécharger le dernier firmware MicroPython depuis l’espace Release du GitHub et de le copier sur le Raspberry Pi Pico.

Utilisez la procédure déjà utilisée plus haut :

  • Débrancher le câble USB du Raspberry Pi Pico
  • Appuyer le bouton BOOTSEL
  • Brancher le câble USB du Raspberry Pi Pico
  • Lâcher le bouton BOOTSEL
  • Coller le firmware MicroPython Pimoroni (fichier au format UF2 sur le stockage de masse USB « RPI-RP2 »

Récupération des données du capteur SGP30

Le capteur SGP30 communique avec le Raspberry Pi Pico via le bus I2C. Il convient donc de relier les broches SDA et SCL du capteurs aux broches correspondantes sur le Raspberry Pi Pico.

Le Raspberry Pi Pico permet de configurer plusieurs interfaces I2C, nous choisissons d’utiliser la première (I2C0). La broche GP21 (27) correspond au SCL et la broche GP20 (26) au SDA.

Broches du Raspberry Pi Pico
Câblage du capteur SGP30 sur le Raspberry Pi Pico
Connexion du module capteur SGP30 au « DECK 2 » de la carte d’extension du Kit Pi Pico

Le code Python disponible sur le GitHub de Pimoroni permet d’afficher sur le Shell de Thonny les valeurs remontées par le capteur :

import time
from pimoroni_i2c import PimoroniI2C
from breakout_sgp30 import BreakoutSGP30

PINS_PICO_EXPLORER = {"sda": 20, "scl": 21}

i2c = PimoroniI2C(**PINS_PICO_EXPLORER)
sgp30 = BreakoutSGP30(i2c)

print("SGP30 initialised - about to start measuring without waiting")

sgp30.start_measurement(False)
id = sgp30.get_unique_id()
print("Started measuring for id 0x", '{:04x}'.format(id[0]), '{:04x}'.format(id[1]), '{:04x}'.format(id[2]), sep="")

j = 0
while True:
    j += 1
    air_quality = sgp30.get_air_quality()
    eCO2 = air_quality[BreakoutSGP30.ECO2]
    TVOC = air_quality[BreakoutSGP30.TVOC]

    air_quality_raw = sgp30.get_air_quality_raw()
    H2 = air_quality_raw[BreakoutSGP30.H2]
    ETHANOL = air_quality_raw[BreakoutSGP30.ETHANOL]

    print(j, ": CO2 ", eCO2, " TVOC ", TVOC, ", raw ", H2, " ", ETHANOL, sep="")
    if j == 30:
        print("Resetting device")
        sgp30.soft_reset()
        time.sleep(0.5)
        print("Restarting measurement, waiting 15 secs before returning")
        sgp30.start_measurement(True)
        print("Measurement restarted, now read every second")

    time.sleep(1.0)
Code exemple fourni par Pimoroni pour lire les données du capteur SGP30

Affichage sur le pico display

Le pico display est prévu pour être installé directement au dos du Raspberry Pi Pico. Mais dans notre tuto nous allons l’installer sur le « DECK 1 » de la carte d’extension.

Le pico display est inséré dans le DECK1 de la carte d’extension du Kit Pi Pico

L’exemple suivi est fourni par Pimoroni. Il permet d’afficher le nom du bouton qui est appuyé sur le pico display.

# This example shows you a simple, non-interrupt way of reading Pico Display's buttons with a loop that checks to see if buttons are pressed.

import picodisplay as display  # Comment this line out to use PicoDisplay2
import utime

# Initialise display with a bytearray display buffer
buf = bytearray(display.get_width() * display.get_height() * 2)
display.init(buf)
display.set_backlight(0.5)


# sets up a handy function we can call to clear the screen
def clear():
    display.set_pen(0, 0, 0)
    display.clear()
    display.update()


while True:
    if display.is_pressed(display.BUTTON_A):              # if a button press is detected then...
        clear()                                           # clear to black
        display.set_pen(255, 255, 255)                    # change the pen colour
        display.text("Button A pressed", 10, 10, 240, 4)  # display some text on the screen
        display.update()                                  # update the display
        utime.sleep(1)                                    # pause for a sec
        clear()                                           # clear to black again
    elif display.is_pressed(display.BUTTON_B):
        clear()
        display.set_pen(0, 255, 255)
        display.text("Button B pressed", 10, 10, 240, 4)
        display.update()
        utime.sleep(1)
        clear()
    elif display.is_pressed(display.BUTTON_X):
        clear()
        display.set_pen(255, 0, 255)
        display.text("Button X pressed", 10, 10, 240, 4)
        display.update()
        utime.sleep(1)
        clear()
    elif display.is_pressed(display.BUTTON_Y):
        clear()
        display.set_pen(255, 255, 0)
        display.text("Button Y pressed", 10, 10, 240, 4)
        display.update()
        utime.sleep(1)
        clear()
    else:
        display.set_pen(255, 0, 0)
        display.text("Press any button!", 10, 10, 240, 4)
        display.update()
    utime.sleep(0.1)  # this number is how frequently the Pico checks for button presses

Taux de CO2 et qualité de l’air

Plusieurs normes définissent la qualité de l’air en fonction de la concentration de CO2. Il est difficile de trouver des sources cohérentes et l’accès aux normes est payant (!).

La couleur de la LED du pico display va dépendre du niveau de CO2. Dans mon programme, j’ai décidé d’utiliser les valeurs suivantes pour la correspondance entre le taux de CO2 et la couleur de la LED :

  • 0..499 ppm -> La qualité de l’air est bonne, la LED sera de couleur verte
  • 500..999 ppm -> La qualité de l’air est moyenne, la LED sera de couleur Orange
  • >= 1000 ppm -> La qualité de l’air est mauvaise, la LED sera de couleur Rouge

Notre programme combinant la mesure par le capteur et son affichage sur l’ecran

Notre programme va lire dans le capteur le taux de CO2 de l’air et l’afficher sur l’écran LCD du pico display. En fonction du taux la couleur de l’affichage et la LED du pico display sera verte, orange ou rouge.

# Tutoduino.fr
# Mesurez la qualite de l'air interieur avec un Raspberry Pi Pico

import picodisplay as display
import utime
from pimoroni_i2c import PimoroniI2C
from breakout_sgp30 import BreakoutSGP30

# Fonction qui retourne le niveau de CO2 et TVOC
def mesure_capteur():
    air_quality = sgp30.get_air_quality()
    eCO2 = air_quality[BreakoutSGP30.ECO2]
    TVOC = air_quality[BreakoutSGP30.TVOC]
    return eCO2, TVOC

# Fonction qui efface l'ecran
def clear():
    display.set_pen(0, 0, 0)
    display.clear()
    display.update()
    
# Gere la couleur en fonction du niveau de CO2
def get_color(CO2):
    if eCO2 < 500:
        return 0,0xff,0 #vert
    elif eCO2 < 1000:
        return 0xff,165,0 #orange
    else:
        return 0xff,0,0 #rouge
            
# Initilisation de l'ecran
buf = bytearray(display.get_width() * display.get_height() * 2)
display.init(buf)
display.set_backlight(0.5)

# Initialisation du capteur
PINS_PICO_EXPLORER = {"sda": 20, "scl": 21}
i2c = PimoroniI2C(**PINS_PICO_EXPLORER)
sgp30 = BreakoutSGP30(i2c)
sgp30.soft_reset()
utime.sleep(1)    
sgp30.start_measurement(False)


# Boucle du programme principal
while True:
    # Lecture de la qualite de l'air sur le capteur    
    eCO2, TVOC = mesure_capteur()       
    print("CO2 ", eCO2, " TVOC ", TVOC)
    r,g,b = get_color(eCO2)
    # Affichage sur l'ecran
    display.set_pen(0xff,0xff,0xff)      
    display.text("Taux CO2", 30, 10, 240, 4)
    display.set_pen(r,g,b)      
    display.text("{}".format(eCO2) + " ppm", 40, 70, 240, 4)
    display.set_led(r,g,b)
    display.update()
    utime.sleep(1)                                    
    clear()
Taux de CO2 de 400ppm indiquant une bonne qualité d’air intérieur

Votre avis compte !

Note moyenne : 5 / 5. Nombre de votes : 3

Pas encore de vote pour ce tutoriel

Désolé si cet article ne vous a pas intéressé

Merci de commenter afin que je puisse l’améliorer.

Dites-moi comment améliorer cette page.