AEP - Einparkalgorithmus

Autoren: Martin Theine und Patrick Schumann
Stand: 15.02.2021

Einleitung

Das Team „AEP - Einparkalgorithmus“ beschäftigt sich mit dem Programmablauf und der Implementierung des autonomen Einparkvorganges unter Verwendung der vorhandenen Einparksensorik. Dazu zählt zum einen das Detektieren einer Parklücke, welche eine außreichende Länge für das vorhandene Carolo-Cup Fahrzeug aufweisen muss und zum anderen das Einparkmanöver selbst. Dazu wird zunächst auf Basis vorliegender Fachliteratur ein Grundkonzept erarbeitet und dazugehörige Berechnungen durchgeführt. Nach erfolgreicher Umsetzung dieses Konzepts wird der Algorithmus erweitert und optimiert, um auf verschiedene realitätsnahe Szenarien reagieren zu können (z.B. kein Hindernis in der Parkbucht). Daraufhin wird ein Testkonzept entwickelt, um die Funktion aller implementierten Zustände überprüfen zu können. Abschließend werden auf Basis dieses Konzepts Unittests und ein Integrationstest durchgeführt, um die korrekte Funktion des entwickelten Einparkalgorithmus zu verifizieren.

Anforderungen

Durch das Lastenheft des Projekts "Autonomes Fahrzeug" werden nachfolgende Anforderungen an das autonome Einparken und somit an den umzusetzenden Einparkalgorithmus gestellt:

Lastenheft im SVN: https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Anforderungsmanagement/Lastenheft/Lastenheft_Autonomes_Fahrzeug.pdf

Abb. 1: REQ - Paralleles Einparken	Abb. 2: REQ - Start des Einparkmanövers
Abb. 3: REQ - Durchführen des Einparkmanövers	Abb. 4: REQ - Erfolgreiches Einparkmanöver

Pflichten / Ziele

Aus den genannten Anforderungen (s.o.) lassen sich nachfolgende Pflichten zu den Meilensteinen 1,2,3 und 4 ableiten.

Pflichtenheft im SVN: https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Anforderungsmanagement/Pflichtenheft/Pflichtenheft.xlsx

Während des Sommersemesters 2020 wurden die nachfolgenden Pflichten und Ziele umgesetzt (Meilenstein 1 und 2). Hierbei lag der Schwerpunkt auf der Implementierung des Einparkalgorithmus im Offline-Modell sowie auf der erfolgreichen Simulation des Einparkmanövers.

Abb. 5: Pflichten Team AEP - Einparkalgorithmus SoSe2020

Während des Wintersemseters 2020/21 sollte der Einparkalgorithmus auf das Fahrzeug integriert werden (Online-Modell). Auf Grund der Tatsache, dass zu Beginn des Semesters kein funktionsfähiges Fahrzeug zur Verfügung stand, wurde der Fokus auf die Fehleranalyse und Instandsetzung des Carolo-Cup-Fahrzeugs gelegt. Die nachfolgenden Pflichten und Ziele repräsentieren somit die Arbeiten am Carolo-Cup-Fahrzeug im Wintersemseter 2020/21 zu Meilenstein 3 und 4:

Abb. 6: Pflichten Team AEP - Einparkalgorithmus WiSe2021

Einige Pflichten mussten aufgrund der nicht gegebenen autonomen Fahrfähigkeit und den eingeschränkten Möglichkeiten der Arbeit am Fahrzeug (bedingt durch die Covid-19-Pandemie) zum Ende des Wintersemesters 2020/21 zurückgestellt werden.

Hinweis: Ziele und Pflichten an das jeweilige Semester anpassen. Ziele und Pflichten des voherigen Jahrgangs entfernen!

Grundkonzept

Konzept AEP - Einparkalgorithmus

Dieses Kapitel befasst sich mit dem Grundkonzept des AEP - Einparkalgorithmus. Das Konzept beruht auf zwei verschiedenen Ansätzen zum autonomen Einparken aus der Literatur (siehe Quelle: [1], [2]) und stellt eine Kombination dieser dar. Zunächst wird davon ausgegangen, dass das Fahrzeug eine Lücke findet, die etwas größer als die mindestens benötigte Parklücke ist. Diese wird durch ein vorderes und ein hinteres Hindernis begrenzt.

Sequenz 1

Das Carlolo-Cup-Fahrzeug fährt zunächst parallel zu den Parkbuchten. Wurde eine passende Parklücke identifiziert, fährt das CCF so lange weiter, bis sich das Fahrzeugheck auf Höhe Heck des parkenden Autos befindet, hinter welchem eingeparkt werden soll. Dadurch wird beim Zurücksetzen so eng wie möglich um dieses vordere Hindernis herumgefahren, ohne dieses zu berühren.

Sequenz 2

Daraufhin soll das Fahrzeug rückwärts eine Rechtskurve fahren, bis dieses im zuvor berechneten Umschlagwinkel zur Fahrbahn steht.

Sequenz 3

Anschließend behält das Fahrzeug diesen Winkel zur Fahrbahn bei und fährt eine Korrekturstrecke gerade rückwärts, um so “tief” wie möglich in die Parklücke hineinzufahren.

Sequenz 4

Nun soll das Fahrzeug rückwärts eine Linkskurve fahren, bis es mit der hinteren linken Ecke auf einen definierten Abstand zum dahinterliegenden Auto herangefahren ist.

Sequenz 5

Abschließend werden zwei Korrekturzüge gefahren. Zunächst absolviert das Fahrzeug eine Rechtskurve vorwärts, bis es parallel zur Fahrbahn steht.

Sequenz 6

Zuletzt fährt es gerade rückwärts, bis es mittig zwischen beiden parkenden Autos steht.

Berechnungen

Zunächst werden anhand der vorliegenden Literatur (siehe Quelle: [1], [2]) Berechnungen im Vorfeld durchgeführt, die fest von den Fahrzeugparametern abhängen. Die für die Berechnungen erforderlichen Parameter werden in den nachfolgenden Parameterdateien deklariert und definiert.

• param_AEP.m
• param_CAR.m

Parameter für Berechnungen

Beschreibung:	Bezeichnung in Matlab / Simulink:	Variablen:	Wert:
Fahrzeugbreite	PAR_CAR_Fahrzeugbreite_f64	$w$	0,200m
Fahrzeuglänge	PAR_CAR_Fahrzeuglaenge_f64	$l$	0,430m
Radstand	PAR_CAR_Radstand_f64	$l_R$	0,265m
Max. Lenkwinkel	PAR_CAR_max_Lenkeinschlag_alpha_deg_f64	$\alpha$	23°
Abstand Hinterachse - Front	PAR_CAR_Radstand_f64 + PAR_CAR_Mitte_Vorderachse_Vorne_f64	$l_F$	0,330m
Abstand Hinterachse - Heck	PAR_CAR_Mitte_Hinterachse_Ende_f64	$l_H$	0,100m
Wendekreisradius	PAR_CAR_Wendekreisradius_f64	$R$	siehe Berechnung
Benötigte Parklückenlänge	PAR_AEP_Parkluecke_Soll_f64	$l_P$	siehe Berechnung
Umlenkwinkel	PAR_AEP_Umschlagwinkel_f64	$\beta$	siehe Berechnung
Korrekturfaktor Rückwärtsfahrt	PAR_AEP_Korrekturfaktor_Rueck_f64	$f_{KR}$	0,2372 (empirisch ermittelt)
Maximaler IR-Sensorwert	PAR_AEP_IR_max_f64	$l_{IRmax.}$	0,300m

Wendekreisradius

$R = \frac{l_r}{\tan(\alpha)} = \frac{0,265m}{\tan(23^\circ)} = 0,624m$

Benötigte Parklücke

$l_P = \sqrt[]{2\cdot R\cdot w + (l_F)^2} + l_H = \sqrt[]{2\cdot 0,624m\cdot 0,200m + (0,330m)^2} + 0,100m = 0,695m$

Umlenkwinkel

Der Umlenkwinkel beschreibt den Gierwinkel des Fahrzeugs, an dem der Lenkumschlag von rechts nach links erfolgen muss.

$\beta = \arccos(\frac{2\cdot R - w}{2\cdot R}) = \arccos(\frac{2\cdot 0,624m - 0,200m}{2\cdot 0,624m}) = 32,88^\circ$

Die nachfolgenden Berechnungen erfolgen in Abhängigkeit zur gemessenen Parklückenlänge und werden bei jedem Druchlauf des Einparkalgorithmus erneut durchgeführt. Die Ergebnisse werden in lokalen Variablen des Stateflow-Modells gespeichert und weiterverarbeitet.

Lokale Variablen für Berechnungen

Beschreibung:	Bezeichnung in Matlab / Simulink:	Variablen:	Wert:
Gemessene Parklückenlänge	AEP_Parkluecke_Ist_f64	$l_g$	siehe Berechnung
Endabstand Heck - Hindernis	AEP_Abstand_Hinten	$x_H$	siehe Berechnung
Korrekturstrecke Rückwärtsfahrt	AEP_Korrekturstrecke_Rueck_f64	$x_{KR}$	siehe Berechnung
Differenz Endabstand maximale IR-Sensorreichweite	AEP_Abstand_Differenz_f64	$\Delta x_{DE}$	siehe Berechnung

Endabstand Heck - Hindernis

$x_H = \frac{l_g - l}{2}$

Korrekturstrecke Rückwärtsfahrt

$x_{KR} = l_g\cdot f_{KR}$

Differenz Endabstand maximale IR-Sensorreichweite

$\Delta x_{DE} = |x_H - l_{IRmax.} |$

Zustandsautomat im Offline-/Online-Modell

I/Os des Zustandsautomaten AEP

Eingangsseitig stehen dem Zustandsautomaten für den Einparkalgorithmus folgende Daten zur Verfügung:

Beschreibung:	Bezeichnung in Matlab / Simulink:
zurückgelegte Strecke in Metern	SenVx_sx_K_f64
Gierwinkel des Gierratensensors in rad	SenGier_psi_filt_K_f64
gemessener Abstand des Infrarotsensors rechts vorne in Metern	SenAbs_xVR_K_f64
gemessener Abstand des Infrarotsensors rechts hinten in Metern	SenAbs_xHR_K_f64
gemessener Abstand des Infrarotsensors hinten rechts in Metern	SenAbs_yHR_K_f64
gemessener Abstand des Infrarotsensors hinten links in Metern	SenAbs_yHL_K_f64
Einparkmodus	PAR_AEP_Measure_or_Park_f64
Länge der Parkbucht	PAR_AEP_Laenge_Parkbucht_f64
Abstand zur Parkbucht	PAR_AEP_Abstand_Startkoordinate_Parkbucht_f64
Geschwindigkeitsvorgabe Lückensuche	PAR_AEP_Suchgeschwindigkeit_f64
Geschwindigkeitsvorgabe Lückenvermessung	PAR_AEP_Vermessgeschwindigkeit_f64
Geschwindigkeitsvorgabe Einparkvorgang	PAR_AEP_Einparkgeschwindigkeit_f64
Geschwindigkeitsvorgabe zum Anhalten	PAR_AEP_Stoppgeschwindigkeit_f64
Lenkwinkelvorgabe Rechtskurve	PAR_AEP_Lenkung_MAX_Rechts_f64
Lenkwinkelvorgabe Geradeausfahrt	PAR_AEP_Lenkung_Mittelstellung_f64
Lenkwinkelvorgabe Linkskurve	PAR_AEP_Lenkung_MAX_Links_f64
Minimaler IR-Sensorwert	PAR_AEP_IR_MIN_f64
Maximaler IR-Sensorwert	PAR_AEP_IR_MAX_f64
Umlenkwinkel	PAR_AEP_Umschlagwinkel_f64
Benötigte Parklückenlänge	PAR_AEP_Parkluecke_Soll_f64
Korrekturstrecke Vorwärtsfahrt	PAR_AEP_Korrekturstrecke_Vor_f64
Korrekturfaktor Rückwärtsfahrt	PAR_AEP_Korrekturfaktor_Rueck_f64
maximale Korrekturstrecke Rückwärtsfahrt	PAR_AEP_Korrekturstrecke_Rueck_MAX_f64
Benötigte Parklückenlänge, um bei Rückwärtsfahrt parallel zur Fahrbahn zu gelangen	PAR_AEP_Parkluecke_Rueck_Parallel_MIN_f64
Streckenbegrenzung Rückwärtsfahrt ohne hinteres Hindernis	PAR_AEP_Streckenbegrenzung_Rueck_f64
Gierwinkel, um parallel zur Fahrbahn zu gelangen	PAR_AEP_Schlussparkwinkel_f64
Fahrzeuglänge	PAR_CAR_Fahrzeuglaenge_f64
Abstand Hinterachse - Heck	PAR_CAR_Mitte_Hinterachse_Ende_f64

Ausgangsseitig werden durch den Zustandsautomaten folgende Daten auf den CCF_Bus gelegt:

Beschreibung:	Bezeichnung in Matlab / Simulink:
Sollvorgabe Lenkwinkel	AEP_LwSoll_f64
Sollvorgabe Geschwindigkeit	AEP_vx_K_soll_f64
Aktiver Zustand des Zustandsautomaten	AEP_AKT_Zustand
Anforderung des Blinkers rechts	Blinker_Rechts_Manual_Enable_bit
Anforderung des Warnblinkers	Warnblinker_Manual_Enable_bit
Ein- und Ausschalten der geregelten Geradeausfahrt	Famo_Modi_Schalter_Lw_int
Ein- und Ausschalten der Geschwindigkeitsvorgabe AEP	Famo_Modi_Schalter_Vx_int

Implementierung des Einparkalgorithmus

Nach Umsetzung des Grundkonzepts wurde ein Optimierungskonzept erarbeitet, welches das Einparken auch mit verschiedenen Positionierungen der Hindernisse ermöglichen soll. Die Programmoptimierungen wurden im Stateflow-Modell (Simulink-Bibliothek: "bib_AutonomesEinparken.mdl", Stateflow-Model: "State Machine AEP1") auf Basis dieses Konzepts umgesetzt. Der nachfolgende Abschnitt beschreibt die Implementierung dieses Stateflow-Modells und soll unter Zuhilfenahme der Programmablaufplänen (siehe nachfolgende Abbildungen) eine schnellere Einarbeitung in den umgesetzten Einparkalgorithmus ermöglichen.

Programmablaufplan - Einparkalgorithmus LueckeSuchen

Superstate „LueckeSuchen“ (AEP_AKT_Zustand = 1):

Entspricht dem Initialzustand des Zustandsautomaten.

Substate „FahreVorBisParkbucht“ (AEP_AKT_Zustand = 1.1):

Das Fahrzeug fährt nach Programmstart zunächst vorwärts und erfasst dabei die gefahrene Strecke ab dem Startpunkt (X: -9.58). Währenddessen wird laufend überprüft, ob die zurückgelegte Strecke dem Abstand zwischen Fahrzeugstartpunkt und Beginn der Parkbucht plus dem Abstand zwischen Fahrzeugfront und Vorderachse entspricht. Ist dies der Fall, so befindet sich das Fahrzeug mit dem vorderen rechten IR-Sensor am Beginn der Parkbucht und kann mit dem Ausmessen der Parklücken beginnen.

Superstate „ParkbuchtVermessen“ (AEP_AKT_Zustand = 2):

Parallel zur Suche einer passenden Lücke misst das Fahrzeug die gefahrene Strecke ab Beginn der Parkbucht. Entspricht die zurückgelegte Strecke der Länge der Parkbucht, bevor eine passende Lücke gefunden wurde, so wird das Fahrzeug angehalten. Dieser Zustand ist ein Substate des Superstates „LueckeSuchen“ und gleichzeitig Superstate für die nachfolgenden zwei Substates.

Substate „ParklueckeSuchen“ (AEP_AKT_Zustand = 2.1):

Das Fahrzeug fährt mit „Suchgeschwindigkeit“ vorwärts, bis der Beginn einer Parklücke gefunden wurde (IR-Sensor vorne rechts detektiert kein Hindernis mehr). In diesem Fall wird in den Substate „ParklueckeAusmessen“ gewechselt.

Substate „ParklueckeAusmessen“ (AEP_AKT_Zustand = 2.2):

Das Fahrzeug fährt mit „Vermessgeschwindigkeit“ vorwärts und misst die gefahrene Strecke ab Beginn der Parklücke. Wird das Ende einer Parklücke gefunden (IR-Sensor vorne rechts detektiert ein Hindernis), so wird geprüft, ob die zurückgelegte Strecke größer oder gleich der im Vorfeld berechneten benötigten Parklückengröße ist. Wenn die Lücke kleiner ist, wird zurück in den Substate „ParklueckeSuchen“ gewechselt und erneut nach dem Beginn einer Lücke gesucht. Ist die Lücke groß genug, so bleibt das Fahrzeug stehen (Wechsel in den State „Ende“) oder beginnt durch Wechsel in den Superstate „Parken“ mit dem Einparkvorgang (je nach Konfiguration in der start.m-Datei: Parameter „Measure_or_Park“). Alternativ kann es vorkommen, dass kein Hindernis in der Parkbucht steht. In diesem Fall soll das Fahrzeug trotzdem einparken, sobald die zurückgelegte Strecke mindestens der Summe aus benötigter Parklückengröße und der doppelten Fahrzeuglänge entspricht. Trifft diese Bedingung zu, so wird das Bit „kein_Hindernis“ gesetzt und dadurch direkt in den Substate „FahreRechtskurve“ gewechselt, da nun kein vorderes Hindernis existiert, an dem sich das Fahrzeug weiterhin orientieren kann. Zuvor wird ebenfalls geprüft, ob das Fahrzeug stehenbleiben oder einparken soll (Parameter „Measure_or_Park“).

Programmablaufplan - Einparkalgorithmus Parken

Superstate „Parken“ (AEP_AKT_Zustand = 3):

Entspricht dem Initialzustand für den Einparkvorgang (wenn Bit „kein_Hindernis“ nicht gesetzt).

Substate „FahreVorBisHinterachseAufHoeheHeckHindernis“ (AEP_AKT_Zustand = 3.1):

Da eine passende Lücke gefunden wurde, wird zunächst das „Blinker_Rechts_Manual_Enable_Bit“ gesetzt. Das Fahrzeug fährt weiter mit „Vermessgeschwindigkeit“ vorwärts, bis sich die Hinterachse auf Höhe Heck des vorderen Hindernisses befindet (IR-Sensor hinten rechts detektiert ein Hindernis). Daraufhin wird in den Substate „FahreVorBisStartposition“ gewechselt.

Substate „FahreVorBisStartposition“ (AEP_AKT_Zustand = 3.2):

Das Fahrzeug fährt weiterhin mit „Vermessgeschwindigkeit“ vorwärts und erfasst dabei die gefahrene Strecke. Ist die zurückgelegte Strecke größer oder gleich dem Abstand der Hinterachse bis zum Fahrzeugende plus der definierten „Korrekturstrecke_Vor“, so ist das Fahrzeug maximal nach vorne gefahren und es wird in den Substate „FahreRechtskurve“ gewechselt.

Substate „FahreRechtskurve“ (AEP_AKT_Zustand = 3.3):

Entspricht dem Initialzustand für den Einparkvorgang (wenn Bit „kein_Hindernis“ gesetzt).

Zunächst wird die geregelte Geradeausfahrt ausgeschaltet (Famo_Modi_Schalter_Lw_int = 2). Die Lenkung des Fahrzeugs wird maximal nach rechts eingeschlagen. Das Fahrzeug fährt nun so lange mit „Einparkgeschwindigkeit“ rückwärts eine Rechtskurve, bis der gemessene Gierwinkel dem zuvor berechneten Umschlagwinkel entspricht.

Substate „BerechnungenMitParklueckeIst“ (AEP_AKT_Zustand = 3.4):

An dieser Stelle werden nachfolgend benötigte Größen in Abhängigkeit von der gemessenen Parklückenlänge berechnet (siehe Abschnitt „Berechnungen“). Wenn die berechnete „Korrekturstrecke_Rueck“ größer als der festgelegte Maximalwert ist, so wird diese auf den Maximalwert gesetzt. Anschließend wird in den Substate „FahreKorrekturstreckeRueck“ gewechselt.

Substate „FahreKorrekturstreckeRueck“ (AEP_AKT_Zustand = 3.5):

Die Lenkung des Fahrzeugs wird in Mittelstellung gebracht und erneut die zurückgelegte Strecke erfasst. Das Fahrzeug fährt im zuvor erreichten Winkel zur Fahrbahn gerade rückwärts, bis die berechnete „Korrekturstrecke_Rueck“ zurückgelegt wurde, um maximal tief in die Parklücke hineinzufahren. Daraufhin wird in den Substate „FahreLinkskurve“ gewechselt.

Substate „FahreLinkskurve“ (AEP_AKT_Zustand = 3.6):

Die Lenkung wird maximal nach links eingeschlagen. Das Fahrzeug fährt mit aktiver Streckenerfassung und gleichbleibender Geschwindigkeit rückwärts eine Linkskurve, bis …

(1) … der linke hintere Infrarotsensor einen festgelegten Mindestabstand zum hinteren Hindernis misst. Dies ist der Fall, wenn ein hinteres Hindernis vorhanden ist.

(2) … die zurückgelegte Strecke der festgelegten Streckenbegrenzung entspricht. Diese Abbruchbedingung wird nur geprüft, wenn sich hinter dem Fahrzeug kein Hindernis befindet (beide hinteren IR-Sensoren den Maximalabstand messen) und die Parklücke zu klein ist, um bereits beim Rückwärtsfahren parallel zur Fahrbahn zu gelangen. Das ist der Fall, wenn die erstmögliche Parklücke in der Parkbucht nur durch ein vorderes Hindernis begrenzt wird und groß genug zum Einparken jedoch kleiner als 95 cm ist.

(3) … bis der gemessene Gierwinkel dem Schlussparkwinkel entspricht (Fahrzeug parallel zur Fahrbahn). Dies ist der Fall, wenn die Parklücke groß genug (> 95 cm) ist, um bereits beim Rückwärtsfahren parallel zur Fahrbahn zu gelangen.

Im Fall (1) oder (2) steht das Fahrzeug noch nicht parallel zur Fahrbahn und muss daher einen Korrekturzug nach vorne fahren, um dies zu erreichen. Es wird in den Substate „FahreKorrekturzugVorFall1“ gewechselt. Im Fall (3) steht das Fahrzeug bereits parallel zur Fahrbahn. Daher muss kein Korrekturzug nach vorne gefahren werden, wie in den Fällen (1) und (2). Es wird direkt in die „Junction“ gewechselt.

Substate „FahreKorrekturzugVorFall1“ (AEP_AKT_Zustand = 3.7):

Die Lenkung des Fahrzeugs wird maximal nach rechts eingeschlagen. Das Fahrzeug fährt nun so lange mit „Vermessgeschwindigkeit“ vorwärts eine Rechtskurve, bis der gemessene Gierwinkel dem festgelegten Schlussparkwinkel entspricht (Fahrzeug parallel zur Fahrbahn).

Junction:

An dieser Stelle wird mit Hilfe einer Junction (siehe Stateflow-Modell) geprüft, ob …

(1) … das Bit „kein_Hindernis“ zuvor gesetzt worden ist. In diesem Fall wird das Fahrzeug gestoppt, da keine Hindernisse vorhanden sind, an denen sich nachfolgend orientiert werden kann (Wechsel in State „Ende“).

(2) … beide hinteren IR-Sensoren den Maximalabstand messen, also hinten kein Hindernis vorhanden ist. Auch in diesem Fall wird das Fahrzeug gestoppt, indem in den State „Ende“ gewechselt wird.

(3) … einer der beiden hinteren IR-Sensoren einen größeren Abstand misst als den zuvor berechneten Endabstand. Dies ist der Fall, wenn hinten ein Hindernis vorhanden ist und das Fahrzeug zu weit vorne in der Parklücke steht. Es ist also notwendig einen Korrekturzug rückwärts zu fahren, um mittig zwischen vorderem und hinterem Hindernis zu stehen. Dazu wird in den Substate „FahreKorrekturzugRueck“ gewechselt.

(4) … einer der beiden hinteren IR-Sensoren einen kleineren Abstand misst als den zuvor berechneten Endabstand. Dies ist der Fall, wenn hinten ein Hindernis vorhanden ist und das Fahrzeug zu weit hinten in der Parklücke steht. Es ist also notwendig einen Korrekturzug vorwärts zu fahren, um mittig zwischen vorderem und hinterem Hindernis zu stehen. Nun wird geprüft, ob der berechnete Endabstand größer als die maximale Sensorreichweite ist. In diesem Fall wird der Endabstand auf den Maximalwert und das „Weiterfahrt_Enable_bit“ gesetzt. Daraufhin wird in den Substate „FahreKorrekturzugVorFall2“ gewechselt.

Substate „FahreKorrekturzugRueck“ (AEP_AKT_Zustand = 3.81):

Die Lenkung des Fahrzeugs wird in Mittelstellung gebracht. Das Fahrzeug fährt mit „Einparkgeschwindigkeit“ gerade rückwärts, bis der zuvor berechnete Endabstand zum hinteren Hindernis erreicht ist. Daraufhin wird das Fahrzeug durch einen Wechsel in den State „Ende“ gestoppt.

Substate „FahreKorrekturzugVorFall2“ (AEP_AKT_Zustand = 3.82):

Die Lenkung des Fahrzeugs wird in Mittelstellung gebracht. Das Fahrzeug fährt mit „Einparkgeschwindigkeit“ gerade vorwärts, bis der zuvor berechnete Endabstand zum hinteren Hindernis erreicht ist. Daraufhin wird geprüft, ob das „Weiterfahrt_Enable_bit“ gesetzt wurde. Falls nicht, wird das Fahrzeug durch einen Wechsel in den State „Ende“ gestoppt. Falls doch wird in den Substate „FahreWeiterBisMitte“ gewechselt.

Substate „FahreWeiterBisMitte“ (AEP_AKT_Zustand = 3.9):

Dieser Substate wird nur aktiv, wenn das Weiterfahrt_Enable_bit gesetzt wurde. Dies ist nur der Fall, wenn der berechnete Endabstand zum hinteren Hindernis die Sensorreichweite übersteigt. Somit kann die hintere IR-Sensorik nicht vollständig genutzt werden, um mittig zwischen beide Hindernisse zu fahren. Daher wird zusätzlich die Streckenerfassung genutzt, um die restliche Strecke vorwärts zu fahren, die über die Reichweite der Sensoren hinausgeht. Diese Differenz wird im Vorfeld im Substate „BerechnungenMitParklueckeIst“ ermittelt. Das Fahrzeug fährt also weiter vorwärts, bis die zurückgelegte Strecke größer oder gleich der berechneten Differenz ist. Daraufhin wird in den State „Ende“ gewechselt und das Fahrzeug gestoppt.

State „Ende“ (AEP_AKT_Zustand = 4):

Das „Warnblinker_Manual_Enable_bit“ wird gesetzt, um anzuzeigen, dass der Parkvorgang beendet wurde und das Fahrzeug wird angehalten.

Unit- und Integrationstest

Simulinkbibliothek - Autonomes EInparken

Mit Hilfe der Unit- und Integrationstests soll die Funktion des AEP - Einparkalgorithmus getestet und überpfrüft werden. Nach erfolgreichem Bestehen der Tests kann so gewährleistet werden, dass die Anforderungen aus dem Lastenheft erfüllt sind. Nachfolgend wird das Vorgehen beim Unit- und Integrationstest stichpunktartig erläutert. Eine Vorlage und die genaue Beschreibung zur Durchführung der Tests ist im SVN hinterlegt.

Vorlage im SVN: https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Teams/AEP/Dokumentation

Die neben stehende Abbildung zeigt die Simulink-Bibliothek "AEP-Autonomes Einparken" mit den aus dieser hervorgehenden Output-Variablen. Die rot eingerahmten Variablen werden vorwiegend zur Auswertung der Unittests herangezogen. Zusätzlich müssen während der Simulation weitere Merkmale beobachtet und dokumentiert werden.

Vorgehen Unittest

1. Öffnen der Datei "AEP_Unittest_und_Integrationstest.docx" in Word
2. Vorlage zu den Unittests (siehe „AEP_Vorlage_Unittest_und_Integrationstest.docx“ Kapitel 2) ausfüllen. Wichtig: Anmerkungen zur Simulation beachten!
3. Öffnen der Datei "start.m" in Matlab R2019b
4. Folgende Parameter setzten
   • Auswahl des Simulationstyps: 1 (Simulation offline)
   • Laden verschiedener Fahrbahnformen: 0 (Rundkurs ohne Kreuzung)
   • Auswahl des Simulationsmodus: 2 oder 3 (je nach durchzuführendem Unittest)
   • Im Fall AEP: Positionswahl der Objekte 0…12 (je nach durchzuführendem Unittest)
5. Unter Registerkarte "Editor" in Matlab auf "RUN" klicken, um Matlab-Skript auszuführen --> Simulink-Modell öffnet sich
6. Erforderliche Variablen (siehe "AEP_Vorlage_Unittest_und_Integrationstest.docx" Kapitel 2) im Watch-Window anzeigen und zur Auswertung des Tests nutzen
7. Im Subsystem "AEP-Autonomes Einparken" mit klicken von „Run“ unter der Registerkarte "Simulation" die Simulation starten
8. Testergebnisse in "AEP_Vorlage_Unittest_und_Integrationstest.docx" Kapitel 2 dokumentieren und mit nachfolgender Dateibezeichnung in SVN hinterlegen . Gegebenenfalls zusätzlich Screenshots und Videos der Simulation in SVN hinterlegen.
   • Ablage in SVN: https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Testdokumente/Unittests
   • Dateibezeichnung Testergebnisse (PDF-Datei): „CCF_AEP_Unittest_Datum_NameTestperson.pdf“
   • Dateibezeichnung Screenshots (PNG-Datei): „CCF_AEP_Unittest_IDxxx_Datum_NameTestperson.png“

Testfälle Unittest

(Stand 19.06.2020: Test in der Simulationsumgebeung)

Unittest-ID:	Beschreibung:	Testergebnis:	Stand:
001	Test der Funktionen Streckenerfassung und Parklückenvermessung	i.O.	18.06.2020
002	Einzelnes Hindernis am Anfang der Parkbucht	i.O.	18.06.2020
003	Kein Hindernis in der Parkbucht	i.O.	18.06.2020
004	Keine ausreichend große Parklücke	i.O.	18.06.2020
005	Ein einzelnes Hindernis im Abstand von < 0,95m vom Anfang der Parkbucht	i.O.	18.06.2020
006	Größte Parklücke an beliebiger Position und prozentuale Erhöhung der Parklückenlänge	i.O.	19.06.2020
007	Größte Parklücke an beliebiger Position, Parklückenlänge minimal und prozentuale Erhöhung der Hindernisbreite	i.O.	19.06.2020

Vorgehen Integrationstest

Der Integrationstest wird im Anschluss an die Unittests durchgeführt und bildet die abschließende Funktionskontrolle des AEP - Einparkalgorithmus. Hierzu wird der während der Entwicklungs- und Optimierungsphase im SVN angelegte "Branch" mit dem "Trunk" gemerget und anschließend die Unittests "Test der Funktionen Streckenerfassung und Parklückenvermessung" und "Größte Parklücke an beliebiger Position und prozentuale Erhöhung der Parklückenlänge" wiederholt. Die Ergebnisse der Unittets vor und nach dem Mergen werden miteinander verglichen. Sind die Ergebnisse der Tests identisch, so gilt der Integrationstest als bestanden.

• Ablage in SVN: https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Testdokumente/Integrationstests
• Dateibezeichnung Testergebnisse (PDF-Datei): „CCF_AEP_Integrationstest_Datum_NameTestperson.pdf“
• Dateibezeichnung Screenshots (PNG-Datei): „CCF_AEP_Integrationstest_IDxxx_Datum_NameTestperson.png“

Testfälle Integrationstest

(Stand 15.07.2020: Test in der Simulationsumgebeung)

Unittest-ID:	Beschreibung:	Testergebnis:	Stand:
001	Test der Funktionen Streckenerfassung und Parklückenvermessung	i.O.	15.07.2020
006	Größte Parklücke an beliebiger Position und prozentuale Erhöhung der Parklückenlänge	i.O.	15.07.2020

Zusammenfassung

Ergebnisse MS1 und MS2:

Das erarbeitete Konzept des Einparkalgorithmus funktioniert in Simulation für alle Testfälle einwandfrei. Videos einzelner Testfälle, welche die Funktion neben den Messprotokollen und Screenshots verifizieren, sind in folgendem Ordner abgelegt: //svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Teams/AEP/Bilder und Videos/Videos

Ergebnisse MS3 und MS4:

Auf dem Fahrzeug konnte der Einparkalgorithmus nicht getestet werden, da das Fahrzeug noch nicht autonom fahrfähig ist (siehe AEP - Autonomes Einparken -> 4. "Online-Modell"). Die durchgeführten Fehleranalysen (Fehlerprotokolle) und Arbeiten am Fahrzeug wurden in den folgenden Wiki-Artikeln dokumentiert:

• Analyse und Fehlersuche WS20/21
• AEP - Autonomes Einparken
• AuF - Antrieb und Fernbedienung

Offene Punkte

Stand: 15.02.2021

• Funktionstest der Vermessung der Parklücke mittels IR-Sensoren (Online-Modell)
• Ermitteln der realen Fahrzeugparameter (z.B. Wendekreis, Lenkwinkel, etc.)
• Anpassen des AEP-Einparkalgorithmus an reale Bedingungen (Fahrzeug und reale Parkbucht)
• Durchführen der Unit- und Integrationstest im Online-Modell (mit Carolo-Cup-Fahrzeug)

• Bitte beachten: Der Artikel Fahrzeugsoftware bildet alte Stände der Parameterdateien und Simulink-Modelle ab. Dieser muss im Bezug auf die AEP-Software aktualisiert werden.

Ausblick

• Nutzen des Kamera-Moduls und des LIDAR-Sensor zum Erfassen der Parkbucht und Ausmessen der Parklücke
• Optimierung der Fahrzeuggeometrie um größeren Lenkwinkel zu realisieren

Quellen / Weiterführende Literatur

[1] Hermann Norbert, Mathematik ist Überall. 4.Auflage
[2] Kochem Michael, Parkassistent

Literatur im SVN: https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Literatur

---

→ zurück zum Hauptartikel: SDE Praktikum Autonomes Fahren
→ zum Artikel Autonomes Einparken: AEP - Autonomes Einparken
→ zum Artikel Einparksensorik: AEP - Einparksensorik