สร้างหุ่นยนต์นำทางด้วย Lidar ด้วย GiggleBot: 8 ขั้นตอน

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

ในบทช่วยสอนนี้ เรากำลังทำให้ GiggleBot จัดการกับความยากของเขาวงกต

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

ในเวลาเดียวกัน GiggleBot กำลังส่งข้อมูลนี้ไปยัง BBC micro:bit ระยะไกลที่แสดงบนเมทริกซ์ LED ขนาด 5 x 5 ในตำแหน่งที่สัมพันธ์กับสิ่งกีดขวาง

งานของคุณคือสามารถนำทาง GiggleBot ได้ด้วยการดูสิ่งที่แสดงบน BBC micro:bit อื่นเท่านั้น ในการควบคุม GiggleBot จะใช้ปุ่มบน BBC micro:bit ระยะไกล

ฟังดูเหมือนสนุก! ลงไปกันเถอะ

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

เราต้องการ:

1. GiggleBot.
2. ก้อนแบตเตอรี่สำหรับ BBC micro:bit มันมาพร้อมกับ BBC micro:bit ในแพ็คเกจ
3. แบตเตอรี่ AA x3 สำหรับ GiggleBot
4. สาย Grove เพื่อเชื่อมต่อเซ็นเซอร์วัดระยะทางกับ GiggleBot
5. ชุดเซอร์โวจาก DexterIndustries
6. x3 BBC micro:บิต. ตัวหนึ่งสำหรับ GiggleBot และอีกตัวหนึ่งเคยควบคุมหุ่นยนต์จากระยะไกล
7. เซนเซอร์วัดระยะทางจาก DexterIndustries

รับหุ่นยนต์ GiggleBot สำหรับ BBC micro:bit ที่นี่!

ขั้นตอนที่ 2: การประกอบหุ่นยนต์

ในการทำให้ GiggleBot พร้อมที่จะตั้งโปรแกรม เราต้องประกอบมันขึ้นมา แม้ว่าจะไม่ต้องทำอะไรมาก

ใส่แบตเตอรี่ AA 3 ก้อนในช่องด้านล่างของ GiggleBot

ประกอบชุดเซอร์โว สำหรับแขนหมุนของเซอร์โว ให้ใช้รูสุดท้ายของมันเพื่อยึดเซอร์โวเข้ากับขั้วต่อด้านหน้าของ GiggleBot คุณสามารถใช้สกรูและ/หรือลวดเพื่อให้มีความมั่นคงมากขึ้นในตำแหน่งเดิม หรือคุณสามารถกาวร้อนกับกระดาน ในกรณีของฉัน ฉันใช้สกรูและสายสั้นเพื่อผูกแขนเซอร์โวกับบอร์ด GiggleBot

เมื่อติดตั้งแขนเซอร์โวเข้ากับเซอร์โว ตรวจสอบให้แน่ใจว่าได้ตั้งค่าเซอร์โวไว้ที่ตำแหน่ง 80 แล้ว คุณสามารถทำได้โดยเรียก gigglebot.set_servo(gigglebot. RIGHT, 80) คุณสามารถอ่านเพิ่มเติมเกี่ยวกับเรื่องนี้ได้ที่นี่

ถัดไป วางเซ็นเซอร์วัดระยะทางที่ด้านหน้าของแพ็คเกจเซอร์โวแล้วแก้ไขตามตัวอย่างด้านบน

สุดท้าย เชื่อมต่อเซ็นเซอร์วัดระยะทางด้วยสายเคเบิล Grove กับพอร์ต I2C 2 พอร์ต และเซอร์โวมอเตอร์กับพอร์ตด้านขวาบน GiggleBot - มีการกล่าวถึงพอร์ตที่ถูกต้อง

ขั้นตอนที่ 3: สร้างเขาวงกตของคุณเอง - ไม่บังคับ

ในกรณีนี้ ฉันใช้กล่องหลายๆ กล่องเพื่อสร้างแทร็กลูปปิด คล้ายกับกล่อง NASCAR

ในขั้นตอนนี้ คุณสามารถสร้างสรรค์ได้อย่างแท้จริงและทำให้มันบิดเบี้ยวตามต้องการหรือทำให้มันยาวมาก ๆ เพราะมันขึ้นอยู่กับคุณจริงๆ

หรือหากคุณไม่ต้องการแทร็กเลย คุณสามารถวาง GiggleBot ไว้ในห้องครัวหรือห้องนั่งเล่น เป็นต้น ซึ่งน่าจะดีพอเพราะมีกำแพงและสิ่งกีดขวางมากมายที่คุณยังต้องหลีกเลี่ยง

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

เพื่อให้คุณสามารถตั้งโปรแกรม BBC micro:bit ใน MicroPython ได้ คุณต้องตั้งค่าตัวแก้ไขสำหรับมัน (ตัวแก้ไข Mu) และตั้งค่า GiggleBot MicroPython Runtime เป็นรันไทม์ คุณต้องทำตามคำแนะนำในหน้านี้ ณ ขณะนี้ เวอร์ชัน v0.4.0 ของรันไทม์ถูกใช้

ขั้นตอนที่ 5: การเขียนโปรแกรม GiggleBot - ตอนที่ I

ขั้นแรก มาตั้งค่าสคริปต์ของ GiggleBot สคริปต์นี้จะทำให้ GiggleBot หมุนเซอร์โวมอเตอร์ได้ 160 องศา (80 องศาในแต่ละทิศทาง) ในขณะเดียวกันก็อ่านค่า 10 ค่าจากเซ็นเซอร์วัดระยะทางต่อเทิร์น

เมื่อเปิดเครื่อง GiggleBot จะยืนอยู่ข้างๆ จนกว่าจะได้รับคำสั่งจากรีโมทคอนโทรล มีได้ 3 คำสั่งเท่านั้น: ไปข้างหน้า ไปทางซ้าย หรือทางขวา

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

GiggleBot ที่ใช้ LIDAR ควบคุมจากระยะไกล

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

จาก Distance_sensor นำเข้า DistanceSensor

จาก microbit นำเข้า sleep

จากการนำเข้า utime ticks_us, sleep_us

นำเข้า ustruct

นำเข้าวิทยุ

#หยุดหุ่นยนต์ถ้ามันเคลื่อนที่แล้ว

หยุด()

#เปิดใช้งานวิทยุ

วิทยุ.on()

#วัตถุเซ็นเซอร์ระยะ

ds = DistanceSensor()

ds.start_continuous()

rotator_time =0.7# วัดเป็นวินาที

rotator_span =160# วัดเป็นองศา

หมุน_steps =10

overhead_compensation =1.05# กำหนดเป็นเปอร์เซ็นต์

time_per_step =10**6* rotation_time / (rotate_steps * overhead_compensation)

last_read_time =0

เรดาร์ =bytearray(rotate_steps)

servo_rotate_direction =0# 0 สำหรับการขึ้นไป (0->160) และ 1 มิฉะนั้น

Radar_index =0

set_servo(ขวา, 0)

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

#อ่านจากเรดาร์

ถ้า ticks_us() - last_read_time > time_per_step:

#อ่านจากเซ็นเซอร์ระยะ

เรดาร์[radar_index] =int(ds.read_range_continuous() /10)

last_read_time = ticks_us()

พิมพ์ (radar_index)

# ทำตรรกะสำหรับการหมุนเซอร์โวจากซ้ายไปขวา

ถ้า radar_index == rotation_steps -1and servo_rotate_direction ==0:

set_servo(ขวา, 0)

servo_rotate_direction = 1

elif radar_index ==0และ servo_rotate_direction ==1:

set_servo(ขวา, หมุน_span)

servo_rotate_direction =0

อื่น:

Radar_index +=1ถ้า servo_rotate_direction ==0else-1

#และส่งค่าเรดาร์

radio.send_bytes(เรดาร์)

ลอง:

#อ่านคำสั่งหุ่นยนต์

lmotor, rmotor = ustruct.unpack('bb', radio.receive_bytes())

# และสั่งงานมอเตอร์ควรมีคำสั่งที่ได้รับ

set_speed(lmotor, rmotor)

ขับ()

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

ผ่าน

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

ขั้นตอนที่ 6: การเขียนโปรแกรมรีโมท - ตอนที่ II

สิ่งที่ต้องทำคือตั้งโปรแกรม BBC micro:bit ตัวที่ 2 ที่ทำหน้าที่เป็นรีโมท

รีโมตใช้เพื่อแสดงระยะทางสัมพัทธ์กับสิ่งกีดขวางบนหน้าจอที่สร้างพิกเซลขนาด 5 x 5 พิกเซล อย่างมากที่สุด จะมีการเปิด 10 พิกเซล

ในเวลาเดียวกัน รีโมทก็ให้ความสามารถในการควบคุม GiggleBot จากระยะไกลด้วยการกดปุ่ม 2 ปุ่ม: เลื่อนไปข้างหน้า ไปทางซ้าย และทางขวา

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

GiggleBot ที่ใช้ LIDAR ที่ควบคุมจากระยะไกล - Remote Code

จาก microbit นำเข้า sleep, display, button_a, button_b

นำเข้า ustruct

นำเข้าวิทยุ

นำเข้าคณิตศาสตร์

วิทยุ.on()

หมุน_steps =10

หมุน_span =160# ในหน่วยองศา

หมุน_step = หมุน_สแปน / หมุน _ ขั้น

max_distance =50# หน่วยเป็นเซนติเมตร

side_length_leds =3# วัดใน # ของพิกเซล

เรดาร์ =bytearray(rotate_steps)

xar = ไบต์เรย์ (rotate_steps)

yar =bytearray(หมุน_steps)

save_xar =bytearray(rotate_steps)

save_yar =bytearray(หมุน_ขั้นตอน)

motor_speed = 50

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

สถานะ = radio.receive_bytes_into(เรดาร์)

ถ้าสถานะไม่ใช่ไม่มี:

# display.clear()

สำหรับ c, val inenumerate(เรดาร์):

ถ้าเรดาร์[c] <= max_distance:

# คำนวณพิกัด 2d ของแต่ละระยะทาง

มุม = rotation_steps / (rotate_steps -1) * rotation_step * c

มุม += (180-rotation_span) /2.0

x_c = math.cos(มุม * math.pi /180.0) * เรดาร์[c]

y_c = math.sin (มุม * math.pi /180.0) * เรดาร์[c]

# ปรับขนาดระยะทางให้พอดีกับจอแสดงผลไมโครบิต 5x5

x_c = x_c * (side_length_leds -1) / max_distance

y_c = y_c * (side_length_leds +1) / max_distance

#พิกัดตำแหน่ง

x_c += (side_length_leds -1)

y_c = (side_length_leds +1) - y_c

# พิกัดกลมตรงตำแหน่งที่พบ LED

ถ้า x_c - math.floor(x_c) <0.5:

x_c = math.floor(x_c)

อื่น:

x_c = math.ceil(x_c)

ถ้า y_c - math.floor(y_c) <0.5:

y_c = math.floor(y_c)

อื่น:

y_c = math.ceil (y_c)

xar[c] = x_c

yar[c] = y_c

อื่น:

xar[c] =0

ยา[c] =0

display.clear()

สำหรับ x, y inzip(xar, yar):

display.set_pixel(x, y, 9)

# พิมพ์ (รายการ (zip (xar, yar, เรดาร์)))

stateA = button_a.is_pressed()

stateB = button_b.is_pressed()

ถ้า stateA และ stateB:

radio.send_bytes(ustruct.pack('bb', motor_speed, motor_speed))

พิมพ์ ('ไปข้างหน้า')

ถ้า stateA และไม่ใช่ stateB:

radio.send_bytes(ustruct.pack('bb', motor_speed, -motor_speed))

พิมพ์('ซ้าย')

ถ้าไม่ใช่ stateA และ stateB:

radio.send_bytes(ustruct.pack('bb', -motor_speed, motor_speed))

พิมพ์ ('ถูกต้อง')

ifnot stateA และไม่ใช่ stateB:

radio.send_bytes(ustruct.pack('bb', 0, 0))

พิมพ์ ('หยุด')

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

ขั้นตอนที่ 7: การตีความหน้าจอระยะไกล

"loading="lazy" ควบคุม GiggleBot คุณมีตัวเลือกดังต่อไปนี้:

1. กดปุ่ม A และปุ่ม B เพื่อย้าย GiggleBot ไปข้างหน้า
2. กดปุ่ม A เพื่อหมุน GiggleBot ไปทางซ้าย
3. กดปุ่ม B เพื่อหมุน GiggleBot ไปทางขวา

หากต้องการดูทิศทางที่ตรวจพบสิ่งกีดขวางที่ใกล้ที่สุด เพียงดูที่หน้าจอของรีโมท (BBC micro:bit ระยะไกลที่คุณกำลังถืออยู่) คุณควรจะสามารถควบคุม GiggleBot ได้จากระยะไกลโดยไม่ต้องมองมัน