Arduino po meri za ohranjanje gumbov volana CAN pri novem avtomobilskem stereoju: 9 korakov (s slikami)

2024 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2024-01-30 12:07

Odločil sem se, da bom v svojem Volvu V70 -02 zamenjal prvotni avtomobilski stereo, tako da bom lahko užival v stvareh, kot so mp3, bluetooth in prostoročna oprema.

Moj avto ima nekaj krmilnih elementov na volanu za stereo, ki bi jih še vedno rad uporabljal. Nisem pričakoval, da bo to problem, ker je na trgu več adapterjev, ki naj bi bili združljivi z mojim avtomobilom. Vendar sem kmalu ugotovil, da niso! (Zdi se, da bi lahko imeli adapterji za V70 težave z avtomobili -02 zaradi nekoliko drugačnega protokola CAN.)

Kaj torej storiti? Ohraniti stari stereo? Živite življenje z nedelujočimi gumbi? Seveda ne! Če na trgu ni delujočega adapterja, ga bomo morali zgraditi!

To navodilo je mogoče uporabiti (z nekaterimi prilagoditvami) za avtomobile, kjer volanski gumbi komunicirajo prek vodila CAN.

1. korak: Ugotovite, kako poslati ukaze na stereo

Najprej morate ugotoviti, kakšen tip daljinskega vhoda stereo pričakuje. Običajno vam proizvajalci tega ne povedo in verjetno tudi nimate dostopa do delujočih daljinskih upravljalnikov za povratno tehniko.

Daljinski upravljalnik za moj novi stereo (Kenwood) je sestavljen iz ene same žice in nisem mogel izvedeti nobenih informacij o tem, kako deluje. Ima pa tudi 3,5 mm priključek za daljinski vnos. Tudi o tem nisem mogel izvedeti ničesar. Obstaja pa nekaj informacij o 3,5 -milimetrskem vtiču za druge blagovne znamke, ki kažejo, da se različni ukazi prepoznajo z uporabo posebnega upora med konico in tulcem (in po izbiri med obročem in tulcem). Npr. https://forum.arduino.cc/index.php?topic=230068.0. Zato sem se odločil, da poskusim, opremljen s ploščico, kopico uporov in 3,5 -milimetrskim vtičem, priključenim na stereo in priključenim na ploščo. Sprva ni bilo ničesar prepoznano, vendar ima stereo meni "način učenja" in tam je mogoče ukaze uspešno nastaviti z uporabo različnih uporov. Uspeh!

Vendar sem pozneje ugotovil, da sem naredil napako: vsi ukazi, ki jih je stereo zdelo, da se jih je naučil, dejansko ne bi delovali. Npr. 30 kOhm je bilo najdenih v učnem načinu, vendar kasneje ni delovalo in pri nekaterih ukazih, ki sem jih nastavil, je bila razlika upora tako majhna, da se je kasneje sprožil napačen ukaz.

Zato priporočam, da za vse ukaze na daljavo, ki jih želite upravljati, uporabite krovno ploščo z upori in stikalnimi gumbi ter dejansko preizkusite, ali bodo vsi delovali.

Če vaš avtomobilski stereo ne more sprejeti vnosa na enak način, boste morali ugotoviti, kako deluje, da lahko prilagodite to rešitev. Če sploh ne morete ugotoviti, imate težave.

2. korak: Ugotovite, kje se povežete z vodilom CAN

Morate najti dobro mesto za povezavo z vodilom CAN. Ker zamenjate stari stereo, ki komunicira prek CAN -a, bi to morali najti za stereo. CAN vodilo je sestavljeno iz par zvitih žic (CAN-L in CAN_H). Preverite shemo ožičenja vašega avtomobila.

3. korak: Povratni inženiring sporočil CAN

Razen če vam Google pove, katera sporočila CAN morate poslušati, se boste morali povezati z vodilom CAN in narediti nekaj obratnega inženiringa. Uporabil sem Arduino Uno in CAN ščit. (V resnici ne potrebujete ščita CAN, kot boste videli kasneje, lahko namesto tega uporabite nekaj poceni komponent.)

Posvetujte se z Googlom, da ugotovite, kakšno hitrost prenosa morate uporabiti pri povezovanju z avtomobilom. (Običajno boste ugotovili, da obstaja hitra in nizka hitrost mreže CAN. Povezujete se z mrežo z nizko hitrostjo.)

Arduino boste morali programirati tudi za beleženje vseh sporočil CAN prek serijskega vmesnika, da jih lahko shranite v datoteko dnevnika v računalniku. Standardni Arduino IDE ne shranjuje podatkov v datoteko dnevnika, lahko pa uporabite npr. Namesto tega kit.

Preden začnete pisati svoj program, morate namestiti knjižnico CAN_BUS_Shield.

Tukaj je nekaj psevdo kode, ki vam bo pomagala začeti s programom:

nastaviti()

{init serijska povezava init knjižnica CAN} loop () {če je sporočilo CAN prejeto {preberite zapis zapisa zapisa zapisa CAN v dnevnik vnesite dnevnik v serijo}}

Namigi:

Za dostop do funkcionalnosti knjižnice CAN boste uporabili primerek razreda MCP_CAN:

MCP_CAN m_can;

Začetek CAN:

medtem ko (m_can.begin ()! = CAN_OK)

{zamuda (1000); }

Preverite in preberite sporočila CAN:

medtem ko (m_can.checkReceive () == CAN_MSGAVAIL)

{// Pridobite ID CAN, dolžino sporočila in podatke o sporočilu m_can.readMsgBufID (& m_canId, & m_msgLen, m_msgBuf); // Naredite nekaj s podatki o sporočilu tukaj}

Če potrebujete dodatno pomoč, lahko v naslednjem koraku najdete povezavo do mojega programa. Knjižnica ščitnikov CAN vsebuje tudi primer. Ali pa preverite navodila mviljoen2, ki vključujejo podoben korak.

Najprej boste potrebovali referenčno datoteko, ki vam bo pomagala filtrirati podatke. Preklopite vžig v radijski način in vse za nekaj minut beležite, ne da bi se morali dotakniti gumbov.

Nato za vsak gumb začnite beleženje, pritisnite gumb in ustavite beleženje.

Ko končate, morate iz dnevnikov gumbov izločiti vse, kar je v vašem referenčnem dnevniku, da poiščete svoje kandidate. Ugotovil sem, da je ostalo še veliko sporočil, zato sem naredil več dnevnikov in nato zahteval, da "kandidati za ukaz A morajo biti v vseh datotekah gumbov A in v nobeni od referenčnih datotek". To mi je pustilo le nekaj možnosti, da poskusim.

Dnevniki bodo vsebovali veliko sporočil, zato boste morali za to napisati program ali uporabiti Excel. (Za svoje potrebe sem uporabil program z zelo težko kodiranimi pogoji, zato se bojim, da ne morem ponuditi programa, ki ga lahko uporabite.)

Opozorilo: Ne morete biti prepričani, da bo gumb vedno ustvaril enako sporočilo. Nekateri bitovi lahko vsebujejo naraščajoče števce itd. (Lahko pa le, da je ID sporočila enak.)

Če slučajno imate Volvo V70 -02, to želite:

• ID sporočila: 0x0400066Byte0: 0x00, 0x40, 0x80 ali 0xc0 (vseeno)
• Byte1: 0x00 (vseeno)
• Byte2: 0x00 (vseeno)
• Byte3: 0x00-0x07 (vseeno)
• Byte4: 0x1f (vseeno)
• Byte5: 0x40 (vseeno)
• Byte6: 0x40 (vseeno)
• Byte7: Identifikator gumba: 0x77 = povečanje glasnosti, 0x7b = zmanjšanje glasnosti, 0x7d = naslednja skladba, 0x7e = prejšnja skladba.

Ko menite, da ste našli ukaze, je morda dobro, da program spremenite tako, da beleži le zanimiva sporočila. Med pritiskom na gumbe poglejte v okno serijskega dnevnika in preverite, ali ste prepoznali pravilna sporočila.

4. korak: Prototip strojne opreme

Vaša strojna oprema mora biti sposobna:

1. Prepoznajte ukaze, prejete na vodilu CAN
2. Pošljite ukaze v drugi obliki v stereo

Če imate dovolj prostora, lahko za prvi del uporabite Arduino in CAN ščit, za drugega pa pritrdite nekaj dodatne strojne opreme. Vendar pa obstajajo nekatere pomanjkljivosti:

• Stroški ščita CAN
• Velikost
• Napajalnik Arduino ne bo zadovoljen, če bo priključen neposredno na vaše avtomobile 12V (verjetno bo deloval, vendar se bo njegovo življenje verjetno skrajšalo).

Zato sem namesto tega uporabil naslednje:

• Atmega 328, "možgani Arduino". (Obstaja nekaj različic, dobite tisto, ki je enaka tisti na Arduino Uno. Lahko jo kupite z zagonskim nalagalnikom Arduino ali brez njega.)
• 16 MHz kristalni + kondenzatorji za signal ure.
• MCP2551 CAN oddajnik.
• Krmilnik CAN MCP2515.
• TSR1-2450, pretvori 6,5-36V v 5V. (V prototipu se ne uporablja, ker programski opremi ne bo mar za napajanje.)
• Stikalo CD4066B, ki bo uporabljeno pri pošiljanju ukazov v stereo.
• Par uporov. (Vrednosti lahko najdete v shemi Eagle v naslednjem koraku.)

Dobra stvar pri tej konfiguraciji je, da je popolnoma združljiva z Arduino in knjižnico ščitnikov CAN.

Če želite upravljati več kot štiri gumbe, razmislite o uporabi drugega kot CD4066B. CD4066B lahko opišemo kot štiri stikala v enem, od katerih vsako krmili eden od zatičev GPIO Atmegas. Na vsako stikalo je priključen upor, ki ga lahko uporabite za nadzor upora, ki se uporablja kot vhod v stereo. Tako lahko to preprosto uporabite za pošiljanje štirih različnih ukazov. Če jih združimo, lahko dobimo dodatne vrednosti upora. Tu pride do napake, ki sem jo omenil prej. Imam štiri gumbe, vendar sem nameraval dva od njih uporabiti z dolgim in kratkim pritiskom, da dobim šest različnih ukazov. Toda na koncu sem ugotovil, da ne najdem kombinacije uporov, ki bi mi dala šest delovnih kombinacij. Verjetno bi bilo mogoče namesto tega priključiti analogni izhodni signal na stereo (3,5 mm konica). (Upoštevajte, da Atmega nima pravih analognih izhodov, zato bi bila potrebna dodatna strojna oprema.)

Za namene testiranja sem naredil tudi preprost simulator "avto in stereo" za povezavo s svojim prototipom. Olajša odpravljanje napak in razen če uživate v svojem avtomobilu in programirate, vam to lahko priporočam.

Prototip je prikazan na spodnji ploščici na sliki. Za napajanje, programiranje in serijsko beleženje je priključen na Arduino Uno, kjer je bil odstranjen čip Atmega.

Zgornja plošča je simulator avtomobila + stereo, ki bo uporabljen za začetno testiranje prototipa.

Prototip + simulator naj bi deloval takole:

• Pritisnite eno od stikalnih tipk na plošči simulatorja. (To so gumbi na volanu.)
• Ko simulacijski program zazna gumb, bo poslal ustrezno sporočilo CAN vsakih 70 ms, dokler je gumb pritisnjen. (Ker so dnevniki, ki sem jih vzel prej, nakazovali, da tako deluje v mojem avtomobilu.) Prav tako bo poslal veliko "neželenih" sporočil CAN za simulacijo drugega prometa na avtobusu.
• Sporočila CAN se pošiljajo na vodilo CAN.
• Sporočila CAN sprejema prototip.
• MCP2515 vrže vsa nepovezana sporočila na podlagi ID -ja sporočila.
• Ko MCP2515 prejme sporočilo, ki ga je treba obravnavati, bo to pomenilo, da ima sporočilo v čakalni vrsti.
• Atmega bo prebrala sporočilo in se odločila, kateri gumb naj se šteje za aktiven.
• Atmega bo spremljala tudi, kdaj je bilo prejeto zadnje sporočilo, po določenem času pa bo gumb veljal za sproščen. (Sporočila CAN samo označujejo, da je gumb pritisnjen, ne pa, da je bil pritisnjen ali spuščen.)
• Če je gumb aktiven, se aktivira eno ali več stikal v CD4066B.
• Simulator (zdaj deluje kot vaš stereo) bo zaznal, da med konico in tulcem deluje upor. (Konica je priključena na 3.3V in prek upora na analogni vhodni pin. Ko noben ukaz ni aktiven, bo ta pin prebral 3.3V, ko je ukaz aktiven, bo vrednost postala nižja in identificirala ukaz.
• Ko je ukaz aktiven, bo aktiviran tudi ustrezen LED. (Obstaja šest LED, ker sem nameraval uporabiti dva dolga / kratka pritiska za dva gumba.)

Za več podrobnosti o prototipni strojni opremi glejte sheme Eagle v naslednjem koraku.

Dodatne podrobnosti o strojni opremi simulatorja:

• 16 MHz kristal
• 22 pF kondenzatorji
• LED upore je treba izbrati glede na lastnosti LED
• Upor, priključen na A7 in 3.3V, izberite npr. 2 kOhm (ni kritično).
• Upori, priključeni na MCP2551 in MCP2515, so vlečni / spustni. Izberite npr. 10 kOhm.

(Če želite, lahko uporabite ščit CAN za "del CAN" simulatorja.)

Pomembno je, da veste, kako so zatiči Atmega preslikani na zatiče Arduino, ko oblikujete strojno opremo.

(Ne priključujte nobenih LED diod neposredno na CD 4066B, saj lahko prenese le nizek tok. To sem poskusil, ko sem prvič preizkusil izhod, čip pa je postal neuporaben. Dobra stvar je, da sem jih kupil le zato, ker so so tako poceni.)

5. korak: Programiranje varovalk

Morda ste v prejšnjem koraku opazili, da prototip nima ločenih komponent za generiranje signala ure na MCP2515. To je zato, ker že obstaja 16 MHz kristal, ki se uporablja kot signal ure Atmega, ki ga lahko uporabimo. Vendar ga ne moremo preprosto povezati neposredno z MCP2515 in privzeto ni signala izhoda ure na Atmegi.

(Če želite, lahko ta korak preskočite in namesto tega dodate dodatno strojno opremo.)

Lahko pa uporabimo nekaj, kar se imenuje "programiranje varovalk", da omogočimo izhodni signal na enem od zatičev GPIO.

Najprej boste morali poiskati datoteko z imenom "Board.txt", ki jo uporablja vaš Arduino IDE. Vnos za Arduino Uno boste morali kopirati, mu dati novo ime in spremeniti vrednost za low_fuses.

Moja nova tabla izgleda tako:

################################################# #############Na podlagi Arduino Uno#Spremembe:#nizke_varovalke so bile spremenjene iz 0xff v 0xbf, da omogočijo 16 MHz taktni izhod na Atmega PB0/pin 14 = Arduino D8

clkuno.name = Ura je izklopljena (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_cbokloader.extended.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.kuri = arkuno.build.kuri

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

Upoštevajte, da se izhodna ura aktivira tako, da njen kontrolni bit nastavite na 0.

Ko ustvarite novo ploščo v konfiguracijski datoteki plošč, boste morali zapisati nov zagonski nalagalnik v Atmego. To lahko storite na različne načine, uporabil sem metodo, opisano na

Ko to storite, ne pozabite izbrati nove vrste plošče in ne Arduino Uno, ko naložite program v Atmego.

6. korak: programska oprema

Čas je, da naredite neumno strojno opremo z dodajanjem programske opreme.

Tu je nekaj psevdo kode za prototip:

lastReceivedTime = 0

lastReceivedCmd = none cmdTimeout = 100 setup () {enable watchdog configure pins D4-D7 as output pins init CAN filter CAN filter} loop () {ponastavi watchdog if (prejeto sporočilo CAN) {za vsak ukaz gumba {če sporočilo CAN pripada ukaz gumba {lastReceivedTime = zdaj lastReceivedCmd = cmd}}} če je zdaj> lastReceivedTime + cmdTimeout {lastReceivedCmd = nič} za vsak ukaz gumba {če je lastReceivedCmd ukaz gumba {nastavi ukaz pin output = on} else {nastavi ukaz pin output = off }}}

cmdTimeout se odloči, kako dolgo naj počakamo, preden razmislimo o zadnjem sproščenem gumbu. Ker se ukazi sporočil gumba CAN pošiljajo približno vsakih 70 ms, mora biti večji od tistega z določenim robom. Če pa je prevelik, bo prišlo do zamika. 100 ms se torej zdi dober kandidat.

Toda kaj je čuvaj? To je uporabna majhna strojna funkcija, ki nas lahko reši v primeru nesreče. Predstavljajte si, da imamo napako, ki povzroči zrušitev programa, medtem ko je ukaz za povečanje glasnosti aktiven. Potem bi na koncu dobili stereo na največji glasnosti! Če pa nadzornik za določen čas ni ponastavljen, se bo odločil, da se je zgodilo nekaj nepričakovanega, in preprosto izvede ponastavitev.

void setup ()

{// dovolite največ 250 ms zanke wdt_enable (WDTO_250MS); // druge init stvari} void loop () {wdt_reset (); // delati stvari}

LAHKO filter? No, krmilnik CAN lahko konfigurirate tako, da zavrže vsa sporočila, ki se ne ujemajo s filtrom, tako da programski opremi ni treba izgubljati časa za sporočila, ki nas ne zanimajo.

brez podpisa dolga maska = 0x1fffffff; // V masko vključi vseh 29 bitov glave

nepodpisani dolgi filterId = 0x0400066; // Zanima nas samo to sporočilo CAN id m_can.init_Mask (0, CAN_EXTID, mask); // Maska 0 velja za filter 0-1 m_can.init_Mask (1, CAN_EXTID, maska); // Maska 1 velja za filter 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);

Za več podrobnosti o nastavitvi filtra + maske preverite kodo knjižnice CAN in dokumentacijo krmilnika CAN.

Krmilnik CAN lahko nastavite tudi tako, da ob prejemu sporočila (ki ni filtrirano) poveča prekinitev. (V zgornjem primeru ni vključeno, vendar je v mojem programu nekaj kode zanj.) V tem primeru res ne doda nobene vrednosti in bi lahko bilo zmedeno, če niste vajeni programiranja.

Skratka, to je bila prototipna programska oprema. Potrebujemo pa tudi kodo za ploščo simulatorja:

lastSentTime = 0

minDelayTime = 70 setup () {konfigurirajte zatiče A0-A5 kot izhodne zatiče, nastavite zatiče D4-D7 kot vhodne zatiče z notranjim dvigom. init CAN} loop () {send "junk" can msg set set activeButton = nič za vsak gumb {če je gumb pritisnjen {set activeButton = button}} če je activeButton! = nič {if now> lastSentTime + minDelayTime {ukaz gumba za pošiljanje lahko sporoči } nastavi lastSentTime = zdaj} inval = preberi pin A7 pred tem (cmd) {if (min <inval <max) {led on} else {led off}} počakaj 1 ms}

To bo neprekinjeno pošiljalo "neželena" sporočila CAN približno vsake ms, medtem ko je gumb pritisnjen na ustrezen ukaz vsakih 70 ms.

Morda boste morali zapisati vnos na nožici A7, medtem ko pritiskate različne gumbe, da ugotovite ustrezne vrednosti za spremenljivke min in max, ki pripadajo vsakemu gumbu. (Ali ga lahko izračunate, vendar vam bo dejansko branje vnosa dalo natančnejše vrednosti.)

Pri programiranju načinov zatičevanja morate biti previdni. Če ste pomotoma namestili zatiče, namenjene uporabi notranjega izvlečka, kot izhodne, boste ustvarili potencialno bližnjico, ki bo poškodovala vaš Arduino, ko nastavite visoko izhodno moč.

Če želite preveriti moje programe, jih lahko prenesete tukaj:

• Program za beleženje sporočil CAN
• Program za ploščo simulatorja
• Program za prototip / končno ploščo

Zavedati se morate, da se ti programi v resnici ne ujemajo s psevdo kodo, vsebujejo veliko "dodatnih" stvari, ki v resnici niso potrebne, in če niste seznanjeni s predmetno usmerjenim programiranjem, je verjetno malo težko prebrati.

7. korak: Končna strojna oprema

Ko ste zadovoljni s svojim programom (ne pozabite preizkusiti prototipa v avtomobilu po končnem testiranju s ploščo simulatorja) je čas, da sestavite pravo strojno opremo.

Tu imate tri možnosti:

• Hitro in umazano - spajajte stvari skupaj na prototipno ploščo PCB.
• Hardcore DIY - jedkajte svoje PCB.
• Leni način - naročite profesionalno tiskano vezje za spajkanje komponent.

Če se vam ne mudi, lahko priporočim zadnjo možnost. Če potrebujete le majhen PCB, kot je ta, ga je zelo poceni naročiti iz Kitajske. (In potem boste verjetno dobili približno deset kosov, da si lahko privoščite nekaj napak pri spajkanju.)

Če želite naročiti tiskane vezje, morate svoj dizajn poslati v Gerber formatu. Za to obstaja različna programska oprema. Uporabil sem Eagle, ki ga lahko priporočim. Pričakujete lahko nekaj ur, da se tega naučite, potem pa deluje dobro. Za majhne plošče, kot je ta, ga lahko uporabite brezplačno.

Pri oblikovanju bodite previdni. Ne želite čakati štiri tedne na dostavo, samo da ugotovite, da ste naredili nekaj narobe.

(Če imate dobre sposobnosti spajkanja, lahko oblikujete površinsko nameščene komponente in dobite res majhen adapter. Nisem.)

Nato naročite pri npr. https://www.seeedstudio.com/fusion_pcb.html. Sledite navodilom za ustvarjanje datotek Gerber iz vaše zasnove. Lahko dobite tudi predogled rezultata, da se prepričate, ali je v redu.

(Na koncu sem moral za R4-R7 izbrati druge upore, ki niso navedeni na sliki sheme. Namesto tega sem uporabil 2k, 4,7k, 6,8k in 14,7k.)

In zapomnite si - ne zamenjujte oštevilčenja pinov Atmega z oštevilčenjem pinov Arduino!

Priporočam, da čipa Atmega ne spajkate neposredno, ampak uporabite vtičnico. Potem ga lahko preprosto odstranite, če ga morate ponovno programirati.

8. korak: Montaža avtomobila

Zdaj pa k najbolj zabavnemu delu - namestite ga v avto in začnite uporabljati! (Ko naredite / kupite etui zanj.)

Če ste prototip že popolnoma preizkusili v svojem avtomobilu, bi moralo vse delovati odlično.

(Kot sem že omenil, tega nisem storil, zato sem moral zamenjati nekaj uporov in narediti nekaj sprememb v svojem programu.)

Razmislite tudi, ali ga namestite za stereo ali kje drugje. Nad škatlo za rokavice sem našel dobro mesto, kamor ga lahko pridem iz predala, ne da bi kaj ločil. To bi lahko bilo koristno, če se odločim za nadgradnjo pozneje.

Končno moji gumbi spet delujejo! Kako bi lahko preživel dva meseca brez njih?

9. korak: Prihodnje izboljšave

Kot sem že omenil, bom za večjo prilagodljivost 4066B zamenjal z drugim (verjetno z digitalnim potenciometrom).

Obstaja tudi veliko drugih stvari, ki jih lahko storite. Npr. dodajte modul bluetooth in naredite aplikacijo za daljinsko upravljanje za telefon. Ali pa GPS -modul, potem ko ste blizu doma, lahko samodejno povečate glasnost in pošljete sporočilo CAN "okna navzdol", tako da lahko vsi vaši sosedje uživajo v vaši čudoviti glasbi.