Benutzerdefiniertes Arduino zum Halten von CAN-Lenkradtasten mit neuem Autoradio - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:21

Ich beschloss, das originale Autoradio in meinem Volvo V70 -02 durch ein neues zu ersetzen, damit ich Dinge wie MP3, Bluetooth und Freisprechen genießen kann.

Mein Auto hat einige Lenkradsteuerungen für die Stereoanlage, die ich gerne noch verwenden möchte. Ich habe nicht erwartet, dass das ein Problem ist, da es mehrere Adapter auf dem Markt gibt, die mit meinem Auto kompatibel sein sollen. Ich fand jedoch bald heraus, dass sie es nicht waren! (Es scheint, als hätten die Adapter für V70 aufgrund eines etwas anderen CAN-Protokolls Probleme mit -02-Fahrzeugen.)

Was also tun? Die alte Stereoanlage behalten? Ein Leben mit nicht funktionierenden Knöpfen führen? Natürlich nicht! Wenn es keinen funktionierenden Adapter auf dem Markt gibt, müssen wir einen bauen!

Dieses anweisbare kann (mit einigen Anpassungen) auf Autos angewendet werden, bei denen die Lenkradtasten über den CAN-Bus kommunizieren.

Schritt 1: Finden Sie heraus, wie Sie Befehle an die Stereoanlage senden

Als erstes sollten Sie herausfinden, welche Art von Remote-Eingang die Stereoanlage erwartet. Normalerweise werden Ihnen die Hersteller das nicht sagen und Sie haben wahrscheinlich auch keinen Zugriff auf funktionierende Fernbedienungen für das Reverse Engineering.

Der Remote-In für meine neue Stereoanlage (Kenwood) besteht aus einem einzigen Kabel und ich konnte keine Informationen darüber herausfinden, wie es funktioniert. Es hat jedoch auch eine 3,5-mm-Klinke für den Remote-Eingang. Auch dazu konnte ich nichts herausfinden. Es gibt jedoch einige Informationen über eine 3,5-mm-Buchse für andere Marken, die darauf hindeuten, dass unterschiedliche Befehle durch Anlegen eines bestimmten Widerstands zwischen Spitze und Hülse (und optional zwischen Ring und Hülse) identifiziert werden. Z. B. https://forum.arduino.cc/index.php?topic=230068.0. Also beschloss ich, das auszuprobieren, ausgestattet mit einem Steckbrett, einer Reihe von Widerständen und einem 3,5-mm-Stecker, der an die Stereoanlage angeschlossen und mit dem Steckbrett verbunden wurde. Zuerst wurde nichts erkannt, aber die Stereoanlage verfügt über ein "Lernmodus"-Menü und dort konnten die Befehle unter Anwendung verschiedener Widerstände erfolgreich eingerichtet werden. Erfolg!

Später fand ich jedoch heraus, dass ich hier einen Fehler gemacht hatte: Nicht alle Befehle, die die Stereoanlage zu lernen schien, funktionierten tatsächlich. Z. B. 30 kOhm wurden im Lernmodus gefunden, funktionierten aber später nicht und bei einigen der von mir eingestellten Befehle war der Widerstandsunterschied so gering, dass später der falsche Befehl ausgelöst wurde.

Daher empfehle ich, dass Sie ein Steckbrett mit Widerständen und Schaltknöpfen für alle Fernbedienungsbefehle verwenden, die Sie handhaben möchten, und tatsächlich testen, ob alle funktionieren.

Wenn Ihr Autoradio keinen Eingang auf die gleiche Weise empfangen kann, müssen Sie herausfinden, wie es funktioniert, damit Sie diese Lösung anpassen können. Wenn Sie es überhaupt nicht herausfinden können, haben Sie ein Problem.

Schritt 2: Finden Sie heraus, wo Sie den CAN-Bus anschließen

Sie müssen einen geeigneten Ort für den Anschluss an den CAN-Bus finden. Da Sie eine alte Stereoanlage ersetzen, die über CAN kommuniziert, sollten Sie dies hinter der Stereoanlage finden können. Der CAN-Bus besteht aus einem Paar verdrillter Adern (CAN-L und CAN_H). Konsultieren Sie zur Sicherheit einen Schaltplan für Ihr Auto.

Schritt 3: Reverse Engineering von CAN-Nachrichten

Sofern Google Ihnen nicht sagen kann, auf welche CAN-Nachrichten Sie hören sollten, müssen Sie eine Verbindung zum CAN-Bus herstellen und ein Reverse Engineering durchführen. Ich habe ein Arduino Uno und ein CAN-Shield verwendet. (Sie brauchen das CAN-Shield nicht wirklich, wie Sie später sehen werden, können Sie stattdessen einige billige Komponenten auf einem Steckbrett verwenden.)

Wenden Sie sich an Google, um herauszufinden, welche Baudrate Sie verwenden sollten, wenn Sie eine Verbindung zu Ihrem Auto herstellen. (In der Regel werden Sie feststellen, dass es ein Hochgeschwindigkeits- und ein Niedriggeschwindigkeits-CAN-Netz gibt. Sie verbinden sich mit dem Niedriggeschwindigkeitsnetz.)

Sie müssen den Arduino auch so programmieren, dass er alle CAN-Nachrichten über die serielle Schnittstelle protokolliert, damit Sie sie in einer Protokolldatei auf Ihrem Computer speichern können. Die Standard-Arduino-IDE speichert keine Daten in einer Protokolldatei, aber Sie können z. B. Kitt statt.

Bevor Sie mit dem Schreiben Ihres Programms beginnen, müssen Sie die CAN_BUS_Shield-Bibliothek installieren.

Hier sind einige Pseudocodes, die Ihnen den Einstieg in Ihr Programm erleichtern:

erstellen()

{ Serielle Verbindung initieren CAN-Bibliothek initieren } loop () { wenn CAN-Nachricht empfangen wird { Protokolleintrag CAN-Nachrichtenformat lesen Protokolleintrag in Serie schreiben } }

Hinweise:

Sie verwenden eine Instanz der Klasse MCP_CAN, um auf die Funktionalität der CAN-Bibliothek zuzugreifen:

MCP_CAN m_can;

Init-CAN:

while (m_can.begin() != CAN_OK)

{ Verzögerung (1000); }

CAN-Botschaften prüfen und lesen:

while(m_can.checkReceive() == CAN_MSGAVAIL)

{ // CAN-ID, Nachrichtenlänge und Nachrichtendaten abrufen m_can.readMsgBufID(&m_canId, &m_msgLen, m_msgBuf); // Hier etwas mit den Nachrichtendaten machen }

Wenn Sie weitere Hilfe benötigen, finden Sie in einem späteren Schritt einen Link zu meinem Programm. Die CAN-Shield-Bibliothek enthält auch ein Beispiel. Oder überprüfen Sie die Anleitung von mviljoen2, die einen ähnlichen Schritt enthält.

Zunächst benötigen Sie eine Referenzdatei, die Ihnen beim Herausfiltern der Daten hilft. Schalten Sie die Zündung in den Radiomodus und protokollieren Sie alles für ein paar Minuten, ohne irgendwelche Tasten zu berühren.

Starten Sie dann für jede der Schaltflächen die Aufzeichnung, drücken Sie die Taste und stoppen Sie die Aufzeichnung.

Wenn Sie fertig sind, müssen Sie alles, was sich in Ihrem Referenzprotokoll befindet, aus Ihren Schaltflächenprotokollen herausfiltern, um Ihre Kandidaten zu finden. Ich fand heraus, dass noch viele Nachrichten übrig waren, also machte ich weitere Protokolle und verlangte dann, dass "Kandidaten für Befehl A in allen Button-A-Dateien und in keiner der Referenzdateien enthalten sein müssen". Dadurch blieben mir nur noch wenige Möglichkeiten zum Ausprobieren.

Die Protokolle enthalten viele Nachrichten, daher müssen Sie ein Programm dafür schreiben oder möglicherweise Excel verwenden. (Ich habe ein Programm mit sehr hart codierten Bedingungen für meine Bedürfnisse verwendet, daher kann ich leider kein Programm anbieten, das Sie verwenden können.)

Ein Wort zur Warnung: Sie können nicht sicher sein, dass eine Schaltfläche immer eine identische Meldung erzeugt. Einige der Bits können inkrementierende Zähler usw. enthalten. (Sie können jedoch ausschließen, dass die Nachrichten-ID dieselbe ist.)

Wenn Sie einen Volvo V70 -02 haben, suchen Sie Folgendes:

• Nachrichten-ID: 0x0400066Byte0: 0x00, 0x40, 0x80 oder 0xc0 (egal)
• Byte1: 0x00 (egal)
• Byte2: 0x00 (egal)
• Byte3: 0x00-0x07 (egal)
• Byte4: 0x1f (egal)
• Byte5: 0x40 (egal)
• Byte6: 0x40 (egal)
• Byte7: Tastenkennung: 0x77 = Lautstärke erhöhen, 0x7b = Lautstärke verringern, 0x7d = nächster Titel, 0x7e = vorheriger Titel.

Wenn Sie glauben, die Befehle gefunden zu haben, ist es möglicherweise eine gute Idee, das Programm so zu ändern, dass es nur die interessanten Nachrichten protokolliert. Sehen Sie sich das serielle Protokollfenster an, während Sie die Tasten drücken, um zu überprüfen, ob Sie die richtigen Meldungen identifiziert haben.

Schritt 4: Der Hardware-Prototyp

Ihre Hardware muss in der Lage sein:

1. Auf dem CAN-Bus empfangene Befehle erkennen
2. Befehle in einem anderen Format an die Stereoanlage senden

Wenn Sie genügend Platz haben, können Sie für den ersten Teil ein Arduino und ein CAN-Shield verwenden und für den zweiten etwas zusätzliche Hardware anbringen. Es gibt jedoch einige Nachteile:

• Kosten des CAN-Shields
• Größe
• Das Arduino-Netzteil wird nicht glücklich sein, wenn es direkt an Ihre Autos 12V angeschlossen ist (es wird wahrscheinlich funktionieren, aber seine Lebensdauer wird wahrscheinlich verkürzt).

Also habe ich stattdessen Folgendes verwendet:

• Atmega 328, das "Arduino-Gehirn". (Es gibt einige Varianten, holen Sie sich diejenige, die der auf Arduino Uno entspricht. Sie können sie mit oder ohne Arduino-Bootloader kaufen.)
• 16 MHz Quarz + Kondensatoren für Taktsignal.
• MCP2551 CAN-Transceiver.
• MCP2515 CAN-Controller.
• TSR1-2450, wandelt 6,5-36V in 5V um. (Im Prototyp nicht verwendet, da sich die Software nicht um die Stromversorgung kümmert.)
• CD4066B-Schalter, der beim Senden von Befehlen an die Stereoanlage verwendet wird.
• Ein paar Widerstände. (Die Werte finden Sie in einem späteren Schritt in den Eagle-Schaltplänen.)

Das Gute an dieser Konfiguration ist, dass sie vollständig kompatibel mit dem Arduino und der CAN-Shield-Bibliothek ist.

Wenn Sie mehr als vier Tasten bedienen möchten, sollten Sie etwas anderes als den CD4066B verwenden. Der CD4066B kann als vier Schalter in einem beschrieben werden, die jeweils von einem der Atmegas GPIO-Pins gesteuert werden. An jeden Schalter ist ein Widerstand angeschlossen, der verwendet werden kann, um den Widerstand zu steuern, der als Eingang zum Stereo verwendet wird. Damit können also ganz einfach vier verschiedene Befehle gesendet werden. Wenn sie kombiniert werden, können zusätzliche Widerstandswerte erhalten werden. Hier kommt der oben erwähnte Fehler ins Spiel. Ich habe vier Tasten, aber ich hatte vor, zwei davon als langes und kurzes Drücken zu implementieren, um mir sechs verschiedene Befehle zu geben. Aber am Ende fand ich heraus, dass ich keine Kombination von Widerständen finden konnte, die mir sechs Arbeitskombinationen geben würde. Es wäre wahrscheinlich möglich, stattdessen ein analoges Out-Signal an die Stereoanlage (3,5 mm Spitze) anzuschließen. (Beachten Sie, dass der Atmega keine echten analogen Ausgangspins hat, sodass zusätzliche Hardware erforderlich wäre.)

Zu Testzwecken habe ich auch einen einfachen "Auto- und Stereo"-Simulator erstellt, um ihn mit meinem Prototyp zu verbinden. Es macht das Debuggen einfacher und wenn Sie nicht gerne in Ihrem Auto sitzen und programmieren, kann ich das empfehlen.

Der Prototyp wird durch das untere Steckbrett im Bild veranschaulicht. Zur Stromversorgung, Programmierung und seriellen Protokollierung wird es an einen Arduino Uno angeschlossen, bei dem der Atmega-Chip entfernt wurde.

Das obere Steckbrett ist der Auto + Stereo-Simulator, der für erste Tests des Prototyps verwendet wird.

Der Prototyp + Simulator soll so funktionieren:

• Drücken Sie einen der Schalter auf der Simulatorplatine. (Das sind deine Lenkradtasten.)
• Wenn das Simulatorprogramm einen Tastendruck erkennt, sendet es alle 70 ms die entsprechende CAN-Nachricht, solange die Taste gedrückt wird. (Weil die Protokolle, die ich zuvor aufgenommen habe, darauf hinweisen, dass es in meinem Auto funktioniert.) Es sendet auch viele "Junk"-CAN-Nachrichten, um anderen Verkehr auf dem Bus zu simulieren.
• Auf dem CAN-Bus werden CAN-Botschaften gesendet.
• CAN-Nachrichten werden vom Prototyp empfangen.
• Der MCP2515 wirft alle nicht verwandten Nachrichten basierend auf der Nachrichten-ID.
• Wenn der MCP2515 eine Nachricht empfängt, die verarbeitet werden soll, zeigt er an, dass eine Nachricht eingereiht ist.
• Der Atmega liest die Nachricht und entscheidet, welche Schaltfläche als aktiv betrachtet werden soll.
• Der Atmega verfolgt auch, wann die letzte Nachricht eingegangen ist, nach einer bestimmten Zeit gilt die Schaltfläche als freigegeben. (Die CAN-Nachrichten zeigen nur an, dass eine Taste gedrückt ist, nicht, dass sie gedrückt oder losgelassen wurde.)
• Wenn eine Taste als aktiv betrachtet wird, werden ein oder mehrere Schalter im CD4066B aktiviert.
• Der Simulator (der jetzt als Ihre Stereoanlage fungiert) erkennt, dass zwischen Spitze und Hülse ein Widerstand ausgeübt wird. (Die Spitze ist mit 3,3 V und über einen Widerstand mit einem analogen Eingangspin verbunden. Wenn kein Befehl aktiv ist, liest dieser Pin 3,3 V, wenn ein Befehl aktiv ist, wird der Wert niedriger und identifiziert den Befehl.
• Während ein Befehl aktiv ist, wird auch die entsprechende LED aktiviert. (Es gibt sechs LEDs, weil ich geplant hatte, für zwei meiner Tasten unterschiedliche lange / kurze Tasten zu verwenden.)

Weitere Informationen zur Prototyp-Hardware finden Sie in einem späteren Schritt unter Eagle-Schaltpläne.

Zusätzliche Details zur Simulatorplatinen-Hardware:

• 16 MHz Quarz
• 22 pF Kondensatoren
• LED-Widerstände sollten basierend auf den LED-Eigenschaften ausgewählt werden
• Widerstand an A7 und 3,3V angeschlossen, wählen Sie z. B. 2kOhm (nicht kritisch).
• An MCP2551 und MCP2515 angeschlossene Widerstände sind Pull-Up / Pull-Down. Wählen Sie z. B. 10kOhm.

(Oder Sie können das CAN-Shield für den "CAN-Teil" des Simulators verwenden, wenn Sie es vorziehen.)

Es ist wichtig, dass Sie wissen, wie die Atmega-Pins auf Arduino-Pins abgebildet werden, wenn Sie die Hardware entwerfen.

(Schließen Sie keine LEDs direkt an den CD 4066B an, er verträgt nur einen geringen Strom. Das habe ich beim ersten Testen des Ausgangs versucht und der Chip wird unbrauchbar. Das Gute ist, dass ich ein paar davon gekauft hatte, nur weil sie sind so günstig.)

Schritt 5: Sicherungsprogrammierung

Vielleicht haben Sie im vorherigen Schritt bemerkt, dass der Prototyp keine separaten Komponenten hat, um das Taktsignal zum MCP2515 zu erzeugen. Das liegt daran, dass als Atmega-Taktsignal bereits ein 16-MHz-Quarz verwendet wird, den wir verwenden können. Aber wir können es nicht einfach direkt an den MCP2515 anschließen und standardmäßig gibt es kein Clock-Out-Signal am Atmega.

(Wenn Sie möchten, können Sie diesen Schritt überspringen und stattdessen die zusätzliche Takthardware hinzufügen.)

Wir können jedoch eine sogenannte "Fuse-Programmierung" verwenden, um ein Clock-Out-Signal an einem der GPIO-Pins zu aktivieren.

Zuerst müssen Sie eine Datei namens "boards.txt" finden, die von Ihrer Arduino-IDE verwendet wird. Sie müssen den Eintrag für Arduino Uno kopieren, ihm einen neuen Namen geben und den Wert für low_fuses ändern.

Mein neues Board sieht so aus:

################################################ ############ # Basierend auf Arduino Uno # Änderungen: # low_fuses von 0xff auf 0xbf geändert, um 16 MHz Takt zu aktivieren # out auf Atmega PB0/pin 14 = Arduino D8

clkuno.name=Abmelden (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.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=.ardu.variant=ardu.variant

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

Beachten Sie, dass der Taktausgang aktiviert wird, indem sein Steuerbit auf 0 gesetzt wird.

Wenn Sie das neue Board in der Board-Konfigurationsdatei erstellt haben, müssen Sie einen neuen Bootloader auf den Atmega brennen. Dazu gibt es verschiedene Möglichkeiten, ich habe die in https://www.arduino.cc/en/Tutorial/ArduinoToBreadboard beschriebene Methode verwendet.

Nachdem Sie dies getan haben, denken Sie daran, Ihren neuen Board-Typ und nicht das Arduino Uno auszuwählen, wenn Sie ein Programm auf den Atmega hochladen.

Schritt 6: Die Software

Es ist an der Zeit, die dumme Hardware intelligent zu machen, indem Sie Software hinzufügen.

Hier ist ein Pseudocode für den Prototyp:

lastReceivedTime = 0

lastReceivedCmd = none cmdTimeout = 100 setup() { Watchdog aktivieren Pins D4-D7 als Ausgangspins konfigurieren CAN-Setup CAN-Filter initieren } loop() { Watchdog zurücksetzen if (CAN-Nachricht wird empfangen) { für jeden Tastenbefehl { wenn CAN-Nachricht gehört zu the button command { lastReceivedTime = now lastReceivedCmd = cmd } } } if now > lastReceivedTime + cmdTimeout { lastReceivedCmd = none } for each button command { if lastReceivedCmd is button command { set command pin output = on } else { set command pin output = off } } }

cmdTimeout legt fest, wie lange wir warten sollen, bevor die letzte aktive Schaltfläche als freigegeben betrachtet wird. Da Schaltflächen-CAN-Nachrichtenbefehle ungefähr alle 70 ms gesendet werden, muss sie mit einem gewissen Spielraum größer sein. Aber wenn es zu groß ist, wird es ein Lag-Erlebnis geben. 100 ms scheinen also ein guter Kandidat zu sein.

Aber was ist ein Wachhund? Es ist eine nützliche kleine Hardwarefunktion, die uns im Falle eines Absturzes retten kann. Stellen Sie sich vor, wir haben einen Fehler, der dazu führt, dass das Programm abstürzt, während der Befehl zum Erhöhen der Lautstärke aktiv ist. Dann würden wir mit der Stereoanlage auf maximaler Lautstärke enden! Wenn der Watchdog jedoch für die bestimmte Zeit nicht zurückgesetzt wird, entscheidet er, dass etwas Unerwartetes passiert ist und gibt einfach einen Reset aus.

Void-Setup ()

{ // Erlaube maximal 250 ms für die Schleife wdt_enable(WDTO_250MS); // andere Init-Sachen aufrechtzuerhalten. Void loop () { wdt_reset (); // Sachen machen }

KANN filtern? Nun, Sie können den CAN-Controller so konfigurieren, dass alle Nachrichten, die nicht dem Filter entsprechen, verworfen werden, damit die Software keine Zeit mit Nachrichten verschwenden muss, die uns nicht interessieren.

lange Maske ohne Vorzeichen = 0x1fffffff; // Alle 29 Header-Bits in die Maske aufnehmen

vorzeichenlose lange filterId = 0x0400066; // Wir kümmern uns nur um diese CAN-Nachricht id m_can.init_Mask(0, CAN_EXTID, mask); // Maske 0 gilt für Filter 0-1 m_can.init_Mask(1, CAN_EXTID, mask); // Maske 1 gilt für 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);

Weitere Informationen zum Einrichten von Filter + Maske finden Sie im CAN-Bibliothekscode und in der CAN-Controller-Dokumentation.

Sie können den CAN-Controller auch so einstellen, dass er beim Empfang einer Nachricht (die nicht herausgefiltert wird) einen Interrupt auslöst. (Im obigen Beispiel nicht enthalten, aber in meinem Programm gibt es Code dafür.) In diesem Fall fügt es keinen wirklichen Wert hinzu und es könnte verwirrend sein, wenn Sie nicht an die Programmierung gewöhnt sind.

Das war also zusammengefasst die Prototyp-Software. Aber wir brauchen auch etwas Code für das Simulatorboard:

lastSentTime = 0

minDelayTime = 70 setup() { Pins A0-A5 als Ausgangspins konfigurieren Pins D4-D7 als Eingangspins mit internem Pullup konfigurieren. init CAN } loop() { sende "junk" can msg set activeButton = none for each button { if button is pushed { set activeButton = button } } if activeButton != none { if now > lastSentTime + minDelayTime { send button command can message } set lastSentTime = now } inval = read pin A7 foreach (cmd) { if (min < inval < max) { led on } else { led off } } warte 1 ms }

Dadurch werden ungefähr alle ms kontinuierlich "Junk"-CAN-Nachrichten gesendet und während eine Taste gedrückt wird, alle 70 ms den entsprechenden Befehl.

Möglicherweise müssen Sie die Eingabe an Pin A7 protokollieren, während Sie die verschiedenen Tasten drücken, um geeignete Werte für die Min- und Max-Variablen zu finden, die zu jeder Taste gehören. (Oder Sie können es berechnen, aber das tatsächliche Lesen der Eingabe liefert Ihnen genauere Werte.)

Sie müssen ein wenig vorsichtig sein, wenn Sie die Pin-Modi programmieren. Wenn Sie versehentlich die Pins setzen, die stattdessen internen Pullup als Ausgangspins verwenden sollen, erstellen Sie eine potenzielle Verknüpfung, die Ihren Arduino beschädigt, wenn Sie den Ausgang auf High setzen.

Wenn Sie meine Programme überprüfen möchten, können sie hier heruntergeladen werden:

• Protokollprogramm für CAN-Nachrichten
• Programm für das Simulatorboard
• Programm für Prototyp/Endplatine

Sie sollten sich bewusst sein, dass diese Programme nicht wirklich mit dem Pseudocode hier übereinstimmen, sie enthalten viel "zusätzliches" Zeug, das nicht wirklich benötigt wird und wenn Sie mit objektorientierter Programmierung nicht vertraut sind, kann es wahrscheinlich etwas schwierig sein, es zu lesen.

Schritt 7: Die endgültige Hardware

Wenn Sie mit Ihrem Programm zufrieden sind (denken Sie daran, den Prototypen nach dem letzten Test mit dem Simulatorboard im Auto zu testen), ist es an der Zeit, die echte Hardware zu konstruieren.

Hier haben Sie drei Möglichkeiten:

• Schnell und dreckig - Löten Sie das Zeug auf einer Leiterplatten-Prototypplatine zusammen.
• Hardcore DIY - ätzen Sie Ihre eigene Leiterplatte.
• Der faule Weg - bestellen Sie eine professionelle Leiterplatte zum Auflöten der Komponenten.

Wenn Sie es nicht eilig haben, kann ich die letzte Option empfehlen. Wenn Sie nur eine kleine Platine wie diese benötigen, ist es sehr günstig, sie aus China zu bestellen. (Und dann werden Sie wahrscheinlich zehn Stück oder so bekommen, damit Sie sich einige Lötfehler leisten können.)

Um Leiterplatten zu bestellen, müssen Sie Ihr Design im Gerber-Format senden. Dafür gibt es verschiedene Software. Ich habe Eagle verwendet, das ich empfehlen kann. Sie können ein paar Stunden erwarten, um es zu lernen, aber dann funktioniert es gut. Für kleine Boards wie dieses können Sie es kostenlos verwenden.

Seien Sie vorsichtig, wenn Sie das Design erstellen. Sie möchten nicht vier Wochen auf die Lieferung warten, nur um herauszufinden, dass Sie etwas falsch gemacht haben.

(Wenn Sie gute Lötkenntnisse haben, können Sie für oberflächenmontierte Komponenten konstruieren und einen wirklich kleinen Adapter bekommen. Ich nicht.)

Dann bestellen Sie z. B. https://www.seeedstudio.com/fusion_pcb.html. Befolgen Sie die Anweisungen zum Generieren der Gerber-Dateien aus Ihrem Design. Sie können auch eine Vorschau des Ergebnisses anzeigen, um sicherzustellen, dass es in Ordnung ist.

(Am Ende musste ich andere Widerstände für R4-R7 auswählen als im Schaltplanbild aufgeführt. Stattdessen habe ich 2k, 4,7k, 6,8k und 14,7k verwendet.)

Und denken Sie daran - verwechseln Sie nicht die Atmega-Pin-Nummerierung mit der Arduino-Pin-Nummerierung!

Ich empfehle, den Atmega-Chip nicht direkt zu verlöten, sondern einen Sockel zu verwenden. Dann können Sie es leicht entfernen, falls Sie es neu programmieren müssen.

Schritt 8: Automontage

Nun zum lustigsten Teil - montieren Sie es in Ihr Auto und fangen Sie an, es zu benutzen! (Nachdem Sie einen Koffer dafür gemacht / gekauft haben.)

Wenn Sie den Prototypen in Ihrem Auto bereits vollständig getestet haben, sollte alles perfekt funktionieren.

(Wie ich bereits erwähnt habe, habe ich dies nicht getan, also musste ich einige Widerstände ersetzen und einige Änderungen in meinem Programm vornehmen.)

Überlegen Sie auch, ob Sie es hinter der Stereoanlage oder woanders montieren sollten. Ich habe eine gute Stelle über meinem Handschuhfach gefunden, wo ich es aus dem Handschuhfach heraus erreichen kann, ohne etwas auseinander zu nehmen. Das könnte nützlich sein, wenn ich mich entscheide, es später zu aktualisieren.

Endlich funktionieren meine Tasten wieder! Wie könnte ich zwei Monate ohne sie überleben?

Schritt 9: Zukünftige Verbesserungen

Wie bereits erwähnt, wenn ich eine Version 2.0 davon mache, werde ich den 4066B durch etwas anderes ersetzen (wahrscheinlich ein digitales Potentiometer), um mehr Flexibilität zu erzielen.

Es gibt auch viele andere Dinge, die Sie tun können. Z. B. Fügen Sie ein Bluetooth-Modul hinzu und erstellen Sie eine Fernbedienungs-App für Ihr Telefon. Oder ein GPS-Modul, dann können Sie, wenn Sie sich in der Nähe Ihres Hauses befinden, automatisch die Lautstärke erhöhen und die CAN-Nachricht "Fenster runter" senden, damit alle Ihre Nachbarn Ihre wunderbare Musik genießen können.