Arduino แบบกำหนดเองเพื่อให้ปุ่มพวงมาลัย CAN กับเครื่องเสียงรถยนต์ใหม่: 9 ขั้นตอน (พร้อมรูปภาพ)

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

ฉันตัดสินใจเปลี่ยนสเตอริโอติดรถยนต์เดิมในวอลโว่ V70 -02 ด้วยสเตอริโอใหม่ ดังนั้นฉันจึงสามารถเพลิดเพลินกับสิ่งต่างๆ เช่น mp3 บลูทูธ และแฮนด์ฟรี

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

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

คำแนะนำนี้สามารถนำไปใช้ (พร้อมการดัดแปลงบางอย่าง) กับรถยนต์ที่ปุ่มบนพวงมาลัยสื่อสารผ่าน CAN บัส

ขั้นตอนที่ 1: ค้นหาวิธีส่งคำสั่งไปยังสเตอริโอ

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

รีโมตสำหรับสเตอริโอใหม่ของฉัน (Kenwood) ประกอบด้วยสายเส้นเดียว และฉันไม่พบข้อมูลใดๆ เกี่ยวกับวิธีการทำงาน อย่างไรก็ตาม มีแจ็ค 3.5 มม. สำหรับอินพุตระยะไกลด้วย ฉันก็ไม่พบอะไรเกี่ยวกับเรื่องนั้นเช่นกัน แต่มีข้อมูลบางอย่างเกี่ยวกับแจ็ค 3.5 มม. สำหรับแบรนด์อื่น ๆ ที่แนะนำให้ระบุคำสั่งที่แตกต่างกันโดยใช้ความต้านทานเฉพาะระหว่างส่วนปลายและปลอก (และเป็นทางเลือกระหว่างวงแหวนและปลอก) เช่น. https://forum.arduino.cc/index.php?topic=230068.0. ดังนั้นฉันจึงตัดสินใจลองทำดู โดยติดตั้งเขียงหั่นขนม ตัวต้านทานจำนวนหนึ่ง และปลั๊ก 3.5 มม. ที่เสียบเข้ากับสเตอริโอและเชื่อมต่อกับเขียงหั่นขนม ไม่พบสิ่งใดในตอนแรก แต่สเตอริโอมีเมนู "โหมดการเรียนรู้" และสามารถตั้งค่าคำสั่งได้สำเร็จในขณะที่ใช้ความต้านทานต่างๆ ความสำเร็จ!

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

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

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

ขั้นตอนที่ 2: ค้นหาตำแหน่งที่จะเชื่อมต่อกับ CAN Bus

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

ขั้นตอนที่ 3: วิศวกรรมย้อนกลับของ CAN Messages

เว้นแต่ Google จะสามารถบอกคุณได้ว่าข้อความ CAN ใดที่คุณควรฟัง คุณจะต้องเชื่อมต่อกับบัส CAN และทำวิศวกรรมย้อนกลับ ฉันใช้ Arduino Uno และ CAN shield (คุณไม่จำเป็นต้องมีชีลด์ CAN จริงๆ เพราะคุณจะเห็นในภายหลัง คุณสามารถใช้ส่วนประกอบราคาถูกบนเขียงหั่นขนมแทนได้)

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

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

ก่อนที่คุณจะเริ่มเขียนโปรแกรม คุณต้องติดตั้งไลบรารี CAN_BUS_Shield

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

ติดตั้ง()

{ การเชื่อมต่ออนุกรม init init ไลบรารี CAN } ลูป () { หากได้รับข้อความ CAN { อ่านรายการบันทึกรูปแบบข้อความ CAN เขียนรายการบันทึกลงในซีเรียล } }

คำแนะนำ:

คุณจะใช้อินสแตนซ์ของคลาส MCP_CAN เพื่อเข้าถึงฟังก์ชันไลบรารี CAN:

MCP_CAN m_can;

เริ่มต้นสามารถ:

ในขณะที่ (m_can.begin() != CAN_OK)

{ ล่าช้า (1,000); }

ตรวจสอบและอ่านข้อความ CAN:

ในขณะที่(m_can.checkReceive() == CAN_MSGAVAIL)

{ // รับ CAN id ความยาวข้อความ และข้อมูลข้อความ m_can.readMsgBufID(&m_canId, &m_msgLen, m_msgBuf); // ทำอะไรกับข้อมูลข้อความที่นี่ }

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

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

จากนั้นสำหรับแต่ละปุ่ม ให้เริ่มการบันทึก กดปุ่ม และหยุดการบันทึก

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

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

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

หากคุณมี Volvo V70 -02 นี่คือสิ่งที่คุณต้องการ:

• รหัสข้อความ: 0x0400066Byte0: 0x00, 0x40, 0x80 หรือ 0xc0 (ไม่สนใจ)
• Byte1: 0x00 (ไม่สนใจ)
• Byte2: 0x00 (ไม่สนใจ)
• Byte3: 0x00-0x07 (ไม่สนใจ)
• Byte4: 0x1f (ไม่สนใจ)
• Byte5: 0x40 (ไม่สนใจ)
• Byte6: 0x40 (ไม่สนใจ)
• Byte7: ตัวระบุปุ่ม: 0x77 = เพิ่มระดับเสียง, 0x7b = ลดระดับเสียง, 0x7d = แทร็กถัดไป, 0x7e = แทร็กก่อนหน้า

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

ขั้นตอนที่ 4: ต้นแบบฮาร์ดแวร์

ฮาร์ดแวร์ของคุณต้องสามารถ:

1. ระบุคำสั่งที่ได้รับบนบัส CAN
2. ส่งคำสั่งในรูปแบบอื่นไปยังสเตอริโอ

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

• ค่าใช้จ่ายของโล่ CAN
• ขนาด
• แหล่งจ่ายไฟ Arduino จะไม่พอใจหากเชื่อมต่อโดยตรงกับรถยนต์ของคุณ 12V (อาจใช้งานได้ แต่อายุการใช้งานอาจสั้นลง)

ดังนั้นฉันจึงใช้สิ่งต่อไปนี้แทน:

• Atmega 328 "สมองของ Arduino" (มีบางรุ่นให้เลือกรุ่นที่เท่ากับ Arduino Uno คุณสามารถซื้อได้ทั้งแบบมีหรือไม่มี Arduino boot loader)
• คริสตัล 16 MHz + ตัวเก็บประจุสำหรับสัญญาณนาฬิกา
• MCP2551 ตัวรับส่งสัญญาณ CAN
• MCP2515 ตัวควบคุม CAN
• TSR1-2450 แปลง 6.5-36V เป็น 5V (ไม่ใช้ในโปรโตไทป์เพราะซอฟต์แวร์จะไม่สนใจพาวเวอร์ซัพพลาย)
• สวิตช์ CD4066B ที่จะใช้เมื่อส่งคำสั่งไปยังสเตอริโอ
• ตัวต้านทานสองสามตัว (ค่าสามารถพบได้ในแผนผังของ Eagle ในขั้นตอนต่อมา)

ข้อดีของการกำหนดค่านี้คือสามารถทำงานร่วมกับ Arduino และไลบรารี CAN shield ได้อย่างสมบูรณ์

หากคุณต้องการจัดการปุ่มมากกว่าสี่ปุ่ม คุณอาจต้องพิจารณาใช้อย่างอื่นที่ไม่ใช่ CD4066B CD4066B สามารถอธิบายได้ว่าเป็นสวิตช์สี่ตัวในหนึ่งตัว โดยแต่ละตัวควบคุมโดยหมุด Atmegas GPIO ตัวใดตัวหนึ่ง สวิตช์แต่ละตัวจะมีตัวต้านทานเชื่อมต่ออยู่ ซึ่งสามารถใช้ควบคุมความต้านทานที่ใช้เป็นอินพุตของสเตอริโอได้ จึงสามารถใช้เพื่อส่งคำสั่งต่างๆ สี่คำสั่งได้อย่างง่ายดาย หากรวมกันแล้วสามารถรับค่าความต้านทานเพิ่มเติมได้ นี่คือที่มาของข้อผิดพลาดที่ฉันพูดถึงก่อนหน้านี้ ฉันมีปุ่มสี่ปุ่ม แต่ฉันวางแผนที่จะใช้ปุ่มสองปุ่มนี้โดยกดแบบยาวและสั้นเพื่อให้คำสั่งที่แตกต่างกันหกคำสั่ง แต่ในที่สุดฉันก็พบว่าฉันไม่สามารถหาตัวต้านทานแบบผสมที่จะให้ชุดค่าผสมที่ใช้งานได้หกชุด อาจเป็นไปได้ที่จะเชื่อมต่อสัญญาณแอนะล็อกเอาท์กับสเตอริโอ (ปลาย 3.5 มม.) แทน (โปรดทราบว่า Atmega ไม่มีพินแบบอะนาล็อกที่แท้จริง ดังนั้นจำเป็นต้องมีฮาร์ดแวร์เพิ่มเติม)

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

ต้นแบบจะแสดงโดยเขียงหั่นขนมด้านล่างในภาพ สำหรับแหล่งจ่ายไฟ การเขียนโปรแกรม และการบันทึกแบบอนุกรม จะต่อเข้ากับ Arduino Uno ซึ่งถอดชิป Atmega ออก

เขียงหั่นขนมด้านบนเป็นเครื่องจำลองรถยนต์ + สเตอริโอที่จะใช้สำหรับการทดสอบเบื้องต้นของต้นแบบ

ต้นแบบ + ตัวจำลองมีจุดมุ่งหมายเพื่อทำงานดังนี้:

• กดปุ่มสวิตช์ปุ่มใดปุ่มหนึ่งบนบอร์ดจำลอง (นั่นคือปุ่มบนพวงมาลัยของคุณ)
• เมื่อโปรแกรมจำลองตรวจพบการกดปุ่ม โปรแกรมจะส่งข้อความ CAN ที่เกี่ยวข้องทุก ๆ 70 ms ตราบใดที่มีการกดปุ่ม (เนื่องจากบันทึกที่ฉันใช้ไปก่อนหน้านี้ระบุว่ามันทำงานอย่างไรในรถของฉัน) นอกจากนี้ยังจะส่งข้อความ CAN "ขยะ" จำนวนมากเพื่อจำลองการจราจรอื่นๆ บนรถบัส
• ข้อความ CAN ถูกส่งบนบัส CAN
• ต้นแบบได้รับข้อความ CAN
• MCP2515 จะแสดงข้อความที่ไม่เกี่ยวข้องทั้งหมดตามรหัสข้อความ
• เมื่อ MCP2515 ได้รับข้อความที่ควรได้รับการจัดการ แสดงว่ามีข้อความที่จัดคิวไว้
• Atmega จะอ่านข้อความและตัดสินใจว่าปุ่มใดที่ควรพิจารณาว่าใช้งานได้
• Atmega จะติดตามเมื่อได้รับข้อความล่าสุด หลังจากช่วงเวลาหนึ่ง ปุ่มจะถือว่าถูกปล่อย (ข้อความ CAN บ่งชี้ว่าปุ่มไม่ทำงานเท่านั้น ไม่ใช่ว่าถูกผลักหรือปล่อย)
• หากถือว่าปุ่มทำงานอยู่ สวิตช์อย่างน้อยหนึ่งตัวใน CD4066B จะเปิดใช้งาน
• เครื่องจำลอง (ตอนนี้ทำหน้าที่เป็นสเตอริโอของคุณ) จะตรวจพบว่ามีการใช้ความต้านทานระหว่างปลายและปลอกหุ้ม (ปลายเชื่อมต่อกับ 3.3V และผ่านตัวต้านทานไปยังพินอินพุตแบบอะนาล็อก เมื่อไม่มีคำสั่งใดทำงาน พินนี้จะอ่าน 3.3V เมื่อคำสั่งทำงาน ค่าจะลดลงและระบุคำสั่ง
• ในขณะที่คำสั่งทำงานอยู่ ไฟ LED ที่เกี่ยวข้องก็จะเปิดใช้งานด้วย (มีไฟ LED หกดวงเพราะฉันวางแผนที่จะใช้การกดแบบยาว / สั้น ๆ สำหรับปุ่มสองปุ่มของฉัน)

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับฮาร์ดแวร์ต้นแบบ โปรดดู Eagle schematics ในขั้นตอนถัดไป

รายละเอียดเพิ่มเติมเกี่ยวกับฮาร์ดแวร์บอร์ดจำลอง:

• คริสตัล 16 MHz
• ตัวเก็บประจุ 22 pF
• ควรเลือกตัวต้านทาน LED ตามคุณสมบัติของ LED
• ตัวต้านทานเชื่อมต่อกับ A7 และ 3.3V เลือกเช่น 2kOhm (ไม่สำคัญ)
• ตัวต้านทานที่เชื่อมต่อกับ MCP2551 และ MCP2515 เป็นแบบดึงขึ้น / เลื่อนลง เลือกเช่น 10 กิโลโอห์ม

(หรือคุณสามารถใช้โล่ CAN สำหรับ "ส่วน CAN" ของเครื่องจำลองได้หากต้องการ)

เป็นสิ่งสำคัญที่คุณจะต้องรู้ว่าหมุด Atmega ถูกจับคู่กับพิน Arduino อย่างไรเมื่อคุณออกแบบฮาร์ดแวร์

(อย่าต่อไฟ LED ใดๆ กับ CD 4066B โดยตรงเลย มันทำได้แค่กระแสไฟต่ำเท่านั้น ผมลองแล้วเมื่อผมทดสอบเอาท์พุตแล้วชิปก็ไร้ประโยชน์ ข้อดีคือผมซื้อมาสองสามตัวเพราะพวกมัน ถูกมาก)

ขั้นตอนที่ 5: การเขียนโปรแกรมฟิวส์

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

(หากต้องการ คุณสามารถข้ามขั้นตอนนี้และเพิ่มฮาร์ดแวร์นาฬิกาพิเศษแทนได้)

อย่างไรก็ตาม เราสามารถใช้สิ่งที่เรียกว่า "การเขียนโปรแกรมฟิวส์" เพื่อเปิดใช้งานสัญญาณนาฬิกาออกบนหมุด GPIO ตัวใดตัวหนึ่งได้

ก่อนอื่น คุณจะต้องค้นหาไฟล์ชื่อ "boards.txt" ที่ใช้โดย Arduino IDE ของคุณ คุณจะต้องคัดลอกรายการสำหรับ Arduino Uno ตั้งชื่อใหม่และเปลี่ยนค่าสำหรับ low_fuses

กระดานใหม่ของฉันมีลักษณะดังนี้:

####################################################### ############ # ตาม Arduino Uno # การเปลี่ยนแปลง: # low_fuses เปลี่ยนจาก 0xff เป็น 0xbf เพื่อเปิดใช้งานนาฬิกา 16 MHz # ออกบน Atmega PB0/pin 14 = Arduino D8

clkuno.name=นาฬิกา (Arduino Uno)

clkuno.upload.protocol=arduino clkuno.upload.maximum_size=32256 clkuno.upload.speed=115200 clkuno.bootloader.low_fuses=0xbf clkuno.bootloader.high_fuses=0xde clkuno.bootloader.extended_fusesclkuno.bootloader.high_fuses=0xde clkuno.bootloader.extended_fusesclkuno.bootloader.bootloader.file=optiboot_atmega328.hex clkuno.bootloader.unlock_bits=0xff clkuno.bootloader.lock_bits=0xcf clkuno.build.mcu=atmega328p clkuno.build.f_cpu=16000000L clkuno.build.core=arduino.cludian

##############################################################

โปรดทราบว่านาฬิกาเอาต์เปิดใช้งานโดยการตั้งค่าบิตควบคุมเป็น 0

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

หลังจากที่คุณทำเสร็จแล้ว อย่าลืมเลือกประเภทบอร์ดใหม่ ไม่ใช่ Arduino Uno เมื่อคุณอัปโหลดโปรแกรมไปยัง Atmega

ขั้นตอนที่ 6: ซอฟต์แวร์

ถึงเวลาทำให้ฮาร์ดแวร์ใบ้ฉลาดด้วยการเพิ่มซอฟต์แวร์

นี่คือรหัสหลอกสำหรับต้นแบบ:

LastReceivedTime = 0

lastReceivedCmd = none cmdTimeout = 100 setup () { เปิดใช้งาน watchdog กำหนดค่าพิน D4-D7 เป็นพินเอาต์พุตในการตั้งค่า CAN filter ได้ } ลูป () { รีเซ็ต watchdog ถ้า (ได้รับข้อความ CAN) { สำหรับคำสั่งแต่ละปุ่ม { if CAN message เป็นของ คำสั่งปุ่ม { lastReceivedTime = ตอนนี้ lastReceivedCmd = cmd } } } if now > lastReceivedTime + cmdTimeout { lastReceivedCmd = none } สำหรับแต่ละคำสั่งปุ่ม { if lastReceivedCmd เป็นคำสั่งของปุ่ม { set command pin output = on } อื่น ๆ { set command pin output = off } } }

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

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

การตั้งค่าเป็นโมฆะ ()

{ // อนุญาตสูงสุด 250 ms สำหรับลูป wdt_enable (WDTO_250MS); // สิ่งเริ่มต้นอื่น ๆ } วงเป็นโมฆะ () { wdt_reset (); // ทำสิ่งต่างๆ }

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

หน้ากากยาวที่ไม่ได้ลงนาม = 0x1fffffff; // รวมส่วนหัวทั้งหมด 29 บิตในมาสก์

filterId ยาวที่ไม่ได้ลงชื่อ = 0x0400066; // เราสนใจเฉพาะรหัสข้อความ CAN นี้เท่านั้น m_can.init_Mask(0, CAN_EXTID, mask); // มาสก์ 0 ใช้กับฟิลเตอร์ 0-1 m_can.init_Mask(1, CAN_EXTID, มาสก์); // มาสก์ 1 ใช้กับตัวกรอง 2-5 m_can.init_Filt(0, CAN_EXTID, filterId); m_can.init_Filt(1, CAN_EXTID, filterId); m_can.init_Filt(2, CAN_EXTID, filterId); m_can.init_Filt(3, CAN_EXTID, filterId); m_can.init_Filt(4, CAN_EXTID, filterId); m_can.init_Filt(5, CAN_EXTID, filterId);

ตรวจสอบรหัสไลบรารี CAN และเอกสารควบคุม CAN สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับวิธีการตั้งค่าตัวกรอง + มาสก์

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

นั่นคือซอฟต์แวร์ต้นแบบโดยสรุป แต่เราต้องการรหัสสำหรับบอร์ดจำลองเช่นกัน:

LastSentTime = 0

minDelayTime = การตั้งค่า 70 () { กำหนดค่าพิน A0-A5 เป็นพินเอาต์พุต กำหนดค่าพิน D4-D7 เป็นพินอินพุตพร้อมพูลอัปภายใน init CAN } loop () { send "junk" can msg set activeButton = none สำหรับแต่ละปุ่ม { ถ้ากดปุ่ม { set activeButton = button } } if activeButton != none { if now > lastSentTime + minDelayTime { send button command can message } set lastSentTime = now } inval = read pin A7 foreach (cmd) { if (min < inval < max) { led on } else { led off } } รอ 1 ms }

การดำเนินการนี้จะส่งข้อความ CAN "ขยะ" อย่างต่อเนื่องทุกๆ มิลลิวินาที และในขณะที่มีการกดปุ่มคำสั่งที่เกี่ยวข้องทุกๆ 70 มิลลิวินาที

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

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

หากคุณต้องการตรวจสอบโปรแกรมของฉัน สามารถดาวน์โหลดได้ที่นี่:

• โปรแกรมบันทึกข้อความ CAN
• โปรแกรมสำหรับบอร์ดจำลอง
• โปรแกรมสำหรับต้นแบบ / บอร์ดสุดท้าย

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

ขั้นตอนที่ 7: ฮาร์ดแวร์ขั้นสุดท้าย

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

คุณมีสามตัวเลือกที่นี่:

• รวดเร็วและสกปรก - ประสานสิ่งของเข้าด้วยกันบนบอร์ดต้นแบบ PCB
• ฮาร์ดคอร์ DIY - แกะสลัก PCB ของคุณเอง
• วิธีที่ขี้เกียจ - สั่งซื้อ PCB มืออาชีพเพื่อประสานส่วนประกอบต่างๆ

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

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

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

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

แล้วสั่งได้ที่ https://www.seeedstudio.com/fusion_pcb.html. ทำตามคำแนะนำสำหรับวิธีสร้างไฟล์ Gerber จากการออกแบบของคุณ คุณยังสามารถดูตัวอย่างผลลัพธ์เพื่อให้แน่ใจว่าใช้ได้

(ในที่สุดฉันต้องเลือกตัวต้านทานอื่นสำหรับ R4-R7 มากกว่าที่แสดงในภาพแผนผัง แต่ฉันใช้ 2k, 4.7k, 6.8k และ 14.7k แทน)

และจำไว้ว่า - อย่าสับสนระหว่างหมายเลขพิน Atmega กับหมายเลขพิน Arduino!

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

ขั้นตอนที่ 8: การติดตั้งในรถยนต์

มาถึงส่วนที่สนุกที่สุดแล้ว - ติดตั้งในรถของคุณแล้วเริ่มใช้งาน! (หลังจากที่คุณได้ทำ/ซื้อเคสให้แล้ว)

หากคุณได้ทดสอบต้นแบบในรถของคุณอย่างครบถ้วนแล้ว ทุกอย่างก็ควรจะทำงานได้อย่างสมบูรณ์

(ดังที่ฉันได้กล่าวไว้ก่อนหน้านี้ฉันไม่ได้ดังนั้นฉันต้องเปลี่ยนตัวต้านทานบางตัวและทำการเปลี่ยนแปลงในโปรแกรมของฉัน)

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

ในที่สุดปุ่มของฉันก็กลับมาใช้งานได้อีกครั้ง! ฉันจะอยู่รอดได้สองเดือนโดยไม่มีพวกเขาได้อย่างไร

ขั้นตอนที่ 9: การปรับปรุงในอนาคต

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

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