Arduino personalizzato per mantenere i pulsanti del volante CAN con la nuova autoradio: 9 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

Ho deciso di sostituire l'autoradio originale della mia Volvo V70 -02 con un nuovo stereo così potrò godermi cose come mp3, bluetooth e vivavoce.

La mia macchina ha alcuni comandi al volante per lo stereo che vorrei poter usare ancora. Non mi aspettavo che fosse un problema perché ci sono diversi adattatori sul mercato che dovrebbero essere compatibili con la mia auto. Tuttavia ho scoperto presto che non lo erano! (Sembra che gli adattatori per V70 potrebbero avere problemi con le auto -02 a causa di un protocollo CAN leggermente diverso.)

Allora cosa fare? Tieni il vecchio stereo? Vivi una vita con pulsanti non funzionanti? Ovviamente no! Se non esiste un adattatore funzionante sul mercato, dovremo costruirne uno!

Questa istruzione può essere applicata (con alcuni adattamenti) alle auto in cui i pulsanti del volante comunicano tramite il bus CAN.

Passaggio 1: scopri come inviare comandi allo stereo

La prima cosa da fare è scoprire quale tipo di ingresso remoto si aspetta lo stereo. In genere i produttori non te lo diranno e probabilmente non avrai nemmeno accesso a telecomandi funzionanti per il reverse engineering.

Il telecomando del mio nuovo stereo (Kenwood) è costituito da un singolo cavo e non sono riuscito a trovare alcuna informazione su come funziona. Tuttavia ha anche un jack da 3,5 mm per l'ingresso remoto. Nemmeno io sono riuscito a scoprire nulla al riguardo. Ma ci sono alcune informazioni su un jack da 3,5 mm per altre marche che suggeriscono che i diversi comandi vengono identificati applicando una resistenza specifica tra punta e manicotto (e facoltativamente tra anello e manicotto). Per esempio. https://forum.arduino.cc/index.php?topic=230068.0. Così ho deciso di provarlo, equipaggiato con una breadboard, un mucchio di resistori e una spina da 3,5 mm collegata allo stereo e collegata alla breadboard. All'inizio non è stato riconosciuto nulla, ma lo stereo ha un menu "modalità di apprendimento" e lì i comandi potrebbero essere impostati con successo applicando varie resistenze. Successo!

Tuttavia, in seguito ho scoperto di aver commesso un errore qui: non tutti i comandi che lo stereo sembrava apprendere avrebbero effettivamente funzionato. Per esempio. 30 kOhm è stato trovato in modalità di apprendimento ma non ha funzionato in seguito e per alcuni dei comandi che ho impostato la differenza di resistenza era così piccola che in seguito è stato attivato il comando sbagliato.

Quindi ti consiglio di utilizzare una breadboard con resistori e pulsanti di commutazione per tutti i comandi remoti che vuoi gestire e testare effettivamente che tutti funzionino.

Se la tua autoradio non può ricevere input allo stesso modo, dovrai capire come funziona in modo da poter adattare questa soluzione. Se non riesci a capire affatto, allora hai un problema.

Passaggio 2: scopri dove collegarti al bus CAN

È necessario individuare un buon punto per connettersi al bus CAN. Dal momento che stai sostituendo un vecchio stereo che comunica su CAN dovresti essere in grado di trovarlo dietro lo stereo. Il bus CAN è costituito da una coppia di fili intrecciati (CAN-L e CAN_H). Consulta uno schema elettrico per la tua auto per essere sicuro.

Passaggio 3: ingegneria inversa dei messaggi CAN

A meno che Google non possa dirti quali messaggi CAN dovresti ascoltare, dovrai connetterti al bus CAN e fare un po' di reverse engineering. Ho usato un Arduino Uno e uno shield CAN. (Non hai davvero bisogno dello scudo CAN, come vedrai in seguito puoi invece usare alcuni componenti economici su una breadboard.)

Consulta Google per scoprire quale baud rate dovresti usare quando ti colleghi alla tua auto. (In genere scoprirai che c'è una rete CAN ad alta velocità e una a bassa velocità. Ti stai collegando alla rete a bassa velocità.)

Dovrai anche programmare Arduino per registrare tutti i messaggi CAN sull'interfaccia seriale in modo da poterli salvare in un file di registro sul tuo computer. L'IDE Arduino standard non salverà i dati in un file di registro ma puoi usare ad es. Mastice invece.

Prima di iniziare a scrivere il tuo programma devi installare la libreria CAN_BUS_Shield.

Ecco alcuni pseudo codici per aiutarti a iniziare con il tuo programma:

impostare()

{ init serial connection init CAN library } loop() { se il messaggio CAN viene ricevuto { read CAN message format log entry scrivi log entry to serial } }

Suggerimenti:

Utilizzerai un'istanza della classe MCP_CAN per accedere alla funzionalità della libreria CAN:

MCP_CAN m_can;

Inizializzazione CAN:

while (m_can.begin() != CAN_OK)

{ ritardo(1000); }

Controllare e leggere i messaggi CAN:

while(m_can.checkReceive() == CAN_MSGAVAIL)

{ // Ottieni l'ID CAN, la lunghezza del messaggio e i dati del messaggio m_can.readMsgBufID(&m_canId, &m_msgLen, m_msgBuf); // Fai qualcosa con i dati del messaggio qui }

Se hai bisogno di ulteriore aiuto puoi trovare un collegamento al mio programma in un passaggio successivo. La libreria CAN shield include anche un esempio. Oppure controlla l'istruzione di mviljoen2 che include un passaggio simile.

Per prima cosa avrai bisogno di un file di riferimento per aiutarti a filtrare i dati. Metti l'accensione in modalità radio e registra tutto per un paio di minuti senza toccare alcun pulsante.

Quindi, per ciascuno dei pulsanti, avviare la registrazione, premere il pulsante e interrompere la registrazione.

Quando hai finito, devi filtrare tutto ciò che è nel tuo registro di riferimento dai registri dei pulsanti per trovare i tuoi candidati. Ho scoperto che c'erano ancora molti messaggi rimasti, quindi ho creato più registri e poi ho richiesto che "i candidati per il comando A devono essere in tutti i file del pulsante A e in nessuno dei file di riferimento". Questo mi ha lasciato solo poche possibilità di provare.

I registri conterranno molti messaggi, quindi dovrai scrivere un programma per questo o possibilmente usare Excel. (Ho usato un programma con condizioni molto codificate per le mie esigenze, quindi temo di non poter offrire un programma che tu possa usare.)

Un avvertimento: non puoi essere sicuro che un pulsante produrrà sempre un messaggio identico. Alcuni bit potrebbero contenere contatori incrementali, ecc. (Tuttavia, è possibile escludere che l'id del messaggio sia lo stesso).

Se ti capita di avere una Volvo V70 -02, questo è quello che cerchi:

• ID messaggio: 0x0400066Byte0: 0x00, 0x40, 0x80 o 0xc0 (non importa)
• Byte1: 0x00 (non importa)
• Byte2: 0x00 (non importa)
• Byte3: 0x00-0x07 (non importa)
• Byte4: 0x1f (non importa)
• Byte5: 0x40 (non importa)
• Byte6: 0x40 (non importa)
• Byte7: Identificatore del pulsante: 0x77 = volume su, 0x7b = volume giù, 0x7d = traccia successiva, 0x7e = traccia precedente.

Quando ritieni di aver trovato i comandi potrebbe essere una buona idea modificare il programma in modo che registri solo i messaggi interessanti. Guarda la finestra del registro seriale mentre premi i pulsanti per verificare di aver identificato i messaggi corretti.

Passaggio 4: il prototipo hardware

Il tuo hardware deve essere in grado di:

1. Identificare i comandi ricevuti sul bus CAN
2. Invia comandi in un altro formato allo stereo

Se hai abbastanza spazio puoi usare un Arduino e uno shield CAN per la prima parte e collegare dell'hardware aggiuntivo per la seconda. Tuttavia ci sono alcuni inconvenienti:

• Costo della schermatura CAN
• Taglia
• L'alimentatore Arduino non sarà contento se è collegato direttamente alla tua auto a 12V (probabilmente funzionerà ma la sua vita sarà probabilmente accorciata).

Quindi invece ho usato quanto segue:

• Atmega 328, il "cervello Arduino". (Ci sono alcune varianti, prendi quella uguale a quella su Arduino Uno. Puoi acquistarla con o senza boot loader Arduino.)
• Cristallo da 16 MHz + condensatori per segnale di clock.
• Ricetrasmettitore CAN MCP2551.
• Controllore CAN MCP2515.
• TSR1-2450, converte 6.5-36V in 5V. (Non utilizzato nel prototipo perché il software non si preoccupa dell'alimentazione.)
• Interruttore CD4066B che verrà utilizzato quando si inviano comandi allo stereo.
• Un paio di resistori. (I valori possono essere trovati negli schemi Eagle in un passaggio successivo.)

Un aspetto positivo di questa configurazione è che è completamente compatibile con Arduino e la libreria CAN shield.

Se vuoi gestire più di quattro pulsanti potresti prendere in considerazione l'utilizzo di qualcos'altro oltre al CD4066B. Il CD4066B può essere descritto come quattro interruttori in uno, ciascuno controllato da uno dei pin Atmegas GPIO. Ad ogni interruttore è collegata una resistenza che può essere utilizzata per controllare la resistenza utilizzata come ingresso allo stereo. Quindi questo può essere facilmente utilizzato per inviare quattro diversi comandi. Se vengono combinati, è possibile ottenere valori di resistenza aggiuntivi. È qui che entra in gioco l'errore che ho menzionato prima. Ho quattro pulsanti, ma ho pianificato di implementarne due come pressione lunga e breve per darmi sei comandi diversi. Ma alla fine ho scoperto che non riuscivo a trovare una combinazione di resistori che mi avrebbe dato sei combinazioni funzionanti. Probabilmente sarebbe invece possibile collegare un segnale di uscita analogica allo stereo (punta da 3,5 mm). (Si noti che l'Atmega non ha veri pin di uscita analogici, quindi sarebbe necessario dell'hardware aggiuntivo.)

A scopo di test ho realizzato anche un semplice simulatore "auto e stereo" da collegare al mio prototipo. Semplifica il debug e, a meno che non ti piaccia sederti in macchina e programmare, posso consigliarlo.

Il prototipo è illustrato dalla breadboard inferiore nell'immagine. Per l'alimentazione, la programmazione e la registrazione seriale è collegato a un Arduino Uno dove è stato rimosso il chip Atmega.

La breadboard superiore è il simulatore auto + stereo che verrà utilizzato per i primi test del prototipo.

Il prototipo + simulatore è pensato per funzionare in questo modo:

• Premi uno dei pulsanti di commutazione sulla scheda del simulatore. (Questi sono i pulsanti del volante.)
• Quando il programma del simulatore rileva la pressione di un pulsante, invia il messaggio CAN corrispondente ogni 70 ms finché il pulsante viene premuto. (Perché i registri che ho preso in precedenza indicavano che è così che funziona nella mia auto.) Invierà anche molti messaggi CAN "spazzatura" per simulare altro traffico sul bus.
• I messaggi CAN vengono inviati sul bus CAN.
• I messaggi CAN vengono ricevuti dal prototipo.
• L'MCP2515 genera tutti i messaggi non correlati in base all'ID messaggio.
• Quando l'MCP2515 riceve un messaggio che deve essere gestito, indicherà che ha un messaggio in coda.
• L'Atmega leggerà il messaggio e deciderà quale pulsante deve essere considerato attivo.
• L'Atmega terrà traccia anche di quando è stato ricevuto l'ultimo messaggio, dopo un certo tempo il pulsante si riterrà rilasciato. (I messaggi CAN indicano solo che un pulsante è premuto, non che è stato premuto o rilasciato.)
• Se un pulsante è considerato attivo, verranno attivati uno o più interruttori nel CD4066B.
• Il simulatore (che ora funge da stereo) rileverà che viene applicata una resistenza tra punta e manicotto. (La punta è collegata a 3,3 V e tramite un resistore a un pin di ingresso analogico. Quando nessun comando è attivo questo pin leggerà 3,3 V, quando un comando è attivo il valore si abbasserà e identificherà il comando.
• Mentre è attivo un comando si attiverà anche il led corrispondente. (Ci sono sei led perché ho pianificato di usare diverse pressioni lunghe / brevi per due dei miei pulsanti.)

Per maggiori dettagli sull'hardware del prototipo, vedere gli schemi Eagle in un passaggio successivo.

Ulteriori dettagli sull'hardware della scheda del simulatore:

• Cristallo da 16 MHz
• Condensatori da 22 pF
• I resistori LED devono essere selezionati in base alle proprietà del LED
• Resistenza collegata a A7 e 3.3V, selezionare ad es. 2kOhm (non critico).
• I resistori collegati a MCP2551 e MCP2515 sono pull-up/pull-down. Seleziona ad es. 10 kOhm.

(Oppure puoi usare lo scudo CAN per la "parte CAN" del simulatore, se preferisci.)

È importante sapere come i pin Atmega sono mappati sui pin Arduino quando si progetta l'hardware.

(Non collegare nessun led direttamente al CD 4066B, può gestire solo una bassa corrente. L'ho provato quando ho testato per la prima volta l'uscita e il chip è diventato inutile. La cosa buona è che ne avevo comprati un paio solo perché sono così economici.)

Passaggio 5: programmazione dei fusibili

Forse hai notato nel passaggio precedente che il prototipo non ha componenti separati per generare il segnale di clock per l'MCP2515. Questo perché esiste già un cristallo da 16 MHz utilizzato come segnale di clock Atmega che possiamo utilizzare. Ma non possiamo semplicemente collegarlo direttamente all'MCP2515 e per impostazione predefinita non c'è segnale di clock out sull'Atmega.

(Se preferisci, puoi saltare questo passaggio e aggiungere invece l'hardware dell'orologio extra.)

Tuttavia possiamo usare qualcosa chiamato "programmazione dei fusibili" per abilitare un segnale di clock out su uno dei pin GPIO.

Per prima cosa dovrai individuare un file chiamato "boards.txt" utilizzato dal tuo IDE Arduino. Dovrai copiare la voce per Arduino Uno, dargli un nuovo nome e modificare il valore per low_fuses.

La mia nuova scheda si presenta così:

################################################# ############ # Basato su Arduino Uno # Modifiche: # low_fuses cambiato da 0xff a 0xbf per abilitare il clock a 16 MHz # out su 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=0xfd clkuno.pathuno.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 clkunovari.build.core.buildild

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

Notare che il clock out viene attivato impostando il suo bit di controllo su 0.

Dopo aver creato la nuova scheda nel file di configurazione delle schede, dovrai masterizzare un nuovo boot loader sull'Atmega. Ci sono vari modi per farlo, io ho usato il metodo descritto in

Dopo averlo fatto, ricordati di selezionare il tuo nuovo tipo di scheda e non Arduino Uno quando carichi un programma su Atmega.

Passaggio 6: il software

È ora di rendere intelligente l'hardware stupido aggiungendo del software.

Ecco alcuni pseudo codice per il prototipo:

lastReceivedTime = 0

lastReceivedCmd = nessuno cmdTimeout = 100 setup() { abilita watchdog configura i pin D4-D7 come pin di uscita init CAN setup CAN filter } loop() { reset watchdog se (viene ricevuto un messaggio CAN) { per ogni comando pulsante { se il messaggio CAN appartiene a the button command { lastReceivedTime = now lastReceivedCmd = cmd } } } if now > lastReceivedTime + cmdTimeout { lastReceivedCmd = none } for each button command { if lastReceivedCmd è button command { set command pin output = on } else { set command pin output = off } } }

cmdTimeout decide quanto tempo dobbiamo aspettare prima di considerare l'ultimo pulsante attivo rilasciato. Poiché i comandi del messaggio CAN del pulsante vengono inviati circa ogni 70 ms, è necessario che sia maggiore di quello con un certo margine. Ma se è troppo grande ci sarà un'esperienza di lag. Quindi 100 ms sembrano un buon candidato.

Ma cos'è un cane da guardia? È una piccola funzionalità hardware utile che può salvarci in caso di crash. Immagina di avere un bug che causa l'arresto anomalo del programma mentre è attivo il comando di aumento del volume. Quindi finiremmo con lo stereo al massimo volume! Ma se il watchdog non viene ripristinato per il tempo specifico, deciderà che è successo qualcosa di imprevisto e emetterà semplicemente un ripristino.

configurazione nulla()

{ // consenti max 250 ms per il ciclo wdt_enable(WDTO_250MS); // altre cose iniziali } void loop() { wdt_reset(); // fare cose }

PU filtrare? Bene, puoi configurare il controller CAN per scartare tutti i messaggi che non corrispondono al filtro in modo che il software non debba perdere tempo con messaggi che non ci interessano.

maschera lunga senza segno = 0x1fffffff; // Include tutti i 29 bit di intestazione nella maschera

filterId lungo senza segno = 0x0400066; // Ci interessa solo questo messaggio CAN id m_can.init_Mask(0, CAN_EXTID, mask); // La maschera 0 si applica al filtro 0-1 m_can.init_Mask(1, CAN_EXTID, mask); // La maschera 1 si applica al filtro 2-5 m_can.init_Filt(0, CAN_EXTID, filterId); m_can.init_Filt(, CAN_EXTID, filterId); m_can.init_Filt(, 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);

Controllare il codice della libreria CAN e la documentazione del controller CAN per maggiori dettagli su come impostare filtro + maschera.

È inoltre possibile impostare il controller CAN per generare un'interruzione quando viene ricevuto un messaggio (non filtrato). (Non incluso nell'esempio sopra, ma c'è del codice per questo nel mio programma.) In questo caso non aggiunge alcun valore e potrebbe creare confusione se non sei abituato alla programmazione.

Quindi questo era il software prototipo in sintesi. Ma abbiamo bisogno anche del codice per la scheda del simulatore:

lastSentTime = 0

minDelayTime = 70 setup() { configura i pin A0-A5 come pin di output configura i pin D4-D7 come pin di input con pullup interno. init CAN } loop() { invia "junk" can msg set activeButton = none per ogni pulsante { se il pulsante viene premuto { set activeButton = button } } if activeButton ! = none { if now > lastSentTime + minDelayTime { invia il comando del pulsante può inviare un messaggio } set lastSentTime = now } inval = leggi pin A7 foreach(cmd) { if (min < inval < max) { led acceso } else { led spento } } aspetta 1 ms }

Questo invierà continuamente messaggi CAN "spazzatura" circa ogni ms e mentre viene premuto un pulsante il comando corrispondente ogni 70 ms.

Potrebbe essere necessario registrare l'input sul pin A7 mentre si premono i diversi pulsanti per scoprire i valori adatti per le variabili min e max appartenenti a ciascun pulsante. (Oppure puoi calcolarlo, ma in realtà la lettura dell'input ti darà valori più precisi.)

È necessario prestare un po' di attenzione quando si programmano le modalità dei pin. Se imposti accidentalmente i pin destinati a utilizzare il pullup interno come pin di output, creerai una potenziale scorciatoia che danneggerà il tuo Arduino quando imposti l'output su alto.

Se vuoi controllare i miei programmi possono essere scaricati qui:

• Programma di registrazione dei messaggi CAN
• Programma per la scheda del simulatore
• Programma per prototipo/scheda finale

Dovresti essere consapevole che quei programmi non corrispondono davvero allo pseudo codice qui, contengono molte cose "extra" che non sono realmente necessarie e se non hai familiarità con la programmazione orientata agli oggetti può probabilmente essere un po' difficile da leggere.

Passaggio 7: l'hardware finale

Quando sei soddisfatto del tuo programma (ricorda di testare il prototipo in macchina dopo il test finale con la scheda del simulatore) è il momento di costruire il vero hardware.

Hai tre opzioni qui:

• Veloce e sporco: salda il materiale insieme su una scheda prototipo PCB.
• Hardcore DIY: incidi il tuo PCB.
• Il modo più pigro: ordina un PCB professionale su cui saldare i componenti.

Se non hai fretta posso consigliarti l'ultima opzione. Se hai solo bisogno di un piccolo PCB come questo, è molto economico ordinarlo dalla Cina. (E poi probabilmente otterrai una decina di pezzi, quindi puoi permetterti alcuni errori di saldatura.)

Per ordinare i PCB dovrai inviare il tuo design in formato Gerber. Ci sono vari software per questo. Ho usato Eagle che posso consigliare. Puoi aspettarti alcune ore per impararlo, ma poi funziona bene. Per piccole schede come questa puoi usarlo gratuitamente.

Fai attenzione quando crei il design. Non vorrai aspettare quattro settimane per la consegna solo per scoprire che hai fatto qualcosa di sbagliato.

(Se hai buone capacità di saldatura puoi progettare componenti montati in superficie e ottenere un adattatore davvero piccolo. Io no.)

Quindi ordina ad es. https://www.seeedstudio.com/fusion_pcb.html. Segui le istruzioni su come generare i file Gerber dal tuo progetto. Puoi anche ottenere un'anteprima del risultato per assicurarti che sia ok.

(Alla fine ho dovuto selezionare altri resistori per R4-R7 rispetto a quelli elencati nell'immagine dello schema. Invece ho usato 2k, 4.7k, 6.8k e 14.7k.)

E ricorda: non confondere la numerazione dei pin Atmega con la numerazione dei pin Arduino!

Ti consiglio di non saldare direttamente il chip Atmega ma di utilizzare un socket. Quindi puoi rimuoverlo facilmente nel caso in cui sia necessario riprogrammarlo.

Passaggio 8: montaggio in auto

Ora la parte più divertente: montalo sulla tua auto e inizia a usarlo! (Dopo averne fatto/acquistato una custodia.)

Se hai già testato completamente il prototipo nella tua auto, tutto dovrebbe funzionare perfettamente.

(Come ho detto prima, non l'ho fatto, quindi ho dovuto sostituire alcuni resistori e apportare alcune modifiche al mio programma.)

Considera anche se dovresti montarlo dietro lo stereo o da qualche altra parte. Ho trovato un buon posto sopra il vano portaoggetti dove posso raggiungerlo dall'interno del vano portaoggetti senza smontare nulla. Potrebbe essere utile se decidessi di aggiornarlo in un secondo momento.

Finalmente i miei pulsanti funzionano di nuovo! Come potrei sopravvivere per due mesi senza di loro?

Passaggio 9: miglioramenti futuri

Come accennato, se realizzo una versione 2.0 di questa sostituirò il 4066B con qualcos'altro (probabilmente un potenziometro digitale) per una maggiore flessibilità.

Ci sono anche molte altre cose che puoi fare. Per esempio. aggiungi un modulo bluetooth e crea un'app di controllo remoto per il tuo telefono. Oppure un modulo gps, quindi quando sei vicino a casa puoi alzare automaticamente il volume e inviare il messaggio CAN "finestre giù" in modo che tutti i tuoi vicini possano godersi la tua meravigliosa musica.