Robot quadrupède à base de Raspberry Pi Pico (MicroPython)

Au début du mois, je vous ai présenté un robot quadrupède très facile à fabriquer qui comportait deux servomoteurs branchés à un Arduino Uno. Je vous présente aujourd'hui le même robot, dans lequel j'ai remplacé l'Arduino par un Raspberry Pi Pico programmé en MicroPython.

Dans un premier temps, voici une courte vidéo qui montre le robot en mouvement.

Fabrication du robot

J'ai fabriqué le robot en utilisant du carton et quelques bâtonnets de bois, assemblés avec de la colle et du ruban gommé.

Pour que le robot puisse avancer, il est important que les deux servomoteurs soient inclinés par rapport à l'horizontale, d'où la forme triangulaire du châssis du robot.

Connexions des servomoteurs au Rasbperry Pi Pico

Chaque servomoteur est alimenté par une tension continue de 5 V (broche Vbus du Raspberry Pi Pico).

Servomoteur avant: 

• fil jaune: broche GP15 du Raspberry Pi Pico
• fil rouge: broche Vbus du Raspberry Pi Pico
• fil brun: broche GND du Raspberry Pi Pico

Servomoteur arrière: 

• fil jaune: broche GP13 du Raspberry Pi Pico
• fil rouge: broche Vbus du Raspberry Pi Pico
• fil brun: broche GND du Raspberry Pi Pico

Script en MicroPython

Ce script fait avancer le robot de quelques pas vers l'avant, puis de quelques pas vers l'arrière. Vous devrez probablement ajuster les variables "pwm_avant" et "pwm_arriere": il s'agit de la durée de l'impulsion pour laquelle chaque servomoteur se trouve à sa positon moyenne  (la patte droite n'est alors ni en avant, ni en arrière par rapport à la patte gauche).

Il sera peut-être pertinent de modifier également le contenu de la variable "pas": si vous l'augmentez, le robot fera de plus grandes enjambées (ainsi, il marchera peut-être un peu plus vite, à moins qu'il ne perde l'équilibre...). 

-

	'''
	Robot quadrupède à 2 servomoteurs, version Raspberry Pi Pico
	Plus d'informations:
	https://electroniqueamateur.blogspot.com/2021/06/robot-quadrupede-base-de-raspberry-pi.html
	'''
	import machine
	import utime
	pwm_avant = 4800 # position centrale du servomoteur avant
	pwm_arriere = 4600 # position centrale du servomoteur arriere
	pas = 600 # augmenter pour de plus grands pas
	# les 4 phases de la marche avant
	marche_avant = [pwm_avant - pas , pwm_arriere + pas, pwm_avant + pas, pwm_arriere + pas,
	pwm_avant + pas, pwm_arriere - pas, pwm_avant - pas, pwm_arriere - pas ]
	# les 4 phases de la marche arrière
	marche_arriere = [pwm_avant - pas , pwm_arriere - pas, pwm_avant + pas, pwm_arriere - pas,
	pwm_avant + pas, pwm_arriere + pas, pwm_avant - pas, pwm_arriere + pas ]
	servo_avant = machine.PWM(machine.Pin(15))
	servo_avant.freq(50)
	servo_arriere = machine.PWM(machine.Pin(13))
	servo_arriere.freq(50)
	while True:
	# marche avant
	for i in range (10):
	for n in range(4):
	servo_avant.duty_u16(marche_avant[2*n])
	servo_arriere.duty_u16(marche_avant[(2*n) + 1])
	utime.sleep(.3)
	# marche arrière
	for i in range (10):
	for n in range(4):
	servo_avant.duty_u16(marche_arriere[2*n])
	servo_arriere.duty_u16(marche_arriere[(2*n) + 1])
	utime.sleep(.3)

view raw RP_Pico_quadrupede.py hosted with ❤ by GitHub

-

À lire également

• La version Arduino du même robot
• Les autres projets de robotique
• Programmer le Raspberry Pi Pico en MicroPython avec Thonny

Yves Pelletier (Facebook)

Utilisation d'un écran tactile TFT SPI 240 X 320 (ILI9341) avec le Raspberry Pi Pico

Nous allons maintenant brancher un Raspberry Pi Pico à un écran tactile SPI 240 X 320 muni d'un contrôleur ILI9341 (pour l'affichage) et d'un contrôleur XPT2046 (capteur tactile). Le Raspberry Pi Pico sera programmé en MicroPython.

Connexions de l'écran au Raspberry Pi Pico

Le module comporte un total de 18 broches:

• 2 broches pour l'alimentation (VCC et GND)
• 7 broches pour l'affichage
• 5 broches pour le capteur tactile (celles dont le nom débute par "T_")
• De l'autre côté de la carte, 4 broches pour le lecteur de carte SD (que je n'ai pas utilisé)

Il serait tout à fait acceptable de brancher l'afficheur et le capteur tactile (XPT2046) sur le même bus SPI. Toutefois, l'auteur de la bibliothèque que nous allons utiliser fait remarquer que l'affichage supporte une vitesse de communication beaucoup plus rapide que le capteur tactile. Pour cette raison, il suggère de brancher l'afficheur et le capteur tactile sur deux bus SPI différents, et c'est ce que j'ai fait (affichage sur le bus SPI0 et détection du touché sur le bus SPI1).

Ça représente beaucoup de fils à connecter... De gauche à droite sur l'écran du schéma ci-dessous:

• Broche T_IRQ de l'écran : Broche GP2 du RP Pico
• Broche T_DO de l'écran: Broche GP8 du RP Pico
• Broche T_DIN de l'écran: Broche GP11 du RP Pico
• Broche T_CS de l'écran: Broche GP12 du RP Pico
• Broche T_CLK de l'écran: Broche GP10 du RP Pico
• Broche SDO (MISO) de l'écran: Broche GP4 du RP Pico (probablement pas nécessaire)
• Broche LED de l'écran: Sortie 3,3 V du RP Pico
• Broche SCK de l'écran: Broche GP6 du RP Pico
• Broche SDI (MOSI) de l'écran: Broche GP7 du RP Pico
• Broche DC de l'écran: Broche GP13 du RP Pico
• Broche RESET de l'écran: Broche GP14 du RP Pico
• Broche CS de l'écran: Broche GP15 du RP Pico
• Broche GND de l'écran: Broche GND du RP Pico
• Broche VCC de l'écran: Sortie 3,3 V du RP Pico

Installation des bibliothèques

J'ai utilisé les bibliothèques MicroPython offertes par rdagger.

Pour que les scripts que je présente plus loin dans cet article fonctionnent correctement, tous les fichiers suivants doivent être copiés dans le Raspberry Pi Pico:

• ili9341.py (gestion de l'affichage)
• xpt2046.py (gestion du capteur tactile)
• xglcd_font.py (pour affichage de texte)
• Unispace12x24.c, à l'intérieur du répertoire "fonts"

Le dépôt github présente une bonne quantité de scripts en MicroPython qui montrent comment afficher du texte, des formes géométriques, des images et des animations sur l'écran (il s'agit des 11 fichiers dont le titre débute par "demo").  Mais puisqu'il n'y a aucun exemple simple montrant comment utiliser la bibliothèque xpt2046.py, c'est sur cet aspect que je vais insister.

Routine de calibration

Lorsqu'on touche l'écran, le capteur tactile envoie au Raspberry Pi Pico deux valeurs qui sont proportionnelles à la position (horizontale et verticale) qui a été touchée.  Ces valeurs brutes doivent toutefois être transformées si on désire qu'elles correspondent aux coordonnées des pixels sur l'écran.

Pour compliquer les choses, les valeurs générées ne sont pas identiques d'un écran à l'autre. Pour cette raison, il est utile d'exécuter une routine comme celle qui est présentée ci-dessous, afin de connaître les valeurs propres à l'écran que nous utilisons.

Le script ci-dessous invite l'utilisateur à toucher tour à tour chacun des 4 coins de l'écran.

Lorsque c'est terminé, les valeurs extrêmes sont affichées:

• x_min (coordonnée x lorsqu'on touche le bord gauche de l'écran)
• x_max (coordonnée x lorsqu'on touche le bord droit de l'écran)
• y_min (coordonnée y lorsqu'on touche le haut de l'écran)
• y_max (coordonnée y lorsqu'on touche le bas de l'écran)

Ces informations peuvent être entrées dans nos scripts afin que les coordonnées de la position touchée correspondent aux coordonnées du pixel correspondant sur l'écran.

-

	'''
	Routine de calibration d'un écran tactile
	ILI9341 branché à un Raspberry Pi Pico.
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2021/06/utilisation-dun-ecran-tactile-tft-spi.html
	'''
	from machine import Pin, SPI
	import ili9341
	from xglcd_font import XglcdFont
	from xpt2046 import Touch
	minX = maxX = minY = maxY = 500
	def dessine_fleche(etape):
	if (etape == 1): # coin supérieur gauche
	display.draw_line(0, 0, 40, 40, ili9341.color565(255, 255, 255))
	display.draw_line(0, 0, 0, 20, ili9341.color565(255, 255, 255))
	display.draw_line(0, 0, 20, 0, ili9341.color565(255, 255, 255))
	if (etape == 2): # coin supérieur droit
	display.draw_line(239, 0, 199, 40, ili9341.color565(255, 255, 255))
	display.draw_line(239, 0, 239, 20, ili9341.color565(255, 255, 255))
	display.draw_line(239, 0, 219, 0, ili9341.color565(255, 255, 255))
	if (etape == 3): # coin inférieur gauche
	display.draw_line(0, 319, 40, 279, ili9341.color565(255, 255, 255))
	display.draw_line(0, 319, 0, 299, ili9341.color565(255, 255, 255))
	display.draw_line(0, 319, 20, 319, ili9341.color565(255, 255, 255))
	if (etape == 4): # coin inférieur droit
	display.draw_line(239, 319, 199, 279, ili9341.color565(255, 255, 255))
	display.draw_line(239, 319, 239, 299, ili9341.color565(255, 255, 255))
	display.draw_line(239, 319, 219, 319, ili9341.color565(255, 255, 255))
	def routine_touch(x, y):
	global minX, maxX, minY, maxY
	global etape
	if (etape < 6):
	# obtention des valeurs brutes
	rawX = xptTouch.send_command(xptTouch.GET_X)
	rawY = xptTouch.send_command(xptTouch.GET_Y)
	if rawX != 0:
	if rawX > maxX:
	maxX = rawX
	elif rawX < minX:
	minX = rawX
	if rawY != 0:
	if rawY > maxY:
	maxY = rawY
	elif rawY < minY:
	minY = rawY
	if etape < 5:
	print("Etape " + str(etape) + " : " + str(rawX) + "," + str(rawY))
	etape = etape + 1
	#effacage de toutes les fleches
	display.fill_rectangle(0, 0, 41, 41, ili9341.color565(0, 0, 0))
	display.fill_rectangle(199, 0, 41, 41, ili9341.color565(0, 0, 0))
	display.fill_rectangle(0, 279, 41, 41, ili9341.color565(0, 0, 0))
	display.fill_rectangle(199, 279, 41, 41, ili9341.color565(0, 0, 0))
	if etape < 5:
	dessine_fleche(etape)
	if etape == 5:
	print("x_min: " + str(minX) + " , " + "x_max: " + str(maxX) + " , " +
	"y_min: " + str(minY) + " , " + "y_max: " + str(maxY))
	display.fill_rectangle(0, 0, 240, 320, ili9341.color565(0, 0, 0))
	display.draw_text(20, 100, "x_min: " + str(minX), unispace,
	ili9341.color565(255, 255, 255))
	display.draw_text(20, 130, "x_max: " + str(maxX), unispace,
	ili9341.color565(255, 255, 255))
	display.draw_text(20, 160, "y_min: " + str(minY), unispace,
	ili9341.color565(255, 255, 255))
	display.draw_text(20, 190, "y_max: " + str(maxY), unispace,
	ili9341.color565(255, 255, 255))
	# initialisation de l'affichage
	spiTFT = SPI(0, baudrate=40000000, sck=Pin(6), mosi=Pin(7))
	display = ili9341.Display(spiTFT, dc=Pin(13), cs=Pin(15), rst=Pin(14))
	#initialisation du capteur tactile
	spiXPT = SPI(1, baudrate=1000000,sck=Pin(10), mosi=Pin(11), miso=Pin(8))
	xptTouch = Touch(spiXPT, cs=Pin(12), int_pin=Pin(2),
	int_handler=routine_touch,
	x_min=0, x_max=2200, y_min=0, y_max=2200)
	# chargement de la police de caractères
	unispace = XglcdFont('fonts/Unispace12x24.c', 12, 24)
	# instructions à l'écran
	display.draw_text(30, 130, 'Touchez le bout', unispace,
	ili9341.color565(255, 255, 255))
	display.draw_text(50, 160, 'de la fleche', unispace,
	ili9341.color565(255, 255, 255))
	etape = 1
	dessine_fleche(etape)
	while True:
	pass

view raw RP_Pico_ILI9341_calibration.py hosted with ❤ by GitHub

-

Vérification de la calibration

Voici maintenant un script minimaliste qui permet de vérifier rapidement la qualité de la calibration: avant de l'utiliser, c'est important de modifier le contenu de la ligne 29 pour qu'il corresponde aux valeurs trouvées au moyen du script de calibration.

Lorsque vous exécutez ce script, un point blanc est tracé chaque fois que vous touchez l'écran. Si la calibration est correcte, le point devrait se tracer à la position touchée.

-

	'''
	Vérification de la calibration d'un écran
	tactile ILI9341 branché à un Raspberry Pi Pico.
	Un point est tracé là où on touche l'écran.
	Plus d'infos:
	https://electroniqueamateur.blogspot.com/2021/06/utilisation-dun-ecran-tactile-tft-spi.html
	'''
	from machine import Pin, SPI
	import ili9341
	from xglcd_font import XglcdFont
	from xpt2046 import Touch
	# routine exécutée lorsqu'on touche l'écran
	def routine_touch(x, y):
	display.fill_circle(x, y, 2, ili9341.color565(255, 255, 255))
	# initialisation de l'affichage
	spiTFT = SPI(0, baudrate=40000000, sck=Pin(6), mosi=Pin(7))
	display = ili9341.Display(spiTFT, dc=Pin(13), cs=Pin(15), rst=Pin(14))
	# initialisation du capteur tactiel
	spiXPT = SPI(1, baudrate=1000000,sck=Pin(10), mosi=Pin(11), miso=Pin(8))
	# il est important d'écrire les valeurs de x_min, x_max, y_min et y_max obtenues
	# grâce au script calibration.py:
	xptTouch = Touch(spiXPT, cs=Pin(12), int_pin=Pin(2),
	int_handler=routine_touch,
	x_min=128, x_max=1919, y_min=224, y_max=1963)
	# chargement de la police de caractères
	unispace = XglcdFont('fonts/Unispace12x24.c', 12, 24)
	# instructions à l'écran
	display.draw_text(30, 150, "Touchez l'ecran", unispace,
	ili9341.color565(255, 255, 255))
	while True:
	pass

view raw RP_Pico_ILI9341_verification.py hosted with ❤ by GitHub

-

Script: un exemple avec des boutons

Voici finalement un exemple dans lequel deux boutons apparaissent à l'écran. Lorsqu'on touche le bouton de gauche, un cercle vert est affichée, alors que c'est un rectangle rouge qui s'affiche lorsqu'on clique sur le bouton de droite. Encore une fois, pour que ça fonctionne bien, c'est important d'écrire vos paramètres de calibration à la ligne 68 du script.

-

	'''
	Exemple d'utilisation de l'écran tactile ILI9341
	avec un Raspberry Pi Pico.
	Des boutons à l'écran peuvent être touchés pour
	afficher des formes géométriques.
	Plus d'informations:
	https://electroniqueamateur.blogspot.com/2021/06/utilisation-dun-ecran-tactile-tft-spi.html
	'''
	from machine import Pin, SPI
	# Pour les 3 fichiers ci-dessous:
	# https://github.com/rdagger/micropython-ili9341
	import ili9341
	from xglcd_font import XglcdFont
	from xpt2046 import Touch
	# définition de quelques couleurs
	rouge = ili9341.color565(255, 0, 0)
	vert = ili9341.color565(0,255, 0)
	bleu = ili9341.color565(0,0, 255)
	blanc = ili9341.color565(255, 255, 255)
	noir = ili9341.color565(0,0,0)
	# position des boutons
	bouton1 = (20, 170, 120, 40) # x, y, largeur, hauteur
	bouton2 = (175, 170, 120, 40)
	# c'est la routine qui est déclanchée lorsque l'écran
	# envoie un signal sur la broche "interrupt"
	def routine_touch(x, y):
	# inversion des coordonnées x et y (car mode paysage)
	x, y = y, x
	y = 240 - y
	# a-t-on cliqué sur le premier bouton?
	if ((x > bouton1[0]) and (x < bouton1[0] + bouton1[2])
	and (y > bouton1[1]) and (y < bouton1[1] + bouton1[3])):
	# on efface le dessin précédent
	display.fill_rectangle(0, 0, 320, 150, noir)
	# on affiche le dessin choisi
	display.fill_circle(160, 80, 60, vert)
	# a-t-on cliqué sur le deuxième bouton?
	if ((x > bouton2[0]) and (x < bouton2[0] + bouton2[2])
	and (y > bouton2[1]) and (y < bouton2[1] + bouton2[3])):
	# on efface le dessin précédent
	display.fill_rectangle(0, 0, 320, 150, noir)
	# on affiche le dessin choisi
	display.fill_rectangle(60, 40, 200, 100, rouge)
	# initialisation de l'affichage en mode paysage (rotation 90)
	spiTFT = SPI(0, baudrate=40000000, sck=Pin(6), mosi=Pin(7))
	display = ili9341.Display(spiTFT, dc=Pin(13), cs=Pin(15), rst=Pin(14),
	width=320, height=240, rotation = 90)
	spiXPT = SPI(1, baudrate=1000000,sck=Pin(10), mosi=Pin(11), miso=Pin(8))
	#initialisation du capteur tactile
	xptTouch = Touch(spiXPT, cs=Pin(12), int_pin=Pin(2),
	int_handler = routine_touch,
	x_min=128, x_max=1919, y_min=224, y_max=1963)
	# (x_min, x_max, y_min et y_max sont les valeurs ajustées pour mon écran)
	# chargement de la police de caractère
	unispace = XglcdFont('fonts/Unispace12x24.c', 12, 24)
	# Affichage du message initial
	display.draw_text(0, 50, 'Veuillez faire votre choix', unispace,
	ili9341.color565(255, 128, 0))
	#dessin du premier bouton
	display.fill_rectangle(bouton1[0], bouton1[1], bouton1[2], bouton1[3], rouge)
	display.draw_rectangle(bouton1[0], bouton1[1], bouton1[2], bouton1[3], blanc)
	display.draw_text(bouton1[0]+20, bouton1[1]+6, 'Cercle', unispace, blanc,rouge)
	#dessin du deuxième bouton
	display.fill_rectangle(bouton2[0], bouton2[1], bouton2[2], bouton2[3], bleu)
	display.draw_rectangle(bouton2[0], bouton2[1], bouton2[2], bouton2[3], blanc)
	display.draw_text(bouton2[0]+4, bouton2[1]+6, 'Rectangle', unispace, blanc,bleu)
	while True:
	pass

view raw RP_Pico_ILI9341_boutons.py hosted with ❤ by GitHub

-

À lire également

Le même écran tactile peut être utilisé avec un ESP32, un ESP8266 ou une STM32 Blue Pill (toutes ces cartes ont été programmées avec l'IDE Arduino).

D'autre part, nous avons déjà exploré l'utilisation d'autres afficheurs avec le Raspberry Pi Pico programmé en MicroPython: 

• écran OLED SH1106
• écran couleur SPI ST7735
• afficheur LCD 16 X 2 
• afficheur TM1638

Yves Pelletier (Facebook)

Mesurer la pression atmosphérique et la température avec le BMP180 et le Raspberry Pi Pico

Dans cet article, nous mesurons la pression atmosphérique et la température au moyen d'un module BMP180 relié à un Raspberry Pi Pico programmé en MicroPython.

Avant d'aller plus loin, j'aimerais vous faire remarquer que le BMP180 est plutôt désuet, comme capteur. Il n'est plus fabriqué par Bosch, et les modules BMP180 qui avaient été mis au point par Adafruit et Sparkfun ne sont plus commercialisés. Mais mon module BMP180 fonctionne très bien, et je ne vois donc aucune raison de le remplacer par autre chose.

Connexions

Puisque le BMP180 utilise le bus I2C, 4 fils sont suffisants pour connecter le module au Raspberry Pi Pico:

• Broche VIN du module BMP180 : Sortie 3,3 V du Raspberry Pi Pico
• Broche GND du module BMP180: Broche GND du Raspberry Pi Pico
• Broche SCL du module BMP180: Broche GP9 du Rasbperry Pi Pico
• Broche SDA du module BMP180: Broche GP8 du Raspberry Pi Pico

Installation du pilote MicroPython

J'ai utilisé ce pilote MicroPython bmp180.py. Si vous tentez de l'utiliser tel quel, toutefois, vous obtiendrez probablement le message d'erreur "OSError: I2C operation not supported".

Le problème réside dans la ligne 47 du fichier bmp180.py: la méthode I2C.start() n'est pas supportée par MicroPython sur Raspberry Pi Pico. La bonne nouvelle, c'est que tout semble fonctionner correctement si vous commentez ou effacez le contenu de la ligne 47 ("self._bmp_i2c.start()"):

Après avoir modifié le fichier bmp180.py, il est important de le copier à l'intérieur du Raspberry Pi Pico.

Script

Voici un script assez minimaliste qui affiche à chaque seconde la température (en degrés Celsius) et la pression (en kilopascals). 

-

	'''
	Lecture de la température et de la pression atmosphérique
	avec un capteur BMP180 branché à un Raspberry Pi Pico.
	Pour plus d'infos:
	https://electroniqueamateur.blogspot.com/2021/06/mesurer-la-pression-atmospherique-et-la.html
	'''
	from bmp180 import BMP180
	# https://github.com/micropython-IMU/micropython-bmp180
	from machine import I2C, Pin
	from utime import sleep
	i2c = I2C(0, scl=Pin(9), sda=Pin(8), freq=200000)
	bmp180 = BMP180(i2c)
	while True:
	temperature = bmp180.temperature
	pression = bmp180.pressure/1000.0
	print("Temperature: {:.1f} °C Pression: {:.1f} kPa"
	.format(temperature , pression))
	sleep(1)

view raw RP_pico_BMP180.py hosted with ❤ by GitHub

-

À lire également

• Utilisation de Thonny pour programmer le Raspberry Pi Pico en MicroPython

• La température et la pression pourraient être affichées sur un écran OLED SH1106, sur un écran couleur ST7735, sur un afficheur LCD 16 X 2 ou sur un afficheur TM1638.

• Pour transformer votre Raspberry Pi Pico en station météorologique, vous pouvez ajouter un DHT22 qui mesure, en plus de la température, l'humidité relative.

• Le module BMP180 a également été utilisé avec un Arduino, un Raspberry Pi et un micro:bit. On peut l'utiliser pour mesurer la pression dans un liquide ou comme capteur principal d'une flûte à bec MIDI.

Yves Pelletier (Facebook)

Mesurer la température et l'humidité relative avec un DHT22 (AM2302) et un Raspberry Pi Pico

Le capteur DHT22 (également connu sous l'appellation AM2302) est conçu pour mesurer la température ambiante ainsi que l'humidité relative de l'air. Dans cet article, nous le branchons à un Raspberry Pi Pico programmé en MicroPython. Pendant que nous y sommes, nous en profiterons pour calculer le point de rosée et l'indice humidex.

Connexions

J'ai utilisé un module prêt à l'emploi qui comporte, en plus du capteur, une résistance et un condensateur.

Ce module ne comporte que 3 connecteurs: + et - pour l'alimentation, et OUT pour la transmission du signal.

• Broche + du DHT22: sortie 3,3 V du Raspberry Pi Pico
• Broche OUT du DHT22: broche GP15 du Raspberry Pi Pico
• Broche - du DHT22: broche GND du Raspberry Pi Pico

Installation du pilote DHT22

Daniel Perron a publié un pilote MicroPython pour le DHT22 qui utilise de façon très efficace la fonctionnalité PIO (programmable input/output) du Raspberry Pi Pico. 

Le fichier "DHT22.py" doit être installé dans le Raspberry Pi Pico.

Script

Voici un exemple qui affiche à chaque seconde le résultat de la mesure de température et d'humidité. J'ai ajouté le calcul du point de rosée et de l'humidex.

-

	'''
	Lecture d'un capteur de température/humidité DHT22
	avec un Raspberry Pi Pico.
	Calcul du point de rosée et de l'humidex.
	Pour plus d'informations:
	https://electroniqueamateur.blogspot.com/2021/06/mesurer-la-temperature-et-lhumidite.html
	'''
	from machine import Pin
	from DHT22 import DHT22 #https://github.com/danjperron/PicoDHT22
	import time
	import math
	time.sleep_ms(1000) # on laisse le capteur se stabiliser
	dht22 = DHT22(Pin(15,Pin.IN,Pin.PULL_UP)) # initialisation du DHT22 (broche 15)
	while True:
	# mesure de la température et de l'humidité
	temperature, humidite = dht22.read()
	# calcul du point de rosée (formule de Heinrich Gustav Magnus-Tetens)
	alpha = math.log(humidite / 100.0) + (17.27 * temperature) / (237.3 + temperature)
	rosee = (237.3 * alpha) / (17.27 - alpha)
	#calcul de l'humidex
	humidex = temperature + 0.5555 * (6.11 * math.exp(5417.753 * (1 / 273.16 - 1 / (273.15 + rosee))) - 10)
	print("Temperature: {:.1f} °C Humidite: {:.1f} % Rosee: {:.1f} °C Humidex: {:.1f}"
	.format(temperature , humidite, rosee , humidex))
	time.sleep_ms(1000)

view raw RP_pico_DHT22.py hosted with ❤ by GitHub

-

Point de rosée et indice humidex

Connaissant la température et l'humidité relative, la formule de Heinrich Gustav Magnus-Tetens permet de calculer le point de rosée (il s'agit de la température sous laquelle la vapeur d'eau contenue dans l'air se condense sur les surfaces):

Dans le script, j'ai calculé α(T,RH) à la ligne 26, puis je l'ai utilisée à la ligne 49 pour le calcul du point de rosée (ligne 27).

Finalement, j'ai calculé l'indice humidex (ligne 30) grâce à l'équation mise au point par Masterton et Richardson:

À lire également

• Le capteur DHT22 a aussi été utilisé avec un Arduino et un Raspberry Pi.

• En ce qui concerne le Raspberry Pi Pico, d'autres articles montrent comment programmer le Raspberry Pi Pico en MicroPython, contrôler un servomoteur, mesurer une distance avec le HC-SR04 , communiquer en Bluetooth avec le HC06, lire un tag RFID avec un module RC522 et utiliser quelques modèles d'afficheurs: écran OLED SH1106, écran couleur SPI ST7735, afficheur LCD 16 X 2 et afficheur TM1638.

• De façon plus particulière, si vous désirez fabriquer une mini station météo avec votre Raspberry Pi Pico, l'ajout d'un BMP180 vous permettrait de mesurer également la pression atmosphérique.

Yves Pelletier (Facebook)

Robot quadrupède à 2 servomoteurs (Arduino)

Je vous présente aujourd'hui un robot quadrupède peu coûteux et très facile à fabriquer.  Il est constitué de deux servomoteurs: un premier servomoteur qui contrôle la paire de pattes avant, et un deuxième servomoteur qui contrôle la paire de pattes arrière. Pour que le robot puisse avancer, il est très important que les servomoteurs soient légèrement inclinés (les pattes ne sont donc pas parfaitement perpendiculaires au sol).

Avant d'aller plus loin, observons le robot en mouvement (il se déplace d'abord vers l'avant, puis ensuite vers l'arrière):

Fabrication du robot

J'ai fabriqué la structure mécanique de mon robot avec du carton, quelques baguettes de bois, un peu de colle et du ruban gommé.

Pour les pattes, j'ai utilisé quatre segments de crayons. Les crayons sont assemblées par paires, collés à chaque extrémité d'une tige de bois. 

Un palonnier de servomoteur est fixé sur la tige de bois, à mi-chemin entre les deux pattes (contrairement à ce que suggère la photo, c'est préférable de visser le palonnier au servomoteur avant de le fixer à la tige de bois).

Pour le châssis, j'ai découpé un rectangle dans du carton ondulé. ainsi que deux triangles pour les côtés. Deux petites ouvertures rectangulaires sont juste assez grandes pour qu'on puisse y insérer les servomoteurs.

On assemble le tout en ne lésinant pas sur le ruban gommé...

J'ai ajouté un peu de ruban gommé sur le bout des pattes pour les rendre plus adhérentes.

Circuit

J'ai fait mes tests avec une carte Arduino Uno mais, puisqu'il s'agit de contrôler deux servomoteurs, n'importe quel microcontrôleur pourvu de 2 sorties PWM fera l'affaire. Si votre robot est de petite taille, vous préférerez peut-être une carte de plus petite dimension comme l'Arduino Nano ou la STM32 Bluepill. Si vous optez pour l'ESP8266 ou l'ESP32, vous ajoutez la possibilité de contrôler votre robot via le réseau WiFi.

Sans surprise, chaque servomoteur est alimenté par une tension de 5 V, et contrôlé par une broche PWM (en l'occurrence les broches 9 et 10).

Installation de la bibliothèque Servo

Si ce n'est pas déjà fait, on installe la bibliothèque Servo au moyen du gestionnaire de bibliothèque.

Sketch

Voici le sketch utilisé: le robot marche un certain temps vers l'avant, puis ensuite vers l'arrière.

-

	/*
	Robot quadrupède à 2 servomoteurs
	Pour plus d'infos:
	https://electroniqueamateur.blogspot.com/2021/06/robot-quadrupede-2-servomoteurs-arduino.html
	*/
	// bibliothèque servo
	#include <Servo.h>
	// numéro des broches utilisées (doivent être des sorties PWM)
	#define pin_servo_avant 9
	#define pin_servo_arriere 10
	// angle de rotation des servos par rapport à leur position d'équilibre
	// (vous l'augmentez pour faire de plus grands pas)
	#define angle_rotation 20
	//position d'équilibre des servos, en degrés
	#define angle_avant 90
	#define angle_arriere 90
	// création de deux objets servo
	Servo servo_avant, servo_arriere;
	// les 4 phases de la marche avant
	char marche_avant[] = {angle_avant - angle_rotation, angle_arriere + angle_rotation,
	angle_avant + angle_rotation, angle_arriere + angle_rotation,
	angle_avant + angle_rotation, angle_arriere - angle_rotation,
	angle_avant - angle_rotation, angle_arriere - angle_rotation
	};
	// les 4 phases de la marche arrière
	char marche_arriere[] = {angle_avant - angle_rotation, angle_arriere - angle_rotation,
	angle_avant + angle_rotation, angle_arriere - angle_rotation,
	angle_avant + angle_rotation, angle_arriere + angle_rotation,
	angle_avant - angle_rotation, angle_arriere + angle_rotation
	};
	void setup()
	{
	servo_avant.attach(pin_servo_avant);
	servo_arriere.attach(pin_servo_arriere);
	}
	void loop()
	{
	// on avance (10 cycles):
	for (int i = 0; i < 10; i++) {
	for (int n = 0; n < 4; n++) {
	servo_avant.write(marche_avant[2 * n]);
	servo_arriere.write(marche_avant[(2 * n) + 1]);
	delay(300);
	}
	}
	// on recule (10 cycles):
	for (int i = 0; i < 10; i++) {
	for (int n = 0; n < 4; n++) {
	servo_avant.write(marche_arriere[2 * n]);
	servo_arriere.write(marche_arriere[(2 * n) + 1]);
	delay(300);
	}
	}
	}

view raw robot_quadrupede.ino hosted with ❤ by GitHub

-

Les 4 phases du mouvement

La marche du robot s'effectue en 4 phases; à chaque phase, un seul des deux servomoteurs change de position:

Phase 1:  servo avant à 70°, servo arrière à 110°

Phase 2: servo avant à 110°, servo arrière à 110°

Phase 3: servo avant à 110°, servo arrière à 70°

Phase 4: servo avant à 70°, servo arrière à 70°

Sources

Ce robot est fortement inspiré de celui qui avait été présenté par Vinod sur son blog Electronics the King of Hobbies. J'ai été intrigué par la simplicité du robot, tout en regrettant que Vinod ait utilisé une carte MSP430 Launchpad programmée...en assembleur!

Le même principe a été utilisé par Edwindertien pour son robot SimpleWalker. Si vous disposez de la machinerie nécessaire, vous serez certainement intéressés par ses plans détaillés (il a fait un robot en contreplaqué et un autre en acrylique). Son sketch Arduino a servi de point de départ à mon propre sketch.

À lire également

• Avec du matériel similaire, vous pouvez fabriquer un robot qui dessine
• Mes autres projets de robotique

Yves Pelletier (Facebook)