Ndjekësi i linjës GiggleBot duke përdorur Python: 5 hapa

2024 Autor: John Day | [email protected]. E modifikuara e fundit: 2024-01-30 12:18

Këtë herë, ne po programojmë në MicroPython Dexter Industries GiggleBot për të ndjekur një vijë të zezë duke përdorur sensorin e saj të integruar të ndjekësve.

GiggleBot duhet të çiftohet me një mikro BBC: bit në mënyrë që të kontrollohet në mënyrë të përshtatshme.

Nëse ky mësim është shumë i avancuar për ju dhe programimi i GiggleBot është shumë tani për tani, gjithmonë mund të kaloni tutorialin fillestar që ju tregon se si roboti mund të programohet në MakeCode këtu. Udhëzuesi i lidhur do t'ju përcjellë me bazat.

Hapi 1: Komponentët e kërkuar

Kërkohen përbërësit e mëposhtëm të harduerit:

1. x3 bateri AA - në rastin tim unë po përdor bateri të rimbushshme të cilat kanë një tension më të ulët në përgjithësi.
2. Një robot Dexter Industries GiggleBot për mikro: bit.
3. Një mikro e BBC: pak.

Sigurisht, ju gjithashtu keni nevojë për një kabllo mikro USB për të programuar mikro BBC: bit - ky kabllo në përgjithësi vjen brenda paketës së mikro BBC: bit ose gjithmonë mund të përdorni atë që përdoret për karikimin e telefonave inteligjentë (Android).

Merrni GiggleBot për mikro: pak këtu

Hapi 2: Vendosni gjurmët

Ju do të duhet të kaloni nëpër shtypjen e disa pllakave dhe hartimin e gjurmëve tuaja. Ju mund të përdorni pllakat tona në mënyrë që të jeni 100% të sigurtë se po përsëritni kushtet tona. Ose nëse ndiheni aventurierë, mund të përdorni ndonjë kasetë të zezë dhe ta bëni vetë. Këtu është PDF për pllakat që kemi përdorur.

Pista e mësipërme përbëhet nga numri i mëposhtëm i pllakave të ndryshme:

• 12 pllaka të tipit #1.
• 5 pllaka të tipit #2.
• 3 shabllone të llojit të pllakave #5.
• 3 shabllone të llojit të pllakave #6 - këtu, do të përfundoni me një pllakë shtesë.

Më tej, shtypini ato dhe prerë ato. Provoni t'i vendosni ato si në foton e mësipërme dhe mbani në mend se në anën e djathtë të sipërme të pista, 2 pllaka duhet të mbivendosen njëra me tjetrën - kjo pritet në rast se pyesni veten nëse po bëni diçka të gabuar.

Hapi 3: Krijimi i Mjedisit

Në mënyrë që të jeni në gjendje të programoni mikro BBC: bit në MicroPython, duhet të krijoni një redaktues për të (Editori Mu) dhe të vendosni GiggleBot MicroPython Runtime si kohën e tij të funksionimit. Për këtë, duhet të ndiqni udhëzimet në këtë faqe. Deri në këtë moment, përdoret versioni v0.4.0 i kohës së ekzekutimit.

Hapi 4: Programimi i GiggleBot

Para se të filloni me të, koha e ekzekutimit GiggleBot MicroPython përmban kohën klasike të funksionimit për mikro BBC: bit dhe biblioteka të tjera për të mbështetur GiggleBot dhe Sensorë të tjerë të Industrisë Dexter.

Pasi ta vendosni, hapni skriptin e mëposhtëm në redaktuesin Mu dhe klikoni në Flash. Kjo do të ndezë GiggleBot MicroPython Runtime dhe skenarin që sapo keni hapur në mikro tuaj BBC: bit. Skenari tregohet gjithashtu më poshtë.

Sapo të përfundojë procesi i ndezjes, vendosni mikroin e BBC -së: futeni në GiggleBot me neopixelët e bordit të drejtuar përpara, vendoseni në pistë dhe ndizeni.

Vini re se në skenar, PID dhe 2 konstante të tjera (pika e caktuar e shpejtësisë dhe konstantet e shpejtësisë minimale) janë vendosur tashmë.

Shënim: Skenari i mëposhtëm mund të ketë mungesë të hapësirave të bardha dhe kjo duket të jetë për shkak të ndonjë problemi në shfaqjen e GitHub Gists. Klikoni në thelbin për t'ju çuar në faqen e tij GitHub ku mund të kopjoni-ngjisni kodin.

Ndjekësi i linjës PID i GiggleBot - i sintonizuar me NeoPixels

nga importi i mikrobitit*

nga importi i gigglebot*

nga importi i gjumit sleep_ms, ticks_us

import ustruct

# inicializoni neopixelët GB

neo = init ()

# koha

norma e përditësimit = 50

# fitime/konstante (duke supozuar se tensioni i baterisë është rreth 4.0 volt)

Kp = 25.0

Ki = 0.5

Kd = 35.0

pika e nxitjes = 0.3

përqindja_min e shpejtësisë = 0.3

shpejtësia_baza = 70

pika e përcaktimit = 0.5

pozicioni i fundit = pika e caktuar

integral = 0.0

run_neopixels = E vërtetë

center_pixel = 5# ku pikseli qendror i buzëqeshjes ndodhet në GB

# bruz = tuple (harta (lambda x: int (x / 5), (64, 224, 208))) # ngjyra për t'u përdorur për të nxjerrë gabimin me neopixelët

# bruz = (12, 44, 41) # që është pikërisht bruzja e mësipërme e komentuar mbi këtë

error_width_per_pixel = 0.5/3# gabim max i ndarë me numrin e segmenteve midis secilit neopixel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, above_bound, më i vogël_motor_power, më i lartë_motor_power):

shpejtësia bazë_ globale

nëse abs_error> = pika_të shkaktimit:

# x0 = 0.0

# y0 = 0.0

# x1 = pjesa e sipërme -e lidhur - pika -shkas

# y1 = 1.0

# x = abs_error - pika_të shkaktimit

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

# e njejta si

y = (abs_error - point_ trigger) / (above_bound - point_ trigger)

fuqia motorike = shpejtësia_baza * (fuqia_motor_ e vogël + (1- vjeç) * (fuqia_më e lartë_motor - fuqia_motor_motor])

fuqia motorike e kthimit

tjeter:

kthehu shpejtësinë bazë * fuqinë më të lartë_motore

vrap = E gabuar

gabimi i mëparshëm = 0

ndërsa e vërtetë:

# nëse shtypet butoni a atëherë filloni të ndiqni

nëse butoni_a.është shtypur ():

drejtuar = E vërtetë

# por nëse shtypet butoni b ndaloni ndjekësin e linjës

nëse button_b.is_pressed ():

vrap = E gabuar

integral = 0.0

gabimi i mëparshëm = 0.0

pixels_off ()

ndal ()

ms_gjumës (500)

nëse ekzekutohet është e vërtetë:

# lexoni sensorët e linjës

koha e fillimit = ticks_us ()

djathtas, majtas = sensori i leximit (LINE_SENSOR, TO DYT)

# rreshti është në të majtë kur pozicioni <0.5

# rreshti është në të djathtë kur pozicioni> 0.5

# rreshti është në mes kur pozicioni = 0.5

# është një mesatare aritmetike e ponderuar

provo:

pozicioni = djathtas /noton (majtas + djathtas)

përveçZeroDivisionError:

pozicioni = 0.5

# diapazoni duhet të jetë (0, 1) dhe jo [0, 1]

nëse pozicioni == 0: pozicioni = 0.001

nëse pozicioni == 1: pozicioni = 0.999

# përdorni një kontrollues PD

gabim = pozicioni - pika e caktuar

integral += gabim

korrigjim = Kp * gabim + Ki * integral + Kd * (gabim - gabimi_paraprak)

gabimi i mëparshëm = gabim

# llogarit shpejtësinë e motorit

motor_speed = e sipërme_bound_linear_speed_reducer (abs (gabim), pika e përcaktuar * pika e shkasit, pika e caktuar, min_speed_percent, 1.0)

leftMotorSpeed = shpejtësia motorike + korrigjimi

rightMotorSpeed = shpejtësia_ motorike - korrigjim

# ndriçoni neopixelët sipas gabimit të dhënë

nëse run_neopixels ështëTë vërteta dhe totali_llogarit %3 == 0:

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

neo = (0, 0, 0)

për i inb '\ x00 / x01 / x02 / x03':

ifabs (gabim)> error_width_per_pixel * i:

nëse gabimi <0:

# neo [center_pixel + i] = bruz

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

tjeter:

# neo [center_pixel - i] = bruz

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

tjeter:

për qind = 1- (error_width_per_pixel * i -abs (error)) / error_width_per_pixel

# ndriçoni pikselin aktual

nëse gabimi <0:

# neo [center_pixel + i] = tuple (harta (lambda x: int (x * përqindja), bruz))

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

tjeter:

# neo [center_pixel - i] = tuple (harta (lambda x: int (x * përqindja), bruz))

neo [qendra_pixel - i] = (int (64* përqind /5), int (224* përqind /5), int (208* përqind /5))

pushim

neo.shfaqje ()

provo:

# kap shpejtësitë e motorit

nëse lihetMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

nëse është e drejtëMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

nëse lihetMotorShpejtësia <-100:

leftMotorSpeed = -100

nëse është e drejtëMotorSpeed <-100:

rightMotorSpeed = -100

# aktivizoni motorët

set_speed (leftMotorSpeed, rightMotorSpeed)

ngas ()

# print ((gabim, shpejtësia_ motorike))

përveç:

# në rast se futemi në ndonjë çështje të pazgjidhshme

kaloj

# dhe ruani frekuencën e lakut

koha e mbarimit = ticks_us ()

vonesa_diff = (koha e mbarimit - koha e fillimit) /1000

if1000.0/ update_rate - delay_diff> 0:

gjumë (1000.0/ vlera e përditësimit - vonesë_diff)

shiko rawgigglebot_tuned_line_follower.py e pritur me ❤ nga GitHub

Hapi 5: Lejoni që të funksionojë

Ka 2 butona në mikro të BBC: bit: butoni A dhe butoni B:

• Shtypja e butonit A e vendos GiggleBot të ndjekë linjën (nëse ka një të tillë).
• Shtypja e butonit B ndalon GiggleBot dhe rivendos gjithçka në mënyrë që ta përdorni përsëri.

Advisedshtë shumë e këshillueshme që të mos ngrini GiggleBot ndërsa është duke ndjekur një linjë dhe pastaj ta vendosni përsëri në të sepse gabimi që llogarit mund të grumbullohet dhe të prishë totalisht rrugën e robotit. Nëse dëshironi ta ngrini, shtypni butonin B dhe pastaj kur ta vendosni përsëri shtypni përsëri A.