1  // Part of BNC, a utility for retrieving decoding and


2  // converting GNSS data streams from NTRIP broadcasters.


3  //


4  // Copyright (C) 2007


5  // German Federal Agency for Cartography and Geodesy (BKG)


6  // http://www.bkg.bund.de


7  // Czech Technical University Prague, Department of Geodesy


8  // http://www.fsv.cvut.cz


9  //


10  // Email: eurefip@bkg.bund.de


11  //


12  // This program is free software; you can redistribute it and/or


13  // modify it under the terms of the GNU General Public License


14  // as published by the Free Software Foundation, version 2.


15  //


16  // This program is distributed in the hope that it will be useful,


17  // but WITHOUT ANY WARRANTY; without even the implied warranty of


18  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the


19  // GNU General Public License for more details.


20  //


21  // You should have received a copy of the GNU General Public License


22  // along with this program; if not, write to the Free Software


23  // Foundation, Inc., 59 Temple Place  Suite 330, Boston, MA 021111307, USA.


24 


25  /* 


26  * BKG NTRIP Client


27  * 


28  *


29  * Class: RTCM3Decoder


30  *


31  * Purpose: RTCM3 Decoder


32  *


33  * Author: L. Mervart


34  *


35  * Created: 24Aug2006


36  *


37  * Changes:


38  *


39  * */


40 


41  #include <iostream>


42  #include <iomanip>


43  #include <sstream>


44  #include <math.h>


45  #include <string.h>


46 


47  #include "bits.h"


48  #include "gnss.h"


49  #include "RTCM3Decoder.h"


50  #include "rtcm_utils.h"


51  #include "bncconst.h"


52  #include "bnccore.h"


53  #include "bncutils.h"


54  #include "bncsettings.h"


55 


56  using namespace std;


57 


58  // Error Handling


59  ////////////////////////////////////////////////////////////////////////////


60  void RTCM3Error(const char*, ...) {


61  }


62 


63  // Constructor


64  ////////////////////////////////////////////////////////////////////////////


65  RTCM3Decoder::RTCM3Decoder(const QString& staID, bncRawFile* rawFile) :


66  GPSDecoder() {


67 


68  _staID = staID;


69  _rawFile = rawFile;


70 


71  connect(this, SIGNAL(newGPSEph(t_ephGPS)), BNC_CORE,


72  SLOT(slotNewGPSEph(t_ephGPS)));


73  connect(this, SIGNAL(newGlonassEph(t_ephGlo)), BNC_CORE,


74  SLOT(slotNewGlonassEph(t_ephGlo)));


75  connect(this, SIGNAL(newGalileoEph(t_ephGal)), BNC_CORE,


76  SLOT(slotNewGalileoEph(t_ephGal)));


77  connect(this, SIGNAL(newSBASEph(t_ephSBAS)), BNC_CORE,


78  SLOT(slotNewSBASEph(t_ephSBAS)));


79  connect(this, SIGNAL(newBDSEph(t_ephBDS)), BNC_CORE,


80  SLOT(slotNewBDSEph(t_ephBDS)));


81 


82  _MessageSize = _SkipBytes = _BlockSize = _NeedBytes = 0;


83  }


84 


85  // Destructor


86  ////////////////////////////////////////////////////////////////////////////


87  RTCM3Decoder::~RTCM3Decoder() {


88  QMapIterator<QByteArray, RTCM3coDecoder*> it(_coDecoders);


89  while (it.hasNext())


90  {


91  it.next();


92  delete it.value();


93  }


94  }


95 


96  //


97  ////////////////////////////////////////////////////////////////////////////


98  bool RTCM3Decoder::DecodeRTCM3GPS(unsigned char* data, int size) {


99  bool decoded = false;


100  bncTime CurrentObsTime;


101  int i, numsats, syncf, type;


102  uint64_t numbits = 0, bitfield = 0;


103 


104  data += 3; /* header */


105  size = 6; /* header + crc */


106 


107  GETBITS(type, 12)


108  SKIPBITS(12)


109  /* id */


110  GETBITS(i, 30)


111 


112  CurrentObsTime.set(i);


113  if (_CurrentTime.valid() && CurrentObsTime != _CurrentTime) {


114  decoded = true;


115  _obsList.append(_CurrentObsList);


116  _CurrentObsList.clear();


117  }


118 


119  _CurrentTime = CurrentObsTime;


120 


121  GETBITS(syncf, 1)


122  /* sync */


123  GETBITS(numsats, 5)


124  SKIPBITS(4)


125  /* smind, smint */


126 


127  while (numsats) {


128  int sv, code, l1range, amb = 0;


129  t_satObs CurrentObs;


130  CurrentObs._time = CurrentObsTime;


131 


132  GETBITS(sv, 6)


133  if (sv < 40)


134  CurrentObs._prn.set('G', sv);


135  else


136  CurrentObs._prn.set('S', sv  20);


137 


138  t_frqObs *frqObs = new t_frqObs;


139  /* L1 */


140  GETBITS(code, 1);


141  (code) ?


142  frqObs>_rnxType2ch.assign("1W") : frqObs>_rnxType2ch.assign("1C");


143  GETBITS(l1range, 24);


144  GETBITSSIGN(i, 20);


145  if ((i & ((1 << 20)  1)) != 0x80000) {


146  frqObs>_code = l1range * 0.02;


147  frqObs>_phase = (l1range * 0.02 + i * 0.0005) / GPS_WAVELENGTH_L1;


148  frqObs>_codeValid = frqObs>_phaseValid = true;


149  }


150  GETBITS(i, 7);


151  frqObs>_lockTime = lti2sec(type,i);


152  frqObs>_lockTimeValid = (frqObs>_lockTime >= 0.0 && frqObs>_phaseValid);


153  frqObs>_slipCounter = i;


154  if (type == 1002  type == 1004) {


155  GETBITS(amb, 8);


156  if (amb) {


157  frqObs>_code += amb * 299792.458;


158  frqObs>_phase += (amb * 299792.458) / GPS_WAVELENGTH_L1;


159  }


160  GETBITS(i, 8);


161  if (i) {


162  frqObs>_snr = i * 0.25;


163  frqObs>_snrValid = true;


164  }


165  }


166  CurrentObs._obs.push_back(frqObs);


167  if (type == 1003  type == 1004) {


168  frqObs = new t_frqObs;


169  /* L2 */


170  GETBITS(code, 2);


171  switch (code) {


172  case 3:


173  frqObs>_rnxType2ch.assign("2W"); /* or "2Y"? */


174  break;


175  case 2:


176  frqObs>_rnxType2ch.assign("2W");


177  break;


178  case 1:


179  frqObs>_rnxType2ch.assign("2P");


180  break;


181  case 0:


182  frqObs>_rnxType2ch.assign("2X"); /* or "2S" or "2L"? */


183  break;


184  }


185  GETBITSSIGN(i, 14);


186  if ((i & ((1 << 14)  1)) != 0x2000) {


187  frqObs>_code = l1range * 0.02 + i * 0.02 + amb * 299792.458;


188  frqObs>_codeValid = true;


189  }


190  GETBITSSIGN(i, 20);


191  if ((i & ((1 << 20)  1)) != 0x80000) {


192  frqObs>_phase = (l1range * 0.02 + i * 0.0005 + amb * 299792.458)


193  / GPS_WAVELENGTH_L2;


194  frqObs>_phaseValid = true;


195  }


196  GETBITS(i, 7);


197  frqObs>_lockTime = lti2sec(type,i);


198  frqObs>_lockTimeValid = (frqObs>_lockTime >= 0.0 && frqObs>_phaseValid);


199  frqObs>_slipCounter = i;


200  if (type == 1004) {


201  GETBITS(i, 8);


202  if (i) {


203  frqObs>_snr = i * 0.25;


204  frqObs>_snrValid = true;


205  }


206  }


207  CurrentObs._obs.push_back(frqObs);


208  }


209  _CurrentObsList.push_back(CurrentObs);


210  }


211 


212  if (!syncf) {


213  decoded = true;


214  _obsList.append(_CurrentObsList);


215  _CurrentTime.reset();


216  _CurrentObsList.clear();


217  }


218  return decoded;


219  }


220 


221  #define RTCM3_MSM_NUMSIG 32


222  #define RTCM3_MSM_NUMSAT 64


223  #define RTCM3_MSM_NUMCELLS 96 /* arbitrary limit */


224 


225  /**


226  * Frequency numbers of GLONASS with an offset of 100 to detect unset values.


227  * Gets filled by ephemeris and data blocks and shared between different streams.


228  */


229  static int GLOFreq[RTCM3_MSM_NUMSAT];


230 


231  /*


232  * Storage structure to store frequency and RINEX ID assignment for MSM


233  * message */


234  struct CodeData {


235  double wl;


236  const char *code; /* currently unused */


237  };


238 


239  /** MSM signal types for GPS and SBAS */


240  static struct CodeData gps[RTCM3_MSM_NUMSIG] = {


241  {0.0, 0},


242  {GPS_WAVELENGTH_L1, "1C"},


243  {GPS_WAVELENGTH_L1, "1P"},


244  {GPS_WAVELENGTH_L1, "1W"},


245  {0.0, 0},


246  {0.0, 0},


247  {0.0, 0},


248  {GPS_WAVELENGTH_L2, "2C"},


249  {GPS_WAVELENGTH_L2, "2P"},


250  {GPS_WAVELENGTH_L2, "2W"},


251  {0.0, 0},


252  {0.0, 0},


253  {0.0, 0},


254  {0.0, 0},


255  {GPS_WAVELENGTH_L2, "2S"},


256  {GPS_WAVELENGTH_L2, "2L"},


257  {GPS_WAVELENGTH_L2, "2X"},


258  {0.0, 0},


259  {0.0, 0},


260  {0.0, 0},


261  {0.0, 0},


262  {GPS_WAVELENGTH_L5, "5I"},


263  {GPS_WAVELENGTH_L5, "5Q"},


264  {GPS_WAVELENGTH_L5, "5X"},


265  {0.0, 0},


266  {0.0, 0},


267  {0.0, 0},


268  {0.0, 0},


269  {0.0, 0},


270  {GPS_WAVELENGTH_L1, "1S"},


271  {GPS_WAVELENGTH_L1, "1L"},


272  {GPS_WAVELENGTH_L1, "1X"}


273  };


274 


275  /**


276  * MSM signal types for GLONASS


277  *


278  * NOTE: Uses 0.0, 1.0 for wavelength as sat index dependence is done later!


279  */


280  static struct CodeData glo[RTCM3_MSM_NUMSIG] = {


281  {0.0, 0},


282  {0.0, "1C"},


283  {0.0, "1P"},


284  {0.0, 0},


285  {0.0, 0},


286  {0.0, 0},


287  {0.0, 0},


288  {1.0, "2C"},


289  {1.0, "2P"},


290  {GLO_WAVELENGTH_L1a, "4A"},


291  {GLO_WAVELENGTH_L1a, "4B"},


292  {GLO_WAVELENGTH_L1a, "4X"},


293  {GLO_WAVELENGTH_L2a, "6A"},


294  {GLO_WAVELENGTH_L2a, "6B"},


295  {GLO_WAVELENGTH_L2a, "6X"},


296  {GLO_WAVELENGTH_L3, "3I"},


297  {GLO_WAVELENGTH_L3, "3Q"},


298  {GLO_WAVELENGTH_L3, "3X"},


299  {0.0, 0},


300  {0.0, 0},


301  {0.0, 0},


302  {0.0, 0},


303  {0.0, 0},


304  {0.0, 0},


305  {0.0, 0},


306  {0.0, 0},


307  {0.0, 0},


308  {0.0, 0},


309  {0.0, 0},


310  {0.0, 0},


311  {0.0, 0},


312  {0.0, 0}


313  };


314 


315  /** MSM signal types for Galileo */


316  static struct CodeData gal[RTCM3_MSM_NUMSIG] = {


317  {0.0, 0},


318  {GAL_WAVELENGTH_E1, "1C"},


319  {GAL_WAVELENGTH_E1, "1A"},


320  {GAL_WAVELENGTH_E1, "1B"},


321  {GAL_WAVELENGTH_E1, "1X"},


322  {GAL_WAVELENGTH_E1, "1Z"},


323  {0.0, 0},


324  {GAL_WAVELENGTH_E6, "6C"},


325  {GAL_WAVELENGTH_E6, "6A"},


326  {GAL_WAVELENGTH_E6, "6B"},


327  {GAL_WAVELENGTH_E6, "6X"},


328  {GAL_WAVELENGTH_E6, "6Z"},


329  {0.0, 0},


330  {GAL_WAVELENGTH_E5B, "7I"},


331  {GAL_WAVELENGTH_E5B, "7Q"},


332  {GAL_WAVELENGTH_E5B, "7X"},


333  {0.0, 0},


334  {GAL_WAVELENGTH_E5AB,"8I"},


335  {GAL_WAVELENGTH_E5AB,"8Q"},


336  {GAL_WAVELENGTH_E5AB,"8X"},


337  {0.0, 0},


338  {GAL_WAVELENGTH_E5A, "5I"},


339  {GAL_WAVELENGTH_E5A, "5Q"},


340  {GAL_WAVELENGTH_E5A, "5X"},


341  {0.0, 0},


342  {0.0, 0},


343  {0.0, 0},


344  {0.0, 0},


345  {0.0, 0},


346  {0.0, 0},


347  {0.0, 0},


348  {0.0, 0}


349  };


350 


351  /** MSM signal types for QZSS */


352  static struct CodeData qzss[RTCM3_MSM_NUMSIG] = {


353  {0.0, 0},


354  {GPS_WAVELENGTH_L1, "1C"},


355  {0.0, 0},


356  {0.0, 0},


357  {0.0, 0},


358  {0.0, 0},


359  {0.0, 0},


360  {0.0, 0},


361  {QZSS_WAVELENGTH_L6, "6S"},


362  {QZSS_WAVELENGTH_L6, "6L"},


363  {QZSS_WAVELENGTH_L6, "6X"},


364  {0.0, 0},


365  {0.0, 0},


366  {0.0, 0},


367  {GPS_WAVELENGTH_L2, "2S"},


368  {GPS_WAVELENGTH_L2, "2L"},


369  {GPS_WAVELENGTH_L2, "2X"},


370  {0.0, 0},


371  {0.0, 0},


372  {0.0, 0},


373  {0.0, 0},


374  {GPS_WAVELENGTH_L5, "5I"},


375  {GPS_WAVELENGTH_L5, "5Q"},


376  {GPS_WAVELENGTH_L5, "5X"},


377  {0.0, 0},


378  {0.0, 0},


379  {0.0, 0},


380  {0.0, 0},


381  {0.0, 0},


382  {GPS_WAVELENGTH_L1, "1S"},


383  {GPS_WAVELENGTH_L1, "1L"},


384  {GPS_WAVELENGTH_L1, "1X"}


385  };


386 


387  /** MSM signal types for Beidou/BDS */


388  static struct CodeData bds[RTCM3_MSM_NUMSIG] = {


389  {0.0, 0},


390  {BDS_WAVELENGTH_B1, "2I"},


391  {BDS_WAVELENGTH_B1, "2Q"},


392  {BDS_WAVELENGTH_B1, "2X"},


393  {0.0, 0},


394  {0.0, 0},


395  {0.0, 0},


396  {BDS_WAVELENGTH_B3, "6I"},


397  {BDS_WAVELENGTH_B3, "6Q"},


398  {BDS_WAVELENGTH_B3, "6X"},


399  {0.0, 0},


400  {0.0, 0},


401  {0.0, 0},


402  {BDS_WAVELENGTH_B2, "7I"},


403  {BDS_WAVELENGTH_B2, "7Q"},


404  {BDS_WAVELENGTH_B2, "7X"},


405  {0.0, 0},


406  {0.0, 0},


407  {0.0, 0},


408  {0.0, 0},


409  {0.0, 0},


410  {BDS_WAVELENGTH_B2a, "5D"},


411  {BDS_WAVELENGTH_B2a, "5P"},


412  {BDS_WAVELENGTH_B2a, "5X"},


413  {BDS_WAVELENGTH_B2b, "7D"},


414  {0.0, 0},


415  {0.0, 0},


416  {0.0, 0},


417  {0.0, 0},


418  {BDS_WAVELENGTH_B1C, "1D"},


419  {BDS_WAVELENGTH_B1C, "1P"},


420  {BDS_WAVELENGTH_B1C, "1X"}


421  };


422 


423  /** MSM signal types for IRNSS */


424  static struct CodeData irn[RTCM3_MSM_NUMSIG] = {


425  {0.0, 0},


426  {0.0, 0},


427  {0.0, 0},


428  {0.0, 0},


429  {0.0, 0},


430  {0.0, 0},


431  {0.0, 0},


432  {IRNSS_WAVELENGTH_S, "9A"},


433  {0.0, 0},


434  {0.0, 0},


435  {0.0, 0},


436  {0.0, 0},


437  {0.0, 0},


438  {0.0, 0},


439  {0.0, 0},


440  {0.0, 0},


441  {0.0, 0},


442  {0.0, 0},


443  {0.0, 0},


444  {0.0, 0},


445  {0.0, 0},


446  {IRNSS_WAVELENGTH_L5, "5A"},


447  {0.0, 0},


448  {0.0, 0},


449  {0.0, 0},


450  {0.0, 0},


451  {0.0, 0},


452  {0.0, 0},


453  {0.0, 0},


454  {0.0, 0},


455  {0.0, 0},


456  {0.0, 0}


457  };


458 


459  #define UINT64(c) c ## ULL


460 


461  //


462  ////////////////////////////////////////////////////////////////////////////


463  bool RTCM3Decoder::DecodeRTCM3MSM(unsigned char* data, int size) {


464  bool decoded = false;


465  int type, syncf, i;


466  uint64_t numbits = 0, bitfield = 0;


467 


468  data += 3; /* header */


469  size = 6; /* header + crc */


470 


471  GETBITS(type, 12)


472  SKIPBITS(12)


473  /* id */


474  char sys;


475  if (type >= 1131)


476  sys = 'I';


477  else if (type >= 1121)


478  sys = 'C';


479  else if (type >= 1111)


480  sys = 'J';


481  else if (type >= 1101)


482  sys = 'S';


483  else if (type >= 1091)


484  sys = 'E';


485  else if (type >= 1081)


486  sys = 'R';


487  else if (type >= 1071)


488  sys = 'G';


489 


490  bncTime CurrentObsTime;


491  if (sys == 'C') /* BDS */ {


492  GETBITS(i, 30)


493  CurrentObsTime.setBDS(i);


494  }


495  else if (sys == 'R') /* GLONASS */ {


496  SKIPBITS(3)


497  GETBITS(i, 27)


498  /* tk */


499  CurrentObsTime.setTk(i);


500  }


501  else /* GPS style date */ {


502  GETBITS(i, 30)


503  CurrentObsTime.set(i);


504  }


505  if (_CurrentTime.valid() && CurrentObsTime != _CurrentTime) {


506  decoded = true;


507  _obsList.append(_CurrentObsList);


508  _CurrentObsList.clear();


509  }


510  _CurrentTime = CurrentObsTime;


511 


512  GETBITS(syncf, 1)


513  /**


514  * Ignore unknown types except for sync flag


515  *


516  * We actually support types 13 in following code, but as they are missing


517  * the full cycles and can't be used later we skip interpretation here already.


518  */


519  if (type <= 1137 && (type % 10) >= 4 && (type % 10) <= 7) {


520  int sigmask, numsat = 0, numsig = 0;


521  uint64_t satmask, cellmask, ui;


522  // satellite data


523  double rrmod[RTCM3_MSM_NUMSAT]; // GNSS sat rough ranges modulo 1 millisecond


524  int rrint[RTCM3_MSM_NUMSAT]; // number of integer msecs in GNSS sat rough ranges


525  int rdop[RTCM3_MSM_NUMSAT]; // GNSS sat rough phase range rates


526  int extsat[RTCM3_MSM_NUMSAT];// extended sat info


527  // signal data


528  int ll[RTCM3_MSM_NUMCELLS]; // lock time indicator


529  /*int hc[RTCM3_MSM_NUMCELLS];*/ // half cycle ambiguity indicator


530  double cnr[RTCM3_MSM_NUMCELLS]; // signal cnr


531  double cp[RTCM3_MSM_NUMCELLS]; // fine phase range data


532  double psr[RTCM3_MSM_NUMCELLS]; // fine psr


533  double dop[RTCM3_MSM_NUMCELLS]; // fine phase range rates


534 


535  SKIPBITS(3 + 7 + 2 + 2 + 1 + 3)


536  GETBITS64(satmask, RTCM3_MSM_NUMSAT)


537 


538  /* http://gurmeetsingh.wordpress.com/2008/08/05/fastbitcountingroutines/ */


539  for (ui = satmask; ui; ui &= (ui  1) /* remove rightmost bit */)


540  ++numsat;


541  GETBITS(sigmask, RTCM3_MSM_NUMSIG)


542  for (i = sigmask; i; i &= (i  1) /* remove rightmost bit */)


543  ++numsig;


544  for (i = 0; i < RTCM3_MSM_NUMSAT; ++i)


545  extsat[i] = 15;


546 


547  i = numsat * numsig;


548  GETBITS64(cellmask, (unsigned )i)


549  // satellite data


550  switch (type % 10) {


551  case 1:


552  case 2:


553  case 3:


554  /* partial data, already skipped above, but implemented for future expansion ! */


555  for (int j = numsat; j;)


556  GETFLOAT(rrmod[j], 10, 1.0 / 1024.0)


557  break;


558  case 4:


559  case 6:


560  for (int j = numsat; j;)


561  GETBITS(rrint[j], 8)


562  for (int j = numsat; j;)


563  GETFLOAT(rrmod[j], 10, 1.0 / 1024.0)


564  break;


565  case 5:


566  case 7:


567  for (int j = numsat; j;)


568  GETBITS(rrint[j], 8)


569  for (int j = numsat; j;)


570  GETBITS(extsat[j], 4)


571  for (int j = numsat; j;)


572  GETFLOAT(rrmod[j], 10, 1.0 / 1024.0)


573  for (int j = numsat; j;)


574  GETBITSSIGN(rdop[j], 14)


575  break;


576  }


577  // signal data


578  int numcells = numsat * numsig;


579  /** Drop anything which exceeds our cell limit. Increase limit definition


580  * when that happens. */


581  if (numcells <= RTCM3_MSM_NUMCELLS) {


582  switch (type % 10) {


583  case 1:


584  for (int count = numcells; count;)


585  if (cellmask & (UINT64(1) << count))


586  GETFLOATSIGN(psr[count], 15, 1.0 / (1 << 24))


587  break;


588  case 2:


589  for (int count = numcells; count;)


590  if (cellmask & (UINT64(1) << count))


591  GETFLOATSIGN(cp[count], 22, 1.0 / (1 << 29))


592  for (int count = numcells; count;)


593  if (cellmask & (UINT64(1) << count))


594  GETBITS(ll[count], 4)


595  for (int count = numcells; count;)


596  if (cellmask & (UINT64(1) << count))


597  SKIPBITS(1)/*GETBITS(hc[count], 1)*/


598  break;


599  case 3:


600  for (int count = numcells; count;)


601  if (cellmask & (UINT64(1) << count))


602  GETFLOATSIGN(psr[count], 15, 1.0 / (1 << 24))


603  for (int count = numcells; count;)


604  if (cellmask & (UINT64(1) << count))


605  GETFLOATSIGN(cp[count], 22, 1.0 / (1 << 29))


606  for (int count = numcells; count;)


607  if (cellmask & (UINT64(1) << count))


608  GETBITS(ll[count], 4)


609  for (int count = numcells; count;)


610  if (cellmask & (UINT64(1) << count))


611  SKIPBITS(1)/*GETBITS(hc[count], 1)*/


612  break;


613  case 4:


614  for (int count = numcells; count;)


615  if (cellmask & (UINT64(1) << count))


616  GETFLOATSIGN(psr[count], 15, 1.0 / (1 << 24))


617  for (int count = numcells; count;)


618  if (cellmask & (UINT64(1) << count))


619  GETFLOATSIGN(cp[count], 22, 1.0 / (1 << 29))


620  for (int count = numcells; count;)


621  if (cellmask & (UINT64(1) << count))


622  GETBITS(ll[count], 4)


623  for (int count = numcells; count;)


624  if (cellmask & (UINT64(1) << count))


625  SKIPBITS(1)/*GETBITS(hc[count], 1)*/


626  for (int count = numcells; count;)


627  if (cellmask & (UINT64(1) << count))


628  GETBITS(cnr[count], 6)


629  break;


630  case 5:


631  for (int count = numcells; count;)


632  if (cellmask & (UINT64(1) << count))


633  GETFLOATSIGN(psr[count], 15, 1.0 / (1 << 24))


634  for (int count = numcells; count;)


635  if (cellmask & (UINT64(1) << count))


636  GETFLOATSIGN(cp[count], 22, 1.0 / (1 << 29))


637  for (int count = numcells; count;)


638  if (cellmask & (UINT64(1) << count))


639  GETBITS(ll[count], 4)


640  for (int count = numcells; count;)


641  if (cellmask & (UINT64(1) << count))


642  SKIPBITS(1)/*GETBITS(hc[count], 1)*/


643  for (int count = numcells; count;)


644  if (cellmask & (UINT64(1) << count))


645  GETFLOAT(cnr[count], 6, 1.0)


646  for (int count = numcells; count;)


647  if (cellmask & (UINT64(1) << count))


648  GETFLOATSIGN(dop[count], 15, 0.0001)


649  break;


650  case 6:


651  for (int count = numcells; count;)


652  if (cellmask & (UINT64(1) << count))


653  GETFLOATSIGN(psr[count], 20, 1.0 / (1 << 29))


654  for (int count = numcells; count;)


655  if (cellmask & (UINT64(1) << count))


656  GETFLOATSIGN(cp[count], 24, 1.0 / (1U << 31))


657  for (int count = numcells; count;)


658  if (cellmask & (UINT64(1) << count))


659  GETBITS(ll[count], 10)


660  for (int count = numcells; count;)


661  if (cellmask & (UINT64(1) << count))


662  SKIPBITS(1)/*GETBITS(hc[count], 1)*/


663  for (int count = numcells; count;)


664  if (cellmask & (UINT64(1) << count))


665  GETFLOAT(cnr[count], 10, 1.0 / (1 << 4))


666  break;


667  case 7:


668  for (int count = numcells; count;)


669  if (cellmask & (UINT64(1) << count))


670  GETFLOATSIGN(psr[count], 20, 1.0 / (1 << 29))


671  for (int count = numcells; count;)


672  if (cellmask & (UINT64(1) << count))


673  GETFLOATSIGN(cp[count], 24, 1.0 / (1U << 31))


674  for (int count = numcells; count;)


675  if (cellmask & (UINT64(1) << count))


676  GETBITS(ll[count], 10)


677  for (int count = numcells; count;)


678  if (cellmask & (UINT64(1) << count))


679  SKIPBITS(1)/*GETBITS(hc[count], 1)*/


680  for (int count = numcells; count;)


681  if (cellmask & (UINT64(1) << count))


682  GETFLOAT(cnr[count], 10, 1.0 / (1 << 4))


683  for (int count = numcells; count;)


684  if (cellmask & (UINT64(1) << count))


685  GETFLOATSIGN(dop[count], 15, 0.0001)


686  break;


687  }


688  i = RTCM3_MSM_NUMSAT;


689  int j = 1;


690  t_satObs CurrentObs;


691  for (int count = numcells; count;) {


692  while (j >= 0 && !(sigmask & (1 << j)))


693  ;


694  if (j < 0) {


695  while (!(satmask & (UINT64(1) << (i))))


696  /* next satellite */


697  ;


698  if (CurrentObs._obs.size() > 0)


699  _CurrentObsList.push_back(CurrentObs);


700  CurrentObs.clear();


701  CurrentObs._time = CurrentObsTime;


702  if (sys == 'S')


703  CurrentObs._prn.set(sys, 20  1 + RTCM3_MSM_NUMSAT  i);


704  else


705  CurrentObs._prn.set(sys, RTCM3_MSM_NUMSAT  i);


706  j = RTCM3_MSM_NUMSIG;


707  while (!(sigmask & (1 << j)))


708  ;


709  numsat;


710  }


711  if (cellmask & (UINT64(1) << count)) {


712  struct CodeData cd = {0.0, 0};


713  switch (sys) {


714  case 'J':


715  cd = qzss[RTCM3_MSM_NUMSIG  j  1];


716  break;


717  case 'C':


718  cd = bds[RTCM3_MSM_NUMSIG  j  1];


719  break;


720  case 'G':


721  case 'S':


722  cd = gps[RTCM3_MSM_NUMSIG  j  1];


723  break;


724  case 'R':


725  cd = glo[RTCM3_MSM_NUMSIG  j  1];


726  {


727  int k = GLOFreq[RTCM3_MSM_NUMSAT  i  1];


728  if (extsat[numsat] < 14) { // channel number is available as extended info for MSM5/7


729  k = GLOFreq[RTCM3_MSM_NUMSAT  i  1] = 100 + extsat[numsat]  7;


730  }


731  if (k) {


732  if (cd.wl == 0.0) {


733  cd.wl = GLO_WAVELENGTH_L1(k  100);


734  }


735  else if (cd.wl == 1.0) {


736  cd.wl = GLO_WAVELENGTH_L2(k  100);


737  }


738  }


739  else if (!k && cd.wl <= 1) {


740  cd.code = 0;


741  }


742  }


743  break;


744  case 'E':


745  cd = gal[RTCM3_MSM_NUMSIG  j  1];


746  break;


747  case 'I':


748  cd = irn[RTCM3_MSM_NUMSIG  j  1];


749  break;


750  }


751  if (cd.code) {


752  t_frqObs *frqObs = new t_frqObs;


753  frqObs>_rnxType2ch.assign(cd.code);


754 


755  switch (type % 10) {


756  case 1:


757  if (psr[count] > 1.0 / (1 << 10)) {


758  frqObs>_code = psr[count] * LIGHTSPEED / 1000.0


759  + (rrmod[numsat]) * LIGHTSPEED / 1000.0;


760  frqObs>_codeValid = true;


761  }


762  break;


763  case 2:


764  if (cp[count] > 1.0 / (1 << 8)) {


765  frqObs>_phase = cp[count] * LIGHTSPEED / 1000.0 / cd.wl


766  + (rrmod[numsat]) * LIGHTSPEED / 1000.0 / cd.wl;


767  frqObs>_phaseValid = true;


768  frqObs>_lockTime = lti2sec(type,ll[count]);


769  frqObs>_lockTimeValid = (frqObs>_lockTime >= 0.0);


770  frqObs>_slipCounter = ll[count];


771  }


772  break;


773  case 3:


774  if (psr[count] > 1.0 / (1 << 10)) {


775  frqObs>_code = psr[count] * LIGHTSPEED / 1000.0


776  + (rrmod[numsat]) * LIGHTSPEED / 1000.0;


777  frqObs>_codeValid = true;


778  }


779  if (cp[count] > 1.0 / (1 << 8)) {


780  frqObs>_phase = cp[count] * LIGHTSPEED / 1000.0 / cd.wl


781  + rrmod[numsat] * LIGHTSPEED / 1000.0 / cd.wl;


782  frqObs>_phaseValid = true;


783  frqObs>_lockTime = lti2sec(type,ll[count]);


784  frqObs>_lockTimeValid = (frqObs>_lockTime >= 0.0);


785  frqObs>_slipCounter = ll[count];


786  }


787  break;


788  case 4:


789  if (psr[count] > 1.0 / (1 << 10)) {


790  frqObs>_code = psr[count] * LIGHTSPEED / 1000.0


791  + (rrmod[numsat] + rrint[numsat]) * LIGHTSPEED / 1000.0;


792  frqObs>_codeValid = true;


793  }


794  if (cp[count] > 1.0 / (1 << 8)) {


795  frqObs>_phase = cp[count] * LIGHTSPEED / 1000.0 / cd.wl


796  + (rrmod[numsat] + rrint[numsat]) * LIGHTSPEED / 1000.0 / cd.wl;


797  frqObs>_phaseValid = true;


798  frqObs>_lockTime = lti2sec(type,ll[count]);


799  frqObs>_lockTimeValid = (frqObs>_lockTime >= 0.0);


800  frqObs>_slipCounter = ll[count];


801  }


802  frqObs>_snr = cnr[count];


803  frqObs>_snrValid = true;


804  break;


805  case 5:


806  if (psr[count] > 1.0 / (1 << 10)) {


807  frqObs>_code = psr[count] * LIGHTSPEED / 1000.0


808  + (rrmod[numsat] + rrint[numsat]) * LIGHTSPEED / 1000.0;


809  frqObs>_codeValid = true;


810  }


811  if (cp[count] > 1.0 / (1 << 8)) {


812  frqObs>_phase = cp[count] * LIGHTSPEED / 1000.0 / cd.wl


813  + (rrmod[numsat] + rrint[numsat]) * LIGHTSPEED / 1000.0 / cd.wl;


814  frqObs>_phaseValid = true;


815  frqObs>_lockTime = lti2sec(type,ll[count]);


816  frqObs>_lockTimeValid = (frqObs>_lockTime >= 0.0);


817  frqObs>_slipCounter = ll[count];


818  }


819  frqObs>_snr = cnr[count];


820  frqObs>_snrValid = true;


821  if (dop[count] > 1.6384) {


822  frqObs>_doppler = (dop[count] + rdop[numsat]) / cd.wl;


823  frqObs>_dopplerValid = true;


824  }


825  break;


826  case 6:


827  if (psr[count] > 1.0 / (1 << 10)) {


828  frqObs>_code = psr[count] * LIGHTSPEED / 1000.0


829  + (rrmod[numsat] + rrint[numsat]) * LIGHTSPEED / 1000.0;


830  frqObs>_codeValid = true;


831  }


832  if (cp[count] > 1.0 / (1 << 8)) {


833  frqObs>_phase = cp[count] * LIGHTSPEED / 1000.0 / cd.wl


834  + (rrmod[numsat] + rrint[numsat]) * LIGHTSPEED / 1000.0 / cd.wl;


835  frqObs>_phaseValid = true;


836  frqObs>_lockTime = lti2sec(type,ll[count]);


837  frqObs>_lockTimeValid = (frqObs>_lockTime >= 0.0);


838  frqObs>_slipCounter = ll[count];


839  }


840 


841  frqObs>_snr = cnr[count];


842  frqObs>_snrValid = true;


843  break;


844  case 7:


845  if (psr[count] > 1.0 / (1 << 10)) {


846  frqObs>_code = psr[count] * LIGHTSPEED / 1000.0


847  + (rrmod[numsat] + rrint[numsat]) * LIGHTSPEED / 1000.0;


848  frqObs>_codeValid = true;


849  }


850  if (cp[count] > 1.0 / (1 << 8)) {


851  frqObs>_phase = cp[count] * LIGHTSPEED / 1000.0 / cd.wl


852  + (rrmod[numsat] + rrint[numsat]) * LIGHTSPEED / 1000.0 / cd.wl;


853  frqObs>_phaseValid = true;


854  frqObs>_lockTime = lti2sec(type,ll[count]);


855  frqObs>_lockTimeValid = (frqObs>_lockTime >= 0.0);


856  frqObs>_slipCounter = ll[count];


857  }


858 


859  frqObs>_snr = cnr[count];


860  frqObs>_snrValid = true;


861 


862  if (dop[count] > 1.6384) {


863  frqObs>_doppler = (dop[count] + rdop[numsat]) / cd.wl;


864  frqObs>_dopplerValid = true;


865  }


866  break;


867  }


868  CurrentObs._obs.push_back(frqObs);


869  }


870  }


871  }


872  if (CurrentObs._obs.size() > 0) {


873  _CurrentObsList.push_back(CurrentObs);


874  }


875  }


876  }


877  else if ((type % 10) < 4) {


878  emit(newMessage(QString("%1: Block %2 contain partial data! Ignored!")


879  .arg(_staID).arg(type).toLatin1(), true));


880  }


881  if (!syncf) {


882  decoded = true;


883  _obsList.append(_CurrentObsList);


884  _CurrentTime.reset();


885  _CurrentObsList.clear();


886  }


887  return decoded;


888  }


889 


890  //


891  ////////////////////////////////////////////////////////////////////////////


892  bool RTCM3Decoder::DecodeRTCM3GLONASS(unsigned char* data, int size) {


893  bool decoded = false;


894  bncTime CurrentObsTime;


895  int i, numsats, syncf, type;


896  uint64_t numbits = 0, bitfield = 0;


897 


898  data += 3; /* header */


899  size = 6; /* header + crc */


900 


901  GETBITS(type, 12)


902  SKIPBITS(12)


903  /* id */


904  GETBITS(i, 27)


905  /* tk */


906 


907  CurrentObsTime.setTk(i);


908  if (_CurrentTime.valid() && CurrentObsTime != _CurrentTime) {


909  decoded = true;


910  _obsList.append(_CurrentObsList);


911  _CurrentObsList.clear();


912  }


913  _CurrentTime = CurrentObsTime;


914 


915  GETBITS(syncf, 1)


916  /* sync */


917  GETBITS(numsats, 5)


918  SKIPBITS(4)


919  /* smind, smint */


920 


921  while (numsats) {


922  int sv, code, l1range, amb = 0, freq;


923  t_satObs CurrentObs;


924  CurrentObs._time = CurrentObsTime;


925 


926  GETBITS(sv, 6)


927  CurrentObs._prn.set('R', sv);


928  GETBITS(code, 1)


929  GETBITS(freq, 5)


930  GLOFreq[sv  1] = 100 + freq  7; /* store frequency for other users (MSM) */


931 


932  t_frqObs *frqObs = new t_frqObs;


933  /* L1 */


934  (code) ?


935  frqObs>_rnxType2ch.assign("1P") : frqObs>_rnxType2ch.assign("1C");


936  GETBITS(l1range, 25);


937  GETBITSSIGN(i, 20);


938  if ((i & ((1 << 20)  1)) != 0x80000) {


939  frqObs>_code = l1range * 0.02;


940  frqObs>_phase = (l1range * 0.02 + i * 0.0005)


941  / GLO_WAVELENGTH_L1(freq  7);


942  frqObs>_codeValid = frqObs>_phaseValid = true;


943  }


944  GETBITS(i, 7);


945  frqObs>_lockTime = lti2sec(type,i);


946  frqObs>_lockTimeValid = (frqObs>_lockTime >= 0.0 && frqObs>_phaseValid);


947  frqObs>_slipCounter = i;


948  if (type == 1010  type == 1012) {


949  GETBITS(amb, 7);


950  if (amb) {


951  frqObs>_code += amb * 599584.916;


952  frqObs>_phase += (amb * 599584.916) / GLO_WAVELENGTH_L1(freq  7);


953  }


954  GETBITS(i, 8);


955  if (i) {


956  frqObs>_snr = i * 0.25;


957  frqObs>_snrValid = true;


958  }


959  }


960  CurrentObs._obs.push_back(frqObs);


961  if (type == 1011  type == 1012) {


962  frqObs = new t_frqObs;


963  /* L2 */


964  GETBITS(code, 2);


965  switch (code) {


966  case 3:


967  frqObs>_rnxType2ch.assign("2P");


968  break;


969  case 2:


970  frqObs>_rnxType2ch.assign("2P");


971  break;


972  case 1:


973  frqObs>_rnxType2ch.assign("2P");


974  break;


975  case 0:


976  frqObs>_rnxType2ch.assign("2C");


977  break;


978  }


979  GETBITSSIGN(i, 14);


980  if ((i & ((1 << 14)  1)) != 0x2000) {


981  frqObs>_code = l1range * 0.02 + i * 0.02 + amb * 599584.916;


982  frqObs>_codeValid = true;


983  }


984  GETBITSSIGN(i, 20);


985  if ((i & ((1 << 20)  1)) != 0x80000) {


986  frqObs>_phase = (l1range * 0.02 + i * 0.0005 + amb * 599584.916)


987  / GLO_WAVELENGTH_L2(freq  7);


988  frqObs>_phaseValid = true;


989  }


990  GETBITS(i, 7);


991  frqObs>_lockTime = lti2sec(type,i);


992  frqObs>_lockTimeValid = (frqObs>_lockTime >= 0.0 && frqObs>_phaseValid);


993  frqObs>_slipCounter = i;


994  if (type == 1012) {


995  GETBITS(i, 8);


996  if (i) {


997  frqObs>_snr = i * 0.25;


998  frqObs>_snrValid = true;


999  }


1000  }


1001  CurrentObs._obs.push_back(frqObs);


1002  }


1003  _CurrentObsList.push_back(CurrentObs);


1004  }


1005  if (!syncf) {


1006  decoded = true;


1007  _obsList.append(_CurrentObsList);


1008  _CurrentTime.reset();


1009  _CurrentObsList.clear();


1010  }


1011  return decoded;


1012  }


1013 


1014  //


1015  ////////////////////////////////////////////////////////////////////////////


1016  bool RTCM3Decoder::DecodeGPSEphemeris(unsigned char* data, int size) {


1017  bool decoded = false;


1018 


1019  if (size == 67) {


1020  t_ephGPS eph;


1021  int i, week;


1022  uint64_t numbits = 0, bitfield = 0;


1023  int fitIntervalFalg = 0;


1024 


1025  data += 3; /* header */


1026  size = 6; /* header + crc */


1027  SKIPBITS(12)


1028 


1029  eph._receptDateTime = currentDateAndTimeGPS();


1030 


1031  GETBITS(i, 6)


1032  eph._prn.set('G', i);


1033  GETBITS(week, 10)


1034  GETBITS(i, 4)


1035  eph._ura = accuracyFromIndex(i, eph.type());


1036  GETBITS(eph._L2Codes, 2)


1037  GETFLOATSIGN(eph._IDOT, 14, R2R_PI/(double)(1<<30)/(double)(1<<13))


1038  GETBITS(eph._IODE, 8)


1039  GETBITS(i, 16)


1040  i <<= 4;


1041  eph._TOC.set(i * 1000);


1042  GETFLOATSIGN(eph._clock_driftrate, 8, 1.0 / (double )(1 << 30) / (double )(1 << 25))


1043  GETFLOATSIGN(eph._clock_drift, 16, 1.0 / (double )(1 << 30) / (double )(1 << 13))


1044  GETFLOATSIGN(eph._clock_bias, 22, 1.0 / (double )(1 << 30) / (double )(1 << 1))


1045  GETBITS(eph._IODC, 10)


1046  GETFLOATSIGN(eph._Crs, 16, 1.0 / (double )(1 << 5))


1047  GETFLOATSIGN(eph._Delta_n, 16, R2R_PI/(double)(1<<30)/(double)(1<<13))


1048  GETFLOATSIGN(eph._M0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1049  GETFLOATSIGN(eph._Cuc, 16, 1.0 / (double )(1 << 29))


1050  GETFLOAT(eph._e, 32, 1.0 / (double )(1 << 30) / (double )(1 << 3))


1051  GETFLOATSIGN(eph._Cus, 16, 1.0 / (double )(1 << 29))


1052  GETFLOAT(eph._sqrt_A, 32, 1.0 / (double )(1 << 19))


1053  GETBITS(i, 16)


1054  i <<= 4;


1055  eph._TOEsec = i;


1056  bncTime t;


1057  t.set(i * 1000);


1058  eph._TOEweek = t.gpsw();


1059  int numOfRollOvers = int(floor(t.gpsw()/1024.0));


1060  week += (numOfRollOvers * 1024);


1061  /* week from HOW, differs from TOC, TOE week, we use adapted value instead */


1062  if (eph._TOEweek > week + 1  eph._TOEweek < week  1) /* invalid week */


1063  return false;


1064  GETFLOATSIGN(eph._Cic, 16, 1.0 / (double )(1 << 29))


1065  GETFLOATSIGN(eph._OMEGA0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1066  GETFLOATSIGN(eph._Cis, 16, 1.0 / (double )(1 << 29))


1067  GETFLOATSIGN(eph._i0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1068  GETFLOATSIGN(eph._Crc, 16, 1.0 / (double )(1 << 5))


1069  GETFLOATSIGN(eph._omega, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1070  GETFLOATSIGN(eph._OMEGADOT, 24, R2R_PI/(double)(1<<30)/(double)(1<<13))


1071  GETFLOATSIGN(eph._TGD, 8, 1.0 / (double )(1 << 30) / (double )(1 << 1))


1072  GETBITS(eph._health, 6)


1073  GETBITS(eph._L2PFlag, 1)


1074  GETBITS(fitIntervalFalg, 1)


1075  eph._fitInterval = fitIntervalFromFlag(fitIntervalFalg, eph._IODC, eph.type());


1076  eph._TOT = 0.9999e9;


1077 


1078  emit newGPSEph(eph);


1079  decoded = true;


1080  }


1081  return decoded;


1082  }


1083 


1084  //


1085  ////////////////////////////////////////////////////////////////////////////


1086  bool RTCM3Decoder::DecodeGLONASSEphemeris(unsigned char* data, int size) {


1087  bool decoded = false;


1088 


1089  if (size == 51) {


1090  t_ephGlo eph;


1091  int sv, i, tk;


1092  uint64_t numbits = 0, bitfield = 0;


1093 


1094  data += 3; /* header */


1095  size = 6; /* header + crc */


1096  SKIPBITS(12)


1097 


1098  eph._receptDateTime = currentDateAndTimeGPS();


1099 


1100  GETBITS(sv, 6)


1101  eph._prn.set('R', sv);


1102 


1103  GETBITS(i, 5)


1104  eph._frequency_number = i  7;


1105  GETBITS(eph._almanac_health, 1) /* almanac healthy */


1106  GETBITS(eph._almanac_health_availablility_indicator, 1) /* almanac health ok */


1107  GETBITS(eph._P1, 2) /* P1 */


1108  GETBITS(i, 5)


1109  tk = i * 60 * 60;


1110  GETBITS(i, 6)


1111  tk += i * 60;


1112  GETBITS(i, 1)


1113  tk += i * 30;


1114  eph._tki = tk  3*60*60;


1115  if(eph._tki < 0.0) {


1116  eph._tki += 86400.0;


1117  }


1118  GETBITS(eph._health, 1) /* MSB of Bn*/


1119  GETBITS(eph._P2, 1) /* P2 */


1120  GETBITS(i, 7)


1121  eph._TOC.setTk(i * 15 * 60 * 1000); /* tb */


1122 


1123  GETFLOATSIGNM(eph._x_velocity, 24, 1.0 / (double )(1 << 20))


1124  GETFLOATSIGNM(eph._x_pos, 27, 1.0 / (double )(1 << 11))


1125  GETFLOATSIGNM(eph._x_acceleration, 5, 1.0 / (double )(1 << 30))


1126  GETFLOATSIGNM(eph._y_velocity, 24, 1.0 / (double )(1 << 20))


1127  GETFLOATSIGNM(eph._y_pos, 27, 1.0 / (double )(1 << 11))


1128  GETFLOATSIGNM(eph._y_acceleration, 5, 1.0 / (double )(1 << 30))


1129  GETFLOATSIGNM(eph._z_velocity, 24, 1.0 / (double )(1 << 20))


1130  GETFLOATSIGNM(eph._z_pos, 27, 1.0 / (double )(1 << 11))


1131  GETFLOATSIGNM(eph._z_acceleration, 5, 1.0 / (double )(1 << 30))


1132  GETBITS(eph._P3, 1) /* P3 */


1133  GETFLOATSIGNM(eph._gamma, 11, 1.0 / (double )(1 << 30) / (double )(1 << 10))


1134  GETBITS(eph._M_P, 2) /* GLONASSM P, */


1135  GETBITS(eph._M_l3, 1) /*GLONASSM ln (third string) */


1136  GETFLOATSIGNM(eph._tau, 22, 1.0 / (double )(1 << 30)) /* GLONASS tau n(tb) */


1137  GETFLOATSIGNM(eph._M_delta_tau, 5, 1.0 / (double )(1 << 30)) /* GLONASSM delta tau n(tb) */


1138  GETBITS(eph._E, 5)


1139  GETBITS(eph._M_P4, 1) /* GLONASSM P4 */


1140  GETBITS(eph._M_FT, 4) /* GLONASSM Ft */


1141  GETBITS(eph._M_NT, 11) /* GLONASSM Nt */


1142  GETBITS(eph._M_M, 2) /* GLONASSM M */


1143  GETBITS(eph._additional_data_availability, 1) /* GLONASSM The Availability of Additional Data */


1144  GETBITS(eph._NA, 11) /* GLONASSM Na */


1145  GETFLOATSIGNM(eph._tauC, 32, 1.0/(double)(1<<30)/(double)(1<<1)) /* GLONASS tau c */


1146  GETBITS(eph._M_N4, 5) /* GLONASSM N4 */


1147  GETFLOATSIGNM(eph._M_tau_GPS, 22, 1.0/(double)(1<<30)) /* GLONASSM tau GPS */


1148  GETBITS(eph._M_l5, 1) /* GLONASSM ln (fifth string) */


1149 


1150  unsigned year, month, day;


1151  eph._TOC.civil_date(year, month, day);


1152  eph._gps_utc = gnumleap(year, month, day);


1153  eph._tt = eph._TOC;


1154 


1155  eph._xv(1) = eph._x_pos * 1.e3;


1156  eph._xv(2) = eph._y_pos * 1.e3;


1157  eph._xv(3) = eph._z_pos * 1.e3;


1158  eph._xv(4) = eph._x_velocity * 1.e3;


1159  eph._xv(5) = eph._y_velocity * 1.e3;


1160  eph._xv(6) = eph._z_velocity * 1.e3;


1161 


1162  GLOFreq[sv  1] = 100 + eph._frequency_number ; /* store frequency for other users (MSM) */


1163  _gloFrq = QString("%1 %2").arg(eph._prn.toString().c_str()).arg(eph._frequency_number, 2, 'f', 0);


1164 


1165  emit newGlonassEph(eph);


1166  decoded = true;


1167  }


1168  return decoded;


1169  }


1170 


1171  //


1172  ////////////////////////////////////////////////////////////////////////////


1173  bool RTCM3Decoder::DecodeQZSSEphemeris(unsigned char* data, int size) {


1174  bool decoded = false;


1175 


1176  if (size == 67) {


1177  t_ephGPS eph;


1178  int i, week;


1179  uint64_t numbits = 0, bitfield = 0;


1180  int fitIntervalFalg = 0;


1181 


1182  data += 3; /* header */


1183  size = 6; /* header + crc */


1184  SKIPBITS(12)


1185 


1186  eph._receptDateTime = currentDateAndTimeGPS();


1187 


1188  GETBITS(i, 4)


1189  eph._prn.set('J', i);


1190 


1191  GETBITS(i, 16)


1192  i <<= 4;


1193  eph._TOC.set(i * 1000);


1194 


1195  GETFLOATSIGN(eph._clock_driftrate, 8, 1.0 / (double )(1 << 30) / (double )(1 << 25))


1196  GETFLOATSIGN(eph._clock_drift, 16, 1.0 / (double )(1 << 30) / (double )(1 << 13))


1197  GETFLOATSIGN(eph._clock_bias, 22, 1.0 / (double )(1 << 30) / (double )(1 << 1))


1198  GETBITS(eph._IODE, 8)


1199  GETFLOATSIGN(eph._Crs, 16, 1.0 / (double )(1 << 5))


1200  GETFLOATSIGN(eph._Delta_n, 16, R2R_PI/(double)(1<<30)/(double)(1<<13))


1201  GETFLOATSIGN(eph._M0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1202  GETFLOATSIGN(eph._Cuc, 16, 1.0 / (double )(1 << 29))


1203  GETFLOAT(eph._e, 32, 1.0 / (double )(1 << 30) / (double )(1 << 3))


1204  GETFLOATSIGN(eph._Cus, 16, 1.0 / (double )(1 << 29))


1205  GETFLOAT(eph._sqrt_A, 32, 1.0 / (double )(1 << 19))


1206  GETBITS(i, 16)


1207  i <<= 4;


1208  eph._TOEsec = i;


1209  bncTime t;


1210  t.set(i*1000);


1211  eph._TOEweek = t.gpsw();


1212  GETFLOATSIGN(eph._Cic, 16, 1.0 / (double )(1 << 29))


1213  GETFLOATSIGN(eph._OMEGA0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1214  GETFLOATSIGN(eph._Cis, 16, 1.0 / (double )(1 << 29))


1215  GETFLOATSIGN(eph._i0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1216  GETFLOATSIGN(eph._Crc, 16, 1.0 / (double )(1 << 5))


1217  GETFLOATSIGN(eph._omega, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1218  GETFLOATSIGN(eph._OMEGADOT, 24, R2R_PI/(double)(1<<30)/(double)(1<<13))


1219  GETFLOATSIGN(eph._IDOT, 14, R2R_PI/(double)(1<<30)/(double)(1<<13))


1220  GETBITS(eph._L2Codes, 2)


1221  GETBITS(week, 10)


1222  int numOfRollOvers = int(floor(t.gpsw()/1024.0));


1223  week += (numOfRollOvers * 1024);


1224  /* week from HOW, differs from TOC, TOE week, we use adapted value instead */


1225  if (eph._TOEweek > week + 1  eph._TOEweek < week  1) /* invalid week */


1226  return false;


1227 


1228  GETBITS(i, 4)


1229  if (i <= 6)


1230  eph._ura = ceil(10.0 * pow(2.0, 1.0 + i / 2.0)) / 10.0;


1231  else


1232  eph._ura = ceil(10.0 * pow(2.0, i / 2.0)) / 10.0;


1233  GETBITS(eph._health, 6)


1234  GETFLOATSIGN(eph._TGD, 8, 1.0 / (double )(1 << 30) / (double )(1 << 1))


1235  GETBITS(eph._IODC, 10)


1236  GETBITS(fitIntervalFalg, 1)


1237  eph._fitInterval = fitIntervalFromFlag(fitIntervalFalg, eph._IODC, eph.type());


1238  eph._TOT = 0.9999e9;


1239 


1240  emit newGPSEph(eph);


1241  decoded = true;


1242  }


1243  return decoded;


1244  }


1245 


1246  //


1247  ////////////////////////////////////////////////////////////////////////////


1248  bool RTCM3Decoder::DecodeIRNSSEphemeris(unsigned char* data, int size) {


1249  bool decoded = false;


1250 


1251  if (size == 67) {


1252  t_ephGPS eph;


1253  int i, week, L5Flag, SFlag;


1254  uint64_t numbits = 0, bitfield = 0;


1255 


1256  data += 3; /* header */


1257  size = 6; /* header + crc */


1258  SKIPBITS(12)


1259 


1260  eph._receptDateTime = currentDateAndTimeGPS();


1261 


1262  GETBITS(i, 6)


1263  eph._prn.set('I', i);


1264  GETBITS(week, 10)


1265  GETFLOATSIGN(eph._clock_bias, 22, 1.0 / (double )(1 << 30) / (double )(1 << 1))


1266  GETFLOATSIGN(eph._clock_drift, 16, 1.0 / (double )(1 << 30) / (double )(1 << 13))


1267  GETFLOATSIGN(eph._clock_driftrate, 8, 1.0 / (double )(1 << 30) / (double )(1 << 25))


1268  GETBITS(i, 4)


1269  eph._ura = accuracyFromIndex(i, eph.type());


1270  GETBITS(i, 16)


1271  i <<= 4;


1272  eph._TOC.set(i * 1000);


1273  GETFLOATSIGN(eph._TGD, 8, 1.0 / (double )(1 << 30) / (double )(1 << 1))


1274  GETFLOATSIGN(eph._Delta_n, 22, R2R_PI/(double)(1<<30)/(double)(1 << 11))


1275  // IODCE


1276  GETBITS(eph._IODE, 8)


1277  eph._IODC = eph._IODE;


1278  SKIPBITS(10)


1279  GETBITS(L5Flag, 1)


1280  GETBITS(SFlag, 1)


1281  if (L5Flag == 0 && SFlag == 0) {


1282  eph._health = 0.0;


1283  }


1284  else if (L5Flag == 0 && SFlag == 1) {


1285  eph._health = 1.0;


1286  }


1287  else if (L5Flag == 1 && SFlag == 0) {


1288  eph._health = 2.0;


1289  }


1290  else if (L5Flag == 1 && SFlag == 1) {


1291  eph._health = 3.0;


1292  }


1293  GETFLOATSIGN(eph._Cuc, 15, 1.0 / (double )(1 << 28))


1294  GETFLOATSIGN(eph._Cus, 15, 1.0 / (double )(1 << 28))


1295  GETFLOATSIGN(eph._Cic, 15, 1.0 / (double )(1 << 28))


1296  GETFLOATSIGN(eph._Cis, 15, 1.0 / (double )(1 << 28))


1297  GETFLOATSIGN(eph._Crc, 15, 1.0 / (double )(1 << 4))


1298  GETFLOATSIGN(eph._Crs, 15, 1.0 / (double )(1 << 4))


1299  GETFLOATSIGN(eph._IDOT, 14, R2R_PI/(double)(1<<30)/(double)(1<<13))


1300  GETFLOATSIGN(eph._M0, 32, R2R_PI/(double)(1<<30)/(double)(1<< 1))


1301  GETBITS(i, 16)


1302  i <<= 4;


1303  eph._TOEsec = i;


1304  bncTime t;


1305  t.set(i * 1000);


1306  eph._TOEweek = t.gpsw();


1307  int numOfRollOvers = int(floor(t.gpsw()/1024.0));


1308  week += (numOfRollOvers * 1024);


1309  /* week from HOW, differs from TOC, TOE week, we use adapted value instead */


1310  if (eph._TOEweek > week + 1  eph._TOEweek < week  1) /* invalid week */


1311  return false;


1312  GETFLOAT(eph._e, 32, 1.0 / (double )(1 << 30) / (double )(1 << 3))


1313  GETFLOAT(eph._sqrt_A, 32, 1.0 / (double )(1 << 19))


1314  GETFLOATSIGN(eph._OMEGA0, 32, R2R_PI/(double)(1<<30)/(double)(1<< 1))


1315  GETFLOATSIGN(eph._omega, 32, R2R_PI/(double)(1<<30)/(double)(1<< 1))


1316  GETFLOATSIGN(eph._OMEGADOT, 22, R2R_PI/(double)(1<<30)/(double)(1<<11))


1317  GETFLOATSIGN(eph._i0, 32, R2R_PI/(double)(1<<30)/(double)(1<< 1))


1318  SKIPBITS(2)


1319  SKIPBITS(2)


1320  eph._TOT = 0.9999e9;


1321 


1322  emit newGPSEph(eph);


1323  decoded = true;


1324  }


1325  return decoded;


1326  }


1327 


1328  //


1329  ////////////////////////////////////////////////////////////////////////////


1330  bool RTCM3Decoder::DecodeSBASEphemeris(unsigned char* data, int size) {


1331  bool decoded = false;


1332 


1333  if (size == 35) {


1334  t_ephSBAS eph;


1335  int i;


1336  uint64_t numbits = 0, bitfield = 0;


1337 


1338  data += 3; /* header */


1339  size = 6; /* header + crc */


1340  SKIPBITS(12)


1341 


1342  eph._receptDateTime = currentDateAndTimeGPS();


1343 


1344  GETBITS(i, 6)


1345  eph._prn.set('S', 20 + i);


1346  GETBITS(eph._IODN, 8)


1347  GETBITS(i, 13)


1348  i <<= 4;


1349  eph._TOC.setTOD(i * 1000);


1350  GETBITS(i, 4)


1351  eph._ura = accuracyFromIndex(i, eph.type());


1352  GETFLOATSIGN(eph._x_pos, 30, 0.08)


1353  GETFLOATSIGN(eph._y_pos, 30, 0.08)


1354  GETFLOATSIGN(eph._z_pos, 25, 0.4)


1355  GETFLOATSIGN(eph._x_velocity, 17, 0.000625)


1356  GETFLOATSIGN(eph._y_velocity, 17, 0.000625)


1357  GETFLOATSIGN(eph._z_velocity, 18, 0.004)


1358  GETFLOATSIGN(eph._x_acceleration, 10, 0.0000125)


1359  GETFLOATSIGN(eph._y_acceleration, 10, 0.0000125)


1360  GETFLOATSIGN(eph._z_acceleration, 10, 0.0000625)


1361  GETFLOATSIGN(eph._agf0, 12, 1.0 / (1 << 30) / (1 << 1))


1362  GETFLOATSIGN(eph._agf1, 8, 1.0 / (1 << 30) / (1 << 10))


1363 


1364  eph._TOT = 0.9999E9;


1365  eph._health = 0;


1366 


1367  emit newSBASEph(eph);


1368  decoded = true;


1369  }


1370  return decoded;


1371  }


1372 


1373  //


1374  ////////////////////////////////////////////////////////////////////////////


1375  bool RTCM3Decoder::DecodeGalileoEphemeris(unsigned char* data, int size) {


1376  bool decoded = false;


1377  uint64_t numbits = 0, bitfield = 0;


1378  int i;


1379 


1380  data += 3; /* header */


1381  size = 6; /* header + crc */


1382  GETBITS(i, 12)


1383 


1384  if ((i == 1046 && size == 61)  (i == 1045 && size == 60)) {


1385  t_ephGal eph;


1386 


1387  eph._receptDateTime = currentDateAndTimeGPS();


1388 


1389  eph._inav = (i == 1046);


1390  eph._fnav = (i == 1045);


1391  GETBITS(i, 6)


1392  eph._prn.set('E', i, eph._inav ? 1 : 0);


1393 


1394  GETBITS(eph._TOEweek, 12) //FIXME: rollover after week 4095!!


1395  GETBITS(eph._IODnav, 10)


1396  GETBITS(i, 8)


1397  eph._SISA = accuracyFromIndex(i, eph.type());


1398  GETFLOATSIGN(eph._IDOT, 14, R2R_PI/(double)(1<<30)/(double)(1<<13))


1399  GETBITSFACTOR(i, 14, 60)


1400  eph._TOC.set(1024 + eph._TOEweek, i);


1401  GETFLOATSIGN(eph._clock_driftrate, 6, 1.0 / (double )(1 << 30) / (double )(1 << 29))


1402  GETFLOATSIGN(eph._clock_drift, 21, 1.0 / (double )(1 << 30) / (double )(1 << 16))


1403  GETFLOATSIGN(eph._clock_bias, 31, 1.0 / (double )(1 << 30) / (double )(1 << 4))


1404  GETFLOATSIGN(eph._Crs, 16, 1.0 / (double )(1 << 5))


1405  GETFLOATSIGN(eph._Delta_n, 16, R2R_PI/(double)(1<<30)/(double)(1<<13))


1406  GETFLOATSIGN(eph._M0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1407  GETFLOATSIGN(eph._Cuc, 16, 1.0 / (double )(1 << 29))


1408  GETFLOAT(eph._e, 32, 1.0 / (double )(1 << 30) / (double )(1 << 3))


1409  GETFLOATSIGN(eph._Cus, 16, 1.0 / (double )(1 << 29))


1410  GETFLOAT(eph._sqrt_A, 32, 1.0 / (double )(1 << 19))


1411  GETBITSFACTOR(eph._TOEsec, 14, 60)


1412  /* FIXME: overwrite value, copied from old code */


1413  eph._TOEsec = eph._TOC.gpssec();


1414  GETFLOATSIGN(eph._Cic, 16, 1.0 / (double )(1 << 29))


1415  GETFLOATSIGN(eph._OMEGA0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1416  GETFLOATSIGN(eph._Cis, 16, 1.0 / (double )(1 << 29))


1417  GETFLOATSIGN(eph._i0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1418  GETFLOATSIGN(eph._Crc, 16, 1.0 / (double )(1 << 5))


1419  GETFLOATSIGN(eph._omega, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1420  GETFLOATSIGN(eph._OMEGADOT, 24, R2R_PI/(double)(1<<30)/(double)(1<<13))


1421  GETFLOATSIGN(eph._BGD_1_5A, 10, 1.0 / (double )(1 << 30) / (double )(1 << 2))


1422  if (eph._inav) {


1423  /* set unused F/NAV values */


1424  eph._E5aHS = 0.0;


1425  eph._e5aDataInValid = false;


1426 


1427  GETFLOATSIGN(eph._BGD_1_5B, 10, 1.0 / (double )(1 << 30) / (double )(1 << 2))


1428  GETBITS(eph._E5bHS, 2)


1429  GETBITS(eph._e5bDataInValid, 1)


1430  GETBITS(eph._E1_bHS, 2)


1431  GETBITS(eph._e1DataInValid, 1)


1432  }


1433  else {


1434  /* set unused I/NAV values */


1435  eph._BGD_1_5B = 0.0;


1436  eph._E5bHS = 0.0;


1437  eph._E1_bHS = 0.0;


1438  eph._e1DataInValid = false;


1439  eph._e5bDataInValid = false;


1440 


1441  GETBITS(eph._E5aHS, 2)


1442  GETBITS(eph._e5aDataInValid, 1)


1443  }


1444  eph._TOT = 0.9999e9;


1445 


1446  emit newGalileoEph(eph);


1447  decoded = true;


1448  }


1449  return decoded;


1450  }


1451 


1452  //


1453  ////////////////////////////////////////////////////////////////////////////


1454  bool RTCM3Decoder::DecodeBDSEphemeris(unsigned char* data, int size) {


1455  bool decoded = false;


1456 


1457  if (size == 70) {


1458  t_ephBDS eph;


1459  int i;


1460  uint64_t numbits = 0, bitfield = 0;


1461 


1462  data += 3; /* header */


1463  size = 6; /* header + crc */


1464  SKIPBITS(12)


1465 


1466  eph._receptDateTime = currentDateAndTimeGPS();


1467 


1468  GETBITS(i, 6)


1469  eph._prn.set('C', i);


1470 


1471  SKIPBITS(13)


1472  /* week */


1473  GETBITS(i, 4)


1474  eph._URA = accuracyFromIndex(i, eph.type());


1475  GETFLOATSIGN(eph._IDOT, 14, R2R_PI/(double)(1<<30)/(double)(1<<13))


1476  GETBITS(eph._AODE, 5)


1477  GETBITS(i, 17)


1478  i <<= 3;


1479  eph._TOC.setBDS(i * 1000);


1480  GETFLOATSIGN(eph._clock_driftrate, 11, 1.0 / (double )(1 << 30) / (double )(1 << 30) / (double )(1 << 6))


1481  GETFLOATSIGN(eph._clock_drift, 22, 1.0 / (double )(1 << 30) / (double )(1 << 20))


1482  GETFLOATSIGN(eph._clock_bias, 24, 1.0 / (double )(1 << 30) / (double )(1 << 3))


1483  GETBITS(eph._AODC, 5)


1484  GETFLOATSIGN(eph._Crs, 18, 1.0 / (double )(1 << 6))


1485  GETFLOATSIGN(eph._Delta_n, 16, R2R_PI/(double)(1<<30)/(double)(1<<13))


1486  GETFLOATSIGN(eph._M0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1487  GETFLOATSIGN(eph._Cuc, 18, 1.0 / (double )(1 << 30) / (double )(1 << 1))


1488  GETFLOAT(eph._e, 32, 1.0 / (double )(1 << 30) / (double )(1 << 3))


1489  GETFLOATSIGN(eph._Cus, 18, 1.0 / (double )(1 << 30) / (double )(1 << 1))


1490  GETFLOAT(eph._sqrt_A, 32, 1.0 / (double )(1 << 19))


1491  GETBITS(i, 17)


1492  i <<= 3;


1493  eph._TOEsec = i;


1494  eph._TOE.setBDS(i * 1000);


1495  GETFLOATSIGN(eph._Cic, 18, 1.0 / (double )(1 << 30) / (double )(1 << 1))


1496  GETFLOATSIGN(eph._OMEGA0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1497  GETFLOATSIGN(eph._Cis, 18, 1.0 / (double )(1 << 30) / (double )(1 << 1))


1498  GETFLOATSIGN(eph._i0, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1499  GETFLOATSIGN(eph._Crc, 18, 1.0 / (double )(1 << 6))


1500  GETFLOATSIGN(eph._omega, 32, R2R_PI/(double)(1<<30)/(double)(1<<1))


1501  GETFLOATSIGN(eph._OMEGADOT, 24, R2R_PI/(double)(1<<30)/(double)(1<<13))


1502  GETFLOATSIGN(eph._TGD1, 10, 0.0000000001)


1503  GETFLOATSIGN(eph._TGD2, 10, 0.0000000001)


1504  GETBITS(eph._SatH1, 1)


1505 


1506  eph._TOT = 0.9999E9;


1507  emit newBDSEph(eph);


1508  decoded = true;


1509  }


1510  return decoded;


1511  }


1512 


1513  //


1514  ////////////////////////////////////////////////////////////////////////////


1515  bool RTCM3Decoder::DecodeAntennaReceiver(unsigned char* data, int size) {


1516  char *antenna;


1517  char *antserialnum;


1518  char *receiver;


1519  char *recfirmware;


1520  char *recserialnum;


1521  int type;


1522  int antsernum = 1;


1523  int antnum = 1;


1524  int recnum = 1;


1525  int recsernum = 1;


1526  int recfirnum = 1;


1527  uint64_t numbits = 0, bitfield = 0;


1528 


1529  data += 3; /* header*/


1530  size = 6; /* header + crc */


1531 


1532  GETBITS(type, 12)


1533  SKIPBITS(12) /* reference station ID */


1534  GETSTRING(antnum, antenna)


1535  if ((antnum > 1 && antnum < 265) &&


1536  (_antType.empty()  strncmp(_antType.back().descriptor, antenna, recnum) != 0)) {


1537  _antType.push_back(t_antInfo());


1538  memcpy(_antType.back().descriptor, antenna, antnum);


1539  _antType.back().descriptor[antnum] = 0;


1540  }


1541  SKIPBITS(8) /* antenna setup ID */


1542  if (type == 1008  type == 1033 ) {


1543  GETSTRING(antsernum, antserialnum)


1544  if ((antsernum > 1 && antsernum < 265)) {


1545  memcpy(_antType.back().serialnumber, antserialnum, antsernum);


1546  _antType.back().serialnumber[antsernum] = 0;


1547  }


1548  }


1549 


1550  if (type == 1033) {


1551  GETSTRING(recnum, receiver)


1552  GETSTRING(recfirnum, recfirmware)


1553  GETSTRING(recsernum, recserialnum)


1554  if ((recnum > 1 && recnum < 265) &&


1555  (_recType.empty()  strncmp(_recType.back().descriptor, receiver, recnum) != 0)) {


1556  _recType.push_back(t_recInfo());


1557  memcpy(_recType.back().descriptor, receiver, recnum);


1558  _recType.back().descriptor[recnum] = 0;


1559  if (recfirnum > 1 && recfirnum < 265) {


1560  memcpy(_recType.back().firmware, recfirmware, recfirnum);


1561  _recType.back().firmware[recfirnum] = 0;


1562  }


1563  if (recsernum > 1 && recsernum < 265) {


1564  memcpy(_recType.back().serialnumber, recserialnum, recsernum);


1565  _recType.back().serialnumber[recsernum] = 0;


1566  }


1567  }


1568  }


1569  return true;


1570  }


1571 


1572  //


1573  ////////////////////////////////////////////////////////////////////////////


1574  bool RTCM3Decoder::DecodeAntennaPosition(unsigned char* data, int size) {


1575  int type;


1576  uint64_t numbits = 0, bitfield = 0;


1577  double x, y, z;


1578 


1579  data += 3; /* header */


1580  size = 6; /* header + crc */


1581 


1582  GETBITS(type, 12)


1583  _antList.push_back(t_antRefPoint());


1584  _antList.back().type = t_antRefPoint::ARP;


1585  SKIPBITS(22)


1586  GETBITSSIGN(x, 38)


1587  _antList.back().xx = x * 1e4;


1588  SKIPBITS(2)


1589  GETBITSSIGN(y, 38)


1590  _antList.back().yy = y * 1e4;


1591  SKIPBITS(2)


1592  GETBITSSIGN(z, 38)


1593  _antList.back().zz = z * 1e4;


1594  if (type == 1006)


1595  {


1596  double h;


1597  GETBITS(h, 16)


1598  _antList.back().height = h * 1e4;


1599  _antList.back().height_f = true;


1600  }


1601  _antList.back().message = type;


1602 


1603  return true;


1604  }


1605 


1606  //


1607  ////////////////////////////////////////////////////////////////////////////


1608  t_irc RTCM3Decoder::Decode(char* buffer, int bufLen, vector<string>& errmsg) {


1609  bool decoded = false;


1610 


1611  errmsg.clear();


1612 


1613  while (bufLen && _MessageSize < sizeof(_Message)) {


1614  int l = sizeof(_Message)  _MessageSize;


1615  if (l > bufLen)


1616  l = bufLen;


1617  memcpy(_Message + _MessageSize, buffer, l);


1618  _MessageSize += l;


1619  bufLen = l;


1620  buffer += l;


1621  int id;


1622  while ((id = GetMessage())) {


1623  /* reset station ID for file loading as it can change */


1624  if (_rawFile)


1625  _staID = _rawFile>staID();


1626  /* store the id into the list of loaded blocks */


1627  _typeList.push_back(id);


1628 


1629  /* SSR I+II data handled in another function, already pass the


1630  * extracted data block. That does no harm, as it anyway skip everything


1631  * else. */


1632  if ((id >= 1057 && id <= 1068) 


1633  (id >= 1240 && id <= 1270) 


1634  (id == 4076)) {


1635  RTCM3coDecoder::e_type type = RTCM3coDecoder::RTCMssr;


1636  if (id == 4076) {


1637  type = RTCM3coDecoder::IGSssr;


1638  }


1639  if (!_coDecoders.contains(_staID.toLatin1()))


1640  _coDecoders[_staID.toLatin1()] = new RTCM3coDecoder(_staID, type);


1641  RTCM3coDecoder* coDecoder = _coDecoders[_staID.toLatin1()];


1642  if (coDecoder>Decode(reinterpret_cast<char *>(_Message), _BlockSize,


1643  errmsg) == success) {


1644  decoded = true;


1645  }


1646  }


1647  else if (id >= 1070 && id <= 1229) { /* MSM */


1648  if (DecodeRTCM3MSM(_Message, _BlockSize))


1649  decoded = true;


1650  }


1651  else {


1652  switch (id) {


1653  case 1001:


1654  case 1003:


1655  emit(newMessage(


1656  QString("%1: Block %2 contain partial data! Ignored!")


1657  .arg(_staID).arg(id).toLatin1(), true));


1658  break; /* no use decoding partial data ATM, remove break when data can be used */


1659  case 1002:


1660  case 1004:


1661  if (DecodeRTCM3GPS(_Message, _BlockSize))


1662  decoded = true;


1663  break;


1664  case 1009:


1665  case 1011:


1666  emit(newMessage(


1667  QString("%1: Block %2 contain partial data! Ignored!")


1668  .arg(_staID).arg(id).toLatin1(), true));


1669  break; /* no use decoding partial data ATM, remove break when data can be used */


1670  case 1010:


1671  case 1012:


1672  if (DecodeRTCM3GLONASS(_Message, _BlockSize))


1673  decoded = true;


1674  break;


1675  case 1019:


1676  if (DecodeGPSEphemeris(_Message, _BlockSize))


1677  decoded = true;


1678  break;


1679  case 1020:


1680  if (DecodeGLONASSEphemeris(_Message, _BlockSize))


1681  decoded = true;


1682  break;


1683  case 1043:


1684  if (DecodeSBASEphemeris(_Message, _BlockSize))


1685  decoded = true;


1686  break;


1687  case 1044:


1688  if (DecodeQZSSEphemeris(_Message, _BlockSize))


1689  decoded = true;


1690  break;


1691  case 1041:


1692  if (DecodeIRNSSEphemeris(_Message, _BlockSize))


1693  decoded = true;


1694  break;


1695  case 1045:


1696  case 1046:


1697  if (DecodeGalileoEphemeris(_Message, _BlockSize))


1698  decoded = true;


1699  break;


1700  case 1042:


1701  if (DecodeBDSEphemeris(_Message, _BlockSize))


1702  decoded = true;


1703  break;


1704  case 1007:


1705  case 1008:


1706  case 1033:


1707  DecodeAntennaReceiver(_Message, _BlockSize);


1708  break;


1709  case 1005:


1710  case 1006:


1711  DecodeAntennaPosition(_Message, _BlockSize);


1712  break;


1713  }


1714  }


1715  }


1716  }


1717  return decoded ? success : failure;


1718  }


1719  ;


1720 


1721  //


1722  ////////////////////////////////////////////////////////////////////////////


1723  uint32_t RTCM3Decoder::CRC24(long size, const unsigned char *buf) {


1724  uint32_t crc = 0;


1725  int ii;


1726  while (size) {


1727  crc ^= (*buf++) << (16);


1728  for (ii = 0; ii < 8; ii++) {


1729  crc <<= 1;


1730  if (crc & 0x1000000)


1731  crc ^= 0x01864cfb;


1732  }


1733  }


1734  return crc;


1735  }


1736 


1737  //


1738  ////////////////////////////////////////////////////////////////////////////


1739  int RTCM3Decoder::GetMessage(void) {


1740  unsigned char *m, *e;


1741  int i;


1742 


1743  m = _Message + _SkipBytes;


1744  e = _Message + _MessageSize;


1745  _NeedBytes = _SkipBytes = 0;


1746  while (e  m >= 3) {


1747  if (m[0] == 0xD3) {


1748  _BlockSize = ((m[1] & 3) << 8)  m[2];


1749  if (e  m >= static_cast<int>(_BlockSize + 6)) {


1750  if (static_cast<uint32_t>((m[3 + _BlockSize] << 16)


1751   (m[3 + _BlockSize + 1] << 8)


1752   (m[3 + _BlockSize + 2])) == CRC24(_BlockSize + 3, m)) {


1753  _BlockSize += 6;


1754  _SkipBytes = _BlockSize;


1755  break;


1756  }


1757  else


1758  ++m;


1759  }


1760  else {


1761  _NeedBytes = _BlockSize;


1762  break;


1763  }


1764  }


1765  else


1766  ++m;


1767  }


1768  if (e  m < 3)


1769  _NeedBytes = 3;


1770 


1771  /* copy buffer to front */


1772  i = m  _Message;


1773  if (i && m < e)


1774  memmove(_Message, m, static_cast<size_t>(_MessageSize  i));


1775  _MessageSize = i;


1776 


1777  return !_NeedBytes ? ((_Message[3] << 4)  (_Message[4] >> 4)) : 0;


1778  }


1779 


1780  // Time of Corrections


1781  //////////////////////////////////////////////////////////////////////////////


1782  int RTCM3Decoder::corrGPSEpochTime() const {


1783  return


1784  _coDecoders.size() > 0 ?


1785  _coDecoders.begin().value()>corrGPSEpochTime() : 1;


1786  }

