gps.cpp

this the code of bootstation

#include "stdafx.h"

#include<windows.h>
#include<iostream.h>
#include<stdio.h>
#include<stdlib.h>
#include <math.h>
#include <fstream>
#include"GPS.h"
using namespace std;

//----------------------------------------------//
//												//
//                Konstruktor					//
//												//
//----------------------------------------------//
CSerial::CSerial()
{
	hComm      = INVALID_HANDLE_VALUE;
	bDebugInfo = FALSE;
	RMC_flag=false;
}


//----------------------------------------------//
//												//
//                Destruktor					//
//												//
//----------------------------------------------//
CSerial::~CSerial()
{
	Close ();
}

//------------------------------------------------------------------------------------------------------------------------
// Funktion:     BOOL Open (int nComPortNr, int nBaud, int nBits, int nParity, int nStopp);
// Beschreibung: oeffnen eines Com-Ports mit den uebergebenen Eigenschaften
// Paramter:     Int iComPortNr: Nummer des zuoeffnenden Ports
//				 Int iBaud     : Baudrate
//				 Int iBits	   : 
//				 Int iParity   : Ist ein ParityBit vorhanden
//               Int iStopp    : Ist ein StopBit vorhanden
// Return:	     Bool: True    : Funktion erfolgreich durchlaufen
//				 Bool: False   : Fehler in der Funktion
//------------------------------------------------------------------------------------------------------------------------
CSerial::Open (int nComPortNr, int nBaud, int nBits, int nParity, int nStopp)
{
   if ( bDebugInfo == TRUE )
   {
	printf("****** Funktion: CSerial::Open ******\n");
   }

   if (INVALID_HANDLE_VALUE != hComm) // Ist Bereits ein Port geoeffnet
   {
	if ( bDebugInfo == TRUE ) printf("****** Funktion: CSerial::Open: Port bereits geoeffnet!******\n");	 
	return (TRUE);
   }

   char szPort[16]; // Char Array zum Speichern des Port Names mit Nr. ( z.B: \\\\.\\COM1 )

   wsprintf (szPort, "\\\\.\\COM%d", nComPortNr);  //Erstellen des erforderlichen Portnamens aus der Portnummer

   hComm = CreateFile (szPort,
						  GENERIC_READ | GENERIC_WRITE,
                    0,
                    0,
                    OPEN_EXISTING,
                    FILE_ATTRIBUTE_NORMAL,
                    NULL);  // Erstellen des Handler fuer den Port

   if (hComm == INVALID_HANDLE_VALUE)
   {
	if ( bDebugInfo == TRUE ) printf("****** Funktion: CSerial::Open: Handler wurde nicht erstellt! ******\n");
    return (FALSE);
   }

   if (!GetCommTimeouts(hComm, &timeouts_alt))
   {
	if ( bDebugInfo == TRUE ) printf("****** Funktion: CSerial::Open: Alten Timeouts konnten nicht ausgelesen werden ******\n");
	return (FALSE);
   }

   // Setzen der TimeOut Zeiten

   COMMTIMEOUTS timeouts;
   timeouts.ReadIntervalTimeout         = MAXDWORD ;
   timeouts.ReadTotalTimeoutMultiplier  = MAXDWORD ;
   timeouts.ReadTotalTimeoutConstant    = 3000; // TimeoutZeit in ms
   timeouts.WriteTotalTimeoutMultiplier = 1000;
   timeouts.WriteTotalTimeoutConstant   = 1000;

   if (!SetCommTimeouts(hComm, &timeouts))
   {
	if ( bDebugInfo == TRUE ) printf("****** Funktion: CSerial::Open: Neuen Timeouts konnten nicht gesetzt werden ******\n");
	return (FALSE);
   }

   
   DCB dcb;						   // Erzeugen der Struktur zum Setzen der Eigenschaften des Com-Ports
   ZeroMemory (&dcb, sizeof(dcb)); // Loeschen der Speicherbereichs
   dcb.DCBlength = sizeof(DCB);    // Setzen der Laenge

   if (!GetCommState (hComm, &dcb))
   {
	if ( bDebugInfo == TRUE ) printf("****** Funktion: CSerial::Open: Alten ComStates konnten nicht ausgelesen werden ******\n");
    return (FALSE);
   }
	

    // Speicher der alten Werte des Com-Ports
	dcb_alt = dcb;
	
	// Setzen dr Eigenschaften des geoeffneten Com-Ports
	dcb.fBinary = TRUE; // muss immer "TRUE" sein!
	dcb.fParity = TRUE;
	dcb.fOutxCtsFlow = FALSE;
	dcb.fOutxDsrFlow = FALSE;
	dcb.fDtrControl = DTR_CONTROL_ENABLE;
	dcb.fDsrSensitivity = FALSE;
	dcb.fTXContinueOnXoff = TRUE;
	dcb.fOutX = FALSE;
	dcb.fInX = FALSE;
	dcb.fErrorChar = FALSE;
	dcb.fNull = FALSE;
	dcb.fRtsControl = RTS_CONTROL_ENABLE;
	dcb.fAbortOnError = FALSE;
	dcb.wReserved = 0; // muss immer "0" sein!
 
	dcb.BaudRate = nBaud;
	dcb.ByteSize = (BYTE)nBits;
	dcb.Parity   = (BYTE)nParity;
	dcb.StopBits = (BYTE)nStopp;   
	
   dcb.fParity = (dcb.Parity != NOPARITY);

   if (!SetCommState(hComm, &dcb))
   {
	if ( bDebugInfo == TRUE ) printf("****** Funktion: CSerial::Open: Neuen ComStats konnten nicht gesetzt werden ******\n");
    return (FALSE);
   }

   return(TRUE);
}


//------------------------------------------------------------------------------------------------------------------------
// Funktion:     BOOL Close ();
// Beschreibung: Schliessen des geoeffneten Com-Ports
// Paramter:     -
// Return:	     Bool: True    : Funktion erfolgreich durchlaufen
//				 Bool: False   : Fehler in der Funktion
//------------------------------------------------------------------------------------------------------------------------
CSerial::Close (void)
{
	if ( bDebugInfo == TRUE ) printf("****** Funktion: CSerial::Close ******\n");
    
	BOOL bResult;

	if(INVALID_HANDLE_VALUE == hComm) // Wurde ein Port geoeffnet
		return (TRUE);

	SetCommTimeouts(hComm, &timeouts_alt); // Wiederherstellen der Ausgangswerte (Timeouts)
	SetCommState(hComm, &dcb_alt);		   // Wiederherstellen der Ausgangswerte (Eigenschaften)	

	bResult = CloseHandle(hComm);		   // Schliessen des Ports und Speichern ob erfolgreich	
	hComm   = INVALID_HANDLE_VALUE;		   // Invalid dem Handler zuweisen..	

	return(bResult);					   // Wurde der Port erfolgreich geschlossen	
}


//------------------------------------------------------------------------------------------------------------------------
// Funktion:     BOOL SetTimeout (int iTimeout);
// Beschreibung: Setzen der absoluten Zeit bis zu einem Timeouts
// Paramter:     Int iTimeout  : Zeit bis Timeout in Sec
// Return:	     Bool: True    : Funktion erfolgreich durchlaufen
//				 Bool: False   : Fehler in der Funktion
//------------------------------------------------------------------------------------------------------------------------
CSerial::SetTimeout (int iTimeout)
{
	if ( bDebugInfo == TRUE ) printf("****** Funktion: CSerial::SetTimeout ******\n");	
    
	if (INVALID_HANDLE_VALUE == hComm)	// Es mu?erst ein Port geoeffnet werden bevor das Timeout gesetz werden kann
	{
	 if ( bDebugInfo == TRUE ) printf("****** Funktion: CSerial::SetTimeout: Keine Timeouts gesetzt -> Invalid Handler! ******\n");
	 return (TRUE);
	}

    COMMTIMEOUTS timeouts;
    timeouts.ReadIntervalTimeout = MAXDWORD ;
    timeouts.ReadTotalTimeoutMultiplier = MAXDWORD ;
    timeouts.ReadTotalTimeoutConstant = (DWORD) iTimeout;
    timeouts.WriteTotalTimeoutMultiplier = 1000;
    timeouts.WriteTotalTimeoutConstant = 1000;
 
    if (!SetCommTimeouts(hComm, &timeouts))	// Wurde die neuen Timeout aktzepiert?
	{
	 if ( bDebugInfo == TRUE ) printf("****** Funktion: CSerial::SetTimeout: Neuen Timeouts wurden nicht gesetzt! ******\n");
	 return (FALSE);
	}

    return(TRUE);	
			
}

//------------------------------------------------------------------------------------------------------------------------
// Funktion:     BOOL IsOpen ();
// Beschreibung: Ist der Com-Port geoeffnet
// Paramter:     -
// Return:	     Bool: True    : Funktion erfolgreich durchlaufen
//				 Bool: False   : Fehler in der Funktion
//------------------------------------------------------------------------------------------------------------------------
CSerial::IsOpen (void)
{
	if ( bDebugInfo == TRUE ) printf("****** Funktion: CSerial::IsOpen ******\n");

	if (INVALID_HANDLE_VALUE != hComm) // Ist es der Handler Invalid dann w黵de noch kein Port ge鰂fnet
		return (TRUE);
	else
		return (FALSE);
}

//------------------------------------------------------------------------------------------------------------------------
// Funktion:     int ReadData (char *buffer, int iMaxCount);
// Beschreibung: Lesen von Data vom ComPort
// Paramter:     char *buffer  : Zeiger auf Array fuer eingelesende Zeichen
//				 int iMaxCount : Anzahl der zulesenden Zeichen
// Return:	     Int           : Anzahl der gelesenden Zeichen
//------------------------------------------------------------------------------------------------------------------------
CSerial::ReadData (char *buffer, int iMaxCount)
{
	if(RMC_flag)
	{
		return (0);
	}
	else
	{
	

	if (INVALID_HANDLE_VALUE == hComm) // ist der Handler invalid
	{
	  if ( bDebugInfo == TRUE ) 
      return (0);
	}
   
   // loeschen des Arrays
   for ( int i = 0; i < 82; i++)
   {
    buffer[i] = '\0'; 
   }
   //*****XXXXXXXXXXXXXXXXXXXXXXXXX
   stat='\0';
   for (int j = 0; i<11;i++)
   {
	   latitude[j]='\0';
   }
   for (int k = 0; i<12;i++)
   {
	   longitude[k]='\0';
   }

   //*XXXXXXXXXXXXXXXXXXXXXXXXXXXX


   DWORD dwRead = 0;
   char chRead;  // Gelesendes Zeichen/Byte
   i = 0;    // Schleifenindex
   
   //erst wenn ein anfang einer nachricht gefunden wurde ....Daten speichern
   BOOL bTest = FALSE;
   

   while (ReadFile(hComm, &chRead, 1, &dwRead, NULL))  // Lesen eines Zeichen/Byte
   {
	   
	   if (dwRead != 1)
           break;
       
	   if ( chRead == '$' )
	   {
        bTest = TRUE;
	   }
       
       
	    
	   if ( bTest )
	   {
	    if ( chRead == CR )
		{
         break;
		}
		buffer[i] = chRead; // Speichern des eingelesenden Zeichen
		i++;
	   }
       
		 if (i == iMaxCount) // Maximalanzahl an Zeichen gelesen
		 break;
	}
    
    buffer[82] = '\0';
	//pruefen nachricht RMC
	   if(buffer[3]=='R' && buffer[4]=='M' && buffer[5]=='C')
	   {
		   RMC_flag = true;
	   }

	return (i); // Rueckgabe der Anzahl der gelesenden Zeichen
}//else if(RMC_flag)
}

//------------------------------------------------------------------------------------------------------------------------
// Funktion:     int SendData (const char *buffer, int iBytesToWrite);
// Beschreibung: Lesen von Data vom ComPort
// Paramter:     const char *buffer: Zeiger auf Array mit den zu sendenen Zeichen
//				 int iBytesToWrite : Anzahl der zusendenen Zeichen
// Return:	     Int               : Anzahl der gesendeten Zeichen
//------------------------------------------------------------------------------------------------------------------------
CSerial::SendData (const char *buffer, int iBytesToWrite)
{
	if ( bDebugInfo == TRUE ) printf("****** Funktion: CSerial::SendData ******\n");

	if (INVALID_HANDLE_VALUE == hComm)  // Ist der Handler Invalid