La sortie du Raspberry Pi PICO a créé quelques remous dans le monde des microcontrôleurs. Un engouement pour certains, un questionnement pour d’autres qui ne voient pas ce que cette carte amène par rapport à un Arduino ou à un ESP32. Chacun se fera une opinion ou conservera la sienne. Quoi qu’il en soit, la mise sur le maché du microcontrôleur RP2040 seul a déclenché chez de nombreux fabricants la création de cartes. J’ai choisi la SeeedStudio Mini Dev Board Wio RP 2040 qui présente l’avantage d’intégrer un circuit Wi-Fi.

Cliquer pour plus d’infos sur les niveaux

J’ai classé cet article en avancé pour la partie installation de NetAssistant et Qt5 pour lesquels il faudra vous débrouiller et chercher un peu si l’installation se déroule mal… Par contre l’utilisation de la carte SeeedStudio est accessible par un débutant.

Au sommaire :

1 Carte Wio RP2040 mini Dev Board – avec Wifi – de Seeedstudio
- 1.1 Caractéristiques
2 Consommation
3 Vidéo
4 Conclusion
5 Sources

Carte Wio RP2040 mini Dev Board – avec Wifi – de Seeedstudio

Le module Wio RP2040 de SeeedStudio

La famille Wio RP2040 est construite autour du module Wio RP2040, qui intègre des capacités WiFi avec le RP2040 pour fournir une transmission sans fil stable et fiable.

Un ESP8285 caché sous le blindage aux côtés du RP2040 assure la liaison WiFi

Le module est entièrement compatible avec les outils de développement RP2040, tels que MicroPython avec l’éditeur de code Thonny Python qui est utilisé avec le Raspberry Pi Pico.

Avec quelques lignes de code simples, vous pouvez facilement ajouter la connectivité sans fil à vos projets et construire des capacités IoT efficaces et fiables ! Le module Wio RP2040 présente des pastilles un facteur de forme compact, et peut être soudé sur divers circuits imprimés de manière pratique.

De nombreuses interfaces sont accessibles, notamment 32 broches GPIO, dont 20 sont programmables et compatibles PWM, ainsi que 2 broches UART, 4 ADC, 2 SPI, 2 I2C et 1 USB. Certaines broches peuvent même être multiplexées, ce qui vous offre une grande flexibilité dans votre choix d’E/S. V

Le Wio RP2040 est livré avec le bootloader MicroPython UF2 de Seeed, qui donne à votre module Wio RP2040 des pilotes sans fil, un support réseau, usocket et MQTT dès sa sortie de la boîte – vous permettant de passer directement au développement !

La carte de développement WiO RP2040 Mini Dev Board, intègre le module Wio RP2040 avec des périphériques matériels supplémentaires pour faciliter votre expérience de prototypage. Construite autour d’une interface USB-C, la Wio RP2040 Mini Dev Board ajoute également deux boutons pour le démarrage et la réinitialisation afin de rendre les tests de vos projets beaucoup plus pratiques et agréables !

Caractéristiques

Processeur double cœur Arm Cortex-M0+ cadencé à 133MHz
264KB SRAM interne,
2MB Flash
Connectivité WiFi, 2.4-2.4835 GHz avec mode AP & Station
Broches d’E/S : 32 GPIO (20 PIO / PWM), ainsi que 2 UART, 4 ADC, 2 SPI, 2 I2C, 1 USB.
Support C/C++, MicroPython avec le bootloader Wio RP2040 MicroPython de Seeed.

Consommation

La carte consomme environ 50 mA.

Installer le firmware UF2

Normalement la carte WiO RP2040 arrive avec le firmware déjà installé. Ce télechargement vous sera utile si vous devez réinstaller MicroPython.

Pour dialoguer avec la carte WiO RP2040, j’ai opté pour un Raspberry Pi 400, mais vous pouvez utiliser une autre machine, comme un PC. Téléchargez ce fichier : firmware-v1.15.1.uf2. Il contient MicroPython et SeeedStudio l’a préparé pour qu’il contienne toutes les librairies nécessaires pour utiliser la carte WiO.

[stextbox id=’info’ caption=’.uf2′]C’est un format de flashing USB (USB Flashing Format = UF2), un fichier de données binaires utilisé à l’origine par le PXT (Programming Experience Toolkit) de Microsoft et MakeCode. Il contient un programme binaire qui peut être transféré d’un PC (ou d’un Raspberry Pi) à un microcontrôleur, tel qu’une carte Arduino ou PICO.[/stextbox]

Vous retrouvez le firmware dans le dossier Downloads de Raspberry Pi OS. Si vous devez réinstaller MicroPython sur la carte, il faudra appuyer sur le bouton BOOT en connectant la carte. La carte sera vue comme un périphérique de stockage et une fenêtre s’ouvrira sur le bureau du Raspberry Pi. Il suffit de copier le firmware dans la fenêtre pour le réinstaller. (Voyez cet article sur le blog pour plus de détails)

Tester la carte

Pour tester la carte on va commencer par la connecter au Raspberry Pi avec un câble USB <=> USB-C, sans appuyer sur un des deux boutons (BOOT et RUN). La LED PWR (Power) s’allume. c’est un premier pas 😛 Ensuite on va ouvrir Thonny IDE : Sur le Raspberry Pi ouvrez le menu principal puis > Programmation > Thonny Python IDE. Dans Thonny Cliquez sur Run > Select Interpreter…

Vérifiez que c’est bien MicroPython pour PICO qui va exécuter le code, sinon sélectionnez le dans la liste déroulante (Cette option est disponible dans les versions de Thonny les plus récentes. Au besoin mettez votre IDE Thonny à jour).

Éventuellement passez Thonny en Français ( Tools > Options > General). Redémarrez Thonny.

Normalement vous devez fonctionner avec un MicroPython (la version peut évoluer dans le temps) mais surtout la mention Seeed Wio with RP2040 prouve que vous disposez des librairies nécessaires. Faisons parler la carte WiO :

On est maintenant certain que la carte fonctionne, puisqu’elle a exécuté la commande print.

Le schéma de la carte indique que la LED USER est connectée au GPIO13. Nous allons vérifier si elle fonctionne correctement. La LED qui s’allume c’est le « Hello world » de l’électronicien 😉

Dans Thonny IDE saisissez manuellement le programme suivant :

Respectez scrupuleusement les majuscules/minuscules, la ponctuation et les indentations – décalages). Cliquez sur le bouton de démarrage du programme (flèche rouge).

Thonny IDE vous demande d’enregistrer le programme avent de l’exécuter. Vous pouvez l’enregistrer sur votre ordinateur (flèche rouge) ou directement dans le PICO.

Sans grande originalité, j’ai créé un dossier WioRP2040 dans lequel j’ai rangé le programme blink.py. Après enregistrement le programme se lance et…

La LED bleue USER se met à clignoter. Bingo, tout fonctionne, on peut passer à la suite.

Tester le WiFi

Sur PC télécharger et installer NetAssist https://down.itsvse.com/item_en/qakzaw.html

Sur Raspberry Pi 400 installer QT5

sudo apt-get install qt5-default
sudo rpi-update reboot

1 2	sudo apt-get install qt5-default sudo rpi-update reboot

sudo apt-get update 
sudo apt-get upgrade

1 2	sudo apt-get update sudo apt-get upgrade

Installer la chaine de compilation

sudo apt-get install build-essential

1	sudo apt-get install build-essential

paquets recommandés pour QT5

sudo apt-get install libfontconfig1-dev libdbus-1-dev libfreetype6-dev libicu-dev libudev-dev libinput-dev libxkbcommon-dev libssl-dev libpng-dev libjpeg-dev libglib2.0-dev libraspberrypi-dev

1	sudo apt-get install libfontconfig1-dev libdbus-1-dev libfreetype6-dev libicu-dev libudev-dev libinput-dev libxkbcommon-dev libssl-dev libpng-dev libjpeg-dev libglib2.0-dev libraspberrypi-dev

Installer NetAssistant

git clone https://github.com/busyluo/NetAssistant.git
cd NetAssistant
qmake
make
sudo make install

git clone https://github.com/busyluo/NetAssistant.git

cd NetAssistant

qmake

make

sudo make install

En ligne de commande saisir

NetAssistant

et…

oups ça va être compliqué 🙂 … Cliquez sur Language et choisissez English, vous verrez que ça va vous rassurer… (désolé pas de français ici)

Ah… ça va mieux ! On va configurer NetAssistant en serveur :

Passez le protocole en TCP Server. L’adresse locale est celle du Raspberry Pi. J’ai choisi le port 8080 pour la connexion. Cliquez sur le bouton Connect et vous obtenez l’image de droite.

import network
import usocket
from machine import Pin, I2C, ADC, UART, SPI, PWM
from time import sleep

N1 = network.WLAN_SPI(network.STA_IF)
N1.active(True)

print("API list:")
dir(N1)

print("wifi list:")
lis = N1.scan()
for q in lis:
    print(q)

N1.connect("Livebox-57A9","258xxxxxxxxxxxxxxxxxxxx279")
if N1.isconnected():
    print("         ip                      gateway                    netmask                       MAC                       ssid")
    print(N1.ifconfig())
    s=usocket.socket()
    addr=('192.168.1.31',8080)
    s.connect(addr)
    s.send('Hello! Wio RP2040')

import network

import usocket

from machine import Pin, I2C, ADC, UART, SPI, PWM

from time import sleep

N1 = network.WLAN_SPI(network.STA_IF)

N1.active(True)

print("API list:")

dir(N1)

print("wifi list:")

lis = N1.scan()

for q in lis:

print(q)

N1.connect("Livebox-57A9","258xxxxxxxxxxxxxxxxxxxx279")

if N1.isconnected():

print(" ip gateway netmask MAC ssid")

print(N1.ifconfig())

s=usocket.socket()

addr=('192.168.1.31',8080)

s.connect(addr)

s.send('Hello! Wio RP2040')

Quand on lance le programme il se passe des choses :

On voit que la carte WiO RP2040 liste les points d’accès voisins, se connecte à la Livebox et récupère l’adresse 192.168.1.35. Au passage, je note que les plus proches voisins sont à une quinzaine de mètres (lotissement) et que le nombre de points d’accès détecté est important ! Ensuite le programme se termine normalement, sans erreur. Regardons du côté du serveur TCP :

On retrouve dans le programme les éléments nécessaires à la connexion, comme ci-dessous.

On voit qu’on peut envoyer des informations via le Wi-Fi à une machine extérieure.

MQTT

MQTT (Message Queuing Telemetry Transport) est un protocole de messagerie publication-souscription basé sur le protocole TCP/IP. Il a été initialement développé par Andy Stanford-Clark (IBM) et Arlen Nipper (EuroTech). (wikipedia)

J’avais écrit deux articles à ce sujet, vous pouvez vous y référer pour en savoir plus sur MQTT : Le premier article en 2015 dont les programmes sont sans doute dépassés, et un autre article en 2018.

Ce schéma montre le principe de fonctionnement de MQTT. A gauche figurent les “publieurs”. Ce sont des machines (Arduino, ESP8266, Raspberry Pi…) qui captent des valeurs (température, humidité, pression, consommation électrique, consommation d’eau…) et les envoient à un serveur appelé “Broker”.
Des clients “souscripteurs” sont connectés au “Broker”. Ils ont sollicité l’envoi de certaines données. Lorsque le Broker reçoit ces données, il les retransmet aux clients qui se sont abonnés à ce flux de données. Par exemple un des clients souscripteurs recevra la température et l’humidité pour en faire un graphe en temps réel. L’autre client recevra la consommation d’eau et déclenchera une alerte si elle dépasse une valeur déterminée.

Pour le genre de liaison entre un objet connecté à base de WiO RP2040 et un ordinateur (ici un Raspberry Pi 400) c’est souvent ce protocole qui est mis en œuvre

Installer Mosquitto

sudo apt-get install mosquitto
sudo apt-get install mosquitto-clients

1 2	sudo apt-get install mosquitto sudo apt-get install mosquitto-clients

On commence par installer le broker Mosquitto et les clients si vous voulez vous connecter. Vous installez mosquitto_sub (pour souscrire), mosquitto_pub (pour publier des messages) et mosquitto_passw (pour configurer des utilisateurs et des mots de passe).

Vous pouvez vérifier que Mosquitto fonctionne. Il sera automatiquement démarré quand vous démarrerez le système.

pi@raspberrypi:~ $ systemctl status mosquitto
● mosquitto.service - Mosquitto MQTT v3.1/v3.1.1 Broker
Loaded: loaded (/lib/systemd/system/mosquitto.service; enabled; vendor preset: enabled)
Active: active (running) since Tue 2021-08-31 15:34:14 CEST; 9min ago
Docs: man:mosquitto.conf(5)
man:mosquitto(8)
Main PID: 614 (mosquitto)
Tasks: 1 (limit: 4915)
CGroup: /system.slice/mosquitto.service
└─614 /usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf

août 31 15:34:14 raspberrypi systemd[1]: Starting Mosquitto MQTT v3.1/v3.1.1 Broker...
août 31 15:34:14 raspberrypi systemd[1]: Started Mosquitto MQTT v3.1/v3.1.1 Broker.

pi@raspberrypi:~ $ systemctl status mosquitto

● mosquitto.service - Mosquitto MQTT v3.1/v3.1.1 Broker

Loaded: loaded (/lib/systemd/system/mosquitto.service; enabled; vendor preset: enabled)

Active: active (running) since Tue 2021-08-31 15:34:14 CEST; 9min ago

Docs: man:mosquitto.conf(5)

man:mosquitto(8)

Main PID: 614 (mosquitto)

Tasks: 1 (limit: 4915)

CGroup: /system.slice/mosquitto.service

└─614 /usr/sbin/mosquitto -c /etc/mosquitto/mosquitto.conf

août 31 15:34:14 raspberrypi systemd[1]: Starting Mosquitto MQTT v3.1/v3.1.1 Broker...

août 31 15:34:14 raspberrypi systemd[1]: Started Mosquitto MQTT v3.1/v3.1.1 Broker.

Tester Mosquitto en local

On peut tester le fonctionnement. Ouvrez 2 fenêtres de terminal (ou de terminaux si vous trouvez que ça fait mieux 🙂 ). Dans la première tapez

mosquitto_sub -h localhost -t "LED"

1	mosquitto_sub -h localhost -t "LED"

puis tapez sur la touche entrée. Vous venez de souscrire au broker et êtes en attente des messages.

Dans l’autre fenêtre tapez :

mosquitto_pub -h localhost -t "LED" - m on

1	mosquitto_pub -h localhost -t "LED" - m on

puis tapez sur la touche entrée. vous venez d’envoyer un message au broker. Comme vous avez utilisé le même topi (-t) : « LED » vous recevez le message dans le subscriber :

Tester Mosquitto avec la carte Wio RP2040 en publisher

Le programme mqtt_pub_01.py est exécuté par la carte Dev Wio RTP2040. Il est inscrit comme publisher (fournisseur) au topic Wio_RP2040 du broker MQTT Mosquitto, installé sur le Raspberry Pi 400. En ligne de commande, depuis le Raspberry Pi 400, on lance un subscriber connecté au Topic Wio_RP2040 du broker. Le message émis par le programme mqtt_pub_01.py lors du démarrage de la carte Wio RP2040 est récupéré par le subscriber qui affiche le message Démarrage Wio dans la fenêtre de terminal.

Saisir le programme mqtt_pub_01.py suivant dans Thonny IDE. Lancez son exécution.

# Programme test MQTT publisher
import network
import mqtt
from machine import Pin, I2C, ADC, UART, SPI, PWM
from time import sleep
 
N1 = network.WLAN_SPI(network.STA_IF)
N1.active(True)
N1.connect("Livebox-57A9","258xxxxxxxxxxxxxxxxxx279")
if N1.isconnected():
    print("    ip               gateway           netmask            MAC            ssid")
    print(N1.ifconfig())
 
SERVER = '192.168.1.31'
CLIENT_ID = 'Wio RP2040_Dev_board'

cl = mqtt.MQTTClient(CLIENT_ID, SERVER, mqtt_port = 1883)
cl.connect()
 
cl.publish("Wio_RP2040","Démarrage Wio")

# Programme test MQTT publisher

import network

import mqtt

from machine import Pin, I2C, ADC, UART, SPI, PWM

from time import sleep

N1 = network.WLAN_SPI(network.STA_IF)

N1.active(True)

N1.connect("Livebox-57A9","258xxxxxxxxxxxxxxxxxx279")

if N1.isconnected():

print(" ip gateway netmask MAC ssid")

print(N1.ifconfig())

SERVER = '192.168.1.31'

CLIENT_ID = 'Wio RP2040_Dev_board'

cl = mqtt.MQTTClient(CLIENT_ID, SERVER, mqtt_port = 1883)

cl.connect()

cl.publish("Wio_RP2040","Démarrage Wio")

Ouvrez une fenêtre de terminal (eh oui…) pour vous abonner au topic de la carte WiO RP2040. Au démarrage du programme vous devez recevoir le message de démarrage :

Ceci confirme que le broker fonctionne, que la carte Wio RP2040 envoie bien un message au Topic « LED » et que le subscriber connecté à ce topic le récupère parfaitement !

Tester Mosquitto avec la carte Wio RP2040 en subscriber

Shéma de principe d'une liason mqtt entre un Raspberry Pi et une carte Wio RP2040

Cliquer pour agrandir

Le programme mqtt_sub_01.py est exécuté par la carte Dev Wio RTP2040. Il est inscrit comme subscriber (abonné) au topic LED du broker MQTT Mosquitto, installé sur le Raspberry Pi 400 400. En ligne de commande, depuis le Raspberry Pi 400, on envoie les messages on puis off au Topic LED du broker. Ce message est récupéré par la carte Wio RP2040 et le programme allume ou éteint la LED USER de la carte.

Chargez le programme mqtt_sub_01.py dans Thonny IDE et exécutez le sur la carte Wio RP2040.

# Programme test MQTT minimaliste
# Se connecte au topic LED du serveur MQTT
# on allume la LED
# off éteint la LED

import network
import mqtt
from machine import Pin, I2C, ADC, UART, SPI, PWM
from time import sleep
 
N1 = network.WLAN_SPI(network.STA_IF)
N1.active(True)
N1.connect("Livebox-57A9","258xxxxxxxxxxxxxxxxxx279")

print ("Connecté au Wi-Fi")
print(N1.ifconfig()[0])
sleep(1)

led = Pin(13, Pin.OUT)
led.value(0)
 
SERVER = '192.168.1.31'
CLIENT_ID = 'Wio RP2040_Dev_board'
TOPIC = 'LED'

def mqtt_callback(topic):
    print('topic: {}'.format(topic[0]))
    print('msg:{}'.format(topic[1]))
    msg = topic[1]
    if(msg == "off"):
        led.value(0)
    if(msg == "on"):
        led.value(1)

cl = mqtt.MQTTClient(CLIENT_ID, SERVER, mqtt_port = 1883)
cl.connect()
cl.subscribe("LED")
cl.set_callback(mqtt_callback)
print('Connecté au broker MQTT %s, inscrit au topic %s' % (SERVER, TOPIC))
print('En attente...')

while True:
    cl.wait_msg()
    sleep(1)

# Programme test MQTT minimaliste

# Se connecte au topic LED du serveur MQTT

# on allume la LED

# off éteint la LED

import network

import mqtt

from machine import Pin, I2C, ADC, UART, SPI, PWM

from time import sleep

N1 = network.WLAN_SPI(network.STA_IF)

N1.active(True)

N1.connect("Livebox-57A9","258xxxxxxxxxxxxxxxxxx279")

print ("Connecté au Wi-Fi")

print(N1.ifconfig()[0])

sleep(1)

led = Pin(13, Pin.OUT)

led.value(0)

SERVER = '192.168.1.31'

CLIENT_ID = 'Wio RP2040_Dev_board'

TOPIC = 'LED'

def mqtt_callback(topic):

print('topic: {}'.format(topic[0]))

print('msg:{}'.format(topic[1]))

msg = topic[1]

if(msg == "off"):

led.value(0)

if(msg == "on"):

led.value(1)

cl = mqtt.MQTTClient(CLIENT_ID, SERVER, mqtt_port = 1883)

cl.connect()

cl.subscribe("LED")

cl.set_callback(mqtt_callback)

print('Connecté au broker MQTT %s, inscrit au topic %s' % (SERVER, TOPIC))

print('En attente...')

while True:

cl.wait_msg()

sleep(1)

Il serait intéressant d’imaginer l’utilisation simultanée de la carte Wio RP2040 en subscriber en même temps que publisher. Ceci permettrait par exemple de transmettre les donénes climatiques à un serveur domotique central qui prendrait des décisions et les renverrait à la carte Wio RP2040 pour exécution (ouvrir une trappe, démarrer un chauffage, une ventilation, un arrosage…).

Cela est normalement réalisable avec MQTT mais l’implémentation du client dans cette version de Seeedstudio n’autoriqe que l’utilisation de wait_msg() qui est une fonction bloquante. Elle attend l’arrivée d’un message mais boque le programme pendant ce temps.

L’absence de check_msg() est gênante. Cette fonction est non non bloquante car elle teste juste si un message est arrivé, et continue l’exécution si aucun message n’est présent.
J’ai fait remonter cette constatation à l’équipe de dev de SeeedStudio. Ca devrait évoluer dans une prochaine version.

>>> help(mqtt.MQTTClient)
object <class 'mqtt'> is of type type
__del__ -- <function>
set_callback -- <function>
connect -- <function>
disconnect -- <function>
publish -- <function>
subscribe -- <function>
wait_msg -- <function>
>>>

>>> help(mqtt.MQTTClient)

object <class 'mqtt'> is of type type

__del__ -- <function>

set_callback -- <function>

connect -- <function>

disconnect -- <function>

publish -- <function>

subscribe -- <function>

wait_msg -- <function>

>>>

Envoi de données température et humidité

Ici c’est un capteur DHT22 que j’ai utilisé. Ce capteur de température et d’humidité DHT22 (ou AM2302) communique avec le RP2040 via un port série. Le capteur est calibré et ne nécessite pas de composants supplémentaires pour pouvoir être utilisé. Les DHT11 et DHT22 sont connus pour dériver dans le temps.

Le capteur DHT 22 est relié à GP2. J’ai utilisé une bibliothèque MicroPython pour le DHT11/DHT22 (voir en bas d’article dans les sources).

Montage du DHT22

Le programme mqtt_DHT.py est à charger dans Thonny IDE.

from machine import Pin
import network
import mqtt
from time import sleep
from dht import DHT11, InvalidChecksum

pin = Pin(2, Pin.OUT, Pin.PULL_DOWN)
sensor = DHT11(pin)

N1 = network.WLAN_SPI(network.STA_IF)
N1.active(True)
N1.connect("Livebox-57A9","258xxxxxxxxxxxxxxxxxx279")
if N1.isconnected():
    print("    ip               gateway           netmask            MAC            ssid")
    print(N1.ifconfig())
 
SERVER = '192.168.1.31'
CLIENT_ID = 'Wio RP2040_Dev_board'

cl = mqtt.MQTTClient(CLIENT_ID, SERVER, mqtt_port = 1883)
cl.connect()

print('Connecté au broker MQTT ', SERVER)
print('En attente...')

while True:
    t  = (sensor.temperature)
    h = (sensor.humidity)
    print("Temperature: {}".format(sensor.temperature))
    print("Humidity: {}".format(sensor.humidity))
    cl.publish("Temp", str(t))
    cl.publish("Hum", str(h)) 
    sleep(5)

from machine import Pin

import network

import mqtt

from time import sleep

from dht import DHT11, InvalidChecksum

pin = Pin(2, Pin.OUT, Pin.PULL_DOWN)

sensor = DHT11(pin)

N1 = network.WLAN_SPI(network.STA_IF)

N1.active(True)

N1.connect("Livebox-57A9","258xxxxxxxxxxxxxxxxxx279")

if N1.isconnected():

print(" ip gateway netmask MAC ssid")

print(N1.ifconfig())

SERVER = '192.168.1.31'

CLIENT_ID = 'Wio RP2040_Dev_board'

cl = mqtt.MQTTClient(CLIENT_ID, SERVER, mqtt_port = 1883)

cl.connect()

print('Connecté au broker MQTT ', SERVER)

print('En attente...')

while True:

t = (sensor.temperature)

h = (sensor.humidity)

print("Temperature: {}".format(sensor.temperature))

print("Humidity: {}".format(sensor.humidity))

cl.publish("Temp", str(t))

cl.publish("Hum", str(h))

sleep(5)

Ce programme lit les données du DHT22 toutes les 5 secondes et envoie le résultat au broker MQTT, dans les Topics Temp et Hum. Ouvrez 2 fenêtres de terminaux et lancez dans chacune un subscriber qui va récupérer et afficher les données reçues.

Sur un Raspberry Pi : Programme de lecture de données du DHT22, envoi au broker Mosquitto et affichage grâce à deux subscribers.

Cliquer pour agrandir

Utilisation de Node-Red

Afficher des connées en mode texte, c’est bien. Ca permet de vérifier que tout fonctionne. Mais avouez que ce n’est pas très sexy. C’est quand même mieux d’avoir un beau tableau de bord avec des jauges, des barres et des bourons, non ?

Node-Red est présent dans la rubrique programmation de Raspberry Pi OS. Il permet de réaliser facilement des traitements de flux de données de différentes provenances et justement… MQTT est présent. On peut ensuite créer un tableau de bord (dashboard) pour représenter les données de façon visuelle. Le dashboard est accessible via une page web, sur le Raspberry Pi lui même ou depuis n’importe quelle machine connectée au réseau, voire même par Internet…

Ici j’ai connecté 2 subscribers aux Topics Temp et hum vus plus haut. Les données récupérées sont transmises à deux jauges, chargées de l’affichage.

et avec le même programme que précédemment, on obtient :

C’est quand même plus joli… Et pour actionner des commandes, ici ce serait une LED mais vous pouvez imaginer de commander de nombreux actionneurs…

Un bouton A/M permet d’allumer et éteindre la LED simplement en cliquant dessus. Si vous ne connaissez pas Node-Red, je vous engage à découvrir les possibilités de ce langage…

Vidéo

Dans cette vidéo, vous découvrirez une présentation de la carte Wio RP2040 mini Dev Board, vous verrez comment lui ajouter des picots pour l’utiliser sur une breadboard, et enfin vous la verrez en action, avec les exemples de cete article.

Conclusion

Avec cette carte Wio RP2040 mini Dev Board, SeeedStudio a fait une utilisation intelligente du microcontrôleur en lui adjoignant la connectivité Wi-Fi. C’est ce qui manque au Raspberry Pi Pico. ici on a une carte compacte, équipée des deux boutons poussoirs nécessaires (il n’y en a qu’un sur le Pico), alimentée via USB-C.

Une carte bien adaptée à la réalisation d’objets connectés IoT. Il faudra encore un peu de développement software pour que tout soit « parfait », mais l’essentiel est présent.

Voci les liens (non affiliés) vers les produits. La demande est très forte et si un des produits est momentanément en rupture de stock, la réapro est généralement rapide.

Lien pour le module RP2040 : https://www.seeedstudio.com/Wio-RP2040-Module-p-4932.html

Lien pour la carte de Dev RP2040 : https://www.seeedstudio.com/Wio-RP2040-mini-Dev-Board-p-4933.html

Sources

Carte de développement WiO RP2040 : https://www.seeedstudio.com/Wio-RP2040-mini-Dev-Board-p-4933.html
Démarrer avec la carte de dev WiO RP2040 : https://wiki.seeedstudio.com/Wio_RP2040_mini_Dev_Board-Onboard_Wifi/
Firmware UF2 : https://files.seeedstudio.com/wiki/Wio_RP2040_mini_Dev_Board-Onboard_Wifi/firmware-v1.15.1.uf2
Module WiO RP2040 chez Mouser : https://www.mouser.fr/new/seeed-studio/seeed-studio-wio-rp2040-module/
Gestion du WiFi : https://github.com/jandrassy/WiFiEspAT
Présentation du module WiO RP2040 : https://www.seeedstudio.com/blog/2021/05/20/introducing-seeeds-wio-rp2040-family-mini-dev-board-module/
ESP32 MicroPython webserver : https://randomnerdtutorials.com/esp32-esp8266-micropython-web-server/
Installer NetAssistant : https://github.com/busyluo/NetAssistant
MicroPython et réseau : https://docs.micropython.org/en/latest/esp8266/tutorial/network_tcp.html
Installer Mosquitto : https://projetsdiy.fr/mosquitto-broker-mqtt-raspberry-pi/
Bibliothèque DHT11/DHT22 : https://how2electronics.com/interfacing-dht11-temperature-humidity-sensor-with-raspberry-pi-pico/
Mosquitto et Node-Red : https://bentek.fr/mosquitto-node-red-raspberry-pi/
Afficher les lectures DHT22 : https://projetsdiy.fr/node-red-dashboard-gauges-graphiques-notifications-html/

3 réflexions au sujet de « Carte Wio RP2040 Wi-Fi de SeeedStudio »

Gordon 7 septembre 2021 à 21 h 51 min

Salut François.

Belle présentation, comme d’habitude.

Que ce soit le Raspberry Pi Pico ou celui-ci, le Wio RP2040 Wi-Fi de SeeedStudio, j’ai le même problème. Il faut souder les picots !
Du coup, je n’ai toujours pas acheté le Raspberry Pi Pico. L’avantage du modèle SeeedStudio est le Wifi.
Je préfère de loin le ESP32 !

Cordialement.
Artemus24.
@+

Répondre ↓
Gildas 21 janvier 2022 à 13 h 22 min

Merci pour cet article très intéressant et pour votre travail de vulgarisation depuis des années .

Est-il possible d’utiliser ces modules en C++ avec l’IDE arduino ?

Pourrait-il remplacer une carte esp32 ?

Répondre ↓
1. François MOCQ Auteur de l’article21 janvier 2022 à 15 h 59 min
  
  Bonjour
  oui c est compatible IDE arduino voyez ici : https://wiki.seeedstudio.com/Get-Wio-RP2040-mini-Dev-Board-started-with-Machine-Learning-using-Arduino/
  Cette carte pourrait remplacer un ESP32 mais n fonction de l’appli ce n’est pas forcément justifié
  certaines caractéristiques de l’ESP sont meilleures 🙂
  voyez ici par exemple https://www.iottrends.tech/blog/raspberry-pi-pico-vs-esp-32/
  cdt
  françois
  
  Répondre ↓

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

Carte Wio RP2040 Wi-Fi de SeeedStudio

Carte Wio RP2040 mini Dev Board – avec Wifi – de Seeedstudio

Caractéristiques

Consommation

Installer le firmware UF2

Tester la carte

Tester le WiFi

MQTT

Installer Mosquitto

Tester Mosquitto en local

Tester Mosquitto avec la carte Wio RP2040 en publisher

Tester Mosquitto avec la carte Wio RP2040 en subscriber

Envoi de données température et humidité

Utilisation de Node-Red

Vidéo

Conclusion

Sources

À propos François MOCQ

3 réflexions au sujet de « Carte Wio RP2040 Wi-Fi de SeeedStudio »

Laisser un commentaire Annuler la réponse