Simulation einer Raketen-Telemetrie: Sensor-Fusion verstehen

Stell dir vor, du bist ein Arzt, aber dein Patient ist kilometerweit entfernt und rast mit 500 km/h durch die Luft. Wie kannst du wissen, ob es ihm gut geht? Genau das ist die Aufgabe der Telemetrie.

In der Raumfahrt ist Telemetrie lebenswichtig. Raketen schicken ständig Daten zur Erde: "Ich bin 100 Meter hoch", "Meine Batterie ist voll", "Ich drehe mich gerade". Aber bevor wir eine echte Rakete mit teurer Elektronik starten, müssen wir sicher sein, dass unser Code am Boden funktioniert. Ein Fehler in der Luft kann nicht mehr korrigiert werden!

So sieht das Innenleben einer Modellrakete schematisch aus.

01. Das Problem: Sensoren lügen (manchmal)

Um zu wissen, wie hoch und schnell unsere Rakete ist, nutzen wir Sensoren. Die zwei wichtigsten sind:

• Das Barometer: Es misst den Luftdruck. Je höher wir sind, desto geringer ist der Druck. Es ist wie ein Höhenmesser im Flugzeug.
• Das Accelerometer: Es misst die Beschleunigung (G-Kräfte). Das spürst du, wenn du im Auto in den Sitz gedrückt wirst.

Klingt einfach, oder? Leider gibt es ein Problem: Sensoren sind nicht perfekt. Sie haben "Rauschen". Das bedeutet, selbst wenn die Rakete still auf dem Tisch liegt, zeigen die Werte kleine Schwankungen an. Mal 1 Meter hoch, mal 0 Meter, mal -1 Meter.

Die blaue Linie ist die Wahrheit, die rote Zick-Zack-Linie ist das, was der Sensor uns sagt.

02. Wir bauen eine Simulation

Statt eine echte Rakete zu starten, nutzen wir einen Arduino (einen kleinen Computer), um den Flug zu simulieren. Wir schreiben ein Programm, das so tut, als würde es fliegen. Es erzeugt künstliche Sensorwerte – inklusive dem nervigen Rauschen!

Das hat riesige Vorteile:

• Es kostet nichts (kein Raketenmotor nötig).
• Wir können es 1000 Mal wiederholen.
• Wir können "Katastrophen" simulieren, ohne dass etwas kaputt geht.

Schritt 1: Der perfekte Flug

Zuerst programmieren wir einen perfekten Flug. Mathematisch ist das eine Parabel oder eine Sinus-Kurve: Die Rakete steigt auf, wird oben langsamer, dreht um und fällt wieder.

Hier ist der Code für euren Arduino. Er berechnet eine theoretische Höhe und wandelt sie in Luftdruck um (denn das misst der Sensor ja eigentlich).

void setup() {
  Serial.begin(115200);
  while (!Serial); // Warte auf USB-Verbindung
  Serial.println("Start Simulation...");
}

float zeit = 0.0; 

void loop() {
  // 1. Die Physik-Simulation (Die Wahrheit)
  // Wir simulieren einen Flug, der bei 0 startet und bei PI (ca. 3.14) endet.
  float flugPhase = 0;
  
  if (zeit < 3.14159) {
    flugPhase = sin(zeit); // Sinus-Kurve für schönen Bogen
    zeit += 0.05;          // Zeit läuft weiter
  } else {
    flugPhase = 0;         // Landung, wir bleiben am Boden
  }

  // Unsere Rakete fliegt maximal 100 Meter hoch
  float wahreHoehe = flugPhase * 100.0;

  // 2. Die Sensor-Simulation (Was wir messen)
  // Luftdruck auf Meereshöhe ist ca. 1013 hPa.
  // Pro Meter Höhe sinkt der Druck um ca. 0.12 hPa.
  float sensorDruck = 1013.25 - (wahreHoehe * 0.12);

  // Sensoren sind nie perfekt! Wir fügen "Rauschen" hinzu.
  // Zufallswert zwischen -0.5 und +0.5
  float rauschen = random(-50, 50) / 100.0; 
  float gemessenerDruck = sensorDruck + rauschen;

  // Rückrechnung: Was würde unser Höhenmesser anzeigen?
  float gemesseneHoehe = (1013.25 - gemessenerDruck) / 0.12;

  // Ausgabe für den "Serial Plotter" in der Arduino IDE
  Serial.print("Wahrheit:");
  Serial.print(wahreHoehe);
  Serial.print(",");
  Serial.print("Sensor:");
  Serial.println(gemesseneHoehe);

  delay(100); // Kurze Pause
}

03. Die Lösung: Sensor-Fusion

Wie bekommen wir aus dem gezappelten Sensor-Wert wieder eine glatte Kurve? Wir könnten einfach den Durchschnitt der letzten 10 Werte nehmen. Das nennt man "Tiefpassfilter". Aber das macht die Daten langsam. Wenn die Rakete schnell die Richtung ändert, hinkt unser Wert hinterher.

Die Profis nutzen Sensor-Fusion. Wir kombinieren zwei Sensoren, die unterschiedliche Stärken haben:

Wir nehmen das Beste aus beiden Welten.

Wir bauen uns einen Komplementär-Filter. Stell dir vor, du mischst ein Getränk: 95% Saft (unser vertrauenswürdiger, aber langsamer alter Wert) und 5% Sprudel (der neue, wilde Messwert).

Hier ist der verbesserte Code mit Filter:

// ... (Setup wie oben)

float gefilterteHoehe = 0.0;

void loop() {
  // ... (Physik & Sensor Simulation wie oben) ...
  // (Füge hier den Code von oben ein bis zur Berechnung von 'gemesseneHoehe')

  // --- HIER IST DIE MAGIE ---
  
  // Der Filter:
  // Wir nehmen 90% vom letzten sauberen Wert (Erfahrung)
  // Und nur 10% vom neuen, zappeligen Messwert (Neue Info)
  gefilterteHoehe = (gefilterteHoehe * 0.90) + (gemesseneHoehe * 0.10);

  Serial.print("Sensor_Roh:");
  Serial.print(gemesseneHoehe);
  Serial.print(",");
  Serial.print("Sensor_Fusion:");
  Serial.println(gefilterteHoehe);

  delay(100);
}

Wenn du das plottest, wirst du sehen: Die "Sensor_Fusion" Linie ist fast so glatt wie die Wahrheit, reagiert aber trotzdem schnell genug. Du hast gerade deinen ersten Algorithmus für Raumfahrt-Software geschrieben! 🚀

04. Bereit für den echten Start?

Simulationen sind toll, aber nichts schlägt das Gefühl, wenn der Countdown läuft und der Motor zündet. Wenn du lernen willst, wie du diese Software auf einen echten Chip brennst, Sensoren verlötest und die Daten live auf deinen Laptop funkst, während die Rakete 300 Meter über dir schwebt... dann habe ich etwas für dich.