Aangepaste Arduino om die knoppies van die stuurwiel met nuwe motorstereo te behou: 9 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:27

Ek het besluit om die oorspronklike stereo in my Volvo V70 -02 met 'n nuwe stereo te vervang, sodat ek dinge soos mp3, bluetooth en handsfree kan geniet.

My motor het 'n paar stuurwielkontroles vir die stereo wat ek graag nog wil kan gebruik. Ek het nie verwag dat dit 'n probleem sou wees nie, want daar is verskeie adapters op die mark wat verenigbaar is met my motor. Ek het egter gou agtergekom dat dit nie die geval was nie! (Dit lyk asof die adapters vir V70 probleme ondervind met -02 motors as gevolg van 'n effens ander CAN -protokol.)

So, wat om dan te doen? Hou die ou stereo? Leef u 'n lewe met knoppies wat nie werk nie? Natuurlik nie! As daar geen werkende adapter op die mark is nie, moet ons een bou!

Hierdie instruksies kan (met enkele aanpassings) toegepas word op motors waar die stuurknoppies oor die CAN -bus kommunikeer.

Stap 1: Ontdek hoe u opdragte na die stereo kan stuur

Die eerste ding wat u moet doen, is om uit te vind watter tipe ingang op afstand die stereo verwag. Gewoonlik sal die vervaardigers dit nie vir u sê nie, en u het waarskynlik ook nie toegang tot werkende afstandsbedienings vir reverse engineering nie.

Die afstandsbediening vir my nuwe stereo (Kenwood) bestaan uit 'n enkele draad en ek kon nog nie inligting vind oor hoe dit werk nie. Dit het egter ook 'n 3,5 mm -aansluiting vir afstandsinvoer. Ek kon ook niks daaroor uitvind nie. Maar daar is inligting oor 'n 3,5 mm -aansluiting vir ander handelsmerke wat daarop dui dat verskillende opdragte geïdentifiseer kan word deur 'n spesifieke weerstand tussen punt en mou (en optioneel tussen ring en mou) toe te pas. Bv. https://forum.arduino.cc/index.php?topic=230068.0. Daarom het ek besluit om dit te probeer, toegerus met 'n broodbord, 'n klomp weerstande en 'n 3,5 mm -prop wat aan die stereo gekoppel is en aan die broodbord gekoppel is. Niks is aanvanklik herken nie, maar die stereo het 'n 'leermodus' -spyskaart, en daar kan die opdragte suksesvol opgestel word terwyl verskillende weerstand toegepas word. Sukses!

Maar later het ek agtergekom dat ek hier 'n fout gemaak het: nie al die opdragte wat die stereo kon leer nie, sou eintlik werk. Bv. 30 kOhm is in die leermodus gevind, maar het later nie gewerk nie, en vir sommige van die opdragte wat ek opgestel het, was die weerstandsverskil so klein dat die verkeerde opdrag later begin is.

Ek beveel dus aan dat u 'n broodbord met weerstande en skakelknoppies vir al die afstandsopdragte wat u wil hanteer, gebruik en eintlik toets of hulle almal sal werk.

As u motorstereo nie op dieselfde manier insette kan ontvang nie, moet u uitvind hoe dit werk, sodat u hierdie oplossing kan aanpas. As u glad nie kan agterkom nie, het u 'n probleem.

Stap 2: Vind uit waar om aan te sluit op die CAN -bus

U moet 'n goeie plek vind om aan te sluit op die CAN -bus. Aangesien u 'n ou stereo vervang wat oor CAN kommunikeer, moet u dit agter die stereo kan vind. Die CAN-bus bestaan uit 'n paar gedraaide drade (CAN-L en CAN_H). Raadpleeg 'n bedradingsdiagram vir u motor om seker te wees.

Stap 3: Omgekeerde ontwerp van CAN -boodskappe

Tensy Google vir u kan sê na watter CAN -boodskappe u moet luister, moet u met die CAN -bus skakel en 'n bietjie reverse engineering doen. Ek het 'n Arduino Uno en 'n CAN -skild gebruik. (U het nie regtig die CAN -skild nodig nie, soos u later sal sien, kan u eerder 'n paar goedkoop komponente op 'n broodbord gebruik.)

Raadpleeg Google om uit te vind watter baud -tempo u moet gebruik as u met u motor skakel. (Gewoonlik sal u agterkom dat daar 'n hoë spoed en 'n lae spoed CAN -netwerk is. U maak verbinding met die laespoednet.)

U moet die Arduino ook programmeer om alle CAN -boodskappe via die seriële koppelvlak aan te meld, sodat u dit in 'n loglêer op u rekenaar kan stoor. Die standaard Arduino IDE stoor nie data in 'n loglêer nie, maar u kan bv. Putty in plaas daarvan.

Voordat u met u program begin skryf, moet u die CAN_BUS_Shield -biblioteek installeer.

Hier is 'n paar pseudokodes om u te help om met u program te begin:

stel op()

{init seriële verbinding init CAN biblioteek} lus () {as CAN boodskap ontvang word {lees CAN boodskap formaat log inskrywing skryf log inskrywing na reeks}}

Wenke:

U sal 'n instansie van klas MCP_CAN gebruik om toegang tot die funksie van die CAN -biblioteek te verkry:

MCP_CAN m_can;

Eerste KAN:

terwyl (m_can.begin ()! = CAN_OK)

{vertraging (1000); }

Kyk na en lees KAN -boodskappe:

terwyl (m_can.checkReceive () == CAN_MSGAVAIL)

{// Kry KAN -ID, boodskaplengte en boodskapdata m_can.readMsgBufID (& m_canId, & m_msgLen, m_msgBuf); // Doen iets met die boodskapdata hier}

As u meer hulp nodig het, kan u later 'n skakel na my program vind. Die CAN -skildbiblioteek bevat ook 'n voorbeeld. Of kyk na die instruksies van mviljoen2 wat 'n soortgelyke stap insluit.

Eerstens benodig u 'n verwysingslêer om u te help om data uit te filtreer. Skakel die ontsteking in die radiomodus en teken alles vir 'n paar minute aan sonder om aan enige knoppies te raak.

Begin dan vir elke knoppie om aan te meld, druk op die knoppie en stop met aanmeld.

As u klaar is, moet u alles wat in u verwysingslogboek is, uit u knoppieslogboeke filter om u kandidate te vind. Ek het uitgevind dat daar nog baie boodskappe oor was, so ek het meer logboeke gemaak en toe vereis dat "kandidate vir opdrag A in alle knoppie-A-lêers moet wees en in geen van die verwysingslêers nie". Dit het my net 'n paar moontlikhede gelaat om te probeer.

Die logboeke bevat baie boodskappe, dus u moet 'n program hiervoor skryf of moontlik Excel gebruik. (Ek het 'n program met baie harde kode vir my behoeftes gebruik, so ek is bevrees dat ek nie 'n program kan aanbied wat u kan gebruik nie.)

'N Waarskuwingswoord: U kan nie seker wees dat 'n knoppie altyd 'n identiese boodskap sal lewer nie. Sommige van die stukkies bevat moontlik toenemende tellers, ens. (U kan egter uitsluit dat die boodskap -ID dieselfde is.)

As u toevallig 'n Volvo V70 -02 het, is dit waarna u op soek is:

• Boodskap -ID: 0x0400066 Byte0: 0x00, 0x40, 0x80 of 0xc0 (gee nie om nie)
• Byte1: 0x00 (gee nie om nie)
• Byte2: 0x00 (gee nie om nie)
• Byte3: 0x00-0x07 (gee nie om nie)
• Byte4: 0x1f (gee nie om nie)
• Byte5: 0x40 (gee nie om nie)
• Byte6: 0x40 (gee nie om nie)
• Byte7: Knoppie -identifiseerder: 0x77 = volume op, 0x7b = volume laer, 0x7d = volgende snit, 0x7e = vorige snit.

As u van mening is dat u die opdragte gevind het, is dit 'n goeie idee om die program aan te pas sodat dit slegs die interessante boodskappe registreer. Kyk na die seriële log venster terwyl u op die knoppies druk om te verifieer dat u die korrekte boodskappe geïdentifiseer het.

Stap 4: Die hardeware prototipe

U hardeware moet in staat wees om:

1. Identifiseer opdragte wat op die CAN -bus ontvang is
2. Stuur opdragte in 'n ander formaat na die stereo

As u genoeg ruimte het, kan u 'n Arduino en 'n CAN -skild vir die eerste deel gebruik en 'n paar ekstra hardeware vir die tweede. Daar is egter 'n paar nadele:

• Die koste van die CAN -skild
• Grootte
• Die Arduino -kragtoevoer sal nie gelukkig wees as dit direk aan u 12V -motor gekoppel is nie (dit sal waarskynlik werk, maar die lewensduur daarvan sal waarskynlik verkort word).

Daarom gebruik ek die volgende:

• Atmega 328, die "Arduino -brein". (Daar is 'n paar variante; kry die een wat gelyk is aan die op Arduino Uno. U kan dit koop met of sonder Arduino -laaier.)
• 16 MHz kristal + kapasitors vir kloksein.
• MCP2551 KAN -ontvanger.
• MCP2515 KAN kontroleerder.
• TSR1-2450, skakel 6,5-36V om na 5V. (Word nie in die prototipe gebruik nie omdat die sagteware nie omgee vir die kragtoevoer nie.)
• CD4066B -skakelaar wat gebruik sal word wanneer opdragte na die stereo gestuur word.
• 'N Paar weerstande. (Die waardes kan later in die Eagle -skemas gevind word.)

'N Goeie ding met hierdie opset is dat dit ten volle versoenbaar is met die Arduino en die CAN -skildbiblioteek.

As u meer as vier knoppies wil hanteer, wil u dit oorweeg om iets anders as die CD4066B te gebruik. Die CD4066B kan beskryf word as vier skakelaars in een, elk beheer deur een van die Atmegas GPIO -penne. By elke skakelaar is daar 'n weerstand gekoppel wat gebruik kan word om die weerstand wat as ingang na die stereo gebruik word, te beheer. Dit kan dus maklik gebruik word om vier verskillende opdragte te stuur. As hulle gekombineer word, kan addisionele weerstandswaardes verkry word. Dit is waar die fout wat ek vroeër genoem het, kom. Ek het vier knoppies, maar ek was van plan om twee van hulle so lank en kort te druk om my ses verskillende opdragte te gee. Maar uiteindelik het ek uitgevind dat ek nie 'n kombinasie van weerstande kon vind wat my ses werkkombinasies sou gee nie. Dit is waarskynlik moontlik om eerder 'n analoog uitgangssignaal aan die stereo (3,5 mm -punt) te koppel. (Let daarop dat die Atmega geen ware analoog -penne het nie, dus ekstra hardeware is nodig.)

Vir toetsdoeleindes het ek ook 'n eenvoudige "motor- en stereo" -simulator gemaak om aan te sluit op my prototipe. Dit maak ontfouting makliker, en tensy u daarvan hou om in u motor te sit en te programmeer, kan ek dit aanbeveel.

Die prototipe word geïllustreer deur die onderste broodbord in die prentjie. Vir kragtoevoer, programmering en seriële aanmelding word dit aan 'n Arduino Uno gekoppel waar die Atmega -chip verwyder is.

Die boonste broodbord is die motor + stereosimulator wat gebruik sal word vir die eerste toets van die prototipe.

Die prototipe + simulator is bedoel om so te werk:

• Druk een van die skakelaars op die simulatorbord. (Dit is jou stuurwielknoppies.)
• As die simulatorprogram 'n druk op die knoppie opspoor, stuur dit die ooreenstemmende KAN -boodskap elke 70 ms, solank die knoppie ingedruk word. (Omdat die logs wat ek vroeër geneem het, aangedui het hoe dit in my motor werk.) Dit stuur ook baie "rommel" KAN -boodskappe om ander verkeer op die bus te simuleer.
• CAN -boodskappe word op die CAN -bus gestuur.
• KAN -boodskappe word deur die prototipe ontvang.
• Die MCP2515 gooi alle onverwante boodskappe op grond van die boodskap -ID.
• As die MCP2515 'n boodskap ontvang wat hanteer moet word, sal dit aandui dat dit 'n boodskap bevat.
• Die Atmega sal die boodskap lees en besluit watter knoppie as aktief beskou moet word.
• Die Atmega sal ook tred hou met die ontvangs van die laaste boodskap, na 'n sekere tyd sal die knoppie as vrygestel beskou word. (Die CAN -boodskappe dui slegs aan dat 'n knoppie af is, nie dat dit gedruk of losgemaak is nie.)
• As 'n knoppie as aktief beskou word, word een of meer skakelaars in die CD4066B geaktiveer.
• Die simulator (wat nou as u stereo optree) sal opspoor dat 'n weerstand tussen punt en mou toegepas word. (Die punt is gekoppel aan 3.3V en deur 'n weerstand aan 'n analoog invoerpen. As geen opdrag aktief is nie, lees hierdie pen 3.3V, as 'n opdrag aktief is, word die waarde laer en identifiseer die opdrag.
• Terwyl 'n opdrag aktief is, word die ooreenstemmende LED ook geaktiveer. (Daar is ses LED's omdat ek van plan was om twee lang / kort druk op twee van my knoppies te gebruik.)

Vir meer besonderhede oor die prototipe hardeware, sien Eagle -skemas in 'n latere stap.

Bykomende besonderhede oor die hardeware van die simulatorbord:

• 16 MHz kristal
• 22 pF kapasitors
• LED -weerstande moet gekies word op grond van LED -eienskappe
• Weerstand gekoppel aan A7 en 3.3V, kies bv. 2 kOhm (nie krities nie).
• Weerstands gekoppel aan MCP2551 en MCP2515 is optrek / aftrek. Kies bv. 10 kOhm.

(Of u kan die CAN -skild vir die 'CAN -deel' van die simulator gebruik as u dit verkies.)

Dit is belangrik dat u weet hoe die Atmega -penne aan die Arduino -penne gekoppel word wanneer u die hardeware ontwerp.

(Moet geen leds direk op die CD 4066B aansluit nie, dit kan slegs 'n lae stroom hanteer. Ek het dit probeer toe ek die uitset vir die eerste keer getoets het en die chip nutteloos geword het. is so goedkoop.)

Stap 5: Sekeringsprogrammering

Miskien het u in die vorige stap opgemerk dat die prototipe geen aparte komponente het om die kloksignaal na die MCP2515 te genereer nie. Dit is omdat daar reeds 'n 16 MHz kristal is wat gebruik word as die Atmega -kloksein wat ons kan gebruik. Maar ons kan dit nie sommer direk aan die MCP2515 koppel nie en daar is standaard geen klokuitsein op die Atmega nie.

(As u verkies, kan u hierdie stap oorslaan en in plaas daarvan die ekstra horlosie -hardeware byvoeg.)

Ons kan egter iets genaamd 'lontprogrammering' gebruik om 'n uitkloksein op een van die GPIO -penne moontlik te maak.

Eerstens moet u 'n lêer met die naam "boards.txt" opspoor wat deur u Arduino IDE gebruik word. U moet die inskrywing vir Arduino Uno kopieer, 'n nuwe naam gee en die waarde vir low_fuses verander.

My nuwe bord lyk so:

#################################################### ##############Gebaseer op Arduino Uno#Veranderinge:#lae_sekerings verander van 0xff na 0xbf om 16 MHz -klok in te skakel#out op Atmega PB0/pin 14 = Arduino D8

clkuno.name = Uitklok (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.bootloado.extended_fuses = 0xdot.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 = du.build.core = du.build.core = duo.

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

Let daarop dat die klok uit geaktiveer word deur die bedieningsbit op 0 te stel.

As u die nuwe bord in die konfigurasie -lêer van die planke geskep het, moet u 'n nuwe opstartlaaier na die Atmega verbrand. Daar is verskillende maniere om dit te doen; ek gebruik die metode wat beskryf word in

Nadat u dit gedoen het, moet u onthou om u nuwe bordtipe te kies en nie die Arduino Uno as u 'n program na die Atmega oplaai nie.

Stap 6: Die sagteware

Tyd om die stomme hardeware slim te maak deur sagteware by te voeg.

Hier is 'n paar pseudokodes vir die prototipe:

lastReceivedTime = 0

lastReceivedCmd = none cmdTimeout = 100 opstelling () {aktiveer waghond stel penne D4-D7 op as uitvoerpenne init CAN setup CAN filter} lus () {reset waghond as (CAN boodskap ontvang word) {vir elke knoppie opdrag {as CAN boodskap behoort aan die knoppieopdrag {lastReceivedTime = nou lastReceivedCmd = cmd}}} as nou> lastReceivedTime + cmdTimeout {lastReceivedCmd = none} vir elke knoppieopdrag {as lastReceivedCmd knoppieopdrag is {set command pin output = on} else {set command pin output = off }}}

cmdTimeout besluit hoe lank ons moet wag voordat ons kyk na die laaste aktiewe knoppie wat vrygestel is. Omdat die knoppie KAN -boodskapopdragte ongeveer elke 70 ms gestuur word, moet dit groter wees as die marge. Maar as dit te groot is, sal daar 'n vertragingservaring wees. 100 ms lyk dus 'n goeie kandidaat.

Maar wat is 'n waghond? Dit is 'n nuttige klein hardeware -funksie wat ons kan red in geval van 'n ongeluk. Stel u voor dat ons 'n fout het wat veroorsaak dat die program ineenstort terwyl die volume -opdrag aktief is. Dan eindig ons met die stereo op maksimum volume! Maar as die waghond nie vir die spesifieke tyd herstel word nie, sal dit besluit dat iets onverwags gebeur het en sal dit eenvoudig herstel word.

leemte opstelling ()

{// laat maksimum 250 ms toe vir die lus wdt_enable (WDTO_250MS); // ander init stuff} leemte lus () {wdt_reset (); // doen dinge}

KAN filter? U kan die CAN -beheerder instel om alle boodskappe wat nie by die filter pas nie, weg te gooi, sodat die sagteware nie tyd hoef te mors op boodskappe wat ons nie omgee nie.

ongetekende lang masker = 0x1fffffff; // Sluit al die 29 kopstukke in die masker in

ongetekende lang filterId = 0x0400066; // Ons gee net om vir hierdie KAN -boodskap -id m_can.init_Mask (0, CAN_EXTID, masker); // 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);

Kyk na die CAN -biblioteekkode en die dokumentasie van die CAN -kontroleerder vir meer inligting oor hoe om filter + masker op te stel.

U kan ook die CAN -beheerder instel om 'n onderbreking te veroorsaak wanneer 'n boodskap (wat nie uitgefiltreer is nie) ontvang word. (Dit is nie in die voorbeeld hierbo ingesluit nie, maar daar is 'n paar kode daarvoor in my program.) In hierdie geval voeg dit nie regtig waarde toe nie, en dit kan verwarrend wees as u nie gewoond is aan programmering nie.

Dit was dus die prototipe sagteware in opsomming. Maar ons benodig ook 'n kode vir die simulatorbord:

lastSentTime = 0

minDelayTime = 70 opstelling () {konfigureer penne A0-A5 as uitsetpenne stel penne D4-D7 as invoerpenne met interne pullup op. init CAN} lus () {stuur "rommel" kan msg set activeButton = none vir elke knoppie {as knoppie gedruk word {set activeButton = button}} as activeButton! = none {if now> lastSentTime + minDelayTime {stuur knoppie bevel kan boodskap stuur } stel lastSentTime = nou} inval = lees speld A7 voor (cmd) {if (min <ongeldig <maks.) {led on} anders {led af}} wag vir 1 ms}

Dit stuur CAN -boodskappe ongeveer elke ms voortdurend "rommel" en terwyl 'n knoppie ingedruk word, word die ooreenstemmende opdrag elke 70 ms.

Miskien moet u die invoer op pen A7 aanmeld terwyl u op die verskillende knoppies druk om die geskikte waardes uit te vind vir die min- en maksimum veranderlikes wat aan elke knoppie behoort. (Of u kan dit bereken, maar die lees van die insette gee u meer presiese waardes.)

U moet 'n bietjie versigtig wees as u die penmodusse programmeer. As u per ongeluk die penne instel wat bedoel is om interne pullup as uitvoerpenne te gebruik, sal u 'n moontlike kortpad skep wat u Arduino kan beskadig as u die uitset hoog stel.

As u my programme wil nagaan, kan hulle hier afgelaai word:

• KAN boodskappe aanmeldprogram
• Program vir die simulatorbord
• Program vir prototipe / finale bord

U moet weet dat hierdie programme nie regtig ooreenstem met die pseudokode nie; dit bevat baie 'ekstra' dinge wat u nie regtig nodig het nie, en as u nie vertroud is met objekgeoriënteerde programmering nie, kan dit 'n bietjie moeilik wees om te lees.

Stap 7: Die finale hardeware

As u tevrede is met u program (onthou om die prototipe in die motor te toets na die laaste toets met die simulatorbord), is dit tyd om die regte hardeware te bou.

U het drie opsies hier:

• Vinnig en vuil - soldeer die goed saam op 'n PCB -prototipe bord.
• Hardcore DIY - ets jou eie PCB.
• Die lui manier - bestel 'n professionele PCB om die komponente aan te soldeer.

As u nie haastig is nie, kan ek die laaste opsie aanbeveel. As u net 'n klein PCB soos hierdie benodig, is dit baie goedkoop om dit uit China te bestel. (Dan kry u waarskynlik ongeveer tien stukke, sodat u soldeerfoute kan bekostig.)

Om PCB's te bestel, moet u u ontwerp in Gerber -formaat stuur. Daar is verskillende sagteware hiervoor. Ek het Eagle gebruik wat ek kan aanbeveel. U kan 'n paar uur verwag om dit te leer, maar dan werk dit goed. Vir klein borde soos hierdie kan u dit gratis gebruik.

Wees versigtig wanneer u die ontwerp maak. U wil nie vier weke wag vir aflewering nie, net om uit te vind dat u iets verkeerd gedoen het.

(As u goeie soldeervaardighede het, kan u ontwerp vir komponente op die oppervlak en 'n baie klein adapter kry. Ek het nie.)

Bestel dan by bv. https://www.seeedstudio.com/fusion_pcb.html. Volg die instruksies vir die generering van die Gerber -lêers uit u ontwerp. U kan ook 'n voorskou van die resultaat kry om te verseker dat dit goed is.

(Uiteindelik moes ek ander weerstande vir R4-R7 kies as wat op die skematiese prentjie verskyn. In plaas daarvan gebruik ek 2k, 4.7k, 6.8k en 14.7k.)

En onthou - moenie die Atmega -pen -nommer met die Arduino -pen -nommer verwar nie!

Ek beveel aan dat u nie die Atmega -chip direk soldeer nie, maar 'n voetstuk gebruik. Dan kan u dit maklik verwyder as u dit moet herprogrammeer.

Stap 8: Car Mounting

Nou tot die lekkerste deel - monteer dit in u motor en begin dit gebruik! (Nadat u 'n saak daarvoor gemaak of gekoop het.)

As u die prototipe in u motor reeds volledig getoets het, behoort alles perfek te werk.

(Soos ek vroeër genoem het, het ek dit nie gedoen nie, maar ek moes 'n paar weerstande vervang en 'n paar veranderinge in my program aanbring.)

Oorweeg ook of u dit agter die stereo of êrens anders moet monteer. Ek het 'n goeie plek bokant my handskoenkas gevind waar ek dit van binne die handskoenhouer kan bereik sonder om iets uitmekaar te haal. Dit kan nuttig wees as ek besluit om dit later op te gradeer.

Uiteindelik werk my knoppies weer! Hoe sou ek twee maande sonder hulle kon oorleef?

Stap 9: Toekomstige verbeterings

Soos genoem, sal ek die 4066B vervang met iets anders (waarskynlik 'n digitale potensiometer) vir 'n groter buigsaamheid as ek 'n weergawe 2.0 hiervan maak.

Daar is ook baie ander dinge wat u kan doen. Bv. voeg 'n bluetooth -module by en maak 'n afstandbeheer -app vir u telefoon. Of 'n GPS -module, as u naby die huis is, kan u outomaties die volume verhoog en die "windows down" KAN -boodskap stuur sodat al u bure van u wonderlike musiek kan geniet.