dgpslistener.h

Gps 数据采集

#define XOFFLIMIT( x )      (x.wXOFFLimit)
#define CTSOUTFLOW( x )     (x.fCTSOutFlow)
#define DSROUTFLOW( x )     (x.fDSROutFlow)
#define DSRINFLOW( x )      (x.fDSRInFlow)
#define XONXOFFOUTFLOW( x ) (x.fXonXoffOutFlow)
#define XONXOFFINFLOW( x )  (x.fXonXoffInFlow)
#define TXAFTERXOFFSENT(x)  (x.fTXafterXoffSent)

#define NOREADING( x )      (x.fNoReading)
#define NOWRITING( x )      (x.fNoWriting)
#define NOEVENTS( x )       (x.fNoEvents)
#define NOSTATUS( x )       (x.fNoStatus)
#define SHOWTIMEOUTS( x )   (x.fDisplayTimeouts)
// end of #include "ttyinfo.h"

// GLOBAL DEFINES
#define TTY_BUFFER_SIZE         MAXROWS * MAXCOLS
#define MAX_STATUS_BUFFER       20000
#define MAX_WRITE_BUFFER        1024
#define MAX_READ_BUFFER         2048
#define READ_TIMEOUT            500
#define STATUS_CHECK_TIMEOUT    500
#define WRITE_CHECK_TIMEOUT     500
#define PURGE_FLAGS             PURGE_TXABORT | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_RXCLEAR 
#define EVENTFLAGS_DEFAULT      EV_BREAK | EV_CTS | EV_DSR | EV_ERR | EV_RING | EV_RLSD
#define FLAGCHAR_DEFAULT        '\n'

// Write request types
#define WRITE_CHAR          0x01
#define WRITE_FILE          0x02
#define WRITE_FILESTART     0x03
#define WRITE_FILEEND       0x04
#define WRITE_ABORT         0x05
#define WRITE_BLOCK         0x06

// Read states
#define RECEIVE_TTY                    0x01
#define RECEIVE_CAPTURED               0x02
#define RECEIVE_TTYBLACKBOXCOOKED      0x03
#define RECEIVE_CAPTUREDBLACKBOXCOOKED 0x04

// window coords
#define MAXXWINDOW          750
#define MAXYWINDOW          530
#define STARTXWINDOW        80
#define STARTYWINDOW        70

#define SETTINGSFACTOR      5
#define STATUSFACTOR        5

// window timer ids
#define TIMERID             1

#define MAXLEN_TEMPSTR      20
#define MAX_STATUS_LENGTH   100

#define AMOUNT_TO_READ          512
#define NUM_READSTAT_HANDLES    4

// GLOBAL VARIABLES
OSVERSIONINFO gOSV;
HINSTANCE     ghInst;
HACCEL        ghAccel;
HWND          ghwndMain;
HWND          ghWndToolbarDlg;
HWND          ghWndStatusDlg;
HWND          ghWndTTY;
HWND          ghWndHidden;

//  Window placement variables
WORD gwBaseY;
LONG gcyMinimumWindowHeight;

//  Flags controlling thread actions
HANDLE ghThreadExitEvent;
BOOL gfAbortTransfer;

//  File transfer variables
DWORD  gdwFileTransferLeft;
DWORD  gdwReceiveState;
HANDLE ghFileCapture;

//  Status updating
CRITICAL_SECTION gStatusCritical;
HANDLE ghStatusMessageEvent;
HANDLE ghStatusMessageHeap;
HFONT ghFontStatus;
int   gnStatusIndex;

typedef struct STATUS_MESSAGE;

struct STATUS_MESSAGE * glpStatusMessageHead;
struct STATUS_MESSAGE * glpStatusMessageTail;

typedef struct STATUS_MESSAGE
{
  struct STATUS_MESSAGE * lpNext;     // pointer to next node
  char chMessageStart;                // variable length string start here
} STATUS_MESSAGE;

//  Port name
char gszPort[10];

//  Writer heap variables
CRITICAL_SECTION gcsWriterHeap;
CRITICAL_SECTION gcsDataHeap;
HANDLE ghWriterHeap;
HANDLE ghWriterEvent;
HANDLE ghTransferCompleteEvent;

//  Write request data structure; look in Writer.c for more info
typedef struct WRITEREQUEST;

struct WRITEREQUEST *gpWriterHead;
struct WRITEREQUEST *gpWriterTail;

typedef struct WRITEREQUEST
{
  DWORD      dwWriteType;        // char, file start, file abort, file packet
  DWORD      dwSize;             // size of buffer
  char       ch;                 // ch to send
  char *     lpBuf;              // address of buffer to send
  HANDLE     hHeap;              // heap containing buffer
  HWND       hWndProgress;       // status bar window handle
  struct WRITEREQUEST *pNext;    // next node in the list
  struct WRITEREQUEST *pPrev;    // prev node in the list
} WRITEREQUEST, *PWRITEREQUEST;

// Variables from the original file transfer.c
HANDLE hFile;
HANDLE hTransferAbortEvent;
HANDLE hTransferThread;
UINT   uTimerId;
MMRESULT mmTimer = (MMRESULT)NULL;
char * lpBuf;

// BlackBoxPlus specific globals
char CmdBuffer[128]; // buffer is even oversized, since no NMEA 0183 command has more than 80 chars

// For Walter's minimal NMEA-Parser

#if ! defined(CARRIAGE_RETURN)
#define CARRIAGE_RETURN 0x0D
#endif

#if ! defined(LINE_FEED)
#define LINE_FEED       0x0A
#endif

typedef enum
{
  UNIMPLEMENTED = 0,
  GPGGA,
  GPGSA,
  GPGSV,
  GPRMC,
  PGRMT
} KNOWNSENTENCES;

enum 
{
  CHECKSUM_PARSE_ERROR = 11,
  UNKNOWNSENTENCE_PARSE_ERROR
};

// Prototypes of functions
BOOL VersionCheck(void);
BOOL InitializeApp(HINSTANCE,int);
int WINAPI MTTTYWndProc(HWND,UINT,WPARAM,LPARAM);
void CmdDispatch(int,HWND,LPARAM);
void OpenTTYChildWindow(HWND);
BOOL ScrollTTYVert(HWND,WORD,WORD);
BOOL ScrollTTYHorz(HWND,WORD,WORD);
BOOL PaintTTY(HWND);
BOOL NEAR MoveTTYCursor(HWND);
BOOL NEAR SetTTYFocus(HWND);
BOOL NEAR KillTTYFocus(HWND);
BOOL NEAR SizeTTY(HWND,WORD,WORD);
int WINAPI TTYChildProc(HWND,UINT,WPARAM,LPARAM);
void GlobalInitialize(void);
void GlobalCleanup(void);
BOOL ClearTTYContents(void);
void InitNewFont(LOGFONT,COLORREF);
BOOL InitTTYInfo(void);
void DestroyTTYInfo(void);
void StartThreads(void);
HANDLE SetupCommPort(void);
DWORD WaitForThreads(DWORD);
BOOL BreakDownCommPort(void);
BOOL DisconnectOK(void);
void TransferRepeatCreate(LPCTSTR,DWORD);
void TransferRepeatDestroy(void);
void CALLBACK TransferRepeatDo(UINT,UINT,DWORD,DWORD,DWORD);
void TransferFileTextStart(LPCTSTR);
void TransferFileTextEnd(void);
void ReceiveFileText(LPCTSTR,BOOL);
HANDLE OpenTheFile(LPCTSTR);
HANDLE CreateTheFile(LPCTSTR);
BOOL GetTransferSizes(HANDLE,DWORD*,DWORD*,DWORD*);
void ShowTransferStatistics(DWORD,DWORD,DWORD);
UINT CheckForMessages(void);
void CaptureFile(HANDLE,HWND,BOOL);
DWORD WINAPI TransferThreadProc(LPVOID);
void OpenSettingsToolbar(HWND);
void ChangeConnection(HWND,BOOL);
void UpdateTTYInfo(void);
BOOL UpdateConnection(void);
void FillComboBox(HWND,char **,DWORD *,WORD,DWORD);
void SetComboBox(HWND,WORD,DWORD);
BOOL SettingsDlgInit(HWND);
DWORD GetdwTTYItem(HWND,int,char **,DWORD *,int);
BYTE GetbTTYItem(HWND,int, char **,DWORD *,int);
BOOL CALLBACK ToolbarProc(HWND,UINT,WPARAM,LPARAM);
void InitHexControl(HWND,WORD,WORD,char);
char GetHexControl(HWND,WORD,WORD);
void InitCommEventsDlg(HWND,DWORD);
void SaveCommEventsDlg(HWND);
BOOL CALLBACK CommEventsProc(HWND,UINT,WPARAM,LPARAM);
void SaveFlowControlDlg(HWND);
void InitFlowControlDlg(HWND);
void FlowDefault(HWND,WORD);
BOOL CALLBACK FlowControlProc(HWND,UINT,WPARAM,LPARAM);
void InitTimeoutsDlg(HWND,COMMTIMEOUTS);
void SaveTimeoutsDlg(HWND);
BOOL CALLBACK TimeoutsProc(HWND,UINT,WPARAM,LPARAM);
BOOL CALLBACK GetADWORDProc(HWND,UINT,WPARAM,LPARAM);
DWORD GetAFrequency(void);
void OpenStatusToolbar(HWND);
HFONT CreateStatusEditFont(void);
BOOL CALLBACK StatusDlgProc(HWND,UINT,WPARAM,LPARAM);
void InitStatusMessage(void);
void StatusMessage(void);
void UpdateStatus(char *);
void ReportModemStatus(DWORD);
void CheckModemStatus(BOOL);
void ReportComStat(COMSTAT);
void CheckComStat(BOOL);
void ReportStatusEvent(DWORD);
BOOL CmdAbout(HWND);
UINT InitAboutDlg(HWND);
BOOL CALLBACK AboutDlgProc(HWND,UINT,WPARAM,LPARAM);
DWORD ErrorExtender(DWORD,char **);
void ErrorReporter(char *);
void OutputABufferToWindow(HWND,char *,DWORD);
void OutputABufferToWindow(HWND,char *,DWORD);
void OutputABufferToFile(HANDLE,char *,DWORD);
void OutputABufferToFile(HANDLE,char *,DWORD);
void OutputABuffer(HWND,char *,DWORD);
DWORD WINAPI WriterProc(LPVOID);
void HandleWriteRequests();
void WriterComplete(void);
void WriterAbort(PWRITEREQUEST);
void WriterFile(PWRITEREQUEST);
void WriterBlock(PWRITEREQUEST);
void WriterFileStart(DWORD);
void WriterChar(PWRITEREQUEST);
void WriterGeneric(char *,DWORD);
BOOL WriterAddNewNode(DWORD,DWORD,char,char *,HANDLE,HWND);
BOOL WriterAddNewNodeTimeout(DWORD,DWORD,char,char *,HANDLE,HWND,DWORD);
BOOL WriterAddFirstNodeTimeout(DWORD,DWORD,char,char *,HANDLE,HWND,DWORD);
BOOL WriterAddExistingNode(PWRITEREQUEST,DWORD,DWORD,char,char *,HANDLE,HWND);
void AddToLinkedList(PWRITEREQUEST);
void AddToFrontOfLinkedList(PWRITEREQUEST);
PWRITEREQUEST RemoveFromLinkedList(PWRITEREQUEST);
void ErrorInComm(char *);
DWORD WINAPI ReaderAndStatusProc(LPVOID);
void ErrorHandler(char *);
// BlackBoxPlus specific functions
void BlackBoxDGPSInterpretedWindowOutput(HWND,char *,DWORD);
void BlackBoxDGPSInterpretedFileOutput(HANDLE,char *,DWORD);
BOOL BlackBoxEndOfCommand(char *,DWORD,char *,char *);
void BlackBoxInterpretCmd(char *);
// Minimal NMEA Parser functions
KNOWNSENTENCES NMEAParserGetSentenceType(const char *);
DWORD NMEAParserComputeChecksum(char *);
DWORD NMEAParserGetContainedChecksum(char *);
DWORD NMEAParserHexValue(const char *);
void NMEAParserAnalyzeGPRMC(char *);
CString NMEAParserField(int,char *);
static inline double NMEAParserGetDegreesFromNMEALat(const char,const char [10]);
static inline double NMEAParserGetMinutesFromNMEALat(const char [10]);
static inline double NMEAParserGetDegreesFromNMEALon(const char,const char [11]);
static inline double NMEAParserGetMinutesFromNMEALon(const char [11]);

// Inline functions definitions

// Remember: North is positive, south is negative
inline double NMEAParserGetDegreesFromNMEALat(const char nOrS,const char lat[10])
{
  char buf[3];
  double result;

  buf[0] = lat[0];
  buf[1] = lat[1];
  buf[2] = '\0';

  result = atof(buf); 

  if (nOrS == 'S') // NMEA uses capital letters
  {
    result = -result;
  }
  
  return result; 
}

inline double NMEAParserGetMinutesFromNMEALat(const char lat[10])
{
  char buf[8];

  buf[0] = lat[2];
  buf[1] = lat[3];  
  buf[2] = lat[4];
  buf[3] = lat[5];
  buf[4] = lat[6];
  buf[5] = lat[7];
  buf[6] = lat[8];
  buf[7] = '\0';

  return(atof(buf)); 
}

// Remember: West is negative, East is positive
inline double NMEAParserGetDegreesFromNMEALon(const char eOrW,const char lon[11])
{
  char buf[4];
  double result;

  buf[0] = lon[0];
  buf[1] = lon[1];
  buf[2] = lon[2];
  buf[3] = '\0';

  result = atof(buf);
  
  if (eOrW == 'W')  // NMEA uses capital letters