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	Berechnung der Stellgröße muss anhand der Regelabweichung erfolgen.				Lukas Berkemeier
2	Die Stellgröße muss so auf die Motoransteuerung berechnet werden, dass die Regelung auf die Solllinie erfolgt.				Lukas Berkemeier
3	Das Regelverhalten muss auf gerader Strecke im Bereich +- 24 mm zur Solllinie Regeln
4	Das Regelverhalten muss in Kurven im Bereich +- 24 mm zur Solllinie Regeln

Fehlerbehebung

Um eine gute Regelung auf gerader Strecke wie in Kurven zu erhalten, sodass die Mittellinie im nächsten Schritt auf der kompletten Fahrbahn gemessen, berechnet und eingezeichnet werden kann, müssen die Regelparameter Kp und Kd noch angepasst werden.

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.