การวัดความเร็วระยะทางและมุมสำหรับหุ่นยนต์เคลื่อนที่โดยใช้ arduino และ lm393 speed sensor (h206)

หุ่นยนต์ได้เริ่มคลานเข้ามาในสังคมของเราอย่างช้าๆเพื่อทำให้ชีวิตของเราเรียบง่ายขึ้น เราสามารถพบหุ่นยนต์ส่งอาหารหกล้อจาก Starship บนท้องถนนในสหราชอาณาจักรได้แล้วซึ่งนำทางท่ามกลางพลเรือนอย่างชาญฉลาดเพื่อไปให้ถึงจุดหมาย หุ่นยนต์เคลื่อนที่ทุกตัวที่เคลื่อนที่ไปในสภาพแวดล้อมควรตระหนักถึงตำแหน่งและทิศทางของมันด้วยความเคารพต่อโลกแห่งความเป็นจริง มีหลายวิธีในการบรรลุเป้าหมายนี้โดยใช้เทคโนโลยีที่แตกต่างกันเช่น GPS, RF Triangulation, Accelerometers, Gyroscopes เป็นต้นแต่ละเทคนิคมีข้อดีของตัวเองและมีเอกลักษณ์เฉพาะ ในบทช่วยสอนเกี่ยวกับเซ็นเซอร์ความเร็ว Arduino LM393นี้เราจะใช้โมดูลเซ็นเซอร์ความเร็ว LM393 ที่ใช้งานง่ายเพื่อวัดพารามิเตอร์ที่สำคัญบางอย่างเช่นความเร็วระยะทางที่เดินทางและมุมของหุ่นยนต์โดยใช้ Arduino ด้วยพารามิเตอร์เหล่านี้หุ่นยนต์จะสามารถรู้สถานะโลกแห่งความเป็นจริงและสามารถใช้เพื่อนำทางได้อย่างปลอดภัย

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

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

LM393 โมดูลเซ็นเซอร์ความเร็ว (H206)

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

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

H206 การจัดวางเซนเซอร์

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

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

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

DIY Arduino LM393 Speed ​​Sensor แผนภาพวงจรหุ่นยนต์

แผนภาพวงจรทั้งหมดของหุ่นยนต์ตรวจจับความเร็วและระยะทางแสดงอยู่ด้านล่าง บ็อตประกอบด้วยArduino Nanoเป็นสมองมอเตอร์กระแสตรงสองตัวสำหรับล้อขับเคลื่อนด้วยโมดูลไดรเวอร์มอเตอร์ H-Bridge L298N จอยสติ๊กใช้เพื่อควบคุมความเร็วและทิศทางของบอทและเซ็นเซอร์ความเร็วสองตัว H206 ใช้เพื่อวัดความเร็วระยะทางและนางฟ้าของบอท ค่าที่วัดจะมีการแสดงจากนั้นในโมดูล 16x2 จอแอลซีดีโพเทนชิออมิเตอร์ที่เชื่อมต่อกับ LCD สามารถใช้เพื่อปรับความคมชัดของ LCD และใช้ตัวต้านทานเพื่อ จำกัด กระแสที่ไหลไปยังแบ็คไลท์ของ LCD

ครบวงจรโดยใช้พลังงานจากเซลล์ลิเธียม 7.4V 7.4V นี้จ่ายให้กับขา 12V ของโมดูลไดรเวอร์มอเตอร์ ตัวควบคุมแรงดันไฟฟ้าบนโมดูลไดรเวอร์มอเตอร์จะแปลง 7.4V เป็นควบคุม + 5V ซึ่งใช้เพื่อจ่ายไฟให้กับ Arduino, LCD, เซนเซอร์และจอยสติ๊ก

มอเตอร์ถูกควบคุมโดยพินดิจิทัล 8,9,10 และ 11 ของ Arduino เนื่องจากต้องควบคุมความเร็วของมอเตอร์ด้วยเราจึงควรส่งสัญญาณ PWM ไปยังขั้วบวกของมอเตอร์ ดังนั้นเราจึงมีพิน 9 และ 10 ซึ่งเป็นพินที่รองรับ PWM ทั้งคู่ ค่า X และ Y จากจอยสติ๊กจะอ่านโดยใช้หมุดอะนาล็อก A2 และ A3 ตามลำดับ

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

ตอนนี้ส่วนฮาร์ดแวร์เสร็จสมบูรณ์แล้วให้เราเข้าสู่ตรรกะว่าเราจะวัดความเร็วระยะทางและตัวเดียวของบอทอย่างไรจากนั้นไปที่ส่วนการเขียนโปรแกรม

ตรรกะเบื้องหลังการวัดความเร็วด้วยโมดูลเซ็นเซอร์ความเร็ว LM393

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

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

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

เวลาที่ถ่าย = เวลาปัจจุบัน - ก่อนหน้านี้เวลา timetaken = มิลลิวินาที() - pevtime ; // timetaken ในmillisec

เมื่อเราคำนวณเวลาที่ใช้แล้วเราสามารถคำนวณค่าของรอบต่อนาทีได้โดยใช้สูตรด้านล่างโดยที่ (1000 / เวลาที่ถ่าย) ให้ RPS (รอบต่อวินาที) และคูณด้วย 60 เพื่อแปลง RPS เป็น RPM (รอบต่อนาที).

รอบต่อนาที = (1,000 / เวลาถ่าย) * 60;

หลังจากคำนวณรอบต่อนาทีแล้วเราสามารถคำนวณความเร็วของรถได้โดยใช้สูตรด้านล่างนี้หากเราทราบรัศมีของล้อ

ความเร็ว = 2π× RPS ×รัศมีล้อ v = radius_of_wheel * รอบต่อนาที * 0.104

หมายเหตุสูตรข้างต้นใช้สำหรับคำนวณความเร็วเป็น m / s หากคุณต้องการคำนวณเป็นกม. / ชม. ให้แทนที่ 0.0104 ด้วย 0.376 หากคุณอยากรู้ว่าค่า 0.104 ได้มาอย่างไรลองทำให้สูตร V = 2π× RPS ×รัศมีของวงล้อง่ายขึ้น

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

ถ้า (การหมุน> = 40) { Timetaken = millis () - pevtime; // ตั้งเวลาเป็นมิลลิวินาที รอบต่อนาที = (1000 / Timetaken) * 60; // สูตรคำนวณ rpm pevtime = millis (); การหมุน = 0; }

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

/ * จะลดลงเป็นศูนย์หากรถหยุด * / if (มิลลิวินาที () - dtime> 500) // ไม่พบการขัดจังหวะเป็นเวลา 500ms { rpm = v = 0; // ทำให้รอบต่อนาทีและความเร็วเป็นศูนย์ dtime = มิลลิวินาที (); }

ตรรกะหลังการวัดระยะทางที่ล้อ

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

ระยะทาง = 2πr * จำนวน ระยะการหมุน= (2 * 3.141 * radius_of_wheel) * (left_intr / 40)

ในกรณีที่เส้นรอบวงของวงล้อคำนวณโดยใช้สูตร2πrจากนั้นจะคูณด้วยจำนวนการหมุนของวงล้อ

ตรรกะเบื้องหลังการวัดมุมของบอท

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

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

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

int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80);

โดยที่ 90 คือมุมที่ครอบคลุมเมื่อทำการขัดจังหวะ 80 ค่าผลลัพธ์คือการขัดจังหวะด้วยจำนวนคูณ เรายังใช้โมดูลัส 360 เพื่อให้ค่าผลลัพธ์ไม่เกิน 36 เมื่อเราคำนวณทั้งมุมซ้ายและขวาแล้วมุมที่มีประสิทธิภาพที่บอทหันไปสามารถหาได้ง่ายๆโดยการลบมุมซ้ายในรูปแบบมุมขวา

มุม = angle_right - angle_left;

รหัสหุ่นยนต์ Arduino

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

เราเริ่มต้นโปรแกรมโดยกำหนดดิจิตอล I / O หมุดสำหรับสองมอเตอร์ โปรดทราบว่าเราต้องควบคุมความเร็วของมอเตอร์ด้วยดังนั้นเราจึงต้องใช้หมุด PWM บน Arduino เพื่อควบคุมมอเตอร์ ที่นี่เราใช้พิน 8,9,10 และ 11

#define LM_pos 9 // มอเตอร์ซ้าย # กำหนด LM_neg 8 // มอเตอร์ซ้าย # กำหนด RM_pos 10 // มอเตอร์ขวา # กำหนด RM_neg 11 // มอเตอร์ขวา # กำหนด joyX A2 # กำหนด joyY A3

ในการวัดความเร็วและระยะทางที่ครอบคลุมเราจำเป็นต้องทราบรัศมีของล้อวัดค่าและป้อนเป็นเมตรดังที่แสดงด้านล่าง สำหรับบอทของฉันรัศมีคือ 0.033 เมตร แต่อาจแตกต่างกันไปสำหรับคุณตามบอทของคุณ

รัศมีลอย _of_wheel = 0.033; // วัดรัศมีล้อของคุณแล้วป้อนที่นี่เป็นซม

ภายใน ติดตั้ง ฟังก์ชั่นที่เราเริ่มต้นค่าทั้งหมดเพื่อเป็นศูนย์และจากนั้นแสดงข้อความแนะนำบนหน้าจอ LCDนอกจากนี้เรายังได้เตรียมใช้งานจอภาพแบบอนุกรมเพื่อจุดประสงค์ในการดีบัก จากนั้นเราได้กล่าวว่าเซ็นเซอร์ความเร็ว H206 เชื่อมต่อกับพิน 2 และ 3 เป็นตัวขัดจังหวะภายนอก นั่นคือที่ที่เคยตรวจพบการขัดจังหวะฟังก์ชัน ISR Left_ISR และ Right_ISR จะดำเนินการตามนั้น

การตั้งค่าเป็นโมฆะ () { rotation = rpm = pevtime = 0; // เริ่มต้นตัวแปรทั้งหมดเป็นศูนย์ Serial.begin (9600); lcd.begin (16, 2); // เริ่มต้น 16 * 2 LCD lcd.print ("Bot Monitor"); // Intro Message line 1 lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Intro Message line 2 ล่าช้า (2000); lcd.clear (); lcd.print ("Lt: Rt:"); lcd.setCursor (0, 1); lcd.print ("S: D: A:"); pinMode (LM_pos, เอาท์พุท); pinMode (LM_neg, เอาท์พุท); pinMode (RM_pos, เอาท์พุท); pinMode (RM_neg, เอาท์พุท); digitalWrite (LM_neg, LOW); digitalWrite (RM_neg, LOW); attachInterrupt (digitalPinToInterrupt (2), Left_ISR, CHANGE); // Left_ISR ถูกเรียกเมื่อเซ็นเซอร์ล้อซ้ายถูกทริกเกอร์ attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Right_ISR ถูกเรียกเมื่อเซ็นเซอร์ล้อขวาถูกเรียกใช้ }

ภายในรูทีน Left_ISR เราเพียงแค่เพิ่มตัวแปรที่เรียกว่า left_intrซึ่งจะใช้ในการวัดมุมของบอทในภายหลัง ภายใน Right_ISR เราทำสิ่งเดียวกัน แต่จากนั้นเรายังคำนวณความเร็วที่นี่ด้วย การหมุนตัวแปรจะเพิ่มขึ้นสำหรับการขัดจังหวะทุกครั้งจากนั้นใช้ตรรกะข้างต้นเพื่อคำนวณความเร็ว

โมฆะ Left_ISR () { left_intr ++; ล่าช้า (10); } เป็นโมฆะ Right_ISR () { right_intr ++; ล่าช้า (10); การหมุน ++; dtime = มิลลิวินาที (); ถ้า (การหมุน> = 40) { Timetaken = millis () - pevtime; // กำหนดเวลาเป็นมิลลิวินาที รอบต่อนาที = (1000 / เวลาถ่าย) * 60; // สูตรคำนวณ rpm pevtime = millis (); การหมุน = 0; } }

ภายในฟังก์ชั่นอนันต์ห่วงหลักที่เราตรวจสอบค่าของ X และ Y จากจอยสติ๊ก ขึ้นอยู่กับค่าหากมีการย้ายจอยสติ๊กเราควบคุมบอทตามนั้น ความเร็วของบอทขึ้นอยู่กับว่าจอยสติ๊กถูกผลักไปไกลแค่ไหน

int xValue = analogRead (joyX); int yValue = analogRead (joyY); การเร่งความเร็ว int = แผนที่ (xValue, 500, 0, 0, 200); ถ้า (xValue <500) { analogWrite (LM_pos, การเร่งความเร็ว); analogWrite (RM_pos, การเร่งความเร็ว); } else { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } ถ้า (yValue> 550) analogWrite (RM_pos, 80); ถ้า (yValue <500) analogWrite (LM_pos, 100);

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

v = radius_of_wheel * รอบต่อนาที * 0.104; //0.033 คือรัศมีของล้อใน ระยะ เมตร= (2 * 3.141 * radius_of_wheel) * (left_intr / 40); int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80); มุม = angle_right - angle_left; lcd.setCursor (3, 0); lcd.print (""); lcd.setCursor (3, 0); lcd.print (left_intr); lcd.setCursor (11, 0); lcd.print (""); lcd.setCursor (11, 0); lcd.print (right_intr); lcd.setCursor (2, 1); lcd.print (""); lcd.setCursor (2, 1); lcd.print (v); lcd.setCursor (9, 1); lcd.print (""); lcd.setCursor (9, 1); lcd.print (ระยะทาง); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (มุม);

การทดสอบหุ่นยนต์ Arduino สำหรับการวัดระยะทางความเร็วและมุม

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

บนหน้าจอ LCD ที่ระยะขีดข่วนและแสดงให้เห็นถึงจำนวน Rt ซ้ายขัดจังหวะและสิทธิขัดจังหวะนับตามลำดับ คุณจะพบว่าค่าเหล่านี้เพิ่มขึ้นสำหรับทุกช่องว่างที่เซ็นเซอร์ตรวจพบ อุณหภูมิS ระบุความเร็วของบอทในหน่วยเมตร / วินาทีและคำว่า D หมายถึงระยะทางที่ครอบคลุมเป็นเมตร มุมของบอทจะแสดงที่ส่วนท้ายโดยที่ 0 °เป็นค่าตรงและจะเป็นลบสำหรับการหมุนทวนเข็มนาฬิกาและเป็นค่าบวกสำหรับการหมุนตามเข็มนาฬิกา

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