GiggleBot līnijas sekotājs, izmantojot Python: 5 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:55

Šoreiz mēs programmā MicroPython Dexter Industries GiggleBot sekojam melnai līnijai, izmantojot iebūvēto līnijas sekotāja sensoru.

Lai to pareizi kontrolētu, GiggleBot ir jāsavieno pārī ar BBC micro: bit.

Ja šī apmācība jums ir pārāk attīstīta un GiggleBot programmēšana pagaidām ir par daudz, jūs vienmēr varat izlasīt sākuma apmācību, kas parāda, kā robotu var ieprogrammēt šeit MakeCode. Saistītā apmācība iepazīstinās jūs ar pašiem pamatiem.

1. darbība. Nepieciešamās sastāvdaļas

Nepieciešami šādi aparatūras komponenti:

1. x3 AA baterijas - manā gadījumā es izmantoju uzlādējamas baterijas, kurām kopumā ir zemāks spriegums.
2. Dexter Industries GiggleBot robots micro: bit.
3. BBC mikro: bit.

Protams, jums ir nepieciešams arī mikro USB kabelis, lai ieprogrammētu BBC micro: bit - šis kabelis parasti ir iekļauts BBC micro: bit iepakojumā, vai arī jūs vienmēr varat izmantot vienu, kas tiek izmantots (Android) viedtālruņu uzlādēšanai.

Iegūstiet GiggleBot for micro: bit šeit

2. darbība: iestatiet dziesmas

Jums būs jāiziet dažu flīžu drukāšana un jāizveido savas dziesmas. Jūs varat izmantot mūsu pašu flīzes, lai būtu 100% pārliecināts, ka atkārtojat mūsu nosacījumus. Vai arī, ja jūtaties piedzīvojumu pilns, varat izmantot melnu lenti un izveidot savu. Šeit ir mūsu izmantoto flīžu PDF fails.

Iepriekšējais celiņš sastāv no šāda skaita dažādu flīžu:

• 12 1. tipa flīzes.
• 5 2. tipa flīzes.
• 3 flīžu tipa #5 veidnes.
• 3 6. tipa flīžu veidnes - šeit jūs iegūsit vienu papildu flīzi.

Tālāk izdrukājiet tos un sagrieziet. Mēģiniet tos novietot tāpat kā iepriekš redzamajā fotoattēlā un paturiet prātā, ka trases labajā augšējā malā 2 flīzēm ir jāpārklājas viena ar otru - tas ir sagaidāms, ja rodas jautājums, vai darāt kaut ko nepareizi.

3. darbība: vides iestatīšana

Lai jūs varētu programmēt BBC micro: bit programmā MicroPython, jums ir jāizveido tam redaktors (Mu redaktors) un kā izpildlaiks jāiestata GiggleBot MicroPython Runtime. Lai to izdarītu, jums jāievēro šajā lapā sniegtie norādījumi. No šī brīža tiek izmantota izpildlaika versija v0.4.0.

4. solis: GiggleBot programmēšana

Pirms ķerties pie tā, GiggleBot MicroPython izpildlaiks satur klasisko izpildlaiku BBC micro: bit un citām bibliotēkām, lai atbalstītu GiggleBot un citus Dexter Industries Sensorus.

Pēc tā iestatīšanas atveriet šo skriptu Mu redaktorā un noklikšķiniet uz Flash. Tas mirgos GiggleBot MicroPython Runtime un skriptu, ko tikko atvērāt savam BBC micro: bit. Skripts ir parādīts arī zemāk.

Kad mirgošanas process ir pabeigts, sakraujiet BBC micro: bit GiggleBot ar tāfeles neopikseļiem uz priekšu, novietojiet to uz sliežu ceļa un ieslēdziet to.

Ievērojiet, ka skriptā PID un citas 2 konstantes (ātruma uzdotā vērtība un minimālās ātruma konstantes) jau ir iestatītas.

Piezīme. Šim skriptam, iespējams, trūkst atstarpes, un šķiet, ka tas ir saistīts ar kādu problēmu, parādot GitHub Gists. Noklikšķiniet uz būtības, lai nokļūtu tās GitHub lapā, kur varat kopēt un ielīmēt kodu.

GiggleBot PID līnijas sekotājs - noregulēts ar NeoPikseļiem

no mikrobitu importa*

no gigglebot importēšanas*

no utime importēt sleep_ms, ticks_us

importēt ustruktu

# inicializējiet GB neopikseļus

neo = init ()

# laiks

update_rate = 50

# pieaugums/konstante (pieņemot, ka akumulatora spriegums ir aptuveni 4,0 volti)

Kp = 25,0

Ki = 0,5

Kd = 35,0

sprūda_punkts = 0,3

min_speed_percent = 0.3

bāzes_ātrums = 70

uzdotā vērtība = 0,5

last_position = uzdotā vērtība

integrālis = 0,0

run_neopixels = Patiesa

center_pixel = 5# kur smaida centrālais pikselis atrodas GB

# tirkīzs = kortekss (karte (lambda x: int (x / 5), (64, 224, 208))) # krāsa, ko izmantot, lai uzzīmētu kļūdu ar neopikseliem

# tirkīzs = (12, 44, 41) # kas ir tieši iepriekš aprakstītais tirkīzs

error_width_per_pixel = 0.5/3# max kļūda dalīta ar segmentu skaitu starp katru neopikseli

defupper_bound_linear_speed_reducer (abs_error, trigger_point, ylä_bound, mazākais_motor_power, augstākais_motor_power):

globālais bāzes ātrums

ja abs_error> = trigger_point:

# x0 = 0,0

# y0 = 0,0

# x1 = augšējā robeža - sprūda_punkts

# y1 = 1,0

# x = abs_error - trigger_point

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

# tāds pats kā

y = (abs_kļūda - sprūda_punkts) / (augšējā_pozīcija - sprūda_punkts)

motora_jauda = bāzes_ātrums * (mazākais_motora_jauda + (1 -g) * (augstākā_motora_jauda - mazākā_motora_jauda))

atgriezt motor_power

cits:

atgriezt bāzes_speed * lielāko_motora_jaudu

palaist = Nepareizi

iepriekšējā_kļūda = 0

kamēr patiesība:

# ja tiek nospiesta poga a, sāciet sekot

ja poga_a.is_piespiesta ():

palaist = taisnība

# bet, ja tiek nospiesta poga b, apturiet līnijas sekotāju

ja poga_b.is_piespiesta ():

palaist = Nepareizi

integrālis = 0,0

iepriekšējā_kļūda = 0,0

pixels_off ()

apstāties ()

miega_ms (500)

ja palaist isTrue:

#lasiet līnijas sensorus

start_time = ticks_us ()

pa labi, pa kreisi = lasīšanas sensors (LINE_SENSOR, ABET)

# līnija atrodas kreisajā pusē, ja pozīcija ir <0,5

# līnija atrodas labajā pusē, ja pozīcija> 0,5

# līnija atrodas vidū, kad pozīcija = 0,5

# tas ir vidējais svērtais aritmētiskais

pamēģini:

pozīcija = labais /pludiņš (pa kreisi + pa labi)

izņemot ZeroDivisionError:

pozīcija = 0,5

# diapazonam ir jābūt (0, 1), nevis [0, 1]

ja pozīcija == 0: pozīcija = 0,001

ja pozīcija == 1: pozīcija = 0,999

# izmantojiet PD kontrolieri

kļūda = pozīcija - uzdotā vērtība

integrālis += kļūda

labojums = Kp * kļūda + Ki * integrālis + Kd * (kļūda - iepriekšējā_kļūda)

iepriekšējā_kļūda = kļūda

# aprēķiniet motora apgriezienus

motora ātrums = augšējais_saistītais_ lineārais_ātruma samazinātājs (abs (kļūda), uzdotā vērtība * sprūda_punkts, iestatītā vērtība, min_speed_percent, 1.0)

leftMotorSpeed = motor_speed + korekcija

rightMotorSpeed = motor_speed - korekcija

# iedegas neopikseļi atbilstoši dotajai kļūdai

ja 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':

ifabs (kļūda)> error_width_per_pixel * i:

ja kļūda <0:

# neo [centrs_pixel + i] = tirkīza

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

cits:

# neo [centrs_pixel - i] = tirkīza

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

cits:

procenti = 1- (error_width_per_pixel * i -abs (kļūda)) / error_width_per_pixel

# iedegas pašreizējais pikselis

ja kļūda <0:

# neo [center_pixel + i] = kortele (karte (lambda x: int (x * procenti), tirkīza krāsa))

neo [centra_pikseļi + i] = (int (64* procenti /5), int (224* procenti /5), int (208* procenti /5))

cits:

# neo [center_pixel - i] = karte (karte (lambda x: int (x * procenti), tirkīza krāsa))

neo [centra_pikseļi - i] = (int (64* procenti /5), int (224* procenti /5), int (208* procenti /5))

pārtraukums

neo.show ()

pamēģini:

# saīsiniet motora apgriezienus

ja pa kreisiMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - pa kreisiMotorSpeed +100

ja rightMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

ja pa kreisiMotora ātrums <-100:

leftMotorSpeed = -100

ja pareiziMotorSpeed <-100:

rightMotorSpeed = -100

# iedarbiniet motorus

set_speed (leftMotorSpeed, rightMotorSpeed)

braukt ()

# drukāt ((kļūda, motora ātrums))

izņemot:

# gadījumā, ja mēs nonākam pie kādas nefiksējamas problēmas

iziet

# un saglabājiet cilpas frekvenci

end_time = ticks_us ()

delay_diff = (beigu laiks - sākuma laiks) /1000

if1000.0/ update_rate - delay_diff> 0:

miega režīms (1000.0/ update_rate - delay_diff)

skatīt rawgigglebot_tuned_line_follower.py, ko mitina GitHub ar ❤

5. darbība. Ļaujiet tai darboties

BBC mikro ir divas pogas: bit: poga A un poga B:

• Nospiežot pogu A, GiggleBot seko līnijai (ja tāda ir).
• Nospiežot pogu B, GiggleBot tiek apturēts un viss tiek atiestatīts, lai jūs varētu to atkal izmantot.

Ir ļoti ieteicams nepacelt GiggleBot, kamēr tā seko līnijai, un pēc tam to atkal uzlikt, jo aprēķināšanas kļūda var uzkrāties un pilnībā izjaukt robota maršrutu. Ja vēlaties to pacelt, nospiediet pogu B un tad, kad to ievietojat atpakaļ, vēlreiz nospiediet A.