← Zum vorherigen Versionsunterschied Zum nächsten Versionsunterschied →

Version vom 12. Juli 2026, 10:50 Uhr

Dozent:	Prof. Dr.-Ing. Schneider
Lehrveranstaltung:	Moderne Tracking Systeme
Modul	Business and Systems Engineering, Systemintegration
Modulbezeichnung:	BSE-M-2-2.01
Modulverantwortung:	Prof. UlrichSchneider
Prüfungsform:	Hausarbeit
Abgabetermin:	19.07.2026

Hausarbeit: Sensorfusion zur 2D-Navigation eines mobilen Roboters mit KF, EKF und UKF

Der Autonome Mobile Roboter (AMR, AlphaBot) soll wie im Video gezeigt möglichst exakt die Ränder eines Quadrats abfahren.

Video: Mobile Robot Localisation

URL: https://www.youtube.com/watch?v=PWdxnERpynU

Im Rahmen dieser Hausarbeit soll eine Sensorfusionslösung zur Navigation eines mobilen Roboters entwickelt und untersucht werden.

Als Versuchsplattform dient ein Waveshare AlphaBot, der mit einer MPU9250-Inertialsensoreinheit ausgestattet ist. Die Sensordaten werden erfasst, verarbeitet und zur Schätzung der Roboterpose verwendet.

Ziel ist die Entwicklung und Bewertung verschiedener Bayes-basierter Schätzverfahren:

Kalman-Filter (KF)
Extended Kalman-Filter (EKF)
Unscented Kalman-Filter (UKF)
Partikelfilter (PF)

Die Verfahren sollen hinsichtlich Genauigkeit, Robustheit und Rechenaufwand verglichen werden.

Notwendige Hardware

AlphaBot mit
Arduino R4 Wifi und
MPU 9250 IMU
USB-C Kabel

Notwendige Software

Arduino IDE 2.3.10
MATLAB^® (z. B. R2025b) mit Arduino Support Package

Vorbereitung

Arbeiten Sie sich anhand dieses Artikels in den AlphaBot ein. Sie benötigen lediglich die Ansteuerung der Motoren, das Auslesen der Inkrementalgeber und die Daten der IMU MPU 9250.
Leihen Sie sich die Hardware für die Hausarbeit bei Prof. Schneider oder Marc Ebmeyer aus.
machen Sie bei Fragen frühzeitig einen termin mit Prof Schneider.
Binden Sie den Arduino Uno R4 Wifi in Ihre Wifi-Umgebung ein. Sie dürfen hierfür gern unser Labor verwenden.
Tragen Sie die WLAN-Zugangsdaten und die IP-Adresse des MATLAB-Rechners in die entsprechende Zeile ein.
Übertragen Sie das Programm DemoUnoR4Wifi.ino auf den Arduino uno R4 Wifi.
Versorgen Sie den Arduino Uno R4 mit Spannung (6 V-24 V). Die Daten werden nun gesendet. Die TX-LED blinkt kontinuierlich.
Starten Sie DemoUnoR4Wifi.m auf dem PC. Die Daten Zeit in s;Zähler müssten nun empfangen und im Command Window dargestellt werden.
Sie sind nun startbereit!

Demos

DemoUnoR4Wifi.m

// Notw. Hardware HC-05 Bluetooth Modul
// Vorbereitung:
//                 1) Binden Sie den Uno R4 in Ihr Netzwerk ein (Z. 25, 26).
//                 2) Tragen Sie die IP Ihres MATLAB Rechners ein (Z. 32).
//                 3) Übertragen Sie das Skript an den Uno R4. 
//                 4) Wählen Sie einen frein UDP-Port (Z. 38).
//*****************************************************************************

#include <WiFiS3.h>
#include <WiFiUdp.h>

// WLAN Zugangsdaten
char ssid[] = "Ihr_WLAN_Name";     // Anpassen
char pass[] = "Ihr_WLAN_Passwort"; // Anpassen

WiFiUDP udp;

// IP-Adresse des MATLAB-Rechners
IPAddress matlabIP(192, 168, 1, 1);  // Anpassen

// MATLAB UDP-Port
unsigned int matlabPort = 7000;

void setup()
{
  Serial.begin(115200);
  while (!Serial);
  Serial.println("Verbinde WLAN...");

  while (WiFi.begin(ssid, pass) != WL_CONNECTED)
  {
    delay(5000);
    Serial.print(".");
  }

  Serial.println();
  Serial.println("WLAN verbunden");
  Serial.print("Arduino IP: ");
  Serial.println(WiFi.localIP());
  udp.begin(7001);
}


void loop()
{
  static int Zaehler_s16 = 0;             // Beispiel für Messwert
  float Zeit_f32 = float(millis())/1000;  // Zeit in s

  char Daten_s8[50];

  // Format: Float;Integer
  sprintf(Daten_s8, "%.3f;%d", Zeit_f32, Zaehler_s16);

  Serial.println(Daten_s8);

  // UDP senden
  udp.beginPacket(matlabIP, matlabPort);
  udp.write(Daten_s8);
  udp.endPacket();

  Zaehler_s16++; // Zähler inkrementieren

  delay(100);
}

DemoUnoR4Wifi.ino

clear all; clc;

port = 7000; % UDP Port, auf dem MATLAB lauscht

u = udpport("IPV4", "LocalPort", port);

disp("Warte auf UDP-Daten vom Arduino ...")

while true
    nBytes = u.NumBytesAvailable;
    if nBytes  > 0 % Prüfen, ob Daten vorhanden sind
        data = read(u, nBytes, "string");
        disp(data)
    end
end

GetDate.ino aus der Bibliothek MPU9250_asukiaaa

#include <MPU9250_asukiaaa.h>

#ifdef _ESP32_HAL_I2C_H_
#define SDA_PIN 21
#define SCL_PIN 22
#endif

MPU9250_asukiaaa mySensor;
float aX, aY, aZ, aSqrt, gX, gY, gZ, mDirection, mX, mY, mZ;

void setup() {
  Serial.begin(115200);
  while(!Serial);
  Serial.println("started");

#ifdef _ESP32_HAL_I2C_H_ // For ESP32
  Wire.begin(SDA_PIN, SCL_PIN);
  mySensor.setWire(&Wire);
#endif

  mySensor.beginAccel();
  mySensor.beginGyro();
  mySensor.beginMag();

  // You can set your own offset for mag values
  // mySensor.magXOffset = -50;
  // mySensor.magYOffset = -55;
  // mySensor.magZOffset = -10;
}

void loop() {
  uint8_t sensorId;
  int result;

  result = mySensor.readId(&sensorId);
  if (result == 0) {
    Serial.println("sensorId: " + String(sensorId));
  } else {
    Serial.println("Cannot read sensorId " + String(result));
  }

  result = mySensor.accelUpdate();
  if (result == 0) {
    aX = mySensor.accelX();
    aY = mySensor.accelY();
    aZ = mySensor.accelZ();
    aSqrt = mySensor.accelSqrt();
    Serial.println("accelX: " + String(aX));
    Serial.println("accelY: " + String(aY));
    Serial.println("accelZ: " + String(aZ));
    Serial.println("accelSqrt: " + String(aSqrt));
  } else {
    Serial.println("Cannod read accel values " + String(result));
  }

  result = mySensor.gyroUpdate();
  if (result == 0) {
    gX = mySensor.gyroX();
    gY = mySensor.gyroY();
    gZ = mySensor.gyroZ();
    Serial.println("gyroX: " + String(gX));
    Serial.println("gyroY: " + String(gY));
    Serial.println("gyroZ: " + String(gZ));
  } else {
    Serial.println("Cannot read gyro values " + String(result));
  }

  result = mySensor.magUpdate();
  if (result != 0) {
    Serial.println("cannot read mag so call begin again");
    mySensor.beginMag();
    result = mySensor.magUpdate();
  }
  if (result == 0) {
    mX = mySensor.magX();
    mY = mySensor.magY();
    mZ = mySensor.magZ();
    mDirection = mySensor.magHorizDirection();
    Serial.println("magX: " + String(mX));
    Serial.println("maxY: " + String(mY));
    Serial.println("magZ: " + String(mZ));
    Serial.println("horizontal direction: " + String(mDirection));
  } else {
    Serial.println("Cannot read mag values " + String(result));
  }

  Serial.println("at " + String(millis()) + "ms");
  Serial.println(""); // Add an empty line
  delay(500);
}

E15_RadInkrementalgeberFahrt.ino

/* Bibliotheken einbinden */
#include "AlphaBot.h"

/* Globale KONSTANTEN deklarieren */
AlphaBot R2D2 = AlphaBot();               // Instanz des Alphabot wird erzeugt. */
const byte PORT_ENC_L_u8 = 2;             // Die linke Lichtschranke (CNTL) liegt an Arduino D2
const byte PORT_ENC_R_u8 = 3;             // Die rechte Lichtschranke (CNTR) liegt an Arduino D3
const byte ANZAHL_INCREMENTE_u8 = 40;     // Die Encoderscheibe hat 20 Löcher und somit 40 Zustände
const int MOTOR_POWER_s16 = 80;           // Motorleistung
const unsigned long BAUDRATE_u32 = 9600;  // Serielle Übertragungsgeschwindigkeit in Baud
const unsigned long DELAY_MS_u32 = 1000;  // Delay in ms

/* Globale Variablen */
volatile byte valEncL_u8 = 0;               // https://www.arduino.cc/reference/de/language/variables/data-types/byte/
volatile byte valEncR_u8 = 0;               // Inkrementzähler
volatile long int RadumdrehungenL_s32 = 0;  // https://www.arduino.cc/reference/de/language/variables/data-types/long/
volatile long int RadumdrehungenR_s32 = 0;  // Zähler für die kompletten Radumdrehungen

/* Einmalige Systeminitialisierung */
void setup() {
  Serial.begin(BAUDRATE_u32);                 // Seriellen Monitor starten
  pinMode(PORT_ENC_L_u8, INPUT);              // Eingangsport D2 definieren
  pinMode(PORT_ENC_R_u8, INPUT);              // Eingangsport D3 definieren
  attachInterrupt(0, updateEncoderL, CHANGE); // 0: D2 Auslösen des Interrupts bei Signalwechsel
  attachInterrupt(1, updateEncoderR, CHANGE); // 1: D3 https://www.arduino.cc/reference/de/language/functions/external-interrupts/attachinterrupt/
}
/* Zyklusschleife */
void loop() {  
  /* Ausgaben im Seriellen Monitor */
  Serial.print(valEncL_u8);
  Serial.print(" :-: ");
  Serial.print(valEncR_u8);
  Serial.print(" :-: ");
  Serial.print(RadumdrehungenL_s32);
  Serial.print(" :-: ");
  Serial.print(RadumdrehungenR_s32);
  Serial.print("\n");
  delay(DELAY_MS_u32);

  R2D2.MotorRun(MOTOR_POWER_s16, MOTOR_POWER_s16);  // Fahrt starten
  delay(DELAY_MS_u32);                              // Fahrzeit
  R2D2.Brake();                                     // Alle Motoren stoppen
}

/* Unterfunktionen */
void updateEncoderL(){                  // Inkrementalgeber Links
  valEncL_u8++;
  if (valEncL_u8 > ANZAHL_INCREMENTE_u8)// 40 Zustandswechsel = 1 Radumdrehung 
  { 
    valEncL_u8 = 0;                     // Reset Inkrementzähler
    RadumdrehungenL_s32++;              // Umdrehungen inkrementieren
  } 
}

void updateEncoderR(){                  // Inkrementalgeber Rechts
  valEncR_u8++;
  if (valEncR_u8 > ANZAHL_INCREMENTE_u8)// 40 Zustandswechsel = 1 Radumdrehung
  { 
    valEncR_u8 = 0;                     // Reset Inkrementzähler
    RadumdrehungenR_s32++;              // Umdrehungen inkrementieren
  } 
}

Weitere AlphaBot und Arduino Demos finden Sie im SVN-Repositorium

https://svn.hshl.de/svn/Informatikpraktikum_1/trunk/Arduino/ArduinoLibOrdner/

Aufgabe 1: Systemaufbau und Datenerfassung

Der AlphaBot wird über eine ebene Fläche bewegt. Während der Fahrt werden Sensordaten aufgezeichnet.

Folgende Sensoren stehen zur Verfügung:

Sensor	Messgröße	Verwendung
MPU9250 Gyroskop	Gierrate $\dot{Ψ} = ω_{z}$	Orientierung
MPU9250 Beschleunigungssensor	$a_{x}, a_{y}$	Bewegungsdynamik
MPU9250 Magnetometer	Magnetfeldrichtung	absolute Orientierung
Radencoder	Raddrehzahlen	Geschwindigkeit und Weg

Die Messdaten werden über eine WLAN-Verbindung vom Arduino Uno R4 WiFi an MATLAB übertragen.

Das Datenformat soll mindestens enthalten:

Zeitstempel in s;Messnummer;Sensordaten

Beispiel:

1.25;2300;0.012;-0.034;9.812;0.01;0.02;-0.01

Aufgaben

Implementieren Sie eine Messdatenübertragung zwischen Arduino Uno R4 WiFi und MATLAB^®.
Erfassen und speichern Sie die Sensordaten des AlphaBots.
Dokumentieren Sie die Abtastrate, Datenqualität und mögliche Messfehler.

Aufgabe 2: Analyse der Sensorsignale

Untersuchen Sie die Eigenschaften der verfügbaren Sensordaten.

Führen Sie folgende Analysen durch:

Bestimmung der Abtastrate
Darstellung der Sensorsignale im Zeitbereich
Frequenzanalyse mittels FFT
Untersuchung von Offset und Drift
Bestimmung der Messunsicherheit

Bewerten Sie insbesondere:

Gyro-Bias und Drift
Rauschen des Beschleunigungssensors
Störungen des Magnetometers
Schlupf der Räder

Aufgabe 3: Bewegungsmodell des Roboters

Entwickeln Sie ein geeignetes Bewegungsmodell für den AlphaBot.

Der Roboter kann als Differentialantrieb modelliert werden.

Beispiel:

$x_{k + 1} = x_{k} + v_{k} \cos (ψ_{k}) Δ t$

$y_{k + 1} = y_{k} + v_{k} \sin (ψ_{k}) Δ t$

$ψ_{k + 1} = ψ_{k} + ω_{k} Δ t$

Diskutieren Sie:

Wahl der Zustandsgrößen
Modellannahmen
Modellfehler

Aufgabe 4: Navigation ohne Filter

Implementieren Sie zunächst eine reine Zustandsschätzung ohne Sensorfusion.

Der Zustand des Roboters wird beschrieben durch: $x_{k} = [\begin{matrix} x_{k} \\ y_{k} \\ ψ_{k} \\ v_{k} \\ b_{ω, k} \end{matrix}]$

mit:

$x, y$ : Position des Roboters in der Ebene
$ψ$ : Orientierung (Yaw-Winkel)
$v$ : Geschwindigkeit
$b_{ω}$ : Gyro-Bias

Untersuchen Sie:

Drift
Positionsfehler
Einfluss von Sensorausfällen

Aufgabe 5: Kalman-Filter (KF)

Entwickeln Sie ein lineares Zustandsmodell. Begründen Sie die Wahl des Zustandsmodells.

Die Zustandsschätzung soll mit einem klassischen Kalman-Filter erfolgen.

Bestimmen Sie:

Zustandsvektor
Systemmatrix
Messmatrix
Prozessrauschen $Q$
Messrauschen $R$

Untersuchen Sie den Einfluss der Filterparameter auf das Ergebnis.

Aufgabe 6: Extended Kalman-Filter (EKF)

Erweitern Sie das System auf das nichtlineare Robotermodell.

Implementieren Sie:

Prediction-Schritt
Berechnung der Jacobi-Matrix
Update-Schritt
Innovation und Innovationskovarianz

Bewerten Sie:

Genauigkeit
Stabilität
Verhalten bei Kurvenfahrt

Aufgabe 7: Unscented Kalman-Filter (UKF)

Im Gegensatz zum Extended Kalman-Filter wird keine Linearisierung des Bewegungs- oder Messmodells durch Berechnung einer Jacobi-Matrix durchgeführt. Stattdessen wird die Wahrscheinlichkeitsverteilung des Zustands durch eine Menge von Sigma-Punkten approximiert.

Erweitern Sie die bisher implementierte Zustandsschätzung des AlphaBots um einen Unscented Kalman-Filter (UKF).

Vergleichen Sie UKF und EKF hinsichtlich:

Positionsfehler
Winkelfehler
Verhalten bei Kurvenfahrt
Einfluss des Parameters $κ$
Rechenaufwand

Diskutieren Sie:

Welche Vorteile bietet die Unscented Transformation gegenüber der Linearisierung des EKF?
Wann liefert der UKF bessere Ergebnisse als der EKF?
Welche Grenzen besitzt der verwendete UKF-Ansatz?

Aufgabe 8: Experimentelle Untersuchung

Führen Sie, wie im Video dargestellt, verschiedene Fahrversuche auf einem vorgegebenen Quadrat durch.

Nutzen Sie als Referenz das Videobild oder die Referenzstation im Labor. Machen Sie mit Prof. Schneider frühzeitig einen Termin, wenn Sie im Labor messen möchten.

Bewerten Sie die Filter anhand von:

Kriterium	KF	EKF	UKF
Positionsfehler
Winkelfehler
Robustheit
Rechenzeit

Aufgabe 9: Diskussion und Bewertung

Beantworten Sie folgende Fragen:

Welche Annahmen treffen KF, EKF und UKF?
Wann versagen lineare Filter?
Welche Vorteile bietet der UKF gegenüber dem EKF?
Welche zusätzlichen Sensoren würden die Navigation verbessern?

Diskutieren Sie abschließend, welches Verfahren für die Navigation des AlphaBots am besten geeignet ist und begründen Sie Ihre Entscheidung.

Abgabe

Die Hausarbeit soll enthalten:

Beschreibung des Systemaufbaus
PAP der MATLAB-Programme
PAP des Arduino-Programms
Messdatenanalyse
Herleitung der verwendeten Modelle
Vergleich der Filterverfahren
Diskussion der Ergebnisse

Abgabeordner

Nachdem Sie zur Prüfung angemeldet sind, lege ich für Sie einen Sciebo-Arbeitsordner an. Bitte legen Sie darin Ihre Ergebnisse ab

Arduino-Datei,
MATLAB^®-Dateien,
Referenzmessung oder Referenzvideo und
Hausarbeit als .pdf

und organisieren Sie sich ggf. in Unterordnern.

Bewertung

Die Bewertung der Hausarbeit erfolgt anhand der Kriterien in Tabelle 1. Diese Bewertung wird in Ihrem Abgabeordner publiziert. Dieses gilt als Klausureinsicht. Melden Sie sich bitte bei Rückfragen frühzeitig.

Tabelle 1: Bewertungskriterien
Kriterium	Punkte
Dokumentation und Qualität der Recherche	5
Qualität und Quantität der Auswahlkriterien	5
Systematik bei der Auswahl des Ansatzes	5
Darstellung des Lösungsansatzes	5
Umsetzung des Lösungsansatzes	5
Anwendung und Optimierung des Partikelfilters zur Spurverfolgung	5
Qualität des Ergebnisses	5
Qualität der Ergebnisdiskussion	5
Summe:	40

Tutorial

BSE Moderne Tracking Systeme (SoSe 2026): Unterschied zwischen den Versionen

Version vom 12. Juli 2026, 10:50 Uhr

Inhaltsverzeichnis

Hausarbeit: Sensorfusion zur 2D-Navigation eines mobilen Roboters mit KF, EKF und UKF

Notwendige Hardware

Notwendige Software

Vorbereitung

Demos

Aufgabe 1: Systemaufbau und Datenerfassung

Aufgabe 2: Analyse der Sensorsignale

Aufgabe 3: Bewegungsmodell des Roboters

Aufgabe 4: Navigation ohne Filter

Aufgabe 5: Kalman-Filter (KF)

Aufgabe 6: Extended Kalman-Filter (EKF)

Aufgabe 7: Unscented Kalman-Filter (UKF)

Aufgabe 8: Experimentelle Untersuchung

Aufgabe 9: Diskussion und Bewertung

Abgabe

Abgabeordner

Bewertung

Tutorial

Navigationsmenü

@@ Zeile 20: / Zeile 20: @@
 Der Autonome Mobile Roboter (AMR, AlphaBot) soll wie im Video gezeigt möglichst exakt die Ränder eines Quadrats abfahren.
 {{#ev:youtube|https://www.youtube.com/watch?v=PWdxnERpynU | 720 | | Video: Mobile Robot Localisation  |frame}}
+ URL: https://www.youtube.com/watch?v=PWdxnERpynU
 Im Rahmen dieser Hausarbeit soll eine Sensorfusionslösung zur Navigation eines mobilen Roboters entwickelt und untersucht werden.

BSE Moderne Tracking Systeme (SoSe 2026): Unterschied zwischen den Versionen

Version vom 12. Juli 2026, 10:50 Uhr

Hausarbeit: Sensorfusion zur 2D-Navigation eines mobilen Roboters mit KF, EKF und UKF

Notwendige Hardware

Notwendige Software

Vorbereitung

Demos

Aufgabe 1: Systemaufbau und Datenerfassung

Aufgabe 2: Analyse der Sensorsignale

Aufgabe 3: Bewegungsmodell des Roboters

Aufgabe 4: Navigation ohne Filter

Aufgabe 5: Kalman-Filter (KF)

Aufgabe 6: Extended Kalman-Filter (EKF)

Aufgabe 7: Unscented Kalman-Filter (UKF)

Aufgabe 8: Experimentelle Untersuchung

Aufgabe 9: Diskussion und Bewertung

Abgabe

Abgabeordner

Bewertung

Tutorial

Navigationsmenü

Suche