ส่งข้อมูลตัวเลขจาก Arduino ตัวหนึ่งไปยังอีกตัวหนึ่ง: 16 ขั้นตอน

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

บทนำ

โดย David Palmer, CDIO Tech ที่มหาวิทยาลัยแอสตัน

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

คุณสามารถทดสอบการทำงานได้ง่ายๆ เพียงพิมพ์สตริงตัวเลขเพื่อส่งที่เทอร์มินัล Serial Monitor และดูตัวเลขกลับมาที่จอภาพ Serial ตัวที่สองที่เชื่อมต่อกับ Arduino ตัวที่สอง คุณยังสามารถใช้ลิงก์ Bluetooth ได้อีกด้วย

มันทำอะไร

จำเป็นต้องพัฒนาโปรแกรม Arduino สองโปรแกรม (สเก็ตช์ใน Arduino speak) หนึ่งโปรแกรมหลักเพื่อเชื่อมต่อกับคอมพิวเตอร์โฮสต์ที่ใช้งาน Arduino Serial Monitor หนึ่งโปรแกรมทำหน้าที่เป็น Slave เพื่อรับข้อความอนุกรมจาก Master ถอดรหัสและส่งกลับ สเลฟสามารถเลือกแสดงตัวเลขที่เกี่ยวข้องบน Serial Monitor ของ IDE ตัวที่สองได้ - ในกรณีที่คุณต้องการใช้สิ่งนี้ อาจช่วยให้สิ่งต่างๆ ทำงานได้ตั้งแต่แรก และช่วยคุณได้หากคุณตัดสินใจที่จะเปลี่ยนแปลงโปรแกรมเพื่อให้เหมาะกับความต้องการของคุณเอง

อุปกรณ์

• 2 Arduino's
• สาย USB 2 เส้น
• สายแพทช์ (ตามต้องการ)
• 1 PC/แล็ปท็อปที่โหลดด้วย Arduino IDE (มีให้ดาวน์โหลดฟรีจากเว็บไซต์ Arduino.cc)

ขั้นตอนที่ 1: การตั้งค่า - ตั้งค่าฮาร์ดแวร์ของคุณก่อน

เสียบ Arduinos 2 ตัวเข้ากับพอร์ต USB 2 พอร์ตบนคอมพิวเตอร์ของคุณ

เคล็ดลับ เป็นความคิดที่ดีที่จะติดป้ายกำกับเป็น M และ S (หลักและรอง) เพื่อไม่ให้เกิดความสับสนในภายหลัง (ดังแสดงใน 2 รูปที่นี่)

ขั้นตอนที่ 2: การตั้งค่า - ตั้งค่าหน้าจอของคุณ

สิ่งที่ดีที่สุดคือการตั้งค่าหน้าจอของคุณเพื่อให้คุณมี

• IDE ที่โหลดด้วยโปรแกรม Master ทางด้านซ้ายและ
• ที่มีทาสอยู่ทางขวา

เก็บ Serial Monitors for Maser และ Slave ไว้ทางซ้ายและขวาตามที่แสดงในภาพหน้าจอที่นี่

ขั้นตอนที่ 3: ตั้งค่า Master End จากนั้นเชื่อมต่อเข้าด้วยกัน - ตอนที่ 1

เมื่อคุณตั้งค่า Master End Serial Monitor ให้ส่งตัวเลขสองตัว คุณต้องใช้อักขระเริ่มต้นและสิ้นสุด ตัวคั่น และอักขระคั่นด้วยเครื่องหมายจุลภาคตามที่คุณเห็นที่นี่

ตอนนี้คุณต้องเชื่อมต่อ Arduino 2 ตัวเข้าด้วยกันผ่านซีเรียล ทำได้โดยใช้สายแพตช์สองเส้น

ฉันใช้สีเขียวและสีเหลือง

• เอาสีเหลืองไปก่อน ต้องเสียบ D6 กับ Arduino หนึ่งตัว และ D7 ในอันที่สอง
• จากนั้นตรงข้ามกับสายสีเขียว D7 บนตัวแรกและ D6 บน Arduino ตัวที่สอง

อีกทางหนึ่ง หากคุณมีบางอย่างที่พร้อมใช้งาน เช่น โมดูล Bluetooth หนึ่งคู่ เช่น HC-05 อุปกรณ์เหล่านี้จะให้เอฟเฟกต์เดียวกันกับสายไฟด้านบน

ขั้นตอนที่ 4: ตั้งค่า Master End จากนั้นเชื่อมต่อเข้าด้วยกัน - ตอนที่ 2

เรากำลังใช้ประโยชน์จากไลบรารี Software Serial ข้อมูลเพิ่มเติมสามารถดูได้จากลิงค์นี้

คุณสามารถดูมันถูกเรียกออกมาในบรรทัดที่ 7 ของโปรแกรมใดโปรแกรมหนึ่ง มันกำหนดค่าพินดิจิตอล 7 และ 6 เป็น TX และ RX (ส่งและรับ) นี่คือวิธีที่ข้อมูลจะเดินทางออกจาก Master Arduino ผ่านสายสีเขียวไปยัง Slave และเมื่อโปรแกรม Slave ใน Arduino ตัวที่สองทำงานเสร็จ ให้กลับผ่านสายสีเหลือง ที่ด้านล่างของภาพประกอบเดียวกัน (ในหน้าต่าง Serial Monitor) คุณสามารถดูข้อมูลที่เราส่งได้สำเร็จแล้วในลูปที่อธิบายไว้ที่นี่ และกลับมาที่พีซีโดยแยกจำนวนเต็มคู่ออกมาอย่างสวยงาม

ขั้นตอนที่ 5: ภาพรวมของภาพร่าง / โปรแกรม - โครงสร้างของโปรแกรม

เค้าโครง เช่นเดียวกับสเก็ตช์ Arduino ทั้งหมดมี 3 ส่วนพื้นฐาน:

• ปฏิญญา
• การตั้งค่า
• วงหลัก

อย่างที่มักจะเกิดขึ้น เราได้ใช้ส่วนที่ 4 ซึ่งเป็นส่วนเพิ่มเติมของ 'ฟังก์ชัน' หากคุณไม่คุ้นเคยกับการใช้ฟังก์ชัน คุณสามารถใช้ Google สำหรับ "ฟังก์ชัน Arduino" และคุณจะพบไซต์คำอธิบายเช่นตัวอย่างในลิงก์นี้: www.tutorialspoint.com/arduino/arduino_functions…..

เรายังได้ใช้แท็บต่างๆ เพื่อแยกโปรแกรมออกเป็นบล็อคที่จัดการได้มากขึ้น

สามช่วงตึกที่เราใช้สามารถเห็นได้ที่ด้านบนของแต่ละภาพประกอบของหน้าต่าง IDE ด้านบน:

• simpleRxTx0330Master
• ทั่วไป
• บันทึกย่อ

ไฟล์เหล่านี้เป็นไฟล์แยกกันภายในโฟลเดอร์ของโปรแกรม ดังที่คุณเห็นในมุมมอง Windows Explorer ของไฟล์ของโปรแกรม Slave

มีเหตุผลที่ดีมากว่าทำไมเราทำเช่นนี้

• ขณะที่เรากำลังสร้างโปรแกรม เราจึงได้ตระหนักว่าโปรแกรมส่วนใหญ่สำหรับอาจารย์เหมือนกับของทาส
• เราลงเอยด้วยการดึงส่วนทั่วไปทั้งหมดลงในแท็บ ซึ่งเราจึงตั้งชื่อว่า "ทั่วไป" จากนั้นทุกครั้งที่เราดีบั๊กส่วนหนึ่ง (ทดสอบแล้วและพอใจที่มันใช้ได้ดี) เราก็แค่คัดลอกและวางทั้งแท็บ ตรงข้ามจาก Master to Slave หรือในทางกลับกัน
• แท็บบันทึกย่อก็เหมือนกัน เนื่องจากการออกแบบเป็นแบบทั่วไป

ไม่มีการเรียกฟังก์ชันใดๆ จาก setup ฟังก์ชันทั้งหมดถูกเรียกจากลูป ดังนั้นเราจึงสร้างฟังก์ชันเหล่านี้ขึ้นหลังจากการตั้งค่า แต่ก่อนการวนซ้ำ

ขั้นตอนที่ 6: การออกแบบจากบนลงล่าง

เป็นความคิดที่ดีที่จะออกแบบร่างของคุณโดยเริ่มจากคำจำกัดความของสิ่งที่คุณต้องการทำ

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

เป็นไปตามหลักปรัชญาการออกแบบที่ดี ซึ่งสอนในมหาวิทยาลัยหลายแห่ง เรียกว่า CDIO (หากคุณยังไม่รู้จักสิ่งนี้ คุณสามารถใช้ Google ได้ และค้นหาเว็บไซต์เพื่ออธิบาย เช่น https://www.cdio.org/s) โดยพื้นฐานแล้วกล่าวว่า: อย่าเริ่มการออกแบบก่อนที่คุณจะเข้าใจแนวคิดที่ชัดเจน อย่าเริ่มใช้งานจนกว่าคุณจะมีการออกแบบที่ชัดเจน อย่าคาดหวังให้ใช้งานได้ก่อนที่คุณจะมีการดำเนินการที่ชัดเจน C ก่อน ตามด้วย D I และ O ในแต่ละขั้นตอนถัดไป คุณวนซ้ำ (ย้อนกลับวนซ้ำ) ดังนั้นเมื่อคุณพอใจกับการออกแบบเริ่มต้นของคุณวนกลับมาและตรวจสอบว่ายังคงเป็นไปตามแนวคิดและอัปเดต ตัว C ถ้าคุณต้องการ และอื่นๆ ดังนั้นแม้ว่าคุณจะต้องปฏิบัติการอยู่ก็ตาม ให้กลับไปด้านบนสุด และอีกครั้ง ดูว่า C เป็นอย่างไรในตอนนี้ จากนั้น D และฉัน และทำและตรวจสอบทั้งหมด เปลี่ยนแปลงตามความจำเป็น ด้วยการเขียนโปรแกรมสเก็ตช์การทำงานจะเหมือนกันหากคุณออกแบบจากบนลงล่าง

ขั้นตอนที่ 7: แนวคิดและการออกแบบ - ตอนที่ 1

แนวคิดที่นี่ดูเหมือนข้อกำหนดของโครงร่างที่ระบุไว้ในแท็บ 'บันทึกย่อ'

การออกแบบอาจดูเหมือนลูปเวอร์ชันแรกๆ ซึ่งตรงกับแท็บบันทึกย่อและอาจมีลักษณะเหมือนที่คุณเห็นในรูปนี้

ดูว่าฉันชอบเริ่มต้นด้วย CTRL-C จริง ๆ แล้วคัดลอกความคิดเห็นไปที่ส่วนหัวของลูปก่อนแล้วจึงเริ่มเติมช่องว่างด้วยคำสั่งที่จะทำสิ่งเหล่านั้น

สิ่งนี้รวบรวมได้จริงตามที่คุณเห็นที่ด้านล่างของหน้าจอในรูป นั่นคือการเข้าถึงจาก CDIO stage D ถึง I และเมื่อเราพัฒนาโค้ด ก็เป็นความคิดที่ดีที่จะวนรอบ DI นี้ต่อไป

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

ขั้นตอนที่ 8: แนวคิดและการออกแบบ - ตอนที่ 2

สองฟังก์ชันแรกที่เราแนะนำในที่นี้คือ (recv() และ tran() เพื่อรับจากพอร์ตฮาร์ดแวร์และการส่งสัญญาณไปยังพอร์ตซอฟต์แวร์ - ดังนั้นจึงเรียกใช้ด้วยพารามิเตอร์ ' hw ' หรือ ' sw ' ที่แสดงขึ้น

นอกจากนี้ เราได้เพิ่มการทดสอบกับตัวแปรส่วนกลางที่เรียกว่า newData นี่คือแฟล็กที่เราจะตั้งค่าภายในฟังก์ชัน " void recv(); " เมื่อได้รับข้อความ ตัวแปรนี้จะถูกตั้งค่าสถานะจาก false เป็น true เราทำเช่นนี้เพื่อที่เราจะส่งข้อความก็ต่อเมื่อได้รับข้อความ (flag ==true) ในบรรทัดที่ 134 และเมื่อเราส่งข้อความของเราแล้ว นั่นคือ 'งานเสร็จแล้ว' เราจึงล้างการตั้งค่าสถานะกลับเป็นเท็จอีกครั้งในบรรทัดที่ 137

อีกครั้งเราสามารถตรวจสอบการคอมไพล์ (D ถึง I) และคราวนี้เรามีข้อความแสดงข้อผิดพลาด 'ไม่ประกาศ' (แสดง) นี่กำลังบอกเราว่าเรายังไม่ได้ประกาศ recv(); การทำงาน. เราวางแผนที่จะดำเนินการนี้ในภายหลัง ดังนั้นสำหรับตอนนี้เพื่อให้เราได้รับคอมไพล์ใหม่ทั้งหมด เราจำเป็นต้องสร้างฟังก์ชันจำลองหรือตัวยึดตำแหน่ง ดังที่แสดงต่อไป

อีกครั้งเราสามารถตรวจสอบการคอมไพล์ (D ถึง I) และคราวนี้เรามีข้อความแสดงข้อผิดพลาด 'ไม่ได้ประกาศ' อีกข้อความสำหรับ tran(); การทำงาน. สิ่งนี้ต้องการการสร้างโครงที่คล้ายกัน อีกครั้งเราสามารถตรวจสอบการคอมไพล์ (D ถึง I) และคราวนี้เราจะพบว่ามันใช้งานได้อย่างสมบูรณ์แบบ จนถึงตอนนี้ดีมาก

ขั้นตอนที่ 9: เสร็จสิ้นลูปหลัก: A) การรับจาก USB, B) การรับจาก Slave Arduino

มีชิ้นสุดท้ายที่เราได้เพิ่มเข้าไปเพื่อจบส่วนนี้ซึ่งก็คือการเพิ่มโค้ดการดีบัก

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

ดังนั้นบรรทัดการดีบักเหล่านี้ [136-139 ที่แสดง] จะถูกเพิ่มเข้าไปถัดไปในลูปหลักและ แท้จริงแล้ว คุณสามารถทดสอบได้ในส่วนท้ายของมาสเตอร์โดยทำให้ตัวแปรดีบัก true และคอมไพล์ (I) แล้วถ้า คุณเชื่อมต่อ Arduino ขึ้น คุณสามารถอัปโหลด เปิด Serial Monitor และดูว่ามีอะไรกลับมาใน Serial Monitor ดังที่แสดงไว้ที่นี่ (คุณเห็นข้อความ "DEBUG MODE" เพิ่มหรือไม่)

ขั้นตอนที่ 10: การรับและจัดการข้อมูลใน Slave Arduino

รับจาก Slave Arduino

เพิ่มรหัสที่จำเป็นสำหรับช่องสัญญาณที่สองไปยังลูปหลัก ซอฟต์แวร์รับอนุกรมตามที่แสดง - บรรทัดที่ 149 ถึง 155

คุณเห็นไหมว่าโครงสร้างเป็นไปตามที่เราเขียนไว้ข้างต้นสำหรับกรณีมาสเตอร์อย่างหลวมๆ

นอกจากนี้ คุณจะเห็นว่าเราได้รับข้อผิดพลาดของคอมไพเลอร์ ฟังก์ชันอื่นที่ไม่ได้ประกาศ - คราวนี้ parseData(); - ดังนั้น เราต้องสร้าง stub สำหรับสิ่งนี้ด้วย ก่อนที่เราจะสามารถรันคอมไพล์การทดสอบที่ปราศจากข้อผิดพลาดได้

การจัดการข้อมูลใน Slave Arduino

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

และคุณควรพบว่าคราวนี้มันรวบรวมได้อย่างสมบูรณ์

ขั้นตอนที่ 11: เขียนฟังก์ชันรับ

ฟังก์ชัน Receive - void recv(char from){} - มีสองงานหลัก

1 เพื่อรับสตริงอักขระจากช่อง USB และ

2 เพื่อรับหนึ่งจากช่อง Arduino ไปยัง Arduino

ก่อนอื่นเราจะต้องใช้เพราะมันใช้ฮาร์ดแวร์ UART ในตัวของ Arduino และอย่างที่สองโดยใช้ไลบรารี Arduino มาตรฐาน: ซอฟต์แวร์ UART

เมื่อเราเริ่มเพิ่มโค้ดในฟังก์ชัน - เพื่อสร้างฟังก์ชันที่ทำบางสิ่ง แทนที่จะเป็นเพียง stub - เราต้องจำไว้ว่าให้ลบหรือแสดงความคิดเห็นใน stub ที่มันถูกแทนที่ มิฉะนั้น เราจะได้รับข้อผิดพลาดในการคอมไพล์: การกำหนด 'void lrec(char)'

ลองและรับข้อผิดพลาด จากนั้นลองวิธีใดวิธีหนึ่งที่แนะนำข้างต้นเพื่อกำจัดมัน

เริ่มต้นด้วยฟังก์ชันที่ดูเหมือนบรรทัดที่ 75 ถึง 88 สีเหลืองที่เราแสดงที่นี่

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

มาดูโค้ดที่เราเขียนไว้สำหรับฟังก์ชัน recv() กัน

มันค่อนข้างสะอาด คุณสามารถเห็นการใช้เงื่อนไข 'ถ้า' เพื่อสร้างฟังก์ชันสองส่วนที่กล่าวมาข้างต้น

รหัสภายในส่วน 'sw' และส่วน 'hw' อยู่ในรูปแบบเดียวกัน และฉันจะอธิบายไว้ที่นี่

คู่แรกของบรรทัดในแต่ละกรณีคือจุดเริ่มต้นของการวนรอบ หากคุณไม่คุ้นเคย คุณสามารถค้นหาได้ในไซต์ Arduino.cc/Reference สำหรับคำอธิบายและตัวอย่าง ที่นี่เรารอ 'ในขณะที่' ฟังก์ชัน 'ซีเรียล' ในตัวยังไม่ได้รับอักขระใด ๆ และเนื่องจากตัวแปร newData ถูกปิด (เช่น newData == เงื่อนไขเท็จเป็นจริง) ทันทีที่ตัวละคร - หรือมากกว่าหนึ่งตัว - ได้รับในขณะที่จะ 'ดรอปผ่าน' ไปยังบรรทัดที่สองในคู่นี้ จากนั้นจะเรียกใช้ recAstringChar(char); ฟังก์ชันเพื่อจัดการกับอักขระปัจจุบัน คู่บรรทัดนี้จะสลับกันในขณะที่ (หรือตราบเท่าที่) มีอักขระใด ๆ ที่ยังต้องได้รับ เมื่อพวกเขาทั้งหมดเสร็จสิ้นในขณะที่สถานะจะสิ้นสุดลงโดยอนุญาตให้ระดับถัดไปของ if หรือ else สิ้นสุดลงและอนุญาตให้ rec(char); ฟังก์ชั่นที่จะสิ้นสุด ดังนั้นขณะนี้ได้รับข้อความเต็มผึ้งแล้ว

ขั้นตอนที่ 12: เขียนฟังก์ชันย่อยการรับ - ตอนที่ 1

ตอนนี้เราต้องเขียนฟังก์ชันที่เรียกว่า recAstringChar(char);. คุณเห็นจากความคิดเห็นที่บรรทัดที่ 50 ที่ด้านบนนี้ว่าหน้าที่ของมันคือการอัปเดตบัฟเฟอร์สองตัวพร้อมสำเนาของข้อความซีเรียลที่เข้ามา [ปรากฏว่าในขณะที่ฉันกำลังพยายามทำให้ทั้งหมดนี้ทำงานได้ สิ่งหนึ่งที่ฉันได้เรียนรู้คือฉันต้องการบัฟเฟอร์ที่แตกต่างกันสองตัว - หรืออย่างน้อยนั่นเป็นวิธีที่ง่ายที่สุดในการแก้ปัญหาบางอย่าง ดังนั้นมันจึงกลายเป็นที่ต้องการ 2 บัฟเฟอร์ ดังนั้น ฉันเพิ่งสร้างมันขึ้นมา] ฉันเรียกบัฟเฟอร์หนึ่งอัน: receivedData และอีกอันหนึ่ง: receiveChars

บัฟเฟอร์เป็นตัวแปรร่วม ดังนั้นจึงมีการประกาศที่ระดับโมดูล ดูบรรทัดที่ 9 และ 10 ของแท็บทั่วไป มีตัวแปรอื่น ๆ ที่ประกาศไว้ภายในฟังก์ชันนี้ซึ่งมีขอบเขตเฉพาะที่แสดงอยู่ในบรรทัดที่ 51-54 ที่นี่ นี่ไม่ใช่สถานที่ที่จะอธิบายความแตกต่างระหว่างคนสากลและคนในท้องถิ่น แต่มีข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้ใน https://www.arduino.cc/glossary/en/ ภายใต้ Local and Global

คุณยังสามารถค้นหาข้อมูลทั้งหมดเกี่ยวกับประเภทข้อมูลและตัวแก้ไขประเภท: static, boolean, byte, const, char ใน https://www.arduino.cc/reference/en/#variables ที่แสดงไว้ที่นี่

โฟลว์โปรแกรมหลักในฟังก์ชันนี้ควบคุมโดย if ที่บรรทัด 56 ที่นี่ และส่วนอื่นๆ ที่สอดคล้องกันที่บรรทัด 74 สิ่งนี้เกี่ยวข้องกับสองสถานการณ์

a) [จากบรรทัดที่ 74 บน] เมื่อข้อความที่ได้รับเริ่มต้นขึ้น สิ่งนี้เกิดขึ้นเมื่อพบ startMarker - สิ่งนี้ถูกกำหนดให้เป็นอักขระ ' < ' ซึ่งเป็นสาเหตุที่เมื่อใดก็ตามที่เราทดสอบแบบร่าง เรามักจะเริ่มสตริงของเราด้วยอักขระนั้น หากเราไม่ดำเนินการ จะไม่มีการประมวลผลใดๆ ว่าได้รับ ข้อมูลทั้งหมดจะถูกละเว้น เหมือนกับว่าเรากำลังพิมพ์เรื่องไร้สาระที่พรอมต์แป้นพิมพ์ ' Serial Monitor '

b) [บรรทัดที่ 56 ถึง 73] ซึ่งรับอักขระอื่นๆ ทั้งหมด ไม่ว่าจะเป็นอะไรก็ตาม แต่จะจัดการกับอักขระหลังจากเริ่มต้นที่ถูกต้องเท่านั้น (ได้รับ '>' ดังใน a) ด้านบน)

ในบรรทัดเหล่านี้ (จาก 74 ถึง 78) เราใส่ที่ได้รับ < ลงในบัฟเฟอร์ตัวใดตัวหนึ่ง (receivedData[0]) แต่ไม่ได้อยู่ในอีกอันหนึ่ง เราปรับตัวชี้บัฟเฟอร์ (ตัวแปร: อักขระ ndx) ให้ชี้ไปที่ตำแหน่งบัฟเฟอร์สำรองถัดไป (receivedData[1]) โดยใช้คำสั่ง post-increment (++) ในบรรทัด ndx++; และเราตั้งค่าสถานะกำลังดำเนินการเป็นจริง

การไหลของโปรแกรมในส่วนนี้ของฟังก์ชันถูกควบคุมโดย if ที่บรรทัดที่ 57 ที่นี่ และส่วนอื่นๆ ที่สอดคล้องกันที่บรรทัด 65 ซึ่งเกี่ยวข้องกับสองสถานการณ์

a) [จากบรรทัดที่ 65 บน] เมื่อข้อความที่ได้รับสิ้นสุดลง สิ่งนี้เกิดขึ้นเมื่อพบ endMarker - กำหนดเป็น > ซึ่งเป็นสาเหตุที่เมื่อใดก็ตามที่เราทดสอบร่างของเรา เรามักจะจบสตริงด้วยอักขระนั้น สิ่งหนึ่งที่เกิดขึ้นเมื่อรับอักขระสิ้นสุดคือ global flag (ตัวแปรทางเทคนิค) newData ถูกตั้งค่า true เช่นเดียวกับที่ฟังก์ชันสิ้นสุด เพื่อให้ฟังก์ชันที่เรียกใช้ฟังก์ชันย่อยของเรา (ฟังก์ชันการเรียก: recv(char);) สามารถ 'รู้' ว่าได้รับข้อมูลใหม่ที่ถูกต้องครบถ้วนแล้ว

b) [บรรทัด 57 ถึง 64] ซึ่งรับอักขระอื่น ๆ ทั้งหมดไม่ว่าจะเป็นอะไร มันแค่จอดเรียงกันอย่างเป็นระเบียบในบัฟเฟอร์ทั้งสอง

ขั้นตอนที่ 13: เขียนฟังก์ชันย่อยการรับ - ตอนที่ 2

อาจช่วยยกตัวอย่างว่าบัฟเฟอร์ 2 ตัวมีลักษณะอย่างไรเมื่อบรรจุแล้ว หากเราต้องป้อน บัฟเฟอร์จะมีอักขระที่แสดงอยู่ในนั้น:

ตอนนี้คุณจะเห็นว่าเรามีบัฟเฟอร์หนึ่งตัวซึ่งเป็นอักขระเดียวกับที่เราพิมพ์ครั้งแรก และบัฟเฟอร์หนึ่งตัวซึ่งมีเพียงสองค่าและเครื่องหมายจุลภาคคั่น ตอนนี้เรามีโค้ดบางตัวที่สามารถรับอักขระที่เราพิมพ์บนแป้นพิมพ์ Serial Monitor ได้ เราสามารถย้ายจาก CDIO เฟส I เป็น O ได้ โดยพิมพ์สตริงลงไปแล้วดูว่าเกิดอะไรขึ้น อัปโหลดรหัสไปยัง Master Arduino เปิด Serial Monitor แล้วลองพิมพ์สิ่งที่ถูกต้องเช่น Enter คุณได้รับเสียงสะท้อนบนหน้าจอ Serial Monitor เหมือนกับที่แสดงที่นี่หรือไม่?

ขั้นตอนที่ 14: เขียนฟังก์ชันการส่งและแยกวิเคราะห์

ครั้งแรกสำหรับการส่งสัญญาณ

ตอนนี้เราได้รับสตริงแล้ว เราสามารถเขียนฟังก์ชันส่ง: tran(char); เพื่อแทนที่ต้นขั้ว ซึ่งจะทำให้เราสามารถส่งสตริงจาก Master ไปยัง Slave Arduino

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

ป้อนฟังก์ชันนี้ตามที่แสดงในบรรทัดที่ 117 ถึง 133 ตามที่คุณจะทราบ ฟังก์ชันนี้มีสองส่วน ส่วนหนึ่งสำหรับส่งไปยังช่อง USB (ฮาร์ดแวร์ UART) และอีกส่วนเพื่อส่งไปยัง Arduino (ซอฟต์แวร์ UART) อีกส่วน ซึ่งควรรวบรวมข้อผิดพลาด - ฟรี และคุณสามารถอัปโหลดภาพร่างได้ทันทีและดูว่าเกิดอะไรขึ้น ครั้งนี้จะส่ง. คุณได้รับผลลัพธ์ที่แสดง?

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

ขั้นตอนที่ 15: เขียนฟังก์ชันการส่งและแยกวิเคราะห์

จากนั้นสำหรับ Parse

นี่คือโค้ดบางส่วนที่แยกวิเคราะห์สตริงที่ได้รับเพื่อดึงสตริงที่เป็นตัวเลขบางส่วนและแปลงเป็นค่าจำนวนเต็ม มันเป็นโมฆะ parseData(); หน้าที่ของลูปหลัก

แทนที่ต้นขั้ว parse ด้วยรหัสที่แสดงในบรรทัดที่ 98 - 113 อัปโหลดแล้วมาดูกันว่าปัญหาที่เรามีกับค่าจำนวนเต็ม 2 ค่าได้รับการแก้ไขแล้วหรือไม่ มาลองกัน.

ใช่ มันใช้งานได้ดังที่แสดง จำนวนเต็มที่พบคือ 49 และ 98

ขั้นตอนที่ 16: รอบชิงชนะเลิศ

ข้อมูลนี้ได้เปลี่ยนจาก PC ผ่าน Master ผ่าน Slave และย้อนกลับผ่าน Master อีกครั้งไปยัง PC อีกครั้ง ด้วยเวอร์ชันที่เสร็จสิ้นแล้วของ Common ที่อัปโหลดทั้งใน Master และ Slave และเมื่อปิดโหมดแก้ไขข้อบกพร่องแล้ว เราจะเห็นข้อมูลที่ได้รับอย่างถูกต้องที่ปลายทั้งสองด้านดังที่แสดงไว้ที่นี่