En tant que créateur toujours à la recherche de cartes microcontrôleurs abordables mais puissantes, je suis tombé amoureux du Raspberry Pi Pico. Sa taille compacte, ses performances impressionnantes et ses options de programmation polyvalentes le rendent parfait pour un large éventail de projets. Dans cet article, je vais partager certains de mes projets Pico préférés qui mettent en valeur ses capacités, des constructions simples pour débutants aux applications plus avancées.
Projet 1 : LED clignotante avec motifs personnalisés (adapté aux débutants)
Configuration matérielle
Pour ce projet, vous aurez besoin d'un Raspberry Pi Pico, d'une maquette, d'une LED, d'une résistance de 220 ohms et de fils de raccordement. Connectez l'anode de la LED à la broche GPIO 25 via la résistance et la cathode à la broche de masse du Pico. Cette configuration garantit que la LED est protégée contre les surintensités par la résistance et qu'elle est correctement connectée à la broche GPIO du Pico pour le contrôle.
Mise en œuvre du code
À l'aide de MicroPython, nous allons créer un programme permettant de faire clignoter la LED selon différents motifs. Commencez par importer les modules nécessaires :
from machine import Pin, Timer
Ensuite, initialisez la broche LED :
led = Pin(25, Pin.OUT)
Créez un objet minuterie pour contrôler les intervalles de clignotement. L'extrait de code suivant configure une minuterie qui active et désactive la LED toutes les 500 millisecondes :
tim = Timer()
def tick(timer):
led.toggle()
tim.init(freq=2, mode=Timer.PERIODIC, callback=tick)
Test et personnalisation
Une fois le code téléchargé sur le Pico (en l'enregistrant sous le nom main.py et en branchant le Pico), la LED devrait commencer à clignoter. Vous pouvez personnaliser les modes de clignotement en modifiant la période du minuteur ou en créant des fonctions plus complexes pour contrôler les temps d'allumage et d'extinction de la LED. Par exemple, vous pouvez créer une fonction qui fait clignoter la LED selon un code morse ou selon un motif qui change en fonction d'une entrée externe. Ce projet est un excellent moyen de se familiariser avec le contrôle des broches GPIO et MicroPython sur le Pico.
Projet 2 : Système de surveillance de la température (niveau intermédiaire)
Configuration matérielle requise
Procurez-vous un Raspberry Pi Pico, un capteur de température DS18B20, une résistance de 4,7 kΩ, une maquette et des fils de raccordement. Le DS18B20 utilise une interface 1-Wire, donc connectez son VCC à 3,3 V, son GND à la masse et sa broche DATA à la broche GPIO 18 du Pico. La résistance se place entre la broche DATA et le VCC pour tirer le signal vers le haut. Cette configuration assure une communication stable entre le Pico et le capteur de température, car le protocole 1-Wire nécessite une résistance de pull-up appropriée pour une transmission fiable des données.
Développement de code
Dans MicroPython, utilisez les bibliothèques onewire et ds18x20 pour communiquer avec le capteur. Commencez par importer les bibliothèques et initialisez le bus 1-Wire :
import machine
import onewire
import ds18x20
import time
Ensuite, configurez le bus sur la broche GPIO choisie :
ds_pin = machine.Pin(18)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
Recherchez les appareils et créez un objet DS18B20 :
roms = ds_sensor.scan()
print('Found DS devices: ', roms)
Le code suivant lit la température et l'affiche sur la console :
while True:
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
print(ds_sensor.read_temp(rom))
time.sleep(2)
Enregistrement et affichage des données
Pour rendre le système plus utile, vous pouvez ajouter un petit écran OLED (connecté via I2C) afin d'afficher la température en temps réel ou d'enregistrer les données dans un fichier sur un ordinateur connecté. Pour l'écran OLED, vous pouvez utiliser la bibliothèque ssd1306. Commencez par importer les modules nécessaires et initialisez l'interface I2C :
from machine import I2C, Pin
import ssd1306
i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000)
oled = ssd1306.SSD1306_I2C(128, 32, i2c)
Ensuite, modifiez la boucle de lecture de la température pour afficher la température sur l'écran OLED :
while True:
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
temp = ds_sensor.read_temp(rom)
print(temp)
oled.fill(0)
oled.text(f"Temp: {temp} C", 0, 0)
oled.show()
time.sleep(2)
Pour l'enregistrement des données, vous pouvez utiliser le code suivant pour écrire les données de température dans un fichier du système de fichiers interne du Pico :
file = open('temperatures.txt', 'w')
while True:
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
temp = ds_sensor.read_temp(rom)
print(temp)
file.write(f"{time.time()},{temp}\n")
file.flush()
time.sleep(2)
Ce projet montre comment interfacer des capteurs externes à l'aide des broches GPIO du Pico et met en avant sa capacité à gérer l'acquisition de données provenant de capteurs.
Projet 3 : Téléchargeur de données IoT (avancé)
Configuration matérielle
Vous aurez besoin d'un Raspberry Pi Pico W (avec Wi-Fi intégré), d'un capteur environnemental BME280 (qui mesure la température, l'humidité et la pression), d'une maquette et de fils de raccordement. Connectez le BME280 au Pico à l'aide d'I2C : SDA à GPIO 8, SCL à GPIO 9, VCC à 3,3 V et GND à la terre. Cette configuration de connexion permet au Pico de communiquer avec le capteur BME280 via le bus I2C, ce qui permet de récupérer les données environnementales.
Intégration du code et de l'IoT
Pour utiliser MicroPython sur le Pico W, connectez-vous d'abord à un réseau Wi-Fi. Configurez les identifiants Wi-Fi :
import network
ssid = 'your_SSID'
password = 'your_PASSWORD'
Connectez-vous à l'aide de l'interface réseau :
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(ssid, password)
while not wlan.isconnected():
pass
print('Connected to WiFi')
Ensuite, initialisez le capteur BME280 à l'aide de la classe bme280. Vous devrez peut-être installer la bibliothèque bme280 si elle n'est pas déjà installée. Voici comment l'initialiser :
import bme280_i2c
i2c = machine.I2C(0, sda=machine.Pin(8), scl=machine.Pin(9))
bme = bme280_i2c.BME280_I2C(i2c)
Le code lit les données du capteur et les télécharge vers une plateforme IoT telle que Ubidots ou Thingspeak à l'aide de la méthode HTTP POST. Voici une version simplifiée de la fonction de téléchargement des données :
import urequests
def upload_data(temperature, humidity, pressure):
url = 'https://industrial.api.ubidots.com/api/v1.6/devices/your_device_label'
headers = {'X-Auth-Token': 'your_token', 'Content-Type': 'application/json'}
data = '{"temperature": %s, "humidity": %s, "pressure": %s}' % (temperature, humidity, pressure)
response = urequests.post(url, headers=headers, data=data)
if response.status_code == 200:
print('Data uploaded successfully')
else:
print('Error uploading data')
response.close()
while True:
temperature, pressure, humidity = bme.values
temperature = float(temperature.strip(' C'))
humidity = float(humidity.strip(' %'))
pressure = float(pressure.strip(' hPa'))
upload_data(temperature, humidity, pressure)
time.sleep(60)
Tests et évolutivité
Une fois le code exécuté, le Pico W se connectera à Internet, lira les données du BME280 et les téléchargera sur la plateforme IoT choisie. Vous pouvez consulter les données en temps réel sur le tableau de bord de la plateforme. Ce projet met en avant les capacités sans fil du Pico W et montre comment créer des solutions IoT évolutives avec le Pico, ouvrant la voie à des applications domotiques, à la surveillance environnementale, etc. Si vous envisagez de développer ce projet, vous pouvez ajouter d'autres capteurs, ajuster les intervalles de collecte de données ou même utiliser une plateforme IoT plus robuste dotée de fonctionnalités d'analyse avancées.
Projets Pico pour explorer PIO, USB, capteurs et régulation
Un projet utile enseigne une notion matérielle à la fois et permet de mesurer le résultat. Choisissez d’abord la carte précise de la famille Pico, car processeur, radio, mémoire, broches et logiciels varient ; concevez ensuite les interfaces selon les limites logiques documentées de 3,3 V.
- Commencer par l’acquisition : enregistrer un capteur étalonné avec horodatage et intervalle défini.
- Explorer PIO : générer ou capter une interface sensible au temps et la vérifier sur des points d’essai.
- Créer un périphérique USB : réaliser une petite fonction humaine ou série avec reconnexion claire.
- Ajouter une boucle fermée : réguler vitesse, lumière ou température sur un système sûr et borné.
- Concevoir le prototype : prévoir découplage, adaptation de niveau, protection, points de test et compilation reproductible.
Conclusion
Le Raspberry Pi Pico est un outil fantastique pour les créateurs de tous niveaux, offrant des possibilités infinies pour des projets créatifs. Que vous débutiez avec un simple clignotement de LED ou que vous construisiez un système IoT avancé, le prix abordable, les performances et la facilité d'utilisation du Pico en font un choix de premier ordre. J'espère que ces projets vous inspireront à commencer à expérimenter vos propres constructions Pico. Partagez vos projets dans les commentaires ci-dessous – j'aimerais beaucoup voir ce que vous créez !
