Pasadyang Arduino upang Panatilihing MAAARI ang Mga Pindutan sa Mga Manibela na May Bagong Car Stereo: 9 Mga Hakbang (na may Mga Larawan)

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:14

Napagpasyahan kong palitan ang orihinal na stereo ng kotse sa aking Volvo V70 -02 ng isang bagong stereo upang masisiyahan ako sa mga bagay tulad ng mp3, Bluetooth at handsfree.

Ang aking kotse ay may ilang mga kontrol sa manibela para sa stereo na nais kong magamit pa rin. Hindi ko inaasahan na magiging problema iyon dahil maraming mga adaptor sa merkado na dapat na katugma sa aking kotse. Gayunpaman natagpuan ko sa lalong madaling panahon na hindi sila! (Mukhang ang mga adaptor para sa V70 ay maaaring may mga problema sa -02 mga kotse dahil sa isang bahagyang naiibang CAN protocol.)

Kaya kung ano ang gagawin pagkatapos? Panatilihin ang lumang stereo? Live ang isang buhay na may mga hindi gumaganang mga pindutan? Syempre hindi! Kung walang nagtatrabaho adapter sa merkado pagkatapos ay magkakaroon kami upang bumuo ng isa!

Maaaring mailapat ang itinuturo na ito (na may ilang mga pagbagay) sa mga kotse kung saan nakikipag-usap ang mga pindutan ng manibela sa CAN bus.

Hakbang 1: Alamin Kung Paano Magpadala ng Mga Utos sa Stereo

Ang unang bagay na dapat mong gawin ay upang malaman kung anong uri ng remote input ang inaasahan ng stereo. Kadalasan hindi sasabihin sa iyo ng mga tagagawa iyon at marahil ay wala kang access sa pagtatrabaho ng mga remote control para sa reverse engineering din.

Ang remote in para sa aking bagong stereo (Kenwood) ay binubuo ng isang solong kawad at hindi ko nagawang malaman ang anumang impormasyon tungkol sa kung paano ito gumagana. Gayunpaman mayroon din itong 3.5 mm jack para sa remote input. Wala rin akong nalaman tungkol doon. Ngunit may ilang impormasyon tungkol sa isang 3.5 mm jack para sa iba pang mga tatak na nagpapahiwatig na ang iba't ibang mga utos ay nakilala sa pamamagitan ng paglalapat ng isang tiyak na paglaban sa pagitan ng tip at manggas (at opsyonal sa pagitan ng singsing at manggas). Hal. https://forum.arduino.cc/index.php?topic=230068.0. Kaya't nagpasya akong subukan iyon, na nilagyan ng isang breadboard, isang bungkos ng resistors at isang plug na 3.5 mm na naka-plug in sa stereo at nakakonekta sa breadboard. Walang kinilala sa una, ngunit ang stereo ay may menu na "mode ng pagkatuto" at doon ang mga utos ay maaaring matagumpay na na-set up habang naglalapat ng iba't ibang paglaban. Tagumpay!

Gayunpaman nalaman ko kalaunan na nagkamali ako rito: Hindi lahat ng mga utos na tila natutunan ng stereo ay talagang gagana. Hal. Ang 30 kOhm ay natagpuan sa mode ng pag-aaral ngunit hindi gumana sa paglaon at para sa ilan sa mga utos na itinakda ko ang pagkakaiba ng paglaban ay napakaliit na kalaunan ang maling utos ay napalitaw.

Kaya inirerekumenda ko na gumamit ka ng isang breadboard na may resistors at lumipat ng mga pindutan para sa lahat ng mga remote na utos na nais mong hawakan at talagang subukan na ang lahat ng mga ito ay gagana.

Kung ang iyong kotse stereo ay hindi makakatanggap ng input sa parehong paraan pagkatapos ay kakailanganin mong malaman kung paano ito gumagana upang maaari mong iakma ang solusyon na ito. Kung hindi mo talaga mawari lahat mayroon kang problema.

Hakbang 2: Alamin Kung Saan Makikonekta sa CAN Bus

Kailangan mong hanapin ang isang magandang lugar upang kumonekta sa CAN bus. Dahil pinapalitan mo ang isang lumang stereo na nakikipag-usap sa HINDI dapat mong makita iyon sa likod ng stereo. Ang CAN bus ay binubuo ng isang pares ng mga twisted wires (CAN-L at CAN_H). Kumunsulta sa isang diagram ng mga kable para masiguro ang iyong sasakyan.

Hakbang 3: Baliktarin ang Engineering ng CAN Messages

Maliban kung masasabi sa iyo ng Google kung ano ang MAAARING mga mensahe na dapat mong pakinggan pagkatapos kakailanganin mong kumonekta sa CAN bus at gumawa ng ilang reverse engineering. Gumamit ako ng isang Arduino Uno at isang CAN na kalasag. (Hindi mo talaga kailangan ang CAN na kalasag, tulad ng makikita mo sa paglaon maaari kang gumamit ng ilang mga murang sangkap sa isang breadboard sa halip.)

Kumunsulta sa Google upang malaman kung anong baud rate ang dapat mong gamitin kapag kumokonekta sa iyong kotse. (Karaniwan ay makikita mo na mayroong isang mataas na bilis at isang mababang bilis na CAN net. Kumokonekta ka sa mababang bilis ng net.)

Kakailanganin mo ring i-program ang Arduino upang mag-log lahat ng mga mensahe ng CAN sa serial interface upang mai-save mo sila sa isang log file sa iyong computer. Ang karaniwang Arduino IDE ay hindi makatipid ng data sa isang log file ngunit maaari mong gamitin ang hal. Sa halip ay masilya.

Bago mo simulang isulat ang iyong programa kailangan mong i-install ang CAN_BUS_Shield library.

Narito ang ilang pseudo code upang matulungan kang makapagsimula sa iyong programa:

setup ()

{init serial connection init CAN library} loop () {kung CAN message ay natanggap {read CAN message format log entry wrote log entry to serial}}

Mga Pahiwatig:

Gumagamit ka ng isang halimbawa ng klase MCP_CAN upang ma-access ang CAN library na pag-andar:

MCP_CAN m_can;

Init CAN:

habang (m_can.begin ()! = CAN_OK)

{pagkaantala (1000); }

Suriin at basahin ang mga CAN na mensahe:

habang (m_can.checkReceive () == CAN_MSGAVAIL)

{// Kumuha ng CAN id, haba ng mensahe at data ng mensahe m_can.readMsgBufID (& m_canId, & m_msgLen, m_msgBuf); // Gumawa ng isang bagay sa data ng mensahe dito}

Kung kailangan mo ng karagdagang tulong maaari kang makahanap ng isang link sa aking programa sa susunod na hakbang. May kasama ring halimbawa ang library ng CAN Shield. O suriin ang itinuturo ng mviljoen2 na may kasamang isang katulad na hakbang.

Una kakailanganin mo ang isang sanggunian na file upang matulungan kang mag-filter ng data. Lumipat sa ignition sa radio mode at i-log ang lahat sa loob ng isang minuto nang hindi hinawakan ang anumang mga pindutan.

Pagkatapos para sa bawat isa sa mga pindutan, simulang mag-log, itulak ang pindutan at ihinto ang pag-log.

Kapag tapos ka na kailangan mong i-filter ang lahat na nasa iyong sanggunian log mula sa iyong mga tala ng pindutan upang hanapin ang iyong mga kandidato. Nalaman ko na marami pa ring natitirang mga mensahe kaya gumawa ako ng higit pang mga tala at pagkatapos ay hinihiling na "ang mga kandidato para sa utos A ay dapat na nasa lahat ng mga pindutan-A-file at wala sa mga sanggunian na file". Naiwan ako ng ilang mga posibilidad lamang upang subukan.

Maglalaman ang mga log ng maraming mensahe kaya kakailanganin mong magsulat ng ilang programa para dito o posibleng gumamit ng Excel. (Gumamit ako ng isang programa na may napakahirap na mga naka-code na kondisyon para sa aking mga pangangailangan kaya natatakot akong hindi ako mag-alok ng isang programa na maaari mong magamit.)

Isang salita ng babala: Hindi ka makasisiguro na ang isang pindutan ay palaging makakagawa ng isang magkaparehong mensahe. Ang ilan sa mga piraso ay maaaring maglaman ng mga pagtaas ng counter atbp (Maaari mong maliban sa mensahe id na maging pareho subalit.)

Kung nagkakaroon ka ng Volvo V70 -02 ito ang hinahabol mo:

• Id ng mensahe: 0x0400066Byte0: 0x00, 0x40, 0x80 o 0xc0 (walang pakialam)
• Byte1: 0x00 (walang pakialam)
• Byte2: 0x00 (walang pakialam)
• Byte3: 0x00-0x07 (walang pakialam)
• Byte4: 0x1f (walang pakialam)
• Byte5: 0x40 (walang pakialam)
• Byte6: 0x40 (walang pakialam)
• Byte7: Kilalanin ang button: 0x77 = volume up, 0x7b = volume down, 0x7d = susunod na track, 0x7e = nakaraang track.

Kapag naniniwala kang natagpuan mo ang mga utos maaaring maging isang magandang ideya na baguhin ang programa upang mag-log lamang ito ng mga kagiliw-giliw na mensahe. Tingnan ang window ng serial log habang pinindot mo ang mga pindutan upang ma-verify na natukoy mo ang mga tamang mensahe.

Hakbang 4: Ang Hardware Prototype

Kailangan ng iyong hardware na:

1. Tukuyin ang mga natanggap na utos sa CAN bus
2. Magpadala ng mga utos sa isa pang format sa stereo

Kung mayroon kang sapat na puwang maaari kang gumamit ng isang Arduino at isang CAN na kalasag para sa unang bahagi at maglakip ng ilang karagdagang hardware para sa pangalawa. Gayunpaman mayroong ilang mga drawbacks:

• Gastos ng CAN Shield
• Sukat
• Ang suplay ng kuryente ng Arduino ay hindi magiging masaya kung nakakonekta ito nang direkta sa iyong mga kotse 12V (malamang na gagana ito ngunit ang buhay ay malamang na paikliin).

Kaya sa halip ay ginamit ko ang sumusunod:

• Atmega 328, ang "utak ng Arduino". (Mayroong ilang mga variant, kunin ang isa na katumbas ng isa sa Arduino Uno. Maaari mo itong bilhin gamit o wala ang Arduino boot loader.)
• 16 MHz kristal + capacitor para sa signal ng orasan.
• MCP2551 CAN transceiver.
• MCP2515 MAAARI control.
• Ang TSR1-2450, nagko-convert ng 6.5-36V sa 5V. (Hindi ginamit sa prototype dahil ang software ay walang pakialam sa power supply.)
• Ang CD4066B switch na gagamitin kapag nagpapadala ng mga utos sa stereo.
• Isang pares ng resistors. (Ang mga halaga ay maaaring matagpuan sa mga iskema ng Eagle sa susunod na hakbang.)

Ang isang magandang bagay sa pagsasaayos na ito ay na ito ay ganap na katugma sa Arduino at ang CAN Shield library.

Kung nais mong hawakan ang higit sa apat na mga pindutan baka gusto mong isaalang-alang na gumamit ng ibang bagay kaysa sa CD4066B. Ang CD4066B ay maaaring inilarawan bilang apat na switch sa isa, bawat isa ay kinokontrol ng isa sa mga Atmegas GPIO pin. Sa bawat switch mayroong isang resistor na konektado na maaaring magamit upang makontrol ang paglaban na ginamit bilang input sa stereo. Kaya madali itong magagamit upang magpadala ng apat na magkakaibang utos. Kung pinagsama sila pagkatapos ay maaaring makuha ang mga karagdagang halaga ng paglaban. Dito pumapasok ang pagkakamali na nabanggit ko kanina. Mayroon akong apat na mga pindutan, ngunit binalak kong ipatupad ang dalawa sa kanila habang mahaba at maikling pindutin upang bigyan ako ng anim na magkakaibang utos. Ngunit sa huli nalaman ko na hindi ako makakahanap ng isang kumbinasyon ng mga resistors na magbibigay sa akin ng anim na nagtatrabaho na mga kumbinasyon. Marahil ay posible na ikonekta ang isang analog out signal sa stereo (3.5 mm na tip) sa halip. (Tandaan na ang Atmega ay walang totoong mga analog out na pin kaya kinakailangan ng ilang karagdagang hardware.)

Para sa mga layuning pagsubok ay gumawa rin ako ng isang simpleng "kotse at stereo" na simulator upang kumonekta sa aking prototype. Ginagawa nitong mas madali ang pag-debug at maliban kung nasisiyahan ka na umupo sa iyong kotse at programa maaari ko itong inirerekumenda.

Ang prototype ay inilalarawan ng ilalim ng breadboard sa imahe. Para sa supply ng kuryente, programa at serial logging na nakakabit ito sa isang Arduino Uno kung saan tinanggal ang Atmega chip.

Ang itaas na tinapay ay ang kotse + stereo simulator na gagamitin para sa paunang pagsubok ng prototype.

Ang prototype + simulator ay inilaan upang gumana tulad nito:

• Pindutin ang isa sa mga pindutan ng switch sa simulator board. (Iyon ang iyong mga pindutan ng manibela.)
• Kapag nakita ng programa ng simulator ang isang pindutan na pindutin magpapadala ito ng kaukulang mensahe ng CAN sa bawat 70 ms hangga't ang pindutan ay naitulak. (Dahil ang mga troso na kinuha ko kanina ay ipinahiwatig na kung paano ito gumagana sa aking kotse.) Magpapadala din ito ng maraming mga "basura" na mensahe ng CAN upang gayahin ang iba pang trapiko sa bus.
• Ang mga mensahe ng CAN ay naipadala sa CAN bus.
• CAN mga mensahe ay natanggap ng prototype.
• Itinapon ng MCP2515 ang lahat ng mga hindi kaugnay na mensahe batay sa message id.
• Kapag ang MCP2515 ay nakatanggap ng isang mensahe na dapat hawakan ito ay ipahiwatig na mayroon itong isang mensahe na naka-enquue.
• Basahin ng Atmega ang mensahe at magpapasya kung aling pindutan ang dapat isaalang-alang na aktibo.
• Masusubaybayan din ng Atmega kung kailan natanggap ang huling mensahe, pagkatapos ng isang tiyak na oras ang pindutan ay maituturing na pinakawalan. (Ipinapahiwatig lamang ng mga mensahe ng CAN na ang isang pindutan ay nakababa, hindi na naitulak o pinakawalan ito.)
• Kung ang isang pindutan ay itinuturing na aktibo pagkatapos ang isa o higit pang mga switch sa CD4066B ay isasaaktibo.
• Ang simulator (kumikilos ngayon bilang iyong stereo) ay makakakita na ang isang paglaban ay inilapat sa pagitan ng tip at manggas. (Ang tip ay konektado sa 3.3V at sa pamamagitan ng isang risistor sa isang analog input pin. Kapag walang utos na aktibo ang pin na ito ay magbasa ng 3.3V, kapag ang isang utos ay aktibo ang halaga ay magiging mas mababa at kilalanin ang utos.
• Habang ang isang utos ay aktibo ang kaukulang humantong ay buhayin din. (Mayroong anim na leds dahil binalak kong gumamit ng iba't ibang haba / maikling pindutin para sa dalawa sa aking mga pindutan.)

Para sa higit pang mga detalye tungkol sa hardware ng prototype, tingnan ang mga eskematiko ng Eagle sa susunod na hakbang.

Mga karagdagang detalye tungkol sa hardware ng simulator board:

• 16 MHz na kristal
• 22 pF capacitor
• Ang mga LED resistor ay dapat mapili batay sa mga pag-aari ng LED
• Ang risistor ay konektado sa A7 at 3.3V, piliin ang hal. 2kOhm (hindi kritikal).
• Ang mga resistors na konektado sa MCP2551 at MCP2515 ay pull-up / pull-down. Pumili hal. 10 kOhm.

(O maaari mong gamitin ang CAN kalasag para sa "MAAARI bahagi" ng simulator kung nais mo.)

Mahalagang malaman mo kung paano naka-map ang mga pin ng Atmega sa mga pin ng Arduino kapag idinisenyo mo ang hardware.

(Huwag ikonekta ang anumang mga leds nang direkta sa CD 4066B, maaari lamang itong hawakan ang isang mababang kasalukuyang. Sinubukan ko iyon noong una kong sinubukan ang output at ang chip ay naging walang silbi. Ang magandang bagay ay bumili ako ng ilan sa kanila dahil lamang sa napakamura.)

Hakbang 5: Programming ng Fuse

Marahil napansin mo sa nakaraang hakbang na ang prototype ay walang hiwalay na mga bahagi upang makabuo ng signal ng orasan sa MCP2515. Iyon ay dahil mayroon nang isang 16 MHz na kristal na ginamit bilang signal ng orasan ng Atmega na maaari naming magamit. Ngunit hindi namin simpleng makakonekta ito nang direkta sa MCP2515 at sa pamamagitan ng default walang signal out na orasan sa Atmega.

(Kung mas gusto mo maaari mong laktawan ang hakbang na ito at idagdag ang karagdagang hardware sa orasan.)

Gayunpaman maaari naming gamitin ang isang bagay na tinatawag na "fuse program" upang paganahin ang isang signal ng orasan sa isa sa mga pin ng GPIO.

Una kakailanganin mong hanapin ang isang file na pinangalanang "boards.txt" na ginamit ng iyong Arduino IDE. Kakailanganin mong kopyahin ang entry para sa Arduino Uno, bigyan ito ng isang bagong pangalan at baguhin ang halaga para sa mga low_fuse.

Ang aking bagong board ay ganito:

###Oooooooooooooooo # # # # # # # # # #

clkuno.name = Clock out (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 = 0xfdk clapuno.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 = arduino clkuno.build.v

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

Tandaan na ang orasan ay naaktibo sa pamamagitan ng pagtatakda ng kontrol nito nang kaunti sa 0.

Kapag nilikha mo ang bagong board sa mga file ng pagsasaayos ng mga board kakailanganin mong sunugin ang isang bagong boot loader sa Atmega. Mayroong iba't ibang mga paraan upang magawa ito, ginamit ko ang pamamaraang inilarawan sa

Pagkatapos mong magawa ito, tandaan na piliin ang iyong bagong uri ng board at hindi ang Arduino Uno kapag nag-upload ka ng isang programa sa Atmega.

Hakbang 6: Ang Software

Oras upang gawing matalino ang pipi na hardware sa pamamagitan ng pagdaragdag ng ilang software.

Narito ang ilang pseudo code para sa prototype:

lastReceivedTime = 0

lastReceivedCmd = none cmdTimeout = 100 setup () {paganahin ang pag-configure ng watchdog ng mga pin D4-D7 bilang mga output pin na MAAARING i-set up ang CAN filter} loop () {reset watchdog kung (CAN message ay natanggap) {para sa bawat command button {kung ang CAN message ay kabilang sa ang pindutan ng utos {lastReceivedTime = now lastReceivedCmd = cmd}}} kung ngayon> lastReceivedTime + cmdTimeout {lastReceivedCmd = wala} para sa bawat utos ng pindutan {kung ang lastReceivedCmd ay pindutan ng pindutan {itakda ang utos pin output = sa} iba pa {itakda ang utos ng utos ng utos = }}}

Nagpasya ang cmdTimeout kung gaano katagal dapat tayong maghintay bago isaalang-alang ang huling aktibong pindutan na inilabas. Dahil ang button na CAN message ay ipinadala ang mga utos ng humigit-kumulang sa bawat 70 ms kailangan itong maging mas malaki kaysa sa na may ilang margin. Ngunit kung ito ay malaki ay magkakaroon ng isang lag karanasan. Kaya't ang 100 ms ay tila isang mahusay na kandidato.

Ngunit ano ang isang tagapagbantay? Ito ay isang kapaki-pakinabang na maliit na tampok sa hardware na maaaring mag-save sa amin sa kaso ng isang pag-crash. Isipin na mayroon kaming isang bug na sanhi ng pag-crash ng programa habang ang dami ng utos ay aktibo. Pagkatapos ay magtatapos kami sa stereo sa max na dami! Ngunit kung ang watchdog ay hindi na-reset para sa tukoy na oras magpapasya ito na may isang bagay na hindi inaasahan na nangyari at maglabas lamang ng isang pag-reset.

walang bisa ang pag-setup ()

{// payagan ang max 250 ms para sa loop wdt_enable (WDTO_250MS); // other init stuff} void loop () {wdt_reset (); // gawin mga bagay-bagay }

MAAARI bang mag-filter? Sa gayon, maaari mong i-configure ang CAN controller upang itapon ang lahat ng mga mensahe na hindi tumutugma sa filter upang ang software ay hindi magsayang ng oras sa mga mensahe na wala kaming pakialam.

unsigned mahabang mask = 0x1fffffff; // Isama ang lahat ng 29 mga header bits sa maskara

unsigned mahabang filterId = 0x0400066; // Nag-aalala lang kami tungkol sa CAN message id m_can.init_Mask (0, CAN_EXTID, mask); // Nalalapat ang mask 0 sa filter na 0-1 m_can.init_Mask (1, CAN_EXTID, mask); // Nalalapat ang mask 1 sa 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);

Suriin ang CAN code ng aklatan at ang dokumentasyon ng CAN controller para sa higit pang mga detalye tungkol sa kung paano mag-set up ng filter + mask.

Maaari mo ring i-set up ang CAN controller upang itaas ang isang nakakagambala kapag ang isang mensahe (na hindi nai-filter) ay natanggap. (Hindi kasama sa halimbawa sa itaas ngunit may ilang mga code para dito sa aking programa.) Sa kasong ito hindi talaga ito nagdaragdag ng anumang halaga at maaaring nakalilito kung hindi ka sanay sa pag-program.

Kaya't iyon ang prototype software sa buod. Ngunit kailangan namin ng ilang code para sa board ng simulator din:

lastSentTime = 0

minDelayTime = 70 setup () {i-configure ang mga pin na A0-A5 bilang mga output pin na configure ang mga pin na D4-D7 bilang mga input pin na may panloob na pullup. init CAN} loop () {send "junk" can msg set aktibo Button = none for each button {if button is push {set active Button = button}} if active Button! = none {if now> lastSentTime + minDelayTime {send button command can message } itakda ang lastSentTime = ngayon} inval = basahin ang pin A7 aloach (cmd) {kung (min <inval <max) {humantong sa} iba pa {humantong}} maghintay para sa 1 ms}

Ito ay patuloy na magpapadala ng "junk" CAN mga mensahe na tinatayang bawat ms at habang ang isang pindutan ay tinulak ang kaukulang utos bawat 70 ms.

Maaaring kailanganin mong i-log ang input sa pin A7 habang pinipindot ang iba't ibang mga pindutan upang malaman ang naaangkop na mga halaga para sa mga min at max na variable na kabilang sa bawat pindutan. (O maaari mo itong kalkulahin, ngunit ang tunay na pagbabasa ng input ay magbibigay sa iyo ng mas tumpak na mga halaga.)

Kailangan mong maging medyo maingat kapag pinaprograma mo ang mga mode ng pin. Kung hindi mo sinasadyang itakda ang mga pin na inilaan upang magamit ang panloob na pullup bilang mga output pin sa halip ay lilikha ka ng isang potensyal na shortcut na makakasira sa iyong Arduino kapag itinakda mo ang output ng mataas.

Kung nais mong suriin ang aking mga programa maaari silang ma-download dito:

• CAN program ng pag-log ng mga mensahe
• Programa para sa board ng simulator
• Programa para sa prototype / panghuling board

Dapat mong magkaroon ng kamalayan na ang mga programang iyon ay hindi talaga tumutugma sa pseudo code dito, naglalaman sila ng maraming "labis" na bagay na hindi talaga kinakailangan at kung hindi ka pamilyar sa object oriented na programa maaaring marahil ay medyo mahirap basahin.

Hakbang 7: Ang Pangwakas na Hardware

Kapag masaya ka sa iyong programa (tandaan na subukan ang prototype sa kotse pagkatapos ng huling pagsubok sa simulator board) oras na upang buuin ang totoong hardware.

Mayroon kang tatlong mga pagpipilian dito:

• Mabilis at marumi - maghinang ng mga bagay-bagay sa isang PCB prototype board.
• Hardcore DIY - mag-ukit ng iyong sariling PCB.
• Ang tamad na paraan - mag-order ng isang propesyonal na PCB upang maghinang ng mga bahagi.

Kung hindi ka nagmamadali maaari kong magrekomenda ng huling pagpipilian. Kung kakailanganin mo lamang ang isang maliit na PCB tulad nito napakamurang mag-order nito mula sa China. (At pagkatapos ay marahil ay makakakuha ka ng sampung piraso o higit pa upang makaya mo ang ilang mga pagkakamali sa paghihinang.)

Upang mag-order ng mga PCB kakailanganin mong ipadala ang iyong disenyo sa Gerber format. Mayroong iba't ibang mga software para dito. Gumamit ako ng Eagle na maaari kong magrekomenda. Maaari mong asahan ang ilang oras upang malaman ito ngunit pagkatapos ito ay maayos. Para sa maliliit na board na tulad nito maaari mo itong gamitin nang libre.

Mag-ingat kapag ginawa mo ang disenyo. Hindi mo nais na maghintay ng apat na linggo para sa paghahatid upang malaman lamang na may mali kang nagawa.

(Kung mayroon kang mahusay na mga kasanayan sa paghihinang maaari kang mag-disenyo para sa mga naka-mount na bahagi at makakuha ng isang talagang maliit na adapter. Hindi ko ginawa.)

Pagkatapos ay mag-order sa hal. https://www.seeedstudio.com/fusion_pcb.html. Sundin ang mga tagubilin para sa kung paano makabuo ng mga Gerber file mula sa iyong disenyo. Maaari ka ring makakuha ng isang preview ng resulta upang matiyak na ito ay ok.

(Sa huli kailangan kong pumili ng iba pang mga resistors para sa R4-R7 kaysa sa nakalista sa larawan ng eskematiko. Sa halip ay gumamit ako ng 2k, 4.7k, 6.8k at 14.7k.)

At tandaan - huwag lituhin ang pagnunumero ng pin na Atmega sa pagraranggo ng Arduino pin!

Inirerekumenda ko na huwag mong solder ang Atmega chip nang direkta ngunit gumamit ng isang socket. Pagkatapos ay maaari mong madaling alisin ito kung sakaling kailanganin mong i-reprogram ito.

Hakbang 8: Pag-mount ng Kotse

Ngayon sa pinakasayang bahagi - i-mount ito sa iyong kotse at simulang gamitin ito! (Matapos mong gumawa / bumili ng kaso para rito.)

Kung nasubukan mo nang kumpleto ang prototype sa iyong sasakyan ang lahat ay dapat na gumana nang perpekto.

(Tulad ng nabanggit ko kanina hindi ko ginawa kaya kailangan kong palitan ang ilang mga resistors at gumawa ng ilang mga pagbabago sa aking programa.)

Isaalang-alang din kung dapat mong i-mount ito sa likod ng stereo o sa kung saan man. Natagpuan ko ang isang magandang lugar sa itaas ng aking glove box kung saan maaabot ko ito mula sa loob ng glove box nang hindi pinaghihiwalay. Maaari itong maging kapaki-pakinabang kung magpapasya akong i-upgrade ito sa paglaon.

Sa wakas ang aking mga pindutan ay gumagana muli! Paano ako makakaligtas sa loob ng dalawang buwan kung wala sila?

Hakbang 9: Mga Pagpapabuti sa Hinaharap

Tulad ng nabanggit, kung gumawa ako ng isang bersyon 2.0 nito palitan ko ang 4066B ng ibang bagay (marahil isang digital potentiometer) para sa higit na kakayahang umangkop.

Marami ding iba pang mga bagay na maaari mong gawin. Hal. magdagdag ng isang module ng Bluetooth at gumawa ng isang remote control app para sa iyong telepono. O isang module ng gps, pagkatapos kapag malapit ka sa bahay maaari kang awtomatikong taasan ang lakas ng tunog at ipadala ang mensahe na "windows down" CAN upang ang lahat ng iyong mga kapitbahay ay masiyahan sa iyong kahanga-hangang musika.