AEP - Einparkalgorithmus: Unterschied zwischen den Versionen

Version vom 5. Februar 2021, 14:16 Uhr

Autoren: Martin Theine und Patrick Schumann

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 (Abb. 1 - Abb. 4) lassen sich nachfolgende Pflichten ableiten.

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

Pflichten Team AEP - Einparkalgorithmus SoSe2020

Pflichten Team AEP - Einparkalgorithmus WiSe2021

Grundkonzept

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

$\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.} |$

Umsetzung 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: "AEP - Autonomes Einparken", 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 (Abb. 7 und Abb. 8) eine schnellere Einarbeitung in den umgesetzten Einparkalgorithmus ermöglichen.

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“).

Abb. 8: 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.

Implementierung im Offline-/Online-Modell

...

Unit- und Integrationstest

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

Abb. 9 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

Öffnen der Datei "AEP_Unittest_und_Integrationstest.docx" in Word
Vorlage zu den Unittests (siehe „AEP_Vorlage_Unittest_und_Integrationstest.docx“ Kapitel 2) ausfüllen. Wichtig: Anmerkungen zur Simulation beachten!
Öffnen der Datei "start.m" in Matlab R2019b
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)
Unter Registerkarte "Editor" in Matlab auf "RUN" klicken, um Matlab-Skript auszuführen --> Simulink-Modell öffnet sich
Erforderliche Variablen (siehe "AEP_Vorlage_Unittest_und_Integrationstest.docx" Kapitel 2) im Watch-Window anzeigen und zur Auswertung des Tests nutzen
Im Subsystem "AEP-Autonomes Einparken" mit klicken von „Run“ unter der Registerkarte "Simulation" die Simulation starten
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

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

Offene Punkte

(Stand: 15.02.2021)

...
Anpassen der verwendeten Formeln im Hinblick auf reale Einflüsse

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 relisieren

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

@@ Zeile 24: / Zeile 24: @@
 '''Pflichtenheft im SVN:''' https://svn.hshl.de/svn/MTR_SDE_Praktikum/trunk/Anforderungsmanagement/Pflichtenheft/Pflichtenheft_SoSe_2020.xlsx
-[[Datei:CCF_AEP_Pflichten_SoSe2020.JPG|thumb|1600px|none|Abb. 5: Pflichten Team AEP - Einparkalgorithmus SoSe2020]]
+[[Datei:CCF_AEP_Pflichten_SoSe2020.JPG|thumb|1600px|none|Pflichten Team AEP - Einparkalgorithmus SoSe2020]]
-[[Datei:CCF_AEP_Pflichten_WiSe2021.png|thumb|none|Abb. 6: Pflichten Team AEP - Einparkalgorithmus SoSe2020]]
+[[Datei:CCF_AEP_Pflichten_WiSe2021.png|thumb|2000px|none|Pflichten Team AEP - Einparkalgorithmus WiSe2021]]
 == Grundkonzept ==