Sintonització del seguidor de la línia GiggleBot - Avançat: 7 passos

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

En aquest breu Instructables, sintonitzareu el vostre propi GiggleBot per seguir una línia negra. En aquest altre tutorial GiggleBot Line Follower, hem codificat els valors de sintonització perquè funcionin segons aquest escenari. És possible que vulgueu que es comporti millor amb altres beneficis.

En aquest tutorial, us mostrem 2 scripts que es poden carregar en diferents micro de la BBC: bits perquè un d’ells es posi al GiggleBot i, amb l’altre, els 2 botons s’utilitzen per passar un menú i sintonitzar diferents paràmetres. L’enviament d’aquests paràmetres actualitzats es fa a través de la ràdio.

Pas 1: components necessaris

Necessitareu el següent:

1. Un robot GiggleBot per al micro: bit.
2. piles AA x3
3. x2 BBC micro: bits: un per al GiggleBot i l’altre que fa de control remot per a la sintonització de paràmetres.
4. Una bateria per a un micro: bit de la BBC: com la que inclou el paquet de micro: bits de la BBC.

Obteniu el robot GiggleBot per al micro: bit de la BBC aquí

Pas 2: Configuració de les pistes i l'entorn

També heu de construir les vostres pistes (descarregar, imprimir, tallar i cintes) i després configurar l'entorn (l'IDE i el temps d'execució).

Com que aquest tutorial està molt relacionat amb aquest altre tutorial titulat GiggleBot Line Follower, aneu-hi i seguiu els passos 2 i 3 i torneu aquí.

Pel que fa a l’IDE, podeu utilitzar l’editor Mu i, durant el temps d’execució, heu de descarregar el GiggleBot MicroPython Runtime. El temps d'execució es pot descarregar de la seva documentació aquí. Aneu al capítol Introducció a la documentació i seguiu aquestes instruccions per configurar l'entorn. A partir d’aquest moment s’utilitza la versió v0.4.0 del temps d’execució.

Pas 3: Configuració del GiggleBot

Abans de fer passar el temps d’execució al GiggleBot, assegureu-vos d’haver escollit la velocitat i la velocitat d’actualització desitjades per al GiggleBot: per defecte, la velocitat s’estableix a 100 (variable base_speed) i la velocitat d’actualització és 70 (variable actualització taxa).

Donada la implementació actual, la taxa d’actualització més alta que es pot aconseguir és de 70 i si run_neopixels s’estableix en True, només es podrà assolir 50. Per tant, en certa manera, es podria dir que la taxa d’actualització per defecte és al límit del que pot fer el micro: bit de la BBC.

Només per deixar constància, el sensor de seguidor de línia pot retornar actualitzacions 100 vegades per segon.

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.

Sintonitzador de seguidors de línia PID GiggleBot (requereix un comandament a distància per afinar-lo) - xjfls23

des de la importació de microbits *

des de la importació de gigglebot *

des d’utime importar sleep_ms, ticks_us

importar ràdio

importar ustruct

# inicialitzar els neopíxels de ràdio i GB

radio.on ()

neo = init ()

# temps

taxa_actualització = 70

# valors de guany predeterminats

Kp = 0,0

Ki = 0,0

Kd = 0,0

setpoint = 0,5

trigger_point = 0,0

min_speed_percent = 0,2

velocitat base = 100

last_position = setpoint

integral = 0,0

run_neopixels = Fals

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

temps_total = 0,0

total_counts = 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

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

temps_total = 0,0

total_counts = 0

pixels_off ()

Atura()

sleep_ms (500)

si s'executa és Veritat:

# llegiu els sensors de línia

hora_inici = ticks_us ()

# comproveu si hem actualitzat els guanys Kp / Kd amb un comandament a distància

provar:

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

set_eyes ()

exceptTypeError:

passar

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

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 per mostrar a quina direcció ha d'anar el GiggleBot

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] = (12, 44, 41)

en cas contrari:

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 (12 * per cent), int (44 * per cent), int (41 * per cent))

en cas contrari:

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

neo [centre_pixel - i] = (int (12 * per cent), int (44 * per cent), int (41 * per cent))

trencar

neo.show ()

provar:

# retallar els motors

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

total_time + = delay_diff

total_counts + = 1

if1.0 / update_rate - delay_diff> 0:

sleep (1.0 / update_rate - delay_diff)

visualitza rawgigglebot_line_follower_tuner.py allotjat amb ❤ per GitHub

Pas 4: Configuració del sintonitzador (remot)

El següent que hem de fer és fer flash el runtime + script al segon micro: bit de la BBC. Aquest segon micro: bit actuarà com un control remot al GiggleBot, que s’utilitzarà per sintonitzar els paràmetres següents:

1. Kp = guany proporcional per al controlador PID.
2. Ki = guany integral per al controlador PID.
3. Kd = guany derivat per al controlador PID.
4. trigger_point = el punt expressat en percentatges entre la velocitat mínima i màxima del GiggleBot on la velocitat comença a reduir-se linealment fins a assolir la velocitat mínima.
5. min_speed_percent = la velocitat mínima expressada en percentatge de la velocitat màxima.

Les altres 2 variables restants que es poden sintonitzar estan directament codificades en l'script que es troba al GiggleBot: la velocitat actualització i la velocitat base que representa la velocitat màxima. Tal com es descriu a la documentació, la velocitat màxima que es pot establir per a GiggleBot és de 100, que també és el valor per defecte del nostre GiggleBot.

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.

Sintonitzador de seguidors de línia PID remot GiggleBot (requereix l’altra part) - xjfls23

des de la importació de microbits *

de la importació utime sleep_ms

importar ràdio

importar ustruct

El primer element és el guany de Kp

El segon element és el guany Ki

El tercer element és el guany de Kd

El quart element és el trigger_point per als motors per reduir la velocitat (0 -> 1)

El cinquè element és la velocitat mínima dels motors expressada en percentatges (0 -> 1)

guanys = [0,0, 0,0, 0,0, 1,0, 0,0]

stepSize = 0,1

# 0 i 1 per al primer element

# 2 i 3 per al 2n element

currentSetting = 0

defshowMenu ():

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

radio.on ()

showMenu ()

whileTrue:

actualitzat = Fals

si button_a.is_pressed ():

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

actualitzat = True

si button_b.is_pressed ():

si currentSetting% 2 == 0:

# augmentar el guany quan CurrentSetting és 0 o 2 o..

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

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

en cas contrari:

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

en cas contrari:

# augmentar el guany quan CurrentSetting és 1 o 3 o..

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

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

en cas contrari:

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

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

actualitzat = True

si s'actualitza:

showMenu ()

sleep_ms (200)

visualitza rawgigglebot_line_follower_configurator.py allotjat amb ❤ per GitHub

Pas 5: Tuning del GiggleBot

Col·loqueu el GiggleBot a la pista, engegueu-lo i deixeu-lo córrer. Mentrestant, hauràs de tornar a posar-lo a la pista i sintonitzar els guanys / paràmetres amb l’altre bit de BBC: bit que tens a la mà.

Per iniciar el GiggleBot, premeu el botó A del micro BBC: bit del GiggleBot i per aturar-lo i restablir el seu estat, premeu el botó B.

Al micro: bit remot de la BBC, si premeu el botó A, accedireu a totes les opcions del menú i el botó B augmenta / disminueix el valor corresponent. És com posar el rellotge al tauler d’un cotxe vell. Les opcions són així:

1. Les opcions 0-1 són per al guany de Kp.
2. Hi ha 2-3 opcions per obtenir el guany Ki.
3. Hi ha 4-5 opcions per obtenir el guany de Kd.
4. Hi ha 6-7 opcions per establir el valor de consigna per al moment en què els motors comencen a ralentir-se.
5. Les opcions 8-9 són per establir la velocitat mínima.

Tingueu en compte que els números parells del menú serveixen per augmentar els valors corresponents i per als senars és exactament el contrari.

A més, en prémer el botó B del micro: bit de la BBC de GiggleBot, veureu a la pantalla de Neopixel el nombre de mil·lisegons transcorreguts des de l’últim reinici i el nombre de cicles que ha passat el robot. Amb aquests 2 podeu calcular la velocitat d’actualització del robot.

Per últim i el més important, he proposat 2 afinacions per al GiggleBot. Un d’ells és per quan s’apaguen els LED de Neopixel i l’altre per a quan sigui diferent. Els LED de Neopixel s’utilitzen per mostrar en quina direcció s’ha acumulat l’error.

Primer conjunt d’ajust dels paràmetres (amb LEDs NeoPixel apagats)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0,3 (el 30%)
5. min_speed_percent = 0,2 (el 20%)
6. base_speed = 100 (també coneguda com a velocitat màxima)
7. update_rate = 70 (en execució @ 70Hz)

2n conjunt d'ajust dels paràmetres (amb els LED NeoPixel engegats)

1. Kp = 25,0
2. Ki = 0,5
3. Kd = 35,0
4. trigger_setpoint = 0,3 (el 30%)
5. min_speed_percent = 0,3 (el 30%)
6. base_speed = 70 (també coneguda com a velocitat màxima)
7. update_rate = 50 (funcionant a 50Hz)
8. A més, la variable run_neopixels s'ha d'establir a True en l'script que es carrega al micro: bit de la BBC de GiggleBot. Això farà que els LEDs NeoPixel parpellegin de manera que indiquin cap a quina direcció s’acumula l’error.

Pas 6: GiggleBot s'executa amb els NeoPixels apagats

Aquest és un exemple d’execució del GiggleBot amb els primers paràmetres d’ajust que es troben al pas anterior. En aquest exemple, els LED NeoPixel estan apagats.

Pas 7: GiggleBot s'executa amb els Neopixels activats

Aquest és un exemple d’execució del GiggleBot amb el segon conjunt de paràmetres d’ajust que es troba al pas 5. Aquest exemple té els LED NeoPixel activats.

Fixeu-vos en com en aquest exemple, el GiggleBot té més dificultats per seguir la línia, perquè els LED de Neopixel "mengen" el temps de CPU del micro: bit de la BBC. Per això, vam haver de reduir la taxa d’actualització de 70 a 50.