Anpassad Arduino för att behålla CAN -rattknappar med ny bilstereo: 9 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:46

Jag bestämde mig för att ersätta den ursprungliga bilstereon i min Volvo V70 -02 med en ny stereo så att jag kommer att kunna njuta av saker som mp3, bluetooth och handsfree.

Min bil har några rattkontroller för stereon som jag skulle vilja fortfarande kunna använda. Jag trodde inte att det skulle vara ett problem eftersom det finns flera adaptrar på marknaden som ska vara kompatibla med min bil. Men jag fick snart reda på att de inte var det! (Det verkar som om adaptrarna för V70 kan ha problem med -02 -bilar på grund av ett något annorlunda CAN -protokoll.)

Så vad ska man göra då? Behåll den gamla stereon? Lev ett liv med knappar som inte fungerar? Självklart inte! Om det inte finns någon fungerande adapter på marknaden måste vi bygga en!

Denna instruerbara kan tillämpas (med vissa anpassningar) på bilar där rattknapparna kommunicerar över CAN -bussen.

Steg 1: Ta reda på hur du skickar kommandon till stereon

Det första du bör göra är att ta reda på vilken typ av fjärringång stereon förväntar sig. Vanligtvis kommer tillverkarna inte att berätta det för dig och du har förmodligen inte tillgång till fungerande fjärrkontroller för omvänd konstruktion heller.

Fjärrkontrollen för min nya stereo (Kenwood) består av en enda tråd och jag har inte kunnat ta reda på någon information om hur det fungerar. Men den har också ett 3,5 mm -uttag för fjärranslutning. Jag kunde inte heller få reda på något om det. Men det finns viss information om ett 3,5 mm -uttag för andra märken som tyder på att olika kommandon identifieras genom att tillämpa ett specifikt motstånd mellan spets och ärm (och valfritt mellan ring och ärm). T.ex. https://forum.arduino.cc/index.php?topic=230068.0. Så jag bestämde mig för att prova, utrustad med ett brödbräda, ett gäng motstånd och en 3,5 mm -kontakt ansluten till stereon och ansluten till brödbrädet. Inget känns igen först, men stereon har en "inlärningsläge" -meny och där kan kommandona framgångsrikt ställas in samtidigt som olika motstånd tillämpas. Framgång!

Men jag fick senare reda på att jag gjorde ett misstag här: Inte alla kommandon som stereon verkade lära sig skulle faktiskt fungera. T.ex. 30 kOhm hittades i inlärningsläge men fungerade inte senare och för några av kommandona som jag ställde in var motståndsskillnaden så liten att fel kommando senare utlöstes.

Så jag rekommenderar att du använder en brödbräda med motstånd och omkopplare för alla fjärrkommandon som du vill hantera och faktiskt testa att alla fungerar.

Om din bilstereo inte kan ta emot input på samma sätt måste du ta reda på hur det fungerar så att du kan anpassa den här lösningen. Om du inte alls kan räkna ut har du ett problem.

Steg 2: Ta reda på var du ska ansluta till CAN -bussen

Du måste hitta ett bra ställe att ansluta till CAN -bussen. Eftersom du byter ut en gammal stereo som kommunicerar över CAN borde du kunna hitta den bakom stereon. CAN-bussen består av ett par tvinnade trådar (CAN-L och CAN_H). Se ett kopplingsschema för din bil för att vara säker.

Steg 3: Omvänd konstruktion av CAN -meddelanden

Om inte Google kan berätta vilka CAN -meddelanden du ska lyssna på, måste du ansluta till CAN -bussen och göra lite omvänd teknik. Jag använde en Arduino Uno och en CAN -sköld. (Du behöver inte riktigt CAN -skölden, som du kommer att se senare kan du använda några billiga komponenter på en brödbräda istället.)

Kontakta Google för att ta reda på vilken överföringshastighet du ska använda när du ansluter till din bil. (Vanligtvis kommer du att upptäcka att det finns en hög hastighet och en låg hastighet CAN nät. Du ansluter till låg hastighet nätet.)

Du måste också programmera Arduino för att logga alla CAN -meddelanden över det seriella gränssnittet så att du kan spara dem i en loggfil på din dator. Standard Arduino IDE sparar inte data i en loggfil men du kan använda t.ex. Spackel istället.

Innan du börjar skriva ditt program måste du installera biblioteket CAN_BUS_Shield.

Här är några pseudokoder som hjälper dig att komma igång med ditt program:

uppstart()

{init seriell anslutning init CAN bibliotek} loop () {om CAN -meddelande tas emot {läs CAN -meddelandeformat loggpost skriv loggpost till seriell}}

Tips:

Du kommer att använda en instans av klass MCP_CAN för att komma åt funktionen CAN -bibliotek:

MCP_CAN m_can;

Init CAN:

medan (m_can.begin ()! = CAN_OK)

{fördröjning (1000); }

Sök efter och läs CAN -meddelanden:

medan (m_can.checkReceive () == CAN_MSGAVAIL)

{// Hämta CAN -id, meddelandelängd och meddelandedata m_can.readMsgBufID (& m_canId, & m_msgLen, m_msgBuf); // Gör något med meddelandedata här}

Om du behöver mer hjälp kan du hitta en länk till mitt program i ett senare steg. CAN -sköldbiblioteket innehåller också ett exempel. Eller kolla mviljoen2s instruerbara som innehåller ett liknande steg.

Först behöver du en referensfil som hjälper dig att filtrera bort data. Byt tändning till radioläge och logga allt i ett par minuter utan att trycka på några knappar.

Sedan för var och en av knapparna, börja logga, tryck på knappen och sluta logga.

När du är klar måste du filtrera bort allt som finns i referensloggen från knapploggarna för att hitta dina kandidater. Jag fick reda på att det fortfarande var många meddelanden kvar så jag gjorde fler loggar och krävde sedan att "kandidater för kommando A måste finnas i alla knapp-A-filer och i ingen av referensfilerna". Det gav mig bara några möjligheter att prova.

Loggarna kommer att innehålla många meddelanden så du måste skriva något program för detta eller eventuellt använda Excel. (Jag använde ett program med mycket hårda kodade förhållanden för mina behov så jag är rädd att jag inte kan erbjuda ett program du kan använda.)

Ett varningsord: Du kan inte vara säker på att en knapp alltid kommer att ge ett identiskt meddelande. Några av bitarna kan innehålla ökande räknare etc. (Du kan dock undvika att meddelande -id är samma.)

Om du råkar ha en Volvo V70 -02 är det här du är ute efter:

• Meddelande -id: 0x0400066 Byte0: 0x00, 0x40, 0x80 eller 0xc0 (bryr mig inte)
• Byte1: 0x00 (bryr mig inte)
• Byte2: 0x00 (bryr mig inte)
• Byte3: 0x00-0x07 (bryr mig inte)
• Byte4: 0x1f (bryr mig inte)
• Byte5: 0x40 (bryr mig inte)
• Byte6: 0x40 (bryr mig inte)
• Byte7: Knappidentifierare: 0x77 = volym upp, 0x7b = volym ned, 0x7d = nästa spår, 0x7e = föregående spår.

När du tror att du har hittat kommandona kan det vara en bra idé att ändra programmet så att det bara loggar de intressanta meddelandena. Titta på det seriella loggfönstret medan du trycker på knapparna för att verifiera att du har identifierat rätt meddelanden.

Steg 4: Hårdvaruprototypen

Din hårdvara måste kunna:

1. Identifiera kommandon som tas emot på CAN -bussen
2. Skicka kommandon i ett annat format till stereon

Om du har tillräckligt med utrymme kan du använda en Arduino och en CAN -skärm för den första delen och fästa lite extra hårdvara för den andra. Det finns dock några nackdelar:

• Kostnaden för CAN -skölden
• Storlek
• Arduino -strömförsörjningen blir inte glad om den är ansluten direkt till dina bilars 12V (det kommer förmodligen att fungera men dess livslängd kommer sannolikt att förkortas).

Så istället använde jag följande:

• Atmega 328, "Arduino -hjärnan". (Det finns några varianter, få den som är lika med den på Arduino Uno. Du kan köpa den med eller utan Arduino boot loader.)
• 16 MHz kristall + kondensatorer för klocksignal.
• MCP2551 CAN -mottagare.
• MCP2515 CAN -styrenhet.
• TSR1-2450, omvandlar 6,5-36V till 5V. (Används inte i prototypen eftersom mjukvaran inte bryr sig om strömförsörjningen.)
• CD4066B -omkopplare som används när du skickar kommandon till stereon.
• Ett par motstånd. (Värdena finns i Eagle -schemat i ett senare steg.)

En bra sak med denna konfiguration är att den är helt kompatibel med Arduino och CAN -sköldbiblioteket.

Om du vill hantera fler än fyra knappar kan du överväga att använda något annat än CD4066B. CD4066B kan beskrivas som fyra switchar i en, var och en styrd av en av Atmegas GPIO -stiften. Till varje switch finns ett motstånd anslutet som kan användas för att styra det motstånd som används som ingång till stereon. Så detta kan enkelt användas för att skicka fyra olika kommandon. Om de kombineras kan ytterligare resistansvärden erhållas. Det är här misstaget jag nämnde tidigare kommer in. Jag har fyra knappar, men jag planerade att implementera två av dem så lång och kort tryckning för att ge mig sex olika kommandon. Men till slut fick jag reda på att jag inte kunde hitta en kombination av motstånd som skulle ge mig sex arbetskombinationer. Det skulle förmodligen vara möjligt att ansluta en analog ut -signal till stereon (3,5 mm spets) istället. (Observera att Atmega inte har några riktiga analoga utpinnar så att ytterligare hårdvara skulle behövas.)

För teständamål gjorde jag också en enkel "bil- och stereosimulator" för att ansluta till min prototyp. Det gör felsökning enklare och om du inte tycker om att sitta i bilen och programmera kan jag rekommendera det.

Prototypen illustreras av den nedre brödbrädan i bilden. För strömförsörjning, programmering och seriell loggning är den ansluten till en Arduino Uno där Atmega -chipet har tagits bort.

Den övre brödbrädan är bilen + stereosimulatorn som kommer att användas för inledande testning av prototypen.

Prototypen + simulatorn är avsedd att fungera så här:

• Tryck på en av knapparna på simulatorbordet. (Det är dina rattknappar.)
• När simulatorprogrammet upptäcker en knapptryckning skickar det motsvarande CAN -meddelande var 70: e ms så länge knappen trycks in. (Eftersom loggarna jag tog tidigare indikerade att det är så det fungerar i min bil.) Det kommer också att skicka massor av "skräp" CAN -meddelanden för att simulera annan trafik på bussen.
• CAN -meddelanden skickas på CAN -bussen.
• CAN -meddelanden tas emot av prototypen.
• MCP2515 kastar alla orelaterade meddelanden baserat på meddelande -id: t.
• När MCP2515 tar emot ett meddelande som ska hanteras kommer det att indikera att det har ett meddelande inmatat.
• Atmega kommer att läsa meddelandet och bestämma vilken knapp som ska anses vara aktiv.
• Atmega kommer också att hålla reda på när det senaste meddelandet mottogs, efter en viss tid kommer knappen att anses vara släppt. (CAN -meddelandena indikerar bara att en knapp är nere, inte att den har tryckts eller släppts.)
• Om en knapp anses vara aktiv kommer en eller flera omkopplare i CD4066B att aktiveras.
• Simulatorn (som nu fungerar som din stereo) kommer att upptäcka att ett motstånd appliceras mellan spets och ärm. (Spetsen är ansluten till 3,3V och via ett motstånd till en analog ingångsstift. När inget kommando är aktivt läser detta stift 3,3V, när ett kommando är aktivt blir värdet lägre och identifierar kommandot.
• Medan ett kommando är aktivt kommer motsvarande lysdiod också att aktiveras. (Det finns sex lysdioder eftersom jag planerade att använda olika lång / kort tryckning för två av mina knappar.)

Mer information om prototypmaskinvaran finns i Eagle -scheman i ett senare steg.

Ytterligare information om simulatorkortets hårdvara:

• 16 MHz kristall
• 22 pF kondensatorer
• LED -motstånd bör väljas baserat på LED -egenskaper
• Motstånd anslutet till A7 och 3.3V, välj t.ex. 2kOhm (inte kritiskt).
• Motstånd anslutna till MCP2551 och MCP2515 är pull-up / pull-down. Välj t.ex. 10 kOhm.

(Eller så kan du använda CAN -skölden för "CAN -delen" i simulatorn om du föredrar det.)

Det är viktigt att du vet hur Atmega -stiften mappas till Arduino -stift när du designar hårdvaran.

(Anslut inte några lysdioder direkt till CD 4066B, den kan bara hantera en låg ström. Jag försökte det när jag först testade utgången och chipet blev värdelöst. Det som är bra är att jag hade köpt ett par av dem bara för att de är så billiga.)

Steg 5: Säkringsprogrammering

Kanske märkte du i föregående steg att prototypen inte har några separata komponenter för att generera klocksignalen till MCP2515. Det beror på att det redan finns en 16 MHz kristall som används som Atmega -klocksignalen som vi kan använda. Men vi kan inte helt enkelt ansluta den direkt till MCP2515 och som standard finns det ingen urkopplingssignal på Atmega.

(Om du föredrar kan du hoppa över det här steget och lägga till den extra klockhårdvaran istället.)

Men vi kan använda något som kallas "säkringsprogrammering" för att aktivera en urkopplingssignal på en av GPIO -stiften.

Först måste du hitta en fil med namnet "boards.txt" som används av din Arduino IDE. Du måste kopiera posten för Arduino Uno, ge den ett nytt namn och ändra värdet för low_fuses.

Min nya tavla ser ut så här:

#################################################### ##############Baserat på Arduino Uno#Ändringar:#låga_säkringar ändrade från 0xff till 0xbf för att aktivera 16 MHz klocka#out på Atmega PB0/pin 14 = Arduino D8

clkuno.name = Klocka ut (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 = 0xdot.bootloader.foxload.bootloader.fotloader.foxloader.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 = ar.build.core.du.du.build.core = du

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

Observera att urklockan aktiveras genom att ställa in dess kontrollbit till 0.

När du har skapat det nya kortet i styrelsens konfigurationsfil måste du bränna en ny startladdare till Atmega. Det finns olika sätt att göra detta, jag använde metoden som beskrivs i

När du har gjort detta, kom ihåg att välja din nya korttyp och inte Arduino Uno när du laddar upp ett program till Atmega.

Steg 6: Programvaran

Dags att göra den dumma hårdvaran smart genom att lägga till lite programvara.

Här är några pseudokoder för prototypen:

lastReceivedTime = 0

lastReceivedCmd = none cmdTimeout = 100 setup () {enable watchdog configure pins D4-D7 as output pins init CAN setup CAN filter} loop () {reset watchdog if (CAN meddelande tas emot) {för varje knappkommando {om CAN-meddelande tillhör knappkommandot {lastReceivedTime = nu lastReceivedCmd = cmd}}} om nu> lastReceivedTime + cmdTimeout {lastReceivedCmd = none} för varje knappkommando {om lastReceivedCmd är knappkommando {set command pin output = on} else {set command pin output = off }}}

cmdTimeout bestämmer hur länge vi ska vänta innan vi överväger den senaste aktiva knappen som släpptes. Eftersom knapp CAN -meddelandekommandon skickas ungefär var 70 ms måste den vara större än den med viss marginal. Men om det är för stort kommer det att finnas en eftersläpningsupplevelse. Så 100 ms verkar vara en bra kandidat.

Men vad är en vakthund? Det är en användbar liten maskinvarufunktion som kan rädda oss vid en krasch. Tänk dig att vi har ett fel som orsakar att programmet kraschar medan volym upp -kommandot är aktivt. Då skulle vi sluta med stereon på maxvolym! Men om vakthunden inte återställs för den specifika tiden kommer den att avgöra att något oväntat har hänt och helt enkelt utföra en återställning.

void setup ()

{// tillåt max 250 ms för loop wdt_enable (WDTO_250MS); // andra init -saker} void loop () {wdt_reset (); // göra saker }

KAN man filtrera? Tja, du kan konfigurera CAN -styrenheten för att kassera alla meddelanden som inte matchar filtret så att programvaran inte behöver slösa tid på meddelanden som vi inte bryr oss om.

osignerad lång mask = 0x1fffffff; // Inkludera alla 29 rubrikbitar i masken

osignerat långt filterId = 0x0400066; // Vi bryr oss bara om detta CAN -meddelande -id m_can.init_Mask (0, CAN_EXTID, mask); // Mask 0 gäller filter 0-1 m_can.init_Mask (1, CAN_EXTID, mask); // Mask 1 gäller 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);

Kontrollera CAN -bibliotekskoden och CAN -styrdokumentationen för mer information om hur du konfigurerar filter + mask.

Du kan också ställa in CAN -styrenheten för att lyfta ett avbrott när ett meddelande (som inte filtreras bort) tas emot. (Ingår inte i exemplet ovan men det finns lite kod för det i mitt program.) I det här fallet lägger det inte till något värde och det kan vara förvirrande om du inte är van att programmera.

Så det var prototypprogramvaran i sammandrag. Men vi behöver också en kod för simulatorkortet:

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 ýtt {set activeButton = button}} if activeButton! = none {if now> lastSentTime + minDelayTime {send button command can message } ställ in lastSentTime = nu} inval = läs pin A7 foreach (cmd) {if (min <inval <max) {led on} else {led off}} vänta i 1 ms}

Detta kommer kontinuerligt att skicka "skräp" CAN -meddelanden ungefär var ms och medan en knapp trycks in motsvarande kommando var 70 ms.

Du kan behöva logga ingången på stift A7 medan du trycker på de olika knapparna för att ta reda på lämpliga värden för min- och maxvariablerna som tillhör varje knapp. (Eller så kan du beräkna det, men att faktiskt läsa inmatningen ger dig mer exakta värden.)

Du måste vara lite försiktig när du programmerar stiftlägena. Om du av misstag ställer in stiften som är avsedda att använda intern pullup som utgångsstiften istället kommer du att skapa en potentiell genväg som kommer att skada din Arduino när du ställer in utgången högt.

Om du vill kolla mina program kan de laddas ner här:

• CAN meddelanden logga program
• Program för simulatorkortet
• Program för prototyp / slutbräda

Du bör vara medveten om att dessa program inte riktigt matchar pseudokoden här, de innehåller många "extra" saker som inte verkligen behövs och om du inte är bekant med objektorienterad programmering kan det förmodligen vara lite svårt att läsa.

Steg 7: Den sista hårdvaran

När du är nöjd med ditt program (kom ihåg att testa prototypen i bilen efter sista testet med simulatorkortet) är det dags att konstruera den riktiga hårdvaran.

Du har tre alternativ här:

• Snabbt och smutsigt - löd ihop sakerna på ett PCB -prototypkort.
• Hardcore DIY - ets ditt eget kretskort.
• Det lata sättet - beställ ett professionellt kretskort för att löda komponenterna.

Om du inte har bråttom kan jag rekommendera det sista alternativet. Om du bara behöver en liten PCB som denna är det väldigt billigt att beställa den från Kina. (Och då kommer du förmodligen att få tio stycken eller så så att du har råd med några lödningsfel.)

För att beställa kretskort måste du skicka din design i Gerber -format. Det finns olika program för detta. Jag använde Eagle som jag kan rekommendera. Du kan förvänta dig några timmar att lära dig det men då fungerar det bra. För små brädor som denna kan du använda den gratis.

Var försiktig när du gör designen. Du vill inte vänta fyra veckor på leveransen bara för att ta reda på att du gjorde något fel.

(Om du har bra lödningskunskaper kan du designa för ytmonterade komponenter och få en riktigt liten adapter. Det gjorde jag inte.)

Beställ sedan på t.ex. https://www.seeedstudio.com/fusion_pcb.html. Följ instruktionerna för hur du genererar Gerber -filer från din design. Du kan också få en förhandsvisning av resultatet för att se till att det är ok.

(I slutändan var jag tvungen att välja andra motstånd för R4-R7 än som anges i schematisk bild. Istället använde jag 2k, 4.7k, 6.8k och 14.7k.)

Och kom ihåg - blanda inte ihop Atmega -stiftnumreringen med Arduino -stiftnumreringen!

Jag rekommenderar att du inte lödar Atmega -chipet direkt utan använder ett uttag. Då kan du enkelt ta bort den om du behöver programmera om den.

Steg 8: Bilmontering

Nu till den roligaste delen - montera den i din bil och börja använda den! (När du har gjort / köpt ett fodral för det.)

Om du redan har testat prototypen i bilen helt ska allt fungera perfekt.

(Som jag nämnde tidigare gjorde jag inte det, så jag var tvungen att byta ut några motstånd och göra några ändringar i mitt program.)

Fundera också på om du ska montera den bakom stereon eller någon annanstans. Jag hittade en bra plats ovanför min handskfack där jag kan nå den inifrån handskfacket utan att ta isär något. Det kan vara användbart om jag bestämmer mig för att uppgradera det senare.

Äntligen fungerar mina knappar igen! Hur kunde jag överleva i två månader utan dem?

Steg 9: Framtida förbättringar

Som nämnts, om jag gör en version 2.0 av detta kommer jag att ersätta 4066B med något annat (förmodligen en digital potentiometer) för större flexibilitet.

Det finns också många andra saker du kan göra. T.ex. lägg till en bluetooth -modul och skapa en fjärrkontrollapp för din telefon. Eller en gps -modul, så när du är nära hemmet kan du automatiskt höja volymen och skicka "windows down" CAN -meddelandet så att alla dina grannar kan njuta av din underbara musik.