Beschleunigung aus Geschwindigkeit berechnen und ausgeben

Hallo liebe Fachleute,

ich bin leider seit der Schulzeit eine absolute Formelnull (ich bitte um Nachsicht) und hoffe daher auf Eure Hilfe, eine Lösung für meine Fragestellung zu finden. Folgendes Problem - ich versuche es so detailliert wie möglich zu beschreiben:

Ich habe ein Arduinosketch, dass mir aus einem Simulatorprogramm den Wert für die gefahrene Geschwindigkeit ausliest und diesen Wert an ein Stellservo ausgibt, um damit die Geschwindigkeit anzuzeigen. Funktioniert soweit auch ganz prima.

Nun möchte ich mir aber auch die Beschleunigung anzeigen lassen, sowohl beim Beschleunigen als auch beim Abbremsen. Es ist ja so, dass Fahrzeuge immer ungleichmäßig beschleunigte Bewegungen erfahren, welche nicht so einfach wie eine gleichmäßige Beschleunigung zu berechnen ist.

Nun habe ich ja im Arduino feste Abfragezyklen, in denen jeweils eine Veränderung der Geschwindigkeit festgestellt werden kann, womit man doch die Beschleunigung berechnen könnte…

Da ich jedoch mit abstraktem Formeldenken leider nicht zurechtkomme, würde ich mich sehr freuen, wenn mir ein Fachmann auf - für einen Laien wie mich - nachvollziehbare Weise einen Weg aufzeigen könnte, wie ich diesen Beschleunigungswert aus der Geschwindigkeit für einen Abfragezyklus errechnen kann.

Möglicherweise sollte ich diese Frage vielleicht im Physikforum stellen, aber mir geht’s ja auch um das Einbauen einer Formel in den Code.

Für Eure Hilfe und Eure Geduld bedanke ich mich jetzt schon sehr herzlich :slight_smile:

Liebe Grüße

Christiane

Hier der Code für den Geschwindigkeitsservo, diesen habe ich nicht selbst entwickelt:

#include <Servo.h>

typedef enum {  NONE, GOT_v } states;
states state = NONE;
unsigned int aktueller_wert;

unsigned int wert_fur_an = 1;

// Servoname
Servo geschwindigkeit;


void setup ()
{
  Serial.begin (115200);

  state = NONE;
  geschwindigkeit.attach(9);  

} 

// Servo Geschwindigkeit
void Servo4(const unsigned int value)
{          
  geschwindigkeit.write(aktueller_wert);  
}

void aktion_ausfuhren()
{
  switch (state)
  {
    case GOT_v:
      Servo4(aktueller_wert);    
    break;
  }
  aktueller_wert = 0; 
}

void processIncomingByte (const byte c)
{
  if (isdigit (c))
  {
    aktueller_wert *= 10;
    aktueller_wert += c - '0';
  }
  else

  {
    aktion_ausfuhren ();
    switch (c)
    {
    case 'v':
      state = GOT_v;
      break; 
    default:
      state = NONE;
      break;
    }
  }
}

void loop()
{
	if (Serial.available())
		processIncomingByte (Serial.read());
}



// basiert auf Code von Nick und Lars. Vielen Dank dafür

jeweils eine Veränderung der Geschwindigkeit festgestellt werden kann, womit man doch die Beschleunigung berechnen könnte

Das ist doch schon mal ein Ansatz 8)

Nun habe ich ja im Arduino feste Abfragezyklen

Das ist ein Irrtum, aber du hast einen ZeitZähler. Im Beispiel BlinkWithoutDelay wird dir geseigt, wie du daraus einen beliebigen festen Zyklus machen könntest, aber du kannst etwas ähnliches auch mit variablen Zyklusdauern machen:
Immer wenn ein neuer Geschwindigkeitswert an den Servo geht, bildest du den Zeitunterschied zum vorigen Mal und teilst den Geschwindigkeitsunterschied durch den Zeitunterschied.

Wie Rechnen in der C - Programmiersprache geht, solltest du auch aus irgendwelchen Dummy Tutorials oder durch Ansehen und Raten bei gefundenen Sketchen rauskriegen.
Die Berechnungen in der Funktion processIncomingByte() sind allerdings ein für den Anfang abschreckendes Beispiel, obwohl sie mir sehr gut gefallen. Wie die funktionieren, kriegen wir später :wink: Gruß an “Nick und Lars”

Dein Sketch vergisst leider die vorige Geschindigkeit und muss sich noch die Zeit merken, knobel mal ein bisschen, dann wirst du bestimmt geholfen :wink:

Um es physikalisch nochmal kurz aufzuklären.

Du willst die Beschleunigung wissen. Die Beschleunigung ist nichts anderes als die Geschwindigkeitsänderung pro Zeit. Ergo deltaV/t.
Somit kommt man auch von der Einheit m/s auf m/s².

Du musst also zwischen zwei Messzyklen das Delta der Geschwindigkeit und die Zeitspanne ermitteln. Wie das geht hat ja Michael bereits geschrieben. Wichtig ist, dass du mit Meter pro Sekunde arbeitest. Falls deine Simulation km/h liefert, dann musst du erstmal noch durch 3,6 teilen, damit du auf m/s kommst. Sonst stimmt nachher die Beschleunigung nicht.

hi,

nochmal einfacher:

Du hast zwei geschwindigkeitsmessungen und weißt die zeit dazwischen.

also Du mißt im abstand einer sekunde zwei geschwindigkeiten, z.b. 5m/s und 7m/s.
der unterschied ist 2m/s, das dividierst Du durch die zeit, also 1 s. das ergibt eine beschleunigung von 2m/s².
wenn die dazwischenliegende zeit nur 0,2 sekunden beträgt, also 2 durch 0,2, ergibt 10m/s².

beim bremsen ist es genauso, von 7m/s auf 5m/s ergibt sich eine änderung von -2m/s, dividiert durch 0,2 ergibt -10m/s², also eine negative beschleunigung von 10m/s².

gruß stefan