GiggleBot Line Follower- ի կարգավորում - Ընդլայնված ՝ 7 քայլ

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

Այս շատ կարճ Instructables- ում դուք մտադիր եք կարգավորել ձեր սեփական GiggleBot- ը ՝ սև գծին հետևելու համար: Այս GiggleBot Line Follower- ի այս այլ ձեռնարկում մենք կոշտ կոդավորեցինք թյունինգի արժեքները `այդ սցենարի համաձայն աշխատելու համար: Դուք գուցե ցանկանաք այն ավելի լավ պահել ՝ այլ ձեռքբերումներ ունենալով:

Այս ձեռնարկում մենք ձեզ ցույց ենք տալիս 2 սցենար, որոնք երկուսն էլ կարող են բեռնվել BBC- ի տարբեր միկրոներում. պարամետրերը: Այս թարմացված պարամետրերի ուղարկումը կատարվում է ռադիոյի միջոցով:

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

Ձեզ անհրաժեշտ կլինի հետևյալը.

1. GiggleBot ռոբոտը միկրո.
2. x3 AA մարտկոցներ
3. x2 BBC micro: բիթեր `մեկը GiggleBot- ի համար, իսկ մյուսը` որպես հեռակառավարիչ `պարամետրերը կարգավորելու համար:
4. ԲիԲիՍիի միկրո -բիթ մարտկոց `բիթ, ինչպես այն, որը գալիս է BBC միկրո: բիթ փաթեթում:

Ձեռք բերեք GiggleBot ռոբոտը BBC- ի միկրո. Մի քիչ այստեղ:

Քայլ 2. Հետքերի և միջավայրի ստեղծում

Դուք նաև պետք է իրականում կառուցեք ձեր հետքերը (ներբեռնեք, տպեք, կտրեք և կպչեք սալիկներ), այնուհետև ստեղծեք միջավայրը (IDE- ն և գործարկման ժամանակը):

Քանի որ այս ձեռնարկը շատ կապված է այս GiggleBot Line Follower վերնագրով այս այլ ձեռնարկի հետ, պարզապես գնացեք այնտեղ և հետևեք 2 -րդ և 3 -րդ քայլերին, ապա վերադառնաք այստեղ:

Ինչ վերաբերում է IDE- ին, ապա կարող եք օգտագործել Mu խմբագրիչը, իսկ գործարկման համար անհրաժեշտ է ներբեռնել GiggleBot MicroPython Runtime- ը: Գործողության ժամանակը կարելի է ներբեռնել դրա փաստաթղթերից այստեղ: Գնացեք փաստաթղթերի «Սկիզբ» բաժին և հետևեք շրջակա միջավայրի ստեղծման վերաբերյալ այդ հրահանգներին: Այս պահի դրությամբ օգտագործվում է գործարկման ժամանակի v0.4.0 տարբերակը:

Քայլ 3: Կարգավորեք GiggleBot- ը

Մինչև GiggleBot- ին գործարկման ժամանակը թարթելը, համոզվեք, որ ընտրել եք GiggleBot- ի ձեր նախընտրած արագությունը և թարմացման արագությունը. Լռելյայնորեն, արագությունը սահմանվում է 100 (base_speed variable) և թարմացման արագությունը `70 (update_rate variable):

Հաշվի առնելով ընթացիկ իրականացումը ՝ թարմացման ամենաբարձր արագությունը, որին կարելի է հասնել, 70 է, և եթե run_neopixels- ը սահմանվում է True, ապա հնարավոր է հասնել միայն 50 -ի: Այսպիսով, ինչ -որ կերպ, կարելի է ասել, որ կանխադրված թարմացման արագությունը գտնվում է այն բանի եզրին, ինչ BBC- ի միկրո -բիթը կարող է անել:

Տեղեկատվության համար նշենք, որ գծի հետևորդի սենսորը կարող է վայրկյանում 100 անգամ վերադարձնել թարմացումները:

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

GiggleBot PID Line Follower Tuner (այն կարգավորելու համար անհրաժեշտ է հեռակառավարիչ) - xjfls23

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

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

utime import sleep_ms, ticks_us- ից

ռադիո ներմուծել

ներմուծել ustruct

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

radio.on ()

neo = init ()

# ժամկետ

Update_rate = 70

# կանխադրված շահույթի արժեքներ

Kp = 0.0

Ki = 0.0

Kd = 0.0

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

ձգան_ կետ = 0,0

min_speed_percent = 0.2

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

last_position = setpoint

ինտեգրալ = 0.0

run_neopixels = Կեղծ

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

ընդհանուր_ժամանակ = 0.0

ընդհանուր_հաշիվներ = 0

իսկ ճշմարիտ:

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

եթե button_a.is_pressed ():

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

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

եթե button_b.is_pressed ():

վազել = Կեղծ

ինտեգրալ = 0.0

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

display.scroll ('{} - {}'. ձևաչափ (total_time, total_counts), ուշացում = 100, սպասել = Կեղծ)

ընդհանուր_ժամանակ = 0.0

ընդհանուր_հաշիվներ = 0

pixels_off ()

կանգ առնել ()

sleep_ms (500)

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

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

start_time = ticks_us ()

# ստուգեք, արդյոք մենք թարմացրել ենք Kp/Kd- ի շահումները հեռակառավարմամբ

փորձել:

Kp, Ki, Kd, trigger_point, min_speed_percent = ustruct.unpack ('fffff', radio.receive_bytes ())

set_eyes ()

përjashtTypeError:

անցնել

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

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

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

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

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

փորձել:

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

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

դիրք = 0.5

եթե դիրքը == 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 = շարժիչ_ արագություն - ուղղում

# լուսավորեք նեոպիքսելները ՝ ցույց տալու համար, թե որ ուղղությամբ պետք է գնա GiggleBot- ը

եթե 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:

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

այլ:

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 (12* տոկոս), int (44* տոկոս), int (41* տոկոս))

այլ:

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

neo [center_pixel - i] = (int (12* տոկոս), int (44* տոկոս), int (41* տոկոս))

ընդմիջում

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

ընդհանուր_ժամ += ուշացում_տարբերություն

ընդհանուր_հաշիվներ += 1

if1.0/ update_rate - delay_diff> 0:

քուն (1.0/ թարմացման գնահատական - հետաձգում_տարբերություն)

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

Քայլ 4: Կարգավորիչ (հեռակառավարիչ) կարգավորիչ

Հաջորդ բանը, որ մենք պետք է անենք, գործարկման ժամանակը + սցենարն է BBC- ի 2 -րդ միկրո -բիթին: Այս երկրորդ միկրո: բիթը հանդես կգա որպես GiggleBot- ի հեռակառավարիչ, որը կօգտագործվի հետևյալ պարամետրերը կարգավորելու համար.

1. Kp = PID վերահսկիչի համամասնական շահույթը:
2. Ki = PID վերահսկիչի անբաժանելի շահույթը:
3. Kd = ածանցյալ շահույթ PID վերահսկիչի համար:
4. trigger_point = այն կետը, որը արտահայտված է տոկոսներով GiggleBot- ի նվազագույն և առավելագույն արագությունների միջև, որտեղ արագությունը սկսում է գծայինորեն նվազել մինչև հասնի նվազագույն արագությանը:
5. min_speed_percent = նվազագույն արագությունը արտահայտված առավելագույն արագության տոկոսով:

Մնացած 2 փոփոխականները, որոնք կարող են կարգավորվել, ուղղակիորեն կոշտ կոդավորված են GiggleBot- ում տեղադրված սցենարի մեջ `թարմացման_կարգը և բազային_ արագությունը, որը ներկայացնում է առավելագույն արագությունը: Ինչպես նկարագրված է փաստաթղթերում, առավելագույն արագությունը, որը կարող է սահմանվել GiggleBot- ի համար, 100 է, որը նաև մեր GiggleBot- ի կանխադրված արժեքն է:

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

GiggleBot Remote PID Line Follower Tuner (պահանջում է մյուս մասը) - xjfls23

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

utime import sleep_ms- ից

ռադիո ներմուծել

ներմուծել ustruct

# 1 -ին տարրը Kp շահումն է

# 2 -րդ տարրը Ki ձեռքբերումն է

# 3 -րդ տարրը Kd շահումն է

# 4 -րդ տարրը շարժիչի շարժիչ ուժն է `արագությունը իջեցնելու համար (0 -> 1)

# 5 -րդ տարրը շարժիչների նվազագույն արագությունն է ՝ արտահայտված տոկոսներով (0 -> 1)

շահույթ = [0.0, 0.0, 0.0, 1.0, 0.0]

քայլ Չափ = 0.1

# 0 և 1 -ին 1 -ին տարրի համար

# 2 և 3 2 -րդ տարրի համար

ընթացիկ կարգավորում = 0

defshowMenu ():

display.scroll ('{} - {}'. ձևաչափ (ընթացիկ կարգավորում, ձեռքբերումներ [int (currentSetting /2)]), ուշացում = 100, սպասել = Կեղծ)

radio.on ()

showMenu ()

իսկ ճշմարիտ:

թարմացվել է = Սխալ

եթե button_a.is_pressed ():

currentSetting = (currentSetting +1) % (2*5)

թարմացվել է = Trueիշտ է

եթե button_b.is_pressed ():

եթե ընթացիկ Կարգավորում %2 == 0:

# բարձրացնել շահույթը, երբ ընթացիկ կարգավորումը 0 կամ 2 կամ..

ifint (currentSetting /2) [0, 2] -ում:

ձեռքբերումներ [int (currentSetting /2)] += 10* stepSize

այլ:

ձեռքբերումներ [int (currentSetting /2)] += stepSize

այլ:

# բարձրացնել շահույթը, երբ ընթացիկ կարգավորումն է 1 կամ 3 կամ..

ifint (currentSetting /2) [0, 2] -ում:

ձեռքբերումներ [int (currentSetting /2)] -= 10* stepSize

այլ:

ձեռքբերումներ [int (currentSetting /2)] -= stepSize

radio.send_bytes (ustruct.pack ('fffff', *gains))

թարմացվել է = Trueիշտ է

թարմացման դեպքում `

showMenu ()

sleep_ms (200)

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

Քայլ 5: Կարգավորեք GiggleBot- ը

Տեղադրեք GiggleBot- ը ուղու վրա, միացրեք այն և թողեք այն աշխատի: Միևնույն ժամանակ, դուք անընդհատ ստիպված կլինեք այն հետ դնել ուղու վրա և կարգավորել ձեռքբերումներն/պարամետրերը BBC- ի մյուս միկրոկառույցի հետ:

GiggleBot- ը գործարկելու համար սեղմեք GiggleBot- ի BBC միկրո.

Հեռակա BBC micro: bit- ի վրա, կոճակը սեղմելը կտանի ձեզ իր ընտրացանկի յուրաքանչյուր տարբերակի վրա, իսկ B կոճակը մեծացնում/նվազեցնում է համապատասխան արժեքը: Դա նման է ժամացույցը հին մեքենայի վահանակի վրա դնելուն: Ընտրանքներն այսպիսին են.

1. 0-1 տարբերակները Kp շահի համար են:
2. 2-3 տարբերակ Ki- ի շահի համար է:
3. 4-5 տարբերակ Kd- ի համար է:
4. 6-7 տարբերակները սահմանման կետն այն պահի համար են, երբ շարժիչները սկսում են դանդաղեցնել:
5. 8-9 տարբերակները նվազագույն արագության սահմանման համար են:

Հիշեք, որ ընտրացանկի զույգ թվերը համապատասխան արժեքներն ավելացնելու համար են, իսկ կենտերի համար ՝ ճիշտ հակառակը:

Բացի այդ, GiggleBot- ի BBC micro- ի վրա B կոճակը սեղմելիս, նրա Neopixel- ով պատրաստված էկրանին կտեսնեք վերջին վերակայումից անցած միլիվայրկյանների քանակը և ռոբոտի ցիկլերի քանակը, որոնցով կարող եք հաշվարկել ռոբոտի թարմացման արագությունը:

Վերջապես և ամենակարևորը, ես հանդես եկա 2 կարգավորմամբ GiggleBot- ի համար: Նրանցից մեկը նախատեսված է այն ժամանակ, երբ Neopixel LED- ները անջատված են, իսկ մյուսը `այլ դեպքերում: Neopixel LED- ները օգտագործվում են ցույց տալու, թե որ ուղղությամբ է կուտակվել սխալը:

Պարամետրերի կարգավորման 1 -ին փաթեթ (անջատված NeoPixel LED- ներով)

1. Kp = 32.0
2. Ki = 0.5
3. Kd = 80.0
4. trigger_setpoint = 0.3 (ինչը 30%է)
5. min_speed_percent = 0.2 (ինչը 20%է)
6. base_speed = 100 (հայտնի է նաև առավելագույն արագությամբ)
7. update_rate = 70 (աշխատում է @70Hz)

Պարամետրերի կարգավորման 2 -րդ փաթեթ (NeoPixel LED- ները միացված են)

1. Kp = 25.0
2. Ki = 0.5
3. Kd = 35.0
4. trigger_setpoint = 0.3 (ինչը 30%է)
5. min_speed_percent = 0.3 (ինչը 30%է)
6. base_speed = 70 (հայտնի է նաև առավելագույն արագությամբ)
7. update_rate = 50 (աշխատում է @50Hz)
8. Բացի այդ, փոփոխական run_neopixels- ը պետք է սահմանվի True- ի այն սցենարում, որը բեռնվում է GiggleBot- ի BBC micro: bit- ում: Սա կստիպի NeoPixel լուսադիոդային լուսարձակները այնպես, որ նրանք նշեն, թե որ ուղղությամբ է սխալը կուտակվում:

Քայլ 6. GiggleBot- ը աշխատում է անջատված NeoPixels- ով

Սա GiggleBot- ի գործարկման օրինակ է `նախորդ քայլում հայտնաբերված թյունինգի 1 -ին պարամետրերով: Այս օրինակում անջատված են NeoPixel LED- ները:

Քայլ 7. GiggleBot- ը աշխատում է միացված նեոպիքսելներով

Սա GiggleBot- ի գործարկման օրինակ է `քայլ 5 -ում հայտնաբերված թյունինգի պարամետրերի երկրորդ փաթեթով: Այս օրինակում NeoPixel LED- ները միացված են:

Ուշադրություն դարձրեք, թե ինչպես է այս օրինակում GiggleBot- ն ավելի դժվարությամբ հետևում գծին, քանի որ Neopixel LED- ները «ուտում» են պրոցեսորի ժամանակը BBC- ի միկրո. Այդ իսկ պատճառով մենք ստիպված եղանք թարմացման մակարդակը 70 -ից իջեցնել 50 -ի: