SDE WS25: BluetoothRegelung.ino

Abb. 1: Skizze der Mittellinienerfassung

Modul:	BluetoothRegelung.ino
Revision:	10877
Autor:	Lukas Berkemeier
Datum:	06.11.2025
System:	Arduino IDE
SVN-URL:	https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/_Semesterordner/WS2025/Sprint_1/c-files/BluetoothRegelung/BluetoothRegelung.ino

Einleitung/Funktion

Im Modul BluetoothRegelung.ino wird die Regelabweichung genutzt um die Stellgröße zu berechnen und die Alphabotmotoren zu regeln. Im Modul wird außerdem bereits die Bluetoothübertragung aus Arbeitspaket 1.4 Übertragung der Ist-Ablage via BT MATLAB→Arduino genutzt, mit der die Regelabweichung empfangen wird. Die Regelabweichung ist dabei die Distanz zur Solllinie in mm.

Funktionaler Systementwurf

Anforderungen

Die Anforderungen werden aus Arbeitspaket 1.5 Geregelte Fahrt anhand der Ist-Ablage entnommen.

Technischer Systementwurf

Der Systementwurf entspricht dem Modulentwurf aus Abbildung 2.

• 
  Abb. 2: BluetoothRegelung.ino

Komponentenspezifikation

Die Distanz zur Mittellinie wird durch die Messwerte der Tracking-Sensoren ermittelt.

1. Empfang der Regelabweichung über die Serielle Schnittstelle bzw. HC-05 Bluetoothmodul
2. Regelung anhand der Regelabweichung
3. Der P-Anteil entspricht der Regelabweichung
4. Zeitdifferenz dt zum letzten Durchlauf berechnen
5. D-Anteil berechnen: $(Regelabweichung-letzteRegelabweichung)/dt$
6. Stellgröße berechnen: $Kp*P+Kd*D$
7. Alphabotmotoren mit Stellgröße ansteuern

Programmierung

messeMittellinie.ino 

 /* Sensorbibliothek hinzufügen */
#include "AlphaBot.h"                   // Arduino Bibliothek für die Motoren einbinden    

AlphaBot  Alphabot = AlphaBot();        // Instanz des AlphaBot wird erzeugt

unsigned long LetzterZeitstempel_u32;   // Hilfsgröße: Zeitstempel des letzten Zyklus in ms
float LetzterError_s16 = 0;             // Hilfsgröße: e aus letztem Zyklus

static const int MAX_POWER_s16 = 80;    // Maximalleistung des Antriebs
static const float Kp = 0.07;            // Proportionalitätsfaktor
static const float Kd = 1.8;            // Differentieller Faktor

void setup()
{
  Serial.begin(9600);
  LetzterZeitstempel_u32=millis();
}

void loop()
{
  int8_t e;
  if(Serial.available())              // Regelabweichung empfangen wenn Daten vorhanden sind
  {
    e=Serial.read();
    Serial.println(e); // Regelabweichung in cm empfangen
    int regelabweichung = e * 100; // für Regelung auflösung ändern
    regelung(regelabweichung);
  }
  
}

void regelung(int regelabweichung)
{
  static unsigned long Zeit_u32;        // Aktueller Zeitstempel
  float P_s32;                     // P-Anteil des PD-Reglers
  float D_s32;                      // D-Anteil des PD-Reglers
  float Stellgroesse_s32;           // Stellgroesse zur Berechnung der Kurvenfahrt

  /* Regleranteile P berechnen */
  P_s32 = regelabweichung;                             // P-Anteil

  /* Regleranteile D berechnen */
  Zeit_u32 = millis();                                      // Aktuelle Zeitstempel in ms
  float dt_s32=(float)((Zeit_u32-LetzterZeitstempel_u32));  // Zykluszeit dt in ms, ca. 20 ms
  D_s32 = (float)(regelabweichung - LetzterError_s16)/dt_s32;             // D-Anteil  de/dt

  LetzterZeitstempel_u32=Zeit_u32;                          // Aktuelle Werte speichern
  LetzterError_s16 = regelabweichung;        

  /* Ergebnis des Reglers */
  Stellgroesse_s32 = Kp* P_s32 + Kd * D_s32;                // Stellgroesse berechnen
  /* Alphabot  regeln */
  float MotorPowerLinks = -MAX_POWER_s16 + Stellgroesse_s32/2;  // Motorleistung anpassen
  float MotorPowerRechts = -MAX_POWER_s16 - Stellgroesse_s32/2;
  Alphabot.MotorRun(MotorPowerLinks,  MotorPowerRechts);
  Serial.print("Nach ansteuerung: ");
  Serial.println(regelabweichung);
}

Modultest

Da es sich bei dieser Entwicklung um die eines einzelnen Moduls handelt, schließt der Modultest mit dem Testbericht die Entwicklung ab (vgl. Tabelle 2). Zum Testen des Moduls wird das Modul BluetoothRegelung.ino und trackeSendeReglerTest.m genutzt. Das Arduino-Programm beinhaltet den Empfang der Daten und die Stellgrößenberechnung. Mit dem Skript trackeSendeReglerTest.m wird die Distanz des Prismas zur y-Achse der Topcon Station in Millimeter berechnet und mit Bluetooth an den Alphabot gesendet.

Systematisches Vorgehen beim Testen:

• Bluetooth Dongle in PC einstecken
• Arduino des Alphabot mit USB-Kabel an einen PC anschließen
• Arduino IDE starten
• BluetoothRegelung.ino öffnen
• COM-Port des Alphabot auswählen
• Programm auf den Arduino des Alphabot hochladen (Das HC-05 Modul muss dazu abgezogen werden)
• Seriellen Monitor starten

• Topcon Station aufbauen
• TopCon gemäß Artikel in Betrieb nehmen.
• trackeSendeReglerTest.m öffnen und starten

Tabelle 1: Testbericht für den Modultest

ID	Testfallbeschreibung	Eingang	Erwartetes Ergebnis	Testergebnis	Testperson	Datum
1					Lukas Berkemeier
2					Lukas Berkemeier
3					Lukas Berkemeier
4					Lukas Berkemeier

Fehlerbehebung

Abb. 5: messeMittellinie.ino mit gesamter Sensorspannweite

Nach der ersten Modulplanung sollte die Spannweite wie in Abbildung 5 von beiden äußeren Sensoren zentral über der Mitte der Mittellinie, mit 65 mm Spannweite genutzt werden. Mit der Funktion map() wurden den Positionswerten 350-3650 die Entfernungen 33 bis -33 mm zugewiesen. Bei dieser Spannweite kam es im Bereich der äußeren Sensoren immer zu Messungenauigkeiten. Zur Fehlerbehebung wurde die Spannweite auf 48 mm (+-24 mm) verringert und den Positionswerten 800-3200 die Entfernungen 24 bis -24 mm zugewiesen. Im Modultest wurden die Änderungen als passend bewiesen.
Eine weitere Fehlerursache ist die Kalibrierung bzw. die Beleuchtung der Sensoren. Je nach Beleuchtung können verschiedene Werte gemessen werden. Ein möglicher Schritt zur Fehlerbehebung wäre das Anbringen einer Beleuchtung für die Sensoren um die Beleuchtung möglichst konstant zu halten.

Zusammenfassung

Das Modul messeMittellinie.ino wurde systematisch entworfen, getestet und dokumentiert. Sämtliche Anforderungen aus dem Arbeitspaket SDE WS25: AP 1.6 Messung der Mittellinie wurden erfüllt. Die Funktion kann eingesetzt werden, um die Distanz der Mitte der Mittellinie zum zentralen Sensor des Alphabot zu berechnen. In Zukunft kann das Modul verwendet werden um die Positionen der realen Mittellinienstreifen der Fahrbahn zu bestimmen.