开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > MacOS编程 > 查看源码
Gps.cpp
资源名称：winceforGPSandGPRSconnect.rar　[点击查看]
上传用户：pumpssky
上传日期：2007-12-07
资源大小：110k
文件大小：14k
源码类别：

MacOS编程

开发平台：

C/C++

Gps.cpp：源码内容
  1. // Gps.cpp: implementation of the CGps class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "gmark.h"
  7. #include "define.h"
  8. #include "Gps.h"
  9. #include "GmarkDoc.h"
  10. #include "GmarkView.h"
  12. #ifdef _DEBUG
  13. #undef THIS_FILE
  14. static char THIS_FILE[]=__FILE__;
  15. #define new DEBUG_NEW
  16. #endif
  18. FILE *fpRinex;
  20. //////////////////////////////////////////////////////////////////////
  21. // Construction/Destruction
  22. //////////////////////////////////////////////////////////////////////
  24. CGps::CGps()
  25. {
  26. m_portA.SetGps( this );
  27. m_portA.m_bNoRead = FALSE;
  28. m_portB.m_bNoRead = TRUE;
  30. // Initialize the local variable
  31. for(int i=0; i<GPS_MAX_RECNUM; i++)
  32. {
  33. m_tCommData[i] = NULL;
  34. }
  36. m_CurrIndex = 0;
  38. m_bGpsMsgBusy = FALSE;
  39. }
  41. CGps::~CGps()
  42. {
  43. // Release the memory
  44. for(int i=0; i<GPS_MAX_RECNUM; i++)
  45. {
  46. if(m_tCommData[i] != NULL) delete m_tCommData[i];
  47. }
  48. }
  50. void CGps::OnReceived(unsigned char *buf, int nBytes)
  51. {
  52. m_pLog->Write((const char *)buf);
  54. /* char sTemp[256];
  55. memset(sTemp,0,sizeof(sTemp));
  56. sprintf(sTemp,"nBytes=%d, len=%d, buf[0]=%2X", nBytes, strlen((const char*)buf), buf[0]);
  57. m_pLog->Write((const char *)sTemp);*/
  59. ::SendMessage( m_hGmarkView, WM_GPSRECEIVED, (WORD)nBytes, (LONG)buf );
  60. }
  62. void CGps::AddChecksum(LPSTR cmd, LPSTR chksum)
  63. {
  64. int nIndex;
  65. int nLength;
  66. unsigned char cChkSum;
  67. unsigned char str[4];
  69. if(cmd == NULL || chksum == NULL) return;
  71. nLength =  strlen(cmd);
  72. if( nLength < 1 ) return; //empty command not need to add chksum
  74. memset( str, 0, sizeof(str) );
  76. cChkSum = 0;
  77. nIndex = 1;
  78. while( nIndex < nLength )
  79. {
  80. cChkSum = cChkSum^cmd[nIndex];
  81. nIndex++;
  82. }
  84. sprintf((char *)str, "*%02X", cChkSum);
  86. strcpy( chksum, cmd );
  87. chksum[nLength] = str[0];
  88. chksum[nLength+1] = str[1];
  89. chksum[nLength+2] = str[2];
  90. }
  92. void CGps::GetToken(LPSTR str, int n, LPSTR token)
  93. {
  94. int nLength =  strlen(str);
  95. int nCount = 0;
  96. int nTokenCount = 0;
  97. LPSTR szResult = new char[nLength+1];
  99. memset( szResult, 0,  nLength+1);
  101. while( nCount < nLength)
  102. {
  103. if( str[nCount] == ',' || str[nCount] == '*' )
  104. {
  105. if( nTokenCount == n )
  106. {
  107. break;
  108. }
  109. else
  110. {
  111. nTokenCount++;
  112. memset( szResult, 0,  nLength+1);
  113. }
  114. }
  115. else 
  116. {
  117. szResult[strlen(szResult)] = str[nCount]; 
  118. }
  120. nCount++;
  121. }
  123. strcpy( token, szResult );
  125. delete szResult;
  126. }
  128. void CGps::CompleteMsg(unsigned char *buf, int nBytes)
  129. {
  130. int nLen = nBytes;
  131. char *p = (char *)buf;
  132. char *CompMsg = new char[nLen + 1];
  133. int index = m_CurrIndex;
  134. int nIsCompleted;
  135. int nIsFoundPlace = 0;
  136. int nOrgLen = 0;
  137. int nCompLen= 0;
  139. nOrgLen = nBytes; 
  141. do
  142. {
  143. memset( CompMsg, 0, nLen + 1 );
  144. nIsCompleted = GetCompleteMsg( p, nOrgLen, CompMsg, nCompLen );
  146. //reset the offset in case anything left
  147. if( nIsCompleted == RET_OK) 
  148. {
  149. p = p + nCompLen + 2;
  150. nOrgLen = nOrgLen - nCompLen - 2;
  151. }
  153. // Find an index not completed to place the message
  154. index = m_CurrIndex;
  155. nIsFoundPlace = 0;
  156. do 
  157. {
  158. if( m_tCommData[index] == NULL ) 
  159. {
  160. m_tCommData[index] = new COMM_DATA;
  161. m_tCommData[index]->CompleteFlg = 0;
  162. memset( m_tCommData[index]->Message, 
  163. 0, 
  164. sizeof(m_tCommData[index]->Message) );
  166. nIsFoundPlace = 1;
  167. break;
  168. }
  169. else 
  170. {
  171. if( m_tCommData[index]->CompleteFlg == 1 )
  172. {
  173. index = IndexIncrease( index );
  174. continue;
  175. }
  177. nIsFoundPlace = 1;
  178. break;
  179. }
  180. } while(index != m_CurrIndex); //search only one round
  182. // append the message
  183. if(nIsFoundPlace == 1)
  184. {
  185. memcpy( m_tCommData[index]->Message + strlen(m_tCommData[index]->Message), 
  186. (const char *)CompMsg, nCompLen );
  187. }
  188. else 
  189. {
  190. memset( m_tCommData[index]->Message, 
  191. 0, 
  192. sizeof(m_tCommData[index]->Message) );
  193. memcpy( m_tCommData[index]->Message, 
  194. (const char *)CompMsg, nCompLen );
  195. }
  197. // set the flag
  198. if(nIsCompleted == RET_OK)
  199. {
  200. m_tCommData[index]->CompleteFlg = 1;
  202. // refresh the current index
  203. m_CurrIndex = IndexIncrease( index );
  204. }
  206. }while( (nIsCompleted == RET_OK) && (strlen(p) > 0) );
  209. delete CompMsg;
  210. }
  212. void CGps::CreateGPSData()
  213. {
  214. int index;
  215. char szCmdType[GPS_MAX_NEMASIZE+1];
  216. int nIsUpdate;
  218. index = m_CurrIndex;
  219. nIsUpdate = 0;
  220. do {
  221. if( m_tCommData[index] != NULL &&
  222. m_tCommData[index]->CompleteFlg == 1 ) 
  223. {
  224. // process message only when the checksum is right
  225. if( IsChecksumCorrect( m_tCommData[index]->Message) )
  226. {
  227. memset( szCmdType, 0, sizeof(szCmdType) );
  229. //according the command type do corresponding deal
  230. GetToken( m_tCommData[index]->Message, 0, szCmdType );
  232. if(strcmp(szCmdType, "$GPGGA") == 0)
  233. {
  234. ParseGGA( m_tCommData[index]->Message );
  236. // need to update gps data in the view
  237. nIsUpdate = 1;
  238. }
  239. else if(strcmp(szCmdType, "$GPGLL") == 0)
  240. {
  241. ParseGLL( m_tCommData[index]->Message );
  242. nIsUpdate = 1;
  243. }
  244. else if(strcmp(szCmdType, "$GPGSA") == 0)
  245. {
  246. ParseGSA( m_tCommData[index]->Message );
  247. nIsUpdate = 1;
  248. }
  249. else if(strcmp(szCmdType, "$PASHR") == 0)
  250. {
  251. GetToken( m_tCommData[index]->Message, 1, szCmdType );
  253. if(strcmp(szCmdType, "PBN") == 0) // PBN data
  254. {
  255. ParsePBN( m_tCommData[index]->Message );
  256. }
  257. if(strcmp(szCmdType, "MCA") == 0) // MCA data
  258. {
  259. ParseMCA( m_tCommData[index]->Message );
  260. }
  261. if(strcmp(szCmdType, "SNV") == 0) // SNV data
  262. {
  263. ParseSNV( m_tCommData[index]->Message );
  264. }
  265. else if(strcmp(szCmdType, "CRT") == 0)
  266. {
  267. ParseCRT( m_tCommData[index]->Message );
  268. }
  269. }
  270. }
  272. // release the record memory
  273. delete m_tCommData[index];
  274. m_tCommData[index] = NULL;
  275. }
  277. index = IndexIncrease( index );
  278. }
  279. while( index != m_CurrIndex );
  281. if( nIsUpdate == 1 )
  282. {
  283. // Notify the view to refresh the gps data
  284. ::PostMessage( m_hGmarkView, WM_GPSUPDATE, 0, 0 );
  285. }
  286. }
  288. int CGps::IndexIncrease(int index)
  289. {
  290. if( index >= GPS_MAX_RECNUM - 1 ) index = 0;
  291. else index++;
  293. return index;
  294. }
  296. int CGps::IndexDecrease(int index)
  297. {
  298. if( index <= 0 ) index = GPS_MAX_RECNUM - 1;
  299. else index--;
  301. return index;
  302. }
  304. void CGps::ParseGGA(char *Message)
  305. {
  306. char szToken[GPS_MAX_NEMASIZE+1];
  307. double c = 111352.0044; // = r*pai/180 = 6380000(m)*3.1415926/180
  309. GetToken( Message, 6, szToken );
  310. m_tGpsData.Status = atoi(szToken);
  312. GetToken( Message, 7, szToken );
  313. m_tGpsData.SatCount = atoi(szToken);
  315. GetToken( Message, 4, szToken );
  316. m_tGpsData.Longitude = DegToVal(szToken); //Jing du
  318. m_tGpsData.LonDeg = (int)m_tGpsData.Longitude;
  319. m_tGpsData.LonMin = (int)((m_tGpsData.Longitude - m_tGpsData.LonDeg)*60);
  320. m_tGpsData.LonSec = ((m_tGpsData.Longitude - m_tGpsData.LonDeg)*60 - m_tGpsData.LonMin)*60;
  322. GetToken( Message, 2, szToken );
  323. m_tGpsData.Latitude = DegToVal(szToken); //Wei du
  325. m_tGpsData.LatDeg = (int)m_tGpsData.Latitude;
  326. m_tGpsData.LatMin = (int)((m_tGpsData.Latitude - m_tGpsData.LatDeg)*60);
  327. m_tGpsData.LatSec = ((m_tGpsData.Latitude - m_tGpsData.LatDeg)*60 - m_tGpsData.LatMin)*60;
  329. // chang (longitude,latitude) to (x,y)
  330. // m_tGpsData.X =(m_tGpsData.Longitude - m_orig_lon)*c;
  331. // m_tGpsData.Y =(m_tGpsData.Latitude - m_orig_lat)*c;
  332. }
  334. void CGps::ParseGLL(char *Message)
  335. {
  336. char szToken[GPS_MAX_NEMASIZE+1];
  338. GetToken( Message, 1, szToken );
  339. m_tGpsData.Latitude = DegToVal(szToken);
  341. GetToken( Message, 3, szToken );
  342. m_tGpsData.Longitude = DegToVal(szToken);
  344. GetToken( Message, 6, szToken );
  345. // m_tGpsData.Status = atoi(szToken);
  346. }
  348. void CGps::ParseGSA(char *Message)
  349. {
  350. char szToken[GPS_MAX_NEMASIZE+1];
  352. GetToken( Message, 15, szToken );
  353. m_tGpsData.PDOP = atof(szToken);
  355. GetToken( Message, 16, szToken );
  356. m_tGpsData.HDOP = atof(szToken);
  358. GetToken( Message, 17, szToken );
  359. m_tGpsData.VDOP = atof(szToken);
  360. }
  362. void CGps::ParseCRT(char *Message)
  363. {
  364. char szToken[GPS_MAX_NEMASIZE+1];
  366. GetToken( Message, 2, szToken );
  367. m_tGpsData.Status = atoi(szToken);
  369. GetToken( Message, 3, szToken );
  370. m_tGpsData.SatCount = atoi(szToken);
  372. GetToken( Message, 5, szToken );
  373. m_tGpsData.X = atof(szToken);
  375. GetToken( Message, 6, szToken );
  376. m_tGpsData.Y = atof(szToken);
  378. GetToken( Message, 13, szToken );
  379. m_tGpsData.PDOP = atof(szToken);
  381. GetToken( Message, 14, szToken );
  382. m_tGpsData.HDOP = atof(szToken);
  384. GetToken( Message, 15, szToken );
  385. m_tGpsData.VDOP = atof(szToken);
  386. }
  388. void CGps::ParsePBN(char *Message)
  389. {
  390. #define PBN_DATA_SIZE 56
  391. char PbnData[PBN_DATA_SIZE];
  393. memcpy( PbnData, Message + 11, PBN_DATA_SIZE );
  395. if( !BinCheckSum(PbnData, PBN_DATA_SIZE) ) return;
  397. PBN_DATA *pbnData;
  399. // get PBN_DATA structure
  400. pbnData = (PBN_DATA *)PbnData;
  402. // write PBN_DATA to RINEX file
  403. fwrite(pbnData, 1, sizeof(PBN_DATA), fpRinex);
  404. }
  406. void CGps::ParseMCA(char *Message)
  407. {
  408. #define MCA_DATA_SIZE 37
  409. char McaData[MCA_DATA_SIZE];
  411. memcpy( McaData, Message + 11, MCA_DATA_SIZE );
  413. if( !BinCheckSum(McaData, MCA_DATA_SIZE, 1) ) return;
  415. MCA_DATA *mcaData;
  417. // get MCA_DATA structure
  418. mcaData = (MCA_DATA *)McaData;
  420. // write MCA_DATA to RINEX file
  421. fwrite(mcaData, 1, sizeof(MCA_DATA), fpRinex);
  422. }
  424. void CGps::ParseSNV(char *Message)
  425. {
  426. #define SNV_DATA_SIZE 132
  427. char SnvData[SNV_DATA_SIZE];
  429. memcpy( SnvData, Message + 11, SNV_DATA_SIZE );
  431. if( !BinCheckSum(SnvData, SNV_DATA_SIZE) ) return;
  433. SNV_DATA *snvData;
  435. // get SNV_DATA structure
  436. snvData = (SNV_DATA *)SnvData;
  438. // write SNV_DATA to RINEX file
  439. fwrite(snvData, 1, sizeof(SNV_DATA), fpRinex);
  440. }
  442. double CGps::DegToVal(char *deg)
  443. {
  444. double result;
  445. char *p=NULL;
  446. char d[4];
  447. char m[9];
  449. memset( d, 0, sizeof(d) );
  450. memset( m, 0, sizeof(m) );
  452. p = strstr( deg, "." );
  453. if(p)
  454. {
  455. int n = p-deg;
  456. strncpy( d, deg, n-2 );
  457. strncpy( m, deg+n-2, 8 );
  458. }
  459. else
  460. {
  461. strncpy( d, deg, sizeof(d)-1 );
  462. strcpy( m, "" );
  463. }
  465. result = atoi(d) + atof(m)/60;
  466. return result;
  467. }
  469. int CGps::SendCmd(LPSTR cmd)
  470. {
  471. LPSTR pSendCmd;
  472. char szCrLf[3] = {0x0d, 0x0a, 0};
  473. int nLength;
  474. int nRet;
  476. nLength =  strlen(cmd);
  477. pSendCmd = new char[nLength + 6];
  478. memset( pSendCmd, 0, nLength + 6 );
  480. // add checksum to command
  481. AddChecksum(cmd, pSendCmd);
  483. // add <cr>+<lf>
  484. strcpy( pSendCmd + strlen(pSendCmd), szCrLf );
  486. nRet = m_portA.SendData(pSendCmd, strlen(pSendCmd));
  488. if( (unsigned int)nRet != strlen(pSendCmd) ) nRet = RET_NG;
  489. else nRet = RET_OK;
  491. delete pSendCmd;
  493. return nRet;
  494. }
  496. int CGps::Initialize(int baudrate)
  497. {
  498. int nRet = RET_OK;
  500. //set the GGA message to be output automatically every 1 second.
  501. SendCmd("$PASHS,NME,GGA,A,ON,1");
  503. //Initialize the COM6 for port B of GPS module
  505. return nRet;
  506. }
  508. int CGps::Close()
  509. {
  510. int nRet = RET_OK;
  512. if(!m_portA.Close()) nRet = RET_NG;
  513. if(!m_portB.Close()) nRet = RET_NG;
  515. //close the raw data file
  516. fclose(fpRinex);
  518. return nRet;
  519. }
  521. void CGps::SetViewHandle(HWND hView)
  522. {
  523. m_hGmarkView = hView;
  524. }
  526. int CGps::Connect()
  527. {
  528. int nRet = RET_OK;
  530. //Initialize the COM2 for port A of GPS module
  532. while(1)
  533. {
  534. //the default bps of port A is 4800
  535. #ifndef _WIN32_WCE_CEPC
  536. if( m_portA.Open(2, 115200) == FALSE )
  537. #else
  538. if( m_portA.Open(1, 115200) == FALSE )
  539. #endif
  540. {
  541. nRet = RET_NG;
  542. break;
  543. }
  545. //the default bps of port B is 4800
  546. #ifndef _WIN32_WCE_CEPC
  547. if( m_portB.Open(6, 57600) == FALSE )
  548. #else
  549. if( m_portB.Open(0, 57600) == FALSE )
  550. #endif
  551. {
  552. nRet = RET_NG;
  553. break;
  554. }
  556. break;
  557. }
  559. //open file to write raw data
  560. char filename[MAX_PATH];
  562. memset( filename, 0, sizeof(filename) );
  563. this->m_GmarkView->CreateFilename(filename, FN_RAW);
  565. fpRinex = fopen( filename, "wb" );
  567. return nRet;
  568. }
  570. HWND CGps::GetViewHandle()
  571. {
  572. return m_hGmarkView;
  573. }
  575. int CGps::GetCompleteMsg(LPSTR OrgMsg, int nOrgLen, LPSTR CompMsg, int & nCompLen)
  576. {
  577. int nRet = RET_NG;
  578. char * p = NULL;
  580. for(int i = 0; i < nOrgLen-1; i++)
  581. {
  582. if( OrgMsg[i] == 0x0d &&
  583. OrgMsg[i+1] == 0x0a )
  584. {
  585. p = OrgMsg + i;
  586. break;
  587. }
  588. }
  590. if( p == NULL )
  591. {
  592. memcpy( CompMsg, OrgMsg, nOrgLen );
  593. nCompLen = nOrgLen;
  594. nRet = RET_NG;
  595. }
  596. else
  597. {
  598. nCompLen = p - OrgMsg;
  599. memcpy( CompMsg, OrgMsg, nCompLen );
  600. nRet = RET_OK;
  601. }
  603. return nRet;
  604. }
  606. void CGps::ClearGpsData()
  607. {
  608. m_tGpsData.Latitude = -1;
  609. m_tGpsData.Longitude = -1;
  610. m_tGpsData.SatCount = -1;
  611. m_tGpsData.Status = -1;
  613. // Notify the view to refresh the gps data
  614. ::PostMessage( m_hGmarkView, WM_GPSUPDATE, 0, 0 );
  615. }
  617. void CGps::WriteRTCM(char *rtcm)
  618. {
  619. m_portB.SendData( rtcm, strlen(rtcm) );
  620. }
  622. void CGps::SetOrigPosition(double orig_lon, double orig_lat)
  623. {
  624. m_orig_lon = orig_lon;
  625. m_orig_lat = orig_lat;
  626. }
  628. BOOL CGps::IsChecksumCorrect(char *message)
  629. {
  630. char szCmd[GPS_MAX_NEMASIZE+1];
  631. char szChecksum[GPS_MAX_NEMASIZE+1];
  632. char *p;
  634. memset(szCmd, 0, sizeof(szCmd));
  635. memset(szChecksum, 0, sizeof(szChecksum));
  637. if(strncmp(message, "$PASHR,PBN,", 11)==0)
  638. {
  639. return TRUE;
  640. }
  642. p = strstr( message, "*" );
  643. if(!p)
  644. {
  645. return FALSE;
  646. }
  648. strncpy( szCmd, message, p-message );
  650. AddChecksum( szCmd, szChecksum );
  652. if( strcmp( message, szChecksum ) != 0 )
  653. {
  654. return FALSE;
  655. }
  657. return TRUE;
  658. }
  660. void CGps::SetViewWnd(CWnd *pWnd)
  661. {
  662. m_GmarkView = (CGmarkView *)pWnd;
  663. }
  665. BOOL CGps::BinCheckSum(char *buf, int len, int BinType)
  666. {
  667. if(BinType == 0)
  668. {
  669. unsigned short chsum, checksum;
  670. unsigned short * p;
  672. p = (unsigned short *)buf;
  673. chsum = 0;
  675. for(int i=0; i<len-2; i+=2)
  676. {
  677. chsum += *p;
  678. p++;
  679. }
  681. checksum = *p;
  683. if(chsum == checksum) return TRUE;
  684. else return FALSE;
  685. }
  686. else
  687. {
  688. unsigned char chsum, checksum;
  689. unsigned char * p;
  691. p = (unsigned char *)buf;
  692. chsum = 0;
  694. for(int i=0; i<len-1; i++)
  695. {
  696. chsum = (*p)^chsum;
  697. p++;
  698. }
  700. checksum = *p;
  702. if(chsum == checksum) return TRUE;
  703. else return FALSE;
  704. }
  705. }