Index: /trunk/BNC/RTIGS/RTIGSDecoder.cpp =================================================================== --- /trunk/BNC/RTIGS/RTIGSDecoder.cpp (revision 304) +++ /trunk/BNC/RTIGS/RTIGSDecoder.cpp (revision 305) @@ -1,26 +1,2 @@ -// Part of BNC, a utility for retrieving decoding and -// converting GNSS data streams from NTRIP broadcasters, -// written by Leos Mervart. -// -// Copyright (C) 2006 -// German Federal Agency for Cartography and Geodesy (BKG) -// http://www.bkg.bund.de -// Czech Technical University Prague, Department of Advanced Geodesy -// http://www.fsv.cvut.cz -// -// Email: euref-ip@bkg.bund.de -// -// This program is free software; you can redistribute it and/or -// modify it under the terms of the GNU General Public License -// as published by the Free Software Foundation, version 2. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. /* ------------------------------------------------------------------------- @@ -28,5 +4,5 @@ * ------------------------------------------------------------------------- * - * Class: RTIGSDecoder + * Class: rtigs * * Purpose: RTIGS Decoder @@ -40,23 +16,25 @@ * -----------------------------------------------------------------------*/ -#include "RTIGSDecoder.h" +#include "rtigs.h" #include "bncconst.h" -#include "rtigs.h" using namespace std; +#undef L1 +#undef L2 + // Constructor //////////////////////////////////////////////////////////////////////////// -RTIGSDecoder::RTIGSDecoder() { +rtigs::rtigs() { } // Destructor //////////////////////////////////////////////////////////////////////////// -RTIGSDecoder::~RTIGSDecoder() { +rtigs::~rtigs() { } // //////////////////////////////////////////////////////////////////////////// -void RTIGSDecoder::Decode(char* buffer, int bufLen) { +void rtigs::Decode(char* buffer, int bufLen) { // Append the incomming data to the internal buffer @@ -70,5 +48,7 @@ unsigned short xx; memcpy( (void*) &xx, &_buffer.data()[ii], sizeof(xx) ); - revbytes( (unsigned char*) &xx, sizeof(xx) ); + if (_GPSTrans.f_IsLittleEndian) { + SwitchBytes( (char*) &xx, sizeof(xx) ); + } if (xx == 200) { _buffer = _buffer.mid(ii); @@ -77,4 +57,5 @@ } } + if (! found) { _buffer.clear(); @@ -82,41 +63,34 @@ } - // Read the Header - // --------------- - if (_buffer.size() < (int) sizeof(RTIGSH)) { - return; - } - RTIGSH rtigs_header; - bytes_to_rtigsh(&rtigs_header, (unsigned char*) _buffer.data()); + unsigned char* p_buf = (unsigned char*) _buffer.data(); - // Read the Observations - // --------------------- - int numBytes = sizeof(RTIGSH) + rtigs_header.num_bytes; - if (_buffer.size() < numBytes) { + unsigned short messType = _GPSTrans.GetRTIGSHdrRecType(p_buf); + unsigned short numbytes = _GPSTrans.GetRTIGSHdrRecBytes(p_buf); + + // Not enough new data, return + // --------------------------- + if (_buffer.size() < numbytes) { return; } - if (rtigs_header.rec_id == 200) { - RTIGSO rtigs_obs; - memcpy(&rtigs_obs, &rtigs_header, sizeof(RTIGSH)); - memcpy((unsigned char*) &rtigs_obs.data, _buffer.data(), - rtigs_header.num_bytes - sizeof(RTIGSH)); + // Decode the epoch + // ---------------- + if (messType == 200) { + RTIGSO_T rtigs_obs; + short numObs = _GPSTrans.Decode_RTIGS_Obs(p_buf, numbytes, rtigs_obs); - GPSEpoch epoch; - rtigso_to_raw(&rtigs_obs, &epoch); - - for (short ii = 0; ii < epoch.num_sv; ii++) { + for (short ii = 0; ii < numObs; ii++) { Observation* obs = new Observation(); - obs->SVPRN = epoch.sv[ii].prn; - obs->GPSWeek = epoch.GPSTime / (7 * 86400); - obs->GPSWeeks = epoch.GPSTime % (7 * 86400); - obs->C1 = epoch.sv[ii].CARange; - obs->P1 = epoch.sv[ii].P1Range; - obs->P2 = epoch.sv[ii].P2Range; - obs->L1 = epoch.sv[ii].L1Phase; - obs->L2 = epoch.sv[ii].L2Phase; - obs->SNR1 = int(epoch.sv[ii].L1Snr * 10); - obs->SNR2 = int(epoch.sv[ii].L2Snr * 10); + obs->SVPRN = _GPSTrans.DecObs.Obs[ii].sat_prn; + obs->GPSWeek = _GPSTrans.DecObs.Obs[ii].GPSTime / (7 * 86400); + obs->GPSWeeks = _GPSTrans.DecObs.Obs[ii].GPSTime % (7 * 86400); + obs->C1 = _GPSTrans.DecObs.Obs[ii].l1_pseudo_range; + obs->P1 = _GPSTrans.DecObs.Obs[ii].p1_pseudo_range; + obs->P2 = _GPSTrans.DecObs.Obs[ii].p2_pseudo_range; + obs->L1 = _GPSTrans.DecObs.Obs[ii].p1_phase; + obs->L2 = _GPSTrans.DecObs.Obs[ii].p2_phase; + obs->SNR1 = int(_GPSTrans.DecObs.Obs[ii].l1_sn * 10); + obs->SNR2 = int(_GPSTrans.DecObs.Obs[ii].l2_sn * 10); _obsList.push_back(obs); @@ -126,4 +100,4 @@ // Unprocessed bytes remain in buffer // ---------------------------------- - _buffer = _buffer.mid(numBytes); + _buffer = _buffer.mid(numbytes); } Index: /trunk/BNC/RTIGS/RTIGSDecoder.h =================================================================== --- /trunk/BNC/RTIGS/RTIGSDecoder.h (revision 304) +++ /trunk/BNC/RTIGS/RTIGSDecoder.h (revision 305) @@ -1,41 +1,19 @@ -// Part of BNC, a utility for retrieving decoding and -// converting GNSS data streams from NTRIP broadcasters, -// written by Leos Mervart. -// -// Copyright (C) 2006 -// German Federal Agency for Cartography and Geodesy (BKG) -// http://www.bkg.bund.de -// Czech Technical University Prague, Department of Advanced Geodesy -// http://www.fsv.cvut.cz -// -// Email: euref-ip@bkg.bund.de -// -// This program is free software; you can redistribute it and/or -// modify it under the terms of the GNU General Public License -// as published by the Free Software Foundation, version 2. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -#ifndef RTIGSDECODER_H -#define RTIGSDECODER_H +#ifndef RTIGS_H +#define RTIGS_H #include #include "../RTCM/GPSDecoder.h" +#include "cgps_transform.h" -class RTIGSDecoder : public GPSDecoder { +class rtigs : public GPSDecoder { public: - RTIGSDecoder(); - ~RTIGSDecoder(); + rtigs(); + ~rtigs(); void Decode(char* buffer = 0, int bufLen = 0); private: - QByteArray _buffer; + CGPS_Transform _GPSTrans; + QByteArray _buffer; } ; Index: /trunk/BNC/RTIGS/cgps_transform.cpp =================================================================== --- /trunk/BNC/RTIGS/cgps_transform.cpp (revision 305) +++ /trunk/BNC/RTIGS/cgps_transform.cpp (revision 305) @@ -0,0 +1,761 @@ +#include "cgps_transform.h" + +#define MAXSTREAM 10000 + +//////////////////////////////////////////////////////////////////////////// +void SwitchBytes( char *Start, int Size ) { + char Tmp; + char *End = Start + Size - 1; + for( Tmp = *Start; Start < End; Tmp = *Start ){ + *Start++ = *End; + *End-- = Tmp; + } +} + +#ifdef CGPS_TRANSFORM_MAIN +int main() { + + unsigned char data_stream[MAXSTREAM]; + unsigned short numbytes; + RTIGSS_T rtigs_sta; + RTIGSO_T rtigs_obs; + RTIGSM_T rtigs_met; + RTIGSE_T rtigs_eph; + short PRN; + short retval; + unsigned short statID; + unsigned short messType; + CGPS_Transform GPSTrans; + + memset(data_stream , 0, sizeof(data_stream)); + + // use something like recvfrom + FILE* inpFile = fopen("RTIGS.txt", "rb"); + + while (true) { + size_t nr = 0; + if (inpFile) { + nr = fread(data_stream, sizeof(unsigned char), MAXSTREAM, inpFile); + if (nr == 0) exit(0); + cout << "Number of bytes read: " << nr << endl; + } + else { + exit(1); + } + + // Find the beginning of the message + // --------------------------------- + size_t sz = sizeof(unsigned short); + bool found = false; + size_t ii; + for (ii = 0; ii < nr - sz; ii += sz) { + unsigned short xx; + memcpy( (void*) &xx, &data_stream[ii], sz); + SwitchBytes( (char*) &xx, sz); + if (xx == 200) { + found = true; + break; + } + } + if (! found) { + cout << "Message not found\n"; + exit(0); + } + else { + cout << "Message found at " << ii << endl; + } + + + messType = GPSTrans.GetRTIGSHdrRecType(&data_stream[ii]); + numbytes = GPSTrans.GetRTIGSHdrRecBytes(&data_stream[ii]); + statID = GPSTrans.GetRTIGSHdrStaID(&data_stream[ii]); + + cout << "messType " << messType << endl; + cout << "numbytes " << numbytes << endl; + cout << "statID " << statID << endl; + + switch (messType) { + case 100: + GPSTrans.Decode_RTIGS_Sta(&data_stream[ii], numbytes , rtigs_sta); + break; + case 200: + retval = GPSTrans.Decode_RTIGS_Obs(&data_stream[ii], numbytes , rtigs_obs); + if (retval >= 1) { + GPSTrans.print_CMEAS(); + } + break; + case 300: + retval = GPSTrans.Decode_RTIGS_Eph(&data_stream[ii], numbytes , rtigs_eph, PRN); + break; + case 400: + retval = GPSTrans.Decode_RTIGS_Met(&data_stream[ii], numbytes , &rtigs_met); + break; + } + } + + return 0; +} +#endif + +// Constructor +//////////////////////////////////////////////////////////////////////////// +CGPS_Transform::CGPS_Transform() { + + // Decoded Obs Array of 12 CMeas Observation Records + memset((void *)&DecObs, 0, sizeof(ARR_OBS_T )); + + // Keplarian Broadcast Eph + memset((void *)&TNAV_Eph,0, sizeof(ARR_TNAV_T )); + + NumObsRead = -1; + CAFlag = -1; + ASFlag = -1; + P2Flag = -1; + P1Flag = -1; + InitEndianFlag(); + + memset (PhaseArcStartTime, 0, sizeof(PhaseArcStartTime)); +} + +// Destructor +//////////////////////////////////////////////////////////////////////////// +CGPS_Transform::~CGPS_Transform() { +} + +// +//////////////////////////////////////////////////////////////////////////// +unsigned short CGPS_Transform::GetRTIGSHdrRecType(unsigned char *RTIGS_Str) +{ + unsigned short recordID; + memcpy ((void *)&recordID,RTIGS_Str, sizeof(recordID)); + if (f_IsLittleEndian) + { + SwitchBytes( (char *)&recordID, sizeof(recordID) ); + } + return recordID; +} + +// +//////////////////////////////////////////////////////////////////////////// +unsigned short CGPS_Transform::GetRTIGSHdrRecBytes(unsigned char *RTIGS_Str) +{ + unsigned short bytes; + memcpy ((void *)&bytes,&RTIGS_Str[8], sizeof(bytes)); + if (f_IsLittleEndian) + { + SwitchBytes( (char *)&bytes, sizeof(bytes) ); + } + return bytes; + +} + +// +//////////////////////////////////////////////////////////////////////////// +unsigned short CGPS_Transform::GetRTIGSHdrStaID(unsigned char *RTIGS_Str) +{ + unsigned short StaID = 0; + memcpy ((void *)&StaID, &RTIGS_Str[2], sizeof(StaID)); + if (f_IsLittleEndian) + { + SwitchBytes( (char *)&StaID, sizeof(StaID) ); + } + return StaID; +} + + +// +//////////////////////////////////////////////////////////////////////////// +void CGPS_Transform::InitEndianFlag() { + short one = 1; + char *cp = (char *)&one; + if (*cp== 0) { + f_IsLittleEndian = false; + } + else { + f_IsLittleEndian = true; + } +} + + +// +//////////////////////////////////////////////////////////////////////////// +unsigned long CGPS_Transform::JPL_xtractLongVal (unsigned startBitNbr, unsigned xtractNbrBits, const char *msg) +{ + unsigned long retValue=0, i=0; + + unsigned short posBit = xtractNbrBits - 1; + + for(i=0; i> numShift) & 0x0001) << posBit--); + + } + + return retValue; +} + +// +//////////////////////////////////////////////////////////////////////////// +inline void CGPS_Transform::SwitchIGS_Sta_HdrBytes( RTIGSS_T *StaHdr) +{ + SwitchBytes( (char *)&StaHdr->GPSTime, sizeof(unsigned long) ); + SwitchBytes( (char *)&StaHdr->num_bytes, sizeof(unsigned short) ); + SwitchBytes( (char *)&StaHdr->rec_id, sizeof(unsigned short) ); + SwitchBytes( (char *)&StaHdr->sta_id, sizeof(unsigned short) ); +} + +// +//////////////////////////////////////////////////////////////////////////// +inline void CGPS_Transform::SwitchIGS_Obs_HdrBytes( RTIGSO_T *ObsHdr) +{ + SwitchBytes( (char *)&ObsHdr->GPSTime, sizeof(unsigned long) ); + SwitchBytes( (char *)&ObsHdr->num_bytes, sizeof(unsigned short) ); + SwitchBytes( (char *)&ObsHdr->rec_id, sizeof(unsigned short) ); + SwitchBytes( (char *)&ObsHdr->sta_id, sizeof(unsigned short) ); +} + +// +//////////////////////////////////////////////////////////////////////////// +inline void CGPS_Transform::SwitchIGS_Eph_HdrBytes( RTIGSE_T *EphHdr) + +{ + SwitchBytes( (char *)&EphHdr->CollectedGPSTime, sizeof(unsigned long) ); + SwitchBytes( (char *)&EphHdr->num_bytes, sizeof(unsigned short) ); + SwitchBytes( (char *)&EphHdr->rec_id, sizeof(unsigned short) ); + SwitchBytes( (char *)&EphHdr->sta_id, sizeof(unsigned short) ); +} + +// +//////////////////////////////////////////////////////////////////////////// +inline short CGPS_Transform::SwitchIGS_Met_RecBytes( RTIGSM_T *MetHdr) +{ +short retval = 1; +short i, num_items; + num_items = (short)MetHdr->numobs; + SwitchBytes( (char *)&MetHdr->GPSTime, sizeof(unsigned long) ); + SwitchBytes( (char *)&MetHdr->num_bytes, sizeof(unsigned short) ); + SwitchBytes( (char *)&MetHdr->rec_id, sizeof(unsigned short) ); + SwitchBytes( (char *)&MetHdr->sta_id, sizeof(unsigned short) ); + + /*switch met data bytes*/ + for (i=0; i < num_items; i++) + { + if (&MetHdr->mets[i] != NULL) + { + SwitchBytes( (char *)&MetHdr->mets[i], sizeof(long) ); + } + else + { + retval = -1; + } + + } +return retval; +} +// +//////////////////////////////////////////////////////////////////////////// + +short CGPS_Transform::Save_TNAV_T_To_Container(TNAV_T *rtcurrent_eph, short &prn) +{ +short retval = 1;//, i; +long PRN; + + PRN = rtcurrent_eph->Satellite; + + if (f_IsLittleEndian) + { + SwitchBytes( (char *)&PRN, sizeof(PRN)); + } + + if ((PRN > 0) && (PRN <= 32)) + { + memcpy( (void *)&TNAV_Eph.Eph[(PRN-1)] ,rtcurrent_eph,sizeof(TNAV_T)); + prn = (short)PRN; + } + else + { + retval = -1; + } +return retval; +} + +// +//////////////////////////////////////////////////////////////////////////// +short CGPS_Transform::CA_Extract(char * CAStr, double &CA_Rng) +{ + + +unsigned long CARng2, CARng1; +short retval = 0; +double dtemp; + + + CGPS_Transform::CAFlag = JPL_xtractLongVal(0, 1, CAStr); + CGPS_Transform::ASFlag = JPL_xtractLongVal(1, 1, CAStr); + CGPS_Transform::P2Flag = JPL_xtractLongVal(2, 1, CAStr); + CGPS_Transform::P1Flag = JPL_xtractLongVal(3, 1, CAStr); + + if (CAFlag) + { + //Read most significant bits + CARng2 = JPL_xtractLongVal(4, 4, CAStr); + //Read an int's worth of data + CARng1 = JPL_xtractLongVal (8,32,CAStr); +// if (f_IsLittleEndian == false) +// { + //KML June 8/2004 + //Added this code to deal with Big Endian architectures +// SwitchBytes( (char *) &CARng2, sizeof(CARng2) ); +// SwitchBytes( (char *) &CARng1, sizeof(CARng1) ); +// } + + dtemp = 0.0; + dtemp = CARng2; + + CA_Rng = dtemp*pow ((double)2,32); + CA_Rng += CARng1; + + CA_Rng /= 1000; //CA in metres + } + else + { + retval = -1; + } +return retval; +} + +// +//////////////////////////////////////////////////////////////////////////// +short CGPS_Transform::P1_P2_Block_Extract(char * P1P2Str, double CA, double &Rng , double &Phase, double &RngF2Delta,short decode_F1orF2Flag ) +{ +short retval =0; +short PhaseOverFlowFlag; +long SignFlag,temp; + +double RngDelta, PhaseDelta; + + if (decode_F1orF2Flag == 1) + { + PhaseOverFlowFlag = CGPS_Transform::P1Flag; + } + else if (decode_F1orF2Flag == 2) + { + PhaseOverFlowFlag = CGPS_Transform::P2Flag; + } + //***************************** + // Decode Pseudo Range + //***************************** + SignFlag = JPL_xtractLongVal (0,1,P1P2Str); + temp = JPL_xtractLongVal (1,17,P1P2Str); + +//KML June 8/2004 +// if (f_IsLittleEndian == false) +// { + //Added this code to deal with Big Endian architectures +// SwitchBytes( (char *) &temp, sizeof(temp) ); +// } + + + RngDelta = temp; + RngDelta /= 1000.0; + + + if (SignFlag) + { + RngDelta *= -1; + } + + + if (decode_F1orF2Flag == 2) + { + RngF2Delta = RngDelta; + } + + Rng = CA + RngDelta; + + //*************************** + // Decode Phase + //*************************** + + SignFlag = JPL_xtractLongVal (18,1, P1P2Str); + temp = JPL_xtractLongVal (19,21, P1P2Str); +// if (f_IsLittleEndian == false) +// { + + //KML June 8th 2004 + //Added this code to deal with Big Endian architectures +// SwitchBytes( (char *) &temp, sizeof(temp) ); +// } + + PhaseDelta = temp; + + PhaseDelta = PhaseDelta * 2 / 100000; + + + + + //Phase overflow add to phase + if(PhaseOverFlowFlag) + { + PhaseDelta += MAXL1L2; + } + + if (SignFlag) + { + PhaseDelta *= -1; + } + + if (decode_F1orF2Flag == 1) + { + // frequency 1 + Phase = (CA - (ScaleFactor2*RngF2Delta)+ PhaseDelta) / L1; + } + else if (decode_F1orF2Flag == 2) + { + // frequency 2 + Phase = (CA - (ScaleFactor1*RngF2Delta)+ PhaseDelta) / L2; + } + else + { + retval =-1; + } +return retval; +} + +// +//////////////////////////////////////////////////////////////////////////// +short CGPS_Transform::Decode_RTIGS_Sta(unsigned char *RTIGS_Str, unsigned short RTIGS_Bytes, RTIGSS_T &rtigs_sta) +{ +short retval = 1; + memcpy ((void *)&rtigs_sta.rec_id, &RTIGS_Str[0], (sizeof(RTIGSS_T) - sizeof(rtigs_sta.data))); + if (f_IsLittleEndian) + { + SwitchIGS_Sta_HdrBytes( &rtigs_sta); + } + if (rtigs_sta.rec_id == 100) + { + if (rtigs_sta.sta_rec_type ==0 ) + { + rtigs_sta.data = NULL; + } + else + { + retval = -2; //no other type supported at this time + } + } + + + else + { + + + retval = -1; + + } + +return retval ; +} + +// +//////////////////////////////////////////////////////////////////////////// +short CGPS_Transform::Decode_RTIGS_Soc_Obs(unsigned char *SocStr, short &StrPos, short CMeasIndex, short SocBytes, unsigned long GPSTime) +{ +short retval =1; +double CA, RngF2Delta, PhaseL1,PhaseL2, P1, P2; +//static unsigned short PhaseArcStartTime[MAXSV]; moved to class header +JPL_COMP_OBS_T GPSObs; +//printf("String pos %hd Total Bytes %hd\n", StrPos,SocBytes); + + if ((StrPos <= SocBytes) && ((CMeasIndex >= 0 ) && (CMeasIndex < MAXSV ))) + { + + memcpy((void *)&GPSObs.prn, (void *)&SocStr[StrPos], 1); + + if ((GPSObs.prn > 0 ) && (GPSObs.prn <= 32)) + { + StrPos+=1; + + memcpy((void *)&GPSObs.epoch_sequence, (void *)&SocStr[StrPos],2); + + if (f_IsLittleEndian == false) + { + //KML June 8/2003 + //Added this code to deal with Big Endian architectures + SwitchBytes( (char *) &GPSObs.epoch_sequence, sizeof(GPSObs.epoch_sequence) ); + } + + //****************************** + // Read and decode CA + //****************************** + StrPos+=2; + memcpy((void *)&GPSObs.ca_range, (void *)&SocStr[StrPos],5); + CA_Extract(GPSObs.ca_range, CA); + + if (CGPS_Transform::CAFlag) //Defined in the Class by CA_Extract + { + //************************************ + // Read CA SNR + //************************************ + StrPos+=5; + memcpy((void *)&GPSObs.CA_snr, (void *)&SocStr[StrPos],1); + //************************************ + // Read and decode P2 L2 + //************************************ + StrPos+=1; + memcpy((void *)&GPSObs.L2_range_phase, (void *)&SocStr[StrPos],5); + + P1_P2_Block_Extract(GPSObs.L2_range_phase, CA, P2 , PhaseL2, RngF2Delta, 2 ); + + + StrPos+=5; + memcpy((void *)&GPSObs.L2_snr, (void *)&SocStr[StrPos],1); + //************************************ + // Read and decode P1 L1 + //************************************ + StrPos+=1; + + + memcpy((void *)&GPSObs.L1_range_phase, (void *)&SocStr[StrPos],5); + + P1_P2_Block_Extract(GPSObs.L1_range_phase, CA, P1, PhaseL1, RngF2Delta, 1); + + StrPos+=5; + memcpy((void *)&GPSObs.L1_snr, (void *)&SocStr[StrPos],1); + StrPos+=1; + + DecObs.Obs[CMeasIndex].GPSTime = GPSTime; /* broadcast time sec.*/ + DecObs.Obs[CMeasIndex].chn = CMeasIndex + 1; /* Channel not real*/ + DecObs.Obs[CMeasIndex].sat_prn = GPSObs.prn; /* satellite ID*/ + DecObs.Obs[CMeasIndex].ntrvl = 1; /* number of seconds Changed from 0 to 1 Nov. 25/2003*/ + DecObs.Obs[CMeasIndex].flag[0] = 4; /*observation quality flags*/ //KML Changed Nov. 25/2000 to 4 to indicate Benchmark + + if (PhaseArcStartTime[(short)(GPSObs.prn-1)] != GPSObs.epoch_sequence) + { + PhaseArcStartTime[(short)(GPSObs.prn-1)] = GPSObs.epoch_sequence; + DecObs.Obs[CMeasIndex].flag[0] |= 0x20; + } + + DecObs.Obs[CMeasIndex].l1_pseudo_range = CA; /* frequency-1 CA pseudorange */ + DecObs.Obs[CMeasIndex].l1_phase = PhaseL1; /* frequency-1 CA carrier phase */ + //**************************************************** + // Changed SNR Ashtech to DBHz Nov 15/2002 + //**************************************************** + DecObs.Obs[CMeasIndex].l1_sn = GPSObs.CA_snr; + + DecObs.Obs[CMeasIndex].p1_pseudo_range = P1; /* frequency-1 P1 carrier phase */ + DecObs.Obs[CMeasIndex].p1_phase = PhaseL1; /* frequency-1 P1 pseudorange */ + + DecObs.Obs[CMeasIndex].p1_sn = GPSObs.L1_snr; + + DecObs.Obs[CMeasIndex].l2_pseudo_range = P2; /* frequency-2 pseudorange (XCorr) */ + DecObs.Obs[CMeasIndex].l2_phase = PhaseL2; /* frequency-2 carrier phase (XCorr) */ + + DecObs.Obs[CMeasIndex].l2_sn = GPSObs.L2_snr; + DecObs.Obs[CMeasIndex].p2_pseudo_range = P2; /* frequency-2 pseudorange */ + DecObs.Obs[CMeasIndex].p2_phase = PhaseL2; /* frequency-2 carrier phase */ + } + else + { + //skip this obs + DecObs.Obs[CMeasIndex].sat_prn = 0; + } + } + else + { + retval = -2; + + } + } + else + { + retval = -1; + } +return retval; +} + +// +//////////////////////////////////////////////////////////////////////////// +short CGPS_Transform::RTIGSO_Str_To_CMEAS(unsigned char *RTIGSO_Str, short RTIGS_Bytes, RTIGSO_T &rtigs_obs) +{ +short retval =1,i, StrPos;//, HdrRetval; +//short NumObs= 0; +short decoded_cnt = 0; +short IGSObsMinusPtr; + + + //************************************ + // Zero out CMEAS_T container + //************************************ +memset((void *)&DecObs.Obs[0], 0 , sizeof(ARR_OBS_T) ); + + //*********************************************** + // Decode Header store in class container + //*********************************************** + + + StrPos = IGSObsMinusPtr = sizeof(RTIGSO_T) - sizeof (rtigs_obs.data); + + //// cout << "StrPos " << StrPos << endl; + + memcpy ((void *)&rtigs_obs.rec_id, RTIGSO_Str, IGSObsMinusPtr); + + if (f_IsLittleEndian) + { + SwitchIGS_Obs_HdrBytes( &rtigs_obs); + } + + + // 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); + + if((rtigs_obs.rec_id == 200) && (rtigs_obs.num_obs <= MAXCHANNELS_FOR_SOCKETS_TYPE1)) + { + for (i = 0 ; i < rtigs_obs.num_obs;i++) + { + //********************************************* + // the following function decodes the soc + // structure and writes the obs to the + // class's CMEAS container + //********************************************* + + if (Decode_RTIGS_Soc_Obs( RTIGSO_Str, StrPos, decoded_cnt, RTIGS_Bytes, rtigs_obs.GPSTime) < 0) + { + retval = -2; + } + else + { + decoded_cnt ++; + } + }//end of for + retval = NumObsRead = decoded_cnt; //NumObsRead class member + } + else + { + retval = -1; + } +//ObsSeqNum++; +return retval; +} + + +// +//////////////////////////////////////////////////////////////////////////// +short CGPS_Transform::Decode_RTIGS_Obs(unsigned char *RTIGSO_Str, unsigned short RTIGS_Bytes,RTIGSO_T &rtigs_obs) +{ + short retval = 1;//, i; + + + if ((retval = RTIGSO_Str_To_CMEAS(RTIGSO_Str, RTIGS_Bytes, rtigs_obs)) < 0) + { + retval = -1; + } + +return retval; +} + +// +//////////////////////////////////////////////////////////////////////////// +short CGPS_Transform::Decode_RTIGS_Met(unsigned char *RTIGS_Str, unsigned short RTIGS_Bytes, RTIGSM_T *rtigs_met) +{ +short retval = 1; +short numbytes = 0; +numbytes = sizeof(RTIGSM_T) - sizeof(rtigs_met->mets); +memcpy ((void *)rtigs_met, RTIGS_Str, numbytes); + + if ((short)rtigs_met->numobs <= 3) + { + if (rtigs_met->mets != NULL) + { + memcpy ((void *)&rtigs_met->mets[0], &RTIGS_Str[numbytes], ((short)rtigs_met->numobs * sizeof(long)) ); + if (f_IsLittleEndian) + { + SwitchIGS_Met_RecBytes( rtigs_met); + } + if (rtigs_met->rec_id != 400) + { + retval = -1; + } + } + else + { + retval = -2; + delete [] rtigs_met->mets; + } + } + else + { + printf("failed number of Obs\n"); + } + +return retval; +} + +// +//////////////////////////////////////////////////////////////////////////// +short CGPS_Transform::Decode_RTIGS_Eph(unsigned char *RTIGS_Str, unsigned short RTIGS_Bytes, RTIGSE_T &rtigs_eph, short &PRN) +{ + short retval = 1;//, i; + short index = 0; + short prn; + const short SubFrameSize = 24; + TNAV_T trans_eph; + index = sizeof(RTIGSE_T ) - sizeof (rtigs_eph.data); + + memcpy ((void *)&rtigs_eph.rec_id, &RTIGS_Str[0], index); //copy header into struct from string + if (f_IsLittleEndian) + { + SwitchIGS_Eph_HdrBytes( &rtigs_eph); + } + + if (rtigs_eph.rec_id == 300) + { + //********************************************* + // the following method saves the eph + // in the class's TNAV_T container + //********************************************* + trans_eph.GPSCollectedTime = rtigs_eph.CollectedGPSTime; + trans_eph. Satellite = (long)rtigs_eph.prn; + //******************************************** + // Container class is in network byte order + //******************************************** + if (f_IsLittleEndian) + { + SwitchBytes( (char *)&trans_eph.GPSCollectedTime, sizeof(trans_eph.GPSCollectedTime) ); + SwitchBytes( (char *)&trans_eph. Satellite, sizeof(trans_eph. Satellite) ); + } + + memcpy((void *)&trans_eph.SubFrame1, (const void *)&RTIGS_Str[index], SubFrameSize); + memcpy((void *)&trans_eph.SubFrame2, (const void *)&RTIGS_Str[(index + SubFrameSize)], SubFrameSize); + memcpy((void *)&trans_eph.SubFrame3, (const void *)&RTIGS_Str[(index + (SubFrameSize * 2)) ], SubFrameSize); + if (Save_TNAV_T_To_Container(&trans_eph, prn) >= 1) //function saves eph in container and returns prn + { + PRN = prn; + } + else + { + retval = -1; + } + } + else + { + retval = -1; + } + +return retval; +} + +void CGPS_Transform::print_CMEAS() +{ +short i; + printf("\nGPSTime SV CA SNR P1 SNR P2 SNR\n"); + printf("Seconds (m) DBHz (m) DBHz (m) DBHz\n"); + for (i=0; i < NumObsRead ; i++) + { + 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, + DecObs.Obs[i].l1_pseudo_range,DecObs.Obs[i].l1_sn, + DecObs.Obs[i].p1_pseudo_range, DecObs.Obs[i].p1_sn, + DecObs.Obs[i].l2_pseudo_range,DecObs.Obs[i].l2_sn); + } +} + Index: /trunk/BNC/RTIGS/cgps_transform.h =================================================================== --- /trunk/BNC/RTIGS/cgps_transform.h (revision 305) +++ /trunk/BNC/RTIGS/cgps_transform.h (revision 305) @@ -0,0 +1,127 @@ + +#ifndef CGPS_TRANSFORM_H +#define CGPS_TRANSFORM_H + +#include +#include +#include +#include +#include + +using namespace std; + +#include "rtacp.h" +#include "rtstruct.h" +#include "rtigs_records.h" + +#define MAXCHANNELS_FOR_SOCKETS_TYPE1 12 +#define MAXSV 32 +#define ScaleFactor1 4.0914555603263203 //(f1ion + f2ion) +#define ScaleFactor2 2 * F1ION +#define MAXL1L2 41.94302 + +void SwitchBytes( char *Start, int Size ); + +typedef struct +{ + unsigned char prn; // satellite ID + unsigned short epoch_sequence; // like Ashtech seq number of phase epochs + // was like this, now modulo 10 hours, + // each digit is now 1 sec, not .05 secs like before + + char ca_range[5]; // ca range in millimeters + // first 4 bits are status bits, as follows + // if bit 7 on, sucessful packing of ca_range + // if bit 6 on, Z track mode or AS is on + // if bit 5 on, overflow of L2_block phase + // if bit 4 on, overflow of L1_block phase + // next 36 bits are the observable + // 68719.476735 is the max allowable obsev. + // if not packed, L2_block and L1_block is + // just then packed with 0s + + unsigned char CA_snr; // receiver snr for ca in dbHz KML the SNR is (DBHz * 4.25) rounded to an int (max is 60.0) + + char L2_range_phase[5]; + // first 2 bytes and 2 bits is for the range, next 6 bits and 2 bytes are for phase. + // + // range units are in millimeters, from -131071 to 131071 (2^17 - 1) + // 0000 0000 0000 0000 01 would be +1 mm + // 1000 0000 0000 0000 01 would be -1 mm + // 0100 0000 0000 0000 00 would be 65536 mm + // 1100 0000 0000 0000 00 would be -65536 mm + // 0111 1111 1111 1111 11 would be 131071 mm + // 1111 1111 1111 1111 11 woule be -131071 mm + // dynamic range must be <= 131.071 meters + // + // phase units are in 2/100 millimeters from -4194304 to 4194304 + // 00 0000 0000 0000 0000 0001 would be +.02 mm + // 10 0000 0000 0000 0000 0001 would be -.02 mm + // 01 1111 1111 1111 1111 1111 ( 2097151) would be 41943.02 mm + // 11 1111 1111 1111 1111 1111 (-2097151) would be -41943.02 mm + // (2^21 - 1)*2 mm + // dynamic range must be <= 41.94302 meters + // + // note if the limits are exceded, a -0 (minus zero) is returned + // indicating not a number + // + // Note however, we extended this dynamic range to 83.88606 meters as + // below with the spare bits in the ca_range field. If this limit + // is exceeded we return a -0 ( minus zero ) + unsigned char L2_snr; // snr for this data type in dbHz KML the SNR is (DBHz * 4.25) rounded to an int (max is 60.0 ) + + char L1_range_phase[5]; // same as format for L2_range_phase + + unsigned char L1_snr; // snr for this data type in dbHz KML the SNR is (DBHz * 4.25) rounded to an int (max is 60.0 ) + +} JPL_COMP_OBS_T; + +typedef struct +{ + TNAV_T Eph[MAXSV]; //32 prns +} ARR_TNAV_T; + +typedef struct { + CMEAS_T Obs[MAXSV]; //32 obs +} ARR_OBS_T ; + +class CGPS_Transform { +friend class rtigs; +private: + ARR_OBS_T DecObs; + ARR_TNAV_T TNAV_Eph; + short NumObsRead; + short CAFlag; + short ASFlag; + short P2Flag; + short P1Flag; + bool f_IsLittleEndian; + unsigned short PhaseArcStartTime[MAXSV]; +public: + CGPS_Transform(); + ~CGPS_Transform(); + void InitEndianFlag(); + short Decode_Soc_Obs(unsigned char *SocStr, short &StrIndex, short index, short SocBytes); + short Decode_RTIGS_Soc_Obs(unsigned char *SocStr, short &StrPos, short CMeasIndex, short SocBytes, unsigned long GPSTime); + short RTIGSO_Str_To_CMEAS(unsigned char *RTIGSO_Str, short RTIGS_Bytes, RTIGSO_T &rtigs_obs); //done needs testing KML + void print_CMEAS(); + short Save_TNAV_T_To_Container(TNAV_T *rtcurrent_eph, short &prn); + short CA_Extract(char * CAStr, double &CA_Rng); //done + short P1_P2_Block_Extract(char * P1P2Str, double CA, double &Rng , double &Phase, double &RngF2Delta,short decode_F1orF2Flag );//done + unsigned long JPL_xtractLongVal (unsigned startBitNbr, unsigned xtractNbrBits, const char *msg); //done + inline void SwitchIGS_Sta_HdrBytes( RTIGSS_T *StaHdr); + inline void SwitchIGS_Obs_HdrBytes( RTIGSO_T *ObsHdr); + inline void SwitchIGS_Eph_HdrBytes( RTIGSE_T *EphHdr); + inline short SwitchIGS_Met_RecBytes( RTIGSM_T *MetHdr); + unsigned short GetRTIGSHdrRecType(unsigned char *RTIGS_Str); + unsigned short GetRTIGSHdrStaID(unsigned char *RTIGS_Str); + unsigned short GetRTIGSHdrRecBytes(unsigned char *RTIGS_Str); + unsigned long GetRTIGSHdrGPSSeconds(unsigned char *RTIGS_Str); + short Decode_RTIGS_Sta(unsigned char *RTIGS_Str, unsigned short RTIGS_Bytes, RTIGSS_T &rtigs_sta_dec); // contents of record contain all info + short Decode_RTIGS_Obs(unsigned char *RTIGS_Str, unsigned short RTIGS_Bytes, RTIGSO_T &rtigs_obs); // stores obs in class container + short Decode_RTIGS_Eph(unsigned char *RTIGS_Str, unsigned short RTIGS_Bytes, RTIGSE_T &rtigs_eph, short arrPRN[]); // stores eph in class container + short Decode_RTIGS_Eph(unsigned char *RTIGS_Str, unsigned short RTIGS_Bytes, RTIGSE_T &rtigs_eph, short &PRN); //stors in class and returns prn + short Decode_RTIGS_Met(unsigned char *RTIGS_Str, unsigned short RTIGS_Bytes, RTIGSM_T *rtigs_met); // contents of record contain all info. +}; + +#endif Index: /trunk/BNC/RTIGS/rtacp.h =================================================================== --- /trunk/BNC/RTIGS/rtacp.h (revision 305) +++ /trunk/BNC/RTIGS/rtacp.h (revision 305) @@ -0,0 +1,65 @@ +/*************************************************************************** + rtacp.h - description + ------------------- + begin : Mon Mar 27 2000 + copyright : (C) 2000 by Ken MacLeod + email : macleod@geod.nrcan.gc.ca + ***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ +/* $Header: /usr/local/cvsroot/BNC/RTIGS/rtacp.h,v 1.1 2006/08/20 13:36:49 mervart Exp $ */ +#ifndef _RTACP +#define _RTACP + +#include +#include +#include +#include +#include +#include "rtstruct.h" +#ifndef _RTAP +//#include "GTT.h" +#endif + +#define gps_start_second 0 +#define gps_end_second 1572480000 + +#define DATA_RATE 1 /* data rate used in decimate */ +#define NUM_PTS 14 /* number of code points used in on either side */ +#define L_NUM_PTS 4 /* maximum number of phase points on either side for polynomial fit */ +#define L_ORDER 3 /* order of polynomial fit to phase */ +#define L2_L1_ORDER 3 /* order of polynomial fit to L2-L1 series */ +#define NSEC 30 /* decimation epoch */ +#define MIN_ELEV 10.0 +#define MAXGAP 600 /* gap in stats_l2_l1 function for reinitialization */ + /* A B and C precise model values */ + +#define PM_A ( (154.0*154.0) + (120.0*120.0) ) / ( (154.0*154.0) - (120.0*120.0) ) +#define PM_B ( 2.0 * (120.0*120.0) ) / ( (154.0*154.0) - (120.0*120.0) ) +#define PM_C ( 2.0 * (154.0*154.0) ) / ( (154.0*154.0) - (120.0*120.0) ) + + +#define L1F (154.0 * 10.23e6) /* L1 frequency */ +#define L2F (120.0 * 10.23e6) /* L2 frequency */ +#define PCR (10.23e6) /* P chipping rate */ +#define CACR (1.023e6) /* CA chipping rate */ + +#define DEBUG 1 + +#define SYS_GPS_OFFSET 315964800 /* used for METS */ + +#define CORH_MAX_TIME_DIFF 30 /* max time diff in seconds between local corrections */ +#define CORH_NUM 10 /* number of previous values used to compute RRC */ +#define RRC_ORDER 3 + + + + +#endif Index: unk/BNC/RTIGS/rtigs.cpp =================================================================== --- /trunk/BNC/RTIGS/rtigs.cpp (revision 304) +++ (revision ) @@ -1,187 +1,0 @@ -/* rtigs.cpp - * - Source functions - * - * Copyright (c) 2006 - * Geoscience Australia - * - * Written by James Stewart - * E-mail: James.Stewart@ga.gov.au - * - * Enquiries contact - * Michael Moore - * E-mail: Michael.Moore@ga.gov.au - * - * Based on the GNU General Public License published Icecast 1.3.12 - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -#include -#include "rtigs.h" - -void bytes_to_rtigsh(RTIGSH *rtigsh, unsigned char *packet) { - memcpy(rtigsh, packet, sizeof(RTIGSH)); - revbytes((unsigned char *)&(rtigsh->rec_id), 2); - revbytes((unsigned char *)&(rtigsh->sta_id), 2); - revbytes((unsigned char *)&(rtigsh->GPSTime), 4); - revbytes((unsigned char *)&(rtigsh->num_bytes), 2); -} - -int rtigso_to_raw(RTIGSO *rtigso, GPSEpoch *gpse) { - struct JPL_COMP_OBS_T soc; - int ptr = 0; - unsigned char * p1; - unsigned char * p2; - - double CA_Range = 0.00; - double P1_Range, P2_Range, L1_Cycles, L2_Cycles; - double L1_Diff = 0.00; - double L2_Diff = 0.00; - - long long ABS_CA_Range = 0; - - double L1_Phase = 0.00; - double L2_Phase = 0.00; - - int ABS_L1_Diff = 0; - int ABS_L2_Diff = 0; - int ABS_L1_Phase = 0; - int ABS_L2_Phase = 0; - - gpse->num_sv = rtigso->num_obs; - gpse->GPSTime = rtigso->GPSTime; - gpse->sta_id = rtigso->sta_id; - - for(ptr = 0; ptr < rtigso->num_obs; ptr++) { - memset(&soc, 0, sizeof(struct JPL_COMP_OBS_T)); - memcpy(&(soc.prn), &(rtigso->data[ptr][0]), 1); - memcpy(&(soc.epoch_sequence), &(rtigso->data[ptr][1]), 2); - memcpy(&(soc.ca_range[0]), &(rtigso->data[ptr][3]), 18); - - p1 = ((unsigned char *)&ABS_CA_Range); - p2 = &(soc.ca_range[0]); - - p1[4] = (p2[0] & 0xF); - p1[3] = p2[1]; - p1[2] = p2[2]; - p1[1] = p2[3]; - p1[0] = p2[4]; - - p1 = (unsigned char *)&ABS_L1_Diff; - p2 = (unsigned char *)&(soc.L1_range_phase[0]); - - if(p2[0] & 0x80) - L1_Diff = -1.000; - else - L1_Diff = 1.000; - - p1[2] = (p2[0] & 0x40) >> 6; - p1[1] = ((p2[0] & 0x3F) << 2) + ((p2[1] & 0xC0) >> 6); - p1[0] = ((p2[1] & 0x3F) << 2) + ((p2[2] & 0xC0) >> 6); - - if(p2[2] & 0x20) - L1_Phase = -1.000; - else - L1_Phase = 1.000; - - p1 = (unsigned char *)&ABS_L1_Phase; - p1[2] = (p2[2] & 0x1F); - p1[1] = p2[3]; - p1[0] = p2[4]; - - - - p1 = (unsigned char *)&ABS_L2_Diff; - p2 = (unsigned char *)&(soc.L2_range_phase[0]); - - if(p2[0] & 0x80) - L2_Diff = -1.000; - else - L2_Diff = 1.000; - - p1[2] = (p2[0] & 0x40) >> 6; - p1[1] = ((p2[0] & 0x3F) << 2) + ((p2[1] & 0xC0) >> 6); - p1[0] = ((p2[1] & 0x3F) << 2) + ((p2[2] & 0xC0) >> 6); - - if(p2[2] & 0x20) - L2_Phase = -1.000; - else - L2_Phase = 1.000; - - p1 = (unsigned char *)&ABS_L2_Phase; - p1[2] = (p2[2] & 0x1F); - p1[1] = p2[3]; - p1[0] = p2[4]; - - p2 = &(soc.ca_range[0]); - if(p2[0] & 0x20) - ABS_L2_Phase += (1 << 22); - if(p2[0] & 0x10) - ABS_L1_Phase += (1 << 22); - - L1_Phase = L1_Phase * (((double)ABS_L1_Phase) / 50000.00); - L2_Phase = L2_Phase * (((double)ABS_L2_Phase) / 50000.00); - - L1_Diff = L1_Diff * (((double)ABS_L1_Diff) / 1000.00); - L2_Diff = L2_Diff * (((double)ABS_L2_Diff) / 1000.00); - - CA_Range = (double)ABS_CA_Range / 1000; - P1_Range = CA_Range + L1_Diff; - P2_Range = CA_Range + L2_Diff; - - L1_Cycles = ((CA_Range + L1_Phase) - (SF2 * L2_Diff)) / W1; - L2_Cycles = ((CA_Range + L2_Phase) - (SF1 * L2_Diff)) / W2; - - gpse->sv[ptr].prn = soc.prn; - gpse->sv[ptr].locktime = soc.epoch_sequence; - gpse->sv[ptr].CARange = CA_Range; - gpse->sv[ptr].CASnr = soc.CA_snr; - - gpse->sv[ptr].P1Range = P1_Range; - gpse->sv[ptr].L1Phase = L1_Cycles; - gpse->sv[ptr].L1Snr = soc.L1_snr; - - gpse->sv[ptr].P2Range = P2_Range; - gpse->sv[ptr].L2Phase = L2_Cycles; - gpse->sv[ptr].L2Snr = soc.L2_snr; - } - return 0; -} - -int rtigsm_to_raw(RTIGSM *rtigsm, GPSMet *met) { - met->GPSTime = rtigsm->GPSTime; - met->sta_id = rtigsm->sta_id; - met->temperature = rtigsm->temp; - met->pressure = rtigsm->press; - met->humidity = rtigsm->humid; - revbytes((unsigned char *)&met->temperature, 4); - revbytes((unsigned char *)&met->pressure, 4); - revbytes((unsigned char *)&met->humidity, 4); - return 0; -} - -void revbytes(unsigned char *buf, unsigned char size) { - unsigned char tmp; - unsigned char *ptr1 = buf; - unsigned char *ptr2 = buf + (size - 1); - - while(ptr1 < ptr2) { - tmp = *ptr1; - *ptr1 = *ptr2; - *ptr2 = tmp; - ptr1++; - ptr2--; - } -} Index: unk/BNC/RTIGS/rtigs.h =================================================================== --- /trunk/BNC/RTIGS/rtigs.h (revision 304) +++ (revision ) @@ -1,221 +1,0 @@ -/* Defines for the RTIGS <--> Raw Converter - * - Source functions - * - * Copyright (c) 2006 - * Geoscience Australia - * - * Written by James Stewart - * E-mail: James.Stewart@ga.gov.au - * - * Enquiries contact - * Michael Moore - * E-mail: Michael.Moore@ga.gov.au - * - * Based on the GNU General Public License published Icecast 1.3.12 - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ -#ifndef __RTIGS_H_INCLUDED__ -#define __RTIGS_H_INCLUDED__ 1 - -typedef unsigned int u_int32_t; -typedef unsigned short u_int16_t; -typedef unsigned char u_int8_t; -typedef unsigned char u_char; - -#define C ((double)299792458.00) /* speed of light in vaccuum */ -#define F1 ((double)1575.42E+06) /* GPS L1 frequency */ -#define F2 ((double)1227.60E+06) /* GPS L2 frequency */ -#define F1_SQUARE (F1 * F1) /* GPS L1 frequency squared */ -#define F2_SQUARE (F2 * F2) /* GPS L2 frequency squared */ -#define W1 ((double)(C / F1)) /* GPS L1 wavelength */ -#define W2 ((double)(C / F2)) /* GPS L2 wavelength */ -#define F1ION (F2_SQUARE / (F1_SQUARE - F2_SQUARE)) /* L1 iono scale factor */ -#define F2ION (F1_SQUARE / (F1_SQUARE - F2_SQUARE)) /* L2 iono scale factor */ -#define SF1 (F1ION + F2ION) -#define SF2 (F1ION * 2) -#define SF3 (F2ION * 2) -#define MAXCYCLEOSL1 374 // changed to fit 83.88 metres 441 Feb. 24/2004 ~100m in cycles was 526 -#define MAXCYCLEOSL2 291 // changed to fit 83.88 metres 343 Feb. 24/2004 was ~100m in cycles 410 - -/* RTIGSH_T Structure -> RTIGS Header structure, Used For Working Out What Sort Of Packet We Got */ -struct RTIGSH_T - { - u_int16_t rec_id; - u_int16_t sta_id; - u_int32_t GPSTime; - u_int16_t num_bytes; - u_int8_t IODS; - u_int8_t misc; - }; - - -/* RTIGSS_T Structure -> RTIGS Station structure, normally rec_id = 100 */ -struct RTIGSS_T - { - u_int16_t rec_id; - u_int16_t sta_id; - u_int32_t GPSTime; - u_int16_t num_bytes; - u_int8_t IODS; - u_int8_t sta_rec_type; - u_char IGS_UniqueID[8]; - }; - - -/* RTIGSO_T Structure -> RTIGS Observation structure, normally rec_id = 200 */ -struct RTIGSO_T - { - u_int16_t rec_id; - u_int16_t sta_id; - u_int32_t GPSTime; - u_int16_t num_bytes; - u_int8_t IODS; - u_int8_t num_obs; - u_char data[12][21]; - }; - -/* RTIGSE_T Structure -> RTIGS Ephemeris structure, normally rec_id = 300 */ -struct RTIGSE_T - { - u_int16_t rec_id; - u_int16_t sta_id; - u_int32_t GPSTime; - u_int16_t num_bytes; - u_int8_t IODS; - u_int8_t prn; - u_char data[72]; - }; - - -/* RTIGSM_T Structure -> RTIGS Met structure, normally rec_id = 400 */ -struct RTIGSM_T - { - u_int16_t rec_id; - u_int16_t sta_id; - u_int32_t GPSTime; - u_int16_t num_bytes; - u_int8_t IODS; - u_int8_t num_obs; - long temp; - long press; - long humid; - }; - -/* The 21 Byte SOC Compressed Observation Structure per SV */ -struct JPL_COMP_OBS_T - { - unsigned char prn; // satellite ID - unsigned short epoch_sequence; // like Ashtech seq number of phase epochs - // was like this, now modulo 10 hours, - // each digit is now 1 sec, not .05 secs like before - unsigned char ca_range[5]; // ca range in millimeters - // first 4 bits are status bits, as follows - // if bit 7 on, sucessful packing of ca_range - // if bit 6 on, Z track mode or AS is on - // if bit 5 on, overflow of L2_block phase - // if bit 4 on, overflow of L1_block phase - // next 36 bits are the observable - // 68719.476735 is the max allowable obsev. - // if not packed, L2_block and L1_block is - // just then packed with 0s - - unsigned char CA_snr; // receiver snr for ca in dbHz KML the SNR is (DBHz * 4.25) rounded to an int (max is 60.0) - unsigned char L2_range_phase[5]; - // first 2 bytes and 2 bits is for the range, next 6 bits and 2 bytes are for phase. - // - // range units are in millimeters, from -131071 to 131071 (2^17 - 1) - // 0000 0000 0000 0000 01 would be +1 mm - // 100000000000000001 would be -1 mm - // 0100 0000 0000 0000 00 would be 65536 mm - // 1100 0000 0000 0000 00 would be -65536 mm - // 0111 1111 1111 1111 11 would be 131071 mm - // 111111111111111111 woule be -131071 mm - // dynamic range must be <= 131.071 meters - // - // phase units are in 2/100 millimeters from -4194304 to 4194304 - // 00 0000 0000 0000 0000 0001 would be +.02 mm - // 10 0000 0000 0000 0000 0001 would be -.02 mm - // 01 1111 1111 1111 1111 1111 ( 2097151) would be 41943.02 mm - // 11 1111 1111 1111 1111 1111 (-2097151) would be -41943.02 mm - // (2^21 - 1)*2 mm - // dynamic range must be <= 41.94302 meters - // - // note if the limits are exceded, a -0 (minus zero) is returned - // indicating not a number - // - // Note however, we extended this dynamic range to 83.88606 meters as - // below with the spare bits in the ca_range field. If this limit - // is exceeded we return a -0 ( minus zero ) - unsigned char L2_snr; // snr for this data type in dbHz, the SNR is (DBHz * 4.25) rounded to an int (max is 60.0 ) - unsigned char L1_range_phase[5]; // same as format for L2_range_phase - unsigned char L1_snr; // snr for this data type in dbHz, the SNR is (DBHz * 4.25) rounded to an int (max is 60.0 ) - }; - - -/* GPSSatellite Structure -> 44 Byte raw SV Structure */ -struct GPSSatellite - { - unsigned char prn; - unsigned char CASnr; - unsigned char L1Snr; - unsigned char L2Snr; - double CARange; - double P1Range; - double L1Phase; - double P2Range; - double L2Phase; - unsigned short locktime; - }; - -/* GPSEpoch Structure -> raw epoch Structure */ -struct GPSEpoch_T - { - unsigned int GPSTime; - unsigned short sta_id; - unsigned char num_sv; - unsigned char padding; - struct GPSSatellite sv[12]; - }; - -struct GPSMet_T - { - unsigned int GPSTime; - unsigned short sta_id; - long temperature; - long humidity; - long pressure; - }; - -typedef struct RTIGSO_T RTIGSO; -typedef struct RTIGSE_T RTIGSE; -typedef struct RTIGSS_T RTIGSS; -typedef struct RTIGSM_T RTIGSM; -typedef struct RTIGSH_T RTIGSH; -typedef struct GPSEpoch_T GPSEpoch; -typedef struct GPSMet_T GPSMet; - - -/* Function Declarations */ -extern void bytes_to_rtigsh(RTIGSH *rtigsh, unsigned char *packet); -extern int rtigso_to_raw(RTIGSO *rtigso, GPSEpoch *gpse); -extern int rtigsm_to_raw(RTIGSM *rtigsm, GPSMet *met); - - -void revbytes(unsigned char *buf, unsigned char size); - -#endif - - Index: /trunk/BNC/RTIGS/rtigs_records.h =================================================================== --- /trunk/BNC/RTIGS/rtigs_records.h (revision 305) +++ /trunk/BNC/RTIGS/rtigs_records.h (revision 305) @@ -0,0 +1,251 @@ +/*************************************************************************** + rtigs_records.h - description + ------------------- + begin : Wed Aug 27 2003 + copyright : (C) 2003 by Ken MacLeod + email : ken.macleod@nrcan.gc.ca. + ***************************************************************************/ + +/*************************************************************************** + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + ***************************************************************************/ +#ifndef _RTIGS_T +#define _RTIGS_T + +/***************************************************************************** +* RT-IGS record structures +* +* General: +* +* Every record will have a defined number. We propose the following: +* 1) Station record number 100; +* 2) Observation record number 200; +* 3) Ephemeris record number 300; +* 4) Meteorological record number 400; +* +* Every station will have a unique number. We propose the following: +* +* 1-99 reserved for JPL +* 100-199 reserved for NRCan +* 200-299 reserved for NGS +* 300-399 reserved for ESOC +* 400-499 reserved for GFZ +* 500-599 reserved for BKG +* 600-699 reserved for GEOSCIENCE AUS. +* 700-799 others +* etc +* The number of bytes in each real time message will include the header as +* well as the data content, but NOT the pointer. For example : +* +* 1) A station message is output once per hour and is 20 bytes +* +* 2) An observation message is output once per second. The header is +* 12 bytes long and the SOC data is 21 bytes per PRN. So a typical +* RTIGSO_T message will be 390 bytes if 8 sats are being tracked +* +* 3) An ephemeris message is output when the ephemeris is decoded by the +* GPS receiver. The time in the Ephemeris header is the collected time. +* One ephemeris can be bundled in a RTIGSE_T. +* A RTIGSE_T message contains one eph. the message consists of 12 header +* bytes and 72 ephemeris bytes, for a total of 84 bytes. +* +* 4) The RTIGSM_T (met) message should be issues once every 15 minutes. +* A basic met message consists of a 12 byte header and 3 longs (temp, +* press and relative humidity) for a total of 24 bytes. +* +* All records will be related to a station configuration indicated by the +* Issue of Data Station(IODS). The IODS will enable the user to identify +* the equipment and software that was used to derive the observation data. +* +* Each record header will contain the GPS Time in seconds which is +* continuous from ((6 Jan-1980)). +* +* The data payload of each record will consist of observations. The +* structures shown below indicate a pointer to data but in fact the broadcast +* messages will not contain the pointed only the data. Users will have to +* manage the data and the pointer is shown to illustrate where the data is +* located in the message and one possible data management option. +* +* +* All record data in network byte order (Big Endian), ie IA32 users will +* have to swap bytes ;-) +****************************************************************************** +* Developed by Ken MacLeod Aug. 27/2003 +* Updated and revised Feb. 10/2004 with comments from R. Muellershoen +*****************************************************************************/ + +#define MAXSTA 256 +#define MAXSOC 264 /* 12 + (12 * 21) = 264*/ +#define MAXEPH 876 /* 12 + (12 * 72) = 876*/ +#define MAXMETS 6 + + +/***************************************************************************** +* Structure name : RTIGSS_T +* +* Purpose: +* +* Encapsulate the station information that is required for real-time users +* +* Users should use this record is to link data to a specific station +* configuration. +* The station message should be transmitted by station operator every +* hour and upon update. +* If the stations record Issue of Data Station(IODS) and the IODS in the +* observation record do not match then the data should be used without +* further investigation +* +* +* +* This record is not intended to replace the IGS Station log but it is +* seen as a subset of the IGS log and contains information that enables +* real-time users to monitor station changes. +* +* +*Version: 1.0 +* +*By Ken MacLeod Aug. 27/2003 +*Changes: Revised Feb. 10/2004 updated the message description info. + ****************************************************************************/ + +typedef struct rtigs_station +{ + unsigned short rec_id; /*100 indicates station record this message */ + /* to be issued once per hour*/ + unsigned short sta_id; /*unique number assigned to each station. */ + /* Uniquely linked to an IGS Station log by */ + /* the station record*/ + unsigned long GPSTime; /* time of issue, GPS time is seconds from */ + /* the beginning of GPS (6 Jan-1980)*/ + unsigned short num_bytes; /* total number of bytes in the message, */ + /* including the header*/ + unsigned char IODS; /* a flag indicating the current station */ + /* configuration this will change every time */ + /* the station hardware changes*/ + unsigned char sta_rec_type; /* could be various station data formats: */ + /* 0 indicates that there is no additional */ + /* station data*/ + char IGS_UniqueID[8]; /* IGS ID eg NRC1 will use IGS 4 character */ + /* standard but c requires a \0 to terminate */ + /* the string */ + unsigned char *data; /* default station headers Does Not */ + /* contain data. The current message does */ + /* not contain additional station */ + /* information the pointer is shown only */ + /* to illustrate options*/ +}RTIGSS_T; + +/****************************************************************************** + * Structure name : RTIGSO_T + * + * Purpose : GPS Observations + * Currently the JPL Soc format is used to compress the + * observation data. + * See JPL's website for a description of the SOC + * compression routine + *Version: 1.0 + * + *By Ken MacLeod Aug. 27/2003 + *Changes: Revised Feb. 10/2004 Remove station clock and obs time + * in milliseconds and add to the message description + *****************************************************************************/ +typedef struct rtigs_obs +{ + unsigned short rec_id; /* 200 indicates rt-igs gps observation*/ + unsigned short sta_id; /* Unique num. assigned to each station */ + /* Uniquely linked to an IGS Station log y */ + /* the station record*/ + unsigned long GPSTime; /* observation time of issue, GPS time is */ + /* seconds from the beginning of GPS */ + /* (6 Jan-1980)*/ + unsigned short num_bytes; /* total number of bytes in the message, */ + /* including the header, but not the data */ + /* pointer*/ + unsigned char IODS; /* a flag indicating the current station */ + /* configuration that derived the */ + /* observations this value will change */ + /* every time the station configuration */ + /* changes*/ + unsigned char num_obs; /* number of GPS Observations in data block*/ + unsigned char *data; /* pointer to soc observation data (4 byte pointer), this pointer */ + /* is not in the message the data starts */ + /* here, the pointer is used to manage the */ + /* SOC data once the RTIGS0_T message has */ + /* been decoded */ +} RTIGSO_T; +/***************************************************************************** + * Structure name : RTIGSE_T + * + * Purpose : SV Ephemeris in Broadcast format parity removed + * + *Version: 1.0 + * + *By Ken MacLeod Aug. 27/2003 + *Changes: Revised Feb. 10/2004 + *****************************************************************************/ +typedef struct rtigs_ephemeris +{ + unsigned short rec_id; /* 300 indicates rt-igs eph*/ + unsigned short sta_id; /* unique number assigned */ + /* to each station*/ + unsigned long CollectedGPSTime; /* time ephemeris received at */ + /*station, GPS time is seconds */ + /* from the beginning of GPS */ + /* (6 Jan-1980)*/ + unsigned short num_bytes; /* total number of bytes in the message, */ + /* including the header, but not the size */ + /* of the data pointer*/ + unsigned char IODS; /* a flag indicating the current station */ + /* configuration that derived the */ + /* observations this will change every */ + /* time the sta config changes*/ + unsigned char prn; /* PRN*/ + unsigned char *data; /* In the RTIGSE_T message the data */ + /* starts here, the pointer is used to */ + /* manage the eph data once the RTIGSE_T */ + /* message has been decoded */ + /* The RTIGSE_T eph. format consists of */ + /* the 3 broadcast sub frames with the */ + /* parity bits removed so 3 */ + /* subframes = 72 bytes */ +} RTIGSE_T; + +/*********************************************************************** + * Structure name : RTIGSM_T + * + * Purpose : Station Meteorological observations + * + *Version: 1.0 + * + *By Ken MacLeod Aug. 27/2003 + *Changes: Changed the met array to an long pointer + ***********************************************************************/ +typedef struct rtigs_mets +{ + unsigned short rec_id; /* 400 indicates rt-igs met*/ + unsigned short sta_id; /* unique number assigned to each */ + /* station*/ + unsigned long GPSTime; /* time of issue, GPS time is seconds */ + /* from the beginning of GPS (6 Jan-1980)*/ + unsigned short num_bytes; /* total number of bytes in the message,*/ + /* including the header but not the pointer*/ + unsigned char IODS; /* a flag indicating the current station */ + /* config that derived the observations */ + /* this will change every time the station */ + /* configuration changes*/ + unsigned char numobs; /* if only temp, press, rel hum then : 3 */ + long *mets; /* temp(Deg C), press (mb), */ + /* rel humid(%), zenith Wet(metres), */ + /* Zenith Dry(metres), Zenith Total */ + /* (metres) and each scaled by 1000 so */ + /* 1000.123 mb = 1000123*/ + /*if the zenith observations are not */ + /* present only enter 3 for the num of obs.*/ +} RTIGSM_T; + +#endif Index: /trunk/BNC/RTIGS/rtstruct.h =================================================================== --- /trunk/BNC/RTIGS/rtstruct.h (revision 305) +++ /trunk/BNC/RTIGS/rtstruct.h (revision 305) @@ -0,0 +1,233 @@ +/*************************************************************************** + rtstruct.h - description + ------------------- + begin : Tue Mar 7 2000 + copyright : (C) 2000 by Ken MacLeod + email : macleod@geod.nrcan.gc.ca + ***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ +/*-------------------------------------------------------------------------*/ +/* Name : rtstruct.h */ + +/* Purpose : structure definitions for the wide area prototype */ + +/* RCS: $Header: /usr/local/cvsroot/BNC/RTIGS/rtstruct.h,v 1.1 2006/08/20 13:36:49 mervart Exp $ */ + +/* Externals : */ +/*-------------------------------------------------------------------------*/ +#ifndef _RTSTRUCT +#define _RTSTRUCT + +/**************************************************************************/ +/*** ***/ +/*** RTAP Function Prototypes: ***/ +/*** ***/ +/*** 1) typedef defines the RTAP types for non-RTAP ***/ +/*** compiles ***/ +/*** ***/ +/*** 2) To compile within RTAP use -D_RTAP compile option ***/ +/*** ***/ +/*** Note: Most function prototypes are commented out until the ***/ +/*** corresponding functions are changed accordingly ***/ +/*** ***/ +/**************************************************************************/ + +#ifdef _RTAP + +#include +#include + +#else + +typedef double rtDouble; +typedef float rtFloat; +typedef char rtChar; +typedef unsigned char rtUInt8; +typedef unsigned short rtUInt16; +typedef unsigned int rtUInt32; +typedef int rtInt32; +typedef short rtInt16; +typedef char rtInt8; +typedef int rtInt; +typedef struct timeval rtTime; + +typedef rtUInt32 rtDbQuality; +typedef rtUInt8 rtLogical; +typedef rtUInt8 rtBytes4[4]; +typedef rtUInt8 rtBytes8[8]; +typedef rtUInt8 rtBytes12[12]; +typedef rtUInt8 rtBytes16[16]; +typedef rtUInt8 rtBytes20[20]; +typedef rtUInt8 rtBytes32[32]; +typedef rtUInt8 rtBytes48[48]; +typedef rtUInt8 rtBytes64[64]; +typedef rtUInt8 rtBytes80[80]; +typedef rtUInt8 rtBytes128[128]; +typedef rtUInt8 rtBytes256[256]; + +#endif + +/* Now define our constants */ +/* Our CONS_T structure member names are now lower case to prevent conflict */ + +#define MAX_STA (24) /* maximum stations */ +#define PI (3.141592653589793) /* value of PI */ +#define DTR (0.017453292519943) /* deg to rad conversion con. */ +#define C (299792458.00) /* speed of light in vaccuum */ +#define F1 (1575.42E+06) /* GPS L1 frequency */ +#define F1_SQUARE (F1 * F1) /* GPS L1 frequency squared */ +#define L1 (C / F1) /* GPS L1 wavelength */ +#define F2 (1227.60E+06) /* GPS L2 frequency */ +#define F2_SQUARE (F2 * F2) /* GPS L2 frequency squared */ +#define L2 (C / F2) /* GPS L2 wavelength */ +#define F3 (F1 - F2) /* GPS widelane frequency */ +#define L3 (C / F3) /* GPS widelane wavelength */ +#define F1ION (F2_SQUARE / (F1_SQUARE - F2_SQUARE)) /* L1 iono scale factor */ +#define F2ION (F1_SQUARE / (F1_SQUARE - F2_SQUARE)) /* L2 iono scale factor */ +#define IonoH (350000.0) /* Ionospheric height in metres */ + + /******************************* + * Content: Broadcast Orbit + * Representation + ********************************/ +typedef struct broadcast{ +double satellite; /* satellite number */ +double gps_week; /* gps week number from 81/01/06*/ +double user_range_acc; /* user range accuracy in meters */ +double sat_health; /* satellite health (all bits) */ +double fit_interval; /* ephemeris fit interval */ +double l2code; /* Codes on L2 indicator */ +double l2pflag; /* Data flag for L2 P code */ +double issue_of_clock; /* issue of clock */ +double issue_of_eph; /* issue of ephemeris */ +double transmit_time; /* time of transmission */ +double clock_ref_time; /* reference time of the clock */ +double eph_ref_time; /* reference time of the ephem */ +double a0; /* satellite clock coefficient */ +double a1; /* satellite clock coefficient */ +double a2; /* satellite clock coefficient */ +double ref_mean_anmly; /* mean anomoly at reference time */ +double mean_mot_diff; /* mean motion difference */ +double orbit_ecc; /* orbit eccentricity */ +double orbit_semimaj; /* square root of orbit semimajor axis */ +double arg_of_perigee; /* argument of perigee */ +double orbit_incl; /* orbit inclination */ +double incl_rate; /* orbit inclination rate */ +double right_asc; /* right ascension */ +double right_asc_rate; /* rate of right ascension */ +double lat_cos_corr; /* ampl of cos harm corr to arg of lat */ +double lat_sin_corr; /* ampl of sin harm corr to arg of lat */ +double orbit_cos_corr; /* ampl of cos harm corr to orbit */ +double orbit_sin_corr; /* ampl of sin harm corr to orbit */ +double incl_cos_corr; /* ampl of cos harm corr to the incl */ +double incl_sin_corr; /* ampl of sin harm corr to the incl */ +double group_delay; /* estimated group delay differential */ +}BEPH_T; + + + + /****************************** + * Content:Receiver independent + * GPS observation data structure + * contains all possible obs + *******************************/ +typedef struct complete_measurement{ +unsigned long GPSTime; /* broadcast time sec.*/ +unsigned char chn; /* Channel*/ +unsigned char sat_prn; /* satellite ID*/ +unsigned short ntrvl; /* number of seconds */ +unsigned char flag[4]; /*observation quality flags*/ +float l1_sn; /* signal-to-noise CA frequency 1 */ + +double l1_pseudo_range; /* frequency-1 CA pseudorange */ +double l1_phase; /* frequency-1 CA carrier phase */ + /*KML for this struct SNR will be DBHz */ +double p1_pseudo_range; /* frequency-1 P1 pseudorange */ +double p1_phase; /* frequency-1 P1 carrier phase */ +float p1_sn; /* signal-to-noise P1 frequency 1 */ +float l2_sn; /* signal-to-noise frequency 2 */ + + /*KML for this struct SNR will be DBHz */ +double l2_pseudo_range; /* frequency-2 pseudorange (XCorr) */ +double l2_phase; /* frequency-2 carrier phase (XCorr) */ + /*KML for this struct SNR will be DBHz */ +double p2_pseudo_range; /* frequency-2 pseudorange */ +double p2_phase; /* frequency-2 carrier phase */ +}CMEAS_T; + + + + + /******************************* + * Content:Turbo Rogue Receiver + * Raw Turbo Broadcast Message + *******************************/ +typedef struct rawtbeph{ +char block_type; /* Turbo record type */ +char block_length; /* Turbo record in bytes */ +char Satellite; /* Sat. PRN */ +char Dummy; +long GPSEpochTime; +long GPSCollectedTime; +unsigned long SubFrame1[6]; /* SubFrame1 hexbits */ +unsigned long SubFrame2[6]; /* SubFrame2 hexbits */ +unsigned long SubFrame3[6]; /* SubFrame3 hexbits */ +}RNAV_T; + + /******************************** + * Content: Turbo Rogue Receiver + * Raw TurboRogue GPS observation + ********************************/ +typedef struct rawtbobserv{ +char BlockType; +char BlockSize; +char Satellite; +char Channel; +long GPSTimeTag; +char SampleInterval; +char Flags; +unsigned short SNR[3]; +double CAfaz; +double CAtau; +float faz1; +float tau1; +float faz2; +float tau2; +}TBIN_T; + + /******************************* + * Content:Turbo Rogue Receiver + * Turbo Broadcast Message + *******************************/ +typedef struct reducedbeph{ +long Satellite; +long GPSCollectedTime; +unsigned long SubFrame1[6]; /* SubFrame1 hexbits */ +unsigned long SubFrame2[6]; /* SubFrame2 hexbits */ +unsigned long SubFrame3[6]; /* SubFrame3 hexbits */ +}TNAV_T; + + + /************************************* + * Content: Meteorological Observations + * Summarized met data + *************************************/ +typedef struct scaledmet{ +long GPSTime; /*GPS Time */ +long Temp; /*scaled temperature */ +long TempStdDev; /*scaled temp. std dev */ +long Pressure; /*scaled pressure */ +long PressureStdDev ; /*scaled press. std dev */ +long RelHum; /*scaled percentage */ +long RelHumStdDev; /*scaled prec. std dev */ +}METS_T; + +#endif