Niestandardowe Arduino, aby zachować przyciski na kierownicy CAN z nowym samochodowym stereo: 9 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:32

Zdecydowałem się wymienić oryginalny radioodtwarzacz samochodowy w moim Volvo V70 -02 na nowy, aby móc cieszyć się takimi rzeczami jak mp3, bluetooth i zestaw głośnomówiący.

Mój samochód ma kilka elementów sterujących na kierownicy do sterowania stereo, z których nadal chciałbym móc korzystać. Nie spodziewałem się, że będzie to problem, ponieważ na rynku jest kilka adapterów, które mają być kompatybilne z moim samochodem. Szybko jednak dowiedziałem się, że nie! (Wygląda na to, że adaptery do V70 mogą mieć problemy z samochodami -02 ze względu na nieco inny protokół CAN.)

Co więc zrobić? Zachować stare stereo? Żyj życiem z niedziałającymi przyciskami? Oczywiście nie! Jeśli na rynku nie ma działającego adaptera, będziemy musieli go zbudować!

Ta instrukcja może być zastosowana (z pewnymi adaptacjami) w samochodach, w których przyciski na kierownicy komunikują się przez magistralę CAN.

Krok 1: Dowiedz się, jak wysyłać polecenia do zestawu stereo

Pierwszą rzeczą, którą powinieneś zrobić, to dowiedzieć się, jakiego typu wejścia zdalnego oczekuje stereo. Zazwyczaj producenci tego nie informują i prawdopodobnie nie masz też dostępu do działających pilotów do inżynierii wstecznej.

Pilot do mojego nowego stereo (Kenwood) składa się z jednego przewodu i nie udało mi się znaleźć żadnych informacji o tym, jak to działa. Ma jednak również gniazdo 3,5 mm do zdalnego wejścia. O tym też nic nie mogłem się dowiedzieć. Istnieją jednak pewne informacje na temat gniazda 3,5 mm dla innych marek, sugerujące, że różne polecenia są identyfikowane przez zastosowanie określonego oporu między końcówką a tuleją (i opcjonalnie między pierścieniem a tuleją). Np. https://forum.arduino.cc/index.php?topic=230068.0. Postanowiłem więc spróbować, wyposażony w płytkę stykową, wiązkę rezystorów i wtyk 3,5 mm wpięty do stereo i podłączony do płytki stykowej. Początkowo nic nie zostało rozpoznane, ale stereo ma menu „tryb uczenia się” i tam można było z powodzeniem ustawiać polecenia przy różnych oporach. Powodzenie!

Jednak później dowiedziałem się, że popełniłem błąd: nie wszystkie polecenia, których system stereo wydawał się uczyć, faktycznie działały. Np. 30 kOhm zostało znalezione w trybie uczenia, ale później nie zadziałało i dla niektórych poleceń, które ustawiłem, różnica rezystancji była tak mała, że później uruchomiono niewłaściwe polecenie.

Zalecam więc użycie płytki stykowej z rezystorami i przyciskami przełącznika dla wszystkich zdalnych poleceń, które chcesz obsłużyć i faktycznie przetestować, czy wszystkie będą działać.

Jeśli radioodtwarzacz samochodowy nie może odbierać sygnału wejściowego w ten sam sposób, musisz dowiedzieć się, jak to działa, aby dostosować to rozwiązanie. Jeśli w ogóle nie możesz tego rozgryźć, masz problem.

Krok 2: Dowiedz się, gdzie podłączyć się do magistrali CAN

Musisz znaleźć dobre miejsce do podłączenia do magistrali CAN. Ponieważ wymieniasz stary zestaw stereo, który komunikuje się przez CAN, powinieneś być w stanie znaleźć go za zestawem stereo. Magistrala CAN składa się z pary skręconych przewodów (CAN-L i CAN_H). Aby się upewnić, zapoznaj się ze schematem elektrycznym swojego samochodu.

Krok 3: Inżynieria wsteczna komunikatów CAN

O ile Google nie może ci powiedzieć, jakich komunikatów CAN powinieneś słuchać, będziesz musiał połączyć się z magistralą CAN i wykonać inżynierię wsteczną. Użyłem Arduino Uno i nakładki CAN. (Tak naprawdę nie potrzebujesz osłony CAN, jak zobaczysz później, możesz zamiast tego użyć tanich komponentów na płytce stykowej.)

Skonsultuj się z Google, aby dowiedzieć się, jakiej szybkości transmisji należy użyć podczas łączenia się z samochodem. (Zazwyczaj zauważysz, że istnieje sieć CAN o wysokiej i niskiej prędkości. Łączysz się z siecią o niskiej prędkości.)

Będziesz także musiał zaprogramować Arduino do rejestrowania wszystkich komunikatów CAN przez interfejs szeregowy, dzięki czemu można je zapisać w pliku dziennika na komputerze. Standardowe Arduino IDE nie zapisuje danych do pliku logu, ale można użyć m.in. Zamiast tego kit.

Zanim zaczniesz pisać swój program musisz zainstalować bibliotekę CAN_BUS_Shield.

Oto kilka pseudokodów, które pomogą Ci rozpocząć pracę z programem:

Ustawiać()

{ init połączenie szeregowe init biblioteka CAN } loop() { jeśli wiadomość CAN została odebrana { odczyt formatu wiadomości CAN wpis logu zapisz wpis logu do portu szeregowego } }

Poradnik:

Użyjesz instancji klasy MCP_CAN, aby uzyskać dostęp do funkcji biblioteki CAN:

MCP_CAN m_can;

Rozpocznij MOŻE:

while (m_can.begin() != CAN_OK)

{ opóźnienie(1000); }

Sprawdź i przeczytaj komunikaty CAN:

while(m_can.checkReceive() == CAN_MSGAVAIL)

{ // Pobierz identyfikator CAN, długość wiadomości i dane wiadomości m_can.readMsgBufID(&m_canId, &m_msgLen, m_msgBuf); // Zrób coś z danymi wiadomości tutaj }

Jeśli potrzebujesz więcej pomocy, możesz znaleźć link do mojego programu w późniejszym kroku. Biblioteka CAN Shield zawiera również przykład. Lub sprawdź instrukcję mviljoen2, która zawiera podobny krok.

Najpierw potrzebujesz pliku referencyjnego, który pomoże Ci odfiltrować dane. Przełącz zapłon w tryb radia i rejestruj wszystko przez kilka minut bez dotykania żadnych przycisków.

Następnie dla każdego z przycisków rozpocznij rejestrowanie, naciśnij przycisk i zatrzymaj rejestrowanie.

Kiedy skończysz, musisz odfiltrować wszystko, co znajduje się w Twoim dzienniku referencyjnym, z dzienników przycisków, aby znaleźć kandydatów. Dowiedziałem się, że pozostało jeszcze wiele wiadomości, więc stworzyłem więcej logów, a następnie zażądałem, aby „kandydaci do polecenia A musieli znajdować się we wszystkich plikach przycisku A i w żadnym z plików referencyjnych”. Pozostawiło mi to tylko kilka możliwości do wypróbowania.

Dzienniki będą zawierały wiele wiadomości, więc będziesz musiał napisać jakiś program do tego lub ewentualnie użyć Excela. (Użyłem programu z bardzo mocno zakodowanymi warunkami dla moich potrzeb, więc obawiam się, że nie mogę zaoferować programu, którego możesz użyć.)

Słowo ostrzeżenia: nie możesz być pewien, że przycisk zawsze wyświetli identyczną wiadomość. Niektóre bity mogą zawierać zwiększające się liczniki itp. (Możesz jednak z wyjątkiem identyfikatora wiadomości, aby był taki sam).

Jeśli masz Volvo V70 -02, to jest to, czego szukasz:

• Identyfikator wiadomości: 0x0400066Byte0: 0x00, 0x40, 0x80 lub 0xc0 (nieważne)
• Byte1: 0x00 (nieważne)
• Byte2: 0x00 (nieważne)
• Byte3: 0x00-0x07 (nieważne)
• Byte4: 0x1f (nieważne)
• Byte5: 0x40 (nieważne)
• Byte6: 0x40 (nieważne)
• Byte7: Identyfikator przycisku: 0x77 = zwiększanie głośności, 0x7b = zmniejszanie głośności, 0x7d = następny utwór, 0x7e = poprzedni utwór.

Jeśli uważasz, że znalazłeś polecenia, dobrym pomysłem może być zmodyfikowanie programu tak, aby rejestrował tylko interesujące wiadomości. Podczas naciskania przycisków spójrz na okno dziennika szeregowego, aby sprawdzić, czy zidentyfikowałeś prawidłowe komunikaty.

Krok 4: Prototyp sprzętowy

Twój sprzęt musi być w stanie:

1. Zidentyfikuj polecenia otrzymane na magistrali CAN
2. Wysyłaj polecenia w innym formacie do zestawu stereo

Jeśli masz wystarczająco dużo miejsca, możesz użyć Arduino i nakładki CAN na pierwszą część i dołączyć dodatkowy sprzęt do drugiej. Istnieją jednak pewne wady:

• Koszt osłony CAN
• Rozmiar
• Zasilacz Arduino nie będzie zadowolony, jeśli będzie podłączony bezpośrednio do Twoich samochodów 12V (prawdopodobnie będzie działał, ale jego żywotność prawdopodobnie zostanie skrócona).

Więc zamiast tego użyłem:

• Atmega 328, „mózg Arduino”. (Istnieją pewne warianty, zdobądź ten, który jest równy temu na Arduino Uno. Możesz go kupić z programem ładującym Arduino lub bez.)
• Kryształ 16 MHz + kondensatory dla sygnału zegarowego.
• Nadajnik-odbiornik CAN MCP2551.
• Kontroler CAN MCP2515.
• TSR1-2450, konwertuje 6,5-36V na 5V. (Nie używany w prototypie, ponieważ oprogramowanie nie będzie dbało o zasilanie.)
• Przełącznik CD4066B, który będzie używany podczas wysyłania poleceń do zestawu stereo.
• Kilka rezystorów. (Wartości można znaleźć na schemacie Eagle w późniejszym kroku.)

Dobrą rzeczą w tej konfiguracji jest to, że jest w pełni kompatybilna z Arduino i biblioteką CAN shield.

Jeśli chcesz obsługiwać więcej niż cztery przyciski, możesz rozważyć użycie czegoś innego niż CD4066B. CD4066B można opisać jako cztery przełączniki w jednym, każdy sterowany przez jeden z pinów Atmegas GPIO. Do każdego przełącznika podłączony jest rezystor, którym można sterować rezystancją używaną jako wejście do zestawu stereo. Dzięki temu można to łatwo wykorzystać do wysłania czterech różnych poleceń. Jeśli są one połączone, można uzyskać dodatkowe wartości rezystancji. W tym miejscu pojawia się błąd, o którym wspomniałem wcześniej. Mam cztery przyciski, ale planowałem zaimplementować dwa z nich jako długie i krótkie naciśnięcie, aby dać mi sześć różnych poleceń. Ale w końcu okazało się, że nie mogę znaleźć kombinacji rezystorów, która dałaby mi sześć działających kombinacji. Prawdopodobnie można by zamiast tego podłączyć analogowy sygnał wyjściowy do stereo (końcówka 3,5 mm). (Zauważ, że Atmega nie ma prawdziwych pinów wyjścia analogowego, więc wymagany byłby dodatkowy sprzęt.)

Do celów testowych stworzyłem również prosty symulator „samochód i stereo”, który można podłączyć do mojego prototypu. Ułatwia to debugowanie i jeśli nie lubisz siedzieć w samochodzie i programować, mogę to polecić.

Prototyp ilustruje dolna płytka stykowa na zdjęciu. W celu zasilania, programowania i logowania szeregowego jest dołączony do Arduino Uno, z którego usunięto układ Atmega.

Górna płytka stykowa to symulator samochód + stereo, który posłuży do wstępnego testowania prototypu.

Prototyp + symulator ma działać tak:

• Naciśnij jeden z przycisków przełączników na tablicy symulatora. (To są przyciski na kierownicy.)
• Gdy program symulatora wykryje naciśnięcie przycisku, będzie wysyłał odpowiedni komunikat CAN co 70 ms tak długo, jak przycisk jest wciśnięty. (Ponieważ dzienniki, które zrobiłem wcześniej, wskazywały, że tak to działa w moim samochodzie.) Będzie również wysyłać wiele „śmieciowych” wiadomości CAN, aby symulować inny ruch w autobusie.
• Komunikaty CAN są wysyłane przez magistralę CAN.
• Komunikaty CAN są odbierane przez prototyp.
• MCP2515 wyrzuca wszystkie niepowiązane wiadomości na podstawie identyfikatora wiadomości.
• Gdy MCP2515 odbierze komunikat, który powinien zostać obsłużony, wskaże, że ma komunikat umieszczony w kolejce.
• Atmega odczyta wiadomość i zdecyduje, który przycisk należy uznać za aktywny.
• Atmega będzie również śledzić, kiedy ostatnia wiadomość została odebrana, po pewnym czasie przycisk zostanie uznany za zwolniony. (Komunikaty CAN wskazują tylko, że przycisk jest wciśnięty, a nie, że został wciśnięty lub zwolniony).
• Jeśli przycisk zostanie uznany za aktywny, zostanie aktywowany jeden lub więcej przełączników w CD4066B.
• Symulator (działający teraz jako stereo) wykryje, że pomiędzy końcówką a tuleją występuje opór. (Końcówka jest podłączona do 3,3 V i przez rezystor do pinu wejścia analogowego. Gdy żadne polecenie nie jest aktywne, ten pin odczytuje 3,3 V, gdy polecenie jest aktywne, wartość spadnie i zidentyfikuje polecenie.
• Gdy polecenie jest aktywne, odpowiednia dioda również zostanie aktywowana. (Jest sześć diod led, ponieważ planowałem użyć różnych długich / krótkich naciśnięć dla dwóch moich przycisków.)

Aby uzyskać więcej informacji na temat prototypowego sprzętu, zobacz schematy Eagle w późniejszym kroku.

Dodatkowe szczegóły dotyczące sprzętu płyty symulatora:

• Kryształ 16 MHz
• Kondensatory 22 pF
• Rezystory LED należy dobierać na podstawie właściwości LED
• Rezystor podłączony do A7 i 3,3V, wybierz m.in. 2kOhm (nie krytyczne).
• Rezystory podłączone do MCP2551 i MCP2515 są typu pull-up / pull-down. Wybierz np. 10 kiloomów.

(Lub możesz użyć osłony CAN dla "części CAN" symulatora, jeśli wolisz.)

Ważne jest, aby podczas projektowania sprzętu wiedzieć, w jaki sposób piny Atmega są mapowane na piny Arduino.

(Nie podłączaj żadnych diod bezpośrednio do CD 4066B, może on obsługiwać tylko niski prąd. Próbowałem tego, kiedy pierwszy raz testowałem wyjście i chip stał się bezużyteczny. Dobrą rzeczą jest to, że kupiłem kilka z nich tylko dlatego, że są takie tanie.)

Krok 5: Programowanie bezpieczników

Być może zauważyłeś w poprzednim kroku, że prototyp nie ma oddzielnych elementów do generowania sygnału zegarowego do MCP2515. To dlatego, że jako sygnał zegarowy Atmegi jest już 16 MHz kryształ, który możemy wykorzystać. Ale nie możemy po prostu podłączyć go bezpośrednio do MCP2515 i domyślnie nie ma sygnału taktowania na Atmega.

(Jeśli wolisz, możesz pominąć ten krok i zamiast tego dodać dodatkowy sprzęt zegara).

Możemy jednak użyć czegoś, co nazywa się „programowaniem bezpieczników”, aby włączyć sygnał wyjścia zegara na jednym z pinów GPIO.

Najpierw musisz zlokalizować plik o nazwie „boards.txt” używany przez twoje Arduino IDE. Będziesz musiał skopiować wpis dotyczący Arduino Uno, nadać mu nową nazwę i zmienić wartość dla low_fuses.

Moja nowa tablica wygląda tak:

################################################## ############ # Na podstawie Arduino Uno # Zmiany: # low_fuses zmienione z 0xff na 0xbf, aby włączyć zegar 16 MHz # wyjście na Atmega PB0/pin 14 = Arduino D8

clkuno.name=Wyłączenie zegara (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_bootti cl.kunoopd.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.clku=standard.arduino

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

Zauważ, że wyjście zegara jest aktywowane przez ustawienie jego bitu kontrolnego na 0.

Po utworzeniu nowej płyty w pliku konfiguracyjnym płyt będziesz musiał nagrać nowy program ładujący do Atmegi. Można to zrobić na różne sposoby, użyłem metody opisanej w

Po wykonaniu tej czynności pamiętaj, aby podczas przesyłania programu do Atmegi wybrać nowy typ płytki, a nie Arduino Uno.

Krok 6: Oprogramowanie

Czas, aby głupi sprzęt stał się inteligentny, dodając trochę oprogramowania.

Oto kilka pseudokodów dla prototypu:

ostatni czas otrzymania = 0

lastReceivedCmd = none cmdTimeout = 100 setup() { włącz watchdog skonfiguruj piny D4-D7 jako piny wyjściowe init CAN setup CAN filter } loop() { reset watchdog if (otrzymano wiadomość CAN) { dla każdego polecenia przycisku { jeśli wiadomość CAN należy do polecenie przycisku { lastReceivedTime = now lastReceivedCmd = cmd } } } if now > lastReceivedTime + cmdTimeout { lastReceivedCmd = brak } dla każdego polecenia przycisku { if lastReceivedCmd is button command { set command pin output = on } else { set command pin output = off } } }

cmdTimeout określa, jak długo powinniśmy czekać, zanim uznamy, że ostatni aktywny przycisk został zwolniony. Ponieważ komendy wiadomości przycisku CAN są wysyłane co około 70 ms, musi być ona większa niż z pewnym marginesem. Ale jeśli jest zbyt duży, wystąpią opóźnienia. Więc 100 ms wydaje się dobrym kandydatem.

Ale czym jest pies stróżujący? Jest to przydatna mała funkcja sprzętowa, która może nas uratować w przypadku awarii. Wyobraź sobie, że mamy błąd powodujący awarię programu, gdy aktywne jest polecenie zwiększania głośności. Wtedy skończylibyśmy z dźwiękiem stereo na maksymalnej głośności! Ale jeśli watchdog nie zostanie zresetowany na określony czas, stwierdzi, że wydarzyło się coś nieoczekiwanego i po prostu zresetuje.

pusta konfiguracja()

{ // zezwól na max 250 ms dla pętli wdt_enable(WDTO_250MS); // inne rzeczy init } void loop() { wdt_reset(); // robić coś }

MOŻE filtrować? Otóż można skonfigurować sterownik CAN tak, aby odrzucał wszystkie komunikaty, które nie pasują do filtra, dzięki czemu oprogramowanie nie musi tracić czasu na komunikaty, na których nam nie zależy.

długa maska bez znaku = 0x1fffffff; // Uwzględnij wszystkie 29 bitów nagłówka w masce

unsigned long filterId = 0x0400066; // Dbamy tylko o ten id wiadomości CAN m_can.init_Mask(0, CAN_EXTID, mask); // Maska 0 dotyczy filtra 0-1 m_can.init_Mask(1, CAN_EXTID, maska); // Maska 1 dotyczy filtra 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);

Sprawdź kod biblioteki CAN i dokumentację sterownika CAN, aby uzyskać więcej informacji o tym, jak ustawić filtr + maskę.

Możesz także skonfigurować kontroler CAN, aby podniósł przerwanie, gdy zostanie odebrany komunikat (który nie jest odfiltrowany). (Nie ujęte w powyższym przykładzie, ale w moim programie jest trochę kodu.) W tym przypadku tak naprawdę nie dodaje to żadnej wartości i może być mylące, jeśli nie jesteś przyzwyczajony do programowania.

Więc to było w skrócie prototypowe oprogramowanie. Ale potrzebujemy też trochę kodu dla płytki symulatora:

LastSentTime = 0

minDelayTime = 70 setup() { skonfiguruj piny A0-A5 jako piny wyjściowe skonfiguruj piny D4-D7 jako piny wejściowe z wewnętrznym pullup. init CAN } loop() { send "junk" can msg set activeButton = none dla każdego przycisku { jeśli przycisk jest wciśnięty { set activeButton = przycisk } } if activeButton != none { if now > lastSentTime + minDelayTime { wyślij polecenie przycisku can wiadomość } set lastSentTime = now } inval = odczytaj pin A7 foreach(cmd) { if (min < inval < max) { led on } else { led off } } czekaj na 1 ms }

Spowoduje to ciągłe wysyłanie „śmieciowych” wiadomości CAN w przybliżeniu co ms, a po naciśnięciu przycisku odpowiednie polecenie co 70 ms.

Być może trzeba będzie zarejestrować dane wejściowe na pinie A7 podczas naciskania różnych przycisków, aby znaleźć odpowiednie wartości dla zmiennych min i max należących do każdego przycisku. (Lub możesz to obliczyć, ale faktyczne odczytanie danych wejściowych da ci dokładniejsze wartości.)

Musisz być trochę ostrożny podczas programowania trybów pinów. Jeśli przypadkowo ustawisz piny przeznaczone do użycia wewnętrznego pullup jako pinów wyjściowych, utworzysz potencjalny skrót, który uszkodzi twoje Arduino, gdy ustawisz wysokie wyjście.

Jeśli chcesz sprawdzić moje programy można je pobrać tutaj:

• Program dziennika wiadomości CAN
• Program na tablicę symulatora
• Program do prototypu/płyty końcowej

Powinieneś być świadomy, że te programy tak naprawdę nie pasują do pseudokodu tutaj, zawierają wiele "dodatkowych" rzeczy, które nie są tak naprawdę potrzebne, a jeśli nie jesteś zaznajomiony z programowaniem obiektowym, prawdopodobnie może być trochę trudny do odczytania.

Krok 7: Ostateczny sprzęt

Kiedy jesteś zadowolony ze swojego programu (pamiętaj, aby przetestować prototyp w samochodzie po ostatecznych testach z płytką symulatora) nadszedł czas na skonstruowanie prawdziwego sprzętu.

Masz tutaj trzy opcje:

• Szybko i brudno - zlutuj wszystko na płytce prototypowej PCB.
• Hardcore DIY - wytraw własną płytkę drukowaną.
• Leniwy sposób - zamów profesjonalną płytkę PCB do wlutowania elementów.

Jeśli nie spieszysz się, mogę polecić ostatnią opcję. Jeśli potrzebujesz tylko takiej małej płytki PCB, bardzo tanio jest ją zamówić z Chin. (A potem prawdopodobnie dostaniesz około dziesięciu sztuk, więc możesz sobie pozwolić na błędy lutowania.)

Aby zamówić PCB musisz przesłać swój projekt w formacie Gerber. Istnieje do tego różne oprogramowanie. Użyłem Eagle, który mogę polecić. Możesz spodziewać się kilku godzin, aby się tego nauczyć, ale potem działa dobrze. W przypadku takich małych tablic możesz go używać za darmo.

Zachowaj ostrożność podczas projektowania. Nie chcesz czekać cztery tygodnie na dostawę tylko po to, by dowiedzieć się, że zrobiłeś coś złego.

(Jeśli masz dobre umiejętności lutowania, możesz zaprojektować elementy do montażu powierzchniowego i uzyskać naprawdę mały adapter. Ja nie.)

Następnie zamów u m.in. https://www.seeedstudio.com/fusion_pcb.html. Postępuj zgodnie z instrukcjami, jak wygenerować pliki Gerber z projektu. Możesz również uzyskać podgląd wyniku, aby upewnić się, że jest w porządku.

(Ostatecznie musiałem dobrać inne rezystory dla R4-R7 niż wymienione na schemacie. Zamiast tego użyłem 2k, 4,7k, 6,8k i 14,7k.)

I pamiętaj – nie myl numeracji pinów Atmegi z numeracją pinów Arduino!

Polecam nie lutować bezpośrednio układu Atmega tylko użyć gniazda. Następnie możesz go łatwo usunąć na wypadek konieczności przeprogramowania.

Krok 8: Montaż samochodu

Teraz najfajniejsza część - zamontuj ją w swoim samochodzie i zacznij jej używać! (Po zrobieniu / zakupie etui.)

Jeśli już w pełni przetestowałeś prototyp w swoim samochodzie, wszystko powinno działać idealnie.

(Jak wspomniałem wcześniej nie zrobiłem więc musiałem wymienić kilka rezystorów i dokonać pewnych zmian w moim programie.)

Zastanów się również, czy powinieneś zamontować go za zestawem stereo, czy w innym miejscu. Znalazłem dobre miejsce nad schowkiem na rękawiczki, gdzie mogę sięgnąć do niego z wnętrza schowka bez rozbierania czegokolwiek. To może się przydać, jeśli zdecyduję się na uaktualnienie go później.

Wreszcie moje przyciski znów działają! Jak mógłbym przeżyć bez nich dwa miesiące?

Krok 9: Przyszłe ulepszenia

Jak wspomniano, jeśli zrobię wersję 2.0 tego, zastąpię 4066B czymś innym (prawdopodobnie potencjometrem cyfrowym) dla większej elastyczności.

Jest też wiele innych rzeczy, które możesz zrobić. Np. dodaj moduł bluetooth i stwórz aplikację do zdalnego sterowania na swój telefon. Lub moduł GPS, a gdy jesteś blisko domu, możesz automatycznie zwiększyć głośność i wysłać wiadomość CAN "opuszczanie okien", aby wszyscy twoi sąsiedzi mogli cieszyć się wspaniałą muzyką.