GiggleBot Line'i jälgija Pythoni abil: 5 sammu

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:48

Seekord programmeerime MicroPythonis Dexter Industries GiggleBoti, et järgida musta joont, kasutades selle sisseehitatud joonejälgija andurit.

GiggleBot peab olema ühendatud BBC mikro: bitiga, et seda õigesti juhtida.

Kui see õpetus on teie jaoks liiga arenenud ja GiggleBoti programmeerimine on praegu liiga palju, võite alati läbi vaadata stardijuhendi, mis näitab teile, kuidas saab siin MakeCode'is robotit programmeerida. Lingitud õpetus tutvustab teile põhitõdesid.

Samm: nõutavad komponendid

Vaja on järgmisi riistvarakomponente:

1. x3 AA patareid - minu puhul kasutan laetavaid patareisid, mille pinge on üldiselt madalam.
2. Dexter Industries GiggleBot robot micro: bitile.
3. BBC mikro: bit.

Muidugi on BBC micro: bit programmeerimiseks vaja ka mikro -USB -kaablit - see kaabel kuulub tavaliselt BBC micro: bit paketti või võite alati kasutada seda, mida kasutatakse (Android) nutitelefonide laadimiseks.

Hankige GiggleBot micro: bit jaoks siit

2. samm: seadistage rajad

Peate läbima mõne plaadi printimise ja oma lugude kujundamise. Võite kasutada meie enda plaate, nii et olete 100% kindel, et kordate meie tingimusi. Või kui tunnete end seiklushimulisena, võite kasutada mõnda musta linti ja teha oma. Siin on meie kasutatud plaatide PDF.

Ülaltoodud rada koosneb järgmisest arvust erinevatest plaatidest:

• 12 tüüpi plaate 1.
• 5 tüüpi plaate nr 2.
• 3 plaatide tüüpi nr 5 malli.
• 3 plaaditüüpi nr 6 malli - siin saate ühe täiendava plaadi.

Järgmisena printige need ja lõigake need. Proovige need paigutada nagu ülaltoodud fotol ja pidage meeles, et raja paremas ülanurgas peavad kaks plaati üksteisega kattuma - seda oodatakse juhuks, kui te ei tea, kas teete midagi valesti.

3. samm: keskkonna seadistamine

Selleks, et saaksite MicroPythonis programmeerida BBC mikro: bit, peate selle jaoks seadistama redaktori (Mu Editor) ja seadistama käitusajaks GiggleBot MicroPython Runtime. Selleks peate järgima sellel lehel olevaid juhiseid. Sellest hetkest alates kasutatakse käitusaja versiooni v0.4.0.

4. samm: GiggleBoti programmeerimine

Enne selle juurde asumist sisaldab GiggleBot MicroPython käitusaeg BBC micro: bit'i ja muude teekide klassikalist käitusaega GiggleBoti ja teiste Dexter Industries Sensorite toetamiseks.

Pärast selle seadistamist avage Mu -redaktoris järgmine skript ja klõpsake nuppu Flash. See vilgutab GiggleBot MicroPython Runtime'i ja skripti, mille olete just oma BBC mikro: bitile avanud. Skript on näidatud ka allpool.

Kui vilkuv protsess on tehtud, virnastage BBC micro: bit GiggleBot'i nii, et tahvli neopikslid oleksid ettepoole suunatud, asetage see rajale ja lülitage see sisse.

Pange tähele, et skriptis on PID ja teised 2 konstandit (kiiruse seadeväärtus ja minimaalsed kiiruskonstandid) juba seatud.

Märkus. Järgmisel skriptil võib olla tühikuid ja see näib olevat tingitud mõnest probleemist GitHubi esitusviiside kuvamisel. GitHubi lehele viimiseks klõpsake põhisisu, kus saate koodi kopeerida ja kleepida.

GiggleBot PID rea jälgija - häälestatud koos NeoPikslitega

mikrobitite impordist*

gigglebot'i impordist*

utime impordist sleep_ms, ticks_us

impordi ustruktuur

# lähtestage GB neopikslid

neo = init ()

# ajastus

update_rate = 50

# võimendust/konstanti (eeldades, et aku pinge on umbes 4,0 volti)

Kp = 25,0

Ki = 0,5

Kd = 35,0

päästiku_punkt = 0,3

min_kiiruse_protsent = 0,3

baaskiirus = 70

seadeväärtus = 0,5

viimane_asend = seadeväärtus

integraal = 0,0

run_neopixels = Tõsi

center_pixel = 5# kus naeratuse keskne piksel asub GB -l

# türkiissinine = tuple (kaart (lambda x: int (x / 5), (64, 224, 208))) # värv, mida kasutatakse vea joonistamiseks neopikslitega

# türkiis = (12, 44, 41) # mis on täpselt ülaltoodud türkiissinine

error_width_per_pixel = 0,5/3# max viga jagatud segmentide arvuga iga neopikseli vahel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, ülemine_bound, väikseim_mootori võimsus, kõrgeim_mootori_võimsus):

globaalne baaskiirus

kui abs_error> = trigger_point:

# x0 = 0,0

# y0 = 0,0

# x1 = ülemine_piir - päästiku_punkt

# y1 = 1,0

# x = abs_error - trigger_point

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

# sama nagu

y = (abs_error - trigger_point) / (ülemine_piir - trigger_point)

mootori_võimsus = baaskiirus * (väikseim_mootori_võimsus + (1 -a) * (suurim_mootori_võimsus - väikseim_mootori_võimsus))

tagastada mootor_võimsus

muidu:

tagastage baaskiirus * suurim_mootori_võimsus

joosta = vale

eelmine_viga = 0

Kuigi tõsi:

# kui vajutate nuppu a, alustage järgimist

kui button_a.is_pressed ():

joosta = Tõsi

# aga kui nuppu b vajutatakse, peatage joone järgija

kui button_b.is_pressed ():

joosta = vale

integraal = 0,0

eelmine_viga = 0,0

pixels_off ()

peatus ()

uni_ms (500)

kui run isTrue:

# loe liiniandureid

algus_aeg = puugid_ (()

parem, vasak = lugemisandur (LINE_SENSOR, MÕLEM)

# rida on vasakul, kui positsioon <0,5

# rida on paremal, kui positsioon> 0,5

# rida on keskel, kui positsioon = 0,5

# see on kaalutud keskmine aritmeetiline

proovige:

asend = parem /ujuk (vasak + parem)

välja arvatud ZeroDivisionError:

positsioon = 0,5

# vahemik peab olema (0, 1) ja mitte [0, 1]

kui positsioon == 0: positsioon = 0,001

kui positsioon == 1: positsioon = 0,999

# kasutage PD -kontrollerit

viga = asukoht - seadeväärtus

integraal += viga

parandus = Kp * viga + Ki * integraal + Kd * (viga - eelmine_viga)

eelmine_viga = viga

# arvutage mootori kiirused

mootorikiirus = ülemine_piiratud_jooneline_kiiruse vähendaja (abs (viga), seadeväärtus * käivituspunkt, seadepunkt, minikiiruse protsent, 1.0)

leftMotorSpeed = mootorikiirus + parandus

rightMotorSpeed = mootor_kiirus - parandus

# sütti neopikslid vastavalt antud veale

kui run_neopixels isTrueand total_counts %3 == 0:

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

neo = (0, 0, 0)

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

ifabs (viga)> error_width_per_pixel * i:

kui viga <0:

# neo [center_pixel + i] = türkiissinine

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

muidu:

# neo [center_pixel - i] = türkiissinine

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

muidu:

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

# süttib praegune piksel

kui viga <0:

# neo [center_pixel + i] = tuple (kaart (lambda x: int (x * protsent), türkiissinine))

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

muidu:

# neo [center_pixel - i] = tuple (kaart (lambda x: int (x * protsent), türkiissinine))

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

murda

neo.show ()

proovige:

# kärpige mootori kiirust

kui vasakuleMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

kui õigeMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

kui vasakule Mootorikiirus <-100:

leftMotorSpeed = -100

kui õigeMotorSpeed <-100:

rightMotorSpeed = -100

# käivitage mootorid

set_speed (leftMotorSpeed, rightMotorSpeed)

sõitma ()

# print ((viga, mootori kiirus))

välja arvatud:

# juhuks, kui satume mõne parandamatu probleemi juurde

üle andma

# ja säilitage silmuse sagedus

end_time = ticks_us ()

delay_diff = (lõpuaeg - algusaeg) /1000

if1000.0/ update_rate - delay_diff> 0:

unerežiim (1000.0/ update_rate - delay_diff)

vaata rawgigglebot_tuned_line_follower.py, mille hostiks on GitHub ❤

Samm: laske sellel käituda

BBC mikro -l on kaks nuppu: bit: nupp A ja nupp B:

• Nupu A vajutamine paneb GiggleBoti järgima joont (kui see on olemas).
• Nupu B vajutamine peatab GiggleBoti ja lähtestab kõik, et saaksite seda uuesti kasutada.

Soovitatav on GiggleBotit mitte tõsta, kui see joont järgib, ja seejärel uuesti selle peale panna, sest arvutusviga võib koguneda ja roboti marsruudi täielikult segi ajada. Kui soovite seda tõsta, vajutage nuppu B ja seejärel tagasi pannes uuesti nuppu A.