Urmăritor de linii GiggleBot folosind Python: 5 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

De data aceasta, programăm în MicroPython Dexter Industries GiggleBot pentru a urma o linie neagră folosind senzorul său de linie încorporat.

GiggleBot trebuie asociat cu un micro BBC: bit pentru a putea fi controlat corespunzător.

Dacă acest tutorial este prea avansat pentru dvs. și programarea GiggleBot este prea multă pentru moment, puteți merge întotdeauna prin tutorialul de pornire care vă arată cum poate fi programat robotul în MakeCode aici. Tutorialul conectat vă va conduce prin elementele de bază.

Pasul 1: Componente necesare

Sunt necesare următoarele componente hardware:

1. baterii x3 AA - în cazul meu folosesc baterii reîncărcabile care au o tensiune totală mai mică.
2. Un robot GiggleBot Dexter Industries pentru micro: bit.
3. Un micro: bit BBC.

Desigur, aveți nevoie și de un cablu micro USB pentru a programa BBC micro: bit - acest cablu vine în general în pachetul BBC micro: bit sau puteți folosi oricând unul care este folosit pentru încărcarea smartphone-urilor (Android).

Obțineți GiggleBot pentru micro: bit aici

Pasul 2: Configurați pistele

Va trebui să treceți prin imprimarea unor plăci și proiectarea propriilor piese. Puteți utiliza propriile plăci, astfel încât să fiți 100% sigur că reproduceți condițiile noastre. Sau, dacă vă simțiți aventuros, puteți folosi o bandă neagră și să vă creați propria. Iată PDF-ul pentru plăcile pe care le-am folosit.

Pista de mai sus este compusă din următorul număr de dale diferite:

• 12 plăci de tipul 1.
• 5 plăci de tipul 2.
• 3 șabloane de tip faianță # 5.
• 3 șabloane de tip faianță # 6 - aici, veți ajunge cu o faianță suplimentară.

Apoi, tipăriți-le și tăiați-le. Încercați să le așezați ca în fotografia de mai sus și rețineți că în partea dreaptă sus a pistei, 2 plăci trebuie să se suprapună una cu alta - acest lucru este de așteptat în cazul în care vă întrebați dacă faceți ceva greșit.

Pasul 3: Configurarea mediului

Pentru a putea programa BBC micro: bit în MicroPython, trebuie să configurați un editor pentru acesta (Editorul Mu) și să setați GiggleBot MicroPython Runtime ca runtime. Pentru aceasta, trebuie să urmați instrucțiunile de pe această pagină. În acest moment, se folosește versiunea v0.4.0 a runtime-ului.

Pasul 4: Programarea GiggleBot

Înainte de a ajunge la asta, runtime-ul GiggleBot MicroPython conține runtime-ul clasic pentru micro: bit și alte biblioteci BBC pentru a sprijini GiggleBot și alte senzori Dexter Industries.

După configurare, deschideți următorul script în editorul Mu și faceți clic pe Flash. Acest lucru va clipi Runtime-ul GiggleBot MicroPython și scriptul pe care tocmai l-ați deschis la micro: bitul BBC. Scriptul este, de asemenea, prezentat mai jos.

Odată ce procesul de intermitent este finalizat, stivați micro-ul BBC: în GiggleBot cu neopixelii plăcii orientați înainte, plasați-l pe pistă și porniți-l.

Observați că în script, PID și alte 2 constante (valoarea de referință a vitezei și constantele de viteză minimă) sunt deja setate.

Notă: Următorul script ar putea să aibă spații albe lipsă și acest lucru se pare că se datorează unor probleme la afișarea GitHub Gists. Faceți clic pe esență pentru a vă duce la pagina GitHub, unde puteți copia-lipi codul.

GiggleBot PID Line Follower - Acordat cu NeoPixels

din importul microbitului *

din importul gigglebot *

din utime import sleep_ms, ticks_us

import ustruct

# inițializează neopixeli GB

neo = init ()

# calendarul

update_rate = 50

# câștiguri / constante (presupunând că tensiunea bateriei este de aproximativ 4,0 volți)

Kp = 25,0

Ki = 0,5

Kd = 35,0

trigger_point = 0.3

min_speed_percent = 0.3

viteză_bază = 70

setpoint = 0,5

last_position = setpoint

integral = 0,0

run_neopixels = Adevărat

center_pixel = 5 # unde pixelul central al zâmbetului este situat pe GB

# turcoaz = tuplu (hartă (lambda x: int (x / 5), (64, 224, 208))) # culoare de utilizat pentru a desena eroarea cu neopixeli

# turcoaz = (12, 44, 41) # care este exact turcoazul de mai sus comentat mai sus

error_width_per_pixel = 0,5 / 3 # eroare maximă împărțită la numărul de segmente dintre fiecare neopixel

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

viteză_bază globală

dacă abs_error> = trigger_point:

# x0 = 0,0

# y0 = 0,0

# x1 = upper_bound - trigger_point

# y1 = 1.0

# x = abs_error - trigger_point

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

# la fel ca

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

motor_power = base_speed * (smallest_motor_power + (1- y) * (maximum_motor_power - smallest_motor_power))

returnează puterea_motor

altceva:

returnează viteza_bază * cea mai mare_puteră_motor

run = False

previous_error = 0

whileTrue:

# dacă este apăsat butonul a, începeți să urmați

dacă button_a.is_pressed ():

alerga = Adevărat

# dar dacă butonul b este apăsat, opriți următorul linie

dacă button_b.is_pressed ():

run = False

integral = 0,0

previous_error = 0.0

pixels_off ()

Stop()

sleep_ms (500)

dacă rulați este Adevărat:

# citiți senzorii de linie

start_time = ticks_us ()

dreapta, stânga = read_sensor (LINE_SENSOR, BOTH)

# linia este în stânga când poziția <0,5

# linia este în dreapta când poziția> 0,5

# linia este la mijloc când poziția = 0,5

# este o medie aritmetică ponderată

încerca:

poziție = dreapta / plutitor (stânga + dreapta)

exceptZeroDivisionError:

poziția = 0,5

# intervalul trebuie să fie (0, 1) și nu [0, 1]

dacă poziția == 0: poziția = 0,001

if position == 1: position = 0.999

# utilizați un controler PD

eroare = poziție - setpoint

integral + = eroare

corecție = eroare Kp * + Ki * integral + Kd * (eroare - eroare_anterioră)

previous_error = eroare

# calculați turațiile motorului

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

leftMotorSpeed = motor_speed + corecție

rightMotorSpeed = motor_speed - corectare

# aprindeți neopixeli în funcție de eroarea dată

dacă run_neopixels este adevărat și total_counts% 3 == 0:

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

neo = (0, 0, 0)

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

ifabs (eroare)> error_width_per_pixel * i:

dacă eroarea <0:

# neo [center_pixel + i] = turcoaz

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

altceva:

# neo [center_pixel - i] = turcoaz

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

altceva:

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

# aprinde pixelul curent

dacă eroarea <0:

# neo [center_pixel + i] = tuplu (hartă (lambda x: int (x * procent), turcoaz))

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

altceva:

# neo [center_pixel - i] = tuplu (hartă (lambda x: int (x * procent), turcoaz))

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

pauză

neo.show ()

încerca:

# fixați turațiile motorului

if leftMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

dacă rightMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

dacă leftMotorSpeed <-100:

leftMotorSpeed = -100

dacă rightMotorSpeed <-100:

rightMotorSpeed = -100

# acționați motoarele

set_speed (leftMotorSpeed, rightMotorSpeed)

conduce()

# print ((eroare, motor_speed))

cu exceptia:

# în caz că intrăm într-o problemă nesoluționată

trece

# și mențineți frecvența buclei

time_ end = ticks_us ()

delay_diff = (end_time - start_time) / 1000

if1000.0 / update_rate - delay_diff> 0:

sleep (1000.0 / update_rate - delay_diff)

vizualizați rawgigglebot_tuned_line_follower.py găzduit cu ❤ de GitHub

Pasul 5: Lăsați-l să ruleze

Există 2 butoane pe BBC micro: bit: butonul A și butonul B:

• Apăsând pe butonul A se setează GiggleBot să urmeze linia (dacă există una).
• Apăsând butonul B oprește GiggleBot și resetează totul, astfel încât să îl poți folosi din nou.

Este foarte recomandat să nu ridicați GiggleBot în timp ce urmează o linie și apoi să-l puneți din nou pe ea, deoarece eroarea de calcul ar putea acumula și încurca total ruta robotului. Dacă doriți să-l ridicați, apăsați pe butonul B și apoi, când îl puneți din nou, apăsați din nou pe A.