नई कार स्टीरियो के साथ CAN स्टीयरिंग व्हील बटन रखने के लिए कस्टम Arduino: 9 चरण (चित्रों के साथ)

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:22

मैंने अपने वोल्वो V70 -02 में मूल कार स्टीरियो को एक नए स्टीरियो के साथ बदलने का फैसला किया ताकि मैं एमपी 3, ब्लूटूथ और हैंड्सफ्री जैसी चीजों का आनंद ले सकूं।

मेरी कार में स्टीरियो के लिए कुछ स्टीयरिंग व्हील नियंत्रण हैं जिनका मैं अभी भी उपयोग करने में सक्षम होना चाहूंगा। मुझे उम्मीद नहीं थी कि यह कोई समस्या होगी क्योंकि बाजार में ऐसे कई एडेप्टर हैं जो मेरी कार के अनुकूल होने चाहिए। हालाँकि मुझे जल्द ही पता चला कि वे नहीं थे! (ऐसा लगता है कि V70 के लिए एडेप्टर में थोड़ा अलग CAN प्रोटोकॉल के कारण -02 कारों में समस्या हो सकती है।)

तो फिर क्या करें? पुराना स्टीरियो रखें? गैर-काम करने वाले बटनों के साथ जीवन जिएं? बिलकूल नही! अगर बाजार में कोई काम करने वाला एडॉप्टर नहीं है तो हमें एक बनाना होगा!

यह निर्देश उन कारों पर (कुछ अनुकूलन के साथ) लागू किया जा सकता है जहां स्टीयरिंग व्हील बटन CAN बस पर संचार करते हैं।

चरण 1: स्टीरियो को कमांड भेजने का तरीका जानें

पहली चीज जो आपको करनी चाहिए वह यह पता लगाना है कि स्टीरियो किस प्रकार के रिमोट इनपुट की अपेक्षा करता है। आमतौर पर निर्माता आपको यह नहीं बताएंगे और संभवत: आपके पास रिवर्स इंजीनियरिंग के लिए काम करने वाले रिमोट कंट्रोल तक पहुंच नहीं है।

मेरे नए स्टीरियो (केनवुड) के लिए रिमोट में एक ही तार होता है और मुझे इस बारे में कोई जानकारी नहीं मिल पाई है कि यह कैसे काम करता है। हालाँकि इसमें रिमोट इनपुट के लिए 3.5 मिमी जैक भी है। मुझे इस बारे में भी कुछ पता नहीं चला। लेकिन अन्य ब्रांडों के लिए 3.5 मिमी जैक के बारे में कुछ जानकारी है कि टिप और आस्तीन (और वैकल्पिक रूप से अंगूठी और आस्तीन के बीच) के बीच एक विशिष्ट प्रतिरोध लागू करके विभिन्न आदेशों की पहचान की जाती है। उदा. https://forum.arduino.cc/index.php?topic=230068.0। इसलिए मैंने इसे एक कोशिश देने का फैसला किया, एक ब्रेडबोर्ड से लैस, प्रतिरोधों का एक गुच्छा और एक 3.5 मिमी प्लग स्टीरियो में प्लग किया गया और ब्रेडबोर्ड से जुड़ा। पहले कुछ भी नहीं पहचाना गया था, लेकिन स्टीरियो में "लर्निंग मोड" मेनू है और वहां विभिन्न प्रतिरोधों को लागू करते हुए कमांड को सफलतापूर्वक सेट किया जा सकता है। सफलता!

हालाँकि मुझे बाद में पता चला कि मैंने यहाँ एक गलती की है: स्टीरियो को सीखने वाले सभी कमांड वास्तव में काम नहीं करेंगे। उदा. 30 kOhm लर्निंग मोड में पाया गया था लेकिन बाद में काम नहीं किया और कुछ कमांड के लिए मैंने प्रतिरोध अंतर इतना छोटा सेट किया कि बाद में गलत कमांड चालू हो गया।

इसलिए मैं अनुशंसा करता हूं कि आप उन सभी दूरस्थ आदेशों के लिए प्रतिरोधों और स्विच बटनों के साथ एक ब्रेडबोर्ड का उपयोग करें जिन्हें आप संभालना चाहते हैं और वास्तव में परीक्षण करते हैं कि वे सभी काम करेंगे।

यदि आपकी कार स्टीरियो उसी तरह इनपुट प्राप्त नहीं कर सकती है तो आपको यह पता लगाना होगा कि यह कैसे काम करता है ताकि आप इस समाधान को अनुकूलित कर सकें। यदि आप बिल्कुल नहीं समझ सकते हैं तो आपको समस्या है।

चरण 2: पता लगाएँ कि CAN बस से कहाँ जुड़ना है

CAN बस से जुड़ने के लिए आपको एक अच्छी जगह तलाशनी होगी। चूंकि आप एक पुराने स्टीरियो को बदल रहे हैं जो CAN पर संचार करता है, आपको स्टीरियो के पीछे उसे खोजने में सक्षम होना चाहिए। CAN बस में मुड़ तारों (CAN-L और CAN_H) की एक जोड़ी होती है। सुनिश्चित करने के लिए अपनी कार के लिए वायरिंग आरेख देखें।

चरण 3: CAN संदेशों की रिवर्स इंजीनियरिंग

जब तक Google आपको यह नहीं बता सकता कि आपको कौन से CAN संदेश सुनने चाहिए, तब तक आपको CAN बस से कनेक्ट करने और कुछ रिवर्स इंजीनियरिंग करने की आवश्यकता होगी। मैंने एक Arduino Uno और एक CAN शील्ड का उपयोग किया। (आपको वास्तव में CAN शील्ड की आवश्यकता नहीं है, जैसा कि आप बाद में देखेंगे कि आप इसके बजाय ब्रेडबोर्ड पर कुछ सस्ते घटकों का उपयोग कर सकते हैं।)

अपनी कार से कनेक्ट करते समय आपको किस बॉड दर का उपयोग करना चाहिए, यह जानने के लिए Google से परामर्श लें। (आमतौर पर आप पाएंगे कि हाई स्पीड और लो स्पीड CAN नेट है। आप लो स्पीड नेट से कनेक्ट कर रहे हैं।)

सीरियल इंटरफ़ेस पर सभी CAN संदेशों को लॉग करने के लिए आपको Arduino को प्रोग्राम करने की भी आवश्यकता होगी ताकि आप उन्हें अपने कंप्यूटर पर एक लॉग फ़ाइल में सहेज सकें। मानक Arduino IDE डेटा को लॉग फ़ाइल में नहीं सहेजेगा, लेकिन आप इसका उपयोग कर सकते हैं उदा। इसके बजाय पोटीन।

इससे पहले कि आप अपना प्रोग्राम लिखना शुरू करें, आपको CAN_BUS_Shield लाइब्रेरी स्थापित करनी होगी।

आपके प्रोग्राम के साथ आरंभ करने में आपकी सहायता के लिए यहां कुछ छद्म कोड दिए गए हैं:

सेट अप()

{इनिट सीरियल कनेक्शन इनिट कैन लाइब्रेरी} लूप () {यदि संदेश प्राप्त हो सकता है {संदेश प्रारूप पढ़ सकते हैं लॉग प्रविष्टि सीरियल में लॉग प्रविष्टि लिख सकते हैं}}

संकेत:

CAN पुस्तकालय की कार्यक्षमता तक पहुँचने के लिए आप कक्षा MCP_CAN के उदाहरण का उपयोग करेंगे:

एमसीपी_कैन एम_कैन;

इनिट कर सकते हैं:

जबकि (m_can.begin() != CAN_OK)

{देरी (1000); }

CAN संदेशों को देखें और पढ़ें:

जबकि (m_can.checkReceive () == CAN_MSGAVAIL)

{// CAN आईडी, संदेश की लंबाई और संदेश डेटा प्राप्त करें m_can.readMsgBufID(&m_canId, &m_msgLen, m_msgBuf); // यहां संदेश डेटा के साथ कुछ करें }

यदि आपको और सहायता की आवश्यकता है तो आप बाद के चरण में मेरे कार्यक्रम का लिंक पा सकते हैं। कैन शील्ड लाइब्रेरी में एक उदाहरण भी शामिल है। या mviljoen2 के निर्देशयोग्य की जाँच करें जिसमें एक समान चरण शामिल है।

डेटा को फ़िल्टर करने में आपकी सहायता के लिए पहले आपको एक संदर्भ फ़ाइल की आवश्यकता होगी। इग्निशन को रेडियो मोड पर स्विच करें और बिना किसी बटन को छुए कुछ मिनटों के लिए सब कुछ लॉग करें।

फिर प्रत्येक बटन के लिए, लॉगिंग प्रारंभ करें, बटन दबाएं और लॉगिंग बंद करें।

जब आप कर लें तो आपको अपने उम्मीदवारों को खोजने के लिए अपने बटन लॉग से अपने संदर्भ लॉग में जो कुछ भी है उसे फ़िल्टर करना होगा। मुझे पता चला कि अभी भी बहुत सारे संदेश बाकी थे इसलिए मैंने और लॉग बनाए और फिर आवश्यक था कि "कमांड ए के लिए उम्मीदवार सभी बटन-ए-फाइलों में और किसी भी संदर्भ फाइल में नहीं होना चाहिए"। इसने मुझे कोशिश करने के लिए केवल कुछ संभावनाओं के साथ छोड़ दिया।

लॉग में बहुत सारे संदेश होंगे इसलिए आपको इसके लिए कुछ प्रोग्राम लिखना होगा या संभवतः एक्सेल का उपयोग करना होगा। (मैंने अपनी आवश्यकताओं के लिए बहुत कठिन कोडित शर्तों के साथ एक प्रोग्राम का उपयोग किया है, इसलिए मुझे डर है कि मैं आपके द्वारा उपयोग किए जा सकने वाले प्रोग्राम की पेशकश नहीं कर सकता।)

चेतावनी का एक शब्द: आप यह सुनिश्चित नहीं कर सकते कि एक बटन हमेशा एक समान संदेश देगा। कुछ बिट्स में इंक्रीमेंटिंग काउंटर आदि हो सकते हैं। (हालांकि आप संदेश आईडी को छोड़कर वही हो सकते हैं।)

यदि आपके पास वोल्वो V70 -02 है तो आप यही चाहते हैं:

• संदेश आईडी: 0x0400066Byte0: 0x00, 0x40, 0x80 या 0xc0 (परवाह न करें)
• बाइट1: 0x00 (परवाह न करें)
• बाइट 2: 0x00 (परवाह न करें)
• बाइट3: 0x00-0x07 (परवाह न करें)
• बाइट4: 0x1f (परवाह न करें)
• बाइट5: 0x40 (परवाह न करें)
• बाइट6: 0x40 (परवाह न करें)
• बाइट7: बटन पहचानकर्ता: 0x77 = वॉल्यूम अप, 0x7b = वॉल्यूम डाउन, 0x7d = अगला ट्रैक, 0x7e = पिछला ट्रैक।

जब आप मानते हैं कि आपको आदेश मिल गए हैं तो प्रोग्राम को संशोधित करना एक अच्छा विचार हो सकता है ताकि यह केवल दिलचस्प संदेशों को लॉग करे। यह सत्यापित करने के लिए कि आपने सही संदेशों की पहचान की है, बटन दबाते समय सीरियल लॉग विंडो देखें।

चरण 4: हार्डवेयर प्रोटोटाइप

आपके हार्डवेयर को निम्न में सक्षम होना चाहिए:

1. CAN बस में प्राप्त कमांड की पहचान करें
2. स्टीरियो को दूसरे प्रारूप में कमांड भेजें

यदि आपके पास पर्याप्त जगह है तो आप पहले भाग के लिए Arduino और CAN शील्ड का उपयोग कर सकते हैं और दूसरे भाग के लिए कुछ अतिरिक्त हार्डवेयर संलग्न कर सकते हैं। हालांकि कुछ कमियां हैं:

• CAN शील्ड की कीमत
• आकार
• Arduino बिजली की आपूर्ति खुश नहीं होगी यदि यह सीधे आपकी कारों 12V से जुड़ी है (यह शायद काम करेगी लेकिन इसका जीवन छोटा हो जाएगा)।

तो इसके बजाय मैंने निम्नलिखित का उपयोग किया:

• Atmega 328, "Arduino मस्तिष्क"। (कुछ प्रकार हैं, वह प्राप्त करें जो Arduino Uno पर एक के बराबर है। आप इसे Arduino बूट लोडर के साथ या बिना खरीद सकते हैं।)
• क्लॉक सिग्नल के लिए 16 मेगाहर्ट्ज क्रिस्टल + कैपेसिटर।
• MCP2551 ट्रांसीवर कर सकता है।
• MCP2515 CAN नियंत्रक।
• TSR1-2450, 6.5-36V से 5V में कनवर्ट करता है। (प्रोटोटाइप में उपयोग नहीं किया गया क्योंकि सॉफ्टवेयर बिजली की आपूर्ति की परवाह नहीं करेगा।)
• CD4066B स्विच जिसका उपयोग स्टीरियो को कमांड भेजते समय किया जाएगा।
• प्रतिरोधों की एक जोड़ी। (मान बाद के चरण में ईगल स्कीमैटिक्स में पाए जा सकते हैं।)

इस कॉन्फ़िगरेशन के साथ एक अच्छी बात यह है कि यह Arduino और CAN शील्ड लाइब्रेरी के साथ पूरी तरह से संगत है।

यदि आप चार से अधिक बटनों को संभालना चाहते हैं तो आप CD4066B के अलावा कुछ और उपयोग करने पर विचार कर सकते हैं। CD4066B को एक में चार स्विच के रूप में वर्णित किया जा सकता है, प्रत्येक को Atmegas GPIO पिन में से एक द्वारा नियंत्रित किया जाता है। प्रत्येक स्विच में एक प्रतिरोधक जुड़ा होता है जिसका उपयोग स्टीरियो में इनपुट के रूप में उपयोग किए जाने वाले प्रतिरोध को नियंत्रित करने के लिए किया जा सकता है। तो यह आसानी से चार अलग-अलग कमांड भेजने के लिए इस्तेमाल किया जा सकता है। यदि वे संयुक्त हैं तो अतिरिक्त प्रतिरोध मान प्राप्त किए जा सकते हैं। यह वह जगह है जहां मैंने पहले उल्लेख की गलती आती है। मेरे पास चार बटन हैं, लेकिन मैंने छह अलग-अलग कमांड देने के लिए उनमें से दो को लंबे और छोटे प्रेस के रूप में लागू करने की योजना बनाई है। लेकिन अंत में मुझे पता चला कि मुझे प्रतिरोधों का एक संयोजन नहीं मिला जो मुझे छह कार्य संयोजन देगा। इसके बजाय एनालॉग आउट सिग्नल को स्टीरियो (3.5 मिमी टिप) से कनेक्ट करना संभवतः संभव होगा। (ध्यान दें कि Atmega में कोई वास्तविक एनालॉग आउट पिन नहीं है, इसलिए कुछ अतिरिक्त हार्डवेयर की आवश्यकता होगी।)

परीक्षण उद्देश्यों के लिए मैंने अपने प्रोटोटाइप से जुड़ने के लिए एक सरल "कार और स्टीरियो" सिम्युलेटर भी बनाया। यह डिबगिंग को आसान बनाता है और जब तक आप अपनी कार और प्रोग्राम में बैठने का आनंद नहीं लेते हैं, मैं इसकी सिफारिश कर सकता हूं।

प्रोटोटाइप छवि में नीचे ब्रेडबोर्ड द्वारा चित्रित किया गया है। बिजली की आपूर्ति, प्रोग्रामिंग और सीरियल लॉगिंग के लिए इसे एक Arduino Uno से जोड़ा जाता है जहां Atmega चिप को हटा दिया गया है।

ऊपरी ब्रेडबोर्ड कार + स्टीरियो सिम्युलेटर है जिसका उपयोग प्रोटोटाइप के प्रारंभिक परीक्षण के लिए किया जाएगा।

प्रोटोटाइप + सिम्युलेटर का उद्देश्य इस तरह काम करना है:

• सिम्युलेटर बोर्ड पर स्विच बटनों में से एक को दबाएं। (वे आपके स्टीयरिंग व्हील बटन हैं।)
• जब सिम्युलेटर प्रोग्राम एक बटन प्रेस का पता लगाता है तो यह प्रत्येक 70 एमएस में संबंधित संदेश भेज सकता है जब तक कि बटन धक्का दिया जाता है। (क्योंकि मैंने पहले जो लॉग लिए थे, उससे संकेत मिलता था कि यह मेरी कार में कैसे काम कर रहा है।) यह बस में अन्य ट्रैफ़िक को अनुकरण करने के लिए बहुत सारे "जंक" CAN संदेश भी भेजेगा।
• CAN बस में CAN संदेश भेजे जाते हैं।
• CAN संदेश प्रोटोटाइप द्वारा प्राप्त किए जा सकते हैं।
• MCP2515 संदेश आईडी के आधार पर सभी असंबंधित संदेशों को फेंकता है।
• जब MCP2515 को एक संदेश प्राप्त होता है जिसे संभाला जाना चाहिए, तो यह इंगित करेगा कि इसमें एक संदेश संलग्न है।
• Atmega संदेश को पढ़ेगा और तय करेगा कि कौन सा बटन सक्रिय माना जाना चाहिए।
• अंतिम संदेश प्राप्त होने पर Atmega भी ट्रैक रखेगा, एक निश्चित समय के बाद बटन को जारी माना जाएगा। (कैन संदेश केवल यह इंगित करता है कि एक बटन नीचे है, न कि यह धक्का दिया गया है या जारी किया गया है।)
• यदि एक बटन को सक्रिय माना जाता है तो CD4066B में एक या अधिक स्विच सक्रिय हो जाएंगे।
• सिम्युलेटर (अब आपके स्टीरियो के रूप में कार्य कर रहा है) यह पता लगाएगा कि टिप और आस्तीन के बीच एक प्रतिरोध लगाया गया है। (टिप 3.3V से और एक रेसिस्टर के माध्यम से एक एनालॉग इनपुट पिन से जुड़ा है। जब कोई कमांड सक्रिय नहीं है तो यह पिन 3.3V पढ़ेगा, जब कोई कमांड सक्रिय होता है तो मान कम हो जाएगा और कमांड की पहचान करेगा।
• जबकि एक कमांड सक्रिय है, संबंधित एलईडी भी सक्रिय हो जाएगी। (छः एलईडी हैं क्योंकि मैंने अपने दो बटनों के लिए अलग-अलग लंबे / छोटे प्रेस का उपयोग करने की योजना बनाई है।)

प्रोटोटाइप हार्डवेयर के बारे में अधिक जानकारी के लिए, बाद के चरण में ईगल स्कीमैटिक्स देखें।

सिम्युलेटर बोर्ड हार्डवेयर के बारे में अतिरिक्त विवरण:

• 16 मेगाहर्ट्ज क्रिस्टल
• 22 पीएफ कैपेसिटर
• एलईडी गुणों के आधार पर एलईडी प्रतिरोधों का चयन किया जाना चाहिए
• A7 और 3.3V से जुड़ा रोकनेवाला, उदा चुनें। 2kOhm (महत्वपूर्ण नहीं)।
• MCP2551 और MCP2515 से जुड़े प्रतिरोध पुल-अप / पुल-डाउन हैं। उदाहरण का चयन करें 10 कोहम।

(या यदि आप चाहें तो सिम्युलेटर के "कैन पार्ट" के लिए कैन शील्ड का उपयोग कर सकते हैं।)

यह महत्वपूर्ण है कि आप जानते हैं कि जब आप हार्डवेयर डिज़ाइन करते हैं तो एटमेगा पिन को Arduino पिन में कैसे मैप किया जाता है।

(किसी भी एलईडी को सीधे सीडी ४०६६बी से न जोड़ें, यह केवल एक कम धारा को संभाल सकता है। मैंने कोशिश की कि जब मैंने पहली बार आउटपुट का परीक्षण किया और चिप बेकार हो गई। अच्छी बात यह है कि मैंने उनमें से एक जोड़े को सिर्फ इसलिए खरीदा था क्योंकि वे बहुत सस्ते हैं।)

चरण 5: फ्यूज प्रोग्रामिंग

हो सकता है कि आपने पिछले चरण में देखा हो कि प्रोटोटाइप में MCP2515 को क्लॉक सिग्नल उत्पन्न करने के लिए कोई अलग घटक नहीं है। ऐसा इसलिए है क्योंकि पहले से ही 16 मेगाहर्ट्ज क्रिस्टल का उपयोग एटमेगा घड़ी संकेत के रूप में किया जाता है जिसका हम उपयोग कर सकते हैं। लेकिन हम इसे सीधे MCP2515 से कनेक्ट नहीं कर सकते हैं और डिफ़ॉल्ट रूप से Atmega पर कोई क्लॉक आउट सिग्नल नहीं है।

(यदि आप चाहें तो आप इस चरण को छोड़ सकते हैं और इसके बजाय अतिरिक्त घड़ी हार्डवेयर जोड़ सकते हैं।)

हालाँकि हम GPIO पिन में से किसी एक पर क्लॉक आउट सिग्नल को सक्षम करने के लिए "फ्यूज प्रोग्रामिंग" नामक किसी चीज़ का उपयोग कर सकते हैं।

सबसे पहले आपको अपने Arduino IDE द्वारा उपयोग की जाने वाली "boards.txt" नाम की एक फ़ाइल का पता लगाना होगा। आपको Arduino Uno के लिए प्रविष्टि को कॉपी करना होगा, इसे एक नया नाम देना होगा और Low_fuses के लिए मान बदलना होगा।

मेरा नया बोर्ड इस तरह दिखता है:

############################################# ########### # Arduino Uno पर आधारित # परिवर्तन: # कम_फ्यूज 0xff से 0xbf में बदलकर 16 मेगाहर्ट्ज घड़ी सक्षम करने के लिए # Atmega PB0/पिन 14 पर = Arduino D8

clkuno.name=क्लॉक आउट (Arduino Uno)

clkuno.upload.protocol=arduino clkuno.upload.maximum_size=32256.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.

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

ध्यान दें कि क्लॉक आउट इसके कंट्रोल बिट को 0 पर सेट करके सक्रिय होता है।

जब आपने बोर्ड कॉन्फ़िगरेशन फ़ाइल में नया बोर्ड बना लिया है तो आपको Atmega में एक नया बूट लोडर बर्न करना होगा। ऐसा करने के कई तरीके हैं, मैंने https://www.arduino.cc/en/Tutorial/ArduinoToBreadboard में वर्णित विधि का उपयोग किया।

ऐसा करने के बाद, अपने नए बोर्ड प्रकार का चयन करना याद रखें, न कि Arduino Uno को जब आप Atmega पर कोई प्रोग्राम अपलोड करते हैं।

चरण 6: सॉफ्टवेयर

कुछ सॉफ्टवेयर जोड़कर गूंगे हार्डवेयर को स्मार्ट बनाने का समय आ गया है।

प्रोटोटाइप के लिए यहां कुछ छद्म कोड दिए गए हैं:

अंतिम प्राप्त समय = 0

lastReceivedCmd = कोई नहीं cmdTimeout = 100 सेटअप () { वॉचडॉग कॉन्फ़िगर पिन D4-D7 को आउटपुट पिन के रूप में सक्षम कर सकता है, जो फ़िल्टर कर सकता है} लूप () {वॉचडॉग को रीसेट करें यदि (संदेश प्राप्त हो सकता है) {प्रत्येक बटन कमांड के लिए {यदि संदेश संबंधित हो सकता है बटन कमांड {lastReceivedTime = now lastReceivedCmd = cmd}}} अगर अभी> lastReceivedTime + cmdTimeout {lastReceivedCmd = कोई नहीं} प्रत्येक बटन कमांड के लिए {यदि lastReceivedCmd बटन कमांड है {सेट कमांड पिन आउटपुट = ऑन} और {सेट कमांड पिन आउटपुट = ऑफ } } }

cmdTimeout यह तय करता है कि जारी किए गए अंतिम सक्रिय बटन पर विचार करने से पहले हमें कितनी देर प्रतीक्षा करनी चाहिए। क्योंकि बटन CAN संदेश कमांड लगभग प्रत्येक 70 ms पर भेजे जाते हैं, इसे कुछ मार्जिन के साथ इससे बड़ा होना चाहिए। लेकिन अगर यह बड़ा है तो लैग का अनुभव होगा। तो 100 एमएस एक अच्छे उम्मीदवार की तरह लगता है।

लेकिन चौकीदार क्या है? यह एक उपयोगी छोटी हार्डवेयर सुविधा है जो दुर्घटना की स्थिति में हमें बचा सकती है। कल्पना कीजिए कि हमारे पास एक बग है जिसके कारण वॉल्यूम अप कमांड सक्रिय होने पर प्रोग्राम क्रैश हो जाता है। तब हम अधिकतम वॉल्यूम पर स्टीरियो के साथ समाप्त होंगे! लेकिन अगर वॉचडॉग को विशिष्ट समय के लिए रीसेट नहीं किया जाता है, तो यह तय करेगा कि कुछ अप्रत्याशित हुआ है और बस एक रीसेट जारी करें।

व्यर्थ व्यवस्था()

{// लूप के लिए अधिकतम 250 एमएस की अनुमति दें wdt_enable(WDTO_250MS); // अन्य init सामान} शून्य लूप () {wdt_reset (); // कार्य करना }

फ़िल्टर कर सकते हैं? ठीक है, आप CAN नियंत्रक को उन सभी संदेशों को त्यागने के लिए कॉन्फ़िगर कर सकते हैं जो फ़िल्टर से मेल नहीं खाते हैं ताकि सॉफ़्टवेयर को उन संदेशों पर समय बर्बाद न करना पड़े जिनकी हमें परवाह नहीं है।

अहस्ताक्षरित लंबा मुखौटा = 0x1fffffff; // सभी 29 हेडर बिट्स को मास्क में शामिल करें

अहस्ताक्षरित लंबा फ़िल्टर आईडी = 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 नियंत्रक भी सेट कर सकते हैं। (उपरोक्त उदाहरण में शामिल नहीं है, लेकिन मेरे कार्यक्रम में इसके लिए कुछ कोड है।) इस मामले में यह वास्तव में कोई मूल्य नहीं जोड़ता है और यदि आप प्रोग्रामिंग के अभ्यस्त नहीं हैं तो यह भ्रमित हो सकता है।

तो वह संक्षेप में प्रोटोटाइप सॉफ्टवेयर था। लेकिन हमें सिम्युलेटर बोर्ड के लिए भी कुछ कोड चाहिए:

लास्टसेंटटाइम = 0

minDelayTime = 70 सेटअप () {पिन A0-A5 को आउटपुट पिन के रूप में कॉन्फ़िगर करें पिन D4-D7 को आंतरिक पुलअप के साथ इनपुट पिन के रूप में कॉन्फ़िगर करें। init CAN} लूप () {भेजें "जंक" संदेश सेट कर सकते हैं सक्रियबटन = प्रत्येक बटन के लिए कोई नहीं {यदि बटन को धक्का दिया जाता है {सक्रिय बटन सेट करें = बटन}} यदि सक्रिय बटन! = कोई नहीं {अगर अब> lastSentTime + minDelayTime {भेजें बटन कमांड संदेश भेज सकता है } lastSentTime = now } inval = पढ़ें पिन A7 foreach (cmd) {अगर (न्यूनतम <इनवैल <अधिकतम) {नेतृत्व पर} और {नेतृत्व बंद}} 1 एमएस के लिए प्रतीक्षा करें}

यह लगभग हर एमएस में लगातार "जंक" संदेश भेज सकता है और जब एक बटन को प्रत्येक 70 एमएस में संबंधित कमांड को धक्का दिया जाता है।

प्रत्येक बटन से संबंधित न्यूनतम और अधिकतम चर के लिए उपयुक्त मान ज्ञात करने के लिए आपको विभिन्न बटनों को दबाते हुए पिन A7 पर इनपुट लॉग करने की आवश्यकता हो सकती है। (या आप इसकी गणना कर सकते हैं, लेकिन वास्तव में इनपुट पढ़ने से आपको अधिक सटीक मान मिलेंगे।)

पिन मोड की प्रोग्रामिंग करते समय आपको थोड़ा सावधान रहने की जरूरत है। यदि आप गलती से पिन को आउटपुट पिन के रूप में आंतरिक पुलअप का उपयोग करने के लिए सेट करते हैं तो आप एक संभावित शॉर्टकट बनाएंगे जो आउटपुट को उच्च सेट करने पर आपके Arduino को नुकसान पहुंचाएगा।

यदि आप मेरे कार्यक्रमों की जांच करना चाहते हैं तो उन्हें यहां डाउनलोड किया जा सकता है:

• संदेश लॉग प्रोग्राम कर सकते हैं
• सिम्युलेटर बोर्ड के लिए कार्यक्रम
• प्रोटोटाइप / अंतिम बोर्ड के लिए कार्यक्रम

आपको पता होना चाहिए कि वे प्रोग्राम वास्तव में यहां छद्म कोड से मेल नहीं खाते हैं, उनमें बहुत सारी "अतिरिक्त" चीजें हैं जिनकी वास्तव में आवश्यकता नहीं है और यदि आप ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग से परिचित नहीं हैं तो शायद इसे पढ़ना थोड़ा मुश्किल हो सकता है.

चरण 7: अंतिम हार्डवेयर

जब आप अपने कार्यक्रम से खुश होते हैं (सिम्युलेटर बोर्ड के साथ अंतिम परीक्षण के बाद कार में प्रोटोटाइप का परीक्षण करना याद रखें) यह वास्तविक हार्डवेयर बनाने का समय है।

यहां आपके पास तीन विकल्प हैं:

• त्वरित और गंदा - एक पीसीबी प्रोटोटाइप बोर्ड पर सामान को एक साथ मिलाएं।
• हार्डकोर DIY - अपना खुद का PCB खोदें।
• आलसी तरीका - एक पेशेवर पीसीबी को घटकों को मिलाप करने का आदेश दें।

यदि आप जल्दी में नहीं हैं तो मैं अंतिम विकल्प सुझा सकता हूं। अगर आपको केवल इस तरह के एक छोटे पीसीबी की जरूरत है तो इसे चीन से मंगवाना बहुत सस्ता है। (और फिर आपको शायद दस टुकड़े मिलेंगे या तो आप कुछ सोल्डरिंग गलतियों को बर्दाश्त कर सकते हैं।)

पीसीबी ऑर्डर करने के लिए आपको अपना डिजाइन Gerber फॉर्मेट में भेजना होगा। इसके लिए विभिन्न सॉफ्टवेयर हैं। मैंने ईगल का इस्तेमाल किया जिसकी मैं सिफारिश कर सकता हूं। आप इसे सीखने के लिए कुछ घंटों की अपेक्षा कर सकते हैं लेकिन फिर यह ठीक काम करता है। इस तरह के छोटे बोर्डों के लिए आप इसे मुफ्त में इस्तेमाल कर सकते हैं।

डिजाइन बनाते समय सावधान रहें। आप केवल यह पता लगाने के लिए कि आपने कुछ गलत किया है, डिलीवरी के लिए चार सप्ताह का इंतजार नहीं करना चाहती।

(यदि आपके पास अच्छा सोल्डरिंग कौशल है तो आप सतह पर लगे घटकों के लिए डिज़ाइन कर सकते हैं और वास्तव में एक छोटा एडेप्टर प्राप्त कर सकते हैं। मैंने नहीं किया।)

फिर उदा। https://www.seeedstudio.com/fusion_pcb.html। अपने डिज़ाइन से Gerber फ़ाइलें कैसे उत्पन्न करें, इसके लिए निर्देशों का पालन करें। यह सुनिश्चित करने के लिए कि यह ठीक है, आप परिणाम का पूर्वावलोकन भी प्राप्त कर सकते हैं।

(अंत में मुझे योजनाबद्ध चित्र में सूचीबद्ध की तुलना में R4-R7 के लिए अन्य प्रतिरोधों का चयन करना पड़ा। इसके बजाय मैंने 2k, 4.7k, 6.8k और 14.7k का उपयोग किया।)

और याद रखें - Arduino पिन नंबरिंग के साथ Atmega पिन नंबरिंग को भ्रमित न करें!

मेरा सुझाव है कि आप Atmega चिप को सीधे न मिलाएं बल्कि एक सॉकेट का उपयोग करें। फिर आप इसे आसानी से हटा सकते हैं यदि आपको इसे पुन: प्रोग्राम करने की आवश्यकता है।

चरण 8: कार माउंटिंग

अब सबसे मजेदार भाग पर - इसे अपनी कार में माउंट करें और इसका उपयोग करना शुरू करें! (आपके द्वारा इसके लिए केस बनाने/खरीदने के बाद।)

यदि आपने अपनी कार में पहले से ही प्रोटोटाइप का पूरी तरह से परीक्षण कर लिया है, तो सब कुछ पूरी तरह से काम करना चाहिए।

(जैसा कि मैंने पहले उल्लेख किया था कि मैंने ऐसा नहीं किया था इसलिए मुझे कुछ प्रतिरोधों को बदलना पड़ा और अपने कार्यक्रम में कुछ बदलाव करने पड़े।)

यह भी विचार करें कि क्या आपको इसे स्टीरियो के पीछे या कहीं और माउंट करना चाहिए। मुझे अपने ग्लोव बॉक्स के ऊपर एक अच्छी जगह मिली, जहां मैं ग्लोव बॉक्स के अंदर से बिना कुछ अलग किए उस तक पहुंच सकता हूं। यह उपयोगी हो सकता है अगर मैं इसे बाद में अपग्रेड करने का निर्णय लेता हूं।

अंत में मेरे बटन फिर से काम कर रहे हैं! मैं उनके बिना दो महीने कैसे रह सकता था?

चरण 9: भविष्य में सुधार

जैसा कि उल्लेख किया गया है, अगर मैं इसका एक संस्करण 2.0 बनाता हूं तो मैं अधिक लचीलेपन के लिए 4066B को किसी और चीज़ (शायद एक डिजिटल पोटेंशियोमीटर) से बदल दूंगा।

और भी बहुत सी चीजें हैं जो आप कर सकते हैं। उदा. एक ब्लूटूथ मॉड्यूल जोड़ें और अपने फोन के लिए रिमोट कंट्रोल ऐप बनाएं। या एक जीपीएस मॉड्यूल, फिर जब आप घर के नजदीक होते हैं तो आप स्वचालित रूप से वॉल्यूम बढ़ा सकते हैं और "विंडोज़ डाउन" संदेश भेज सकते हैं ताकि आपके सभी पड़ोसी आपके अद्भुत संगीत का आनंद उठा सकें।