Vlastní Arduino pro udržení tlačítek na volantu CAN s novým autorádiem: 9 kroků (s obrázky)

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:23

Rozhodl jsem se nahradit původní autorádio ve svém Volvu V70 -02 novým stereem, abych si mohl užívat věci jako mp3, bluetooth a handsfree.

Moje auto má několik ovládacích prvků na volantu pro stereo, které bych chtěl ještě používat. Nečekal jsem, že to bude problém, protože na trhu je několik adaptérů, které mají být kompatibilní s mým autem. Brzy jsem však zjistil, že nejsou! (Zdá se, že adaptéry pro V70 mohou mít problémy s vozy -02 kvůli mírně odlišnému protokolu CAN.)

Co tedy dělat? Ponechat staré stereo? Žít život s nefungujícími tlačítky? Samozřejmě že ne! Pokud na trhu není žádný funkční adaptér, budeme jej muset postavit!

Tento instruktáž lze použít (s určitými úpravami) na vozy, kde tlačítka na volantu komunikují po sběrnici CAN.

Krok 1: Zjistěte, jak odesílat příkazy na stereo

První věc, kterou byste měli udělat, je zjistit, jaký typ dálkového vstupu stereo očekává. To vám výrobci obvykle neřeknou a pravděpodobně nemáte přístup ani k funkčním dálkovým ovladačům pro reverzní inženýrství.

Dálkový ovladač pro mé nové stereo (Kenwood) se skládá z jediného drátu a nebyl jsem schopen zjistit žádné informace o tom, jak funguje. Má však také 3,5 mm konektor pro vzdálený vstup. Také jsem o tom nemohl nic zjistit. Existují však informace o 3,5 mm konektoru pro jiné značky, které naznačují, že různé příkazy jsou identifikovány použitím specifického odporu mezi špičkou a pouzdrem (a volitelně mezi kroužkem a pouzdrem). Např. https://forum.arduino.cc/index.php?topic=230068.0. Rozhodl jsem se to tedy zkusit a je vybaven prkénkem, spoustou rezistorů a 3,5mm konektorem zapojeným do stereo a připojeným k prkénku. Nejprve nebylo nic rozpoznáno, ale stereo má nabídku „režimu učení“a tam lze příkazy úspěšně nastavit za použití různého odporu. Úspěch!

Později jsem však zjistil, že jsem zde udělal chybu: Ne všechny příkazy, které se stereo zdálo, by ve skutečnosti fungovaly. Např. V režimu učení bylo nalezeno 30 kOhm, ale později to nefungovalo a u některých příkazů, které jsem nastavil, byl rozdíl odporu tak malý, že později byl spuštěn špatný příkaz.

Doporučuji tedy použít prkénko s odpory a tlačítky přepínačů pro všechny dálkové příkazy, které chcete zvládnout, a ve skutečnosti vyzkoušet, že všechny budou fungovat.

Pokud vaše autorádio nemůže přijímat vstup stejným způsobem, budete muset zjistit, jak funguje, abyste mohli toto řešení přizpůsobit. Pokud na to vůbec nemůžete přijít, máte problém.

Krok 2: Zjistěte, kde se připojit ke sběrnici CAN

Pro připojení ke sběrnici CAN musíte najít dobré místo. Protože nahrazujete staré stereo, které komunikuje přes CAN, měli byste to za stereem najít. Sběrnice CAN se skládá z dvojice zkroucených vodičů (CAN-L a CAN_H). Pro jistotu nahlédněte do schématu zapojení vašeho auta.

Krok 3: Reverzní inženýrství zpráv CAN

Pokud vám Google neřekne, jaké zprávy CAN byste měli poslouchat, budete se muset připojit ke sběrnici CAN a provést nějaké reverzní inženýrství. Použil jsem Arduino Uno a štít CAN. (Ve skutečnosti nepotřebujete štít CAN, jak uvidíte později, můžete místo toho použít nějaké levné komponenty na prkénko.)

Poraďte se s Googlem a zjistěte, jakou přenosovou rychlost byste měli používat při připojení k autu. (Obvykle zjistíte, že existuje vysokorychlostní a nízkorychlostní síť CAN. Připojujete se k síti s nízkou rychlostí.)

Budete také muset naprogramovat Arduino tak, aby protokolovalo všechny zprávy CAN přes sériové rozhraní, abyste je mohli uložit do souboru protokolu ve vašem počítači. Standardní Arduino IDE neukládá data do souboru protokolu, ale můžete použít např. Místo toho tmel.

Než začnete psát svůj program, musíte si nainstalovat knihovnu CAN_BUS_Shield.

Zde je několik pseudokódů, které vám pomohou začít s programem:

založit()

{init serial connection init CAN library} loop () {if CAN message is receive {read CAN message format log log write write log entry to serial}}

Tipy:

K přístupu k funkcím knihovny CAN použijete instanci třídy MCP_CAN:

MCP_CAN m_can;

Init CAN:

while (m_can.begin ()! = CAN_OK)

{zpoždění (1000); }

Zkontrolujte a přečtěte si zprávy CAN:

while (m_can.checkReceive () == CAN_MSGAVAIL)

{// Získejte ID CAN, délku zprávy a data zprávy m_can.readMsgBufID (& m_canId, & m_msgLen, m_msgBuf); // Udělejte něco s daty zprávy zde}

Pokud potřebujete další pomoc, můžete v pozdějším kroku najít odkaz na můj program. Knihovna štítu CAN také obsahuje příklad. Nebo se podívejte na instrukci mviljoen2, která obsahuje podobný krok.

Nejprve budete potřebovat referenční soubor, který vám pomůže filtrovat data. Přepněte zapalování do režimu rádia a vše zaznamenávejte na několik minut, aniž byste se dotkli jakýchkoli tlačítek.

Potom pro každé z tlačítek spusťte protokolování, stiskněte tlačítko a zastavte protokolování.

Až budete hotovi, musíte z protokolů tlačítek odfiltrovat vše, co je ve vašem referenčním protokolu, abyste našli své kandidáty. Zjistil jsem, že ještě zbývá spousta zpráv, takže jsem udělal další protokoly a poté jsem požadoval, aby „kandidáti na příkaz A museli být ve všech souborech typu A a v žádném z referenčních souborů“. Zbývalo mi tedy jen několik možností, jak to vyzkoušet.

Protokoly budou obsahovat spoustu zpráv, takže k tomu budete muset napsat nějaký program nebo případně použít Excel. (Pro své potřeby jsem použil program s velmi pevně zakódovanými podmínkami, takže se obávám, že nemohu nabídnout program, který můžete použít.)

Slovo varování: Nemůžete si být jisti, že tlačítko vždy vydá identickou zprávu. Některé z bitů mohou obsahovat přírůstkové čítače atd. (ID zprávy však můžete ponechat stejné.)

Pokud náhodou máte Volvo V70 -02, o co vám jde:

• ID zprávy: 0x0400066Byt 0: 0x00, 0x40, 0x80 nebo 0xc0 (nezáleží na tom)
• Byte1: 0x00 (je mi to jedno)
• Byte2: 0x00 (je mi to jedno)
• Byte3: 0x00-0x07 (je mi to jedno)
• Byte4: 0x1f (je mi to jedno)
• Byte5: 0x40 (je mi to jedno)
• Byte6: 0x40 (je mi to jedno)
• Byte7: Identifikátor tlačítka: 0x77 = zvýšení hlasitosti, 0x7b = snížení hlasitosti, 0x7d = další skladba, 0x7e = předchozí skladba.

Když věříte, že jste našli příkazy, může být vhodné upravit program tak, aby zaznamenával pouze zajímavé zprávy. Při stisknutí tlačítek se podívejte do okna sériového protokolu a ověřte, že jste identifikovali správné zprávy.

Krok 4: Hardwarový prototyp

Váš hardware musí umět:

1. Identifikujte příkazy přijaté na sběrnici CAN
2. Odesílejte příkazy v jiném formátu na stereo

Pokud máte dostatek místa, můžete pro první část použít Arduino a CAN štít a pro druhou připojit další hardware. Existují však určité nevýhody:

• Náklady na štít CAN
• Velikost
• Napájecí zdroj Arduino nebude šťastný, pokud je připojen přímo k vašim vozidlům 12 V (pravděpodobně bude fungovat, ale jeho životnost se pravděpodobně zkrátí).

Místo toho jsem použil následující:

• Atmega 328, „mozek Arduina“. (Existují některé varianty, získejte tu, která se rovná té na Arduino Uno. Můžete si ji koupit s bootloaderem Arduino nebo bez něj.)
• 16 MHz krystal + kondenzátory pro hodinový signál.
• MCP2551 CAN transceiver.
• Řadič CAN MCP2515.
• TSR1-2450, převádí 6,5-36V na 5V. (V prototypu není použito, protože software se nebude starat o napájení.)
• Přepínač CD4066B, který bude použit při odesílání příkazů do stereo.
• Pár odporů. (Hodnoty lze nalézt ve schématech Eagle v pozdějším kroku.)

Dobrá věc s touto konfigurací je, že je plně kompatibilní s Arduino a knihovnou štítů CAN.

Pokud chcete ovládat více než čtyři tlačítka, můžete zvážit použití něčeho jiného než CD4066B. CD4066B lze popsat jako čtyři přepínače v jednom, každý ovládaný jedním z pinů Atmegas GPIO. Ke každému přepínači je připojen odpor, který lze použít k ovládání odporu používaného jako vstup do stereofonního signálu. To lze tedy snadno použít k odeslání čtyř různých příkazů. Pokud jsou kombinovány, lze získat další hodnoty odporu. Zde nastává chyba, kterou jsem zmínil dříve. Mám čtyři tlačítka, ale plánoval jsem implementovat dvě z nich jako dlouhé a krátké stisknutí, abych dostal šest různých příkazů. Nakonec jsem ale zjistil, že jsem nemohl najít kombinaci odporů, která by mi dala šest pracovních kombinací. Pravděpodobně by místo toho bylo možné připojit analogový výstupní signál ke stereu (hrot 3,5 mm). (Všimněte si, že Atmega nemá žádné skutečné analogové výstupy, takže bude vyžadován nějaký další hardware.)

Pro účely testování jsem také vytvořil jednoduchý simulátor „auta a stereo“pro připojení k mému prototypu. Usnadňuje ladění a pokud vás nebaví sedět v autě a programovat, mohu to doporučit.

Prototyp je znázorněn na spodní liště na obrázku. Pro napájení, programování a sériové protokolování je připojen k Arduino Uno, kde byl odstraněn čip Atmega.

Horní prkénko je auto + stereo simulátor, který bude použit pro počáteční testování prototypu.

Simulátor prototypu + má fungovat takto:

• Stiskněte jedno z přepínačů na desce simulátoru. (To jsou tlačítka na volantu.)
• Když program simulátoru detekuje stisknutí tlačítka, odešle odpovídající zprávu CAN každých 70 ms, dokud je tlačítko stisknuto. (Protokoly, které jsem vzal dříve, naznačovaly, že to tak funguje v mém autě.) Bude také odesílat spoustu „nevyžádaných“zpráv CAN, které budou simulovat další provoz v autobuse.
• Zprávy CAN jsou odesílány na sběrnici CAN.
• Prototyp přijímá zprávy CAN.
• MCP2515 vyvolá všechny nesouvisející zprávy na základě ID zprávy.
• Když MCP2515 obdrží zprávu, která by měla být zpracována, bude to znamenat, že má zprávu zařazenou do fronty.
• Atmega přečte zprávu a rozhodne, které tlačítko by mělo být považováno za aktivní.
• Atmega bude také sledovat, kdy byla přijata poslední zpráva, po určité době bude tlačítko považováno za uvolněné. (Zprávy CAN pouze indikují, že je tlačítko dole, nikoli že bylo stisknuto nebo uvolněno.)
• Pokud je tlačítko považováno za aktivní, aktivuje se jeden nebo více přepínačů v CD4066B.
• Simulátor (nyní funguje jako vaše stereo) detekuje, že je mezi špičkou a pouzdrem vyvíjen odpor. (Špička je připojena k 3,3 V a přes odpor k analogovému vstupnímu pinu. Když není aktivní žádný příkaz, tento pin bude číst 3,3 V, když je příkaz aktivní, hodnota se sníží a identifikuje příkaz.
• Když je příkaz aktivní, aktivuje se také odpovídající LED. (Existuje šest diod, protože jsem plánoval použít různá dlouhá / krátká stisknutí pro dvě z mých tlačítek.)

Další podrobnosti o hardwaru prototypu najdete v schématech Eagle v pozdějším kroku.

Další podrobnosti o hardwaru desky simulátoru:

• 16 MHz krystal
• 22 pF kondenzátory
• Rezistory LED by měly být vybrány na základě vlastností LED
• Rezistor připojený k A7 a 3,3 V, vyberte např. 2 kOhm (není kritické).
• Rezistory připojené k MCP2551 a MCP2515 jsou vytahovací / stahovací. Vyberte např. 10 kOhm.

(Nebo můžete použít štít CAN pro „část CAN“simulátoru, pokud dáváte přednost.)

Při návrhu hardwaru je důležité vědět, jak jsou piny Atmega mapovány na piny Arduino.

(Nepřipojujte žádné diody přímo k CD 4066B, zvládne pouze nízký proud. Zkoušel jsem to, když jsem poprvé testoval výstup a čip se stal nepoužitelným. Dobrá věc je, že jsem jich pár koupil jen proto, že jsou tak levné.)

Krok 5: Programování pojistek

Možná jste si v předchozím kroku všimli, že prototyp nemá žádné samostatné součásti pro generování hodinového signálu do MCP2515. Důvodem je, že jako hodinový signál Atmega již existuje krystal 16 MHz, který můžeme použít. Nemůžeme jej však jednoduše připojit přímo k MCP2515 a ve výchozím nastavení není na Atmega signál hodinového výstupu.

(Pokud chcete, můžete tento krok přeskočit a místo toho přidat další hardware hodin.)

Můžeme však použít něco, co se nazývá „programování pojistek“, abychom na jednom z kolíků GPIO aktivovali signál hodinového signálu.

Nejprve budete muset vyhledat soubor s názvem „boards.txt“používaný vaším Arduino IDE. Budete muset zkopírovat záznam pro Arduino Uno, dát mu nový název a změnit hodnotu pro low_fuses.

Moje nová deska vypadá takto:

############################################################################ ###############Založeno na Arduino Uno#Změny:#low_fuses změněno z 0xff na 0xbf, aby bylo možné aktivovat hodiny 16 MHz#výstup na Atmega PB0/pin 14 = Arduino D8

clkuno.name = Clock out (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.ebootkubox =.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

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

Všimněte si, že časový limit se aktivuje nastavením jeho řídicího bitu na 0.

Když vytvoříte novou desku v konfiguračním souboru desek, budete muset na Atmega vypálit nový zavaděč. Existují různé způsoby, jak toho dosáhnout, použil jsem metodu popsanou v

Až to uděláte, nezapomeňte při nahrávání programu do Atmega vybrat svůj nový typ desky a ne Arduino Uno.

Krok 6: Software

Čas udělat z hloupého hardwaru chytrý přidáním nějakého softwaru.

Zde je několik pseudo kódů pro prototyp:

lastReceivedTime = 0

lastReceivedCmd = žádný cmdTimeout = 100 nastavení () {povolit watchdog konfigurovat piny D4-D7 jako výstupní piny init CAN nastavení CAN filtr CAN smyčka} () {resetovat hlídacího psa, pokud (je přijata zpráva CAN) {pro každý příkaz tlačítka {pokud zpráva CAN patří příkaz tlačítka {lastReceivedTime = nyní lastReceivedCmd = cmd}}} pokud nyní> lastReceivedTime + cmdTimeout {lastReceivedCmd = none} pro každý příkaz tlačítka {if lastReceivedCmd je příkaz tlačítka {set command pin output = on} else {set command pin output = off }}}

cmdTimeout určuje, jak dlouho bychom měli čekat, než zvážíme poslední aktivní tlačítko uvolněné. Protože příkazy tlačítka CAN jsou odesílány přibližně každých 70 ms, musí být větší než s určitým okrajem. Pokud je ale příliš velký, dojde ke zpoždění. 100 ms se tedy jeví jako dobrý kandidát.

Ale co je to hlídací pes? Je to malá užitečná hardwarová funkce, která nás může zachránit v případě havárie. Představte si, že máme chybu způsobující zhroucení programu, když je aktivní příkaz pro zvýšení hlasitosti. Pak bychom skončili se stereem na maximální hlasitosti! Pokud se ale hlídací pes na určitou dobu neresetuje, rozhodne, že se stalo něco neočekávaného, a jednoduše provede reset.

neplatné nastavení ()

{// povolit max. 250 ms pro smyčku wdt_enable (WDTO_250MS); // další inicializační věci} void loop () {wdt_reset (); // dělat věci }

CAN filtr? Řadič CAN můžete nakonfigurovat tak, aby zahodil všechny zprávy, které neodpovídají filtru, takže software nemusí ztrácet čas zprávami, které nás nezajímají.

nepodepsaná dlouhá maska = 0x1fffffff; // Zahrňte do masky všech 29 bitů záhlaví

nepodepsaný dlouhý filtrId = 0x0400066; // Staráme se pouze o tuto zprávu CAN id m_can.init_Mask (0, CAN_EXTID, maska); // Maska 0 platí pro filtr 0-1 m_can.init_Mask (1, CAN_EXTID, maska); // Maska 1 platí pro filtr 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);

Další podrobnosti o nastavení filtru + masky najdete v kódu knihovny CAN a v dokumentaci k řadiči CAN.

Můžete také nastavit řadič CAN tak, aby vyvolával přerušení při přijetí zprávy (která není odfiltrována). (Není zahrnuto v příkladu výše, ale v mém programu je nějaký kód.) V tomto případě to ve skutečnosti nepřidává žádnou hodnotu a může to být matoucí, pokud nejste zvyklí na programování.

Takže to byl souhrnný prototyp softwaru. Ale potřebujeme také nějaký kód pro desku simulátoru:

lastSentTime = 0

minDelayTime = 70 setup () {configure pins A0-A5 as output pins configure pins D4-D7 as input pins with internal pullup. init CAN} loop () {send "junk" can msg set activeButton = none for each button {if button is printed {set activeButton = button}} if activeButton! = none {if now> lastSentTime + minDelayTime {send button command can message } set lastSentTime = now} inval = číst pin A7 foreach (cmd) {if (min <inval <max) {led on} else {led off}} wait for 1 ms}

To bude nepřetržitě odesílat „nevyžádané“zprávy CAN přibližně každých ms a při stisknutí tlačítka každých 70 ms odpovídající příkaz.

Možná budete muset přihlásit vstup na pin A7 při stisknutí různých tlačítek, abyste zjistili vhodné hodnoty pro minimální a maximální proměnné náležející ke každému tlačítku. (Nebo to můžete vypočítat, ale ve skutečnosti čtení vstupu vám poskytne přesnější hodnoty.)

Při programování režimů pinů musíte být trochu opatrní. Pokud omylem nastavíte piny určené k použití interního pullupu jako výstupních kolíků, vytvoříte potenciální zkratku, která poškodí váš Arduino, když nastavíte výstup vysoko.

Pokud chcete zkontrolovat mé programy, lze je stáhnout zde:

• Program pro protokolování zpráv CAN
• Program pro desku simulátoru
• Program pro prototyp / finální desku

Měli byste si být vědomi toho, že tyto programy zde ve skutečnosti neodpovídají pseudokódu, obsahují spoustu „extra“věcí, které ve skutečnosti nejsou potřeba, a pokud nejste obeznámeni s objektově orientovaným programováním, může být pravděpodobně trochu obtížné číst.

Krok 7: Konečný hardware

Když jste se svým programem spokojeni (nezapomeňte otestovat prototyp v autě po závěrečném testování na desce simulátoru), je na čase sestavit skutečný hardware.

Zde máte tři možnosti:

• Rychlé a špinavé - spojte věci dohromady na desce prototypu desky plošných spojů.
• Hardcore DIY - leptejte si vlastní desku plošných spojů.
• Líný způsob - objednejte si profesionální desku plošných spojů na pájení součástek.

Pokud nespěcháte, mohu doporučit poslední možnost. Pokud potřebujete pouze malou desku plošných spojů, jako je tato, je velmi levné ji objednat z Číny. (A pak pravděpodobně dostanete asi deset kusů, abyste si mohli dovolit nějaké chyby při pájení.)

K objednání desek plošných spojů budete muset zaslat svůj návrh ve formátu Gerber. K tomu existuje různý software. Použil jsem Eagle, který mohu doporučit. Můžete očekávat, že se to naučíte za pár hodin, ale pak to funguje dobře. U malých desek, jako je tato, ji můžete použít zdarma.

Při vytváření návrhu buďte opatrní. Nechcete čekat čtyři týdny na doručení, abyste zjistili, že jste něco udělali špatně.

(Pokud máte dobré pájecí schopnosti, můžete navrhnout součástky pro povrchovou montáž a získat opravdu malý adaptér. Já ne.)

Pak objednejte např. https://www.seeedstudio.com/fusion_pcb.html. Postupujte podle pokynů pro generování souborů Gerber z vašeho návrhu. Můžete také získat náhled výsledku, abyste se ujistili, že je v pořádku.

(Nakonec jsem pro R4-R7 musel vybrat jiné odpory, než jsou uvedeny na obrázku schématu. Místo toho jsem použil 2k, 4,7k, 6,8k a 14,7k.)

A pamatujte si - nezaměňujte číslování pinů Atmega s číslováním pinů Arduino!

Doporučuji čip Atmega nepájet přímo, ale použít zásuvku. Poté jej můžete snadno odstranit v případě, že jej budete muset přeprogramovat.

Krok 8: Montáž do auta

Nyní k nejzábavnější části - namontujte ji do auta a začněte ji používat! (Poté, co jste pro něj vyrobili / koupili pouzdro.)

Pokud jste již prototyp ve svém voze plně otestovali, mělo by vše fungovat perfektně.

(Jak jsem již zmínil, neudělal jsem to, takže jsem musel vyměnit některé odpory a provést nějaké změny v mém programu.)

Zvažte také, zda byste jej měli namontovat za stereo nebo někam jinam. Našel jsem si nad schránkou v palubní desce dobré místo, kam na ni dosáhnu zevnitř schránky v palubní desce, aniž bych cokoli rozebíral. To by mohlo být užitečné, pokud se rozhodnu upgradovat později.

Konečně moje tlačítka opět fungují! Jak jsem mohl bez nich přežít dva měsíce?

Krok 9: Budoucí vylepšení

Jak již bylo zmíněno, pokud udělám verzi 2.0, nahradím 4066B za něco jiného (pravděpodobně digitální potenciometr) pro větší flexibilitu.

Můžete také dělat spoustu dalších věcí. Např. přidejte modul bluetooth a vytvořte pro svůj telefon aplikaci pro dálkové ovládání. Nebo modul GPS, pak když jste blízko domova, můžete automaticky zvýšit hlasitost a odeslat zprávu CAN „dolů“, aby si vaši sousedé mohli vychutnat vaši úžasnou hudbu.