Dominique Meurisse, qui gère la boutique MC Hobby avec son épouse est infatigable. Il écrit également des livres (MicroPython et Pyboard et Raspberry Pi Pico et Pico W aux Editions ENI), publie régulièrement de la documentation open-source (bibliothèques et exemples MicroPython) et le reste du temps, vous croyez qu’il se repose ?
Eh bien non pas du tout, il conçoit de nouvelles cartes électroniques…
Sa dernière création est un adaptateur qui permet de contrôler le robot Zumo avec un Raspberry Pi Pico (soudé sur carte).
Même si Dominique est un ami, je précise que cet article n’est pas sponsorisé. J’ai acheté la carte dans sa boutique comme n’importe quel client. Et bien sûr, s’il le faut je n’hésiterai pas à vous parler des points négatifs.
Mais d’où lui vient cette idée ?
Ça fait longtemps que Dominique réfléchit à une solution pour piloter le robot Zumo en MicroPython. Il a aussi conçu un adaptateur Pyboard pour ZUMO. Vous ne trouvez pas qu’il ressemble énormément à notre adaptateur Pico ?
La Pyboard était la première carte de développement à fonctionner en MicroPython. Je la teste dans cet article mais Dominique y a consacré presque 800 pages dans un de ses livres.
Le robot Zumo
Le robot Zumo est compact mais très performant. Il a été conçu pour faire des compétitions de mini Sumo. Le principe est simple, il s’agit de pousser l’adversaire en dehors d’un cercle blanc délimité par une large ligne noire. Mais les robots ne sont pas télécommandés. Ils sont programmés à l’avance et doivent se débrouiller seuls pour éjecter l’adversaire (sans sortir du cercle). Bien sûr, ils disposent de différents capteurs (détection des sols clairs ou foncés, accéléromètre, magnétomètre, et gyroscope), de chenilles pour augmenter l’adhérence, de très bons moteurs et même d’un Buzzer.
Cette version n’intègre pas de microcontrôleur, le robot n’est qu’un « simple » shield équipé de connecteurs au format de l’Arduino Uno. Normalement, il suffit d’insérer la carte et d’utiliser les bibliothèques fournies par Pololu (le fabricant du robot) pour programmer votre Zumo. Ce n’est pas vraiment le sujet de cet article mais si ça vous intéresse, j’explique tout cela dans mon livre sur l’Arduino.
L’adaptateur Pico pour Zumo
La carte de Dominique s’insère à la place de l’Arduino. Elle permet de contrôler le robot Zumo (conçu pour un Arduino en 5V) avec le Raspberry Pi Pico (qui fonctionne sous 3,3V). Elle ajoute aussi quelques connecteurs (Grove, UEXT et Qwiic de l’autre coté) ainsi que des emplacements pour souder des connecteurs supplémentaires. Les boutons Utilisateur et Reset du robot sont dupliqués sur l’adaptateur et beaucoup d’informations utiles sont inscrites sur la carte (ces petits détails semblent anodins, mais ils facilitent énormément la vie de l’utilisateur).
Les bibliothèques MicroPython
Pour faciliter la programmation de l’ensemble (Zumo et Pico) Dominique a réécris les bibliothèques Arduino du robot pour le langage MicroPython. Elles ont déjà été copiées dans le dossier lib du Raspberry Pi Pico (de l’adaptateur Pico-Zumo), mais en cas de besoin vous pouvez les retrouver ici.
Attention, la bibliothèque zumoimu.py ne fonctionne qu’avec la version 1.3 du robot Zumo. Alors si vous possédez la V1.2 il faudra utiliser les bibliothèques lsm303.py et L3G.py (parce que l’accéléromètre, le magnétomètre et le gyroscope sont différents).
La documentation
Dominique accompagne toujours ses créations d’une riche documentation, agrémentée de précieux conseils, de schémas détaillés et d’exemples de code extrêmement utiles. D’habitude il se contentait d’un simple résumé sur la fiche produit et puis il écrivait tout le reste dans son blog, son Wiki, son Github et/ou son forum…
Mais alors cette fois-ci il s’est surpassé, il nous a carrément écris un livre complet !!!
Oui, vous ne rêvez pas, le livre : « Pico, Zumo Robot et MicroPython » est disponible gratuitement au format PDF sur le wiki de MC Hobby :
- Chapitre 1 – Introduction (13 pages) : Présentation rapide des différents éléments (détaillés dans les chapitres suivants).
- Chapitre 2 – MicroPython et Raspberry-Pi Pico (59 pages) : Description du Raspberry-Pi Pico avec des exemples de code en MicroPython
- Chapitre 3 – Zumo Robot (29 pages) : Description du robot Zumo v1.3 (dans sa version shield pour Arduino)
- Chapitre 4 – Brancher (22 pages) : Description de l’adaptateur qui permet la communication entre Pico et Zumo
- Chapitre 5 – Bibliothèque Zumo Robot (26 pages) : Présentation des bibliothèques de Dominique qui permettent de contrôler le robot Zumo en MicroPython
- Chapitre 6 – Tester (30 pages) : Les tests qui permettent de bien prendre en main le robot
- Chapitre 7 – Exemples (58 pages) : Les exemples de codes sont classiques, mais il sont vraiment très bien expliqués
- Chapitre 8 – Exemples avancés (51 pages, pour l’instant) : Le dernier chapitre est actuellement inachevé mais il fourni quand même de nombreuses d’informations pour télécommander le robot Zumo.
Test de l’adaptateur et du robot Zumo
Dans sa version standard, le robot Zumo est équipé de moteurs 75:1 (HP). Cela signifie que les moteurs doivent faire 75 tours pour que la roue du robot fasse un tour complet. Il est possible d’augmenter la puissance en utilisant par exemple des moteurs 100:1 ou 150:1 ou la vitesse avec éventuellement des moteurs 50:1 ou 30:1 mais les moteurs 75:1 restent un très bon compromis entre les 2.
Pour mon test, j’ai simplement repris l’exemple de suivi de ligne fourni par Dominique en augmentant la vitesse maximum à 400 (au lieu de 100).
from zumoshield import ZumoShield
from machine import WDT
import time
z = ZumoShield()
MAX_SPEED = 400
last_error = 0
def clamp( val, _min, _max ):
return max(min(_max, val), _min)
print( "Press Button to start calibration" )
z.buzzer.play(">g8>>c8")
z.button.waitForButton()
time.sleep(1)
z.ir_calibration( motors=True )
z.buzzer.play(">g8>>c8")
try:
wdt = WDT( timeout = 500 ) # 300ms before reset
while(True):
wdt.feed()
position = z.ir.readLineBlack()
error = position -2500
speed_diff = (error/4) + (6*(error-last_error))
last_error = error
m1Speed = MAX_SPEED+speed_diff
m2Speed = MAX_SPEED-speed_diff
m1Speed = clamp( m1Speed, 0, MAX_SPEED )
m2Speed = clamp( m2Speed, 0, MAX_SPEED )
z.motors.setSpeeds(m1Speed,m2Speed)
finally:
z.motors.stop()
Et même à cette vitesse, cela fonctionne parfaitement (avec des moteurs 75:1).
Connecteurs Grove, Qwiic et UEXT
Ils sont reliés au bus I2C (et également aux bus SPI et UART, pour le connecteur UEXT). Les connecteurs UEXT et Qwiic fonctionnent exclusivement sous 3,3V et par défaut, le connecteur Grove est aussi en 3,3V. Mais certains modules (comme par exemple l’afficheur Grove-16×2 LCD) fonctionnent seulement sous 5V. Heureusement, il est possible de modifier la carte pour fournir une alimentation de 5V au connecteur Grove (la procédure est expliquée dans le chapitre 4).
Mais il existe aussi des modules Grove compatibles 3,3V, je vais donc utiliser l’afficheur OLED 0,96 » Grove (128 x 64). Pour permettre au Raspberry Pi Pico de dialoguer avec un module I2C, il faut installer la bibliothèque correspondante. Rendez-vous à l’adresse suivante et téléchargez le fichier ssd1306.py (en faisant un clic droit sur le bouton Raw et en sélectionnant Enregistrer le contenu lié sous…
Ouvrez le fichier ssd1306.py avec Thonny (Fichier-Ouvrir…), connectez le Raspberry Pico. Si un script est en cours d’exécution arrêtez-le en cliquant sur le bouton rouge Stop. Allez dans Fichier-Enregistrer sous…, sélectionnez Raspberry Pi Pico et ensuite le répertoire lib, inscrivez le nom du fichier (ssd1306.py) et cliquez sur OK.
Vous pouvez maintenant ouvrir et modifier le fichier main.py, voilà un exemple de code :
from machine import Pin, I2C
from time import sleep
import ssd1306
i2c = I2C(0,scl=Pin(9), sda=Pin(8), freq=400000)
display = ssd1306.SSD1306_I2C(128, 64, i2c)
while True:
display.fill(0)
display.text('Test de', 35, 4, 1)
display.text("l'adaptateur", 15, 20, 1)
display.text('Pico-Zumo sur :', 5, 36, 1)
display.text('arduiblog.com', 10, 52, 1)
display.show()
sleep(5)
display.fill(1)
display.text('Test de', 35, 4, 0)
display.text("l'adaptateur", 15, 20, 0)
display.text('Pico-Zumo sur :', 5, 36, 0)
display.text('arduiblog.com', 10, 52, 0)
display.show()
sleep(5)
L’ajout d’un écran peut être très utile pour afficher différentes infos (données des différents capteurs, messages, débogage…).
Voilà par exemple le programme de suivi de ligne légèrement modifié pour qu’il affiche à l’écran le message : « Press Button to start calibration » :
from zumoshield import ZumoShield
from machine import Pin, I2C, WDT
import time
import ssd1306
i2c = I2C(0,scl=Pin(9), sda=Pin(8), freq=400000)
display = ssd1306.SSD1306_I2C(128, 64, i2c)
z = ZumoShield()
MAX_SPEED = 400
last_error = 0
def clamp( val, _min, _max ):
return max(min(_max, val), _min)
display.fill(0)
display.text('Press Button', 15, 8, 1)
display.text('to start', 30, 28, 1)
display.text('calibration', 17, 48, 1)
display.show()
z.buzzer.play(">g8>>c8")
z.button.waitForButton()
time.sleep(1)
z.ir_calibration( motors=True )
z.buzzer.play(">g8>>c8")
display.fill(0)
display.show()
try:
wdt = WDT( timeout = 500 ) # 300ms before reset
while(True):
wdt.feed()
position = z.ir.readLineBlack()
error = position -2500
speed_diff = (error/4) + (6*(error-last_error))
last_error = error
m1Speed = MAX_SPEED+speed_diff
m2Speed = MAX_SPEED-speed_diff
m1Speed = clamp( m1Speed, 0, MAX_SPEED )
m2Speed = clamp( m2Speed, 0, MAX_SPEED )
z.motors.setSpeeds(m1Speed,m2Speed)
finally:
z.motors.stop()
Si cela vous intéresse, les fichiers 3D (pare-chocs et support d’afficheur OLED 0,96 ») sont disponibles sur Printables.
L’Arduino caché
Si nous retournons l’adaptateur Pico-Zumo, que voyons nous ?
Mais oui, c’est un Arduino !!!
Un Arduino sous MicroPython, équipé du microcontrôleur RP2040 et compatible avec les cartes d’extension au format de l’Arduino Uno.
Voilà qui ouvre de nouvelles perspectives, alors je compte sur vous pour tester d’autres shields…
Un petit scoop pour finir
Ne le répétez à personne, mais il n’est pas impossible que Dominique travaille déjà sur une carte d’extension qui se fixerait au dessus de l’adaptateur (bien sûr, je vous en reparlerai le moment venu). Mais chut !!! Pour l’instant…
Conclusion
J’aurais préféré que le Raspberry Pi Pico ne soit pas soudé à la carte. Comme ça on aurait pu en mettre un autre (W ou une future version). Mais c’est vraiment un petit détail.
Pour tout le reste, je dirai : Bravo Dominique et MERCI, pour ton investissement dans la promotion du langage MicroPython, pour ta contribution au monde du libre, pour cet excellent livre que tu nous offres, pour ta patience et ta disponibilité (lors de nos échanges par mail) et bien sûr pour cet adaptateur qui est finalement un super Arduino.
Alors si vous voulez soutenir son travail, n’hésitez pas à faire de temps en temps vos courses dans sa boutique.
arduiblog 