Berechnung des Spurpolynoms

Autor: Luca Di Lillo
Betreuer: Prof. Schneider

Einleitung

Damit das Fahrzeug geregelt entlang der ermittelten Fahrbahn fahren kann, muss ein Spurpolynom aus den erkannten Punkten auf der Fahrbahn ermittelt werden. Daher befasst sich dieser Artikel mit der Berechnung des Spurpolynoms. Das ermittelte Polynom ist ein Polynom zweiten Grades mit den Koeffizienten a, b und c, die zusammen das Polynom $y = ax^{2} + bx + c$ bilden. Die Programmierung erfolgt in Matlab anhand mit Hilfe eines Beispielprogramms von Prof. Schneider. Mit den Erkenntnissen des Beispielprogramms soll dann eine Funktion erstellt werden, die aus beliebig vielen Werten ein Polynom berechnet. Im Anschluss soll aus dem Matlab Code C/C++ Code generiert werden, um die Funktion in das Kameraprojekt einzubinden.

Softwareentwurf

Die Funktion zur Berechnung des Spurpolynoms wurde vor der Programmierung in Form eines PAP erstellt.

Programmierung

Die Programmierung der Funktion erfolgte in Matlab, da das Rechnen mit Matrizen und Vektoren dort einfach als in C/C++ ist. Im Folgenden wird die Umsetzung der Funktion genauer erläutert.
Die Funktion arbeitet nach der Quadratischen polynomischen Regression. Die Funktion erhält als Eingabeparamter einen Vektor mit n x-Messwerten und einen mit n y-Messwerten. In der Späteren OSE Software werden die Messwerte die ermittelten Schnittpunkte der Fahrbahn sein, die Werte können jedoch auch allgemeine Werte sein aus denen ein quadratisches Polynom gebildet werden soll. Die weitere Berechnung wird hier schrittweise aufgeführt:

Multiplikation aller x und y Werte zu dem Wert xy $xy = MesswerteX. \cdot MesswerteY.$
Quadrieren der x Werte $x2 = MesswerteX.^{2}$
Kubieren der x Werte $x3 = MesswerteX.^{3}$
Vierte Potenz der x Werte $x4 = MesswerteX.^{4}$
Quadrieren der x-Werte und Multiplikation mit den y-Werten $yx^{2} = MesswerteY. \cdot MesswerteX.^{2}$

Durch diese vorbereitenden Rechenoperationen können jetzt die Koeffizienten a, b und c des Spurpolynoms berechnet werden:

Berechnung von a: $a = \displaystyle\frac{(\overline{yx^{2}} - \overline{y} \cdot \overline{x2}) \cdot (\overline{x2} - (\overline{x})^{2}) - (\overline{xy} - \overline{y} \cdot \overline{x}) \cdot (\overline{x3} - \overline{x} \cdot \overline{x2})}{(\overline{x4} - (\overline{x2})^{2}) \cdot (\overline{x2} - (\overline{x})^{2}) - (\overline{x3} - \overline{x} \cdot \overline{x2})^{2}}$
Berechnung von b: $b = \displaystyle\frac{\overline{xy} - \overline{y} \cdot \overline{x} - a \cdot (\overline{x3} - \overline{x} \cdot \overline{x2})}{\overline{x2} - (\overline{x})^{2}}$
Berechnung von c: $c = \overline{y} - a \cdot \overline{x2} - b \cdot \overline{x}$

Die berechneten Koeffizienten bilden jetzt den Rückgabewert der Funktion. Aus ihnen kann ein Spurpolynom in der Form $y = a \cdot x^{2} + b \cdot x + c$ gebildet werden.

Generierung von C/C++ Code

Damit die in Matlab programmierte Funktion in C/C++ genutzt werden kann, muss daraus C/C++ Code generiert werden. Dazu wird der Matlabcodegenerator verwendet. Die Verwendung wird in dem Wikiartikel Von Matlab zu C code beschrieben.

Aufruf des generierten Codes

Da Matlab durch typedefs, structs und Klassen eigene Datentypen generiert wird im folgenden anhand des Quelltext demonstriert wie die Messwerte in die Form der Matlab Variablen gebracht werden. Danach wird demonstriert, wie die Funktion aufgerufen wird und der Inhalt der Variablen ausgelesen werden kann.
Im ersten Schritt werden Zeiger angelegt, diese Zeiger sollen später auf das jeweilige Array mit den Messwerten zeigen. Da aktuell im Wiki kein Programmcode angezeigt werden kann, sie die Zeilen mit einem Punkt als Präfix Programmcode.

emxArray_real_T* OSE_xWerteMatlabDLL_ast; //Zeiger auf die x-Werte
emxArray_real_T* OSE_yWerteMatlabDLL_ast; //Zeiger auf die y-Werte

Jetzt müssen noch drei Variablen angelegt werden, in denen die späteren Koeffizienten gesichert werden.

real_T OSE_SpurparamterA_f32 = 0, OSE_SpurparamterB_f32 = 0, OSE_SpurparamterC_f32 = 0; //Variablen des Spurpolynoms

Im nächsten Schritt wird den Zeigern vermittelt wo die Daten zu finden sind und wie viel vorhanden sind.

OSE_xWerteMatlabDLL_ast = emxCreateWrapper_real_T(OSE_xWerteFahrbahn_ast, 1, sizeof(OSE_xWerteFahrbahn_ast) / sizeof(OSE_xWerteFahrbahn_ast[0]));
OSE_yWerteMatlabDLL_ast = emxCreateWrapper_real_T(OSE_yWerteFahrbahn_ast, 1, sizeof(OSE_yWerteFahrbahn_ast) / sizeof(OSE_yWerteFahrbahn_ast[0]));

Im letzten Schritt wird die zuvor in Matlab programmierte Polynomfunktion aufgerufen. Die Variablen der Koeffizienten werden alle in der Form Call-By-Reference aufgerufen, sodass diese innerhalb der Funktion mit neuen Werten überschrieben werden können. Die Funktion hat keine Rückgabewerte.

polynom(OSE_xWerteMatlabDLL_ast, OSE_yWerteMatlabDLL_ast, &OSE_SpurparamterA_f32, &OSE_SpurparamterB_f32, &OSE_SpurparamterC_f32); //Berechnen des Spurpolynoms anhand der Matlab Funktion

Die Koeffizienten sind jetzt mit Werten gefüllt die einfach über die Konsole ausgegeben oder über RS232 verschickt werden können. Im angefügten Quelltext ist dieses Kapitel in den Zeilen 339 bis 349 zu finden.

Komponententest

Da es sich bei dieser Entwicklung um die einer einzelnen Komponente handelt, schließt der Komponententest mit dem Testbericht die Entwicklung ab.
Der Test wurde durchgeführt, indem die x und y Werte der Fahrspur aus dem Array des Hauptprogramms in ein Matlab Array gespeichert wurden. Danach wurden die Werte geplottet (siehe Abb. 2 und Abb. 3 blaue Sterne). Gleichzeitig wurde mit diesen Werten und der Polynomfunktion die Koeffizienten a, b und c ermittelt. Aus diesen Werten und der Symbolik Toolbox wurde eine Funktion geplattet und in den Gleichen Plot gelegt (siehe Abb. 2 und Abb. 3 rote Linie), dabei konnte erkannt werden, dass die Messwerte an der Funktion angesiedelt sind. Daher konnte durch den Tutor Marius Köhler, die korrekte Funktionsweise der Funktion festgestellt werden.

Zusammenfassung

Link zum Quelltext und zum Komponententest in SVN

Weiterführende Quelle

Regressionsanalyse der Uni Leipzig