/****************************************************************************
 *
 * Projekt			:	Magnetfeldmessgerät Kartuschenventil
 * Dateiname		:	AppMonitor.c
 * Autor			:	orginal MHoffmann, abgeändert für dieses Projekt Eros Schatzmayer
 * Erstellungsdatum	:	15.05.2020
 * Beschreibung		:	"Command Handler der Monitorschnittstelle"
 *
 *
 * Versionsgeschichte
 * 	Revision 1.0   15.05.2020 SCE erste Version
 *
 ****************************************************************************/

//****************************************************************************
// Includes
#include "AppMonitor.h"

//****************************************************************************
// Konstanten
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
/* Command-Handler Tabelle mit Funktionsaufrufen (Beispiel)
   Definiert wird die Struktur im applikationsspezifischen Monitormodul. */
const TMonitorCommandEntry gudt_MonitorCommandList[] =
{
    {"hilf"		,AppMonitor_ListHelp		,"  ..."},
		
	/*{"cal"		,AppMonitor_Calibrate		," Kalibrierung"},*/
		
	{"clr"      ,AppMonitor_ClrEe           ," Testspeicher loeschen"},
	{"ee"       ,AppMonitor_ShowEE          ,"Eepromdaten anzeigen"},
		
	/*{"get"      ,AppMonitor_GetPoti         ," kont. Messwerte anzeigen"},*/
		
	{"getd"     ,AppMonitor_GetTD           ,"  Testspeicher auslesen"},
	{"gtim"		,AppMonitor_GetTime		    ,"  Zeit lesen"},
	{"gtmp"     ,AppMonitor_GetTemp         ,"  Temperatur lesen"},
	{"set"      ,AppMonitor_SetTestPar      ," Konfiguration Testparameter"},
	{"stim"		,AppMonitor_SetTime		    ,"  Zeit setzen"},
	{"ver"		,AppMonitor_ShowVersion		," Versionsinfo anzeigen"},
    {""			,(TMonitorFunction)NULL		,""}
};

//****************************************************************************
// Globale Variablen
static char gstr_ConvertTmpBuffer[UARTMAXTXBUFSIZE];   // nur uebergangsweise bis zur ueberarbeitung

//------------------------------------------------------------------------
// Globale Monitor-Commandinterpreter-Struktur
TMonitorPara gudt_MonitorPara;
uint8_t	gu8_FirstRun = 1;

//****************************************************************************
// Funktionen

int16_t AppMonitor_Init()
/*==================================================================JoeCAE-FS=
    Funktion:       Monitor_Init
    Ü-Parameter:    -
    R-Parameter:    Fehlercode
    Beschreibung:   Intialisiert den Monitor Commandinterpreter
 *==========================================================================*/
{
    int16_t   int_Ergebnis = 0;

    //Monitor Datenstruktur initialisieren: alles auf 0
    memset(&gudt_MonitorPara,0,sizeof(gudt_MonitorPara));

    //Initialen State setzen
    gudt_MonitorPara.u8_State = MONITOR_STATE_OUTPUTPROMPT;

    //Startmeldung ausgeben
    int_Ergebnis |= AppMonitor_ShowVersion();

    //Wenn Ausgabe NICHT fehlerfrei
    if (int_Ergebnis < ERROR_NOERROR)
    {
        int_Ergebnis = ERROR_MONITOR_INIT;
    }//kein else

    return int_Ergebnis;
}

int16_t AppMonitor_Handler()
/*==================================================================JoeCAE-FS=
 *
 *  Funktion:       MtMonitor_Handler
 *  Ü-Parameter:    -
 *  R-Parameter:    Fehlercode
 *  Beschreibung:   Wird solange durchlaufen, bis der Befehl zum Ruecksprung
 *                  in die Betriebssoftware gegegeben wurde. Initialisiert
 *                  zunaechst die Command-Struktur und wartet dann auf eine
 *                  Eingabe. Ist diese erfolgt, werden Command und ggf.
 *                  Argumente registriert und das Command ausgefuehrt.
 *==========================================================================*/
{
    int16_t   int_i;
    int16_t   int_Ergebnis = ERROR_NOERROR;
    int16_t   int_Fehler   = ERROR_NOERROR;

    switch (gudt_MonitorPara.u8_State)
    {
        //State 0: Prompt ausgeben 
        case MONITOR_STATE_OUTPUTPROMPT:
        {
            //Argument-Variablen zurücksetzen
            gudt_MonitorPara.u8_ArgumentAnzahl   = 0;
            gudt_MonitorPara.pstr_Argument[0]      = NULL;
            gudt_MonitorPara.pstr_Argument[1]      = NULL;
            gudt_MonitorPara.pstr_Argument[2]      = NULL;

            //Prompt ausgeben
			int_Ergebnis = DrvUart_Newline(&gudt_MoniIntf);
            int_Ergebnis = DrvUart_Puts(&gudt_MoniIntf, "->");

            if (int_Ergebnis == ERROR_NOERROR)
            {
                //weiter zu "Warten auf Commandstring"
                gudt_MonitorPara.u8_State = MONITOR_STATE_WAITCOMMAND;
                gudt_MonitorPara.u8_UserState    = MONITOR_USERSTATE_INAKTIV;
                gudt_MonitorPara.u8_UserSubState = 0;
                gudt_MonitorPara.u8_UserIndex    = 0;
                gudt_MonitorPara.u32_UserTimer     =0;
                gudt_MonitorPara.u32_UserVariable32=0;
            }
            else
            {
                int_Ergebnis = ERROR_NOERROR;
            }
            break;
        }
        //State 1: Warten auf Commandstring
        case MONITOR_STATE_WAITCOMMAND:
        {
            //auf eine Eingabe warten (muss mit ENTER abgeschlossen werden) 
            int_Ergebnis = AppMonitor_GetString(gudt_MonitorPara.str_Eingabe);

            //Wenn kompletter Commandstring vorliegt.. 
            if (int_Ergebnis > 0)
            {
                //Weiter zur Commandstring-Untersuchung.. 
                gudt_MonitorPara.u8_State = MONITOR_STATE_CHECKCOMMAND;
            }
            else
            {
                //Wenn Fehler bei Warten auf Command... 
                if (int_Ergebnis < 0)
                {
                    //und zurueck auf Anfang (Ausgabe "->") 
                    gudt_MonitorPara.u8_State = MONITOR_STATE_OUTPUTPROMPT;
                }
                else
                {
                    int_Ergebnis = ERROR_NOERROR;
                }
            }
            break;
        }
        //State 2: Commandstring-Untersuchung..
        case MONITOR_STATE_CHECKCOMMAND:
        {
            //Commandargumente feststellen und separieren
            AppMonitor_CommandArguments(gudt_MonitorPara.str_Eingabe);

            //Wenn keine Argumente (= kein Command):
            if(gudt_MonitorPara.u8_ArgumentAnzahl == 0)
            {
                //zurueck auf Anfang (Ausgabe "->")
                gudt_MonitorPara.u8_State = MONITOR_STATE_OUTPUTPROMPT;
            }
            else
            {
                //Command aus der Liste suchen... 
                for(int_i = 0; (gudt_MonitorCommandList[int_i].pstr_CommandName[0] != 0); int_i++)
                {
                    //Command mit den Listen-Commands vergleichen. Wenn Command erkannt..
                    if(0==strcmp(gudt_MonitorCommandList[int_i].pstr_CommandName,gudt_MonitorPara.pstr_Argument[0]))
                    {
                        //Funktions-Index festhalten und..
                        gudt_MonitorPara.u8_CommandIndex = (uint8_t)int_i;

                        //weiter zur Ausführung 
                        gudt_MonitorPara.u8_State = MONITOR_STATE_RUNSUBFUNCTION;

                        //Variablen fuer Run MonitorFunc initialisieren
		                gudt_MonitorPara.u8_UserState    = MONITOR_USERSTATE_INAKTIV;
		                gudt_MonitorPara.u8_UserSubState = 0;
		                gudt_MonitorPara.u8_UserIndex    = 0;
                        break;
                    }
                }
                //Wenn Command unbekannt... 
                if (gudt_MonitorCommandList[int_i].pstr_CommandName[0] == 0)
                {
					int_Ergebnis = DrvUart_Newline(&gudt_MoniIntf);
                    int_Ergebnis = DrvUart_Puts(&gudt_MoniIntf, "Cmd Err");

                    //Wenn Problem bei der Ausgabe...
                    if (int_Ergebnis != ERROR_NOERROR)
                    {
                        int_Ergebnis = ERROR_MONITOR_CHECKCMD;
                    }//kein else

                    //und zurueck auf Anfang (Ausgabe "->") 
                    gudt_MonitorPara.u8_State = MONITOR_STATE_OUTPUTPROMPT;
                }
            }
            break;
        }
        //State 3: Monitorfunktion ausführen... 
        case MONITOR_STATE_RUNSUBFUNCTION:
        {
            //Monitorfunktion ausführen... 
            int_Ergebnis = gudt_MonitorCommandList[gudt_MonitorPara.u8_CommandIndex].pfunc_CommandFunction(); 

            //Wenn Funktion beendet... 
            if (int_Ergebnis > 0)
            {
                int_Ergebnis = ERROR_NOERROR;

                //weiter zum Abschluss.. 
                gudt_MonitorPara.u8_State = MONITOR_STATE_ENDSUBFUNCTION;
            }
            else
            {
                //Wenn Funktion fehlerhaft beendet... 
                if (int_Ergebnis < 0)
                {
                    int_Fehler = int_Ergebnis;

                    int_Ergebnis |= DrvUart_Puts(&gudt_MoniIntf, "err [mon]");
					int_Ergebnis |= DrvUart_Putint(&gudt_MoniIntf, int_Fehler);

                    //zurueck auf Anfang (Ausgabe "->") 
                    gudt_MonitorPara.u8_State = MONITOR_STATE_OUTPUTPROMPT;

                    //Wenn Problem bei der Fehlerausgabe... 
                    if (int_Ergebnis != ERROR_NOERROR)
                    {
                        int_Ergebnis = ERROR_MONITOR_RUNFUNCTION;
                    }
                    else
                    {
                        int_Ergebnis = ERROR_NOERROR;
                    }
                }
                else
                {
                    int_Ergebnis = ERROR_NOERROR;
                }
            }
            break;
        }
        //State 4: Abschluss Monitor Subfunktion 
        case MONITOR_STATE_ENDSUBFUNCTION:
        {
            //CR/LF-Ausgabe 
            int_Ergebnis = DrvUart_Newline(&gudt_MoniIntf);

            if (int_Ergebnis >=ERROR_NOERROR)
            {

                //zurueck auf Anfang (Ausgabe "->") 
                gudt_MonitorPara.u8_State = MONITOR_STATE_OUTPUTPROMPT;
            }
            //Wenn NICHT erfolgreich: 
            else
            {
                //Fehlermeldung ignorieren und im State verbleiben 
                int_Ergebnis =ERROR_NOERROR;
            }
            break;
        }
        //wenn unbekannter State... 
        default:
        {
            //Rückgabe Fehlernummer
            int_Ergebnis = ERROR_MONITOR_STATE;
            //Monitor in definierten Zustand bringen
            gudt_MonitorPara.u8_State = MONITOR_STATE_OUTPUTPROMPT;
        }
    } 
    //wenn bisher kein Fehler auftrat...
    if (int_Ergebnis == ERROR_NOERROR)
    {
        //Wenn Fehler in I/O Schnittstelle oder in der Ausführung der GetError-Funktion
        if (int_Ergebnis != ERROR_NOERROR)
        {
            if (int_Ergebnis<ERROR_NOERROR)
            {
                int_Ergebnis = ERROR_MONITOR_CHKIOPORT;
            }
        }
    }
    return int_Ergebnis;
}

int16_t AppMonitor_GetString(char* pstr_String)
/*==================================================================JoeCAE-FS=
 *
 *  Funktion:       Monitor_GetString
 *  Ü-Parameter:    Zeiger auf Ziel-String
 *  R-Parameter:    0 solange kein String eingelesen wurde,
 *                  1 wenn ein Commandstring mit CR abgeschlosssen wurde
 *  Beschreibung:   Liest einen String bis "CR" ein, schliesst ihn mit NULL
 *                  ab und gibt einen Zeiger auf den String zurueck, wenn der
 *                  String fehlerfrei eingelesen wurde. Bei Empfang eines
 *                  ESC-Zeichens wird der Empfang abgebrochen und eine NULL
 *                  zurueckgegeben!
 *==========================================================================*/
{
    int16_t int_Ergebnis = ERROR_NOERROR;
    int16_t int_Zeichen;

    //Sub-FunctionState ermitteln 
    switch (gudt_MonitorPara.u8_UserState)
    {
        //Init-State..
        case MONITOR_USERSTATE_INAKTIV:      // Start einer jeden Monitor-Subfunktion
        {
            //String initialisieren
            *pstr_String = 0x0;
            int_Zeichen = 0x0;

            //Initialisiere Subindex..
            gudt_MonitorPara.u8_UserIndex = 0;

            //..und weiter zur Hilfegausgabe..
            gudt_MonitorPara.u8_UserState = GETSTR_ZEICHENLESEN;
            // hier Absichtlich kein break ...
        }
        //Zeichen einlesen, bis CR oder LF  */
        case GETSTR_ZEICHENLESEN:
        {
            //wenn Zeichen empfangen: lesen und ueberpruefen auf.. 
            int_Ergebnis = gudt_MoniIntf.udt_rxbuf.u8_count;

            if (int_Ergebnis > 0)
            {
                int_Ergebnis = ERROR_NOERROR;
                int_Zeichen = DrvUart_Getchar(&gudt_MoniIntf);
                switch (int_Zeichen)
                {
                    //wenn LineFeed empfangen wurde : Zeichen ignorieren 
                    case LF:
                    {
                        break;
                    }
                    //wenn Carriage Return empfangen wurde : Abbruch 
                    case CR:
                    {
                        int_Ergebnis = 1;
                        break;
                    }
                    //wenn Backspace empfangen wurde : senden von BS,Blank,BS um Zeichenauf dem Bildschirm zu loeschen!
                    case BS:
                    {
                        if (gudt_MonitorPara.u8_UserIndex!=0)
                        {
                            DrvUart_Putchar(&gudt_MoniIntf, BS);
                            DrvUart_Putchar(&gudt_MoniIntf, ' ');
                            DrvUart_Putchar(&gudt_MoniIntf, BS);
                            gudt_MonitorPara.u8_UserIndex--;
                            pstr_String[gudt_MonitorPara.u8_UserIndex] = 0x0;
                        }
                        break;
                    }
                    //wenn ESC empfangen wurde : Ruecksetzen des Strings, Abbruch 
                    case ESC:
                    {
                        *pstr_String = 0x0;
                        DrvUart_Putchar(&gudt_MoniIntf, '\n');
                        break;
                    }
                    //alle sonstigen Zeichen speichern 
                    default:
                    {
                        pstr_String[gudt_MonitorPara.u8_UserIndex++] = (uint8_t)int_Zeichen;
                        pstr_String[gudt_MonitorPara.u8_UserIndex] = 0x0;
                        DrvUart_Putchar(&gudt_MoniIntf, (uint8_t)int_Zeichen);
                    }
                } 
                //Wenn Commandstring "voll" ODER CR empfangen ODER LF empfangen..  
                if ( (gudt_MonitorPara.u8_UserIndex >= (MONITOR_MAXCOMMANDLENGTH-1)) ||
                     (int_Zeichen == CR)||(int_Zeichen == ESC) )
                {
                    //Funktion beenden..  */
                    gudt_MonitorPara.u8_UserState = MONITOR_USERSTATE_READY;
                    int_Ergebnis = ERROR_NOERROR;
                }
            }
            //wenn KEIN Zeichen empfangen: im State verbleiben 
            else
            {
                int_Ergebnis = ERROR_NOERROR;
            }
            break;
        } 

        //Wenn Last-State  
        case MONITOR_USERSTATE_READY:            //Abschluss einer JEDEN SubFunktion
        {
            //Substate wieder auf "inaktiv  
            gudt_MonitorPara.u8_UserState = MONITOR_USERSTATE_INAKTIV;

            //Rückgabe "fertig" 
            int_Ergebnis = MONITOR_SUBFUNCTION_READY;
            break;
        }
        //Wenn unbekannter SubState  
        default:
        {
            int_Ergebnis = ERROR_MONITOR_GETSTR_SUBSTATE;
            break;
        }
    }
    return int_Ergebnis;
}

int16_t AppMonitor_CommandArguments(char* pstr_Eingabe)
/*==================================================================JoeCAE-FS=
 *
 *  Funktion:       Monitor_CommandArguments
 *  Ü-Parameter:    Zeiger auf den Argumentstring
 *  R-Parameter:    Fehlercode
 *  Beschreibung:   Untersucht den uebergebenen Command-String auf einen oder
 *                  mehrere Argumente. Das Command zaehlt als Argument mit.
 *                  Ist der Argumentzaehler NULL, ist kein Command erfolgt.
 *==========================================================================*/
{
	char*  puchr_s1;
	char*  puchr_s2;
	uint8_t   u8_Flag;
    uint8_t   u8_Index;

    //lokalen Stringzeiger auf die Argumentliste laden 
    puchr_s1   = pstr_Eingabe;
    puchr_s2   = puchr_s1;

    //alle gudt_MonitorPara.pstr_Argument[] erstmal auf einen definierten Wert setzen
    for (u8_Index=0; u8_Index < MONITOR_MAXARGUMENTS; u8_Index++)
    {
        gudt_MonitorPara.pstr_Argument[u8_Index]=NULL;
    }

    //Loop bis Argumentlistenstring zu Ende... 
    u8_Flag = 0;
    for (u8_Index=0; (*puchr_s2!=0) && (u8_Index<MONITOR_MAXARGUMENTS); puchr_s2++)
    {
        if (u8_Flag)
        {
            //wenn ein nicht_alphanumerisches Zeichen gelesen wird: Argumentzaehler erhoehen,Argumentstringzeiger in die 
            //Argumentzeigerliste eintragen sonst weiterlesen, bis ein nicht_alphanumerisches Zeichen gelesen wird. 
            if (*puchr_s2==' ') // Fuer FAT: "D:\Bla" soll 1 Argument sein
            {
            	u8_Flag = 0;
                gudt_MonitorPara.pstr_Argument[u8_Index] = puchr_s1;
                u8_Index++;
                *puchr_s2 = '\0';
            }
        }
        else
        {
            //wenn ein alphanumerisches Zeichen gelesen wird: Merker setzen,
            //sonst weiterlesen, bis ein alphanumerisches Zeichen gelesen wird.
            if (*puchr_s2!=' ') // Fuer FAT: "D:\Bla" soll 1 Argument sein
            {
            	u8_Flag = 1;
                puchr_s1 = puchr_s2;
            }
        }
    }

    //wenn vorher ein alphanumerisches Zeichen gelesen wurde: Argumentzaehler 
    //nochmal erhoehen und Argumentstringzeiger in die Argumentzeigerliste eintragen. 
    if (u8_Flag) {
        gudt_MonitorPara.pstr_Argument[u8_Index] = puchr_s1;
        u8_Index++;
    }

    //Anzahl der Argumente eintragen
    gudt_MonitorPara.u8_ArgumentAnzahl=u8_Index;

    return ERROR_NOERROR;
}

int16_t AppMonitor_ListHelp()
/*==================================================================JoeCAE-FS=
    Funktion:       MtMonitor_ListHelp
    R-Parameter:    Fehlercode
    Beschreibung:   Gibt die Befehlsliste der Monitorfunktionen aus.
 *==========================================================================*/
{
    int16_t int_Ergebnis = ERROR_NOERROR;
    const TMonitorCommandEntry* pudt_Command;
    uint32_t u32_Len;

    //Sub-FunctionState ermitteln
    switch (gudt_MonitorPara.u8_UserState)
    {
        //Init-State..
        case MONITOR_USERSTATE_INAKTIV:      //Start einer jeden Monitor-Subfunktion
        {
            //Initialisiere Subindex..
            gudt_MonitorPara.u8_UserIndex = 0;

			//Zeile umbrechen
			DrvUart_Newline(&gudt_MoniIntf);

            //..und weiter zur Hilfegausgabe..
            gudt_MonitorPara.u8_UserState = HILFE_HILFEAUSGABE;
            //Absichtlich kein break hier...
        }
        //State : Ausgabe der Nicht-Supervisor-Monitorfunktionen 
        case HILFE_HILFEAUSGABE:
        {
            //Wenn Tabellenende NICHT erreicht...
            pudt_Command=&gudt_MonitorCommandList[gudt_MonitorPara.u8_UserIndex];

            if (pudt_Command->pfunc_CommandFunction != NULL)
            {
				if (UARTMAXTXBUFSIZE - gudt_MoniIntf.udt_txbuf.u8_count > 16) //die TX Queue nicht bis Anschlag volldonnern
				{
					//Zeile ausgeben */
					if (gudt_MonitorPara.u8_UserSubState==0)
					{
						//Name des Commands ausgeben mit ein paar Leerzeichen hinten dran
						strncpy(gstr_ConvertTmpBuffer,pudt_Command->pstr_CommandName,sizeof(gstr_ConvertTmpBuffer));
						gstr_ConvertTmpBuffer[sizeof(gstr_ConvertTmpBuffer)-2]=0; //Sicherheitshalber
						strcat(gstr_ConvertTmpBuffer," \t");
						u32_Len=strlen(gstr_ConvertTmpBuffer);
						while (u32_Len<10)
						{
							gstr_ConvertTmpBuffer[u32_Len]=' ';
							u32_Len++;
						}
						gstr_ConvertTmpBuffer[u32_Len]=0;

						int_Ergebnis=DrvUart_Puts(&gudt_MoniIntf, gstr_ConvertTmpBuffer);
						if (int_Ergebnis>=ERROR_NOERROR)
						{
							gudt_MonitorPara.u8_UserSubState=1;
						}
						else
						{
							//Fehlermeldung ignorieren und im State mit dem aktuellen SubState und Index verbleiben
							//fuer erneuten Versuch beim naechsten Handleraufruf.
							int_Ergebnis=ERROR_NOERROR;
						}
					}

					if (gudt_MonitorPara.u8_UserSubState==1)
					{
						int_Ergebnis = DrvUart_Puts(&gudt_MoniIntf, (char*)pudt_Command->pstr_Help);
						int_Ergebnis |= DrvUart_Newline(&gudt_MoniIntf);

						if (int_Ergebnis==ERROR_NOERROR)
						{
							gudt_MonitorPara.u8_UserSubState=0;
							gudt_MonitorPara.u8_UserIndex++;
						}
						else
						{
							//Fehlermeldung ignorieren und im State mit dem aktuellen SubState und Index verbleiben
							//fuer erneuten Versuch beim naechsten Handleraufruf.
							int_Ergebnis=ERROR_NOERROR;
						}
					}
				}
            }
            //Wenn Tabellenende erreicht...
            else
            {
                //Ausgabefunktion beenden...
                gudt_MonitorPara.u8_UserState = MONITOR_USERSTATE_READY;
            }
            break;
        }
        //Wenn Last-State  
        case MONITOR_USERSTATE_READY:            //Abschluss einer JEDEN SubFunktion
        {
            //Substate wieder auf "inaktiv  
            gudt_MonitorPara.u8_UserState = MONITOR_USERSTATE_INAKTIV;

            int_Ergebnis = MONITOR_SUBFUNCTION_READY;
            break;
        }
        default:
        {
            int_Ergebnis = ERROR_MONITOR_HILFE_SUBSTATE;
            break;
        }
    }
    return int_Ergebnis;
}

int16_t AppMonitor_ShowVersion()
/*==================================================================JoeCAE-FS=
    Funktion:       Monitor_ShowVersion
    R-Parameter:    Fehlercode
    Beschreibung:   Ausgabe von Versionsinformationen
 *==========================================================================*/
{
	DrvUart_Newline(&gudt_MoniIntf);
    DrvUart_Puts(&gudt_MoniIntf, (char*)gudt_SoftwareVersion.str_SoftwareTitle);
    DrvUart_Puts(&gudt_MoniIntf, " v");
    DrvUart_Putuint(&gudt_MoniIntf, gudt_SoftwareVersion.u16_SoftwareVersionMajor);
    DrvUart_Puts(&gudt_MoniIntf, ".");
    DrvUart_Putuint(&gudt_MoniIntf, gudt_SoftwareVersion.u16_SoftwareVersionMinor);
	DrvUart_Puts(&gudt_MoniIntf, " (");
	DrvUart_Puts(&gudt_MoniIntf, (char*)gudt_SoftwareVersion.str_SoftwareDate);
	DrvUart_Puts(&gudt_MoniIntf, ", ");
	DrvUart_Puts(&gudt_MoniIntf, (char*)gudt_SoftwareVersion.str_SoftwareTime);
	DrvUart_Puts(&gudt_MoniIntf, ")");

    return MONITOR_SUBFUNCTION_READY;
}

//Testdaten loeschen
int16_t AppMonitor_ClrEe(void)
{
	//"Speicher-Belegt-Zaehler" zuruecksetzen
	gudt_IntEedata.u32_CycleCnt = 0;
	gudt_IntEedata.u16_ExtEepromWritePtr = 0;
	
	//int.Eeprom schreiben
	ObjSample_SaveIntEedata();
	
	//ext. Eeprom loeschen
	DrvEep_CE();
	
    return MONITOR_SUBFUNCTION_READY;
}

int16_t AppMonitor_SetTestPar(void)
{
	int16_t	i16_Ergebnis = ERROR_NOERROR;
	int16_t	i16_InChar = 0;
	static uint8_t	u8_SubState = 1;
	static uint16_t u16_InVal = 0;
	static uint8_t u8_NegFlag = 0;

	switch (u8_SubState)
	{
		case 1:	//show main menu
			DrvUart_Newline(&gudt_MoniIntf);
			DrvUart_Puts(&gudt_MoniIntf, "Set TestParameters\r\n");
			DrvUart_Puts(&gudt_MoniIntf, "------------------");
			u8_SubState = 2;
			i16_Ergebnis = MONITOR_SUBFUNCTION_CALLAGAIN;
			break;

		case 2: //show current values
			DrvUart_Newline(&gudt_MoniIntf);
			DrvUart_Puts(&gudt_MoniIntf, "\r\nSettings:\r\n");

			/*DrvUart_Puts(&gudt_MoniIntf, "K+_min\t");
			DrvUart_Putint(&gudt_MoniIntf, gudt_IntEedata.udt_TestPara.i16_minTol[0]);
			DrvUart_Puts(&gudt_MoniIntf, " /100mm\r\n");

			DrvUart_Puts(&gudt_MoniIntf, "K+_max\t");
			DrvUart_Putint(&gudt_MoniIntf, gudt_IntEedata.udt_TestPara.i16_maxTol[0]);
			DrvUart_Puts(&gudt_MoniIntf, " /100mm\r\n");

			DrvUart_Puts(&gudt_MoniIntf, "K-_min\t");
			DrvUart_Putint(&gudt_MoniIntf, gudt_IntEedata.udt_TestPara.i16_minTol[1]);
			DrvUart_Puts(&gudt_MoniIntf, " /100mm\r\n");

			DrvUart_Puts(&gudt_MoniIntf, "K-_max\t");
			DrvUart_Putint(&gudt_MoniIntf, gudt_IntEedata.udt_TestPara.i16_maxTol[1]);
			DrvUart_Puts(&gudt_MoniIntf, " /100mm\r\n");*/
			
			/*DrvUart_Puts(&gudt_MoniIntf, "Dauermagnet min\t");
			DrvUart_Putint(&gudt_MoniIntf, gudt_IntEedata.udt_TestPara.i16_minTol[0]);
			DrvUart_Puts(&gudt_MoniIntf, " Gauss\r\n");

			DrvUart_Puts(&gudt_MoniIntf, "Dauermagnet max\t");
			DrvUart_Putint(&gudt_MoniIntf, gudt_IntEedata.udt_TestPara.i16_maxTol[0]);
			DrvUart_Puts(&gudt_MoniIntf, " Gauss\r\n");

			DrvUart_Puts(&gudt_MoniIntf, "Spule min\t");
			DrvUart_Putint(&gudt_MoniIntf, gudt_IntEedata.udt_TestPara.i16_minTol[1]);
			DrvUart_Puts(&gudt_MoniIntf, " Gauss\r\n");

			DrvUart_Puts(&gudt_MoniIntf, "Spule max\t");
			DrvUart_Putint(&gudt_MoniIntf, gudt_IntEedata.udt_TestPara.i16_maxTol[1]);
			DrvUart_Puts(&gudt_MoniIntf, " Gauss\r\n");*/
			
			DrvUart_Puts(&gudt_MoniIntf, "Dauermagnet min\t");
			DrvUart_Putint(&gudt_MoniIntf, gudt_IntEedata.udt_TestParaDM.i16_minTolDM);
			DrvUart_Puts(&gudt_MoniIntf, " Gauss\r\n");
			
			DrvUart_Puts(&gudt_MoniIntf, "Dauermagnet min\t");
			DrvUart_Putint(&gudt_MoniIntf, gudt_IntEedata.udt_TestParaDM.i16_maxTolDM);
			DrvUart_Puts(&gudt_MoniIntf, " Gauss\r\n");
			
			DrvUart_Puts(&gudt_MoniIntf, "Dauermagnet min\t");
			DrvUart_Putint(&gudt_MoniIntf, gudt_IntEedata.udt_TestParaCoil.i16_minTolCoil);
			DrvUart_Puts(&gudt_MoniIntf, " Gauss\r\n");
			
			DrvUart_Puts(&gudt_MoniIntf, "Dauermagnet min\t");
			DrvUart_Putint(&gudt_MoniIntf, gudt_IntEedata.udt_TestParaCoil.i16_maxTolCoil);
			DrvUart_Puts(&gudt_MoniIntf, " Gauss\r\n");

			DrvUart_Transmit(&gudt_MoniIntf);	//UEbertragen der Daten des Monitorsendepuffers

			//DrvUart_Puts(&gudt_MoniIntf, "Tol.\t");
			//DrvUart_Putbyte(&gudt_MoniIntf, gudt_IntEedata.udt_TestPara.u8_Tol);
			//DrvUart_Puts(&gudt_MoniIntf, " /100mm\r\n");

			//DrvUart_Puts(&gudt_MoniIntf, "KOffs\t");
			//DrvUart_Putint(&gudt_MoniIntf, gudt_IntEedata.udt_TestPara.i16_KalibOffset);
			//DrvUart_Puts(&gudt_MoniIntf, " /100mm\r\n");

			DrvUart_Puts(&gudt_MoniIntf, "\r\n[e]dit [q]uit ? \r\n");

			u8_SubState = 3;
			i16_Ergebnis = MONITOR_SUBFUNCTION_CALLAGAIN;
			break;

		case 3:	//main menu - wait input
			switch (DrvUart_Getchar(&gudt_MoniIntf))
			{
				case 'e':
				case 'E':
					u8_SubState = 4;
					i16_Ergebnis = MONITOR_SUBFUNCTION_CALLAGAIN;
					break;

				case 'Q':
				case 'q':
				case ESC:
					u8_SubState = 99;
					i16_Ergebnis = MONITOR_SUBFUNCTION_CALLAGAIN;
					break;

				default:
					i16_Ergebnis = MONITOR_SUBFUNCTION_CALLAGAIN;
			}

			i16_Ergebnis = MONITOR_SUBFUNCTION_CALLAGAIN;
			break;

		case 4: //show change menu

			/*DrvUart_Newline(&gudt_MoniIntf);
			DrvUart_Puts(&gudt_MoniIntf, "change settings:\r\n");
			DrvUart_Puts(&gudt_MoniIntf, "0 - K+_min\r\n");
			DrvUart_Puts(&gudt_MoniIntf, "1 - K+_max\r\n");
			DrvUart_Puts(&gudt_MoniIntf, "2 - K-_min\r\n");
			DrvUart_Puts(&gudt_MoniIntf, "3 - K-_max\r\n");
			DrvUart_Puts(&gudt_MoniIntf, "t - Toleranz\r\n");
			DrvUart_Puts(&gudt_MoniIntf, "k - KalOffset\r\n");
			DrvUart_Puts(&gudt_MoniIntf, "b - back\r\n");*/
			
			// Eros Schatzmayer - 15.05.2020
			DrvUart_Newline(&gudt_MoniIntf);
			DrvUart_Puts(&gudt_MoniIntf, "change settings:\r\n");
			DrvUart_Puts(&gudt_MoniIntf, "0 - Mag_min\r\n");
			DrvUart_Puts(&gudt_MoniIntf, "1 - Mag_max\r\n");
			DrvUart_Puts(&gudt_MoniIntf, "2 - L_min\r\n");
			DrvUart_Puts(&gudt_MoniIntf, "3 - L_max\r\n");
			DrvUart_Puts(&gudt_MoniIntf, "b - back\r\n");

			u8_SubState = 5;

			i16_Ergebnis = MONITOR_SUBFUNCTION_CALLAGAIN;
			break;

		case 5: //input change value
			u8_NegFlag = 0;
			switch (DrvUart_Getchar(&gudt_MoniIntf))
			{
			    case '0': u8_SubState = 10; DrvUart_Puts(&gudt_MoniIntf, "\rnew value> ");u16_InVal=0;break;
				case '1': u8_SubState = 11; DrvUart_Puts(&gudt_MoniIntf, "\rnew value> ");u16_InVal=0;break;
				case '2': u8_SubState = 12; DrvUart_Puts(&gudt_MoniIntf, "\rnew value> ");u16_InVal=0;break;
				case '3': u8_SubState = 13; DrvUart_Puts(&gudt_MoniIntf, "\rnew value> ");u16_InVal=0;break;
				//case 't': u8_SubState = 19; DrvUart_Puts(&gudt_MoniIntf, "\rnew value> ");u16_InVal=0;break;	
				//case 'k': u8_SubState = 20; DrvUart_Puts(&gudt_MoniIntf, "\rnew value> ");u16_InVal=0;break;
				case 'b':
				case ESC: u8_SubState = 1; break;
				

				default:
					;
			}

			i16_Ergebnis = MONITOR_SUBFUNCTION_CALLAGAIN;
			break;

		case 10:
		case 11:
		case 12:
		case 13:
		//case 19:
		//case 20:
		{
			i16_InChar = DrvUart_Getchar(&gudt_MoniIntf);

			if (i16_InChar != ERROR_DRVUART_GETCHAR_EMPTYBUF)
			{
				switch ((uint8_t)i16_InChar)
				{
					case '0':
					case '1':
					case '2':
					case '3':
					case '4':
					case '5':
					case '6':
					case '7':
					case '8':
					case '9':
						DrvUart_Putchar(&gudt_MoniIntf, (uint8_t)i16_InChar);
						u16_InVal *= 10;
						u16_InVal += (((uint8_t)i16_InChar)-'0');
						break;
					case '-':
						DrvUart_Putchar(&gudt_MoniIntf, (uint8_t)i16_InChar);
						u8_NegFlag = 1;
						break;
					case CR:
						//Wert uebernehmen und in das Hauptmenue springen
						switch (u8_SubState)
						{
							case 10:
								//gudt_IntEedata.udt_TestPara.i16_minTol[0] = (int16_t)u16_InVal;
								//if (u8_NegFlag) gudt_IntEedata.udt_TestPara.i16_minTol[0] *= -1;
								gudt_IntEedata.udt_TestParaDM.i16_minTolDM = (int16_t)u16_InVal;
								if (u8_NegFlag) gudt_IntEedata.udt_TestParaDM.i16_minTolDM *= -1;
								break;
							case 11:
								//gudt_IntEedata.udt_TestPara.i16_maxTol[0] = (int16_t)u16_InVal;
								//if (u8_NegFlag) gudt_IntEedata.udt_TestPara.i16_maxTol[0] *= -1;
								gudt_IntEedata.udt_TestParaDM.i16_maxTolDM = (int16_t)u16_InVal;
								if (u8_NegFlag) gudt_IntEedata.udt_TestParaDM.i16_maxTolDM *= -1;
								break;
							case 12:
								//gudt_IntEedata.udt_TestPara.i16_minTol[1] = (int16_t)u16_InVal;
								//if (u8_NegFlag) gudt_IntEedata.udt_TestPara.i16_minTol[1] *= -1;
								gudt_IntEedata.udt_TestParaCoil.i16_minTolCoil = (int16_t)u16_InVal;
								if (u8_NegFlag) gudt_IntEedata.udt_TestParaCoil.i16_minTolCoil *= -1;
								break;
							case 13:
								//gudt_IntEedata.udt_TestPara.i16_maxTol[1] = (int16_t)u16_InVal;
								//if (u8_NegFlag) gudt_IntEedata.udt_TestPara.i16_maxTol[1] *= -1;
								gudt_IntEedata.udt_TestParaCoil.i16_minTolCoil = (int16_t)u16_InVal;
								if (u8_NegFlag) gudt_IntEedata.udt_TestParaCoil.i16_maxTolCoil *= -1;
								break;
							/*case 19:
								gudt_IntEedata.udt_TestPara.u8_Tol = (uint8_t)u16_InVal;break;
							case 20:
								gudt_IntEedata.udt_TestPara.i16_KalibOffset = (int16_t)u16_InVal;
								if (u8_NegFlag) gudt_IntEedata.udt_TestPara.i16_KalibOffset *= -1;
								break;*/
						}
						u8_SubState = 2;
						break;
					default:
						;
				}
			}

			i16_Ergebnis = MONITOR_SUBFUNCTION_CALLAGAIN;
			break;
		}

		case 99:
			//eeprom sichern
			ObjSample_SaveIntEedata();

			//Monitorkunktion beenden
			u8_SubState = 1;
			i16_Ergebnis = MONITOR_SUBFUNCTION_READY;
			break;

		default:
		{
			//unknown substate -> set defined substate
			u8_SubState = 1;
			i16_Ergebnis = MONITOR_SUBFUNCTION_CALLAGAIN;
		}
	}
	return i16_Ergebnis;
}

//Testdaten aus Eeprom auslesen und auf Terminal anzeigen
int16_t AppMonitor_GetTD(void)
{
	uint16_t	i;
	tTestData	TD;

	//Tabellenkopf ausgeben
	ObjSample_PutsLeg();

	//Daten lesen und zeilenweise ausgeben
	for(i = 0; i < (EE_DATA_SIZE/sizeof(tTestData)); i++)
	{
		//Datensatz lesen
		DrvEep_Read(((uint32_t)i)*sizeof(tTestData), (uint8_t*)((&TD)), sizeof(tTestData));

		if (ObjSample_CalcChkSum((uint8_t*)&TD, sizeof(tTestData)) == 0)
		{
			ObjSmpl_ShowTestData(&TD);
		}//kein else
	}

	return MONITOR_SUBFUNCTION_READY;
}

//solange messen, bis ESC, dann das Maximum eines jeden Kanals als Kalibrierreferenz annehmen
/*int16_t AppMonitor_Calibrate(void)
{
	static int16_t i16_xxx[OBJSAMPLE_POTI_CNT];
	uint8_t i;
	int16_t	i16_InChar = 0;
	int16_t i16_tmp;
	int32_t i32_tmp;
	
	if (gu8_FirstRun == 1)
	{
		gu8_FirstRun = 0;

		//Displaytext anzeigen
		ObjLcd_ClearDispBuf();	//Displaybuffer leeren
		ObjLcd_SetBufPos(0,0);	//1.Zeile waehlen
		ObjLcd_Puts("*** Kalibrierung ***");
		ObjLcd_SetBufPos(1,0);	//2.Zeile waehlen
		ObjLcd_Puts("    siehe Monitor   ");
		ObjLcd_Handler();

		DrvUart_Puts(&gudt_MoniIntf, "\r\nKontakte auf Kalibrierhoehe bringen...\r\n");

		//Array mit Maxima nullen
		for(i = 0; i < OBJSAMPLE_POTI_CNT; i++)
		{
			i16_xxx[i] = 0;
		}

		return MONITOR_SUBFUNCTION_CALLAGAIN;
	}
	else
	{		//alle Kanaele messen, anzeigen und ggf. Minimum merken
			DrvUart_Puts(&gudt_MoniIntf, "\rCal: [");
			for(i = 0; i < OBJSAMPLE_POTI_CNT; i++)
			{
				i16_tmp = DrvAdc_ReadPoti(i, DRVADC_FLAG_USE_NO_CALIB);//Messwert holen
				if (i16_tmp > i16_xxx[i]) 
				{
					i16_xxx[i] = i16_tmp;		//ggf. neues Maximum uebernehmen
				}//kein else

				DrvUart_Putuint(&gudt_MoniIntf, i16_xxx[i]);
				DrvUart_Puts(&gudt_MoniIntf, "   ");
			}
			DrvUart_Puts(&gudt_MoniIntf, "]        ");
				
		i16_InChar = DrvUart_Getchar(&gudt_MoniIntf);
		//Abbruch, wenn ESC oder Bestätigung
		if (i16_InChar == ESC || i16_InChar == CR)
		{
			//Kalibrieroffset in Digits umrechnen
			i32_tmp = gudt_IntEedata.udt_TestPara.i16_KalibOffset;
			if(i32_tmp != 0)
			{
				i32_tmp *= 1024;
				i32_tmp /= 1100;
				i32_tmp -= 1;	//wg. rundungsfehlern
			}//kein else, bleibt sonst Null

			//neue Kalibrierdaten uebernehmen
			for(i = 0; i < OBJSAMPLE_POTI_CNT; i++)
			{
				gudt_ObjSmplIntf.i16_Calib[i] = i16_xxx[i] + (int16_t)i32_tmp;
			}
			
			DrvUart_Puts(&gudt_MoniIntf, "\rCal: [");
			for(i = 0; i < OBJSAMPLE_POTI_CNT; i++)
			{
				DrvUart_Putuint(&gudt_MoniIntf, gudt_ObjSmplIntf.i16_Calib[i]);
				DrvUart_Puts(&gudt_MoniIntf, "   ");
			}
			DrvUart_Puts(&gudt_MoniIntf, "]        ");
			
			//int. Eeprom sichern
			ObjSample_SaveIntEedata();
			
			gu8_FirstRun = 1;
			return MONITOR_SUBFUNCTION_READY;
		}
		else
		{
			return MONITOR_SUBFUNCTION_CALLAGAIN;
		}
	}
	
	return MONITOR_SUBFUNCTION_READY;
}*/

//aktuelle Zeit der RTC auslesen
int16_t AppMonitor_GetTime(void)
{
	tDateTime DT;
	
	DrvRtc_GetDateTime(&DT);
	DrvUart_Puts(&gudt_MoniIntf, "\r\nCurrent Time: ");
	DrvUart_Putbyte(&gudt_MoniIntf, DT.std);
	DrvUart_Puts(&gudt_MoniIntf, ":");
	if(DT.min < 10) DrvUart_Puts(&gudt_MoniIntf, "0");
	DrvUart_Putbyte(&gudt_MoniIntf, DT.min);
	DrvUart_Puts(&gudt_MoniIntf, ":");
	if(DT.sek < 10) DrvUart_Puts(&gudt_MoniIntf, "0");
	DrvUart_Putbyte(&gudt_MoniIntf, DT.sek);
	DrvUart_Puts(&gudt_MoniIntf, " ");
	DrvUart_Putbyte(&gudt_MoniIntf, DT.tag);
	DrvUart_Puts(&gudt_MoniIntf, ".");
	DrvUart_Putbyte(&gudt_MoniIntf, DT.mon);
	DrvUart_Puts(&gudt_MoniIntf, ".20");
	if(DT.jhr < 10) DrvUart_Puts(&gudt_MoniIntf, "0");
	DrvUart_Putbyte(&gudt_MoniIntf, DT.jhr);
	DrvUart_Puts(&gudt_MoniIntf, "\r\n");
	
	return MONITOR_SUBFUNCTION_READY;
}

//RTC stellen
int16_t AppMonitor_SetTime(void)
{
	tDateTime DT;
	
	DrvUart_Puts(&gudt_MoniIntf, "\r\nArgCnt = ");
	DrvUart_Putbyte(&gudt_MoniIntf, gudt_MonitorPara.u8_ArgumentAnzahl);
	DrvUart_Puts(&gudt_MoniIntf, "\r\n");
	
	if(gudt_MonitorPara.u8_ArgumentAnzahl == 7)	//komplettes Datum
	{
		if ((gudt_MonitorPara.pstr_Argument[1] == NULL) ||
			(gudt_MonitorPara.pstr_Argument[2] == NULL) ||
			(gudt_MonitorPara.pstr_Argument[3] == NULL) ||
			(gudt_MonitorPara.pstr_Argument[4] == NULL) ||
			(gudt_MonitorPara.pstr_Argument[5] == NULL) ||
			(gudt_MonitorPara.pstr_Argument[6] == NULL) ||
		 	((atoi(gudt_MonitorPara.pstr_Argument[1]) <0) && (atoi(gudt_MonitorPara.pstr_Argument[1]) >23)) ||
		    ((atoi(gudt_MonitorPara.pstr_Argument[2]) <0) && (atoi(gudt_MonitorPara.pstr_Argument[2]) >59)) ||
		    ((atoi(gudt_MonitorPara.pstr_Argument[3]) <0) && (atoi(gudt_MonitorPara.pstr_Argument[3]) >59)) ||
		    ((atoi(gudt_MonitorPara.pstr_Argument[4]) <0) && (atoi(gudt_MonitorPara.pstr_Argument[4]) >31)) ||
		    ((atoi(gudt_MonitorPara.pstr_Argument[5]) <0) && (atoi(gudt_MonitorPara.pstr_Argument[5]) >12)) ||
		    ((atoi(gudt_MonitorPara.pstr_Argument[6]) <0) && (atoi(gudt_MonitorPara.pstr_Argument[6]) >79)) )
		{
			DrvUart_Puts(&gudt_MoniIntf, "date invalid");
		}
		else
		{
			DT.std = (uint8_t)atoi(gudt_MonitorPara.pstr_Argument[1]);
			DT.min = (uint8_t)atoi(gudt_MonitorPara.pstr_Argument[2]);
			DT.sek = (uint8_t)atoi(gudt_MonitorPara.pstr_Argument[3]);
			DT.tag = (uint8_t)atoi(gudt_MonitorPara.pstr_Argument[4]);
			DT.mon = (uint8_t)atoi(gudt_MonitorPara.pstr_Argument[5]);
			DT.jhr = (uint8_t)atoi(gudt_MonitorPara.pstr_Argument[6]);
	
			DrvRtc_SetDateTime(&DT);
			DrvUart_Puts(&gudt_MoniIntf, "\r\nSet Time: ");
			DrvUart_Putbyte(&gudt_MoniIntf, DT.std);
			DrvUart_Puts(&gudt_MoniIntf, ":");
			if(DT.min < 10) DrvUart_Puts(&gudt_MoniIntf, "0");
			DrvUart_Putbyte(&gudt_MoniIntf, DT.min);
			DrvUart_Puts(&gudt_MoniIntf, ":");
			if(DT.sek < 10) DrvUart_Puts(&gudt_MoniIntf, "0");
			DrvUart_Putbyte(&gudt_MoniIntf, DT.sek);
			DrvUart_Puts(&gudt_MoniIntf, " ");
			DrvUart_Putbyte(&gudt_MoniIntf, DT.tag);
			DrvUart_Puts(&gudt_MoniIntf, ".");
			DrvUart_Putbyte(&gudt_MoniIntf, DT.mon);
			DrvUart_Puts(&gudt_MoniIntf, ".20");
			if(DT.jhr < 10) DrvUart_Puts(&gudt_MoniIntf, "0");
			DrvUart_Putbyte(&gudt_MoniIntf, DT.jhr);
			DrvUart_Puts(&gudt_MoniIntf, "\r\n");
		}
	}
	else if (gudt_MonitorPara.u8_ArgumentAnzahl == 4)	//nur Uhrzeit
	{
		DrvRtc_SetDateTime(&DT);	//Datum von Uhr holen
		
		if ((gudt_MonitorPara.pstr_Argument[1] == NULL) ||
			(gudt_MonitorPara.pstr_Argument[2] == NULL) ||
			(gudt_MonitorPara.pstr_Argument[3] == NULL) ||
		 	((atoi(gudt_MonitorPara.pstr_Argument[1]) <0) && (atoi(gudt_MonitorPara.pstr_Argument[1]) >23)) ||
		    ((atoi(gudt_MonitorPara.pstr_Argument[2]) <0) && (atoi(gudt_MonitorPara.pstr_Argument[2]) >59)) ||
		    ((atoi(gudt_MonitorPara.pstr_Argument[3]) <0) && (atoi(gudt_MonitorPara.pstr_Argument[3]) >59)) )
		{
			DrvUart_Puts(&gudt_MoniIntf, "time invalid");
		}
		else
		{
			DT.std = (uint8_t)atoi(gudt_MonitorPara.pstr_Argument[1]);
			DT.min = (uint8_t)atoi(gudt_MonitorPara.pstr_Argument[2]);
			DT.sek = (uint8_t)atoi(gudt_MonitorPara.pstr_Argument[3]);
	
			DrvRtc_SetDateTime(&DT);

			DrvUart_Puts(&gudt_MoniIntf, "\r\nSet Time: ");
			DrvUart_Putbyte(&gudt_MoniIntf, DT.std);
			DrvUart_Puts(&gudt_MoniIntf, ":");
			if(DT.min < 10) DrvUart_Puts(&gudt_MoniIntf, "0");
			DrvUart_Putbyte(&gudt_MoniIntf, DT.min);
			DrvUart_Puts(&gudt_MoniIntf, ":");
			if(DT.sek < 10) DrvUart_Puts(&gudt_MoniIntf, "0");
			DrvUart_Putbyte(&gudt_MoniIntf, DT.sek);
			DrvUart_Puts(&gudt_MoniIntf, " ");
			DrvUart_Putbyte(&gudt_MoniIntf, DT.tag);
			DrvUart_Puts(&gudt_MoniIntf, ".");
			DrvUart_Putbyte(&gudt_MoniIntf, DT.mon);
			DrvUart_Puts(&gudt_MoniIntf, ".20");
			if(DT.jhr < 10) DrvUart_Puts(&gudt_MoniIntf, "0");
			DrvUart_Putbyte(&gudt_MoniIntf, DT.jhr);
			DrvUart_Puts(&gudt_MoniIntf, "\r\n");
		}
	}
	
	return MONITOR_SUBFUNCTION_READY;
}

//Daten des internen EEPROM anzeigen
int16_t AppMonitor_ShowEE(void)
{
	ObjSample_ShowIntEedata();
	
	return MONITOR_SUBFUNCTION_READY;
}

//Temperaturwert der RTC auslesen
int16_t AppMonitor_GetTemp(void)
{
	int16_t temp;
	
	temp = DrvRtc_GetTemp();
	
	DrvUart_Puts(&gudt_MoniIntf, "\r\nTemp: ");
	DrvUart_Putint(&gudt_MoniIntf, temp);
	DrvUart_Puts(&gudt_MoniIntf, "C");
	
	return MONITOR_SUBFUNCTION_READY;
}


//Positionsindex des Drehimpulsgebers auslesen
/*int16_t AppMonitor_GetPoti(void)
{
	uint8_t i;
	int16_t i16_value;
	static uint8_t u8_helper = 0;
	
	if(gudt_MonitorPara.u8_ArgumentAnzahl == 2)
	{
		i = (uint8_t)atoi(gudt_MonitorPara.pstr_Argument[1]);
		i--;		//dekrement, da wir Nullbasiert schaffen
		
		//wenn gueltiger Index
		if (i < OBJSAMPLE_POTI_CNT)
		{
			//Messung starten
			i16_value = DrvAdc_ReadPoti(i, DRVADC_FLAG_USE_CALIB);
			
			//Ergebnis anzeigen
			DrvUart_Puts(&gudt_MoniIntf, "\r\nPoti[");
			DrvUart_Putbyte(&gudt_MoniIntf, i);
			DrvUart_Puts(&gudt_MoniIntf, "]: ");
			DrvUart_Putint(&gudt_MoniIntf, i16_value);
		}

		return MONITOR_SUBFUNCTION_READY;
	}
	else if(gudt_MonitorPara.u8_ArgumentAnzahl == 1)
	{
		if (gu8_FirstRun == 1)
		{
			gu8_FirstRun = 0;
			
			//Werte das 1.Mal anzeigen
			DrvUart_Puts(&gudt_MoniIntf, "\r\nPoti: [");
			for(i=0; i<OBJSAMPLE_POTI_CNT; i++)
			{
				DrvUart_Putuint(&gudt_MoniIntf, DrvAdc_ReadPoti(i, DRVADC_FLAG_USE_NO_CALIB));
				DrvUart_Puts(&gudt_MoniIntf, "   ");
			}
			DrvUart_Puts(&gudt_MoniIntf, "]        ");
			
			return MONITOR_SUBFUNCTION_CALLAGAIN;
		}
		else	//Folgezustand (mehrfaches Durchlaufen, bis ESC)
		{
			if (u8_helper++ > 250)
			{
				u8_helper = 0;
				_delay_ms(1);
				//Werte erneut anzeigen
				DrvUart_Puts(&gudt_MoniIntf, "\rPoti: [");
				for(i=0; i<OBJSAMPLE_POTI_CNT; i++)
				{
					DrvUart_Putuint(&gudt_MoniIntf, DrvAdc_ReadPoti(i, DRVADC_FLAG_USE_NO_CALIB));
					DrvUart_Puts(&gudt_MoniIntf, "   ");
				}
				DrvUart_Puts(&gudt_MoniIntf, "]        ");
			}
			
			//wenn Abbruch
			if (DrvUart_Getchar(&gudt_MoniIntf) == ESC)
			{
				gu8_FirstRun = 1;
				return MONITOR_SUBFUNCTION_READY;
			}
			else
			{
				return MONITOR_SUBFUNCTION_CALLAGAIN;
			}
		}
	}
	
	gu8_FirstRun = 1;
	return MONITOR_SUBFUNCTION_READY;
}*/
