GiggleBot-regelvolger met Python: 5 stappen

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

Deze keer programmeren we in MicroPython de Dexter Industries GiggleBot om een zwarte lijn te volgen met behulp van de ingebouwde lijnvolgersensor.

De GiggleBot moet worden gekoppeld aan een BBC micro:bit om op de juiste manier te kunnen worden bestuurd.

Als deze tutorial te geavanceerd voor je is en het programmeren van de GiggleBot voor nu te veel is, kun je altijd de starterstutorial doorlopen die je laat zien hoe de robot kan worden geprogrammeerd in MakeCode hier. De gekoppelde zelfstudie leidt u door de basisprincipes.

Stap 1: Vereiste componenten

De volgende hardwarecomponenten zijn vereist:

1. x3 AA-batterijen - in mijn geval gebruik ik oplaadbare batterijen die over het algemeen een lagere spanning hebben.
2. Een Dexter Industries GiggleBot-robot voor de micro:bit.
3. Een BBC-micro:bit.

Natuurlijk heb je ook een micro-USB-kabel nodig om de BBC micro:bit te programmeren - deze kabel zit meestal in het BBC micro:bit-pakket of je kunt er altijd een gebruiken die wordt gebruikt voor het opladen van (Android-)smartphones.

Download hier de GiggleBot voor de micro:bit

Stap 2: Stel de sporen in

Je zult een aantal tegels moeten printen en je eigen tracks moeten ontwerpen. U kunt onze eigen tegels gebruiken, zodat u 100% zeker weet dat u onze voorwaarden repliceert. Of als je avontuurlijk bent, kun je wat zwarte tape gebruiken en er zelf een maken. Hier is de PDF voor de tegels die we hebben gebruikt.

Het bovenstaande spoor bestaat uit het volgende aantal verschillende tegels:

• 12 tegels van het type #1.
• 5 tegels van het type #2.
• 3 sjablonen van tegeltype #5.
• 3 sjablonen van tegeltype #6 - hier krijg je een extra tegel.

Druk ze vervolgens af en knip ze uit. Probeer ze te plaatsen zoals op de bovenstaande foto en houd er rekening mee dat aan de rechterbovenkant van de baan 2 tegels elkaar moeten overlappen - dit wordt verwacht voor het geval je je afvraagt of je iets verkeerd doet.

Stap 3: De omgeving instellen

Om de BBC micro:bit in MicroPython te kunnen programmeren, moet je er een editor voor instellen (de Mu Editor) en de GiggleBot MicroPython Runtime als runtime instellen. Daarvoor moet je de instructies op deze pagina volgen. Vanaf dit moment wordt versie v0.4.0 van de runtime gebruikt.

Stap 4: De GiggleBot programmeren

Voordat we ermee aan de slag gaan, bevat de GiggleBot MicroPython-runtime de klassieke runtime voor de BBC micro:bit en andere bibliotheken om de GiggleBot en andere Dexter Industries-sensoren te ondersteunen.

Nadat je het hebt ingesteld, open je het volgende script in de Mu-editor en klik je op Flash. Hiermee flitst de GiggleBot MicroPython Runtime en het script dat je zojuist hebt geopend voor je BBC micro:bit. Het script wordt ook hieronder weergegeven.

Zodra het knipperen is voltooid, stapelt u de BBC micro:bit in de GiggleBot met de neopixels van het bord naar voren gericht, plaatst u deze op de baan en schakelt u hem in.

Merk op dat in het script de PID en andere 2 constanten (het toerentalsetpoint en minimum toerentalconstanten) al zijn ingesteld.

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-lijnvolger - afgestemd met NeoPixels

van microbit-import*

van gigglebot-import*

van utime import sleep_ms, ticks_us

import ustruct

# initialiseer GB neopixels

neo = init()

# timing

update_rate = 50

# versterkingen/constanten (ervan uitgaande dat de batterijspanning ongeveer 4,0 volt is)

Kp = 25.0

Ki = 0,5

Kd = 35.0

trigger_point =0.3

min_speed_percent =0.3

basissnelheid = 70

instelpunt =0.5

last_position = instelpunt

integraal =0.0

run_neopixels =True

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

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

pixels_off()

stop()

sleep_ms(500)

als uitvoeren waar is:

# lees de lijnsensoren

start_time = ticks_us()

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

# het bereik moet (0, 1) zijn en niet [0, 1]

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 volgens de gegeven fout

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] = turkoois

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

anders:

# neo[center_pixel - i] = turkoois

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(64* procent /5), int(224* procent /5), int(208* procent /5))

anders:

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

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

pauze

neo.show()

proberen:

# clip de motorsnelheden

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

if1000.0/ update_rate - delay_diff >0:

slaap (100.0/update_rate - delay_diff)

bekijk rawgigglebot_tuned_line_follower.py gehost met ❤ door GitHub

Stap 5: Het laten lopen

Er zijn 2 knoppen op de BBC micro:bit: knop A en knop B:

• Door op knop A te drukken, laat de GiggleBot de lijn volgen (als die er is).
• Door op knop B te drukken stopt de GiggleBot en reset alles zodat je hem weer kunt gebruiken.

Het wordt ten zeerste aangeraden om de GiggleBot niet op te tillen terwijl hij een lijn volgt en hem er dan weer op te plaatsen, omdat de fout die wordt berekend zich kan ophopen en de route van de robot volledig kan verstoren. Als u hem wilt optillen, drukt u op knop B en als u hem weer terugplaatst, drukt u nogmaals op A.