Tilpasset Arduino for å beholde CAN rattknapper med ny bilstereo: 9 trinn (med bilder)

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:25

Jeg bestemte meg for å bytte ut det originale bilstereoen i min Volvo V70 -02 med et nytt stereoanlegg, så jeg kan glede meg over ting som mp3, bluetooth og håndfri.

Bilen min har noen rattkontroller for stereoanlegget som jeg vil fortsatt kunne bruke. Jeg forventet ikke at det skulle være et problem fordi det er flere adaptere på markedet som skal være kompatible med bilen min. Men jeg fant snart ut at de ikke var det! (Det virker som om adapterne til V70 kan ha problemer med -02 biler på grunn av en litt annen CAN -protokoll.)

Så hva skal jeg gjøre da? Beholder du det gamle stereoanlegget? Lev et liv med knapper som ikke fungerer? Selvfølgelig ikke! Hvis det ikke finnes en fungerende adapter på markedet, må vi bygge en!

Denne instruksen kan brukes (med noen tilpasninger) på biler der rattknappene kommuniserer over CAN -bussen.

Trinn 1: Finn ut hvordan du sender kommandoer til stereoen

Det første du bør gjøre er å finne ut hvilken type fjerninngang stereoen forventer. Vanligvis vil produsentene ikke fortelle deg det, og du har sannsynligvis ikke tilgang til fungerende fjernkontroller for reverse engineering heller.

Fjernkontrollen for mitt nye stereoanlegg (Kenwood) består av en enkelt ledning, og jeg har ikke klart å finne ut informasjon om hvordan det fungerer. Den har imidlertid også en 3,5 mm -kontakt for ekstern inngang. Jeg kunne ikke finne ut noe om det heller. Men det er litt informasjon om en 3,5 mm jack for andre merker som tyder på at forskjellige kommandoer identifiseres ved å bruke en bestemt motstand mellom spiss og hylse (og eventuelt mellom ring og erme). F.eks. https://forum.arduino.cc/index.php?topic=230068.0. Så jeg bestemte meg for å prøve det, utstyrt med et brødbrett, en haug med motstander og en 3,5 mm plugg koblet til stereoanlegget og koblet til brødbrettet. Ingenting ble gjenkjent i begynnelsen, men stereoanlegget har en "læremodus" -meny, og der kan kommandoene vellykket konfigureres mens du bruker forskjellige motstander. Suksess!

Imidlertid fant jeg senere ut at jeg gjorde en feil her: Ikke alle kommandoene som stereoanlegget syntes å lære, ville faktisk fungere. F.eks. 30 kOhm ble funnet i læringsmodus, men fungerte ikke senere, og for noen av kommandoene jeg konfigurerte var motstandsdifferansen så liten at feil kommando senere ble utløst.

Så jeg anbefaler at du bruker et brødbrett med motstander og bryterknapper for alle fjernkommandoene du vil håndtere og faktisk tester at alle fungerer.

Hvis bilstereoen din ikke kan motta inngang på samme måte, må du finne ut hvordan den fungerer, slik at du kan tilpasse denne løsningen. Hvis du ikke kan finne ut i det hele tatt, har du et problem.

Trinn 2: Finn ut hvor du skal koble til CAN -bussen

Du må finne et godt sted å koble til CAN -bussen. Siden du bytter ut et gammelt stereoanlegg som kommuniserer over CAN, bør du kunne finne det bak stereoanlegget. CAN-bussen består av et par vridde ledninger (CAN-L og CAN_H). Se et koblingsskjema for bilen din for å være sikker.

Trinn 3: Omvendt konstruksjon av CAN -meldinger

Med mindre Google kan fortelle deg hvilke CAN -meldinger du bør lytte etter, må du koble deg til CAN -bussen og gjøre omvendt konstruksjon. Jeg brukte en Arduino Uno og et CAN -skjold. (Du trenger egentlig ikke CAN -skjoldet, som du vil se senere kan du bruke noen billige komponenter på et brødbrett i stedet.)

Rådfør deg med Google for å finne ut hvilken overføringshastighet du bør bruke når du kobler til bilen din. (Vanligvis vil du oppdage at det er høy hastighet og lav hastighet CAN -nett. Du kobler deg til lavhastighetsnettet.)

Du må også programmere Arduino for å logge alle CAN -meldinger over det serielle grensesnittet, slik at du kan lagre dem i en loggfil på datamaskinen din. Standard Arduino IDE lagrer ikke data i en loggfil, men du kan bruke f.eks. Kitt i stedet.

Før du begynner å skrive programmet, må du installere CAN_BUS_Shield -biblioteket.

Her er noen pseudokoder som hjelper deg med å komme i gang med programmet ditt:

oppsett ()

{init seriell tilkobling init CAN bibliotek} loop () {hvis CAN melding mottas {les CAN melding format logg oppføring skrive logg oppføring til serial}}

Tips:

Du vil bruke en forekomst av klassen MCP_CAN for å få tilgang til funksjonen for CAN -biblioteket:

MCP_CAN m_can;

Init CAN:

mens (m_can.begin ()! = CAN_OK)

{forsinkelse (1000); }

Se etter og les CAN -meldinger:

mens (m_can.checkReceive () == CAN_MSGAVAIL)

{// Få CAN -ID, meldingslengde og meldingsdata m_can.readMsgBufID (& m_canId, & m_msgLen, m_msgBuf); // Gjør noe med meldingsdataene her}

Hvis du trenger mer hjelp, kan du finne en lenke til programmet mitt i et senere trinn. CAN -skjoldbiblioteket inneholder også et eksempel. Eller sjekk mviljoen2s instruerbare som inkluderer et lignende trinn.

Først trenger du en referansefil for å hjelpe deg med å filtrere ut data. Sett tenningen til radiomodus og logg alt i et par minutter uten å berøre noen knapper.

Deretter begynner du å logge for hver av knappene, trykker på knappen og stopper loggingen.

Når du er ferdig må du filtrere ut alt som er i referanseloggen fra knappeloggene for å finne kandidatene dine. Jeg fant ut at det fortsatt var mange meldinger igjen, så jeg lagde flere logger og krevde deretter at "kandidater til kommando A må være i alle knapp-A-filer og i ingen av referansefilene". Det etterlot meg bare noen få muligheter til å prøve.

Loggene vil inneholde mange meldinger, så du må skrive et program for dette eller muligens bruke Excel. (Jeg brukte et program med veldig harde kodede forhold for mine behov, så jeg er redd jeg ikke kan tilby et program du kan bruke.)

Et advarsel: Du kan ikke være sikker på at en knapp alltid vil gi en identisk melding. Noen av bitene kan inneholde stigende tellere osv. (Du kan bortsett fra at meldings -ID -en er den samme.)

Hvis du tilfeldigvis har en Volvo V70 -02, er dette det du er ute etter:

• Melding -ID: 0x0400066 Byte0: 0x00, 0x40, 0x80 eller 0xc0 (bryr meg ikke)
• Byte1: 0x00 (bryr meg ikke)
• Byte2: 0x00 (bryr meg ikke)
• Byte3: 0x00-0x07 (bryr meg ikke)
• Byte4: 0x1f (bryr meg ikke)
• Byte5: 0x40 (bryr meg ikke)
• Byte6: 0x40 (bryr meg ikke)
• Byte7: Knappidentifikator: 0x77 = volum opp, 0x7b = volum ned, 0x7d = neste spor, 0x7e = forrige spor.

Når du tror at du har funnet kommandoene, kan det være lurt å endre programmet slik at det bare logger de interessante meldingene. Se på det serielle loggvinduet mens du trykker på knappene for å bekrefte at du har identifisert de riktige meldingene.

Trinn 4: Maskinvareprototypen

Maskinvaren din må kunne:

1. Identifiser kommandoer mottatt på CAN -bussen
2. Send kommandoer i et annet format til stereoanlegget

Hvis du har nok plass, kan du bruke en Arduino og et CAN -skjerm for den første delen og feste litt ekstra maskinvare for den andre. Det er imidlertid noen ulemper:

• Kostnaden for CAN -skjoldet
• Størrelse
• Arduino -strømforsyningen vil ikke bli fornøyd hvis den er koblet direkte til bilene dine 12V (det vil sannsynligvis fungere, men levetiden vil trolig bli forkortet).

Så i stedet brukte jeg følgende:

• Atmega 328, "Arduino -hjernen". (Det er noen varianter, få den som er lik den på Arduino Uno. Du kan kjøpe den med eller uten Arduino boot loader.)
• 16 MHz krystall + kondensatorer for klokkesignal.
• MCP2551 CAN -mottaker.
• MCP2515 CAN -kontroller.
• TSR1-2450, konverterer 6,5-36V til 5V. (Ikke brukt i prototypen fordi programvaren ikke bryr seg om strømforsyningen.)
• CD4066B -bryter som skal brukes når du sender kommandoer til stereoanlegget.
• Et par motstander. (Verdiene finner du i Eagle -skjemaene i et senere trinn.)

En god ting med denne konfigurasjonen er at den er fullt kompatibel med Arduino og CAN -skjoldbiblioteket.

Hvis du vil håndtere mer enn fire knapper, kan du vurdere å bruke noe annet enn CD4066B. CD4066B kan beskrives som fire brytere i en, hver styrt av en av Atmegas GPIO -pinnene. Til hver bryter er det tilkoblet en motstand som kan brukes til å kontrollere motstanden som brukes som inngang til stereoanlegget. Så dette kan enkelt brukes til å sende fire forskjellige kommandoer. Hvis de kombineres, kan ytterligere motstandsverdier oppnås. Det er her feilen jeg nevnte tidligere kommer inn. Jeg har fire knapper, men jeg planla å implementere to av dem så lenge og kort trykk for å gi meg seks forskjellige kommandoer. Men til slutt fant jeg ut at jeg ikke kunne finne en kombinasjon av motstander som ville gi meg seks arbeidskombinasjoner. Det ville sannsynligvis være mulig å koble et analogt ut -signal til stereoanlegget (3,5 mm spiss) i stedet. (Vær oppmerksom på at Atmega ikke har noen sanne analoge utpinner, så det vil kreves ekstra maskinvare.)

For testformål laget jeg også en enkel "bil og stereo" simulator for å koble til prototypen min. Det gjør feilsøking enklere, og med mindre du liker å sitte i bilen og programmere, kan jeg anbefale det.

Prototypen er illustrert av det nedre brødbrettet på bildet. For strømforsyning, programmering og seriell logging er den festet til en Arduino Uno der Atmega -brikken er fjernet.

Det øvre brødbrettet er bilen + stereosimulatoren som skal brukes til første testing av prototypen.

Prototypen + simulatoren er ment å fungere slik:

• Trykk på en av bryterknappene på simulatorbordet. (Det er rattknappene dine.)
• Når simulatorprogrammet oppdager et knappetrykk, sender den den tilsvarende CAN -meldingen hver 70 ms så lenge knappen trykkes. (Fordi loggene jeg tok tidligere indikerte at det er slik det fungerer i bilen min.) Det vil også sende mange "søppel" CAN -meldinger for å simulere annen trafikk på bussen.
• CAN -meldinger sendes på CAN -bussen.
• CAN -meldinger mottas av prototypen.
• MCP2515 kaster alle ikke -relaterte meldinger basert på meldings -ID.
• Når MCP2515 mottar en melding som skal håndteres, indikerer den at den har en melding.
• Atmega vil lese meldingen og bestemme hvilken knapp som skal regnes som aktiv.
• Atmega vil også følge med når den siste meldingen ble mottatt. Etter en viss tid vil knappen bli ansett som utgitt. (CAN -meldingene indikerer bare at en knapp er nede, ikke at den har blitt presset eller sluppet.)
• Hvis en knapp anses som aktiv, vil en eller flere brytere i CD4066B bli aktivert.
• Simulatoren (som nå fungerer som din stereo) vil oppdage at det påføres en motstand mellom spissen og ermet. (Spissen er koblet til 3,3V og gjennom en motstand til en analog inngangspinne. Når ingen kommando er aktiv, vil denne pinnen lese 3,3V, når en kommando er aktiv, blir verdien lavere og identifisere kommandoen.
• Mens en kommando er aktiv, vil den tilhørende LED -en også bli aktivert. (Det er seks lysdioder fordi jeg planla å bruke forskjellige lange / korte trykk for to av knappene mine.)

For flere detaljer om prototypemaskinvaren, se Eagle -skjemaer i et senere trinn.

Ytterligere detaljer om simulatorbordets maskinvare:

• 16 MHz krystall
• 22 pF kondensatorer
• LED -motstander bør velges basert på LED -egenskaper
• Motstand koblet til A7 og 3.3V, velg f.eks. 2kOhm (ikke kritisk).
• Motstander koblet til MCP2551 og MCP2515 er pull-up / pull-down. Velg f.eks. 10 kOhm.

(Eller du kan bruke CAN -skjoldet for "CAN -delen" av simulatoren hvis du foretrekker det.)

Det er viktig at du vet hvordan Atmega -pinnene er kartlagt til Arduino -pinner når du designer maskinvaren.

(Ikke koble noen lysdioder direkte til CD 4066B, den kan bare håndtere lav strøm. Jeg prøvde det da jeg først testet utgangen og brikken ble ubrukelig. Det gode er at jeg hadde kjøpt et par av dem bare fordi de er så billige.)

Trinn 5: Sikringsprogrammering

Kanskje du la merke til i forrige trinn at prototypen ikke har separate komponenter for å generere klokkesignalet til MCP2515. Det er fordi det allerede er en 16 MHz krystall som brukes som Atmega -klokkesignal som vi kan bruke. Men vi kan ikke bare koble den direkte til MCP2515, og som standard er det ikke noe utkoblingssignal på Atmega.

(Hvis du foretrekker det, kan du hoppe over dette trinnet og legge til ekstra klokkehardware i stedet.)

Imidlertid kan vi bruke noe som kalles "sikringsprogrammering" for å aktivere et utkoblingssignal på en av GPIO -pinnene.

Først må du finne en fil som heter "boards.txt" som brukes av Arduino IDE. Du må kopiere oppføringen for Arduino Uno, gi den et nytt navn og endre verdien for low_fuses.

Mitt nye brett ser slik ut:

#################################################### ##############Basert på Arduino Uno#Endringer:#lave_sikringer endret fra 0xff til 0xbf for å aktivere 16 MHz klokke#ut på Atmega PB0/pin 14 = Arduino D8

clkuno.name = Klokke 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 = 0xdload.bootloader.fotloader.fotloader.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.

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

Vær oppmerksom på at klokken ut aktiveres ved å sette kontrollbiten til 0.

Når du har opprettet det nye brettet i brettets konfigurasjonsfil, må du brenne en ny oppstartslaster til Atmega. Det er forskjellige måter å gjøre dette på. Jeg brukte metoden beskrevet i

Etter at du har gjort dette, husk å velge din nye brettype og ikke Arduino Uno når du laster opp et program til Atmega.

Trinn 6: Programvaren

På tide å gjøre den dumme maskinvaren smart ved å legge til litt programvare.

Her er noen pseudokoder for 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 melding er mottatt) {for hver knappekommando {hvis CAN melding tilhører knappekommandoen {lastReceivedTime = nå lastReceivedCmd = cmd}}} hvis nå> lastReceivedTime + cmdTimeout {lastReceivedCmd = none} for hver knappekommando {hvis lastReceivedCmd er knappekommando {set command pin output = on} else {set command pin output = off }}}

cmdTimeout bestemmer hvor lenge vi skal vente før vi vurderer den siste aktive knappen som ble sluppet. Fordi knapp CAN -meldingskommandoer sendes omtrent hver 70 ms, må den være større enn den med en viss margin. Men hvis det er for stort, vil det bli en forsinkelsesopplevelse. Så 100 ms virker som en god kandidat.

Men hva er en vakthund? Det er en nyttig liten maskinvarefunksjon som kan redde oss i tilfelle krasj. Tenk at vi har en feil som forårsaker at programmet krasjer mens volum opp -kommandoen er aktiv. Da ville vi ende opp med stereoanlegget på maks volum! Men hvis vakthunden ikke blir tilbakestilt for den bestemte tiden, vil den bestemme at noe uventet har skjedd og ganske enkelt utstede en tilbakestilling.

ugyldig oppsett ()

{// tillat maks 250 ms for sløyfen wdt_enable (WDTO_250MS); // andre init -ting} void loop () {wdt_reset (); // gjøre ting }

KAN filtrere? Vel, du kan konfigurere CAN -kontrolleren til å forkaste alle meldinger som ikke samsvarer med filteret, slik at programvaren ikke trenger å kaste bort tid på meldinger vi ikke bryr oss om.

usignert lang maske = 0x1fffffff; // Inkluder alle 29 topptekstbiter i masken

usignert langt filterId = 0x0400066; // Vi bryr oss bare om denne CAN -meldings -IDen m_can.init_Mask (0, CAN_EXTID, mask); // Maske 0 gjelder filter 0-1 m_can.init_Mask (1, CAN_EXTID, maske); // Maske 1 gjelder 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);

Sjekk CAN -bibliotekskoden og dokumentasjonen for CAN -kontrolleren for mer informasjon om hvordan du konfigurerer filter + maske.

Du kan også konfigurere CAN -kontrolleren til å heve et avbrudd når en melding (som ikke er filtrert bort) mottas. (Ikke inkludert i eksemplet ovenfor, men det er noen kode for det i programmet mitt.) I dette tilfellet gir det egentlig ingen verdi, og det kan være forvirrende hvis du ikke er vant til å programmere.

Så det var prototypeprogramvaren i sammendrag. Men vi trenger også kode for simulatorbrettet:

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 push {set activeButton = button}} if activeButton! = none {if now> lastSentTime + minDelayTime {send button command can message } sett lastSentTime = nå} inval = les pin A7 foreach (cmd) {if (min <ugyldig <maks) {led on} else {led off}} vent i 1 ms}

Dette vil kontinuerlig sende "søppel" CAN -meldinger omtrent hver ms, og mens en knapp trykkes på den tilsvarende kommandoen hver 70 ms.

Du må kanskje logge inngangen på pin A7 mens du trykker på de forskjellige knappene for å finne passende verdier for min- og max -variablene som tilhører hver knapp. (Eller du kan beregne det, men faktisk å lese inngangen vil gi deg mer presise verdier.)

Du må være litt forsiktig når du programmerer pin -modusene. Hvis du ved et uhell stiller inn pinnene som skal bruke intern pullup som utgangspinner i stedet, vil du opprette en potensiell snarvei som vil skade Arduino når du setter utgangen høyt.

Hvis du vil sjekke programmene mine, kan de lastes ned her:

• KAN meldingsloggprogram
• Program for simulatorbrettet
• Program for prototype / sluttbrett

Du bør være oppmerksom på at disse programmene egentlig ikke samsvarer med pseudokoden her, de inneholder mange "ekstra" ting som egentlig ikke er nødvendig, og hvis du ikke er kjent med objektorientert programmering kan det sannsynligvis være litt vanskelig å lese.

Trinn 7: Den siste maskinvaren

Når du er fornøyd med programmet ditt (husk å teste prototypen i bilen etter siste testing med simulatorbrettet) er det på tide å konstruere den virkelige maskinvaren.

Du har tre alternativer her:

• Rask og skitten - lodd sammen tingene på et PCB -prototypebrett.
• Hardcore DIY - ets din egen PCB.
• Den late måten - bestill en profesjonell PCB for å lodde komponentene på.

Hvis du ikke har det travelt, kan jeg anbefale det siste alternativet. Hvis du bare trenger en liten PCB som denne, er det veldig billig å bestille den fra Kina. (Og så vil du sannsynligvis få ti stykker eller så, slik at du har råd til noen loddfeil.)

For å bestille PCB må du sende designen din i Gerber -format. Det finnes forskjellig programvare for dette. Jeg brukte Eagle som jeg kan anbefale. Du kan forvente noen timer å lære det, men da fungerer det fint. For små brett som dette kan du bruke det gratis.

Vær forsiktig når du lager designet. Du vil ikke vente fire uker på levering bare for å finne ut at du gjorde noe galt.

(Hvis du har gode loddeferdigheter, kan du designe for overflatemonterte komponenter og få en veldig liten adapter. Det gjorde jeg ikke.)

Så bestill på f.eks. https://www.seeedstudio.com/fusion_pcb.html. Følg instruksjonene for hvordan du genererer Gerber -filer fra designet ditt. Du kan også få en forhåndsvisning av resultatet for å sikre at det er ok.

(Til slutt måtte jeg velge andre motstander for R4-R7 enn det som er vist på skjematisk bilde. I stedet brukte jeg 2k, 4.7k, 6.8k og 14.7k.)

Og husk - ikke forveksle Atmega -pinnummerering med Arduino -pinnummerering!

Jeg anbefaler at du ikke lodder Atmega -brikken direkte, men bruker en stikkontakt. Deretter kan du enkelt fjerne den hvis du trenger å omprogrammere den.

Trinn 8: Bilmontering

Nå til den morsomste delen - monter den i bilen din og begynn å bruke den! (Etter at du har laget / kjøpt en sak for den.)

Hvis du allerede har testet prototypen i bilen din, bør alt fungere perfekt.

(Som jeg nevnte tidligere, gjorde jeg ikke det, så jeg måtte bytte ut noen motstander og gjøre noen endringer i programmet mitt.)

Vurder også om du skal montere den bak stereoanlegget eller et annet sted. Jeg fant et godt sted over hanskerommet mitt hvor jeg kan nå det fra innsiden av hanskerommet uten å ta noe fra hverandre. Det kan være nyttig hvis jeg bestemmer meg for å oppgradere det senere.

Endelig fungerer knappene mine igjen! Hvordan kunne jeg overleve i to måneder uten dem?

Trinn 9: Fremtidige forbedringer

Som nevnt, hvis jeg lager en versjon 2.0 av denne, vil jeg erstatte 4066B med noe annet (sannsynligvis et digitalt potensiometer) for større fleksibilitet.

Det er også mange andre ting du kan gjøre. F.eks. legg til en Bluetooth -modul og lag en fjernkontroll -app for telefonen. Eller en GPS -modul, så når du er i nærheten av hjemmet kan du automatisk øke volumet og sende "windows down" CAN -meldingen slik at alle dine naboer kan nyte den fantastiske musikken din.