GiggleBot -lynvolgers met behulp van Python: 5 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:25

Hierdie keer programmeer ons in MicroPython die Dexter Industries GiggleBot om 'n swart lyn te volg met behulp van die ingeboude lynvolgersensor.

Die GiggleBot moet gekoppel word aan 'n BBC micro: bit sodat dit behoorlik beheer kan word.

As hierdie tutoriaal vir u te gevorderd is en die programmering van die GiggleBot vir eers te veel is, kan u altyd die begin -tutoriaal lees wat u wys hoe die robot hier in MakeCode geprogrammeer kan word. Die gekoppelde tutoriaal lei u deur die basiese beginsels.

Stap 1: Vereiste komponente

Die volgende hardeware -komponente word benodig:

1. x3 AA -batterye - in my geval gebruik ek herlaaibare batterye met 'n laer spanning in die algemeen.
2. 'N Dexter Industries GiggleBot -robot vir die micro: bit.
3. 'N BBC -mikro: bietjie.

U het natuurlik ook 'n mikro -USB -kabel nodig om die BBC micro: bit te programmeer - hierdie kabel kom gewoonlik in die pakket van die BBC micro: bit, of u kan altyd een gebruik om laai (Android) slimfone.

Kry die GiggleBot vir die mikro: bietjie hier

Stap 2: Stel die snitte op

U sal 'n paar teëls moet druk en u eie snitte ontwerp. U kan ons eie teëls gebruik sodat u 100% seker is dat u ons voorwaardes herhaal. Of as u avontuurlustig voel, kan u swart tape gebruik en u eie maak. Hier is die PDF vir die teëls wat ons gebruik het.

Bogenoemde snit bestaan uit die volgende aantal verskillende teëls:

• 12 teëls van tipe 1.
• 5 teëls van tipe #2.
• 3 sjablone van tipe teël #5.
• 3 sjablone van teëltipe #6 - hier kry u een ekstra teël.

Druk dit dan af en sny dit. Probeer om hulle soos op die foto hierbo te plaas, en hou in gedagte dat twee teëls aan die regterkant van die baan mekaar moet oorvleuel - dit word verwag as u wonder of u iets verkeerd doen.

Stap 3: Die opstel van die omgewing

Om die BBC micro: bit in MicroPython te kan programmeer, moet u 'n redakteur daarvoor opstel (die Mu Editor) en die GiggleBot MicroPython Runtime as tydsduur daarvan stel. Hiervoor moet u die instruksies op hierdie bladsy volg. Vanaf hierdie oomblik word weergawe v0.4.0 van die tydsduur gebruik.

Stap 4: Die programmering van die GiggleBot

Voordat u dit regkry, bevat die GiggleBot MicroPython -runtime die klassieke runtime vir die BBC micro: bit en ander biblioteke om die GiggleBot en ander Dexter Industries Sensors te ondersteun.

Nadat u dit opgestel het, maak die volgende script in die Mu -redakteur oop en klik op Flash. Dit flits die GiggleBot MicroPython Runtime en die script wat u pas oopgemaak het vir u BBC micro: bit. Die draaiboek word ook hieronder getoon.

Sodra die flitsproses voltooi is, stapel die BBC micro: bit in die GiggleBot met die neopixels van die bord vorentoe, plaas dit op die baan en skakel dit aan.

Let op dat die PID en ander 2 konstantes (die snelheidsinstelpunt en minimumsnelheidskonstante) in die script reeds ingestel is.

Let wel: die volgende skrip ontbreek moontlik witruimtes, en dit lyk asof dit 'n probleem is met die vertoning van GitHub Gists. Klik op die kern om u na die GitHub-bladsy te neem, waar u die kode kan kopieer en plak.

GiggleBot PID -lynvolgers - gestem met NeoPixels

vanaf mikrobit -invoer*

vanaf gigglebot invoer*

invoer slaap_ms, bosluise_us vanaf die ou tyd

invoerstruktuur

# initialiseer GB -neopixels

neo = init ()

# tydsberekening

update_rate = 50

# winste/konstantes (as die batteryspanning ongeveer 4,0 volt is)

Kp = 25,0

Ki = 0,5

Kd = 35,0

trigger_point = 0,3

min_snelheidspersent = 0,3

base_speed = 70

setpoint = 0,5

last_position = setpoint

integraal = 0.0

run_neopixels = Waar

center_pixel = 5# waar die middelste pixel van die glimlag op die GB geleë is

# turkoois = tupel (kaart (lambda x: int (x / 5), (64, 224, 208))) # kleur om te gebruik om die fout met die neopixels te teken

# turkoois = (12, 44, 41) # wat presies die bogenoemde turkoois hierbo is

error_width_per_pixel = 0.5/3# maksimum fout gedeel deur die aantal segmente tussen elke neopixel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, smallest_motor_power, highest_motor_power):

globale basis_snelheid

as abs_fout> = trigger_point:

# x0 = 0.0

# y0 = 0.0

# x1 = boonste_gebonde - snellerpunt

# y1 = 1.0

# x = abs_fout - trigger_point

# y = y0 + (x - x0) * (y1 - y0) / (x1 - x0)

# dieselfde as

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

motorpower = basisspoed * (kleinste_motorpower + (1- y) * (hoogste_motorpower - kleinste_motorpower))

stuur motorkrag terug

anders:

gee basissnelheid terug * hoogste_motoriese krag

hardloop = Onwaar

vorige_fout = 0

terwyl dit waar is:

# as knoppie a gedruk word, begin dan volg

as button_a.is_pressed ():

hardloop = waar

# maar as die knoppie b ingedruk word, stop die lynvolger

as button_b.is_pressed ():

hardloop = Onwaar

integraal = 0.0

vorige_fout = 0.0

pixels_off ()

stop ()

slaap_ms (500)

as run isTrue:

# lees die lynsensors

start_time = ticks_us ()

regs, links = lees_sensor (LINE_SENSOR, BEIDE)

# lyn is aan die linkerkant as posisie <0.5

# lyn is aan die regterkant as posisie> 0.5

# lyn is in die middel as posisie = 0,5

# dit is 'n geweegde rekenkundige gemiddelde

probeer:

posisie = regs /dryf (links + regs)

behalwe ZeroDivisionError:

posisie = 0,5

# die omvang moet (0, 1) wees en nie [0, 1]

as posisie == 0: posisie = 0.001

as posisie == 1: posisie = 0,999

# gebruik 'n PD -beheerder

fout = posisie - setpoint

integraal += fout

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

vorige_fout = fout

# bereken motorsnelhede

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

leftMotorSpeed = motor_speed + regstelling

rightMotorSpeed = motor_speed - regstelling

# lig die neopixels op volgens die gegewe fout

as run_neopixels waar is en totale_getalle %3 == 0:

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

neo = (0, 0, 0)

vir i inb '\ x00 / x01 / x02 / x03':

ifabs (fout)> error_width_per_pixel * i:

as 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:

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

# lig die huidige pixel op

as fout <0:

# neo [center_pixel + i] = tuple (kaart (lambda x: int (x * persentasie), turkoois))

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

anders:

# neo [middel_pixel - i] = tupel (kaart (lambda x: int (x * persentasie), turkoois))

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

breek

neo.show ()

probeer:

# knip die motorsnelhede

as linksMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

as dit reg is MotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - regsMotorSpeed +100

as linksMotorSpeed <-100:

leftMotorSpeed = -100

as dit reg is MotorSpeed <-100:

rightMotorSpeed = -100

# aktiveer die motors

set_speed (leftMotorSpeed, rightMotorSpeed)

ry ()

# druk ((fout, motorsnelheid))

behalwe:

# ingeval ons 'n onoplosbare probleem ondervind

slaag

# en handhaaf die lusfrekwensie

end_time = ticks_us ()

delay_diff = (end_time - start_time) /1000

if1000.0/ update_rate - delay_diff> 0:

slaap (1000.0/ update_rate - delay_diff)

sien rawgigglebot_tuned_line_follower.py aangebied deur ❤ deur GitHub

Stap 5: Laat dit loop

Daar is 2 knoppies op die BBC micro: bit: knoppie A en knoppie B:

• Deur op knoppie A te druk, stel die GiggleBot die lyn (as daar een is).
• Deur op knoppie B te druk, stop die GiggleBot en herstel alles sodat u dit weer kan gebruik.

Dit word sterk aanbeveel om nie die GiggleBot op te lig terwyl dit 'n lyn volg nie, en dit dan weer daarop plaas, want die berekeningsfout kan die roete van die robot ophoop en heeltemal verwoes. As u dit wil lig, druk op knoppie B en druk dan weer op A wanneer u dit terugsit.