J’avais déjà présenté un premier article sur les extensions Pimoroni pour Raspberry Pi PICO. Cette fois je me suis penché sur la carte Pico Explorer que proposent les pirates de Pimoroni. On y trouve un écran, 4 boutons poussoirs, un buzzer, une breadboard, 2 connecteurs multifonctions avec des entrées ADC, des E/S GPIO et des sorties de commande moteurs. On n’oubliera pas le support pour le Raspberry Pi PICO ainsi que deux connecteurs destinés à recevoir les cartes « breakout » de Pimoroni.

La carte Pico Explorer de Pimoroni

[stextbox id=’warning’ caption=’Installer Micropython’]Cet article fait suite au précédent que j’avais consacré à Pico et Pimoroni. Pour l’installation du MicroPython de Pimoroni, des bibliothèques etc. référez vous à cet article précédent.[/stextbox]

Présentation

La carte Pico Explorer est un moyens simple et abordable (21€) pour apprendre à utiliser le Raspberry Pi Pico. Elle embarque :

Haut-parleur piézoélectrique
Écran LCD IPS 1,54″ (240 x 240)
Quatre boutons poussoirs
Deux pilotes de moteur en demi-pont (avec LED d’indication de surintensité)
Accès facile aux broches GPIO et ADC
Deux prises I2C Breakout Garden
Mini breadboard pour les prototypes
Pieds en caoutchouc
Compatible avec le Raspberry Pi Pico.
Aucune soudure n’est nécessaire (à condition que votre Pico soit équipé de broches)
Dimensions : environ 117mm x 63mm x 20mm (L x l x H)

Schéma

Cliquez pour agrandir

Son schéma est fourni et téléchargeable. Vous pourrez en savoir plus en cliquant sur l’image ci-dessus.

Brochage

Pimoroni indique sur ce schéma les broches du Raspberry Pi PICO utilisées sur la carte et comment elles sont appelées sur la sérigraphie. Dans notre cas c’est le bus I2C qui va être utilisé. Il est relié aux ports Breakout. ce sont les broches

27 => SCL => GPIO21
26 => SDA => GPIO20

Ces informations seront utiles pour paramétrer l’accès au bus I2C.

Cahier des charges du projet

Le cahier des charges que je me suis donné est le suivant :

Communication et programmation du Raspberry Pi PICO depuis un Raspberry Pi 4 exécutant l’IDE Thonny.
Utiliser les deux ports breakout en y connectant une carte BME680 (breakout 1) et une carte RV3028 (breakout 2).
Les données acquises sur le BME680 (température, humidité, pression, résistance VOC) seront affichées sur l’écran LCD de la carte et sur la console connectée en série sur le PICO via USB.
La carte RTC RV3028 est utilisée comme « garde heure ». Lorsque le PICO est déconnecté de son alimentation, le RV3028 passe en alimentation sur la pile bouton embarquée sur la carte. A la remise en route du Pico, l’heure et la date si c’est souhaité, sont récupérées depuis le circuit RTC.

Matériel utilisé

Raspberry Pi 4 2Go – Raspberry Pi OS – Thonny IDE
Raspberry Pi PICO
Carte Pico Explorer Base de Pimoroni
Carte breakout BME680
Carte breakout RV3028
Alimentation 5V/3A

Vous pourrez télécharger tous les programmes et les bibliothèques utilisés dans cet article.

La carte breakout BME680

La carte fait partie d’une (grande) famille de produits proposés par Pimoroni, les Breakout qui se comptent par dizaines et embarquent chacune un composant plus ou moins évolué.

Les modèles qui nous intéressent possèdent 5 pastilles, se connectent sur le bus I2C (SDA et SCL) et sont compatibles avec les connecteurs Breakout Garden de la carte Pico Explorer.

Le BME680

C’est un composant récent qui est au catalogue de Bosh-Sensortec. Il intègre des capteurs de gaz, de pression, d’humidité et de température de haute linéarité et de haute précision. Il est spécialement développé pour les applications mobiles et les wearables (montres, vêtements…) où la taille et la faible consommation d’énergie sont des exigences critiques. Il permet par exemple de mesurer une altitude avec une précision de l’ordre du mètre. Afin de mesurer la qualité de l’air le capteur de gaz du BME680 peut détecter une large gamme de gaz tels que les composés organiques volatils (COV). Il possède des interfaces I2C et SPI.

On voit sur cette photo la taille du boîtier sur la carte Pimoroni, grâce à la règle posée devant. Vous pouvez télécharger la documentation du BME680 en cliquant sur ce lien.

La carte Pimoroni BME680

Pimoroni fournit cette carte avec des picots à souder si vous voulez la monter en la soudant. Par défaut la carte est à l’adresse 0x76 sur le bus I2C mais vous pouvez la passer en adresse 0x77 en faisant un pont de soudure au dos de la carte (ADDR+1)

La carte est compatible 3,3 et 5 volts. On voit l’ouverture dans le boîtier qui met le composant en contact avec l’air extérieur pour lui permettre d’effectuer ses mesures. La mesure des composés volatils (VOC) se fait avec une résistance constituée d’un oxyde métallique qui est chauffé. Lorsque la résistance est dans un milieu « normal » l’air contient surtout de l’oxygène. Il y a peu de réactions à la surface de la résistance et sa valeur reste élevée. En présence de VOCs (solvants, colles de meubles en aggloméré, vapeurs de peintures…) des réactions chimiques REDOX (oxydo-réduction) ont lieu à la surface de la résistance. Ces réactions produisent du gaz carbonique (CO2) et de l’eau (H20), ce qui diminue la valeur de la résistance. Cette diminution est fonction de la température ambiante et de l’humidité, ce qui rend la détermination d’un pourcentage de qualité de l’air assez complexe. Ce ne sera pas évoqué ici, nous afficherons les mesures brutes.

Vérifier la présence de la carte

Pour vérifier la présence de la carte, il faut s’assurer qu’on a un composant présent à l’adresse 0x76 (en hexadécimal) ou 118 en décimal.

Programme scan_i2c.py

# Importer les bibliothèques utilisées
import machine

# Créer le périphérique I2C
sda=machine.Pin(20)
scl=machine.Pin(21)
i2c=machine.I2C(0,sda=sda, scl=scl, freq=400000)

# Scanner le bus I2C
print('Scan du bus i2c...')
devices = i2c.scan()

if len(devices) == 0:
    print("Aucun composant détecté !")
else:
    print('Composant(s) détectés :',len(devices))

for device in devices:
    print("Adresse en décimal : ",device," | Adresse en Hexadécimal : ",hex(device))

# Importer les bibliothèques utilisées

import machine

# Créer le périphérique I2C

sda=machine.Pin(20)

scl=machine.Pin(21)

i2c=machine.I2C(0,sda=sda, scl=scl, freq=400000)

# Scanner le bus I2C

print('Scan du bus i2c...')

devices = i2c.scan()

if len(devices) == 0:

print("Aucun composant détecté !")

else:

print('Composant(s) détectés :',len(devices))

for device in devices:

print("Adresse en décimal : ",device," | Adresse en Hexadécimal : ",hex(device))

Et vous devez obtenir ceci si des cartes sont détectées :

Ici les deux cartes étant connectées on a deux composants détectés. La carte BME680 à l’adresse Ox76 est bien détectée. Si la carte n’est pas détectée, n’allez pas plus loin… Il faut que la carte soit vue sur le bus I2C pour que les programmes fonctionnent 😉

Programme de lecture des données

La lecture des données utilise la bibliothèque bme680.py dont vous trouvez les sources fournis par Adafruit en suivant ce lien. Commencez par copier la bibliothèque sur le Pico, soit avec rshell soit en l’ouvrant dans Thonny avant de la sauvegarder sur le Pico.

[stextbox id=’info’ caption=’Un peu de patience…’]La résistance met un certain temps à chauffer, attendre quelques minutes avant que la valeur ne se stabilise.[/stextbox]

Le programme lit_bme680.py lit les données du BME680 et les affiche sur la console dans Thonny :

from machine import Pin, I2C
from time import sleep
from bme680 import *

sda=machine.Pin(20)
scl=machine.Pin(21)
i2c=machine.I2C(0,sda=sda, scl=scl, freq=400000)

bme = BME680_I2C(i2c=i2c)

while True:
  try:
    temp = str(round(bme.temperature, 2)) + ' C'    
    hum = str(round(bme.humidity, 2)) + ' %'    
    pres = str(round(bme.pressure, 2)) + ' hPa'    
    gas = str(round(bme.gas/1000, 2)) + ' KOhms'

    print('Température :', temp)
    print('Humidité :', hum)
    print('Pression :', pres)
    print('Gaz :', gas)
    print('-------')
  except OSError as e:
    print('Erreur de lecture.')
 
  sleep(5)

from machine import Pin, I2C

from time import sleep

from bme680 import *

sda=machine.Pin(20)

scl=machine.Pin(21)

i2c=machine.I2C(0,sda=sda, scl=scl, freq=400000)

bme = BME680_I2C(i2c=i2c)

while True:

try:

temp = str(round(bme.temperature, 2)) + ' C'

hum = str(round(bme.humidity, 2)) + ' %'

pres = str(round(bme.pressure, 2)) + ' hPa'

gas = str(round(bme.gas/1000, 2)) + ' KOhms'

print('Température :', temp)

print('Humidité :', hum)

print('Pression :', pres)

print('Gaz :', gas)

print('-------')

except OSError as e:

print('Erreur de lecture.')

sleep(5)

La carte breakout RV3028

Comme la précédente, cette carte fait partie d’une (grande) famille de produits proposés par Pimoroni, les Breakout qui se comptent par dizaines et embarquent chacune un composant plus ou moins évolué. Ce modèle possède 5 pastilles et se connecte sur le bus I2C (SDA et SCL) et est compatible avec les connecteurs Breakout Garden de la carte Pico Explorer.

Le RV3028

Le RV-3028 est un circuit d’horloge temps réel (RTC = Real Time Clock) qui intègre un circuit CMOS et un quartz 32,768 KHz. Cette fréquence correspond exactement 2¹⁵ périodes par seconde, c’est une fréquence facile à utiliser avec des circuits binaires. Ce genre de quartz est également appelé quartz horloger. On le retrouve dans les montres et dans de nombreuses horloges RTC embarquées.

Le RV3028 fonctionne sous vide dans un boîtier céramique hermétiquement scellé avec un couvercle métallique. Ses applications sont nombreuses : IoT, comptage, industrie, automobile, santé, portables, vêtements … Il ne consomme que 45 nA sous 3 Volts et fonctionne entre 1,1 V et 5,5 V. Chaque circuit est calibré en usine avec une précision de ±1 ppm @ 25°C, ce qui assure une heure exacte à ±3s près par mois.

Synoptique du RV3028

Un mot de passe programmable par l’utilisateur assure la protection en écriture de la date et de l’heure, ainsi que de la configuration. Le circuit comporte une EEPROM pour enregistrer la configuration. Il peut générer une alarme et sortir des fréquences de : 32,768 kHz, 8192 Hz, 1024 Hz, 64 Hz, 32 Hz, 1 Hz. Il embarque une mémoire utilisateur non-volatile de 43 octets et une RAM utilisateur de 2 octets. La fréquence maxi sur le bus I2C est de 400 kHz.

Vous pouvez télécharger la notice du RV3028 en cliquant sur ce lien.

La carte Pimoroni RV3028

Si on y regarde de plus près on voit sur la carte ce minuscule composant qu’est le RV3028. En haut de la carte un support de pile accueille une pile à l’oxyde d’argent , de type 337, qui a une capacité de 8mAh et devrait alimenter le RV3028 plus de 10 ans…

La carte comporte 5 pastilles compatibles avec Breakout Garden de Pimoroni. Elle est accessible sur le bus I2C à l’adresse décimale 82, ou 0x52 en hexadécimal.

Vérifier la présence de la carte

Le programme scan_i2c.py vu un peu plus haut permet de vérifier si la carte est bien détectée.

Programme de Mise à l’heure

Commencez par installer la bibliothèque rv3028 : rv3028_rtc.py. Vous en avez une copie dans le package de programmes mais référez vous de préférences à la source sur github par x10dit.

Pour utiliser la carte RV3028, il faut d’abord la mettre à l’heure, mais aussi valider le switch qui permet d’alimenter le circuit par la batterie de sauvegarde en cas de coupure de l’alimentation.

C’est ce que fait le programme set_date_time.py ci dessous. Il est disponible dans le package de programmes que vous pouvez télécharger.

from machine import Pin, I2C
from time import sleep
import rv3028_rtc

sda=machine.Pin(20)
scl=machine.Pin(21)
i2c=machine.I2C(0,sda=sda, scl=scl, freq=400000)
rtc=rv3028_rtc.RV3028(0x52, i2c, "LSM")

date_heure = (2021,04,24,16,43,30,"sam")

rtc.set_rtc_date_time(date_heure)

from machine import Pin, I2C

from time import sleep

import rv3028_rtc

sda=machine.Pin(20)

scl=machine.Pin(21)

i2c=machine.I2C(0,sda=sda, scl=scl, freq=400000)

rtc=rv3028_rtc.RV3028(0x52, i2c, "LSM")

date_heure = (2021,04,24,16,43,30,"sam")

rtc.set_rtc_date_time(date_heure)

Ce programme accède au RV3028 en i2c et positionne LSM pour activer l’utilisation de la batterie de sauvegarde de l’heure.
Ici j’ai passé la date et l’heure « en dur » dans le programme, mais vous pouvez vous amuser à gérer la saisie et la vérification de chacune des valeurs depuis le clavier. Je n’ai pas jugé nécessaire de le faire dans la mesure où ce programme sert très rarement, normalement une seule fois pour initialiser le RV3028.

Dans l’ordre on trouve :
date_heure = (2021,04,24,16,43,30, »sam »)

L’année sur 4 chiffres => 2021
Le mois sur 4 chiffres => 04
La date sur 4 chiffres => 24
L’heure sur 2 chiffres => 16
Les minutes sur 2 chiffres => 43
Les secondes sur 3 chiffres => 30
Les 3 premières lettres du nom du jour entre guillemets => « sam »

Programme de lecture de l’heure

Pour vérifier le bon fonctionnement du RV3028, exécutez d’abord le programme de mise à l’heure ci-dessus. ensuite lancez le programme test_rv3028.py qui va relire les informations de l’horloge RTC :

from machine import Pin, I2C
from time import sleep
import rv3028_rtc
sda=machine.Pin(20)
scl=machine.Pin(21)
i2c=machine.I2C(0,sda=sda, scl=scl, freq=400000)
rtc=rv3028_rtc.RV3028(0x52, i2c, "LSM")

heure = rtc.get_hours()
minute = rtc.get_minutes()
seconde = rtc.get_seconds()

joursemaine = rtc.get_weekday(day_type="long")
nommois = rtc.get_month(month_type="short")
datedujour = rtc.get_date(date_type="ordinal")
an = rtc.get_year()

heure = " {:0&gt;2}:{:0&gt;2}:{:0&gt;2}" .format (str(heure), str(minute), str(seconde))
print (heure)
print(joursemaine, datedujour, nommois, an)

from machine import Pin, I2C

from time import sleep

import rv3028_rtc

sda=machine.Pin(20)

scl=machine.Pin(21)

i2c=machine.I2C(0,sda=sda, scl=scl, freq=400000)

rtc=rv3028_rtc.RV3028(0x52, i2c, "LSM")

heure = rtc.get_hours()

minute = rtc.get_minutes()

seconde = rtc.get_seconds()

joursemaine = rtc.get_weekday(day_type="long")

nommois = rtc.get_month(month_type="short")

datedujour = rtc.get_date(date_type="ordinal")

an = rtc.get_year()

heure = " {:0>2}:{:0>2}:{:0>2}" .format (str(heure), str(minute), str(seconde))

print (heure)

print(joursemaine, datedujour, nommois, an)

Vous devez obtenir en réponse sur la console la date et l’heure du jour. Ne vous étonnez pas si les valeurs sont très différentes ici entre le programme de mise à l’heure et la relecture. Les programmes n’ont pas été exécutés le même jour 😉 :

Bien entendu le choix de la présentation vous appartient et si vous regardez la bibliothèque utilisée vous verrez les nombreuses autres possibilités offertes…

Afficher les données sur l’écran de Pico Explorer

Pour afficher les données sur l’écran de Pico Explorer, il faut au préalable charger le MicroPython de Pimoroni sur le Raspberry Pi Pico car il contient les bibliothèques du matériel Pimoroni. Si vous ne savez pas comment faire, c’est expliqué dans cet article.
Pour tester si l’écran fonctionne il y a plusieurs programmes dont le classique balls_demo.py que vous pouvez télécharger en cliquant sur ce lien mais qui est aussi dans le package de programmes disponibles avec cet article. Si vous l’exécutez vous devez obtenir ceci :

Maintenant qu’on sait que l’écran fonctionne on va pouvoir envoyer des caractères dessus. Vous trouverez un tuto complet sur ce sujet [en Anglais] en suivant ce lien.

Le principe d’un programme gérant l’écran 240x240px, est de créer un buffer (tampon mémoire) dans la mémoire du Raspberry Pi Pico. Ce tampon mesure 240x240x2 octets pour contenir chaque pixel avec une définition de couleurs sur 16 bits. Lorsque le buffer est rempli, une commande permet de transférer les 115200 octets vers l’écran et de rafraichir l’affichage.

Le programme final_680_3028.py termine cet article et fait la synthèse de tout ce qui a été vu auparavant. Il est diaponible dans le pakage de programmes à télécharger.

from machine import Pin, I2C
from time import sleep
from bme680 import *
import picoexplorer as display
import rv3028_rtc
import utime

sda=machine.Pin(20)
scl=machine.Pin(21)
i2c=machine.I2C(0,sda=sda, scl=scl, freq=400000)
rtc=rv3028_rtc.RV3028(0x52, i2c, "LSM")

bme = BME680_I2C(i2c=i2c)

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

# 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:
  try:
    temp = str(round(bme.temperature, 2)) + ' C'
    
    hum = str(round(bme.humidity, 2)) + ' %'
    
    pres = str(round(bme.pressure, 2)) + ' hPa'
    
    gas = str(round(bme.gas/1000, 2)) + ' KOhms'
    
# Affichage de l'heure
    
    heure = rtc.get_hours()
    minute = rtc.get_minutes()
    seconde = rtc.get_seconds()
    
    joursemaine = rtc.get_weekday(day_type="long")
    nommois = rtc.get_month(month_type="short")
    datedujour = rtc.get_date(date_type="ordinal")
    an = rtc.get_year()
    
    heure = "      {:0&gt;2}:{:0&gt;2}:{:0&gt;2}" .format (str(heure), str(minute), str(seconde))
    date = '%s %s %s %s' % (joursemaine, datedujour, nommois, an)

    print (heure)
    print(joursemaine, datedujour, nommois, an)
    print('Température :', temp)
    print('Humidité :', hum)
    print('Pression :', pres)
    print('Gaz :', gas)
    print('-------')
   
    display.set_pen(255, 255, 255)                    # change the pen colour
    display.text(heure, 10, 5, 240, 2)  # display some text on the screen
    
    display.set_pen(255, 255, 255)                    # change the pen colour
    display.text(date, 10, 20, 240, 2)  # display some text on the screen
    

    display.set_pen(255, 255, 255)                    # change the pen colour
    display.text("Temperature :", 10, 40, 240, 3)  # display some text on the screen
    display.set_pen(255, 255, 255)                    # change the pen colour
    display.text(temp, 10, 60, 240, 3)  # display some text on the screen

    display.set_pen(255, 0, 0)                    # change the pen colour
    display.text("Humidite :", 10, 90, 240, 3)  # display some text on the screen
    display.set_pen(255, 0, 0)                    # change the pen colour
    display.text(hum, 10, 110, 240, 3)  # display some text on the screen

    display.set_pen(0, 0, 255)                    # change the pen colour
    display.text("Pression :", 10, 150, 240, 3)  # display some text on the screen
    display.set_pen(0, 0, 255)                    # change the pen colour
    display.text(pres, 10, 170, 240, 3)  # display some text on the screen

    display.set_pen(0, 255, 0)                    # change the pen colour
    display.text("Gaz :", 10, 200, 240, 3)  # display some text on the screen
    display.set_pen(0, 255, 0)                    # change the pen colour
    display.text(gas, 10, 220, 240, 3)  # display some text on the screen
    display.update()                                  # update the display

    

  except OSError as e:
    print('Erreur de lecture.')
   
  sleep(5)
  clear()

from machine import Pin, I2C

from time import sleep

from bme680 import *

import picoexplorer as display

import rv3028_rtc

import utime

sda=machine.Pin(20)

scl=machine.Pin(21)

i2c=machine.I2C(0,sda=sda, scl=scl, freq=400000)

rtc=rv3028_rtc.RV3028(0x52, i2c, "LSM")

bme = BME680_I2C(i2c=i2c)

# Initialise display with a bytearray display buffer

buf = bytearray(display.get_width() * display.get_height() * 2)

display.init(buf)

# 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:

try:

temp = str(round(bme.temperature, 2)) + ' C'

hum = str(round(bme.humidity, 2)) + ' %'

pres = str(round(bme.pressure, 2)) + ' hPa'

gas = str(round(bme.gas/1000, 2)) + ' KOhms'

# Affichage de l'heure

heure = rtc.get_hours()

minute = rtc.get_minutes()

seconde = rtc.get_seconds()

joursemaine = rtc.get_weekday(day_type="long")

nommois = rtc.get_month(month_type="short")

datedujour = rtc.get_date(date_type="ordinal")

an = rtc.get_year()

heure = " {:0>2}:{:0>2}:{:0>2}" .format (str(heure), str(minute), str(seconde))

date = '%s %s %s %s' % (joursemaine, datedujour, nommois, an)

print (heure)

print(joursemaine, datedujour, nommois, an)

print('Température :', temp)

print('Humidité :', hum)

print('Pression :', pres)

print('Gaz :', gas)

print('-------')

display.set_pen(255, 255, 255) # change the pen colour

display.text(heure, 10, 5, 240, 2) # display some text on the screen

display.set_pen(255, 255, 255) # change the pen colour

display.text(date, 10, 20, 240, 2) # display some text on the screen

display.set_pen(255, 255, 255) # change the pen colour

display.text("Temperature :", 10, 40, 240, 3) # display some text on the screen

display.set_pen(255, 255, 255) # change the pen colour

display.text(temp, 10, 60, 240, 3) # display some text on the screen

display.set_pen(255, 0, 0) # change the pen colour

display.text("Humidite :", 10, 90, 240, 3) # display some text on the screen

display.set_pen(255, 0, 0) # change the pen colour

display.text(hum, 10, 110, 240, 3) # display some text on the screen

display.set_pen(0, 0, 255) # change the pen colour

display.text("Pression :", 10, 150, 240, 3) # display some text on the screen

display.set_pen(0, 0, 255) # change the pen colour

display.text(pres, 10, 170, 240, 3) # display some text on the screen

display.set_pen(0, 255, 0) # change the pen colour

display.text("Gaz :", 10, 200, 240, 3) # display some text on the screen

display.set_pen(0, 255, 0) # change the pen colour

display.text(gas, 10, 220, 240, 3) # display some text on the screen

display.update() # update the display

except OSError as e:

print('Erreur de lecture.')

sleep(5)

clear()

Quand vous exécutez ce programme vous devez obtenir quelque chose comme ceci :

Conclusion

Les bibliothèque des cartes Breakout Garden sont encore en cours de développement pour Pico. On voit que malgré cela il est déjà possible de faire fonctionner certaines d’entre elles. avec cet exemple vous saurez lire les données d’un BME680 et d’un RV3028 et les utiliser pour un affichage LCD. La carte Pico Explorer est un bon moyen pour développer des prototypes (il y a une breadbord, un driver pour 2 moteurs, des E/S numériques et analogiques… Bref de quoi s’amuser.

L’étape suivante (pour moi) sera de travailler avec des images, des jauges… Dessinées avec la bibliothèque ou importées comme images. Des développements sont également en cours pour importer d’autres polices de caractères car il faut avouer que celle-ci n’est pas vraiment terrible.

Télécharger les programmes de l’article

Cliquez sur ce lien pour télécharger les programmes et les bibliothèques en Python.

Sources

Carte Pico Explorer Base : https://shop.pimoroni.com/products/pico-explorer-base
Carte RV3028 : https://shop.pimoroni.com/products/rv3028-real-time-clock-rtc-breakout
MicroPython de Pimoroni : https://github.com/pimoroni/pimoroni-pico/releases
Bibliothèques C et Python : https://github.com/pimoroni/pimoroni-pico
Bibliothèque Pico Explorer : https://github.com/pimoroni/pimoroni-pico/tree/main/micropython/modules/pico_explorer
Bibliothèque Pico Explorer : https://github.com/pimoroni/pimoroni-pico/tree/main/micropython/modules/pico_explorer
Bibliothèque RV3028 : https://github.com/x10dit/rv3028_rtc
Schéma de la carte : https://www.framboise314.fr/wp-content/uploads/2021/04/pico_explorer_schematic.pdf
Datasheet BME680 : https://www.framboise314.fr/wp-content/uploads/2021/04/bst-bme680-ds001.pdf
Datasheet RV3028 : https://www.framboise314.fr/wp-content/uploads/2021/04/RV-3028-C7-1524919.pdf

Une réflexion au sujet de « Utilisation des BME680 et RV3028 avec Raspberry Pi Pico »

Ping : Utilisation des matrices de LED LTP305 avec Raspberry Pi Pico - Framboise 314, le Raspberry Pi à la sauce française....
Ping : Un tracker GPS avec la carte Waveshare LoRa SX1262 pour Raspberry Pi Pico [1/2] - Framboise 314, le Raspberry Pi à la sauce française....

Laisser un commentaire Annuler la réponse

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.

Framboise 314, le Raspberry Pi à la sauce française….

La référence du Raspberry Pi en France – Par l'auteur du livre "Raspberry Pi 4" paru aux Edts. ENI

Utilisation des BME680 et RV3028 avec Raspberry Pi Pico

La carte Pico Explorer de Pimoroni

Présentation

Schéma

Brochage

Cahier des charges du projet

Matériel utilisé

La carte breakout BME680

Le BME680

La carte Pimoroni BME680

Vérifier la présence de la carte

Programme de lecture des données

La carte breakout RV3028

Le RV3028

La carte Pimoroni RV3028

Vérifier la présence de la carte

Programme de Mise à l’heure

Programme de lecture de l’heure

Afficher les données sur l’écran de Pico Explorer

Conclusion

Télécharger les programmes de l’article

Sources

À propos François MOCQ

Une réflexion au sujet de « Utilisation des BME680 et RV3028 avec Raspberry Pi Pico »

Laisser un commentaire Annuler la réponse