Fahrzeugsoftware

Aus HSHL Mechatronik
Zur Navigation springen Zur Suche springen

Zur groben Übersicht ein eventueller Leitfaden!!!!

Allgemeines

Autor: Sascha Dienwiebel

Das Projekt "Autonom fahredes Fahrzeug für den Carolo Cup" ist ausschlißlich in MATLAB 2013a / Simulink (für AEP, BSF, Längs- und Querregelung) und Visual Studio (Spurtracking mit Kamera, 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.

- Aufruf unter SVN/.../start.m mit MATLAB 2013a (32 bit)

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

Matlabskripte

Hauptdatei start.m

Autor: Sascha Dienwiebel

Die Datei "start.m" ist diejenige Datei, in der zu Beginn entschieden wird, in welchen Modi 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;

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 Funktion 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 achte, 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 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 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 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 
        PAR_Esm_x0_I_f64                    = 8;            % Startposition in x_I 
        PAR_Esm_y0_I_f64                    = -10;          % Startposition in y_I
        PAR_Esm_psi0_I_f64                  = 0 * pi/180;   % Startausrichtung zu x_I
        switch Lw_Vx_Manuell
            case 0
                PAR_Modi_Schalter_Lw_int    = 1; % Quelle für den Solllenkwinkel 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 Solllenkwinkel
                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 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)
        PAR_Esm_x0_I_f64 = -9.58;                % Startposition in x_I 
        PAR_Esm_y0_I_f64 = -10;                  % Startposition in y_I
        PAR_Esm_psi0_I_f64 = 0 * pi/180;         % Startausrichtung zu x_I
        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 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         = 0; % Kamerasensor Aus (Alle Ausgänge = 0)           
        PAR_Esm_x0_I_f64 = -9.58;                % Startposition in x_I 
        PAR_Esm_y0_I_f64 = -10;                  % Startposition in y_I
        PAR_Esm_psi0_I_f64 = 0 * pi/180;         % Startausrichtung zu x_I
        
        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
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)

Parameterdateien

Autor: Sascha Dienwiebel

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

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.5;     % Geschwindigkeit während des Lückensuchens
PAR_AEP_Vermessgeschwindigkeit_f64   = 0.4;     % Geschwindigkeit während des Lückenvermessens
PAR_AEP_Einparkgeschwindigkeit_f64   = -0.1;    % Geschwindigkeit beim rückwärts Einparken
PAR_AEP_Maximalgeschwindigeit_f64    = 0.5;     % Geschwindigkeit vor Findung des ersten Hindernisses 
PAR_AEP_Korrekturgeschwindigkeit_f64 = 0.05;    % Geschwindigkeit für den Korrekturzug in der Parklücke

PAR_AEP_Einparkwinkel_f64       = 1 * 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


%% Einparkvorgang -Verzögerung
PAR_AEP_Delay_K_f64 = 6; %Verzögerung zum Einparkvorgang; GRUND: Vorerst wird der Gyrosensor kalibriert



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]; 



param_BSF.m

Bei dieser Parameterdatei handelt es sich um die Parameter für die Bahn- und Spurführung. Diese sind zum Beispielt 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

%% 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];


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));  


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;


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]

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.


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

global PAR_Modi_Schalter_Luecke_int

%% Objektliste

objekte_anz = randperm(5);
    switch PAR_Modi_Schalter_Luecke_int
        case 1
            objekte_anz = randperm(5);  % Zufällige Position der Objekte
            luecken_anz = randperm(4);  % Zufällige Position der Parklücken
        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
    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.77; 
        end
    end

    for i = 1:4
        switch luecken_anz(i)
            case 1
                luecke(i) = 0.55; 
            case 2
                luecke(i) = 0.62; 
            case 3
                luecke(i) = 0.80; 
            case 4
                luecke(i) = 0.78;
        end
    end

% X-Positionen der Objekte
    x(1) = -9.2;
    for i = 1:4
        x(i+1) = x(i) + objekt(i)+luecke(i);
    end
    
% Objektliste für den Einparkvorgang
    global PAR_SenAbs_ObjektListe_f64 

    for i = 1:5                           % Nr.  x      y       Breite	Länge       Alpha	v	Plausibilität
        PAR_SenAbs_ObjektListe_f64(i,:) = [ i    x(i)	 -10.43	 0.34   objekt(i)   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.1 0 0 100];
    
%% Demo-Rundkurs als nahezu äquidistanten Punktevektor schreiben
% 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
    global PAR_SenKam_BahnZ_f64
    PAR_SenKam_BahnZ_f64 = [X;Y];   % alles zusammen


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]

Bibliotheken

bib_AutonomesEinparken.mdl

bib_BahnPlanungSpurfuehrung.mdl

bib_Einspurmodell_offline.mdl

bib_Fahrtmodus.mdl

bib_Kinematikmodell_offline.mdl

bib_ObjektSpurErkennung.mdl

bib_Sensoren_Aktoren_offline.mdl

bib_Sensoren_Aktoren_online.mdl

bib_SerCom

bib_Signalaufbereitung

Darstellungen

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

plot_nach_Einparksimulation.m

Autor: Sascha Dienwiebel

Um den Einparkvorgang analysieren zu können, ist es wichtig, im Anschluss an diesen die gefahrenen Geschwindigkeiten, die gemessenen Abstände des Infrarotsensors zur rechten Seite hin und den Lenkeinschlag des Fahrzeugs über die Zeit angezeigt zu bekommen. Genau das wird durch diese Funktion durchgeführt.

plot_nach_Simulation.m

plot_nach_Simulation_BSF.m

plot_nach_Simulation_sollgewschw.m

Funktionen

fahrbahn.m

fahrzeug.m

funktion_kameramodell.m

funktion_simulink_bus_add_to_workspace.m

funktion_simulink_simultan.m

funktion_simulink_simultan_draufsicht.m

funktion_simulink_simultan_Fahrspur.m

parkObjekt.m

Simulinkmodell

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, den Schalter_offline auf 1 zu setzen. Nachdem MATLAB im Anschluss an die Durchführung des Programms alles Parameter und Bibliotheken geladen hat, erscheint folgendes Simulinkmodell (CCF_offline):



Sensorsimulierung

Signalaufbereitung

Kinematikmodell

Aktuatorsimulierung

Online-Betrieb auf dem Fahrzeug

-> Laden von CCF online

ControlDesk

Simulinkmodell einbinden

- in Simulink strg+b zum Builden - in ControlDesk Reloade /Rebuilden(Refresh?)

Layouts

Sensorinbetriebnahme

- Taster - Gyro, Hall, Infrarot

Modus überwachung

- In welchem Modus befinde ich mich? Was ist alles aktiv, was nicht?

Aufnahmen

- Wie nehme ich Sensorsignale in ControlDesk auf?

Signalverarbeitung