Seguidor de línia GiggleBot mitjançant Python: 5 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:13

Aquesta vegada, programem a MicroPython el Dexter Industries GiggleBot per seguir una línia negra mitjançant el sensor de seguidor de línia integrat.

El GiggleBot s’ha d’aparellar amb un micro BBC: bit perquè es pugui controlar adequadament.

Si aquest tutorial és massa avançat per a vosaltres i la programació del GiggleBot és massa per ara, sempre podeu passar pel tutorial d’inici que us mostra com es pot programar el robot a MakeCode aquí. El tutorial enllaçat us guiarà pels conceptes bàsics.

Pas 1: components necessaris

Es requereixen els components de maquinari següents:

1. Bateries AA x3: en el meu cas, faig servir bateries recarregables que tenen una tensió general inferior.
2. Un robot GiggleBot de Dexter Industries per al micro: bit.
3. Un micro: bit de la BBC.

Per descomptat, també necessiteu un cable micro USB per programar el micro: bit de la BBC: aquest cable normalment es troba dins del paquet de la micro: bit de la BBC o sempre podeu utilitzar-ne un que s’utilitzi per carregar telèfons intel·ligents (Android).

Obteniu el GiggleBot per al micro: bit aquí

Pas 2: configureu les pistes

Haureu d’imprimir algunes rajoles i dissenyar les vostres pròpies pistes. Podeu utilitzar les nostres pròpies fitxes perquè estigueu 100% segur de replicar les nostres condicions. O si us sentiu aventurer, podeu fer servir cinta negra i crear-ne de vostres. Aquí teniu el PDF de les fitxes que hem utilitzat.

La pista anterior es compon del nombre següent de mosaics diferents:

• 12 fitxes del tipus # 1.
• 5 fitxes del tipus # 2.
• 3 plantilles del tipus de mosaic # 5.
• 3 plantilles del tipus de mosaic núm. 6: aquí acabareu amb un mosaic addicional.

A continuació, imprimiu-los i talleu-los. Proveu de col·locar-los com a la foto anterior i tingueu en compte que a la part superior dreta de la pista, dues fitxes s’han de superposar entre elles; això s’espera en cas que us pregunteu si feu alguna cosa malament.

Pas 3: Configuració de l'entorn

Per tal que pugueu programar el micro: bit de la BBC a MicroPython, heu de configurar-ne un editor (l’editor Mu) i configurar el temps d’execució de GiggleBot MicroPython Runtime. Per a això, heu de seguir les instruccions d'aquesta pàgina. A partir d’aquest moment s’utilitza la versió v0.4.0 del temps d’execució.

Pas 4: Programació del GiggleBot

Abans d’aconseguir-ho, el temps d’execució de GiggleBot MicroPython conté el temps d’execució clàssic per a les biblioteques micro: bit i altres de la BBC per donar suport al GiggleBot i altres sensors Dexter Industries.

Després de configurar-lo, obriu el següent script a l'editor Mu i feu clic a Flash. Això farà aparèixer el GiggleBot MicroPython Runtime i l’escriptura que acabeu d’obrir al vostre micro: bit de la BBC. A continuació, es mostra el guió.

Un cop fet el procés de parpelleig, apileu el micro: bit de BBC al GiggleBot amb els neopíxels del tauler cap endavant, col·loqueu-lo a la pista i engegueu-lo.

Tingueu en compte que a l'script, el PID i altres 2 constants (el valor de consigna de velocitat i les constants de velocitat mínima) ja estan establertes.

Nota: És possible que el següent script no tingui espais en blanc i sembla que es deu a algun problema en mostrar GitHub Gists. Feu clic al resum per accedir a la pàgina de GitHub, on podeu copiar-enganxar el codi.

Seguidor de la línia PID de GiggleBot: ajustat amb NeoPixels

des de la importació de microbits *

des de la importació de gigglebot *

des d’utime importar sleep_ms, ticks_us

importar ustruct

# inicialitza els neopíxels GB

neo = init ()

# temps

taxa_actualització = 50

# guanys / constants (suposant que la tensió de la bateria ronda els 4,0 volts)

Kp = 25,0

Ki = 0,5

Kd = 35,0

trigger_point = 0,3

min_speed_percent = 0,3

velocitat base = 70

setpoint = 0,5

last_position = setpoint

integral = 0,0

run_neopixels = Cert

center_pixel = 5 # on es troba el píxel central del somriure al GB

# turquesa = tupla (mapa (lambda x: int (x / 5), (64, 224, 208))) # color a utilitzar per dibuixar l'error amb els neopíxels

# turquesa = (12, 44, 41) # que és exactament el turquesa anterior comentat a sobre d'això

error_width_per_pixel = 0,5 / 3 # error màxim dividit pel nombre de segments entre cada neopíxel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, small_motor_power, power_motor_power):

velocitat base global

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)

# el mateix que

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

motor_power = base_speed * (small_motor_power + (1- y) * (power_motor_power - smallest_motor_power))

retorna la potència del motor

en cas contrari:

retorn base_velocitat * potència_motor_alta

córrer = Fals

error_ anterior = 0

whileTrue:

# si es prem el botó a, comenceu a seguir-lo

si button_a.is_pressed ():

run = True

# però si es prem el botó b atureu el seguidor de línia

si button_b.is_pressed ():

córrer = Fals

integral = 0,0

error_anterior = 0,0

pixels_off ()

Atura()

sleep_ms (500)

si s'executa és Veritat:

# llegiu els sensors de línia

hora_inici = ticks_us ()

dreta, esquerra = read_sensor (LINE_SENSOR, AMB)

# línia es troba a l'esquerra quan la posició <0,5

# línia és a la dreta quan la posició> 0,5

# línia es troba al centre quan la posició = 0,5

# és una mitjana aritmètica ponderada

provar:

posició = dreta / flotant (esquerra + dreta)

exceptZeroDivisionError:

posició = 0,5

# l'interval ha de ser (0, 1) i no [0, 1]

si posició == 0: posició = 0,001

si posició == 1: posició = 0,999

# utilitzeu un controlador PD

error = posició - setpoint

integral + = error

correcció = error Kp * + Ki * integral + Kd * (error - error_ anterior)

error_ anterior = error

# calcular les velocitats del motor

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

leftMotorSpeed = velocitat_motor + correcció

rightMotorSpeed = motor_speed - correcció

# il·lumineu els neopíxels segons l'error indicat

si run_neopixels és True i total_counts% 3 == 0:

per a i inb '\ x00 / x01 / x02 / x03 / x04 / x05 / x06 / x07 / x08':

neo = (0, 0, 0)

per a i inb '\ x00 / x01 / x02 / x03':

ifabs (error)> error_width_per_pixel * i:

si error <0:

# neo [centre_pixel + i] = turquesa

neo [centre_pixel + i] = (12, 44, 41)

en cas contrari:

# neo [centre_pixel - i] = turquesa

neo [centre_pixel + i] = (12, 44, 41)

en cas contrari:

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

# il·lumina el píxel actual

si error <0:

# neo [centre_pixel + i] = tupla (mapa (lambda x: int (percentatge x *), turquesa))

neo [centre_pixel + i] = (int (64 * per cent / 5), int (224 * per cent / 5), int (208 * per cent / 5))

en cas contrari:

# neo [centre_pixel - i] = tupla (mapa (lambda x: int (percentatge x *), turquesa))

neo [centre_pixel - i] = (int (64 * per cent / 5), int (224 * per cent / 5), int (208 * per cent / 5))

trencar

neo.show ()

provar:

# retallar les velocitats del motor

if leftMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

si rightMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

si leftMotorSpeed <-100:

leftMotorSpeed = -100

si rightMotorSpeed <-100:

rightMotorSpeed = -100

# accionar els motors

set_speed (leftMotorSpeed, rightMotorSpeed)

conduir()

# print ((error, motor_speed))

excepte:

# per si entrem en algun problema que no es pot solucionar

passar

# i mantenir la freqüència del bucle

hora_final = ticks_us ()

delay_diff = (time_time - start_time) / 1000

if1000.0 / update_rate - delay_diff> 0:

sleep (1000.0 / update_rate - delay_diff)

visualitza rawgigglebot_tuned_line_follower.py allotjat amb ❤ per GitHub

Pas 5: deixar-lo córrer

Hi ha 2 botons al micro: bit: botó A i botó B de la BBC:

• En prémer el botó A, el GiggleBot segueix la línia (si n’hi ha).
• En prémer el botó B s’atura el GiggleBot i es restableix tot per poder tornar-lo a utilitzar.

Es recomana no aixecar el GiggleBot mentre segueix una línia i tornar-lo a posar perquè l'error que es calcula podria acumular-se i desordenar totalment la ruta del robot. Si voleu aixecar-lo, premeu el botó B i, quan el torneu a posar, torneu a prémer A.