Reaktionszeit

Gast #3220009
Lesenswert?

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
Angehängte Dateien:
#3220034
Lesenswert?

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
1
        rpmSoll = 940000/rpm;

mit sinkenden rpm Werten kriegst du da schon ganz ordentliche Sprünge 
rein.
Bei 500 hast du da ein Ergebnis von
1
    940000/500 = 1880
Bei 400
1
    940000/400 = 2350
Bei 300
1
    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
1
    940000/3000 = 313
2
    940000/2900 = 324
3
    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.
#3220048
Lesenswert?

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
1
....
2
        rpm = atoi(stringbuffer);
3
        rpmZiel = 940000/rpm;


und zb in der ISR wird dann gemacht
1
ISR( ... )
2
{
3

4
  if( rpmSoll < rpmZiel )
5
    rpmSoll++;
6
  else if( rpmSoll > rpmZiel )
7
    rpmSoll--;
8

9
  ....
10
  weitere Behandlung wie gehabt
11
}

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.
Gast #3220055
Lesenswert?

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.
#3220060
Lesenswert?

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
1
     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..
1
       rpmZiel = atoi(stringbuffer);

1
ISR( ... )
2
{
3
  if (rpm < rpmZiel )
4
    rpm++;
5
  else if( rpm > rpmZiel )
6
    rpm--;
7

8
  rpmSoll = 940000/rpm;
9

10
...
11
  weiter wie bisher
12
...
13
}
Gast #3220089
Lesenswert?

>> 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

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren