Fahrzeugsoftware

Allgemeines

Das Projekt "Autonom fahredes Fahrzeug für den Carolo Cup" ist ausschliß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".

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

Matlabskripte

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

Autor: Sascha Dienwiebel (Diskussion) 20:52, 3. Feb. 2014 (CET)

Parameterdateien

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

Autor: Sascha Dienwiebel (Diskussion) 18:57, 2. 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.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]

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

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

-> Weitere Auswerteinformationen folgen

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

Funktionen

Die Funktionen stellen den entscheidenden Teil dar, das Fahrzeug fahrend auf der Straße simulieren zu können.

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 rechtsklig auf das entsprechende Subsystem über "Library Link" -> "Go To Library Block". Werden die Bibliotheken innerhalb des Gesamtmodells durch doppelklick auf diese geändert, so muss im Anschluss die Bibliothekverlinkung aktualisiert werden (Rechtsklick auf das Subsystem -> "Library Link" -> "Resolve Link...")

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.

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 gesamte 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 Benötigung 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.

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. Er gibt danach den Solllenkwinkel und die Sollgeschwindigkeit aus. Der in der Abbidlung zu sehende Funktion-Call Generator bewirkt, dass die Funktion in der gegebenen Schrittweite T aufgerufen wird.

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 gleichzeitig gedrückt 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 orangene 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.

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. Das Fahrzeug fährt damit geradeaus, bis der Infrarotsensor vorne rechts das erste Mal einen Wert kleiner 13cm 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. Gegebenenfalls soll dort die Sollgeschwindigkeit für das Suchen langsamer sein, daher wird sie während diesen Zustandes auf AEP_V_SUCHE_f64 gesetzt (In unserem Fall wurde beides ersteinmal zu Testzwecken auf 0,2m/s gestellt). Sobald der oben erwähnte Infrarotsensor jetzt einen größeren Abstand als 15cm erkennt, bedeutet das, ein Anfang einer Parklücke ist gefunden und es wird in den Zustand "ParklueckeAusmessen" gesprungen, wo die Sollgeschwindigkeit erneut einer individuellen Geschwindigkeit (in diesem Fall AEP_V_VERMESSENf64 ebenfalls gleich 0m/s) angepasst wird. Vorerst wird allerdings bei Eintritt in den Zustand der Variable 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 folgende 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 13cm und die Parklücke ist noch nicht groß genug: Dann wird wieder zu Beginn des Zustands "Parkbuchtsuche" gesprungen.
2. Die Parklücke ist groß genug und das nächste Hindernis ist durch den Infrarotsensor detektiert worden: Tritt dieser Fall ein, ist zum einen gewährleistet, das die Lücke groß genug ist, zum Anderen kann der seitlich Abstand zum Hindernis dadurch gemessen werden, dass explizit soweit gefahren wird, bis dieses gefunden ist. Im Anschluss daran wird weiter zu dem oben bereits erwähnten Entscheidungspunkt gesprungen.

Sobald in den Zustand Parken gewechselt wird, wird der Weg berechnet, den das Fahrzeug noch nach vorne fahren muss, und der Variablen AEP_OFFSET_PARKLUECKE_f64 zugewiesen. Er berechnet sich aus v+L+k 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. Jetzt wird die oben berechnete Strecke zurückgelegt. Dafür wird erneut der bis dahin gefahrene Weg (ESM_s_f64) einer 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,3m/s gesetzt. Sofort mit dem Rückwärtsfahren werden die Reifen komplet 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.

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. Sobal sie gleich sind, wird Rechtseinschlag zu Linkseinschlag gewechselt. Dabei wird der Maximale Lenkeinschlag einfach negiert übernommen. Anschließend fährt das Fahrzeug so lange ein Linkskurve rückwärts, bis der Gierratenwinkel kleiner als der vorher vorgegebenen Einparkwinkel (im Stateflow-Modell AEP_WINKEL_IN_LUECKE_f64) ist. Ist dies der Fall, so steht das Fahrzeug wieder parallel zur Straße, allerdings zwischen zwei Hindernissen in der Parklücke. Letzter Schritt ist ein eventueller Korrekturzug. Die Lenkung wird wieder in Mittelstellung gestellt und die Sollgeschwindigkeit wieder auf vorwärtsfahren. Um dem Hinteren Fahrzeug Platz zum Ausparken zu lassen, fährt das RC Fahrzeug soweit vor, bis es einen größeren Abstand als 15cm zu diesem aufweist. 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, 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.

Autor: Sascha Dienwiebel (Diskussion) 20:46, 3. Feb. 2014 (CET)

bib_Signalaufbereitung

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

Im Block SabGier-Gierrate 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.

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

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

ControlDesk

Simulinkmodell einbinden

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

- in ControlDesk Reloade /Rebuilden(Refresh?)

Autor: Julia Müller (Diskussion) 14:37, 3. Feb. 2014 (CET)

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?