GiggleBot Line მიმდევარი პითონის გამოყენებით: 5 ნაბიჯი

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

ამჯერად ჩვენ ვპროგრამებთ MicroPython– ში Dexter Industries GiggleBot– ში, რომ დავიცვათ შავი ხაზი მისი ჩამონტაჟებული ხაზის მიმდევრის სენსორის გამოყენებით.

GiggleBot უნდა იყოს დაწყვილებული BBC მიკრო: ბიტი, რათა ის სათანადოდ გაკონტროლდეს.

თუ ეს სახელმძღვანელო თქვენთვის ძალიან მოწინავეა და GiggleBot– ის პროგრამირება ჯერჯერობით ძალიან ბევრია, თქვენ ყოველთვის შეგიძლიათ გაიაროთ დამწყები სამეურვეო პროგრამა, რომელიც გიჩვენებთ თუ როგორ შეიძლება რობოტის დაპროგრამება MakeCode– ში აქ. დაკავშირებული სახელმძღვანელო გაგიმხელთ საფუძვლებს.

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

საჭიროა აპარატურის შემდეგი კომპონენტები:

1. x3 AA ბატარეები - ჩემს შემთხვევაში მე ვიყენებ მრავალჯერადი დატენვის ბატარეებს, რომლებსაც საერთო ჯამში უფრო დაბალი ძაბვა აქვთ.
2. Dexter Industries GiggleBot რობოტი მიკრო: ბიტი.
3. BBC მიკრო: ცოტა.

რასაკვირველია, თქვენ ასევე გჭირდებათ მიკრო USB კაბელი BBC მიკროპროგრამის დასაპროგრამებლად: ბიტი - ეს კაბელი ზოგადად შედის BBC მიკრო: ბიტის პაკეტში, ან ყოველთვის შეგიძლიათ გამოიყენოთ ის, რომელიც გამოიყენება სმარტფონებისათვის (Android).

მიიღეთ GiggleBot მიკრო: ცოტა აქ

ნაბიჯი 2: დააყენეთ ტრეკები

თქვენ მოგიწევთ ფილების დაბეჭდვა და საკუთარი სიმღერების შემუშავება. თქვენ შეგიძლიათ გამოიყენოთ ჩვენი საკუთარი ფილები ისე, რომ 100% დარწმუნებული იყოთ, რომ იმეორებთ ჩვენს პირობებს. ან თუ თავგადასავლების გრძნობა გეუფლებათ, შეგიძლიათ გამოიყენოთ შავი ლენტი და გააკეთოთ საკუთარი. აქ არის PDF ფილები ჩვენ გამოვიყენეთ.

ზემოთ მოყვანილი სიმღერა შედგება შემდეგი რაოდენობის სხვადასხვა ფილებისგან:

• #1 ტიპის 12 ფილები.
• 5 კრამიტი ტიპის #2.
• კრამიტის ტიპის 5 შაბლონი #5.
• კრამიტის ტიპი 6 შაბლონი #6 - აქ თქვენ დასრულდება ერთი დამატებითი კრამიტით.

შემდეგი, დაბეჭდეთ ისინი და გაჭერით. სცადეთ მოათავსოთ ისინი, როგორც ზემოთ მოცემულ ფოტოში და გაითვალისწინეთ, რომ ბილიკის მარჯვენა ზედა ნაწილში, 2 კრამიტი უნდა გადაფაროს ერთმანეთთან - ეს მოსალოდნელია იმ შემთხვევაში, თუ თქვენ გაინტერესებთ, არასწორად აკეთებთ თუ არა.

ნაბიჯი 3: გარემოს შექმნა

იმისათვის, რომ შეძლოთ BBC– ს მიკროპროგრამის დაპროგრამება MicroPython– ში, თქვენ უნდა შექმნათ მისი რედაქტორი (Mu რედაქტორი) და დააყენოთ GiggleBot MicroPython Runtime, როგორც მისი გაშვების დრო. ამისათვის თქვენ უნდა მიყევით ამ გვერდზე მითითებებს. ამ მომენტისთვის გამოიყენება გაშვების დროის ვერსია v0.4.0.

ნაბიჯი 4: პროგრამირება GiggleBot

სანამ დაიწყებდით მუშაობას, GiggleBot MicroPython– ის გაშვების დრო შეიცავს BBC– ს მიკრო კლასიკურ მუშაობას: ბიტი და სხვა ბიბლიოთეკები GiggleBot– ისა და Dexter Industries– ის სხვა სენსორების მხარდასაჭერად.

მისი დაყენების შემდეგ, გახსენით შემდეგი სკრიპტი Mu რედაქტორში და დააწკაპუნეთ Flash- ზე. ეს აანთებს GiggleBot MicroPython Runtime– ს და სკრიპტს, რომელიც თქვენ ახლახან გახსენით თქვენს BBC მიკრო: ბიტზე. სკრიპტი ასევე ნაჩვენებია ქვემოთ.

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

გაითვალისწინეთ, რომ სკრიპტში PID და სხვა 2 მუდმივი (სიჩქარის მითითებული წერტილი და მინიმალური სიჩქარის მუდმივები) უკვე მითითებულია.

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

GiggleBot PID ხაზის მიმდევარი - მორგებული ნეოპიქსელებით

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

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

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

ustruct იმპორტი

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

neo = init ()

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

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

# მომატება/მუდმივი (ვთქვათ, რომ ბატარეის ძაბვა არის დაახლოებით 4.0 ვოლტი)

Kp = 25.0

Ki = 0.5

Kd = 35.0

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

min_speed_percent = 0.3

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

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

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

მართალია:

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

თუ button_a.is_pressed ():

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

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

თუ button_b.is_pressed ():

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

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

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

pixels_off ()

გაჩერება ()

sleep_ms (500)

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

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

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

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

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

# აანთეთ ნეოპიქსელები მოცემული შეცდომის მიხედვით

თუ 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] = ფირუზი

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

სხვა:

# ნეო [center_pixel - i] = ფირუზი

ნეო [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 (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/ განახლების_ შეფასება - გადადება_დიფ)

rawgigglebot_tuned_line_follower.py ნახვა hosted -ით GitHub

ნაბიჯი 5: გაუშვით მუშაობა

BBC მიკროში არის 2 ღილაკი: ბიტი: ღილაკი A და ღილაკი B:

• ღილაკზე დაჭერით აყენებს GiggleBot- ს დაიცვას ხაზი (თუ არის ერთი).
• ღილაკზე B დაჭერით აჩერებს GiggleBot- ს და აღდგება ყველაფერი ისე, რომ მისი ხელახლა გამოყენება შეძლოთ.

მიზანშეწონილია არ გააუქმოთ GiggleBot სანამ ის მიჰყვება ხაზს და შემდეგ ისევ დააბრუნოთ მასზე, რადგან გამოთვლის შეცდომამ შეიძლება დაგროვდეს და მთლიანად შეაფერხოს რობოტის მარშრუტი. თუ გსურთ მისი აწევა, დააჭირეთ ღილაკს B და შემდეგ როდესაც დააბრუნებთ კვლავ დააჭირეთ A- ს.