Reaktionszeit

[Felix Bäder (Gast)]

Hey Leuts,

ich bin grad dran mir für das Rennspiel LFS nen Externen Tacho zu bauen.

Eigentlich funktioniert auch alles soweit. ich hab nen kleines Programm, 
dass mir die aus dem Spiel exportierten Daten via SerialPort (Baudrate: 
38400) an Meinen Atmega32 sendet. Jetzt hab ich nur das Problem, dass 
wenn ich jetzt im Spiel den Motor abschalte, dann geht die Drehzahl ja 
logischer Weise runter. aber im unteren Bereich, also wenn die Abstände 
zwischen den von MC gesendeten Impulse größer wird, anfängt zu zucken.

Das heißt, die Nadel geht runter bleibt stehen geht weiter runter bleibt 
stehen. Und so weiter...

Kann mal jemand über den Code für den MC schaun ob ich da irgend ein 
Denkfehler drin hab?

Vielen Dank!!

Gruß
Felix Bäder

[Karl H. (kbuchegg)]

Felix Bäder schrieb:


> wenn ich jetzt im Spiel den Motor abschalte, dann geht die Drehzahl ja
> logischer Weise runter. aber im unteren Bereich, also wenn die Abstände
> zwischen den von MC gesendeten Impulse größer wird, anfängt zu zucken.
>
> Das heißt, die Nadel geht runter bleibt stehen geht weiter runter bleibt
> stehen. Und so weiter...

Kannst du das mal in Zahlen festmachen.
Über welche Werte für rpm reden wir da?

Denn

        rpmSoll = 940000/rpm;

mit sinkenden rpm Werten kriegst du da schon ganz ordentliche Sprünge 
rein.
Bei 500 hast du da ein Ergebnis von

    940000/500 = 1880

Bei 400

    940000/400 = 2350

Bei 300

    940000/300 = 3130

d.h. mit 100-er Differenzen werden die Sprünge im Ergebnis bei sinkenden 
Werten immer größer (durch die 1/x Beziehung)

Im Vergleich dazu

    940000/3000 = 313
    940000/2900 = 324
    940000/2800 = 335

sind in diesem Drehzahlbereich die Sprünge viel kleiner, obwohl ich auch 
hier nur ein paar Werte mit 100Upm Differenz gerechnet habe.

[Felix Bäder (Gast)]

Hmm so hab ich mir das noch garnicht angeschaut :D

dann ist auch klar das der so springt... das ist dann eben ab rund 
400rpm stark zu sehen.

[Karl H. (kbuchegg)]

Ich würde mal versuchen, ob es was bringt, wenn man die xxxsoll Werte 
nachlaufend macht.
D.h. der Wert der von der UART kommt wird nicht direkt in die xxxsoll 
Werte gesetzt, sondern ist wiederrum eine Vorgabe für den eigentlichen 
xxxsoll Wert, den der erreichen muss.

So ungefähr

....
        rpm = atoi(stringbuffer);
        rpmZiel = 940000/rpm;

und zb in der ISR wird dann gemacht

ISR( ... )
{

  if( rpmSoll < rpmZiel )
    rpmSoll++;
  else if( rpmSoll > rpmZiel )
    rpmSoll--;

  ....
  weitere Behandlung wie gehabt
}

d.h. der Wert für rpmSoll wird nicht sprunghaft auf einen neuen Wert 
gesetzt, sondern die ISR passt den Wert in kleinen Schritten laufend an, 
wobei sie den Wert so anpasst, dass er auf den Zielwert rpmZiel läuft.

Ob dieses Nachführen jetzt mit einer Schrittweite von 1 passiert oder 
mit größeren Schritten ist grundsätzlich egal. Mit einer Schrittweite 
von 1 ist es halt einfacher, weil dann die Abfragebedingunen einfacher 
sind und keine Sonderfälle berücksichtigen müssen.

Allerdings wird deine Nadel dann auch träger der Vorgabe vom PC folgen, 
was gerade bei den großen Zahlen für rpmZiel unangenehm sein könnte.

[Karl H. (kbuchegg)]

Mir ist ehrlich gesagt auch noch nicht klar, warum du da überhaupt eine 
1/x Beziehung ansetzt.
Was ist das für eine Nadel von der du da sprichst und benötigt die 
wirklich eine derartige Kennlinie in der Ansteuerung?

[Felix Bäder (Gast)]

Bei der Nadel handelt es sich um die Tachonadel. Also die Nadel die mir 
den Wert Anzeigt.
Das ist nen Tacho aus nem zweier Golf. und da muss ich halt entsprechend 
die Impulse senden um die Nadel auf den gewünschten Wert zu bringen.

[Karl H. (kbuchegg)]

Felix Bäder schrieb:
> Bei der Nadel handelt es sich um die Tachonadel. Also die Nadel die mir
> den Wert Anzeigt.
> Das ist nen Tacho aus nem zweier Golf. und da muss ich halt entsprechend
> die Impulse senden um die Nadel auf den gewünschten Wert zu bringen.


Ah verstehe.
Ja, logisch, denn der Tacho reagiert ja wieder auf die Frequenz, d.h. im 
Tacho ist ja im Grunde wieder du UMkehrung der 1/x Beziehung drinn, weil 
du ja die Pulslänge einstellen musst und ja gilt

     f = 1 / t

Dann stimmt das im Grunde schon.

Wie gesagt: ich würde mein Heil in einer derartigen 
Nachlaufsteuerungs-Dämpfung suchen. Da seh ich momentan noch die besten 
Chancen das hinzukriegen. Die Schrittweiten-Adaption wird wohl der 
unangenehmere Teil dabei sein.

Ev. sind ja auch die Sprünge in den rpm Zahlen, die du vom PC bekommst 
schon zu groß. D.h. man könnte bereits hier ein Nachlaufen ansetzen..

       rpmZiel = atoi(stringbuffer);

ISR( ... )
{
  if (rpm < rpmZiel )
    rpm++;
  else if( rpm > rpmZiel )
    rpm--;

  rpmSoll = 940000/rpm;

...
  weiter wie bisher
...
}

[Felix Bäder (Gast)]

Vielen Dank ich werde mir das morgen mal genauer anschauen und hoff es 
wird dann auch so wie ich es will :)

Danke Nochmal

[Stefan (Gast)]

>> rpmSoll = 940000/rpm;

ohne den code gelesen zu haben ...

rpmSoll = (940000/rpm) * m + b;
rpmSoll = log_irgendwas (940000/rpm) * m;
rpmSoll = log_irgendwas (940000/rpm) * m + b;

ich würde auf 2 tippen, schlimstenfalls auf 3

Aber eine Regession kann auch kubisch , ... , ....

Stefan