Fabriquer un robot guidé par Lidar avec le GiggleBot : 8 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Dans ce tutoriel, nous faisons en sorte que le GiggleBot s'attaque aux difficultés d'un labyrinthe.

Nous montons un servo sur le GiggleBot sur lequel nous attachons un capteur de distance. Pendant la course, le servo va tourner d'avant en arrière afin que le capteur de distance puisse mesurer la distance jusqu'à chaque obstacle. Cela fonctionne un peu comme un capteur LIDAR qui est généralement beaucoup plus cher.

Dans le même temps, le GiggleBot envoie ces données à un micro:bit BBC distant qui affiche sur sa matrice de LED 5 par 5 sa position relative par rapport aux obstacles.

Votre travail consiste à pouvoir naviguer dans le GiggleBot uniquement en regardant ce qui est affiché sur l'autre micro:bit de la BBC. Pour contrôler le GiggleBot, les boutons de la télécommande BBC micro:bit sont utilisés.

Cela semble amusant! Allons-y, voulez-vous ?

Étape 1: Composants requis

Nous allons avoir besoin de:

1. Un GiggleBot.
2. Une batterie pour le BBC micro:bit. Il est livré avec un micro:bit BBC dans son emballage.
3. x3 piles AA pour le GiggleBot.
4. Un câble Grove pour connecter le capteur de distance au GiggleBot.
5. Un kit servo de DexterIndustries.
6. x3 BBC micro:bits. Un pour le GiggleBot et un pour contrôler le robot de loin.
7. Un capteur de distance de DexterIndustries.

Obtenez le robot GiggleBot pour le micro:bit de la BBC ici !

Étape 2: Assemblage du robot

Pour préparer le GiggleBot à être programmé, nous devons l'assembler, bien qu'il n'y ait pas grand-chose à faire.

Insérez les 3 piles AA dans son compartiment sous le GiggleBot.

Assemblez le paquet servo. Sur son bras rotatif du servo, utilisez le dernier trou de celui-ci pour fixer le servo sur les connecteurs avant du GiggleBot. Vous pouvez utiliser une vis et/ou du fil pour le rendre plus stable à sa place. Ou vous pouvez le coller à chaud sur la planche. Dans mon cas, j'ai utilisé une vis et un fil court pour attacher le bras du servo à la carte GiggleBot.

Lors du montage du bras de servo sur le servo, assurez-vous que le servo est déjà réglé sur la position 80. Vous pouvez le faire en appelant gigglebot.set_servo(gigglebot. RIGHT, 80). Vous pouvez en savoir plus à ce sujet ici.

Ensuite, placez le capteur de distance sur la face avant de l'ensemble servo et fixez-le comme dans l'exemple ci-dessus.

Enfin, connectez le capteur de distance avec un câble Grove à l'un des 2 ports I2C et le servomoteur au port de droite assis sur le GiggleBot - le port de droite y est mentionné.

Étape 3: Créez votre propre labyrinthe - Facultatif

Dans ce cas, j'ai utilisé un tas de boîtes pour créer une piste en boucle fermée, similaire à une piste NASCAR.

À cette étape, vous pouvez être vraiment créatif et le rendre aussi tordu que vous le souhaitez ou le rendre super long parce que c'est vraiment à vous de décider.

Ou si vous ne voulez pas du tout de piste, vous pouvez mettre le GiggleBot dans une cuisine ou un salon par exemple - cela devrait suffire car il y a beaucoup de murs et d'obstacles que vous devez encore éviter.

Étape 4: Configuration de l'environnement

Pour que vous puissiez programmer le BBC micro:bit dans MicroPython, vous devez configurer un éditeur pour celui-ci (l'éditeur Mu) et définir le GiggleBot MicroPython Runtime comme son runtime. Pour cela, vous devez suivre les instructions sur cette page. A partir de ce moment, la version v0.4.0 du runtime est utilisée.

Étape 5: Programmation du GiggleBot - Partie I

Tout d'abord, configurons le script de GiggleBot. Ce script fera tourner le GiggleBot de son servomoteur à 160 degrés (80 degrés dans chaque direction) tout en prenant 10 lectures du capteur de distance par tour.

Lorsqu'il est allumé, le GiggleBot restera en attente jusqu'à ce qu'il reçoive une commande de la télécommande. Il ne peut y avoir que 3 commandes: avancer, vers la gauche ou vers la droite.

Remarque: le script suivant peut avoir des espaces blancs manquants et cela semble être dû à un problème d'affichage des GitHub Gists. Cliquez sur l'essentiel pour accéder à sa page GitHub où vous pouvez copier-coller le code.

GiggleBot télécommandé basé sur LIDAR

à partir de l'importation gigglebot*

depuis distance_sensor importer DistanceSensor

à partir du sommeil d'importation de microbit

depuis utime import ticks_us, sleep_us

ustruct d'importation

importer une radio

# arrêter le robot s'il est déjà en mouvement

arrêter()

# activer la radio

radio.on()

# objet capteur de distance

ds = DistanceSensor()

ds.start_continuous()

rotate_time =0.7# mesuré en secondes

rotate_span =160# mesuré en degrés

rotation_pas =10

overhead_compensation =1.05# défini en pourcentages

time_per_step =10**6* rotate_time / (rotate_steps * overhead_compensation)

last_read_time =0

radar =bytearray(rotate_steps)

servo_rotate_direction =0# 0 pour aller vers le haut (0->160) et 1 sinon

index_radar =0

set_servo(DROITE, 0)

whileTrue:

# lecture du radar

si ticks_us() - last_read_time > time_per_step:

# lecture du capteur de distance

radar[radar_index] =int(ds.read_range_continuous() /10)

last_read_time = ticks_us()

imprimer(radar_index)

# faire la logique pour faire tourner le servo de gauche à droite

if radar_index == rotate_steps -1 et servo_rotate_direction ==0:

set_servo(DROITE, 0)

servo_rotate_direction =1

elif radar_index ==0et servo_rotate_direction ==1:

set_servo (RIGHT, rotate_span)

servo_rotate_direction =0

autre:

radar_index +=1 si servo_rotate_direction ==0else-1

# et envoyer les valeurs radar

radio.send_bytes(radar)

essayer:

# lire les commandes du robot

lmotor, rmotor = ustruct.unpack('bb', radio.receive_bytes())

# et actionner les moteurs s'il y a des commandes reçues

set_speed(lmotor, rmotor)

conduire()

exceptTypeError:

passe

voir rawgigglebot_lidar_robot.py hébergé avec ❤ par GitHub

Étape 6: Programmation de la télécommande - Partie II

Il ne reste plus qu'à programmer le 2e micro:bit BBC qui fait office de télécommande.

La télécommande est utilisée pour afficher sur son écran de 5 x 5 pixels la distance relative aux obstacles. Au maximum, il y aura 10 pixels activés.

En même temps, la télécommande vous offre la possibilité de contrôler à distance le GiggleBot en appuyant sur ses 2 boutons: avancer, vers la gauche et vers la droite.

Remarque: le script suivant peut avoir des espaces blancs manquants et cela semble être dû à un problème d'affichage des GitHub Gists. Cliquez sur l'essentiel pour accéder à sa page GitHub où vous pouvez copier-coller le code.

GiggleBot télécommandé basé sur LIDAR - Code à distance

à partir du microbit import sleep, display, button_a, button_b

ustruct d'importation

importer une radio

importer des mathématiques

radio.on()

rotation_pas =10

rotate_span =160# en degrés

rotate_step = rotate_span / rotate_steps

max_distance =50# en centimètres

side_length_leds =3# mesuré dans le nombre de pixels

radar =bytearray(rotate_steps)

xar =bytearray(rotate_steps)

yar =bytearray(rotate_steps)

save_xar =bytearray(rotate_steps)

save_yar =bytearray(rotate_steps)

vitesse_moteur =50

whileTrue:

status = radio.receive_bytes_into(radar)

si le statut n'est pasAucun:

# display.clear()

pour c, val inénumérer (radar):

si radar[c] <= max_distance:

# calculer les coordonnées 2D de chaque distance

angle = rotate_steps / (rotate_steps -1) * rotate_step * c

angle += (180- rotate_span) /2.0

x_c = math.cos(angle * math.pi /180.0) * radar[c]

y_c = math.sin(angle * math.pi /180.0) * radar[c]

# mettre à l'échelle les distances pour qu'elles s'adaptent à l'écran 5x5 microbits

x_c = x_c * (side_length_leds -1) / max_distance

y_c = y_c * (side_length_leds +1) / max_distance

# repositionner les coordonnées

x_c += (side_length_leds -1)

y_c = (side_length_leds +1) - y_c

# rondes coordonnées exactement où se trouvent les LED

si x_c - math.floor(x_c) <0,5:

x_c = math.floor(x_c)

autre:

x_c = math.ceil(x_c)

si y_c - math.floor(y_c) <0,5:

y_c = math.floor(y_c)

autre:

y_c = math.ceil(y_c)

xar[c] = x_c

yar[c] = y_c

autre:

xar[c] =0

année[c] =0

display.clear()

pour x, y inzip(xar, yar):

display.set_pixel(x, y, 9)

# print(list(zip(xar, yar, radar)))

stateA = button_a.is_pressed()

stateB = button_b.is_pressed()

si étatA et étatB:

radio.send_bytes(ustruct.pack('bb', motor_speed, motor_speed))

print('en avant')

si étatA et non étatB:

radio.send_bytes(ustruct.pack('bb', motor_speed, -motor_speed))

imprimer('gauche')

sinon étatA et étatB:

radio.send_bytes(ustruct.pack('bb', -motor_speed, motor_speed))

imprimer('droit')

sinon étatA et non étatB:

radio.send_bytes(ustruct.pack('bb', 0, 0))

imprimer('arrêter')

voir rawgigglebot_lidar_remote.py hébergé avec ❤ par GitHub

Étape 7: Interprétation de l'écran distant

"loading="lazy" contrôle le GiggleBot, vous avez les options suivantes:

1. Appuyez sur les boutons A et B pour déplacer le GiggleBot vers l'avant.
2. Appuyez sur le bouton A pour faire tourner le GiggleBot vers la gauche.
3. Appuyez sur le bouton B pour faire tourner le GiggleBot vers la droite.

Pour voir dans quelle direction les obstacles les plus proches sont détectés, il suffit de regarder sur l'écran de la télécommande (la télécommande BBC micro:bit que vous tenez). Vous devriez pouvoir contrôler le GiggleBot de loin sans le regarder.