Changeset 2659 in ntrip for trunk/rtcm3torinex


Ignore:
Timestamp:
Nov 9, 2010, 2:50:16 PM (10 years ago)
Author:
stoecker
Message:

first test of MSM messages

Location:
trunk/rtcm3torinex/lib
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/rtcm3torinex/lib/rtcm3torinex.c

    r2507 r2659  
    225225{0,0,0,0} /* end marker */
    226226};
    227 #define LEAPSECONDS     14 /* only needed for approx. time */
     227#define LEAPSECONDS     15 /* only needed for approx. time */
    228228#define GPSLEAPSTART    19 /* 19 leap seconds existed at 6.1.1980 */
    229229
     
    411411        GETBITS(i, 5)
    412412        ge->frequency_number = i-7;
     413        if(ge->almanac_number >= 1 && ge->almanac_number <= PRN_GLONASS_NUM)
     414          handle->GLOFreq[ge->almanac_number-1] = 100+ge->frequency_number;
    413415        GETBITS(i, 1)
    414416        if(i)
     
    539541          lastlockl1[sv] = i;
    540542          if(handle->lastlockGPSl1[sv] > i || i == 0)
    541             gnss->dataflags[num] |= GNSSDF_LOCKLOSSL1;
     543            gnss->dataflags2[num] |= GNSSDF2_LOCKLOSSL1;
    542544          if(type == 1002 || type == 1004)
    543545          {
     
    571573              s = GNSSDF_S2PDATA; se = GNSSENTRY_S2PDATA;
    572574              if(code >= 2)
    573                 gnss->dataflags[num] |= GNSSDF_XCORRL2;
     575                gnss->dataflags2[num] |= GNSSDF2_XCORRL2;
    574576            }
    575577            else
     
    596598            lastlockl2[sv] = i;
    597599            if(handle->lastlockGPSl2[sv] > i || i == 0)
    598               gnss->dataflags[num] |= GNSSDF_LOCKLOSSL2;
     600              gnss->dataflags2[num] |= GNSSDF2_LOCKLOSSL2;
    599601            if(type == 1004)
    600602            {
     
    717719          lastlockl1[sv] = i;
    718720          if(handle->lastlockGLOl1[sv] > i || i == 0)
    719             gnss->dataflags[num] |= GNSSDF_LOCKLOSSL1;
     721            gnss->dataflags2[num] |= GNSSDF2_LOCKLOSSL1;
    720722          if(type == 1010 || type == 1012)
    721723          {
     
    772774            lastlockl2[sv] = i;
    773775            if(handle->lastlockGLOl2[sv] > i || i == 0)
    774               gnss->dataflags[num] |= GNSSDF_LOCKLOSSL2;
     776              gnss->dataflags2[num] |= GNSSDF2_LOCKLOSSL2;
    775777            if(type == 1012)
    776778            {
     
    795797          handle->lastlockGLOl1[i] = lastlockl1[i];
    796798          handle->lastlockGLOl2[i] = lastlockl2[i];
     799        }
     800        if(!syncf && !old)
     801        {
     802          handle->Data = *gnss;
     803          memset(gnss, 0, sizeof(*gnss));
     804        }
     805        if(!syncf || old)
     806        {
     807          if(wasamb) /* not RINEX compatible without */
     808            ret = 1;
     809          else
     810            ret = 2;
     811        }
     812#ifdef NO_RTCM3_MAIN
     813        else
     814          ret = type;
     815#endif /* NO_RTCM3_MAIN */
     816      }
     817      break;
     818    case 1071: case 1081: case 1091:
     819    case 1072: case 1082: case 1092:
     820    case 1073: case 1083: case 1093:
     821    case 1074: case 1084: case 1094:
     822    case 1075: case 1085: case 1095:
     823    case 1076: case 1086: case 1096:
     824    case 1077: case 1087: case 1097:
     825      if(handle->GPSWeek)
     826      {
     827        struct CodeData {
     828          int typeR;
     829          int typeP;
     830          int typeD;
     831          int typeS;
     832          int lock;
     833          double wl;
     834          const char *code; /* currently unused */
     835        };
     836        struct CodeData gps[RTCM3_MSM_NUMSIG] =
     837        {
     838          {0,0,0,0,0,0,0},
     839          {GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
     840          GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1C"},
     841          {GNSSENTRY_P1DATA,GNSSENTRY_L1PDATA,GNSSENTRY_D1PDATA,
     842          GNSSENTRY_S1PDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1P"},
     843          {GNSSENTRY_P1DATA,GNSSENTRY_L1PDATA,GNSSENTRY_D1PDATA,
     844          GNSSENTRY_S1PDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1W"},
     845          {GNSSENTRY_P1DATA,GNSSENTRY_L1PDATA,GNSSENTRY_D1PDATA,
     846          GNSSENTRY_S1PDATA,GNSSDF2_LOCKLOSSL1,GPS_WAVELENGTH_L1,"1Y"},
     847          {0,0,0,0,0,0,0},
     848          {0,0,0,0,0,0,0},
     849          {GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
     850          GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2C"},
     851          {GNSSENTRY_P2DATA,GNSSENTRY_L2PDATA,GNSSENTRY_D2PDATA,
     852          GNSSENTRY_S2PDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2P"},
     853          {GNSSENTRY_P2DATA,GNSSENTRY_L2PDATA,GNSSENTRY_D2PDATA,
     854          GNSSENTRY_S2PDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2W"},
     855          {GNSSENTRY_P2DATA,GNSSENTRY_L2PDATA,GNSSENTRY_D2PDATA,
     856          GNSSENTRY_S2PDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2Y"},
     857          {0,0,0,0,0,0,0},
     858          {0,0,0,0,0,0,0},
     859          {0,0,0,0,0,0,0},
     860          {GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
     861          GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2S"},
     862          {GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
     863          GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2L"},
     864          {GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
     865          GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,GPS_WAVELENGTH_L2,"2X"},
     866          {0,0,0,0,0,0,0},
     867          {0,0,0,0,0,0,0},
     868          {0,0,0,0,0,0,0},
     869          {0,0,0,0,0,0,0},
     870          {GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
     871          GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5I"},
     872          {GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
     873          GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5Q"},
     874          {GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
     875          GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GPS_WAVELENGTH_L5,"5X"}
     876        };
     877        /* NOTE: Uses 0.0, 1.0 for wavelength as sat index dependence is done later! */
     878        struct CodeData glo[RTCM3_MSM_NUMSIG] =
     879        {
     880          {0,0,0,0,0,0,0},
     881          {GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
     882          GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,0.0,"1C"},
     883          {GNSSENTRY_P1DATA,GNSSENTRY_L1PDATA,GNSSENTRY_D1PDATA,
     884          GNSSENTRY_S1PDATA,GNSSDF2_LOCKLOSSL1,0.0,"1P"},
     885          {0,0,0,0,0,0,0},
     886          {0,0,0,0,0,0,0},
     887          {0,0,0,0,0,0,0},
     888          {0,0,0,0,0,0,0},
     889          {GNSSENTRY_C2DATA,GNSSENTRY_L2CDATA,GNSSENTRY_D2CDATA,
     890          GNSSENTRY_S2CDATA,GNSSDF2_LOCKLOSSL2,1.0,"2C"},
     891          {GNSSENTRY_P2DATA,GNSSENTRY_L2PDATA,GNSSENTRY_D2PDATA,
     892          GNSSENTRY_S2PDATA,GNSSDF2_LOCKLOSSL2,1.0,"2P"},
     893          {0,0,0,0,0,0,0},
     894          {0,0,0,0,0,0,0},
     895          {0,0,0,0,0,0,0},
     896          {0,0,0,0,0,0,0},
     897          {0,0,0,0,0,0,0},
     898          {0,0,0,0,0,0,0},
     899          {0,0,0,0,0,0,0},
     900          {0,0,0,0,0,0,0},
     901          {0,0,0,0,0,0,0},
     902          {0,0,0,0,0,0,0},
     903          {0,0,0,0,0,0,0},
     904          {0,0,0,0,0,0,0},
     905          {0,0,0,0,0,0,0},
     906          {0,0,0,0,0,0,0},
     907          {0,0,0,0,0,0,0}
     908        };
     909        struct CodeData gal[RTCM3_MSM_NUMSIG] =
     910        {
     911          {0,0,0,0,0,0,0},
     912          {GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
     913          GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1C"},
     914          {GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
     915          GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1A"},
     916          {GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
     917          GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1B"},
     918          {GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
     919          GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1X"},
     920          {GNSSENTRY_C1DATA,GNSSENTRY_L1CDATA,GNSSENTRY_D1CDATA,
     921          GNSSENTRY_S1CDATA,GNSSDF2_LOCKLOSSL1,GAL_WAVELENGTH_E1,"1Z"},
     922          {0,0,0,0,0,0,0},
     923          {GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
     924          GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6I"},
     925          {GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
     926          GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6Q"},
     927          {GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
     928          GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6I"},
     929          {GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
     930          GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6Q"},
     931          {GNSSENTRY_C6DATA,GNSSENTRY_L6DATA,GNSSENTRY_D6DATA,
     932          GNSSENTRY_S6DATA,GNSSDF2_LOCKLOSSE6,GAL_WAVELENGTH_E6,"6X"},
     933          {0,0,0,0,0,0,0},
     934          {GNSSENTRY_C5BDATA,GNSSENTRY_L5BDATA,GNSSENTRY_D5BDATA,
     935          GNSSENTRY_S5BDATA,GNSSDF2_LOCKLOSSE5B,GAL_WAVELENGTH_E5B,"7I"},
     936          {GNSSENTRY_C5BDATA,GNSSENTRY_L5BDATA,GNSSENTRY_D5BDATA,
     937          GNSSENTRY_S5BDATA,GNSSDF2_LOCKLOSSE5B,GAL_WAVELENGTH_E5B,"7Q"},
     938          {GNSSENTRY_C5BDATA,GNSSENTRY_L5BDATA,GNSSENTRY_D5BDATA,
     939          GNSSENTRY_S5BDATA,GNSSDF2_LOCKLOSSE5B,GAL_WAVELENGTH_E5B,"7X"},
     940          {0,0,0,0,0,0,0},
     941          {GNSSENTRY_C5ABDATA,GNSSENTRY_L5ABDATA,GNSSENTRY_D5ABDATA,
     942          GNSSENTRY_S5ABDATA,GNSSDF2_LOCKLOSSE5AB,GAL_WAVELENGTH_E5AB,"8I"},
     943          {GNSSENTRY_C5ABDATA,GNSSENTRY_L5ABDATA,GNSSENTRY_D5ABDATA,
     944          GNSSENTRY_S5ABDATA,GNSSDF2_LOCKLOSSE5AB,GAL_WAVELENGTH_E5AB,"8Q"},
     945          {GNSSENTRY_C5ABDATA,GNSSENTRY_L5ABDATA,GNSSENTRY_D5ABDATA,
     946          GNSSENTRY_S5ABDATA,GNSSDF2_LOCKLOSSE5AB,GAL_WAVELENGTH_E5AB,"8X"},
     947          {0,0,0,0,0,0,0},
     948          {GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
     949          GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GAL_WAVELENGTH_E5A,"5I"},
     950          {GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
     951          GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GAL_WAVELENGTH_E5A,"5Q"},
     952          {GNSSENTRY_C5DATA,GNSSENTRY_L5DATA,GNSSENTRY_D5DATA,
     953          GNSSENTRY_S5DATA,GNSSDF2_LOCKLOSSL5,GAL_WAVELENGTH_E5A,"5X"},
     954        };
     955
     956        int sys = RTCM3_MSM_GPS, i, count, j, old = 0, wasamb = 0;
     957        int syncf, sigmask, numsat = 0, numsig = 0, numcells;
     958        uint64_t satmask, cellmask, ui;
     959        double rrmod[RTCM3_MSM_NUMSAT];
     960        int rrint[RTCM3_MSM_NUMSAT], rdop[RTCM3_MSM_NUMSAT];
     961        int ll[RTCM3_MSM_NUMCELLS];
     962        double cnr[RTCM3_MSM_NUMCELLS];
     963        double cp[RTCM3_MSM_NUMCELLS], psr[RTCM3_MSM_NUMCELLS],
     964        dop[RTCM3_MSM_NUMCELLS];
     965        struct gnssdata *gnss = &handle->DataNew;
     966
     967        SKIPBITS(12)
     968        if(type >= 1091)
     969          sys = RTCM3_MSM_GALILEO;
     970        else if(type >= 1081)
     971          sys = RTCM3_MSM_GLONASS;
     972
     973        switch(sys)
     974        {
     975        case RTCM3_MSM_GALILEO: /* use DF004 instead of DF248 */
     976        case RTCM3_MSM_GPS:
     977          GETBITS(i,30)
     978          if(i/1000 < (int)handle->GPSTOW - 86400)
     979            ++handle->GPSWeek;
     980          handle->GPSTOW = i/1000;
     981          break;
     982        case RTCM3_MSM_GLONASS:
     983          SKIPBITS(3)
     984          GETBITS(i,27) /* tk */
     985
     986          updatetime(&handle->GPSWeek, &handle->GPSTOW, i, 0); /* Moscow -> GPS */
     987          i = handle->GPSTOW*1000;
     988          break;
     989        }
     990
     991        if(gnss->week && (gnss->timeofweek != i || gnss->week
     992        != handle->GPSWeek))
     993        {
     994          handle->Data = *gnss;
     995          memset(gnss, 0, sizeof(*gnss));
     996          old = 1;
     997        }
     998        gnss->timeofweek = i;
     999        gnss->week = handle->GPSWeek;
     1000
     1001        GETBITS(syncf, 1)
     1002        if(((type % 10) == 6) || ((type % 10) == 7))
     1003          SKIPBITS(3)
     1004        GETBITS(satmask, RTCM3_MSM_NUMSAT)
     1005
     1006        /* http://gurmeetsingh.wordpress.com/2008/08/05/fast-bit-counting-routines/ */
     1007        for(ui = satmask; ui; ui &= (ui - 1) /* remove rightmost bit */)
     1008          ++numsat;
     1009        GETBITS(sigmask, RTCM3_MSM_NUMSIG)
     1010        for(i = sigmask; i; i &= (i - 1) /* remove rightmost bit */)
     1011          ++numsig;
     1012        i = numsat*numsig;
     1013        GETBITS(cellmask, (unsigned)i)
     1014
     1015        switch(type % 10)
     1016        {
     1017        case 1: case 2: case 3:
     1018          ++wasamb;
     1019          for(j = numsat; j--;)
     1020            GETFLOAT(rrmod[j], 10, 1/1024.0)
     1021          break;
     1022        case 4: case 6:
     1023          for(j = numsat; j--;)
     1024            GETBITS(rrint[j], 8)
     1025          for(j = numsat; j--;)
     1026            GETFLOAT(rrmod[j], 10, 1/1024.0)
     1027          break;
     1028        case 5: case 7:
     1029          for(j = numsat; j--;)
     1030            GETBITS(rrint[j], 8)
     1031          for(j = numsat; j--;)
     1032            GETFLOAT(rrmod[j], 10, 1/1024.0)
     1033          for(j = numsat; j--;)
     1034            GETBITSSIGN(rdop[j], 14)
     1035          break;
     1036        }
     1037
     1038        numcells = numsat*numsig;
     1039        if(numcells <= RTCM3_MSM_NUMCELLS)
     1040        {
     1041          switch(type % 10)
     1042          {
     1043          case 1:
     1044            for(count = numcells; count--;)
     1045              if(cellmask & (UINT64(1)<<count))
     1046                GETFLOATSIGN(psr[count], 15, 0.02)
     1047            break;
     1048          case 2:
     1049            for(count = numcells; count--;)
     1050              if(cellmask & (UINT64(1)<<count))
     1051                GETFLOATSIGN(cp[count], 20, 1/256.0)
     1052            for(count = numcells; count--;)
     1053              if(cellmask & (UINT64(1)<<count))
     1054                GETBITS(ll[count], 4)
     1055            break;
     1056          case 3:
     1057            for(count = numcells; count--;)
     1058              if(cellmask & (UINT64(1)<<count))
     1059                GETFLOATSIGN(psr[count], 15, 0.02)
     1060            for(count = numcells; count--;)
     1061              if(cellmask & (UINT64(1)<<count))
     1062                GETFLOATSIGN(cp[count], 20, 1/256.0)
     1063            for(count = numcells; count--;)
     1064              if(cellmask & (UINT64(1)<<count))
     1065                GETBITS(ll[count], 4)
     1066            break;
     1067          case 4:
     1068            for(count = numcells; count--;)
     1069              if(cellmask & (UINT64(1)<<count))
     1070                GETFLOATSIGN(psr[count], 15, 0.02)
     1071            for(count = numcells; count--;)
     1072              if(cellmask & (UINT64(1)<<count))
     1073                GETFLOATSIGN(cp[count], 20, 1/256.0)
     1074            for(count = numcells; count--;)
     1075              if(cellmask & (UINT64(1)<<count))
     1076                GETBITS(ll[count], 4)
     1077            for(count = numcells; count--;)
     1078              if(cellmask & (UINT64(1)<<count))
     1079                GETBITS(cnr[count], 6)
     1080            break;
     1081          case 5:
     1082            for(count = numcells; count--;)
     1083              if(cellmask & (UINT64(1)<<count))
     1084                GETFLOATSIGN(psr[count], 15, 0.02)
     1085            for(count = numcells; count--;)
     1086              if(cellmask & (UINT64(1)<<count))
     1087                GETFLOATSIGN(cp[count], 20, 1/256.0)
     1088            for(count = numcells; count--;)
     1089              if(cellmask & (UINT64(1)<<count))
     1090                GETBITS(ll[count], 4)
     1091            for(count = numcells; count--;)
     1092              if(cellmask & (UINT64(1)<<count))
     1093                GETFLOAT(cnr[count], 6, 1.0)
     1094            for(count = numcells; count--;)
     1095              if(cellmask & (UINT64(1)<<count))
     1096                GETFLOATSIGN(dop[count], 15, 0.0001)
     1097            break;
     1098          case 6:
     1099            for(count = numcells; count--;)
     1100              if(cellmask & (UINT64(1)<<count))
     1101                GETFLOATSIGN(psr[count], 20, 0.001)
     1102            for(count = numcells; count--;)
     1103              if(cellmask & (UINT64(1)<<count))
     1104                GETFLOATSIGN(cp[count], 22, 1/1024.0)
     1105            for(count = numcells; count--;)
     1106              if(cellmask & (UINT64(1)<<count))
     1107                GETBITS(ll[count], 10)
     1108            for(count = numcells; count--;)
     1109              if(cellmask & (UINT64(1)<<count))
     1110                GETFLOAT(cnr[count], 10, 0.1)
     1111          case 7:
     1112            for(count = numcells; count--;)
     1113              if(cellmask & (UINT64(1)<<count))
     1114                GETFLOATSIGN(psr[count], 20, 0.001)
     1115            for(count = numcells; count--;)
     1116              if(cellmask & (UINT64(1)<<count))
     1117                GETFLOATSIGN(cp[count], 22, 1/1024.0)
     1118            for(count = numcells; count--;)
     1119              if(cellmask & (UINT64(1)<<count))
     1120                GETBITS(ll[count], 10)
     1121            for(count = numcells; count--;)
     1122              if(cellmask & (UINT64(1)<<count))
     1123                GETFLOAT(cnr[count], 10, 0.1)
     1124            for(count = numcells; count--;)
     1125              if(cellmask & (UINT64(1)<<count))
     1126                GETFLOATSIGN(dop[count], 15, 0.0001)
     1127            break;
     1128          }
     1129          i = RTCM3_MSM_NUMSAT;
     1130          j = -1;
     1131          for(count = numcells; count--;)
     1132          {
     1133            while(j >= 0 && !(sigmask&(1<<--j)))
     1134              ;
     1135            if(j < 0)
     1136            {
     1137              while(!(satmask&(UINT64(1)<<(--i)))) /* next satellite */
     1138                ;
     1139              j = RTCM3_MSM_NUMSIG;
     1140              while(!(sigmask&(1<<--j)))
     1141                ;
     1142              --numsat;
     1143            }
     1144            if(cellmask & (UINT64(1)<<count))
     1145            {
     1146              struct CodeData cd = {0,0,0,0,0,0,0};
     1147              double wl = 0.0;
     1148              switch(sys)
     1149              {
     1150              case RTCM3_MSM_GPS: cd = gps[RTCM3_MSM_NUMSIG-j-1];
     1151                wl = cd.wl;
     1152                break;
     1153              case RTCM3_MSM_GLONASS: cd = glo[RTCM3_MSM_NUMSIG-j-1];
     1154                {
     1155                  int k = handle->GLOFreq[RTCM3_MSM_NUMSAT-i-1];
     1156                  if(k)
     1157                  {
     1158                    if(cd.wl == 0.0)
     1159                      wl = GLO_WAVELENGTH_L1(k-100);
     1160                    else if(cd.wl == 1.0)
     1161                      wl = GLO_WAVELENGTH_L2(k-100);
     1162                  }
     1163                }
     1164                break;
     1165              case RTCM3_MSM_GALILEO: cd = gal[RTCM3_MSM_NUMSIG-j-1];
     1166                wl = cd.wl;
     1167                break;
     1168              }
     1169              if(cd.lock && wl) /* lock cannot have a valid zero value */
     1170              {
     1171                int fullsat = sys+RTCM3_MSM_NUMSAT-i-1, num;
     1172                for(num = 0; num < gnss->numsats
     1173                && fullsat != gnss->satellites[num]; ++num)
     1174                  ;
     1175
     1176                if(num == gnss->numsats)
     1177                  gnss->satellites[gnss->numsats++] = fullsat;
     1178
     1179                switch(type % 10)
     1180                {
     1181                case 1:
     1182                  if(psr[count] > -327.68)
     1183                  {
     1184                    gnss->measdata[num][cd.typeR] = psr[count]
     1185                    +(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
     1186                    gnss->dataflags[num] |= (1<<cd.typeR);
     1187                  }
     1188                  break;
     1189                case 2:
     1190                  if(wl && cp[count] > -2048.0)
     1191                  {
     1192                    gnss->measdata[num][cd.typeP] = cp[count]
     1193                    +(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
     1194                    if(handle->lastlockmsm[j][i] != ll[count])
     1195                    {
     1196                      gnss->dataflags2[num] |= cd.lock;
     1197                      handle->lastlockmsm[j][i] = ll[count];
     1198                    }
     1199                    gnss->dataflags[num] |= (1<<cd.typeP);
     1200                  }
     1201                  break;
     1202                case 3:
     1203                  if(psr[count] > -327.68)
     1204                  {
     1205                    gnss->measdata[num][cd.typeR] = psr[count]
     1206                    +(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
     1207                    gnss->dataflags[num] |= (1<<cd.typeR);
     1208                  }
     1209
     1210                  if(wl && cp[count] > -2048.0)
     1211                  {
     1212                    gnss->measdata[num][cd.typeP] = cp[count]
     1213                    +(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
     1214                    if(handle->lastlockmsm[j][i] != ll[count])
     1215                    {
     1216                      gnss->dataflags2[num] |= cd.lock;
     1217                      handle->lastlockmsm[j][i] = ll[count];
     1218                    }
     1219                    gnss->dataflags[num] |= (1<<cd.typeP);
     1220                  }
     1221                  break;
     1222                case 4:
     1223                  if(psr[count] > -327.68)
     1224                  {
     1225                    gnss->measdata[num][cd.typeR] = psr[count]
     1226                    +(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
     1227                    gnss->dataflags[num] |= (1<<cd.typeR);
     1228                  }
     1229
     1230                  if(wl && cp[count] > -2048.0)
     1231                  {
     1232                    gnss->measdata[num][cd.typeP] = cp[count]
     1233                    +(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
     1234                    if(handle->lastlockmsm[j][i] != ll[count])
     1235                    {
     1236                      gnss->dataflags2[num] |= cd.lock;
     1237                      handle->lastlockmsm[j][i] = ll[count];
     1238                    }
     1239                    gnss->dataflags[num] |= (1<<cd.typeP);
     1240                  }
     1241
     1242                  gnss->measdata[num][cd.typeS] = cnr[count];
     1243                    gnss->dataflags[num] |= (1<<cd.typeS);
     1244                  break;
     1245                case 5:
     1246                  if(psr[count] > -327.68)
     1247                  {
     1248                    gnss->measdata[num][cd.typeR] = psr[count]
     1249                    +(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
     1250                    gnss->dataflags[num] |= (1<<cd.typeR);
     1251                  }
     1252
     1253                  if(wl && cp[count] > -2048.0)
     1254                  {
     1255                    gnss->measdata[num][cd.typeP] = cp[count]
     1256                    +(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
     1257                    if(handle->lastlockmsm[j][i] != ll[count])
     1258                    {
     1259                      gnss->dataflags2[num] |= cd.lock;
     1260                      handle->lastlockmsm[j][i] = ll[count];
     1261                    }
     1262                    gnss->dataflags[num] |= (1<<cd.typeP);
     1263                  }
     1264
     1265                  gnss->measdata[num][cd.typeS] = cnr[count];
     1266                    gnss->dataflags[num] |= (1<<cd.typeS);
     1267
     1268                  if(dop[count] > -1.6384)
     1269                  {
     1270                    gnss->measdata[num][cd.typeD] = dop[count]+rdop[numsat];
     1271                    gnss->dataflags[num] |= (1<<cd.typeD);
     1272                  }
     1273                  break;
     1274                case 6:
     1275                  if(psr[count] > -524.288)
     1276                  {
     1277                    gnss->measdata[num][cd.typeR] = psr[count]
     1278                    +(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
     1279                    gnss->dataflags[num] |= (1<<cd.typeR);
     1280                  }
     1281
     1282                  if(wl && cp[count] > -2055.0)
     1283                  {
     1284                    gnss->measdata[num][cd.typeP] = cp[count]
     1285                    +(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
     1286                    if(handle->lastlockmsm[j][i] != ll[count])
     1287                    {
     1288                      gnss->dataflags2[num] |= cd.lock;
     1289                      handle->lastlockmsm[j][i] = ll[count];
     1290                    }
     1291                    gnss->dataflags[num] |= (1<<cd.typeP);
     1292                  }
     1293
     1294                  gnss->measdata[num][cd.typeS] = cnr[count];
     1295                    gnss->dataflags[num] |= (1<<cd.typeS);
     1296                  break;
     1297                case 7:
     1298                  if(psr[count] > -524.288)
     1299                  {
     1300                    gnss->measdata[num][cd.typeR] = psr[count]
     1301                    +(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0;
     1302                    gnss->dataflags[num] |= (1<<cd.typeR);
     1303                  }
     1304
     1305                  if(wl && cp[count] > -2055.0)
     1306                  {
     1307                    gnss->measdata[num][cd.typeP] = cp[count]
     1308                    +(rrmod[numsat]+rrint[numsat])*LIGHTSPEED/1000.0/wl;
     1309                    if(handle->lastlockmsm[j][i] != ll[count])
     1310                    {
     1311                      gnss->dataflags2[num] |= cd.lock;
     1312                      handle->lastlockmsm[j][i] = ll[count];
     1313                    }
     1314                    gnss->dataflags[num] |= (1<<cd.typeP);
     1315                  }
     1316
     1317                  gnss->measdata[num][cd.typeS] = cnr[count];
     1318                    gnss->dataflags[num] |= (1<<cd.typeS);
     1319
     1320                  if(dop[count] > -1.6384)
     1321                  {
     1322                    gnss->measdata[num][cd.typeD] = dop[count]+rdop[numsat];
     1323                    gnss->dataflags[num] |= (1<<cd.typeD);
     1324                  }
     1325                  break;
     1326                }
     1327              }
     1328            }
     1329          }
    7971330        }
    7981331        if(!syncf && !old)
     
    10181551    CHECKFLAGS(S2C,S2)
    10191552    CHECKFLAGS(S2P,S2)
     1553    CHECKFLAGS(C5,C5)
     1554    CHECKFLAGS(L5,L5)
     1555    CHECKFLAGS(D5,D5)
     1556    CHECKFLAGS(S5,S5)
     1557    CHECKFLAGS(C5AB,C5AB)
     1558    CHECKFLAGS(L5AB,L5AB)
     1559    CHECKFLAGS(D5AB,D5AB)
     1560    CHECKFLAGS(S5AB,S5AB)
     1561    CHECKFLAGS(C5B,C5B)
     1562    CHECKFLAGS(L5B,L5B)
     1563    CHECKFLAGS(D5B,D5B)
     1564    CHECKFLAGS(S5B,S5B)
     1565    CHECKFLAGS(C6,C6)
     1566    CHECKFLAGS(L6,L6)
     1567    CHECKFLAGS(D6,D6)
     1568    CHECKFLAGS(S6,S6)
    10201569  }
    10211570#else /* NO_RTCM3_MAIN */
     
    11991748    CHECKFLAGS(S2C,S2)
    12001749    CHECKFLAGS(S2P,S2)
     1750    CHECKFLAGS(C5,C5)
     1751    CHECKFLAGS(L5,L5)
     1752    CHECKFLAGS(D5,D5)
     1753    CHECKFLAGS(S5,S5)
     1754    CHECKFLAGS(C5AB,C5AB)
     1755    CHECKFLAGS(L5AB,L5AB)
     1756    CHECKFLAGS(D5AB,D5AB)
     1757    CHECKFLAGS(S5AB,S5AB)
     1758    CHECKFLAGS(C5B,C5B)
     1759    CHECKFLAGS(L5B,L5B)
     1760    CHECKFLAGS(D5B,D5B)
     1761    CHECKFLAGS(S5B,S5B)
     1762    CHECKFLAGS(C6,C6)
     1763    CHECKFLAGS(L6,L6)
     1764    CHECKFLAGS(D6,D6)
     1765    CHECKFLAGS(S6,S6)
    12011766
    12021767    hdata.data.named.typesofobs = buffer;
     
    15502115                  if(df & (GNSSDF_L1CDATA|GNSSDF_L1PDATA))
    15512116                  {
    1552                     if(Parser->Data.dataflags[i] & GNSSDF_LOCKLOSSL1)
     2117                    if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
    15532118                      lli = '1';
    15542119                    snr = '0'+Parser->Data.snrL1[i];
     
    15562121                  if(df & (GNSSDF_L2CDATA|GNSSDF_L2PDATA))
    15572122                  {
    1558                     if(Parser->Data.dataflags[i] & GNSSDF_LOCKLOSSL2)
     2123                    if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL2)
    15592124                      lli = '1';
    15602125                    snr = '0'+Parser->Data.snrL2[i];
     
    15832148                  if(df & (GNSSDF_L1CDATA|GNSSDF_L1PDATA))
    15842149                  {
    1585                     if(Parser->Data.dataflags[i] & GNSSDF_LOCKLOSSL1)
     2150                    if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
    15862151                      lli = '1';
    15872152                    snr = '0'+Parser->Data.snrL1[i];
     
    15892154                  if(df & (GNSSDF_L2CDATA|GNSSDF_L2PDATA))
    15902155                  {
    1591                     if(Parser->Data.dataflags[i] & GNSSDF_LOCKLOSSL2)
     2156                    if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL2)
    15922157                      lli = '1';
    15932158                    snr = '0'+Parser->Data.snrL2[i];
     
    16162181            else if(Parser->Data.satellites[i] >= PRN_GLONASS_START
    16172182            && Parser->Data.satellites[i] <= PRN_GLONASS_END)
    1618               RTCM3Text("R%02d", Parser->Data.satellites[i] - (PRN_GLONASS_START-1));
     2183              RTCM3Text("R%02d", Parser->Data.satellites[i]
     2184              - (PRN_GLONASS_START-1));
    16192185            else if(Parser->Data.satellites[i] >= PRN_WAAS_START
    16202186            && Parser->Data.satellites[i] <= PRN_WAAS_END)
    1621               RTCM3Text("S%02d", Parser->Data.satellites[i] - PRN_WAAS_START+20);
     2187              RTCM3Text("S%02d", Parser->Data.satellites[i]
     2188              - PRN_WAAS_START+20);
     2189            else if(Parser->Data.satellites[i] >= PRN_GALILEO_START
     2190            && Parser->Data.satellites[i] <= PRN_GALILEO_END)
     2191              RTCM3Text("E%02d", Parser->Data.satellites[i]
     2192              - (PRN_GALILEO_START-1));
     2193            else if(Parser->Data.satellites[i] >= PRN_GIOVE_START
     2194            && Parser->Data.satellites[i] <= PRN_GIOVE_END)
     2195              RTCM3Text("E%02d", Parser->Data.satellites[i]
     2196              - (PRN_GIOVE_START-PRN_GIOVE_OFFSET));
    16222197            else
    16232198              RTCM3Text("%3d", Parser->Data.satellites[i]);
     
    16352210              else if(Parser->Data.satellites[i] >= PRN_GLONASS_START
    16362211              && Parser->Data.satellites[i] <= PRN_GLONASS_END)
    1637                 RTCM3Text("R%02d", Parser->Data.satellites[i] - (PRN_GLONASS_START-1));
     2212                RTCM3Text("R%02d", Parser->Data.satellites[i]
     2213                - (PRN_GLONASS_START-1));
    16382214              else if(Parser->Data.satellites[i] >= PRN_WAAS_START
    16392215              && Parser->Data.satellites[i] <= PRN_WAAS_END)
    1640                 RTCM3Text("S%02d", Parser->Data.satellites[i] - PRN_WAAS_START+20);
     2216                RTCM3Text("S%02d", Parser->Data.satellites[i]
     2217                - PRN_WAAS_START+20);
     2218              else if(Parser->Data.satellites[i] >= PRN_GALILEO_START
     2219              && Parser->Data.satellites[i] <= PRN_GALILEO_END)
     2220                RTCM3Text("E%02d", Parser->Data.satellites[i]
     2221                - (PRN_GALILEO_START-1));
     2222              else if(Parser->Data.satellites[i] >= PRN_GIOVE_START
     2223              && Parser->Data.satellites[i] <= PRN_GIOVE_END)
     2224                RTCM3Text("E%02d", Parser->Data.satellites[i]
     2225                - (PRN_GIOVE_START-PRN_GIOVE_OFFSET));
    16412226              else
    16422227                RTCM3Text("%3d", Parser->Data.satellites[i]);
     
    16822267                if(df & (GNSSDF_L1CDATA|GNSSDF_L1PDATA))
    16832268                {
    1684                   if(Parser->Data.dataflags[i] & GNSSDF_LOCKLOSSL1)
     2269                  if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
    16852270                    lli = '1';
    16862271                  snr = '0'+Parser->Data.snrL1[i];
     
    16882273                if(df & (GNSSDF_L2CDATA|GNSSDF_L2PDATA))
    16892274                {
    1690                   if(Parser->Data.dataflags[i] & (GNSSDF_LOCKLOSSL2|GNSSDF_XCORRL2))
     2275                  if(Parser->Data.dataflags2[i]
     2276                  & (GNSSDF2_LOCKLOSSL2|GNSSDF2_XCORRL2))
    16912277                  {
    16922278                    lli = '0';
    1693                     if(Parser->Data.dataflags[i] & GNSSDF_LOCKLOSSL2)
     2279                    if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL2)
    16942280                      lli += 1;
    1695                     if(Parser->Data.dataflags[i] & GNSSDF_XCORRL2)
     2281                    if(Parser->Data.dataflags2[i] & GNSSDF2_XCORRL2)
    16962282                      lli += 4;
    16972283                  }
    16982284                  snr = '0'+Parser->Data.snrL2[i];
    16992285                }
    1700                 if((df & GNSSDF_P2DATA) && (Parser->Data.dataflags[i] & GNSSDF_XCORRL2))
     2286                if((df & GNSSDF_P2DATA) && (Parser->Data.dataflags2[i]
     2287                & GNSSDF2_XCORRL2))
    17012288                  lli = '4';
    17022289                RTCM3Text("%14.3f%c%c",
  • trunk/rtcm3torinex/lib/rtcm3torinex.h

    r2502 r2659  
    2727#include <stdio.h>
    2828
     29#define NUMRTCM3PARSERSATS    144
    2930#define GNSS_MAXSATS 64
    3031
     
    3334#define PRN_GLONASS_START         38
    3435#define PRN_GLONASS_END           61
     36#define PRN_GALILEO_START         71
     37#define PRN_GALILEO_END           100
    3538#define PRN_WAAS_START            120
    3639#define PRN_WAAS_END              138
     40#define PRN_GIOVE_START           139
     41#define PRN_GIOVE_END             140
     42
     43#define PRN_GLONASS_NUM           (PRN_GLONASS_END-PRN_GLONASS_START+1)
     44
     45#define RTCM3_MSM_NUMSIG      24
     46#define RTCM3_MSM_NUMSAT      40
     47#define RTCM3_MSM_NUMCELLS    64
     48
     49/* system identifiers, use start PRN as value */
     50#define RTCM3_MSM_GPS     PRN_GPS_START
     51#define RTCM3_MSM_GLONASS PRN_GLONASS_START
     52#define RTCM3_MSM_GALILEO PRN_GALILEO_START
    3753
    3854#define GNSSENTRY_C1DATA     0
     
    5268#define GNSSENTRY_S2CDATA    14
    5369#define GNSSENTRY_S2PDATA    15
    54 #define GNSSENTRY_NUMBER     16 /* number of types!!! */
     70
     71#define GNSSENTRY_C5DATA     16
     72#define GNSSENTRY_L5DATA     17
     73#define GNSSENTRY_D5DATA     18
     74#define GNSSENTRY_S5DATA     19
     75#define GNSSENTRY_C6DATA     20
     76#define GNSSENTRY_L6DATA     21
     77#define GNSSENTRY_D6DATA     22
     78#define GNSSENTRY_S6DATA     23
     79#define GNSSENTRY_C5BDATA    24
     80#define GNSSENTRY_L5BDATA    25
     81#define GNSSENTRY_D5BDATA    26
     82#define GNSSENTRY_S5BDATA    27
     83#define GNSSENTRY_C5ABDATA   28
     84#define GNSSENTRY_L5ABDATA   29
     85#define GNSSENTRY_D5ABDATA   30
     86#define GNSSENTRY_S5ABDATA   31
     87
     88#define GNSSENTRY_NUMBER     32 /* number of types!!! */
    5589
    5690/* Data flags. These flags are used in the dataflags field of gpsdata structure
    57    and are used the determine, which data fields are filled with valid data. */
     91   and are required to determine, which data fields are filled with valid data. */
    5892#define GNSSDF_C1DATA         (1<<GNSSENTRY_C1DATA)
    5993#define GNSSDF_C2DATA         (1<<GNSSENTRY_C2DATA)
     
    73107#define GNSSDF_S2PDATA        (1<<GNSSENTRY_S2PDATA)
    74108
     109#define GNSSDF_C5DATA         (1<<GNSSENTRY_C5DATA)
     110#define GNSSDF_L5DATA         (1<<GNSSENTRY_L5DATA)
     111#define GNSSDF_D5DATA         (1<<GNSSENTRY_D5DATA)
     112#define GNSSDF_S5DATA         (1<<GNSSENTRY_S5DATA)
     113#define GNSSDF_C6DATA         (1<<GNSSENTRY_C6DATA)
     114#define GNSSDF_L6DATA         (1<<GNSSENTRY_L6DATA)
     115#define GNSSDF_D6DATA         (1<<GNSSENTRY_D6DATA)
     116#define GNSSDF_S6DATA         (1<<GNSSENTRY_S6DATA)
     117#define GNSSDF_C5BDATA        (1<<GNSSENTRY_C5BDATA)
     118#define GNSSDF_L5BDATA        (1<<GNSSENTRY_L5BDATA)
     119#define GNSSDF_D5BDATA        (1<<GNSSENTRY_D5BDATA)
     120#define GNSSDF_S5BDATA        (1<<GNSSENTRY_S5BDATA)
     121#define GNSSDF_C5ABDATA       (1<<GNSSENTRY_C5ABDATA)
     122#define GNSSDF_L5ABDATA       (1<<GNSSENTRY_L5ABDATA)
     123#define GNSSDF_D5ABDATA       (1<<GNSSENTRY_D5ABDATA)
     124#define GNSSDF_S5ABDATA       (1<<GNSSENTRY_S5ABDATA)
     125
    75126#define RINEXENTRY_C1DATA     0
    76127#define RINEXENTRY_C2DATA     1
     
    83134#define RINEXENTRY_S1DATA     8
    84135#define RINEXENTRY_S2DATA     9
    85 #define RINEXENTRY_NUMBER     10
     136
     137#define RINEXENTRY_C5DATA     10
     138#define RINEXENTRY_L5DATA     11
     139#define RINEXENTRY_D5DATA     12
     140#define RINEXENTRY_S5DATA     13
     141#define RINEXENTRY_C6DATA     14
     142#define RINEXENTRY_L6DATA     15
     143#define RINEXENTRY_D6DATA     16
     144#define RINEXENTRY_S6DATA     17
     145#define RINEXENTRY_C5BDATA    18
     146#define RINEXENTRY_L5BDATA    19
     147#define RINEXENTRY_D5BDATA    20
     148#define RINEXENTRY_S5BDATA    21
     149#define RINEXENTRY_C5ABDATA   22
     150#define RINEXENTRY_L5ABDATA   23
     151#define RINEXENTRY_D5ABDATA   24
     152#define RINEXENTRY_S5ABDATA   25
     153
     154#define RINEXENTRY_NUMBER     26
    86155
    87156#define LIGHTSPEED         2.99792458e8    /* m/sec */
    88157#define GPS_FREQU_L1       1575420000.0  /* Hz */
    89158#define GPS_FREQU_L2       1227600000.0  /* Hz */
     159#define GPS_FREQU_L5       1176450000.0  /* Hz */
    90160#define GPS_WAVELENGTH_L1  (LIGHTSPEED / GPS_FREQU_L1) /* m */
    91161#define GPS_WAVELENGTH_L2  (LIGHTSPEED / GPS_FREQU_L2) /* m */
     162#define GPS_WAVELENGTH_L5  (LIGHTSPEED / GPS_FREQU_L5) /* m */
    92163
    93164#define GLO_FREQU_L1_BASE  1602000000.0  /* Hz */
     
    100171#define GLO_WAVELENGTH_L2(a) (LIGHTSPEED / GLO_FREQU_L2(a)) /* m */
    101172
     173#define GAL_FREQU_E1       1575420000.0  /* Hz */
     174#define GAL_FREQU_E5A      1176450000.0  /* Hz */
     175#define GAL_FREQU_E5AB     1197950000.0  /* Hz */
     176#define GAL_FREQU_E5B      1207140000.0  /* Hz */
     177#define GAL_FREQU_E6       1278750000.0  /* Hz */
     178#define GAL_WAVELENGTH_E1     (LIGHTSPEED / GAL_FREQU_E1) /* m */
     179#define GAL_WAVELENGTH_E5A    (LIGHTSPEED / GAL_FREQU_E5A) /* m */
     180#define GAL_WAVELENGTH_E5AB   (LIGHTSPEED / GAL_FREQU_E5AB) /* m */
     181#define GAL_WAVELENGTH_E5B    (LIGHTSPEED / GAL_FREQU_E5B) /* m */
     182#define GAL_WAVELENGTH_E6     (LIGHTSPEED / GAL_FREQU_E6) /* m */
     183
     184#define PRN_GIOVE_OFFSET 51
     185
    102186/* Additional flags for the data field, which tell us more. */
    103 #define GNSSDF_XCORRL2        (1<<28)  /* cross-correlated L2 */
    104 #define GNSSDF_LOCKLOSSL1     (1<<29)  /* lost lock on L1 */
    105 #define GNSSDF_LOCKLOSSL2     (1<<30)  /* lost lock on L2 */
     187#define GNSSDF2_XCORRL2        (1<<0)  /* cross-correlated L2 */
     188#define GNSSDF2_LOCKLOSSL1     (1<<1)  /* lost lock on L1 */
     189#define GNSSDF2_LOCKLOSSL2     (1<<2)  /* lost lock on L2 */
     190#define GNSSDF2_LOCKLOSSL5     (1<<3)  /* lost lock on L5 */
     191#define GNSSDF2_LOCKLOSSE6     (1<<4)  /* lost lock on E6 */
     192#define GNSSDF2_LOCKLOSSE5B    (1<<5)  /* lost lock on E5B */
     193#define GNSSDF2_LOCKLOSSE5AB   (1<<6)  /* lost lock on E5AB */
     194
     195#define UINT64(c) c ## ULL
    106196
    107197struct converttimeinfo {
     
    115205
    116206struct gnssdata {
    117   int    flags;              /* GPSF_xxx */
     207  int    flags;              /* GNSSF_xxx */
    118208  int    week;               /* week number of GPS date */
    119209  int    numsats;
    120210  double timeofweek;         /* milliseconds in GPS week */
    121211  double measdata[GNSS_MAXSATS][GNSSENTRY_NUMBER];  /* data fields */
    122   int    dataflags[GNSS_MAXSATS];      /* GPSDF_xxx */
     212  unsigned int dataflags[GNSS_MAXSATS];      /* GNSSDF_xxx */
     213  unsigned int dataflags2[GNSS_MAXSATS];     /* GNSSDF2_xxx */
    123214  int    satellites[GNSS_MAXSATS];     /* SV - IDs */
    124215  int    channels[GNSS_MAXSATS];       /* Glonass channels - valid of Glonass SV only */
     
    208299  struct glonassephemeris ephemerisGLONASS;
    209300  struct gnssdata DataNew;
     301  int    GLOFreq[PRN_GLONASS_NUM]; /* frequency numbers of GLONASS + 100 */
    210302  int    size;
    211303  int    lastlockGPSl1[64];
     
    213305  int    lastlockGLOl1[64];
    214306  int    lastlockGLOl2[64];
     307  int    lastlockmsm[RTCM3_MSM_NUMCELLS][NUMRTCM3PARSERSATS];
    215308#ifdef NO_RTCM3_MAIN
    216309  double antX;
Note: See TracChangeset for help on using the changeset viewer.