Aangepaste Arduino om CAN-stuurwielknoppen te behouden met nieuwe autoradio - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

Ik heb besloten om de originele autoradio in mijn Volvo V70 -02 te vervangen door een nieuwe stereo, zodat ik kan genieten van dingen als mp3, bluetooth en handsfree.

Mijn auto heeft een aantal stuurbedieningen voor de stereo die ik nog steeds zou willen kunnen gebruiken. Ik had niet verwacht dat dit een probleem zou zijn, omdat er verschillende adapters op de markt zijn die compatibel zouden moeten zijn met mijn auto. Maar ik kwam er al snel achter dat ze dat niet waren! (Het lijkt erop dat de adapters voor V70 problemen kunnen hebben met -02-auto's vanwege een iets ander CAN-protocol.)

Dus wat te doen dan? De oude stereo behouden? Een leven leiden met niet-werkende knoppen? Natuurlijk niet! Als er geen werkende adapter op de markt is, zullen we er een moeten bouwen!

Deze instructable kan (met enkele aanpassingen) worden toegepast op auto's waarbij de stuurknoppen via de CAN-bus communiceren.

Stap 1: Ontdek hoe u opdrachten naar de stereo kunt verzenden

Het eerste dat u moet doen, is uitzoeken welk type externe ingang de stereo verwacht. Meestal zullen de fabrikanten je dat niet vertellen en heb je waarschijnlijk ook geen toegang tot werkende afstandsbedieningen voor reverse engineering.

De afstandsbediening voor mijn nieuwe stereo (Kenwood) bestaat uit een enkele draad en ik heb geen informatie kunnen vinden over hoe het werkt. Het heeft echter ook een 3,5 mm-aansluiting voor externe invoer. Ook daar kon ik niets over vinden. Maar er is wat informatie over een 3,5 mm-aansluiting voor andere merken die suggereert dat verschillende commando's worden geïdentificeerd door een specifieke weerstand toe te passen tussen tip en sleeve (en optioneel tussen ring en sleeve). bijv. https://forum.arduino.cc/index.php?topic=230068.0. Dus besloot ik dat eens te proberen, uitgerust met een breadboard, een aantal weerstanden en een 3,5 mm-stekker die op de stereo was aangesloten en op het breadboard was aangesloten. Eerst werd er niets herkend, maar de stereo heeft een "leermodus"-menu en daar konden de commando's met succes worden ingesteld met verschillende weerstanden. Succes!

Later ontdekte ik echter dat ik hier een fout had gemaakt: niet alle commando's die de stereo leek te leren, zouden echt werken. bijv. 30 kOhm werd gevonden in leermodus maar werkte later niet en voor sommige van de commando's die ik instelde was het weerstandsverschil zo klein dat later het verkeerde commando werd getriggerd.

Dus ik raad je aan een breadboard met weerstanden en schakelknoppen te gebruiken voor alle afstandsbedieningen die je wilt verwerken en daadwerkelijk te testen of ze allemaal zullen werken.

Als uw autoradio geen invoer op dezelfde manier kan ontvangen, moet u uitzoeken hoe het werkt, zodat u deze oplossing kunt aanpassen. Als je er helemaal niet uitkomt, heb je een probleem.

Stap 2: Zoek uit waar u verbinding kunt maken met de CAN-bus

U moet een goede plek vinden om verbinding te maken met de CAN-bus. Aangezien je een oude stereo vervangt die via CAN communiceert, zou je die achter de stereo moeten kunnen vinden. De CAN-bus bestaat uit een paar getwiste draden (CAN-L en CAN_H). Raadpleeg voor de zekerheid een bedradingsschema van uw auto.

Stap 3: reverse engineering van CAN-berichten

Tenzij Google u kan vertellen naar welke CAN-berichten u moet luisteren, moet u verbinding maken met de CAN-bus en wat reverse-engineering uitvoeren. Ik gebruikte een Arduino Uno en een CAN-shield. (Je hebt het CAN-shield niet echt nodig, zoals je later zult zien, kun je in plaats daarvan wat goedkope componenten op een breadboard gebruiken.)

Raadpleeg Google om erachter te komen welke baudrate u moet gebruiken bij het verbinden met uw auto. (Meestal zult u zien dat er een CAN-net met hoge en een lage snelheid is. U maakt verbinding met het netwerk met lage snelheid.)

U moet de Arduino ook programmeren om alle CAN-berichten via de seriële interface te loggen, zodat u ze kunt opslaan in een logbestand op uw computer. De standaard Arduino IDE slaat geen gegevens op in een logbestand, maar u kunt b.v. Putty in plaats daarvan.

Voordat u begint met het schrijven van uw programma, moet u de CAN_BUS_Shield-bibliotheek installeren.

Hier zijn wat pseudo-code om u op weg te helpen met uw programma:

opstelling()

{ init seriële verbinding init CAN-bibliotheek } loop() { als CAN-bericht is ontvangen { lees CAN-berichtformaat loginvoer schrijf loginvoer naar serieel}}

tips:

U gebruikt een instantie van klasse MCP_CAN om toegang te krijgen tot de CAN-bibliotheekfunctionaliteit:

MCP_CAN m_can;

Init KAN:

while (m_can.begin() != CAN_OK)

{ vertraging (1000); }

Controleer en lees CAN-berichten:

while(m_can.checkReceive() == CAN_MSGAVAIL)

{// Krijg CAN-id, berichtlengte en berichtgegevens m_can.readMsgBufID (&m_canId, &m_msgLen, m_msgBuf); // Doe hier iets met de berichtgegevens }

Als je meer hulp nodig hebt, kun je in een latere stap een link naar mijn programma vinden. De CAN-shield-bibliotheek bevat ook een voorbeeld. Of bekijk de instructable van mviljoen2 die een vergelijkbare stap bevat.

Eerst hebt u een referentiebestand nodig om u te helpen gegevens uit te filteren. Zet het contact in de radiomodus en log alles een paar minuten in zonder een knop aan te raken.

Start vervolgens voor elk van de knoppen met loggen, druk op de knop en stop met loggen.

Als u klaar bent, moet u alles uit uw referentielogboek filteren uit uw knoplogboeken om uw kandidaten te vinden. Ik kwam erachter dat er nog veel berichten over waren, dus ik maakte meer logs en vereiste toen dat "kandidaten voor commando A in alle knop-A-bestanden en in geen van de referentiebestanden moeten staan". Dat liet me met slechts een paar mogelijkheden om te proberen.

De logs zullen veel berichten bevatten, dus je zult hier een programma voor moeten schrijven of eventueel Excel gebruiken. (Ik heb een programma gebruikt met zeer hard gecodeerde voorwaarden voor mijn behoeften, dus ik ben bang dat ik geen programma kan aanbieden dat u kunt gebruiken.)

Een woord van waarschuwing: u kunt er niet zeker van zijn dat een knop altijd een identiek bericht zal produceren. Sommige bits kunnen oplopende tellers enz. bevatten (u kunt echter behalve dat de bericht-ID hetzelfde is.)

Als je toevallig een Volvo V70 -02 hebt, is dit wat je zoekt:

• Bericht-ID: 0x0400066Byte0: 0x00, 0x40, 0x80 of 0xc0 (maakt niet uit)
• Byte1: 0x00 (maakt niet uit)
• Byte2: 0x00 (maakt niet uit)
• Byte3: 0x00-0x07 (maakt niet uit)
• Byte4: 0x1f (maakt niet uit)
• Byte5: 0x40 (maakt niet uit)
• Byte6: 0x40 (maakt niet uit)
• Byte7: Knop-ID: 0x77 = volume omhoog, 0x7b = volume omlaag, 0x7d = volgende track, 0x7e = vorige track.

Als je denkt dat je de commando's hebt gevonden, is het misschien een goed idee om het programma aan te passen zodat het alleen de interessante berichten logt. Kijk naar het seriële logvenster terwijl u op de knoppen drukt om te controleren of u de juiste berichten hebt geïdentificeerd.

Stap 4: Het hardwareprototype

Uw hardware moet in staat zijn om:

1. Identificeer opdrachten ontvangen op de CAN-bus
2. Stuur opdrachten in een ander formaat naar de stereo

Als je genoeg ruimte hebt, kun je voor het eerste deel een Arduino en een CAN-shield gebruiken en voor het tweede wat extra hardware aansluiten. Er zijn echter enkele nadelen:

• Kosten van het CAN-schild
• Maat
• De Arduino-voeding zal niet blij zijn als deze rechtstreeks op de 12V van uw auto wordt aangesloten (het zal waarschijnlijk werken, maar de levensduur zal waarschijnlijk worden verkort).

Dus in plaats daarvan gebruikte ik het volgende:

• Atmega 328, het "Arduino-brein". (Er zijn enkele varianten, koop degene die gelijk is aan die op Arduino Uno. Je kunt het kopen met of zonder Arduino-bootloader.)
• 16 MHz kristal + condensatoren voor kloksignaal.
• MCP2551 CAN-zendontvanger.
• MCP2515 CAN-controller.
• TSR1-2450, converteert 6.5-36V naar 5V. (Niet gebruikt in het prototype omdat de software niet om de voeding geeft.)
• CD4066B-schakelaar die wordt gebruikt bij het verzenden van opdrachten naar de stereo.
• Een paar weerstanden. (De waarden zijn te vinden in de Eagle-schema's in een latere stap.)

Een goede zaak van deze configuratie is dat deze volledig compatibel is met de Arduino en de CAN-shield-bibliotheek.

Als je meer dan vier knoppen wilt bedienen, kun je overwegen om iets anders te gebruiken dan de CD4066B. De CD4066B kan worden omschreven als vier schakelaars in één, elk bestuurd door een van de Atmegas GPIO-pinnen. Op elke schakelaar is een weerstand aangesloten die kan worden gebruikt om de weerstand te regelen die wordt gebruikt als ingang naar de stereo. Dit kan dus gemakkelijk worden gebruikt om vier verschillende commando's te verzenden. Als ze worden gecombineerd, kunnen extra weerstandswaarden worden verkregen. Dit is waar de fout die ik eerder noemde om de hoek komt kijken. Ik heb vier knoppen, maar ik was van plan om er twee te implementeren als lang en kort indrukken om me zes verschillende commando's te geven. Maar uiteindelijk kwam ik erachter dat ik geen combinatie van weerstanden kon vinden die me zes werkende combinaties zouden geven. Het zou waarschijnlijk mogelijk zijn om in plaats daarvan een analoog uit-signaal op de stereo (tip van 3,5 mm) aan te sluiten. (Merk op dat de Atmega geen echte analoge uit-pinnen heeft, dus er is wat extra hardware vereist.)

Voor testdoeleinden heb ik ook een simpele "auto en stereo" simulator gemaakt om aan te sluiten op mijn prototype. Het maakt het debuggen gemakkelijker en tenzij je het leuk vindt om in je auto te zitten en te programmeren, kan ik dat aanbevelen.

Het prototype wordt geïllustreerd door het onderste breadboard in de afbeelding. Voor voeding, programmering en seriële logging is hij aangesloten op een Arduino Uno waar de Atmega-chip is verwijderd.

Het bovenste breadboard is de auto + stereosimulator die zal worden gebruikt voor de eerste tests van het prototype.

Het prototype + simulator is bedoeld om als volgt te werken:

• Druk op een van de schakelknoppen op het simulatorbord. (Dat zijn de knoppen op het stuur.)
• Wanneer het simulatorprogramma een druk op de knop detecteert, verzendt het elke 70 ms het bijbehorende CAN-bericht zolang de knop wordt ingedrukt. (Omdat de logs die ik eerder nam aangaven dat het zo werkt in mijn auto.) Het zal ook veel "junk" CAN-berichten verzenden om ander verkeer op de bus te simuleren.
• CAN-berichten worden via de CAN-bus verzonden.
• CAN-berichten worden door het prototype ontvangen.
• De MCP2515 gooit alle niet-gerelateerde berichten op basis van de bericht-ID.
• Als de MCP2515 een bericht ontvangt dat moet worden afgehandeld, geeft hij aan dat er een bericht in de wachtrij staat.
• De Atmega leest het bericht en beslist welke knop als actief moet worden beschouwd.
• De Atmega houdt ook bij wanneer het laatste bericht is ontvangen, na een bepaalde tijd wordt de knop als losgelaten beschouwd. (De CAN-berichten geven alleen aan dat een knop is ingedrukt, niet dat deze is ingedrukt of losgelaten.)
• Als een knop als actief wordt beschouwd, worden een of meer schakelaars in de CD4066B geactiveerd.
• De simulator (die nu dienst doet als uw stereo) zal detecteren dat er weerstand wordt uitgeoefend tussen tip en sleeve. (De tip is verbonden met 3,3V en via een weerstand met een analoge ingangspin. Als er geen commando actief is, zal deze pin 3,3V aangeven, wanneer een commando actief is, wordt de waarde lager en identificeert het commando.
• Zolang een commando actief is, wordt ook de bijbehorende led geactiveerd. (Er zijn zes leds omdat ik van plan was om verschillende lang / kort indrukken te gebruiken voor twee van mijn knoppen.)

Zie Eagle-schema's in een latere stap voor meer informatie over de prototypehardware.

Aanvullende details over de hardware van de simulatorkaart:

• 16 MHz kristal
• 22 pF condensatoren
• LED-weerstanden moeten worden geselecteerd op basis van LED-eigenschappen
• Weerstand aangesloten op A7 en 3.3V, selecteer b.v. 2kOhm (niet kritisch).
• Weerstanden aangesloten op MCP2551 en MCP2515 zijn pull-up / pull-down. Selecteer bijv. 10 kOhm.

(Of u kunt desgewenst het CAN-schild gebruiken voor het "CAN-gedeelte" van de simulator.)

Het is belangrijk dat u weet hoe de Atmega-pinnen worden toegewezen aan Arduino-pinnen wanneer u de hardware ontwerpt.

(Sluit geen leds rechtstreeks aan op de CD 4066B, deze kan alleen een lage stroomsterkte aan. Ik heb dat geprobeerd toen ik de uitgang voor het eerst testte en de chip werd onbruikbaar. Het goede is dat ik er een paar had gekocht, alleen omdat ze zijn zo goedkoop.)

Stap 5: Zekering programmeren

Misschien is het je in de vorige stap opgevallen dat het prototype geen aparte componenten heeft om het kloksignaal naar de MCP2515 te genereren. Dat komt omdat er al een 16 MHz-kristal wordt gebruikt als het Atmega-kloksignaal dat we kunnen gebruiken. Maar we kunnen hem niet zomaar direct op de MCP2515 aansluiten en standaard zit er geen uitkloksignaal op de Atmega.

(Als je wilt, kun je deze stap overslaan en in plaats daarvan de extra klokhardware toevoegen.)

We kunnen echter iets genaamd "zekeringprogrammering" gebruiken om een uitkloksignaal op een van de GPIO-pinnen in te schakelen.

Eerst moet je een bestand met de naam "boards.txt" vinden dat door je Arduino IDE wordt gebruikt. U moet het item voor Arduino Uno kopiëren, het een nieuwe naam geven en de waarde voor low_fuses wijzigen.

Mijn nieuwe bord ziet er als volgt uit:

################################################## ############ # Gebaseerd op Arduino Uno # Wijzigingen: # low_fuses gewijzigd van 0xff in 0xbf om 16 MHz klok in te schakelen # out op Atmega PB0/pin 14 = Arduino D8

clkuno.name=Uitklokken (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=0xbfloader.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.buildu.

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

Merk op dat de uitkloktijd wordt geactiveerd door het controlebit op 0 te zetten.

Als je het nieuwe bord in het configuratiebestand van het bord hebt gemaakt, moet je een nieuwe bootloader op de Atmega branden. Er zijn verschillende manieren om dit te doen, ik gebruikte de methode beschreven in

Nadat je dit hebt gedaan, vergeet dan niet om je nieuwe bordtype te selecteren en niet de Arduino Uno wanneer je een programma uploadt naar de Atmega.

Stap 6: De software

Tijd om de domme hardware slim te maken door wat software toe te voegen.

Hier zijn enkele pseudo-code voor het prototype:

lastReceivedTime = 0

lastReceivedCmd = geen cmdTimeout = 100 setup() { activeer watchdog configureer pinnen D4-D7 als uitgangspinnen init CAN setup CAN filter} loop () { reset watchdog als (CAN-bericht is ontvangen) { voor elke knopopdracht {als CAN-bericht behoort tot de knopopdracht {lastReceivedTime = now lastReceivedCmd = cmd } } } if now > lastReceivedTime + cmdTimeout {lastReceivedCmd = geen } voor elke knopopdracht { if lastReceivedCmd is knopopdracht { set opdrachtpin-uitvoer = aan } else { stel opdrachtpin-uitvoer = uit } } }

cmdTimeout bepaalt hoe lang we moeten wachten voordat we de laatste actieve knop als vrijgegeven beschouwen. Omdat knop-CAN-berichtcommando's ongeveer elke 70 ms worden verzonden, moet deze groter zijn dan die met enige marge. Maar als het te groot is, zal er een lag-ervaring zijn. Dus 100 ms lijkt een goede kandidaat.

Maar wat is een waakhond? Het is een handige kleine hardwarefunctie die ons kan redden in geval van een crash. Stel je voor dat we een bug hebben waardoor het programma crasht terwijl de opdracht volume omhoog actief is. Dan zouden we eindigen met de stereo op maximaal volume! Maar als de watchdog niet voor de specifieke tijd wordt gereset, zal hij besluiten dat er iets onverwachts is gebeurd en eenvoudig een reset uitvoeren.

ongeldige setup()

{ // sta max. 250 ms toe voor de lus wdt_enable (WDTO_250MS); // andere init-dingen} void loop () { wdt_reset (); // dingen doen }

KAN filteren? Welnu, je kunt de CAN-controller configureren om alle berichten die niet overeenkomen met het filter te negeren, zodat de software geen tijd hoeft te verspillen aan berichten die ons niet interesseren.

niet-ondertekend lang masker = 0x1ffffffff; // Alle 29 header-bits in het masker opnemen

niet-ondertekende lange filterId = 0x0400066; // We geven alleen om dit CAN-bericht id m_can.init_Mask (0, CAN_EXTID, mask); // Masker 0 is van toepassing op filter 0-1 m_can.init_Mask (1, CAN_EXTID, masker); // Masker 1 is van toepassing op 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);

Raadpleeg de CAN-bibliotheekcode en de documentatie van de CAN-controller voor meer informatie over het instellen van filter + masker.

U kunt de CAN-controller ook instellen om een interrupt op te heffen wanneer een bericht (dat niet wordt weggefilterd) wordt ontvangen. (Niet opgenomen in het bovenstaande voorbeeld, maar er is wel wat code voor in mijn programma.) In dit geval voegt het niet echt waarde toe en het kan verwarrend zijn als je niet gewend bent aan programmeren.

Dus dat was de prototypesoftware in het kort. Maar we hebben ook wat code nodig voor het simulatorbord:

lastSentTime = 0

minDelayTime = 70 setup() {configureer pinnen A0-A5 als uitvoerpinnen configureer pinnen D4-D7 als invoerpinnen met interne pullup. init CAN} loop() {verzend "ongewenste" kan msg set activeButton = geen voor elke knop {als de knop wordt ingedrukt {set activeButton = knop} } if activeButton!= geen {if now> lastSentTime + minDelayTime {stuur knop commando kan bericht } set lastSentTime = now } inval = lees pin A7 foreach (cmd) { if (min < inval < max) { led on } else { led off } } wacht 1 ms }

Dit zal continu ongeveer elke ms "junk" CAN-berichten verzenden en terwijl een knop wordt ingedrukt, elke 70 ms het bijbehorende commando.

Mogelijk moet u de invoer op pin A7 loggen terwijl u op de verschillende knoppen drukt om geschikte waarden te vinden voor de min- en max-variabelen die bij elke knop horen. (Of u kunt het berekenen, maar als u de invoer daadwerkelijk leest, krijgt u nauwkeurigere waarden.)

Je moet een beetje voorzichtig zijn bij het programmeren van de pin-modi. Als je per ongeluk de pinnen instelt die bedoeld zijn om interne pullup te gebruiken als uitvoerpinnen, dan creëer je een mogelijke snelkoppeling die je Arduino zal beschadigen wanneer je de uitvoer hoog instelt.

Als je mijn programma's wilt bekijken, kun je ze hier downloaden:

• CAN-berichten log programma
• Programma voor het simulatorbord
• Programma voor prototype / eindbord

U moet zich ervan bewust zijn dat die programma's hier niet echt overeenkomen met de pseudo-code, ze bevatten veel "extra" dingen die niet echt nodig zijn en als u niet bekend bent met objectgeoriënteerd programmeren, kan het waarschijnlijk een beetje moeilijk te lezen zijn.

Stap 7: de definitieve hardware

Als je tevreden bent met je programma (vergeet niet om het prototype in de auto te testen na de laatste tests met het simulatorbord), is het tijd om de echte hardware te bouwen.

Je hebt hier drie opties:

• Snel en vuil - soldeer het spul samen op een PCB-prototypebord.
• Hardcore DIY - ets je eigen PCB.
• De luie manier - bestel een professionele printplaat om de componenten op te solderen.

Als je geen haast hebt, kan ik de laatste optie aanbevelen. Als je alleen zo'n klein printje nodig hebt, is het erg goedkoop om het vanuit China te bestellen. (En dan krijg je waarschijnlijk een stuk of tien, dus je kunt je wat soldeerfouten veroorloven.)

Om printplaten te bestellen, moet u uw ontwerp in Gerber-formaat aanleveren. Hier zijn verschillende software voor. Ik heb Eagle gebruikt, wat ik kan aanbevelen. Je kunt een paar uur verwachten om het te leren, maar dan werkt het prima. Voor kleine borden zoals deze kun je het gratis gebruiken.

Wees voorzichtig bij het maken van het ontwerp. U wilt niet vier weken wachten op de levering om erachter te komen dat u iets verkeerd heeft gedaan.

(Als je goede soldeervaardigheden hebt, kun je ontwerpen voor op het oppervlak gemonteerde componenten en een heel kleine adapter krijgen. Dat deed ik niet.)

Bestel dan bij b.v. https://www.seeedstudio.com/fusion_pcb.html. Volg de instructies voor het genereren van de Gerber-bestanden van uw ontwerp. U kunt ook een voorbeeld van het resultaat krijgen om te controleren of het in orde is.

(Uiteindelijk moest ik andere weerstanden selecteren voor R4-R7 dan vermeld in de schematische afbeelding. In plaats daarvan gebruikte ik 2k, 4.7k, 6.8k en 14.7k.)

En onthoud - verwar de Atmega-pinnummering niet met de Arduino-pinnummering!

Ik raad aan om de Atmega-chip niet direct te solderen, maar een socket te gebruiken. Dan kunt u het gemakkelijk verwijderen voor het geval u het opnieuw moet programmeren.

Stap 8: Automontage

Nu naar het leukste deel - monteer hem in je auto en begin hem te gebruiken! (Nadat je er een hoesje voor hebt gemaakt/gekocht.)

Als je het prototype al volledig in je auto hebt getest, zou alles perfect moeten werken.

(Zoals ik eerder al zei, deed ik dat niet, dus ik moest wat weerstanden vervangen en enkele wijzigingen in mijn programma aanbrengen.)

Overweeg ook of je hem achter de stereo of ergens anders moet monteren. Ik heb een goede plek gevonden boven mijn dashboardkastje waar ik het vanuit het dashboardkastje kan bereiken zonder iets uit elkaar te halen. Dat kan handig zijn als ik besluit om het later te upgraden.

Eindelijk werken mijn knoppen weer! Hoe kon ik twee maanden zonder hen overleven?

Stap 9: Toekomstige verbeteringen

Zoals gezegd, als ik hier een versie 2.0 van maak, zal ik de 4066B vervangen door iets anders (waarschijnlijk een digitale potmeter) voor meer flexibiliteit.

Er zijn ook een heleboel andere dingen die je kunt doen. bijv. voeg een bluetooth-module toe en maak een afstandsbediening-app voor je telefoon. Of een gps-module, dan kun je wanneer je dicht bij huis bent automatisch het volume verhogen en het "windows down" CAN-bericht versturen zodat al je buren kunnen genieten van je heerlijke muziek.