gnss-sdr/src/algorithms/libs/rtklib/rtklib_solution.cc

/*!
 * \file rtklib_solution.cc
 * \brief solution functions
 * \authors <ul>
 *          <li> 2007-2013, T. Takasu
 *          <li> 2017, Javier Arribas
 *          <li> 2017, Carles Fernandez
 *          </ul>
 *
 * This is a derived work from RTKLIB http://www.rtklib.com/
 * The original source code at https://github.com/tomojitakasu/RTKLIB is
 * released under the BSD 2-clause license with an additional exclusive clause
 * that does not apply here. This additional clause is reproduced below:
 *
 * " The software package includes some companion executive binaries or shared
 * libraries necessary to execute APs on Windows. These licenses succeed to the
 * original ones of these software. "
 *
 * Neither the executive binaries nor the shared libraries are required by, used
 * or included in GNSS-SDR.
 *
 * -------------------------------------------------------------------------
 * Copyright (C) 2007-2013, T. Takasu
 * Copyright (C) 2017, Javier Arribas
 * Copyright (C) 2017, Carles Fernandez
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 *----------------------------------------------------------------------------*/

#include <ctype.h>
#include "rtklib_solution.h"
#include "rtklib_rtkcmn.h"
#include "rtklib_rtksvr.h"


/* constants and macros ------------------------------------------------------*/

#define SQR_SOL(x)     ((x)<0.0?-(x)*(x):(x)*(x))
#define SQRT_SOL(x)    ((x)<0.0?0.0:sqrt(x))

const int MAXFIELD = 64;          /* max number of fields in a record */
const int MAXNMEA = 256;          /* max length of nmea sentence */

const double KNOT2M = 0.514444444;  /* m/knot */

static const int solq_nmea[] = {  /* nmea quality flags to rtklib sol quality */
    /* nmea 0183 v.2.3 quality flags: */
    /*  0=invalid, 1=gps fix (sps), 2=dgps fix, 3=pps fix, 4=rtk, 5=float rtk */
    /*  6=estimated (dead reckoning), 7=manual input, 8=simulation */
    SOLQ_NONE ,SOLQ_SINGLE, SOLQ_DGPS, SOLQ_PPP , SOLQ_FIX,
    SOLQ_FLOAT,SOLQ_DR    , SOLQ_NONE, SOLQ_NONE, SOLQ_NONE
};


/* solution option to field separator ----------------------------------------*/
const char *opt2sep(const solopt_t *opt)
{
    if (!*opt->sep) return " ";
    else if (!strcmp(opt->sep,"\\t")) return "\t";
    return opt->sep;
}


/* separate fields -----------------------------------------------------------*/
int tonum(char *buff, const char *sep, double *v)
{
    int n,len = (int)strlen(sep);
    char *p,*q;

    for (p = buff,n = 0;n<MAXFIELD;p = q+len)
    {
        if ((q = strstr(p,sep))) *q = '\0';
        if (*p) v[n++] = atof(p);
        if (!q) break;
    }
    return n;
}


/* sqrt of covariance --------------------------------------------------------*/
double sqvar(double covar)
{
    return covar<0.0?-sqrt(-covar):sqrt(covar);
}


/* convert ddmm.mm in nmea format to deg -------------------------------------*/
double dmm2deg(double dmm)
{
    return floor(dmm/100.0)+fmod(dmm,100.0)/60.0;
}


/* convert time in nmea format to time ---------------------------------------*/
void septime(double t, double *t1, double *t2, double *t3)
{
    *t1 = floor(t/10000.0);
    t -= *t1*10000.0;
    *t2 = floor(t/100.0);
    *t3 = t-*t2*100.0;
}


/* solution to covariance ----------------------------------------------------*/
void soltocov(const sol_t *sol, double *P)
{
    P[0]      = sol->qr[0]; /* xx or ee */
    P[4]      = sol->qr[1]; /* yy or nn */
    P[8]      = sol->qr[2]; /* zz or uu */
    P[1] = P[3] = sol->qr[3]; /* xy or en */
    P[5] = P[7] = sol->qr[4]; /* yz or nu */
    P[2] = P[6] = sol->qr[5]; /* zx or ue */
}


/* covariance to solution ----------------------------------------------------*/
void covtosol(const double *P, sol_t *sol)
{
    sol->qr[0] = (float)P[0]; /* xx or ee */
    sol->qr[1] = (float)P[4]; /* yy or nn */
    sol->qr[2] = (float)P[8]; /* zz or uu */
    sol->qr[3] = (float)P[1]; /* xy or en */
    sol->qr[4] = (float)P[5]; /* yz or nu */
    sol->qr[5] = (float)P[2]; /* zx or ue */
}


/* decode nmea gprmc: recommended minumum data for gps -----------------------*/
int decode_nmearmc(char **val, int n, sol_t *sol)
{
    double tod = 0.0,lat = 0.0,lon = 0.0,vel = 0.0,dir = 0.0,date = 0.0,ang = 0.0,ep[6];
    double pos[3] = {0};
    char act = ' ',ns = 'N',ew = 'E',mew = 'E',mode = 'A';
    int i;

    trace(4,"decode_nmearmc: n=%d\n",n);

    for (i = 0;i<n;i++)
    {
        switch (i)
        {
            case  0: tod  = atof(val[i]); break; /* time in utc (hhmmss) */
            case  1: act  = *val[i];      break; /* A=active,V=void */
            case  2: lat  = atof(val[i]); break; /* latitude (ddmm.mmm) */
            case  3: ns   = *val[i];      break; /* N=north,S=south */
            case  4: lon  = atof(val[i]); break; /* longitude (dddmm.mmm) */
            case  5: ew   = *val[i];      break; /* E=east,W=west */
            case  6: vel  = atof(val[i]); break; /* speed (knots) */
            case  7: dir  = atof(val[i]); break; /* track angle (deg) */
            case  8: date = atof(val[i]); break; /* date (ddmmyy) */
            case  9: ang  = atof(val[i]); break; /* magnetic variation */
            case 10: mew  = *val[i];      break; /* E=east,W=west */
            case 11: mode = *val[i];      break; /* mode indicator (>nmea 2) */
                                      /* A=autonomous,D=differential */
                                      /* E=estimated,N=not valid,S=simulator */
        }
    }
    if ((act != 'A' && act != 'V') || (ns != 'N' && ns != 'S') || (ew != 'E' && ew != 'W'))
    {
        trace(2,"invalid nmea gprmc format\n");
        return 0;
    }
    pos[0] = (ns == 'S'?-1.0:1.0)*dmm2deg(lat)*D2R;
    pos[1] = (ew == 'W'?-1.0:1.0)*dmm2deg(lon)*D2R;
    septime(date,ep+2,ep+1,ep);
    septime(tod,ep+3,ep+4,ep+5);
    ep[0] += ep[0]<80.0?2000.0:1900.0;
    sol->time = utc2gpst(epoch2time(ep));
    pos2ecef(pos,sol->rr);
    sol->stat = mode == 'D'?SOLQ_DGPS:SOLQ_SINGLE;
    sol->ns = 0;

    sol->type = 0; /* postion type = xyz */

    trace(5,"decode_nmearmc: %s rr=%.3f %.3f %.3f stat=%d ns=%d vel=%.2f dir=%.0f ang=%.0f mew=%c mode=%c\n",
          time_str(sol->time,0),sol->rr[0],sol->rr[1],sol->rr[2],sol->stat,sol->ns,
          vel,dir,ang,mew,mode);

    return 1;
}


/* decode nmea gpgga: fix information ----------------------------------------*/
int decode_nmeagga(char **val, int n, sol_t *sol)
{
    gtime_t time;
    double tod = 0.0,lat = 0.0,lon = 0.0,hdop = 0.0,alt = 0.0,msl = 0.0,ep[6],tt;
    double pos[3] = {0};
    char ns = 'N',ew = 'E',ua = ' ',um = ' ';
    int i,solq = 0,nrcv = 0;

    trace(4,"decode_nmeagga: n=%d\n",n);

    for (i = 0;i<n;i++)
    {
        switch (i)
        {
            case  0: tod  = atof(val[i]); break; /* time in utc (hhmmss) */
            case  1: lat  = atof(val[i]); break; /* latitude (ddmm.mmm) */
            case  2: ns   = *val[i];      break; /* N=north,S=south */
            case  3: lon  = atof(val[i]); break; /* longitude (dddmm.mmm) */
            case  4: ew   = *val[i];      break; /* E=east,W=west */
            case  5: solq = atoi(val[i]); break; /* fix quality */
            case  6: nrcv = atoi(val[i]); break; /* # of satellite tracked */
            case  7: hdop = atof(val[i]); break; /* hdop */
            case  8: alt  = atof(val[i]); break; /* altitude in msl */
            case  9: ua   = *val[i];      break; /* unit (M) */
            case 10: msl  = atof(val[i]); break; /* height of geoid */
            case 11: um   = *val[i];      break; /* unit (M) */
        }
    }
    if ((ns != 'N' && ns != 'S') || (ew != 'E' && ew != 'W'))
    {
        trace(2,"invalid nmea gpgga format\n");
        return 0;
    }
    if (sol->time.time == 0.0)
    {
        trace(2,"no date info for nmea gpgga\n");
        return 0;
    }
    pos[0] = (ns == 'N'?1.0:-1.0)*dmm2deg(lat)*D2R;
    pos[1] = (ew == 'E'?1.0:-1.0)*dmm2deg(lon)*D2R;
    pos[2] = alt+msl;

    time2epoch(sol->time,ep);
    septime(tod,ep+3,ep+4,ep+5);
    time = utc2gpst(epoch2time(ep));
    tt = timediff(time,sol->time);
    if      (tt<-43200.0) sol->time = timeadd(time, 86400.0);
    else if (tt> 43200.0) sol->time = timeadd(time,-86400.0);
    else sol->time = time;
    pos2ecef(pos,sol->rr);
    sol->stat = 0 <= solq && solq <= 8?solq_nmea[solq]:SOLQ_NONE;
    sol->ns = nrcv;

    sol->type = 0; /* postion type = xyz */

    trace(5,"decode_nmeagga: %s rr=%.3f %.3f %.3f stat=%d ns=%d hdop=%.1f ua=%c um=%c\n",
          time_str(sol->time,0),sol->rr[0],sol->rr[1],sol->rr[2],sol->stat,sol->ns,
          hdop,ua,um);

    return 1;
}


/* decode nmea ---------------------------------------------------------------*/
int decode_nmea(char *buff, sol_t *sol)
{
    char *p,*q,*val[MAXFIELD];
    int n = 0;

    trace(4,"decode_nmea: buff=%s\n",buff);

    /* parse fields */
    for (p = buff;*p && n<MAXFIELD;p = q+1)
     {
        if ((q = strchr(p,',')) || (q = strchr(p,'*')))
        {
            val[n++] = p; *q = '\0';
        }
        else break;
    }
    /* decode nmea sentence */
    if (!strcmp(val[0],"$GPRMC"))
    {
        return decode_nmearmc(val+1,n-1,sol);
    }
    else if (!strcmp(val[0],"$GPGGA"))
     {
        return decode_nmeagga(val+1,n-1,sol);
    }
    return 0;
}


/* decode solution time ------------------------------------------------------*/
char *decode_soltime(char *buff, const solopt_t *opt, gtime_t *time)
{
    double v[MAXFIELD];
    char *p,*q,s[64] = " ";
    int n,len;

    trace(4,"decode_soltime:\n");

    if (!strcmp(opt->sep,"\\t")) strcpy(s,"\t");
    else if (*opt->sep) strcpy(s,opt->sep);
    len = (int)strlen(s);

    /* yyyy/mm/dd hh:mm:ss or yyyy mm dd hh:mm:ss */
    if (sscanf(buff,"%lf/%lf/%lf %lf:%lf:%lf",v,v+1,v+2,v+3,v+4,v+5) >= 6)
    {
        if (v[0]<100.0)
        {
            v[0] += v[0]<80.0?2000.0:1900.0;
        }
        *time = epoch2time(v);
        if (opt->times == TIMES_UTC)
        {
            *time = utc2gpst(*time);
        }
        else if (opt->times == TIMES_JST)
        {
            *time = utc2gpst(timeadd(*time,-9*3600.0));
        }
        if (!(p = strchr(buff,':')) || !(p = strchr(p+1,':'))) return NULL;
        for (p++;isdigit((int)*p) || *p == '.';) p++;
        return p+len;
    }
    if (opt->posf == SOLF_GSIF)
    {
        if (sscanf(buff,"%lf %lf %lf %lf:%lf:%lf",v,v+1,v+2,v+3,v+4,v+5)<6)
         {
            return NULL;
        }
        *time = timeadd(epoch2time(v),-12.0*3600.0);
        if (!(p = strchr(buff,':')) || !(p = strchr(p+1,':'))) return NULL;
        for (p++;isdigit((int)*p) || *p == '.';) p++;
        return p+len;
    }
    /* wwww ssss */
    for (p = buff,n = 0;n<2;p = q+len)
    {
        if ((q = strstr(p,s))) *q = '\0';
        if (*p) v[n++] = atof(p);
        if (!q) break;
    }
    if (n >= 2 && 0.0 <= v[0] && v[0] <= 3000.0 && 0.0 <= v[1] && v[1]<604800.0)
    {
        *time = gpst2time((int)v[0],v[1]);
        return p;
    }
    return NULL;
}


/* decode x/y/z-ecef ---------------------------------------------------------*/
int decode_solxyz(char *buff, const solopt_t *opt, sol_t *sol)
{
    double val[MAXFIELD],P[9] = {0};
    int i = 0,j,n;
    const char *sep = opt2sep(opt);

    trace(4,"decode_solxyz:\n");

    if ((n = tonum(buff,sep,val))<3) return 0;

    for (j = 0;j<3;j++)
    {
        sol->rr[j] = val[i++]; /* xyz */
    }
    if (i<n) sol->stat = (unsigned char)val[i++];
    if (i<n) sol->ns   = (unsigned char)val[i++];
    if (i+3<n)
    {
        P[0] = val[i]*val[i]; i++; /* sdx */
        P[4] = val[i]*val[i]; i++; /* sdy */
        P[8] = val[i]*val[i]; i++; /* sdz */
        if (i+3<n)
        {
            P[1] = P[3] = SQR_SOL(val[i]); i++; /* sdxy */
            P[5] = P[7] = SQR_SOL(val[i]); i++; /* sdyz */
            P[2] = P[6] = SQR_SOL(val[i]); i++; /* sdzx */
        }
        covtosol(P,sol);
    }
    if (i<n) sol->age   = (float)val[i++];
    if (i<n) sol->ratio = (float)val[i];

    sol->type = 0; /* postion type = xyz */

    if (MAXSOLQ<sol->stat) sol->stat = SOLQ_NONE;
    return 1;
}


/* decode lat/lon/height -----------------------------------------------------*/
int decode_solllh(char *buff, const solopt_t *opt, sol_t *sol)
{
    double val[MAXFIELD],pos[3],Q[9] = {0},P[9];
    int i = 0,n;
    const char *sep = opt2sep(opt);

    trace(4,"decode_solllh:\n");

    n = tonum(buff,sep,val);

    if (!opt->degf)
     {
        if (n<3) return 0;
        pos[0] = val[i++]*D2R; /* lat/lon/hgt (ddd.ddd) */
        pos[1] = val[i++]*D2R;
        pos[2] = val[i++];
    }
    else
    {
        if (n<7) return 0;
        pos[0] = dms2deg(val  )*D2R; /* lat/lon/hgt (ddd mm ss) */
        pos[1] = dms2deg(val+3)*D2R;
        pos[2] = val[6];
        i +=  7;
    }
    pos2ecef(pos,sol->rr);
    if (i<n) sol->stat = (unsigned char)val[i++];
    if (i<n) sol->ns   = (unsigned char)val[i++];
    if (i+3<n)
    {
        Q[4] = val[i]*val[i]; i++; /* sdn */
        Q[0] = val[i]*val[i]; i++; /* sde */
        Q[8] = val[i]*val[i]; i++; /* sdu */
        if (i+3<n)
         {
            Q[1] = Q[3] = SQR_SOL(val[i]); i++; /* sdne */
            Q[2] = Q[6] = SQR_SOL(val[i]); i++; /* sdeu */
            Q[5] = Q[7] = SQR_SOL(val[i]); i++; /* sdun */
        }
        covecef(pos,Q,P);
        covtosol(P,sol);
    }
    if (i<n) sol->age   = (float)val[i++];
    if (i<n) sol->ratio = (float)val[i];

    sol->type = 0; /* postion type = xyz */

    if (MAXSOLQ<sol->stat) sol->stat = SOLQ_NONE;
    return 1;
}


/* decode e/n/u-baseline -----------------------------------------------------*/
int decode_solenu(char *buff, const solopt_t *opt, sol_t *sol)
{
    double val[MAXFIELD],Q[9] = {0};
    int i = 0,j,n;
    const char *sep = opt2sep(opt);

    trace(4,"decode_solenu:\n");

    if ((n = tonum(buff,sep,val))<3) return 0;

    for (j = 0;j<3;j++)
     {
        sol->rr[j] = val[i++]; /* enu */
    }
    if (i<n) sol->stat = (unsigned char)val[i++];
    if (i<n) sol->ns   = (unsigned char)val[i++];
    if (i+3<n)
    {
        Q[0] = val[i]*val[i]; i++; /* sde */
        Q[4] = val[i]*val[i]; i++; /* sdn */
        Q[8] = val[i]*val[i]; i++; /* sdu */
        if (i+3<n)
        {
            Q[1] = Q[3] = SQR_SOL(val[i]); i++; /* sden */
            Q[5] = Q[7] = SQR_SOL(val[i]); i++; /* sdnu */
            Q[2] = Q[6] = SQR_SOL(val[i]); i++; /* sdue */
        }
        covtosol(Q,sol);
    }
    if (i<n) sol->age   = (float)val[i++];
    if (i<n) sol->ratio = (float)val[i];

    sol->type = 1; /* postion type = enu */

    if (MAXSOLQ<sol->stat) sol->stat = SOLQ_NONE;
    return 1;
}


/* decode gsi f solution -----------------------------------------------------*/
int decode_solgsi(char *buff, const solopt_t *opt, sol_t *sol)
{
    double val[MAXFIELD];
    int i = 0,j;

    trace(4,"decode_solgsi:\n");

    if (tonum(buff," ",val)<3) return 0;

    for (j = 0;j<3;j++)
    {
        sol->rr[j] = val[i++]; /* xyz */
    }
    sol->stat = SOLQ_FIX;
    return 1;
}


/* decode solution position --------------------------------------------------*/
int decode_solpos(char *buff, const solopt_t *opt, sol_t *sol)
{
    sol_t sol0 = {{0}};
    char *p = buff;

    trace(4,"decode_solpos: buff=%s\n",buff);

    *sol = sol0;

    /* decode solution time */
    if (!(p = decode_soltime(p,opt,&sol->time)))
    {
        return 0;
    }
    /* decode solution position */
    switch (opt->posf)
    {
        case SOLF_XYZ : return decode_solxyz(p,opt,sol);
        case SOLF_LLH : return decode_solllh(p,opt,sol);
        case SOLF_ENU : return decode_solenu(p,opt,sol);
        case SOLF_GSIF: return decode_solgsi(p,opt,sol);
    }
    return 0;
}


/* decode reference position -------------------------------------------------*/
void decode_refpos(char *buff, const solopt_t *opt, double *rb)
{
    double val[MAXFIELD],pos[3];
    int i,n;
    const char *sep = opt2sep(opt);

    trace(3,"decode_refpos: buff=%s\n",buff);

    if ((n = tonum(buff,sep,val))<3) return;

    if (opt->posf == SOLF_XYZ)
    { /* xyz */
        for (i = 0;i<3;i++) rb[i] = val[i];
    }
    else if (opt->degf == 0)
    { /* lat/lon/hgt (ddd.ddd) */
        pos[0] = val[0]*D2R;
        pos[1] = val[1]*D2R;
        pos[2] = val[2];
        pos2ecef(pos,rb);
    }
    else if (opt->degf == 1 && n >= 7)
     { /* lat/lon/hgt (ddd mm ss) */
        pos[0] = dms2deg(val  )*D2R;
        pos[1] = dms2deg(val+3)*D2R;
        pos[2] = val[6];
        pos2ecef(pos,rb);
    }
}


/* decode solution -----------------------------------------------------------*/
int decode_sol(char *buff, const solopt_t *opt, sol_t *sol, double *rb)
{
    char *p;

    trace(4,"decode_sol: buff=%s\n",buff);

    if (!strncmp(buff,COMMENTH,1))
    { /* reference position */
        if (!strstr(buff,"ref pos") && !strstr(buff,"slave pos")) return 0;
        if (!(p = strchr(buff,':'))) return 0;
        decode_refpos(p+1,opt,rb);
        return 0;
    }
    if (!strncmp(buff,"$GP",3))
    { /* decode nmea */
        if (!decode_nmea(buff,sol)) return 0;

        /* for time update only */
        if (opt->posf != SOLF_NMEA && !strncmp(buff,"$GPRMC",6)) return 2;
    }
    else
    { /* decode position record */
        if (!decode_solpos(buff,opt,sol)) return 0;
    }
    return 1;
}


/* decode solution options ---------------------------------------------------*/
void decode_solopt(char *buff, solopt_t *opt)
{
    char *p;

    trace(4,"decode_solhead: buff=%s\n",buff);

    if (strncmp(buff,COMMENTH,1) && strncmp(buff,"+",1)) return;

    if      (strstr(buff,"GPST")) opt->times = TIMES_GPST;
    else if (strstr(buff,"UTC" )) opt->times = TIMES_UTC;
    else if (strstr(buff,"JST" )) opt->times = TIMES_JST;

    if ((p = strstr(buff,"x-ecef(m)")))
    {
        opt->posf = SOLF_XYZ;
        opt->degf = 0;
        strncpy(opt->sep,p+9,1);
        opt->sep[1] = '\0';
    }
    else if ((p = strstr(buff,"latitude(d'\")")))
    {
        opt->posf = SOLF_LLH;
        opt->degf = 1;
        strncpy(opt->sep,p+14,1);
        opt->sep[1] = '\0';
    }
    else if ((p = strstr(buff,"latitude(deg)")))
    {
        opt->posf = SOLF_LLH;
        opt->degf = 0;
        strncpy(opt->sep,p+13,1);
        opt->sep[1] = '\0';
    }
    else if ((p = strstr(buff,"e-baseline(m)")))
    {
        opt->posf = SOLF_ENU;
        opt->degf = 0;
        strncpy(opt->sep,p+13,1);
        opt->sep[1] = '\0';
    }
    else if ((p = strstr(buff,"+SITE/INF")))
    { /* gsi f2/f3 solution */
        opt->times = TIMES_GPST;
        opt->posf = SOLF_GSIF;
        opt->degf = 0;
        strcpy(opt->sep," ");
    }
}


/* read solution option ------------------------------------------------------*/
void readsolopt(FILE *fp, solopt_t *opt)
{
    char buff[MAXSOLMSG+1];
    int i;

    trace(3,"readsolopt:\n");

    for (i = 0;fgets(buff,sizeof(buff),fp) && i<100;i++)
    { /* only 100 lines */
        /* decode solution options */
        decode_solopt(buff,opt);
    }
}


/* input solution data from stream ---------------------------------------------
* input solution data from stream
* args   : unsigned char data I stream data
*          gtime_t ts       I  start time (ts.time == 0: from start)
*          gtime_t te       I  end time   (te.time == 0: to end)
*          double tint      I  time interval (0: all)
*          int    qflag     I  quality flag  (0: all)
*          solbuf_t *solbuf IO solution buffer
* return : status (1:solution received,0:no solution,-1:disconnect received)
*-----------------------------------------------------------------------------*/
int inputsol(unsigned char data, gtime_t ts, gtime_t te, double tint,
                    int qflag, const solopt_t *opt, solbuf_t *solbuf)
{
    sol_t sol = {{0}};
    int stat;

    trace(4,"inputsol: data=0x%02x\n",data);

    sol.time = solbuf->time;

    if (data == '$' || (!isprint(data) && data != '\r' && data != '\n'))
    { /* sync header */
        solbuf->nb = 0;
    }
    solbuf->buff[solbuf->nb++] = data;
    if (data != '\n' && solbuf->nb<MAXSOLMSG) return 0; /* sync trailer */

    solbuf->buff[solbuf->nb] = '\0';
    solbuf->nb = 0;

    /* check disconnect message */
    if (!strcmp((char *)solbuf->buff,MSG_DISCONN))
    {
        trace(3,"disconnect received\n");
        return -1;
    }
    /* decode solution */
    if ((stat = decode_sol((char *)solbuf->buff,opt,&sol,solbuf->rb))>0)
    {
        solbuf->time = sol.time; /* update current time */
    }
    if (stat != 1 || !screent(sol.time,ts,te,tint) || (qflag && sol.stat != qflag))
    {
        return 0;
    }
    /* add solution to solution buffer */
    return addsol(solbuf,&sol);
}


/* read solution data --------------------------------------------------------*/
int readsoldata(FILE *fp, gtime_t ts, gtime_t te, double tint, int qflag,
                      const solopt_t *opt, solbuf_t *solbuf)
{
    int c;

    trace(3,"readsoldata:\n");

    while ((c = fgetc(fp)) != EOF)
    {
        /* input solution */
        inputsol((unsigned char)c,ts,te,tint,qflag,opt,solbuf);
    }
    return solbuf->n>0;
}


/* compare solution data -----------------------------------------------------*/
int cmpsol(const void *p1, const void *p2)
{
    sol_t *q1 = (sol_t *)p1,*q2 = (sol_t *)p2;
    double tt = timediff(q1->time,q2->time);
    return tt<-0.0?-1:(tt>0.0?1:0);
}


/* sort solution data --------------------------------------------------------*/
int sort_solbuf(solbuf_t *solbuf)
{
    sol_t *solbuf_data;

    trace(4,"sort_solbuf: n=%d\n",solbuf->n);

    if (solbuf->n <= 0) return 0;

    if (!(solbuf_data = (sol_t *)realloc(solbuf->data,sizeof(sol_t)*solbuf->n)))
    {
        trace(1,"sort_solbuf: memory allocation error\n");
        free(solbuf->data); solbuf->data = NULL; solbuf->n = solbuf->nmax = 0;
        return 0;
    }
    solbuf->data = solbuf_data;
    qsort(solbuf->data,solbuf->n,sizeof(sol_t),cmpsol);
    solbuf->nmax = solbuf->n;
    solbuf->start = 0;
    solbuf->end = solbuf->n-1;
    return 1;
}


/* read solutions data from solution files -------------------------------------
* read solution data from soluiton files
* args   : char   *files[]  I  solution files
*          int    nfile     I  number of files
*         (gtime_t ts)      I  start time (ts.time == 0: from start)
*         (gtime_t te)      I  end time   (te.time == 0: to end)
*         (double tint)     I  time interval (0: all)
*         (int    qflag)    I  quality flag  (0: all)
*          solbuf_t *solbuf O  solution buffer
* return : status (1:ok,0:no data or error)
*-----------------------------------------------------------------------------*/
int readsolt(char *files[], int nfile, gtime_t ts, gtime_t te,
                    double tint, int qflag, solbuf_t *solbuf)
{
    FILE *fp;
    solopt_t opt = solopt_default;
    int i;

    trace(3,"readsolt: nfile=%d\n",nfile);

    initsolbuf(solbuf,0,0);

    for (i = 0;i<nfile;i++)
    {
        if (!(fp = fopen(files[i],"rb")))
        {
            trace(1,"readsolt: file open error %s\n",files[i]);
            continue;
        }
        /* read solution options in header */
        readsolopt(fp,&opt);
        rewind(fp);

        /* read solution data */
        if (!readsoldata(fp,ts,te,tint,qflag,&opt,solbuf))
        {
            trace(1,"readsolt: no solution in %s\n",files[i]);
        }
        fclose(fp);
    }
    return sort_solbuf(solbuf);
}


int readsol(char *files[], int nfile, solbuf_t *sol)
{
    gtime_t time = {0};

    trace(3,"readsol: nfile=%d\n",nfile);

    return readsolt(files,nfile,time,time,0.0,0,sol);
}


/* add solution data to solution buffer ----------------------------------------
* add solution data to solution buffer
* args   : solbuf_t *solbuf IO solution buffer
*          sol_t  *sol      I  solution data
* return : status (1:ok,0:error)
*-----------------------------------------------------------------------------*/
int addsol(solbuf_t *solbuf, const sol_t *sol)
{
    sol_t *solbuf_data;

    trace(4,"addsol:\n");

    if (solbuf->cyclic)
    { /* ring buffer */
        if (solbuf->nmax <= 1) return 0;
        solbuf->data[solbuf->end] = *sol;
        if (++solbuf->end >= solbuf->nmax) solbuf->end = 0;
        if (solbuf->start == solbuf->end)
        {
            if (++solbuf->start >= solbuf->nmax) solbuf->start = 0;
        }
        else solbuf->n++;

        return 1;
    }

    if (solbuf->n >= solbuf->nmax)
    {
        solbuf->nmax = solbuf->nmax == 0?8192:solbuf->nmax*2;
        if (!(solbuf_data = (sol_t *)realloc(solbuf->data,sizeof(sol_t)*solbuf->nmax)))
        {
            trace(1,"addsol: memory allocation error\n");
            free(solbuf->data); solbuf->data = NULL; solbuf->n = solbuf->nmax = 0;
            return 0;
        }
        solbuf->data = solbuf_data;
    }
    solbuf->data[solbuf->n++] = *sol;
    return 1;
}


/* get solution data from solution buffer --------------------------------------
* get solution data by index from solution buffer
* args   : solbuf_t *solbuf I  solution buffer
*          int    index     I  index of solution (0...)
* return : solution data pointer (NULL: no solution, out of range)
*-----------------------------------------------------------------------------*/
sol_t *getsol(solbuf_t *solbuf, int index)
{
    trace(4,"getsol: index=%d\n",index);

    if (index<0 || solbuf->n <= index) return NULL;
    if ((index = solbuf->start+index) >= solbuf->nmax)
    {
        index -= solbuf->nmax;
    }
    return solbuf->data+index;
}


/* initialize solution buffer --------------------------------------------------
* initialize position solutions
* args   : solbuf_t *solbuf I  solution buffer
*          int    cyclic    I  solution data buffer type (0:linear,1:cyclic)
*          int    nmax      I  initial number of solution data
* return : status (1:ok,0:error)
*-----------------------------------------------------------------------------*/
void initsolbuf(solbuf_t *solbuf, int cyclic, int nmax)
{
    gtime_t time0 = {0};

    trace(3,"initsolbuf: cyclic=%d nmax=%d\n",cyclic,nmax);

    solbuf->n = solbuf->nmax = solbuf->start = solbuf->end = 0;
    solbuf->cyclic = cyclic;
    solbuf->time = time0;
    solbuf->data = NULL;
    if (cyclic)
    {
        if (nmax <= 2) nmax=2;
        if (!(solbuf->data = (sol_t*)malloc(sizeof(sol_t)*nmax)))
        {
            trace(1,"initsolbuf: memory allocation error\n");
            return;
        }
        solbuf->nmax = nmax;
    }
}


/* free solution ---------------------------------------------------------------
* free memory for solution buffer
* args   : solbuf_t *solbuf I  solution buffer
* return : none
*-----------------------------------------------------------------------------*/
void freesolbuf(solbuf_t *solbuf)
{
    trace(3,"freesolbuf: n=%d\n",solbuf->n);

    free(solbuf->data);
    solbuf->n = solbuf->nmax = solbuf->start = solbuf->end = 0;
    solbuf->data = NULL;
}


void freesolstatbuf(solstatbuf_t *solstatbuf)
{
    trace(3,"freesolstatbuf: n=%d\n",solstatbuf->n);

    solstatbuf->n = solstatbuf->nmax = 0;
    free(solstatbuf->data);
    solstatbuf->data = NULL;
}


/* compare solution status ---------------------------------------------------*/
int cmpsolstat(const void *p1, const void *p2)
{
    solstat_t *q1 = (solstat_t *)p1,*q2 = (solstat_t *)p2;
    double tt = timediff(q1->time,q2->time);
    return tt<-0.0?-1:(tt>0.0?1:0);
}


/* sort solution data --------------------------------------------------------*/
int sort_solstat(solstatbuf_t *statbuf)
{
    solstat_t *statbuf_data;

    trace(4,"sort_solstat: n=%d\n",statbuf->n);

    if (statbuf->n <= 0) return 0;

    if (!(statbuf_data = (solstat_t*)realloc(statbuf->data,sizeof(solstat_t)*statbuf->n)))
    {
        trace(1,"sort_solstat: memory allocation error\n");
        free(statbuf->data); statbuf->data = NULL; statbuf->n = statbuf->nmax = 0;
        return 0;
    }
    statbuf->data = statbuf_data;
    qsort(statbuf->data,statbuf->n,sizeof(solstat_t),cmpsolstat);
    statbuf->nmax = statbuf->n;
    return 1;
}


/* decode solution status ----------------------------------------------------*/
int decode_solstat(char *buff, solstat_t *stat)
{
    static const solstat_t stat0 = {{0}};
    double tow,az,el,resp,resc;
    int n,week,sat,frq,vsat,snr,fix,slip,lock,outc,slipc,rejc;
    char id[32] = "",*p;

    trace(4,"decode_solstat: buff=%s\n",buff);

    if (strstr(buff,"$SAT") != buff) return 0;

    for (p = buff;*p;p++) if (*p == ',') *p = ' ';

    n = sscanf(buff,"$SAT%d%lf%s%d%lf%lf%lf%lf%d%d%d%d%d%d%d%d",
             &week,&tow,id,&frq,&az,&el,&resp,&resc,&vsat,&snr,&fix,&slip,
             &lock,&outc,&slipc,&rejc);

    if (n<15)
     {
        trace(2,"invalid format of solution status: %s\n",buff);
        return 0;
    }
    if ((sat = satid2no(id)) <= 0)
    {
        trace(2,"invalid satellite in solution status: %s\n",id);
        return 0;
    }
    *stat = stat0;
    stat->time = gpst2time(week,tow);
    stat->sat   = (unsigned char)sat;
    stat->frq   = (unsigned char)frq;
    stat->az    = (float)(az*D2R);
    stat->el    = (float)(el*D2R);
    stat->resp  = (float)resp;
    stat->resc  = (float)resc;
    stat->flag  = (unsigned char)((vsat<<5)+(slip<<3)+fix);
    stat->snr   = (unsigned char)(snr*4.0+0.5);
    stat->lock  = (unsigned short)lock;
    stat->outc  = (unsigned short)outc;
    stat->slipc = (unsigned short)slipc;
    stat->rejc  = (unsigned short)rejc;
    return 1;
}

/* add solution status data --------------------------------------------------*/
void addsolstat(solstatbuf_t *statbuf, const solstat_t *stat)
{
    solstat_t *statbuf_data;

    trace(4,"addsolstat:\n");

    if (statbuf->n >= statbuf->nmax)
    {
        statbuf->nmax = statbuf->nmax == 0?8192:statbuf->nmax*2;
        if (!(statbuf_data = (solstat_t *)realloc(statbuf->data,sizeof(solstat_t)*
                                                statbuf->nmax)))
                                                {
            trace(1,"addsolstat: memory allocation error\n");
            free(statbuf->data); statbuf->data = NULL; statbuf->n = statbuf->nmax = 0;
            return;
        }
        statbuf->data = statbuf_data;
    }
    statbuf->data[statbuf->n++] = *stat;
}


/* read solution status data -------------------------------------------------*/
int readsolstatdata(FILE *fp, gtime_t ts, gtime_t te, double tint,
                           solstatbuf_t *statbuf)
{
    solstat_t stat = {{0}};
    char buff[MAXSOLMSG+1];

    trace(3,"readsolstatdata:\n");

    while (fgets(buff,sizeof(buff),fp))
    {
        /* decode solution status */
        if (!decode_solstat(buff,&stat)) continue;

        /* add solution to solution buffer */
        if (screent(stat.time,ts,te,tint))
        {
            addsolstat(statbuf,&stat);
        }
    }
    return statbuf->n>0;
}


/* read solution status --------------------------------------------------------
* read solution status from solution status files
* args   : char   *files[]  I  solution status files
*          int    nfile     I  number of files
*         (gtime_t ts)      I  start time (ts.time == 0: from start)
*         (gtime_t te)      I  end time   (te.time == 0: to end)
*         (double tint)     I  time interval (0: all)
*          solstatbuf_t *statbuf O  solution status buffer
* return : status (1:ok,0:no data or error)
*-----------------------------------------------------------------------------*/
int readsolstatt(char *files[], int nfile, gtime_t ts, gtime_t te,
                        double tint, solstatbuf_t *statbuf)
{
    FILE *fp;
    char path[1024];
    int i;

    trace(3,"readsolstatt: nfile=%d\n",nfile);

    statbuf->n = statbuf->nmax = 0;
    statbuf->data = NULL;

    for (i = 0;i<nfile;i++)
    {
        sprintf(path,"%s.stat",files[i]);
        if (!(fp = fopen(path,"r")))
        {
            trace(1,"readsolstatt: file open error %s\n",path);
            continue;
        }
        /* read solution status data */
        if (!readsolstatdata(fp,ts,te,tint,statbuf))
        {
            trace(1,"readsolt: no solution in %s\n",path);
        }
        fclose(fp);
    }
    return sort_solstat(statbuf);
}


int readsolstat(char *files[], int nfile, solstatbuf_t *statbuf)
{
    gtime_t time = {0};

    trace(3,"readsolstat: nfile=%d\n",nfile);

    return readsolstatt(files,nfile,time,time,0.0,statbuf);
}


/* output solution as the form of x/y/z-ecef ---------------------------------*/
int outecef(unsigned char *buff, const char *s, const sol_t *sol,
                   const solopt_t *opt)
{
    const char *sep = opt2sep(opt);
    char *p = (char *)buff;

    trace(3,"outecef:\n");

    p += sprintf(p,"%s%s%14.4f%s%14.4f%s%14.4f%s%3d%s%3d%s%8.4f%s%8.4f%s%8.4f%s%8.4f%s%8.4f%s%8.4f%s%6.2f%s%6.1f\n",
               s,sep,sol->rr[0],sep,sol->rr[1],sep,sol->rr[2],sep,sol->stat,sep,
               sol->ns,sep,SQRT_SOL(sol->qr[0]),sep,SQRT_SOL(sol->qr[1]),sep,SQRT_SOL(sol->qr[2]),
               sep,sqvar(sol->qr[3]),sep,sqvar(sol->qr[4]),sep,sqvar(sol->qr[5]),
               sep,sol->age,sep,sol->ratio);
    return p-(char *)buff;
}


/* output solution as the form of lat/lon/height -----------------------------*/
int outpos(unsigned char *buff, const char *s, const sol_t *sol,
                  const solopt_t *opt)
{
    double pos[3],dms1[3],dms2[3],P[9],Q[9];
    const char *sep = opt2sep(opt);
    char *p = (char *)buff;

    trace(3,"outpos  :\n");

    ecef2pos(sol->rr,pos);
    soltocov(sol,P);
    covenu(pos,P,Q);
    if (opt->height == 1)
    { /* geodetic height */
        // pos[2] -= geoidh(pos);
    }
    if (opt->degf)
    {
        deg2dms(pos[0]*R2D,dms1);
        deg2dms(pos[1]*R2D,dms2);
        p += sprintf(p,"%s%s%4.0f%s%02.0f%s%08.5f%s%4.0f%s%02.0f%s%08.5f",s,sep,
                   dms1[0],sep,dms1[1],sep,dms1[2],sep,dms2[0],sep,dms2[1],sep,
                   dms2[2]);
    }
    else p += sprintf(p,"%s%s%14.9f%s%14.9f",s,sep,pos[0]*R2D,sep,pos[1]*R2D);
    p += sprintf(p,"%s%10.4f%s%3d%s%3d%s%8.4f%s%8.4f%s%8.4f%s%8.4f%s%8.4f%s%8.4f%s%6.2f%s%6.1f\n",
               sep,pos[2],sep,sol->stat,sep,sol->ns,sep,SQRT_SOL(Q[4]),sep,
               SQRT_SOL(Q[0]),sep,SQRT_SOL(Q[8]),sep,sqvar(Q[1]),sep,sqvar(Q[2]),
               sep,sqvar(Q[5]),sep,sol->age,sep,sol->ratio);
    return p-(char *)buff;
}


/* output solution as the form of e/n/u-baseline -----------------------------*/
int outenu(unsigned char *buff, const char *s, const sol_t *sol,
                  const double *rb, const solopt_t *opt)
{
    double pos[3],rr[3],enu[3],P[9],Q[9];
    int i;
    const char *sep = opt2sep(opt);
    char *p = (char *)buff;

    trace(3,"outenu  :\n");

    for (i = 0;i<3;i++) rr[i] = sol->rr[i]-rb[i];
    ecef2pos(rb,pos);
    soltocov(sol,P);
    covenu(pos,P,Q);
    ecef2enu(pos,rr,enu);
    p += sprintf(p,"%s%s%14.4f%s%14.4f%s%14.4f%s%3d%s%3d%s%8.4f%s%8.4f%s%8.4f%s%8.4f%s%8.4f%s%8.4f%s%6.2f%s%6.1f\n",
               s,sep,enu[0],sep,enu[1],sep,enu[2],sep,sol->stat,sep,sol->ns,sep,
               SQRT_SOL(Q[0]),sep,SQRT_SOL(Q[4]),sep,SQRT_SOL(Q[8]),sep,sqvar(Q[1]),
               sep,sqvar(Q[5]),sep,sqvar(Q[2]),sep,sol->age,sep,sol->ratio);
    return p-(char *)buff;
}


/* output solution in the form of nmea RMC sentence --------------------------*/
int outnmea_rmc(unsigned char *buff, const sol_t *sol)
{
    static double dirp = 0.0;
    gtime_t time;
    double ep[6],pos[3],enuv[3],dms1[3],dms2[3],vel,dir,amag = 0.0;
    char *p = (char *)buff,*q,sum,*emag = "E";

    trace(3,"outnmea_rmc:\n");

    if (sol->stat <= SOLQ_NONE)
    {
        p += sprintf(p,"$GPRMC,,,,,,,,,,,,");
        for (q=(char *)buff+1,sum = 0;*q;q++) sum ^= *q;
        p += sprintf(p,"*%02X%c%c",sum,0x0D,0x0A);
        return p-(char *)buff;
    }
    time = gpst2utc(sol->time);
    if (time.sec >= 0.995) {time.time++; time.sec = 0.0;}
    time2epoch(time,ep);
    ecef2pos(sol->rr,pos);
    ecef2enu(pos,sol->rr+3,enuv);
    vel = norm_rtk(enuv,3);
    if (vel >= 1.0)
    {
        dir = atan2(enuv[0],enuv[1])*R2D;
        if (dir<0.0) dir += 360.0;
        dirp = dir;
    }
    else dir = dirp;
    deg2dms(fabs(pos[0])*R2D,dms1);
    deg2dms(fabs(pos[1])*R2D,dms2);
    p += sprintf(p,"$GPRMC,%02.0f%02.0f%05.2f,A,%02.0f%010.7f,%s,%03.0f%010.7f,%s,%4.2f,%4.2f,%02.0f%02.0f%02d,%.1f,%s,%s",
               ep[3],ep[4],ep[5],dms1[0],dms1[1]+dms1[2]/60.0,pos[0] >= 0?"N":"S",
               dms2[0],dms2[1]+dms2[2]/60.0,pos[1] >= 0?"E":"W",vel/KNOT2M,dir,
               ep[2],ep[1],(int)ep[0]%100,amag,emag,
               sol->stat == SOLQ_DGPS || sol->stat == SOLQ_FLOAT || sol->stat == SOLQ_FIX?"D":"A");
    for (q = (char *)buff+1,sum = 0;*q;q++) sum ^= *q; /* check-sum */
    p += sprintf(p,"*%02X%c%c",sum,0x0D,0x0A);
    return p-(char *)buff;
}


/* output solution in the form of nmea GGA sentence --------------------------*/
int outnmea_gga(unsigned char *buff, const sol_t *sol)
{
    gtime_t time;
    double h,ep[6],pos[3],dms1[3],dms2[3],dop = 1.0;
    int solq;
    char *p = (char *)buff,*q,sum;

    trace(3,"outnmea_gga:\n");

    if (sol->stat <= SOLQ_NONE)
    {
        p += sprintf(p,"$GPGGA,,,,,,,,,,,,,,");
        for (q = (char *)buff+1,sum = 0;*q;q++) sum ^= *q;
        p += sprintf(p,"*%02X%c%c",sum,0x0D,0x0A);
        return p-(char *)buff;
    }
    for (solq = 0;solq<8;solq++) if (solq_nmea[solq] == sol->stat) break;
    if (solq >= 8) solq = 0;
    time = gpst2utc(sol->time);
    if (time.sec >= 0.995) {time.time++; time.sec = 0.0;}
    time2epoch(time,ep);
    ecef2pos(sol->rr,pos);
    h = 0;//geoidh(pos);
    deg2dms(fabs(pos[0])*R2D,dms1);
    deg2dms(fabs(pos[1])*R2D,dms2);
    p += sprintf(p,"$GPGGA,%02.0f%02.0f%05.2f,%02.0f%010.7f,%s,%03.0f%010.7f,%s,%d,%02d,%.1f,%.3f,M,%.3f,M,%.1f,",
               ep[3],ep[4],ep[5],dms1[0],dms1[1]+dms1[2]/60.0,pos[0] >= 0?"N":"S",
               dms2[0],dms2[1]+dms2[2]/60.0,pos[1] >= 0?"E":"W",solq,
               sol->ns,dop,pos[2]-h,h,sol->age);
    for (q = (char *)buff+1,sum = 0;*q;q++) sum ^= *q; /* check-sum */
    p += sprintf(p,"*%02X%c%c",sum,0x0D,0x0A);
    return p-(char *)buff;
}


/* output solution in the form of nmea GSA sentences -------------------------*/
int outnmea_gsa(unsigned char *buff, const sol_t *sol,
                       const ssat_t *ssat)
{
    double azel[MAXSAT*2],dop[4];
    int i,sat,sys,nsat,prn[MAXSAT];
    char *p = (char *)buff,*q,*s,sum;

    trace(3,"outnmea_gsa:\n");

    if (sol->stat <= SOLQ_NONE)
    {
        p += sprintf(p,"$GPGSA,A,1,,,,,,,,,,,,,,,");
        for (q = (char *)buff+1,sum = 0;*q;q++) sum ^= *q;
        p += sprintf(p,"*%02X%c%c",sum,0x0D,0x0A);
        return p-(char *)buff;
    }

    /* GPGSA: gps/sbas */
    for (sat = 1,nsat = 0;sat <= MAXSAT&&nsat<12;sat++)
    {
        if (!ssat[sat-1].vs || ssat[sat-1].azel[1] <= 0.0) continue;
        sys = satsys(sat,prn+nsat);
        if (sys != SYS_GPS && sys != SYS_SBS) continue;
        if (sys == SYS_SBS) prn[nsat] += 33-MINPRNSBS;
        for (i = 0;i<2;i++) azel[i+nsat*2] = ssat[sat-1].azel[i];
        nsat++;
    }
    if (nsat>0)
    {
        s = p;
        p += sprintf(p,"$GPGSA,A,%d",sol->stat <= 0?1:3);
        for (i = 0;i<12;i++)
        {
            if (i<nsat) p += sprintf(p,",%02d",prn[i]);
            else        p += sprintf(p,",");
        }
        dops(nsat,azel,0.0,dop);
        p += sprintf(p,",%3.1f,%3.1f,%3.1f,1",dop[1],dop[2],dop[3]);
        for (q = s+1,sum = 0;*q;q++) sum ^= *q; /* check-sum */
        p += sprintf(p,"*%02X%c%c",sum,0x0D,0x0A);
    }
    /* GLGSA: glonass */
    for (sat = 1,nsat = 0;sat <= MAXSAT && nsat<12;sat++)
    {
        if (!ssat[sat-1].vs || ssat[sat-1].azel[1] <= 0.0) continue;
        if (satsys(sat,prn+nsat) != SYS_GLO) continue;
        for (i = 0;i<2;i++) azel[i+nsat*2] = ssat[sat-1].azel[i];
        nsat++;
    }
    if (nsat>0)
    {
        s = p;
        p += sprintf(p,"$GLGSA,A,%d",sol->stat <= 0?1:3);
        for (i = 0;i<12;i++)
        {
            if (i<nsat) p += sprintf(p,",%02d",prn[i]+64);
            else        p += sprintf(p,",");
        }
        dops(nsat,azel,0.0,dop);
        p += sprintf(p,",%3.1f,%3.1f,%3.1f,2",dop[1],dop[2],dop[3]);
        for (q = s+1,sum = 0;*q;q++) sum ^= *q; /* check-sum */
        p += sprintf(p,"*%02X%c%c",sum,0x0D,0x0A);
    }
    /* GAGSA: galileo */
    for (sat = 1,nsat = 0;sat <= MAXSAT && nsat<12;sat++)
    {
        if (!ssat[sat-1].vs || ssat[sat-1].azel[1] <= 0.0) continue;
        if (satsys(sat,prn+nsat) != SYS_GAL) continue;
        for (i = 0;i<2;i++) azel[i+nsat*2] = ssat[sat-1].azel[i];
        nsat++;
    }
    if (nsat>0)
    {
        s = p;
        p += sprintf(p,"$GAGSA,A,%d",sol->stat <= 0?1:3);
        for (i = 0;i<12;i++)
        {
            if (i<nsat) p += sprintf(p,",%02d",prn[i]);
            else        p += sprintf(p,",");
        }
        dops(nsat,azel,0.0,dop);
        p += sprintf(p,",%3.1f,%3.1f,%3.1f,3",dop[1],dop[2],dop[3]);
        for (q = s+1,sum = 0;*q;q++) sum ^= *q; /* check-sum */
        p += sprintf(p,"*%02X%c%c",sum,0x0D,0x0A);
    }
    return p-(char *)buff;
}


/* output solution in the form of nmea GSV sentence --------------------------*/
int outnmea_gsv(unsigned char *buff, const sol_t *sol,
                       const ssat_t *ssat)
{
    double az,el,snr;
    int i,j,k,n,sat,prn,sys,nmsg,sats[MAXSAT];
    char *p = (char *)buff,*q,*s,sum;

    trace(3,"outnmea_gsv:\n");

    if (sol->stat <= SOLQ_NONE)
    {
        p += sprintf(p,"$GPGSV,1,1,0,,,,,,,,,,,,,,,,");
        for (q = (char *)buff+1,sum = 0;*q;q++) sum ^= *q;
        p += sprintf(p,"*%02X%c%c",sum,0x0D,0x0A);
        return p-(char *)buff;
    }
    /* GPGSV: gps/sbas */
    for (sat = 1,n = 0;sat<MAXSAT && n<12;sat++)
    {
        sys = satsys(sat,&prn);
        if (sys != SYS_GPS && sys != SYS_SBS) continue;
        if (ssat[sat-1].vs && ssat[sat-1].azel[1]>0.0) sats[n++] = sat;
    }
    nmsg = n <= 0?0:(n-1)/4+1;

    for (i = k = 0;i<nmsg;i++)
    {
        s = p;
        p += sprintf(p,"$GPGSV,%d,%d,%02d",nmsg,i+1,n);

        for (j = 0;j<4;j++,k++)
        {
            if (k<n)
            {
                if (satsys(sats[k],&prn) == SYS_SBS) prn += 33-MINPRNSBS;
                az  = ssat[sats[k]-1].azel[0]*R2D; if (az<0.0) az += 360.0;
                el  = ssat[sats[k]-1].azel[1]*R2D;
                snr = ssat[sats[k]-1].snr[0]*0.25;
                p += sprintf(p,",%02d,%02.0f,%03.0f,%02.0f",prn,el,az,snr);
            }
            else p += sprintf(p,",,,,");
        }
        p += sprintf(p,",1"); /* L1C/A */
        for (q = s+1,sum = 0;*q;q++) sum ^= *q; /* check-sum */
        p += sprintf(p,"*%02X%c%c",sum,0x0D,0x0A);
    }
    /* GLGSV: glonass */
    for (sat = 1,n = 0;sat<MAXSAT && n<12;sat++)
    {
        if (satsys(sat,&prn) != SYS_GLO) continue;
        if (ssat[sat-1].vs && ssat[sat-1].azel[1]>0.0) sats[n++] = sat;
    }
    nmsg = n <= 0?0:(n-1)/4+1;

    for (i = k = 0;i<nmsg;i++)
    {
        s = p;
        p += sprintf(p,"$GLGSV,%d,%d,%02d",nmsg,i+1,n);

        for (j = 0;j<4;j++,k++)
        {
            if (k<n)
            {
                satsys(sats[k],&prn); prn += 64; /* 65-99 */
                az  = ssat[sats[k]-1].azel[0]*R2D; if (az<0.0) az += 360.0;
                el  = ssat[sats[k]-1].azel[1]*R2D;
                snr = ssat[sats[k]-1].snr[0]*0.25;
                p += sprintf(p,",%02d,%02.0f,%03.0f,%02.0f",prn,el,az,snr);
            }
            else p += sprintf(p,",,,,");
        }
        p += sprintf(p,",1"); /* L1C/A */
        for (q = s+1,sum = 0;*q;q++) sum ^= *q; /* check-sum */
        p += sprintf(p,"*%02X%c%c",sum,0x0D,0x0A);
    }
    /* GAGSV: galileo */
    for (sat = 1,n = 0;sat<MAXSAT && n<12;sat++)
    {
        if (satsys(sat,&prn) != SYS_GAL) continue;
        if (ssat[sat-1].vs && ssat[sat-1].azel[1]>0.0) sats[n++] = sat;
    }
    nmsg = n <= 0?0:(n-1)/4+1;

    for (i = k = 0;i<nmsg;i++)
    {
        s = p;
        p += sprintf(p,"$GAGSV,%d,%d,%02d",nmsg,i+1,n);

        for (j = 0;j<4;j++,k++)
        {
            if (k<n)
            {
                satsys(sats[k],&prn); /* 1-36 */
                az  = ssat[sats[k]-1].azel[0]*R2D; if (az<0.0) az += 360.0;
                el  = ssat[sats[k]-1].azel[1]*R2D;
                snr = ssat[sats[k]-1].snr[0]*0.25;
                p += sprintf(p,",%02d,%02.0f,%03.0f,%02.0f",prn,el,az,snr);
            }
            else p += sprintf(p,",,,,");
        }
        p += sprintf(p,",7"); /* L1BC */
        for (q = s+1,sum = 0;*q;q++) sum ^= *q; /* check-sum */
        p += sprintf(p,"*%02X%c%c",sum,0x0D,0x0A);
    }
    return p-(char *)buff;
}


/* output processing options ---------------------------------------------------
* output processing options to buffer
* args   : unsigned char *buff IO output buffer
*          prcopt_t *opt    I   processign options
* return : number of output bytes
*-----------------------------------------------------------------------------*/
int outprcopts(unsigned char *buff, const prcopt_t *opt)
{
    const int sys[] = {SYS_GPS,SYS_GLO,SYS_GAL,SYS_QZS,SYS_SBS,0};
    const char *s1[] = {"single","dgps","kinematic","static","moving-base","fixed",
                 "ppp-kinematic","ppp-static","ppp-fixed",""};
    const char *s2[] = {"L1","L1+L2","L1+L2+L5","L1+L2+L5+L6","L1+L2+L5+L6+L7",
                      "L1+L2+L5+L6+L7+L8",""};
    const char *s3[] = {"forward","backward","combined"};
    const char *s4[] = {"off","broadcast","sbas","iono-free","estimation",
                      "ionex tec","qzs","lex","vtec_sf","vtec_ef","gtec",""};
    const char *s5[] = {"off","saastamoinen","sbas","est ztd","est ztd+grad",""};
    const char *s6[] = {"broadcast","precise","broadcast+sbas","broadcast+ssr apc",
                      "broadcast+ssr com","qzss lex",""};
    const char *s7[] = {"gps","glonass","galileo","qzss","sbas",""};
    const char *s8[] = {"off","continuous","instantaneous","fix and hold",""};
    const char *s9[] = {"off","on","auto calib","external calib",""};
    int i;
    char *p = (char *)buff;

    trace(3,"outprcopts:\n");

    p += sprintf(p,"%s pos mode  : %s\n",COMMENTH,s1[opt->mode]);

    if (PMODE_DGPS <= opt->mode && opt->mode <= PMODE_FIXED)
    {
        p += sprintf(p,"%s freqs     : %s\n",COMMENTH,s2[opt->nf-1]);
    }
    if (opt->mode>PMODE_SINGLE)
    {
        p += sprintf(p,"%s solution  : %s\n",COMMENTH,s3[opt->soltype]);
    }
    p += sprintf(p,"%s elev mask : %.1f deg\n",COMMENTH,opt->elmin*R2D);
    if (opt->mode>PMODE_SINGLE)
    {
        p += sprintf(p,"%s dynamics  : %s\n",COMMENTH,opt->dynamics?"on":"off");
        p += sprintf(p,"%s tidecorr  : %s\n",COMMENTH,opt->tidecorr?"on":"off");
    }
    if (opt->mode <= PMODE_FIXED)
    {
        p += sprintf(p,"%s ionos opt : %s\n",COMMENTH,s4[opt->ionoopt]);
    }
    p += sprintf(p,"%s tropo opt : %s\n",COMMENTH,s5[opt->tropopt]);
    p += sprintf(p,"%s ephemeris : %s\n",COMMENTH,s6[opt->sateph]);
    if (opt->navsys != SYS_GPS)
    {
        p += sprintf(p,"%s navi sys  :",COMMENTH);
        for (i = 0;sys[i];i++)
        {
            if (opt->navsys&sys[i]) p += sprintf(p," %s",s7[i]);
        }
        p += sprintf(p,"\n");
    }
    if (PMODE_KINEMA <= opt->mode && opt->mode <= PMODE_FIXED)
    {
        p += sprintf(p,"%s amb res   : %s\n",COMMENTH,s8[opt->modear]);
        if (opt->navsys&SYS_GLO)
        {
            p += sprintf(p,"%s amb glo   : %s\n",COMMENTH,s9[opt->glomodear]);
        }
        if (opt->thresar[0]>0.0)
        {
            p += sprintf(p,"%s val thres : %.1f\n",COMMENTH,opt->thresar[0]);
        }
    }
    if (opt->mode == PMODE_MOVEB && opt->baseline[0]>0.0)
    {
        p += sprintf(p,"%s baseline  : %.4f %.4f m\n",COMMENTH,
                   opt->baseline[0],opt->baseline[1]);
    }
    for (i = 0;i<2;i++)
    {
        if (opt->mode == PMODE_SINGLE || (i >= 1 && opt->mode>PMODE_FIXED)) continue;
        p += sprintf(p,"%s antenna%d  : %-21s (%7.4f %7.4f %7.4f)\n",COMMENTH,
                   i+1,opt->anttype[i],opt->antdel[i][0],opt->antdel[i][1],
                   opt->antdel[i][2]);
    }
    return p-(char *)buff;
}


/* output solution header ------------------------------------------------------
* output solution header to buffer
* args   : unsigned char *buff IO output buffer
*          solopt_t *opt    I   solution options
* return : number of output bytes
*-----------------------------------------------------------------------------*/
int outsolheads(unsigned char *buff, const solopt_t *opt)
{
    const char *s1[] = {"WGS84","Tokyo"},*s2[] = {"ellipsoidal","geodetic"};
    const char *s3[] = {"GPST","UTC ","JST "},*sep = opt2sep(opt);
    char *p = (char *)buff;
    int timeu = opt->timeu<0?0:(opt->timeu>20?20:opt->timeu);

    trace(3,"outsolheads:\n");

    if (opt->posf == SOLF_NMEA) return 0;

    if (opt->outhead)
    {
        p += sprintf(p,"%s (",COMMENTH);
        if      (opt->posf == SOLF_XYZ) p += sprintf(p,"x/y/z-ecef=WGS84");
        else if (opt->posf == SOLF_ENU) p += sprintf(p,"e/n/u-baseline=WGS84");
        else p += sprintf(p,"lat/lon/height=%s/%s",s1[opt->datum],s2[opt->height]);
        p += sprintf(p,",Q=1:fix,2:float,3:sbas,4:dgps,5:single,6:ppp,ns=# of satellites)\n");
    }
    p += sprintf(p,"%s  %-*s%s",COMMENTH,(opt->timef?16:8)+timeu+1,s3[opt->times],sep);

    if (opt->posf == SOLF_LLH)
    { /* lat/lon/hgt */
        if (opt->degf)
         {
            p += sprintf(p,"%16s%s%16s%s%10s%s%3s%s%3s%s%8s%s%8s%s%8s%s%8s%s%8s%s%8s%s%6s%s%6s\n",
                       "latitude(d'\")",sep,"longitude(d'\")",sep,"height(m)",sep,
                       "Q",sep,"ns",sep,"sdn(m)",sep,"sde(m)",sep,"sdu(m)",sep,
                       "sdne(m)",sep,"sdeu(m)",sep,"sdue(m)",sep,"age(s)",sep,"ratio");
        }
        else
        {
            p += sprintf(p,"%14s%s%14s%s%10s%s%3s%s%3s%s%8s%s%8s%s%8s%s%8s%s%8s%s%8s%s%6s%s%6s\n",
                       "latitude(deg)",sep,"longitude(deg)",sep,"height(m)",sep,
                       "Q",sep,"ns",sep,"sdn(m)",sep,"sde(m)",sep,"sdu(m)",sep,
                       "sdne(m)",sep,"sdeu(m)",sep,"sdun(m)",sep,"age(s)",sep,"ratio");
        }
    }
    else if (opt->posf == SOLF_XYZ)
    { /* x/y/z-ecef */
        p += sprintf(p,"%14s%s%14s%s%14s%s%3s%s%3s%s%8s%s%8s%s%8s%s%8s%s%8s%s%8s%s%6s%s%6s\n",
                   "x-ecef(m)",sep,"y-ecef(m)",sep,"z-ecef(m)",sep,"Q",sep,"ns",sep,
                   "sdx(m)",sep,"sdy(m)",sep,"sdz(m)",sep,"sdxy(m)",sep,
                   "sdyz(m)",sep,"sdzx(m)",sep,"age(s)",sep,"ratio");
    }
    else if (opt->posf == SOLF_ENU)
    { /* e/n/u-baseline */
        p += sprintf(p,"%14s%s%14s%s%14s%s%3s%s%3s%s%8s%s%8s%s%8s%s%8s%s%8s%s%8s%s%6s%s%6s\n",
                   "e-baseline(m)",sep,"n-baseline(m)",sep,"u-baseline(m)",sep,
                   "Q",sep,"ns",sep,"sde(m)",sep,"sdn(m)",sep,"sdu(m)",sep,
                   "sden(m)",sep,"sdnu(m)",sep,"sdue(m)",sep,"age(s)",sep,"ratio");
    }
    return p-(char *)buff;
}


/* output solution body --------------------------------------------------------
* output solution body to buffer
* args   : unsigned char *buff IO output buffer
*          sol_t  *sol      I   solution
*          double *rb       I   base station position {x,y,z} (ecef) (m)
*          solopt_t *opt    I   solution options
* return : number of output bytes
*-----------------------------------------------------------------------------*/
int outsols(unsigned char *buff, const sol_t *sol, const double *rb,
                   const solopt_t *opt)
{
    gtime_t time,ts = {0};
    double gpst;
    int week,timeu;
    const char *sep = opt2sep(opt);
    char s[64];
    unsigned char *p = buff;

    trace(3,"outsols :\n");

    if (opt->posf == SOLF_NMEA)
    {
        if (opt->nmeaintv[0]<0.0) return 0;
        if (!screent(sol->time,ts,ts,opt->nmeaintv[0])) return 0;
    }
    if (sol->stat <= SOLQ_NONE || (opt->posf == SOLF_ENU && norm_rtk(rb,3) <= 0.0))
    {
        return 0;
    }
    timeu = opt->timeu<0?0:(opt->timeu>20?20:opt->timeu);

    time = sol->time;
    if (opt->times >= TIMES_UTC) time = gpst2utc(time);
    if (opt->times == TIMES_JST) time = timeadd(time,9*3600.0);

    if (opt->timef) time2str(time,s,timeu);
    else
    {
        gpst = time2gpst(time,&week);
        if (86400*7-gpst<0.5/pow(10.0,timeu))
        {
            week++;
            gpst = 0.0;
        }
        sprintf(s,"%4d%s%*.*f",week,sep,6+(timeu <= 0?0:timeu+1),timeu,gpst);
    }
    switch (opt->posf)
    {
        case SOLF_LLH:  p += outpos (p,s,sol,opt);   break;
        case SOLF_XYZ:  p += outecef(p,s,sol,opt);   break;
        case SOLF_ENU:  p += outenu(p,s,sol,rb,opt); break;
        case SOLF_NMEA: p += outnmea_rmc(p,sol);
                        p += outnmea_gga(p,sol); break;
    }
    return p-buff;
}


/* output solution extended ----------------------------------------------------
* output solution exteneded infomation
* args   : unsigned char *buff IO output buffer
*          sol_t  *sol      I   solution
*          ssat_t *ssat     I   satellite status
*          solopt_t *opt    I   solution options
* return : number of output bytes
* notes  : only support nmea
*-----------------------------------------------------------------------------*/
int outsolexs(unsigned char *buff, const sol_t *sol, const ssat_t *ssat,
                     const solopt_t *opt)
{
    gtime_t ts = {0};
    unsigned char *p = buff;

    trace(3,"outsolexs:\n");

    if (opt->posf == SOLF_NMEA)
    {
        if (opt->nmeaintv[1]<0.0) return 0;
        if (!screent(sol->time,ts,ts,opt->nmeaintv[1])) return 0;
    }
    if (opt->posf == SOLF_NMEA)
    {
        p += outnmea_gsa(p,sol,ssat);
        p += outnmea_gsv(p,sol,ssat);
    }
    return p-buff;
}


/* output processing option ----------------------------------------------------
* output processing option to file
* args   : FILE   *fp       I   output file pointer
*          prcopt_t *opt    I   processing options
* return : none
*-----------------------------------------------------------------------------*/
void outprcopt(FILE *fp, const prcopt_t *opt)
{
    unsigned char buff[MAXSOLMSG+1];
    int n;

    trace(3,"outprcopt:\n");

    if ((n = outprcopts(buff,opt))>0)
    {
        fwrite(buff,n,1,fp);
    }
}


/* output solution header ------------------------------------------------------
* output solution heade to file
* args   : FILE   *fp       I   output file pointer
*          solopt_t *opt    I   solution options
* return : none
*-----------------------------------------------------------------------------*/
void outsolhead(FILE *fp, const solopt_t *opt)
{
    unsigned char buff[MAXSOLMSG+1];
    int n;

    trace(3,"outsolhead:\n");

    if ((n = outsolheads(buff,opt))>0)
    {
        fwrite(buff,n,1,fp);
    }
}


/* output solution body --------------------------------------------------------
* output solution body to file
* args   : FILE   *fp       I   output file pointer
*          sol_t  *sol      I   solution
*          double *rb       I   base station position {x,y,z} (ecef) (m)
*          solopt_t *opt    I   solution options
* return : none
*-----------------------------------------------------------------------------*/
void outsol(FILE *fp, const sol_t *sol, const double *rb,
                   const solopt_t *opt)
{
    unsigned char buff[MAXSOLMSG+1];
    int n;

    trace(3,"outsol  :\n");

    if ((n = outsols(buff,sol,rb,opt))>0)
    {
        fwrite(buff,n,1,fp);
    }
}


/* output solution extended ----------------------------------------------------
* output solution exteneded infomation to file
* args   : FILE   *fp       I   output file pointer
*          sol_t  *sol      I   solution
*          ssat_t *ssat     I   satellite status
*          solopt_t *opt    I   solution options
* return : output size (bytes)
* notes  : only support nmea
*-----------------------------------------------------------------------------*/
void outsolex(FILE *fp, const sol_t *sol, const ssat_t *ssat,
                     const solopt_t *opt)
{
    unsigned char buff[MAXSOLMSG+1];
    int n;

    trace(3,"outsolex:\n");

    if ((n = outsolexs(buff,sol,ssat,opt))>0)
    {
        fwrite(buff,n,1,fp);
    }
}