GiggleBot գծի հետևորդ ՝ օգտագործելով Python- ը ՝ 5 քայլ

2024 Հեղինակ: John Day | [email protected]. Վերջին փոփոխված: 2024-01-30 09:48

Այս անգամ մենք ծրագրավորում ենք MicroPython- ում Dexter Industries GiggleBot- ում ՝ հետևելու սև գծին ՝ օգտագործելով ներկառուցված գծի հետևորդի սենսորը:

GiggleBot- ը պետք է զուգակցվի BBC- ի միկրո.

Եթե այս ձեռնարկը ձեզ համար չափազանց առաջադեմ է, իսկ GiggleBot- ի ծրագրավորումն առայժմ չափազանց շատ է, միշտ կարող եք անցնել մեկնարկային ձեռնարկով, որը ցույց է տալիս, թե ինչպես կարելի է ռոբոտը ծրագրավորել այստեղ MakeCode- ում: Կապված ձեռնարկը ձեզ կտանի հիմնական հիմունքներով:

Քայլ 1: Պահանջվող բաղադրիչներ

Պահանջվում են ապարատային հետևյալ բաղադրիչները.

1. x3 AA մարտկոցներ - իմ դեպքում ես օգտագործում եմ վերալիցքավորվող մարտկոցներ, որոնք ընդհանուր առմամբ ավելի ցածր լարման են:
2. Dexter Industries GiggleBot ռոբոտը միկրո.
3. BBC- ի միկրո.

Իհարկե, ձեզ անհրաժեշտ է նաև միկրո USB մալուխ ՝ BBC միկրո:

Ստացեք GiggleBot- ը միկրո

Քայլ 2: Կարգավորեք հետքերը

Դուք ստիպված կլինեք տպել որոշ սալիկներ և նախագծել ձեր սեփական հետքերը: Դուք կարող եք օգտագործել մեր սեփական սալիկները, որպեսզի 100% վստահ լինեք, որ դուք կրկնում եք մեր պայմանները: Կամ եթե դուք արկածախնդիր եք զգում, կարող եք օգտագործել ինչ -որ սև ժապավեն և պատրաստել ձեր սեփականը: Ահա մեր օգտագործած սալիկների PDF- ը:

Վերոնշյալ ուղին կազմված է հետևյալ թվով տարբեր սալիկներից.

• #1 տիպի 12 սալիկ:
• #2 տիպի 5 սալիկ:
• #5 սալիկի տիպի 3 կաղապար:
• 3 ձևանմուշ կղմինդր #6 - այստեղ դուք կավարտեք մեկ լրացուցիչ սալիկով:

Հաջորդը, տպեք դրանք և կտրեք դրանք: Փորձեք տեղադրել դրանք, ինչպես վերը նշված լուսանկարում, և հիշեք, որ ուղու աջ վերևում 2 սալիկ պետք է համընկնեն մեկը մյուսի հետ:

Քայլ 3: Շրջակա միջավայրի ստեղծում

Որպեսզի կարողանաք ծրագրավորել BBC micro: bit- ը MicroPython- ում, դուք պետք է դրա համար խմբագիր ստեղծեք (Mu Editor) և դրա գործարկման ժամանակը սահմանեք GiggleBot MicroPython Runtime- ը: Դրա համար պետք է հետևել այս էջի հրահանգներին: Այս պահի դրությամբ օգտագործվում է գործարկման ժամանակի v0.4.0 տարբերակը:

Քայլ 4: GiggleBot- ի ծրագրավորում

Մինչև դրան անդրադառնալը, GiggleBot MicroPython- ի գործարկման ժամանակը պարունակում է դասական աշխատաժամանակ BBC- ի միկրո.

Այն կարգավորելուց հետո Mu խմբագրիչում բացեք հետևյալ սցենարը և կտտացրեք Flash- ին: Սա կբացահայտի GiggleBot MicroPython Runtime- ը և այն սցենարը, որը դուք պարզապես բացել եք ձեր BBC micro- ի համար: bit. Սցենարը ցուցադրվում է նաև ներքևում:

Theրամեկուսացման գործընթացն ավարտվելուց հետո տեղադրեք BBC- ի միկրո.

Ուշադրություն դարձրեք, որ սցենարում PID- ն և մյուս 2 հաստատունները (արագության սահմանման կետը և նվազագույն արագության հաստատունները) արդեն սահմանված են:

Նշում. Հետևյալ սցենարի վրա կարող են բաց թողնվել սպիտակ տարածքներ, և դա, ըստ երևույթին, պայմանավորված է GitHub Gists- ի ցուցադրման որոշ խնդիրներով: Կտտացրեք բովանդակությունը ՝ ձեզ GitHub էջ տանելու համար, որտեղ կարող եք պատճենել-տեղադրեք ծածկագիրը:

GiggleBot PID Line Follower - Կարգավորված է NeoPixels- ով

միկրոբիտ ներմուծումից*

gigglebot ներմուծումից*

utime import sleep_ms, ticks_us- ից

ներմուծել ustruct

# նախաստորագրեք ԳԲ նեոպիքսելները

neo = init ()

# ժամկետ

update_rate = 50

# շահում/հաստատունություն (ենթադրելով, որ մարտկոցի լարումը մոտ 4.0 վոլտ է)

Kp = 25.0

Ki = 0.5

Kd = 35.0

ձգան_ կետ = 0.3

min_speed_percent = 0.3

բազային_արագություն = 70

սահմանային կետ = 0.5

last_position = setpoint

ինտեգրալ = 0.0

run_neopixels = Trueիշտ է

center_pixel = 5# որտեղ ժպիտի կենտրոնական պիքսելը գտնվում է ԳԲ -ում

# փիրուզագույն = դուփ (քարտեզ (lambda x: int (x / 5), (64, 224, 208)))

# փիրուզագույն = (12, 44, 41) # որը հենց վերը նշված փիրուզագույնն է, որը մեկնաբանվել է սրա վերևում

error_width_per_pixel = 0.5/3# max սխալ բաժանված յուրաքանչյուր նեոպիքսելի միջև ընկած հատվածների քանակով

defupper_bound_linear_speed_reducer (abs_error, trigger_point, above_bound, ամենափոքր_շարժիչ_ուժը, ամենաբարձր_շարժիչ_ուժը).

գլոբալ բազային_արագություն

եթե abs_error> = trigger_point:

# x0 = 0.0

# y0 = 0.0

# x1 = վերին_սահմանափակ - ձգան_ կետ

# y1 = 1.0

# x = abs_error - ձգան_ կետ

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

# նույնը, ինչ

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

շարժիչ_էներգիա = բազային_արագություն * (ամենափոքր_շարժիչ_հզորությունը + (1- յ)) * (ամենաբարձր_շարժիչ_ուժը - ամենափոքր_շարժիչ_ուժը))

վերադարձնել շարժիչ_հզորությունը

այլ:

վերադարձնել բազային_ արագությունը * ամենաբարձր_շարժիչ_ուժը

վազել = Կեղծ

նախորդ_սխալ = 0

իսկ ճշմարիտ:

# եթե կոճակը սեղմված է, ապա սկսեք հետևել

եթե button_a.is_pressed ():

վազել = Trueշմարիտ

# բայց եթե կոճակը b սեղմված է, դադարեցրեք տողի հետևորդին

եթե button_b.is_pressed ():

վազել = Կեղծ

ինտեգրալ = 0.0

նախորդ_սխալ = 0.0

pixels_off ()

կանգ առնել ()

sleep_ms (500)

եթե վազում է ruշմարիտ.

# կարդալ գծի տվիչները

start_time = ticks_us ()

աջ, ձախ = կարդալ_սենսոր (LINE_SENSOR, ԵՐԿՈ)

# տողը ձախ կողմում է, երբ դիրքը <0.5 է

# տողը աջից է, երբ դիրքը> 0.5 է

# տողը մեջտեղում է, երբ դիրքը = 0.5 է

# դա կշռված թվաբանական միջին է

փորձել:

դիրք = աջ /բոց (ձախ + աջ)

բացառությամբ ZeroDivisionError:

դիրք = 0.5

# միջակայքը պետք է լինի (0, 1) և ոչ [0, 1]

եթե դիրքը == 0: դիրքը = 0.001

եթե դիրքը == 1: դիրքը = 0.999

# օգտագործել PD վերահսկիչ

սխալ = դիրքորոշում - սահմանման կետ

ինտեգրալ += սխալ

ուղղում = Kp * սխալ + Ki * ինտեգրալ + Kd * (սխալ - նախորդ_սխալ)

previous_error = սխալ

# հաշվեք շարժիչի արագությունը

motor_speed = above_bound_linear_speed_reducer (abs (սխալ), setpoint * trigger_point, setpoint, min_speed_percent, 1.0)

leftMotorSpeed = շարժիչ_արագություն + ուղղում

rightMotorSpeed = շարժիչ_ արագություն - ուղղում

# լուսավորեք նեոպիքսելներն ըստ տրված սխալի

եթե run_neopixels- ը ճշմարիտ է և ընդհանուր_հաշիվներ %3 == 0:

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

neo = (0, 0, 0)

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

ifabs (սխալ)> error_width_per_pixel * i:

եթե սխալ <0:

# նեո [center_pixel + i] = փիրուզագույն

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

այլ:

# neo [center_pixel - i] = փիրուզագույն

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

այլ:

տոկոս = 1- (error_width_per_pixel * i -abs (error)) / error_width_per_pixel

# լուսավորեք ընթացիկ պիքսելները

եթե սխալ <0:

# neo [center_pixel + i] = դուփ (քարտեզ (lambda x: int (x * տոկոս), փիրուզագույն))

neo [center_pixel + i] = (int (64* տոկոս /5), int (224* տոկոս /5), int (208* տոկոս /5))

այլ:

# neo [center_pixel - i] = tuple (քարտեզ (lambda x: int (x * տոկոս), փիրուզագույն))

neo [center_pixel - i] = (int (64* տոկոս /5), int (224* տոկոս /5), int (208* տոկոս /5))

ընդմիջում

neo.show ()

փորձել:

# սեղմեք շարժիչի արագությունները

եթե մնացել է MotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

եթե ճիշտ է MotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

եթե մնացել է MotorSpeed <-100:

leftMotorSpeed = -100

եթե ճիշտ է MotorSpeed <-100:

rightMotorSpeed = -100

# գործարկել շարժիչները

set_speed (leftMotorSpeed, rightMotorSpeed)

քշել ()

# տպել ((սխալ, շարժիչ_արագություն))

բացառությամբ ՝

# այն դեպքում, երբ մենք բախվենք ինչ -որ անլուծելի խնդրի

անցնել

# և պահպանեք օղակի հաճախականությունը

վերջ_ժամանակ = ticks_us ()

delay_diff = (ավարտի ժամանակը - մեկնարկի ժամանակը) /1000

if1000.0/ update_rate - delay_diff> 0:

քուն (1000.0/ update_rate - delay_diff)

դիտել rawgigglebot_tuned_line_follower.py հյուրընկալված ❤ -ի կողմից GitHub- ի կողմից

Քայլ 5: Թողնել այն գործի

BBC micro- ում կա 2 կոճակ ՝ bit: կոճակ A և կոճակ B:

• A կոճակի վրա սեղմելը սահմանում է, որ GiggleBot- ը հետևի տողին (եթե այն կա):
• B կոճակին սեղմելը դադարեցնում է GiggleBot- ը և վերակայում է ամեն ինչ, որպեսզի կարողանաք նորից օգտագործել այն:

Խիստ խորհուրդ է տրվում չբարձրացնել GiggleBot- ը, երբ այն հետևում է տողին, այնուհետև այն նորից տեղադրել դրա վրա, քանի որ հաշվարկվող սխալը կարող է կուտակել և ամբողջովին խառնել ռոբոտի երթուղին: Եթե ցանկանում եք այն բարձրացնել, սեղմեք B կոճակի վրա, այնուհետև այն հետ տեղադրելիս կրկին սեղմեք A: