Ein GC Make Projekt: PWM-Box 2.0 - Moderne Carbon Sitzheizung nachrüsten mit Original Schalter

Servus zusammen,

um moderne Carbon-Sitzheizungsmatten nachzurüsten und diese mit dem originalen Sitzheizungsschalter zu betreiben, benötigt man eine Ansteuerung mittels Pulsweitenmodulation, kurz PWM. Dazu gibt es schon seit vielen Jahren eine Lösung in Form einer PWM Box, wie auch im Wiki zu finden: https://golf1wiki.de/index.php/Sitzheizung_nachr%C3%BCsten

Da diese Box recht aufwändig zu bauen ist und aus vielen, diskreten Bauteilen zusammen gelötet werden muss, hatte ich vor einiger Zeit die Idee eine neue, moderne Version davon zu entwerfen, die aus modularen Bauteilen besteht, einfacher aufzubauen ist und kein Umlöten des Sitzheizungsschalters mehr erfordert. Wir leben schließlich heute in einer Welt günstiger kleiner Mikrocontroller und fertig erhältlichen Modulen für Laststeuerung, Sensorik etc.

Wer jetzt schon gedanklich ausgestiegen ist:

Keine Sorge, ich werde die neue Box am Ende auch fertig aufgebaut im Marktplatz anbieten. Sie lässt sich genau wie die alte verkabeln und kann einfach "nur" genutzt werden, ohne sich mit dem inneren Aufbau beschäftigen zu müssen.

Edit: Gibts hier !

Wer Lust hat diese für sich selbst nach zu bauen und mit zu diskutieren sei hiermit herzlich eingeladen, ich werde alle Bauteile, Verkabelung, Programmcode etc. hier veröffentlichen.

Bezugslinks sind übrigens nur Beispiele, es sind keine Affiliate Links und ich habe auch keinen Werbevertrag mit Amazon etc. eBay oder andere Onlineshops eignen sich ebenso gut.

-------------------------------------------------------------------------------------------------------------

Teil 1: Die Stromversorgung

Da die alte Box ein externes Relais zum Ein- und Ausschalten brauchte, wollte ich als erste kleine Verbesserung ein Relais mit einbauen, was die Box per Zündungsplus ein- und ausschaltet. Soweit so einfach, ein halbwegs kompaktes Modell was mindestens 15A verträgt sollte es sein. Da ich mit ganz kleinen Mikrorelais bei größeren Lasten eher schlechte Erfahrungen gemacht habe, habe ich zu so einem mäßig kompakten hier gegriffen:

Gibts etwa hier, ist aber auch von vielen anderen Herstellen erhältlich: https://amzn.eu/d/feGEL67 Eigentlich kann man hier fast jedes normale Kfz Relais nehmen, gerne auch mit mehr als 15A Schaltleistung.

Bekanntlich ist das Bordnetz unserer alten Schätzchen ja alles andere als eine stabile, störungsfreie 12V-Quelle Da man für Mikrocontroller wie Arduino eine stabile 5V oder 3,3V Quelle benötigt, habe ich mich für ein DC-DC Spannungswandler Modul mit dem bekannten LM2596 Baustein entschieden. Diesen hatte ich in der Vergangenheit schon öfters genutzt und gute Erfahrungen gemacht: mehr als ausreichend belastbar für einen Arduino, wird kaum warm da recht effizient und mit rund 150kHz Schaltfrequenz gut gerüstet um Störungen durch das Bordnetz zu egalisieren. Als fertiges Modul mit Weitbereichseingang bis 35v:

Gibts z.B. hier: https://amzn.eu/d/f77Td7B

Teil 2 folgt in Kürze.

Die gute alte MSH50, hatte ich auch mal

Weiter geht's:

Teil 2: Stromversorgung verkabeln, Abgleich und nächste Bauteile

Lasst uns die ersten beiden Bauteile verkabeln, soweit so einfach:

Wichtig:

Bevor man weiter macht, muss das Spannungswandlermodul auf 5V eingestellt werden! Dazu muss ein Multimeter an den Ausgang des Spannungwandlermoduls angeschlossen, der Eingang mit 12V-35V versorgt und dann an dem hellblauen Poti solange gedreht werden bis exakt 5V am Multimeter angezeigt wird.

Ohne diesen Abgleich würden in den nächsten Schritten sonst andere Module zerstört werden.

Als nächstes brauchen wir ein Modul was die Lasten der Heizmatten steuert, sprich leistungsfähige Transistoren (Mosfets). Dazu habe ich als erstes mal Messungen angestellt wieviel Strom typische Carbonheizmatten überhaupt ziehen, denn den Wattangaben auf der Packung ist meist nicht zu trauen. Ich habe insgesamt 4 Carbonheizmatten gemessen, und pro Matte immer 1,5 bis 2A bei 12V gemessen. Pro Sitz werden zwei Matten verbaut, d.h. es müssen mindestens 4A pro Sitz dauerhaft fließen können. Da ich gerne Sicherheitsreserven habe, wollte ich also Module die mindestens das doppelte vertragen.

Schlussendlich habe ich für diese Module hier entschieden: https://amzn.eu/d/f3bRU6Q

Die angeblich 400W dieser Module sind natürlich gnadenlos übertrieben, und würden wenn überhaupt nur mit aktiver Kühlung erreicht werden können. Auf diesem Modul sitzen zwei parallel geschaltete D4184 Transistoren. Damit sollten laut Datenblatt zusammen gut 10-15A Dauerlast ohne Kühlung möglich sein. Meine Tests ergaben daß das auch klappt, selbst nach einer Stunde mit zwei Heizmatten am Ausgang und PWM auf Volllast (100%) war nahezu keine Erwärmung der Transistoren feststellbar.

Teil 3 folgt

Zitat von Benno

Bitte weitermachen!!

Okay

Teil 3: Verkabelung der Lastmodule

Werfen wir einen Blick auf die Rückseite der Lastmodule:

Wie man sieht, ist der Plus-Eingang einfach durchgeschaltet. Das PWM-Signal erfolgt über den Minuseingang, wie übrigens bei der klassischen PWM-Box auch. Damit ist die Verkabelung der Lastseite klar:

Jetzt fehlt natürlich noch die Ansteuerung der Lastmodule. Dazu brauchen wir einen kleinen Mikrocontroller, der einerseits digitale Ausgänge hat die ein PWM-Signal erzeugen können um die beiden Lastmodule anzusteuern. Andererseits sind auch zwei analoge Eingänge notwendig, um mit einer kleinen Schaltung den Sitzheizungsschalter auszulesen. Es gibt viele Mikrocontroller die man dafür nehmen könnte, ich habe mich hier für einen Arduino entschieden, weil ich damit schon Erfahrung aus anderen Projekten hatte. Da der kleinste Arduino hier ausreicht, habe ich zu einem Nano Klon mit Atmel 328P Chip und CH340-USB Controller gegriffen, da es damit erfahrungsgemäß keine Kompatibilitätsprobleme gibt. Ob man eine Version mit Mini-USB oder USB-C-Anschluss nimmt spielt keine Rolle:

Z.B.: https://amzn.eu/d/j8i8dZf

Fortsetzung folgt.

Teil 4: Der Mikrocontroller

Platzieren wir nun als nächstes den Arduino Nano. Die Spannungsversorgung wird mit dem Ausgang des DC-DC-Spannungswandlers verbunden, und für die Ansteuerung der Lastmodule nehmen wir Digitalpins die PWM-fähig sind. In diesem Fall sind das die Pins D3 und D9, auf denen der Nano ein PWM Signal mit 490 Hz erzeugen kann:

Jetzt fehlt "nur" noch die Anbindung des Sitzheizungsschalters um die Stellung der Schalterpotis auszulesen. Achtung, jetzt wirds analog :

Dazu habe ich zuerst ein paar Überlegungen angestellt wie man das machen könnte. Generell kann ein Poti direkt und ohne weitere Bauteile an einen der Analogpins des Arduino abgeschlossen werden, wenn alle drei Pins zugreifbar sind und man den Mittelabgriff des Potis verwenden kann, etwa so:

Dummerweise sind beim Sitzheizungsschalter nur zwei der drei Pins herausgeführt, und ich habe ja extra eine Lösung gesucht bei dem der Schalter nicht mehr modifiziert werden muss. Was also tun? Die Lösung ist ein simpler Spannungsteiler, der besteht bekanntlich aus zwei Widerständen. Einen der Widerstände verbauen wir dabei fest, den anderen Widerstand ersetzt das Poti im Sitzheizungsschalter, das im Falle des Golf1 Schalters Werte zwischen 0 und 500 Ohm annehmen kann.

Um den festen Widerstand zu dimensionieren ist es wichtig zu wissen, daß der Arduino max. 40mA an den Analogeingängen verträgt. Da das Poti in Nullstellung bei 0 Ohm ist, muss der Widerstand also bereits alleine so groß sein, daß höchstens 40mA fließen können. Damit ergibt sich nach Gevatter Ohm aus U=R*I die Gleichung 5V = x * 0,04, womit der Widerstand also mindestens 125 Ohm haben muss. Da ich Sicherheitsreserven mag (...hatte ich das schon erwähnt?) und die Analogpins des Arduino mit ihren 1024 Stufen fein genug auflösen, habe ich hier zu einem 500 Ohm Widerstand gegriffen.

Da wir zwei Potis im Schalter abfragen müssen, Fahrer und Beifahrer, benötigen wir zwei 500-Ohm Widerstände um zwei Spannungsteiler zu bauen. Als Analogpins nehmen wir die Pins A0 und A3. Verkabelt sieht das dann so aus:

Damit ist die PWM-Box elektrisch komplett. Der Rest ist "nur" noch die Programmierung des Arduino, Diese folgt im fünften und letzten Teil in Kürze.

Teil 5: Den Arduino programmieren

Auf zum Letzten Akt Im folgenden gehe ich davon aus, daß der Umgang mit der Arduino IDE bekannt und die Arduino AVR Bibliothek im Boardverwalter eingerichtet ist um den Nano flashen zu können.

Wichtig:

Solltet ihr die Schaltung bis hierhin fertig aufgebaut haben, bitte diese zuerst von der Stromversorgung trennen und unbedingt die Heizmatten abstecken (!). Ansonsten würde die Gefahr bestehen, daß ihr den USB-Port eures Computers zerstört, da die Heizmatten viel mehr Strom ziehen als ein normaler USB-Port liefern kann. Viele moderne Computer haben zwar eine Schutzschaltung um dies zu verhindern, aber testet das bitte lieber nicht

Der Sitzheizungsschalter kann hingegen gefahrlos verbunden sein.

Jetzt könnt ihr den Arduino per USB-Kabel mit eurem Computer verbinden. Es ist normal daß dabei sowohl eine LED am Arduino als auch die LED des DC-DC-Spannungswandlers aufleuchtet.

Der folgenden Code kann einfach Copy&Paste übernommen und geflasht werden:

#define PIN_POTI_FAHRER A0
#define PIN_POTI_BEIFAHRER A3

#define PIN_HEIZUNG_FAHRER 3
#define PIN_HEIZUNG_BEIFAHRER 9

byte PWM_CYCLE_FAHRER = 0;
byte PWM_CYCLE_BEIFAHRER = 0;


void setup()
{
    Serial.begin(9600);
  Serial.println("\n Onestone's Golf 1 PWM Sitzheizungsbox für Arduino");

  // Input Pins für Schalter Potis zum Abfragen
    pinMode(PIN_POTI_FAHRER, INPUT);
     pinMode(PIN_POTI_BEIFAHRER, INPUT);

  // Output Pins für Lasstransistoren
  pinMode(PIN_HEIZUNG_FAHRER, OUTPUT);
  pinMode(PIN_HEIZUNG_BEIFAHRER, OUTPUT);

}

void loop()
{
    measureResistance();
    delay(1000);
}

void measureResistance()
{
    long reading = 0;

  // Schalter Potis abfragen und PWM duty cycle daraus erstellen 
  reading = analogRead(PIN_POTI_FAHRER);
  PWM_CYCLE_FAHRER = (byte)map(reading, 0, 525, 0, 255);
  reading = analogRead(PIN_POTI_BEIFAHRER);
  PWM_CYCLE_BEIFAHRER = (byte)map(reading, 0, 525, 0, 255);

  // PWM cylcles Filtern:
  // - kleine duty cycles herausfiltern, bringen keine Wärme, belasten aber die 
  //   Transistoren sonst. Cycle 10 entspricht kurz vor der 1 auf dem Schalter Rädchen
  // - ab 240 durchschalten auf volle Power, entspricht kurz vor Stufe 5 auf dem 
  //   Schalter Rädchen
  if (PWM_CYCLE_FAHRER < 10) PWM_CYCLE_FAHRER = 0;
  else if (PWM_CYCLE_FAHRER > 240) PWM_CYCLE_FAHRER = 255;
  if (PWM_CYCLE_BEIFAHRER < 10) PWM_CYCLE_BEIFAHRER = 0;
  else if (PWM_CYCLE_BEIFAHRER > 240) PWM_CYCLE_BEIFAHRER = 255;

  // PWM Pins duty cycle setzen für Lasttransistoren
  analogWrite(PIN_HEIZUNG_FAHRER, PWM_CYCLE_FAHRER);
  analogWrite(PIN_HEIZUNG_BEIFAHRER, PWM_CYCLE_BEIFAHRER);

  // Serial.println("Rohwert: " + String(reading));
  Serial.println("PWM cycles: Fahrerseite = " + String(PWM_CYCLE_FAHRER) + " / Beifahrerseite = " + String(PWM_CYCLE_BEIFAHRER));
}

Hier ein paar Erläuterungen um den Code besser nachzuvollziehen:

• Zeilen 1-8:
  • Hier werden die Pins definiert die wir benutzen wollen, für die Lastmodule und die beiden Potis im Schalter, sowie zwei Variablen angelegt
• Zeilen 11-24:
  • Im Setup-Teil wird festgelegt wie die Pins zu benutzen sind: Die beiden Pins für die Potis im Schalter sollen Eingabe-Pins sein, die beiden Pins an denen die Lastmodule hängen sollen Ausgabepins sein. Außerdem schicke ich noch ein paar Ausgaben auf die Serielle Konsole, anhand derer man später testen kann ob das Flashen geklappt hat, oder ob z.B. der Schalter richtig angeschlossen ist
• Zeilen 26-30:
  • Hier wird festgelegt, daß der Schalter einmal pro Sekunde abgefragt wird und die Lastmodule entsprechend angesteuert werden sollen
• Zeilen 32-40:
  • Hier muss man wissen, daß die Analog-Digital-Wandler des Arduino eine Spannung an einem Analog-Pin auf eine Zahl zwischen 0 und 1024 abbilden. Je nach Potistellung liefert die Funktion analogRead aufgrund des Spannungsteilers in unserer Schaltung eine Zahl zwischen 0 und 525 zurück. Mit einer solchen Zahl kann der Ausgabepin des Arduino allerdings direkt nichts anfangen, dieser benötigt für die PWM-Funktion eine Zahl zwischen 0 (aus) und 255 (PWM bei 100%).
  • Hierzu kommt nun die map-Funktion zum Einsatz. Diese Funktion bildet eine beliebige Zahlenreihe auf eine andere Zahlenreihe ab, in unserem Falls also die Zahlenreihe 0-525 auf die Zahlenreihe 0-255
• Zeilen 42-48:
  • Da die Potis in den Schaltern alt sind und nicht immer genau 0 Ohm in Nullstellung und 500 Ohm auf Stufe 5 haben, sondern mal ein paar Ohm mehr oder weniger, habe ich hier noch einen kleinen Filter eingebaut. Dieser bewirkt daß alle Werte unterhalb von 10 auf 0 gesetzt werden um die Sitzheizung nicht im eigentlich ausgeschaltet Zustand immer trotzdem mit ein paar % Leistung anzusteuern.
  • Das gleiche für die Max-Stellung: bei Stufe 5 soll sie immer mit 100% laufen, auch wenn das Poti ein paar Ohm weniger liefern sollte
• Zeilen 50-52:
  • Hier wird nur noch die PWM-Rate der Ausgabepins gesetzt
• Zeile 55:
  • Hier wird auf die Serielle Konsole einmal pro Sekunde die PWM-Rate der erkannten Schalterstellung geschrieben (0-255).

Noch wichtig zu wissen:

• Wenn ihr den Arduino alleine oder die ganze Schaltung ohne angeschlossenen Sitzheizungsschalter flasht und euch dann die Ausgabe auf dem Seriellen Monitor anschaut, seht ihr möglicherweise komische Werte (z.B. "PWM-Cycle 240" oder ähnlich). Das ist ganz normal und braucht euch nicht zu beunruhigen, da die Analogpins frei schwebend irgendetwas zurück liefern. Sobald ein Schalter dran hängt sollten sie ganz normal funktionieren
• Solltet ihr aus irgendeinem Grund alles schon fertig im Auto verbaut haben und dann erst mit einem Laptop und USB-Kabel an den Arduino gehen: Zündung aus und die Stecker Sitze vorher abziehen (!), sonst siehe oben

So, nun viel Spaß beim Nachbauen und ausprobieren

Weitere Ideen und Anregungen sind immer herzlich willkommen!

Zitat von acki

Könnte man mit einer Diode zwischen Spannungsteiler und Arduino absichern, oder?

Ja wäre bestimmt möglich. Dann müsste man den DC-DC-Spannungswandler aber wahrscheinlich ein wenig höher einstellen damit der Arduino noch stabil läuft, da an der Diode ja etwas Spannung abfällt. Andererseits macht man das Flashen nur einmal, dafür kann man auch kurz die Stecker abziehen...

Die Box gibts jetzt auch fertig aufgebaut und geflasht im Marktplatz:

Der Vollständigkeit halber und weil ein paar gefragt haben, hier noch der Anschlussplan: