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 und Parameter geladen werden, ist die Datei "start.m".
Autor: Sascha Dienwiebel (Diskussion) 18:55, 2. Feb. 2014 (CET)
Matlabskripte
Hauptdatei start.m
Autor: Sascha Dienwiebel (Diskussion) 18:57, 2. Feb. 2014 (CET)
Die Hauptdatei "start.m" befindet sich im Ordner SVN-Trunk/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)
Parameterdateien
Autor: Sascha Dienwiebel (Diskussion) 18:57, 2. Feb. 2014 (CET)
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]
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.
-> Weitere Auswerteinformationen folgen
Autor: Sascha Dienwiebel (Diskussion) 18:51, 2. Feb. 2014 (CET)
plot_nach_Simulation.m
plot_nach_Simulation_BSF.m
plot_nach_Simulation_sollgewschw.m
Funktionen
Die Funktionen stellen den entscheidenden Teil dar, dass Fahrzeug fahrend auf der Straße simuliert werden kann.
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):
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
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
Sensorsimulierung
Signalaufbereitung
Kinematikmodell
Aktuatorsimulierung
Online-Betrieb auf dem Fahrzeug
-> Laden von CCF online
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.
- 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?