Table des matières:
2025 Auteur: John Day | [email protected]. Dernière modifié: 2025-01-13 06:57
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:
- x3 piles AA - dans mon cas, j'utilise des piles rechargeables qui ont une tension globale inférieure.
- Un robot Dexter Industries GiggleBot pour le micro:bit.
- 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.