GiggleBot Line Follower– ის დარეგულირება - გაფართოებული: 7 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:18

ამ ძალიან მოკლე ინსტრუქციებში თქვენ აპირებთ საკუთარი GiggleBot- ის მორგებას, რათა დაიცვას შავი ხაზი. ამ სხვა სახელმძღვანელოში GiggleBot Line Follower, ჩვენ მყარად დავწერეთ tuning ღირებულებები იმ სცენარის მიხედვით. შეიძლება დაგჭირდეთ, რომ ის უკეთესად მოიქცეს სხვა მიღწევებით.

ამ გაკვეთილში ჩვენ გაჩვენებთ 2 სკრიპტს, რომელთა ჩატვირთვა შესაძლებელია BBC– ს სხვადასხვა მიკრო მიკროში: ბიტი ისე, რომ ერთი მათგანი მოთავსდეს GiggleBot– ში, ხოლო მეორესთან ერთად, 2 ღილაკი გამოიყენება მენიუს გასავლელად და განსხვავებული მორგებისთვის. პარამეტრები. ამ განახლებული პარამეტრების გაგზავნა ხდება რადიოს საშუალებით.

ნაბიჯი 1: საჭირო კომპონენტები

თქვენ დაგჭირდებათ შემდეგი:

1. GiggleBot რობოტი მიკრო: ბიტი.
2. x3 AA ბატარეები
3. x2 BBC მიკრო: ბიტი - ერთი GiggleBot– ისთვის, მეორე კი დისტანციური მართვის ფუნქცია, პარამეტრების რეგულირებისთვის.
4. ბატარეა BBC მიკრო: ბიტისთვის - ისევე როგორც ის, რაც შედის BBC მიკრო: ბიტის პაკეტში.

მიიღეთ GiggleBot Robot 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 ცვლადი).

ახლანდელი განხორციელების გათვალისწინებით, განახლების ყველაზე მაღალი მაჩვენებელი არის 70 და თუ run_neopixels დაყენებულია True, მაშინ მხოლოდ 50 არის მიღწევადი. ასე რომ, გარკვეულწილად, შეიძლება ითქვას, რომ განახლების ნაგულისხმევი მაჩვენებელი ზუსტად იმ ზღვარზეა, რასაც BBC მიკრო: ბიტს შეუძლია.

მხოლოდ ჩანაწერისთვის, ხაზის მიმდევართა სენსორს შეუძლია განახლებების დაბრუნება წამში 100 -ჯერ.

შენიშვნა: მომდევნო სკრიპტს შეიძლება დაკარგული ჰქონდეს თეთრი სივრცეები და ეს, როგორც ჩანს, გამოწვეულია GitHub Gists– ის ჩვენების პრობლემით. დააწკაპუნეთ არსზე, რათა მიგიყვანოთ მის GitHub გვერდზე, სადაც შეგიძლიათ დააკოპიროთ-ჩასვით კოდი.

GiggleBot PID Line Follower Tuner (მის დასარეგულირებლად საჭიროა დისტანციური მართვის პულტი) - xjfls23

მიკრობიტის იმპორტიდან*

gigglebot იმპორტიდან*

უმეტესი იმპორტიდან sleep_ms, ticks_us

რადიოს იმპორტი

ustruct იმპორტი

# რადიოს და GB ნეოპიქსელების ინიციალიზაცია

რადიო. ()

neo = init ()

# დროის განაწილება

განახლების_ შეფასება = 70

# ნაგულისხმევი მოგების მნიშვნელობა

Kp = 0.0

Ki = 0.0

Kd = 0.0

მითითებული წერტილი = 0.5

გამომწვევი_ წერტილი = 0.0

min_speed_centcent = 0.2

ბაზის_სიჩქარე = 100

last_position = მითითებული წერტილი

ინტეგრალური = 0.0

run_neopixels = მცდარი

center_pixel = 5# სადაც ღიმილის ცენტრალური პიქსელი მდებარეობს GB- ზე

# ფირუზი = tuple (რუკა (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, small_motor_power, უმაღლესი_motor_power):

გლობალური ბაზის_ სიჩქარე

თუ 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

მართალია:

# თუ ღილაკზე a არის დაჭერილი დაიწყეთ მიყევით

თუ button_a.is_pressed ():

გაშვება = მართალია

# მაგრამ თუ ღილაკზე b დაჭერილია შეაჩერე ხაზის მიმდევარი

თუ button_b.is_pressed ():

გაშვება = ყალბი

ინტეგრალური = 0.0

წინა_შეცდომა = 0.0

display.scroll ('{} - {}'. ფორმატი (total_time, total_counts), დაგვიანებით = 100, ლოდინი = ყალბი)

სულ_დრო = 0.0

მთლიანი_ანგარიშები = 0

pixels_off ()

გაჩერება ()

sleep_ms (500)

თუ გაშვება მართალია:

# წაიკითხეთ ხაზის სენსორები

დაწყების დრო = ticks_us ()

# შეამოწმეთ, განაახლოთ თუ არა Kp/Kd მიღწევები დისტანციური მართვის საშუალებით

სცადე:

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

set_eyes ()

përjashtTypeError:

ჩაბარება

მარჯვნივ, მარცხნივ = წაკითხვის_სენსორი (LINE_SENSOR, BOTH)

# ხაზი არის მარცხნივ, როდესაც პოზიცია <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 = motor_speed - შესწორება

# აანთეთ ნეოპიქსელები, რათა ნახოთ რა მიმართულებით უნდა წავიდეს 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:

ნეო [center_pixel + i] = (12, 44, 41)

სხვა:

ნეო [center_pixel - i] = (12, 44, 41)

სხვა:

პროცენტი = 1- (error_width_per_pixel * i -abs (error)) / error_width_per_pixel

# აანთეთ მიმდინარე პიქსელი

თუ შეცდომა <0:

# neo [center_pixel + i] = tuple (რუკა (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- ის ნახვა GitHub– ით hosted hosted

ნაბიჯი 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 დისტანციური PID Line Follower Tuner (მოითხოვს მეორე ნაწილს) - xjfls23

მიკრობიტის იმპორტიდან*

უმეტესი იმპორტიდან 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 პირველი ელემენტისთვის

# 2 და 3 მე -2 ელემენტისთვის

მიმდინარე დაყენება = 0

defshowMenu ():

display.scroll ('{} - {}'. ფორმატი (currentSetting, მოგება [int (currentSetting /2)]), შეფერხება = 100, ლოდინი = ყალბი)

რადიო. ()

შოუს მენიუ ()

მართალია:

განახლებულია = ყალბი

თუ button_a.is_pressed ():

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

განახლებულია = მართალია

თუ button_b.is_pressed ():

თუ მიმდინარე დაყენება %2 == 0:

# გაზრდის მოგებას, როდესაც მიმდინარე დაყენება არის 0 ან 2 ან..

ifint (currentSetting /2) [0, 2]:

იძენს [int (currentSetting /2)] += 10* ნაბიჯი ზომა

სხვა:

იძენს [int (currentSetting /2)] += ნაბიჯი ზომა

სხვა:

# გაზრდის მოგებას, როდესაც მიმდინარე დაყენება არის 1 ან 3 ან..

ifint (currentSetting /2) [0, 2]:

იძენს [int (currentSetting /2)] -= 10* ნაბიჯი ზომა

სხვა:

იძენს [int (currentSetting /2)] -= stepSize

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

განახლებულია = მართალია

განახლების შემთხვევაში:

შოუს მენიუ ()

sleep_ms (200)

rawgigglebot_line_follower_configurator.py- ს ნახვა GitHub- ის მიერ hosted

ნაბიჯი 5: დაარეგულირეთ GiggleBot

განათავსეთ GiggleBot ტრასაზე, ჩართეთ და გაუშვით. ამასობაში, თქვენ მუდმივად მოგიწევთ მისი დაბრუნება ტრასაზე და მოაგვაროთ მიღწევები/პარამეტრები BBC– ს სხვა მიკრო მიკროფონით: ბიტი, რომელსაც ხელში გიჭირავთ.

GiggleBot– ის დასაწყებად, დააჭირეთ ღილაკს A GiggleBot– ის BBC მიკრო: ბიტზე და შეაჩერეთ იგი და ამით აღადგინეთ მისი მდგომარეობა დააჭირეთ ღილაკზე B.

BBC– ის დისტანციურ მიკრო: ბიტზე, ღილაკზე A დაჭერით გადახვალთ მის მენიუს ყველა ვარიანტში და ღილაკი B ზრდის/ამცირებს შესაბამის მნიშვნელობას. ეს იგივეა, რაც საათი დააყენო ძველი მანქანის დაფაზე. პარამეტრები ასეთია:

1. 0-1 ვარიანტია Kp მოგებისთვის.
2. 2-3 ვარიანტი არის Ki მომატებისთვის.
3. 4-5 ვარიანტი არის Kd- ის მოსაპოვებლად.
4. 6-7 ვარიანტი არის მითითებული იმ მომენტისთვის, როდესაც ძრავები იწყებენ შენელებას.
5. 8-9 ვარიანტი არის მინიმალური სიჩქარის დასადგენად.

გაითვალისწინეთ, რომ მენიუში ლუწი რიცხვებია შესაბამისი მნიშვნელობების გასაზრდელად, ხოლო უცნაურებისთვის კი პირიქით.

ასევე, როდესაც დააჭირეთ ღილაკს B GiggleBot– ის BBC მიკრო: ბიტს, თქვენ ნახავთ მის ნეოპიქსელებით დამზადებულ ეკრანზე ბოლო გადატვირთვის შემდეგ გასული მილიწამების რაოდენობას და რობოტის გავლილი ციკლების რაოდენობას - ამ 2 – ით შეგიძლიათ გამოთვალოთ რობოტის განახლების სიჩქარე.

და ბოლოს და რაც მთავარია, მე გამოვიტანე 2 რეგულირება GiggleBot– ისთვის. ერთი მათგანი განკუთვნილია ნეოპიქსელის LED- ების გამორთვისთვის, ხოლო მეორე - სხვაგვარად. Neopixel LED- ები გამოიყენება იმის საჩვენებლად, თუ რომელი მიმართულებით არის დაგროვილი შეცდომა.

პარამეტრების დარეგულირების პირველი ნაკრები (გამორთული 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 მიკრო: ბიტში. ეს გახდის NeoPixel LED- ებს ისე, რომ აანთოს, რომ მიუთითოს რომელი მიმართულებით ხდება შეცდომების დაგროვება.

ნაბიჯი 6: GiggleBot გაშვებული NeoPixels გამორთულია

ეს არის GiggleBot– ის გაშვების მაგალითი, წინა საფეხურზე ნაპოვნი პირველი tuning პარამეტრებით. ამ მაგალითს აქვს გამორთული NeoPixel LED- ები.

ნაბიჯი 7: GiggleBot გაშვებული ნეოპიქსელებით ჩართული

ეს არის GiggleBot– ის გაშვების მაგალითი მე –5 ნაბიჯში, რომელიც ნაჩვენებია მე –5 ნაბიჯში. ამ მაგალითში ჩართულია NeoPixel LED- ები.

გაითვალისწინეთ, როგორ ამ მაგალითში GiggleBot– ს უჭირს ხაზის დაცვა - ეს იმიტომ ხდება, რომ ნეოპიქსელური LED- ები „ჭამენ“BBC– ს მიკრო პროცესორის დროს: bit. ამიტომაც მოგვიწია განახლების მაჩვენებლის შემცირება 70 -დან 50 -მდე.