Arduino + analogen VW Golf Tacho

Hi an die Profis…
das thema gab es schon mal und ähnelt eigenlich denen zu einem Fahradtacho. Das passt aber nicht so ganz zu meinen Anforderungen.

Ich will meinen Tacho der aktuell mechanisch durch eine Tachopese angetrieben wird (Km/h anzeige) elektrisch antreiben.
Dazu habe ich im Getriebe einen Hallsensor der mir x-mal pro Radumdrehung ein Signal liefert.
Dieses Signal müsste der Arduino aufnehmen  umrechnen  und an einen Motor mit bestimmten Drehzahl (je nach eingangswert) ausgeben. Diesem Motor baue ich dann an den Tacho um die Km/h Anzeige zu bedienen.
Eig ganz einfach oder???

ich habe dazu im Netz was alten gefunden. Dies scheint in der tat sauber zu funktionieren, leider jedoch mit einem Schrittmotor.
Ich bräuchte den ausgang jedoch an einem normalen dc-12v-Motor mit mit bis zu ~4500U/min

kann mir evtl. jemand helfen der sich sehr gut mit ardruino auskennt. Ich bin leider kein coder :frowning:

folggendes habe ich gfunden…
Video
Beschreibung

+ // Sketch to drive a speedometer with a stepper motor via an input that pulses
+ // a fixed number of times per mile
+ // Copyright (c) 2014  Kevin Gale <kevin@nhwoods.net>
+ // Version 1.0
+ // 
+ // Permission is hereby granted, free of charge, to any person obtaining a copy
+ // of this software and associated documentation files (the "Software"), to deal
+ // in the Software without restriction, including without limitation the rights
+ // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ // copies of the Software, and to permit persons to whom the Software is
+ // furnished to do so, subject to the following conditions:
+ // 
+ // The above copyright notice and this permission notice shall be included in
+ // all copies or substantial portions of the Software.
+ // 
+ // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ // THE SOFTWARE.
+ //
+ 
+ #include "SwitecX25.h"
+ 
+ // This code uses the FreqMeasure library written by  Paul Stoffregen <paul@pjrc.com>
+ // http://www.pjrc.com/teensy/td_libs_FreqMeasure.html
+ // However to get a stable speed at high speedometer speeds it will probably be
+ // necessary to increase the size of the FREQMEASURE_BUFFER_LEN value in the
+ // FreqMeasure code.  The FreqMeasure code this software was written against
+ // had a FREQMEASURE_BUFFER_LEN of 12. In order to have a stable speedo value
+ // and 100 mph or above the buffer needed to be at least 20 and a value of 50
+ // seems to work just fine and allows a stable speed.  
+ #include "FreqMeasure.h"
+ 
+ const int UpdateInterval = 100;  // 100 milliseconds speedo update rate
+ const double StepsPerDegree = 3.0;  // Motor step is 1/3 of a degree of rotation
+ const unsigned int MaxMotorRotation = 315; // 315 degrees seems like a common safe value.
+ const unsigned int MaxMotorSteps = MaxMotorRotation * StepsPerDegree;
+ const double PulsesPerMile = 5764.0; // Number of input pulses per mile
+ const double SecondsPerHour = 3600.0;
+ 
+ // For this speedo 180 degrees is 87 MPH. It is usually easier to measure half the speedo
+ // It's worth noting that although this code uses the terms MPH and miles the code is actually
+ // unit agnostic. If you just plug in kilometers values into the PulsesPerMile and here in the
+ // SpeedoDegreesPerMPH it will work with kilometers.
+ const double SpeedoDegreesPerMPH = 180.0 / 87.0;  
+ 
+ unsigned long PreviousMillis = 0;   // last time we updated the speedo
+ double MinMotorStep;  // lowest step that will be used - calculated from update interval
+ 
+ SwitecX25 Motor(MaxMotorSteps, 4,5,6,7); // Create the motor object with the maximum steps allowed
+ 
+ void setup(void) 
+ {
+  // Set 8 to pullup. This may or may not be needed depending on the input. The input might come from
+  // a TTL or active buffer thus driving the input line to both 5V and 0V, or the internal pullup on
+  // the ATMega processor might not be a small enough value for a particular Hall sensor.  The 
+  // ATMega328 spec says the internal pullup is  between 20K and 50Kohms.  Some Hall sensors require
+  // closer to 10K to work correctly on 5V. So turning off the internal pullup is logical sometimes.
+  pinMode(8, INPUT_PULLUP);
+ 
+  Motor.zero(); //Initialize stepper at 0 location
+ 
+  // The UpdateInterval controls the minimum speed we can measure. Since we force to zero when two
+  // intervals have gone by without a pulse. To avoid the speedo jumping around at very low speeds we
+  // just force these low speeds to zero. 
+  MinMotorStep = PulseToStep(2 * (UpdateInterval / 1000.0) * F_CPU);
+ 
+  FreqMeasure.begin(); // Start freqmeasure library
+ }
+ 
+ double sum=0;
+ int count=0;
+ double avgPulseLength=0;
+ unsigned int motorStep = 0;
+ int noInputCount = 0;
+ 
+ void loop() {
+  unsigned long currentMillis = millis();
+ 
+  // Update the motor position every UpdateInterval milliseconds
+  if (currentMillis - PreviousMillis >= UpdateInterval) {
+    PreviousMillis = currentMillis;   
+    count = 0;
+    sum = 0;
+ 
+    // Read all the pulses available so we can average them
+    while (FreqMeasure.available()) {
+      sum += FreqMeasure.read();
+      count++;
+    }
+ 
+    if (count) {
+      // Average all the readings we got over our fixed time interval. This helps
+      // stabilize the speedo at higher speeds. The pulse length gets shorter and 
+      // thus harder to measure accurately but we get more pulses to average.
+      // It may be necessary to update the FreqMeasure library to change the buffer
+      // length to hold the full number of pulses per update interval at the highest
+      // speedo values.
+      avgPulseLength = sum / count;
+      motorStep = PulseToStep(avgPulseLength);
+      noInputCount = 0;
+    } 
+    else if (++noInputCount == 2)  // force speed to zero after two missed intervals
+      motorStep = 0;
+ 
+    // Ignore speeds below the the two missed intervals speed so the motor doesn't jump
+    if (motorStep <= MinMotorStep) 
+      motorStep = 0;
+ 
+    Motor.setPosition(motorStep); 
+  }
+ 
+  // Always update the motor. It doesn't instantly go to the desired step so even if
+  // we didn't call setPosition the motor may still be moving to position from the last
+  // setPosition call.
+  Motor.update();
+ }
+ 
+ 
+ // The FreqMeasure gives us the pulse length in CPU cycles.  This formula converts this into a motor step.
+ // Basically we are converting the length of the pulse in CPU cycles into pulses per second and then
+ // converting that into MPH, Once we have MPH that number is converted into degrees and that is then
+ // converted into a number of steps.
+ unsigned int PulseToStep(double pulseLength)
+ {
+  return (unsigned int)((F_CPU * SecondsPerHour * SpeedoDegreesPerMPH * StepsPerDegree) / (PulsesPerMile * pulseLength));
+ }

Wenn ich das richtig leese, erwartet der sketch an PIN 8 das eingangssignal vom Hallgeber das ich wausi eh schon habe :wink:

Nur die Frage ist wie bekomme ich es quasi hin, das bei einem Eingangswert von 75,6 HZ den DC.Motor mit ~1266U/min antreibt?

puh das war janz schön viel und hoffe ich finde hier Hilfe :wink:

Bin kein Profi, kann dir aber so viel sagen, dass du für den DC-Motor eine Geschwindigkeitsregelung bräuchtest, wenn es genau werden soll und nicht nur eine Spielerei. Weiterhin müsste der DC-Motor vermutlich mit einem Transistor angetrieben werden anstatt mit dem Strom vom Arduino direkt.

Wenn du das wirklich selbst machen willst musst du dich einarbeiten ins Arduino programmieren und in oben genannte Themen. Ich denke nicht, dass dir jemand deinen Code für dich schreibt. Kopierter Code aus dem Netzt funktioniert halt auch nur für den zugehörigen Hardwareaufbau.

Vielleicht geht es aber auch einfacher als du denkst: Was passiert denn im Tacho selbst noch? Wird da das Drehsignal nicht sowieso wieder in ein Spannungssignal umgewandelt? Dann musst du am Tacho nichts drehen, wenn du ihm direkt diese Spannung reingibst.

Selbst wenn das nicht geht: Wenn du den Tacho so umbaust, dass ein Schrittmotor die Nadel bewegt, dann hast du ja den Aufbau wie du ihn im Netz gefunden hast.

JettaJens: ....... Nur die Frage ist wie bekomme ich es quasi hin, das bei einem Eingangswert von 75,6 HZ den DC.Motor mit ~1266U/min antreibt? .....

Zuerst machst du dir mal Gedanken zum Motor. Der Arduino kann dir maximal 5 Volt liefern und der Strom darf nicht höher als 30mA (max40mA) sein. Passt das zu deinem Motor? Welche elektrischen Daten hat dein Motor?

Dann liest dir mal durch wie das so ist mit einem analogen Ausgang bei einem µC. Der ist nicht ganz so anlog wie du dir das vielleicht vorstellst.

Dann wirst du dir überlegen müssen wie genau die Drehzahl gehalten werden soll. An einen Motor nur eine regelbare Spannung leiten ist eher eine Wunschdrehzahl aber vielleicht nicht so genau wie du das benötigst. Je höher die Drehzahl wird umso mehr werden die Lagerverluste wirksam.

Du wirst wohl eine Drehzahlmessung benötigen und dann immer der Sollwert anpassen müssen (= eine Regelung). Warum andere Menschen einen Schrittmotor verwenden hat also einen Grund.

Und nicht vergessen - egal ob dieser Motor oder doch ein anderes Modell - den µC vor Spannungsspitzen schützen.

Die Software (75,6 Hz = 1266 U/min) ist noch dein kleinstes Problem. Zuerst mal die Hardware zum laufen bringen.

Hi

Spielverderber Modus AN Ist der Tacho TÜV-relavant? Meiner kurzen Recherche nach: Ja Dann hast Du, nach Umbau, KEINEN Tacho mehr im Fahrzeug und somit bekommst Du keinen weiteren Stempel. wieder lieb bin

Die 'Anderen' nehmen einen Stepper, weil sich die Geschwindigkeit nicht so schnell ändert und man mit dem Stepper 'zielsicher' eine Position anfahren kann - wenn der Arduino will, daß die Nadel auf 70 steht, wird Die Das auch tun - ganz ohne Regelkreis, Den Du bei einem DC-Bürsten-Motor brauchen würdest. Wobei - bei einem Bürsten-Motor ... bei einem BLDC ist die Geschwindigkeit direkt von der Ansteuerung abhängig - auch können die Biester verflixt schnell drehen, brauchen aber 'Strom ohne Ende'. Hier sollte Es, zumindest theoretisch, recht einfach sein, die Taktgeschwindigkeit der gemessenen Geschwindigkeit proportional zu erzeugen, also wirklich nur die Tachowelle simulieren.

MfG

Analoge Tachos brauchen eine Drehbewegung, das ist kein Spannungssignal, sondern eine Art Wirbelstromscheibe mit Feder. Je schneller der Magnet an der Tachowelle dreht, desdo weiter wird die Nadel ausgelenkt. Eine Feder sorgt für das passende Gegenmoment. Mechanisch ein sehr anspruchsvolles Bauteil. Kann über die Federvorspannung sogar kalibriert werden.

Die nächste Generation an Cockpit hatte dann schon Schrittmotorantriebe. Ob es zwischendrin Varianten gab, die quasi wie ein Spannungsmesser mit einer Spannung angesteuert wurden, weis ich nicht. Hatte so ein Cockpit noch nicht gesehen bzw dran rumgebastelt.

Schrittmotorantriebe erkennt man meist daran, das sie bei Zündung ein, einmal auf Anschlag und zurück fahren. Funktionstest ist Vorschrift.

In ein analoges Tachomodul den DC-Motor mit Rückmeldung einzubauen ist sehr aufwendig. Ihn an den Tachowellenanschluss zu flanschen, benötigt ein Lager mit Überwurfmutter und die passende Achse mit Mitnehmer. Man darf sich das nicht zu leicht vorstellen, aber da wir ja immer an unseren Aufgaben wachsen, dürftest du hinterher ein gutes Stück größer sein.

Puh das geht ja ab hier :smiley:

zu den Fragen und weitere Anmerkungen:
um Spannungsspitzen im KFZ Boardnetz abzufangen würde ich sowas in der richtung verwenden.
Kfz_Spannungsspitzenkiller

Gedanken zum Motor:
ich weiß das der Arduino maximal 5 Volt liefert. Hier würde ich mir eine zusatzschaltung mit H-Brückentreiber bauen.

TÜV:
Tüv relevant sind Fahrtrichtungsanzeiger(Blinker) & Fernlicht.
Da das Auto BJ. 1981 ist geleten auch dessen Richtlinien zur Homologierung 1981. Damals wie heute ist der Geschwindigkeitsgeber ein “Schätzeisen” das je nach Tachoskala eine max. 10% abweichung nach oben haben darf. (dazu habe ich auch eine Bescheinigung) Wie die Tachonadel angetrieben wird ist NICHT definiert. Sie muss funktionieren.
Das Thema TÜV können wir vom Tisch nehmen.

Analoge Tachos brauchen eine Drehbewegung-korrekt–>deshalb benötige ich einen DC Motor der eine bestimmte Drehzahl erreichen muss.

ich habe einen Tacho deren Zeiger mittels Wirbelstromprinzip angetrieben wird. bedeutet:
die Tachopese die an den Tacho (von hinten) befestigt wird treibt den wegstreckenzähler als auch die Tachonadel mit Wirbelstromprinzip an. Der Wegstreckenzähler hat einen K-Wert
“Der k-Wert (je nach Hersteller auch k-Zahl oder Wegezahl) ist in der Fahrzeug- und Antriebstechnik das Verhältnis zwischen den Umdrehungen einer Tachometerwelle und der zurückgelegten Wegstrecke.
Sie ist abhängig von der Radgröße und der Übersetzung zur Antriebswelle beziehungsweise zum
Tachometerwellenantrieb.”
in meinem Fall 950 =950U/min für einem KM.

Sicher kann ich einen Schrittmotor verwenden, dann würde aber der integrierte Wegstreckenzähler nicht mehr korrekt mitlaufen :wink:
Ich benötige also den DC Motor.

Da die Anzeige eh ein Schätzeisen ist muss die errechnette Drehzahl auch nicht zu 100% stimmen.

Den Motor an den Eingang für die Tachowelle zu flanschen:

  1. ist das keine Hexerei
  2. war das ja nicht meine Fragestellung :wink:

Am ende vom Lied, will ich zunächst nichts weiter als das der Arduino die ermittelte Hz Frequenz umrechnet und ggf. mittels pwn signal ausgeben kann.

Alles weitere für die Absicherung der Module und sichere Ansteuerung ist hier erst mal nebensächlich :wink: denn ich baue mir das alles zunächst in einer kleinen Versuchsumgebung auf.

PS: ich bin auf quellcodes aus dem Netz angewiesen da ich das coden nicht behersche. Von daher versuche ich mich mit diesen Mitteln einzuarbeiten und hoffe auf ein wenig unterstützung. Nicht jeder kann auf anhieb alles :wink:

Ein DC Motor ist Lastabhängig. Mit einer bestimmten Spannung wird eine Drehzahl erreicht, die stark vom Gegenmoment abhängig ist. Wäre das jetzt ein nagelneuer Tacho und du würdest das ganze in einem trockenen klimatisierten Umfeld betreiben, würde man sich das ganze im Versuch austesten.

Dein Auto dagegen ist vielen unterscheidlichen Bedingungen ausgesetzt. Und damit ändert sich das Gegenmoment so stark, das du die +10% die der Tacho abweichen darf nicht mehr einhalten kannst. Ohne Feedback wird das nix und eine Regelschleife zu programmieren ist nicht trivial und in deinem Fall rein aus der Theorie fast nicht machbar. Man müsste eine parametrierbare Schnittstelle erstellen, damit die die Anpassung vornehmen kannst. Den wir wissen ja garnicht wie dein Motor und deine Wellenantriebskraft zusammenpassen.

Ich würde mich mal in Tachogenerator einlesen, das ist ein Modul das am Motor dran geflanscht ist und ein Drehzahlabhängiges Spannungssignal rausgibt. Anhand dessen ist die Drehzahl ermittelbar und dementsprechend kannst du diese in einen Regelkreis einspeisen und deine Drehzahl anpassen.

Aber das hier viel Try&Error zum Einsatz kommt, wird es schwer wenn dir da jemand was programmieren soll. So ein Regelkreis ist nicht trivial und mal eben mit Copy Paste erledigt.

Hi

Um von der Regelschleife weg zu kommen dachte ich ja an den BLDC - Der bekommt ein Drehfeld und dreht sich je nach Polpaarzahl entsprechend langsamer (in entgegengesetzter Richtung - aber wohl egal, wie herum das Feld wandert, wenn die Welle richtig dreht).

Einen BLDC-Treiber habe ich schon als AVR-Projekt gesehen - Wohlgemerkt AVR, nicht Arduino, kann sein, daß man aufgrund der benötigten Geschwindigkeit Da 'etwas tiefer' muß.

Hier sehe ich ggf. ein Problem, wen ndas Auto wirklich nur Schritt fährt, da die BLDC nahezu Kurzschlüsse darstellen und somit sehr viel Strom 'recht gemächlich' zwischen den Spulen wechselt - kA, ob man Da auch eine Art Chopper benutzen kann. Im Modellbau wird Das wohl auch noch Niemand gemacht haben, da die BLDC eher nicht für's langsame Drehen gedacht sind.

MfG

PS: Hätte jetzt aber schon erwartet, als Bauchgefühl, daß der Tacho TÜV-relevant ist - dann eben halt nicht ;)

Ein BLDC ist vom Aufbau ein Synchronmotor aber die Ansteuerung ist kein Frequenzwandler sondern der Treiber schaltet die nächste Spule nach der Totorposition (durch Sensoren oder durch Messung der Spannung an der nicht bestromten Phase).

Damit ein BLDC Drehzahlsteuerbar ist mußt Du nach erreichen der wunschdrehzahl auf eine Konstantfrequenz umschalten. Das macht ein Handelsüblicher Treiber nicht. Grüße Uwe

ich finde den Umweg der Mechanischen Wandlung sinnarm. Bau den Tacho auf elektronisch um. Besser noch - beschreibe genau um welchen Tacho es sich handelt "Golf" gibt es ja wie Sand am Meer. Überhaupt stellt sich die Frage, weswegen tauscht du die Tachowelle gegen ein Kabel aus? Was willst du eigentlich wirklich erreichen?

es handelt sich um ein Golf1 Cabrio BJ. 1983 mit Umbau auf einen Turmoumbau und 02A Getriebe, das von hause aus ein Impulsgeber hat um (im orig. Golf3 bspw. den Tacho zu füttern) Hier findet der geber verwendung für ein Freiprogrammierbares MotorSteuergerät.

Ein Umbau auf elektronischen TAcho kommt aus mehreren Aspekten NICHT in Frage. Im Originalen Golf1 geht die Tachwelle vom Getriebe zum Tacho. Da jetzt im Getriebe ja schon der Impulsgeber sitz geht das nicht.

Mögliche Lösungen. 1. einen Adapter bauen der sowohl als Impulsgeber dient und an dem man auch die Tachowelle anflanschen kann.

  1. den vorhandenen Impulsgeber "doppelt" verwenden. einmal fürs MSTG und einmal für den Tacho. dadurch resultiert das die TAchowelle verschwindet. Für einen "cleanen Motorraum" ideal ;)

Ok, verständlich. Und mir würde der Orginal-Tacho auch besser gefallen beim Oldtimer. Da passt kein Digitaler.

Um so mehr kommst du also nicht umhin, dir da entweder einen Kumpel mit guten Programmierkenntnissen anzulachen oder dich selbst mit Regelkreisen und der dazu gehörigen Programmierung zu beschäftigen.

In Detailfragen finden sich bestimmt genug Helfer, aber für ein “ich bastel dir den Code mal zurecht, macht du die Mechanik” findest eher selten jemanden. Vorallem nicht wenns was gescheites werden soll.

Woher dann deine Impulse kommen, wäre zudem auch egal, weil du ja dann immer umrechnen kannst von Impulszahl zur Wegstrecke und aus der heraus die aktuelle Speed. Am einfachsten für dich dürfte dann noch der Tachogenerator sein. Weil der eine Spannung liefert. Und am Arduino die Spannung leicht messbar ist, weil er schon AD-Wandler hat dafür. Drehzahl/Spannung muss dann immer einen konstanten Wert ergeben. Wenn Wert kleiner, dann Drehzahl erhöhen, wenn Wert größer, dann Drehzahl verkleinern. So wird das regeln relativ einfach gemacht. Und da kaum eine Verzögerung zwischen Drehzahländerung und Tachosignal gibt, muss man auch keinen PID-Regelkreis aufbauen. Zumindest wenn man nicht extreme Genauigkeit erreichen will. Die Vorgabe von +10% lässt dir viel Spielraum. Sollte dann die Tachonadel etwas zittern wegen der Regelung, meldest dich wieder, dann kann man einen Filter dazu coden, der deine Regelschleife etwas verzögert und glättet. Für die paar Zeilen die dann nötig sind findet sich Bestimmt ein Helfer.

Was du im Prinzip hast ist vermutlich ein digitaler Sensor (Hallsensor, 0 oder 5V) und du möchtest einen DC-Motor mit Arduino ansteuern, per H-Brücke - auch Motortreiber genannt.

Das sind deine Teilprobleme, von der Regelungsproblematik mal abgesehen. Es gibt zig Anleitungen zum Thema Sensoren auslesen und Motor ansteuern mit Arduino im Netz. Ich würde dir aber empfehlen erstmal ein paar Anfängertutorials durchzuarbeiten, auch wenns da erstmal nur um langweilige LEDs geht. Du brauchst die Grundlagen. Wie schon gesagt wird dir hier sicher konkreter geholfen wenn du diese Schritte gegangen bist und einen Code vorzuweisen hast.

Hier mal ein guter Artikel zum Thema Motor ansteuern: https://www.heise.de/developer/artikel/Gut-motorisiert-mit-Gleichstrommotoren-3224170.html