Changeset 4371 in ntrip for trunk/rtcm3torinex


Ignore:
Timestamp:
Jul 3, 2012, 2:10:38 PM (8 years ago)
Author:
stoecker
Message:

add RINEX3 code type support

Location:
trunk/rtcm3torinex/lib
Files:
2 edited

Legend:

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

    r4370 r4371  
    11561156        };
    11571157
    1158         int sys = RTCM3_MSM_GPS, i=0, count, j, old = 0, wasnoamb = 0;
     1158        int sys = RTCM3_MSM_GPS, i=0, count, j, old = 0, wasnoamb = 0,
     1159        start=PRN_GPS_START;
    11591160        int syncf, sigmask, numsat = 0, numsig = 0, numcells;
    11601161        uint64_t satmask, cellmask, ui;
     
    11701171        SKIPBITS(12)
    11711172        if(type >= 1121)
     1173        {
    11721174          sys = RTCM3_MSM_COMPASS;
     1175          start = PRN_COMPASS_START;
     1176        }
    11731177        else if(type >= 1111)
     1178        {
    11741179          sys = RTCM3_MSM_QZSS;
     1180          start = PRN_QZSS_START;
     1181        }
    11751182        else if(type >= 1101)
     1183        {
    11761184          sys = RTCM3_MSM_SBAS;
     1185          start = PRN_SBAS_START;
     1186        }
    11771187        else if(type >= 1091)
     1188        {
    11781189          sys = RTCM3_MSM_GALILEO;
     1190          start = PRN_GALILEO_START;
     1191        }
    11791192        else if(type >= 1081)
     1193        {
    11801194          sys = RTCM3_MSM_GLONASS;
     1195          start = PRN_GLONASS_START;
     1196        }
    11811197
    11821198        switch(sys)
     
    14201436                  fullsat += PRN_GIOVE_START-50;
    14211437                else
    1422                   fullsat += sys;
     1438                  fullsat += start;
    14231439
    14241440                for(num = 0; num < gnss->numsats
     
    14301446
    14311447                gnss->codetype[num] = cd.code;
     1448                if(!handle->info[sys].type[cd.typeR])
     1449                {
     1450                  handle->info[sys].type[cd.typeR] =
     1451                  handle->info[sys].type[cd.typeP] =
     1452                  handle->info[sys].type[cd.typeD] =
     1453                  handle->info[sys].type[cd.typeS] = cd.code[1];
     1454                }
    14321455
    14331456                switch(type % 10)
     
    17111734  return 1+snprintf(buffer, buffersize,
    17121735  rinex3 ?
    1713   "RTCM3TOR. %-10.10s%-20.20s%04d%02d%02d %02d%02d%02d UTC "
     1736  "RTCM3TORINEX %-7.7s%-20.20s%04d%02d%02d %02d%02d%02d UTC "
    17141737  "PGM / RUN BY / DATE" :
    1715   "RTCM3TOR. %-10.10s%-20.20s%04d-%02d-%02d %02d:%02d    "
     1738  "RTCM3TORINEX %-7.7s%-20.20s%04d-%02d-%02d %02d:%02d    "
    17161739  "PGM / RUN BY / DATE", revisionstr, user, 1900+t2->tm_year,
    17171740  t2->tm_mon+1, t2->tm_mday, t2->tm_hour, t2->tm_min, t2->tm_sec);
     
    17351758    if(Parser->allflags & GNSSDF_##b##DATA) \
    17361759    { \
    1737       Parser->dataflag##a[Parser->numdatatypes##a] = GNSSDF_##b##DATA; \
    1738       Parser->datapos##a[Parser->numdatatypes##a] = GNSSENTRY_##b##DATA; \
    1739       ++Parser->numdatatypes##a; \
     1760      Parser->info[RTCM3_MSM_##a].flags[Parser->numdatatypes##a] = GNSSDF_##b##DATA; \
     1761      Parser->info[RTCM3_MSM_##a].pos[Parser->numdatatypes##a] = GNSSENTRY_##b##DATA; \
     1762      ++Parser->info[RTCM3_MSM_##a].numdtypes; \
    17401763    }
    17411764
     
    17801803      if(data[RINEXENTRY_##b##DATA]) \
    17811804      { \
    1782         Parser->dataflagGPS[data[RINEXENTRY_##b##DATA]-1] = GNSSDF_##a##DATA; \
    1783         Parser->dataposGPS[data[RINEXENTRY_##b##DATA]-1] = GNSSENTRY_##a##DATA; \
     1805        Parser->info[RTCM3_MSM_GPS].flags[data[RINEXENTRY_##b##DATA]-1] = GNSSDF_##a##DATA; \
     1806        Parser->info[RTCM3_MSM_GPS].pos[data[RINEXENTRY_##b##DATA]-1] = GNSSENTRY_##a##DATA; \
    17841807      } \
    17851808      else \
    17861809      { \
    1787         Parser->dataflag[Parser->numdatatypesGPS] = GNSSDF_##a##DATA; \
    1788         Parser->datapos[Parser->numdatatypesGPS] = GNSSENTRY_##a##DATA; \
    1789         data[RINEXENTRY_##b##DATA] = ++Parser->numdatatypesGPS; \
     1810        Parser->dataflag[Parser->info[RTCM3_MSM_GPS].numtypes] = GNSSDF_##a##DATA; \
     1811        Parser->datapos[Parser->info[RTCM3_MSM_GPS].numtypes] = GNSSENTRY_##a##DATA; \
     1812        data[RINEXENTRY_##b##DATA] = ++Parser->info[RTCM3_MSM_GPS].numtypes; \
    17901813      } \
    17911814    }
     
    18891912    if(flags & GNSSDF_##b##DATA) \
    18901913    { \
    1891       Parser->dataflag##a[Parser->numdatatypes##a] = GNSSDF_##b##DATA; \
    1892       Parser->datapos##a[Parser->numdatatypes##a] = GNSSENTRY_##b##DATA; \
    1893       ++Parser->numdatatypes##a; \
    1894       snprintf(tbuffer+tbufferpos, sizeof(tbuffer)-tbufferpos, " %-3s", #c); \
     1914      Parser->info[RTCM3_MSM_##a].flags[Parser->info[RTCM3_MSM_##a].numtypes] \
     1915      = GNSSDF_##b##DATA; \
     1916      Parser->info[RTCM3_MSM_##a].pos[Parser->info[RTCM3_MSM_##a].numtypes] \
     1917      = GNSSENTRY_##b##DATA; \
     1918      ++Parser->info[RTCM3_MSM_##a].numtypes; \
     1919      if(Parser->info[RTCM3_MSM_##a].type[GNSSENTRY_##b##DATA]) \
     1920        snprintf(tbuffer+tbufferpos, sizeof(tbuffer)-tbufferpos, " %-2.2s%c", #c,\
     1921        Parser->info[RTCM3_MSM_##a].type[GNSSENTRY_##b##DATA]); \
     1922      else \
     1923        snprintf(tbuffer+tbufferpos, sizeof(tbuffer)-tbufferpos, " %-3s", #c); \
    18951924      tbufferpos += 4; \
    18961925    }
     
    19011930    for(i = 0; i < Parser->Data.numsats; ++i)
    19021931      flags |= Parser->Data.dataflags[i];
     1932
     1933    CHECKFLAGSNEW(SBAS, C1,  C1C)
     1934    CHECKFLAGSNEW(SBAS, L1C, L1C)
     1935    CHECKFLAGSNEW(SBAS, D1C, D1C)
     1936    CHECKFLAGSNEW(SBAS, S1C, S1C)
     1937    CHECKFLAGSNEW(SBAS, P1,  C1W)
     1938    CHECKFLAGSNEW(SBAS, L1P, L1W)
     1939    CHECKFLAGSNEW(SBAS, D1P, D1W)
     1940    CHECKFLAGSNEW(SBAS, S1P, S1W)
     1941    CHECKFLAGSNEW(SBAS, C5,  C5)
     1942    CHECKFLAGSNEW(SBAS, L5,  L5)
     1943    CHECKFLAGSNEW(SBAS, D5,  D5)
     1944    CHECKFLAGSNEW(SBAS, S5,  S5)
     1945
     1946    hdata.data.named.typesofobsS = buffer;
     1947    i = 1+snprintf(buffer, buffersize,
     1948    "S  %3d%-52.52s  SYS / # / OBS TYPES", Parser->info[RTCM3_MSM_SBAS].numtypes, tbuffer);
     1949    buffer += i; buffersize -= i;
    19031950
    19041951    CHECKFLAGSNEW(GPS, C1,  C1C)
     
    19141961    CHECKFLAGSNEW(GPS, D5,  D5)
    19151962    CHECKFLAGSNEW(GPS, S5,  S5)
    1916 
    1917     hdata.data.named.typesofobsS = buffer;
    1918     i = 1+snprintf(buffer, buffersize,
    1919     "S  %3d%-52.52s  SYS / # / OBS TYPES", Parser->numdatatypesGPS, tbuffer);
    1920     buffer += i; buffersize -= i;
    1921 
    19221963    CHECKFLAGSNEW(GPS, P2,  C2P)
    19231964    CHECKFLAGSNEW(GPS, L2P, L2P)
     
    19281969    CHECKFLAGSNEW(GPS, D2C, D2X)
    19291970    CHECKFLAGSNEW(GPS, S2C, S2X)
    1930     CHECKFLAGSNEW(GPS, C1N, C1X)
    1931     CHECKFLAGSNEW(GPS, L1N, L1X)
    1932     CHECKFLAGSNEW(GPS, D1N, D1X)
    1933     CHECKFLAGSNEW(GPS, S1N, S1X)
     1971    CHECKFLAGSNEW(GPS, C1N, C1)
     1972    CHECKFLAGSNEW(GPS, L1N, L1)
     1973    CHECKFLAGSNEW(GPS, D1N, D1)
     1974    CHECKFLAGSNEW(GPS, S1N, S1)
    19341975
    19351976    hdata.data.named.typesofobsG = buffer;
    19361977    i = 1+snprintf(buffer, buffersize,
    1937     "G  %3d%-52.52s  SYS / # / OBS TYPES", Parser->numdatatypesGPS, tbuffer);
    1938     if(Parser->numdatatypesGPS>13)
     1978    "G  %3d%-52.52s  SYS / # / OBS TYPES", Parser->info[RTCM3_MSM_GPS].numtypes, tbuffer);
     1979    if(Parser->info[RTCM3_MSM_GPS].numtypes>13)
    19391980    {
    19401981      i += snprintf(buffer+i-1, buffersize,
     
    19451986    tbufferpos = 0;
    19461987
    1947     CHECKFLAGSNEW(GLO, C1,  C1C)
    1948     CHECKFLAGSNEW(GLO, L1C, L1C)
    1949     CHECKFLAGSNEW(GLO, D1C, D1C)
    1950     CHECKFLAGSNEW(GLO, S1C, S1C)
    1951     CHECKFLAGSNEW(GLO, P1,  C1P)
    1952     CHECKFLAGSNEW(GLO, L1P, L1P)
    1953     CHECKFLAGSNEW(GLO, D1P, D1P)
    1954     CHECKFLAGSNEW(GLO, S1P, S1P)
    1955     CHECKFLAGSNEW(GLO, P2,  C2P)
    1956     CHECKFLAGSNEW(GLO, L2P, L2P)
    1957     CHECKFLAGSNEW(GLO, D2P, D2P)
    1958     CHECKFLAGSNEW(GLO, S2P, S2P)
    1959     CHECKFLAGSNEW(GLO, C2,  C2C)
    1960     CHECKFLAGSNEW(GLO, L2C, L2C)
    1961     CHECKFLAGSNEW(GLO, D2C, D2C)
    1962     CHECKFLAGSNEW(GLO, S2C, S2C)
     1988    CHECKFLAGSNEW(GLONASS, C1,  C1C)
     1989    CHECKFLAGSNEW(GLONASS, L1C, L1C)
     1990    CHECKFLAGSNEW(GLONASS, D1C, D1C)
     1991    CHECKFLAGSNEW(GLONASS, S1C, S1C)
     1992    CHECKFLAGSNEW(GLONASS, P1,  C1P)
     1993    CHECKFLAGSNEW(GLONASS, L1P, L1P)
     1994    CHECKFLAGSNEW(GLONASS, D1P, D1P)
     1995    CHECKFLAGSNEW(GLONASS, S1P, S1P)
     1996    CHECKFLAGSNEW(GLONASS, P2,  C2P)
     1997    CHECKFLAGSNEW(GLONASS, L2P, L2P)
     1998    CHECKFLAGSNEW(GLONASS, D2P, D2P)
     1999    CHECKFLAGSNEW(GLONASS, S2P, S2P)
     2000    CHECKFLAGSNEW(GLONASS, C2,  C2C)
     2001    CHECKFLAGSNEW(GLONASS, L2C, L2C)
     2002    CHECKFLAGSNEW(GLONASS, D2C, D2C)
     2003    CHECKFLAGSNEW(GLONASS, S2C, S2C)
    19632004
    19642005    hdata.data.named.typesofobsR = buffer;
    19652006    i = 1+snprintf(buffer, buffersize,
    1966     "R  %3d%-52.52s  SYS / # / OBS TYPES", Parser->numdatatypesGLO, tbuffer);
    1967     if(Parser->numdatatypesGLO>13)
     2007    "R  %3d%-52.52s  SYS / # / OBS TYPES", Parser->info[RTCM3_MSM_GLONASS].numtypes, tbuffer);
     2008    if(Parser->info[RTCM3_MSM_GLONASS].numtypes>13)
    19682009    {
    19692010      i += snprintf(buffer+i-1, buffersize,
     
    19742015    tbufferpos = 0;
    19752016
    1976     CHECKFLAGSNEW(GAL, C1,   C1)
    1977     CHECKFLAGSNEW(GAL, L1C,  L1)
    1978     CHECKFLAGSNEW(GAL, D1C,  D1)
    1979     CHECKFLAGSNEW(GAL, S1C,  S1)
    1980     CHECKFLAGSNEW(GAL, C6,   C6)
    1981     CHECKFLAGSNEW(GAL, L6,   L6)
    1982     CHECKFLAGSNEW(GAL, D6,   D6)
    1983     CHECKFLAGSNEW(GAL, S6,   S6)
    1984     CHECKFLAGSNEW(GAL, C5,   C5)
    1985     CHECKFLAGSNEW(GAL, L5,   L5)
    1986     CHECKFLAGSNEW(GAL, D5,   D5)
    1987     CHECKFLAGSNEW(GAL, S5,   S5)
    1988     CHECKFLAGSNEW(GAL, C5B,  C7)
    1989     CHECKFLAGSNEW(GAL, L5B,  L7)
    1990     CHECKFLAGSNEW(GAL, D5B,  D7)
    1991     CHECKFLAGSNEW(GAL, S5B,  S7)
    1992     CHECKFLAGSNEW(GAL, C5AB, C8)
    1993     CHECKFLAGSNEW(GAL, L5AB, L8)
    1994     CHECKFLAGSNEW(GAL, D5AB, D8)
    1995     CHECKFLAGSNEW(GAL, S5AB, S8)
     2017    CHECKFLAGSNEW(GALILEO, C1,   C1)
     2018    CHECKFLAGSNEW(GALILEO, L1C,  L1)
     2019    CHECKFLAGSNEW(GALILEO, D1C,  D1)
     2020    CHECKFLAGSNEW(GALILEO, S1C,  S1)
     2021    CHECKFLAGSNEW(GALILEO, C6,   C6)
     2022    CHECKFLAGSNEW(GALILEO, L6,   L6)
     2023    CHECKFLAGSNEW(GALILEO, D6,   D6)
     2024    CHECKFLAGSNEW(GALILEO, S6,   S6)
     2025    CHECKFLAGSNEW(GALILEO, C5,   C5)
     2026    CHECKFLAGSNEW(GALILEO, L5,   L5)
     2027    CHECKFLAGSNEW(GALILEO, D5,   D5)
     2028    CHECKFLAGSNEW(GALILEO, S5,   S5)
     2029    CHECKFLAGSNEW(GALILEO, C5B,  C7)
     2030    CHECKFLAGSNEW(GALILEO, L5B,  L7)
     2031    CHECKFLAGSNEW(GALILEO, D5B,  D7)
     2032    CHECKFLAGSNEW(GALILEO, S5B,  S7)
     2033    CHECKFLAGSNEW(GALILEO, C5AB, C8)
     2034    CHECKFLAGSNEW(GALILEO, L5AB, L8)
     2035    CHECKFLAGSNEW(GALILEO, D5AB, D8)
     2036    CHECKFLAGSNEW(GALILEO, S5AB, S8)
    19962037
    19972038    hdata.data.named.typesofobsE = buffer;
    19982039    i = 1+snprintf(buffer, buffersize,
    1999     "E  %3d%-52.52s  SYS / # / OBS TYPES", Parser->numdatatypesGAL, tbuffer);
    2000     if(Parser->numdatatypesGAL>13)
     2040    "E  %3d%-52.52s  SYS / # / OBS TYPES", Parser->info[RTCM3_MSM_GALILEO].numtypes, tbuffer);
     2041    if(Parser->info[RTCM3_MSM_GALILEO].numtypes>13)
    20012042    {
    20022043      i += snprintf(buffer+i-1, buffersize,
     
    20072048    tbufferpos = 0;
    20082049
    2009     CHECKFLAGSNEW(COM, CB1,  C2I)
    2010     CHECKFLAGSNEW(COM, LB1,  L2I)
    2011     CHECKFLAGSNEW(COM, DB1,  D2I)
    2012     CHECKFLAGSNEW(COM, SB1,  S2I)
    2013     CHECKFLAGSNEW(COM, CB2,  C7I)
    2014     CHECKFLAGSNEW(COM, LB2,  L7I)
    2015     CHECKFLAGSNEW(COM, DB2,  D7I)
    2016     CHECKFLAGSNEW(COM, SB2,  S7I)
    2017     CHECKFLAGSNEW(COM, CB3,  C6I)
    2018     CHECKFLAGSNEW(COM, LB3,  L6I)
    2019     CHECKFLAGSNEW(COM, DB3,  D6I)
    2020     CHECKFLAGSNEW(COM, SB3,  S6I)
     2050    CHECKFLAGSNEW(COMPASS, CB1,  C2I)
     2051    CHECKFLAGSNEW(COMPASS, LB1,  L2I)
     2052    CHECKFLAGSNEW(COMPASS, DB1,  D2I)
     2053    CHECKFLAGSNEW(COMPASS, SB1,  S2I)
     2054    CHECKFLAGSNEW(COMPASS, CB2,  C7I)
     2055    CHECKFLAGSNEW(COMPASS, LB2,  L7I)
     2056    CHECKFLAGSNEW(COMPASS, DB2,  D7I)
     2057    CHECKFLAGSNEW(COMPASS, SB2,  S7I)
     2058    CHECKFLAGSNEW(COMPASS, CB3,  C6I)
     2059    CHECKFLAGSNEW(COMPASS, LB3,  L6I)
     2060    CHECKFLAGSNEW(COMPASS, DB3,  D6I)
     2061    CHECKFLAGSNEW(COMPASS, SB3,  S6I)
    20212062
    20222063    hdata.data.named.typesofobsC = buffer;
    20232064    i = 1+snprintf(buffer, buffersize,
    2024     "C  %3d%-52.52s  SYS / # / OBS TYPES", Parser->numdatatypesCOM, tbuffer);
    2025     if(Parser->numdatatypesCOM>13)
     2065    "C  %3d%-52.52s  SYS / # / OBS TYPES", Parser->info[RTCM3_MSM_COMPASS].numtypes, tbuffer);
     2066    if(Parser->info[RTCM3_MSM_COMPASS].numtypes>13)
    20262067    {
    20272068      i += snprintf(buffer+i-1, buffersize,
     
    20322073    tbufferpos = 0;
    20332074
    2034     CHECKFLAGSNEW(QZS, C1,  C1C)
    2035     CHECKFLAGSNEW(QZS, L1C, L1C)
    2036     CHECKFLAGSNEW(QZS, D1C, D1C)
    2037     CHECKFLAGSNEW(QZS, S1C, S1C)
    2038 
    2039     CHECKFLAGSNEW(QZS, CSAIF, C1Z)
    2040     CHECKFLAGSNEW(QZS, LSAIF, L1Z)
    2041     CHECKFLAGSNEW(QZS, DSAIF, D1Z)
    2042     CHECKFLAGSNEW(QZS, SSAIF, S1Z)
    2043 
    2044     CHECKFLAGSNEW(QZS, C1N, C1X)
    2045     CHECKFLAGSNEW(QZS, L1N, L1X)
    2046     CHECKFLAGSNEW(QZS, D1N, D1X)
    2047     CHECKFLAGSNEW(QZS, S1N, S1X)
    2048 
    2049     CHECKFLAGSNEW(QZS, C6, C6)
    2050     CHECKFLAGSNEW(QZS, L6, L6)
    2051     CHECKFLAGSNEW(QZS, D6, D6)
    2052     CHECKFLAGSNEW(QZS, S6, S6)
    2053 
    2054     CHECKFLAGSNEW(QZS, C2,  C2X)
    2055     CHECKFLAGSNEW(QZS, L2C, L2X)
    2056     CHECKFLAGSNEW(QZS, D2C, D2X)
    2057     CHECKFLAGSNEW(QZS, S2C, S2X)
    2058 
    2059     CHECKFLAGSNEW(QZS, C5,  C5)
    2060     CHECKFLAGSNEW(QZS, L5,  L5)
    2061     CHECKFLAGSNEW(QZS, D5,  D5)
    2062     CHECKFLAGSNEW(QZS, S5,  S5)
     2075    CHECKFLAGSNEW(QZSS, C1,  C1C)
     2076    CHECKFLAGSNEW(QZSS, L1C, L1C)
     2077    CHECKFLAGSNEW(QZSS, D1C, D1C)
     2078    CHECKFLAGSNEW(QZSS, S1C, S1C)
     2079
     2080    CHECKFLAGSNEW(QZSS, CSAIF, C1Z)
     2081    CHECKFLAGSNEW(QZSS, LSAIF, L1Z)
     2082    CHECKFLAGSNEW(QZSS, DSAIF, D1Z)
     2083    CHECKFLAGSNEW(QZSS, SSAIF, S1Z)
     2084
     2085    CHECKFLAGSNEW(QZSS, C1N, C1)
     2086    CHECKFLAGSNEW(QZSS, L1N, L1)
     2087    CHECKFLAGSNEW(QZSS, D1N, D1)
     2088    CHECKFLAGSNEW(QZSS, S1N, S1)
     2089
     2090    CHECKFLAGSNEW(QZSS, C6, C6)
     2091    CHECKFLAGSNEW(QZSS, L6, L6)
     2092    CHECKFLAGSNEW(QZSS, D6, D6)
     2093    CHECKFLAGSNEW(QZSS, S6, S6)
     2094
     2095    CHECKFLAGSNEW(QZSS, C2,  C2)
     2096    CHECKFLAGSNEW(QZSS, L2C, L2)
     2097    CHECKFLAGSNEW(QZSS, D2C, D2)
     2098    CHECKFLAGSNEW(QZSS, S2C, S2)
     2099
     2100    CHECKFLAGSNEW(QZSS, C5,  C5)
     2101    CHECKFLAGSNEW(QZSS, L5,  L5)
     2102    CHECKFLAGSNEW(QZSS, D5,  D5)
     2103    CHECKFLAGSNEW(QZSS, S5,  S5)
    20632104
    20642105    hdata.data.named.typesofobsJ = buffer;
    20652106    i = 1+snprintf(buffer, buffersize,
    2066     "J  %3d%-52.52s  SYS / # / OBS TYPES", Parser->numdatatypesQZS, tbuffer);
    2067     if(Parser->numdatatypesQZS>13)
     2107    "J  %3d%-52.52s  SYS / # / OBS TYPES", Parser->info[RTCM3_MSM_QZSS].numtypes, tbuffer);
     2108    if(Parser->info[RTCM3_MSM_QZSS].numtypes>13)
    20682109    {
    20692110      i += snprintf(buffer+i-1, buffersize,
     
    20792120      if(data[RINEXENTRY_##b##DATA]) \
    20802121      { \
    2081         Parser->dataflagGPS[data[RINEXENTRY_##b##DATA]-1] = GNSSDF_##a##DATA; \
    2082         Parser->dataposGPS[data[RINEXENTRY_##b##DATA]-1] = GNSSENTRY_##a##DATA; \
     2122        Parser->info[RTCM3_MSM_GPS].flags[data[RINEXENTRY_##b##DATA]-1] = GNSSDF_##a##DATA; \
     2123        Parser->info[RTCM3_MSM_GPS].pos[data[RINEXENTRY_##b##DATA]-1] = GNSSENTRY_##a##DATA; \
    20832124      } \
    20842125      else \
    20852126      { \
    2086         Parser->dataflag[Parser->numdatatypesGPS] = GNSSDF_##a##DATA; \
    2087         Parser->datapos[Parser->numdatatypesGPS] = GNSSENTRY_##a##DATA; \
    2088         data[RINEXENTRY_##b##DATA] = ++Parser->numdatatypesGPS; \
     2127        Parser->flags[Parser->info[RTCM3_MSM_GPS].numtypes] = GNSSDF_##a##DATA; \
     2128        Parser->pos[Parser->info[RTCM3_MSM_GPS].numtypes] = GNSSENTRY_##a##DATA; \
     2129        data[RINEXENTRY_##b##DATA] = ++Parser->info[RTCM3_MSM_GPS].numtypes; \
    20892130        snprintf(tbuffer+tbufferpos, sizeof(tbuffer)-tbufferpos, "    "#b); \
    20902131        tbufferpos += 6; \
     
    21372178    hdata.data.named.typesofobs = buffer;
    21382179    i = 1+snprintf(buffer, buffersize,
    2139     "%6d%-54.54s# / TYPES OF OBSERV", Parser->numdatatypesGPS, tbuffer);
    2140     if(Parser->numdatatypesGPS>9)
     2180    "%6d%-54.54s# / TYPES OF OBSERV", Parser->info[RTCM3_MSM_GPS].numtypes, tbuffer);
     2181    if(Parser->info[RTCM3_MSM_GPS].numtypes>9)
    21412182    {
    21422183      i += snprintf(buffer+i-1, buffersize,
    21432184      "\n      %-54.54s# / TYPES OF OBSERV", tbuffer+9*6);
    21442185    }
    2145     if(Parser->numdatatypesGPS>18)
     2186    if(Parser->info[RTCM3_MSM_GPS].numtypes>18)
    21462187    {
    21472188      i += snprintf(buffer+i-1, buffersize,
     
    24592500          for(i = 0; i < Parser->Data.numsats; ++i)
    24602501          {
    2461             int glo = 0, gal = 0, qzs = 0, com = 0;
     2502            int sys[RTCM3_MSM_NUMSYS] = {0,0,0,0,0,0};
    24622503            if(Parser->Data.satellites[i] <= PRN_GPS_END)
     2504            {
    24632505              RTCM3Text("G%02d", Parser->Data.satellites[i]);
     2506              sys[RTCM3_MSM_GPS] = 1;
     2507            }
    24642508            else if(Parser->Data.satellites[i] >= PRN_GLONASS_START
    24652509            && Parser->Data.satellites[i] <= PRN_GLONASS_END)
    24662510            {
    24672511              RTCM3Text("R%02d", Parser->Data.satellites[i] - (PRN_GLONASS_START-1));
    2468               glo = 1;
     2512              sys[RTCM3_MSM_GLONASS] = 1;
    24692513            }
    24702514            else if(Parser->Data.satellites[i] >= PRN_GALILEO_START
     
    24722516            {
    24732517              RTCM3Text("E%02d", Parser->Data.satellites[i] - (PRN_GALILEO_START-1));
    2474               gal = 1;
     2518              sys[RTCM3_MSM_GALILEO] = 1;
    24752519            }
    24762520            else if(Parser->Data.satellites[i] >= PRN_GIOVE_START
     
    24782522            {
    24792523              RTCM3Text("E%02d", Parser->Data.satellites[i] - (PRN_GIOVE_START-PRN_GIOVE_OFFSET));
    2480               gal = 1;
     2524              sys[RTCM3_MSM_GALILEO] = 1;
    24812525            }
    24822526            else if(Parser->Data.satellites[i] >= PRN_QZSS_START
     
    24842528            {
    24852529              RTCM3Text("J%02d", Parser->Data.satellites[i] - (PRN_QZSS_START-1));
    2486               qzs = 1;
     2530              sys[RTCM3_MSM_QZSS] = 1;
    24872531            }
    24882532            else if(Parser->Data.satellites[i] >= PRN_COMPASS_START
     
    24902534            {
    24912535              RTCM3Text("C%02d", Parser->Data.satellites[i] - (PRN_COMPASS_START-1));
    2492               com = 1;
     2536              sys[RTCM3_MSM_COMPASS] = 1;
    24932537            }
    24942538            else if(Parser->Data.satellites[i] >= PRN_SBAS_START
    24952539            && Parser->Data.satellites[i] <= PRN_SBAS_END)
     2540            {
    24962541              RTCM3Text("S%02d", Parser->Data.satellites[i] - PRN_SBAS_START+20);
     2542              sys[RTCM3_MSM_SBAS] = 1;
     2543            }
    24972544            else
     2545            {
    24982546              RTCM3Text("%3d", Parser->Data.satellites[i]);
    2499 
    2500             if(glo)
    2501             {
    2502               for(j = 0; j < Parser->numdatatypesGLO; ++j)
     2547            }
     2548
     2549            if(sys[RTCM3_MSM_GLONASS])
     2550            {
     2551              for(j = 0; j < Parser->info[RTCM3_MSM_GLONASS].numtypes; ++j)
    25032552              {
    2504                 int df = Parser->dataflagGLO[j];
    2505                 int pos = Parser->dataposGLO[j];
     2553                int df = Parser->info[RTCM3_MSM_GLONASS].flags[j];
     2554                int pos = Parser->info[RTCM3_MSM_GLONASS].pos[j];
    25062555                if((Parser->Data.dataflags[i] & df)
    25072556                && !isnan(Parser->Data.measdata[i][pos])
     
    25312580              }
    25322581            }
    2533             else if(gal)
    2534             {
    2535               for(j = 0; j < Parser->numdatatypesGAL; ++j)
     2582            else if(sys[RTCM3_MSM_GALILEO])
     2583            {
     2584              for(j = 0; j < Parser->info[RTCM3_MSM_GALILEO].numtypes; ++j)
    25362585              {
    2537                 int df = Parser->dataflagGAL[j];
    2538                 int pos = Parser->dataposGAL[j];
     2586                int df = Parser->info[RTCM3_MSM_GALILEO].flags[j];
     2587                int pos = Parser->info[RTCM3_MSM_GALILEO].pos[j];
    25392588                if((Parser->Data.dataflags[i] & df)
    25402589                && !isnan(Parser->Data.measdata[i][pos])
     
    25822631              }
    25832632            }
    2584             else if(com)
    2585             {
    2586               for(j = 0; j < Parser->numdatatypesCOM; ++j)
     2633            else if(sys[RTCM3_MSM_COMPASS])
     2634            {
     2635              for(j = 0; j < Parser->info[RTCM3_MSM_COMPASS].numtypes; ++j)
    25872636              {
    2588                 int df = Parser->dataflagCOM[j];
    2589                 int pos = Parser->dataposCOM[j];
     2637                int df = Parser->info[RTCM3_MSM_COMPASS].flags[j];
     2638                int pos = Parser->info[RTCM3_MSM_COMPASS].pos[j];
    25902639                if((Parser->Data.dataflags[i] & df)
    25912640                && !isnan(Parser->Data.measdata[i][pos])
     
    26182667              }
    26192668            }
    2620             else if(qzs)
    2621             {
    2622               for(j = 0; j < Parser->numdatatypesQZS; ++j)
     2669            else if(sys[RTCM3_MSM_QZSS])
     2670            {
     2671              for(j = 0; j < Parser->info[RTCM3_MSM_QZSS].numtypes; ++j)
    26232672              {
    2624                 int df = Parser->dataflagQZS[j];
    2625                 int pos = Parser->dataposQZS[j];
     2673                int df = Parser->info[RTCM3_MSM_QZSS].flags[j];
     2674                int pos = Parser->info[RTCM3_MSM_QZSS].pos[j];
    26262675                if((Parser->Data.dataflags[i] & df)
    26272676                && !isnan(Parser->Data.measdata[i][pos])
    2628                 && !isinf(Parser->Data.measdata[i][pos]))
     2677                && !isinf(Parser->Data.measdata[i][pos])
     2678                && (Parser->Data.codetype[i]
     2679                  && Parser->info[RTCM3_MSM_QZSS].type[pos]
     2680                  && Parser->info[RTCM3_MSM_QZSS].type[pos]
     2681                  == Parser->Data.codetype[i][1]))
    26292682                {
    26302683                  char lli = ' ';
     
    26572710              }
    26582711            }
     2712            else if(sys[RTCM3_MSM_SBAS])
     2713            {
     2714              for(j = 0; j < Parser->info[RTCM3_MSM_SBAS].numtypes; ++j)
     2715              {
     2716                int df = Parser->info[RTCM3_MSM_SBAS].flags[j];
     2717                int pos = Parser->info[RTCM3_MSM_SBAS].pos[j];
     2718                if((Parser->Data.dataflags[i] & df)
     2719                && !isnan(Parser->Data.measdata[i][pos])
     2720                && !isinf(Parser->Data.measdata[i][pos]))
     2721                {
     2722                  char lli = ' ';
     2723                  char snr = ' ';
     2724                  if(df & (GNSSDF_L1CDATA|GNSSDF_L1PDATA))
     2725                  {
     2726                    if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL1)
     2727                      lli = '1';
     2728                    snr = '0'+Parser->Data.snrL1[i];
     2729                  }
     2730                  if(df & GNSSDF_L5DATA)
     2731                  {
     2732                    if(Parser->Data.dataflags2[i] & GNSSDF2_LOCKLOSSL5)
     2733                      lli = '1';
     2734                    snr = ' ';
     2735                  }
     2736                  RTCM3Text("%14.3f%c%c",
     2737                  Parser->Data.measdata[i][pos],lli,snr);
     2738                }
     2739                else
     2740                { /* no or illegal data */
     2741                  RTCM3Text("                ");
     2742                }
     2743              }
     2744            }
    26592745            else
    26602746            {
    2661               for(j = 0; j < Parser->numdatatypesGPS; ++j)
     2747              for(j = 0; j < Parser->info[RTCM3_MSM_GPS].numtypes; ++j)
    26622748              {
    2663                 int df = Parser->dataflagGPS[j];
    2664                 int pos = Parser->dataposGPS[j];
     2749                int df = Parser->info[RTCM3_MSM_GPS].flags[j];
     2750                int pos = Parser->info[RTCM3_MSM_GPS].pos[j];
    26652751                if((Parser->Data.dataflags[i] & df)
    26662752                && !isnan(Parser->Data.measdata[i][pos])
     
    27782864          for(i = 0; i < Parser->Data.numsats; ++i)
    27792865          {
    2780             for(j = 0; j < Parser->numdatatypesGPS; ++j)
     2866            for(j = 0; j < Parser->info[RTCM3_MSM_GPS].numtypes; ++j)
    27812867            {
    27822868              int v = 0;
    2783               int df = Parser->dataflag[j];
    2784               int pos = Parser->datapos[j];
     2869              int df = Parser->flags[j];
     2870              int pos = Parser->pos[j];
    27852871              if((Parser->Data.dataflags[i] & df)
    27862872              && !isnan(Parser->Data.measdata[i][pos])
     
    27912877              else
    27922878              {
    2793                 df = Parser->dataflagGPS[j];
    2794                 pos = Parser->dataposGPS[j];
     2879                df = Parser->info[RTCM3_MSM_GPS].flags[j];
     2880                pos = Parser->info[RTCM3_MSM_GPS].pos[j];
    27952881
    27962882                if((Parser->Data.dataflags[i] & df)
     
    28352921                Parser->Data.measdata[i][pos],lli,snr);
    28362922              }
    2837               if(j%5 == 4 || j == Parser->numdatatypesGPS-1)
     2923              if(j%5 == 4 || j == Parser->info[RTCM3_MSM_GPS].numtypes-1)
    28382924                RTCM3Text("\n");
    28392925            }
  • trunk/rtcm3torinex/lib/rtcm3torinex.h

    r4369 r4371  
    2323*/
    2424
    25 #define RTCM3TORINEX_VERSION "1.50"
     25#define RTCM3TORINEX_VERSION "2"
    2626
    2727#include <stdio.h>
     
    5151#define RTCM3_MSM_NUMCELLS    64
    5252
    53 /* system identifiers, use start PRN as value */
    54 #define RTCM3_MSM_GPS     PRN_GPS_START
    55 #define RTCM3_MSM_GLONASS PRN_GLONASS_START
    56 #define RTCM3_MSM_GALILEO PRN_GALILEO_START
    57 #define RTCM3_MSM_SBAS    PRN_SBAS_START
    58 #define RTCM3_MSM_QZSS    PRN_QZSS_START
    59 #define RTCM3_MSM_COMPASS PRN_COMPASS_START
     53/* system identifiers */
     54#define RTCM3_MSM_GPS     0
     55#define RTCM3_MSM_GLONASS 1
     56#define RTCM3_MSM_GALILEO 2
     57#define RTCM3_MSM_SBAS    3
     58#define RTCM3_MSM_QZSS    4
     59#define RTCM3_MSM_COMPASS 5
     60
     61#define RTCM3_MSM_NUMSYS  6
    6062
    6163#define GNSSENTRY_CODE    0
     
    410412  int    SISA;
    411413  int    E5aHS;
     414};
     415
     416struct DataInfo {
     417  long long flags[RINEXENTRY_NUMBER];
     418  int       pos[RINEXENTRY_NUMBER];
     419  int       numtypes;
     420  char      type[GNSSENTRY_NUMBER];
    412421};
    413422
     
    443452  int    leapsec;
    444453#endif /* NO_RTCM3_MAIN */
    445   int    datapos[RINEXENTRY_NUMBER];
    446   long long dataflag[RINEXENTRY_NUMBER];
    447   /* for RINEX2 GPS and GLO are both handled in GPS */
    448   int    dataposGPS[RINEXENTRY_NUMBER]; /* SBAS has same entries */
    449   long long dataflagGPS[RINEXENTRY_NUMBER];
    450   int    dataposGLO[RINEXENTRY_NUMBER]; /* only used for RINEX3 */
    451   long long dataflagGLO[RINEXENTRY_NUMBER];
    452   int    dataposGAL[RINEXENTRY_NUMBER]; /* only used for RINEX3 */
    453   long long dataflagGAL[RINEXENTRY_NUMBER];
    454   int    dataposQZS[RINEXENTRY_NUMBER]; /* only used for RINEX3 */
    455   long long dataflagQZS[RINEXENTRY_NUMBER];
    456   int    dataposCOM[RINEXENTRY_NUMBER]; /* only used for RINEX3 */
    457   long long dataflagCOM[RINEXENTRY_NUMBER];
    458   int    numdatatypesGPS;
    459   int    numdatatypesGLO; /* only used for RINEX3 */
    460   int    numdatatypesGAL; /* only used for RINEX3 */
    461   int    numdatatypesQZS; /* only used for RINEX3 */
    462   int    numdatatypesCOM; /* only used for RINEX3 */
    463   int    validwarning;
    464   int    init;
    465   int    startflags;
    466   int    rinex3;
     454  int          pos[RINEXENTRY_NUMBER];
     455  long long    flags[RINEXENTRY_NUMBER];
     456  /* For RINEX2 only field GPS is used */
     457  struct DataInfo info[RTCM3_MSM_NUMSYS];
     458  int          validwarning;
     459  int          init;
     460  int          startflags;
     461  int          rinex3;
    467462  const char * headerfile;
    468463  const char * glonassephemeris;
    469464  const char * gpsephemeris;
    470   FILE *glonassfile;
    471   FILE *gpsfile;
     465  FILE *       glonassfile;
     466  FILE *       gpsfile;
    472467};
    473468
Note: See TracChangeset for help on using the changeset viewer.