Fahrzeugsoftware

→ zurück zum Hauptartikel: Praktikum SDE

Allgemeines

Übersicht über die eingesetzten Entwicklungstools

Das Projekt Autonom fahrendes Fahrzeug für den Carolo Cup ist ausschließlich in MATLAB 2013a / Simulink (für Autonomes Einparken (AEP), Bahn- und Spurführung (BSF) und Längs- und Querregelung) und Visual Studio (Spurtracking mit der Kamera und Objekterkennung mit Laserscanner und Kamera) programmiert.

Zu beachten ist dabei, dass keine MATLAB 2012a und MATLAB 2013a Skripte gemischt werden dürfen. Es muss eine einheitliche Programmierung in der gleichen Version erfolgen! Sollte also eine neue Version MATLAB 2014a auf dem Markt erscheinen, muss darauf geachtet werden, alle einzelnen Skripte und Bibliotheken auf diese Version zu aktualisieren.

Es bestehen zwei Simulinkmodelle, die je nach Auswahl in der Hauptdatei start.m ausgeführt werden. Zum Einen gibt es den Offline-Betrieb, welcher zur Simulation der einzelnen Funktion zur Verfügung steht, um Fehler in der Programmierung schnellstmöglich beheben zu können. Zum Anderen existiert der Online-Betrieb, welcher mit den realen Rückgabewerten der am Fahrzeug verbauten Sensoren arbeitet und den Motor und die Servolenkung über PWM-Signale ansteuert.

Das Hauptprogramm, worin alle Bibliotheken, Parameter und das Simulinkmodell geladen werden, ist die Datei start.m.

Autoren:

Sascha Dienwiebel (Diskussion) 18:55, 2. Feb. 2014 (CET)

Stephan Maier (Diskussion) 18:55, 12. Juli 2016 (CET)

Matlabskripte

Nach Öffnen des Programms MATLAB erscheint, falls der DSpace Dongel am Bordcomputer eingesteckt ist, ein Fenster Select dSpace RTI Platform Support. Wenn das Programm online auf dem Fahrzeug laufen soll, so muss in diesem Fenster die Schaltfläche RTI1104 gewählt werden.

RTI wählen

Anschließend initialisiert sich die dSpace Karte. Erst wenn im Anschluss an die im CommandWindow nachfolgend angezeigten Informationen finish erscheint, kann wie gewohnt in MATLAB programmiert werden.

Command Window nach Initialisierung dSpace RTI

Autoren:

Julia Müller (Diskussion) 12:12, 5. Feb. 2014 (CET)

Sascha Dienwiebel (Diskussion) 14:27, 6. Feb. 2014 (CET)

Bilder:

Julia Müller (Diskussion) 12:12, 5. Feb. 2014 (CET)

Hauptdatei start.m

Die Hauptdatei start.m befindet sich im Ordner Externer Link/Software/CaroloCupFahrzeug.

Sie ist diejenige Datei, in der zu Beginn entschieden wird, in welchem Modus das Simulink geöffnet werden soll. Dabei kann zu Beginn zwischen dem Online- und Offline-Betrieb gewählt werden.

%% Auswahl des Simulationstyps %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Schalter "Simulation". 
% 0: Modell für die dSPACE-Karte
% 1: Simulation offline
Schalter_offline    = 1;

Darüber hinaus können zwei verschiedene Rundkursarten simuliert werden. Über die globale Variable "PAR_Modi_Schalter_Fahrbahn_int" kann mit einem Wert von null eine ovale Fahrbahn wie in Abbildung 1(a) erstellt werden oder mit einem Wert von eins eine dem Carolo-Cup-Bahn ähnliche Fahrbahn mit einem Kreuzungsbereich wie in Abbildung 1(b) gezeigt wird.

%% Laden verschiedener Fahrbahnformen %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 0: Rundkurs ohne Kreuzung
% 1: Rundkurs mit Kreuzung
global PAR_Modi_Schalter_Fahrbahn_int
PAR_Modi_Schalter_Fahrbahn_int = 1;

• 

  Abbildung 1(a): Einfache ovale Fahrbahn.

• 

  Abbildung 1(b): Carolo-Cup-Fahrbahn mit Kreuzungsbereich.

Im Anschluss wird die Wahl getroffen, welche Aktion das Fahrzeug durchführen soll. Die Variable "Simulinkmodus" wird im späteren Verlauf dafür verwendet, die passenden Parameter für die entsprechende Durchführung zu laden.

%% Auswahl des Simulinkmodus %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 1: BSF (Bahn und Spurführung)
% 2: AEP (Einparkmodus: Lücke suchen, vermessen und anschließend anhalten)
% 3: AEP (Einparkmodus: Lücke suchen, vermessen und einparken)
Simulinkmodus    = 3;

In der Regel wird von den einzelnen Funktionen die Geschwindigkeit und der Lenkwinkel selbst bestimmt. Dennoch gibt es die Möglichkeit, die Werte manuell zu bestimmen. Dafür muss der Variablen Lw_Vw_Manuell der Wert 1 zugewiesen werden und im Anschluss die gewünschte Geschwindigkeit in Metern pro Sekunde und der Lenkwinkel in Radiant eingegeben werden.

%% Quelle für Solllenkwinkel und Sollgeschwindigkeit %%%%%%%%%%%%%%%%%%%%
% 0: Automatisch
% 1: manuelle Vorgabe (Werte s. u. beim Fahrmanöver)
Lw_Vx_Manuell               = 0; 

% Bei Wahl der manuellen Vorgaben
PAR_Famo_VxSollManuell_f64  = 0.5;          % Sollgeschwindigkeit [m/s]
PAR_Famo_LwSollManuell_f64  = 2 * pi/180;   % Solllenkwinkel [rad]

Für den Fall der Wahl des Einparkmodus besteht die Möglichkeit, die parkenden Fahrzeuge in der Parkbucht per Zufall setzen zu lassen, oder für schnelles Testen die größte Parklücke direkt nach dem ersten parkenden Fahrzeug zu positionieren (siehe param_SEN_offline.m).

%% Im Fall AEP: Positionswahl der Objekte %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 1: Positionierung zufällig
% 0: Positionierung vorgegeben (größte Lücke vorne)
global PAR_Modi_Schalter_Luecke_int
PAR_Modi_Schalter_Luecke_int = 0;

Im darauf folgenden Schritt wird die Basisschrittweiter der Simulation bestimmt. Dabei ist darauf zu achten, dass die Bahn- und Spurführung keine größere Schrittweite als 0,005s besitzen darf, da sonst die Querregelung instabil wird. Die Einparksimulation hingegen wird deutlich langsamer bei einer so geringen Schrittweite. Daher ist für diese der Wert 0,02s gewählt worden. Die Variable T wird im Offline-Simulinkmodell für die einzustellende Schrittweite verwendet.

%% Basisschrittweite [s]
switch Schalter_offline
    case 1
        T = 0.005;   % Basisschrittweite [s] offline: Regelung BSF mit T = 0,02 instabil!
       if Simulinkmodus == 3 || Simulinkmodus == 2
        T = 0.02;   % Basisschrittweite [s] 
       end
    case 0
        T = 0.005;  % Basisschrittweite [s] online
end

Abschließend mit Auswahlmöglichkeit für den Benutzer ist die Wahl der Simulationsdarstellung für den Offline-Betrieb zu nennen. Es gibt einerseits die Möglichkeit, sich die gesamte Draufsicht von Fahrspur und Fahrzeug (eventuell auch Parkbucht mit parkenden Fahrzeugen) anzeigen zu lassen, andereseits kann man sich auch nur die Fahrspur plotten lassen. Der Wert 1 bedeutet jeweils die Aktivierung der Plots.

%% Simulations Darstellungen %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Darstellung der Draufsicht während der Simulation?
% 0: Aus
% 1: Ein
PAR_Darstellung_Schalter_EIN_bit = 1; 

% Darstellung der Fahrspur während der Simulation?
% 0: Aus
% 1: Ein
PAR_Darstellung_Fahrspur_Schalter_EIN_bit = 0;

Sind die gewünschten Einstellungen getroffen, so folgt alles weitere automatisch mit der Betätigung des Play-Buttons in MATLAB. Je nach ausgewähltem Modus und gewünschter Simulation oder Betrieb auf dem Fahrzeug werden nachfolgend erläuterte notwendige Variablen definiert (Beispiel: Wahl des Modus 1 => Bahn- und Spurführung; kurz: BSF): Für die Simulation der Bahn- und Spurführung wird der Variablen Simulinkmodus der Wert 1 zugewiesen. Durch eine Switch-Case-Abfrage wird zu Beginn das Einspurmodell aktiviert, die Abstandssensorik ausgeschaltet (nicht benötigt), der Kamerasensor eingeschaltet (Spurdetektion) und die Startposition im Plot in Abhängigkeit der ausgewählten Fahrbahn bestimmt (x und y Position). Die Sartausrichtung soll bei 0° liegen. Durch eine weitere Fallunterscheidung wird betrachtet, ob der Benutzer den Solllenkwinkel und die Sollgeschwindigkeit manuell eingegeben hat oder automatisch ermitteln lassen möchte. Zu guter letzt wird der dem Modus entsprechenden Taster, falls es sich um eine Offline-Simulation handeln soll, mit wahr (boolean(1)) belegt, wohin gegen die restlichen Taster falsch zugewiesen bekommen (boolean(0)).

switch Simulinkmodus
    case 1 % BSF 
        PAR_SimSchalter_ESM_Kinematikmodell = 1;            % Einspurmodell
        PAR_SenAbs_Schalter_EIN_bit         = 0;            % Abstandssensorik Aus
        PAR_SenKam_Schalter_EIN_bit         = 1;            % Kamerasensor
        
        % Einstellen der Startposition für verschiedene Fahrbahnformen
        switch PAR_Modi_Schalter_Fahrbahn_int
            case 0
                PAR_Esm_x0_I_f64            = -9.58;        % Startposition in x_I 
                PAR_Esm_y0_I_f64            = -10;          % Startposition in y_I
            case 1
                PAR_Esm_x0_I_f64            = 2;        % Startposition in x_I 
                PAR_Esm_y0_I_f64            = -5;          % Startposition in y_I
            otherwise
                disp('Ungültige Auswahl der Fahrbahnform!')
        end
       
        PAR_Esm_psi0_I_f64                  = 0 * pi/180;   % Startausrichtung zu x_I
        PAR_AEP_Measure_or_Park             = 0;           % Für AEP definiert, wird einmal abgefragt, deshalb hier als 0 definiert
        switch Lw_Vx_Manuell
            case 0
                PAR_Modi_Schalter_Lw_int    = 1; % Quelle für den Sollllenkwinkel aus BSF Funktion
                PAR_Modi_Schalter_Vx_int    = 1; % Quelle für den Sollgeschwindigkeit aus BSF Funktion
            case 1
                PAR_Modi_Schalter_Lw_int    = 3; % manuelle Vorgabe für den Sollllenkwinkel
                PAR_Modi_Schalter_Vx_int    = 3; % manuelle Vorgabe für den Sollgeschwindigkeit
        end
        if Schalter_offline == 1
            PAR_SenTast_AEP_bit                 = boolean(0);
            PAR_SenTast_BSF_Rundk_bit           = boolean(1);
            PAR_SenTast_BSF_RundkHindernis_bit  = boolean(0);
            PAR_SenTast_reserve_bit             = boolean(0);
        end
       
    case 2 % AEP (Lücke geregelt suchen, vermessen und anschließend anhalten)
        PAR_SenAbs_Schalter_EIN_bit         = 1; % Abstandssensorik Ein
        PAR_SimSchalter_ESM_Kinematikmodell = 2; % 2: für Kinematikmodell (einfaches Modell zum Einparken!)
        PAR_AEP_Measure_or_Park             = 1; % Vermessen und anhalten wenn die vermessene Lücke groß genug ist
        PAR_SenKam_Schalter_EIN_bit         = 0; % Kamerasensor Aus (Alle Ausgänge = 0)
       
        % Einstellen der Startposition für verschiedene Fahrbahnformen
        switch PAR_Modi_Schalter_Fahrbahn_int
            case 0
                PAR_Esm_x0_I_f64            = -9.58;        % Startposition in x_I 
                PAR_Esm_y0_I_f64            = -10;          % Startposition in y_I
            case 1
                PAR_Esm_x0_I_f64            = -3.19;        % Startposition in x_I 
                PAR_Esm_y0_I_f64            = -5;          % Startposition in y_I
            otherwise
                disp('Ungültige Auswahl der Fahrbahnform!')
        end
       
        PAR_Esm_psi0_I_f64 = 0 * pi/180;         % Startausrichtung zu x_I
        PAR_SenKam_SpurC_Offset_f64 = 0.1;       % Abstand zur rechten Spurbegrenzungslinie in Metern
        switch Lw_Vx_Manuell
            case 0
                PAR_Modi_Schalter_Lw_int    = 2; % Quelle für den Sollllenkwinkel aus AEP Funktion
                PAR_Modi_Schalter_Vx_int    = 2; % Quelle für den Sollgeschwindigkeit aus AEP Funktion
            case 1
                PAR_Modi_Schalter_Lw_int    = 3; % manuelle Vorgabe für den Sollllenkwinkel
                PAR_Modi_Schalter_Vx_int    = 3; % manuelle Vorgabe für den Sollgeschwindigkeit
        end
        if Schalter_offline == 1
            PAR_SenTast_AEP_bit                 = boolean(1);
            PAR_SenTast_BSF_Rundk_bit           = boolean(0);
            PAR_SenTast_BSF_RundkHindernis_bit  = boolean(0);
            PAR_SenTast_reserve_bit             = boolean(0);
        else
            PAR_SenTast_AEP_bit                 = boolean(0);
        end
       
    case 3 % AEP (Lücke geregelt suchen, vermessen und einparken)      
        PAR_SenAbs_Schalter_EIN_bit         = 1; % Abstandssensorik Ein
        PAR_SimSchalter_ESM_Kinematikmodell = 2; % für Kinematikmodell (einfaches Modell zum Einparken!)       
        PAR_AEP_Measure_or_Park             = 2; % Vermessen, Parken, Korrekturzug, Anhalten
        PAR_SenKam_Schalter_EIN_bit         = 1; % Kamerasensor Aus (Alle Ausgänge = 0)           
       
        % Einstellen der Startposition für verschiedene Fahrbahnformen
        switch PAR_Modi_Schalter_Fahrbahn_int
            case 0
                PAR_Esm_x0_I_f64            = -9.58;        % Startposition in x_I 
                PAR_Esm_y0_I_f64            = -10;          % Startposition in y_I
            case 1
                PAR_Esm_x0_I_f64            = -3.19;        % Startposition in x_I 
                PAR_Esm_y0_I_f64            = -5;          % Startposition in y_I
            otherwise
                disp('Ungültige Auswahl der Fahrbahnform!')
        end
       
        PAR_Esm_psi0_I_f64 = 4 * pi/180;         % Startausrichtung zu x_I
        PAR_SenKam_SpurC_Offset_f64 = 0.1;       % Abstand zur rechten Spurbegrenzungslinie in Metern
        switch Lw_Vx_Manuell
            case 0
                PAR_Modi_Schalter_Lw_int    = 1; % Quelle für den Sollllenkwinkel aus AEP Funktion
                PAR_Modi_Schalter_Vx_int    = 2; % Quelle für den Sollgeschwindigkeit aus AEP Funktion
            case 1
                PAR_Modi_Schalter_Lw_int    = 3; % manuelle Vorgabe für den Sollllenkwinkel
                PAR_Modi_Schalter_Vx_int    = 3; % manuelle Vorgabe für den Sollgeschwindigkeit
        end
        if Schalter_offline == 1
            PAR_SenTast_AEP_bit                 = boolean(1);
            PAR_SenTast_BSF_Rundk_bit           = boolean(0);
            PAR_SenTast_BSF_RundkHindernis_bit  = boolean(0);
            PAR_SenTast_reserve_bit             = boolean(0);
        else
            PAR_SenTast_AEP_bit                 = boolean(0);
        end
       
    case  4 % BSF mit Objekten auf der Fahrbahn
        PAR_SimSchalter_ESM_Kinematikmodell = 1;            % Einspurmodell
        PAR_SenAbs_Schalter_EIN_bit         = 0;            % Abstandssensorik Aus
        PAR_SenLIDAR_Schalter_EIN_bit       = 1;            % LIDAR Abstandssensorik EIN
        PAR_SenKam_Schalter_EIN_bit         = 1;            % Kamerasensor
       
        % Einstellen der Startposition für verschiedene Fahrbahnformen
        switch PAR_Modi_Schalter_Fahrbahn_int
            case 0
                PAR_Esm_x0_I_f64            = -9.58;        % Startposition in x_I 
                PAR_Esm_y0_I_f64            = -10;          % Startposition in y_I
            case 1
                PAR_Esm_x0_I_f64            = -3.19;        % Startposition in x_I 
                PAR_Esm_y0_I_f64            = -5;           % Startposition in y_I
            otherwise
                disp('Ungültige Auswahl der Fahrbahnform!')
        end
       
        PAR_Esm_psi0_I_f64                  = 0 * pi/180;   % Startausrichtung zu x_I
        PAR_AEP_Measure_or_Park             = 0;           % Für AEP definiert, wird einmal abgefragt, deshalb hier als 0 definiert
        switch Lw_Vx_Manuell
            case 0
                PAR_Modi_Schalter_Lw_int    = 1; % Quelle für den Sollllenkwinkel aus BSF Funktion
                PAR_Modi_Schalter_Vx_int    = 1; % Quelle für den Sollgeschwindigkeit aus BSF Funktion
            case 1
                PAR_Modi_Schalter_Lw_int    = 3; % manuelle Vorgabe für den Sollllenkwinkel
                PAR_Modi_Schalter_Vx_int    = 3; % manuelle Vorgabe für den Sollgeschwindigkeit
        end
        if Schalter_offline == 1
            PAR_SenTast_AEP_bit                 = boolean(0);
            PAR_SenTast_BSF_Rundk_bit           = boolean(1);
            PAR_SenTast_BSF_RundkHindernis_bit  = boolean(0);
            PAR_SenTast_reserve_bit             = boolean(0);
        end
       
        % Darstellung der Spuren ausschalten
        PAR_Darstellung_Fahrspur_Schalter_EIN_bit = 0;
       
        % Statusmeldung
        disp('BSF mit LIDAR-Objekten auf der Fahrbahn...')  
end

Nach diesen Zuordnungen werden dem Skript Pfade hinzugefügt und notwendige Parameter geladen.

%% Pfade setzen %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
addpath(genpath('bibliotheken'))
addpath(genpath('darstellung'))
addpath(genpath('funktionen'))
addpath(genpath('parameter'))

%% Parameter laden %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
param_CAR
param_AEP
param_BSF
param_OSE
param_SAB

switch Schalter_offline
    case 1
        param_AKT_offline
        param_SEN_offline
        param_ESM_offline
    case 0
        param_AKT_online
        param_SEN_online
end

Abschließend wird das Offline- oder Online-Simulinkmodell geöffent und ein Text als Zeichen der Fertigstellung des Modells im Command Window von MATLAB angezeigt.

%% Modell öffnen %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
switch Schalter_offline
    case 1
        open('CCF_offline');
    case 0
        open('CCF_online');
end

% Meldung anzeigen
fprintf('%s: Parameter geladen. Öffne das Modell....\n', mfilename)

Autoren:
Sascha Dienwiebel (Diskussion) 17:45, 6. Feb. 2014 (CET)
Stephan Marks

Parameterdateien

In den Parameterdateien werden für übergeordnete Funktionen und Bereiche (zB.: Das Fahrzeug) Eigenschaften in Parametern festgehalten.

Autor: Sascha Dienwiebel (Diskussion) 14:04, 4. Feb. 2014 (CET)

param_AEP.m

Diese Parameterdatei ist für die Funktion des automen Einparkens bereit gestellt. Hier werden zum Einen die zu fahrenden Geschwindigkeiten während des Einparkvorgangs, zum Anderen aber auch der maximal erlaubte Einparkwinkel definiert. Vorerst wird die maximal notwendige Größe der Parklücke vor Durchführung des Vorgangs berechnet. Es werden ein seitlicher Abstand zu den Hindernissen von 8cm angenommen und die Maße des Fahrzeug aus param_CAR.m verwendet.

%%%
%%% Parameterdatei für AEP - Autonomes Einparken
%%% Carolo-Cup-Fahrzeug
%%%
%%% Hochschule Hamm-Lippstadt
%%%

% Später für die Berechnung der benötigten Parklücke
global PAR_CAR_Wendekreisradius_f64
global PAR_CAR_Fahrzeugbreite_f64
global PAR_CAR_Radstand_f64
global PAR_CAR_Mitte_Vorderachse_Vorne_f64
global PAR_CAR_Mitte_Hinterachse_Ende_f64

r = Fahrzeugsoftware#PAR_CAR_Wendekreisradius_f64;
w = Fahrzeugsoftware#PAR_CAR_Fahrzeugbreite_f64;
L = Fahrzeugsoftware#PAR_CAR_Radstand_f64;
v = Fahrzeugsoftware#PAR_CAR_Mitte_Vorderachse_Vorne_f64;
b = Fahrzeugsoftware#PAR_CAR_Mitte_Hinterachse_Ende_f64;

% Annahme für Abstand p zur Kalkulation der definitiv benötigten Parklücke
p = 0.08; % [m]
% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Geschwindigkeiten während des Einparkvorgangs
PAR_AEP_Suchgeschwindigkeit_f64     = 0.8;      % 0,5 Geschwindigkeit während des Lückensuchens vorher!
PAR_AEP_Vermessgeschwindigkeit_f64  = 0.8;      % 0,4 Geschwindigkeit während des Lückenvermessens vorher!
PAR_AEP_Einparkgeschwindigkeit_f64  = -0.8;     % -0,1 eschwindigkeit beim rückwärts Einparken vorher!
PAR_AEP_Maximalgeschwindigeit_f64   = 0.8;      % 0,5 vorher!

PAR_AEP_Einparkwinkel_f64       = 9 * pi/180;   % Schlussparkwinkel

%PAR_CAR_noetige_parkluecke_f64  = 2*(sqrt((r^2)-(r-(w/2)-(0.08/2))^2))+b-(sqrt((r-(w/2))^2-(r-(w/2)-p)^2)); % [m] berechnung der nötigen Parklücke
PAR_CAR_noetige_parkluecke_f64 = 1.9* PAR_CAR_Fahrzeuglaenge_f64;   % für AEP-Testzwecke

Autor: Sascha Dienwiebel (Diskussion) 14:04, 4. Feb. 2014 (CET)

Autor: Martin Berysztak (Diskussion) & Adem Hadziric (Diskussion) 17:14, 22. Jan. 2015 (CET)

Autor: Philipp Tewes (Diskussion) 16:27, 1. Feb. 2017 (CET)

param_AKT_online.m

param_AKT_online.m stellt die Parameter zur Ansteuerung der Aktoren im Online-Modus bereit.

%%%
%%% Parameterdatei für AKT - Aktoren - online
%%% Carolo-Cup-Fahrzeug
%%%
%%% Hochschule Hamm-Lippstadt
%%%

global PAR_CAR_max_Lenkeinschlag_alpha_rad_f64

%% Lenkwinkel
% Kennlinie für Pulsweite_Lenkwinkel zu mittlerem tatsächlichen Lenkwinkel
% an den Vorderrädern
PAR_LookUpLwY_f64 = [0.84  0.097 0.11 0.12 0.13];
PAR_LookUpLwX_f64 = [-0.02 -0.01 0    0.01 0.02];

%% Pararmeter Gaspedalstellung
PAR_LookUpGaspedal_f64 =     [-1     0       1];
PAR_LookUpPWMSignalGas_f64 = [0.0741 0.09144 0.1292];  

%% Gradientenbegrenzung des Gaspedal-PWM-Ausgangs (Delta pro Schrittweite?)
% riesiger Wert für Gradientenbegrenzung, um diese abzuschalten. Denn: die
% Fernbedienung übermittelt noch kein richtiges Signal, mit dem "normal"
% gefahren werden könnte. Warum ist noch unklar. Deshalb:
% Gradientenbegrenzung erstmal weglassen.

PAR_AktRtiPwm_GradbegrenzRising_f64    = 100000; 
% PAR_AktRtiPwm_GradbegrenzRising_f64  = 0.01/1000;
% für die fallende Flanke ist der gleiche Wert verwendet (siehe Simulinkblock) 

%% Radiant in Lenkwinkel PWM
PAR_LookUpLenkwinkel_f64               = [-PAR_CAR_max_Lenkeinschlag_alpha_rad_f64 0 PAR_CAR_max_Lenkeinschlag_alpha_rad_f64];
PAR_LookUpPWMSignalLw_f64              = [0.064 0.087 0.111]; 

Autor: Sascha Dienwiebel (Diskussion) 14:04, 4. Feb. 2014 (CET)

param_BSF.m

Bei dieser Parameterdatei handelt es sich um die Parameter für die Bahn- und Spurführung. Diese sind zum Beispiel die Anteile der Längs- und Querregelung, Lenkwinkelbegrenzung und eine Lookuptabelle für die Geschwindigkeit über den Lenkwinkel.

%%%
%%% Parameterdatei für BSF - Bahnplanung und Spurfuehrung
%%% Carolo-Cup-Fahrzeug
%%%
%%% Hochschule Hamm-Lippstadt
%%%

global PAR_CAR_max_Lenkeinschlag_alpha_rad_f64

%% Manuelle Vorgabe von Lenkwinkel und Gaspedalstellung 
%(z. B. per ControlDesk)
PAR_BsfQuer_LwSollManuell_f64               = 0;
PAR_BsfQuer_LwSollManuellEin_bit            = boolean(0);

PAR_BsfLaengs_GasSollManuell_f64            = 0;
PAR_BsfLaengs_GasSollManuellEin_bit         = boolean(0); 

%% Parametereinstellungen Längsregelung
PAR_BsfLaengs_PAnteil_f64                   = 2;
PAR_BsfLaengs_IAnteil_f64                   = 0;
PAR_BsfLaengs_DAnteil_f64                   = 10;

PAR_BsfLaengs_Filter_DAnteil_f64            = 10;  % Eckfrequenz des PT1-Filters für den gefilterten D-Anteil

% Bestimmung Längsgeschwindigkeit
PAR_BsfVx_Filter_VxSoll_f64                 = 0.5; % Hz

% AntiWindUp
PAR_BsfLaengs_AntiWindUp_f64=1; % 0: kein Anti-WindUp; >0: mit Anti-WindUp

% Maximal zulässige Querbeschleunigung
PAR_BsfQuer_a_max = 2; %Parameter für die Querbeschleunigung
PAR_BsfLaengs_Factor = 0; %Faktor für die Zusammensetzung der Sollgeschwindigkeiten aus Kurven- und Geradeausfahrt

%% Parametereinstellungen Querregelung
PAR_BsfQuer_PAnteil_f64                     = 0.5;
PAR_BsfQuer_IAnteil_f64                     = 0.001;
PAR_BsfQuer_DAnteil_f64                     = 0.1;

PAR_BsfQuer_Filter_DAnteil_f64              = 1;  % Eckfrequenz des PT1-Filters für den gefilterten D-Anteil

% Lenkwinkelbegrenzung
PAR_BsfQuer_max_Lw_f64                      = PAR_CAR_max_Lenkeinschlag_alpha_rad_f64;    % maximaler Lenkwinkel in radiant
PAR_BsfQuer_min_Lw_f64                      = -PAR_CAR_max_Lenkeinschlag_alpha_rad_f64;   % minimaler Lenkwinkel in radiant

% Ist-Bahn-Bestimmung
PAR_BSFQuer_VorausschauBegrenzung_f64       = 0.8;    % Begrenzungsfaktor für die Vorausschauweite in Abhängigkeit von dem Kreisradius der Kurve 

% Vorausschauweite
PAR_BSFQuer_GainVorausschauweite_f64        = 0.2;    % Verstärkungsfaktor für die Vorausschauweite in Abhängigkeit von der aktuellen Geschwindigkeit

%% Geschwindigkeitsvorgabe über Lenkwinkel
PAR_BSF_KameraAParameterVorgabe_f64         =   [-0.5 0   0.5];
PAR_Famo_VxSollBSF_f64                      = 5*[0.1  0.5 0.1];

Autor: Sascha Dienwiebel (Diskussion) 14:04, 4. Feb. 2014 (CET)

param_CAR.m

Wie der Name schon sagt befinden sich hier die Dimensionen und die Masse des Fahrzeugs.

%%% Parameterdatei für AEP - Autonomes Einparken
%%% Carolo-Cup-Fahrzeug
%%%
%%% Hochschule Hamm-Lippstadt
%%% 

%% Fahrzeugparameter %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Originale RC-Fahrzeugmaße -----------------------------------------------
global PAR_CAR_Fahrzeuglaenge_f64              
global PAR_CAR_Fahrzeugbreite_f64                     
global PAR_CAR_Radstand_f64                           
global PAR_CAR_Mitte_Hinterachse_Ende_f64             
global PAR_CAR_Mitte_Vorderachse_Vorne_f64         
global PAR_CAR_max_Lenkeinschlag_alpha_deg_f64
global PAR_CAR_Schwerpunkt_Mitte_Hinterachse_f64
global PAR_CAR_Wendekreisradius_f64
global PAR_CAR_max_Lenkeinschlag_alpha_rad_f64
global PAR_CAR_Masse_f64 

PAR_CAR_Fahrzeuglaenge_f64                  = 0.43;     % !! Bei Maßänderungen Sensorposition in bib_Sensoren_Aktoren_offline.mdl anpassen
PAR_CAR_Fahrzeugbreite_f64                  = 0.29;     % !! Bei Maßänderungen Sensorposition in bib_Sensoren_Aktoren_offline.mdl anpassen             
PAR_CAR_Radstand_f64                        = 0.265;   
PAR_CAR_Mitte_Hinterachse_Ende_f64          = 0.100;        
PAR_CAR_Mitte_Vorderachse_Vorne_f64         = 0.065;    
PAR_CAR_max_Lenkeinschlag_alpha_deg_f64     = 25;       % Maximaler Einschlagwinkel [°]
PAR_CAR_Schwerpunkt_Mitte_Hinterachse_f64   = 0.110;    % FÜR DAS KINEMATIKMODELL
PAR_CAR_Masse_f64                           = 5.5;      % Fahrzeugmasse [Kg]

%% Nicht editieren! Automatische Berechnung %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
PAR_CAR_max_Lenkeinschlag_alpha_rad_f64     = PAR_CAR_max_Lenkeinschlag_alpha_deg_f64*pi/180; % Umrechnung in radiant
PAR_CAR_Wendekreisradius_f64                = PAR_CAR_Radstand_f64/(tan(PAR_CAR_max_Lenkeinschlag_alpha_rad_f64));  

Autor: Sascha Dienwiebel (Diskussion) 14:04, 4. Feb. 2014 (CET)

param_ESM_offline.m

Hier befinden sich die Parameter für das Einspurmodell.

%%%
%%% Parameterdatei für ESM - Einspurmodell - offline
%%% Carolo-Cup-Fahrzeug
%%%
%%% Hochschule Hamm-Lippstadt
%%%
%%% Prof. Göbel, 07.09.2012 

%% Fahrzeugdaten
global PAR_CAR_Fahrzeugbreite_f64
global PAR_CAR_Fahrzeuglaenge_f64
global PAR_CAR_Masse_f64

%% Reifen
c_alpha_vorne   = 200;    %[N/rad] %Prof. Göbel: c_alpha_vorne   = 200; Grobe Abschätzung durch m*g = F_yv + F_yh; c_v = F_yv/alpha_max und alpha_max = 5°
c_alpha_hinten  = 400;    %[N/rad]
c_V             = c_alpha_vorne;
c_H             = c_alpha_hinten;

%% Laengen
l_vorne         = 0.135;     %[m]
l_hinten        = 0.125;     %[m] 
l_V             = l_vorne;
l_H             = l_hinten;
l_ges           = l_vorne + l_hinten;
l_W             = 0;

%% Massen
m               = PAR_CAR_Masse_f64; %[kg]geschätzt
m_Z             = 0;
J_zz            = (m/12)*(PAR_CAR_Fahrzeuglaenge_f64^2+PAR_CAR_Fahrzeugbreite_f64^2) ; % [kg*m^2] Quaderberechnung

%% Aktordynamik
w_V = 2*pi*30; %[1/s]
D_V = 1;

w_H = 2*pi*30; %[1/s]
D_H = 1;

Autor: Sascha Dienwiebel (Diskussion) 14:04, 4. Feb. 2014 (CET)

param_OSE.m

Noch kein Inhalt. Allerdings für eventuelle Einträge vorhanden

param_SAB.m

Für die Signalaufbereitung des Gyrosensors sind in dieser Datei nötige Werte hinterlegt.

%%%
%%% Parameterdatei für SAB - Signalaufbereitung
%%% Carolo-Cup-Fahrzeug
%%%
%%% Hochschule Hamm-Lippstadt
%%%

%% Gierratensensor
PAR_SabGier_FitlerF_K_f64       = 0.9;          % Eckfrequenz des PT1-Filters für die gefilterte Gierrate [Hz]
PAR_SabGier_psiReset_bit        = boolean(0);
PAR_SabGier_IntGain_f64         = 1.0; 
PAR_SabGier_Delay_K_f64         = 5;            % Zeitverzögerung für Gyrokalibrierung 

%% PT1-Filterung der Kamera-Parameter
PAR_SabKam_f_SenKamSpurABC_f64  = 0.5;          %[Hz]

Autor: Sascha Dienwiebel (Diskussion) 14:04, 4. Feb. 2014 (CET)

param_SEN_offline.m

Im Simulationsmodus reicht es nicht aus, das Fahrzeug auf der Straße zu simulieren, zusätzlich müssen die Sensoren des Fahrzeugs simuliert werden. In dieser Datei werden die Positionen und Dimensionen der parkenden Fahrzeuge für das autonome Einparken und die Straßendimension für die Bahn- und Spurführung erstellt. Mit dem Wissen über die Position und Dimension der einzelnen Teile können die Sensoren simuliert werden. Je nach dem, welcher Fahrbahntyp in der "start.m"-Datei ausgewählt wurde, werden die entsprechenden Fahrbahninformationen aus einer .mat-Datei ausgelesen.

%****************************************************************
% Modul           : param_SEN_offline.m                         *
%                                                               *
% Datum           : -                                           *
%                                                               *
% Funktion        : Die Parameter für die Sensoren in der       *
%                   Offline-Simulation werden deklariert        *
%                                                               *
% Implementation  : MATLAB 2013a                 		*
%                                                               *
% Author          : Prof. Göbel             		        *
%                                                               *
% Bemerkung       :                                             *
%                                                               *
% Letzte Änderung : 14-Dez-2018, Marks                          *
%                                                               *
%***************************************************************/

%% Für die Darstellungfunktion funktion_simulink_simultan_draufsicht müssen notwendige Parameter global sein.
global PAR_Modi_Schalter_Luecke_int
global PAR_SenKam_BahnZ_f64
global PAR_SenAbs_SpurBreite_f64
global PAR_SenAbs_ObjektListe_f64

%disp('param_SEN_offline.m geladen...')
nMaxObjekte = 6;

%% Fahrbahnparameter
PAR_SenAbs_SpurBreite_f64 = 0.41; % 41 cm
switch PAR_Modi_Schalter_Fahrbahn_int
    case 0
        disp('Fahrbahn ohne Kreuzung');
        load('RundkursOhneKreuzung.mat'); % Mittellinie in Datei gespeichert
        xStop = []; % keine Stopplinien vorhanden
        yStop = [];

    case 1
        disp('Fahrbahn mit Kreuzung');
        load('RundkursMitKreuzung.mat'); % Mittellinie in Datei gespeichert
        load('Stopplinien.mat'); % Stopplinien in Datei gespeichert  
end
xParkluecke = X(1)+0.8;  % m - Position der Parklücke, erstes Objekt
yParkluecke = Y(1)-0.43; % m - Position der Parklücke, erstes Objekt 

%%% Demo-Rundkurs als nahezu äquidistanten Punktevektor schreiben
%% Mittelpunkt is das Zentrum des Ovals
%% x-Achse zeigt nach rechts
%% y-Achse nach oben
%
%% unten: parallele Linie zur x-Achse im Abstand -10
%X1 = (-10:0.3:9.9);
%Y1 = -10*ones(1, numel(X1));
%% oben: parallele Linie zur x-Achse im Abstand 10
%X3 = (10:-0.3:-9.9);
%Y3 = 10*ones(1, numel(X1));
%% rechts: Halbkreis um (10;0) mit Radius 10
%X2 = 10 + 10*cos(pi/20.*X1);
%Y2 = 10*sin(pi/20.*X1);
%% links: Halbkreis um (-10;0) mit Radius 10
%X4 = -10 + 10*cos(pi+pi/20.*X1);
%Y4 = 10*sin(pi+pi/20.*X1);
%% Zusammenfügen der Teile
%X=[X1, X2, X3, X4];             % X-Werte
%Y=[Y1, Y2, Y3, Y4];             % Y-Werte

PAR_SenKam_BahnZ_f64 = [X;Y]; 	% alles zusammen
PAR_SenKam_Stoplinien_f64 = [xStop;yStop]; 

if Simulinkmodus < 4
    %% Objekte in den Parklücken
    switch PAR_Modi_Schalter_Luecke_int
        case 2
            objekte_anz = randperm(5);  % Zufällige Position der Objekte
            luecken_anz = randperm(4);  % Zufällige Position der Parklücken
            objekte_breite = randperm(5); % Zufällige Breite der Objekte
        case 1
            objekte_anz = randperm(5);  % Zufällige Position der Objekte
            luecken_anz = randperm(4);  % Zufällige Position der Parklücken
            objekte_breite = [1 1 1 1 1]; % Definierte Objektbreite
        case 0
            objekte_anz = [5 4 3 2 1];  % Definierte Objektposition
            luecken_anz = [4 3 2 1];    % Definierte Parklückenposition. Größte zweitgrößte zuerst
            objekte_breite = [1 1 1 1 1]; % Definierte Objektbreite
    end
    
    for i = 1:5
         switch objekte_anz(i)
            case 1
                objekt(i) = 0.385;
            case 2
                objekt(i) = 0.385;
            case 3
                objekt(i) = 0.385;
            case 4
                objekt(i) = 0.44;
            case 5
                objekt(i) = 0.21; % Default: 0.77 m | 0.2 war fehlerhaft
        end
    end
    
    for i = 1:4
        switch luecken_anz(i)
            case 1
                luecke(i) = 0.55; % Default: 0.55 AEP_Parkluecke_Soll = 0.97
            case 2
                luecke(i) = 0.62;
            case 3
                luecke(i) = 0.80;
            case 4
                luecke(i) = 0.78; % 2
        end
    end
    
    for i = 1:5
        switch objekte_breite(i)
            case 1
                breite(i) = 0.34;
            case 2
                breite(i) = 0.23;
            case 3
                breite(i) = 0.43;
            case 4
                breite(i) = 0.12;
            case 5
                breite(i) = 0.3;
        end
    end
    
    % X-Positionen der Objekte
    x(1) = xParkluecke;
    for i = 1:4
        x(i+1) = x(i) + objekt(i)+luecke(i);
    end
    
    % Objektliste für den Einparkvorgang
    for i = 1:5                          % Nr. x       y               Breite	     Länge       Alpha	 v	Plausibilität
       PAR_SenAbs_ObjektListe_f64(i,:) = [ i   x(i)	yParkluecke	breite(i)    objekt(i)   0       0	100];
    end
    
    UeberschreibenMitFehlerdaten = 0;
    
    if UeberschreibenMitFehlerdaten == 1
                               
        PAR_SenAbs_ObjektListe_f64 = [1, xParkluecke, yParkluecke, 0.43, 0.44, 0, 0, 100;
                                      2, xParkluecke + 1, yParkluecke, 0.12, 0.19, 0, 0, 100;
                                      3, xParkluecke + 2, yParkluecke, 0.23, 0.21, 0, 0, 100;
                                      4, xParkluecke + 3.2, yParkluecke, 0.3, 0.385, 0, 0, 100;
                                      5, xParkluecke + 5.4, yParkluecke, 0.34, 0.385, 0, 0, 100];
         
    end
        
%     % In die Größte Lücke wird noch ein kleines Hindernis gesetzt
%     [wert, position] = max(luecke);
%     PAR_SenAbs_ObjektListe_f64(6,:) = [6 (x(position)+0.775) -10.43 0.34 0.33 0 0 100]; %-10.43 vorher -10.5
else % Simulinkmodus 4
    %% Objekte auf der Fahrbahn, SCH
    % Generiere 6 zufällige Ziele auf der Fahrbahn
    disp('Simulinkmodus 4....')
    aIndex = sort(randi(length(X),nMaxObjekte,1));
    for i = 1:nMaxObjekte                 % Nr. x               y               Breite	Länge       Alpha	v	Plausibilität
        if aIndex(i) < length(X)
            Ausrichtungswinkel_deg = atan2((Y(aIndex(i)+1)-Y(aIndex(i))),(X(aIndex(i)+1)-X(aIndex(i))))*180/pi; 
            Help(i,:)=[X(aIndex(i)) X(aIndex(i)+1) (X(aIndex(i)+1)-X(aIndex(i))) Y(aIndex(i)) Y(aIndex(i)+1) (Y(aIndex(i)+1)-Y(aIndex(i))) atand((Y(aIndex(i)+1)-Y(aIndex(i)))/(X(aIndex(i)+1)-X(aIndex(i))))];
        else Ausrichtungswinkel_deg=0;
        end;
        PAR_SenAbs_ObjektListe_f64(i,:) = [ i   X(aIndex(i))	Y(aIndex(i))	0.20    0.3         Ausrichtungswinkel_deg       0	100];
    end
end;

% %% Teste die Fahrbahndarstellung - AUSKOMMENTIEREN!, SCH
% clc
% if ishandle(1)
%     close(1)
% end
% figure(1)
% plot(PAR_SenKam_BahnZ_f64(1,:), PAR_SenKam_BahnZ_f64(2,:), 'b') % Vorgegebene Fahrbahn
% hold on
% plot(-10,-10,'b*')
% plotFahrbahn; % Skript zur Darstellung der Fahrbahn
% 
% % Test der Winkel
% for i=1:6
%     quiver(PAR_SenAbs_ObjektListe_f64(i,2),PAR_SenAbs_ObjektListe_f64(i,3),cosd(PAR_SenAbs_ObjektListe_f64(i,6)), sind(PAR_SenAbs_ObjektListe_f64(i,6)))
% end
% PAR_SenAbs_ObjektListe_f64
% Help
% disp('DEBUG')

Autor: Sascha Dienwiebel (Diskussion) 14:04, 4. Feb. 2014 (CET)

Autor: Philipp Tewes (Diskussion) 16:30, 1. Feb. 2017 (CET)

Autor: Stephan Marks

param_SEN_online.m

Im Online Modus müssen die von den Sensoren gelieferten Spannungen in eine Distanz (in dem Fall Meter) umgewandelt werden. Zusammenhänge zwsichen Spannung und Distanz werden hier teils durch eine LookupTable, aber auch durch direkt Umrechnungen dargestellt.

%%%
%%% Parameterdatei für SEN - Sensoren - online
%%% Carolo-Cup-Fahrzeug
%%%
%%% Hochschule Hamm-Lippstadt
%%%

%% Abstandssensorik Infrarot
PAR_SenAbs_LookUpVRx_f64 = [0.0075    0.0150    0.0221    0.0276    0.0312    0.037    0.0450    0.0545   0.0680    0.091     0.1330    0.1860    0.2510]; % Wert aus AD-Wandler [V]
PAR_SenAbs_LookUpVRy_f64 = [0.6000    0.5500    0.5000    0.4500    0.4000    0.3500    0.3000   0.2500    0.2000   0.1500    0.1000    0.0700    0.0500]; % Abstand [m]

PAR_SenAbs_LookUpHRx_f64 = [0.0145    0.019    0.0252    0.0308    0.0375    0.0472   0.0591    0.0807     0.119    0.1670]; % Wert aus AD-Wandler [V]
PAR_SenAbs_LookUpHRy_f64 = [0.5000    0.4500    0.4000    0.3500    0.3000   0.2500    0.2000   0.1500    0.1000    0.0700]; % Abstand [m]

PAR_SenFernb_Lw_UpperBound_f64         = 0.098;
PAR_SenFernb_Lw_LowerBound_f64         = 0.09;

PAR_SenFernb_FreqGas_UpperBound_f64    = 70;
PAR_SenFernb_FreqGas_LowerBound_f64    = 10;

%% Range für das Gas
PAR_SenFernb_Gas_UpperBound_f64        = 0.11;
PAR_SenFernb_Gas_LowerBound_f64        = 0.085;

% Aktivierungsdauer, damit Fernbedieungseingriff durchgegeben wird
PAR_SenFernb_Gas_Aktivierung_f64       = 0.1;

% Range Frequenz Lenkwinkel
PAR_SenFernb_FreqLw_UpperBound_f64     = 70;
PAR_SenFernb_FreqLw_LowerBound_f64     = 10;

% Maximalgeschwindigkeit bei Schleichfahrt
PAR_SenFernb_MaxGasPWMBreite_K_f64     = 0.98;
PAR_SenFernb_MinGasPWMBreite_K_f64     = 0.94;

%% Abstandssensorik Ultraschall
PAR_SenAbs_UltraschallKF_f64           = 2/0.0118; % Kalibrierfaktor zur Umrechnung von Pulsdauer auf Abstand [m]

%% Geschwindigkeitssensorik Hallsensor
PAR_SenGesch_HallSampleTime_f64        = 0.001;  % ms
PAR_SenGesch_HallStep2Deg_f64          = 60/360; % 60 Deg Motorstep  60/360 = 0.1667
PAR_SenGesch_HallRaddurchmesser_f64    = 0.0663; % m
PAR_SenGesch_HallRadumfang_f64         = pi*PAR_SenGesch_HallRaddurchmesser_f64; %0.2083 m
PAR_SenGesch_HallMotoruebersetzung_f64 = 4;      % 4 Motorumdrehungen = 1 Radumdrehung
PAR_SenGesch_Hallv_min_f64             = 0.05;   % Kleinste erreichbare Geschwindigkeit (darunter können die Hallsensoren nur zu selten Pulse empfangen)
PAR_SenGesch_Hallds_f64                = 1*PAR_SenGesch_HallStep2Deg_f64*PAR_SenGesch_HallRadumfang_f64/PAR_SenGesch_HallMotoruebersetzung_f64; % Single Step

% Filterfrequenz des PT1-Filters der Rohgeschwindigkeit
PAR_SenGeschw_AnteilFrequenz           = 0.1;    % [Hz]

%% Gierratensensor
PAR_SenGier_UmrechFaktor_K_f64         = 60000/180*pi; % Umrechnugnsfaktor von AD-Wert [V] auf Gierrate [rad/s]

Autor: Philipp Tewes (Diskussion) 11:44, 9. Jul. 2016 (CET)

param_VIS_offline.m

Für die Offline Simulation kann bestimmt werden wie oft die Anzeige erneut geplottet wird.

%%%
%%% Parameterdatei für die Visualisierung der Offline Simulation
%%% Carolo-Cup-Fahrzeug
%%%
%%% Hochschule Hamm-Lippstadt
%%%

global PAR_VIS_Anzahl_Schritte_n;

PAR_VIS_Anzahl_Schritte_n = 50; % Alle 50 Schritte die gefahrende Bahn plotten

Autor: Sascha Dienwiebel (Diskussion) 14:04, 4. Feb. 2014 (CET)

Darstellungen

In dem Ordner "darstellungen" sind MATLAB-Skripte hinterlegt, die gezielt nach Simulationsdurchläufen durch die MATLAB-Datei stop.m aufgerufen werden. Damit kann das Verhalten des Fahrzeugs und dessen Sensoren im Anschluss an den Durchlauf analysiert werden.

Am Ende der Datei stop.m ist die Bezeichnung der gewünschten Plot-Anzeige einzugeben (siehe nachfolgendes Skript)

%%%
%%% Stop-Funktion der Simulation:
%%% Nachbearbeitung der Simulation zur Auswertung, etc.
%%% (--> Daten in Struktur sammeln,...)
%%%


%% CCF-Ergebnisstruktur erzeugen
% leere Struktur anlegen
CCF = []; % komplexe Ergebnisstruktur zur Ablage von Signalen, Zusatzinfos, Einheiten, Beschreibung,...
CCF_mess = []; % einfache Ergebnisstruktur mit den Signalen in der ersten Ebene OHNE Zusatzinfos

% Alle Variablennamen holen
variablen = whos;

% alle Variablen durchgehen. Bei denen, die gleich lang wie der Zeitstrahl
% "t" sind, Werte in neue Struktur übernehmen und Variable löschen.
for ii = 1:length(variablen)
    if variablen(ii).size(1) == length(t) && ~strcmp(variablen(ii).name, 't') && ~isempty(variablen(ii).name)
        eval(['CCF.signale.(variablen(ii).name).daten = ',variablen(ii).name,';']);
        eval(['CCF_mess.(variablen(ii).name) = ',variablen(ii).name,';']);
        eval(['clear ',variablen(ii).name]);
    end
end

%% Darstellung durch Plot-Skripte
% hier eigene Skripte einfügen, dieser liegen dann unter \darstellung
plot_nach_Einparksimulation
plot_nach_Simulation_Konzept_Sollgeschw

Autor: Sascha Dienwiebel (Diskussion) 14:04, 4. Feb. 2014 (CET)

plot_nach_Einparksimulation.m

Um den Einparkvorgang analysieren zu können, ist es wichtig, im Anschluss an diesen die gefahrenen Geschwindigkeiten(Abbildung 1.Zeile 2.Spalte), die gemessenen Abstände des Infrarotsensors zur rechten Seite hin (Abbildung 2.Zeile 2.Spalte) und den Lenkeinschlag des Fahrzeugs (Abbildung 1.Zeile 3.Spalte) über die Zeit angezeigt zu bekommen. Desweiteren wird in der zweiten Zeile und ersten Spalte über die Zeit der Gieratenwinkel in Radiant und in selbiger Zeile aber in der dritten Spalte die Winkelveränderung pro Sekunde aufgetragen.

Plot nach simuliertem Einparkvorgang

Wie an der Geschwindigkeitsanzeige zu erkennen ist, startet das Auto nach 5 Sekunden mit der Fahrt (Grund siehe bib_Autonomes Einparken) mit einer Geschwindigkeit von 0,5 m/s. Der seitliche Abstand zu den Hindernissen ist dabei unendlich (begrenzt auf 250cm). Sobald das erste seitlich stehende Hindernis gefunden ist (Abstand < 13cm), ist der Beginn der allgemeinen Parkbucht gefunden und das Fahrzeug fährt weiter mit der vorherigen Geschwindigkeit. Erst wenn die erste Lücke nach diesem Hindernis gefunden ist (Abstand wieder unendlich) senkt das Fahrzeug seine Geschwindigkeit auf die des Suchmodus (0,4 m/s). Mit haltender Geschwindigkeit vermisst das Fahrzeug die Parklücke. Wenn die Parklücke groß genug ist, wird noch bis zu dem nächsten Hindernis vorgefahren, was den weiteren Einfall in der Abstandsmessung hervorruft. Von dort aus wird eine weitere definierte Strecke vorgefahren und schließlich der Rückwärtsgang mit einer negativen Geschwindigkeit von -0,1 m/s eingeschaltet. Gleichzeitig sinkt der Lenkwinkel in Vollanschlag negativer Richtung (-25°) und der Gierratenwert beginnt zu steigen. Ab einem berechneten Gierwinkel von in diesem Beispiel 0,87rad wird in den positiven Vollanschlag eingelenkt (25°) und der Gierwinkel läuft wieder zurück. Sobald der Wert 0rad vom Gyro Sensor zurückgeliefert wird, steht das Fahrzeug parallel zum Straßenrand in der Parklücke und sowohl die Geschwindigkeit als auch der Lenkwinkel gehen zurück auf 0.

Autor: Sascha Dienwiebel (Diskussion) 18:51, 2. Feb. 2014 (CET)

plot_nach_Simulation_Konzept_Sollgeschw.m

In der Datei plot_nach_Simulation_Konzept_Sollgewschw.m werden die gefahrene Strecke, der Krümmungsradius (SenKam_SpurA_f64) und die Sollgeschwindigkeit (BsfVx_VxSoll_f64) nach einer Simulation zur Analyse des Blocks BSFVx - Bestimmung Sollgeschwindigkeit ausgegeben. Die folgende Abbildung zeigt die Ausgabe.<br\>

Autor: Nils Brunnert (Diskussion) 13:06, 6. Feb. 2014 (CET)

Funktionen

Die Funktionen stellen den entscheidenden Teil dar, das Fahrzeug fahrend auf der Straße simulieren zu können. Sie sind unter diesem externen Link/Software/CaroloCupFahrzeug/funktionen zu finden.

plotFahrbahn.m

Bei der Simulation der Strecke wurde das Regelwerk für den Carolo Cup 2013 berücksichtigt. Die Vorgaben die dem Regelwerk entnommen werden konnten, sind die Straßenbreite von 820 mm, die Linienbreite von 20 mm der Abstand zwischen den Mittellinien und die Länge der Mittellinien von 200mm und die Breite der Startlinie von 40 mm, aus der Straßenbreite und der Breite der Mittellinie resultiert die Breite der Fahrbahn (400mm). Die Darstellung der Strecke wird durch die Funktion fahrbahn.m realisiert. Die Darstellung der Strecke ist abhängig von dem Referenzpunkt, welcher der Funktion als Parameter aus der übergeordneten Funktion übergeben wird.

Der Funktionskopf gestaltet sich wie folgt.

function [] = plotFahrbahn()

Der Referenzpunkt bzw. der Startpunkt der Fahrt befindet sich mittig auf der rechten Fahrspur auf der Startlinie. Die Simulation der Umgebung wird unterschieden in vier Abschnitte. Der erste Abschnitt beschreibt die Simulation der Strecke ohne die Parkbucht. Alle verwendeten Konstanten werden in Metern angegeben.

Simulation der Fahrbahn

global PAR_SenKam_BahnZ_f64 PAR_SenAbs_ObjektListe_f64 PAR_SenAbs_SpurBreite_f64  
PAR_SenKam_Stoplinien_f64

% Fahrspur * gegeben in PAR_SenKam_BahnZ_f64
% |        *  |
% |     |  *  |
% |        *  |
% |     |  *  |
% A     B     C

iMax = length(PAR_SenKam_BahnZ_f64);
X = PAR_SenKam_BahnZ_f64(1,:); X(1,iMax+1)=PAR_SenKam_BahnZ_f64(1,1); %Ende mit Anfang verbinden
Y = PAR_SenKam_BahnZ_f64(2,:); Y(1,iMax+1)=PAR_SenKam_BahnZ_f64(2,1); %Ende mit Anfang verbinden
% Schleife über alle Datenpunkte
for i=1:iMax
    Winkel_deg = atan2((Y(i+1)-Y(i)),(X(i+1)-X(i)))*180/pi; % Kurs
    n1=[sind(Winkel_deg);-cosd(Winkel_deg)]; % Normalenvektor
    A(:,i) = PAR_SenKam_BahnZ_f64(:,i)-1.5*PAR_SenAbs_SpurBreite_f64*n1;
    B(:,i) = PAR_SenKam_BahnZ_f64(:,i)-0.5*PAR_SenAbs_SpurBreite_f64*n1;
    C(:,i) = PAR_SenKam_BahnZ_f64(:,i)+0.5*PAR_SenAbs_SpurBreite_f64*n1;
end
% Ende = Anfang
A(:,i+1)=A(:,1);
B(:,i+1)=B(:,1);
C(:,i+1)=C(:,1);

% Außenlinie links
plot(A(1,:),A(2,:),'k', 'LineWidth',2)
% Mittellinie
plot(B(1,:),B(2,:),'--k', 'LineWidth',1.4)
% Außenlinie rechts
plot(C(1,:),C(2,:),'-k', 'LineWidth',2)

Der zweite Abschnitt beschreibt die Parkbucht ohne Hindernisse.

% Startlinie
% Startlinie 40mm x 820 mm über die gesamte Straße
rectangle('Position',[C(1,1) C(2,1) 0.04 0.82], 'FaceColor', [0 0 0]);
   
% Parkbucht Startlinie
  plot([AEP_x_f64+0.75 AEP_x_f64+0.75],[AEP_y_f64-0.225 AEP_y_f64-0.645],'k')
  plot([AEP_x_f64+0.77 AEP_x_f64+0.77],[AEP_y_f64-0.225 AEP_y_f64-0.625],'k')
   
% Parkbucht Außenlinie
  plot([AEP_x_f64+0.77 AEP_x_f64+5.98],[AEP_y_f64-0.625 AEP_y_f64-0.625],'k')
  plot([AEP_x_f64+0.75 AEP_x_f64+6],[AEP_y_f64-0.645 AEP_y_f64-0.645],'k')
   
% Parkbucht Endlinie
  plot([AEP_x_f64+5.98 AEP_x_f64+5.98],[AEP_y_f64-0.225 AEP_y_f64-0.625],'k')
  plot([AEP_x_f64+6 AEP_x_f64+6],[AEP_y_f64-0.225 AEP_y_f64-0.645],'k')

Im dritten Abschnitt des Quelltexts werden die parkenden Hindernisse dargestellt.

%% Parkende Hindernisse
for i=1:size(PAR_SenAbs_ObjektListe_f64, 1)
   plotObjekt(PAR_SenAbs_ObjektListe_f64(i,2), PAR_SenAbs_ObjektListe_f64(i,3), PAR_SenAbs_ObjektListe_f64(i,4), PAR_SenAbs_ObjektListe_f64(i,5), PAR_SenAbs_ObjektListe_f64(i,6))
end

Zuletzt werden im vierten Abschnitt die Stopplinien, falls vorhanden, dargestellt.

%% Plot Stopplinien
nMax = length(PAR_SenKam_Stoplinien_f64);
if nMax >0 % gibt es Stopplinien?
    % 40 x 41
    StopLinienBreite = 0.04;  % m
    StopLinienLaenge = 0.41; % m
   
    fill(PAR_SenKam_Stoplinien_f64(1,:),PAR_SenKam_Stoplinien_f64(2,:),'w','EdgeColor','w'); % Linien auf Kreuzung löschen
    for i=1:nMax
        a = PAR_SenKam_Stoplinien_f64(:,i);
        if i == nMax
            b = PAR_SenKam_Stoplinien_f64(:,1); % wieder den ersten Punkt
        else
            b = PAR_SenKam_Stoplinien_f64(:,i+1);
        end
       
        v = b-a;
        n = [v(2);-v(1)];
        n0 = n/norm(n);
        c = b - StopLinienBreite*n0;
        d = a - StopLinienBreite*n0;
       
        X = [a b c d];
        if mod(i,2)== 0
            fill(X(1,:),X(2,:),'w','EdgeColor','w');
        else
            fill(X(1,:),X(2,:),'k','EdgeColor','k');
        end
    end;
    fill(X(1,:),X(2,:),'w','EdgeColor','w');
end

Autoren:

Miladin Ceranic

Sascha Dienwiebel (Diskussion) 22:42, 7. Feb. 2014 (CET)

Stephan Marks

fahrzeug.m

Das benötigte Fahrzeug für die Simulation ist mit Hilfe von Vektoren und trigonometrischen Funktionen als M-File dargestellt. Die benötigten Eingangsparameter der Funktion sind der Zählerstand, die X (ESM_x_I_f64) und Y Position (ESM_y_I_f64) und der Dreh-Winkel (ESM_psi_f64) des Fahrzeugs.

Beschreibung des Quelltextes

Das M-File beginnt mit einem Funktionskopf, welcher die Parameter: Zählerstand (der aktuelle Durchlauf des Funktion), den Drehwinkel, die X- und Y-Position des Fahrzeugs aus der übergeordneten Funktion übergeben bekommt.

Funktionskopf

function [] = fahrzeug(zaehler, ESM_psi_f64, ESM_x_I_f64, ESM_y_I_f64)

Zu Beginn der Funktion werden die globalen handles angelegt, mit dessen Hilfe die Position des Fahrzeugs geändert werden kann.

% Fahrzeug Parameter
  global h_fahrzeug h_richtung;
  global PAR_CAR_Fahrzeugbreite_f64
  global PAR_CAR_Fahrzeuglaenge_f64

Im nächsten Abschnitt werden die Fahrzeugparameter als Konstanten definiert.

  breite = PAR_CAR_Fahrzeugbreite_f64;
  laenge = PAR_CAR_Fahrzeuglaenge_f64;

Im nachfolgenden Schritt werden in den Zeilen 1 bis 16 die Verbindungspunkte des Fahrzeugs und in den Zeilen 17 bis 25 die relevanten Verbindungspunkte der Richtungsanzeige in Abhängigkeit von dem Referenzpunkt mathematische berechnet. Die mathematische Berechnung wird im nächsten Abschnitt beschrieben.

1 % Berechnung der Referenzpunkte in abhängigkeit der Geschwindigkeit
2  x_start = ESM_x_I_f64;% + cos(ESM_psi_f64) * ESM_vCx_B_f64;
3  y_start = ESM_y_I_f64;% + sin(ESM_psi_f64) * ESM_vCx_B_f64;
   
4 % Eckpunkte des Fahrzeugs als X- und Y-Vektor
5  x_fahrzeug = [x_start,...
6                x_start - sin(ESM_psi_f64) * breite / 2,...
7                x_start - sin(ESM_psi_f64) * breite / 2 - cos(ESM_psi_f64) * laenge,...
8                x_start - sin(ESM_psi_f64) * breite / 2 - cos(ESM_psi_f64) * laenge + sin(ESM_psi_f64) * breite,...
9                x_start - sin(ESM_psi_f64) * breite / 2 + sin(ESM_psi_f64) * breite,...
10               x_start];
11 y_fahrzeug = [y_start,...
12               y_start + cos(ESM_psi_f64) * breite / 2,...
13               y_start + cos(ESM_psi_f64) * breite / 2 - sin(ESM_psi_f64) * laenge,...
14               y_start + cos(ESM_psi_f64) * breite / 2 - sin(ESM_psi_f64) * laenge - cos(ESM_psi_f64) * breite,...
15               y_start + cos(ESM_psi_f64) * breite / 2 - cos(ESM_psi_f64) * breite,...
16               y_start];
   
17 % Eckpunkte der Fahrtrichtung
18   x_richtung = [x_start,...
19                 x_start - sin(ESM_psi_f64) * breite / 2 - cos(ESM_psi_f64) * laenge,...
20                 x_start - sin(ESM_psi_f64) * breite / 2 - cos(ESM_psi_f64) * laenge + sin(ESM_psi_f64) * breite,...
21                 x_start];
22   y_richtung = [y_start,...
23                 y_start + cos(ESM_psi_f64) * breite / 2 - sin(ESM_psi_f64) * laenge,...
24                 y_start + cos(ESM_psi_f64) * breite / 2 - sin(ESM_psi_f64) * laenge - cos(ESM_psi_f64) * breite,...
25                 y_start];

Im letzten Schritt wird das Fahrzeug simuliert (geplottet). Anhand des Zählers, wie oft die Funktion aufgerufen wurde, wird Unterschieden ob das Fahrzeug geplottet (nachfolgendes Skript Zeilen 2 bis 4) oder als Objekt verschoben werden soll (nachfolgendes Skript Zeilen 5 bis 8).

1 % Anzeige des Fahrzeugs mit Fahrtrichtung
2   if zaehler == 1
3      h_fahrzeug = plot(x_fahrzeug, y_fahrzeug,'r');
4      h_richtung = plot(x_richtung, y_richtung,'c');
5   else
6      set(h_fahrzeug,'XData',x_fahrzeug,'YData',y_fahrzeug);
7      set(h_richtung,'XData',x_richtung,'YData',y_richtung);
8   end

Autor:

Miladin Ceranic

Sascha Dienwiebel (Diskussion) 23:09, 7. Feb. 2014 (CET)

Das mathematische Modell

In der nachfolgenden Abbildung wird das Fahrzeug dargestellt. Der Punkt P1 (in grün gezeichnet) stellt den Referenzpunkt und den Nullpunkt im Körperkoordinatensystem des Fahrzeugs da. Dieser wird durch die eingelesenen Parameter x_start und y_start definiert.

Mathematisches Modell des Fahrzeugs

Die Berechnung der einzelnen Punkte des Fahrzeugs erfolgt wie in der nächsten Abbildung exemplarisch für den Punkt P2 dargestellt.

Ausschnitt des mathematisches Modell des Fahrzeugs

Der Punkt P2 kann durch die trigonometrischen Funktionen komponentenweise wie folgt beschrieben werden:

$P2_{x} = P1_{x} - \sin\alpha \cdot \frac{b}{2}$

$P2_{y} = P1_{y} + \cos\alpha \cdot \frac{b}{2}$

Alle weiteren Punkte lassen sich analog berechnen.

Autor:

Miladin Ceranic

Sascha Dienwiebel (Diskussion) 23:20, 7. Feb. 2014 (CET)

parkObjekt.m

Die parkenden Objekte werden ähnlich wie das Fahrzeug simuliert, mit dem Unterschied das diese feststehend sind und entweder zufällig oder der Reihe nach mit der größten Parklücke zuerst platziert werden. Die Eigenschaften der für die Einparksimulation benötigten Objekte können der Parameterliste param_SEN_offline.m entnommen werden.

Autoren

Miladin Ceranic

Sascha Dienwiebel (Diskussion) 23:29, 7. Feb. 2014 (CET)

Simulinkmodell

Bibliotheken

Bibliotheken (engl. Library) sind in Simulink erstellte Subsysteme. Sowohl das Simulinkmodell des Online- als auch des Offline-Betrieb basieren auf der Verlinkung mehrerer Bibliotheken, welche getrennt voneinander bearbeitet werden können, ohne andere Funktionen zu beeinträchtigen. Es besteht entweder die Möglichkeit, direkt über den Ordner Software/CaroloCupFahrzeug/bibliotheken zu dem gewünschten Subsystem zu gelangen, oder im ausgeführten Simulinkmodell per Rechtsklick auf das entsprechende Subsystem über Library Link -> Go To Library Block. Werden die Bibliotheken innerhalb des Gesamtmodells durch einen Doppelklick auf diese geändert, so muss im Anschluss die Bibliothekverlinkung aktualisiert werden (Rechtsklick auf das Subsystem -> Library Link -> Resolve Link...)

Autor: Sascha Dienwiebel (Diskussion) 17:37, 6. Feb. 2014 (CET)

bib_AutonomesEinparken.mdl

In der Bibliothek für das autonome Einparken (Blockbezeichnung: AEP-Autonomes Einparken) befindet sich die gesamte Funktion des autonomen Einparkens. Wie in der nachfolgenden Abbildung zu sehen ist geht in die Bibliothek der komplette Bus des Simulinkmodells, von welchem intern nur die nötigen Variablen abgegriffen werden.

Autor: Sascha Dienwiebel (Diskussion) 17:37, 6. Feb. 2014 (CET)

Ansteuerung der Einparkvorgangs

Nach dem Öffnen der Bibliothek erscheint folgendes Modell:

Gestartet wird der Vorgang sowohl im Online-Betrieb als auch im Offline-Modus durch die Variable PAR_SenTast_AEP_bit. Sie bekommt entweder durch den Druck des roten Tasters oder durch Zuweisung in der Hauptdatei start.m den boolschen Wert Wahr zugewiesen. Das in der obigen Abbildung zu sehende Subsystem beinhalten ein Stateflow-Modell, worin der Vorgang durchgeführt wird. Aktiviert wird dieser Block durch einen Trigger (siehe Zeichen mit steigender und fallender Flanke im Subsystem).

Da die Genauigkeit des autonomen Einparkens von der Genauigkeit des Gierratensensors abhängig ist, muss gewährleistet sein, dass dieser zu Beginn des Vorgangs gut kalibriert ist. Aus diesem Grund wird eine Verzögerung von sicherheitshalber 5 Sekunden vor die Aktivierung des Subsystems gesetzt. Der Block Transport Delay funktioniert nur mit Werten vom Typ Double, weshalb das eingehende Signal der Tastervariablen vorerst konvertiert werden muss, im Anschluss an die Zeitverzögerung aber wieder zurückkonvertiert wird, um mit einheitlichen Daten weiterarbeiten zu können.

Nach der Verzögerung geht das Signal direkt in die Matlabfunktion (AEP Startfunktion), welche für eine Selbsthaltung sorgt, da das Triggern des Subsystems nur für die Zeit der Ansteuerung aktiviert ist. Im Online-Modus wird aber nur einmal kurz der Taster betätigt und im Anschluss an das Loslassen die Variable PAR_SenTast_AEP_bit wieder auf falsch gesetzt. Aufgrund der Notwendigkeit einer Variablen zum Zurücksetzen der Selbsthaltung geht ein weiteres Signal, dass des weißen, als Reserve festgelegten Tasters, mit in die Funktion hinein. Die Selbsthaltung in der Matlab-Funktion läuft wie folgt ab:

function Ansteuerung = fcn(Starttaster,Reset)

%% Wenn Starttaster gedrückt wird, muss eine Selbsthaltung erfolgen.
% Das Subsystem ist nur solange aktiv, wie der Eingang des Triggers = 1 ist.
% Zurückzusetzen ist sie durch den Resettaster (weißer Taster)

persistent hold
if isempty(hold)
    hold = 0;
end

if Starttaster == 0
    if hold == 1
        Ansteuerung = 1;
    else
        Ansteuerung = 0;
    end
    if Reset == 1
        Ansteuerung = 0;
        hold = 0;
    end
elseif Starttaster == 1        
    Ansteuerung = 1;
    hold = 1;
else
    Ansteuerung = 0;
end

Die Variable Ansteuerung ist der Ausgabewert der Funktion und kann entweder 1 oder 0 für Ansteuern oder nicht Ansteuern annehmen. hold ist diejenige Variable, die für die Selbsthaltung sorgt. Sobald der Starttaster den Wert 1 annimmt, wird diese Variable auf 1 gesetzt. Erst durch anschließend einzelne Betätigung von Reset wird dies wieder rückgängig gemacht.

Autor: Sascha Dienwiebel (Diskussion) 17:37, 6. Feb. 2014 (CET)

Ein- und Ausgänge des Einparkalgorithmus beinhaltenden Stateflowmodells

Der Algorithmus des Einparkvorgangs ist in einem Stateflowmodell realisiert, welches sich in dem oben erwähnten Subsystem befindet und folgende Ein- und Ausgänge aufweist, die zusätzlich in der Abbildung darunter zu sehen sind.

1. Zurückgelegte Strecke
2. Abstand des Infrarotsensors vorne rechts
3. Abstand des Infrarotsensor hinten rechts
4. Radiant des Gyrosensors
5. Auswahlvariable, ob nach lückenfindung eingeparkt, oder lediglich angehalten werden soll
6. Fahrzeugparameter (v,L,r und b)

Der Einparkalgorithmus verarbeitet diese Informationen und gibt im Anschluss die im Bild dargestellten Parameter wieder aus. Hier wurde eine hohe Anzahl an Parametern für Überwachungszwecke im Control Desk ausgeführt. Der in der Abbidlung zu sehende Funktion-Call Generator bewirkt, dass die Funktion in der gegebenen Schrittweite T aufgerufen wird.

Autor: Sascha Dienwiebel (Diskussion) 17:37, 6. Feb. 2014 (CET)

Autor: Martin Berysztak (Diskussion) & Adem Hadziric (Diskussion) 15:17, 22. Jan. 2015 (CET)

Autor: Philipp Tewes (Diskussion) 15:45, 1. Feb. 2017 (CET)

Der Einparkalgorithmus

Der Algorithmus wird anhand des Zustandsdiagramms, dem in MATLAB / Simulink genannten Stateflow-Diagramm, Schritt für Schritt beschrieben.

Um die Variablen und Parameter ansehen zu können, muss in Simulink Strg + h zur gleichen Zeit betätigt werden. Einigen Parametern, die in dem Stateflow-Modell verwendet werden, sind Werte aus der Parameterdatei param_AEP zugewiesen.

Der Block innerhalb des grünen Bereichs stellt dabei die Lückensuche, der gelbe das Einparken und der rote den letzten Zustand, das Halten, dar.

Der mit dem Pfeil gekennzeichnete Knoten ist die Entscheidung, ob im Anschluss an die Lückenfindung eingeparkt, oder angehalten werden soll.

Der Abbildung folgend werden die einzelnen Blöcke detailierter beschrieben.

Für die bessere Nachfolgung im ControlDesk ist die zusätzliche Variable: AEP_AKT_Zustand hinzugefügt worden. Über diese kann der aktuelle Zustand während des Einparkens verfolgt werden

Nachfolgende Abbildung zeigt den ersten Zustand, in den gesprungen wird, sobald der Einparkvorgang beginnen soll. Während dieser Zustand durchlaufen wird, bleibt die Lenkung des Fahrzeugs in Mittelstellung (during: AEP_LwSoll_f64 = AEP_Lenkung_Mittelstellung_f64;). Von dort aus wird sofort der Zustand Start aufgerufen. In diesem wird der Sollgeschwindigkeit AEP_Vx_K_soll_f64 die eingegebene Maximalgeschwindigkeit AEP_V_MAX_f64 zugewiesen.

Zum Start der Lückensuche wird die Quelle des Lenkwinkel auf den Sollwinkel des BSF Moduls gesetzt. Die Sollgeschwindigkeit wird heruntergesetzt, damit die geregelte geradeausfahrt ordnungsgemäß durchgeführt werden kann. Aus dem Start Zustand sind zwei Übergänge möglich. Einmal wird geprüft ob beim Starten des Einparkmanövers ein Fahrzeug nebenliegend sich befindet. Zum anderen fährt das Fahrzeug so lange geradeaus, bis der Infrarotsensor vorne rechts das erste Mal einen Wert kleiner 15cm zurückgibt [SenAbs_xVR_K_f64 < AEP_IR_MIN_f64]. Ist dies der Fall, so ist der Anfang von parkenden Hindernissen gefunden und es geht weiter zur Parkbuchtsuche. Sobald der oben erwähnte Infrarotsensor einen größeren Abstand als 50cm erkennt, bedeutet das, ein Anfang einer Parklücke ist gefunden und es wird in den Zustand ParklueckeAusmessen gesprungen. Hierdurch lässt sich sicherstellen, dass das Fahrzeug bei dem Einparkvorgang ein Objekt auf dem "Bürgersteig" erkennt und nicht mit ihm zusammenstößt. Vorerst wird allerdings bei Eintritt in den Zustand der Variablen AEP_start_streckenerfassung_f64 der bis dahin zurückgelegte Weg zugewiesen. Die Länge der Parklücke wird dadurch ermittelt, dass bei jedem erneuten Durchlauf dieses Blocks der zu Beginn zurückgelegte Weg von der aktuellen Strecke abgezogen wird. Der daraus resultierende Wert wird mit der nötigen Größe der Parklücke verglichen. Dabei werden zwei Fälle unterschieden:

1. Der Infrarotsensor misst einen kleineren Wert als 15cm und die Parklücke ist noch nicht groß genug: Dann wird wieder zu Beginn des Zustands Parkbuchtsuche gesprungen.
2. Der Infrarotsensor misst einen größeren Wert als 50cm und die Parklücke ist groß genug: Tritt dieser Fall ein, wird der Parkvorgang gestartet.

Sobald in den Zustand Parken gewechselt wird, wird die Quelle des Lenkwinkels wieder auf dem AEP Modus gesetzt und der Weg wird berechnet, den das Fahrzeug noch nach vorne fahren muss, und der Variablen AEP_OFFSET_PARKLUECKE_f64 zugewiesen. Er berechnet sich aus v+L aus dem Kapitel Berechnung nötiger Größen des Projekts AEP - Autonomes Einparken. Direkt im Anschluss wird mit dem aktuellen seitlichen Abstand zum Hindernis der Umschlagwinkel $\beta$ (siehe Link) berechnet. Der Abstand vom Fahrzeug zum Hindernis in der Parklücke wird als fest angenommen, da der Abstand vom BSF Modul geregelt wird. Jetzt wird die oben berechnete Strecke zurückgelegt. Dafür wird erneut der bis dahin gefahrene Weg ESM_s_f64 der Variablen AEP_start_streckenerfassung_endeParkluecke_f64 zugeteilt, die immer wieder von der Gesamtstrecke abgezogen wird, bis der daraus resultierende Wert größer als die AEP_OFFSET-Variable von oben ist.

Nun folgt das eigentliche Einparken. Dafür wird die Sollgeschwindigkeit auf die besagten -0,8m/s gesetzt. Sofort mit dem Rückwärtsfahren werden die Reifen komplett nach rechts eingeschlagen. Dafür wird dem Solllenkwinkel AEP_LwSoll_f64 der Lenkwinkel AEP_LENKUNG_MAX_RECHTS_f64 zugewiesen. Der Vorgegebene Lenkeinschlag ist dabei in der Parameterdatei param_CAR.m dem Parameter PAR_CAR_max_Lenkeinschlag_alpha_deg_f64 in Grad zu übermitteln. Umgerechnet wird er vor Ort in radiant und anschließend dem maximalen Lenkeinschlag im Stateflow-Modell zugeteilt. Da der Übergang von positiver zu negativer Geschwindigkeit nicht flüssig stattfand und das Fahrzeug durch die Lenkvorgabe noch seitlich nach vorne gefahren ist, wurde hier der after-Befehl eingeführt. Über diesen ist der Effekt beseitigt worden.

Während das Fahrzeug seine Rechtskurve fährt, ändert sich der Wert des Gierratensensor und der übermittelte Winkel ESM_psi_f64, von diesem kann mit dem zuvor berechneten Umschlagwinkel verglichen werden. Dieser Wert ist wie im [.........] erwähnt, in sämtlichen Fällen als zu groß berechnet worden, wodurch das Fahrzeug nicht immer Ideal neben der Fahrbahn stand. Daher ist über Tests der Wert 0,79 als Faktor vorgesetzt worden. Hierdurch ist die Endposition optimiert worden. Folgend wird, sobald sie gleich sind, vom Rechts- zum Linkseinschlag gewechselt. Hier ist für den Übergang, ebenfalls der after-Befehl eingeführt worden. Dabei wird der maximale Lenkeinschlag einfach negiert übernommen. Anschließend fährt das Fahrzeug so lange eine Linkskurve rückwärts, bis der Gierratenwinkel kleiner als der vorher vorgegebenen Einparkwinkel AEP_WINKEL_IN_LUECKE_f64 ist. Ist dies der Fall, so steht das Fahrzeug zwischen zwei Hindernissen in der Parklücke parallel zur Straße. Der letzte Schritt ist ein eventueller Korrekturzug. Die Lenkung wird wieder in Mittelstellung und die Sollgeschwindigkeit auf Vorwärtsfahren gestellt. Um dem hinteren Fahrzeug Platz zum Ausparken zu lassen, fährt das Fahrzeug soweit vor, bis es einen größeren Abstand als 25cm zu diesem aufweist. Hierzu wird zunächst überprüft, welcher der hinteren Infrarotsensoren ein Objekt detektiert hat. Daraufhin wird so lange vorgefahren bis an diesem Sesor der wert über 25cm steigt. Erst dann ist das Einparken beendet und es wird seitens des Parkens in den Zustand Ende gesprungen.

Im Zustand Ende wird, wie in der kommenden Abbildung zu sehen ist, die Sollgeschwindigkeit auf 0 (AEP_V_STOPP_f64) und der Solllenkwinkel erneut zur Sicherheit in Mittelstellung gesetzt.

Während des gesamte Einparkvorgangs werden Solllenkwinkel und Sollgeschwindigkeit am Ausgang des Stateflow-Modells abgesendet. Der Zuletzt in den beiden Variablen AEP_vx_K_soll_f64 und AEP_LwSoll_f64 gespeicherte Wert wird weitergeleitet.

Update

Dadurch, dass das BSF Modul die gewünschte Fahrspur für das geregelte geradeaus Fahren zu stark an den rechten Fahrbahnrand gelegt hat, kollidiert das Fahrzeug beim Einparken mit den Hindernisse. Daher ist es Notwendig, dass vor der Online Ausführung in Control Desk der "c" Parameter, also die Verschiebung der gewünschten Fahrspur, auf 0.1 gesetzt wird.

Autor: Sascha Dienwiebel (Diskussion) 17:37, 6. Feb. 2014 (CET)

Autor: Martin Berysztak (Diskussion) & Adem Hadziric (Diskussion) 18:23, 22. Jan. 2015 (CET)

Autor: Philipp Tewes (Diskussion) 16:24, 1. Feb. 2017 (CET)

bib_BahnPlanungSpurfuehrung.mdl

Innerhalb der Bibliothek Bahnplanung und Spurführung gibt es drei Subsysteme. Das Übersichtsbild dieser Bibliothek ist in der nachfolgenden Abbildung dargestellt.

Das Submodul "BSFVx - Bestimmung der Sollgeschwindigkeit"

bib_Fahrtmodus.mdl

Die Bibliothek für den Fahrtmodus legt fest aus welcher Quelle das Fahrzeug die aktuelle Sollgeschwindigkeit und den Solllenkwinkel wählt. Zwei Multiswitches steuern von welcher Quelle gelesen wird. Es gibt drei Möglichkeiten: Es kann unabhängig von einander die Geschwindigkeit und der Lenkwinkel des BSF und des AEP Moduls genutzt werden oder die Sollwerte können manuell durch eine Variable in der start.m Datei festgelegt werden. Diese einstellung müssen vor dem Start des Programms festgelegt werden. Es gibt jedoch die Möglichkeit aus dem AEP Modul heraus den Famo_Modi_Schalter_Lw_int anzusteuern um so während der Fahrt zwischen dem Sollenkwinkel des BSF Moduls auf den des AEP Moduls umzuschalten. Diese Variable wird über den BUS vom AEP Modul in das FAMO Modul übergeben.

Autor: Philipp Tewes (Diskussion) 15:46, 9. Jul. 2016 (CET)

bib_Sensoren_Aktoren_online.mdl

Bibliothek für Sensoren und Aktoren im Online-Betrieb

Die Bibliothek für die Sensoren und Aktoren im Online-Betrieb besteht aus zwei Blöcken. Ein Block dient dem Einlesen der Sensoren und der zweite Block dient der Ausgabe an die Aktoren.

Block Aktoren

In dem Aktoren-Block werden die PWM-Signale für den Lenkwinkel und die Geschwindigkeit an die RTI-Blöcke weitergeleitet. Zusätzlich wird das Signal für die blaue LED, die den Eingriff und die Fahrt im RC-Modus signalisiert, auf den entsprechenden Anschluss an der DSpace Karte übertragen.

Block Sensoren

In dem Sensoren_Block werden in den verschiedenen Blöcken alle Signale, die die Sensoren an die DSpace-Karte liefern in das Programm eingelesen.

Im obersten Block soll die Kamera eingelesen werden. In diesem Block sind die Ein- und Ausgänge angelegt worden. Alle Ausgänge erhalten ein Signal vom Ground.Die Eingänge und einige Ausgänge werden in einem Terminator beendet. Das notwendige Programm muss noch erstellt werden.

Block Längsgeschwindigkeit im Block der Sensoren im Online-Betrieb

In dem Block SenVx-Laengsgeschwindigkeit werden die drei Phasen der Hall-Sensoren eingelesen. Über den Block Combinational Logic wird bestimmt, in welchem der 6 Zustände sich der Hall Sensor befindet. Es folgt die Matlab-Funktion Cal-Fahrrichtung, in der werden gefahrene Distanz und Geschwindigkeit berechnet.

Die Funktion sieht wie folgt aus:

function [CurrFahrtrichtung, CurrCnt, DistanceOut, CurrSpeed, dn, nState, CurrState1, Temp] = fcn(FahrrichtungIn, LoopCnt,    
StartCnt, LastState, CurrState, DistanceIn, LastSpeed)

%#codegen
% Autor: Prof. Dr. ulrich Schneider
% Diese Funktion berechnet die gehfahrene Distanz und die Geschwindigkeit
% für die Hall-Sensoren

% 2Do: 
% - Konstanten müssen in die Parameterdatei herausgeführt werden.
% - Kalibrierfahrt für die Strecke

% SampleTime
SampleTime = 0.001; %ms
Step2Deg = 60/360; %60 Deg Motorstep  60/360 = 0.1667
Raddurchmesser = 0.0663; %m
Radumfang = pi*Raddurchmesser; %0.2083 m
Motoruebersetzung = 4; % 4 Motorumdrehungen = 1 Radumdrehung
v_min = 0.05; %Kleinste erreichbare Geschwindigkeit (darunter können die Hallsensoren nur zu selten Pulse empfangen)

% init outputs by default
DistanceOut = DistanceIn;
CurrCnt =  StartCnt;

CurrState1 = CurrState;
CurrFahrtrichtung = FahrrichtungIn; % forward
Temp=0;
dn = LoopCnt - StartCnt;
dt = dn*SampleTime;
ds = 1*Step2Deg*Radumfang/Motoruebersetzung; % Single Step
    if (dn <1000) %1s
        CurrSpeed =  LastSpeed; %hold
    else
        CurrSpeed = 0; %reset
    end
       
       
CurrSpeed =  LastSpeed;
nState = CurrState-LastState;
if ((nState==1)||(nState==-5))
    CurrFahrtrichtung = 1;
    DistanceOut = DistanceIn + ds;
    if(dt>0)
        CurrSpeed = ds/dt;
    else
        CurrSpeed = 0; % Div by Zero
    end;
    CurrCnt = LoopCnt;
    Temp=1;
elseif ((nState==-1)||(nState == 5))
    CurrFahrtrichtung = 0; % backward
    DistanceOut = DistanceIn - ds;
    if(dt>0)
        CurrSpeed = -ds/dt;
    else
        CurrSpeed = 0; % Div by Zero
    end;
    CurrCnt = LoopCnt;
    Temp=2;
end;


% Wird dt zu groß (d. h. wurde schon lange auf einen neuen Puls gewartet),
% dann wird v = 0 gesetzt.
dt_max = ds/v_min;
if(dt>dt_max)
    CurrSpeed = 0;
end

Die berechnete und ungefilterte aktuelle Geschwindigkeit wird anschließend noch über einen PT1-Filter Tiefpass gefiltert. Sodass als gefilterte Geschwindigkeit SenVx_vx_K_f64 ausgegeben wird. Anschließend werden dieses Signal und einige weitere Signale auf Ausgänge geführt. Ein Großteil wird jedoch im Sensor-Block terminiert. Die Geschwindigkeit SenVx_vx_K_f64, die zurückgelegte Strecke SenVx_sx_K_f64 und die Information über die Fahrtrichtung SenVx_Fahrtrichtung_bit werden auf den Signal-Bus gelegt.

Im Block SenLw-Lenkwinkel befindet sich nur eine Konstante mit dem Wert Null, die auf den Ausgang gelegt wird. In diesem Block befindet sich der Kommentar: "Der Istlenkwinkel ist gleich dem Solllenkwinkel, da dieser nur duchgestellt wird. Soll der Lenkwinkel auch vorliegen, wenn per Fernbedienung gefahren wird, ist hier eine Fallunterscheidung nach Fernbedienung aktiv/nicht aktiv vorzunehmen." Eine Anpassung oder Ergänzungen in diesem Block müssen noch erfolgen.

Es folgt der Block SenGier-Gierrate.

In diesem Block wird das Spannungssignal des Gyro Sensors, welches seit dem SS2022 auf dem 3. Kanal des Multiplexers der DSpace-Karte anliegt, in einen Gierwinkel-Wert, d.h. in Si-Einheit rad/s, umgewandelt. Der Umrechnungsfaktor PAR_SenGier_UmrechFaktor_K_f64 befindet sich in der Parameterdatei param_SEN_online.m.

Autoren : Martin Berysztak Adem Hadziric (Diskussion) 17:30, 22. Jan. 2015 (CET)

Autoren : Zhiyu Chen, Nils Koch (Diskussion) 11:46, 02. Nov. 2022 (CET)

Der Block SenFernb-Fernbedienung bearbeitet die eingelesenen PWM-Signale der Fernbedienung.

In diesen Block werden die PWM-Signale für die Geschwindigkeit und den Lenkwinkel eingelesen. Das PWM-Signal wird dabei in ein Frequenz-Signal und ein Signal mit der Information über die Pulsbreite geteilt, sodass folgende vier Signale entstehen:

Signal	Bedeutung
SenRti_PwmBreiteLw_f64	Signal mit der Information über die Pulsbreite des PWM Signals für den Lenkwinkel
SenRti_PwmFLw_f64	Signal mit der Information über die Frequenz des PWM Signals für den Lenkwinkel
SenRti_PwmBreiteGas_f64	Signal mit der Information über die Pulsbreite des PWM Signals für Gas/Geschwindigkeit
SenRti_PwmFGas_f64	Signal mit der Information über die Frequenz des PWM Signals für Gas/Geschwindigkeit

Das Signal der Fernbedienung ist sehr stark von Störungen beeinflusst. Um diese Störungen zu minimieren, wurde an einer Filterung der Fernbedienungssignale gearbeitet. Zur Auswahl und Auslegung eine geeigneten Filters ist zunächst das Signal SenRti_PwmBreiteGas_f64 betrachtet worden. Ein Block zur Filterung wurde eingebaut. Informationen über die Auswahl, Auslegung und den verwendeten Block sind zu finden unter Filterung Fernbedienung. Die Filterung der anderen Signale müsste noch ergänzt werden.

Nach der Filterung des Signals werden die Signale zum einen an eine Ausgang geleitet. Zum anderen werden sie in einen Block Check Duty Cycle oder Check Static Range geleitet. In diesen Blöcken wird überprüft, ob die vier Signale in ihrem Range liegen, d.h. es wird überprüft ob die Fernbedienung betätigt wird oder nicht. Die oberen und unteren Grenzen des Range der einzelnen Sgnale sind als Konstanten in der Parameterdatei param_Sen_online.m hinterlegt. Sollte man an der Fernbedienung die eingestellten Bereiche über die Drehsteller verändern, so müssen auch die Kontanten angepasst werden. Wird die Fernbedienung nicht betätigt, so liegen die Signale in ihrem Arbeitsbereich. Wenn die Signale im Arbeitsbereich liegen, gibt der Block eine logische 1 weiter. Sobald das Signal den Arbeitsbereich verlässt, wird eine logische Null weiter gegeben. Anschließend werden die Check-Bits der Signale des Lenkwinkels über einen NAND-Block zusammengeführt. Nur wenn die Frequenz und die Pulsbreite in ihrem Arbeitsbereich liegen, wird an beiden Eingängen des NAND-Blocks eine logische 1 anliegen und somit eine logische 0 ausgegeben. Sobald ein Signal den Arbeitsbereich verlässt und eine logisch 0 am Eingang anliegt, wird der Ausgang auf logisch 1 gesetzt. Dieselbe logische NAND-Verküpfung erfolgt für die beiden Gas-Signale. Für das Gas-Signal und für das Lenkwinkel-Signal existiert anschließend ein logischer Wert. Diese beiden logischen Werte werden nun über eine OR-Verknüpfung zu einem Signal zusammengefasst. Liegt nun an einem Signal eine logisch 1 an, so wird das Ausgangssignal des OR-Blocks zu logisch 1. Nur wenn beide Signale logiche Null sind, ist auch das Ausgangssignal 0. Der Ausgang dieser OR-Verknüpfung wird an eine AND-Verknüpfung mit drei Eingängen weitergeleitet. Der Ausgang dieser AND-Verknüpfung ist mit dem Einschaltsignal der Fernbedienung verbunden. Ein weiterer Eingang dieser AND-Verknüpfung ist die Blinkfrequenz, gemäß den CaroloCup-Regeln. Zwischen der OR-Verknüpfung und der AND-Verknüpfung mit drei Eingängen liegt eine weitere AND-Verknüpfung mit zwei Eingängen. Die Eingänge dieser AND-Verknüpfung sind mit den Range-Bausteinen für die Frequenz des Lenkwinkels und die Frequenz des Gaspedals verknüpft. Führt diese AND-Verknüpfung ein logisch 1 Signal, so ist die Fernbedienung definitiv eingeschaltet.

Ein weiterer Block befasst sich mit der Abstandssensorik.

Die Blöcke für die Berechnung der Ultraschall Sensorik sind noch von der vorherigen Gruppe erhalten. Aktuell wird kein Ultraschall Sensor verwendet. Sollte wieder ein Ultraschall Sensor eingesetzt werden, könnte diese Blöcke verwendet werden.

Des Weiteren werden im Block der Abstandssensorik die Signale der Infrarot Sensoren eingelesen. In einem ersten Block wird das Spannungssignal der Infrarotsensoren, die an der DSpace Karte anliegen, von ADC in V umgewandelt. Die Umwandlung erfolgt über folgende Matlab-Funktion:

function [y, bSpike]  = FilterIRSpikes(u, uOld, LoopCnt)
%#codegen

% init
persistent currentMeasurement;
%persistent fSpike; % Frequency of Spikes unit: number of measurements
persistent nSpike;  % clear nSpike Samples
persistent nMean;   % number of mean values
persistent MeanSum; % u1 + u2 + u3+...

%yMean = u;
if isempty(nMean)
    nMean = 0;
end;

if isempty(MeanSum)
    MeanSum = 0;
end;

if isempty(nSpike)
    nSpike = 0;
end;

if isempty(currentMeasurement)
    currentMeasurement = 0;
end;

MEAS_NOISE = 0.016; %0.04; % Volt
nSPIKE = 7;        % Clear n Samples

bSpike = 0;


if LoopCnt==0
    % init once
    nSpike = 0;
    y = u;
    currentMeasurement=u;
elseif ((abs(u-uOld)>MEAS_NOISE)&&(nSpike == 0))
        % spike detected
        nSpike = nSPIKE;  
        MeanSum = 0;
        nMean = 0;
end;



if nSpike >0
    y = currentMeasurement; % hold value
    % decrement spike counter
    nSpike = nSpike -1;
    bSpike = 1;
else
    % calculate mean value
    nMean = nMean+1;
    if nMean>1
        MeanSum = (MeanSum+u);
        
        yMean = MeanSum/nMean;
    else
        % first value
        MeanSum = u;
        yMean = MeanSum;
    end;
    currentMeasurement = yMean;
    y = yMean;
end;  

Anschließend geht das Signal in eine Lookup Tabelle. In dieser Lookup Tabelle ist das Verhältnis zwischen Spannungswert und zugehörigen Abstandswert hinterlegt. Die Parameter der Lookup Tabelle sind in der Parameterdatei param_SEN_online.m hinterlegt.

Der letzte Block SenTaster liest die die Taster ein.

Autor: Julia Müller (Diskussion) 17:20, 5. Feb. 2014 (CET)

bib_Signalaufbereitung

In der Bibliothek Signalaufbereitung werden die Signal des Gyro-Sensors bearbeitet und die Spurkoeffizienten gefiltert.

Block SabGier-Gierrate

Im folgendem Bild ist die Durchführung der Signalaufbereitung für die Gierrate aufgeführt. Hier wird das ungefilterte Signal der Gierrate SenGier_psip_roh_k_f64 eingelesen und aufbereitet. Es erfolgt zum einen eine automatische Offset-Kompensation. Zusätzlich wird das Signal mithilfe eines PT1-Filters und einer entsprechenden Filterfrequenz gefiltert.

Beginnend werden die Signale der Taster ausgelesen und dem Format hin angepasst. Diese sind für die Offsetberechnung notwendig. Aus dem Block werden die Werte SenGier_psip_unfilt_K_f64, SenGier_psi_unfilt_K_f64, SenGier_psip_filt_K_f64, SenGier_psi_filt_K_f64 und SenGier_Reset_bit herausgeführt. Der Wert SenGier_psip_unfilt_K_f64 ist die ungefilterte Gierrate nach der Offset-Kompensation. Dieser Wert wird über einen Discrete-Time Integrator integriert, sodass man als Ergebnis den Gierwinkel SenGier_psi_unfilt_K_f64 erhält hier ist ebenfalls ein Reset möglich, welches durch die Betätigung der Taster erzielt wird. Das ungefilterte Signal wird nach der automatischen Offset-Kompensation mithilfe eines PT1-Filters, d.h. in unserer Anwendung ein Tiefpassfilter, gefiltert. Auf diese Weise soll das Rauschen, welches auf dem Signal liegt unterdrückt werden. Das gefilterte Signal der Gierrate erhält den Variablennamen SenGier_psip_filt_K_f64. Um den gefilterten und offset-kompensierten Gierwinkel zu erhalten, wird die gefilterte Gierrate SenGier_psip_filt_K_f64 einen Discrete-Time Integrator integriert. Man erhält den Gierwinkel SenGier_psi_filt_K_f64. Diese Integration erfolgt nur, wenn die Simulation im Online-Modus ausgewählt wurde (d.h. Schalter_offline = 0) und der rote Taster (SenTast_AEP_bit) betätigt wurde.

Die Variable SabGier_Reset_bit wird benötigt, um vor dem Start des Einparkalgorithmus den berechneten Gierwinkel zu nullen und anschließend mit dem Einparkalgorithmus zu beginnen.

Autor: Julia Müller (Diskussion) 11:45, 4. Feb. 2014 (CET)

Autoren : Martin Berysztak & Adem Hadziric (Diskussion) 18:05, 22. Jan. 2015 (CET)

Einlesen der Taster

Die Taster werden über GPIO (General Purpose Input/Output), Channel 16-19, eingelesen. Sobald einer der Taster gedrückt wird, wird durch Pullup-Widerstände die Spannung auf Masse gelegt. Es handelt sich damit um negative Logik. Um eine positive Logik zu erreichen wird ein in der folgenden Abbildung zu sehender Not-Operator verwendet. Besteht keine Verbindung zur DSpace Box, so erscheint die Bezeichnung "Bad Link" in den Eingangsblöcken.

Die Taster wurden folgendermaßen zugeteilt:

1. rot: Einparken
2. gelb: Rundkurs ohne Hindernisse
3. blau: Rundkurs mit Hindernissen
4. weiß: Reserve (unbelegt)

Die Taster werden via ControlDesk (Layout Taster_Inbetriebnahme) überprüft.

In der Offline-Umgebung sind die Taster im Sensoren-Block als feste Variablen implementiert und aus dem Workspace von MATLAB gezogen, welche zu Beginn der Offline-Simulation passend nach Moduswahl in der Hauptdatei auf eins gesetzt werden und somit einer Schalterbetätigung entsprechen.

Taster im Offline-Betrieb

Autor: Sascha Dienwiebel (Diskussion) 17:40, 6. Feb. 2014 (CET)

Notiz: Das Einlesen der Taster konnte von der Gruppe des SS2018 erfolgreich überprüft werden. Ein Testprotokoll ist im SVN im allgemeinen Ordner für die Testprotokolle unter Dokumentation\Testprotokolle abgelegt.
Autor Notiz: Benedikt Wulowitsch (Diskussion) 17:31, 4. Juli. 2018 (CET)

Offline-Betrieb zur Simulation

Das Offline-Modell des Carolo Cup Fahrzeugs öffnet sich automatisch nach den passenden Eingaben in der Hauptdatei start.m. Wichtig ist dabei, die Variable Schalter_offline auf 1 zu setzen. Nachdem MATLAB im Anschluss an die Durchführung des Programms alle Parameter und Bibliotheken geladen hat, erscheint folgendes Simulinkmodell (CCF_offline):

Autor: Sascha Dienwiebel (Diskussion) 11:24, 4. Feb. 2014 (CET)

Online-Betrieb auf dem Fahrzeug

Das Online-Modell des Carolo Cup Fahrzeugs öffnet sich automatisch nach den passenden Eingaben in der Hauptdatei start.m. Wichtig ist dabei, die Variable Schalter_offline auf 0 zu setzen. Nachdem MATLAB im Anschluss an die Durchführung des Programms alle Parameter und Bibliotheken geladen hat, erscheint folgendes Simulinkmodell (CCF_online):

Optimierung des Codes für schnellere Ausführung:

Autor: Sascha Dienwiebel (Diskussion) 15:19, 3. Feb. 2014 (CET)

ControlDesk

Simulinkmodell einbinden

Reload und Refresh in ControlDesk

Zunächst muss das Simulink-Modell über die Hauptdatei start.m im Online-Modus geöffnet werden. Bevor das Simulink-Modell für ControlDesk gebuilded werden kann, muss man darauf achten, dass alle Bibliotheken gepushed sind. In einer Bibliothek befindet sich das Modell eines einzelnen Blockes. An dem Pfeil in der unteren linken Ecke eines Blocks, der als Bibliothek angelegt ist, erkennt man, ob der Block gepusht ist oder nicht. Ist der Pfeil schwarz, dann ist die Bibliothek gepusht. Sobald der Pfeil grau ist, muss der Block gepusht werden. Dazu muss man einen Rechtsklick auf den Block machen und Library Link > Resolve Link wählen. Es öffnet sich ein neues Fenster. In dem Fenster den bearbeiteten Block wählen und bei Action "-->Push" wählen. Anschließend den Button Apply drücken und das Fenster schließen. Sind mehrere Blöcke disabeld können über den Button "Push all" alle Blöcke gepusht werden. Sofern alle Blöcke gepusht sind, kann das Simulink-Modell gebuilded werden. Dazu in die oberste Ebene des Simulinkmodells gehen und strg+b drücken.

Anzeige im Command Window nach Builden

Im Command Window von Matlab werden die einzelnen Schritte des Buildens aufgeführt. Sobald das Builden beendet ist, findet man in Command Window die Information finished.

Matlab legt die Datei ccf_online.sdf an und speichert sie unter ...\SVN-Unterlagen\Software\CaroloCupFahrzeug. Der allgemeine Umgang mit dem Online-Modell, Matlab, Simulink und ControlDesk ist ebenfalls in einem Video veranschaulicht. Das Video befindet sich ebenfalls im SVN.

erste Seite ControlDek

Anschließend muss ControlDesk 5.0 geöffnet werden. Sofern sich die Startseite öffnet, muss unter Recent das Projekt Carolo Cup Fahrzeug Inbetriebnahme aufgerufen werden. Ansonsten öffnet sich beim Öffnen von ControlDesk das zuletzt ausgewählte Projekt.

Sobald das Projekt geladen ist, kann man das neu gebuildete Projekt in ControlDesk geladen werden. An der linken Seite von ControlDesk befindet sich ein Fenster, in dem die Projektstruktur dargestellt ist. Unter Inbetriebnahme/Hardware Configurations/Platform[DS1104 R&D...] muss man ccf_online.sdf wählen. Klickt man die Datei mit der rechten Maustaste an, öffnet sich ein Kontektmenü. In diesem Menü kann man Reload Variable Description oder Replace Variable Description wählen. Mit Reload lädt man die neue Version desselben Projektes. Mit Replace kann man ein neues Projekt wählen.

Autor: Julia Müller (Diskussion) 17:00, 4. Feb. 2014 (CET)

Oberfläche

An der linken Seite der ControlDesk Oberfläche befindet sich die Projektstruktur. Unten kann man zwischen verschiedenen Reitern wählen und zu Messungen, Bussystem, Layout und Instrument wählen.

An der unteren Seite können Variablen aus der Projektstruktur gewählt und über Drag and Drop in die Instrumente des Layouts gezogen werden.

Im Hauptfenster in der Mitte können eigene Layouts angelegt werden. Die von uns bereits angelegten Layouts befinden sich über dem Hauptfenster in einer Leiste.

Am rechten Rand befinden sich noch zwei weitere Reiter. Zum einen befindet sich dort eine Auswahlliste für weitere Instrumente, die über Drag and Drop ins Hauptfenster gezogen werden können. Mithilfe des zweiten Reiters kann man die Eigenschaften der verwendeten Instrumente anschauen.

Oben in der Menü-Leiste befinden sich die Start- und Stopp-Knöpfe mit denen das Programm auf der DSpace-Karte gestartet werden kann.

Autor: Julia Müller (Diskussion) 18:47, 5. Feb. 2014 (CET)

Instrumente und Variablen einfügen

Oberfläche Control Desk Instrumente

Instrumente können über Drag and Drop aus der Auswahlliste eingefügt werden.

Sind die Instrumente positioniert, können die Einstellungen der Instrumente in derselben Leiste am rechten Rand unter dem Reiter Properties eingestellt werde.

Anschließend müssen die Variablen, die dargestellt werden soll, in die Instrumente eingefügt werden.

Die Variablen können im unteren Teil der Oberfläche gesucht werden. Die Variablen sind links unten nach der Struktur des Projektes abgelegt, d.h. nach Ein- und Ausgängen sortiert. Wichtig ist, dass nur Variablen, die an einem Eingang oder Ausgang angebunden, dargestellt werden können.

Wenn man eine Variable wählen möchte, von der bereits eine Variable aus demselben Block bereits in einem Layout eingebunden ist, kann man etwas tricksen. Man kann die bereits eingebundene Variable mit Rechtsklick anklicken. Es öffnet sich ein Kontektmenü. Unter Variable(s) kann man Select in Variable Browser wählen. Dann öffnet sich im unteren Teil bereits der richtige Pfad und man kann die gewünschte Variable wählen.

Autor: Julia Müller (Diskussion) 19:07, 5. Feb. 2014 (CET)

Messungen aufnehmen

Um Messungen aufzunehmen muss man an der linken Seite von ControlDesk anstelle des Projektbaums den unten befindlichen Reiter Measurement öffnen. Die in den Instrumenten eingebundenen Variablen können über Drag and Drop in die Recorder gezogen werden. Es können mehrere Recorder angelegt werden. Der Recorder kann erst gestartet werden, wenn das Programm auf der DSpace Karte läuft. Gestartet wird der Recorder links in der Mitte zwischen den verschiedenen Recordern und den gewählten Variablen.
Eine ausführliche Anleitung zur Arbeit mit Recordern ist in Messungen mit dSPACE ControlDesk zu finden.

Zu beachten ist, dass wenn die Messungen gespeichert werden, man die Messung zusätzlich als *.mat Datei gespeichert werden müssen. ControlDesk speichert die Datei zunächst nur in einer *.idf Datei. Man kann dann beim Speichern auswählen, dass es zusätzlich als *.mat Datei gespeichert werden soll. Die *.mat Dateien können in Matlab geladen werden. Die Messungen sollen unter ...\SVN_Unterlagen\Software\CaroloCupFahrzeug\dSPACE\Carolo Cup Fahrzeug\Inbetriebnahme\Measurement Data gespeichert werden.

Autor: Julia Müller (Diskussion) 19:30, 5. Feb. 2014 (CET)

Layouts

Hauptoberfläche

Im Layout Main_Oberfläche lassen sich einige wesentliche Funktionen des Fahrzeugs prüfen. Bei aktiviertem Fernbedienungs-Mdous werden im linken Bereich des Layouts die von der Fernbedienung empfangenen Sollwerte wie Gas und Lenkwinkel angezeigt. Mittig lassen sich alle relevanten Werte der Geschwindigkeits-Vorgabe wie Sollgeschwindigkeit und die PID-Werte des Längsreglers auslesen. Außerdem ist ein manuelles Gasgeben per Slider möglich. Im rechten Drittel des Layouts sind die Werte der Lenkwinkel-Vorgabe verortet. Auch hier können sowohl der Soll-Lenkwinkel als auch die PID-Werte der Querregelung ausgelesen werden. Zusätzlich kann der Lenkwinkel manuell eingestellt werden.

Sensorinbetriebnahme

Im Layout Sensor_Inbetriebnahme hingegen lassen sich die Funktionen der Infrarot Sensoren und des Gyro Sensors prüfen. Desweiteren ist in diesem Layout prüfbar, ob die Kalibrierung des Gyro Sensors nach Tastendruck funktioniert. Erneut wird der Status des Starttaster für den Einparkvorgang angezeigt. Eine definierte Zeit nach dem Tasten druck muss der Gierratenwert auf Null zurückspringen und sollte sich somit kalibriert haben (siehe Offset-Kompensation Gyro Sensor). Außerdem werden die vom Lidar-Sensor erkannten Objekte mit ihren Messwerten wie Position und Größe in einer Objektliste dargestellt.

Tasterinbetriebnahme

In Control Desk unter dem Layout Taster_Inbetriebnahme lassen sich alle Taster auf ihre Funktion prüfen. Im nicht betätigten Zustand erscheint eine rot simulierte LED. Sobald einer der Taster betätigt wird, wechselt die Farbe auf grün.

Einparkvorgang - AEP_IR11

Ein weiteres Layout ist explizit für den Einparkvorgang generiert. In diesem Layout werden die Daten des rechts vorne befindlichen Infrarotsensors, des Gyrosensors, der Geschwindigkeit vom Fahreug und der zurückgelegten Strecke angezeigt. Desweiteren wird auch hier der Status des Starttasters für den Vorgang angezeigt. Die Ausgabedaten Sollgeschwindigkeit und Solllenkwinkel des Simulinkmodells werden ebenfalls in Zifferform ausgegeben.

Geschwindigkeitsregelung

In dem Layout Geschwindigkeit wird das Geschwindigkeitssignal betrachtet. Im oberen Diagramm ist die aus den Hallsensordaten berechnete Geschwindigkeit gefiltert und ungefiltert dargestellt. Die zurückgelegte Strecke, die ebenfalls in dem Block SEN-Sensoren-online berechnet wird, ist im unteren, rechten Diagramm zu sehen. Rechts werden die Werte der Fahrgeschwindigkeits-Sollvorgabe dargestellt.

In der oberen rechten Ecke befindet sich eine Check-Box mit der Inschrift Manuelles Gasgeben per Slider. Setzt man dort den Check-Haken, kann man die Sollgeschwindigkeit mit dem Slider, der sich unter der Check-Box befindet, einstellen.

Lichtsteuerung

Im Layout Lichtsteuerung wird der Status aller Lichter grafisch anhand einer Fahrzeug-Skizze dargestellt. Sobald das Häkchen bei Lichtsteuerung Manuell gesetzt wurde, können alle Lichter manuell ein- und ausgeschaltet werden.

RS232-Kommunikation

Im Layout RS232-Kommunikation werden alle Daten angezeigt, welche über die RS232-Schnittstelle übertragen werden. Sowohl die empfangenen Daten, als auch der Eingangs-/Ausgangsbuffer werden dargestellt. Im Diagramm werden die drei Parameter des erzeugten Spurpolynoms dargestellt.

Ausblick

Bisher (WS18/19) konnte die Lidar-Objektliste im Layout Sensorinbetriebnahme noch nicht erfolgreich in Betrieb genommen werden, da falsche Werte ("1") angezeigt werden. Mögliche Fehler sind:

• C-Programm zur Objekterkennung gibt falsche Werte aus
• Fehler in der seriellen Schnittstelle
• Falsche Variablendefinition in ControlDesk

Autor: Julia Müller (Diskussion) und Sascha Dienwiebel (Diskussion) 19:32, 5. Feb. 2014 (CET)
Bearbeitet im WS18/19: Leon Hundertmark (Diskussion) 14:29, 29. Nov. 2018 (CET)

IBM Doors

Zum Anforderungsmanagement bietet sich die Arbeit mit IBM Rational DOORS an. In dem Artikel wird die Vorgehensweise beispielhaft erklärt.

---

→ zurück zum Hauptartikel: Praktikum SDE