Subversion Repositories NaviCtrl

/*#######################################################################################*/

/* !!! THIS IS NOT FREE SOFTWARE !!!                                                     */

/*#######################################################################################*/

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Copyright (c) 2008 Ingo Busker, Holger Buss

// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY

// + FOR NON COMMERCIAL USE ONLY

// + www.MikroKopter.com

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation), 

// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist. 

// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt 

// + bzgl. der Nutzungsbedingungen aufzunehmen. 

// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,

// + Verkauf von Luftbildaufnahmen, usw.

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht, 

// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts

// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"

// + eindeutig als Ursprung verlinkt werden

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion

// + Benutzung auf eigene Gefahr

// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur 

// + mit unserer Zustimmung zulässig

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// + Redistributions of source code (with or without modifications) must retain the above copyright notice, 

// + this list of conditions and the following disclaimer.

// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived

// +     from this software without specific prior written permission.

// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permitted 

// +     for non-commercial use (directly or indirectly)

// +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted 

// +     with our written permission

// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be 

// +     clearly linked as origin 

// +   * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed

//

// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

// +  POSSIBILITY OF SUCH DAMAGE. 

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#include "main.h"

u8 DebugGetAnforderung = 0,DebugDisplayAnforderung = 0,DebugDataAnforderung = 0,GetVersionAnforderung = 0;

unsigned volatile char SioTmp = 0;

unsigned volatile char SendeBuffer[MAX_SENDE_BUFF];

unsigned volatile char RxdBuffer[MAX_EMPFANGS_BUFF];

unsigned volatile char NMEABuffer[MAX_EMPFANGS_BUFF];

unsigned volatile char NeuerDatensatzEmpfangen = 0;

unsigned volatile char NeueKoordinateEmpfangen = 0;

unsigned volatile char UebertragungAbgeschlossen = 1;

unsigned volatile char SendGPSPosAnforderung = 0;

unsigned volatile char CntCrcError = 0;

unsigned volatile char AnzahlEmpfangsBytes = 0;

unsigned volatile char PC_DebugTimeout = 0;

volatile unsigned char DebugTextAnforderung = 255;

unsigned char NurKanalAnforderung = 0;

UART_TypeDef *DebugUART = UART1;    

unsigned char RemotePollDisplayLine = 0;

u8 PcZugriff = 100;

u8 MotorTest[4] = {0,0,0,0};

u8 MeineSlaveAdresse;

volatile struct str_DebugOut    DebugOut;

struct str_ExternControl  ExternControl;

struct str_GPSPosition  GPS_Position;

struct str_VersionInfo VersionInfo;

struct str_PCTargetGPSPosition PCTargetGPSPosition;

s32 Debug_Timer;

static u16 ptr = 0;

unsigned char ConfirmFrame;

#define FIFO_TX_LEVEL  2

UART_InitTypeDef UART_InitStructure;

const unsigned char ANALOG_TEXT[32][16] =

{

   //1234567890123456 

    "WinkelNick      ", //0

    "WinkelRoll      ",

    "AccNick         ",

    "AccRoll         ",

    "AN4             ",

    "AN5             ", //5

    "GPS-Data Counter",

    "7               ",

    "8               ",

    "9               ",

    "10              ", //10

    "Poti1           ",

    "SPI Error       ",

    "SPI Okay        ",

    "Poti2           ",

    "Poti3           ", //15

    "I2C_ReadByte    ",

    "ACC_Speed_N     ",

    "ACC_Speed_E     ",

    "                ",

    "                ", //20

//    "Distance_N      ",

//    "Distance_E      ", //20

    "N_Speed         ",

    "E_Speed             ",

    "I_North         ",

    "I_East          ",

    "GyroKompass     ", //25

    "Heading         ",

//    "Distance2Target ",

//    "Direction2Target",

    "Distance N      ",

    "Distance E      ",

    "GPS_NICK        ",

    "GPS_ROLL        ", //30

    "Used_Sat        "

};

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++ Sende- und Empfangs-Part der Datenübertragung, incl. CRC-Auswertung

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void UART1_IRQHandler(void)

{

 // ---------------------------- Receive ------------------------------------

 if((UART_GetITStatus(UART1, UART_IT_Receive) != RESET)|| (UART_GetITStatus(UART1, UART_IT_ReceiveTimeOut) != RESET) )

 {

  static u16 crc;

  static u8 crc1,crc2,buf_ptr;

  static u8 UartState = 0;

  u8 CrcOkay = 0;

  if (DebugUART != UART1)

  {

    while (UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)

          UART_SendData(DebugUART, UART_ReceiveData(UART1));

  }

  else

  while ((UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)&& (!NeuerDatensatzEmpfangen))

 {

     SioTmp = UART_ReceiveData(UART1);

  if(buf_ptr >= MAX_EMPFANGS_BUFF)    UartState = 0;

  if(SioTmp == '\r' && UartState == 2)

  {

   UartState = 0;

   crc -= RxdBuffer[buf_ptr-2];

   crc -= RxdBuffer[buf_ptr-1];

   crc %= 4096;

   crc1 = '=' + crc / 64;

   crc2 = '=' + crc % 64;

   CrcOkay = 0;

   if((crc1 == RxdBuffer[buf_ptr-2]) && (crc2 == RxdBuffer[buf_ptr-1])) CrcOkay = 1; else { CrcOkay = 0; CntCrcError++;};

   if(!NeuerDatensatzEmpfangen && CrcOkay) // Datensatz schon verarbeitet

    {

     NeuerDatensatzEmpfangen = 1;

//     GPIO_ToggleBit(GPIO6, GPIO_Pin_2); 

         AnzahlEmpfangsBytes = buf_ptr;

     RxdBuffer[buf_ptr] = '\r';

         if(RxdBuffer[2] == 'R')

         {

           PowerOff();

           VIC_DeInit();

           Execute_Bootloader(); // Reset-Commando - Bootloader starten

         }

        // while (UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET) SioTmp = UART_ReceiveData(UART1); 

         //BearbeiteRxDaten();

         break;

        }                                

  }

  else

  switch(UartState)

  {

   case 0:

          if(SioTmp == '#' && !NeuerDatensatzEmpfangen) UartState = 1;  // Startzeichen und Daten schon verarbeitet

                  buf_ptr = 0;

                  RxdBuffer[buf_ptr++] = SioTmp;

                  crc = SioTmp;

          break;

   case 1: // Adresse auswerten

                  UartState++;

                  RxdBuffer[buf_ptr++] = SioTmp;

                  crc += SioTmp;

                  break;

   case 2: //  Eingangsdaten sammeln

                  RxdBuffer[buf_ptr] = SioTmp;

                  if(buf_ptr < MAX_EMPFANGS_BUFF) buf_ptr++;

                  else UartState = 0;

                  crc += SioTmp;

                  break;

   default:

          UartState = 0;

          break;

   }

  }

  }

   UART_ClearITPendingBit(UART1, UART_IT_Receive);

   UART_ClearITPendingBit(UART1, UART_IT_ReceiveTimeOut);

}

// --------------------------------------------------------------------------

void UART1_Transmit(void)

{

    u8 tmp_tx;

  if((!UebertragungAbgeschlossen) && (UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) == RESET))  

  {

   tmp_tx = SendeBuffer[ptr];  

   if((tmp_tx == '\r') || (ptr == MAX_SENDE_BUFF))

     {

       ptr = 0;

       UebertragungAbgeschlossen = 1;

     }

   UART_SendData(UART1, tmp_tx);

   ptr++;

  }

}

// --------------------------------------------------------------------------

void AddCRC(u16 wieviele)

{

 u16 tmpCRC = 0,i;

 //u8 count = FIFO_TX_LEVEL + 2 ;

 for(i = 0; i < wieviele;i++)

  {

   tmpCRC += SendeBuffer[i];

  }

   tmpCRC %= 4096;

   SendeBuffer[i++] = '=' + tmpCRC / 64;

   SendeBuffer[i++] = '=' + tmpCRC % 64;

   SendeBuffer[i++] = '\r';

  ptr = 0;

 // USB_Send_Data((u8 *) SendeBuffer,i);

  {

    UART_SendData(UART1,SendeBuffer[ptr++]);

    UebertragungAbgeschlossen = 0;

  }

}

// --------------------------------------------------------------------------

void SendOutData(u8 cmd,u8 modul, u8 *snd, u8 len)

{

 u16 pt = 0;

 u8 a,b,c;

 u8 ptr = 0;

 SendeBuffer[pt++] = '#';               // Startzeichen

 SendeBuffer[pt++] = modul;             // Adresse (a=0; b=1,...)

 SendeBuffer[pt++] = cmd;                       // Commando

 while(len)

  {

   if(len) { a = snd[ptr++]; len--;} else a = 0;

   if(len) { b = snd[ptr++]; len--;} else b = 0;

   if(len) { c = snd[ptr++]; len--;} else c = 0;

   SendeBuffer[pt++] = '=' + (a >> 2);

   SendeBuffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));

   SendeBuffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));

   SendeBuffer[pt++] = '=' + ( c & 0x3f);

  }

 AddCRC(pt);

}

// --------------------------------------------------------------------------

void Decode64(u8 *ptrOut, u8 len, u8 ptrIn,u8 max)  // Wohin mit den Daten; Wie lang; Wo im RxdBuffer

{

 u8 a,b,c,d;

 u8 ptr = 0;

 u8 x,y,z;

 while(len)

  {

   a = RxdBuffer[ptrIn++] - '=';

   b = RxdBuffer[ptrIn++] - '=';

   c = RxdBuffer[ptrIn++] - '=';

   d = RxdBuffer[ptrIn++] - '=';

   if(ptrIn > max - 2) break;     // nicht mehr Daten verarbeiten, als empfangen wurden

   x = (a << 2) | (b >> 4);

   y = ((b & 0x0f) << 4) | (c >> 2);

   z = ((c & 0x03) << 6) | d;

   if(len--) ptrOut[ptr++] = x; else break;

   if(len--) ptrOut[ptr++] = y; else break;

   if(len--) ptrOut[ptr++] = z; else break;

  }

}

// --------------------------------------------------------------------------

void BearbeiteRxDaten(void)

{

 if(!NeuerDatensatzEmpfangen) return;

// u16 tmp_int_arr1[1];

// u16 tmp_int_arr2[2];

// u16 tmp_int_arr3[3];

 u8  tmp_char_arr2[2];

 s32 tmp_long_arr2[2];

// u8 tmp_char_arr3[3];

// u8 tmp_char_arr4[4];

 //if(!MotorenEin) 

 PcZugriff = 255;

  switch(RxdBuffer[2])

  {

    case 'a':// Texte der Analogwerte

            Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);

            DebugTextAnforderung = tmp_char_arr2[0];

                        break;

   case 'b':

                        Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);

                        RemoteTasten |= ExternControl.RemoteTasten;

            ConfirmFrame = ExternControl.Frame;

            break;

   case 'c':

                        Decode64((unsigned char *) &ExternControl,sizeof(ExternControl),3,AnzahlEmpfangsBytes);

                        RemoteTasten |= ExternControl.RemoteTasten;

            ConfirmFrame = ExternControl.Frame;

            DebugDataAnforderung = 1;

            break;

   case 'h':// x-1 Displayzeilen

            Decode64((unsigned char *) &tmp_char_arr2[0],sizeof(tmp_char_arr2),3,AnzahlEmpfangsBytes);

            RemoteTasten |= tmp_char_arr2[0];

                        if(tmp_char_arr2[1] == 255) NurKanalAnforderung = 1; else NurKanalAnforderung = 0; // keine Displaydaten

                        DebugDisplayAnforderung = 1;

                        break;

   case 't':// Motortest

            Decode64((unsigned char *) &MotorTest[0],sizeof(MotorTest),3,AnzahlEmpfangsBytes);

                        break;

   case 's'://  neue PCTargetGPSPosition

            Decode64((unsigned char *) &tmp_long_arr2[0],sizeof(tmp_long_arr2),3,AnzahlEmpfangsBytes);

            PCTargetGPSPosition.Longitude = tmp_long_arr2[0];

            PCTargetGPSPosition.Latitude = tmp_long_arr2[1];

                    NewPCTargetGPSPosition = 1;

                        break;

   case 'k':// Keys von DubWise

    //        Decode64((unsigned char *) &DubWiseKeys[0],sizeof(DubWiseKeys),3,AnzahlEmpfangsBytes);

                        ConfirmFrame = 1;

                        break;

   case 'v': // Version-Anforderung     und Ausbaustufe

            GetVersionAnforderung = 1;

            break;                                                               

   case 'g':// "Get"-Anforderung für Debug-Daten 

            // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen

            DebugGetAnforderung = 1;

            break;

   case 'l':

   case 'm':

   case 'n':

   case 'o':

   case 'p': // Parametersatz speichern

/*            Decode64((u8 *) &EE_Parameter.Kanalbelegung[0],STRUCT_PARAM_LAENGE,3,AnzahlEmpfangsBytes);

                        WriteParameterSet(RxdBuffer[2] - 'l' + 1, (u8 *) &EE_Parameter.Kanalbelegung[0], STRUCT_PARAM_LAENGE);

            eeprom_write_byte(&EEPromArray[EEPROM_ADR_ACTIVE_SET], RxdBuffer[2] - 'l' + 1);  // aktiven Datensatz merken

            Piep(GetActiveParamSetNumber());*/

         break;

  }

// DebugOut.AnzahlZyklen =  Debug_Timer_Intervall;

 NeuerDatensatzEmpfangen = 0;

}

//############################################################################

//Routine für die Serielle Ausgabe

s16 uart_putchar (char c)

//############################################################################

{

        if (c == '\n')

                uart_putchar('\r');

        while (UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) != RESET);

        UART_SendData(UART1, c);

        return (0);

}

// --------------------------------------------------------------------------

void SerialPutString(u8 *s)

{

    while (*s != '\0')

    {

        uart_putchar(*s);

        s ++;

    }

}

//############################################################################

//Init der Seriellen Schnittstelle

void Debug_UART1_Init (void)

//############################################################################

{

    GPIO_InitTypeDef GPIO_InitStructure;

    SCU_APBPeriphClockConfig(__UART1, ENABLE);  // Enable the UART1 Clock 

    SCU_APBPeriphClockConfig(__GPIO3, ENABLE);  // Enable the GPIO3 Clock 

    /*Configure UART1_Rx pin GPIO3.2*/

    GPIO_DeInit(GPIO3);

        GPIO_InitStructure.GPIO_Direction =     GPIO_PinInput;

    GPIO_InitStructure.GPIO_Pin =                       GPIO_Pin_2;

    GPIO_InitStructure.GPIO_Type =                      GPIO_Type_PushPull ;

    GPIO_InitStructure.GPIO_IPConnected =       GPIO_IPConnected_Enable;

    GPIO_InitStructure.GPIO_Alternate =         GPIO_InputAlt1  ;

    GPIO_Init(GPIO3, &GPIO_InitStructure);

    /*Configure UART1_Tx pin GPIO3.3*/

        GPIO_InitStructure.GPIO_Direction =     GPIO_PinOutput;

    GPIO_InitStructure.GPIO_Pin =                       GPIO_Pin_3;

    GPIO_InitStructure.GPIO_Type =                      GPIO_Type_PushPull ;

    GPIO_InitStructure.GPIO_Alternate =         GPIO_OutputAlt2  ;

    GPIO_Init(GPIO3, &GPIO_InitStructure);

  /* UART1 configured as follow:

          - Word Length = 8 Bits

          - One Stop Bit

          - No parity

          - BaudRate = 57600 baud

          - Hardware flow control Disabled

          - Receive and transmit enabled

          - Receive and transmit FIFOs are Disabled

    */

    UART_InitStructure.UART_WordLength =                        UART_WordLength_8D;

    UART_InitStructure.UART_StopBits =                          UART_StopBits_1;

    UART_InitStructure.UART_Parity =                            UART_Parity_No ;

    UART_InitStructure.UART_BaudRate =                          BAUD_RATE ;

    UART_InitStructure. UART_HardwareFlowControl =      UART_HardwareFlowControl_None;

    UART_InitStructure.UART_Mode =                                      UART_Mode_Tx_Rx;

    //UART_InitStructure.UART_FIFO =                                    UART_FIFO_Disable;

    UART_InitStructure.UART_FIFO =                                      UART_FIFO_Enable;

    UART_InitStructure.UART_TxFIFOLevel = UART_FIFOLevel_1_2;

    UART_InitStructure.UART_RxFIFOLevel = UART_FIFOLevel_1_2;

        UART_DeInit(UART1);

    UART_Init(UART1, &UART_InitStructure);

    UART_ITConfig(UART1, UART_IT_Receive | UART_IT_ReceiveTimeOut /*| UART_IT_Transmit */, ENABLE);

    //UART_ITConfig(UART1, UART_IT_Receive , ENABLE);    

        UART_Cmd(UART1, ENABLE);

    VIC_Config(UART1_ITLine, VIC_IRQ, 4);

    VIC_ITCmd(UART1_ITLine, ENABLE);  

  Debug_Timer = SetDelay(3000);  

  //----------------------------------------

}

//---------------------------------------------------------------------------------------------

void DatenUebertragung(void)  

{

 if(!UebertragungAbgeschlossen) return;

   if(DebugGetAnforderung && UebertragungAbgeschlossen)               // Bei Get werden die vom PC einstellbaren Werte vom PC zurückgelesen

   {

      SendOutData('G',MeineSlaveAdresse,(unsigned char *) &ExternControl,sizeof(ExternControl));

          DebugGetAnforderung = 0;

   }

    if((CheckDelay(Debug_Timer) || DebugDataAnforderung) && UebertragungAbgeschlossen)  

         {

          SendOutData('D',MeineSlaveAdresse,(unsigned char *) &DebugOut,sizeof(DebugOut));

          DebugDataAnforderung = 0;

          Debug_Timer = SetDelay(2000);  

         }

    if(DebugTextAnforderung != 255) // Texte für die Analogdaten

     {

      SendOutData('A',DebugTextAnforderung + '0',(unsigned char *) ANALOG_TEXT[DebugTextAnforderung],16);

      DebugTextAnforderung = 255;

         }

     if(DebugDisplayAnforderung && UebertragungAbgeschlossen)

         {

      Menu();

          DebugDisplayAnforderung = 0;

      if(++RemotePollDisplayLine == 4 || NurKanalAnforderung)

      {

       SendOutData('4',0,(unsigned char *) &VersionInfo,sizeof(VersionInfo));   // DisplayZeile übertragen

       RemotePollDisplayLine = -1;

      }

      else  SendOutData('0' + RemotePollDisplayLine,0,(unsigned char *)&DisplayBuff[20 * RemotePollDisplayLine],20);   // DisplayZeile übertragen

         }

    if(GetVersionAnforderung && UebertragungAbgeschlossen)

     {

      SendOutData('V',MeineSlaveAdresse,(unsigned char *) &VersionInfo,sizeof(VersionInfo));

          GetVersionAnforderung = 0;

     }

    if(SendGPSPosAnforderung && UebertragungAbgeschlossen)

     {

      SendOutData('Q',MeineSlaveAdresse,(unsigned char *) &GPS_Position,sizeof(GPS_Position));

          SendGPSPosAnforderung = 0;

     }

}