Butter Robot: หุ่นยนต์ Arduino กับวิกฤตการดำรงอยู่: 6 ขั้นตอน (พร้อมรูปภาพ)

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

โปรเจ็กต์นี้สร้างจากซีรีย์อนิเมชั่นเรื่อง "Rick and Morty" ในตอนหนึ่ง ริกสร้างหุ่นยนต์ที่มีจุดประสงค์เพียงอย่างเดียวคือนำเนยมา ในฐานะนักศึกษาจาก Bruface (คณะวิศวกรรมศาสตร์บรัสเซลส์) เรามีงานมอบหมายสำหรับโครงการเมคคาทรอนิกส์ซึ่งก็คือการสร้างหุ่นยนต์ตามหัวข้อที่แนะนำ การมอบหมายสำหรับโครงการนี้คือ: สร้างหุ่นยนต์ที่เสิร์ฟเฉพาะเนย มันสามารถมีวิกฤตอัตถิภาวนิยม แน่นอนว่าหุ่นยนต์ในตอนของ Rick and Morty เป็นหุ่นยนต์ที่ค่อนข้างซับซ้อนและจำเป็นต้องทำให้เข้าใจง่ายขึ้น:

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

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

สรุป หุ่นยนต์ต้องปฏิบัติตามข้อกำหนดต่อไปนี้:

• ต้องปลอดภัย: ต้องหลีกเลี่ยงอุปสรรคและป้องกันตัวเองจากการล้มโต๊ะ
• หุ่นยนต์ต้องมีขนาดเล็ก: พื้นที่บนโต๊ะมีจำกัด และไม่มีใครต้องการหุ่นยนต์ที่เสิร์ฟเนยแต่มีขนาดเพียงครึ่งเดียวของโต๊ะ
• การทำงานของหุ่นยนต์ไม่สามารถขึ้นอยู่กับขนาดหรือรูปร่างของโต๊ะได้ ด้วยวิธีนี้จึงสามารถใช้กับโต๊ะต่างๆ ได้
• ต้องนำเนยไปให้คนที่ใช่ที่โต๊ะ

ขั้นตอนที่ 1: แนวคิดหลัก

ข้อกำหนดที่กล่าวถึงก่อนหน้านี้สามารถทำได้โดยใช้เทคนิคต่างๆ การตัดสินใจเกี่ยวกับการออกแบบหลักที่ได้อธิบายไว้ในขั้นตอนนี้ รายละเอียดเกี่ยวกับวิธีการนำแนวคิดเหล่านี้ไปปฏิบัติสามารถพบได้ในขั้นตอนต่อไปนี้

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

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

การตรวจจับปุ่มสามารถทำได้โดยใช้เซ็นเซอร์ IR และไฟ LED ข้อดีของ IR คือมองไม่เห็นซึ่งทำให้การใช้งานไม่รบกวนผู้คนที่โต๊ะอาหาร สามารถใช้เลเซอร์ได้เช่นกัน แต่จากนั้นแสงจะมองเห็นได้และเป็นอันตรายเมื่อมีคนชี้เลเซอร์ไปที่ดวงตาของบุคคลอื่น นอกจากนี้ ผู้ใช้จะต้องกำหนดเป้าหมายเซ็นเซอร์บนหุ่นยนต์ด้วยลำแสงเลเซอร์บางๆ ซึ่งค่อนข้างน่ารำคาญ ด้วยการจัดเตรียมหุ่นยนต์ด้วยเซ็นเซอร์ IR สองตัว และสร้างปุ่มด้วยไฟ LED IR หุ่นยนต์รู้ทิศทางที่เขาต้องการไปโดยทำตามความเข้มของแสงอินฟราเรด เมื่อไม่มีปุ่ม หุ่นยนต์สามารถหมุนไปรอบๆ ได้จนกว่าไฟ LED ดวงใดดวงหนึ่งจะจับสัญญาณจากปุ่มใดปุ่มหนึ่ง

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

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

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

ขั้นตอนที่ 2: วัสดุ

ชิ้นส่วนเครื่องจักรกล

• เครื่องพิมพ์ 3 มิติและเครื่องตัดเลเซอร์

  • PLA จะใช้สำหรับการพิมพ์ 3 มิติ แต่คุณยังสามารถใช้ABS.ได้
  • แผ่นไม้อัดเบิร์ช 3 มม. จะใช้สำหรับการตัดด้วยเลเซอร์ เนื่องจากทำให้ปรับเปลี่ยนได้ง่ายในภายหลัง สามารถใช้เพล็กซิกลาสได้ แต่จะปรับเปลี่ยนได้ยากกว่าเมื่อตัดด้วยเลเซอร์โดยไม่ทำลาย

• น็อต น็อต แหวนรอง

  ส่วนประกอบส่วนใหญ่ยึดเข้าด้วยกันโดยใช้สลักเกลียวหัวปุ่ม M3 แหวนรอง และน็อต แต่บางส่วนต้องใช้ชุดสลักเกลียว M2 หรือ M4 ความยาวของสลักเกลียวอยู่ในช่วง 8-12 มม

• ตัวเว้นระยะ PCB, 25 มม. และ 15 มม.
• เซอร์โวมอเตอร์ 2 ตัวพร้อมล้อที่เข้ากันได้
• ลวดโลหะหนาประมาณ 1-2 มม.

ชิ้นส่วนอิเล็กทรอนิกส์

• ไมโครคอนโทรลเลอร์

  1 บอร์ด Arduino UNO

• เซอร์โวมอเตอร์

  • เซอร์โวมอเตอร์ขนาดใหญ่ 2 ตัว: Feetech ต่อเนื่อง 6Kg 360 องศา
  • มอเตอร์เซอร์โวขนาดเล็ก 2 ตัว: Feetech FS90

• เซนเซอร์

  • 1 เซ็นเซอร์อัลตราโซนิก
  • เซ็นเซอร์ความใกล้ชิดอินฟราเรด 2 ตัว
  • โฟโตไดโอด IR 2 ตัว

• แบตเตอรี่

  • 1 ที่ใส่แบตเตอรี่ 9V + แบตเตอรี่
  • ที่ใส่แบตเตอรี่ 4AA 1 ก้อน + แบตเตอรี่
  • 1 กล่องแบตเตอรี่ 9V + แบตเตอรี่

• ส่วนประกอบเพิ่มเติม

  • สายกระโดด สายไฟ และแผ่นบัดกรี
  • ตัวต้านทานบางตัว
  • 1 IR LED
  • 3 สวิตช์
  • ออด 1 ตัว
  • 1 ปุ่ม
  • 1 ขั้วต่อแบตเตอรี่ Arduino ถึง 9V

ขั้นตอนที่ 3: ทดสอบอุปกรณ์อิเล็กทรอนิกส์

การสร้างปุ่ม:

ปุ่มนี้สร้างขึ้นโดยง่ายด้วยสวิตช์ ไฟ LED อินฟราเรด และตัวต้านทาน 220 โอห์มแบบอนุกรม ใช้พลังงานจากแบตเตอรี่ 9V ชุดนี้ใส่ในชุดแบตเตอรี่ 9V เพื่อการออกแบบที่กะทัดรัดและสะอาดตา

การสร้างโมดูลรับสัญญาณอินฟราเรด:

โมดูลเหล่านี้ทำด้วยแผงบัดกรีแบบรูทะลุ ซึ่งต่อมาจะติดด้วยสกรูกับหุ่นยนต์ในภายหลัง วงจรสำหรับโมดูลเหล่านี้แสดงไว้ในแผนผังทั่วไป หลักการคือการวัดความเข้มของแสงอินฟราเรด เพื่อปรับปรุงการวัด สามารถใช้คอลลิเมเตอร์ (ทำด้วยท่อหด) เพื่อโฟกัสไปยังทิศทางที่สนใจได้

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

• เซอร์โวมอเตอร์แบบต่อเนื่อง;
• เซ็นเซอร์อัลตราโซนิก;
• เซอร์โวมอเตอร์ไม่ต่อเนื่อง
• ออด;
• การตรวจจับทิศทางปุ่ม IR;
• การตรวจจับขอบด้วยพรอกซิมิตี้เซนเซอร์

รหัสเหล่านี้สามารถช่วยให้เข้าใจส่วนประกอบต่างๆ ในตอนเริ่มต้น แต่ก็มีประโยชน์มากสำหรับการดีบักในภายหลัง หากเกิดปัญหาขึ้น สามารถตรวจพบจุดบกพร่องได้ง่ายขึ้นโดยการทดสอบส่วนประกอบทั้งหมดแยกกัน

ขั้นตอนที่ 4: การออกแบบชิ้นส่วนที่พิมพ์ 3 มิติและเลเซอร์คัต

เลเซอร์ตัดชิ้น

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

เพลตเหล่านี้จำเป็นต้องเจาะรูที่จำเป็นเพื่อขันสกรูสเปเซอร์และส่วนประกอบอื่นๆ สำหรับการประกอบขั้นสุดท้าย โดยหลักแล้ว แผ่นทั้งสามแผ่นมีรูอยู่ที่ตำแหน่งเดียวกันสำหรับตัวเว้นระยะ และรูเฉพาะสำหรับอุปกรณ์อิเล็กทรอนิกส์ที่ยึดตามแต่ละแผ่นตามลำดับ สังเกตว่าแผ่นตรงกลางมีรูสำหรับร้อยสายไฟอยู่ตรงกลาง

ชิ้นส่วนที่เล็กกว่าจะถูกตัดให้ได้ขนาดของเซอร์โวขนาดใหญ่เพื่อยึดเข้ากับชุดประกอบ

3D พิมพ์ชิ้น

นอกจากการตัดด้วยเลเซอร์แล้ว บางชิ้นจะต้องพิมพ์ 3 มิติ:

• การรองรับเซ็นเซอร์อัลตราโซนิกซึ่งเชื่อมโยงกับแขนเซอร์โวมอเตอร์ขนาดเล็กหนึ่งตัว
• รองรับล้อเลื่อนและเซ็นเซอร์ขอบ IR สองตัว การออกแบบเฉพาะของปลายชิ้นรูปทรงกล่องสำหรับเซ็นเซอร์ IR ทำหน้าที่เป็นหน้าจอเพื่อหลีกเลี่ยงการรบกวนระหว่างปุ่มที่ส่งสัญญาณ IR และเซ็นเซอร์ IR ที่ต้องเน้นเฉพาะสิ่งที่เกิดขึ้นบนพื้นดินเท่านั้น
• รองรับไมโครเซอร์โวมอเตอร์ที่เปิดฝา

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

  • อันล่างซึ่งจะยึดกับเพลทบน
  • และด้านบนซึ่งเชื่อมต่อกับด้านล่างด้วยบานพับ และกระตุ้นโดยเซอร์โวโดยใช้ลวดโลหะหนา เราตัดสินใจเพิ่มบุคลิกเล็กน้อยให้กับหุ่นยนต์โดยให้ความเห็นแก่หุ่นยนต์

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

ไฟล์ SOLIDWORKS ทั้งหมดสามารถพบได้ในโฟลเดอร์ซิป

ขั้นตอนที่ 5: การประกอบและการเดินสายไฟ

การประกอบจะเป็นการผสมผสานระหว่างการเดินสายไฟและการขันส่วนประกอบเข้าด้วยกันโดยเริ่มจากด้านล่างขึ้นด้านบน

แผ่นด้านล่าง

แผ่นด้านล่างประกอบกับชุดแบตเตอรี่ 4AA, เซอร์โวมอเตอร์, ชิ้นส่วนพิมพ์ (ติดลูกล้อใต้เพลต), เซ็นเซอร์ขอบทั้งสอง และตัวเว้นวรรคชาย-หญิง 6 ตัว

จานกลาง

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

โมดูลอัลตราโซนิกสามารถติดเข้ากับเซอร์โวที่ไม่ต่อเนื่องซึ่งติดตั้งไว้ที่แผ่นตรงกลางด้วย Arduino, ชุดแบตเตอรี่ 9V (จ่ายไฟให้กับ Arduino) และโมดูลรับสัญญาณอินฟราเรดสองตัวที่ด้านหน้าของหุ่นยนต์ โมดูลเหล่านี้ทำด้วยบอร์ดบัดกรีแบบรูรูและยึดด้วยสกรูเข้ากับเพลต วงจรสำหรับโมดูลเหล่านี้แสดงไว้ในแผนผังทั่วไป

จานบน

ในส่วนนี้ของการประกอบ สวิตซ์ไม่ได้รับการแก้ไข แต่หุ่นยนต์สามารถทำทุกอย่างได้ยกเว้นการกระทำที่ต้องใช้ฝาปิด ซึ่งช่วยให้เราสามารถทำการทดสอบเพื่อแก้ไข treshold เพื่อปรับรหัสของการเคลื่อนไหวและเพื่อให้ง่าย เข้าถึงพอร์ตของ Arduino

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

สิ่งสุดท้ายที่ต้องทดสอบและแก้ไขคือมุมของเซอร์โวเพื่อเปิดฝาอย่างถูกต้อง

ต้องปรับเกณฑ์ของเซ็นเซอร์ขอบด้วยโพเทนชิออมิเตอร์ที่ให้มา (โดยใช้ไขควงปากแบน) สำหรับพื้นผิวโต๊ะต่างๆ ตารางสีขาวควรมีเกณฑ์ที่ต่ำกว่าตารางสีน้ำตาลเป็นต้น นอกจากนี้ ความสูงของเซ็นเซอร์ยังส่งผลต่อเกณฑ์ที่ต้องการอีกด้วย

เมื่อสิ้นสุดขั้นตอนนี้ การประกอบจะเสร็จสิ้น และส่วนสุดท้ายที่เหลือคือรหัสที่ขาดหายไป

ขั้นตอนที่ 6: การเข้ารหัส: รวบรวมทุกอย่างเข้าด้วยกัน

รหัสที่จำเป็นทั้งหมดเพื่อให้หุ่นยนต์ทำงานอยู่ในไฟล์ซิปที่สามารถดาวน์โหลดได้ สิ่งที่สำคัญที่สุดคือรหัส "หลัก" ที่มีการตั้งค่าและลูปการทำงานของหุ่นยนต์ ฟังก์ชันอื่นๆ ส่วนใหญ่เขียนเป็นไฟล์ย่อย (รวมถึงในโฟลเดอร์ซิปด้วย) ไฟล์ย่อยเหล่านี้ควรบันทึกไว้ในโฟลเดอร์เดียวกัน (ซึ่งมีชื่อว่า "main") เป็นสคริปต์หลักก่อนอัปโหลดไปยัง Arduino

ขั้นแรกให้กำหนดความเร็วทั่วไปของหุ่นยนต์พร้อมกับตัวแปร "เตือน" "การเตือน" นี้เป็นค่าที่จดจำว่าหุ่นยนต์กำลังหมุนไปในทิศทางใด ถ้า "เตือน = 1" หุ่นยนต์กำลัง/กำลังเลี้ยวซ้าย ถ้า "เตือน = 2" หุ่นยนต์กำลัง/กำลังเลี้ยวขวา

ความเร็ว int = 9; // ความเร็วทั่วไปของหุ่นยนต์

int เตือน = 1; // ทิศทางเริ่มต้น

ในการตั้งค่าหุ่นยนต์ ไฟล์ย่อยต่างๆ ของโปรแกรมจะถูกเตรียมข้อมูลเบื้องต้น ในไฟล์ย่อยเหล่านี้ มีการเขียนฟังก์ชันพื้นฐานเกี่ยวกับการควบคุมมอเตอร์ เซ็นเซอร์ … โดยเริ่มต้นในการตั้งค่า ฟังก์ชันที่อธิบายในแต่ละไฟล์เหล่านี้สามารถใช้ในลูปหลักได้ โดยการเปิดใช้งานฟังก์ชัน r2D2() หุ่นยนต์จะส่งเสียงเหมือนหุ่นยนต์ R2D2 จากแฟรนไชส์ภาพยนตร์ Star Wars เมื่อ มันเริ่มต้นขึ้น ที่นี่ ฟังก์ชัน r2D2() ถูกปิดใช้งานเพื่อป้องกันไม่ให้เสียงกริ่งดึงกระแสไฟมากเกินไป

การตั้งค่าเป็นโมฆะ () { initialize_IR_sensors (); initialize_obstacles_and_edges(); initialize_movement(); initialize_lid(); initialize_buzzer(); // r2D2(); int เตือน = 1; // ทิศทางเริ่มต้น Starter (เตือน); }

ฟังก์ชัน Starter(remind) จะถูกเรียกในการตั้งค่าก่อน ฟังก์ชันนี้ทำให้หุ่นยนต์หันกลับมามองหาสัญญาณ IR ของปุ่มใดปุ่มหนึ่ง เมื่อพบปุ่มแล้ว โปรแกรมจะออกจากฟังก์ชัน Starter โดยเปลี่ยนตัวแปร 'cond' เป็น false ระหว่างการหมุนของหุ่นยนต์ จะต้องตระหนักถึงสภาพแวดล้อมของมัน: จะต้องตรวจจับขอบและสิ่งกีดขวาง มีการตรวจสอบทุกครั้งก่อนจะหมุนต่อไป เมื่อหุ่นยนต์ตรวจพบสิ่งกีดขวางหรือขอบ โปรโตคอลเพื่อหลีกเลี่ยงสิ่งกีดขวางหรือขอบเหล่านี้จะถูกดำเนินการ โปรโตคอลเหล่านี้จะอธิบายในภายหลังในขั้นตอนนี้ ฟังก์ชัน Starter มีตัวแปรหนึ่งตัวซึ่งเป็นตัวแปรเตือนที่กล่าวถึงก่อนหน้านี้ โดยการให้ค่าการเตือนแก่ฟังก์ชัน Starter หุ่นยนต์จะรู้ว่าต้องหันไปทางใดเพื่อที่จะมองหาปุ่ม

//Starter Loop: หันหลังกลับและค้นหาปุ่ม //------------------------------------------ ----------------

ถือเป็นโมฆะ Starter (int เตือน) { if (isedgeleft () || isedgeright ()) {// ตรวจจับขอบ edgeDetected (เตือน); } อื่น ๆ { bool cond = true; while (cond == true) { if (buttonleft() == false && buttonright() == false && isButtonDetected() == true) { cond = false; } else { if (remind == 1) { // เราเลี้ยวซ้าย if (isobstacleleft()) { stopspeed(); หลีกเลี่ยง _obstacle (เตือน); } else if (isedgeleft() || isedgeright()) { // ตรวจจับขอบ edgeDetected (เตือน); } อื่น ๆ { เลี้ยวซ้าย (ความเร็ว); } } else if (เตือน == 2) { if (isobstacleright()) { stopspeed(); หลีกเลี่ยง _obstacle (เตือน); } else if (isedgeleft() || isedgeright()) { // ตรวจจับขอบ edgeDetected (เตือน); } อื่น { เลี้ยวขวา (ความเร็ว); } } } } } } }

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

• ความแตกต่างระหว่างแสง IR ที่ตรวจพบโดยเซ็นเซอร์ด้านซ้ายและขวานั้นมากกว่าเกณฑ์ที่กำหนดและมีปุ่มอยู่
• ความแตกต่างของแสงอินฟราเรดนั้นน้อยกว่าเกณฑ์ และมีปุ่มอยู่ด้านหน้าหุ่นยนต์
• ความแตกต่างของแสงอินฟราเรดนั้นน้อยกว่าเกณฑ์ และไม่มีปุ่มที่ด้านหน้าของหุ่นยนต์

วิธีการทำงานของแทร็กประจำมีดังนี้: เมื่อตรวจพบปุ่ม หุ่นยนต์จะเคลื่อนที่ไปทางปุ่มโดยหมุนไปในทิศทางเดียวกับที่มันหมุน (โดยใช้ตัวแปรการเตือน) และในขณะเดียวกันก็เคลื่อนไปข้างหน้าเล็กน้อย หากหุ่นยนต์หมุนมากเกินไป ปุ่มจะหายไปอีกครั้ง และเมื่อถึงจุดนี้ หุ่นยนต์จะจำได้ว่าเขาต้องหันไปทางอื่น สิ่งนี้ทำได้ในขณะที่ก้าวไปข้างหน้าเล็กน้อย เมื่อทำเช่นนี้ หุ่นยนต์จะเลี้ยวซ้ายและเลี้ยวขวาอย่างต่อเนื่อง แต่ในขณะเดียวกันก็ยังคงเคลื่อนเข้าหาปุ่ม ทุกครั้งที่หุ่นยนต์พบปุ่ม มันจะหมุนไปเรื่อยๆ จนกว่าปุ่มจะหายไป ซึ่งในกรณีนี้มันจะเริ่มเคลื่อนที่ไปอีกทางหนึ่ง สังเกตความแตกต่างในฟังก์ชันที่ใช้ใน Starter loop และ main loop: Starter loop ใช้ "turnleft()" หรือ "turnright()" ในขณะที่ลูปหลักใช้ "moveleft()" และ "moveright()" ฟังก์ชัน moveleft/right ไม่เพียงแต่ทำให้หุ่นยนต์หมุนได้ แต่ยังทำให้เขาเคลื่อนที่ไปข้างหน้าพร้อมกันด้วย

/* Functional loop ---------------------------- ตรงนี้มีแต่ track Routine */

int หายไป = 0; // หากสูญหาย = 0 พบปุ่ม หากสูญหาย = 1 ปุ่มจะหายไป void loop() { if (isedgeleft() || isedgeright()) {

ถ้า (!isobstacle()) {

ก้าวไปข้างหน้า(ความเร็ว); ล่าช้า(5); } อื่น ๆ {หลีกเลี่ยง_obstacle (เตือน); } อื่น {ถ้า (เตือน == 1 && แพ้ == 1) { // เราเลี้ยวซ้ายหยุดความเร็ว (); ถ้า (!isobstacleright()) { เคลื่อนที่เร็ว (ความเร็ว); // หันกลับไปหาปุ่ม } อื่น ๆ {หลีกเลี่ยงสิ่งกีดขวาง (เตือน); } เตือน = 2; } else if (เตือน == 2 && แพ้ == 1) { stopspeed(); ถ้า (!isobstacleleft()) { moveleft (ความเร็ว); //เรากำลังเลี้ยวขวา } อื่นๆ {หลีกเลี่ยงสิ่งกีดขวาง (เตือน); } เตือน = 1; } else if (lost == 0) { if (remind == 1) { // เราเลี้ยวซ้าย if (!isobstacleleft()) { moveleft (speed); //เรากำลังเลี้ยวขวา } อื่น { stopspeed(); หลีกเลี่ยง _obstacle (เตือน); } // } else if (เตือน == 2) { if (!isobstacleright()) { เคลื่อนที่เร็ว (ความเร็ว); // หันไปหาปุ่ม } else { stopspeed(); หลีกเลี่ยง _obstacle (เตือน); } } } ล่าช้า(10); แพ้ = 0; } } //} }

ตอนนี้มีคำอธิบายเล็กน้อยของสองกิจวัตรที่ซับซ้อนที่สุด:

หลีกเลี่ยงขอบ

โปรโตคอลเพื่อหลีกเลี่ยงขอบถูกกำหนดไว้ในฟังก์ชันที่เรียกว่า "edgeDetection()" ซึ่งเขียนไว้ในไฟล์ย่อย "การเคลื่อนไหว" โปรโตคอลนี้อาศัยข้อเท็จจริงที่ว่าหุ่นยนต์ควรพบขอบเมื่อถึงปลายทางเท่านั้น: ปุ่ม เมื่อหุ่นยนต์ตรวจพบขอบ สิ่งแรกที่มันทำคือขยับถอยหลังเล็กน้อยเพื่อให้อยู่ในระยะที่ปลอดภัยจากขอบ เมื่อเสร็จแล้ว หุ่นยนต์จะรอ 2 วินาที ถ้ามีคนกดปุ่มที่ด้านหน้าของหุ่นยนต์ในสองวินาทีนั้น หุ่นยนต์รู้ว่ามันมาถึงคนที่ต้องการเนยแล้ว และเปิดช่องใส่เนยและยื่นเนยให้ณ จุดนี้ มีคนเอาเนยออกจากหุ่นยนต์ได้ หลังจากนั้นไม่กี่วินาที หุ่นยนต์จะเบื่อที่จะรอและจะปิดฝาเนย เมื่อปิดฝาแล้ว หุ่นยนต์จะดำเนินการวนรอบ Starter เพื่อค้นหาปุ่มอื่น หากเกิดขึ้นที่หุ่นยนต์พบขอบก่อนที่จะถึงจุดหมายปลายทางและไม่ได้กดปุ่มที่ด้านหน้าของหุ่นยนต์ หุ่นยนต์จะไม่เปิดฝาเนยและจะดำเนินการวนรอบ Starter ทันที

หลีกเลี่ยงอุปสรรค

ฟังก์ชัน avoid_obstacle() ยังอยู่ในไฟล์ย่อย "การเคลื่อนไหว" ส่วนที่ยากในการหลีกเลี่ยงอุปสรรคคือความจริงที่ว่าหุ่นยนต์มีจุดบอดที่ค่อนข้างใหญ่ เซ็นเซอร์อัลตราโซนิกถูกวางไว้ที่ด้านหน้าของหุ่นยนต์ ซึ่งหมายความว่าสามารถตรวจจับสิ่งกีดขวางได้ แต่ไม่รู้ว่าจะผ่านไปเมื่อไหร่ ในการแก้ปัญหานี้ ใช้หลักการดังต่อไปนี้: เมื่อหุ่นยนต์พบสิ่งกีดขวาง หุ่นยนต์จะใช้ตัวแปรเรมิงเพื่อหมุนไปในทิศทางอื่น วิธีนี้ทำให้หุ่นยนต์หลีกเลี่ยงการชนสิ่งกีดขวาง หุ่นยนต์จะหมุนต่อไปจนกว่าเซ็นเซอร์อัลตราโซนิกจะตรวจไม่พบสิ่งกีดขวางอีกต่อไป ในช่วงเวลาที่หุ่นยนต์กำลังหมุน ตัวนับจะเพิ่มขึ้นจนกว่าจะตรวจไม่พบสิ่งกีดขวางอีกต่อไป ตัวนับนี้ให้ค่าประมาณความยาวของสิ่งกีดขวาง โดยการเคลื่อนไปข้างหน้าและในขณะเดียวกันการลดเคาน์เตอร์สามารถหลีกเลี่ยงสิ่งกีดขวางได้ เมื่อตัวนับถึง 0 คุณสามารถใช้ฟังก์ชัน Starter อีกครั้งเพื่อย้ายปุ่ม แน่นอนว่าหุ่นยนต์จะทำหน้าที่สตาร์ทเตอร์โดยหมุนไปในทิศทางที่จำได้ว่ามันกำลังเดินไปก่อนที่เขาจะพบกับสิ่งกีดขวาง (อีกครั้งโดยใช้ตัวแปรการเตือน)

เมื่อคุณเข้าใจโค้ดอย่างถ่องแท้แล้ว ก็เริ่มใช้งานได้เลย!

อย่าลืมปรับเกณฑ์ให้เข้ากับสภาพแวดล้อมของคุณ (เช่น การสะท้อน IR สูงกว่าบนตารางสีขาว) และปรับพารามิเตอร์ต่างๆ ให้เข้ากับความต้องการของคุณ นอกจากนี้ ควรให้ความสนใจเป็นพิเศษกับการเปิดเครื่องของโมดูลต่างๆ สิ่งสำคัญคือ เซอร์โวมอเตอร์ไม่ได้ขับเคลื่อนโดยพอร์ต Arduino 5V เนื่องจากใช้กระแสไฟมาก (อาจทำให้ไมโครคอนโทรลเลอร์เสียหายได้) หากเซ็นเซอร์ใช้แหล่งพลังงานเดียวกันกับแหล่งจ่ายไฟเซอร์โว อาจพบปัญหาการวัดบางอย่าง