Changeset 6141 in ntrip


Ignore:
Timestamp:
Sep 13, 2014, 5:08:22 PM (10 years ago)
Author:
mervart
Message:
 
Location:
trunk/BNC/src
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/BNC/src/PPP/pppEphPool.cpp

    r6107 r6141  
    8181/////////////////////////////////////////////////////////////////////////////
    8282void t_pppEphPool::t_satEphPool::putOrbCorrection(t_orbCorr* corr) {
     83  cout << "ORB: " << corr->_prn.toString() << ' ' << corr->IOD() << endl;
    8384  for (unsigned ii = 0; ii < _ephs.size(); ii++) {
    8485    t_eph* eph = _ephs[ii];
    … …  
    8889    }
    8990  }
     91  cout << "wrong" << endl;
    9092  delete corr;
    9193}
    … …  
    9496/////////////////////////////////////////////////////////////////////////////
    9597void t_pppEphPool::t_satEphPool::putClkCorrection(t_clkCorr* corr) {
     98  cout << "CLK: " << corr->_prn.toString() << ' ' << corr->IOD() << ' ' << corr->_dClk << endl;
     99  bool set = false;
    96100  for (unsigned ii = 0; ii < _ephs.size(); ii++) {
    97101    t_eph* eph = _ephs[ii];
    98102    if (eph->IOD() == corr->IOD()) {
    99103      eph->setClkCorr(corr);
     104      set = true;
    100105    }
     106  }
     107  if (!set) {
     108    cout << "wrong" << endl;
    101109  }
    102110  delete corr;
    … …  
    107115t_irc t_pppEphPool::t_satEphPool::getCrd(const bncTime& tt, ColumnVector& xc,
    108116                                           ColumnVector& vv) const {
     117  cout << "getCrd " << endl;
    109118  for (unsigned ii = 0; ii < _ephs.size(); ii++) {
    110119    t_eph* eph = _ephs[ii];
    111120    t_irc irc = eph->getCrd(tt, xc, vv, OPT->useOrbClkCorr());
     121    cout << "getCrd " << eph->prn().toString() << ' ' << irc << endl;
    112122    if (irc == success) {
    113123      if (eph->prn().system() == 'R') {

  • trunk/BNC/src/RTCM3/RTCM3coDecoder.cpp

    r5665 r6141  
    6969    _fileNameSkl = path + staID;
    7070  }
    71   _out      = 0;
    72   _GPSweeks = -1.0;
     71  _out = 0;
    7372
    7473  qRegisterMetaType<bncTime>("bncTime");
    75 
    76   connect(this, SIGNAL(newCorrLine(QString, QString, bncTime)),
    77           BNC_CORE, SLOT(slotNewCorrLine(QString, QString, bncTime)));
     74  qRegisterMetaType< QList<t_orbCorr> >("QList:t_orbCorr");
     75  qRegisterMetaType< QList<t_clkCorr> >("QList:t_clkCorr");
     76
     77  connect(this, SIGNAL(newOrbCorrections(QList<t_orbCorr>)),
     78          BNC_CORE, SLOT(slotNewOrbCorrections(QList<t_orbCorr>)));
     79
     80  connect(this, SIGNAL(newClkCorrections(QList<t_clkCorr>)),
     81          BNC_CORE, SLOT(slotNewClkCorrections(QList<t_clkCorr>)));
    7882
    7983  connect(this, SIGNAL(providerIDChanged(QString)),
    … …  
    99103// Reopen Output File
    100104////////////////////////////////////////////////////////////////////////
    101 void RTCM3coDecoder::reopen(const QString& fileNameSkl, QString& fileName,
    102                             ofstream*& out) {
    103 
    104   if (!fileNameSkl.isEmpty()) {
     105void RTCM3coDecoder::reopen() {
     106
     107  if (!_fileNameSkl.isEmpty()) {
    105108
    106109    bncSettings settings;
    … …  
    111114                                      settings.value("corrIntr").toString());
    112115
    113     QString fileNameHlp = fileNameSkl
     116    QString fileNameHlp = _fileNameSkl
    114117      + QString("%1").arg(datTim.date().dayOfYear(), 3, 10, QChar('0'))
    115118      + hlpStr + datTim.toString(".yyC");
    116119
    117     if (fileName == fileNameHlp) {
     120    if (_fileName == fileNameHlp) {
    118121      return;
    119122    }
    120123    else {
    121       fileName = fileNameHlp;
    122     }
    123 
    124     delete out;
     124      _fileName = fileNameHlp;
     125    }
     126
     127    delete _out;
    125128    if ( Qt::CheckState(settings.value("rnxAppend").toInt()) == Qt::Checked) {
    126       out = new ofstream( fileName.toAscii().data(),
    127                            ios_base::out | ios_base::app );
     129      _out = new ofstream( _fileName.toAscii().data(), ios_base::out | ios_base::app );
    128130    }
    129131    else {
    130       out = new ofstream( fileName.toAscii().data() );
     132      _out = new ofstream( _fileName.toAscii().data() );
    131133    }
    132134  }
    … …  
    170172            _bias.NumberOfSat[CLOCKORBIT_SATGPS] > 0 || _bias.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) ) {
    171173
    172         reopen(_fileNameSkl, _fileName, _out);
     174        reopen();
    173175
    174176        // Guess GPS week and sec using system time
    … …  
    189191            GPSweek -= 1;
    190192          }
    191           _GPSweeks = GPSEpochTime;
     193          _lastTime.set(GPSweek, double(GPSEpochTime));
    192194        }
    193195
    … …  
    223225            }
    224226          }
    225 
    226           _GPSweeks = weekDay * 86400.0 + GPSDaySec;
     227          _lastTime.set(GPSweek, weekDay * 86400.0 + GPSDaySec);
    227228        }
    228229
    229230        checkProviderID();
    230231
    231         QStringList asciiLines = corrsToASCIIlines(GPSweek, _GPSweeks,
    232                                                    _co, &_bias);
    233 
    234         QStringListIterator it(asciiLines);
    235         while (it.hasNext()) {
    236           QString line = it.next();
    237           printLine(line, GPSweek, _GPSweeks);
    238         }
     232        sendResults();
    239233
    240234        retCode = success;
     235
    241236        memset(&_co, 0, sizeof(_co));
    242237        memset(&_bias, 0, sizeof(_bias));
    … …  
    245240  }
    246241
    247   if (retCode != success) {
    248     _GPSweeks = -1.0;
    249   }
    250242  return retCode;
    251243}
    … …  
    253245//
    254246////////////////////////////////////////////////////////////////////////////
    255 void RTCM3coDecoder::printLine(const QString& line, int GPSweek,
    256                                double GPSweeks) {
    257   if (_out) {
    258     *_out << line.toAscii().data() << endl;
    259     _out->flush();
    260   }
    261 
    262   int    currWeek;
    263   double currSec;
    264   currentGPSWeeks(currWeek, currSec);
    265   bncTime currTime(currWeek, currSec);
    266 
    267   bncTime coTime(GPSweek, GPSweeks);
    268 
    269   double dt = currTime - coTime;
    270   const double MAXDT = 10 * 60.0;
    271   if (fabs(dt) > MAXDT) {
    272     emit newMessage("suspicious correction: " + _staID.toAscii() + " "
    273                     + line.toAscii(), false);
    274   }
    275   else {
    276     emit newCorrLine(line, _staID, coTime);
    277   }
    278 }
    279 
    280 //
    281 ////////////////////////////////////////////////////////////////////////////
    282 QStringList RTCM3coDecoder::corrsToASCIIlines(int GPSweek, double GPSweeks,
    283                                               const ClockOrbit& co,
    284                                               const CodeBias* bias) {
    285 
    286   QStringList retLines;
     247void RTCM3coDecoder::sendResults() {
     248
     249  QList<t_orbCorr> orbCorrections;
     250  QList<t_clkCorr> clkCorrections;
    287251
    288252  // Loop over all satellites (GPS and Glonass)
    289253  // ------------------------------------------
    290   if (co.NumberOfSat[CLOCKORBIT_SATGPS] > 0 || co.NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
    291     QString line1;
    292     line1.sprintf("! Orbits/Clocks: %d GPS %d Glonass",
    293                   co.NumberOfSat[CLOCKORBIT_SATGPS], co.NumberOfSat[CLOCKORBIT_SATGLONASS]);
    294     retLines << line1;
    295   }
    296   for (int ii = 0; ii < CLOCKORBIT_NUMGPS+co.NumberOfSat[CLOCKORBIT_SATGLONASS]; ii++) {
     254  for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS + _co.NumberOfSat[CLOCKORBIT_SATGLONASS]; ii++) {
    297255    char sysCh = ' ';
    298     if      (ii < co.NumberOfSat[CLOCKORBIT_SATGPS]) {
     256    if      (ii < _co.NumberOfSat[CLOCKORBIT_SATGPS]) {
    299257      sysCh = 'G';
    300258    }
    … …  
    302260      sysCh = 'R';
    303261    }
    304 
    305     if (sysCh != ' ') {
    306 
    307       QString linePart;
    308       linePart.sprintf("%d %d %d %.1f %c%2.2d",
    309                        co.messageType, co.UpdateInterval, GPSweek, GPSweeks,
    310                        sysCh, co.Sat[ii].ID);
    311 
    312       // Combined message (orbit and clock)
    313       // ----------------------------------
    314       if ( co.messageType == COTYPE_GPSCOMBINED     ||
    315            co.messageType == COTYPE_GLONASSCOMBINED ) {
    316         QString line;
    317         line.sprintf("   %3d"
    318                      "   %8.3f %8.3f %8.3f %8.3f"
    319                      "   %10.5f %10.5f %10.5f %10.5f"
    320                      "   %10.5f",
    321                      co.Sat[ii].IOD,
    322                      co.Sat[ii].Clock.DeltaA0,
    323                      co.Sat[ii].Orbit.DeltaRadial,
    324                      co.Sat[ii].Orbit.DeltaAlongTrack,
    325                      co.Sat[ii].Orbit.DeltaCrossTrack,
    326                      co.Sat[ii].Clock.DeltaA1,
    327                      co.Sat[ii].Orbit.DotDeltaRadial,
    328                      co.Sat[ii].Orbit.DotDeltaAlongTrack,
    329                      co.Sat[ii].Orbit.DotDeltaCrossTrack,
    330                      co.Sat[ii].Clock.DeltaA2);
    331         retLines << linePart+line;
     262    else {
     263      continue;
     264    }
     265
     266    // Orbit correction
     267    // ----------------
     268    if ( _co.messageType == COTYPE_GPSCOMBINED     ||
     269         _co.messageType == COTYPE_GLONASSCOMBINED ||
     270         _co.messageType == COTYPE_GPSORBIT        ||
     271         _co.messageType == COTYPE_GLONASSORBIT    ) {
     272
     273      t_orbCorr orbCorr;
     274      orbCorr._prn.set(sysCh, _co.Sat[ii].ID);
     275      orbCorr._staID    = _staID.toAscii().data();
     276      orbCorr._iod      = _co.Sat[ii].IOD;
     277      orbCorr._time     = _lastTime;
     278      orbCorr._system   = 'R';
     279      orbCorr._xr[0]    = _co.Sat[ii].Orbit.DeltaRadial;
     280      orbCorr._xr[1]    = _co.Sat[ii].Orbit.DeltaAlongTrack;
     281      orbCorr._xr[2]    = _co.Sat[ii].Orbit.DeltaCrossTrack;
     282      orbCorr._dotXr[0] = _co.Sat[ii].Orbit.DotDeltaRadial;
     283      orbCorr._dotXr[1] = _co.Sat[ii].Orbit.DotDeltaAlongTrack;
     284      orbCorr._dotXr[2] = _co.Sat[ii].Orbit.DotDeltaCrossTrack;
     285
     286      orbCorrections.push_back(orbCorr);
     287
     288      _IODs[orbCorr._prn.toString()] = _co.Sat[ii].IOD;
     289    }
     290
     291    if ( _co.messageType == COTYPE_GPSCOMBINED     ||
     292         _co.messageType == COTYPE_GLONASSCOMBINED ||
     293         _co.messageType == COTYPE_GPSCLOCK        ||
     294         _co.messageType == COTYPE_GLONASSCLOCK    ) {
     295
     296      t_clkCorr clkCorr;
     297      clkCorr._prn.set(sysCh, _co.Sat[ii].ID);
     298      clkCorr._staID      = _staID.toAscii().data();
     299      clkCorr._time       = _lastTime;
     300      clkCorr._dClk       = _co.Sat[ii].Clock.DeltaA0,
     301      clkCorr._dotDClk    = _co.Sat[ii].Clock.DeltaA1,
     302      clkCorr._dotDotDClk = _co.Sat[ii].Clock.DeltaA2;
     303      clkCorr._clkPartial = 0.0;
     304
     305      if (_IODs.contains(clkCorr._prn.toString())) {
     306        clkCorr._iod = _IODs[clkCorr._prn.toString()];
     307        clkCorrections.push_back(clkCorr);
    332308      }
    333 
    334       // Orbits only
    335       // -----------
    336       else if ( co.messageType == COTYPE_GPSORBIT     ||
    337                 co.messageType == COTYPE_GLONASSORBIT ) {
    338         QString line;
    339         line.sprintf("   %3d"
    340                      "   %8.3f %8.3f %8.3f"
    341                      "   %10.5f %10.5f %10.5f",
    342                      co.Sat[ii].IOD,
    343                      co.Sat[ii].Orbit.DeltaRadial,
    344                      co.Sat[ii].Orbit.DeltaAlongTrack,
    345                      co.Sat[ii].Orbit.DeltaCrossTrack,
    346                      co.Sat[ii].Orbit.DotDeltaRadial,
    347                      co.Sat[ii].Orbit.DotDeltaAlongTrack,
    348                      co.Sat[ii].Orbit.DotDeltaCrossTrack);
    349         retLines << linePart+line;
    350       }
    351 
    352       // Clocks only
    353       // -----------
    354       else if ( co.messageType == COTYPE_GPSCLOCK     ||
    355                 co.messageType == COTYPE_GLONASSCLOCK ) {
    356         QString line;
    357         line.sprintf("   %8.3f   %10.5f   %10.5f",
    358                      co.Sat[ii].Clock.DeltaA0,
    359                      co.Sat[ii].Clock.DeltaA1,
    360                      co.Sat[ii].Clock.DeltaA2);
    361         retLines << linePart+line;
    362       }
    363 
    364       // User Range Accuracy
    365       // -------------------
    366       else if ( co.messageType == COTYPE_GPSURA     ||
    367                 co.messageType == COTYPE_GLONASSURA ) {
    368         QString line;
    369         line.sprintf("   %f", co.Sat[ii].UserRangeAccuracy);
    370         retLines << linePart+line;
    371       }
    372 
    373       // High-Resolution Clocks
    374       // ----------------------
    375       else if ( co.messageType == COTYPE_GPSHR     ||
    376                 co.messageType == COTYPE_GLONASSHR ) {
    377         QString line;
    378         line.sprintf("   %8.3f", co.Sat[ii].hrclock);
    379         retLines << linePart+line;
    380       }
     309    }
     310
     311    // High-Resolution Clocks
     312    // ----------------------
     313    if ( _co.messageType == COTYPE_GPSHR     ||
     314         _co.messageType == COTYPE_GLONASSHR ) {
    381315    }
    382316  }
    … …  
    384318  // Loop over all satellites (GPS and Glonass)
    385319  // ------------------------------------------
    386   if (bias) {
    387     if (bias->NumberOfSat[CLOCKORBIT_SATGPS] > 0 || bias->NumberOfSat[CLOCKORBIT_SATGLONASS] > 0) {
    388       QString line1;
    389       line1.sprintf("! Biases: %d GPS %d Glonass",
    390                     bias->NumberOfSat[CLOCKORBIT_SATGPS], bias->NumberOfSat[CLOCKORBIT_SATGLONASS]);
    391       retLines << line1;
    392     }
    393     for (int ii = 0; ii < CLOCKORBIT_NUMGPS + bias->NumberOfSat[CLOCKORBIT_SATGLONASS]; ii++) {
    394       char sysCh = ' ';
    395       int messageType;
    396       if      (ii < bias->NumberOfSat[CLOCKORBIT_SATGPS]) {
    397         sysCh = 'G';
    398         messageType = BTYPE_GPS;
    399       }
    400       else if (ii >= CLOCKORBIT_NUMGPS) {
    401         sysCh = 'R';
    402         messageType = BTYPE_GLONASS;
    403       }
    404       if (sysCh != ' ') {
    405         QString line;
    406         line.sprintf("%d %d %d %.1f %c%2.2d %d",
    407                      messageType, bias->UpdateInterval, GPSweek, GPSweeks,
    408                      sysCh, bias->Sat[ii].ID,
    409                      bias->Sat[ii].NumberOfCodeBiases);
    410         for (int jj = 0; jj < bias->Sat[ii].NumberOfCodeBiases; jj++) {
    411           QString hlp;
    412           hlp.sprintf(" %d %8.3f",  bias->Sat[ii].Biases[jj].Type,
    413                       bias->Sat[ii].Biases[jj].Bias);
    414           line += hlp;
    415         }
    416         retLines << line;
    417       }
    418     }
    419   }
    420 
    421   return retLines;
     320  QList<t_satBias> satBiases;
     321  for (unsigned ii = 0; ii < CLOCKORBIT_NUMGPS + _bias.NumberOfSat[CLOCKORBIT_SATGLONASS]; ii++) {
     322    char sysCh = ' ';
     323    if      (ii < _bias.NumberOfSat[CLOCKORBIT_SATGPS]) {
     324      sysCh = 'G';
     325    }
     326    else if (ii >= CLOCKORBIT_NUMGPS) {
     327      sysCh = 'R';
     328    }
     329    else {
     330      continue;
     331    }
     332    t_satBias satBias;
     333    satBias._prn.set(sysCh, _bias.Sat[ii].ID);
     334    satBias._time      = _lastTime;
     335    satBias._nx        = 0;
     336    satBias._jumpCount = 0;
     337    for (unsigned jj = 0; jj < _bias.Sat[ii].NumberOfCodeBiases; jj++) {
     338    }
     339  }
     340
     341  if (orbCorrections.size() > 0) {
     342    emit newOrbCorrections(orbCorrections);
     343  }
     344  if (clkCorrections.size() > 0) {
     345    emit newClkCorrections(clkCorrections);
     346  }
     347  if (_out) {
     348    QListIterator<t_orbCorr> itOrb(orbCorrections);
     349    while (itOrb.hasNext()) {
     350      const t_orbCorr& orbCorr = itOrb.next();
     351      *_out << "O " << orbCorr.toString() << endl;
     352    }
     353    QListIterator<t_clkCorr> itClk(clkCorrections);
     354    while (itClk.hasNext()) {
     355      const t_clkCorr& clkCorr = itClk.next();
     356      *_out << "C " << clkCorr.toString() << endl;
     357    }
     358    _out->flush();
     359  }
    422360}
    423361

  • trunk/BNC/src/RTCM3/RTCM3coDecoder.h

    r5738 r6141  
    2727
    2828#include <fstream>
    29 
    3029#include <QtCore>
    3130#include <QtNetwork>
    32 
    3331#include "GPSDecoder.h"
    3432
    3533extern "C" {
    36 #include "clock_orbit_rtcm.h"
     34# include "clock_orbit_rtcm.h"
    3735}
    3836
    … …  
    4341  virtual ~RTCM3coDecoder();
    4442  virtual t_irc Decode(char* buffer, int bufLen, std::vector<std::string>& errmsg);
    45   virtual int corrGPSEpochTime() const {return (int) _GPSweeks;}
     43  virtual int   corrGPSEpochTime() const {return int(_lastTime.gpssec());}
    4644
    47   static QStringList corrsToASCIIlines(int GPSweek, double GPSweeks,
    48                                        const ClockOrbit& co, const CodeBias* bias);
    49   static void reopen(const QString& fileNameSkl, QString& fileName,
    50                      std::ofstream*& out);
    5145 signals:
    52   void newCorrLine(QString line, QString staID, bncTime coTime);
     46  void newOrbCorrections(QList<t_orbCorr> orbCorr);
     47  void newClkCorrections(QList<t_clkCorr> clkCorr);
     48  void newBiases(QList<t_satBias> biases);
    5349  void newMessage(QByteArray msg, bool showOnScreen);
    5450  void providerIDChanged(QString staID);
    5551
    5652 private:
    57   void printLine(const QString& line, int GPSweek, double GPSweeks);
     53  void sendResults();
     54  void reopen();
    5855  void checkProviderID();
    5956  std::ofstream* _out;
    … …  
    6259  QString        _fileName;
    6360  QByteArray     _buffer;
    64   double         _GPSweeks;
    6561  ClockOrbit     _co;
    6662  CodeBias       _bias;
    6763  int            _providerID[3];
     64  bncTime        _lastTime;
     65  QMap<std::string, unsigned short> _IODs;
    6866};
    6967

  • trunk/BNC/src/bnccore.cpp

    r6051 r6141  
    118118  _userName = _userName.leftJustified(20, ' ', true);
    119119
    120   _corrs = new QMultiMap<bncTime, QString>;
     120  _corrs = new QMultiMap<bncTime, t_clkCorr>;
    121121
    122122  _dateAndTimeGPS = 0;
    … …  
    633633////////////////////////////////////////////////////////////////////////////
    634634void t_bncCore::slotQuit() {
    635   cout << "t_bncCore::slotQuit" << endl;
    636635  delete _caster; _caster = 0;
    637636  qApp->quit();
    … …  
    640639//
    641640////////////////////////////////////////////////////////////////////////////
    642 void t_bncCore::slotNewCorrLine(QString line, QString staID, bncTime coTime) {
    643 
     641void t_bncCore::slotNewOrbCorrections(QList<t_orbCorr> orbCorrections) {
     642  emit newOrbCorrections(orbCorrections);
     643}
     644
     645//
     646////////////////////////////////////////////////////////////////////////////
     647void t_bncCore::slotNewClkCorrections(QList<t_clkCorr> clkCorrections) {
    644648  QMutexLocker locker(&_mutex);
     649
     650  if (clkCorrections.size() == 0) {
     651    return;
     652  }
     653  bncTime coTime = clkCorrections[0]._time;
     654  QString staID(clkCorrections[0]._staID.c_str());
    645655
    646656  // Combination of Corrections
    … …  
    648658#ifdef USE_COMBINATION
    649659  if (_bncComb) {
    650     _bncComb->processCorrLine(staID, line);
     660    _bncComb->processClkCorrections(clkCorrections);
    651661  }
    652662#endif
    … …  
    677687  }
    678688
    679   _corrs->insert(coTime, QString(line + " " + staID));
     689  for (int ii = 0; ii < clkCorrections.size(); ii++) {
     690    _corrs->insert(coTime, clkCorrections[ii]);
     691  }
    680692
    681693  // Dump Corrections
    … …  
    693705////////////////////////////////////////////////////////////////////////////
    694706void t_bncCore::dumpCorrs(bncTime minTime, bncTime maxTime) {
    695   QStringList allCorrs;
    696   QMutableMapIterator<bncTime, QString> it(*_corrs);
     707  QList<t_clkCorr> allCorrs;
     708  QMutableMapIterator<bncTime, t_clkCorr> it(*_corrs);
    697709  while (it.hasNext()) {
    698710    it.next();
    … …  
    709721////////////////////////////////////////////////////////////////////////////
    710722void t_bncCore::dumpCorrs() {
    711   QStringList allCorrs;
    712   QMutableMapIterator<bncTime, QString> it(*_corrs);
     723  QList<t_clkCorr> allCorrs;
     724  QMutableMapIterator<bncTime, t_clkCorr> it(*_corrs);
    713725  while (it.hasNext()) {
    714726    allCorrs << it.next().value();
    … …  
    720732// Dump List of Corrections
    721733////////////////////////////////////////////////////////////////////////////
    722 void t_bncCore::dumpCorrs(const QStringList& allCorrs) {
    723   emit newCorrections(allCorrs);
     734void t_bncCore::dumpCorrs(const QList<t_clkCorr>& allCorrs) {
     735  emit newClkCorrections(allCorrs);
    724736  if (_socketsCorr) {
    725     QListIterator<QString> it(allCorrs);
     737    QListIterator<t_clkCorr> it(allCorrs);
    726738    while (it.hasNext()) {
    727       QString corrLine = it.next() + "\n";
    728    
     739      const t_clkCorr& corr = it.next();
    729740      QMutableListIterator<QTcpSocket*> is(*_socketsCorr);
    730741      while (is.hasNext()) {
    731742        QTcpSocket* sock = is.next();
    732743        if (sock->state() == QAbstractSocket::ConnectedState) {
    733           if (sock->write(corrLine.toAscii()) == -1) {
     744          if (sock->write(corr.toString().c_str()) == -1) {
    734745            delete sock;
    735746            is.remove();

  • trunk/BNC/src/bnccore.h

    r5991 r6141  
    8181  void slotNewGlonassEph(glonassephemeris* glonasseph, const QString& staID);
    8282  void slotNewGalileoEph(galileoephemeris* galileoeph);
    83   void slotNewCorrLine(QString line, QString staID, bncTime coTime);
     83  void slotNewOrbCorrections(QList<t_orbCorr> orbCorr);
     84  void slotNewClkCorrections(QList<t_clkCorr> clkCorr);
    8485  void slotQuit();
    8586
    … …  
    8990  void newEphGlonass(glonassephemeris glonasseph);
    9091  void newEphGalileo(galileoephemeris galileoeph);
    91   void newCorrections(QStringList);
     92  void newOrbCorrections(QList<t_orbCorr> orbCorr);
     93  void newClkCorrections(QList<t_clkCorr> clkCorr);
    9294  void providerIDChanged(QString);
    9395  void newPosition(QByteArray staID, bncTime time, QVector<double> xx);
    … …  
    111113  void dumpCorrs(bncTime minTime, bncTime maxTime);
    112114  void dumpCorrs();
    113   void dumpCorrs(const QStringList& allCorrs);
     115  void dumpCorrs(const QList<t_clkCorr>& allCorrs);
    114116  void messagePrivate(const QByteArray& msg);
    115117  void checkEphemeris(gpsephemeris* oldEph, gpsephemeris* newEph);
    … …  
    147149  QMap<QString, bncTime> _lastCorrDumpTime;
    148150  double              _waitCoTime;
    149   QMultiMap<bncTime, QString>* _corrs;
     151  QMultiMap<bncTime, t_clkCorr>* _corrs;
    150152  QString             _confFileName;
    151153  QDate               _fileDate;

  • trunk/BNC/src/bncephuser.cpp

    r6140 r6141  
    186186}
    187187
    188 //
    189 ////////////////////////////////////////////////////////////////////////////
    190 t_irc t_corr::readLine(const QString& line) {
    191 
    192   if (line[0] == '!') {
    193     return failure;
    194   }
    195 
    196   QTextStream in(line.toAscii());
    197 
    198   in >> messageType;
    199 
    200   if (!relevantMessageType(messageType)) {
    201     return failure;
    202   }
    203 
    204   int     updateInterval;
    205   int     GPSweek;
    206   double  GPSweeks;
    207   in >> updateInterval >> GPSweek >> GPSweeks >> prn;
    208 
    209   if      ( messageType == COTYPE_GPSCOMBINED    ||
    210             messageType == COTYPE_GLONASSCOMBINED ) {
    211     rao.ReSize(3);       rao       = 0.0;
    212     dotRao.ReSize(3);    dotRao    = 0.0;
    213     dClk       = 0.0;
    214     dotDClk    = 0.0;
    215     dotDotDClk = 0.0;
    216     in >> iod
    217        >> dClk       >> rao[0]       >> rao[1]       >> rao[2]
    218        >> dotDClk    >> dotRao[0]    >> dotRao[1]    >> dotRao[2]
    219        >> dotDotDClk;
    220 
    221     dClk       /= t_CST::c;
    222     dotDClk    /= t_CST::c;
    223     dotDotDClk /= t_CST::c;
    224 
    225     tClk.set(GPSweek, GPSweeks);
    226     tRao.set(GPSweek, GPSweeks);
    227   }
    228   else if ( messageType == COTYPE_GPSORBIT    ||
    229             messageType == COTYPE_GLONASSORBIT ) {
    230     rao.ReSize(3);       rao       = 0.0;
    231     dotRao.ReSize(3);    dotRao    = 0.0;
    232     in >> iod
    233        >> rao[0]       >> rao[1]       >> rao[2]
    234        >> dotRao[0]    >> dotRao[1]    >> dotRao[2];
    235 
    236     tRao.set(GPSweek, GPSweeks);
    237 
    238     if (tClk != tRao) {
    239       dClk       = 0.0;
    240       dotDClk    = 0.0;
    241       dotDotDClk = 0.0;
    242       tClk.reset();
    243     }
    244   }
    245   else if ( messageType == COTYPE_GPSCLOCK    ||
    246             messageType == COTYPE_GLONASSCLOCK ) {
    247     dClk       = 0.0;
    248     dotDClk    = 0.0;
    249     dotDotDClk = 0.0;
    250     in >> dClk >> dotDClk >> dotDotDClk;
    251     dClk       /= t_CST::c;
    252     dotDClk    /= t_CST::c;
    253     dotDotDClk /= t_CST::c;
    254 
    255     tClk.set(GPSweek, GPSweeks);
    256   }
    257   else if ( messageType == COTYPE_GPSHR    ||
    258             messageType == COTYPE_GLONASSHR ) {
    259     if (tRao.valid() && tClk.valid()) {
    260       in >> hrClk;
    261       hrClk /= t_CST::c;
    262     }
    263   }
    264 
    265   return success;
    266 }
    267 

  • trunk/BNC/src/bncephuser.h

    r6140 r6141  
    3636#  include "clock_orbit_rtcm.h"
    3737}
    38 
    39 class t_corr {
    40  public:
    41   t_corr() {
    42     rao.ReSize(3);       
    43     dotRao.ReSize(3);   
    44     messageType = 0;
    45     iod         = 0;
    46     dClk        = 0.0;
    47     dotDClk     = 0.0;
    48     dotDotDClk  = 0.0;
    49     hrClk       = 0.0;
    50     rao         = 0.0;
    51     dotRao      = 0.0;
    52     eph         = 0;
    53   }
    54  
    55   ~t_corr() {}
    56 
    57   bool ready() {return tRao.valid() && tClk.valid();}
    58 
    59   static bool relevantMessageType(int msgType) {
    60     return ( msgType == COTYPE_GPSCOMBINED     ||
    61              msgType == COTYPE_GLONASSCOMBINED ||
    62              msgType == COTYPE_GPSORBIT        ||
    63              msgType == COTYPE_GPSCLOCK        ||
    64              msgType == COTYPE_GLONASSORBIT    ||
    65              msgType == COTYPE_GLONASSCLOCK    ||
    66              msgType == COTYPE_GPSHR           ||
    67              msgType == COTYPE_GLONASSHR );
    68   }
    69 
    70   t_irc readLine(const QString& line);
    71 
    72   int          messageType;
    73   QString      prn;
    74   bncTime      tClk;
    75   bncTime      tRao;
    76   int          iod;
    77   double       dClk;
    78   double       dotDClk;
    79   double       dotDotDClk;
    80   double       hrClk;
    81   ColumnVector rao;
    82   ColumnVector dotRao;
    83   const t_eph* eph;
    84 };
    8538
    8639class bncEphUser : public QObject {

  • trunk/BNC/src/combination/bnccomb.h

    r5861 r6141  
    66#include <newmat.h>
    77#include "bncephuser.h"
     8#include "satObs.h"
    89
    910class bncRtnetDecoder;
    … …  
    3536  bncComb();
    3637  virtual ~bncComb();
    37   void processCorrLine(const QString& staID, const QString& line);
     38  void processOrbCorrections(const QList<t_orbCorr>& orbCorrections);
     39  void processClkCorrections(const QList<t_clkCorr>& clkCorrections);
    3840  int  nStreams() const {return _ACs.size();}
    3941
    … …  
    6264  };
    6365
    64   class cmbCorr : public t_corr {
     66  class cmbCorr : public t_clkCorr {
    6567   public:
    6668    QString      acName;
    6769    ColumnVector diffRao;
    68     QString ID() {return acName + "_" + prn;}
     70    QString ID() {return acName + "_" + QString(_prn.toString().c_str());}
    6971  };
    7072
    … …  
    8385  void processEpoch();
    8486  t_irc processEpoch_filter(QTextStream& out,
    85                             QMap<QString, t_corr*>& resCorr,
     87                            QMap<QString, t_clkCorr*>& resCorr,
    8688                            ColumnVector& dx);
    8789  t_irc processEpoch_singleEpoch(QTextStream& out,
    88                                  QMap<QString, t_corr*>& resCorr,
     90                                 QMap<QString, t_clkCorr*>& resCorr,
    8991                                 ColumnVector& dx);
    9092  t_irc createAmat(Matrix& AA, ColumnVector& ll, DiagonalMatrix& PP,
    91                    const ColumnVector& x0, QMap<QString, t_corr*>& resCorr);
    92   void dumpResults(const QMap<QString, t_corr*>& resCorr);
    93   void printResults(QTextStream& out, const QMap<QString, t_corr*>& resCorr);
    94   void switchToLastEph(const t_eph* lastEph, t_corr* corr);
     93                   const ColumnVector& x0, QMap<QString, t_clkCorr*>& resCorr);
     94  void dumpResults(const QMap<QString, t_clkCorr*>& resCorr);
     95  void printResults(QTextStream& out, const QMap<QString, t_clkCorr*>& resCorr);
     96  void switchToLastEph(const t_eph* lastEph, t_clkCorr* corr);
    9597  t_irc checkOrbits(QTextStream& out);
    9698

  • trunk/BNC/src/ephemeris.cpp

    r6109 r6141  
    1212#include "bnccore.h"
    1313#include "bncutils.h"
     14#include "satObs.h"
    1415#include "pppInclude.h"
    1516
    … …  
    2627//
    2728////////////////////////////////////////////////////////////////////////////
    28 void t_eph::setOrbCorr(const BNC_PPP::t_orbCorr* orbCorr) {
     29void t_eph::setOrbCorr(const t_orbCorr* orbCorr) {
    2930  delete _orbCorr;
    30   _orbCorr = new BNC_PPP::t_orbCorr(*orbCorr);
     31  _orbCorr = new t_orbCorr(*orbCorr);
    3132}
    3233
    3334//
    3435////////////////////////////////////////////////////////////////////////////
    35 void t_eph::setClkCorr(const BNC_PPP::t_clkCorr* clkCorr) {
     36void t_eph::setClkCorr(const t_clkCorr* clkCorr) {
    3637  delete _clkCorr;
    37   _clkCorr = new BNC_PPP::t_clkCorr(*clkCorr);
     38  _clkCorr = new t_clkCorr(*clkCorr);
    3839}
    3940

  • trunk/BNC/src/ephemeris.h

    r6139 r6141  
    1414}
    1515
    16 namespace BNC_PPP {
    17   class t_orbCorr;
    18   class t_clkCorr;
    19 }
     16class t_orbCorr;
     17class t_clkCorr;
    2018
    2119class t_eph {
    … …  
    3533  t_prn   prn() const {return _prn;}
    3634  t_irc   getCrd(const bncTime& tt, ColumnVector& xc, ColumnVector& vv, bool useCorr) const;
    37   void    setOrbCorr(const BNC_PPP::t_orbCorr* orbCorr);
    38   void    setClkCorr(const BNC_PPP::t_clkCorr* clkCorr);
     35  void    setOrbCorr(const t_orbCorr* orbCorr);
     36  void    setClkCorr(const t_clkCorr* clkCorr);
    3937  const QDateTime& receptDateTime() const {return _receptDateTime;}
    4038  static QString rinexDateStr(const bncTime& tt, const t_prn& prn, double version);
    … …  
    4442 protected: 
    4543  virtual void position(int GPSweek, double GPSweeks, double* xc, double* vv) const = 0;
    46   t_prn               _prn;
    47   bncTime             _TOC;
    48   QDateTime           _receptDateTime;
    49   bool                _ok;
    50   BNC_PPP::t_orbCorr* _orbCorr;
    51   BNC_PPP::t_clkCorr* _clkCorr;
     44  t_prn      _prn;
     45  bncTime    _TOC;
     46  QDateTime  _receptDateTime;
     47  bool       _ok;
     48  t_orbCorr* _orbCorr;
     49  t_clkCorr* _clkCorr;
    5250};
    5351

  • trunk/BNC/src/pppInclude.h

    r6135 r6141  
    3535  std::string  _log;         
    3636  bool         _error;       
    37 };
    38 
    39 class t_orbCorr {
    40  public:
    41   t_prn          prn() const {return _prn;}
    42   unsigned short IOD() const {return _iod;}
    43   t_prn          _prn;
    44   unsigned short _iod;
    45   bncTime        _time;
    46   char           _system;
    47   double         _xr[3];
    48   double         _dotXr[3];
    49 };
    50 
    51 class t_clkCorr {
    52  public:
    53   t_prn          prn() const {return _prn;}
    54   unsigned short IOD() const {return _iod;}
    55   t_prn          _prn;
    56   unsigned short _iod;
    57   bncTime        _time;
    58   double         _dClk;
    59   double         _dotDClk;
    60   double         _dotDotDClk;
    61   double         _clkPartial;
    62 };
    63 
    64 class t_frqBias {
    65  public:
    66   t_frqBias() {
    67     _code       = 0.0;         
    68     _codeValid  = false;     
    69     _phase      = 0.0;         
    70     _phaseValid = false;   
    71   }
    72   std::string _rnxType2ch;
    73   double      _code;         
    74   bool        _codeValid;     
    75   double      _phase;         
    76   bool        _phaseValid;   
    77 };
    78 
    79 class t_satBias {
    80  public:
    81   t_prn                  _prn;
    82   bncTime                _time;
    83   int                    _nx;
    84   int                    _jumpCount;
    85   std::vector<t_frqBias> _bias;
    8637};
    8738

  • trunk/BNC/src/pppRun.cpp

    r6140 r6141  
    7575          BNC_CORE, SIGNAL(newNMEAstr(QByteArray, QByteArray)));
    7676
    77   for (unsigned iPrn = 0; iPrn <= t_prn::MAXPRN; iPrn++) {
    78     _lastOrbCorrIOD[iPrn]   = -1;
    79     _lastClkCorrValue[iPrn] = 0.0;
    80   }
    81 
    8277  _pppClient = new t_pppClient(_opt);
    8378
    … …  
    10297            this, SLOT(slotNewEphGalileo(galileoephemeris)),conType);
    10398
    104     connect(BNC_CORE, SIGNAL(newCorrections(QStringList)),
    105             this, SLOT(slotNewCorrections(QStringList)),conType);
     99    connect(BNC_CORE, SIGNAL(newOrbCorrections(QList<t_orbCorr>)),
     100            this, SLOT(slotNewOrbCorrections(QList<t_orbCorr>)),conType);
     101
     102    connect(BNC_CORE, SIGNAL(newClkCorrections(QList<t_clkCorr>)),
     103            this, SLOT(slotNewClkCorrections(QList<t_clkCorr>)),conType);
    106104  }
    107105  else {
    … …  
    230228  // Process the oldest epochs
    231229  // ------------------------
     230  cout << "epoData " << _epoData.size() << endl;
     231
    232232  while (_epoData.size() && !waitForCorr(_epoData.front()->_time)) {
    233233
    234234    const vector<t_satObs*>& satObs = _epoData.front()->_satObs;
     235
     236    cout << "satObs " << satObs.size() << endl;
    235237
    236238    t_output output;
    … …  
    287289//
    288290////////////////////////////////////////////////////////////////////////////
    289 void t_pppRun::slotNewCorrections(QStringList corrList) {
    290   QMutexLocker locker(&_mutex);
    291 
    292   // Check the Mountpoint (source of corrections)
    293   // --------------------------------------------
     291void t_pppRun::slotNewOrbCorrections(QList<t_orbCorr> orbCorr) {
     292  if (orbCorr.size() == 0) {
     293    return;
     294  }
     295
    294296  if (_opt->_realTime) {
    295     if (_opt->_corrMount.empty()) {
     297    if (_opt->_corrMount.empty() || _opt->_corrMount != orbCorr[0]._staID) {
    296298      return;
    297299    }
    298     QMutableListIterator<QString> itm(corrList);
    299     while (itm.hasNext()) {
    300       QStringList hlp = itm.next().split(" ");
    301       if (hlp.size() > 0) {
    302         QString mountpoint = hlp[hlp.size()-1];
    303         if (mountpoint != QString(_opt->_corrMount.c_str())) {
    304           itm.remove();     
    305         }
    306       }
    307     }
    308   }
    309 
    310   if (corrList.size() == 0) {
     300  }
     301  vector<t_orbCorr*> corrections;
     302  for (int ii = 0; ii < orbCorr.size(); ii++) {
     303    corrections.push_back(new t_orbCorr(orbCorr[ii]));
     304    _lastClkCorrTime = orbCorr[ii]._time;
     305  }
     306
     307  _pppClient->putOrbCorrections(corrections);
     308}
     309
     310//
     311////////////////////////////////////////////////////////////////////////////
     312void t_pppRun::slotNewClkCorrections(QList<t_clkCorr> clkCorr) {
     313  if (clkCorr.size() == 0) {
    311314    return;
    312315  }
    313316
    314   vector<t_orbCorr*> orbCorr;
    315   vector<t_clkCorr*> clkCorr;
    316   vector<t_satBias*> satBias;
    317 
    318   QListIterator<QString> it(corrList);
    319   while (it.hasNext()) {
    320     QString line = it.next();
    321 
    322     QTextStream in(&line);
    323     int     messageType;
    324     int     updateInterval;
    325     int     GPSweek;
    326     double  GPSweeks;
    327     QString prn;
    328     in >> messageType >> updateInterval >> GPSweek >> GPSweeks >> prn;
    329 
    330     if ( t_corr::relevantMessageType(messageType) ) {
    331       t_corr corr;
    332       corr.readLine(line);
    333       if      (messageType == COTYPE_GPSCOMBINED || messageType == COTYPE_GLONASSCOMBINED ||
    334                messageType == COTYPE_GPSORBIT    || messageType == COTYPE_GLONASSORBIT    ) {
    335         t_orbCorr* cc = new t_orbCorr();
    336         cc->_prn.set(corr.prn.toAscii().data());
    337         cc->_iod       = corr.iod;
    338         cc->_time      = corr.tRao;
    339         cc->_system    = 'R';
    340         cc->_xr[0]     = corr.rao[0];
    341         cc->_xr[1]     = corr.rao[1];
    342         cc->_xr[2]     = corr.rao[2];
    343         cc->_dotXr[0]  = corr.dotRao[0];
    344         cc->_dotXr[0]  = corr.dotRao[1];
    345         cc->_dotXr[0]  = corr.dotRao[2];
    346         orbCorr.push_back(cc);
    347 
    348         _lastOrbCorrIOD[cc->_prn.toInt()] = cc->_iod;
    349       }
    350       else if (messageType == COTYPE_GPSCOMBINED || messageType == COTYPE_GLONASSCOMBINED ||
    351                messageType == COTYPE_GPSCLOCK    || messageType == COTYPE_GLONASSCLOCK    ) {
    352         t_clkCorr* cc = new t_clkCorr();
    353         cc->_prn.set(corr.prn.toAscii().data());
    354         cc->_iod         = corr.iod;
    355         cc->_time        = corr.tClk;
    356         cc->_dClk        = corr.dClk;
    357         cc->_dotDClk     = corr.dotDClk;
    358         cc->_dotDotDClk  = corr.dotDotDClk;
    359         cc->_clkPartial  = 0.0;
    360         if (messageType == COTYPE_GPSCLOCK || messageType == COTYPE_GLONASSCLOCK) {
    361           int lastIOD = _lastOrbCorrIOD[cc->_prn.toInt()];
    362           if (lastIOD != -1) {
    363             cc->_iod = lastIOD;
    364           }
    365           else {
    366             delete cc;
    367             cc = 0;
    368           }
    369         }
    370         if (cc) {
    371           clkCorr.push_back(cc);
    372           _lastClkCorrValue[cc->_prn.toInt()] = cc->_dClk;
    373           if (_lastClkCorrTime.undef() || cc->_time > _lastClkCorrTime) {
    374             _lastClkCorrTime = cc->_time;
    375           }
    376         }
    377       }
    378     }
    379     else if ( messageType == BTYPE_GPS || messageType == BTYPE_GLONASS ) {
    380     }
    381   }
    382 
    383   _pppClient->putOrbCorrections(orbCorr);
    384   _pppClient->putClkCorrections(clkCorr);
    385   _pppClient->putBiases(satBias);   
    386 
    387   for (unsigned ii = 0; ii < orbCorr.size(); ii++) {
    388     delete orbCorr[ii];
    389   }
    390   for (unsigned ii = 0; ii < clkCorr.size(); ii++) {
    391     delete clkCorr[ii];
    392   }
    393   for (unsigned ii = 0; ii < satBias.size(); ii++) {
    394     delete satBias[ii];
    395   }
    396 }
    397 
     317  if (_opt->_realTime) {
     318    if (_opt->_corrMount.empty() || _opt->_corrMount != clkCorr[0]._staID) {
     319      return;
     320    }
     321  }
     322  vector<t_clkCorr*> corrections;
     323  for (int ii = 0; ii < clkCorr.size(); ii++) {
     324    corrections.push_back(new t_clkCorr(clkCorr[ii]));
     325  }
     326
     327  _pppClient->putClkCorrections(corrections);
     328}
    398329
    399330//

  • trunk/BNC/src/pppRun.h

    r6137 r6141  
    66#include <QtCore>
    77
     8#include "satObs.h"
    89#include "pppOptions.h"
    910#include "pppClient.h"
    … …  
    3738  void slotNewEphGlonass(glonassephemeris gloeph);
    3839  void slotNewEphGalileo(galileoephemeris galeph);
    39   void slotNewCorrections(QStringList corrList);
     40  void slotNewOrbCorrections(QList<t_orbCorr> orbCorr);
     41  void slotNewClkCorrections(QList<t_clkCorr> clkCorr);
    4042  void slotNewObs(QByteArray staID, QList<t_satObs> obsList);
    4143  void slotSetSpeed(int speed);
    … …  
    6163  t_pppClient*           _pppClient;
    6264  std::deque<t_epoData*> _epoData;
    63   int                    _lastOrbCorrIOD[t_prn::MAXPRN+1];
    64   double                 _lastClkCorrValue[t_prn::MAXPRN+1];
    6565  bncTime                _lastClkCorrTime;
    6666  t_rnxObsFile*          _rnxObsFile;

  • trunk/BNC/src/rinex/corrfile.cpp

    r5732 r6141  
    7171  }
    7272
    73   QStringList corrs;
     73  QStringList lines;
    7474
    7575  if (!_lastLine.isEmpty()) {
    76     corrs << _lastLine;
     76    lines << _lastLine;
    7777  }
    7878
    … …  
    8585
    8686    if (stopRead(tt)) {
    87       if (corrs.size()) {
    88 
    89         QListIterator<QString> it(corrs);
    90         while (it.hasNext()) {
    91           const QString& cLine = it.next();
    92           t_corr* corr = new t_corr();
    93           corr->readLine(cLine);
    94           if (corr->tRao.valid()) {
    95             _corrIODs[corr->prn] = corr->iod;
    96           }
     87      QList<t_orbCorr> orbCorr;
     88      QList<t_clkCorr> clkCorr;
     89      QListIterator<QString> it(lines);
     90      while (it.hasNext()) {
     91        const QString& str = it.next();
     92        if      (str[0] == 'C') {
     93          t_clkCorr corr(str.toAscii().data());
     94          _lastTime = corr._time;
     95          clkCorr.push_back(corr);
    9796        }
    98 
    99         emit newCorrections(corrs);
     97        else if (str[0] == 'O') {
     98          t_orbCorr corr(str.toAscii().data());
     99          _lastTime = corr._time;
     100          orbCorr.push_back(corr);
     101        }
     102      }         
     103      if (orbCorr.size() > 0) {
     104        emit newOrbCorrections(orbCorr);
     105      }
     106      if (clkCorr.size() > 0) {
     107        emit newClkCorrections(clkCorr);
    100108      }
    101109      return;
    102110    }
    103111    else {
    104       corrs << _lastLine;
     112      lines << _lastLine;
    105113    }
    106114  }
    … …  
    111119bool t_corrFile::stopRead(const bncTime& tt) {
    112120
    113   if (_lastLine.isEmpty()) {
     121  if (_lastTime.undef()) {
    114122    return false;
    115123  }
    116124
    117   QTextStream in(_lastLine.toAscii(), QIODevice::ReadOnly);
    118   int    messageType, updateInterval, GPSweek;
    119   double GPSweeks;
    120   in >> messageType >> updateInterval >> GPSweek >> GPSweeks;
    121 
    122   bncTime tNew(GPSweek, GPSweeks);
    123 
    124   if (tNew > tt) {
     125  if (_lastTime > tt) {
    125126    return true;
    126127  }   

  • trunk/BNC/src/rinex/corrfile.h

    r5732 r6141  
    2929#include "bncconst.h"
    3030#include "bnctime.h"
     31#include "satObs.h"
    3132
    3233class t_corrFile : public QObject {
    … …  
    4041
    4142 signals:
    42   void newCorrections(QStringList);
     43  void newOrbCorrections(QList<t_orbCorr>);
     44  void newClkCorrections(QList<t_clkCorr>);
    4345
    4446 private:
    … …  
    4850  QString            _lastLine;
    4951  QMap<QString, int> _corrIODs;
     52  bncTime            _lastTime;
    5053};
    5154

  • trunk/BNC/src/satObs.h

    r6137 r6141  
    5959class t_orbCorr {
    6060 public:
     61  t_orbCorr();
     62  t_orbCorr(const std::string& str);
    6163  t_prn          prn() const {return _prn;}
    6264  unsigned short IOD() const {return _iod;}
     65  std::string    toString() const;
     66  std::string    _staID;
    6367  t_prn          _prn;
    6468  unsigned short _iod;
    … …  
    7175class t_clkCorr {
    7276 public:
     77  t_clkCorr();
     78  t_clkCorr(const std::string& str);
    7379  t_prn          prn() const {return _prn;}
    7480  unsigned short IOD() const {return _iod;}
     81  std::string    toString() const;
     82  std::string    _staID;
    7583  t_prn          _prn;
    7684  unsigned short _iod;
    … …  
    99107class t_satBias {
    100108 public:
     109  std::string            _staID;
    101110  t_prn                  _prn;
    102111  bncTime                _time;

  • trunk/BNC/src/src.pri

    r6136 r6141  
    8484          bncephuser.cpp bncoutf.cpp bncclockrinex.cpp bncsp3.cpp     \
    8585          bncbytescounter.cpp bncsslconfig.cpp reqcdlg.cpp            \
    86           ephemeris.cpp t_prn.cpp                                     \
     86          ephemeris.cpp t_prn.cpp satObs.cpp                          \
    8787          upload/bncrtnetdecoder.cpp upload/bncuploadcaster.cpp       \
    8888          upload/bncrtnetuploadcaster.cpp upload/bnccustomtrafo.cpp   \
    … …  
    110110QT += network
    111111
    112 exists(combination/bnccomb.h) {
    113   DEFINES += USE_COMBINATION
    114   HEADERS += combination/bnccomb.h
    115   SOURCES += combination/bnccomb.cpp
    116 }
     112# exists(combination/bnccomb.h) {
     113#   DEFINES += USE_COMBINATION
     114#   HEADERS += combination/bnccomb.h
     115#   SOURCES += combination/bnccomb.cpp
     116# }
    117117
    118118exists(PPP) {
Note: See TracChangeset for help on using the changeset viewer.