การปรับแต่ง GiggleBot Line Follower - ขั้นสูง: 7 ขั้นตอน

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:05

ใน Instructables สั้น ๆ นี้ คุณจะต้องปรับแต่ง GiggleBot ของคุณเองให้ทำตามเส้นสีดำ ในบทช่วยสอนอื่น ๆ ของ GiggleBot Line Follower เราฮาร์ดโค้ดค่าการปรับแต่งให้ทำงานตามสถานการณ์นั้น คุณอาจต้องการทำให้มันทำงานได้ดีขึ้นด้วยการหาผลประโยชน์อื่นๆ

ในบทช่วยสอนนี้ เรากำลังแสดงให้คุณเห็น 2 สคริปต์ที่สามารถโหลดทั้งสองสคริปต์บน BBC micro:bits ที่แตกต่างกัน เพื่อให้หนึ่งในนั้นถูกใส่ลงใน GiggleBot และอีกปุ่มหนึ่งจะใช้ 2 ปุ่มเพื่อเข้าสู่เมนูและปรับแต่งให้แตกต่างกัน พารามิเตอร์ การส่งพารามิเตอร์ที่อัปเดตเหล่านี้ทำได้ผ่านวิทยุ

ขั้นตอนที่ 1: ส่วนประกอบที่จำเป็น

คุณจะต้องมีสิ่งต่อไปนี้:

1. หุ่นยนต์ GiggleBot สำหรับ micro:bit
2. x3 AA แบตเตอรี่
3. x2 BBC micro:bits - อันหนึ่งสำหรับ GiggleBot และอีกอันหนึ่งทำหน้าที่เป็นรีโมตสำหรับปรับแต่งพารามิเตอร์
4. แบตเตอรี่สำหรับ BBC micro:bit - เช่นเดียวกับแบตเตอรี่ที่มาในแพ็คเกจ BBC micro:bit

รับ GiggleBot Robot สำหรับ BBC micro:bit ที่นี่

ขั้นตอนที่ 2: การตั้งค่าแทร็กและสภาพแวดล้อม

คุณต้องสร้างแทร็กของคุณจริงๆ ด้วย (ดาวน์โหลด พิมพ์ ตัดและติดเทปไทล์) จากนั้นตั้งค่าสภาพแวดล้อม (IDE และรันไทม์)

เนื่องจากบทช่วยสอนนี้มีความเกี่ยวข้องกับบทช่วยสอนอื่นๆ ที่มีชื่อว่า GiggleBot Line Follower เพียงไปที่นั่นและทำตามขั้นตอนที่ 2 และ 3 แล้วกลับมาที่นี่

สำหรับ IDE คุณสามารถใช้ตัวแก้ไข Mu และสำหรับรันไทม์ คุณต้องดาวน์โหลด GiggleBot MicroPython Runtime สามารถดาวน์โหลดรันไทม์ได้จากเอกสารประกอบ ที่นี่ ตรงไปที่บทเริ่มต้นใช้งานของเอกสารและปฏิบัติตามคำแนะนำในการตั้งค่าสภาพแวดล้อม ณ ขณะนี้ เวอร์ชัน v0.4.0 ของรันไทม์ถูกใช้

ขั้นตอนที่ 3: การตั้งค่า GiggleBot

ก่อนที่จะกะพริบรันไทม์ไปที่ GiggleBot ตรวจสอบให้แน่ใจว่าคุณได้เลือกความเร็วและอัตราการอัปเดตที่คุณต้องการสำหรับ GiggleBot โดยค่าเริ่มต้น ความเร็วจะถูกตั้งไว้ที่ 100 (ตัวแปร base_speed) และอัตราการอัปเดตตั้งไว้ที่ 70 (ตัวแปร update_rate)

จากการใช้งานในปัจจุบัน อัตราการอัปเดตสูงสุดที่สามารถทำได้คือ 70 และหากตั้งค่า run_neopixels เป็น True ก็จะทำได้เพียง 50 รายการเท่านั้น ในทางหนึ่ง คุณสามารถพูดได้ว่าอัตราการอัพเดทเริ่มต้นนั้นอยู่ตรงขอบของสิ่งที่ BBC micro:bit สามารถทำได้

สำหรับการบันทึก เซ็นเซอร์ติดตามบรรทัดสามารถส่งคืนการอัปเดต 100 ครั้งต่อวินาที

หมายเหตุ: สคริปต์ต่อไปนี้อาจมีช่องว่างหายไป และดูเหมือนว่าจะเกิดจากปัญหาบางอย่างในการแสดง GitHub Gists คลิกที่ส่วนสำคัญเพื่อนำคุณไปยังหน้า GitHub ซึ่งคุณสามารถคัดลอกและวางโค้ดได้

GiggleBot PID Line Follower Tuner (ต้องใช้รีโมทเพื่อปรับแต่ง) - xjfls23

จากการนำเข้าไมโครบิต*

จากการนำเข้า gigglebot*

จาก utime นำเข้า sleep_ms, ticks_us

นำเข้าวิทยุ

นำเข้า ustruct

# เริ่มต้นวิทยุและ GB neopixels

วิทยุ.on()

นีโอ = init()

#จับเวลา

update_rate =70

# ค่าเกนเริ่มต้น

Kp =0.0

กี่ = 0.0

Kd =0.0

ค่าที่ตั้งไว้ =0.5

trigger_point =0.0

min_speed_percent =0.2

base_speed = 100

last_position = เซ็ตพอยต์

อินทิกรัล =0.0

run_neopixels =False

center_pixel =5# โดยที่พิกเซลตรงกลางของรอยยิ้มจะอยู่บน GB

# เทอร์ควอยซ์ = ทูเพิล(แผนที่(แลมบ์ดา x: int(x / 5), (64, 224, 208))) # สีที่จะใช้วาดข้อผิดพลาดด้วยนีโอพิกเซล

# เทอร์ควอยซ์ = (12, 44, 41) # ซึ่งเป็นสีเทอร์ควอยซ์ด้านบนที่แสดงความคิดเห็นไว้ข้างต้น

error_width_per_pixel =0.5/3# ข้อผิดพลาดสูงสุดหารด้วยจำนวนเซ็กเมนต์ระหว่างแต่ละ neopixel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, smallest_motor_power, maximum_motor_power):

ฐานโลก_ความเร็ว

ถ้า abs_error >= trigger_point:

# x0 = 0.0

# y0 = 0.0

# x1 = ขอบเขตบน - trigger_point

# y1 = 1.0

# x = abs_error - trigger_point

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

# เหมือนกับ

y = (abs_error - trigger_point) / (บน_bound - trigger_point)

motor_power = base_speed * (smallest_motor_power + (1- y) * (สูงสุด_motor_power - เล็กที่สุด_motor_power))

ส่งคืน motor_power

อื่น:

คืนค่า base_speed * maximum_motor_power

วิ่ง = เท็จ

Previous_error =0

total_time =0.0

total_counts =0

ในขณะที่จริง:

# หากกดปุ่ม a ให้เริ่มติดตาม

ถ้า button_a.is_pressed():

วิ่ง = จริง

#แต่ถ้ากดปุ่ม b ให้หยุดผู้ติดตามไลน์

ถ้า button_b.is_pressed():

วิ่ง = เท็จ

อินทิกรัล =0.0

Previous_error =0.0

display.scroll('{} - {}'.format(total_time, total_counts), ดีเลย์=100, รอ=เท็จ)

total_time =0.0

total_counts =0

พิกเซล_off()

หยุด()

sleep_ms(500)

ถ้ารัน isTrue:

#อ่านเส้นเซ็นเซอร์

start_time = ticks_us()

# ตรวจสอบว่าเราได้อัปเดตกำไร Kp/Kd ด้วยรีโมทหรือไม่

ลอง:

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

set_eyes()

ยกเว้นประเภทข้อผิดพลาด:

ผ่าน

ขวา, ซ้าย = read_sensor(LINE_SENSOR, ทั้งสอง)

# เส้นอยู่ด้านซ้ายเมื่อตำแหน่ง < 0.5

# เส้นอยู่ทางขวาเมื่อตำแหน่ง > 0.5

# เส้นอยู่ตรงกลางเมื่อตำแหน่ง = 0.5

#มันคือค่าเฉลี่ยเลขคณิตถ่วงน้ำหนัก

ลอง:

ตำแหน่ง = ขวา /float(ซ้าย + ขวา)

ยกเว้นข้อผิดพลาด ZeroDivision:

ตำแหน่ง =0.5

ถ้าตำแหน่ง ==0: ตำแหน่ง =0.001

ถ้าตำแหน่ง ==1: ตำแหน่ง =0.999

# ใช้ตัวควบคุม PD

ข้อผิดพลาด = ตำแหน่ง - จุดตั้งค่า

อินทิกรัล += ข้อผิดพลาด

การแก้ไข = Kp * ข้อผิดพลาด + Ki * อินทิกรัล + Kd * (ข้อผิดพลาด - Previous_error)

Previous_error = ข้อผิดพลาด

#คำนวณความเร็วมอเตอร์

motor_speed = upper_bound_linear_speed_reducer (abs (ข้อผิดพลาด), setpoint * trigger_point, setpoint, min_speed_percent, 1.0)

leftMotorSpeed = motor_speed + การแก้ไข

rightMotorSpeed = motor_speed - การแก้ไข

# ทำให้นีโอพิกเซลสว่างขึ้นเพื่อแสดงทิศทางที่ GiggleBot ต้องไป

ถ้า run_neopixels isTrue และ total_counts %3==0:

สำหรับผม'\x00\x01\x02\x03\x04\x05\x06\x07\x08':

นีโอ = (0, 0, 0)

สำหรับฉันใน'\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 (แผนที่ (แลมบ์ดา x: int (x * เปอร์เซ็นต์), เทอร์ควอยซ์))

neo[center_pixel + i] = (int(12* เปอร์เซ็นต์), int(44* เปอร์เซ็นต์), int(41* เปอร์เซ็นต์))

อื่น:

# neo [center_pixel - i] = tuple (แผนที่ (แลมบ์ดา x: int (x * เปอร์เซ็นต์), เทอร์ควอยซ์))

neo[center_pixel - i] = (int(12* เปอร์เซ็นต์), int(44* เปอร์เซ็นต์), int(41* เปอร์เซ็นต์))

หยุดพัก

neo.show()

ลอง:

#หนีบมอเตอร์

ถ้าเหลือความเร็วมอเตอร์ >100:

leftMotorSpeed =100

rightMotorSpeed = rightMotorSpeed - ซ้ายMotorSpeed +100

ถ้าใช่ความเร็วมอเตอร์ >100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

ถ้า leftMotorSpeed <-100:

leftMotorSpeed = -100

ถ้า rightMotorSpeed <-100:

rightMotorSpeed = -100

#สั่งงานมอเตอร์

set_speed(leftMotorSpeed, rightMotorSpeed)

ขับ()

# พิมพ์ ((ข้อผิดพลาด, motor_speed))

ยกเว้น:

#ในกรณีที่เราประสบปัญหาบางอย่างที่แก้ไขไม่ได้

ผ่าน

# และรักษาความถี่ลูป

end_time = ticks_us()

delay_diff = (end_time - start_time) /1000

total_time += delay_diff

total_counts +1

if1.0/ update_rate - delay_diff >0:

สลีป (1.0/ update_rate - delay_diff)

ดู rawgigglebot_line_follower_tuner.py โฮสต์ด้วย ❤ โดย GitHub

ขั้นตอนที่ 4: การตั้งค่าจูนเนอร์ (รีโมท)

สิ่งต่อไปที่เราต้องทำคือแฟลชรันไทม์ + สคริปต์ไปที่ BBC micro:bit ตัวที่ 2 micro:bit ตัวที่สองนี้จะทำหน้าที่เป็นรีโมทไปยัง GiggleBot ซึ่งจะใช้เพื่อปรับแต่งพารามิเตอร์ต่อไปนี้:

1. Kp = อัตราขยายตามสัดส่วนสำหรับตัวควบคุม PID
2. Ki = กำไรรวมสำหรับคอนโทรลเลอร์ PID
3. Kd = อนุพันธ์เกนสำหรับคอนโทรลเลอร์ PID
4. trigger_point = จุดที่แสดงเป็นเปอร์เซ็นต์ระหว่างความเร็วต่ำสุดและสูงสุดของ GiggleBot โดยที่ความเร็วเริ่มลดลงเป็นเส้นตรงจนกว่าจะถึงความเร็วต่ำสุด
5. min_speed_percent = ความเร็วต่ำสุดที่แสดงเป็นเปอร์เซ็นต์ของความเร็วสูงสุด

ตัวแปรที่เหลืออีก 2 ตัวที่สามารถปรับแต่งได้นั้นจะถูกฮาร์ดโค้ดโดยตรงในสคริปต์ที่อยู่บน GiggleBot: update_rate และ base_speed ซึ่งแสดงถึงความเร็วสูงสุด ตามที่อธิบายไว้ในเอกสารประกอบ ความเร็วสูงสุดที่สามารถตั้งค่าสำหรับ GiggleBot คือ 100 ซึ่งเป็นค่าเริ่มต้นสำหรับ GiggleBot ของเราด้วย

หมายเหตุ: สคริปต์ต่อไปนี้อาจมีช่องว่างหายไป และดูเหมือนว่าจะเกิดจากปัญหาบางอย่างในการแสดง GitHub Gists คลิกที่ส่วนสำคัญเพื่อนำคุณไปยังหน้า GitHub ซึ่งคุณสามารถคัดลอกและวางโค้ดได้

GiggleBot Remote PID Line Follower Tuner (ต้องใช้ส่วนอื่น ๆ) - xjfls23

จากการนำเข้าไมโครบิต*

จาก utime นำเข้า sleep_ms

นำเข้าวิทยุ

นำเข้า ustruct

# องค์ประกอบที่ 1 คือ Kp gain

# องค์ประกอบที่ 2 คือ Ki gain

# องค์ประกอบที่ 3 คือ Kd gain

# องค์ประกอบที่ 4 คือ trigger_point สำหรับมอเตอร์เพื่อลดความเร็ว (0 -> 1)

# 5 องค์ประกอบคือความเร็วขั้นต่ำสำหรับมอเตอร์ที่แสดงเป็นเปอร์เซ็นต์ (0 -> 1)

กำไร = [0.0, 0.0, 0.0, 1.0, 0.0]

ขนาดขั้น =0.1

# 0 และ 1 สำหรับองค์ประกอบที่ 1

# 2 และ 3 สำหรับองค์ประกอบที่ 2

currentSetting =0

defshowMenu():

display.scroll('{} - {}'.format(currentSetting, gains[int(currentSetting /2)]), ดีเลย์=100, รอ=เท็จ)

วิทยุ.on()

แสดงเมนู()

ในขณะที่จริง:

ปรับปรุง =False

ถ้า button_a.is_pressed():

currentSetting = (การตั้งค่าปัจจุบัน +1) % (2*5)

อัพเดท =True

ถ้า button_b.is_pressed():

ถ้า currentSetting %2==0:

# เพิ่มกำไรเมื่อ currentSetting เป็น 0 หรือ 2 หรือ..

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

กำไร[int(currentSetting /2)] +=10* stepSize

อื่น:

กำไร[int(currentSetting /2)] += stepSize

อื่น:

# เพิ่มกำไรเมื่อ currentSetting เป็น 1 หรือ 3 หรือ..

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

ได้รับ[int(currentSetting /2)] -=10* stepSize

อื่น:

กำไร[int(currentSetting /2)] -= stepSize

radio.send_bytes(ustruct.pack('ffffff', *กำไร))

อัพเดท =True

หากอัปเดต:

แสดงเมนู()

sleep_ms(200)

ดู rawgigglebot_line_follower_configurator.py ที่โฮสต์ด้วย ❤ โดย GitHub

ขั้นตอนที่ 5: ปรับแต่ง GiggleBot

วาง GiggleBot บนแทร็ก เปิดเครื่องแล้วปล่อยให้มันทำงาน ในระหว่างนี้ คุณจะต้องนำมันกลับมาบนแทร็กและปรับแต่งค่าเกน/พารามิเตอร์ด้วย BBC micro:bit อื่นๆ ที่คุณถืออยู่ในมือ

ในการเริ่มต้น GiggleBot ให้กดปุ่ม A บน BBC micro:bit ของ GiggleBot และเพื่อหยุดการทำงานและรีเซ็ตสถานะโดยกดปุ่ม B

บน BBC micro:bit ระยะไกล การกดปุ่ม A จะนำคุณผ่านทุกตัวเลือกในเมนูและปุ่ม B จะเพิ่ม/ลดค่าที่เกี่ยวข้อง มันเหมือนกับการตั้งนาฬิกาบนแผงหน้าปัดของรถรุ่นเก่า ตัวเลือกมีลักษณะดังนี้:

1. 0-1 ตัวเลือกสำหรับกำไร Kp
2. 2-3 ตัวเลือกสำหรับกำไร Ki
3. 4-5 ตัวเลือกสำหรับกำไร Kd
4. ตัวเลือก 6-7 ตัวใช้สำหรับตั้งค่าจุดที่กำหนดไว้สำหรับช่วงเวลาที่มอเตอร์เริ่มช้าลง
5. 8-9 ตัวเลือกสำหรับการตั้งค่าความเร็วขั้นต่ำ

โปรดทราบว่าตัวเลขคู่ในเมนูใช้สำหรับการเพิ่มค่าที่สอดคล้องกัน และสำหรับเลขคี่จะเป็นค่าตรงกันข้าม

นอกจากนี้ เมื่อกดปุ่ม B บน BBC micro:bit ของ GiggleBot คุณจะเห็นจำนวนมิลลิวินาทีที่ผ่านไปตั้งแต่การรีเซ็ตครั้งล่าสุดและจำนวนรอบที่หุ่นยนต์ผ่านไปบนหน้าจอที่สร้างด้วยนีโอพิกเซลด้วย 2 สิ่งเหล่านี้คุณสามารถคำนวณได้ อัตราการอัพเดทของหุ่นยนต์

สุดท้ายและที่สำคัญที่สุด ฉันได้ปรับแต่ง 2 ค่าสำหรับ GiggleBot หนึ่งในนั้นใช้สำหรับเมื่อปิด Neopixel LED และอีกอันใช้สำหรับเมื่อเป็นอย่างอื่น ไฟ LED Neopixel ใช้เพื่อแสดงว่าเกิดข้อผิดพลาดขึ้นในทิศทางใด

การปรับค่าพารามิเตอร์ชุดที่ 1 (โดยปิด LED NeoPixel)

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 ในสคริปต์ที่โหลดบน BBC micro:bit ของ GiggleBot สิ่งนี้จะทำให้ไฟ LED ของ NeoPixel กะพริบในลักษณะที่บ่งบอกว่าข้อผิดพลาดสะสมไปในทิศทางใด

ขั้นตอนที่ 6: GiggleBot ทำงานโดยปิด NeoPixels

นี่คือตัวอย่างของการรัน GiggleBot ด้วยพารามิเตอร์การปรับแต่งที่ 1 ที่พบในขั้นตอนก่อนหน้า ตัวอย่างนี้ปิดไฟ LED NeoPixel

ขั้นตอนที่ 7: GiggleBot ทำงานโดยเปิด Neopixels ไว้

นี่คือตัวอย่างของการรัน GiggleBot ด้วยชุดพารามิเตอร์การปรับแต่งชุดที่ 2 ที่พบในขั้นตอนที่ 5 ตัวอย่างนี้มีไฟ LED NeoPixel เปิดอยู่

สังเกตว่าในตัวอย่างนี้ GiggleBot มีเวลามากขึ้นในการติดตามบรรทัด - นั่นเป็นเพราะไฟ LED Neopixel กำลัง "กิน" เวลา CPU ของ BBC micro:bit นั่นเป็นเหตุผลที่เราต้องลดอัตราการอัปเดตจาก 70 ลงเหลือ 50