GiggleBot Line Follower Gamit ang Python: 5 Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:12

Sa oras na ito, nagpaprogram kami sa MicroPython ng Dexter Industries GiggleBot upang sundin ang isang itim na linya gamit ang built-in na tagasunod na sensor.

Ang GiggleBot ay kailangang ipares sa isang BBC micro: kaunti upang makontrol ito nang naaangkop.

Kung ang tutorial na ito ay masyadong advanced para sa iyo at i-program ang GiggleBot ay sobra para sa ngayon, maaari mong palaging dumaan sa starter tutorial na nagpapakita sa iyo kung paano mai-program ang robot sa MakeCode dito. Ang naka-link na tutorial ay magtuturo sa iyo sa mga pangunahing kaalaman.

Hakbang 1: Kinakailangan na Mga Sangkap

Ang mga sumusunod na sangkap ng hardware ay kinakailangan:

1. x3 AA na baterya - sa aking kaso gumagamit ako ng mga rechargeable na baterya na mayroong isang mas mababang boltahe sa pangkalahatan.
2. Ang isang Dexter Industries GiggleBot robot para sa micro: bit.
3. Isang BBC micro: kaunti.

Siyempre, kailangan mo rin ng isang micro USB cable upang mai-program ang BBC micro: bit - ang cable na ito sa pangkalahatan ay nasa loob ng BBC micro: package ni bit o maaari mong palaging gumamit ng isa na ginagamit para sa pagsingil ng (mga Android) smartphone.

Kunin ang GiggleBot para sa micro: kaunti dito

Hakbang 2: I-set up ang Mga Track

Kailangan mong dumaan sa pag-print ng ilang mga tile at pagdidisenyo ng iyong sariling mga track. Maaari mong gamitin ang aming sariling mga tile upang ikaw ay 100% sigurado na kinokopya mo ang aming mga kundisyon. O kung sa tingin mo ay malakas ang loob, maaari kang gumamit ng isang itim na tape at gumawa ng iyong sarili. Narito ang PDF para sa mga tile na ginamit namin.

Ang track sa itaas ay binubuo ng sumusunod na bilang ng iba't ibang mga tile:

• 12 tile ng uri # 1.
• 5 mga tile ng uri # 2.
• 3 mga template ng uri ng tile # 5.
• 3 mga template ng uri ng tile # 6 - dito, magtatapos ka sa isang sobrang tile.

Susunod, i-print ang mga ito at gupitin ito. Subukang ilagay ang mga ito tulad ng nasa itaas na larawan at tandaan na sa kanang tuktok na bahagi ng track, 2 mga tile ang kailangang mag-overlap sa isa't isa - inaasahan ito kung sakaling nagtataka ka kung may ginagawa kang mali.

Hakbang 3: Pag-set up ng Kapaligiran

Upang ma-program mo ang BBC micro: kaunti sa MicroPython, kailangan mong mag-set up ng isang editor para dito (ang Mu Editor) at itakda ang GiggleBot MicroPython Runtime bilang runtime nito. Para doon, kailangan mong sundin ang mga tagubilin sa pahinang ito. Tulad ng sa sandaling ito, ginagamit ang bersyon v0.4.0 ng runtime.

Hakbang 4: Programming ang GiggleBot

Bago bumaba dito, ang GiggleBot MicroPython runtime ay naglalaman ng klasikong runtime para sa BBC micro: bit at iba pang mga aklatan upang suportahan ang GiggleBot at iba pang Dexter Industries Sensors.

Pagkatapos i-set up ito, buksan ang sumusunod na script sa Mu editor at mag-click sa Flash. Ipa-flash nito ang GiggleBot MicroPython Runtime at ang script na binuksan mo lamang sa iyong BBC micro: bit. Ang script ay ipinakita rin sa ibaba.

Kapag natapos na ang proseso ng flashing, isalansan ang BBC micro: bit sa GiggleBot kasama ang mga neopixel ng board na nakaharap, ilagay ito sa track at buksan ito.

Pansinin na sa script, ang PID at iba pang 2 mga pare-pareho (ang setpoint ng bilis at minimum na mga Constant ng bilis) ay naitakda na.

Tandaan: Ang sumusunod na script ay maaaring may mga nawawalang mga whitespaces at tila ito ay sanhi ng ilang isyu sa pagpapakita ng GitHub Gists. Mag-click sa buod upang dalhin ka sa pahina ng GitHub na kung saan maaari mong kopyahin-i-paste ang code.

GiggleBot PID Line Follower - Na-tugma w / NeoPixels

mula sa microbit import *

mula sa gigglebot import *

mula sa utime import sleep_ms, ticks_us

mag-import ng us konstruksyon

# ipasimula ang mga GB neopixel

neo = init ()

# tiyempo

update_rate = 50

# mga nadagdag / patuloy (sa pag-aakalang ang boltahe ng baterya ay nasa 4.0 volts)

Kp = 25.0

Ki = 0.5

Kd = 35.0

trigger_point = 0.3

min_speed_percent = 0.3

base_speed = 70

setpoint = 0.5

last_position = setpoint

integral = 0.0

run_neopixels = Tama

center_pixel = 5 # kung saan matatagpuan ang center pixel ng ngiti sa GB

# turquoise = tuple (mapa (lambda x: int (x / 5), (64, 224, 208))) # Kulay na gagamitin upang iguhit ang error sa mga neopixel

# turquoise = (12, 44, 41) # na eksakto sa itaas na turkesa ay nagkomento sa itaas nito

error_width_per_pixel = 0.5 / 3 # max error na hinati sa bilang ng mga segment sa pagitan ng bawat neopixel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, pinakamaliit na_motor_power, pinakamataas_motor_power):

pandaigdigang base_pabilis

kung 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)

# katulad ng

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

motor_power = base_speed * (pinakamaliit_motor_power + (1- y) * (pinakamataas_motor_power - pinakamaliit_motor_power))

ibalik ang motor_power

iba pa:

ibalik ang base_speed * pinakamataas_motor_power

takbo = Mali

nakaraang_error = 0

habang Totoo:

Ang # kung pindutan a ay pinindot pagkatapos simulang sundin

kung ang button_a.is_pressed ():

patakbuhin = Totoo

# ngunit kung ang pindutan b ay pinindot itigil ang tagasunod sa linya

kung ang button_b.is_pressed ():

takbo = Mali

integral = 0.0

nakaraang_error = 0.0

pix_off ()

huminto ()

sleep_ms (500)

kung tatakbo ay Totoo:

# basahin ang mga sensor ng linya

start_time = ticks_us ()

kanan, kaliwa = read_sensor (LINE_SENSOR, BOTH)

Ang # linya ay nasa kaliwa kapag ang posisyon <0.5

Ang # linya ay nasa kanan kapag posisyon> 0.5

Ang # linya ay nasa gitna kapag posisyon = 0.5

# ito ay isang bigat na ibig sabihin ng arithmetic

subukan:

posisyon = kanan / float (kaliwa + kanan)

exceptZeroDivisionError:

posisyon = 0.5

# ang saklaw ay dapat na (0, 1) at hindi [0, 1]

kung posisyon == 0: posisyon = 0.001

kung posisyon == 1: posisyon = 0.999

# Gumamit ng isang PD Controller

error = posisyon - setpoint

integral + = error

pagwawasto = Kp * error + Ki * integral + Kd * (error - nakaraang_error)

nakaraang_error = error

# kalkulahin ang bilis ng motor

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

leftMotorSpeed = motor_speed + pagwawasto

rightMotorSpeed = motor_speed - pagwawasto

# sindihan ang mga neopixel alinsunod sa ibinigay na error

kung ang run_neopixels ayTrueand total_counts% 3 == 0:

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

neo = (0, 0, 0)

para sa inb '\ x00 / x01 / x02 / x03':

ifabs (error)> error_width_per_pixel * i:

kung error <0:

# neo [center_pixel + i] = turkesa

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

iba pa:

# neo [center_pixel - i] = turkesa

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

iba pa:

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

# sindihan ang kasalukuyang pixel

kung error <0:

# neo [center_pixel + i] = tuple (mapa (lambda x: int (x * porsyento), turkesa))

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

iba pa:

# neo [center_pixel - i] = tuple (mapa (lambda x: int (x * porsyento), turkesa))

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

pahinga

neo.show ()

subukan:

# clip ang bilis ng motor

kung leftMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

kung tamaMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - kananMotorSpeed +100

kung leftMotorSpeed <-100:

leftMotorSpeed = -100

kung tamaMotorSpeed <-100:

rightMotorSpeed = -100

# i-aktibo ang mga motor

set_speed (leftMotorSpeed, kananMotorSpeed)

drive ()

# print ((error, motor_speed))

maliban sa:

# kung sakaling mapunta kami sa ilang hindi na-aayos na isyu

pumasa

# at panatilihin ang dalas ng loop

end_time = ticks_us ()

delay_diff = (end_time - start_time) / 1000

if1000.0 / update_rate - delay_diff> 0:

pagtulog (1000.0 / update_rate - delay_diff)

tingnan ang rawgigglebot_tuned_line_follower.py naka-host sa ❤ ng GitHub

Hakbang 5: Hinahayaan itong Tumakbo

Mayroong 2 mga pindutan sa BBC micro: bit: pindutan A at pindutan B:

• Ang pagpindot sa pindutan A ay nagtatakda ng GiggleBot upang sundin ang linya (kung mayroong isa).
• Ang pagpindot sa pindutan B ay hihinto ang GiggleBot at i-reset ang lahat upang maaari mo itong magamit muli.

Lubhang pinapayuhan na huwag iangat ang GiggleBot habang sumusunod ito sa isang linya at pagkatapos ay ibalik ito dito dahil ang error na kumakalkula ay maaaring maipon at ganap na guluhin ang ruta ng robot. Kung nais mong iangat ito, pindutin ang pindutan B at pagkatapos kapag ibalik mo ito, pindutin muli ang A.