Người theo dõi dòng GiggleBot bằng Python: 5 bước

2024 Tác giả: John Day | [email protected]. Sửa đổi lần cuối: 2024-01-30 13:33

Lần này, chúng tôi đang lập trình trong MicroPython the Dexter Industries GiggleBot để đi theo đường màu đen bằng cách sử dụng cảm biến theo dõi dòng tích hợp của nó.

GiggleBot phải được ghép nối với một micro: bit BBC để nó được điều khiển một cách thích hợp.

Nếu hướng dẫn này quá nâng cao đối với bạn và việc lập trình GiggleBot là quá nhiều vào lúc này, bạn luôn có thể xem qua hướng dẫn dành cho người mới bắt đầu chỉ cho bạn cách lập trình robot trong MakeCode tại đây. Hướng dẫn được liên kết sẽ hướng dẫn bạn những điều cơ bản.

Bước 1: Các thành phần bắt buộc

Các thành phần phần cứng sau là bắt buộc:

1. x3 pin AA - trong trường hợp của tôi, tôi đang sử dụng pin sạc lại có điện áp tổng thể thấp hơn.
2. Một robot GiggleBot của Dexter Industries cho micro: bit.
3. Một vi BBC: bit.

Tất nhiên, bạn cũng cần một cáp micro USB để lập trình BBC micro: bit - cáp này thường đi kèm trong gói BBC micro: bit hoặc bạn luôn có thể sử dụng một cáp được sử dụng để sạc điện thoại thông minh (Android).

Nhận GiggleBot cho micro: bit tại đây

Bước 2: Thiết lập các tuyến đường

Bạn sẽ phải thực hiện việc in một số ô và thiết kế các bản nhạc của riêng bạn. Bạn có thể sử dụng gạch của chính chúng tôi để bạn chắc chắn 100% rằng bạn đang tái tạo các điều kiện của chúng tôi. Hoặc nếu bạn cảm thấy mạo hiểm, bạn có thể sử dụng một số băng đen và làm của riêng bạn. Đây là PDF cho các ô mà chúng tôi đã sử dụng.

Bài hát trên bao gồm một số ô khác nhau sau:

• 12 ô loại 1.
• 5 gạch loại # 2.
• 3 mẫu gạch kiểu # 5.
• 3 mẫu của loại ô số 6 - ở đây, bạn sẽ kết thúc với một ô bổ sung.

Tiếp theo, in chúng và cắt chúng. Hãy thử đặt chúng như trong ảnh trên và lưu ý rằng ở phía trên cùng bên phải của đường đua, 2 gạch phải chồng lên nhau - điều này được mong đợi trong trường hợp bạn đang tự hỏi liệu mình có làm sai điều gì không.

Bước 3: Thiết lập Môi trường

Để bạn có thể lập trình BBC micro: bit trong MicroPython, bạn phải thiết lập một trình chỉnh sửa cho nó (Mu Editor) và đặt GiggleBot MicroPython Runtime làm thời gian chạy của nó. Đối với điều đó, bạn phải làm theo hướng dẫn trên trang này. Tại thời điểm này, phiên bản v0.4.0 của thời gian chạy được sử dụng.

Bước 4: Lập trình GiggleBot

Trước khi bắt đầu, thời gian chạy GiggleBot MicroPython chứa thời gian chạy cổ điển cho BBC micro: bit và các thư viện khác để hỗ trợ GiggleBot và các Bộ cảm biến Dexter Industries khác.

Sau khi thiết lập, hãy mở tập lệnh sau trong trình chỉnh sửa Mu và nhấp vào Flash. Thao tác này sẽ flash GiggleBot MicroPython Runtime và tập lệnh bạn vừa mở cho vi BBC: bit của mình. Kịch bản cũng được hiển thị bên dưới.

Khi quá trình nhấp nháy hoàn tất, hãy xếp BBC micro: bit vào GiggleBot với các neopixels của bảng hướng về phía trước, đặt nó trên đường ray và bật nó lên.

Lưu ý rằng trong script, PID và 2 hằng số khác (điểm đặt tốc độ và hằng số tốc độ tối thiểu) đã được thiết lập.

Lưu ý: Tập lệnh sau có thể thiếu khoảng trắng và điều này có vẻ là do một số vấn đề khi hiển thị GitHub Gists. Nhấp vào ý chính để đưa bạn đến trang GitHub nơi bạn có thể sao chép và dán mã.

Người theo dõi dòng GiggleBot PID - Điều chỉnh w / NeoPixels

từ nhập microbit *

từ nhập gigglebot *

từ utime import sleep_ms, ticks_us

nhập khẩu

# khởi tạo neopixels GB

neo = init ()

# thời gian

update_rate = 50

# tăng / hằng số (giả sử điện áp pin là khoảng 4,0 vôn)

Kp = 25,0

Ki = 0,5

Kd = 35,0

trigger_point = 0,3

min_speed_percent = 0,3

base_speed = 70

điểm đặt = 0,5

last_position = điểm đặt

tích phân = 0,0

run_neopixels = True

center_pixel = 5 # nơi đặt pixel chính giữa của nụ cười trên GB

# turquoise = tuple (map (lambda x: int (x / 5), (64, 224, 208))) # color để sử dụng để vẽ lỗi với neopixel

# turquoise = (12, 44, 41) # chính xác là màu ngọc lam ở trên đã nhận xét ở trên

error_width_per_pixel = 0.5 / 3 # lỗi tối đa chia cho số phân đoạn giữa mỗi neopixel

defupper_bound_linear_speed_reducer (abs_error, trigger_point, upper_bound, small_motor_power, high_motor_power):

base_speed toàn cầu

nếu abs_error> = trigger_point:

# x0 = 0.0

# y0 = 0,0

# x1 = upper_bound - trigger_point

# y1 = 1,0

# x = abs_error - trigger_point

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

# giống như

y = (abs_error - trigger_point) / (upper_bound - trigger_point)

motor_power = base_speed * (small_motor_power + (1- y) * (high_motor_power - small_motor_power))

trả lại motor_power

khác:

trả về base_speed * cao nhất_motor_power

run = Sai

before_error = 0

whileTrue:

# nếu nút a được nhấn thì bắt đầu làm theo

if button_a.is_pressed ():

run = Đúng

# nhưng nếu nút b được nhấn thì dừng người theo dõi dòng

if button_b.is_pressed ():

run = Sai

tích phân = 0,0

before_error = 0.0

pixel_off ()

ngừng lại()

sleep_ms (500)

nếu chạy isTrue:

# đọc các cảm biến dòng

start_time = ticks_us ()

right, left = read_sensor (LINE_SENSOR, BOTH)

# dòng ở bên trái khi vị trí <0,5

# dòng ở bên phải khi vị trí> 0,5

# dòng ở giữa khi vị trí = 0,5

# đó là một trung bình cộng có trọng số

cố gắng:

position = right / float (left + right)

trừZeroDivisionError:

vị trí = 0,5

# phạm vi phải là (0, 1) chứ không phải [0, 1]

nếu vị trí == 0: vị trí = 0,001

nếu vị trí == 1: vị trí = 0,999

# sử dụng bộ điều khiển PD

error = position - setpoint

tích phân + = lỗi

sửa = Kp * lỗi + Ki * tích phân + Kd * (lỗi - lỗi_trước)

before_error = error

# tính toán tốc độ động cơ

motor_speed = upper_bound_linear_speed_reducer (abs (lỗi), setpoint * trigger_point, setpoint, min_speed_percent, 1,0)

leftMotorSpeed = motor_speed + chỉnh sửa

rightMotorSpeed = motor_speed - hiệu chỉnh

# thắp sáng các neopixels theo lỗi đã cho

nếu run_neopixels isTrueand total_counts% 3 == 0:

cho tôi inb '\ x00 / x01 / x02 / x03 / x04 / x05 / x06 / x07 / x08':

neo = (0, 0, 0)

cho tôi inb '\ x00 / x01 / x02 / x03':

ifabs (error)> error_width_per_pixel * i:

nếu lỗi <0:

# neo [center_pixel + i] = màu ngọc lam

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

khác:

# neo [center_pixel - i] = turquoise

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

khác:

phần trăm = 1- (error_width_per_pixel * i -abs (error)) / error_width_per_pixel

# làm sáng pixel hiện tại

nếu lỗi <0:

# neo [center_pixel + i] = tuple (bản đồ (lambda x: int (x * phần trăm), màu ngọc lam))

neo [center_pixel + i] = (int (64 * phần trăm / 5), int (224 * phần trăm / 5), int (208 * phần trăm / 5))

khác:

# neo [center_pixel - i] = tuple (bản đồ (lambda x: int (x * phần trăm), màu ngọc lam))

neo [center_pixel - i] = (int (64 * phần trăm / 5), int (224 * phần trăm / 5), int (208 * phần trăm / 5))

nghỉ

neo.show ()

cố gắng:

# clip tốc độ động cơ

nếu leftMotorSpeed> 100:

leftMotorSpeed = 100

rightMotorSpeed = rightMotorSpeed - leftMotorSpeed +100

nếu đúngMotorSpeed> 100:

rightMotorSpeed = 100

leftMotorSpeed = leftMotorSpeed - rightMotorSpeed +100

nếu leftMotorSpeed <-100:

leftMotorSpeed = -100

nếu phảiMotorSpeed <-100:

rightMotorSpeed = -100

# kích hoạt động cơ

set_speed (leftMotorSpeed, rightMotorSpeed)

lái xe()

# print ((error, motor_speed))

ngoại trừ:

# trong trường hợp chúng tôi gặp một số vấn đề không thể khắc phục

đi qua

# và duy trì tần số vòng lặp

end_time = ticks_us ()

delay_diff = (end_time - start_time) / 1000

if1000.0 / update_rate - delay_diff> 0:

ngủ (1000.0 / update_rate - delay_diff)

xem rawgigglebot_tuned_line_follower.py được lưu trữ với ❤ bởi GitHub

Bước 5: Để nó chạy

Có 2 nút trên vi BBC: bit: nút A và nút B:

• Nhấn vào nút A sẽ đặt GiggleBot theo dòng (nếu có).
• Nhấn vào nút B sẽ dừng GiggleBot và đặt lại mọi thứ để bạn có thể sử dụng lại.

Chúng tôi khuyên bạn không nên nhấc GiggleBot khi nó đang đi theo một đường và sau đó đặt nó trở lại vì lỗi đang tính toán có thể tích lũy và làm rối loạn hoàn toàn tuyến đường của robot. Nếu bạn muốn nhấc nó lên, hãy nhấn vào nút B và sau đó khi bạn đặt nó trở lại, hãy nhấn A một lần nữa.