source: ntrip/trunk/BNC/RTIGS/cgps_transform.cpp@ 60

Last change on this file since 60 was 58, checked in by mervart, 20 years ago

* empty log message *
File size: 20.2 KB
Line 
1#include "cgps_transform.h"
2
3#define MAXSTREAM 10000
4
5////////////////////////////////////////////////////////////////////////////
6void SwitchBytes( char *Start, int Size ) {
7 char Tmp;
8 char *End = Start + Size - 1;
9 for( Tmp = *Start; Start < End; Tmp = *Start ){
10 *Start++ = *End;
11 *End-- = Tmp;
12 }
13}
14
15int main() {
16
17 unsigned char data_stream[MAXSTREAM];
18 unsigned short numbytes;
19 RTIGSS_T rtigs_sta;
20 RTIGSO_T rtigs_obs;
21 RTIGSM_T rtigs_met;
22 RTIGSE_T rtigs_eph;
23 short PRN;
24 short retval;
25 unsigned short statID;
26 unsigned short messType;
27 CGPS_Transform GPSTrans;
28
29 memset(data_stream , 0, sizeof(data_stream));
30
31 // use something like recvfrom
32 FILE* inpFile = fopen("RTIGS.txt", "rb");
33
34 while (true) {
35 size_t nr = 0;
36 if (inpFile) {
37 nr = fread(data_stream, sizeof(unsigned char), MAXSTREAM, inpFile);
38 if (nr == 0) exit(0);
39 cout << "Number of bytes read: " << nr << endl;
40 }
41 else {
42 exit(1);
43 }
44
45 // Find the beginning of the message
46 // ---------------------------------
47 size_t sz = sizeof(unsigned short);
48 bool found = false;
49 size_t ii;
50 for (ii = 0; ii < nr - sz; ii += sz) {
51 unsigned short xx;
52 memcpy( (void*) &xx, &data_stream[ii], sz);
53 SwitchBytes( (char*) &xx, sz);
54 if (xx == 200) {
55 found = true;
56 break;
57 }
58 }
59 if (! found) {
60 cout << "Message not found\n";
61 exit(0);
62 }
63 else {
64 cout << "Message found at " << ii << endl;
65 }
66
67
68 messType = GPSTrans.GetRTIGSHdrRecType(&data_stream[ii]);
69 numbytes = GPSTrans.GetRTIGSHdrRecBytes(&data_stream[ii]);
70 statID = GPSTrans.GetRTIGSHdrStaID(&data_stream[ii]);
71
72 cout << "messType " << messType << endl;
73 cout << "numbytes " << numbytes << endl;
74 cout << "statID " << statID << endl;
75
76 switch (messType) {
77 case 100:
78 GPSTrans.Decode_RTIGS_Sta(&data_stream[ii], numbytes , rtigs_sta);
79 break;
80 case 200:
81 retval = GPSTrans.Decode_RTIGS_Obs(&data_stream[ii], numbytes , rtigs_obs);
82 if (retval >= 1) {
83 GPSTrans.print_CMEAS();
84 }
85 break;
86 case 300:
87 retval = GPSTrans.Decode_RTIGS_Eph(&data_stream[ii], numbytes , rtigs_eph, PRN);
88 break;
89 case 400:
90 retval = GPSTrans.Decode_RTIGS_Met(&data_stream[ii], numbytes , &rtigs_met);
91 break;
92 }
93 }
94
95 return 0;
96}
97
98// Constructor
99////////////////////////////////////////////////////////////////////////////
100CGPS_Transform::CGPS_Transform() {
101
102 // Decoded Obs Array of 12 CMeas Observation Records
103 memset((void *)&DecObs, 0, sizeof(ARR_OBS_T ));
104
105 // Keplarian Broadcast Eph
106 memset((void *)&TNAV_Eph,0, sizeof(ARR_TNAV_T ));
107
108 NumObsRead = -1;
109 CAFlag = -1;
110 ASFlag = -1;
111 P2Flag = -1;
112 P1Flag = -1;
113 InitEndianFlag();
114
115 memset (PhaseArcStartTime, 0, sizeof(PhaseArcStartTime));
116}
117
118// Destructor
119////////////////////////////////////////////////////////////////////////////
120CGPS_Transform::~CGPS_Transform() {
121}
122
123//
124////////////////////////////////////////////////////////////////////////////
125unsigned short CGPS_Transform::GetRTIGSHdrRecType(unsigned char *RTIGS_Str)
126{
127 unsigned short recordID;
128 memcpy ((void *)&recordID,RTIGS_Str, sizeof(recordID));
129 if (f_IsLittleEndian)
130 {
131 SwitchBytes( (char *)&recordID, sizeof(recordID) );
132 }
133 return recordID;
134}
135
136//
137////////////////////////////////////////////////////////////////////////////
138unsigned short CGPS_Transform::GetRTIGSHdrRecBytes(unsigned char *RTIGS_Str)
139{
140 unsigned short bytes;
141 memcpy ((void *)&bytes,&RTIGS_Str[8], sizeof(bytes));
142 if (f_IsLittleEndian)
143 {
144 SwitchBytes( (char *)&bytes, sizeof(bytes) );
145 }
146 return bytes;
147
148}
149
150//
151////////////////////////////////////////////////////////////////////////////
152unsigned short CGPS_Transform::GetRTIGSHdrStaID(unsigned char *RTIGS_Str)
153{
154 unsigned short StaID = 0;
155 memcpy ((void *)&StaID, &RTIGS_Str[2], sizeof(StaID));
156 if (f_IsLittleEndian)
157 {
158 SwitchBytes( (char *)&StaID, sizeof(StaID) );
159 }
160 return StaID;
161}
162
163
164//
165////////////////////////////////////////////////////////////////////////////
166void CGPS_Transform::InitEndianFlag() {
167 short one = 1;
168 char *cp = (char *)&one;
169 if (*cp== 0) {
170 f_IsLittleEndian = false;
171 }
172 else {
173 f_IsLittleEndian = true;
174 }
175}
176
177
178//
179////////////////////////////////////////////////////////////////////////////
180unsigned long CGPS_Transform::JPL_xtractLongVal (unsigned startBitNbr, unsigned xtractNbrBits, const char *msg)
181{
182 unsigned long retValue=0, i=0;
183
184 unsigned short posBit = xtractNbrBits - 1;
185
186 for(i=0; i<xtractNbrBits; i++, startBitNbr++)
187 {
188 unsigned short numShift = 7 - (startBitNbr % 8);
189 unsigned short byteNbr = startBitNbr / 8;
190 retValue |= (((msg[byteNbr] >> numShift) & 0x0001) << posBit--);
191
192 }
193
194 return retValue;
195}
196
197//
198////////////////////////////////////////////////////////////////////////////
199inline void CGPS_Transform::SwitchIGS_Sta_HdrBytes( RTIGSS_T *StaHdr)
200{
201 SwitchBytes( (char *)&StaHdr->GPSTime, sizeof(unsigned long) );
202 SwitchBytes( (char *)&StaHdr->num_bytes, sizeof(unsigned short) );
203 SwitchBytes( (char *)&StaHdr->rec_id, sizeof(unsigned short) );
204 SwitchBytes( (char *)&StaHdr->sta_id, sizeof(unsigned short) );
205}
206
207//
208////////////////////////////////////////////////////////////////////////////
209inline void CGPS_Transform::SwitchIGS_Obs_HdrBytes( RTIGSO_T *ObsHdr)
210{
211 SwitchBytes( (char *)&ObsHdr->GPSTime, sizeof(unsigned long) );
212 SwitchBytes( (char *)&ObsHdr->num_bytes, sizeof(unsigned short) );
213 SwitchBytes( (char *)&ObsHdr->rec_id, sizeof(unsigned short) );
214 SwitchBytes( (char *)&ObsHdr->sta_id, sizeof(unsigned short) );
215}
216
217//
218////////////////////////////////////////////////////////////////////////////
219inline void CGPS_Transform::SwitchIGS_Eph_HdrBytes( RTIGSE_T *EphHdr)
220
221{
222 SwitchBytes( (char *)&EphHdr->CollectedGPSTime, sizeof(unsigned long) );
223 SwitchBytes( (char *)&EphHdr->num_bytes, sizeof(unsigned short) );
224 SwitchBytes( (char *)&EphHdr->rec_id, sizeof(unsigned short) );
225 SwitchBytes( (char *)&EphHdr->sta_id, sizeof(unsigned short) );
226}
227
228//
229////////////////////////////////////////////////////////////////////////////
230inline short CGPS_Transform::SwitchIGS_Met_RecBytes( RTIGSM_T *MetHdr)
231{
232short retval = 1;
233short i, num_items;
234 num_items = (short)MetHdr->numobs;
235 SwitchBytes( (char *)&MetHdr->GPSTime, sizeof(unsigned long) );
236 SwitchBytes( (char *)&MetHdr->num_bytes, sizeof(unsigned short) );
237 SwitchBytes( (char *)&MetHdr->rec_id, sizeof(unsigned short) );
238 SwitchBytes( (char *)&MetHdr->sta_id, sizeof(unsigned short) );
239
240 /*switch met data bytes*/
241 for (i=0; i < num_items; i++)
242 {
243 if (&MetHdr->mets[i] != NULL)
244 {
245 SwitchBytes( (char *)&MetHdr->mets[i], sizeof(long) );
246 }
247 else
248 {
249 retval = -1;
250 }
251
252 }
253return retval;
254}
255//
256////////////////////////////////////////////////////////////////////////////
257
258short CGPS_Transform::Save_TNAV_T_To_Container(TNAV_T *rtcurrent_eph, short &prn)
259{
260short retval = 1;//, i;
261long PRN;
262
263 PRN = rtcurrent_eph->Satellite;
264
265 if (f_IsLittleEndian)
266 {
267 SwitchBytes( (char *)&PRN, sizeof(PRN));
268 }
269
270 if ((PRN > 0) && (PRN <= 32))
271 {
272 memcpy( (void *)&TNAV_Eph.Eph[(PRN-1)] ,rtcurrent_eph,sizeof(TNAV_T));
273 prn = (short)PRN;
274 }
275 else
276 {
277 retval = -1;
278 }
279return retval;
280}
281
282//
283////////////////////////////////////////////////////////////////////////////
284short CGPS_Transform::CA_Extract(char * CAStr, double &CA_Rng)
285{
286
287
288unsigned long CARng2, CARng1;
289short retval = 0;
290double dtemp;
291
292
293 CGPS_Transform::CAFlag = JPL_xtractLongVal(0, 1, CAStr);
294 CGPS_Transform::ASFlag = JPL_xtractLongVal(1, 1, CAStr);
295 CGPS_Transform::P2Flag = JPL_xtractLongVal(2, 1, CAStr);
296 CGPS_Transform::P1Flag = JPL_xtractLongVal(3, 1, CAStr);
297
298 if (CAFlag)
299 {
300 //Read most significant bits
301 CARng2 = JPL_xtractLongVal(4, 4, CAStr);
302 //Read an int's worth of data
303 CARng1 = JPL_xtractLongVal (8,32,CAStr);
304// if (f_IsLittleEndian == false)
305// {
306 //KML June 8/2004
307 //Added this code to deal with Big Endian architectures
308// SwitchBytes( (char *) &CARng2, sizeof(CARng2) );
309// SwitchBytes( (char *) &CARng1, sizeof(CARng1) );
310// }
311
312 dtemp = 0.0;
313 dtemp = CARng2;
314
315 CA_Rng = dtemp*pow ((double)2,32);
316 CA_Rng += CARng1;
317
318 CA_Rng /= 1000; //CA in metres
319 }
320 else
321 {
322 retval = -1;
323 }
324return retval;
325}
326
327//
328////////////////////////////////////////////////////////////////////////////
329short CGPS_Transform::P1_P2_Block_Extract(char * P1P2Str, double CA, double &Rng , double &Phase, double &RngF2Delta,short decode_F1orF2Flag )
330{
331short retval =0;
332short PhaseOverFlowFlag;
333long SignFlag,temp;
334
335double RngDelta, PhaseDelta;
336
337 if (decode_F1orF2Flag == 1)
338 {
339 PhaseOverFlowFlag = CGPS_Transform::P1Flag;
340 }
341 else if (decode_F1orF2Flag == 2)
342 {
343 PhaseOverFlowFlag = CGPS_Transform::P2Flag;
344 }
345 //*****************************
346 // Decode Pseudo Range
347 //*****************************
348 SignFlag = JPL_xtractLongVal (0,1,P1P2Str);
349 temp = JPL_xtractLongVal (1,17,P1P2Str);
350
351//KML June 8/2004
352// if (f_IsLittleEndian == false)
353// {
354 //Added this code to deal with Big Endian architectures
355// SwitchBytes( (char *) &temp, sizeof(temp) );
356// }
357
358
359 RngDelta = temp;
360 RngDelta /= 1000.0;
361
362
363 if (SignFlag)
364 {
365 RngDelta *= -1;
366 }
367
368
369 if (decode_F1orF2Flag == 2)
370 {
371 RngF2Delta = RngDelta;
372 }
373
374 Rng = CA + RngDelta;
375
376 //***************************
377 // Decode Phase
378 //***************************
379
380 SignFlag = JPL_xtractLongVal (18,1, P1P2Str);
381 temp = JPL_xtractLongVal (19,21, P1P2Str);
382// if (f_IsLittleEndian == false)
383// {
384
385 //KML June 8th 2004
386 //Added this code to deal with Big Endian architectures
387// SwitchBytes( (char *) &temp, sizeof(temp) );
388// }
389
390 PhaseDelta = temp;
391
392 PhaseDelta = PhaseDelta * 2 / 100000;
393
394
395
396
397 //Phase overflow add to phase
398 if(PhaseOverFlowFlag)
399 {
400 PhaseDelta += MAXL1L2;
401 }
402
403 if (SignFlag)
404 {
405 PhaseDelta *= -1;
406 }
407
408 if (decode_F1orF2Flag == 1)
409 {
410 // frequency 1
411 Phase = (CA - (ScaleFactor2*RngF2Delta)+ PhaseDelta) / L1;
412 }
413 else if (decode_F1orF2Flag == 2)
414 {
415 // frequency 2
416 Phase = (CA - (ScaleFactor1*RngF2Delta)+ PhaseDelta) / L2;
417 }
418 else
419 {
420 retval =-1;
421 }
422return retval;
423}
424
425//
426////////////////////////////////////////////////////////////////////////////
427short CGPS_Transform::Decode_RTIGS_Sta(unsigned char *RTIGS_Str, unsigned short RTIGS_Bytes, RTIGSS_T &rtigs_sta)
428{
429short retval = 1;
430 memcpy ((void *)&rtigs_sta.rec_id, &RTIGS_Str[0], (sizeof(RTIGSS_T) - sizeof(rtigs_sta.data)));
431 if (f_IsLittleEndian)
432 {
433 SwitchIGS_Sta_HdrBytes( &rtigs_sta);
434 }
435 if (rtigs_sta.rec_id == 100)
436 {
437 if (rtigs_sta.sta_rec_type ==0 )
438 {
439 rtigs_sta.data = NULL;
440 }
441 else
442 {
443 retval = -2; //no other type supported at this time
444 }
445 }
446
447
448 else
449 {
450
451
452 retval = -1;
453
454 }
455
456return retval ;
457}
458
459//
460////////////////////////////////////////////////////////////////////////////
461short CGPS_Transform::Decode_RTIGS_Soc_Obs(unsigned char *SocStr, short &StrPos, short CMeasIndex, short SocBytes, unsigned long GPSTime)
462{
463short retval =1;
464double CA, RngF2Delta, PhaseL1,PhaseL2, P1, P2;
465//static unsigned short PhaseArcStartTime[MAXSV]; moved to class header
466JPL_COMP_OBS_T GPSObs;
467//printf("String pos %hd Total Bytes %hd\n", StrPos,SocBytes);
468
469 if ((StrPos <= SocBytes) && ((CMeasIndex >= 0 ) && (CMeasIndex < MAXSV )))
470 {
471
472 memcpy((void *)&GPSObs.prn, (void *)&SocStr[StrPos], 1);
473
474 if ((GPSObs.prn > 0 ) && (GPSObs.prn <= 32))
475 {
476 StrPos+=1;
477
478 memcpy((void *)&GPSObs.epoch_sequence, (void *)&SocStr[StrPos],2);
479
480 if (f_IsLittleEndian == false)
481 {
482 //KML June 8/2003
483 //Added this code to deal with Big Endian architectures
484 SwitchBytes( (char *) &GPSObs.epoch_sequence, sizeof(GPSObs.epoch_sequence) );
485 }
486
487 //******************************
488 // Read and decode CA
489 //******************************
490 StrPos+=2;
491 memcpy((void *)&GPSObs.ca_range, (void *)&SocStr[StrPos],5);
492 CA_Extract(GPSObs.ca_range, CA);
493
494 if (CGPS_Transform::CAFlag) //Defined in the Class by CA_Extract
495 {
496 //************************************
497 // Read CA SNR
498 //************************************
499 StrPos+=5;
500 memcpy((void *)&GPSObs.CA_snr, (void *)&SocStr[StrPos],1);
501 //************************************
502 // Read and decode P2 L2
503 //************************************
504 StrPos+=1;
505 memcpy((void *)&GPSObs.L2_range_phase, (void *)&SocStr[StrPos],5);
506
507 P1_P2_Block_Extract(GPSObs.L2_range_phase, CA, P2 , PhaseL2, RngF2Delta, 2 );
508
509
510 StrPos+=5;
511 memcpy((void *)&GPSObs.L2_snr, (void *)&SocStr[StrPos],1);
512 //************************************
513 // Read and decode P1 L1
514 //************************************
515 StrPos+=1;
516
517
518 memcpy((void *)&GPSObs.L1_range_phase, (void *)&SocStr[StrPos],5);
519
520 P1_P2_Block_Extract(GPSObs.L1_range_phase, CA, P1, PhaseL1, RngF2Delta, 1);
521
522 StrPos+=5;
523 memcpy((void *)&GPSObs.L1_snr, (void *)&SocStr[StrPos],1);
524 StrPos+=1;
525
526 DecObs.Obs[CMeasIndex].GPSTime = GPSTime; /* broadcast time sec.*/
527 DecObs.Obs[CMeasIndex].chn = CMeasIndex + 1; /* Channel not real*/
528 DecObs.Obs[CMeasIndex].sat_prn = GPSObs.prn; /* satellite ID*/
529 DecObs.Obs[CMeasIndex].ntrvl = 1; /* number of seconds Changed from 0 to 1 Nov. 25/2003*/
530 DecObs.Obs[CMeasIndex].flag[0] = 4; /*observation quality flags*/ //KML Changed Nov. 25/2000 to 4 to indicate Benchmark
531
532 if (PhaseArcStartTime[(short)(GPSObs.prn-1)] != GPSObs.epoch_sequence)
533 {
534 PhaseArcStartTime[(short)(GPSObs.prn-1)] = GPSObs.epoch_sequence;
535 DecObs.Obs[CMeasIndex].flag[0] |= 0x20;
536 }
537
538 DecObs.Obs[CMeasIndex].l1_pseudo_range = CA; /* frequency-1 CA pseudorange */
539 DecObs.Obs[CMeasIndex].l1_phase = PhaseL1; /* frequency-1 CA carrier phase */
540 //****************************************************
541 // Changed SNR Ashtech to DBHz Nov 15/2002
542 //****************************************************
543 DecObs.Obs[CMeasIndex].l1_sn = GPSObs.CA_snr;
544
545 DecObs.Obs[CMeasIndex].p1_pseudo_range = P1; /* frequency-1 P1 carrier phase */
546 DecObs.Obs[CMeasIndex].p1_phase = PhaseL1; /* frequency-1 P1 pseudorange */
547
548 DecObs.Obs[CMeasIndex].p1_sn = GPSObs.L1_snr;
549
550 DecObs.Obs[CMeasIndex].l2_pseudo_range = P2; /* frequency-2 pseudorange (XCorr) */
551 DecObs.Obs[CMeasIndex].l2_phase = PhaseL2; /* frequency-2 carrier phase (XCorr) */
552
553 DecObs.Obs[CMeasIndex].l2_sn = GPSObs.L2_snr;
554 DecObs.Obs[CMeasIndex].p2_pseudo_range = P2; /* frequency-2 pseudorange */
555 DecObs.Obs[CMeasIndex].p2_phase = PhaseL2; /* frequency-2 carrier phase */
556 }
557 else
558 {
559 //skip this obs
560 DecObs.Obs[CMeasIndex].sat_prn = 0;
561 }
562 }
563 else
564 {
565 retval = -2;
566
567 }
568 }
569 else
570 {
571 retval = -1;
572 }
573return retval;
574}
575
576//
577////////////////////////////////////////////////////////////////////////////
578short CGPS_Transform::RTIGSO_Str_To_CMEAS(unsigned char *RTIGSO_Str, short RTIGS_Bytes, RTIGSO_T &rtigs_obs)
579{
580short retval =1,i, StrPos;//, HdrRetval;
581//short NumObs= 0;
582short decoded_cnt = 0;
583short IGSObsMinusPtr;
584
585
586 //************************************
587 // Zero out CMEAS_T container
588 //************************************
589memset((void *)&DecObs.Obs[0], 0 , sizeof(ARR_OBS_T) );
590
591 //***********************************************
592 // Decode Header store in class container
593 //***********************************************
594
595
596 StrPos = IGSObsMinusPtr = sizeof(RTIGSO_T) - sizeof (rtigs_obs.data);
597
598 cout << "StrPos " << StrPos << endl;
599
600 memcpy ((void *)&rtigs_obs.rec_id, RTIGSO_Str, IGSObsMinusPtr);
601
602 if (f_IsLittleEndian)
603 {
604 SwitchIGS_Obs_HdrBytes( &rtigs_obs);
605 }
606
607
608 // printf("RecNumber : %hd Station ID %hd Num Obs %hd NumBytes %hd\n",rtigs_obs.rec_id, rtigs_obs.sta_id, rtigs_obs.num_obs, rtigs_obs.num_bytes);
609
610 if((rtigs_obs.rec_id == 200) && (rtigs_obs.num_obs <= MAXCHANNELS_FOR_SOCKETS_TYPE1))
611 {
612 for (i = 0 ; i < rtigs_obs.num_obs;i++)
613 {
614 //*********************************************
615 // the following function decodes the soc
616 // structure and writes the obs to the
617 // class's CMEAS container
618 //*********************************************
619
620 if (Decode_RTIGS_Soc_Obs( RTIGSO_Str, StrPos, decoded_cnt, RTIGS_Bytes, rtigs_obs.GPSTime) < 0)
621 {
622 retval = -2;
623 }
624 else
625 {
626 decoded_cnt ++;
627 }
628 }//end of for
629 retval = NumObsRead = decoded_cnt; //NumObsRead class member
630 }
631 else
632 {
633 retval = -1;
634 }
635//ObsSeqNum++;
636return retval;
637}
638
639
640//
641////////////////////////////////////////////////////////////////////////////
642short CGPS_Transform::Decode_RTIGS_Obs(unsigned char *RTIGSO_Str, unsigned short RTIGS_Bytes,RTIGSO_T &rtigs_obs)
643{
644 short retval = 1;//, i;
645
646
647 if ((retval = RTIGSO_Str_To_CMEAS(RTIGSO_Str, RTIGS_Bytes, rtigs_obs)) < 0)
648 {
649 retval = -1;
650 }
651
652return retval;
653}
654
655//
656////////////////////////////////////////////////////////////////////////////
657short CGPS_Transform::Decode_RTIGS_Met(unsigned char *RTIGS_Str, unsigned short RTIGS_Bytes, RTIGSM_T *rtigs_met)
658{
659short retval = 1;
660short numbytes = 0;
661numbytes = sizeof(RTIGSM_T) - sizeof(rtigs_met->mets);
662memcpy ((void *)rtigs_met, RTIGS_Str, numbytes);
663
664 if ((short)rtigs_met->numobs <= 3)
665 {
666 if (rtigs_met->mets != NULL)
667 {
668 memcpy ((void *)&rtigs_met->mets[0], &RTIGS_Str[numbytes], ((short)rtigs_met->numobs * sizeof(long)) );
669 if (f_IsLittleEndian)
670 {
671 SwitchIGS_Met_RecBytes( rtigs_met);
672 }
673 if (rtigs_met->rec_id != 400)
674 {
675 retval = -1;
676 }
677 }
678 else
679 {
680 retval = -2;
681 delete [] rtigs_met->mets;
682 }
683 }
684 else
685 {
686 printf("failed number of Obs\n");
687 }
688
689return retval;
690}
691
692//
693////////////////////////////////////////////////////////////////////////////
694short CGPS_Transform::Decode_RTIGS_Eph(unsigned char *RTIGS_Str, unsigned short RTIGS_Bytes, RTIGSE_T &rtigs_eph, short &PRN)
695{
696 short retval = 1;//, i;
697 short index = 0;
698 short prn;
699 const short SubFrameSize = 24;
700 TNAV_T trans_eph;
701 index = sizeof(RTIGSE_T ) - sizeof (rtigs_eph.data);
702
703 memcpy ((void *)&rtigs_eph.rec_id, &RTIGS_Str[0], index); //copy header into struct from string
704 if (f_IsLittleEndian)
705 {
706 SwitchIGS_Eph_HdrBytes( &rtigs_eph);
707 }
708
709 if (rtigs_eph.rec_id == 300)
710 {
711 //*********************************************
712 // the following method saves the eph
713 // in the class's TNAV_T container
714 //*********************************************
715 trans_eph.GPSCollectedTime = rtigs_eph.CollectedGPSTime;
716 trans_eph. Satellite = (long)rtigs_eph.prn;
717 //********************************************
718 // Container class is in network byte order
719 //********************************************
720 if (f_IsLittleEndian)
721 {
722 SwitchBytes( (char *)&trans_eph.GPSCollectedTime, sizeof(trans_eph.GPSCollectedTime) );
723 SwitchBytes( (char *)&trans_eph. Satellite, sizeof(trans_eph. Satellite) );
724 }
725
726 memcpy((void *)&trans_eph.SubFrame1, (const void *)&RTIGS_Str[index], SubFrameSize);
727 memcpy((void *)&trans_eph.SubFrame2, (const void *)&RTIGS_Str[(index + SubFrameSize)], SubFrameSize);
728 memcpy((void *)&trans_eph.SubFrame3, (const void *)&RTIGS_Str[(index + (SubFrameSize * 2)) ], SubFrameSize);
729 if (Save_TNAV_T_To_Container(&trans_eph, prn) >= 1) //function saves eph in container and returns prn
730 {
731 PRN = prn;
732 }
733 else
734 {
735 retval = -1;
736 }
737 }
738 else
739 {
740 retval = -1;
741 }
742
743return retval;
744}
745
746void CGPS_Transform::print_CMEAS()
747{
748short i;
749 printf("\nGPSTime SV CA SNR P1 SNR P2 SNR\n");
750 printf("Seconds (m) DBHz (m) DBHz (m) DBHz\n");
751 for (i=0; i < NumObsRead ; i++)
752 {
753 printf("%ld %2hd %10.1lf %4.1f %10.1lf %4.1f %10.1lf %4.1f \n",DecObs.Obs[i].GPSTime, DecObs.Obs[i].sat_prn,
754 DecObs.Obs[i].l1_pseudo_range,DecObs.Obs[i].l1_sn,
755 DecObs.Obs[i].p1_pseudo_range, DecObs.Obs[i].p1_sn,
756 DecObs.Obs[i].l2_pseudo_range,DecObs.Obs[i].l2_sn);
757 }
758}
759
Note: See TracBrowser for help on using the repository browser.