Suiveur de ligne GiggleBot utilisant Python : 5 étapes

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

Cette fois-ci, nous programmons en MicroPython le Dexter Industries GiggleBot pour suivre une ligne noire à l'aide de son capteur de suivi de ligne intégré.

Le GiggleBot doit être associé à un BBC micro:bit pour qu'il soit contrôlé de manière appropriée.

Si ce tutoriel est trop avancé pour vous et que la programmation du GiggleBot l'est pour l'instant, vous pouvez toujours passer par le tutoriel de démarrage qui vous montre comment programmer le robot dans MakeCode ici. Le didacticiel lié vous guidera à travers les bases.

Étape 1: Composants requis

Les composants matériels suivants sont requis:

1. x3 piles AA - dans mon cas, j'utilise des piles rechargeables qui ont une tension globale inférieure.
2. Un robot Dexter Industries GiggleBot pour le micro:bit.
3. Un micro:bit BBC.

Bien sûr, vous avez également besoin d'un câble micro USB pour programmer le BBC micro:bit - ce câble est généralement inclus dans le package BBC micro:bit ou vous pouvez toujours en utiliser un qui est utilisé pour charger les smartphones (Android).

Obtenez le GiggleBot pour le micro:bit ici

Étape 2: Configurer les pistes

Vous devrez imprimer des tuiles et concevoir vos propres pistes. Vous pouvez utiliser nos propres tuiles pour être sûr à 100 % de reproduire nos conditions. Ou si vous vous sentez aventureux, vous pouvez utiliser du ruban noir et créer le vôtre. Voici le PDF des tuiles que nous avons utilisées.

La piste ci-dessus est composée du nombre suivant de tuiles différentes:

• 12 tuiles de type #1.
• 5 tuiles de type #2.
• 3 modèles de tuile de type #5.
• 3 modèles de tuile de type #6 - ici, vous vous retrouverez avec une tuile supplémentaire.

Ensuite, imprimez-les et coupez-les. Essayez de les placer comme sur la photo ci-dessus et gardez à l'esprit que sur le côté supérieur droit de la piste, 2 tuiles doivent se chevaucher - c'est normal au cas où vous vous demanderiez si vous faites quelque chose de mal.

Étape 3: 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 4: Programmation du GiggleBot

Avant de commencer, le runtime GiggleBot MicroPython contient le runtime classique pour le BBC micro:bit et d'autres bibliothèques pour prendre en charge le GiggleBot et d'autres capteurs Dexter Industries.

Après l'avoir configuré, ouvrez le script suivant dans l'éditeur Mu et cliquez sur Flash. Cela fera clignoter le GiggleBot MicroPython Runtime et le script que vous venez d'ouvrir sur votre BBC micro:bit. Le script est également présenté ci-dessous.

Une fois le processus de flashage terminé, empilez le BBC micro:bit dans le GiggleBot avec les néopixels de la carte orientés vers l'avant, placez-le sur la piste et allumez-le.

Notez que dans le script, le PID et les 2 autres constantes (la consigne de vitesse et les constantes de vitesse minimale) sont déjà définis.

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.

Suiveur de ligne GiggleBot PID - Optimisé avec NeoPixels

à partir de l'import microbit*

à partir de l'importation gigglebot*

depuis utime import sleep_ms, ticks_us

ustruct d'importation

# initialiser Go néopixels

néo = init()

# Horaire

taux_mise à jour =50

# gains/constantes (en supposant que la tension de la batterie est d'environ 4,0 volts)

Kp =25,0

Ki =0,5

Kd =35,0

trigger_point =0.3

min_speed_percent =0.3

vitesse_base =70

consigne =0,5

last_position = point de consigne

intégrale =0.0

run_neopixels =Vrai

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

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

pixels_off()

arrêter()

sleep_ms(500)

si run isTrue:

# lire les capteurs de ligne

start_time = ticks_us()

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

# la plage doit être (0, 1) et non [0, 1]

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 en fonction de l'erreur donnée

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:

# neo[center_pixel + i] = turquoise

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

autre:

# neo[center_pixel - i] = turquoise

néo[centre_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(64* pourcent /5), int(224* pourcent /5), int(208* pourcent /5))

autre:

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

neo[center_pixel - i] = (int(64* pourcent /5), int(224* pourcent /5), int(208* pourcent /5))

Pause

neo.show()

essayer:

# clip les vitesses du moteur

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

if1000.0/ update_rate - delay_diff >0:

sleep(1000.0/ update_rate - delay_diff)

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

Étape 5: Laisser fonctionner

Il y a 2 boutons sur le BBC micro:bit: bouton A et bouton B:

• En appuyant sur le bouton A, le GiggleBot suit la ligne (s'il y en a une).
• Un appui sur le bouton B arrête le GiggleBot et réinitialise tout pour que vous puissiez l'utiliser à nouveau.

Il est fortement conseillé de ne pas soulever le GiggleBot pendant qu'il suit une ligne puis de le remettre dessus car l'erreur de calcul pourrait s'accumuler et gâcher totalement la route du robot. Si vous souhaitez le soulever, appuyez sur le bouton B puis lorsque vous le remettez appuyez à nouveau sur A.