Arduino personalizat pentru a păstra butoanele de volan CAN cu noul sistem stereo auto: 9 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

Am decis să înlocuiesc stereo-ul auto original din Volvo V70 -02 cu un stereo nou, așa că mă voi putea bucura de lucruri precum mp3, bluetooth și handsfree.

Mașina mea are câteva comenzi pe volan pentru stereo pe care aș vrea să le pot folosi în continuare. Nu mă așteptam să fie o problemă, deoarece există mai multe adaptoare pe piață care ar trebui să fie compatibile cu mașina mea. Cu toate acestea, am aflat curând că nu erau! (Se pare că adaptoarele pentru V70 ar putea avea probleme cu -02 mașini din cauza unui protocol CAN ușor diferit.)

Deci, ce să faci atunci? Păstrați vechiul stereo? Trăiți o viață cu butoane care nu funcționează? Desigur că nu! Dacă nu există un adaptor de lucru pe piață, va trebui să construim unul!

Această instrucțiune poate fi aplicată (cu unele adaptări) mașinilor unde butoanele volanului comunică prin autobuzul CAN.

Pasul 1: Aflați cum să trimiteți comenzi la stereo

Primul lucru pe care trebuie să-l faceți este să aflați ce tip de intrare la distanță se așteaptă stereo. De obicei, producătorii nu vă vor spune asta și probabil că nici nu aveți acces la telecomenzi funcționale pentru inginerie inversă.

Telecomanda pentru noul meu stereo (Kenwood) constă dintr-un singur fir și nu am reușit să aflu informații despre cum funcționează. Cu toate acestea, are și o mufă de 3,5 mm pentru intrarea de la distanță. Nici eu nu am putut afla nimic despre asta. Dar există câteva informații despre o mufă de 3,5 mm pentru alte mărci, sugerând că diferite comenzi sunt identificate prin aplicarea unei rezistențe specifice între vârf și manșon (și opțional între inel și manșon). De exemplu. https://forum.arduino.cc/index.php?topic=230068.0. Așa că am decis să încerc, echipat cu o placă de măsurare, o grămadă de rezistențe și o mufă de 3,5 mm conectată la stereo și conectată la placă. Nimic nu a fost recunoscut la început, dar stereo-ul are un meniu „modul de învățare” și acolo comenzile ar putea fi configurate cu succes aplicând diverse rezistențe. Succes!

Cu toate acestea, am aflat ulterior că am făcut o greșeală aici: nu toate comenzile pe care stereo pare să le învețe nu ar funcționa. De exemplu. 30 kOhm a fost găsit în modul de învățare, dar nu a funcționat mai târziu și pentru unele dintre comenzile pe care le-am configurat, diferența de rezistență a fost atât de mică încât mai târziu a fost declanșată comanda greșită.

Așadar, vă recomand să utilizați o placă de rezoluție cu rezistențe și butoane de comutare pentru toate comenzile la distanță pe care doriți să le gestionați și să testați efectiv că toate vor funcționa.

Dacă stereo-ul mașinii dvs. nu poate primi intrări în același mod, va trebui să vă dați seama cum funcționează, astfel încât să puteți adapta această soluție. Dacă nu vă dați seama deloc, atunci aveți o problemă.

Pasul 2: Aflați unde să vă conectați la magistrala CAN

Trebuie să localizați un loc bun pentru a vă conecta la autobuzul CAN. Deoarece înlocuiți un stereo vechi care comunică prin CAN, ar trebui să îl puteți găsi în spatele stereo-ului. Autobuzul CAN constă dintr-o pereche de fire răsucite (CAN-L și CAN_H). Consultați o schemă de cabluri pentru mașina dvs. pentru a fi sigur.

Pasul 3: Inginerie inversă a mesajelor CAN

Cu excepția cazului în care Google vă poate spune ce mesaje CAN ar trebui să ascultați, va trebui să vă conectați la magistrala CAN și să faceți o inginerie inversă. Am folosit un Arduino Uno și un scut CAN. (Nu prea aveți nevoie de scutul CAN, așa cum veți vedea mai târziu, puteți folosi în schimb câteva componente ieftine pe o placă de măsurare.)

Consultați Google pentru a afla ce viteză de transmisie ar trebui să utilizați atunci când vă conectați la mașină. (De obicei, veți găsi că există o rețea CAN de viteză mare și de viteză mică. Vă conectați la rețeaua de viteză mică.)

De asemenea, va trebui să programați Arduino pentru a înregistra toate mesajele CAN prin interfața serială, astfel încât să le puteți salva într-un fișier jurnal de pe computer. IDE-ul standard Arduino nu va salva date într-un fișier jurnal, dar puteți utiliza de ex. Chit în schimb.

Înainte de a începe să scrieți programul, trebuie să instalați biblioteca CAN_BUS_Shield.

Iată câteva pseudo-coduri pentru a vă ajuta să începeți programul:

înființat()

{init conexiune serială init bibliotecă CAN} buclă () {dacă mesajul CAN este primit {citiți mesajul CAN format jurnal intrare jurnal scrie intrare jurnal în serie}}

Sugestii:

Veți utiliza o instanță din clasa MCP_CAN pentru a accesa funcționalitatea bibliotecii CAN:

MCP_CAN m_can;

Init CAN:

while (m_can.begin ()! = CAN_OK)

{întârziere (1000); }

Căutați și citiți mesaje CAN:

while (m_can.checkReceive () == CAN_MSGAVAIL)

{// Obțineți codul CAN, lungimea mesajului și datele mesajului m_can.readMsgBufID (& m_canId, & m_msgLen, m_msgBuf); // Faceți ceva cu datele mesajului aici}

Dacă aveți nevoie de mai mult ajutor, puteți găsi un link către programul meu într-un pas ulterior. Biblioteca CAN shield include, de asemenea, un exemplu. Sau verificați instructivitatea mviljoen2 care include un pas similar.

Mai întâi veți avea nevoie de un fișier de referință pentru a vă ajuta să filtrați datele. Comutați contactul în modul radio și înregistrați totul timp de câteva minute fără a atinge niciun buton.

Apoi, pentru fiecare dintre butoane, începeți înregistrarea, apăsați butonul și opriți înregistrarea.

Când ați terminat, trebuie să filtrați tot ce este în jurnalul de referință din jurnalele butoanelor pentru a vă găsi candidații. Am aflat că mai sunt încă multe mesaje așa că am făcut mai multe jurnale și apoi am solicitat ca „candidații la comanda A să fie în toate butoanele-A-fișiere și în niciunul din fișierele de referință”. Asta mi-a lăsat doar câteva posibilități de încercare.

Jurnalele vor conține o mulțime de mesaje, așa că va trebui să scrieți un program pentru acest lucru sau, eventual, să utilizați Excel. (Am folosit un program cu condiții codate foarte greu pentru nevoile mele, așa că mă tem că nu pot oferi un program pe care îl puteți folosi.)

Un avertisment: nu puteți fi sigur că un buton va produce întotdeauna un mesaj identic. Unii dintre biți ar putea conține contoare de incrementare etc.

Dacă se întâmplă să aveți un Volvo V70 -02, asta urmăriți:

• ID mesaj: 0x0400066Byte0: 0x00, 0x40, 0x80 sau 0xc0 (nu-mi pasă)
• Byte1: 0x00 (nu-i pasă)
• Byte2: 0x00 (nu-i pasă)
• Byte3: 0x00-0x07 (nu-i pasă)
• Byte4: 0x1f (nu-i pasă)
• Byte5: 0x40 (nu-i pasă)
• Byte6: 0x40 (nu-i pasă)
• Byte7: identificator buton: 0x77 = creșterea volumului, 0x7b = reducerea volumului, 0x7d = pista următoare, 0x7e = pista precedentă.

Când credeți că ați găsit comenzile, ar putea fi o idee bună să modificați programul astfel încât să înregistreze doar mesajele interesante. Uitați-vă la fereastra jurnalului serial în timp ce apăsați butoanele pentru a verifica dacă ați identificat mesajele corecte.

Pasul 4: Prototipul hardware

Hardware-ul dvs. trebuie să fie capabil să:

1. Identificați comenzile primite pe magistrala CAN
2. Trimiteți comenzi în alt format către stereo

Dacă aveți suficient spațiu, puteți utiliza un Arduino și un scut CAN pentru prima parte și puteți atașa hardware suplimentar pentru a doua. Cu toate acestea, există unele dezavantaje:

• Costul scutului CAN
• mărimea
• Sursa de alimentare Arduino nu va fi fericită dacă este conectată direct la mașinile dvs. de 12V (probabil va funcționa, dar viața sa va fi scurtată probabil).

Deci, în schimb, am folosit următoarele:

• Atmega 328, „creierul Arduino”. (Există câteva variante, obțineți cea care este egală cu cea de pe Arduino Uno. Puteți să o cumpărați cu sau fără încărcătorul de încărcare Arduino.)
• Cristal de 16 MHz + condensatori pentru semnal de ceas.
• Transmițător CAN MCP2551.
• Controler CAN MCP2515.
• TSR1-2450, convertește 6,5-36V în 5V. (Nu este utilizat în prototip, deoarece software-ului nu îi pasă de sursa de alimentare.)
• Comutator CD4066B care va fi utilizat la trimiterea comenzilor către stereo.
• Câteva rezistențe. (Valorile pot fi găsite în schemele Eagle într-un pas ulterior.)

Un lucru bun cu această configurație este că este pe deplin compatibil cu Arduino și biblioteca CAN shield.

Dacă doriți să gestionați mai mult de patru butoane, vă recomandăm să utilizați altceva decât CD4066B. CD4066B poate fi descris ca patru comutatoare într-unul, fiecare controlat de unul dintre pinii Atmegas GPIO. La fiecare comutator există un rezistor conectat care poate fi utilizat pentru a controla rezistența utilizată ca intrare la stereo. Deci, acest lucru poate fi utilizat cu ușurință pentru a trimite patru comenzi diferite. Dacă sunt combinate, se pot obține valori de rezistență suplimentare. Aici intervine greșeala pe care am menționat-o mai devreme. Am patru butoane, dar am intenționat să implementez două dintre ele cu o apăsare lungă și scurtă pentru a-mi da șase comenzi diferite. Dar, în cele din urmă, am aflat că nu găsesc o combinație de rezistențe care să-mi ofere șase combinații de lucru. Probabil ar fi posibil să conectați un semnal de ieșire analogică la stereo (vârf de 3,5 mm). (Rețineți că Atmega nu are pini de ieșire analogici adevărați, așa că ar fi necesară hardware suplimentară.)

În scopuri de testare, am realizat și un simulator simplu „auto și stereo” pentru conectarea la prototipul meu. Face depanarea mai ușoară și dacă nu vă place să stați în mașină și să programați, vă pot recomanda asta.

Prototipul este ilustrat de panoul inferior din imagine. Pentru alimentare, programare și înregistrare în serie, este atașat la un Arduino Uno unde a fost îndepărtat cipul Atmega.

Panoul superior este simulatorul auto + stereo care va fi utilizat pentru testarea inițială a prototipului.

Simulatorul prototip + este destinat să funcționeze astfel:

• Apăsați unul dintre butoanele de comutare de pe placa simulatorului. (Acestea sunt butoanele voastre ale volanului.)
• Când programul simulator detectează apăsarea unui buton, acesta va trimite mesajul CAN corespunzător la fiecare 70 ms atâta timp cât butonul este apăsat. (Deoarece jurnalele pe care le-am luat mai devreme indicau că așa funcționează în mașina mea.) De asemenea, va trimite o mulțime de mesaje CAN „nedorite” pentru a simula alt trafic pe autobuz.
• Mesajele CAN sunt trimise pe magistrala CAN.
• Mesajele CAN sunt primite de prototip.
• MCP2515 aruncă toate mesajele fără legătură pe baza id-ului mesajului.
• Când MCP2515 primește un mesaj care ar trebui tratat, acesta va indica faptul că are un mesaj pus în coadă.
• Atmega va citi mesajul și va decide ce buton ar trebui considerat activ.
• Atmega va urmări, de asemenea, când a fost primit ultimul mesaj, după un anumit timp, butonul va fi considerat eliberat. (Mesajele CAN indică doar că un buton este oprit, nu că a fost apăsat sau eliberat.)
• Dacă un buton este considerat activ, atunci unul sau mai multe comutatoare din CD4066B vor fi activate.
• Simulatorul (care acționează acum ca stereo) va detecta că se aplică o rezistență între vârf și manșon. (Vârful este conectat la 3,3 V și printr-un rezistor la un pin analogic de intrare. Când nu este activă nicio comandă, acest pin va citi 3,3 V, când o comandă este activă, valoarea va deveni mai mică și va identifica comanda.
• În timp ce o comandă este activă, ledul corespunzător va fi, de asemenea, activat. (Există șase leduri, deoarece am planificat să folosesc diferite apăsări lungi / scurte pentru două dintre butoanele mele.)

Pentru mai multe detalii despre hardware-ul prototip, consultați schemele Eagle într-un pas ulterior.

Detalii suplimentare despre hardware-ul simulatorului:

• Cristal de 16 MHz
• Condensatoare de 22 pF
• Rezistențele cu LED-uri ar trebui selectate pe baza proprietăților LED-urilor
• Rezistor conectat la A7 și 3.3V, selectați de ex. 2kOhm (nu este critic).
• Rezistoarele conectate la MCP2551 și MCP2515 sunt pull-up / pull-down. Selectați de ex. 10 kOhm.

(Sau puteți utiliza scutul CAN pentru „partea CAN” a simulatorului, dacă preferați.)

Este important să știți cum sunt mapate pinii Atmega la pinii Arduino atunci când proiectați hardware-ul.

(Nu conectați leduri direct la CD 4066B, acesta poate gestiona doar un curent redus. Am încercat asta când am testat prima dată ieșirea și cipul a devenit inutil. Lucrul bun este că am cumpărat câteva dintre ele doar pentru că sunt atât de ieftine.)

Pasul 5: Programarea siguranțelor

Poate ați observat în pasul anterior că prototipul nu are componente separate pentru a genera semnalul de ceas către MCP2515. Asta pentru că există deja un cristal de 16 MHz folosit ca semnal de ceas Atmega pe care îl putem folosi. Dar nu îl putem conecta direct la MCP2515 și implicit nu există semnal de ieșire pe Atmega.

(Dacă preferați, puteți sări peste acest pas și să adăugați în schimb hardware suplimentar pentru ceas.)

Cu toate acestea, putem folosi ceva numit „programare a siguranței” pentru a activa un semnal de ieșire pe unul dintre pinii GPIO.

Mai întâi va trebui să localizați un fișier numit „boards.txt” utilizat de ID-ul dvs. Arduino. Va trebui să copiați intrarea pentru Arduino Uno, să îi dați un nume nou și să modificați valoarea pentru low_fuses.

Noul meu forum arată astfel:

###################################################### ############# # Bazat pe Arduino Uno # Modificări: # low_fuses s-au schimbat de la 0xff la 0xbf pentru a activa ceasul de 16 MHz # out pe 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.extended_fuses = 0xd.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 clkuno

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

Rețineți că ceasul este activat setând bitul de control la 0.

După ce ați creat noua placă în fișierul de configurare a plăcilor, va trebui să ardeți un nou încărcător de încărcare pe Atmega. Există diverse modalități de a face acest lucru, am folosit metoda descrisă în

După ce ați făcut acest lucru, nu uitați să selectați noul tip de placă și nu Arduino Uno atunci când încărcați un program pe Atmega.

Pasul 6: Software-ul

E timpul să faceți hardware-ul stupid inteligent prin adăugarea unor programe software.

Iată câteva pseudo-coduri pentru prototip:

lastReceivedTime = 0

lastReceivedCmd = none cmdTimeout = 100 setup () {activate watchdog configure pins D4-D7 as output pins init CAN setup CAN filter} loop () {resetare watchdog if (mesaj CAN este primit) {pentru fiecare comandă buton {dacă mesajul CAN aparține comanda buton {lastReceivedTime = acum lastReceivedCmd = cmd}}} dacă acum> lastReceivedTime + cmdTimeout {lastReceivedCmd = none} pentru fiecare comandă buton {dacă lastReceivedCmd este comanda buton {set command pin output = on} else {set command pin output = off }}}

cmdTimeout decide cât timp ar trebui să așteptăm înainte să luăm în considerare ultimul buton activ lansat. Deoarece comenzile de mesaje ale butonului CAN sunt trimise aproximativ la fiecare 70 ms, acesta trebuie să fie mai mare decât cel cu o anumită marjă. Dar dacă este prea mare, va exista o experiență de întârziere. Deci 100 ms pare un candidat bun.

Dar ce este un câine de pază? Este o mică caracteristică hardware utilă care ne poate salva în caz de avarie. Imaginați-vă că avem o eroare care a provocat blocarea programului în timp ce comanda de creștere a volumului este activă. Apoi am ajunge cu stereo pe volumul maxim! Dar dacă câinele de supraveghere nu este resetat pentru timpul specific, va decide că s-a întâmplat ceva neașteptat și va emite pur și simplu o resetare.

configurare nulă ()

{// permite maxim 250 ms pentru bucla wdt_enable (WDTO_250MS); // alte lucruri init} bucla void () {wdt_reset (); // face lucruri}

POATE filtra? Ei bine, puteți configura controlerul CAN pentru a elimina toate mesajele care nu se potrivesc cu filtrul, astfel încât software-ul să nu trebuiască să piardă timpul cu mesajele de care nu ne interesează.

mască lungă nesemnată = 0x1fffffff; // Includeți toți cei 29 de biți de antet în mască

filtru lung nesemnat = 0x0400066; // Ne pasă doar de acest mesaj CAN id m_can.init_Mask (0, CAN_EXTID, mask); // Masca 0 se aplică filtrului 0-1 m_can.init_Mask (1, CAN_EXTID, mască); // Masca 1 se aplică filtrului 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);

Verificați codul bibliotecii CAN și documentația controlerului CAN pentru mai multe detalii despre modul de configurare a filtrului + mască.

De asemenea, puteți configura controlerul CAN pentru a declanșa o întrerupere la primirea unui mesaj (care nu este filtrat). (Nu este inclus în exemplul de mai sus, dar există un cod pentru acesta în programul meu.) În acest caz, nu prea adaugă nicio valoare și ar putea fi confuz dacă nu sunteți obișnuiți cu programarea.

Deci acesta a fost rezumatul software-ului prototip. Dar avem nevoie de ceva cod și pentru placa simulatorului:

lastSentTime = 0

minDelayTime = 70 setup () {configure pins A0-A5 as output pins configure pins D4-D7 as pins input with pullup internal. init CAN} loop () {send "junk" can msg set activeButton = none for each button {dacă butonul este apăsat {set activeButton = button}} if activeButton! = none {if now> lastSentTime + minDelayTime {send button command can message } set lastSentTime = now} invalid = read pin A7 foreach (cmd) {if (min <inval <max) {led on} else {led off}} așteptați 1 ms}

Aceasta va trimite în mod continuu mesaje CAN „nedorite” aproximativ la fiecare ms și în timp ce un buton este apăsat, comanda corespunzătoare la fiecare 70 ms.

S-ar putea să fie nevoie să înregistrați intrarea pe pinul A7 în timp ce apăsați diferitele butoane pentru a afla valorile potrivite pentru variabilele min și max aparținând fiecărui buton. (Sau îl puteți calcula, dar de fapt citirea intrării vă va oferi valori mai precise.)

Trebuie să fiți puțin atenți atunci când programați modurile pin. Dacă în mod accidental setați pinii intenționați să utilizeze pullup intern ca pin de ieșire, atunci veți crea o scurtătură potențială care vă va deteriora Arduino atunci când setați ieșirea ridicată.

Dacă doriți să verificați programele mele, acestea pot fi descărcate de aici:

• Program de înregistrare a mesajelor CAN
• Program pentru placa simulatorului
• Program pentru prototip / tablă finală

Trebuie să știți că acele programe nu se potrivesc cu pseudocodul aici, conțin o mulțime de lucruri „suplimentare” care nu sunt cu adevărat necesare și dacă nu sunteți familiarizat cu programarea orientată pe obiecte, poate fi puțin dificil de citit.

Pasul 7: Hardware-ul final

Când sunteți mulțumit de programul dvs. (nu uitați să testați prototipul în mașină după testarea finală cu placa simulatorului) este timpul să construiți hardware-ul real.

Aici aveți trei opțiuni:

• Rapid și murdar - lipiți lucrurile împreună pe o placă prototip PCB.
• DIY hardcore - gravează-ți propriul PCB.
• Modul leneș - comandați un PCB profesional pentru a lipi componentele.

Dacă nu vă grăbiți, vă pot recomanda ultima opțiune. Dacă aveți nevoie doar de un PCB mic ca acesta, este foarte ieftin să îl comandați din China. (Și atunci veți obține probabil zece piese sau cam așa pentru a vă permite niște greșeli de lipire.)

Pentru a comanda PCB-uri, va trebui să trimiteți designul în format Gerber. Există diverse programe pentru acest lucru. Am folosit Eagle pe care îl pot recomanda. Vă puteți aștepta la câteva ore să îl învățați, dar apoi funcționează bine. Pentru placi mici ca aceasta o puteți folosi gratuit.

Aveți grijă când faceți designul. Nu doriți să așteptați patru săptămâni pentru livrare doar pentru a afla că ați făcut ceva greșit.

(Dacă aveți abilități bune de lipire, puteți proiecta pentru componente montate la suprafață și puteți obține un adaptor foarte mic. Nu am făcut-o.)

Apoi comandați de ex. https://www.seeedstudio.com/fusion_pcb.html. Urmați instrucțiunile pentru cum să generați fișierele Gerber din designul dvs. De asemenea, puteți obține o previzualizare a rezultatului pentru a vă asigura că este în regulă.

(În cele din urmă a trebuit să selectez alte rezistențe pentru R4-R7 decât cele enumerate în imaginea schematică. În schimb, am folosit 2k, 4.7k, 6.8k și 14.7k.)

Și amintiți-vă - nu confundați numerotarea pinilor Atmega cu numerotarea pinilor Arduino!

Vă recomand să nu lipiți direct cipul Atmega, ci să utilizați o priză. Apoi îl puteți elimina cu ușurință în cazul în care trebuie să îl reprogramați.

Pasul 8: Montarea mașinii

Acum, până la partea cea mai distractivă - montați-l în mașină și începeți să-l utilizați! (După ce ați creat / cumpărat o husă pentru aceasta.)

Dacă ați testat deja complet prototipul în mașină, totul ar trebui să funcționeze perfect.

(Așa cum am menționat mai devreme, nu am făcut-o, așa că a trebuit să înlocuiesc unele rezistențe și să fac unele schimbări în programul meu.)

Luați în considerare, de asemenea, dacă ar trebui să-l montați în spatele stereo sau în altă parte. Am găsit un loc bun deasupra cutiei cu mănuși, unde pot ajunge din interiorul cutiei cu mănuși, fără a desprinde nimic. Acest lucru ar putea fi util dacă decid să îl actualizez mai târziu.

În cele din urmă, butoanele mele funcționează din nou! Cum aș putea supraviețui două luni fără ei?

Pasul 9: Îmbunătățiri viitoare

După cum am menționat, dacă fac o versiune 2.0 a acestei, voi înlocui 4066B cu altceva (probabil un potențiometru digital) pentru o mai mare flexibilitate.

Există, de asemenea, o mulțime de alte lucruri pe care le puteți face. De exemplu. adăugați un modul bluetooth și creați o aplicație de telecomandă pentru telefon. Sau un modul GPS, atunci când sunteți aproape de casă puteți crește automat volumul și trimite mesajul „Windows down” CAN, astfel încât toți vecinii să se bucure de muzica dvs. minunată.