- แผนภูมิวงจรรวม
- การสร้างสัญญาณ PWM บนพิน GPIO สำหรับการควบคุมเซอร์โวมอเตอร์
- การเขียนโปรแกรม PIC16F8771A สำหรับแขนหุ่นยนต์
- การจำลองรหัสแขนหุ่นยนต์ PIC
- การออกแบบ PCB โดยใช้ EasyEDA
- การคำนวณและการสั่งซื้อตัวอย่างออนไลน์
- การทำงานของแขนหุ่นยนต์ PIC
ตั้งแต่สายการประกอบของอุตสาหกรรมการผลิตรถยนต์ไปจนถึงหุ่นยนต์ผ่าตัดศัลยกรรมในอวกาศจะพบ Robotic Arms ได้ทุกที่ กลไกของหุ่นยนต์เหล่านี้คล้ายกับมนุษย์ซึ่งสามารถตั้งโปรแกรมให้ทำงานคล้ายกันและเพิ่มขีดความสามารถได้ สามารถใช้เพื่อดำเนินการซ้ำ ๆ ได้เร็วและแม่นยำกว่ามนุษย์หรือสามารถใช้ในสภาพแวดล้อมที่รุนแรงโดยไม่ต้องเสี่ยงชีวิต เราได้สร้าง Record and Play Robotic Arm โดยใช้ Arduino ซึ่งสามารถฝึกให้ทำงานเฉพาะและทำซ้ำได้ตลอดไป
ในบทช่วยสอนนี้เราจะใช้ไมโครคอนโทรลเลอร์ 8 บิต PIC16F877Aมาตรฐานอุตสาหกรรมเพื่อควบคุมแขนหุ่นยนต์เดียวกันกับโพเทนชิโอมิเตอร์ความท้าทายของโครงการนี้คือ PIC16F877A มีพินที่สามารถ PWN ได้เพียงสองตัว แต่เราจำเป็นต้องควบคุมเซอร์โวมอเตอร์ประมาณ 5 ตัวสำหรับหุ่นยนต์ของเราซึ่งต้องใช้หมุด PWM 5 ตัว ดังนั้นเราจึงต้องใช้หมุด GPIO และสร้างสัญญาณ PWM บนพิน PIC GPIO โดยใช้ตัวจับเวลาขัดจังหวะ แน่นอนว่าตอนนี้เราสามารถอัพเกรดเป็นไมโครคอนโทรลเลอร์ที่ดีกว่าหรือใช้ IC de-multiplexer เพื่อทำให้สิ่งต่างๆง่ายขึ้นที่นี่ แต่ถึงกระนั้นก็คุ้มค่าที่จะให้โครงการนี้ลองประสบการณ์การเรียนรู้
โครงสร้างทางกลของแขนหุ่นยนต์ที่ฉันใช้ในโปรเจ็กต์นี้ถูกพิมพ์เป็น 3 มิติโดยสมบูรณ์สำหรับโครงการก่อนหน้าของฉัน คุณสามารถค้นหาไฟล์การออกแบบและขั้นตอนการประกอบที่สมบูรณ์ได้ที่นี่ หรือหากคุณไม่มีเครื่องพิมพ์ 3 มิติคุณสามารถสร้าง Robotic Arm แบบง่ายๆโดยใช้กระดาษแข็งตามที่แสดงในลิงค์ สมมติว่าคุณมีแขนหุ่นยนต์ของคุณอยู่แล้วให้ดำเนินการต่อในโครงการ
แผนภูมิวงจรรวม
แผนภาพวงจรที่สมบูรณ์สำหรับแขนหุ่นยนต์ที่ใช้ไมโครคอนโทรลเลอร์ PICนี้แสดงไว้ด้านล่าง แผนผังถูกวาดโดยใช้ EasyEDA
แผนภาพวงจรค่อนข้างเรียบง่ายโครงการเสร็จสมบูรณ์จะถูกขับเคลื่อนโดยอะแดปเตอร์ 12Vจากนั้น 12V นี้จะถูกแปลงเป็น + 5V โดยใช้ตัวควบคุมแรงดันไฟฟ้า 7805 สองตัว ป้ายหนึ่งมีข้อความว่า + 5V และอีกอันมีข้อความว่า + 5V (2) เหตุผลในการมีตัวควบคุมสองตัวคือเมื่อเซอร์โวหมุนมันจะดึงกระแสมากซึ่งจะทำให้แรงดันตก แรงดันตกนี้บังคับให้ PIC รีสตาร์ทตัวเองดังนั้นเราจึงไม่สามารถใช้งานทั้ง PIC และเซอร์โวมอเตอร์บนราง + 5V เดียวกันได้ดังนั้นจึงใช้ป้ายกำกับว่า + 5V เพื่อจ่ายไฟให้กับไมโครคอนโทรลเลอร์ PIC, LCD และโพเทนชิโอมิเตอร์และเอาต์พุตตัวควบคุมแยกต่างหากซึ่งมีข้อความว่า + 5V (2) ใช้เพื่อจ่ายไฟให้กับเซอร์โวมอเตอร์
พินเอาต์พุตทั้งห้าของโพเทนชิโอมิเตอร์ซึ่งให้แรงดันไฟฟ้าแปรผันตั้งแต่ 0V ถึง 5V เชื่อมต่อกับพินอนาล็อก An0 ถึง AN4 ของ PIC เนื่องจากเราวางแผนที่จะใช้ตัวจับเวลาเพื่อสร้าง PWM เซอร์โวมอเตอร์จึงสามารถเชื่อมต่อกับพิน GPIO ใดก็ได้ ฉันได้เลือกพินจาก RD2 ถึง RD6 สำหรับเซอร์โวมอเตอร์ แต่อาจเป็น GPIO ใดก็ได้ที่คุณเลือก
เนื่องจากโปรแกรมเกี่ยวข้องกับการดีบักจำนวนมากจอ LCD 16x2 จึงเชื่อมต่อกับพอร์ต B ของ PIC นี่จะแสดงรอบการทำงานของเซอร์โวมอเตอร์ที่กำลังควบคุม นอกจากนี้ฉันยังได้ขยายการเชื่อมต่อสำหรับ GPIO และพินอนาล็อกทั้งหมดในกรณีที่จำเป็นต้องเชื่อมต่อเซ็นเซอร์ใด ๆ ในอนาคต ในที่สุดฉันก็เชื่อมต่อพินโปรแกรมเมอร์ H1 เพื่อตั้งโปรแกรม PIC โดยตรงด้วย pickit3 โดยใช้ตัวเลือกการเขียนโปรแกรม ICSP
การสร้างสัญญาณ PWM บนพิน GPIO สำหรับการควบคุมเซอร์โวมอเตอร์
เมื่อวงจรพร้อมแล้วเราต้องหาวิธีสร้างสัญญาณ PWN บนพิน GPIO ของ PIC เพื่อควบคุมเซอร์โวมอเตอร์ เราเคยเบื่อบางสิ่งที่คล้ายกันโดยใช้วิธีการขัดจังหวะตัวตั้งเวลาและประสบความสำเร็จ ที่นี่เรากำลังจะสร้างต่อจากนี้ดังนั้นหากคุณยังใหม่ที่นี่เราขอแนะนำให้คุณอ่านบทแนะนำก่อนหน้านี้ก่อนที่จะดำเนินการต่อไป
เซอร์โวมอเตอร์สำหรับงานอดิเรกทั้งหมดทำงานด้วยความถี่ 50Hz ความหมายหนึ่งรอบพัลส์ที่สมบูรณ์สำหรับเซอร์โวมอเตอร์จะเป็น 1/50 (F = 1 / T) ซึ่งเป็น 20ms จาก 20 มิลลิวินาทีที่สมบูรณ์นี้สัญญาณควบคุมจะอยู่ระหว่าง 0 ถึง 2 มิลลิวินาทีเท่านั้นในขณะที่สัญญาณที่เหลือจะปิดตลอดเวลา รูปด้านล่างแสดงให้เห็นว่าเวลา ON แตกต่างกันเพียง 0 ถึง 2ms เพื่อหมุนมอเตอร์จาก 0 องศาถึง 180 องศาของระยะเวลาทั้งหมด 20ms
ด้วยเหตุนี้เราจึงต้องเขียนโปรแกรมในลักษณะที่ PIC อ่าน 0 ถึง 1204 จากโพเทนชิออมิเตอร์และแมปเป็น 0 ถึง 100 ซึ่งจะเป็นรอบการทำงานของเซอร์โวมอเตอร์ การใช้รอบการทำงานนี้เราสามารถคำนวณเวลาเปิดของเซอร์โวมอเตอร์ได้ จากนั้นเราสามารถเริ่มต้นการขัดจังหวะตัวจับเวลาให้ล้นในช่วงเวลาปกติเพื่อให้มันทำหน้าที่คล้ายกับฟังก์ชัน millis () ใน Arduino ด้วยวิธีนี้เราสามารถสลับพินสถานะ GPIO ให้สูงตามระยะเวลาที่ต้องการและปิดหลังจาก 20ms (หนึ่งรอบที่สมบูรณ์) จากนั้นทำซ้ำขั้นตอนเดียวกัน ตอนนี้เราเข้าใจตรรกะแล้วให้เราเข้าสู่โปรแกรม
การเขียนโปรแกรม PIC16F8771A สำหรับแขนหุ่นยนต์
เช่นเดียวกับโปรแกรมที่สมบูรณ์พร้อมวิดีโอสามารถพบได้ที่ส่วนท้ายของหน้านี้โค้ดสามารถดาวน์โหลดได้จากที่นี่พร้อมไฟล์ที่จำเป็นทั้งหมด ในส่วนนี้เราจะพูดถึงตรรกะเบื้องหลังโปรแกรม โปรแกรมนี้ใช้โมดูล ADC, โมดูลตั้งเวลาและโมดูล LCD เพื่อควบคุมแขนหุ่นยนต์ หากคุณไม่ทราบวิธีใช้คุณสมบัติ ADC หรือคุณสมบัติตัวตั้งเวลาหรือเชื่อมต่อ LCD กับ PIC คุณสามารถกลับไปที่ลิงก์ต่างๆเพื่อเรียนรู้ได้ คำอธิบายด้านล่างนี้ได้รับโดยสมมติว่าผู้อ่านคุ้นเคยกับแนวคิดเหล่านี้
การกำหนดค่าพอร์ตของตัวจับเวลา 0
ส่วนที่สำคัญที่สุดในรหัสการตั้งค่าตัวจับเวลา 0 ไปกว่าการไหลสำหรับความล่าช้าที่เฉพาะเจาะจงทุก สูตรคำนวณความล่าช้านี้สามารถกำหนดเป็น
ความล่าช้า = ((256-REG_val) * (Prescal * 4)) / Fosc
ด้วยการใช้ OPTION_REG และ TMR0 register เราได้ตั้งค่า Timer 0 ให้ทำงานด้วยค่า prescalar เป็น 32 และค่า REG ถูกตั้งเป็น 248 ความถี่คริสตัล (Fosc) ที่ใช้ในฮาร์ดแวร์ของเราคือ 20Mhz ด้วยค่าเหล่านี้สามารถคำนวณความล่าช้าได้เป็น
ความล่าช้า = ((256-248) * (32 * 4)) / (20000000) = 0.0000512 วินาที (หรือ) = 0.05 มิลลิวินาที
ดังนั้นตอนนี้เราได้ตั้งเวลาที่จะล้นในทุก 0.05ms รหัสในการทำเช่นเดียวกันได้รับด้านล่าง
/ ***** การกำหนดค่าพอร์ตสำหรับ Timer ****** / OPTION_REG = 0b00000100; // Timer0 พร้อมความถี่ภายนอกและ 32 เป็น prescalar // ยังเปิดใช้งาน PULL UPs TMR0 = 248; // โหลดค่าเวลาสำหรับ 0.0001s; delayValue สามารถอยู่ระหว่าง 0-256 เท่านั้น TMR0IE = 1; // เปิดใช้งานบิตขัดจังหวะตัวจับเวลาใน PIE1 register GIE = 1; // เปิดใช้งาน Global Interrupt PEIE = 1; // เปิดใช้งานการขัดจังหวะอุปกรณ์ต่อพ่วง / *********** ______ *********** /
จากหน้าต่างควบคุม 0ms ถึง 2ms ทั้งหมดของเซอร์โวมอเตอร์เราสามารถควบคุมได้ด้วยความละเอียด 0.05msec ซึ่งทำให้เรามี (2 / 0.05) 40 ตำแหน่งที่แตกต่างกันสำหรับมอเตอร์ระหว่าง 0 องศาถึง 180 องศา คุณสามารถลดค่านี้เพิ่มเติมได้หาก MCU ของคุณรองรับเพื่อให้ได้ตำแหน่งที่มากขึ้นและการควบคุมที่แม่นยำ
Interrupt Service Routine (ISR)
ตอนนี้เราได้ตั้งค่า Timer 0 เป็น over flow สำหรับทุกๆ 0.05ms แล้วเราจะตั้งค่าแฟล็กอินเตอร์รัปต์ TMR0IF เป็น 0.05ms ดังนั้นภายในฟังก์ชัน ISR เราสามารถรีเซ็ตแฟล็กนั้นและเพิ่มตัวแปรที่เรียกว่านับที ละหนึ่ง ตอนนี้ตัวแปรนี้จะเพิ่มขึ้นทีละ 1 สำหรับทุกๆ 0.05 มิลลิวินาที
เป็นโมฆะ interrupt timer_isr () { if (TMR0IF == 1) // Timer flag ถูกทริกเกอร์เนื่องจาก Timer overflow -> ตั้งค่าเป็น overflow สำหรับทุกๆ 0.05ms { TMR0 = 248; // โหลดค่าตัวจับเวลา TMR0IF = 0; // ล้างการ นับ ค่าสถานะขัดจังหวะตัวจับเวลา++; // นับเพิ่มทีละ 1 ทุก 0.05ms }
การคำนวณรอบการทำงานและตรงเวลา
ต่อไปเราต้องคำนวณรอบการทำงานและเวลาสำหรับเซอร์โวมอเตอร์ทั้งห้าตัว เรามีเซอร์โวมอเตอร์ห้าตัวซึ่งแต่ละตัวใช้เพื่อควบคุมส่วนของแขนแต่ละส่วน ดังนั้นเราจึงต้องอ่านค่า ADC ของทั้งห้าและคำนวณรอบการทำงานและเวลาสำหรับแต่ละรายการ
ค่า ADC จะอยู่ในช่วง 0 ถึง 1024 ซึ่งสามารถแปลงเป็นรอบการทำงาน 0% ถึง 100% ได้เพียงแค่คูณ 0.0976 (100/1024 = 0.0976) กับค่าที่ได้รับ รอบการทำงาน 0 ถึง 100% นี้จะต้องถูกแปลงเป็นเวลา ON เรารู้ว่าที่รอบการทำงาน 100% เวลา ON จะต้องเป็น 2ms (สำหรับ 180 องศา) ดังนั้นการคูณ 0.02 (2/100 = 0.02) จะแปลงรอบการทำงาน 0 ถึง 100 เป็น 0 ถึง 2ms แต่แล้วจำนวนตัวแปรตัวจับเวลาของเราถูกตั้งค่าให้เพิ่มขึ้นหนึ่งครั้งสำหรับทุกๆ 0.05 มิลลิวินาที ซึ่งหมายความว่าค่าของการนับจะเท่ากับ 20 (1 / 0.05 = 20) สำหรับทุกๆ 1 มิลลิวินาที ดังนั้นเราต้องคูณ 20 ด้วย 0.02 เพื่อคำนวณเวลาที่แน่นอนสำหรับโปรแกรมของเราซึ่งจะให้ค่า 0.4 (0.02 * 20 = 0.4) รหัสเดียวกันแสดงอยู่ด้านล่างคุณสามารถดูซ้ำได้ 5 ครั้งสำหรับทั้ง 5 pot โดยใช้ for loop ค่าผลลัพธ์จะถูกเก็บไว้ในอาร์เรย์ T_ON
สำหรับ (int pot_num = 0; pot_num <= 3; pot_num ++) { int Pev_val = T_ON; POT_val = (ADC_Read (pot_num)); // อ่านค่าของ POT โดยใช้ ADC Duty_cycle = (POT_val * 0.0976); // แผนที่ 0 ถึง 1024 ถึง 0 ถึง 100 T_ON = Duty_cycle * 0.4; // 20 * 0.02
การเลือกมอเตอร์ที่จะหมุน
เราไม่สามารถควบคุมมอเตอร์ทั้งห้าตัวด้วยกันได้เนื่องจากจะทำให้รหัส ISR หนักมากทำให้ไมโครคอนโทรลเลอร์ทั้งหมดทำงานช้าลง ดังนั้นเราจึงต้องหมุนเซอร์โวมอเตอร์ทีละตัวเท่านั้น ในการเลือกเซอร์โวที่จะหมุนไมโครคอนโทรลเลอร์จะตรวจสอบเวลาเปิดของเซอร์โวมอเตอร์ทั้งห้าตัวและเปรียบเทียบกับเวลาก่อนหน้านี้ หากมีการเปลี่ยนแปลงในเวลา ON เราสามารถสรุปได้ว่าต้องย้ายเซอร์โวโดยเฉพาะ รหัสเดียวกันแสดงอยู่ด้านล่าง
ถ้า (T_ON! = Pev_val) { Lcd_Clear (); เซอร์โว = pot_num; Lcd_Set_Cursor (2,11); Lcd_Print_String ("S:"); Lcd_Print_Char (เซอร์โว + '0'); ถ้า (pot_num == 0) {Lcd_Set_Cursor (1,1); Lcd_Print_String ("A:");} else if (pot_num == 1) {Lcd_Set_Cursor (1,6); Lcd_Print_String ("B:");} else if (pot_num == 2) {Lcd_Set_Cursor (1,11); Lcd_Print_String ("C:");} else if (pot_num == 3) {Lcd_Set_Cursor (2,1); Lcd_Print_String ("D:");} else if (pot_num == 4) {Lcd_Set_Cursor (2,6); Lcd_Print_String ("E:");} ถ่าน d2 = (Duty_cycle)% 10; ถ่าน d1 = (Duty_cycle / 10)% 10; Lcd_Print_Char (d1 + '0'); Lcd_Print_Char (d2 + '0');
นอกจากนี้เรายังพิมพ์วงจรการทำงานของเซอร์โวบนหน้าจอ LCD เพื่อให้ผู้ใช้ทราบถึงตำแหน่งปัจจุบัน ตามการเปลี่ยนแปลงของเวลาเปิดเซอร์โวตัวแปรจะได้รับการอัปเดตด้วยตัวเลขตั้งแต่ 0 ถึง 4 ซึ่งแต่ละตัวแสดงถึงมอเตอร์
การควบคุมเซอร์โวมอเตอร์ภายใน ISR
ภายใน ISR เรามีการนับตัวแปรที่เพิ่มขึ้นทุกๆ 0.05ms ซึ่งหมายความว่าทุกๆ 1ms ตัวแปรจะเพิ่มขึ้นทีละ 20 โดยใช้สิ่งนี้เราต้องควบคุมพินเพื่อสร้างสัญญาณ PWM หากค่าของการนับน้อยกว่าเวลาที่กำหนดไว้ GPIO ของมอเตอร์นั้นจะเปิดโดยใช้บรรทัดด้านล่าง
PORTD = PORTD - servo_code;
ที่นี่ servo_code อาร์เรย์มีรายละเอียดพินของเซอร์โวมอเตอร์ทั้งห้าและขึ้นอยู่กับค่าในเซอร์โวตัวแปรรหัสสำหรับเซอร์โวมอเตอร์เฉพาะนั้นจะถูกใช้ จากนั้นจะมีเหตุผลหรือ (-) ด้วยบิต PORTD ที่มีอยู่เพื่อที่เราจะไม่รบกวนค่าของมอเตอร์อื่นและอัปเดตเฉพาะมอเตอร์ตัวนี้เท่านั้น ในทำนองเดียวกันสำหรับการปิดพิน
PORTD = PORTD & ~ (servo_code);
เราได้ย้อนกลับค่าบิตโดยใช้ตัวดำเนินการตรรกะผกผัน (~) จากนั้นจึงดำเนินการ AND (&) บน PORTD เพื่อปิดเฉพาะพินที่ต้องการในขณะที่ปล่อยพินอื่นไว้ในสถานะก่อนหน้า ข้อมูลโค้ดที่สมบูรณ์แสดงอยู่ด้านล่าง
เป็นโมฆะ interrupt timer_isr () { if (TMR0IF == 1) // Timer flag ถูกทริกเกอร์เนื่องจาก Timer overflow -> ตั้งค่าเป็น overflow สำหรับทุกๆ 0.05ms { TMR0 = 248; // โหลดค่าตัวจับเวลา TMR0IF = 0; // ล้างค่าสถานะขัดจังหวะตัวจับเวลา ++; // นับเพิ่มทีละ 1 สำหรับทุกๆ 0.05ms -> จำนวนจะเท่ากับ 20 สำหรับทุกๆ 1ms (0.05 / 1 = 20)) } int servo_code = {0b01000000, 0b00100000, 0b00010000, 0b00001000, 0b00000100}; ถ้า (นับ> = 20 * 20) นับ = 0; ถ้า (นับ <= (T_ON)) PORTD = PORTD - servo_code; อื่น PORTD = PORTD & ~ (servo_code); }
เรารู้ว่ารอบทั้งหมดจะต้องคงอยู่เป็นเวลา 20ms ก่อนที่พิน GPIO จะเปิดอีกครั้ง ดังนั้นเราจึงตรวจสอบว่าการนับเกิน 20 มิลลิวินาทีหรือไม่โดยการเปรียบเทียบค่าของการนับกับ 400 (การคำนวณเช่นเดียวกับที่กล่าวไว้ข้างต้น) และถ้าใช่เราต้องเริ่มต้นการนับให้เป็นศูนย์อีกครั้ง
การจำลองรหัสแขนหุ่นยนต์ PIC
การจำลองโค้ดก่อนที่จะนำไปใช้กับฮาร์ดแวร์จริงจะดีกว่าเสมอ ดังนั้นฉันจึงใช้ Proteus เพื่อจำลองรหัสของฉันและตรวจสอบว่าทำงานได้อย่างถูกต้อง วงจรที่ใช้ในการจำลองแสดงอยู่ด้านล่างเราได้ใช้ออสซิลโลสโคปเพื่อตรวจสอบว่าสัญญาณ PWM ถูกสร้างขึ้นตามที่ต้องการหรือไม่ นอกจากนี้เราสามารถตรวจสอบได้ว่ามอเตอร์ LCD และเซอร์โวหมุนตามที่คาดไว้หรือไม่
ที่คุณสามารถดูการแสดงที่จอ LCD รอบหน้าที่ของมอเตอร์ D จะเป็น 07 ขึ้นอยู่กับค่าหม้อซึ่งเป็น 3 ถยนต์ ในทำนองเดียวกันถ้าหม้ออื่นถูกย้ายรอบการทำงานของหม้อนั้นและหมายเลขมอเตอร์จะแสดงบนจอ LCD สัญญาณ PWM ที่แสดงบนออสซิลโลสโคปแสดงอยู่ด้านล่าง
รอบระยะเวลาทั้งหมดวัดเป็น 22.2ms โดยใช้ตัวเลือกเคอร์เซอร์บนออสซิลโลสโคปซึ่งใกล้เคียงกับ 20ms ที่ต้องการมาก ในที่สุดเราก็แน่ใจว่ารหัสใช้งานได้ดังนั้นเพื่อดำเนินการต่อกับวงจรเราสามารถบัดกรีบนบอร์ด perf หรือใช้ PCB จะไม่ทำงานได้อย่างง่ายดายบน breadboard เนื่องจาก POT มักจะให้ปัญหาบางอย่างเนื่องจากการเชื่อมต่อที่ไม่ดี
การออกแบบ PCB โดยใช้ EasyEDA
ในการออกแบบแขนหุ่นยนต์ PICนี้ เราได้เลือกเครื่องมือ EDA ออนไลน์ที่เรียกว่า EasyEDA ฉันใช้มันมานานแล้วและพบว่ามันสะดวกมากเพราะมีรอยเท้าที่มีอยู่มากมายและธรรมชาติที่ใช้งานง่าย หลังจากออกแบบ PCB แล้วเราสามารถสั่งซื้อตัวอย่าง PCB โดยบริการผลิต PCB ต้นทุนต่ำ นอกจากนี้ยังมีบริการจัดหาส่วนประกอบที่มีส่วนประกอบอิเล็กทรอนิกส์จำนวนมากและผู้ใช้สามารถสั่งซื้อส่วนประกอบที่ต้องการพร้อมกับคำสั่งซื้อ PCB
ในขณะที่ออกแบบวงจรและ PCB ของคุณคุณยังสามารถทำให้การออกแบบวงจรและ PCB ของคุณเป็นแบบสาธารณะเพื่อให้ผู้ใช้รายอื่นสามารถคัดลอกหรือแก้ไขได้และสามารถใช้ประโยชน์จากงานของคุณได้เรายังทำให้วงจรและเลย์เอาต์ PCB ทั้งหมดของเราเป็นแบบสาธารณะสำหรับวงจรนี้ด้วยตรวจสอบ ลิงค์ด้านล่าง:
easyeda.com/circuitdigest/pic-development-board-for-robotic-arm
เมื่อใช้ลิงก์นี้คุณสามารถสั่งซื้อ PCB เดียวกันกับที่เราใช้ในโครงการนี้และใช้งานได้โดยตรง เมื่อออกแบบเสร็จแล้วจะสามารถดูบอร์ดเป็นโมเดล 3 มิติได้ซึ่งจะเป็นประโยชน์อย่างมากในการมองเห็นว่าบอร์ดจะปรากฏอย่างไรหลังจากการประดิษฐ์ โมเดล 3 มิติของบอร์ดที่เราใช้อยู่แสดงอยู่ด้านล่าง นอกจากนี้คุณยังสามารถดูเลเยอร์บนและล่างของบอร์ดเพื่อตรวจสอบว่าหน้าจอเรียบตามที่คาดไว้หรือไม่
การคำนวณและการสั่งซื้อตัวอย่างออนไลน์
หลังจากออกแบบ PIC Robot PCB นี้เสร็จแล้วคุณสามารถสั่งซื้อ PCB ผ่าน JLCPCB.com ในการสั่งซื้อ PCB จาก JLCPCB คุณต้องมีไฟล์ Gerber หากต้องการดาวน์โหลดไฟล์ Gerber ของ PCB ของคุณเพียงคลิกปุ่ม สร้างไฟล์การผลิต บนหน้าตัวแก้ไข EasyEDA จากนั้นดาวน์โหลดไฟล์ Gerber จากที่นั่นหรือคุณสามารถคลิก สั่งซื้อที่ JLCPCB ดังที่แสดงในภาพด้านล่าง สิ่งนี้จะเปลี่ยนเส้นทางคุณไปยัง JLCPCB.com ซึ่งคุณสามารถเลือกจำนวน PCB ที่คุณต้องการสั่งซื้อจำนวนชั้นทองแดงที่คุณต้องการความหนาของ PCB น้ำหนักทองแดงและแม้แต่สีของ PCB เช่นเดียวกับภาพรวมที่แสดงด้านล่าง:
หลังจากคุณเลือกตัวเลือกทั้งหมดแล้วให้คลิก“ บันทึกลงในรถเข็น” จากนั้นคุณจะเข้าสู่หน้าที่คุณสามารถอัปโหลดไฟล์ Gerber ของคุณซึ่งเราได้ดาวน์โหลดจาก EasyEDA อัปโหลดไฟล์ Gerber ของคุณแล้วคลิก“ บันทึกลงในรถเข็น” และในที่สุดคลิกที่ชำระเงินอย่างปลอดภัยเพื่อดำเนินการสั่งซื้อให้เสร็จสมบูรณ์จากนั้นคุณจะได้รับ PCBs ของคุณในอีกไม่กี่วัน พวกเขากำลังผลิต PCB ในอัตราที่ต่ำมากซึ่งอยู่ที่ 2 เหรียญ เวลาในการสร้างของพวกเขายังน้อยกว่ามากซึ่ง 48 ชั่วโมงด้วยการจัดส่ง DHL 3-5 วันโดยทั่วไปคุณจะได้รับ PCBs ภายในหนึ่งสัปดาห์หลังจากสั่งซื้อ
หลังจากสั่งซื้อ PCB แล้วคุณสามารถ ตรวจสอบ ความคืบหน้าในการผลิต PCB ของคุณ พร้อมวันที่และเวลา คุณตรวจสอบได้โดยไปที่หน้าบัญชีและคลิกที่ "ความคืบหน้าในการผลิต"
หลังจากไม่กี่วันของการสั่งซื้อ PCB ฉันได้รับตัวอย่าง PCB ในบรรจุภัณฑ์ที่ดีดังที่แสดงในภาพด้านล่าง
และหลังจากได้ชิ้นส่วนเหล่านี้ฉันได้บัดกรีส่วนประกอบที่จำเป็นทั้งหมดบน PCB ฉันยังบัดกรี POT โดยตรงโดยตรงแทนที่จะใช้สายเชื่อมต่อเนื่องจากสายหญิงกับหญิงที่ฉันใช้ในตอนแรกซึ่งให้แรงดันไฟฟ้าเอาต์พุตแบบอะนาล็อกแปลก ๆ อาจเป็นเพราะหน้าสัมผัสหลวม เมื่อประกอบส่วนประกอบทั้งหมดแล้ว PCB ของฉันก็มีลักษณะดังนี้
คุณอาจสังเกตเห็นว่ามี 7805 เพียงเครื่องเดียวในบอร์ดนี้ นั่นเป็นเพราะตอนแรกฉันคิดว่าฉันสามารถหลีกเลี่ยงได้เพียงแค่ตัวควบคุมสำหรับการเปิดเครื่องทั้ง PIC และเซอร์โวมอเตอร์และหลังจากนั้นฉันก็รู้ว่าฉันต้องการสองตัว ดังนั้นฉันจึงใช้วงจรภายนอกเพื่อจ่ายไฟเซอร์โวมอเตอร์ผ่านสายสีเขียวที่คุณเห็นที่นี่
อย่างไรก็ตามคุณไม่ต้องกังวลมากนักเพราะ ตอนนี้ฉันได้ทำการเปลี่ยนแปลง PCB แล้ว คุณสามารถใช้ PCB ดัดแปลงและประสานทั้งหน่วยงานกำกับดูแลบนบอร์ดได้
การทำงานของแขนหุ่นยนต์ PIC
หลังจากทำงานที่เหน็ดเหนื่อยมาตลอดก็ถึงเวลาที่ต้องจ่ายเงิน ประสานส่วนประกอบทั้งหมดบนบอร์ดและอัปโหลดโปรแกรมไปยังตัวควบคุม PIC กรอกรหัสได้ด้านล่างหรือสามารถดาวน์โหลดได้จากที่นี่ ตัวเชื่อมต่อการเขียนโปรแกรมที่ให้มาบนบอร์ดจะช่วยให้คุณอัปโหลดโปรแกรมได้โดยตรงโดยใช้ Pickit 3 โดยไม่ต้องยุ่งยากมากนัก เมื่ออัปโหลดโปรแกรมแล้วคุณจะเห็น LCD แสดงเซอร์โวที่กำลังควบคุมอยู่ หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการเขียนโปรแกรมไมโครคอนโทรลเลอร์ PIC เพียงทำตามบทช่วยสอนก่อนหน้านี้
จากตรงนั้นคุณสามารถหมุนหม้อและตรวจสอบว่าเซอร์โวมอเตอร์ตอบสนองต่อโพเทนชิออมิเตอร์แต่ละตัวอย่างไร เมื่อคุณเข้าใจรูปแบบแล้วคุณสามารถควบคุมแขนหุ่นยนต์เพื่อดำเนินการตามที่คุณต้องการเพื่อดำเนินการและสนุกสนาน คุณสามารถดู การทำงานทั้งหมดของโครงการได้ในวิดีโอที่ลิงก์ด้านล่าง
หวังว่าคุณจะเข้าใจโครงการและเรียนรู้สิ่งใหม่ ๆ จากโครงการนี้ หากคุณมีคำถามใด ๆ โปรดทิ้งไว้ในส่วนความคิดเห็นหรือใช้ฟอรัมสำหรับการสนทนาทางเทคนิคอื่น ๆ