Revision 20:094cdb790dcb, committed 2016-07-29

Comitter:

Schreeker

Date:

Fri Jul 29 14:58:49 2016 +0000

Parent:

19:51747c0ab062

Commit message:

Anpassung an Programmierrichtlinie Dokument, sowie letzte Kontrolle und Funktionstest. Alles Ok! Codestatus endg?ltig! Simon Rutzen

Changed in this revision

--- a/LCD.cpp	Tue Jul 12 14:49:28 2016 +0000
+++ b/LCD.cpp	Fri Jul 29 14:58:49 2016 +0000
@@ -3,55 +3,68 @@
 * Zweck:        Beinhaltet alle Funktionen zur Ausgabe von Informationen
                 auf dem LCD-Display, sowie Funktionen zum Debuggen des Projektes
 * Author:       Simon Rutzen, Nils Kemmer
-* Changes:      keine
+* Changes:      
+    19.05.16    Erstellung File und Funktion vLCDSet und Einbinden des Files TextLCD.h
+    23.05.16    vLCDSetDebug eingefügt + °-Zeichen in Anzeige eingefügt
+    24.05.16    Anzeige printf Display neu strukturiert
+    27.05.16    Anzeige printf Display nochmals neu strukturiert endgültig
+                Funktionen kommentiert
+    05.06.16    Typänderung von WinkelData von word auf signed short int
+    28.06.16    DebugFunktion zum Anzeigen der Spannungswerte des a-Sensors
+    30.06.16    initLCD eingefügt zur Anzeige Begrüßungstext beim Anschalten
+    29.07.16    Anpassung an Programmierrichtlinie-Dokument und letzte endgültige
+                Kontrolle Simon Rutzen
 ***********************************************************************************/
 
 /* Includes */
 #include "LCD.h"
 
 /* Objekt zum Steuern des Bildschirmes */
-TextLCD olcd(PA_9, PC_7, PB_5, PB_4, PB_10, PA_8, TextLCD::LCD20x2); // rs, e, d4-d7
+TextLCD oLCD(PA_9, PC_7, PB_5, PB_4, PB_10, PA_8, TextLCD::LCD20x2); // rs, e, d4-d7
 
 /************************************************************************************
-* void vLCDSet(word wWinkelX, word wWinkelY)
+* void LCD_vLCDSet(word wWinkelX, word wWinkelY)
 * Zweck:    Funktion zur Darstellung der aktuellen X- und Y-Lage (in °)
             des Beschleunigungssensores auf dem LCD-Display
 * Parameter:
-    wWinkelX: aktueller Winkel bezogen auf die X-Achse des Beschleunigungssensores
-    wWinkelY: aktueller Winkel bezogen auf die Y-Achse des Beschleunigungssensores
+    wWinkelX:  aktueller Winkel bezogen auf die X-Achse des Beschleunigungssensores
+    wWinkelY:  aktueller Winkel bezogen auf die Y-Achse des Beschleunigungssensores
     bStateLCD: Zustandsvariabel, Anzeigen der Winkel bei Normallage (0) oder Anzeigen
-               der Textnachricht Überkopflage ohne Winkelangaben.
+               der Textnachricht Überkopflage ohne Winkelangaben (1).
 * return Parameter:
     keine
 *************************************************************************************/
-void vLCDSet(int16 wWinkelX, int16 wWinkelY, byte bStateLCD){
+void LCD_vLCDSet(int16 wWinkelX, int16 wWinkelY, byte bStateLCD){
     /* Bildschirm bereinigen*/
-    olcd.cls();
+    oLCD.cls();
     
     /* Einstellen des Anzeigemodus */
     switch(bStateLCD){
+        
         case 0:{
             /* Überschrift in erster Zeile darstellen */
-            olcd.locate(0,0);
-            olcd.printf("Lage:");
+            oLCD.locate(0,0);
+            oLCD.printf("Lage:");
         
     
             /* aktuelle Winkel darstellen in ° */
-            olcd.locate(0,1);
-            olcd.printf("X:%i\337 Y:%i\337",wWinkelX,wWinkelY);    // \337 entspricht °-Zeichen
+            oLCD.locate(0,1);
+            oLCD.printf("X:%i\337 Y:%i\337",wWinkelX,wWinkelY);    // \337 entspricht °-Zeichen
             }
             break;
+            
         case 1:{
             /* Anzeigen der Überkopflage des Sensores */
-            olcd.locate(0,0);
-            olcd.printf("!Ueberkopflage!");
+            oLCD.locate(0,0);
+            oLCD.printf("!Ueberkopflage!");
             }
+            
         default: break;
         }
 }    
 
 /************************************************************************************
-* void vLCDDebug(signed short int wWinkelX, signed short int wWinkelY, signed short int wWinkelZ)
+* void LCD_vLCDDebug(signed short int wWinkelX, signed short int wWinkelY, signed short int wWinkelZ)
 * Zweck:    Debugfunktion zum Anzeigen der aktuellen Messwerte des Beschleunigungssensores
             zwecks Kalibrierung der einzelnen Nullpunkte der Achsen
 * Parameter:
@@ -62,33 +75,33 @@
 * return Parameter:
     keine
 *************************************************************************************/
-void vLCDDebug(int16 wWinkelX, int16 wWinkelY, int16 wWinkelZ){
+void LCD_vLCDDebug(int16 wWinkelX, int16 wWinkelY, int16 wWinkelZ){
     /* Bildschirm bereinigen */
-    olcd.cls();
+    oLCD.cls();
     
     /* Anzeigen der einzelnen Parameter, oben X und Y, unten Z */
-    olcd.locate(0,0);
-    olcd.printf("X:%i Y:%i",wWinkelX,wWinkelY);   
-    olcd.locate(0,1);
-    olcd.printf("Z:%i",wWinkelZ); 
+    oLCD.locate(0,0);
+    oLCD.printf("X:%i Y:%i",wWinkelX,wWinkelY);   
+    oLCD.locate(0,1);
+    oLCD.printf("Z:%i",wWinkelZ); 
     }
     
 /************************************************************************************
-* void initLCD()
+* void LCD_initLCD()
 * Zweck:    Anzeigen des Initialtextes zum Programmstart.
 * Parameter:
     keine
 * return Parameter:
     keine
 *************************************************************************************/    
-void initLCD(){
+void LCD_vinitLCD(){
     /* Löschen des Bildschirmes */
-    olcd.cls();
+    oLCD.cls();
     
     /* Anzeigen des Initialtextes */
-    olcd.locate(3,0);
-    olcd.printf("Lagesensor");
+    oLCD.locate(3,0);
+    oLCD.printf("Lagesensor");
     
-    olcd.locate(1,1);
-    olcd.printf("Nils und Simon");
+    oLCD.locate(1,1);
+    oLCD.printf("Nils und Simon");
     }
\ No newline at end of file

--- a/LCD.h	Tue Jul 12 14:49:28 2016 +0000
+++ b/LCD.h	Fri Jul 29 14:58:49 2016 +0000
@@ -3,17 +3,25 @@
 * Zweck:        Beinhaltet alle Funktionsprototypen zur Ausgabe von Informationen
                 auf dem LCD-Display, sowie Funktionen zum Debuggen des Projektes
 * Author:       Simon Rutzen, Nils Kemmer
-* Changes:      keine
+* Changes:      
+    19.05.16    Erstellung und Prototyp vLCDSet erstellt
+    23.05.16    Rechtscheibfehler Prototyp korrigiert
+    28.06.16    DebugFunktion zum Anzeigen der Spannungswerte des a-Sensors (Prototyp)
+    30.06.16    initLCD eingefügt zur Anzeige Begrüßungstext beim Anschalten (Prototyp)
+    03.07.16    Einfügen Switch-Case-Struktur in vLCDSet für Normal- oder Überkopflage
+    29.07.16    Anpassung an Programmierrichtlinie-Dokument und letzte endgültige
+                Kontrolle Simon Rutzen
 ***********************************************************************************/
 
 #ifndef LCD_H
+
 /* Includes */
 #include "cdef.h"
 #include "TextLCD.h"
 
 /* Prototypen */
-void vLCDSet(int16 wWinkelX, int16 wWinkelY, byte bStateLCD);
-void vLCDDebug(int16 wWinkelX, int16 wWinkelY, int16 wWinkelZ);
-void initLCD();
+void LCD_vLCDSet(int16 wWinkelX, int16 wWinkelY, byte bStateLCD);
+void LCD_vLCDDebug(int16 wWinkelX, int16 wWinkelY, int16 wWinkelZ);
+void LCD_vinitLCD();
 
 #endif
\ No newline at end of file

--- a/LED.cpp	Tue Jul 12 14:49:28 2016 +0000
+++ b/LED.cpp	Fri Jul 29 14:58:49 2016 +0000
@@ -3,13 +3,22 @@
 * Zweck:        Beinhaltet alle Funktionen zur Einstellung der LED-Helligkeit
                 in Abhängigkeit von den berechneten Winkeln.
 * Author:       Simon Rutzen, Nils Kemmer
-* Changes:      keine
+* Changes:      
+    31.05.16    Erstellung File und Kommentar
+    05.06.16    Funktion setLED erstellt + Kommentar zum Code 
+    28.06.16    Funktion initLED erstellt
+    03.07.16    Funktion setLED geschrieben
+    06.07.16    Ueberkopflage auf +- 80° festgelegt (LED blinken)
+    07.07.16    Funktion setLED Helligkeitsbezug auf 80° gesetzt (vorher 90°)
+    12.07.16    Periode PWM auf 10ms gesetzt wegen Flackern der LED's 
+    29.07.16    Anpassung an Programmierrichtlinie-Dokument und letzte endgültige
+                Kontrolle Simon Rutzen
 ***********************************************************************************/
 
 /* Zu benutzende Pins */
 // PWM1 - Channel 1N (PB_15), 2N (PB_14), 3N (PB_13) und 4 (PA_11)
 
-/* Include */
+/* Includes */
 #include "mbed.h"
 #include "Sensor.h"
 
@@ -27,19 +36,20 @@
 PwmOut oLEDYP(PA_11);
 
 /************************************************************************************
-* void setLED(struct WinkelData stWinkelData)
+* byte LED_bsetLED(struct WinkelData stWinkelData)
 * Zweck:    Steuerung der vier LED's auf Basis der berechneten Winkel in stWinkelData.
             1. Auswerten der Z-Achse, ob Überkopflage oder nicht
             2. Ansteurung der LED's auf Basis der berechneten Winkel in stWinkelData
                und Schritt 1.          
 * Parameter:
-    wWinkelX: aktueller Winkel bezogen auf die X-Achse des Beschleunigungssensores
-    wWinkelY: aktueller Winkel bezogen auf die Y-Achse des Beschleunigungssensores
+    wWinkelX:   aktueller Winkel bezogen auf die X-Achse des Beschleunigungssensores
+    wWinkelY:   aktueller Winkel bezogen auf die Y-Achse des Beschleunigungssensores
     wSpannungZ: aktueller Winkel bezogen auf die Y-Achse des Beschleunigungssensores
-* return Parameter:
-    bStateLCD:  LCD zeigt Winkel an (0) oder Textnachricht Überkopflage (1)
+* return bStateLCD:
+    1 :     Normallage -> Winkelanzeige der X- und Y-Achse
+    0 :     Ueberkopflage -> Anzeige Textnachricht, keine Winkel
 *************************************************************************************/
-byte setLED(int16 wWinkelX, int16 wWinkelY, int16 wSpannungZ){
+byte LED_bsetLED(int16 wWinkelX, int16 wWinkelY, int16 wSpannungZ){
     /* Variabeln */
     byte bStateLED = 0;    // Zustand des Lagesensors ( 0: Normallage 1: Überkopflage)
     byte bStateLCD = 0;    // Zustand der LCD-Anzeige ( 0: Winkelausgabe 1: Textnachricht Überkopflage)
@@ -56,6 +66,7 @@
         
     /* Einstellen der LED's */
     switch(bStateLED){
+        
         case 0:{            // Normallage, einstellen der LED-Helligkeit abhängig vom Winkel
             if(wWinkelX <= 0){ 
                 oLEDXN = abs(wWinkelX/80.0);
@@ -73,6 +84,7 @@
                     }
             break;
             }
+            
         case 1:{            // Überkopflage, LED's blinken
             if(oLEDXN.read()> 0){
                 oLEDXN = 0;
@@ -88,6 +100,7 @@
                 }
             break;
             }
+            
         default: break;
         }
     
@@ -96,14 +109,14 @@
     }        
 
 /************************************************************************************
-* void void initLED()
+* void LED_initLED()
 * Zweck:    Blinken der LED's beim Anschalten des Boards. 4x Blinken im 250ms Abstand        
 * Parameter:
     keine
 * return Parameter:
     keine
 *************************************************************************************/
-void initLED(){
+void LED_vinitLED(){
     /* Variabeln */
     int i = 0;
     

--- a/LED.h	Tue Jul 12 14:49:28 2016 +0000
+++ b/LED.h	Fri Jul 29 14:58:49 2016 +0000
@@ -3,12 +3,17 @@
 * Zweck:        Beinhaltet alle Funktionsprototypen zur Einstellung der LED-Helligkeit
                 in Abhängigkeit von den berechneten Winkeln.
 * Author:       Simon Rutzen, Nils Kemmer
-* Changes:      keine
+* Changes:      
+    31.05.16    Erstellung File und Kommentar
+    05.06.16    Funktion setLED erstellt + Kommentar zum Code (Prototyp)
+    28.06.16    Funktion initLED erstellt (Prototyp)
+    29.07.16    Anpassung an Programmierrichtlinie-Dokument und letzte endgültige
+                Kontrolle Simon Rutzen
 ***********************************************************************************/
 #ifndef LED_H
 
 /* Prototypen */
-byte setLED(int16 wWinkelX, int16 wWinkelY, int16 wWinkelZ);
-void initLED();
+byte LED_bsetLED(int16 wWinkelX, int16 wWinkelY, int16 wWinkelZ);
+void LED_vinitLED();
 
 #endif
\ No newline at end of file

--- a/Sensor.cpp	Tue Jul 12 14:49:28 2016 +0000
+++ b/Sensor.cpp	Fri Jul 29 14:58:49 2016 +0000
@@ -3,7 +3,23 @@
 * Zweck:        Beinhaltet alle Funktionen zum Auslesen des Beschleunigungssensors
                 bezüglich der X-, Y-, Z-Koordinaten
 * Author:       Simon Rutzen, Nils Kemmer
-* Changes:      keine
+* Changes:      
+    23.05.16    Erstellung des Files, Strukturen und Funktionen vgetSensData, vcalcdata
+    24.05.16    vcalcData Berechnung des Winkels eingefügt (X-Achse), Defines eingefügt
+                Referenzmessungswerte X-Y-Z Achse 0° und +-90° eingetragen, vgetSensData
+                Mittelung des Messwerte eingefügt (alle Achsen), calcData Werte auf 3
+                Nachkommastellen begrenzt
+    25.05.16    Y-Achsen Winkelberechnungen analog zu X-Achse eingefügt
+    27.05.16    Defines Referenzwerte zur Berechnung der Winkel aller Achsen eingefügt
+                Funktionen Kommentare eingefügt
+    05.06.16    Unterscheidung negativer oder positiver Winkel eingefügt (Neigung aller
+                Achsen)
+    28.06.16    vDebugData zur Ermittlung der Spannungswerte vom a-Sensor erstellt
+    30.06.16    Neue Kalibrierung, Defines geändert
+    06.07.16    Endgültige Kalibrierung, Defines angepasst
+    07.07.16    Überkopflage bei 80° definiert, Defines angepasst
+    29.07.16    Anpassung an Programmierrichtlinie-Dokument und letzte endgültige
+                Kontrolle Simon Rutzen
 ***********************************************************************************/
 
 /*Include*/
@@ -25,10 +41,10 @@
 /* Variabeln */
 
 /*Struktur zum Speichern der von den A/D-Wandlern des µC ausgelesenen Messdaten*/
-struct SensData stSensData = {.wSensX = 0, .wSensY = 0, .wSensZ = 0};
+struct stSensData stSensData = {.wSensX = 0, .wSensY = 0, .wSensZ = 0};
 
-/*Struktur zum Speichern der umgerechneten Messdaten von SensData*/
-struct WinkelData stWinkelData = {.i16WinkelX = 0, .i16WinkelY = 0, .i16SpannungZ = 0};
+/*Struktur zum Speichern der umgerechneten Messdaten von stSensData*/
+struct stWinkelData stWinkelData = {.i16WinkelX = 0, .i16WinkelY = 0, .i16SpannungZ = 0};
 
 /*Konfiguriert die angegebenen Pins als analoge Eingaenge*/
 AnalogIn oZData(PC_2);
@@ -36,16 +52,16 @@
 AnalogIn oXData(PC_4);
 
 /************************************************************************************
-* void vgetSensData(struct SensData *stSensData)
+* void Sensor_vgetSensData(struct stSensData *stSensData)
 * Zweck:    Auslesen der Sensordaten (X-, Y- und Z-Daten) und speichern in
             Strukturen.          
 * Parameter:
-    *stSensData: Pointer auf eine Struktur vom Type SensData zum Abspeichern 
+    *stSensData: Pointer auf eine Struktur vom Type stSensData zum Abspeichern 
                  der X-, Y-, und Z-Daten des Sensors. 
 * return Parameter:
     keine
 *************************************************************************************/
-void vgetSensData(struct SensData *stSensData){
+void Sensor_vgetSensData(struct stSensData *stSensData){
     /* Variabeln */
     int i=0;                    // Laufvariable
     double XDataRead = 0.0;     // Speichervariabel für X Sampels           
@@ -69,25 +85,26 @@
     }
 
 /************************************************************************************
-* void vcalcData(struct SensData *stSensData, struct WinkelData *stWinkelData)
+* void Sensor_vcalcData(struct stSensData *stSensData, struct stWinkelData *stWinkelData)
 * Zweck:    Umrechnen der Sensorwerte in Winkel, sowie Auswertung der Lage für
             LED-Ansteuerung.         
 * Parameter:
-    *stSensData: Pointer auf eine Struktur vom Type SensData zum Abspeichern 
+    *stSensData: Pointer auf eine Struktur vom Type stSensData zum Abspeichern 
                  der X-, Y-, und Z-Daten des Sensors. 
-    *stWinkelData: Pointer auf eine Struktur vom Typ WinkelData zum Abspeichern
-                   der berechneten Winkel für die X-, Y- und Z-Achse.             
+    *stWinkelData: Pointer auf eine Struktur vom Typ stWinkelData zum Abspeichern
+                   der berechneten Winkel für die X- und Y-Achse, sowie Spannungswert
+                   für die Z-Achse.             
 * return Parameter:
     keine
 *************************************************************************************/    
-void vcalcData(struct SensData *stSensData, struct WinkelData *stWinkelData){
+void Sensor_vcalcData(struct stSensData *stSensData, struct stWinkelData *stWinkelData){
     /*Variablen*/
-    double dGMessX;
-    double dGMessY;
-    double dGMessZ;
+    double dGMessX = 0.0;
+    double dGMessY = 0.0;
+    double dGMessZ = 0.0;
     
-    int iVorzeichenX = 0;
-    int iVorzeichenY = 0;
+    byte bVorzeichenX = 0;
+    byte bVorzeichenY = 0;
     
     /* Berechnung des Z-Winkels */
     dGMessZ = (stSensData->wSensZ/65535.0)*3.3;
@@ -97,7 +114,7 @@
     dGMessX = (stSensData->wSensX/65535.0)*3.3;
     /* Auswertung des Vorzeichens */
     if(dGMessX<URefX){
-        iVorzeichenX = 1;
+        bVorzeichenX = 1;
         }
     stWinkelData->i16WinkelX = dGMessX*10000; 
     dGMessX = (int)(dGMessX*1000)/1000.0;
@@ -106,12 +123,14 @@
     if(dGMessX<=1 || dGMessX>=-1){
     stWinkelData->i16WinkelX = asin(dGMessX)*(180/pi);
         }
-    if(iVorzeichenX) stWinkelData->i16WinkelX = -stWinkelData->i16WinkelX;     
-    /* Berechnung des Y-Winkels */    
+    if(bVorzeichenX) stWinkelData->i16WinkelX = -stWinkelData->i16WinkelX;    
+     
+    /* Berechnung des Y-Winkels */ 
     dGMessY = (stSensData->wSensY/65535.0)*3.3;
+    
     /* Auswertung des Vorzeichens */
     if(dGMessY<URefY){
-        iVorzeichenY = 1;
+        bVorzeichenY = 1;
         }
     stWinkelData->i16WinkelY = dGMessY*10000;
     dGMessY = (int)(dGMessY*1000)/1000.0; 
@@ -120,23 +139,23 @@
     if(dGMessY<=1 || dGMessY>=-1){
     stWinkelData->i16WinkelY = asin(dGMessY)*(180/pi);
         }
-    if(iVorzeichenY) stWinkelData->i16WinkelY = -stWinkelData->i16WinkelY;  
+    if(bVorzeichenY) stWinkelData->i16WinkelY = -stWinkelData->i16WinkelY;  
     }
     
 /************************************************************************************
-* void void vDebugData(struct SensData *stSensData, struct WinkelData *stWinkelData)
+* void void Sensor_vDebugData(struct stSensData *stSensData, struct stWinkelData *stWinkelData)
 * Zweck:    Umrechnung der A/D-Wandler Messwerte in Spannungen zum Kalibrieren der
-            Nulllage und für Debugzwecke. Speicherung der Spannungen in WinkelData         
+            Nulllage und für Debugzwecke. Speicherung der Spannungen in stWinkelData         
 * Parameter:
-    *stSensData: Pointer auf eine Struktur vom Type SensData zum Abspeichern 
-                 der X-, Y-, und Z-Daten des Sensors. 
-    *stWinkelData: Pointer auf eine Struktur vom Typ WinkelData zum Abspeichern
+    *stSensData:   Pointer auf eine Struktur vom Type stSensData zum Abspeichern 
+                   der X-, Y-, und Z-Daten des Sensors. 
+    *stWinkelData: Pointer auf eine Struktur vom Typ stWinkelData zum Abspeichern
                    der berechneten Spannungen in diesem Fall(!) für die X-, Y- und Z-Achse.             
 * return Parameter:
     keine
 *************************************************************************************/    
-void vDebugData(struct SensData *stSensData, struct WinkelData *stWinkelData){
-        /*Variablen*/
+void Sensor_vDebugData(struct stSensData *stSensData, struct stWinkelData *stWinkelData){
+    /*Variablen*/
     double dGMessX;
     double dGMessY;
     double dGMessZ;

--- a/Sensor.h	Tue Jul 12 14:49:28 2016 +0000
+++ b/Sensor.h	Fri Jul 29 14:58:49 2016 +0000
@@ -3,7 +3,13 @@
 * Zweck:        Beinhaltet alle Prototypen zum Auslesen des Beschleunigungssensors
                 bezüglich der X-, Y-, Z-Koordinaten
 * Author:       Simon Rutzen, Nils Kemmer
-* Changes:      keine
+* Changes:      
+    23.05.16    Erstellung des Files, Strukturen und Funktionen vgetSensData, 
+                vcalcdata (Prototypen)
+    28.06.16    vDebugData zur Ermittlung der Spannungswerte vom a-Sensor erstellt
+                (Prototyp)
+    29.07.16    Anpassung an Programmierrichtlinie-Dokument und letzte endgültige
+                Kontrolle Simon Rutzen
 ***********************************************************************************/
 #ifndef LED_H
 
@@ -11,22 +17,22 @@
 #include "cdef.h"
 
 /*Struktur zum Speichern der von den A/D-Wandlern des µC ausgelesenen Messdaten*/
-struct SensData{
+struct stSensData{
     word wSensX;
     word wSensY;
     word wSensZ;
     };
     
-    /*Struktur zum Speichern der umgerechneten Messdaten von SensData*/
-struct WinkelData{
+    /*Struktur zum Speichern der umgerechneten Messdaten von stSensData*/
+struct stWinkelData{
     int16 i16WinkelX;
     int16 i16WinkelY;
     int16 i16SpannungZ;
     };
 
 /* Prototypen */
-void vgetSensData(struct SensData *sSensData);
-void vcalcData(struct SensData *sSensData, struct WinkelData *sWinkelData);
-void vDebugData(struct SensData *stSensData, struct WinkelData *stWinkelData);
+void Sensor_vgetSensData(struct stSensData *sstSensData);
+void Sensor_vcalcData(struct stSensData *stSensData, struct stWinkelData *sWinkelData);
+void Sensor_vDebugData(struct stSensData *stSensData, struct stWinkelData *stWinkelData);
 
 #endif
\ No newline at end of file

--- a/main.cpp	Tue Jul 12 14:49:28 2016 +0000
+++ b/main.cpp	Fri Jul 29 14:58:49 2016 +0000
@@ -1,11 +1,24 @@
 /********************************************************************************** 
 * File name:    main.cpp
 * Zweck:        Beinhaltet das Hauptprogramm. Es werden zyklisch die Daten des Be-
-                schleunigungssensores ausgelesen, umgerechnet in Winkel, LED auf
-                Basis der X-,Y- und Z-Winkel angesteuert und die Winkel auf dem
-                LCD-Display angezeigt.
+                schleunigungssensores ausgelesen, umgerechnet in Winkel, die LED's 
+                auf Basis der X-,Y- und Z-Winkel angesteuert und die Winkel auf dem
+                LCD-Display angezeigt oder die Überkopflage angezeigt.
+                
+                !Hinweis: Es wird die Ungarische Notation verwendet!
+                
 * Author:       Simon Rutzen, Nils Kemmer
-* Changes:      keine
+* Changes:      
+    19.05.16    Erstellung und Einbinden von mbed.h, cdef.h und LCD.h
+    23.05.16    Sensor.h + deren Funktionen eingefügt in Hauptprogramm (auch von LCD.h)
+    24.05.16    Ablauf des Hauptprogrammes geplant und Kommentar verfasst
+    25.05.16    Funktion wait aus mbed.h eingefügt wegen LCD-Anzeige
+    27.05.16    Kommentierung des Funktionablaufes
+    28.05.16    Erweiterung mit Debug-Funktionen von LCD.h und Sensor.h
+    28.06.16    Funktion initLED eingefügt
+    30.06.16    Funktion initLCD eingefügt
+    29.07.16    Anpassung an Programmierrichtlinie-Dokument und letzte endgültige
+                Kontrolle Simon Rutzen
 ***********************************************************************************/
 
 /* Includes */
@@ -15,9 +28,9 @@
 #include "Sensor.h"
 #include "LED.h"
 
-/*Structs*/
-extern struct WinkelData stWinkelData;
-extern struct SensData stSensData;
+/*Structs aus Sensor.cpp bzw. Sensor.h*/
+extern struct stWinkelData stWinkelData;
+extern struct stSensData stSensData;
 
 /* Hauptprogramm */
 int main(){
@@ -25,25 +38,25 @@
     byte bStateLCD = 0;
     
     /* Initialisierung (LCD Anzeige + Blinkende LED's */
-    initLCD();
-    initLED();
+    LCD_vinitLCD();
+    LED_vinitLED();
     
     while(1){
         /* Auslesen des Beschleunigungssensores */
-        vgetSensData(&stSensData);
+        Sensor_vgetSensData(&stSensData);
         
         /* Berechnung der Spannungswerte aus den Messdaten für Debugzwecke */
-        //vDebugData(&stSensData, &stWinkelData);
+        //Sensor_vDebugData(&stSensData, &stWinkelData);
         
         /* Berechnung der Winkel aus Messdaten */
-        vcalcData(&stSensData, &stWinkelData);
+        Sensor_vcalcData(&stSensData, &stWinkelData);
         
         /* Einstellen der LED's*/
-        bStateLCD = setLED(stWinkelData.i16WinkelX, stWinkelData.i16WinkelY, stWinkelData.i16SpannungZ);
+        bStateLCD = LED_bsetLED(stWinkelData.i16WinkelX, stWinkelData.i16WinkelY, stWinkelData.i16SpannungZ);
         
         /* Einstellen des LCD-Displays*/
-        vLCDSet(stWinkelData.i16WinkelX, stWinkelData.i16WinkelY, bStateLCD);
-        //vLCDDebug(stWinkelData.i16WinkelX, stWinkelData.i16WinkelY, stWinkelData.i16SpannungZ);
+        LCD_vLCDSet(stWinkelData.i16WinkelX, stWinkelData.i16WinkelY, bStateLCD);
+        //LCD_vLCDDebug(stWinkelData.i16WinkelX, stWinkelData.i16WinkelY, stWinkelData.i16SpannungZ);
         /* Pause */
         wait_ms(100);
         }