Changeset 366 in ntrip for trunk/BNC/RTCM3


Ignore:
Timestamp:
Jan 17, 2007, 4:17:20 PM (18 years ago)
Author:
mervart
Message:

* empty log message *

Location:
trunk/BNC/RTCM3
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified trunk/BNC/RTCM3/RTCM3Decoder.cpp

    r341 r366  
    9090        if (rr == 2) {
    9191          std::cerr << "No valid RINEX! All values are modulo 299792.458!\n";
    92           exit(1);
     92//        exit(1); 
    9393        }
    9494
    … …  
    107107
    108108          for (int jj = 0; jj < _Parser.numdatatypes; jj++) {
    109 
    110             if ( !(_Parser.Data.dataflags[ii] & _Parser.dataflag[jj])
    111                  || isnan(_Parser.Data.measdata[ii][_Parser.datapos[jj]])
    112                  || isinf(_Parser.Data.measdata[ii][_Parser.datapos[jj]]) ) {
    113               continue;
     109            int v = 0;
     110            int df = _Parser.dataflag[jj];
     111            int pos = _Parser.datapos[jj];
     112            if ( (_Parser.Data.dataflags[ii] & df)
     113                 && !isnan(_Parser.Data.measdata[ii][pos])
     114                 && !isinf(_Parser.Data.measdata[ii][pos])) {
     115              v = 1;
    114116            }
    115              
     117            else {
     118              df = _Parser.dataflag2[jj];
     119              pos = _Parser.datapos2[jj];
     120              if ( (_Parser.Data.dataflags[ii] & df)
     121                   && !isnan(_Parser.Data.measdata[ii][pos])
     122                   && !isinf(_Parser.Data.measdata[ii][pos])) {
     123              v = 1;
     124              }
     125            }
     126          if(!v)
     127          { continue; }
     128          else
     129          {
    116130            if      (_Parser.dataflag[jj] & GNSSDF_C1DATA) {
    117131              obs->C1 = _Parser.Data.measdata[ii][_Parser.datapos[jj]];
     132            }
     133            else if (_Parser.dataflag[jj] & GNSSDF_C2DATA) {
     134              obs->C2 = _Parser.Data.measdata[ii][_Parser.datapos[jj]];
    118135            }
    119136            else if (_Parser.dataflag[jj] & GNSSDF_P1DATA) {
    … …  
    123140              obs->P2 = _Parser.Data.measdata[ii][_Parser.datapos[jj]];
    124141            }
    125             else if (_Parser.dataflag[jj] & (GNSSDF_L1CDATA|GNSSDF_L1PDATA)) {
    126               obs->L1   = _Parser.Data.measdata[ii][_Parser.datapos[jj]];
     142            else if (df & (GNSSDF_L1CDATA|GNSSDF_L1PDATA)) {
     143              obs->L1   = _Parser.Data.measdata[ii][pos];
    127144              obs->SNR1 = _Parser.Data.snrL1[ii];
    128145            }
    129             else if (_Parser.dataflag[jj] & (GNSSDF_L2CDATA|GNSSDF_L2PDATA)) {
    130               obs->L2   = _Parser.Data.measdata[ii][_Parser.datapos[jj]];
     146            else if (df & (GNSSDF_L2CDATA|GNSSDF_L2PDATA)) {
     147              obs->L2   = _Parser.Data.measdata[ii][pos];
    131148              obs->SNR2 = _Parser.Data.snrL2[ii];
    132149            }
     150          }
    133151          }
    134152          _obsList.push_back(obs);

  • TabularUnified trunk/BNC/RTCM3/rtcm3torinex.cpp

    r327 r366  
    11/*
    22  Converter for RTCM3 data to RINEX.
    3   $Id: rtcm3torinex.c,v 1.11 2006/11/21 08:27:35 stoecker Exp $
     3  $Id: rtcm3torinex.c,v 1.16 2007/01/11 15:32:26 stoecker Exp $
    44  Copyright (C) 2005-2006 by Dirk Stoecker <stoecker@euronik.eu>
    55
    … …  
    5151
    5252/* CVS revision and version */
    53 static char revisionstr[] = "$Revision: 1.11 $";
     53static char revisionstr[] = "$Revision: 1.16 $";
    5454
    5555static uint32_t CRC24(long size, const unsigned char *buf)
    … …  
    332332              gnss->dataflags[num] |= s;
    333333              gnss->measdata[num][se] = i*0.25;
    334               i /= 4*4;
     334              i /= 4*6;
    335335              if(i > 9) i = 9;
    336336              else if(i < 1) i = 1;
    … …  
    380380                gnss->dataflags[num] |= s;
    381381                gnss->measdata[num][se] = i*0.25;
    382                 i /= 4*4;
     382                i /= 4*6;
    383383                if(i > 9) i = 9;
    384384                else if(i < 1) i = 1;
    … …  
    495495              gnss->dataflags[num] |= s;
    496496              gnss->measdata[num][se] = i*0.25;
    497               i /= 4*4;
     497              i /= 4*6;
    498498              if(i > 9) i = 9;
    499499              else if(i < 1) i = 1;
    … …  
    543543                gnss->dataflags[num] |= s;
    544544                gnss->measdata[num][se] = i*0.25;
    545                 i /= 4*4;
     545                i /= 4*6;
    546546                if(i > 9) i = 9;
    547547                else if(i < 1) i = 1;
    … …  
    654654}
    655655
    656 #define NUMSTARTSKIP 3
     656#define NUMSTARTSKIP 1
     657
     658////////////////////////////////////////////////////////////////////
     659// Aenderung Perlt - kein check auf vorhandene Daten
     660// Abgefragt werden : C1 C2 L1 L2 P1 P2 S1 S2
     661
    657662void HandleHeader(struct RTCM3ParserData *Parser)
    658663{
    659   struct HeaderData hdata;
    660   char thebuffer[MAXHEADERBUFFERSIZE];
    661   char *buffer = thebuffer;
    662   size_t buffersize = sizeof(thebuffer);
    663664  int i;
    664 
    665   hdata.data.named.version =
    666   "     2.11           OBSERVATION DATA    M (Mixed)"
    667   "           RINEX VERSION / TYPE";
    668 
    669   {
    670     const char *str;
    671     time_t t;
    672     struct tm * t2;
    673 
    674 #ifdef NO_RTCM3_MAIN
    675     if(revisionstr[0] == '$')
    676     {
    677       char *a;
    678       int i=0;
    679       for(a = revisionstr+11; *a && *a != ' '; ++a)
    680         revisionstr[i++] = *a;
    681       revisionstr[i] = 0;
    682     }
    683 #endif
    684 
    685     str = getenv("USER");
    686     if(!str) str = "";
    687     t = time(&t);
    688     t2 = gmtime(&t);
    689     hdata.data.named.pgm = buffer;
    690     i = 1+snprintf(buffer, buffersize,
    691     "RTCM3TORINEX %-7.7s%-20.20s%04d-%02d-%02d %02d:%02d    "
    692     "PGM / RUN BY / DATE",
    693     revisionstr, str, 1900+t2->tm_year, t2->tm_mon+1, t2->tm_mday, t2->tm_hour,
    694     t2->tm_min);
    695     buffer += i; buffersize -= i;
    696 
    697     hdata.data.named.observer = buffer;
    698     i = 1+snprintf(buffer, buffersize,
    699     "%-20.20s                                        "
    700     "OBSERVER / AGENCY", str);
    701     buffer += i; buffersize -= i;
    702   }
    703 
    704   hdata.data.named.marker =
    705   "RTCM3TORINEX                                                "
    706   "MARKER NAME";
    707 
    708   hdata.data.named.receiver =
    709   "                                                            "
    710   "REC # / TYPE / VERS";
    711 
    712   hdata.data.named.antenna =
    713   "                                                            "
    714   "ANT # / TYPE";
    715 
    716   hdata.data.named.position =
    717   "         .0000         .0000         .0000                  "
    718   "APPROX POSITION XYZ";
    719 
    720   hdata.data.named.antennaposition =
    721   "         .0000         .0000         .0000                  "
    722   "ANTENNA: DELTA H/E/N";
    723  
    724   hdata.data.named.wavelength =
    725   "     1     1                                                "
    726   "WAVELENGTH FACT L1/2";
    727 
    728   {
    729 #define CHECKFLAGS(a, b) \
    730     if(flags & GNSSDF_##a##DATA \
    731     && !data[RINEXENTRY_##b##DATA]) \
    732     { \
    733       Parser->dataflag[Parser->numdatatypes] = GNSSDF_##a##DATA; \
    734       Parser->datapos[Parser->numdatatypes++] = data[RINEXENTRY_##b##DATA] \
    735       = GNSSENTRY_##a##DATA; \
    736       snprintf(tbuffer+tbufferpos, sizeof(tbuffer)-tbufferpos, "    "#b); \
    737       tbufferpos += 6; \
    738     }
    739 
    740665    int flags = Parser->startflags;
    741666    int data[RINEXENTRY_NUMBER];
    742     char tbuffer[6*RINEXENTRY_NUMBER+1];
    743     int tbufferpos = 0;
    744667    for(i = 0; i < RINEXENTRY_NUMBER; ++i)
    745668      data[i] = 0;
    … …  
    747670      flags |= Parser->Data.dataflags[i];
    748671
    749     CHECKFLAGS(C1,C1)
    750     CHECKFLAGS(C2,C2)
    751     CHECKFLAGS(P1,P1)
    752     CHECKFLAGS(P2,P2)
    753     CHECKFLAGS(L1C,L1)
    754     CHECKFLAGS(L1P,L1)
    755     CHECKFLAGS(L2C,L2)
    756     CHECKFLAGS(L2P,L2)
    757     CHECKFLAGS(D1C,D1)
    758     CHECKFLAGS(D1P,D1)
    759     CHECKFLAGS(D2C,D2)
    760     CHECKFLAGS(D2P,D2)
    761     CHECKFLAGS(S1C,S1)
    762     CHECKFLAGS(S1P,S1)
    763     CHECKFLAGS(S2C,S2)
    764     CHECKFLAGS(S2P,S2)
    765 
    766     hdata.data.named.typesofobs = buffer;
    767     i = 1+snprintf(buffer, buffersize,
    768     "%6i%-54.54s# / TYPES OF OBSERV", Parser->numdatatypes, tbuffer);
    769     if(Parser->numdatatypes>9)
    770     {
    771       i += snprintf(buffer+i-1, buffersize,
    772       "\n      %-54.54s# / TYPES OF OBSERV", tbuffer+9*6);
    773     }
    774     buffer += i; buffersize -= i;
    775   }
    776 
    777   {
    778     struct converttimeinfo cti;
    779     converttime(&cti, Parser->Data.week,
    780     (int)floor(Parser->Data.timeofweek/1000.0));
    781     hdata.data.named.timeoffirstobs = buffer;
    782       i = 1+snprintf(buffer, buffersize,
    783     "  %4d    %2d    %2d    %2d    %2d   %10.7f     GPS         "
    784     "TIME OF FIRST OBS", cti.year%100, cti.month, cti.day, cti.hour,
    785     cti.minute, cti.second + fmod(Parser->Data.timeofweek/1000.0,1.0));
    786 
    787     buffer += i; buffersize -= i;
    788   }
    789 
    790   hdata.numheaders = 11;
    791 
    792   if(Parser->headerfile)
    793   {
    794     FILE *fh;
    795     if((fh = fopen(Parser->headerfile, "r")))
    796     {
    797       size_t siz;
    798       char *lastblockstart;
    799       if((siz = fread(buffer, 1, buffersize-1, fh)) > 0)
    800       {
    801         buffer[siz] = '\n';
    802         if(siz == buffersize)
    803         {
    804           RTCM3Error("Header file is too large. Only %d bytes read.",
    805           siz);
    806         }
    807         /* scan the file line by line and enter the entries in the list */
    808         /* warn for "# / TYPES OF OBSERV" and "TIME OF FIRST OBS" */
    809         /* overwrites entries, except for comments */
    810         lastblockstart = buffer;
    811         for(i = 0; i < (int)siz; ++i)
    812         {
    813           if(buffer[i] == '\n')
    814           { /* we found a line */
    815             char *end;
    816             while(buffer[i+1] == '\r')
    817               ++i; /* skip \r in case there are any */
    818             end = buffer+i;
    819             while(*end == '\t' || *end == ' ' || *end == '\r' || *end == '\n')
    820               *(end--) = 0;
    821             if(end-lastblockstart < 60+5) /* short line */
    822               RTCM3Error("Short Header line '%s' ignored.\n", lastblockstart);
    823             else
    824             {
    825               int pos;
    826               if(!strcmp("COMMENT", lastblockstart+60))
    827                 pos = hdata.numheaders;
    828               else
    829               {
    830                 for(pos = 0; pos < hdata.numheaders; ++pos)
    831                 {
    832                   if(!strcmp(hdata.data.unnamed[pos]+60, lastblockstart+60))
    833                     break;
    834                 }
    835                 if(!strcmp("# / TYPES OF OBSERV", lastblockstart+60)
    836                 || !strcmp("TIME OF FIRST OBS", lastblockstart+60))
    837                 {
    838                   RTCM3Error("Overwriting header '%s' is dangerous.\n",
    839                   lastblockstart+60);
    840                 }
    841               }
    842               if(pos >= MAXHEADERLINES)
    843               {
    844                 RTCM3Error("Maximum number of header lines of %d reached.\n",
    845                 MAXHEADERLINES);
    846               }
    847               else if(!strcmp("END OF HEADER", lastblockstart+60))
    848               {
    849                 RTCM3Error("End of header ignored.\n");
    850               }
    851               else
    852               {
    853                 hdata.data.unnamed[pos] = lastblockstart;
    854                 if(pos == hdata.numheaders)
    855                   ++hdata.numheaders;
    856               }
    857             }
    858             lastblockstart = buffer+i+1;
    859           }
    860         }
    861       }
    862       else
    863       {
    864         RTCM3Error("Could not read data from headerfile '%s'.\n",
    865         Parser->headerfile);
    866       }
    867       fclose(fh);
    868     }
    869     else
    870     {
    871       RTCM3Error("Could not open header datafile '%s'.\n",
    872       Parser->headerfile);
    873     }
    874   }
    875 
    876 #ifndef NO_RTCM3_MAIN
    877   for(i = 0; i < hdata.numheaders; ++i)
    878     RTCM3Text("%s\n", hdata.data.unnamed[i]);
    879   RTCM3Text("                                                            "
    880   "END OF HEADER\n");
    881 #endif
    882 }
     672Parser->dataflag[Parser->numdatatypes] = GNSSDF_C1DATA;
     673Parser->datapos[Parser->numdatatypes] = GNSSENTRY_C1DATA;
     674data[RINEXENTRY_C1DATA] = ++Parser->numdatatypes;
     675
     676Parser->dataflag[Parser->numdatatypes] = GNSSDF_C2DATA;
     677Parser->datapos[Parser->numdatatypes] = GNSSENTRY_C2DATA;
     678data[RINEXENTRY_C2DATA] = ++Parser->numdatatypes;
     679
     680Parser->dataflag[Parser->numdatatypes] = GNSSDF_P1DATA;
     681Parser->datapos[Parser->numdatatypes] = GNSSENTRY_P1DATA;
     682data[RINEXENTRY_P1DATA] = ++Parser->numdatatypes;
     683
     684Parser->dataflag[Parser->numdatatypes] = GNSSDF_P2DATA;
     685Parser->datapos[Parser->numdatatypes] = GNSSENTRY_P2DATA;
     686data[RINEXENTRY_P2DATA] = ++Parser->numdatatypes;
     687
     688Parser->dataflag[Parser->numdatatypes] = GNSSDF_L1CDATA;
     689Parser->datapos[Parser->numdatatypes] = GNSSENTRY_L1CDATA;
     690data[RINEXENTRY_L1DATA] = ++Parser->numdatatypes;
     691Parser->dataflag2[data[RINEXENTRY_L1DATA]-1] = GNSSDF_L1PDATA;
     692Parser->datapos2[data[RINEXENTRY_L1DATA]-1] = GNSSENTRY_L1PDATA;
     693
     694Parser->dataflag[Parser->numdatatypes] = GNSSDF_L2CDATA;
     695Parser->datapos[Parser->numdatatypes] = GNSSENTRY_L2CDATA;
     696data[RINEXENTRY_L2DATA] = ++Parser->numdatatypes;
     697Parser->dataflag2[data[RINEXENTRY_L2DATA]-1] = GNSSDF_L2PDATA;
     698Parser->datapos2[data[RINEXENTRY_L2DATA]-1] = GNSSENTRY_L2PDATA;
     699
     700Parser->dataflag[Parser->numdatatypes] = GNSSDF_S1CDATA;
     701Parser->datapos[Parser->numdatatypes] = GNSSENTRY_S1CDATA;
     702data[RINEXENTRY_S1DATA] = ++Parser->numdatatypes;
     703Parser->dataflag2[data[RINEXENTRY_S1DATA]-1] = GNSSDF_S1PDATA;
     704Parser->datapos2[data[RINEXENTRY_S1DATA]-1] = GNSSENTRY_S1PDATA;
     705
     706Parser->dataflag[Parser->numdatatypes] = GNSSDF_S2CDATA;
     707Parser->datapos[Parser->numdatatypes] = GNSSENTRY_S2CDATA;
     708data[RINEXENTRY_S2DATA] = ++Parser->numdatatypes;
     709Parser->dataflag2[data[RINEXENTRY_S2DATA]-1] = GNSSDF_S2PDATA;
     710Parser->datapos2[data[RINEXENTRY_S2DATA]-1] = GNSSENTRY_S2PDATA;
     711
     712Parser->dataflag[Parser->numdatatypes] = GNSSDF_D1CDATA;
     713Parser->datapos[Parser->numdatatypes] = GNSSENTRY_D1CDATA;
     714data[RINEXENTRY_D1DATA] = ++Parser->numdatatypes;
     715Parser->dataflag2[data[RINEXENTRY_D1DATA]-1] = GNSSDF_D1PDATA;
     716Parser->datapos2[data[RINEXENTRY_D1DATA]-1] = GNSSENTRY_D1PDATA;
     717
     718Parser->dataflag[Parser->numdatatypes] = GNSSDF_D2CDATA;
     719Parser->datapos[Parser->numdatatypes] = GNSSENTRY_D2CDATA;
     720data[RINEXENTRY_D2DATA] = ++Parser->numdatatypes;
     721Parser->dataflag2[data[RINEXENTRY_D2DATA]-1] = GNSSDF_D2PDATA;
     722Parser->datapos2[data[RINEXENTRY_D2DATA]-1] = GNSSENTRY_D2PDATA;
     723}
     724// Ende Aenderung Perlt - kein check auf vorhandene Daten
     725
    883726
    884727void HandleByte(struct RTCM3ParserData *Parser, unsigned int byte)
    … …  
    955798        for(j = 0; j < Parser->numdatatypes; ++j)
    956799        {
    957           if(!(Parser->Data.dataflags[i] & Parser->dataflag[j])
    958           || isnan(Parser->Data.measdata[i][Parser->datapos[j]])
    959           || isinf(Parser->Data.measdata[i][Parser->datapos[j]]))
     800          int v = 0;
     801          int df = Parser->dataflag[j];
     802          int pos = Parser->datapos[j];
     803          if((Parser->Data.dataflags[i] & df)
     804          && !isnan(Parser->Data.measdata[i][pos])
     805          && !isinf(Parser->Data.measdata[i][pos]))
     806          {
     807            v = 1;
     808          }
     809          else
     810          {
     811            df = Parser->dataflag2[j];
     812            pos = Parser->datapos2[j];
     813
     814            if((Parser->Data.dataflags[i] & df)
     815            && !isnan(Parser->Data.measdata[i][pos])
     816            && !isinf(Parser->Data.measdata[i][pos]))
     817            {
     818              v = 1;
     819            }
     820          }
     821
     822          if(!v)
    960823          { /* no or illegal data */
    961824            RTCM3Text("                ");
    … …  
    965828            char lli = ' ';
    966829            char snr = ' ';
    967             if(Parser->dataflag[j] & (GNSSDF_L1CDATA|GNSSDF_L1PDATA))
     830            if(df & (GNSSDF_L1CDATA|GNSSDF_L1PDATA))
    968831            {
    969832              if(Parser->Data.dataflags[i] & GNSSDF_LOCKLOSSL1)
    … …  
    971834              snr = '0'+Parser->Data.snrL1[i];
    972835            }
    973             if(Parser->dataflag[j] & (GNSSDF_L2CDATA|GNSSDF_L2PDATA))
     836            if(df & (GNSSDF_L2CDATA|GNSSDF_L2PDATA))
    974837            {
    975838              if(Parser->Data.dataflags[i] & GNSSDF_LOCKLOSSL2)
    … …  
    978841            }
    979842            RTCM3Text("%14.3f%c%c",
    980             Parser->Data.measdata[i][Parser->datapos[j]],lli,snr);
     843            Parser->Data.measdata[i][pos],lli,snr);
    981844          }
    982845          if(j%5 == 4 || j == Parser->numdatatypes-1)
    … …  
    989852
    990853#ifndef NO_RTCM3_MAIN
    991 static char datestr[]     = "$Date: 2006/11/21 08:27:35 $";
     854static char datestr[]     = "$Date: 2007/01/11 15:32:26 $";
    992855
    993856/* The string, which is send as agent in HTTP request */
    … …  
    12861149    if(!(he=gethostbyname(args.server)))
    12871150    {
    1288       perror("gethostbyname");
     1151      RTCM3Error("Function gethostbyname: %s\n", strerror(errno));
    12891152      exit(1);
    12901153    }
    12911154    if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    12921155    {
    1293       perror("socket");
     1156      RTCM3Error("Function socket: %s\n", strerror(errno));
    12941157      exit(1);
    12951158    }
    … …  
    13011164    sizeof(struct sockaddr)) == -1)
    13021165    {
    1303       perror("connect");
     1166      RTCM3Error("Function connect: %s\n", strerror(errno));
    13041167      exit(1);
    13051168    }
    … …  
    13391202        exit(1);
    13401203      }
    1341       snprintf(buf+i, 5, "\r\n\r\n");
    1342       i += 5;
     1204      buf[i++] = '\r';
     1205      buf[i++] = '\n';
     1206      buf[i++] = '\r';
     1207      buf[i++] = '\n';
    13431208    }
    13441209    if(send(sockfd, buf, (size_t)i, 0) != i)
    13451210    {
    1346       perror("send");
     1211      RTCM3Error("Function send: %s\n", strerror(errno));
    13471212      exit(1);
    13481213    }

  • TabularUnified trunk/BNC/RTCM3/rtcm3torinex.h

    r320 r366  
    11#ifndef RTCM3TORINEX_H
    2 #define RTCM3TORINES_H
     2#define RTCM3TORINEX_H
    33
    44/*
    55  Converter for RTCM3 data to RINEX.
    6   $Id: rtcm3torinex.h,v 1.3 2006/11/15 12:31:31 stoecker Exp $
     6  $Id: rtcm3torinex.h,v 1.5 2007/01/11 14:10:13 stoecker Exp $
    77  Copyright (C) 2005-2006 by Dirk Stoecker <stoecker@euronik.eu>
    88
    … …  
    9494#define GLO_WAVELENGTH_L2(a) (LIGHTSPEED / GLO_FREQU_L2(a)) /* m */
    9595
    96 /* unimportant, only for approx. time needed */
    97 #define LEAPSECONDS 14
    98 
    9996/* Additional flags for the data field, which tell us more. */
    10097#define GNSSDF_LOCKLOSSL1     (1<<29)  /* lost lock on L1 */
    10198#define GNSSDF_LOCKLOSSL2     (1<<30)  /* lost lock on L2 */
     99
     100#define LEAPSECONDS     14 /* only needed for approx. time */
    102101
    103102struct gnssdata {
    … …  
    127126  int    datapos[RINEXENTRY_NUMBER];
    128127  int    dataflag[RINEXENTRY_NUMBER];
     128  int    datapos2[RINEXENTRY_NUMBER];
     129  int    dataflag2[RINEXENTRY_NUMBER];
    129130  int    numdatatypes;
    130131  int    validwarning;
Note: See TracChangeset for help on using the changeset viewer.