De GiggleBot-lijnvolger afstemmen - Geavanceerd - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

In deze zeer korte Instructables ga je je eigen GiggleBot afstemmen om een zwarte lijn te volgen. In deze andere tutorial GiggleBot Line Follower hebben we de afstemmingswaarden hard gecodeerd om volgens dat scenario te werken. Misschien wilt u ervoor zorgen dat het zich beter gedraagt door met andere voordelen te komen.

In deze tutorial laten we je 2 scripts zien die beide kunnen worden geladen op verschillende BBC micro:bits, zodat een van hen in de GiggleBot wordt geplaatst en met de andere worden de 2 knoppen gebruikt om door een menu te gaan en anders af te stemmen parameters. Het verzenden van deze bijgewerkte parameters gebeurt via de radio.

Stap 1: Vereiste componenten

Je hebt het volgende nodig:

1. Een GiggleBot-robot voor de micro:bit.
2. x3 AA-batterijen
3. x2 BBC micro:bits - een voor de GiggleBot en de andere als afstandsbediening voor het afstemmen van parameters.
4. Een batterij voor een BBC micro:bit - zoals degene die wordt geleverd in het BBC micro:bit-pakket.

Download hier de GiggleBot-robot voor de BBC micro:bit

Stap 2: De sporen en omgeving instellen

Je moet ook daadwerkelijk je tracks bouwen (tegels downloaden, printen, knippen en plakken) en vervolgens de omgeving instellen (de IDE en de runtime).

Aangezien deze tutorial erg verwant is aan deze andere tutorial getiteld GiggleBot Line Follower, ga je daarheen en volg je stap 2 en 3 en kom je dan hier terug.

Wat betreft de IDE, je kunt de Mu-editor gebruiken en voor de runtime moet je de GiggleBot MicroPython Runtime downloaden. De runtime kan hier worden gedownload van de documentatie. Ga naar het hoofdstuk Aan de slag in de documentatie en volg die instructies voor het instellen van de omgeving. Vanaf dit moment wordt versie v0.4.0 van de runtime gebruikt.

Stap 3: De GiggleBot instellen

Voordat je de runtime naar de GiggleBot flasht, moet je ervoor zorgen dat je de gewenste snelheid en updatesnelheid voor de GiggleBot hebt gekozen: standaard is de snelheid ingesteld op 100 (variabele base_speed) en de updatesnelheid is ingesteld op 70 (variabele update_rate).

Gezien de huidige implementatie is de hoogste updatesnelheid die kan worden bereikt 70 en als run_neopixels is ingesteld op True, is slechts 50 haalbaar. Dus in zekere zin zou je kunnen zeggen dat de standaard updatesnelheid precies op het randje ligt van wat de BBC micro:bit kan doen.

Even voor de goede orde: de lijnvolgersensor kan 100 keer per seconde updates retourneren.

Opmerking: het volgende script bevat mogelijk ontbrekende spaties en dit lijkt te wijten te zijn aan een probleem bij het weergeven van GitHub Gists. Klik op de kern om naar de GitHub-pagina te gaan waar u de code kunt kopiëren en plakken.

GiggleBot PID Line Follower Tuner (vereist een afstandsbediening om het af te stemmen) - xjfls23

van microbit-import*

van gigglebot-import*

van utime import sleep_ms, ticks_us

radio importeren

import ustruct

# initialiseer radio en GB neopixels

radio.op()

neo = init()

# timing

update_rate = 70

# standaard versterkingswaarden

Kp = 0,0

Ki = 0,0

Kd = 0,0

instelpunt =0.5

trigger_point =0.0

min_speed_percent =0,2

basissnelheid = 100

last_position = instelpunt

integraal =0.0

run_neopixels =False

center_pixel =5# waar de middelste pixel van de glimlach zich op de GB bevindt

# turkoois = tuple(map(lambda x: int(x / 5), (64, 224, 208))) # kleur die moet worden gebruikt om de fout met de neopixels te tekenen

# turkoois = (12, 44, 41) # wat precies de bovenstaande turkoois is die hierboven is becommentarieerd

error_width_per_pixel =0.5/3# max fout gedeeld door het aantal segmenten tussen elke neopixel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, kleinste_motor_power, hoogste_motor_power):

globale basissnelheid

if 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)

# hetzelfde als

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

motor_power = basis_snelheid * (kleinste_motor_power + (1- y) * (hoogste_motor_power - kleinste_motor_power))

retour motor_power

anders:

return base_speed * hoogste_motor_power

uitvoeren =False

previous_error = 0

totale_tijd =0.0

totaal aantal = 0

whileTrue:

# als knop a wordt ingedrukt, begin dan met volgen

if button_a.is_pressed():

rennen = True

# maar als knop b wordt ingedrukt, stop de lijnvolger

if button_b.is_pressed():

uitvoeren =False

integraal =0.0

vorige_fout =0.0

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

totale_tijd =0.0

totaal aantal = 0

pixels_off()

stop()

sleep_ms(500)

als uitvoeren waar is:

# lees de lijnsensoren

start_time = ticks_us()

# controleer of we de Kp/Kd-winsten hebben bijgewerkt met een afstandsbediening

proberen:

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

set_eyes()

behalveTypeError:

doorgang

rechts, links = read_sensor (LINE_SENSOR, BEIDE)

# lijn is aan de linkerkant wanneer positie < 0,5

# lijn is aan de rechterkant wanneer positie > 0,5

# lijn is in het midden wanneer positie = 0,5

# het is een gewogen rekenkundig gemiddelde

proberen:

positie = rechts / zwevend (links + rechts)

behalveZeroDivisionError:

positie =0.5

als positie ==0: positie =0.001

als positie ==1: positie =0.999

# gebruik een PD-controller

fout = positie - instelpunt

integraal += fout

correctie = Kp * fout + Ki * integraal + Kd * (fout - vorige_fout)

previous_error = fout

# bereken motorsnelheden

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

leftMotorSpeed = motor_speed + correctie

rightMotorSpeed = motor_speed - correctie

# verlicht de neopixels om te laten zien in welke richting de GiggleBot moet gaan

if run_neopixels isTrueand total_counts %3==0:

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

neo = (0, 0, 0)

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

ifabs(fout) > error_width_per_pixel * i:

als fout <0:

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

anders:

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

anders:

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

# verlicht de huidige pixel

als fout <0:

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

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

anders:

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

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

pauze

neo.show()

proberen:

# knip de motoren

indien linksMotortoerental >100:

linkerMotorSnelheid = 100

rechtsMotorSnelheid = rechtsMotorSnelheid - linksMotorSnelheid +100

indien juistMotortoerental >100:

rechts MotorSnelheid = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

indien linksMotorsnelheid <-100:

linkerMotorSnelheid =-100

indien rechtsMotorsnelheid <-100:

rechtsMotorSnelheid =-100

# activeer de motoren

set_speed (linksMotorSpeed, rechtsMotorSpeed)

rit()

# print((fout, motor_snelheid))

behalve:

# voor het geval we in een onoplosbaar probleem komen

doorgang

# en behoud de lusfrequentie

end_time = ticks_us()

delay_diff = (eindtijd - begintijd) /1000

total_time += delay_diff

totaal aantal +=1

if1.0/ update_rate - delay_diff >0:

slaap (1.0/ update_rate - delay_diff)

bekijk rawgigglebot_line_follower_tuner.py gehost met ❤ door GitHub

Stap 4: De tuner instellen (afstandsbediening)

Het volgende dat we moeten doen is het runtime + script flashen naar de 2e BBC micro:bit. Deze tweede micro:bit fungeert als een afstandsbediening voor de GiggleBot, die zal worden gebruikt om de volgende parameters af te stemmen:

1. Kp = proportionele versterking voor de PID-regelaar.
2. Ki = integrale versterking voor de PID-regelaar.
3. Kd = afgeleide versterking voor de PID-regelaar.
4. trigger_point = het punt uitgedrukt in percentages tussen de minimum- en maximumsnelheid van de GiggleBot waar de snelheid lineair begint af te nemen totdat deze de minimumsnelheid bereikt.
5. min_speed_percent = de minimum snelheid uitgedrukt in percentage van de maximum snelheid.

De andere 2 resterende variabelen die kunnen worden afgestemd, zijn direct hard gecodeerd in het script dat op de GiggleBot zit: de update_rate en base_speed die de maximale snelheid vertegenwoordigen. Zoals beschreven in de documentatie is de maximale snelheid die kan worden ingesteld voor de GiggleBot 100, wat ook de standaardwaarde is voor onze GiggleBot.

Opmerking: het volgende script bevat mogelijk ontbrekende spaties en dit lijkt te wijten te zijn aan een probleem bij het weergeven van GitHub Gists. Klik op de kern om naar de GitHub-pagina te gaan waar u de code kunt kopiëren en plakken.

GiggleBot Remote PID Line Follower Tuner (vereist het andere onderdeel) - xjfls23

van microbit-import*

van utime import sleep_ms

radio importeren

import ustruct

# 1e element is de Kp-winst

#2de element is de Ki gain

# 3e element is de Kd-versterking

# 4e element is het trigger_point voor motoren om de snelheid te verlagen (0 -> 1)

# 5e element is het min toerental voor motoren uitgedrukt in procenten (0 -> 1)

winst = [0.0, 0.0, 0.0, 1.0, 0.0]

stapgrootte = 0.1

# 0 en 1 voor 1e element

#2 en 3 voor 2e element

huidigeInstelling =0

defshowMenu():

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

radio.op()

laat het menu zien()

whileTrue:

bijgewerkt =False

if button_a.is_pressed():

huidige instelling = (huidige instelling +1) % (2*5)

bijgewerkt =True

if button_b.is_pressed():

als huidige instelling %2==0:

# verhoog de versterking wanneer de huidige instelling 0 of 2 is of..

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

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

anders:

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

anders:

# verhoog de versterking wanneer de huidige instelling 1 of 3 is of..

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

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

anders:

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

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

bijgewerkt =True

indien bijgewerkt:

laat het menu zien()

sleep_ms(200)

bekijk rawgigglebot_line_follower_configurator.py gehost met ❤ door GitHub

Stap 5: De GiggleBot afstemmen

Plaats de GiggleBot op de baan, zet hem aan en laat hem lopen. In de tussentijd moet je hem constant weer op de baan zetten en de gains/parameters afstemmen met de andere BBC micro:bit die je in je hand houdt.

Om de GiggleBot te starten, drukt u op knop A op de BBC micro:bit van de GiggleBot en om deze te stoppen en dus de status te resetten, drukt u op knop B.

Op de afstandsbediening BBC micro:bit, door op knop A te drukken, gaat u door elke optie in het menu en knop B verhoogt/verlaagt de corresponderende waarde. Het is alsof je de klok op het dashboard van een oude auto zet. De opties zijn als volgt:

1. 0-1 opties zijn voor de Kp-winst.
2. 2-3 opties zijn voor de Ki-winst.
3. 4-5 opties zijn voor de Kd-winst.
4. 6-7 opties zijn voor het instellen van het setpoint voor het moment dat de motoren beginnen te vertragen.
5. 8-9 opties zijn voor het instellen van de minimumsnelheid.

Houd er rekening mee dat even getallen in het menu zijn voor het verhogen van de bijbehorende waarden en voor de oneven is het precies het tegenovergestelde.

Wanneer u op knop B drukt op de BBC micro:bit van de GiggleBot, ziet u op het door Neopixel gemaakte scherm het aantal verstreken milliseconden sinds de laatste reset en het aantal cycli dat de robot heeft doorlopen - met deze 2 kunt u berekenen de updatesnelheid van de robot.

Als laatste en belangrijkste heb ik 2 tunings voor de GiggleBot bedacht. Een daarvan is voor wanneer de Neopixel-LED's zijn uitgeschakeld en de andere is voor wanneer het anders is. De Neopixel-LED's worden gebruikt om aan te geven in welke richting de fout zich heeft opgehoopt.

1e set voor het afstemmen van de parameters (met NeoPixel LED's uit)

1. Kp = 32,0
2. Ki = 0,5
3. Kd = 80,0
4. trigger_setpoint = 0.3 (dat is 30%)
5. min_speed_percent = 0.2 (wat 20% is)
6. base_speed = 100 (ook bekend als maximale snelheid)
7. update_rate = 70 (bij 70 Hz)

2e set voor het afstemmen van de parameters (met de NeoPixel-LED's aan)

1. Kp = 25.0
2. Ki = 0,5
3. Kd = 35.0
4. trigger_setpoint = 0.3 (dat is 30%)
5. min_speed_percent = 0.3 (wat 30% is)
6. base_speed = 70 (ook bekend als maximale snelheid)
7. update_rate = 50 (bij 50Hz)
8. Ook moet de variabele run_neopixels worden ingesteld op True in het script dat wordt geladen op de BBC micro:bit van de GiggleBot. Hierdoor gaan de NeoPixel-leds zo knipperen dat ze aangeven in welke richting de fout zich ophoopt.

Stap 6: GiggleBot draait met de NeoPixels uitgeschakeld

Dit is een voorbeeld van het uitvoeren van de GiggleBot met de eerste afstemmingsparameters die in de vorige stap zijn gevonden. In dit voorbeeld zijn de NeoPixel-LED's uitgeschakeld.

Stap 7: GiggleBot draait met de Neopixels ingeschakeld

Dit is een voorbeeld van het uitvoeren van de GiggleBot met de 2e set afstemmingsparameters die u in stap 5 vindt. In dit voorbeeld zijn de NeoPixel-LED's ingeschakeld.

Merk op hoe in dit voorbeeld de GiggleBot het moeilijker heeft om de lijn te volgen - dat komt omdat de Neopixel-LED's de CPU-tijd van de BBC micro:bit "opeten". Daarom moesten we de updatesnelheid verlagen van 70 naar 50.