INHOUDSOPGAWE:
2025 Outeur: John Day | [email protected]. Laas verander: 2025-01-13 06:56
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:
- x3 AA -batterye - in my geval gebruik ek herlaaibare batterye met 'n laer spanning in die algemeen.
- 'N Dexter Industries GiggleBot -robot vir die micro: bit.
- '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.