Découvrez nos
ressources

Programmation Python : prise en main de l'ultrason et de la caméra pour programmer des déplacements autonomes du robot puis organiser une course de robots.

‍

[Contenu vidéo à venir]

‍

‍

Introduction

Le but de ce TP est de programmer AlphAI pour qu’il se déplace de manière autonome et non plus en mode « télécommandé » par l’élève comme dans le TP « AlphAI télécommandé ». Pour cela il faudra utiliser ses capteurs pour qu’il puisse réagir à son environnement, notamment pour détecter des obstacles. 

Nous allons voir un exemple rapide avec l’ultrason, puis passerons à la caméra pour organiser des courses de robots autonomes dans un circuit.

‍

‍

Navigation avec l’ultrason

Découverte du capteur ultrason

La fonction get_distance() (détails dans l’API en dernière page) renvoie la distance mesurée par l’ultrason du robot (en centimètres). Attention à bien activer le capteur avec la fonction set_distance(True) ou elle ne renverra pas une distance mais la valeur None.

Testez cette fonction avec le vrai robot avec le code suivant :

set_distance(True)  # active le capteur à ultrasons
while True:
    d = get_distance()  # récupère la valeur des ultrasons du robot
    print("distance:", d)

En déplaçant le robot à la main, vérifiez que la distance mesurée diminue lorsque le robot est face à un obstacle. Vous pourrez aussi remarquer que malheureusement si le robot est devant un mur, non pas pile en face de lui, mais en diagonale, ce mur n’est pas détecté (la distance mesurée est beaucoup plus grande car les ultrasons se reflètent sur le mur en diagonale sans revenir directement vers le robot).

Déplacement autonome avec l’ultrason

A l’aide de la fonction get_distance(), définissez puis testez une fonction ultrasound_race() qui fait avancer le robot tant qu’il ne perçoit pas d’obstacle avec son ultrason, et pivote à droite lorsqu’il détecte un obstacle. 

Ne cherchez pas à avoir un comportement parfait (ce serait difficile), dès que vous avez un comportement où le robot sait tourner s’il est face à un mur et aller tout droit s’il n’y a pas de mur, passez à la suite.

‍

‍

Navigation avec la caméra

La caméra apporte une information beaucoup plus riche que le capteur de distance ultrason, et permettra de prendre des décisions plus sophistiquées.

Découverte de l’image caméra

Commençons par afficher l’image de la caméra du robot dans le logiciel. Ouvrez l’onglet de paramètres « Capteurs » à gauche, et choisissez le mode de caméra « image 64x48 »

: l’image de ce que voit le robot apparaît. 

Une image est une grille de pixels ; dans une image couleur comme c’est le cas ici, chaque pixel contient 3 valeurs : les intensités de rouge, vert et bleu dans ce pixel. Pour voir cela de manière plus précise, choisissez à présent le mode de caméra avec la résolution faible « image 8x6 »

, et dans l’onglet « Visualisation » cochez « Caméra : résolution dégradée »

: une image très grossière apparaît, et les valeurs rouge/vert/bleu de chaque pixels sont affichées (valeurs entre 0 et 255). 

Pour régler la résolution d’image dans le code Python plutôt que dans le logiciel, il faut commencer par initialiser la caméra, par exemple set_camera("8x6"). Ensuite on récupère l’image avec get_camera(). Cette fonction renvoie un tableau de dimension 3 sous la forme d’un objet « List ». La seule chose à savoir pour ce TP à propos de cet objet est comment accéder aux valeurs des pixels : Si on appelle image cet objet renvoyé, on accède à la valeur du pixel de la ligne i, colonne j et dans le canal k (k=0 pour rouge, 1 pour vert, 2 pour bleu) avec image[i][j][k].

Copiez et exécutez le code suivant, et vérifiez que les 3 valeurs affichées correspondent bien aux 3 valeurs rouge/vert/bleu dans le logiciel du pixel à la 5^ème ligne en partant du haut (indice 4 quand on commence à compter à zéro) et de la 4^ème colonne en partant de la gauche (indice 3).

from alphai import *

from time import sleep

set_camera("8x6")  # active la caméra à la bonne resolution

sleep(1)  # attend 1s que le logiciel active la caméra

while True:
    image = get_camera()  # récupère l’image de la caméra

    line = image[4]

    pixel = line[3]
    print('rouge', pixel[0], 'vert', pixel[1], 'bleu', pixel[2])

Premier déplacement autonome avec la caméra

Nous voulons que le robot effectue de manière autonome des tours de circuit. Si vous utilisez une arène fournie avec les robots AlphAI, le sol est blanc, l’enceinte extérieure est rouge, et l’ilôt central est noir. Nous supposerons que c’est le cas, et que vous voulez faire circuler le robot en tournant dans le sens des aiguilles d’une montre. 

Commencez par écrire une fonction camera_race() pour prendre les décisions répétitivement, de la manière suivante (qui se base uniquement sur la couleur d’un seul pixel dans la partie basse de l’image) :

Si image[4][3][0] < 100 (canal rouge sombre 🡪 le pixel est noir), pivoter à gauche à vitesse 25 pendant 0.5 seconde.

‍

Sinon, si image[4][3][1] < 100 (canal rouge lumineux et canal vert sombre 🡪 le pixel est rouge), pivoter à droite à vitesse 25 pendant 0.5 seconde.

Sinon (canaux rouge et vert lumineux 🡪 le pixel est blanc), aller tout droit à vitesse 40 pendant 0.5 seconde.

‍

Testez ce programme sur la piste.

‍

Pour rappel, la structure si, sinon si, sinon est de la forme suivante en Python :

if condition_1:

action_1()

elif condition_2:

action_2()

else:

action_3()

Compter les pixels de différentes couleurs

Vous avez probablement constaté que prendre des décisions à partir d’un seul pixel n’étaient pas toujours le mieux. Par exemple il peut arriver que le pixel de la 5^ème ligne / 4^ème colonne soit blanc donc le robot décide d’avancer, alors qu’il y a un mur sur le côté et qu’il devrait plutôt tourner.

Pour améliorer le programme, nous allons considérer tous les pixels de l’image de la caméra. Tout d’abord nous allons compter combien de pixels sont noirs, rouges et blancs. Ensuite la décision sera prise ainsi : si la majorité des pixels sont rouge, tourner à droite ; si la majorité des pixels sont sombres, tourner à gauche ; et sinon aller tout droit.

Pour compter le nombre de pixels d’une certaine couleur, réalisez une suite de boucles for pour chaque composante de l’image : les lignes et les colonnes puis comptez pour chaque pixel quelle est sa couleur à l’aide des valeurs de rouge, de vert et de bleu qui la compose. Vous pouvez vous inspirer des seuils précédemment trouvés afin de déterminer la couleur du pixel. Vous pouvez commencer à partir du code suivant ou trouver votre propre façon de faire, il en existe plusieurs ! 

def count_pixel_colors(image: list):

# créer dict ici

nombre_pxl_noir = 0

nombre_pxl_rouge = 0

nombre_pxl_blanc = 0

for i in range(len(image)):

ligne = image[i] 

for j in range(len(ligne)):

pixel = ligne[j]

canal_rouge = pixel[0]

canal_vert = pixel[1]

canal_bleu = pixel[2]

if ...

nombre_pxl_noir +=1

...

else:

...

return {"noir": nombre_pxl_noir, "rouge": nombre_pxl_rouge, "blanc": nombre_pxl_blanc}

Astuce Syntaxe Python pour les boucles for, au lieu d’utiliser des indices i et j pour accéder aux éléments d’un tableau, vous pouvez changer de syntaxe et écrire tout simplement :

for ligne in image:
for pixel in ligne:
rouge = pixel[0]
vert = pixel[1]
bleu = pixel[2]
…

Course de robots autonomes et poursuite des améliorations

A présent, vous pouvez commencer à organiser des courses entre vos robots. 

Celles-ci seront encore plus pimentées si vous continuez de chercher à améliorer votre programme en modifiant par exemple : les vitesses de déplacement, les seuils des couleurs, des actions supplémentaires (en plus du tournant en pivotant sur place, un virage en avançant vers l’avant), etc.

‍

‍

Bilan et retours d'expérience

‍

En programmation, la liste des fonctions accessibles d’un programme s’appelle API, pour Application Programming Interface, Interface de Programmation d’Application. Elle est utilisée par les programmeurs pour savoir comment interagir avec le programme. Vous trouverez l’API du module python alphai en suivant ce lien : https://drive.google.com/file/d/1C4ovPW_eH5KFz5Y9JvSrzLhtmdOpcp6-/view

‍

TP à télécharger (prof et élève)

Documentation de la bibliothèque alphai-api