Réglage du suiveur de ligne GiggleBot - Avancé : 7 étapes

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

Dans ce très court Instructables, vous allez régler votre propre GiggleBot pour suivre une ligne noire. Dans cet autre tutoriel GiggleBot Line Follower, nous avons codé en dur les valeurs de réglage pour qu'elles fonctionnent selon ce scénario. Vous voudrez peut-être l'améliorer en proposant d'autres gains.

Dans ce tutoriel, nous vous montrons 2 scripts qui peuvent tous les deux être chargés sur différents micro:bits BBC afin que l'un d'eux soit mis dans le GiggleBot et avec l'autre, les 2 boutons permettent de parcourir un menu et de régler différents paramètres. L'envoi de ces paramètres mis à jour se fait par radio.

Étape 1: Composants requis

Vous aurez besoin des éléments suivants:

1. Un robot GiggleBot pour le micro:bit.
2. x3 piles AA
3. x2 BBC micro:bits - un pour le GiggleBot et l'autre servant de télécommande pour le réglage des paramètres.
4. Une batterie pour un BBC micro:bit - comme celle qui fait partie du package BBC micro:bit.

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

Étape 2: Configuration des pistes et de l'environnement

Vous devez également créer vos pistes (télécharger, imprimer, découper et enregistrer des tuiles), puis configurer l'environnement (l'IDE et le runtime).

Puisque ce tutoriel est très lié à cet autre tutoriel intitulé GiggleBot Line Follower, allez-y et suivez les étapes 2 et 3 puis revenez ici.

En ce qui concerne l'IDE, vous pouvez utiliser l'éditeur Mu et pour le runtime, vous devez télécharger le GiggleBot MicroPython Runtime. Le runtime peut être téléchargé à partir de sa documentation ici. Dirigez-vous vers le chapitre Mise en route de la documentation et suivez ces instructions sur la configuration de l'environnement. A partir de ce moment, la version v0.4.0 du runtime est utilisée.

Étape 3: Configuration du GiggleBot

Avant de flasher le runtime sur le GiggleBot, assurez-vous d'avoir choisi la vitesse et le taux de mise à jour souhaités pour le GiggleBot: par défaut, la vitesse est définie sur 100 (variable base_speed) et le taux de mise à jour est défini sur 70 (variable update_rate).

Compte tenu de la mise en œuvre actuelle, le taux de mise à jour le plus élevé pouvant être atteint est de 70 et si run_neopixels est défini sur True, alors seulement 50 est réalisable. Donc, d'une certaine manière, vous pourriez dire que le taux de mise à jour par défaut est juste à la limite de ce que le BBC micro:bit peut faire.

Pour mémoire, le capteur suiveur de ligne peut renvoyer des mises à jour 100 fois par seconde.

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 PID Line Follower Tuner (nécessite une télécommande pour le régler) - xjfls23

à partir de l'import microbit*

à partir de l'importation gigglebot*

depuis utime import sleep_ms, ticks_us

importer une radio

ustruct d'importation

# initialiser les néopixels radio et Go

radio.on()

néo = init()

# Horaire

taux_mise à jour =70

# valeurs de gain par défaut

Kp =0.0

Ki =0.0

Kd =0.0

consigne =0,5

trigger_point =0.0

min_speed_percent =0.2

vitesse_base = 100

last_position = point de consigne

intégrale =0.0

run_neopixels =Faux

center_pixel =5# où le pixel central du sourire est situé sur le GB

# turquoise = tuple(map(lambda x: int(x/5), (64, 224, 208))) # couleur à utiliser pour dessiner l'erreur avec les néopixels

# turquoise = (12, 44, 41) # qui est exactement la turquoise ci-dessus commentée ci-dessus

error_width_per_pixel =0.5/3# erreur max divisée par le nombre de segments entre chaque néopixel

defupper_bound_linear_speed_reducer(abs_error, trigger_point, upper_bound, smallest_motor_power, high_motor_power):

vitesse_base globale

si abs_error >= trigger_point:

#x0 = 0.0

# y0 = 0.0

# x1 = upper_bound - trigger_point

# y1 = 1.0

# x = abs_error - trigger_point

# y = y0 + (x - x0) * (y1 - y0) / (x1 - x0)

# pareil que

y = (abs_error - trigger_point) / (upper_bound - trigger_point)

motor_power = base_speed * (smallest_motor_power + (1- y) * (highest_motor_power - smallest_motor_power))

retour motor_power

autre:

return base_speed * high_motor_power

exécuter =Faux

erreur_précédente =0

temps_total =0.0

total_counts =0

whileTrue:

# si le bouton a est enfoncé alors commencez à suivre

si button_a.is_pressed():

exécuter = vrai

# mais si le bouton b est pressé arrêter le suiveur de ligne

si button_b.is_pressed():

exécuter =Faux

intégrale =0.0

erreur_précédente =0.0

display.scroll('{} - {}'.format(total_time, total_counts), delay=100, wait=False)

temps_total =0.0

total_counts =0

pixels_off()

arrêter()

sleep_ms(500)

si run isTrue:

# lire les capteurs de ligne

start_time = ticks_us()

# vérifier si nous avons mis à jour les gains Kp/Kd avec une télécommande

essayer:

Kp, Ki, Kd, trigger_point, min_speed_percent = ustruct.unpack('fffff', radio.receive_bytes())

set_yeux()

exceptTypeError:

passe

droite, gauche = read_sensor (LINE_SENSOR, BOTH)

# la ligne est à gauche lorsque la position < 0,5

# la ligne est à droite lorsque la position > 0,5

# la ligne est au milieu lorsque la position = 0,5

# c'est une moyenne arithmétique pondérée

essayer:

position = droite / flotter (gauche + droite)

exceptZeroDivisionError:

emplacement =0,5

si position ==0: position =0.001

si position ==1: position =0.999

# utiliser un contrôleur PD

erreur = position - consigne

intégrale += erreur

correction = Kp * erreur + Ki * intégrale + Kd * (erreur - erreur_précédente)

erreur_précédente = erreur

# calculer les vitesses des moteurs

motor_speed = upper_bound_linear_speed_reducer(abs(error), setpoint * trigger_point, setpoint, min_speed_percent, 1.0)

leftMotorSpeed = motor_speed + correction

rightMotorSpeed = motor_speed - correction

# allume les néopixels pour montrer dans quelle direction le GiggleBot doit aller

si run_neopixels est True et total_counts %3==0:

pour i inb'\x00\x01\x02\x03\x04\x05\x06\x07\x08':

néo = (0, 0, 0)

pour i inb'\x00\x01\x02\x03':

ifabs(error) > error_width_per_pixel * je:

si erreur <0:

néo[centre_pixel + i] = (12, 44, 41)

autre:

neo[center_pixel - i] = (12, 44, 41)

autre:

pourcentage =1- (error_width_per_pixel * i -abs(error)) / error_width_per_pixel

# allume le pixel actuel

si erreur <0:

# neo[center_pixel + i] = tuple(map(lambda x: int(x * pourcentage), turquoise))

neo[center_pixel + i] = (int(12* pour cent), int(44* pour cent), int(41* pour cent))

autre:

# neo[center_pixel - i] = tuple(map(lambda x: int(x * pourcentage), turquoise))

neo[center_pixel - i] = (int(12* pour cent), int(44* pour cent), int(41* pour cent))

Pause

neo.show()

essayer:

# clipser les moteurs

si gaucheMotorSpeed >100:

gaucheMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

si rightMotorSpeed >100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

si gaucheMotorSpeed <-100:

gaucheMoteurVitesse =-100

si rightMotorSpeed <-100:

droiteMoteurVitesse =-100

# actionner les moteurs

set_speed(leftMotorSpeed, rightMotorSpeed)

conduire()

# print((error, motor_speed))

sauf:

# au cas où nous serions confrontés à un problème irréparable

passe

# et maintenir la fréquence de boucle

end_time = ticks_us()

delay_diff = (end_time - start_time) /1000

total_time += delay_diff

total_counts +=1

if1.0/ update_rate - delay_diff >0:

sleep(1.0/ update_rate - delay_diff)

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

Étape 4: Configuration du tuner (à distance)

La prochaine chose que nous devons faire est de flasher le script runtime + sur le 2ème micro:bit BBC. Ce deuxième micro:bit servira de télécommande au GiggleBot, qui sera utilisé pour régler les paramètres suivants:

1. Kp = gain proportionnel pour le régulateur PID.
2. Ki = gain intégral pour le régulateur PID.
3. Kd = gain dérivé pour le régulateur PID.
4. trigger_point = le point exprimé en pourcentage entre les vitesses minimale et maximale du GiggleBot où la vitesse commence à se réduire linéairement jusqu'à ce qu'elle atteigne la vitesse minimale.
5. min_speed_percent = la vitesse minimale exprimée en pourcentage de la vitesse maximale.

Les 2 autres variables restantes qui peuvent être réglées sont directement codées en dur dans le script qui se trouve sur le GiggleBot: le update_rate et la base_speed qui représentent la vitesse maximale. Comme décrit dans la documentation, la vitesse maximale pouvant être définie pour le GiggleBot est de 100, qui est également la valeur par défaut pour notre GiggleBot.

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 Remote PID Line Follower Tuner (nécessite l'autre partie) - xjfls23

à partir de l'import microbit*

depuis utime importer sleep_ms

importer une radio

ustruct d'importation

# 1er élément est le gain Kp

# 2ème élément est le gain de Ki

# 3ème élément est le gain Kd

# 4ème élément est le trigger_point pour que les moteurs abaissent la vitesse (0 -> 1)

# 5ème élément est la vitesse min des moteurs exprimée en pourcentage (0 -> 1)

gains = [0,0, 0,0, 0,0, 1,0, 0,0]

stepSize =0.1

# 0 et 1 pour le 1er élément

#2 et 3 pour le 2ème élément

CurrentSetting =0

defshowMenu():

display.scroll('{} - {}'.format(currentSetting, gains[int(currentSetting /2)]), delay=100, wait=False)

radio.on()

Afficher le menu()

whileTrue:

mis à jour =Faux

si button_a.is_pressed():

CurrentSetting = (currentSetting +1) % (2*5)

mis à jour = vrai

si button_b.is_pressed():

si CurrentSetting %2==0:

# augmente le gain lorsque currentSetting est 0 ou 2 ou..

ifint(currentSetting /2) dans [0, 2]:

gains[int(currentSetting /2)] +=10* stepSize

autre:

gains[int(currentSetting /2)] += stepSize

autre:

# augmente le gain lorsque currentSetting est 1 ou 3 ou..

ifint(currentSetting /2) dans [0, 2]:

gains[int(currentSetting /2)] -=10* stepSize

autre:

gains[int(currentSetting /2)] -= stepSize

radio.send_bytes(ustruct.pack('fffff', *gains))

mis à jour = vrai

si mise à jour:

Afficher le menu()

sleep_ms(200)

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

Étape 5: Réglage du GiggleBot

Placez le GiggleBot sur la piste, allumez-le et laissez-le fonctionner. En attendant, vous devrez constamment le remettre sur la piste et régler les gains/paramètres avec l'autre BBC micro:bit que vous tenez en main.

Pour démarrer le GiggleBot, appuyez sur le bouton A du BBC micro:bit du GiggleBot et pour l'arrêter et ainsi réinitialiser son état appuyez sur le bouton B.

Sur la télécommande BBC micro:bit, appuyez sur le bouton A pour parcourir toutes les options de son menu et le bouton B augmente/diminue la valeur correspondante. C'est comme régler l'horloge sur le tableau de bord d'une vieille voiture. Les options sont comme ceci:

1. Les options 0-1 sont pour le gain Kp.
2. 2-3 options sont pour le gain Ki.
3. 4-5 options sont pour le gain Kd.
4. Les options 6 à 7 permettent de régler le point de consigne pour le moment où les moteurs commencent à ralentir.
5. 8 à 9 options permettent de régler la vitesse minimale.

Gardez à l'esprit que les nombres pairs dans le menu servent à augmenter les valeurs correspondantes et pour les impairs, c'est exactement le contraire.

De plus, lorsque vous appuyez sur le bouton B du BBC micro:bit du GiggleBot, vous verrez sur son écran fabriqué en néopixel le nombre de millisecondes écoulées depuis la dernière réinitialisation et le nombre de cycles que le robot a parcouru - avec ces 2, vous pouvez calculer le taux de mise à jour du robot.

Enfin et surtout, j'ai proposé 2 réglages pour le GiggleBot. L'un d'eux est pour quand les LED Neopixel sont éteintes et l'autre est pour quand il en est autrement. Les LED Neopixel sont utilisées pour montrer dans quelle direction l'erreur s'est accumulée.

1er jeu de réglage des paramètres (avec les LED NeoPixel éteintes)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0.3 (ce qui correspond à 30%)
5. min_speed_percent = 0.2 (ce qui est 20%)
6. base_speed = 100 (ou vitesse maximale)
7. update_rate = 70 (fonctionnant à 70 Hz)

2ème jeu de réglage des paramètres (avec les LED NeoPixel allumées)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0.3 (ce qui correspond à 30%)
5. min_speed_percent = 0.3 (ce qui correspond à 30%)
6. base_speed = 70 (ou vitesse maximale)
7. update_rate = 50 (fonctionnement à 50 Hz)
8. De plus, la variable run_neopixels doit être définie sur True dans le script qui est chargé sur le micro:bit BBC du GiggleBot. Cela fera clignoter les LED NeoPixel de manière à indiquer dans quelle direction l'erreur s'accumule.

Étape 6: GiggleBot s'exécutant avec les NeoPixels éteints

Ceci est un exemple d'exécution du GiggleBot avec les premiers paramètres de réglage trouvés à l'étape précédente. Dans cet exemple, les LED NeoPixel sont éteintes.

Étape 7: GiggleBot fonctionne avec les Neopixels activés

Ceci est un exemple d'exécution du GiggleBot avec le 2ème ensemble de paramètres de réglage trouvé à l'étape 5. Cet exemple a les LED NeoPixel allumées.

Remarquez comment dans cet exemple, le GiggleBot a plus de mal à suivre la ligne - c'est parce que les LED Neopixel "mangent" le temps CPU du micro:bit BBC. C'est pourquoi nous avons dû réduire le taux de mise à jour de 70 à 50.