สารบัญ:
- ผู้เขียน John Day [email protected].
- Public 2024-01-30 13:05.
- แก้ไขล่าสุด 2025-01-23 15:12.
ใน Instructables สั้น ๆ นี้ คุณจะต้องปรับแต่ง GiggleBot ของคุณเองให้ทำตามเส้นสีดำ ในบทช่วยสอนอื่น ๆ ของ GiggleBot Line Follower เราฮาร์ดโค้ดค่าการปรับแต่งให้ทำงานตามสถานการณ์นั้น คุณอาจต้องการทำให้มันทำงานได้ดีขึ้นด้วยการหาผลประโยชน์อื่นๆ
ในบทช่วยสอนนี้ เรากำลังแสดงให้คุณเห็น 2 สคริปต์ที่สามารถโหลดทั้งสองสคริปต์บน BBC micro:bits ที่แตกต่างกัน เพื่อให้หนึ่งในนั้นถูกใส่ลงใน GiggleBot และอีกปุ่มหนึ่งจะใช้ 2 ปุ่มเพื่อเข้าสู่เมนูและปรับแต่งให้แตกต่างกัน พารามิเตอร์ การส่งพารามิเตอร์ที่อัปเดตเหล่านี้ทำได้ผ่านวิทยุ
ขั้นตอนที่ 1: ส่วนประกอบที่จำเป็น
คุณจะต้องมีสิ่งต่อไปนี้:
- หุ่นยนต์ GiggleBot สำหรับ micro:bit
- x3 AA แบตเตอรี่
- x2 BBC micro:bits - อันหนึ่งสำหรับ GiggleBot และอีกอันหนึ่งทำหน้าที่เป็นรีโมตสำหรับปรับแต่งพารามิเตอร์
- แบตเตอรี่สำหรับ 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 ซึ่งจะใช้เพื่อปรับแต่งพารามิเตอร์ต่อไปนี้:
- Kp = อัตราขยายตามสัดส่วนสำหรับตัวควบคุม PID
- Ki = กำไรรวมสำหรับคอนโทรลเลอร์ PID
- Kd = อนุพันธ์เกนสำหรับคอนโทรลเลอร์ PID
- trigger_point = จุดที่แสดงเป็นเปอร์เซ็นต์ระหว่างความเร็วต่ำสุดและสูงสุดของ GiggleBot โดยที่ความเร็วเริ่มลดลงเป็นเส้นตรงจนกว่าจะถึงความเร็วต่ำสุด
- 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 จะเพิ่ม/ลดค่าที่เกี่ยวข้อง มันเหมือนกับการตั้งนาฬิกาบนแผงหน้าปัดของรถรุ่นเก่า ตัวเลือกมีลักษณะดังนี้:
- 0-1 ตัวเลือกสำหรับกำไร Kp
- 2-3 ตัวเลือกสำหรับกำไร Ki
- 4-5 ตัวเลือกสำหรับกำไร Kd
- ตัวเลือก 6-7 ตัวใช้สำหรับตั้งค่าจุดที่กำหนดไว้สำหรับช่วงเวลาที่มอเตอร์เริ่มช้าลง
- 8-9 ตัวเลือกสำหรับการตั้งค่าความเร็วขั้นต่ำ
โปรดทราบว่าตัวเลขคู่ในเมนูใช้สำหรับการเพิ่มค่าที่สอดคล้องกัน และสำหรับเลขคี่จะเป็นค่าตรงกันข้าม
นอกจากนี้ เมื่อกดปุ่ม B บน BBC micro:bit ของ GiggleBot คุณจะเห็นจำนวนมิลลิวินาทีที่ผ่านไปตั้งแต่การรีเซ็ตครั้งล่าสุดและจำนวนรอบที่หุ่นยนต์ผ่านไปบนหน้าจอที่สร้างด้วยนีโอพิกเซลด้วย 2 สิ่งเหล่านี้คุณสามารถคำนวณได้ อัตราการอัพเดทของหุ่นยนต์
สุดท้ายและที่สำคัญที่สุด ฉันได้ปรับแต่ง 2 ค่าสำหรับ GiggleBot หนึ่งในนั้นใช้สำหรับเมื่อปิด Neopixel LED และอีกอันใช้สำหรับเมื่อเป็นอย่างอื่น ไฟ LED Neopixel ใช้เพื่อแสดงว่าเกิดข้อผิดพลาดขึ้นในทิศทางใด
การปรับค่าพารามิเตอร์ชุดที่ 1 (โดยปิด LED NeoPixel)
- Kp = 32.0
- Ki = 0.5
- Kd = 80.0
- trigger_setpoint = 0.3 (ซึ่งเท่ากับ 30%)
- min_speed_percent = 0.2 (ซึ่งก็คือ 20%)
- base_speed = 100 (หรือที่เรียกว่าความเร็วสูงสุด)
- update_rate = 70 (รัน @70Hz)
การปรับค่าพารามิเตอร์ชุดที่ 2 (โดยเปิด NeoPixel LED)
- Kp = 25.0
- Ki = 0.5
- Kd = 35.0
- trigger_setpoint = 0.3 (ซึ่งเท่ากับ 30%)
- min_speed_percent = 0.3 (ซึ่งก็คือ 30%)
- base_speed = 70 (หรือที่เรียกว่าความเร็วสูงสุด)
- update_rate = 50 (รัน @50Hz)
- นอกจากนี้ ตัวแปร 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
แนะนำ:
Line Follower บน Tinkercad: 3 ขั้นตอน
Line Follower บน Tinkercad: หุ่นยนต์ A-Line Follower Robot ตามชื่อของมัน เป็นยานพาหนะนำทางอัตโนมัติ ซึ่งเดินตามเส้นสายตาที่ฝังอยู่บนพื้นหรือเพดาน โดยปกติ เส้นสายตาคือเส้นทางที่หุ่นยนต์ตัวตามเส้นไป และมันจะเป็นเส้นสีดำบนเ
หุ่นยนต์ Line Follower ด้วย PICO: 5 ขั้นตอน (พร้อมรูปภาพ)
Line Follower Robot ด้วย PICO: ก่อนที่คุณจะสามารถสร้างหุ่นยนต์ที่สามารถยุติอารยธรรมที่เรารู้จักและสามารถยุติเผ่าพันธุ์มนุษย์ได้ ก่อนอื่นคุณต้องสามารถสร้างหุ่นยนต์ง่ายๆ หุ่นยนต์ที่สามารถทำตามเส้นที่ลากบนพื้นได้ และนี่คือที่ที่คุณจะไ
Line Follower Robot Arduino และ L293D Shield: 4 ขั้นตอน
Line Follower Robot Arduino และ L293D Shield: Line Follower เป็นหุ่นยนต์ที่ง่ายมากเหมาะสำหรับอุปกรณ์อิเล็กทรอนิกส์สำหรับผู้เริ่มต้น หุ่นยนต์เคลื่อนที่ไปตามเส้นโดยใช้เซ็นเซอร์ iR เซ็นเซอร์มีไดโอดสองตัว ไดโอดหนึ่งส่งแสงอินฟราเรด อีกไดโอดรับแสงสะท้อนจากพื้นผิว NS
การปรับแต่ง PulseSensor Visualizer เพื่อทริกเกอร์เหตุการณ์ (การตรวจสอบการต่อต้านการผลิต): 8 ขั้นตอน
การปรับแต่ง PulseSensor Visualizer เพื่อทริกเกอร์เหตุการณ์ (Anti-Productivity Monitor): ในคำแนะนำนี้ คุณจะได้เรียนรู้วิธีแก้ไขโปรแกรม PulseSensor Visualizer เพื่อทริกเกอร์เหตุการณ์ในเว็บเบราว์เซอร์ ฉันกำลังเรียกโปรเจ็กต์นี้ว่า Anti Productivity Monitor เพราะในขณะที่เรามีเครื่องมือมากมายที่ช่วยเราตรวจสอบพลังชีวิตของเรา
GiggleBot Line Follower โดยใช้ Python: 5 ขั้นตอน
GiggleBot Line Follower โดยใช้ Python: คราวนี้ เรากำลังเขียนโปรแกรมใน MicroPython the Dexter Industries GiggleBot ให้ติดตามเส้นสีดำโดยใช้เซ็นเซอร์ติดตามบรรทัดในตัว GiggleBot จะต้องจับคู่กับ BBC micro:bit เพื่อให้สามารถ ถูกควบคุมอย่างเหมาะสม หาก