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

first test of MSM messages

File:
1 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",
Note: See TracChangeset for help on using the changeset viewer.