Tilpasset Arduino til at beholde CAN -ratknapper med ny bilstereo: 9 trin (med billeder)

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:29

Jeg besluttede at udskifte den originale bilstereo i min Volvo V70 -02 med en ny stereo, så jeg kan nyde ting som mp3, bluetooth og håndfri.

Min bil har nogle ratbetjeninger til stereoanlægget, som jeg gerne vil stadig kunne bruge. Jeg forventede ikke, at det ville være et problem, fordi der er flere adaptere på markedet, der formodes at være kompatible med min bil. Men jeg fandt hurtigt ud af, at det var de ikke! (Det ser ud til, at adapterne til V70 kan have problemer med -02 biler på grund af en lidt anden CAN -protokol.)

Så hvad skal man så gøre? Behold den gamle stereo? Lev et liv med ikke-fungerende knapper? Selvfølgelig ikke! Hvis der ikke er en fungerende adapter på markedet, bliver vi nødt til at bygge en!

Denne instruerbare kan anvendes (med nogle tilpasninger) på biler, hvor ratknapperne kommunikerer over CAN -bussen.

Trin 1: Find ud af, hvordan du sender kommandoer til stereoen

Den første ting du skal gøre er at finde ud af, hvilken type fjernindgang stereoanlægget forventer. Typisk vil producenterne ikke fortælle dig det, og du har sandsynligvis heller ikke adgang til fungerende fjernbetjeninger til reverse engineering.

Fjernbetjeningen til mit nye stereoanlæg (Kenwood) består af en enkelt ledning, og jeg har ikke kunnet finde ud af oplysninger om, hvordan det fungerer. Det har dog også et 3,5 mm stik til fjernindgang. Det kunne jeg heller ikke finde ud af noget om. Men der er nogle oplysninger om et 3,5 mm stik til andre mærker, der tyder på, at forskellige kommandoer identificeres ved at anvende en bestemt modstand mellem spids og ærme (og eventuelt mellem ring og ærme). F.eks. https://forum.arduino.cc/index.php?topic=230068.0. Så jeg besluttede at prøve det, udstyret med et brødbræt, en flok modstande og et 3,5 mm stik, der er tilsluttet stereoanlægget og forbundet til brødbrættet. Intet blev genkendt i starten, men stereoanlægget har en menu "indlæringstilstand", og der kunne kommandoerne konfigureres med succes, mens forskellige modstand anvendes. Succes!

Men senere fandt jeg ud af, at jeg begik en fejl her: Ikke alle kommandoer, som stereoanlægget syntes at lære, ville faktisk fungere. F.eks. 30 kOhm blev fundet i læringstilstand, men fungerede ikke senere, og for nogle af kommandoerne, jeg konfigurerede, var modstandsforskellen så lille, at den forkerte kommando senere blev udløst.

Så jeg anbefaler, at du bruger et brødbræt med modstande og switch -knapper til alle de fjernkommandoer, du vil håndtere, og faktisk tester, at alle vil fungere.

Hvis din bilstereo ikke kan modtage input på samme måde, bliver du nødt til at finde ud af, hvordan den fungerer, så du kan tilpasse denne løsning. Hvis du slet ikke kan finde ud af det, har du et problem.

Trin 2: Find ud af, hvor du skal oprette forbindelse til CAN -bussen

Du skal finde et godt sted at oprette forbindelse til CAN -bussen. Da du udskifter et gammelt stereoanlæg, der kommunikerer over CAN, burde du kunne finde det bag stereoanlægget. CAN-bussen består af et par snoede ledninger (CAN-L og CAN_H). Se et ledningsdiagram for din bil for at være sikker.

Trin 3: Omvendt konstruktion af CAN -meddelelser

Medmindre Google kan fortælle dig, hvilke CAN -meddelelser du skal lytte efter, skal du oprette forbindelse til CAN -bussen og lave lidt reverse engineering. Jeg brugte en Arduino Uno og et CAN -skjold. (Du behøver ikke rigtig CAN -skjoldet, som du vil se senere kan du i stedet bruge nogle billige komponenter på et brødbræt.)

Kontakt Google for at finde ud af, hvilken baudrate du skal bruge, når du opretter forbindelse til din bil. (Normalt vil du opdage, at der er en høj hastighed og et lavt CAN -net. Du opretter forbindelse til lavhastighedsnettet.)

Du skal også programmere Arduino til at logge alle CAN -meddelelser over det serielle interface, så du kan gemme dem i en logfil på din computer. Standarden Arduino IDE gemmer ikke data i en logfil, men du kan bruge f.eks. Spartel i stedet.

Inden du begynder at skrive dit program, skal du installere CAN_BUS_Shield -biblioteket.

Her er nogle pseudokoder, der hjælper dig med at komme i gang med dit program:

Opsætning()

{init seriel forbindelse init CAN -bibliotek} loop () {hvis CAN -meddelelse modtages {læs CAN -meddelelsesformat logindgang skriv logindgang til seriel}}

Tips:

Du vil bruge en forekomst af klasse MCP_CAN for at få adgang til CAN -bibliotekets funktionalitet:

MCP_CAN m_can;

Init CAN:

mens (m_can.begin ()! = CAN_OK)

{forsinkelse (1000); }

Se efter og læs CAN -meddelelser:

mens (m_can.checkReceive () == CAN_MSGAVAIL)

{// Hent CAN -id, meddelelseslængde og meddelelsesdata m_can.readMsgBufID (& m_canId, & m_msgLen, m_msgBuf); // Gør noget med beskeddataene her}

Hvis du har brug for mere hjælp, kan du finde et link til mit program i et senere trin. CAN -skjoldbiblioteket indeholder også et eksempel. Eller tjek mviljoen2's instruerbare, der indeholder et lignende trin.

Først skal du bruge en referencefil til at hjælpe dig med at filtrere data. Skift tænding til radiotilstand, og log alt i et par minutter uden at trykke på nogen knapper.

Start derefter med at logge for hver af knapperne, tryk på knappen og stop logningen.

Når du er færdig, skal du filtrere alt, hvad der er i din referencelog fra dine knaplogs for at finde dine kandidater. Jeg fandt ud af, at der stadig var mange meddelelser tilbage, så jeg lavede flere logfiler og krævede derefter, at "kandidater til kommando A skal være i alle knap-A-filer og i ingen af referencefilerne". Det efterlod mig kun få muligheder for at prøve.

Logfiler vil indeholde en masse meddelelser, så du bliver nødt til at skrive et program til dette eller muligvis bruge Excel. (Jeg brugte et program med meget hårdt kodede forhold til mine behov, så jeg er bange for, at jeg ikke kan tilbyde et program, du kan bruge.)

Et advarselsord: Du kan ikke være sikker på, at en knap altid vil frembringe en identisk besked. Nogle af bitene kan indeholde stigende tællere osv. (Du kan dog undtage, at meddelelses -id'et er det samme.)

Hvis du tilfældigvis har en Volvo V70 -02, er du her efter:

• Besked -id: 0x0400066 Byte0: 0x00, 0x40, 0x80 eller 0xc0 (ligeglad)
• Byte1: 0x00 (ligeglad)
• Byte2: 0x00 (ligeglad)
• Byte3: 0x00-0x07 (ligeglad)
• Byte4: 0x1f (ligeglad)
• Byte5: 0x40 (ligeglad)
• Byte6: 0x40 (ligeglad)
• Byte7: Knap -id: 0x77 = volumen op, 0x7b = lydstyrke ned, 0x7d = næste spor, 0x7e = forrige nummer.

Når du mener, at du har fundet kommandoerne, kan det være en god idé at ændre programmet, så det kun logger de interessante beskeder. Se på det serielle logvindue, mens du trykker på knapperne for at kontrollere, at du har identificeret de korrekte meddelelser.

Trin 4: Hardware -prototypen

Din hardware skal kunne:

1. Identificer kommandoer modtaget på CAN -bussen
2. Send kommandoer i et andet format til stereoanlægget

Hvis du har nok plads, kan du bruge en Arduino og et CAN -skjold til den første del og vedhæfte noget ekstra hardware til den anden. Der er dog nogle ulemper:

• Omkostninger ved CAN -skjoldet
• Størrelse
• Arduino -strømforsyningen vil ikke være tilfreds, hvis den er forbundet direkte til dine biler 12V (det vil sandsynligvis fungere, men dens levetid vil sandsynligvis blive forkortet).

Så i stedet brugte jeg følgende:

• Atmega 328, "Arduino -hjernen". (Der er nogle varianter, få den der er lig med den på Arduino Uno. Du kan købe den med eller uden Arduino boot loader.)
• 16 MHz krystal + kondensatorer til kloksignal.
• MCP2551 CAN -transceiver.
• MCP2515 CAN -controller.
• TSR1-2450, konverterer 6,5-36V til 5V. (Ikke brugt i prototypen, fordi softwaren ikke vil bekymre sig om strømforsyningen.)
• CD4066B -switch, der bruges, når du sender kommandoer til stereoanlægget.
• Et par modstande. (Værdierne kan findes i Eagle -skemaerne i et senere trin.)

En god ting med denne konfiguration er, at den er fuldt kompatibel med Arduino og CAN -skjoldbiblioteket.

Hvis du vil håndtere mere end fire knapper, kan du overveje at bruge noget andet end CD4066B. CD4066B kan beskrives som fire kontakter i en, der hver styres af en af Atmegas GPIO -benene. Til hver switch er der tilsluttet en modstand, der kan bruges til at styre modstanden, der bruges som input til stereoanlægget. Så dette kan let bruges til at sende fire forskellige kommandoer. Hvis de kombineres, kan der opnås yderligere modstandsværdier. Det er her den fejl, jeg nævnte tidligere, kommer ind. Jeg har fire knapper, men jeg planlagde at implementere to af dem så langt og kort tryk for at give mig seks forskellige kommandoer. Men i sidste ende fandt jeg ud af, at jeg ikke kunne finde en kombination af modstande, der ville give mig seks arbejdskombinationer. Det ville sandsynligvis være muligt at tilslutte et analogt ud -signal til stereoanlægget (3,5 mm spids) i stedet. (Bemærk, at Atmega ikke har nogen ægte analoge udpinde, så noget ekstra hardware ville være påkrævet.)

Til testformål lavede jeg også en simpel "bil og stereo" simulator til at forbinde til min prototype. Det gør fejlfinding lettere, og medmindre du nyder at sidde i din bil og programmere, kan jeg anbefale det.

Prototypen er illustreret af det nederste brødbræt på billedet. Til strømforsyning, programmering og seriel logning er den knyttet til en Arduino Uno, hvor Atmega -chippen er blevet fjernet.

Det øverste brødbræt er bilen + stereosimulatoren, der skal bruges til indledende test af prototypen.

Prototypen + simulatoren er beregnet til at fungere sådan:

• Tryk på en af switch -knapperne på simulatorkortet. (Det er dine ratknapper.)
• Når simulatorprogrammet registrerer et tryk på en knap, sender den den tilsvarende CAN -meddelelse hver 70 ms, så længe knappen trykkes. (Fordi de logfiler, jeg tog tidligere, indikerede, at det er sådan det fungerer i min bil.) Det vil også sende masser af "uønskede" CAN -meddelelser for at simulere anden trafik på bussen.
• CAN -meddelelser sendes på CAN -bussen.
• CAN -meddelelser modtages af prototypen.
• MCP2515 kaster alle ikke -relaterede meddelelser baseret på meddelelses -id'et.
• Når MCP2515 modtager en besked, der skal håndteres, vil det indikere, at den har en meddelelse, der er kørt.
• Atmega læser meddelelsen og beslutter, hvilken knap der skal betragtes som aktiv.
• Atmega vil også holde styr på, hvornår den sidste besked blev modtaget, efter et bestemt tidspunkt vil knappen blive betragtet som frigivet. (CAN -meddelelserne angiver kun, at en knap er nede, ikke at den er blevet skubbet eller frigivet.)
• Hvis en knap betragtes som aktiv, aktiveres en eller flere kontakter i CD4066B.
• Simulatoren (der nu fungerer som din stereo) registrerer, at der anvendes en modstand mellem spids og ærme. (Spidsen er forbundet til 3,3V og via en modstand til en analog indgangsstift. Når ingen kommando er aktiv, læser denne pin 3,3V, når en kommando er aktiv, bliver værdien lavere og identificerer kommandoen.
• Mens en kommando er aktiv, aktiveres den tilhørende LED også. (Der er seks lysdioder, fordi jeg planlagde at bruge forskellige lange / korte tryk på to af mine knapper.)

For flere detaljer om prototypens hardware, se Eagle -skemaer i et senere trin.

Yderligere oplysninger om simulatorkortets hardware:

• 16 MHz krystal
• 22 pF kondensatorer
• LED modstande bør vælges baseret på LED egenskaber
• Modstand tilsluttet A7 og 3.3V, vælg f.eks. 2kOhm (ikke kritisk).
• Modstande forbundet til MCP2551 og MCP2515 er pull-up / pull-down. Vælg f.eks. 10 kOhm.

(Eller du kan bruge CAN -skjoldet til "CAN -delen" af simulatoren, hvis du foretrækker det.)

Det er vigtigt, at du ved, hvordan Atmega -benene er knyttet til Arduino -ben, når du designer hardware.

(Tilslut ikke nogen lysdioder direkte til CD 4066B, den kan kun klare en lav strøm. Jeg prøvede det, da jeg først testede output og chippen blev ubrugelig. Det gode er, at jeg havde købt et par af dem, bare fordi de er så billige.)

Trin 5: Sikringsprogrammering

Måske har du bemærket i det foregående trin, at prototypen ikke har separate komponenter til at generere urets signal til MCP2515. Det er fordi, der allerede er en 16 MHz krystal, der bruges som Atmega -urets signal, som vi kan bruge. Men vi kan ikke bare forbinde det direkte til MCP2515, og som standard er der ikke noget ur -signal på Atmega.

(Hvis du foretrækker det, kan du springe dette trin over og tilføje den ekstra urhardware i stedet.)

Men vi kan bruge noget, der kaldes "sikringsprogrammering" for at aktivere et ur -signal på en af GPIO -benene.

Først skal du finde en fil med navnet "boards.txt", der bruges af din Arduino IDE. Du bliver nødt til at kopiere posten til Arduino Uno, give den et nyt navn og ændre værdien for low_fuses.

Mit nye bord ser sådan ud:

#################################################### ##############Baseret på Arduino Uno#ændringer:#lave_sikringer ændret fra 0xff til 0xbf for at aktivere 16 MHz ur#ud på Atmega PB0/pin 14 = Arduino D8

clkuno.name = Ur ude (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.loadd.fotloader.fxload.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 clkuno.build.core = ar.du.build.core = du

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

Bemærk, at uret aktiveres ved at indstille dets kontrolbit til 0.

Når du har oprettet det nye board i boards -konfigurationsfilen, bliver du nødt til at brænde en ny boot loader til Atmega. Der er forskellige måder at gøre dette på. Jeg brugte metoden beskrevet i

Når du har gjort dette, skal du huske at vælge din nye tavletype og ikke Arduino Uno, når du uploader et program til Atmega.

Trin 6: Softwaren

Tid til at gøre den dumme hardware smart ved at tilføje noget software.

Her er nogle pseudokoder til prototypen:

lastReceivedTime = 0

lastReceivedCmd = none cmdTimeout = 100 setup () {aktiver vagthund konfigurer pins D4-D7 som output pins init CAN setup CAN filter} loop () {reset watchdog if (CAN message is received) {for hver knapkommando {hvis CAN-besked tilhører knapkommandoen {lastReceivedTime = nu lastReceivedCmd = cmd}}} hvis nu> lastReceivedTime + cmdTimeout {lastReceivedCmd = none} for hver knapkommando {hvis lastReceivedCmd er knapkommando {set command pin output = on} else {set command pin output = off }}}

cmdTimeout bestemmer, hvor længe vi skal vente, før vi overvejer den sidste aktive knap frigivet. Fordi knappen CAN -beskedkommandoer sendes cirka hver 70 ms, skal den være større end den med en vis margin. Men hvis det er for stort, vil der være en forsinkelsesoplevelse. Så 100 ms virker som en god kandidat.

Men hvad er en vagthund? Det er en nyttig lille hardwarefunktion, der kan redde os i tilfælde af et nedbrud. Forestil dig, at vi har en fejl, der får programmet til at gå ned, mens kommandoen volumen op er aktiv. Så ville vi ende med stereoanlægget på maksimal lydstyrke! Men hvis vagthunden ikke nulstilles til det bestemte tidspunkt, vil den beslutte, at der er sket noget uventet, og simpelthen udstede en nulstilling.

ugyldig opsætning ()

{// tillad maks. 250 ms for loop wdt_enable (WDTO_250MS); // andre init -ting} void loop () {wdt_reset (); // gør ting}

KAN filtere? Nå, du kan konfigurere CAN -controlleren til at kassere alle meddelelser, der ikke matcher filteret, så softwaren ikke behøver at spilde tid på meddelelser, vi ikke er ligeglade med.

usigneret lang maske = 0x1fffffff; // Inkluder alle 29 header bits i masken

usigneret langt filterId = 0x0400066; // Vi bekymrer os kun om denne CAN -meddelelses -id m_can.init_Mask (0, CAN_EXTID, maske); // Maske 0 gælder filter 0-1 m_can.init_Mask (1, CAN_EXTID, maske); // Maske 1 gælder for 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);

Se CAN -bibliotekskoden og dokumentationen til CAN -controlleren for at få flere oplysninger om opsætning af filter + maske.

Du kan også konfigurere CAN -controlleren til at afbryde en afbrydelse, når der modtages en besked (der ikke er filtreret fra). (Ikke inkluderet i eksemplet ovenfor, men der er noget kode til det i mit program.) I dette tilfælde tilføjer det ikke rigtig nogen værdi, og det kan være forvirrende, hvis du ikke er vant til at programmere.

Så det var prototypesoftwaren i opsummering. Men vi har også brug for en kode til simulatorbrættet:

lastSentTime = 0

minDelayTime = 70 setup () {konfigurer ben A0-A5 som udgangsstifter konfigurer ben D4-D7 som indgangsstifter med intern pullup. init CAN} loop () {send "junk" can msg set activeButton = none for hver knap {hvis der trykkes på knappen {set activeButton = button}} hvis activeButton! = none {if now> lastSentTime + minDelayTime {send button command can message } indstil lastSentTime = nu} inval = læs pin A7 foreach (cmd) {if (min <ugyldig <max) {led on} else {led off}} vent i 1 ms}

Dette vil løbende sende "uønsket" CAN -meddelelser cirka hver ms, og mens der trykkes på en knap, svarer den tilsvarende kommando hver 70 ms.

Du skal muligvis logge input på pin A7, mens du trykker på de forskellige knapper for at finde passende værdier for de min- og max -variabler, der tilhører hver knap. (Eller du kan beregne det, men hvis du læser input, får du mere præcise værdier.)

Du skal være lidt forsigtig, når du programmerer pin -tilstande. Hvis du ved et uheld indstiller benene, der er beregnet til at bruge intern pullup som outputpinde i stedet, vil du oprette en potentiel genvej, der vil beskadige din Arduino, når du sætter output højt.

Hvis du vil tjekke mine programmer, kan de downloades her:

• CAN meddelelser log program
• Program til simulator board
• Program til prototype / slutplade

Du skal være opmærksom på, at disse programmer ikke rigtig matcher pseudokoden her, de indeholder en masse "ekstra" ting, der ikke rigtig er brug for, og hvis du ikke er fortrolig med objektorienteret programmering, kan det sandsynligvis være lidt svært at læse.

Trin 7: Den sidste hardware

Når du er tilfreds med dit program (husk at teste prototypen i bilen efter sidste test med simulatorbrættet) er det tid til at konstruere den rigtige hardware.

Du har tre muligheder her:

• Hurtig og snavset - lodde tingene sammen på et printkort af printkort.
• Hardcore DIY - æts din egen PCB.
• Den dovne måde - bestil et professionelt printkort til at lodde komponenterne på.

Hvis du ikke har travlt, kan jeg anbefale den sidste mulighed. Hvis du kun har brug for et lille print som dette, er det meget billigt at bestille det fra Kina. (Og så får du sandsynligvis ti stykker eller deromkring, så du har råd til nogle loddefejl.)

For at bestille printkort skal du sende dit design i Gerber -format. Der er forskellige software til dette. Jeg brugte Eagle, som jeg kan anbefale. Du kan forvente et par timer at lære det, men så fungerer det fint. Til små tavler som denne kan du bruge den gratis.

Vær forsigtig, når du laver designet. Du vil ikke vente fire uger på levering bare for at finde ud af, at du har gjort noget forkert.

(Hvis du har gode loddeevner, kan du designe til overflademonterede komponenter og få en virkelig lille adapter. Det gjorde jeg ikke.)

Bestil derefter på f.eks. https://www.seeedstudio.com/fusion_pcb.html. Følg instruktionerne for, hvordan du genererer Gerber -filer fra dit design. Du kan også få et eksempel på resultatet for at sikre, at det er ok.

(I sidste ende var jeg nødt til at vælge andre modstande til R4-R7 end angivet i skematisk billede. I stedet brugte jeg 2k, 4,7k, 6,8k og 14,7k.)

Og husk - forveks ikke Atmega pin -nummereringen med Arduino pin -nummereringen!

Jeg anbefaler, at du ikke lodder Atmega -chippen direkte, men bruger en stikkontakt. Derefter kan du nemt fjerne det, hvis du skal omprogrammere det.

Trin 8: Bilmontering

Nu til den sjoveste del - monter den i din bil, og begynd at bruge den! (Når du har lavet / købt en sag til det.)

Hvis du allerede har testet prototypen i din bil fuldt ud, skal alt fungere perfekt.

(Som jeg nævnte tidligere, gjorde jeg det ikke, så jeg var nødt til at udskifte nogle modstande og foretage nogle ændringer i mit program.)

Overvej også, om du skal montere den bag stereoanlægget eller et andet sted. Jeg fandt et godt sted over min handskerum, hvor jeg kan nå den inde fra handskerummet uden at tage noget fra hinanden. Det kan være nyttigt, hvis jeg beslutter mig for at opgradere det senere.

Endelig virker mine knapper igen! Hvordan kunne jeg overleve i to måneder uden dem?

Trin 9: Fremtidige forbedringer

Som nævnt vil jeg, hvis jeg laver en version 2.0 af denne, erstatte 4066B med noget andet (sandsynligvis et digitalt potentiometer) for større fleksibilitet.

Der er også mange andre ting, du kan gøre. F.eks. tilføj et bluetooth -modul, og lav en fjernbetjeningsapp til din telefon. Eller et gps -modul, så når du er tæt på hjemmet, kan du automatisk hæve lydstyrken og sende "vinduerne ned" CAN -besked, så alle dine naboer kan nyde din vidunderlige musik.