บ้าน

หุ่นยนต์ Arduino สำเร็จรูป หุ่นยนต์สี่ขาที่ใช้ Arduino หุ่นยนต์ติดตามยานพาหนะที่ใช้ Arduino ควบคุมจากโทรศัพท์มือถือ

ขอให้เป็นวันที่ดี! ต่อหน้าคุณ คนที่รักคือหุ่นยนต์ศิลปะที่สามารถทาสีวัตถุทรงกลมหรือรูปไข่ได้หลากหลายขนาดตั้งแต่ 4 ถึง 9 ซม.

ในการสร้าง คุณต้องมีเครื่องพิมพ์ 3 มิติ ชุดเครื่องมือมาตรฐาน + Arduino

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

ขั้นตอนที่ 1: เล็กน้อยเกี่ยวกับหุ่นยนต์

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

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

ขั้นตอนที่ 2: อะไหล่ที่จำเป็น

เพื่อทำ งานฝีมือทำเองเราจะต้อง:

ตลับลูกปืน 2x 623;
กิ๊บติดผมที่มีขนาดเส้นผ่าศูนย์กลาง 3 มม. และความยาว 80-90 มม.
สปริง 1x (ความยาว 10 มม. และเส้นผ่านศูนย์กลาง 4.5 มม.);
2x NEMA 17 สเต็ปเปอร์มอเตอร์ (แรงบิด 4.4 กก./ซม.);
สายไฟสำหรับมอเตอร์ (ความยาว 14 + 70 ซม.)
สาย USB;
1x SG90 เซอร์โว;
Arduino เลโอนาร์โด;
โล่ JJRobots;

ตัวขับสเต็ปเปอร์มอเตอร์ 2xA4988;
แหล่งจ่ายไฟ 12V / 2A;
สกรู 11x M3 6 มม.
สกรู 4x M3 16 มม.;
4x ถั่ว M3;
ถ้วยดูด 2x 20 มม.;
1x น๊อตปีกนก M3;
เครื่องหมาย 1x;

ขั้นตอนที่ 3: โครงการทั่วไป

คุณสามารถใช้โครงร่างนี้ได้ในฐานะ "แผ่นโกง"

ขั้นตอนที่ 4: มาเริ่มกันเลย!

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

ขั้นตอนที่ 5: หุ่นยนต์

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

ขั้นตอนที่ 6: ตัวดูด

ติดตั้งถ้วยดูดอันใดอันหนึ่งในรูในที่ยึดรายการ

ขั้นตอนที่ 7: การติดสเต็ปเปอร์มอเตอร์

ยึดสเต็ปเปอร์มอเตอร์ทั้งสองตัวเข้ากับเฟรมหลักด้วยสกรู 8 ตัว

ขั้นตอนที่ 8: แกนหมุน

ให้วางองค์ประกอบทั้งหมดตามที่แสดงในภาพด้านบน

ดูด;
สกรู;
ส่วนบน;
ฤดูใบไม้ผลิ;
แบริ่ง 623 (ควรใส่ในถ้วยด้านซ้าย)
ถ้วยซ้าย;
พื้นที่ว่างสำหรับเฟรมหลัก
ถ้วยขวา;
แบริ่ง 623;
แหวนแยก;
น๊อตปีกนก (M3).

ขั้นตอนที่ 9: ใส่ทุกอย่างเข้าที่

ใส่หุ่นยนต์ที่ประกอบเข้ากับแกนของสเต็ปเปอร์มอเตอร์

ติดตั้งส่วนรองรับด้านซ้ายบนแกนของสเต็ปเปอร์มอเตอร์

เครื่องหมายและไข่ถูกกำหนดไว้เป็นตัวอย่าง (คุณไม่จำเป็นต้องวางตอนนี้)

หมายเหตุ: เซอร์โวจะต้องมีการปรับเปลี่ยน คุณจะต้องตั้งค่ามุมใหม่ในระหว่างกระบวนการสอบเทียบ

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

แก้ไขอุปกรณ์อิเล็กทรอนิกส์ที่ด้านหลังของเฟรมหลักด้วยสกรู (2 อันก็พอ)

มาเชื่อมต่อสายเคเบิลกันเถอะ

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

ขั้นตอนที่ 11: การเขียนโปรแกรม Arduino Leonardo

มาตั้งโปรแกรม Arduino Leonardo โดยใช้สภาพแวดล้อมซอฟต์แวร์ Arduino IDE (v 1.8.1)

ดาวน์โหลด Arduino IDE (v 1.8.1) และติดตั้งโปรแกรม
มาเรียกใช้ซอฟต์แวร์กัน เลือกบอร์ด Arduino Leonardo และ COM-PORT ที่เกี่ยวข้องในเมนู "tools->board"
มาเปิดดาวน์โหลดโค้ด Sphere-O-Bot กันเถอะ มาแตกไฟล์ทั้งหมดในโฟลเดอร์เดียวแล้วเรียกมันว่า "Ejjduino_ARDUINO"

ขั้นตอนที่ 12: Art Robot พร้อมสร้างงานศิลปะ

ขั้นตอนที่ 13: การควบคุมหุ่นยนต์

ซอฟต์แวร์ อิงค์สเคปดาวน์โหลดและติดตั้งซอฟต์แวร์ Inkscape (ฉันแนะนำเวอร์ชันเสถียร 0.91)

ดาวน์โหลดและติดตั้งส่วนขยาย EggBot Control (เวอร์ชัน 2.4.0 ได้รับการทดสอบอย่างสมบูรณ์แล้ว)

ส่วนขยายการควบคุม EggBot สำหรับ Inkscape เป็นเครื่องมือที่จะใช้ในการทดสอบและปรับเทียบ EggBot และถ่ายโอนภาพวาดไปยังไข่ ก่อนอื่นคุณต้องเปิด Inkscape หลังจากเปิดตัว Inkscape เมนู "ส่วนขยาย" จะปรากฏขึ้นและคุณต้องเลือกเมนูย่อย "Eggbot" ในนั้น หากคุณไม่เห็นเมนูย่อย Eggbot แสดงว่าคุณติดตั้งส่วนขยายไม่ถูกต้อง สำรองข้อมูลและปฏิบัติตามคำแนะนำในการติดตั้งส่วนขยายอย่างระมัดระวัง

นั่นคือทั้งหมด ขอบคุณสำหรับความสนใจของคุณ!)

ผลที่ได้คือหุ่นยนต์ที่ค่อนข้างตลกซึ่งมองเห็นสิ่งกีดขวางอยู่ข้างหน้า วิเคราะห์สถานการณ์ จากนั้นจึงเลือกเฉพาะเส้นทางที่ดีที่สุดเท่านั้น หุ่นยนต์กลับกลายเป็นว่าคล่องแคล่วมาก สามารถหมุนได้ 180 องศา และมุมของการหมุนคือ 45 และ 90 องศา ในฐานะตัวควบคุมหลัก ผู้เขียนใช้ Iteaduino ซึ่งเป็นอะนาล็อกของ Arduino

วัสดุและเครื่องมือในการทำหุ่นยนต์:
- ไมโครคอนโทรลเลอร์ (Arduino หรือ Iteaduino ที่คล้ายกัน);
- เซ็นเซอร์อัลตราโซนิก
- ที่ใส่แบตเตอรี่
- ของเล่นจีนเพื่อสร้างฐานล้อ (คุณสามารถซื้อสำเร็จรูปได้);
- เครื่องตัดลวด
- กาว;
- สายไฟ;
- มอเตอร์;
- แผ่นใยไม้อัด;
- จิ๊กซอว์;
- ทรานซิสเตอร์ (D882P)

กระบวนการผลิตหุ่นยนต์:

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

เมื่อเลือกรถยนต์ควรใช้ของเล่นที่มีล้อธรรมดาเพราะตามที่ผู้เขียนระบุว่าหุ่นยนต์กระโดดได้มาก

มีอีกช่วงเวลาหนึ่งที่สายไฟจะออกจากมอเตอร์ โดยหนึ่งในนั้นต้องไม่ลืมเปลี่ยนขั้ว

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

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

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

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

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

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

มาพูดถึงวิธีที่คุณสามารถใช้ Arduino เพื่อสร้างหุ่นยนต์ที่ทรงตัวเหมือน Segway

เซกเวย์จากภาษาอังกฤษ Segway เป็นรถยืนสองล้อที่ติดตั้งไดรฟ์ไฟฟ้า พวกเขาจะเรียกว่าไจโรสคูเตอร์หรือสกูตเตอร์ไฟฟ้า

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

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

ผลลัพธ์ที่ได้ควรเป็นดังนี้:

โครงการหุ่นยนต์

L298N เครื่องยนต์ โมดูลไดรเวอร์:

มอเตอร์เกียร์ DC พร้อมล้อ:

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

หุ่นยนต์ปรับสมดุลในตัวเองเวอร์ชันสมบูรณ์สามารถเห็นได้จากภาพด้านบน ที่ด้านบนมีแบตเตอรี่ Ni-Cd จำนวน 6 ก้อนสำหรับจ่ายไฟให้กับ PCB ระหว่างมอเตอร์จะใช้แบตเตอรี่ขนาด 9 โวลต์สำหรับตัวขับมอเตอร์

ทฤษฎี

ในทฤษฎีการควบคุม การถือครองตัวแปรบางส่วน (ในกรณีนี้คือตำแหน่งของหุ่นยนต์) จำเป็นต้องมีตัวควบคุมพิเศษที่เรียกว่า PID (Proportional Integral Derivative) พารามิเตอร์เหล่านี้แต่ละตัวมี "กำไร" โดยทั่วไปเรียกว่า Kp, Ki และ Kd PID ให้การแก้ไขระหว่างค่าที่ต้องการ (หรืออินพุต) กับค่าจริง (หรือเอาต์พุต) ความแตกต่างระหว่างอินพุตและเอาต์พุตเรียกว่า "ข้อผิดพลาด"

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

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

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

พฤติกรรมของหุ่นยนต์สามารถเห็นได้ด้านล่างในวิดีโอ:

รหัส Arduino สำหรับหุ่นยนต์ทรงตัว

เราต้องการห้องสมุดภายนอกสี่แห่งเพื่อสร้างหุ่นยนต์ของเรา ไลบรารี PID ช่วยให้คำนวณค่า P, I และ D ได้ง่าย ไลบรารี LMotorController ใช้เพื่อควบคุมมอเตอร์สองตัวด้วยโมดูล L298N ไลบรารี I2Cdev และไลบรารี MPU6050_6_Axis_MotionApps20 ได้รับการออกแบบมาเพื่ออ่านข้อมูลจาก MPU6050 คุณสามารถดาวน์โหลดรหัสรวมถึงไลบรารีในที่เก็บนี้

#รวม #รวม #include "I2Cdev.h" #include "MPU6050_6Axis_MotionApps20.h" #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE #include "Wire.h" #endif #define MIN_ABS_SPEED 20 MPU6050 mpu; // การควบคุม/สถานะ MPU vars bool dmpReady = false; // ตั้งค่าจริงหาก DMP init สำเร็จ uint8_t mpuIntStatus; // เก็บไบต์สถานะขัดจังหวะจริงจาก MPU uint8_t devStatus; // ส่งคืนสถานะหลังจากแต่ละอุปกรณ์ทำงาน (0 = สำเร็จ, !0 = ผิดพลาด) uint16_t packetSize; // ขนาดแพ็กเก็ต DMP ที่คาดไว้ (ค่าเริ่มต้นคือ 42 ไบต์) uint16_t fifoCount; // นับไบต์ทั้งหมดที่อยู่ใน FIFO uint8_t fifoBuffer; // บัฟเฟอร์การจัดเก็บ FIFO // การวางแนว/การเคลื่อนไหว vars Quaternion q; // คอนเทนเนอร์ quaternion VectorFloat แรงโน้มถ่วง; // เวกเตอร์แรงโน้มถ่วงลอย ypr; // yaw/pitch/roll คอนเทนเนอร์และเวกเตอร์แรงโน้มถ่วง //PID double originalSetpoint = 173; setpoint สองเท่า = originalSetpoint; การเคลื่อนไหวสองครั้งAngleOffset = 0.1; อินพุตคู่, เอาต์พุต; //ปรับค่าเหล่านี้ให้พอดีกับการออกแบบของคุณเอง double Kp = 50; สองเท่า Kd = 1.4; สอง Ki = 60; PID pid(&อินพุต, &เอาต์พุต, &setpoint, Kp, Ki, Kd, DIRECT); มอเตอร์คู่SpeedFactorLeft = 0.6; มอเตอร์คู่SpeedFactorRight = 0.5; //ตัวควบคุมมอเตอร์ int ENA = 5; int IN1 = 6; int IN2 = 7; int IN3 = 8; int IN4 = 9; int ENB = 10; LMotorController motorController (ENA, IN1, IN2, ENB, IN3, IN4, motorSpeedFactorLeft, motorSpeedFactorRight); บูลผันผวน mpuInterrupt = เท็จ; // ระบุว่าพินขัดจังหวะ MPU มีโมฆะสูงหรือไม่ dmpDataReady() ( mpuInterrupt = true; ) void setup() ( // เข้าร่วมบัส I2C (ไลบรารี I2Cdev ไม่ทำสิ่งนี้โดยอัตโนมัติ) #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin( ); TWBR = 24; // 400kHz I2C clock (200kHz ถ้า CPU เป็น 8MHz) #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire::setup(400, true); #endif mpu.initialize(); devStatus = mpu.dmpInitialize(); // จัดหาไจโรออฟเซ็ตของคุณเองที่นี่ ปรับขนาดสำหรับความไวขั้นต่ำ mpu.setXGyroOffset(220); mpu.setYGyroOffset(76); mpu.setZGyroOffset(-85); mpu.setZaccelOffset(1788); // 1688 ค่าเริ่มต้นจากโรงงานสำหรับการทดสอบของฉัน ชิป // ตรวจสอบให้แน่ใจว่ามันใช้งานได้ (คืนค่า 0 ถ้าใช่) ถ้า (devStatus == 0) ( // เปิด DMP ตอนนี้มันพร้อมแล้ว mpu.setDMPEnabled(true); // เปิดใช้งานการตรวจจับการขัดจังหวะ Arduino ที่แนบInterrupt(0 , dmpDataReady , RISING); mpuIntStatus = mpu.getIntStatus(); // ตั้งค่าสถานะ DMP Ready เพื่อให้ฟังก์ชัน main loop() รู้ว่า "ไม่เป็นไร" dmpReady = true; // รับ DM ที่คาดหวัง ขนาดแพ็กเก็ต P สำหรับการเปรียบเทียบในภายหลัง packetSize = mpu.dmpGetFIFOPacketSize(); //ตั้งค่า PID pid.SetMode(อัตโนมัติ); pid.SetSampleTime(10); ปี๊ด SetOutputLimits (-255, 255); ) else ( // ERROR! // 1 = การโหลดหน่วยความจำเริ่มต้นล้มเหลว // 2 = การอัพเดตการกำหนดค่า DMP ล้มเหลว // (หากจะพัง โดยปกติโค้ดจะเป็น 1) Serial.print(F("DMP Initialization) ล้มเหลว (รหัส ")); Serial.print(devStatus); Serial.println(F(")")); ) ) void loop() ( // หากการเขียนโปรแกรมล้มเหลว อย่าพยายามทำอะไรถ้า (!dmpReady ) return; // รอการขัดจังหวะ MPU หรือแพ็กเก็ตพิเศษที่พร้อมใช้งานในขณะที่ (!mpuInterrupt && fifoCount< packetSize) { //no mpu data - performing PID calculations and output to motors pid.Compute(); motorController.move(output, MIN_ABS_SPEED); } // reset interrupt flag and get INT_STATUS byte mpuInterrupt = false; mpuIntStatus = mpu.getIntStatus(); // get current FIFO count fifoCount = mpu.getFIFOCount(); // check for overflow (this should never happen unless our code is too inefficient) if ((mpuIntStatus & 0x10) || fifoCount == 1024) { // reset so we can continue cleanly mpu.resetFIFO(); Serial.println(F("FIFO overflow!")); // otherwise, check for DMP data ready interrupt (this should happen frequently) } else if (mpuIntStatus & 0x02) { // wait for correct available data length, should be a VERY short wait while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount(); // read a packet from FIFO mpu.getFIFOBytes(fifoBuffer, packetSize); // track FIFO count here in case there is >มี 1 แพ็กเก็ต // (ทำให้เราอ่านเพิ่มเติมได้ทันทีโดยไม่ต้องรอการขัดจังหวะ) fifoCount -= packetSize; mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetGravity(&แรงโน้มถ่วง &q); mpu.dmpGetYawPitchRoll(ypr, &q, &แรงโน้มถ่วง); อินพุต = ypr * 180/M_PI + 180; ) )

ค่า Kp, Ki, Kd อาจใช้หรือไม่ใช้ได้ หากไม่เป็นเช่นนั้น ให้ทำตามขั้นตอนด้านบน โปรดทราบว่าการเอียงในโค้ดตั้งไว้ที่ 173 องศา คุณสามารถเปลี่ยนค่านี้ได้หากต้องการ แต่โปรดทราบว่านี่คือมุมที่หุ่นยนต์ต้องรองรับ นอกจากนี้ หากมอเตอร์ของคุณเร็วเกินไป คุณสามารถปรับค่า motorSpeedFactorLeft และ motorSpeedFactorRight ได้

นั่นคือทั้งหมดที่สำหรับตอนนี้. แล้วพบกันใหม่.

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

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

Arduino Uno เป็นตัวเลือกที่ดีที่สุดสำหรับบอร์ดมือใหม่ บอร์ดที่ธรรมดาที่สุด ราคาไม่แพง และธรรมดาที่สุด มันใช้ชิป ATmega328 ที่มีความถี่สัญญาณนาฬิกา 16 MHz, หน่วยความจำแฟลช 32 KB, RAM 2 KB และ EEPROM 1 KB Uno มี 14 อินพุต/เอาต์พุตดิจิตอลที่สามารถใช้ควบคุมเซ็นเซอร์และเซอร์โวและอุปกรณ์อื่นๆ

Arduino Mega / Mega 2560 เป็นบอร์ดที่จะสะดวกเมื่อคุณรู้ล่วงหน้าว่าโครงการจะยาก ความแตกต่างที่สำคัญคืออินพุต/เอาต์พุตที่มากกว่า (48 ในเมกะ, 54 ในเมกะ 2560) นอกจากนี้ยังมีหน่วยความจำอีกมากมายที่นี่: RAM 8 KB, EEPROM 4 KB และหน่วยความจำแฟลช 128 และ 256 KB (ในเมกะและเมกะ 2560 ตามลำดับ) บอร์ดยังแตกต่างกันในด้านชิป ความเร็ว USB และคุณสมบัติอื่นๆ

แน่นอนว่ายังมี Arduino Pro, Arduino LilyPad และอื่นๆ อีกมากมาย แต่ตอนนี้ขอเน้นสองรุ่นแรก ในกรณีของเรา ทุกอย่างค่อนข้างง่าย: หุ่นยนต์ที่มีขามากจำเป็นต้องมี Mega

รหัสแรก

ขั้นแรก ให้ติดตั้ง Arduino IDE (arduino.cc) ซึ่งเป็นสภาพแวดล้อมการพัฒนาข้ามแพลตฟอร์มฟรี ทีนี้ ถ้าเราเชื่อมต่อ Arduino ของเรา เราสามารถลองเขียนโค้ดแรกบนตัวอย่างที่ง่ายที่สุด: โปรแกรมไฟ LED ที่กะพริบ คอนโทรลเลอร์ Arduino ส่วนใหญ่มีและเชื่อมต่อกับพิน 13 อย่างไรก็ตาม ในโลกของ Arduino โปรแกรมมักเรียกว่าสเก็ตช์ นี่คือข้อความของร่างพร้อมความคิดเห็น:

// ตั้งชื่อพินนี้ว่า LED: const int LED = 13; การตั้งค่าเป็นโมฆะ () ( // เริ่มต้นพินดิจิตอล // สำหรับเอาต์พุต: pinMode (LED, OUTPUT); ) วงเป็นโมฆะ () ( // ตั้งค่าลอจิกหนึ่งระดับ // ไปที่พิน 13 (ไฟ LED): digitalWrite (LED, สูง ); // หยุดสเก็ตช์ชั่วคราว // สักครู่: หน่วงเวลา (1000); // ใช้ระดับตรรกะเป็นศูนย์ // เพื่อตรึง 13 (ปิด LED): digitalWrite (LED, LOW); // หยุดร่างชั่วคราวอีกครั้ง วินาที: ล่าช้า (1000); )

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

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

ตอนนี้เรา "อัปโหลด" ร่างของเราไปยังตัวควบคุม ไม่ เราไม่ต้องการโปรแกรมเมอร์ ตัวควบคุม Arduino นอกเหนือจากภาพสเก็ตช์ของเราแล้ว ยังมีโปรแกรมพิเศษ - bootloader ซึ่งควบคุมการโหลดโค้ดจากคอมพิวเตอร์โดยเฉพาะ ดังนั้นในการอัปโหลดภาพสเก็ตช์ เราต้องใช้เพียงสาย USB และรายการเมนู File → Upload (Ctrl + U) ใน Arduino IDE

คำถามสำคัญ

จริงๆ แล้วเราต้องการขากี่ขา? มากำหนดรูปแบบต่างๆ ของหุ่นยนต์เดินกันเถอะ ตามจำนวนขา:

สองขา - สองขา (ต้นแบบ - ชาย);
สัตว์สี่เท้า - สี่ขา (ต้นแบบ - สัตว์เลี้ยงลูกด้วยนมส่วนใหญ่);
hexapod - หกขา (ต้นแบบ - แมลงส่วนใหญ่);
ปลาหมึกยักษ์ - แปดขา (ต้นแบบ - แมงมุม แมงป่อง ปู และสัตว์ขาปล้องอื่นๆ)

นอกจากจำนวนขาแล้ว การกำหนดค่าของแต่ละขาก็มีความสำคัญเช่นกัน ลักษณะสำคัญของขาคือจำนวนองศาอิสระหรือมิติอิสระ (DOF) ระดับความอิสระคือความสามารถในการหมุนหรืองอรอบแกนเดียว (บ่อยครั้งน้อยกว่าเพื่อเคลื่อนที่ไปข้างหน้าตามแกน) เห็นได้ชัดว่าหากมีเสรีภาพเพียงระดับเดียวคุณจะไม่ไปไกลกว่านี้ ขาที่มีอิสระสององศา (2DOF) ทำให้หุ่นยนต์หลายขาสามารถเคลื่อนที่ได้ แม้ว่า 2DOF จะอนุญาตให้ขยับปลายขาได้อย่างอิสระในระนาบเดียว และขา 3DOF จะขยับ "เท้า" ในพื้นที่ 3 มิติ (เว้นแต่ว่าทั้งสามแกนจะขนานกัน) นอกจากนี้ยังมีขา 4DOF ที่เพิ่มความยืดหยุ่นและช่วงการเคลื่อนไหวของขา แมลงส่วนใหญ่มักมีขา 4DOF

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

ในการตั้งโปรแกรมเซอร์โว ก็เพียงพอแล้วที่จะรู้ว่าพวกเขามีคอนโทรลเลอร์ที่ทำหน้าที่หลักอยู่แล้ว และทั้งหมดที่จำเป็นคือการจ่ายไฟและสัญญาณดิจิตอลที่บอกตัวควบคุมว่าเราต้องการหมุนเพลาขับไปที่ตำแหน่งใด ง่ายต่อการค้นหาข้อมูลเกี่ยวกับการออกแบบของพวกเขา โปรโตคอลของพวกเขาเป็นโปรโตคอลการสื่อสารดิจิทัลที่ง่ายที่สุด: การมอดูเลตความกว้างพัลส์ - PWM (PWM ในภาษาอังกฤษ) เซอร์โวแบบธรรมดาทั้งหมดมีคอนเน็กเตอร์สามพิน: กราวด์, +5V (แรงดันอาจแตกต่างกันไปตามขนาดและกำลัง) และอินพุตสัญญาณ ตัวควบคุม Arduino สามารถสร้างสัญญาณนี้ได้สองวิธี อย่างแรกคือฮาร์ดแวร์ PWM ซึ่งตัวชิปสามารถส่งออกบนพิน I/O ดิจิตอลได้หลายพิน ประการที่สองคือซอฟต์แวร์ ซอฟต์แวร์ช่วยให้คุณรับสัญญาณ PWM ที่แตกต่างกันในเวลาเดียวกันมากกว่าฮาร์ดแวร์ มีแรปเปอร์ที่สะดวกสำหรับ Arduino - ไลบรารีเซอร์โว อนุญาตให้คุณใช้ 12 เซอร์โวพร้อมกันกับคอนโทรลเลอร์ขนาดเล็กส่วนใหญ่ (Uno, Due, Nano) และเซอร์โว 48 ตัวบน Arduino Mega และอื่นๆ พินสัญญาณของเซอร์โวเชื่อมต่อกับพินดิจิตอลของ Arduino กราวด์และกำลัง - แน่นอนว่าสำหรับกราวด์และกำลัง เซอร์โวทั้งหมดสามารถใช้ร่วมกันได้ ในเซอร์โวลูปแบบสามสาย สีดำหรือสีน้ำตาลคือพื้น โดยปกติแล้วจะเป็นสีแดง +5 V ตรงกลาง และสุดท้ายเป็นสัญญาณสีขาวหรือสีเหลือง จากมุมมองของซอฟต์แวร์ การควบคุมทำได้ง่ายมาก:

เซอร์โว myservo; // Servo บน Arduino pin 9 myservo.attach (9); // หมุนไปที่ตำแหน่ง 90º myservo.write(90);

เซอร์โวส่วนใหญ่สามารถหมุนเพลาได้ 180° และสำหรับพวกเขา 90° คือตำแหน่งตรงกลาง เพื่อลดความซับซ้อนในการเชื่อมต่อเซอร์โวกับบอร์ด Arduino มีวิธีแก้ปัญหามากมาย Canonical มากที่สุดคือ Sensors Shield ด้วยการติดตั้งบน Uno และจ่ายไฟให้กับเทอร์มินัลสำหรับเซอร์โว คุณสามารถเชื่อมต่อตัวเชื่อมต่อเข้ากับมันได้โดยตรง

แบตเตอรี่

ประเด็นสำคัญอีกประการหนึ่งคือโภชนาการ หากคุณมีบอร์ดขั้นสูงที่ให้คุณจ่ายไฟให้กับทั้งระบบผ่านสายไฟเส้นเดียว (และเซอร์โวมอเตอร์จะไม่รบกวนการทำงานของคอนโทรลเลอร์) คุณก็สามารถใช้แหล่งจ่ายเพียงแหล่งเดียวได้ ทางเลือกมีขนาดใหญ่ ดีที่สุดคือ Li-Ion / Li-Po briquettes สำหรับวิทยุรุ่น แต่พวกเขายังต้องการที่ชาร์จที่เหมาะสม หากคุณมีตัวควบคุมที่ง่ายกว่า (Uno / Due / Nano) คุณสามารถจ่ายไฟแยกกันได้ เช่น ด้วย Krona 9 โวลต์ และเชื่อมต่อเซอร์โวกับแบตเตอรี่อันทรงพลังหลัก ดังนั้นเซอร์โวจะมีกำลังเพียงพออย่างแน่นอน ในกรณีของแบตเตอรี่ลิเธียม คุณต้องตรวจสอบแรงดันไฟฟ้าอย่างระมัดระวังมากกว่าปกติเพื่อไม่ให้เกิดการคายประจุเกิน (ควรชี้แจงแรงดันไฟฟ้าที่อนุญาตสำหรับแบตเตอรี่บางประเภท) ในการทำเช่นนี้ โวลต์มิเตอร์แบบดิจิตอลขนาดเล็กจะถูกขันเข้ากับหุ่นยนต์ Sleipnir ซึ่งจะกล่าวถึงต่อไป

Robobug ทำมันเอง

ชุด

คอนโทรลเลอร์ Arduino Uno: 1150 rubles
เซอร์โวมอเตอร์สามตัว ผมใช้ HXT500, 200 r. ชิ้น
ช่องใส่แบตเตอรี่สำหรับ "Krona" พร้อมสวิตช์: 50 รูเบิล
แบตเตอรี่ "โครน่า": 145 รูเบิล
ตัวรับสัญญาณ IR: $90
ลวดเหล็กขนาดเส้นผ่านศูนย์กลางประมาณ 1.5 มม. ตัวอย่างเช่น ฉันใช้เครื่องตีไข่ที่หัก

รวม: 2035 น.

DmitryDzz:ฉันต้องการเชิญคุณสร้างด้วงหุ่นยนต์หกขาขนาดเล็กที่ควบคุมจากระยะไกลโดยใช้ตัวควบคุม Arduino Uno อุ้งเท้าจะมีอิสระหนึ่งระดับ การควบคุมจะเกิดขึ้นโดยใช้รีโมทคอนโทรลของทีวีทั่วไป

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

วิธีที่ง่ายกว่าคือใช้ชุดคอนสตรัคเตอร์เพราะในขั้นตอนแรกคอนโทรลเลอร์หนึ่งตัวจะไม่เพียงพอ ตอนนี้ร้านค้าจำนวนมากเสนอชุดดังกล่าว ตัวอย่างเช่น มีร้านค้าออนไลน์ที่ยอดเยี่ยม "Amperka" ที่นี่คุณจะได้รับข้อเสนอจากนักออกแบบที่คล้ายกันหลายคน ซึ่งแตกต่างกันในด้านความสมบูรณ์และแน่นอนในราคา สิ่งที่ง่ายที่สุดก็เพียงพอแล้วสำหรับฉัน - "Matryoshka X" ประกอบด้วยคอนโทรลเลอร์ Arduino Uno, สาย USB สำหรับเชื่อมต่อกับคอมพิวเตอร์, บอร์ดสร้างต้นแบบ (สิ่งที่ขาดไม่ได้!), ชุดจัมเปอร์, ไฟ LED, ตัวต้านทาน และมโนสาเร่อื่นๆ

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

สิ่งที่คุณต้องการจากเครื่องมือ:

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

หากคุณมีทุกอย่าง มาเริ่มกันเลย!

ควบคุม

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

ในขั้นตอนนี้ คุณจะต้องมีเครื่องรับ IR และควรมีบอร์ดต้นแบบด้วย รีโมท IR ส่วนใหญ่ทำงานที่ความถี่พาหะที่ 36 kHz, 38 kHz หรือ 40 kHz (Panasonic, Sony) ข้อยกเว้นคือ Sharp (56 kHz), Bang & Olufsen (455 kHz) และอาจมีคนอื่นที่แปลกใหม่กว่า ดังนั้นตัวรับสัญญาณ IR ที่ 36, 38 หรือ 40 kHz จึงค่อนข้างเหมาะสำหรับเรา ความถี่อาจไม่ตรงกับความถี่พาหะของสัญญาณทุกประการ ในกรณีนี้ ความไวของเครื่องรับจะลดลง แต่ในทางปฏิบัติ ฉันไม่สังเกตเห็นความรู้สึกไม่สบายใดๆ เมื่อใช้ตัวรับ IR TSOP2136 (36 kHz - สองหลักสุดท้าย - ความถี่) และรีโมทคอนโทรลของ Sony (40 kHz)

ดังนั้นตัวรับสัญญาณ IR TSOP21xx, TSOP22xx, TSOP312xx จึงเหมาะสำหรับรีโมทส่วนใหญ่ ตัวเลขสองหลักสุดท้ายอาจเป็น 36, 37, 38 หรือ 40 ก่อนเปิดตัวรับสัญญาณ IR ให้ตรวจสอบพินของพิน - มีเพียงสามตัวเท่านั้น: + 5V (กำลัง), GND (กราวด์), Vs (เอาต์พุต) . มาประกอบวงจรกันดังในภาพประกอบ (การเดินสายสำหรับ TSOP2136)

อย่างที่คุณเห็น เราได้เชื่อมต่อเอาท์พุตของตัวรับสัญญาณ IR เข้ากับอินพุตแบบอะนาล็อกของคอนโทรลเลอร์ A0

นี่คือลักษณะของโค้ดสเก็ตช์:

#include "IRremote.h" // อินพุตแบบอะนาล็อกของคอนโทรลเลอร์ // ที่เชื่อมต่อตัวรับสัญญาณ IR: const int IR_PIN = A0; // สร้างวัตถุรับสัญญาณ IR: IRrecv irrecv(IR_PIN); void setup() ( Serial.begin(9600); Serial.println("ready"); // เริ่มฟังสัญญาณ IR: irrecv.enableIRIn(); ) void loop() ( // อธิบายผลลัพธ์ของโครงสร้าง / / โดยที่ // ได้รับและถอดรหัส // คำสั่ง IR จะถูกวางไว้: ผลลัพธ์ decode_results; // หากยอมรับคำสั่ง IR และ // ถอดรหัสสำเร็จ ให้ส่งออก // รหัสที่ได้รับไปยัง // พอร์ตอนุกรมของคอนโทรลเลอร์: ถ้า ( irrecv.decode (&ผล)) ( Serial.println(ผลลัพธ์.value); irrecv.resume(); ) )

ร่างนี้ใช้ไลบรารีพิเศษ IRremote.h ซึ่งถอดรหัสสัญญาณของรีโมท IR ต่างๆ ห้องสมุดนี้เป็นโครงการเปิด คุณสามารถดาวน์โหลดได้จาก https://github.com/shirriff/Arduino-IRremote และในการเชื่อมต่อกับโครงการของเรา คุณต้องดำเนินการสามขั้นตอน:

คัดลอกไดเร็กทอรีไลบรารีไปยังไดเร็กทอรีไลบรารีซึ่งในทางกลับกันจะอยู่ในไดเร็กทอรีการติดตั้ง Arduino IDE
รีสตาร์ท IDE;
เพิ่มบรรทัด #include "IRremote.h" ที่จุดเริ่มต้นของร่างของเรา

ตอนนี้ฟังก์ชั่นการถอดรหัส IR จะพร้อมใช้งานในแบบร่าง แต่หากต้องการดูรหัสผลลัพธ์ เราจะยังคงใช้วัตถุอนุกรม ด้วยความช่วยเหลือผ่านพอร์ตอนุกรม (สาย USB เดียวกัน) เราจะโอนรหัสไปยังคอมพิวเตอร์ ในฟังก์ชันการตั้งค่า เราเริ่มต้นวัตถุอนุกรม "9600" คือ 9600 baud - อัตราที่จะใช้สำหรับการถ่ายโอนข้อมูล หลังจากการเริ่มต้น เราสามารถเขียนไปยังพอร์ตอนุกรมโดยใช้ฟังก์ชัน println หากต้องการดูผลลัพธ์ของเอาต์พุตนี้บนคอมพิวเตอร์ใน Arduino IDE ให้เลือกรายการเมนู Tools → Serial Monitor (Ctrl + Shift + M) อย่าลืมตั้งค่าไว้ที่ 9600 บอด

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

เราต้องการปุ่มควบคุมระยะไกล 13 ปุ่ม ฉันใช้สิ่งต่อไปนี้:

1 - เลี้ยวซ้ายเรียบ
2 - ก้าวไปข้างหน้า;
3 - เลี้ยวขวาอย่างราบรื่น
4 - เลี้ยวซ้ายตรงจุดนั้น
5 - หยุด;
6 - เลี้ยวขวาตรงจุดนั้น
7 - เคลื่อนที่กลับโดยเลี้ยวขวา
8 - การเคลื่อนไหวย้อนกลับ;
9 - เคลื่อนที่กลับโดยเลี้ยวซ้าย
ปุ่มสีน้ำเงิน - ช้ามาก
สีเหลือง - ช้า;
สีเขียว - เร็ว;
สีแดง - เร็วมาก

จดรหัสสำหรับปุ่มเหล่านี้ คุณจะต้องใช้ในภายหลังสำหรับร่างการควบคุมหุ่นยนต์

อัลกอริธึมการเคลื่อนไหว

ร่างการควบคุมหุ่นยนต์มีอยู่ในหน้าโครงการของเรา (bit.ly/1dEwNDC) อย่าลืมเปลี่ยนค่าคงที่ของรหัสของปุ่มควบคุมระยะไกลที่กดไว้เป็นรหัสของรีโมทคอนโทรลของคุณ (ค่าคงที่ IR_COMMAND_XXX_CODES ในไฟล์ ir_command_codes.h)

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

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

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

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

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

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

X = บาป (2πt/T),

โดยที่ X คือตำแหน่งที่ต้องการของเซอร์โวมอเตอร์ A คือแอมพลิจูดการแกว่ง T คือช่วงการแกว่ง

ดังนั้น ขึ้นอยู่กับช่วงเวลา t เราจะได้รับการเปลี่ยนแปลงในค่าของ X ในช่วงจาก -A ถึง +A เซอร์โวมอเตอร์สามารถอยู่ในตำแหน่งได้ตั้งแต่ 0 ถึง 180° ดังนั้นจึงเป็นการดีกว่าที่เราจะแกว่งตัวรอบตำแหน่ง "ศูนย์" ที่ 90 ° และถ้าเราต้องการให้การแกว่งด้วยคาบ 1 วินาทีรอบตำแหน่ง 90 °ด้วยแอมพลิจูด 30 ° สูตรจะถูกแปลงเป็นรูปแบบต่อไปนี้:

X = 90 + 30 บาป (2πt/1000)

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

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

X = 90 + 30 บาป (2πt/1000 + Φ)

โดยที่ Φ คือเฟสของการแกว่ง ค่าจะอยู่ระหว่าง 0 ถึง 2π

ดูตารางเพื่อทำความเข้าใจว่าเฟสการสั่นของเซอร์โวมอเตอร์ควรเป็นอย่างไรสำหรับการเคลื่อนไหวแต่ละประเภท

การประกอบ

ตอนนี้ เรามาประกอบหุ่นยนต์บนกระดานสร้างต้นแบบและกรอกข้อมูลในร่างการควบคุม

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

ทีนี้มาดูที่แอสเซมบลีกัน องค์ประกอบแบริ่งหลักคือช่องใส่แบตเตอรี่ ฉันแนะนำให้คุณใช้ช่องแบบปิดและใช้สวิตช์เสมอ

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

วิธีที่ง่ายที่สุดคือติดกาวคอนโทรลเลอร์เข้ากับช่อง แต่ฉันไม่ชอบตัวเลือกนี้มากเพราะฉันจะต้องมอบ Arduino Uno ให้กับบั๊กตลอดไป ดังนั้น คุณสามารถทำให้ชีวิตของคุณยุ่งยากขึ้น และใช้ขั้วต่อ Arduino เพื่อติดช่องใส่แบตเตอรี่ กาวขั้วต่อพินที่ด้านล่างของช่องที่มีระยะห่าง 2.54 มม. ระหว่างหมุด ควรตั้งอยู่เพื่อให้เข้าสู่ช่องเสียบคอนโทรลเลอร์ในพื้นที่ของเอาต์พุตดิจิทัล 8-11 เรายังไม่ต้องการพวกเขาอยู่ดี หากขั้วต่อไม่อยู่ในมือ คลิปหนีบกระดาษทรงโค้งรูปตัวยูจะทำได้

สายไฟที่มาจากช่องใส่แบตเตอรี่จะต้องเชื่อมต่อกับขั้ว Vin และ GND ที่อยู่ติดกัน อย่ากลับขั้ว! บวก "Krona" บน Vin ลบ GND เพื่อให้แน่ใจว่ามีการสัมผัสสายไฟกับขั้วต่อ Arduino ที่เชื่อถือได้ คุณสามารถเสียบปลายสายให้หนาขึ้นได้ แต่ฉันใช้คลิปหนีบกระดาษสั้นๆ เป็นปลั๊ก และสถานที่บัดกรีปิดด้วยท่อหดความร้อน

ควรตัดขั้วต่อจากสายเซอร์โว สายไฟ (+5 V - โดยปกติสีแดงและ GND - สีดำหรือสีน้ำตาล) ควรรวมกันและเชื่อมต่อกับแจ็ค 5V และ GND ที่อยู่ติดกันบนคอนโทรลเลอร์ เราจะเชื่อมต่อกันในภายหลัง สายสัญญาณควบคุม (ปกติจะเป็นสีเหลือง) จะถูกส่งออกไปยังเอาต์พุตดิจิทัลของคอนโทรลเลอร์: เซอร์โวมอเตอร์ด้านซ้ายอยู่ที่พิน 2 อันตรงกลางอยู่ที่พิน 4 อันด้านขวาอยู่ที่พิน 7

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

เคล็ดลับในการทำขา ขั้นแรก เตรียมขา "หน้า-หลัง" ซ้ายและขวา ตรวจสอบให้แน่ใจว่าสมมาตร (ให้ความสนใจกับทั้งความยาวและมุมของส่วนโค้ง) เริ่มติดกาวที่ขาหลังจากตรวจสอบให้แน่ใจว่าเซอร์โวมอเตอร์ถูกตั้งไว้ที่ตำแหน่ง "ศูนย์" (90°)

วางขาคู่กลางไว้ท้ายสุด ฉันแนะนำให้คุณทำให้ขากลางยาวขึ้นก่อนจากนั้นหลังจากติดตั้งแล้วให้ตัดให้ได้ความยาวที่ต้องการ ในตำแหน่ง "ศูนย์" ทั้งหกฟุตควรอยู่บนพื้นผิว การพลิกตัวของขากลางที่มีแอมพลิจูด 15° ไม่ควรกีดขวางการเลี้ยวหน้า-หลัง

อะไรต่อไป?

Robobug เป็นแพลตฟอร์มมือถือสำเร็จรูปที่ใช้ตัวควบคุมที่ได้รับความนิยมและราคาไม่แพง โครงการเปิดแล้ว: https://github.com/beetle-ringo/arduino สร้างส้อม (สาขา) ใน GitHub และเพิ่มฟังก์ชันการทำงานของคุณ ปล่อยให้จินตนาการของคุณโลดแล่น - เพิ่ม IR LED และหุ่นยนต์ก็พร้อมสำหรับการต่อสู้ของหุ่นยนต์ เชื่อมต่อเครื่องวัดระยะ เซ็นเซอร์สัมผัส ไจโรสโคป... สอนหุ่นยนต์ให้เลี่ยงสิ่งกีดขวางหรือเดินไปตามเส้น ลองติดตั้งเว็บแคมบนมัน สามารถมีได้เป็นล้านความคิด และคุณสามารถเลือกความคิดที่น่าสนใจที่สุดได้เสมอ

หุ่นยนต์สไลป์เนียร์

ชุด

ตัวควบคุมหุ่นยนต์แมงมุม Arduino Uno Dagu: $2530
เซอร์โวไดรฟ์ SG90 9g (16 ชิ้น) 1150 р.
ก้อนแบตเตอรี่ LiPo, 7.4 V, 1800 mAh $4.99
โมดูลวิทยุ 4 Pin Bluetooth RF Transceiver 270 р.
ตัวแสดงแรงดันไฟฟ้า (อุปกรณ์เสริม) DC 3.3-30V LED แผงมิเตอร์สีแดง $100
มุมอลูมิเนียม. ในตลาดการก่อสร้างที่ใกล้ที่สุด 135 รูเบิล
สลักเกลียวและถั่ว ที่ตลาดนัดที่ใกล้ที่สุด 35 รูเบิล

รวม: 4710 ร.

*ส่วนประกอบถูกซื้อในเวลาที่ต่างกันและสามารถปรับตำแหน่งได้หลายตำแหน่ง

โพโคโนโก:ลองประกอบการกำหนดค่าที่ไม่ได้มาตรฐาน - หุ่นยนต์ 2DOF แปดขา ขา 2DOF นั้นเขียนโปรแกรมได้ง่ายกว่ามาก แถมผมยังมีเซอร์โวที่ไม่ได้ใช้อยู่ในสต็อกอีกด้วย และที่สำคัญที่สุด เป็นไปได้ที่จะตั้งชื่อมันเพื่อเป็นเกียรติแก่ม้าแปดขาของพระเจ้า Odin Sleipnir (ฝันถึงเสมอ!)

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

เรียบร้อยและใช้งานได้จริง แต่ยังห่างไกลจากวิธีแก้ปัญหาที่ถูกที่สุดคือการใช้บอร์ดควบคุมที่ไม่ได้มาตรฐาน ซึ่งปรับให้เหมาะสมสำหรับการเชื่อมต่อเซอร์โวในปริมาณมาก ฉันเจอ Dagu Spider Robot Controller - นี่คือ Arduino Mega ตัวเดียวกัน แต่บนบอร์ดที่มีขั้วต่อพิน 3 พินที่บัดกรีไว้ล่วงหน้า ซึ่งคุณสามารถเชื่อมต่อเซอร์โวทั้ง 48 ตัวนั้นได้ทันทีโดยไม่ต้องใช้เกราะป้องกัน เหมาะสำหรับหุ่นยนต์ Arduino แบบหลายขา