fuxiaoer/RTK_base
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
RTK_base/RTK/rtklib.h

1741 lines
88 KiB
C
Raw Normal View History

完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
/*------------------------------------------------------------------------------
* rtklib.h : RTKLIB constants, types and function prototypes
*
* Copyright (C) 2007-2020 by T.TAKASU, All rights reserved.
*
* options : -DENAGLO enable GLONASS
* -DENAGAL enable Galileo
* -DENAQZS enable QZSS
* -DENACMP enable BeiDou
* -DENAIRN enable IRNSS
* -DNFREQ=n set number of obs codes/frequencies
* -DNEXOBS=n set number of extended obs codes
* -DMAXOBS=n set max number of obs data in an epoch
* -DWIN32 use WIN32 API
* -DWIN_DLL generate library as Windows DLL
*
* version : $Revision:$ $Date:$
* history : 2007/01/13 1.0 rtklib ver.1.0.0
* 2007/03/20 1.1 rtklib ver.1.1.0
* 2008/07/15 1.2 rtklib ver.2.1.0
* 2008/10/19 1.3 rtklib ver.2.1.1
* 2009/01/31 1.4 rtklib ver.2.2.0
* 2009/04/30 1.5 rtklib ver.2.2.1
* 2009/07/30 1.6 rtklib ver.2.2.2
* 2009/12/25 1.7 rtklib ver.2.3.0
* 2010/07/29 1.8 rtklib ver.2.4.0
* 2011/05/27 1.9 rtklib ver.2.4.1
* 2013/03/28 1.10 rtklib ver.2.4.2
* 2020/11/30 1.11 rtklib ver.2.4.3 b34
*-----------------------------------------------------------------------------*/
#define ENAGPS
// #define ENAGLO
// #define ENAGAL
内部测试第一版
2022-07-05 13:42:48 +08:00
#define ENACMP
完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
// #define ENAQZS
同步测试代码
2022-06-22 09:23:36 +08:00
// #define TRACE
完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
// #define L5_TO_L2
// #define ONLY_2FREQ
#define PAR
同步测试代码
2022-06-22 09:23:36 +08:00
//#define USING_FILE_OPT
完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
//#define STATIC
#define STM32
#ifndef RTKLIB_H
#define RTKLIB_H
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <ctype.h>
#include <stdint.h>
完成RTCM解析移植和任务创建
2022-06-16 18:57:17 +08:00
完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
#include <rtthread.h>
#include <rtdevice.h>
同步测试代码
2022-06-22 09:23:36 +08:00
#include <rtk_task.h>
完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
/* constants -----------------------------------------------------------------*/
#define VER_RTKLIB "demo5" /* library version */
#define PATCH_LEVEL "b34e" /* patch level */
#define COPYRIGHT_RTKLIB \
"Copyright (C) 2007-2020 T.Takasu\nAll rights reserved."
#define PI 3.1415926535897932 /* pi */
#define D2R (PI / 180.0) /* deg to rad */
#define R2D (180.0 / PI) /* rad to deg */
#define CLIGHT 299792458.0 /* speed of light (m/s) */
#define SC2RAD 3.1415926535898 /* semi-circle to radian (IS-GPS) */
#define AU 149597870691.0 /* 1 AU (m) */
#define AS2R (D2R / 3600.0) /* arc sec to radian */
#define OMGE 7.2921151467E-5 /* earth angular velocity (IS-GPS) (rad/s) */
#define RE_WGS84 6378137.0 /* earth semimajor axis (WGS84) (m) */
#define FE_WGS84 (1.0 / 298.257223563) /* earth flattening (WGS84) */
#define HION 350000.0 /* ionosphere height (m) */
#define MAXFREQ 6 /* max NFREQ */
#define FREQL1 1.57542E9 /* L1/E1 frequency (Hz) */
#define FREQL2 1.22760E9 /* L2 frequency (Hz) */
#define FREQE5b 1.20714E9 /* E5b frequency (Hz) */
#define FREQL5 1.17645E9 /* L5/E5a/B2a frequency (Hz) */
#define FREQL6 1.27875E9 /* E6/L6 frequency (Hz) */
#define FREQE5ab 1.191795E9 /* E5a+b frequency (Hz) */
#define FREQs 2.492028E9 /* S frequency (Hz) */
#define FREQ1_GLO 1.60200E9 /* GLONASS G1 base frequency (Hz) */
#define DFRQ1_GLO 0.56250E6 /* GLONASS G1 bias frequency (Hz/n) */
#define FREQ2_GLO 1.24600E9 /* GLONASS G2 base frequency (Hz) */
#define DFRQ2_GLO 0.43750E6 /* GLONASS G2 bias frequency (Hz/n) */
#define FREQ3_GLO 1.202025E9 /* GLONASS G3 frequency (Hz) */
#define FREQ1a_GLO 1.600995E9 /* GLONASS G1a frequency (Hz) */
#define FREQ2a_GLO 1.248060E9 /* GLONASS G2a frequency (Hz) */
#define FREQ1_CMP 1.561098E9 /* BDS B1I frequency (Hz) */
#define FREQ2_CMP 1.20714E9 /* BDS B2I/B2b frequency (Hz) */
#define FREQ3_CMP 1.26852E9 /* BDS B3 frequency (Hz) */
#define EFACT_GPS 1.0 /* error factor: GPS */
#define EFACT_GLO 1.5 /* error factor: GLONASS */
#define EFACT_GAL 1.0 /* error factor: Galileo */
#define EFACT_QZS 1.0 /* error factor: QZSS */
#define EFACT_CMP 1.0 /* error factor: BeiDou */
#define EFACT_IRN 1.5 /* error factor: IRNSS */
#define EFACT_SBS 3.0 /* error factor: SBAS */
#define SYS_NONE 0x00 /* navigation system: none */
#define SYS_GPS 0x01 /* navigation system: GPS */
#define SYS_SBS 0x02 /* navigation system: SBAS */
#define SYS_GLO 0x04 /* navigation system: GLONASS */
#define SYS_GAL 0x08 /* navigation system: Galileo */
#define SYS_QZS 0x10 /* navigation system: QZSS */
#define SYS_CMP 0x20 /* navigation system: BeiDou */
#define SYS_IRN 0x40 /* navigation system: IRNS */
#define SYS_LEO 0x80 /* navigation system: LEO */
#define SYS_ALL 0xFF /* navigation system: all */
#define TSYS_GPS 0 /* time system: GPS time */
#define TSYS_UTC 1 /* time system: UTC */
#define TSYS_GLO 2 /* time system: GLONASS time */
#define TSYS_GAL 3 /* time system: Galileo time */
#define TSYS_QZS 4 /* time system: QZSS time */
#define TSYS_CMP 5 /* time system: BeiDou time */
#define TSYS_IRN 6 /* time system: IRNSS time */
#ifndef NFREQ
#define NFREQ 3 /* number of carrier frequencies */
#endif
#define NFREQGLO 2 /* number of carrier frequencies of GLONASS */
#ifndef NEXOBS
#define NEXOBS 0 /* number of extended obs codes */
#endif
#define SNR_UNIT 0.001 /* SNR unit (dBHz) */
#define MINPRNGPS 1 /* min satellite PRN number of GPS */
#define MAXPRNGPS 32 /* max satellite PRN number of GPS */
#define NSATGPS (MAXPRNGPS - MINPRNGPS + 1) /* number of GPS satellites */
#define NSYSGPS 1
#ifdef ENAGLO
#define MINPRNGLO 1 /* min satellite slot number of GLONASS */
#define MAXPRNGLO 27 /* max satellite slot number of GLONASS */
#define NSATGLO (MAXPRNGLO - MINPRNGLO + 1) /* number of GLONASS satellites */
#define NSYSGLO 1
#else
#define MINPRNGLO 0
#define MAXPRNGLO 0
#define NSATGLO 0
#define NSYSGLO 0
#endif
#ifdef ENAGAL
#define MINPRNGAL 1 /* min satellite PRN number of Galileo */
#define MAXPRNGAL 36 /* max satellite PRN number of Galileo */
#define NSATGAL (MAXPRNGAL - MINPRNGAL + 1) /* number of Galileo satellites */
#define NSYSGAL 1
#else
#define MINPRNGAL 0
#define MAXPRNGAL 0
#define NSATGAL 0
#define NSYSGAL 0
#endif
#ifdef ENAQZS
#define MINPRNQZS 193 /* min satellite PRN number of QZSS */
#define MAXPRNQZS 202 /* max satellite PRN number of QZSS */
#define MINPRNQZS_S 183 /* min satellite PRN number of QZSS L1S */
#define MAXPRNQZS_S 191 /* max satellite PRN number of QZSS L1S */
#define NSATQZS (MAXPRNQZS - MINPRNQZS + 1) /* number of QZSS satellites */
#define NSYSQZS 1
#else
#define MINPRNQZS 0
#define MAXPRNQZS 0
#define MINPRNQZS_S 0
#define MAXPRNQZS_S 0
#define NSATQZS 0
#define NSYSQZS 0
#endif
#ifdef ENACMP
#define MINPRNCMP 1 /* min satellite sat number of BeiDou */
#define MAXPRNCMP 46 /* max satellite sat number of BeiDou */
#define NSATCMP (MAXPRNCMP - MINPRNCMP + 1) /* number of BeiDou satellites */
#define NSYSCMP 1
#else
#define MINPRNCMP 0
#define MAXPRNCMP 0
#define NSATCMP 0
#define NSYSCMP 0
#endif
#ifdef ENAIRN
#define MINPRNIRN 1 /* min satellite sat number of IRNSS */
#define MAXPRNIRN 14 /* max satellite sat number of IRNSS */
#define NSATIRN (MAXPRNIRN - MINPRNIRN + 1) /* number of IRNSS satellites */
#define NSYSIRN 1
#else
#define MINPRNIRN 0
#define MAXPRNIRN 0
#define NSATIRN 0
#define NSYSIRN 0
#endif
#ifdef ENALEO
#define MINPRNLEO 1 /* min satellite sat number of LEO */
#define MAXPRNLEO 10 /* max satellite sat number of LEO */
#define NSATLEO (MAXPRNLEO - MINPRNLEO + 1) /* number of LEO satellites */
#define NSYSLEO 1
#else
#define MINPRNLEO 0
#define MAXPRNLEO 0
#define NSATLEO 0
#define NSYSLEO 0
#endif
#define NSYS (NSYSGPS + NSYSGLO + NSYSGAL + NSYSQZS + NSYSCMP + NSYSIRN + NSYSLEO) /* number of systems */
#define MINPRNSBS 120 /* min satellite PRN number of SBAS */
#define MAXPRNSBS 158 /* max satellite PRN number of SBAS */
//#define NSATSBS (MAXPRNSBS-MINPRNSBS+1) /* number of SBAS satellites */
#define NSATSBS 0
#define MAXSAT (NSATGPS + NSATGLO + NSATGAL + NSATQZS + NSATCMP + NSATIRN + NSATSBS + NSATLEO)
//#define MAXSAT 32
/* max satellite number (1 to MAXSAT) */
#define MAXSTA 255
#ifndef MAXOBS
#define MAXOBS 32 /* max number of obs in an epoch 96*/
#endif
#define MAXRCV 2 /* max receiver number (1 to MAXRCV) 64 */
#define MAXOBSTYPE 64 /* max number of obs type in RINEX */
#ifdef OBS_100HZ
#define DTTOL 0.005 /* tolerance of time difference (s) */
#else
#define DTTOL 0.025 /* tolerance of time difference (s) */
#endif
#define MAXDTOE 7200.0 /* max time difference to GPS Toe (s) */
#define MAXDTOE_QZS 7200.0 /* max time difference to QZSS Toe (s) */
#define MAXDTOE_GAL 14400.0 /* max time difference to Galileo Toe (s) */
#define MAXDTOE_CMP 21600.0 /* max time difference to BeiDou Toe (s) */
#define MAXDTOE_GLO 1800.0 /* max time difference to GLONASS Toe (s) */
#define MAXDTOE_IRN 7200.0 /* max time difference to IRNSS Toe (s) */
#define MAXDTOE_SBS 360.0 /* max time difference to SBAS Toe (s) */
#define MAXDTOE_S 86400.0 /* max time difference to ephem toe (s) for other */
#define MAXGDOP 300.0 /* max GDOP */
#define INT_SWAP_TRAC 86400.0 /* swap interval of trace file (s) */
#define INT_SWAP_STAT 86400.0 /* swap interval of solution status file (s) */
#define MAXEXFILE 1024 /* max number of expanded files */
#define MAXSBSAGEF 30.0 /* max age of SBAS fast correction (s) */
#define MAXSBSAGEL 1800.0 /* max age of SBAS long term corr (s) */
#define MAXSBSURA 8 /* max URA of SBAS satellite */
#define MAXBAND 10 /* max SBAS band of IGP */
#define MAXNIGP 201 /* max number of IGP in SBAS band */
#define MAXNGEO 4 /* max number of GEO satellites */
#define MAXCOMMENT 100 /* max number of RINEX comments */
#define MAXSTRPATH 1024 /* max length of stream path */
#define MAXSTRMSG 1024 /* max length of stream message */
#define MAXSTRRTK 8 /* max number of stream in RTK server */
#define MAXSBSMSG 32 /* max number of SBAS msg in RTK server */
#define MAXSOLMSG 8191 /* max length of solution message */
#define MAXRAWLEN 16384 /* max length of receiver raw message */
#define MAXERRMSG 4096 /* max length of error/warning message */
#define MAXANT 64 /* max length of station name/antenna type */
#define MAXSOLBUF 1 /* max number of solution buffer 256*/
#define MAXOBSBUF 1 /* max number of observation data buffer 128*/
#define MAXNRPOS 16 /* max number of reference positions */
#define MAXLEAPS 64 /* max number of leap seconds table */
#define MAXGISLAYER 32 /* max number of GIS data layers */
#define MAXRCVCMD 4096 /* max length of receiver commands */
#define RNX2VER 2.10 /* RINEX ver.2 default output version */
#define RNX3VER 3.00 /* RINEX ver.3 default output version */
#define OBSTYPE_PR 0x01 /* observation type: pseudorange */
#define OBSTYPE_CP 0x02 /* observation type: carrier-phase */
#define OBSTYPE_DOP 0x04 /* observation type: doppler-freq */
#define OBSTYPE_SNR 0x08 /* observation type: SNR */
#define OBSTYPE_ALL 0xFF /* observation type: all */
#define FREQTYPE_L1 0x01 /* frequency type: L1/E1/B1 */
#define FREQTYPE_L2 0x02 /* frequency type: L2/E5b/B2 */
#define FREQTYPE_L3 0x04 /* frequency type: L5/E5a/L3 */
#define FREQTYPE_L4 0x08 /* frequency type: L6/E6/B3 */
#define FREQTYPE_L5 0x10 /* frequency type: E5ab */
#define FREQTYPE_ALL 0xFF /* frequency type: all */
#define CODE_NONE 0 /* obs code: none or unknown */
#define CODE_L1C 1 /* obs code: L1C/A,G1C/A,E1C (GPS,GLO,GAL,QZS,SBS) */
#define CODE_L1P 2 /* obs code: L1P,G1P,B1P (GPS,GLO,BDS) */
#define CODE_L1W 3 /* obs code: L1 Z-track (GPS) */
#define CODE_L1Y 4 /* obs code: L1Y (GPS) */
#define CODE_L1M 5 /* obs code: L1M (GPS) */
#define CODE_L1N 6 /* obs code: L1codeless,B1codeless (GPS,BDS) */
#define CODE_L1S 7 /* obs code: L1C(D) (GPS,QZS) */
#define CODE_L1L 8 /* obs code: L1C(P) (GPS,QZS) */
#define CODE_L1E 9 /* (not used) */
#define CODE_L1A 10 /* obs code: E1A,B1A (GAL,BDS) */
#define CODE_L1B 11 /* obs code: E1B (GAL) */
#define CODE_L1X 12 /* obs code: E1B+C,L1C(D+P),B1D+P (GAL,QZS,BDS) */
#define CODE_L1Z 13 /* obs code: E1A+B+C,L1S (GAL,QZS) */
#define CODE_L2C 14 /* obs code: L2C/A,G1C/A (GPS,GLO) */
#define CODE_L2D 15 /* obs code: L2 L1C/A-(P2-P1) (GPS) */
#define CODE_L2S 16 /* obs code: L2C(M) (GPS,QZS) */
#define CODE_L2L 17 /* obs code: L2C(L) (GPS,QZS) */
#define CODE_L2X 18 /* obs code: L2C(M+L),B1_2I+Q (GPS,QZS,BDS) */
#define CODE_L2P 19 /* obs code: L2P,G2P (GPS,GLO) */
#define CODE_L2W 20 /* obs code: L2 Z-track (GPS) */
#define CODE_L2Y 21 /* obs code: L2Y (GPS) */
#define CODE_L2M 22 /* obs code: L2M (GPS) */
#define CODE_L2N 23 /* obs code: L2codeless (GPS) */
#define CODE_L5I 24 /* obs code: L5I,E5aI (GPS,GAL,QZS,SBS) */
#define CODE_L5Q 25 /* obs code: L5Q,E5aQ (GPS,GAL,QZS,SBS) */
#define CODE_L5X 26 /* obs code: L5I+Q,E5aI+Q,L5B+C,B2aD+P (GPS,GAL,QZS,IRN,SBS,BDS) */
#define CODE_L7I 27 /* obs code: E5bI,B2bI (GAL,BDS) */
#define CODE_L7Q 28 /* obs code: E5bQ,B2bQ (GAL,BDS) */
#define CODE_L7X 29 /* obs code: E5bI+Q,B2bI+Q (GAL,BDS) */
#define CODE_L6A 30 /* obs code: E6A,B3A (GAL,BDS) */
#define CODE_L6B 31 /* obs code: E6B (GAL) */
#define CODE_L6C 32 /* obs code: E6C (GAL) */
#define CODE_L6X 33 /* obs code: E6B+C,LEXS+L,B3I+Q (GAL,QZS,BDS) */
#define CODE_L6Z 34 /* obs code: E6A+B+C,L6D+E (GAL,QZS) */
#define CODE_L6S 35 /* obs code: L6S (QZS) */
#define CODE_L6L 36 /* obs code: L6L (QZS) */
#define CODE_L8I 37 /* obs code: E5abI (GAL) */
#define CODE_L8Q 38 /* obs code: E5abQ (GAL) */
#define CODE_L8X 39 /* obs code: E5abI+Q,B2abD+P (GAL,BDS) */
#define CODE_L2I 40 /* obs code: B1_2I (BDS) */
#define CODE_L2Q 41 /* obs code: B1_2Q (BDS) */
#define CODE_L6I 42 /* obs code: B3I (BDS) */
#define CODE_L6Q 43 /* obs code: B3Q (BDS) */
#define CODE_L3I 44 /* obs code: G3I (GLO) */
#define CODE_L3Q 45 /* obs code: G3Q (GLO) */
#define CODE_L3X 46 /* obs code: G3I+Q (GLO) */
#define CODE_L1I 47 /* obs code: B1I (BDS) (obsolute) */
#define CODE_L1Q 48 /* obs code: B1Q (BDS) (obsolute) */
#define CODE_L5A 49 /* obs code: L5A SPS (IRN) */
#define CODE_L5B 50 /* obs code: L5B RS(D) (IRN) */
#define CODE_L5C 51 /* obs code: L5C RS(P) (IRN) */
#define CODE_L9A 52 /* obs code: SA SPS (IRN) */
#define CODE_L9B 53 /* obs code: SB RS(D) (IRN) */
#define CODE_L9C 54 /* obs code: SC RS(P) (IRN) */
#define CODE_L9X 55 /* obs code: SB+C (IRN) */
#define CODE_L1D 56 /* obs code: B1D (BDS) */
#define CODE_L5D 57 /* obs code: L5D(L5S),B2aD (QZS,BDS) */
#define CODE_L5P 58 /* obs code: L5P(L5S),B2aP (QZS,BDS) */
#define CODE_L5Z 59 /* obs code: L5D+P(L5S) (QZS) */
#define CODE_L6E 60 /* obs code: L6E (QZS) */
#define CODE_L7D 61 /* obs code: B2bD (BDS) */
#define CODE_L7P 62 /* obs code: B2bP (BDS) */
#define CODE_L7Z 63 /* obs code: B2bD+P (BDS) */
#define CODE_L8D 64 /* obs code: B2abD (BDS) */
#define CODE_L8P 65 /* obs code: B2abP (BDS) */
#define CODE_L4A 66 /* obs code: G1aL1OCd (GLO) */
#define CODE_L4B 67 /* obs code: G1aL1OCd (GLO) */
#define CODE_L4X 68 /* obs code: G1al1OCd+p (GLO) */
#define MAXCODE 68 /* max number of obs code */
#define PMODE_SINGLE 0 /* positioning mode: single */
#define PMODE_DGPS 1 /* positioning mode: DGPS/DGNSS */
#define PMODE_KINEMA 2 /* positioning mode: kinematic */
#define PMODE_STATIC 3 /* positioning mode: static */
#define PMODE_STATIC_START 4 /* positioning mode: static */
#define PMODE_MOVEB 5 /* positioning mode: moving-base */
#define PMODE_FIXED 6 /* positioning mode: fixed */
// #define PMODE_PPP_KINEMA 7 /* positioning mode: PPP-kinemaric */
// #define PMODE_PPP_STATIC 8 /* positioning mode: PPP-static */
// #define PMODE_PPP_FIXED 9 /* positioning mode: PPP-fixed */
#define SOLF_LLH 0 /* solution format: lat/lon/height */
#define SOLF_XYZ 1 /* solution format: x/y/z-ecef */
#define SOLF_ENU 2 /* solution format: e/n/u-baseline */
#define SOLF_NMEA 3 /* solution format: NMEA-183 */
#define SOLF_STAT 4 /* solution format: solution status */
#define SOLF_GSIF 5 /* solution format: GSI F1/F2 */
#define SOLQ_NONE 0 /* solution status: no solution */
#define SOLQ_FIX 1 /* solution status: fix */
#define SOLQ_FLOAT 2 /* solution status: float */
#define SOLQ_SBAS 3 /* solution status: SBAS */
#define SOLQ_DGPS 4 /* solution status: DGPS/DGNSS */
#define SOLQ_SINGLE 5 /* solution status: single */
#define SOLQ_PPP 6 /* solution status: PPP */
#define SOLQ_DR 7 /* solution status: dead reconing */
#define MAXSOLQ 7 /* max number of solution status */
#define TIMES_GPST 0 /* time system: gps time */
#define TIMES_UTC 1 /* time system: utc */
#define TIMES_JST 2 /* time system: jst */
#define IONOOPT_OFF 0 /* ionosphere option: correction off */
#define IONOOPT_BRDC 1 /* ionosphere option: broadcast model */
#define IONOOPT_SBAS 2 /* ionosphere option: SBAS model */
#define IONOOPT_IFLC 3 /* ionosphere option: L1/L2 or L1/L5 iono-free LC */
#define IONOOPT_EST 4 /* ionosphere option: estimation */
#define IONOOPT_TEC 5 /* ionosphere option: IONEX TEC model */
#define IONOOPT_QZS 6 /* ionosphere option: QZSS broadcast model */
#define IONOOPT_STEC 8 /* ionosphere option: SLANT TEC model */
#define TROPOPT_OFF 0 /* troposphere option: correction off */
#define TROPOPT_SAAS 1 /* troposphere option: Saastamoinen model */
#define TROPOPT_SBAS 2 /* troposphere option: SBAS model */
#define TROPOPT_EST 3 /* troposphere option: ZTD estimation */
#define TROPOPT_ESTG 4 /* troposphere option: ZTD+grad estimation */
#define TROPOPT_ZTD 5 /* troposphere option: ZTD correction */
#define EPHOPT_BRDC 0 /* ephemeris option: broadcast ephemeris */
#define EPHOPT_PREC 1 /* ephemeris option: precise ephemeris */
#define EPHOPT_SBAS 2 /* ephemeris option: broadcast + SBAS */
#define EPHOPT_SSRAPC 3 /* ephemeris option: broadcast + SSR_APC */
#define EPHOPT_SSRCOM 4 /* ephemeris option: broadcast + SSR_COM */
#define ARMODE_OFF 0 /* AR mode: off */
#define ARMODE_CONT 1 /* AR mode: continuous */
#define ARMODE_INST 2 /* AR mode: instantaneous */
#define ARMODE_FIXHOLD 3 /* AR mode: fix and hold */
#define ARMODE_WLNL 4 /* AR mode: wide lane/narrow lane */
#define ARMODE_TCAR 5 /* AR mode: triple carrier ar */
#define GLO_ARMODE_OFF 0 /* GLO AR mode: off */
#define GLO_ARMODE_ON 1 /* GLO AR mode: on */
#define GLO_ARMODE_AUTOCAL 2 /* GLO AR mode: autocal */
#define GLO_ARMODE_FIXHOLD 3 /* GLO AR mode: fix and hold */
#define SBSOPT_LCORR 1 /* SBAS option: long term correction */
#define SBSOPT_FCORR 2 /* SBAS option: fast correction */
#define SBSOPT_ICORR 4 /* SBAS option: ionosphere correction */
#define SBSOPT_RANGE 8 /* SBAS option: ranging */
#define POSOPT_POS 0 /* pos option: LLH/XYZ */
#define POSOPT_SINGLE 1 /* pos option: average of single pos */
#define POSOPT_FILE 2 /* pos option: read from pos file */
#define POSOPT_RINEX 3 /* pos option: rinex header pos */
#define POSOPT_RTCM 4 /* pos option: rtcm/raw station pos */
#define STR_NONE 0 /* stream type: none */
#define STR_SERIAL 1 /* stream type: serial */
#define STR_FILE 2 /* stream type: file */
#define STR_TCPSVR 3 /* stream type: TCP server */
#define STR_TCPCLI 4 /* stream type: TCP client */
#define STR_NTRIPSVR 5 /* stream type: NTRIP server */
#define STR_NTRIPCLI 6 /* stream type: NTRIP client */
#define STR_FTP 7 /* stream type: ftp */
#define STR_HTTP 8 /* stream type: http */
#define STR_NTRIPCAS 9 /* stream type: NTRIP caster */
#define STR_UDPSVR 10 /* stream type: UDP server */
#define STR_UDPCLI 11 /* stream type: UDP server */
#define STR_MEMBUF 12 /* stream type: memory buffer */
#define STRFMT_RTCM2 0 /* stream format: RTCM 2 */
#define STRFMT_RTCM3 1 /* stream format: RTCM 3 */
#define STRFMT_OEM4 2 /* stream format: NovAtel OEMV/4 */
#define STRFMT_CNAV 3 /* stream format: ComNav */
#define STRFMT_UBX 4 /* stream format: u-blox LEA-*T */
#define STRFMT_SBP 5 /* stream format: Swift Navigation SBP */
#define STRFMT_CRES 6 /* stream format: Hemisphere */
#define STRFMT_STQ 7 /* stream format: SkyTraq S1315F */
#define STRFMT_JAVAD 8 /* stream format: JAVAD GRIL/GREIS */
#define STRFMT_NVS 9 /* stream format: NVS NVC08C */
#define STRFMT_BINEX 10 /* stream format: BINEX */
#define STRFMT_RT17 11 /* stream format: Trimble RT17 */
#define STRFMT_SEPT 12 /* stream format: Septentrio */
#define STRFMT_TERSUS 13 /* stream format: TERSUS */
#define STRFMT_RINEX 14 /* stream format: RINEX */
#define STRFMT_SP3 15 /* stream format: SP3 */
#define STRFMT_RNXCLK 16 /* stream format: RINEX CLK */
#define STRFMT_SBAS 17 /* stream format: SBAS messages */
#define STRFMT_NMEA 18 /* stream format: NMEA 0183 */
#define MAXRCVFMT 13 /* max number of receiver format */
#define STR_MODE_R 0x1 /* stream mode: read */
#define STR_MODE_W 0x2 /* stream mode: write */
#define STR_MODE_RW 0x3 /* stream mode: read/write */
#define GEOID_EMBEDDED 0 /* geoid model: embedded geoid */
#define GEOID_EGM96_M150 1 /* geoid model: EGM96 15x15" */
#define GEOID_EGM2008_M25 2 /* geoid model: EGM2008 2.5x2.5" */
#define GEOID_EGM2008_M10 3 /* geoid model: EGM2008 1.0x1.0" */
#define GEOID_GSI2000_M15 4 /* geoid model: GSI geoid 2000 1.0x1.5" */
#define GEOID_RAF09 5 /* geoid model: IGN RAF09 for France 1.5"x2" */
#define COMMENTH "%" /* comment line indicator for solution */
#define MSG_DISCONN "$_DISCONNECT\r\n" /* disconnect message */
#define DLOPT_FORCE 0x01 /* download option: force download existing */
#define DLOPT_KEEPCMP 0x02 /* download option: keep compressed file */
#define DLOPT_HOLDERR 0x04 /* download option: hold on error file */
#define DLOPT_HOLDLST 0x08 /* download option: hold on listing file */
#define LLI_SLIP 0x01 /* LLI: cycle-slip */
#define LLI_HALFC 0x02 /* LLI: half-cycle not resovled */
#define LLI_BOCTRK 0x04 /* LLI: boc tracking of mboc signal */
#define LLI_HALFA 0x40 /* LLI: half-cycle added */
#define LLI_HALFS 0x80 /* LLI: half-cycle subtracted */
#define P2_5 0.03125 /* 2^-5 */
#define P2_6 0.015625 /* 2^-6 */
#define P2_11 4.882812500000000E-04 /* 2^-11 */
#define P2_15 3.051757812500000E-05 /* 2^-15 */
#define P2_17 7.629394531250000E-06 /* 2^-17 */
#define P2_19 1.907348632812500E-06 /* 2^-19 */
#define P2_20 9.536743164062500E-07 /* 2^-20 */
#define P2_21 4.768371582031250E-07 /* 2^-21 */
#define P2_23 1.192092895507810E-07 /* 2^-23 */
#define P2_24 5.960464477539063E-08 /* 2^-24 */
#define P2_27 7.450580596923828E-09 /* 2^-27 */
#define P2_29 1.862645149230957E-09 /* 2^-29 */
#define P2_30 9.313225746154785E-10 /* 2^-30 */
#define P2_31 4.656612873077393E-10 /* 2^-31 */
#define P2_32 2.328306436538696E-10 /* 2^-32 */
#define P2_33 1.164153218269348E-10 /* 2^-33 */
#define P2_35 2.910383045673370E-11 /* 2^-35 */
#define P2_38 3.637978807091710E-12 /* 2^-38 */
#define P2_39 1.818989403545856E-12 /* 2^-39 */
#define P2_40 9.094947017729280E-13 /* 2^-40 */
#define P2_43 1.136868377216160E-13 /* 2^-43 */
#define P2_48 3.552713678800501E-15 /* 2^-48 */
#define P2_50 8.881784197001252E-16 /* 2^-50 */
#define P2_55 2.775557561562891E-17 /* 2^-55 */
//#ifdef WIN32
//#define thread_t HANDLE
//#define lock_t CRITICAL_SECTION
//#define initlock(f) InitializeCriticalSection(f)
//#define lock(f) EnterCriticalSection(f)
//#define unlock(f) LeaveCriticalSection(f)
//#define FILEPATHSEP '\\'
//#else
//#define thread_t pthread_t
//#define lock_t pthread_mutex_t
//#define initlock(f) pthread_mutex_init(f, NULL)
//#define lock(f) pthread_mutex_lock(f)
//#define unlock(f) pthread_mutex_unlock(f)
#define FILEPATHSEP '/'
//#endif
/* type definitions ----------------------------------------------------------*/
内部测试第一版
2022-07-05 13:42:48 +08:00
完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
typedef struct
{ /* time struct */
time_t time; /* time (s) expressed by standard time_t */
double sec; /* fraction of second under 1 s */
} gtime_t;
typedef struct
{ /* observation data record */
gtime_t time; /* receiver sampling time (GPST) */
uint8_t sat, rcv; /* satellite/receiver number */
uint16_t SNR[NFREQ + NEXOBS]; /* signal strength (0.001 dBHz) */
uint8_t LLI[NFREQ + NEXOBS]; /* loss of lock indicator */
uint8_t code[NFREQ + NEXOBS]; /* code indicator (CODE_???) */
double L[NFREQ + NEXOBS]; /* observation data carrier-phase (cycle) */
double P[NFREQ + NEXOBS]; /* observation data pseudorange (m) */
float D[NFREQ + NEXOBS]; /* observation data doppler frequency (Hz) */
int timevalid; /* time is valid (Valid GNSS fix) for time mark */
gtime_t eventime; /* time of event (GPST) */
uint8_t Lstd[NFREQ + NEXOBS]; /* stdev of carrier phase (0.004 cycles) */
uint8_t Pstd[NFREQ + NEXOBS]; /* stdev of pseudorange (0.01*2^(n+5) meters) */
uint8_t freq; /* GLONASS frequency channel (0-13) */
} obsd_t;
typedef struct
{ /* observation data */
int n, nmax; /* number of obervation data/allocated */
int flag; /* epoch flag (0:ok,1:power failure,>1:event flag) */
int rcvcount; /* count of rcv event */
int tmcount; /* time mark count */
obsd_t *data; /* observation data records */
} obs_t;
typedef struct
{ /* earth rotation parameter data type */
double mjd; /* mjd (days) */
double xp, yp; /* pole offset (rad) */
double xpr, ypr; /* pole offset rate (rad/day) */
double ut1_utc; /* ut1-utc (s) */
double lod; /* length of day (s/day) */
} erpd_t;
typedef struct
{ /* earth rotation parameter type */
int n, nmax; /* number and max number of data */
erpd_t *data; /* earth rotation parameter data */
} erp_t;
// typedef struct
// { /* antenna parameter type */
// int sat; /* satellite number (0:receiver) */
// char type[MAXANT]; /* antenna type */
// char code[MAXANT]; /* serial number or satellite code */
// gtime_t ts, te; /* valid time start and end */
// double off[NFREQ][3]; /* phase center offset e/n/u or x/y/z (m) */
// double var[NFREQ][19]; /* phase center variation (m) */
// /* el=90,85,...,0 or nadir=0,1,2,3,... (deg) */
// } pcv_t;
// typedef struct
// { /* antenna parameters type */
// int n, nmax; /* number of data/allocated */
// pcv_t *pcv; /* antenna parameters data */
// } pcvs_t;
// typedef struct { /* almanac type */
// int sat; /* satellite number */
// int svh; /* sv health (0:ok) */
// int svconf; /* as and sv config */
// int week; /* GPS/QZS: gps week, GAL: galileo week */
// gtime_t toa; /* Toa */
// /* SV orbit parameters */
// double A,e,i0,OMG0,omg,M0,OMGd;
// double toas; /* Toa (s) in week */
// double f0,f1; /* SV clock parameters (af0,af1) */
// } alm_t;
typedef struct
{ /* GPS/QZS/GAL broadcast ephemeris type */
int sat; /* satellite number */
int iode, iodc; /* IODE,IODC */
int sva; /* SV accuracy (URA index) */
int svh; /* SV health (0:ok) */
int week; /* GPS/QZS: gps week, GAL: galileo week */
int code; /* GPS/QZS: code on L2 */
/* GAL: data source defined as rinex 3.03 */
/* BDS: data source (0:unknown,1:B1I,2:B1Q,3:B2I,4:B2Q,5:B3I,6:B3Q) */
int flag; /* GPS/QZS: L2 P data flag */
/* BDS: nav type (0:unknown,1:IGSO/MEO,2:GEO) */
gtime_t toe, toc, ttr; /* Toe,Toc,T_trans */
/* SV orbit parameters */
/*toc???????????????<3F><>???? time of clock
toe????????????????????? ?????????<EFBFBD><EFBFBD>???? time of ephemeris*/
double A, e, i0, OMG0, omg, M0, deln, OMGd, idot;
double crc, crs, cuc, cus, cic, cis;
double toes; /* Toe (s) in week */
double fit; /* fit interval (h) */
double f0, f1, f2; /* SV clock parameters (af0,af1,af2) */
double tgd[6]; /* group delay parameters */
/* GPS/QZS:tgd[0]=TGD */
/* GAL:tgd[0]=BGD_E1E5a,tgd[1]=BGD_E1E5b */
/* CMP:tgd[0]=TGD_B1I ,tgd[1]=TGD_B2I/B2b,tgd[2]=TGD_B1Cp */
/* tgd[3]=TGD_B2ap,tgd[4]=ISC_B1Cd ,tgd[5]=ISC_B2ad */
double Adot, ndot; /* Adot,ndot for CNAV */
} eph_t;
typedef struct
{ /* GLONASS broadcast ephemeris type */
int sat; /* satellite number */
int iode; /* IODE (0-6 bit of tb field) */
int frq; /* satellite frequency number */
int svh, sva, age; /* satellite health, accuracy, age of operation */
gtime_t toe; /* epoch of epherides (gpst) */
gtime_t tof; /* message frame time (gpst) */
double pos[3]; /* satellite position (ecef) (m) */
double vel[3]; /* satellite velocity (ecef) (m/s) */
double acc[3]; /* satellite acceleration (ecef) (m/s^2) */
double taun, gamn; /* SV clock bias (s)/relative freq bias */
double dtaun; /* delay between L1 and L2 (s) */
} geph_t;
// typedef struct { /* precise ephemeris type */
// gtime_t time; /* time (GPST) */
// int index; /* ephemeris index for multiple files */
// double pos[MAXSAT][4]; /* satellite position/clock (ecef) (m|s) */
// float std[MAXSAT][4]; /* satellite position/clock std (m|s) */
// double vel[MAXSAT][4]; /* satellite velocity/clk-rate (m/s|s/s) */
// float vst[MAXSAT][4]; /* satellite velocity/clk-rate std (m/s|s/s) */
// float cov[MAXSAT][3]; /* satellite position covariance (m^2) */
// float vco[MAXSAT][3]; /* satellite velocity covariance (m^2) */
// } peph_t;
// typedef struct { /* precise clock type */
// gtime_t time; /* time (GPST) */
// int index; /* clock index for multiple files */
// double clk[MAXSAT][1]; /* satellite clock (s) */
// float std[MAXSAT][1]; /* satellite clock std (s) */
// } pclk_t;
// typedef struct { /* SBAS ephemeris type */
// int sat; /* satellite number */
// gtime_t t0; /* reference epoch time (GPST) */
// gtime_t tof; /* time of message frame (GPST) */
// int sva; /* SV accuracy (URA index) */
// int svh; /* SV health (0:ok) */
// double pos[3]; /* satellite position (m) (ecef) */
// double vel[3]; /* satellite velocity (m/s) (ecef) */
// double acc[3]; /* satellite acceleration (m/s^2) (ecef) */
// double af0,af1; /* satellite clock-offset/drift (s,s/s) */
// } seph_t;
// typedef struct { /* NORAL TLE data type */
// char name [32]; /* common name */
// char alias[32]; /* alias name */
// char satno[16]; /* satellilte catalog number */
// char satclass; /* classification */
// char desig[16]; /* international designator */
// gtime_t epoch; /* element set epoch (UTC) */
// double ndot; /* 1st derivative of mean motion */
// double nddot; /* 2st derivative of mean motion */
// double bstar; /* B* drag term */
// int etype; /* element set type */
// int eleno; /* element number */
// double inc; /* orbit inclination (deg) */
// double OMG; /* right ascension of ascending node (deg) */
// double ecc; /* eccentricity */
// double omg; /* argument of perigee (deg) */
// double M; /* mean anomaly (deg) */
// double n; /* mean motion (rev/day) */
// int rev; /* revolution number at epoch */
// } tled_t;
// typedef struct { /* NORAD TLE (two line element) type */
// int n,nmax; /* number/max number of two line element data */
// tled_t *data; /* NORAD TLE data */
// } tle_t;
// typedef struct { /* TEC grid type */
// gtime_t time; /* epoch time (GPST) */
// int ndata[3]; /* TEC grid data size {nlat,nlon,nhgt} */
// double rb; /* earth radius (km) */
// double lats[3]; /* latitude start/interval (deg) */
// double lons[3]; /* longitude start/interval (deg) */
// double hgts[3]; /* heights start/interval (km) */
// double *data; /* TEC grid data (tecu) */
// float *rms; /* RMS values (tecu) */
// } tec_t;
// typedef struct { /* SBAS message type */
// int week,tow; /* receiption time */
// uint8_t prn,rcv; /* SBAS satellite PRN,receiver number */
// uint8_t msg[29]; /* SBAS message (226bit) padded by 0 */
// } sbsmsg_t;
// typedef struct { /* SBAS messages type */
// int n,nmax; /* number of SBAS messages/allocated */
// sbsmsg_t *msgs; /* SBAS messages */
// } sbs_t;
// typedef struct { /* SBAS fast correction type */
// gtime_t t0; /* time of applicability (TOF) */
// double prc; /* pseudorange correction (PRC) (m) */
// double rrc; /* range-rate correction (RRC) (m/s) */
// double dt; /* range-rate correction delta-time (s) */
// int iodf; /* IODF (issue of date fast corr) */
// int16_t udre; /* UDRE+1 */
// int16_t ai; /* degradation factor indicator */
// } sbsfcorr_t;
// typedef struct { /* SBAS long term satellite error correction type */
// gtime_t t0; /* correction time */
// int iode; /* IODE (issue of date ephemeris) */
// double dpos[3]; /* delta position (m) (ecef) */
// double dvel[3]; /* delta velocity (m/s) (ecef) */
// double daf0,daf1; /* delta clock-offset/drift (s,s/s) */
// } sbslcorr_t;
// typedef struct { /* SBAS satellite correction type */
// int sat; /* satellite number */
// sbsfcorr_t fcorr; /* fast correction */
// sbslcorr_t lcorr; /* long term correction */
// } sbssatp_t;
// typedef struct { /* SBAS satellite corrections type */
// int iodp; /* IODP (issue of date mask) */
// int nsat; /* number of satellites */
// int tlat; /* system latency (s) */
// sbssatp_t sat[MAXSAT]; /* satellite correction */
// } sbssat_t;
// typedef struct { /* SBAS ionospheric correction type */
// gtime_t t0; /* correction time */
// int16_t lat,lon; /* latitude/longitude (deg) */
// int16_t give; /* GIVI+1 */
// float delay; /* vertical delay estimate (m) */
// } sbsigp_t;
// typedef struct { /* IGP band type */
// int16_t x; /* longitude/latitude (deg) */
// const int16_t *y; /* latitudes/longitudes (deg) */
// uint8_t bits; /* IGP mask start bit */
// uint8_t bite; /* IGP mask end bit */
// } sbsigpband_t;
// typedef struct { /* SBAS ionospheric corrections type */
// int iodi; /* IODI (issue of date ionos corr) */
// int nigp; /* number of igps */
// sbsigp_t igp[MAXNIGP]; /* ionospheric correction */
// } sbsion_t;
typedef struct
{ /* DGPS/GNSS correction type */
gtime_t t0; /* correction time */
double prc; /* pseudorange correction (PRC) (m) */
double rrc; /* range rate correction (RRC) (m/s) */
int iod; /* issue of data (IOD) */
double udre; /* UDRE */
} dgps_t;
// typedef struct { /* SSR correction type */
// gtime_t t0[6]; /* epoch time (GPST) {eph,clk,hrclk,ura,bias,pbias} */
// double udi[6]; /* SSR update interval (s) */
// int iod[6]; /* iod ssr {eph,clk,hrclk,ura,bias,pbias} */
// int iode; /* issue of data */
// int iodcrc; /* issue of data crc for beidou/sbas */
// int ura; /* URA indicator */
// int refd; /* sat ref datum (0:ITRF,1:regional) */
// double deph [3]; /* delta orbit {radial,along,cross} (m) */
// double ddeph[3]; /* dot delta orbit {radial,along,cross} (m/s) */
// double dclk [3]; /* delta clock {c0,c1,c2} (m,m/s,m/s^2) */
// double hrclk; /* high-rate clock corection (m) */
// float cbias[MAXCODE]; /* code biases (m) */
// double pbias[MAXCODE]; /* phase biases (m) */
// float stdpb[MAXCODE]; /* std-dev of phase biases (m) */
// double yaw_ang,yaw_rate; /* yaw angle and yaw rate (deg,deg/s) */
// uint8_t update; /* update flag (0:no update,1:update) */
// } ssr_t;
typedef struct
{ /* navigation data type */
int n, nmax; /* number of broadcast ephemeris */
int ng, ngmax; /* number of glonass ephemeris */
int ns, nsmax; /* number of sbas ephemeris */
int ne, nemax; /* number of precise ephemeris */
int nc, ncmax; /* number of precise clock */
int na, namax; /* number of almanac data */
// int nt,ntmax; /* number of tec grid data */
eph_t *eph; /* GPS/QZS/GAL/BDS/IRN ephemeris */
geph_t *geph; /* GLONASS ephemeris */
// seph_t *seph; /* SBAS ephemeris */
// peph_t *peph; /* precise ephemeris */
// pclk_t *pclk; /* precise clock */
// alm_t *alm; /* almanac data */
// tec_t *tec; /* tec grid data */
erp_t erp; /* earth rotation parameters */
double utc_gps[8]; /* GPS delta-UTC parameters {A0,A1,Tot,WNt,dt_LS,WN_LSF,DN,dt_LSF} */
// double utc_glo[8]; /* GLONASS UTC time parameters {tau_C,tau_GPS} */
// double utc_gal[8]; /* Galileo UTC parameters */
// double utc_qzs[8]; /* QZS UTC parameters */
// double utc_cmp[8]; /* BeiDou UTC parameters */
// double utc_irn[9]; /* IRNSS UTC parameters {A0,A1,Tot,...,dt_LSF,A2} */
// double utc_sbs[4]; /* SBAS UTC parameters */
double ion_gps[8]; /* GPS iono model parameters {a0,a1,a2,a3,b0,b1,b2,b3} */
// double ion_gal[4]; /* Galileo iono model parameters {ai0,ai1,ai2,0} */
// double ion_qzs[8]; /* QZSS iono model parameters {a0,a1,a2,a3,b0,b1,b2,b3} */
// double ion_cmp[8]; /* BeiDou iono model parameters {a0,a1,a2,a3,b0,b1,b2,b3} */
// double ion_irn[8]; /* IRNSS iono model parameters {a0,a1,a2,a3,b0,b1,b2,b3} */
int glo_fcn[32]; /* GLONASS FCN + 8 */
double cbias[MAXSAT][3]; /* satellite DCB (0:P1-P2,1:P1-C1,2:P2-C2) (m) */
double rbias[MAXRCV][2][3]; /* receiver DCB (0:P1-P2,1:P1-C1,2:P2-C2) (m) */
// pcv_t pcvs[MAXSAT]; /* satellite antenna pcv */
// sbssat_t sbssat; /* SBAS satellite corrections */
// sbsion_t sbsion[MAXBAND+1]; /* SBAS ionosphere corrections */
// dgps_t dgps[MAXSAT]; /* DGPS corrections */
// ssr_t ssr[MAXSAT]; /* SSR corrections */
} nav_t;
typedef struct
{ /* station parameter type */
char name[MAXANT]; /* marker name */
char marker[MAXANT]; /* marker number */
char antdes[MAXANT]; /* antenna descriptor */
char antsno[MAXANT]; /* antenna serial number */
char rectype[MAXANT]; /* receiver type descriptor */
char recver[MAXANT]; /* receiver firmware version */
char recsno[MAXANT]; /* receiver serial number */
int antsetup; /* antenna setup id */
int itrf; /* ITRF realization year */
int deltype; /* antenna delta type (0:enu,1:xyz) */
double pos[3]; /* station position (ecef) (m) */
double del[3]; /* antenna position delta (e/n/u or x/y/z) (m) */
double hgt; /* antenna height (m) */
int glo_cp_align; /* GLONASS code-phase alignment (0:no,1:yes) */
double glo_cp_bias[4]; /* GLONASS code-phase biases {1C,1P,2C,2P} (m) */
} sta_t;
typedef struct
{ /* solution type */
gtime_t time; /* time (GPST) */
gtime_t eventime; /* time of event (GPST) */
double rr[6]; /* position/velocity (m|m/s) */
/* {x,y,z,vx,vy,vz} or {e,n,u,ve,vn,vu} */
float qr[6]; /* position variance/covariance (m^2) */
/* {c_xx,c_yy,c_zz,c_xy,c_yz,c_zx} or */
/* {c_ee,c_nn,c_uu,c_en,c_nu,c_ue} */
float qv[6]; /* velocity variance/covariance (m^2/s^2) */
double dtr[6]; /* receiver clock bias to time systems (s) */
uint8_t type; /* type (0:xyz-ecef,1:enu-baseline) */
uint8_t stat; /* solution status (SOLQ_???) */
uint8_t ns; /* number of valid satellites */
float age; /* age of differential (s) */
float ratio; /* AR ratio factor for valiation */
float prev_ratio1; /* previous initial AR ratio factor for validation */
float prev_ratio2; /* previous final AR ratio factor for validation */
float thres; /* AR ratio threshold for valiation */
} sol_t;
// typedef struct
// { /* solution buffer type */
// int n, nmax; /* number of solution/max number of buffer */
// int cyclic; /* cyclic buffer flag */
// int start, end; /* start/end index */
// gtime_t time; /* current solution time */
// sol_t *data; /* solution data */
// double rb[3]; /* reference position {x,y,z} (ecef) (m) */
// uint8_t buff[MAXSOLMSG + 1]; /* message buffer */
// int nb; /* number of byte in message buffer */
// } solbuf_t;
typedef struct
{ /* solution status type */
gtime_t time; /* time (GPST) */
uint8_t sat; /* satellite number */
uint8_t frq; /* frequency (1:L1,2:L2,...) */
float az, el; /* azimuth/elevation angle (rad) */
float resp; /* pseudorange residual (m) */
float resc; /* carrier-phase residual (m) */
uint8_t flag; /* flags: (vsat<<5)+(slip<<3)+fix */
uint16_t snr; /* signal strength (*SNR_UNIT dBHz) */
uint16_t lock; /* lock counter */
uint16_t outc; /* outage counter */
uint16_t slipc; /* slip counter */
uint16_t rejc; /* reject counter */
} solstat_t;
typedef struct
{ /* solution status buffer type */
int n, nmax; /* number of solution/max number of buffer */
solstat_t *data; /* solution status data */
} solstatbuf_t;
typedef struct
{ /* RTCM control struct type */
int staid; /* station id */
int stah; /* station health */
int seqno; /* sequence number for rtcm 2 or iods msm */
// int outtype; /* output message type */
gtime_t time; /* message time */
gtime_t time_s; /* message start time */
obs_t obs; /* observation data (uncorrected) */
nav_t nav; /* satellite ephemerides */
sta_t sta; /* station parameters */
// dgps_t *dgps; /* output of dgps corrections */
// ssr_t ssr[MAXSAT]; /* output of ssr corrections */
// char msg[128]; /* special message */
// char msgtype[256]; /* last message type */
char msmtype[7][128]; /* msm signal types */
int obsflag; /* obs data complete flag (1:ok,0:not complete) */
int ephsat; /* input ephemeris satellite number */
int ephset; /* input ephemeris set (0-1) */
double cp[MAXSAT][NFREQ + NEXOBS]; /* carrier-phase measurement */
uint16_t lock[MAXSAT][NFREQ + NEXOBS]; /* lock time */
uint16_t loss[MAXSAT][NFREQ + NEXOBS]; /* loss of lock count */
gtime_t lltime[MAXSAT][NFREQ + NEXOBS]; /* last lock time */
int nbyte; /* number of bytes in message buffer */
int nbit; /* number of bits in word buffer */
int len; /* message length (bytes) */
uint8_t buff[1200]; /* message buffer */
// uint32_t word; /* word buffer for rtcm 2 */
// uint32_t nmsg2[100]; /* message count of RTCM 2 (1-99:1-99,0:other) */
uint32_t nmsg3[400]; /* message count of RTCM 3 (1-299:1001-1299,300-329:4070-4099,0:ohter) */
// char opt[256]; /* RTCM dependent options */
} rtcm_t;
// typedef struct { /* RINEX control struct type */
// gtime_t time; /* message time */
// double ver; /* RINEX version */
// char type; /* RINEX file type ('O','N',...) */
// int sys; /* navigation system */
// int tsys; /* time system */
// char tobs[8][MAXOBSTYPE][4]; /* rinex obs types */
// obs_t obs; /* observation data */
// nav_t nav; /* navigation data */
// sta_t sta; /* station info */
// int ephsat; /* input ephemeris satellite number */
// int ephset; /* input ephemeris set (0-1) */
// char opt[256]; /* rinex dependent options */
// } rnxctr_t;
// typedef struct { /* download URL type */
// char type[32]; /* data type */
// char path[1024]; /* URL path */
// char dir [1024]; /* local directory */
// double tint; /* time interval (s) */
// } url_t;
typedef struct
{ /* option type */
const char *name; /* option name */
int format; /* option format (0:int,1:double,2:string,3:enum) */
void *var; /* pointer to option variable */
const char *comment; /* option comment/enum labels/unit */
} opt_t;
typedef struct
{ /* SNR mask type */
int ena[2]; /* enable flag {rover,base} */
double mask[NFREQ][9]; /* mask (dBHz) at 5,10,...85 deg */
} snrmask_t;
typedef struct
{ /* processing options type */
int mode; /* positioning mode (PMODE_???) */
int soltype; /* solution type (0:forward,1:backward,2:combined) */
int nf; /* number of frequencies (1:L1,2:L1+L2,3:L1+L2+L5) */
int navsys; /* navigation system */
double elmin; /* elevation mask angle (rad) */
snrmask_t snrmask; /* SNR mask */
int sateph; /* satellite ephemeris/clock (EPHOPT_???) */
int modear; /* AR mode (0:off,1:continuous,2:instantaneous,3:fix and hold,4:ppp-ar) */
int glomodear; /* GLONASS AR mode (0:off,1:on,2:auto cal,3:ext cal) */
int gpsmodear; /* GPS AR mode, debug/learning only (0:off,1:on) */
int bdsmodear; /* BeiDou AR mode (0:off,1:on) */
int arfilter; /* AR filtering to reject bad sats (0:off,1:on) */
int maxout; /* obs outage count to reset bias */
int minlock; /* min lock count to fix ambiguity */
int minfixsats; /* min sats to fix integer ambiguities */
int minholdsats; /* min sats to hold integer ambiguities */
int mindropsats; /* min sats to drop sats in AR */
int minfix; /* min fix count to hold ambiguity */
int armaxiter; /* max iteration to resolve ambiguity */
int ionoopt; /* ionosphere option (IONOOPT_???) */
int tropopt; /* troposphere option (TROPOPT_???) */
int dynamics; /* dynamics model (0:none,1:velociy,2:accel) */
int tidecorr; /* earth tide correction (0:off,1:solid,2:solid+otl+pole) */
int niter; /* number of filter iteration */
int codesmooth; /* code smoothing window size (0:none) */
int intpref; /* interpolate reference obs (for post mission) */
int sbascorr; /* SBAS correction options */
int sbassatsel; /* SBAS satellite selection (0:all) */
int rovpos; /* rover position for fixed mode */
int refpos; /* base position for relative mode */
/* (0:pos in prcopt, 1:average of single pos, */
/* 2:read from file, 3:rinex header, 4:rtcm pos) */
double eratio[NFREQ]; /* code/phase error ratio */
double err[8]; /* observation error terms */
/* [reserved,constant,elevation,baseline,doppler,snr-max,snr, rcv_std] */
double std[3]; /* initial-state std [0]bias,[1]iono [2]trop */
double prn[6]; /* process-noise std [0]bias,[1]iono [2]trop [3]acch [4]accv [5] pos */
double sclkstab; /* satellite clock stability (sec/sec) */
double thresar[8]; /* AR validation threshold */
double elmaskar; /* elevation mask of AR for rising satellite (deg) */
double elmaskhold; /* elevation mask to hold ambiguity (deg) */
double thresslip; /* slip threshold of geometry-free phase (m) */
double thresdop; /* slip threshold of doppler (m) */
double varholdamb; /* variance for fix-and-hold psuedo measurements (cycle^2) */
double gainholdamb; /* gain used for GLO and SBAS sats to adjust ambiguity */
double maxtdiff; /* max difference of time (sec) */
double maxinno; /* reject threshold of innovation (m) */
double maxgdop; /* reject threshold of gdop */
double baseline[2]; /* baseline length constraint {const,sigma} (m) */
double ru[3]; /* rover position for fixed mode {x,y,z} (ecef) (m) */
double rb[3]; /* base position for relative mode {x,y,z} (ecef) (m) */
char anttype[2][MAXANT]; /* antenna types {rover,base} */
double antdel[2][3]; /* antenna delta {{rov_e,rov_n,rov_u},{ref_e,ref_n,ref_u}} */
// pcv_t pcvr[2]; /* receiver antenna parameters {rov,base} */
uint8_t exsats[MAXSAT]; /* excluded satellites (1:excluded,2:included) */
int maxaveep; /* max averaging epoches */
int initrst; /* initialize by restart */
int outsingle; /* output single by dgps/float/fix/ppp outage */
char rnxopt[2][256]; /* rinex options {rover,base} */
int posopt[6]; /* positioning options */
int syncsol; /* solution sync mode (0:off,1:on) */
double odisp[2][6 * 11]; /* ocean tide loading parameters {rov,base} */
int freqopt; /* disable L2-AR */
char pppopt[256]; /* ppp option */
} prcopt_t;
typedef struct
{ /* solution options type */
int posf; /* solution format (SOLF_???) */
int times; /* time system (TIMES_???) */
int timef; /* time format (0:sssss.s,1:yyyy/mm/dd hh:mm:ss.s) */
int timeu; /* time digits under decimal point */
int degf; /* latitude/longitude format (0:ddd.ddd,1:ddd mm ss) */
int outhead; /* output header (0:no,1:yes) */
int outopt; /* output processing options (0:no,1:yes) */
int outvel; /* output velocity options (0:no,1:yes) */
int datum; /* datum (0:WGS84,1:Tokyo) */
int height; /* height (0:ellipsoidal,1:geodetic) */
int geoid; /* geoid model (0:EGM96,1:JGD2000) */
int solstatic; /* solution of static mode (0:all,1:single) */
int sstat; /* solution statistics level (0:off,1:states,2:residuals) */
int trace; /* debug trace level (0:off,1-5:debug) */
double nmeaintv[2]; /* nmea output interval (s) (<0:no,0:all) */
/* nmeaintv[0]:gprmc,gpgga,nmeaintv[1]:gpgsv */
char sep[64]; /* field separator */
char prog[64]; /* program name */
double maxsolstd; /* max std-dev for solution output (m) (0:all) */
} solopt_t;
// typedef struct { /* file options type */
// char satantp[MAXSTRPATH]; /* satellite antenna parameters file */
// char rcvantp[MAXSTRPATH]; /* receiver antenna parameters file */
// char stapos [MAXSTRPATH]; /* station positions file */
// char geoid [MAXSTRPATH]; /* external geoid data file */
// char iono [MAXSTRPATH]; /* ionosphere data file */
// char dcb [MAXSTRPATH]; /* dcb data file */
// char eop [MAXSTRPATH]; /* eop data file */
// char blq [MAXSTRPATH]; /* ocean tide loading blq file */
// char tempdir[MAXSTRPATH]; /* ftp/http temporaly directory */
// char geexe [MAXSTRPATH]; /* google earth exec file */
// char solstat[MAXSTRPATH]; /* solution statistics file */
// char trace [MAXSTRPATH]; /* debug trace file */
// } filopt_t;
// typedef struct { /* RINEX options type */
// gtime_t ts,te; /* time start/end */
// double tint; /* time interval (s) */
// double ttol; /* time tolerance (s) */
// double tunit; /* time unit for multiple-session (s) */
// int rnxver; /* RINEX version (x100) */
// int navsys; /* navigation system */
// int obstype; /* observation type */
// int freqtype; /* frequency type */
// char mask[7][64]; /* code mask {GPS,GLO,GAL,QZS,SBS,CMP,IRN} */
// char staid [32]; /* station id for rinex file name */
// char prog [32]; /* program */
// char runby [32]; /* run-by */
// char marker[64]; /* marker name */
// char markerno[32]; /* marker number */
// char markertype[32]; /* marker type (ver.3) */
// char name[2][32]; /* observer/agency */
// char rec [3][32]; /* receiver #/type/vers */
// char ant [3][32]; /* antenna #/type */
// double apppos[3]; /* approx position x/y/z */
// double antdel[3]; /* antenna delta h/e/n */
// double glo_cp_bias[4]; /* GLONASS code-phase biases (m) */
// char comment[MAXCOMMENT][64]; /* comments */
// char rcvopt[256]; /* receiver dependent options */
// uint8_t exsats[MAXSAT]; /* excluded satellites */
// int glofcn[32]; /* glonass fcn+8 */
// int outiono; /* output iono correction */
// int outtime; /* output time system correction */
// int outleaps; /* output leap seconds */
// int autopos; /* auto approx position */
// int phshift; /* phase shift correction */
// int halfcyc; /* half cycle correction */
// int sep_nav; /* separated nav files */
// gtime_t tstart; /* first obs time */
// gtime_t tend; /* last obs time */
// gtime_t trtcm; /* approx log start time for rtcm */
// char tobs[7][MAXOBSTYPE][4]; /* obs types {GPS,GLO,GAL,QZS,SBS,CMP,IRN} */
// double shift[7][MAXOBSTYPE]; /* phase shift (cyc) {GPS,GLO,GAL,QZS,SBS,CMP,IRN} */
// int nobs[7]; /* number of obs types {GPS,GLO,GAL,QZS,SBS,CMP,IRN} */
// } rnxopt_t;
typedef struct
{ /* satellite status type */
uint8_t sys; /* navigation system */
uint8_t vs; /* valid satellite flag single */
double azel[2]; /* azimuth/elevation angles {az,el} (rad) */
double resp[NFREQ]; /* residuals of pseudorange (m) */
double resc[NFREQ]; /* residuals of carrier-phase (m) */
double icbias[NFREQ]; /* glonass IC bias (cycles) */
uint8_t vsat[NFREQ]; /* valid satellite flag */
uint16_t snr_rover[NFREQ]; /* rover signal strength (0.25 dBHz) */
uint16_t snr_base[NFREQ]; /* base signal strength (0.25 dBHz) */
uint8_t fix[NFREQ]; /* ambiguity fix flag (1:fix,2:float,3:hold) */
uint8_t slip[NFREQ]; /* cycle-slip flag */
uint8_t half[NFREQ]; /* half-cycle valid flag */
int lock[NFREQ]; /* lock counter of phase */
uint32_t outc[NFREQ]; /* obs outage counter of phase */
uint32_t slipc[NFREQ]; /* cycle-slip counter */
uint32_t rejc[NFREQ]; /* reject counter */
double gf[NFREQ - 1]; /* geometry-free phase (m) */
double mw[NFREQ - 1]; /* MW-LC (m) */
double phw; /* phase windup (cycle) */
gtime_t pt[2][NFREQ]; /* previous carrier-phase time */
double ph[2][NFREQ]; /* previous carrier-phase observable (cycle) */
} ssat_t;
typedef struct
{ /* ambiguity control type */
gtime_t epoch[4]; /* last epoch */
int n[4]; /* number of epochs */
double LC[4]; /* linear combination average */
double LCv[4]; /* linear combination variance */
int fixcnt; /* fix count */
char flags[MAXSAT]; /* fix flags */
} ambc_t;
// RTK???????
typedef struct
{ /* RTK control/result type */
sol_t sol; /* RTK solution */
double rb[6]; /* base position/velocity (ecef) (m|m/s) */
int nx, na; /* number of float states/fixed states */
double tt; /* time difference between current and previous (s) */
double *x, *P; /* float states and their covariance */
double *xa, *Pa; /* fixed states and their covariance */
int nfix; /* number of continuous fixes of ambiguity */
int excsat; /* index of next satellite to be excluded for partial ambiguity resolution */
int nb_ar; /* number of ambiguities used for AR last epoch */
double com_bias; /* phase bias common between all sats (used to be distributed to all sats */
char holdamb; /* set if fix-and-hold has occurred at least once */
ambc_t ambc[MAXSAT]; /* ambiguity control */
ssat_t ssat[MAXSAT]; /* satellite status */
int neb; /* bytes in error message buffer */
// char errbuf[MAXERRMSG]; /* error message buffer */
prcopt_t opt; /* processing options */
int initial_mode; /* initial positioning mode */
} rtk_t;
// typedef struct { /* receiver raw data control type */
// gtime_t time; /* message time */
// gtime_t tobs[MAXSAT][NFREQ+NEXOBS]; /* observation data time */
// obs_t obs; /* observation data */
// obs_t obuf; /* observation data buffer */
// nav_t nav; /* satellite ephemerides */
// sta_t sta; /* station parameters */
// int ephsat; /* update satelle of ephemeris (0:no satellite) */
// int ephset; /* update set of ephemeris (0-1) */
// // sbsmsg_t sbsmsg; /* SBAS message */
// char msgtype[256]; /* last message type */
// uint8_t subfrm[MAXSAT][380]; /* subframe buffer */
// double lockt[MAXSAT][NFREQ+NEXOBS]; /* lock time (s) */
// unsigned char lockflag[MAXSAT][NFREQ+NEXOBS]; /* used for carrying forward cycle slip */
// double icpp[MAXSAT],off[MAXSAT],icpc; /* carrier params for ss2 */
// double prCA[MAXSAT],dpCA[MAXSAT]; /* L1/CA pseudrange/doppler for javad */
// uint8_t halfc[MAXSAT][NFREQ+NEXOBS]; /* half-cycle add flag */
// char freqn[MAXOBS]; /* frequency number for javad */
// int nbyte; /* number of bytes in message buffer */
// int len; /* message length (bytes) */
// int iod; /* issue of data */
// int tod; /* time of day (ms) */
// int tbase; /* time base (0:gpst,1:utc(usno),2:glonass,3:utc(su) */
// int flag; /* general purpose flag */
// int outtype; /* output message type */
// uint8_t buff[MAXRAWLEN]; /* message buffer */
// char opt[256]; /* receiver dependent options */
// int format; /* receiver stream format */
// void *rcv_data; /* receiver dependent data */
// } raw_t;
typedef struct
{ /* stream type */
int type; /* type (STR_???) */
int mode; /* mode (STR_MODE_?) */
int state; /* state (-1:error,0:close,1:open) */
uint32_t inb, inr; /* input bytes/rate */
uint32_t outb, outr; /* output bytes/rate */
uint32_t tick_i; /* input tick tick */
uint32_t tick_o; /* output tick */
uint32_t tact; /* active tick */
uint32_t inbt, outbt; /* input/output bytes at tick */
// lock_t lock; /* lock flag */
void *port; /* type dependent port control struct */
char path[MAXSTRPATH]; /* stream path */
char msg[MAXSTRMSG]; /* stream message */
} stream_t;
// typedef struct { /* stream converter type */
// int itype,otype; /* input and output stream type */
// int nmsg; /* number of output messages */
// int msgs[32]; /* output message types */
// double tint[32]; /* output message intervals (s) */
// uint32_t tick[32]; /* cycle tick of output message */
// int ephsat[32]; /* satellites of output ephemeris */
// int stasel; /* station info selection (0:remote,1:local) */
// rtcm_t rtcm; /* rtcm input data buffer */
// raw_t raw; /* raw input data buffer */
// rtcm_t out; /* rtcm output data buffer */
// } strconv_t;
// typedef struct { /* stream server type */
// int state; /* server state (0:stop,1:running) */
// int cycle; /* server cycle (ms) */
// int buffsize; /* input/monitor buffer size (bytes) */
// int nmeacycle; /* NMEA request cycle (ms) (0:no) */
// int relayback; /* relay back of output streams (0:no) */
// int nstr; /* number of streams (1 input + (nstr-1) outputs */
// int npb; /* data length in peek buffer (bytes) */
// char cmds_periodic[16][MAXRCVCMD]; /* periodic commands */
// double nmeapos[3]; /* NMEA request position (ecef) (m) */
// uint8_t *buff; /* input buffers */
// uint8_t *pbuf; /* peek buffer */
// uint32_t tick; /* start tick */
// stream_t stream[16]; /* input/output streams */
// stream_t strlog[16]; /* return log streams */
// // strconv_t *conv[16]; /* stream converter */
// thread_t thread; /* server thread */
// lock_t lock; /* lock flag */
// } strsvr_t;
typedef struct
{ /* RTK server type */
int state; /* server state (0:stop,1:running) */
int cycle; /* processing cycle (ms) */
int nmeacycle; /* NMEA request cycle (ms) (0:no req) */
int nmeareq; /* NMEA request (0:no,1:nmeapos,2:single sol) */
double nmeapos[3]; /* NMEA request position (ecef) (m) */
int buffsize; /* input buffer size (bytes) */
int format[2]; /* input format {rov,base} */
solopt_t solopt[2]; /* output solution options {sol1,sol2} */
int navsel; /* ephemeris select (0:all,1:rover,2:base,3) */
同步测试代码
2022-06-22 09:23:36 +08:00
// int nsbs; /* number of sbas message */
完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
int nsol; /* number of solution buffer */
rtk_t rtk; /* RTK control/result struct */
int nb[2]; /* bytes in input buffers {rov,base} */
同步测试代码
2022-06-22 09:23:36 +08:00
// int nsb[2]; /* bytes in soulution buffers */
// int npb[2]; /* bytes in input peek buffers */
完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
uint8_t *buff[2]; /* input buffers {rov,base} */
同步测试代码
2022-06-22 09:23:36 +08:00
// uint8_t *sbuf[2]; /* output buffers {sol1,sol2} */
// uint8_t *pbuf[2]; /* peek buffers {rov,base} */
完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
sol_t solbuf[MAXSOLBUF]; /* solution buffer */
uint32_t nmsg[2][10]; /* input message counts */
// raw_t raw [2]; /* receiver raw control {rov,base} */
rtcm_t rtcm[2]; /* RTCM control {rov,base} */
// gtime_t ftime[2]; /* download time {rov,base} */
// char files[2][MAXSTRPATH]; /* download paths {rov,base} */
obs_t obs[2][MAXOBSBUF]; /* observation data {rov,base} */
nav_t nav; /* navigation data */
// sbsmsg_t sbsmsg[MAXSBSMSG]; /* SBAS message buffer */
同步测试代码
2022-06-22 09:23:36 +08:00
// stream_t stream[8]; /* streams {rov,base,corr,sol1,sol2,logr,logb,logc} */
完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
// stream_t *moni; /* monitor stream */
uint32_t tick; /* start tick */
// thread_t thread; /* server thread */
int cputime; /* CPU time (ms) for a processing cycle */
int prcout; /* missing observation data count */
int nave; /* number of averaging base pos */
double rb_ave[3]; /* averaging base pos */
// char cmds_periodic[2][MAXRCVCMD]; /* periodic commands */
// char cmd_reset[MAXRCVCMD]; /* reset command */
double bl_reset; /* baseline length to reset (km) */
// lock_t lock; /* lock flag */
} rtksvr_t;
内部测试第一版
2022-07-05 13:42:48 +08:00
typedef struct
{
sol_t sol;
int nbyte; /* number of bytes in message buffer */
int len; /* message length (bytes) */
uint8_t buff[256]; /* message buffer */
} nmea_t;
完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
// typedef struct { /* GIS data point type */
// double pos[3]; /* point data {lat,lon,height} (rad,m) */
// } gis_pnt_t;
// typedef struct { /* GIS data polyline type */
// int npnt; /* number of points */
// double bound[4]; /* boundary {lat0,lat1,lon0,lon1} */
// double *pos; /* position data (3 x npnt) */
// } gis_poly_t;
// typedef struct { /* GIS data polygon type */
// int npnt; /* number of points */
// double bound[4]; /* boundary {lat0,lat1,lon0,lon1} */
// double *pos; /* position data (3 x npnt) */
// } gis_polygon_t;
// typedef struct gisd_tag { /* GIS data list type */
// int type; /* data type (1:point,2:polyline,3:polygon) */
// void *data; /* data body */
// struct gisd_tag *next; /* pointer to next */
// } gisd_t;
// typedef struct { /* GIS type */
// char name[MAXGISLAYER][256]; /* name */
// int flag[MAXGISLAYER]; /* flag */
// gisd_t *data[MAXGISLAYER]; /* gis data list */
// double bound[4]; /* boundary {lat0,lat1,lon0,lon1} */
// } gis_t;
typedef void fatalfunc_t(const char *); /* fatal callback function type */
/* global variables ----------------------------------------------------------*/
extern const double chisqr[]; /* chi-sqr(n) table (alpha=0.001) */
extern const prcopt_t prcopt_default; /* default positioning options */
extern const solopt_t solopt_default; /* default solution output options */
extern const char *formatstrs[]; /* stream format strings */
extern opt_t sysopts[]; /* system options table */
/* satellites, systems, codes functions --------------------------------------*/
int satno(int sys, int prn);
int satsys(int sat, int *prn);
int satid2no(const char *id);
void satno2id(int sat, char *id);
uint8_t obs2code(const char *obs);
char *code2obs(uint8_t code);
double code2freq(int sys, uint8_t code, int fcn);
double sat2freq(int sat, uint8_t code, const nav_t *nav);
int code2idx(int sys, uint8_t code);
int satexclude(int sat, double var, int svh, const prcopt_t *opt);
int testsnr(int base, int freq, double el, double snr,
const snrmask_t *mask);
void setcodepri(int sys, int idx, const char *pri);
int getcodepri(int sys, uint8_t code, const char *opt);
/* matrix and vector functions -----------------------------------------------*/
double *mat(int n, int m);
int *imat(int n, int m);
double *zeros(int n, int m);
double *eye(int n);
double dot(const double *a, const double *b, int n);
double norm(const double *a, int n);
void cross3(const double *a, const double *b, double *c);
int normv3(const double *a, double *b);
void matcpy(double *A, const double *B, int n, int m);
void matmul(const char *tr, int n, int k, int m, double alpha,
const double *A, const double *B, double beta, double *C);
int matinv(double *A, int n);
int solve(const char *tr, const double *A, const double *Y, int n,
int m, double *X);
int lsq(const double *A, const double *y, int n, int m, double *x,
double *Q);
int filter(double *x, double *P, const double *H, const double *v,
const double *R, int n, int m);
int smoother(const double *xf, const double *Qf, const double *xb,
const double *Qb, int n, double *xs, double *Qs);
void matprint(const double *A, int n, int m, int p, int q);
void matfprint(const double *A, int n, int m, int p, int q, FILE *fp);
void add_fatal(fatalfunc_t *func);
/* time and string functions -------------------------------------------------*/
double str2num(const char *s, int i, int n);
int str2time(const char *s, int i, int n, gtime_t *t);
void time2str(gtime_t t, char *str, int n);
gtime_t epoch2time(const double *ep);
void time2epoch(gtime_t t, double *ep);
void time2epoch_n(gtime_t t, double *ep, int n);
gtime_t gpst2time(int week, double sec);
double time2gpst(gtime_t t, int *week);
gtime_t gst2time(int week, double sec);
double time2gst(gtime_t t, int *week);
gtime_t bdt2time(int week, double sec);
double time2bdt(gtime_t t, int *week);
char *time_str(gtime_t t, int n);
gtime_t timeadd(gtime_t t, double sec);
double timediff(gtime_t t1, gtime_t t2);
gtime_t gpst2utc(gtime_t t);
gtime_t utc2gpst(gtime_t t);
gtime_t gpst2bdt(gtime_t t);
gtime_t bdt2gpst(gtime_t t);
gtime_t timeget(void);
void timeset(gtime_t t);
void timereset(void);
double time2doy(gtime_t t);
double utc2gmst(gtime_t t, double ut1_utc);
int read_leaps(const char *file);
int adjgpsweek(int week);
uint32_t tickget(void);
void sleepms(int ms);
int reppath(const char *path, char *rpath, gtime_t time, const char *rov,
const char *base);
int reppaths(const char *path, char *rpaths[], int nmax, gtime_t ts,
gtime_t te, const char *rov, const char *base);
/* coordinates transformation ------------------------------------------------*/
void ecef2pos(const double *r, double *pos);
void pos2ecef(const double *pos, double *r);
void ecef2enu(const double *pos, const double *r, double *e);
void enu2ecef(const double *pos, const double *e, double *r);
void covenu(const double *pos, const double *P, double *Q);
void covecef(const double *pos, const double *Q, double *P);
void xyz2enu(const double *pos, double *E);
void eci2ecef(gtime_t tutc, const double *erpv, double *U, double *gmst);
void deg2dms(double deg, double *dms, int ndec);
double dms2deg(const double *dms);
/* input and output functions ------------------------------------------------*/
// void readpos(const char *file, const char *rcv, double *pos);
int sortobs(obs_t *obs);
void uniqnav(nav_t *nav);
int screent(gtime_t time, gtime_t ts, gtime_t te, double tint);
void freeobs(obs_t *obs);
void freenav(nav_t *nav, int opt);
int geterp(const erp_t *erp, gtime_t time, double *val);
// int readnav(const char *file, nav_t *nav);
// int savenav(const char *file, const nav_t *nav);
// int readblq(const char *file, const char *sta, double *odisp);
// int readerp(const char *file, erp_t *erp);
/* debug trace functions -----------------------------------------------------*/
void traceopen(const char *file);
void traceclose(void);
void tracelevel(int level);
void trace(int level, const char *format, ...);
void tracet(int level, const char *format, ...);
void tracemat(int level, const double *A, int n, int m, int p, int q);
void traceobs(int level, const obsd_t *obs, int n);
void tracenav(int level, const nav_t *nav);
void tracegnav(int level, const nav_t *nav);
void tracehnav(int level, const nav_t *nav);
void tracepeph(int level, const nav_t *nav);
void tracepclk(int level, const nav_t *nav);
void traceb(int level, const uint8_t *p, int n);
int gettracelevel(void);
/* platform dependent functions ----------------------------------------------*/
int execcmd(const char *cmd);
int expath(const char *path, char *paths[], int nmax);
void createdir(const char *path);
/* positioning models --------------------------------------------------------*/
double satazel(const double *pos, const double *e, double *azel);
double geodist(const double *rs, const double *rr, double *e);
void dops(int ns, const double *azel, double elmin, double *dop);
/* atmosphere models ---------------------------------------------------------*/
double ionmodel(gtime_t t, const double *ion, const double *pos,
const double *azel);
double ionmapf(const double *pos, const double *azel);
double ionppp(const double *pos, const double *azel, double re,
double hion, double *pppos);
double tropmodel(gtime_t time, const double *pos, const double *azel,
double humi);
double tropmapf(gtime_t time, const double *pos, const double *azel,
double *mapfw);
int iontec(gtime_t time, const nav_t *nav, const double *pos,
const double *azel, int opt, double *delay, double *var);
// void readtec(const char *file, nav_t *nav, int opt);
int ionocorr(gtime_t time, const nav_t *nav, int sat, const double *pos,
const double *azel, int ionoopt, double *ion, double *var);
int tropcorr(gtime_t time, const nav_t *nav, const double *pos,
const double *azel, int tropopt, double *trp, double *var);
/* antenna models ------------------------------------------------------------*/
// int readpcv(const char *file, pcvs_t *pcvs);
// pcv_t *searchpcv(int sat, const char *type, gtime_t time,
// const pcvs_t *pcvs);
// void antmodel(const pcv_t *pcv, const double *del, const double *azel,
// int opt, double *dant);
// void antmodel_s(const pcv_t *pcv, double nadir, double *dant);
/* earth tide models ---------------------------------------------------------*/
void sunmoonpos(gtime_t tutc, const double *erpv, double *rsun,
double *rmoon, double *gmst);
void tidedisp(gtime_t tutc, const double *rr, int opt, const erp_t *erp,
const double *odisp, double *dr);
/* geiod models --------------------------------------------------------------*/
int opengeoid(int model, const char *file);
void closegeoid(void);
double geoidh(const double *pos);
/* datum transformation ------------------------------------------------------*/
// int loaddatump(const char *file);
// int tokyo2jgd(double *pos);
// int jgd2tokyo(double *pos);
/* ephemeris and clock functions ---------------------------------------------*/
double eph2clk(gtime_t time, const eph_t *eph);
double geph2clk(gtime_t time, const geph_t *geph);
// double seph2clk(gtime_t time, const seph_t *seph);
void eph2pos(gtime_t time, const eph_t *eph, double *rs, double *dts,
double *var);
void geph2pos(gtime_t time, const geph_t *geph, double *rs, double *dts,
double *var);
// void seph2pos(gtime_t time, const seph_t *seph, double *rs, double *dts,
// double *var);
// int peph2pos(gtime_t time, int sat, const nav_t *nav, int opt,
// double *rs, double *dts, double *var);
// void satantoff(gtime_t time, const double *rs, int sat, const nav_t *nav,
// double *dant);
int satpos(gtime_t time, gtime_t teph, int sat, int ephopt,
const nav_t *nav, double *rs, double *dts, double *var,
int *svh);
void satposs(gtime_t time, const obsd_t *obs, int n, const nav_t *nav,
int sateph, double *rs, double *dts, double *var, int *svh);
void setseleph(int sys, int sel);
int getseleph(int sys);
// void readsp3(const char *file, nav_t *nav, int opt);
// int readsap(const char *file, gtime_t time, nav_t *nav);
// int readdcb(const char *file, nav_t *nav, const sta_t *sta);
// int readfcb(const char *file, nav_t *nav);
// void alm2pos(gtime_t time, const alm_t *alm, double *rs, double *dts);
// int tle_read(const char *file, tle_t *tle);
// int tle_name_read(const char *file, tle_t *tle);
// int tle_pos(gtime_t time, const char *name, const char *satno,
// const char *desig, const tle_t *tle, const erp_t *erp,
// double *rs);
/* receiver raw data functions -----------------------------------------------*/
uint32_t getbitu(const uint8_t *buff, int pos, int len);
int32_t getbits(const uint8_t *buff, int pos, int len);
void setbitu(uint8_t *buff, int pos, int len, uint32_t data);
void setbits(uint8_t *buff, int pos, int len, int32_t data);
uint32_t rtk_crc32(const uint8_t *buff, int len);
uint32_t rtk_crc24q(const uint8_t *buff, int len);
uint16_t rtk_crc16(const uint8_t *buff, int len);
// int decode_word (uint32_t word, uint8_t *data);
// int decode_frame(const uint8_t *buff, eph_t *eph, alm_t *alm,
// double *ion, double *utc);
// int test_glostr(const uint8_t *buff);
// int decode_glostr(const uint8_t *buff, geph_t *geph, double *utc);
// int decode_bds_d1(const uint8_t *buff, eph_t *eph, double *ion,
// double *utc);
// int decode_bds_d2(const uint8_t *buff, eph_t *eph, double *utc);
// int decode_gal_inav(const uint8_t *buff, eph_t *eph, double *ion,
// double *utc);
// int decode_gal_fnav(const uint8_t *buff, eph_t *eph, double *ion,
// double *utc);
// int decode_irn_nav(const uint8_t *buff, eph_t *eph, double *ion,
// double *utc);
// int init_raw (raw_t *raw, int format);
// void free_raw (raw_t *raw);
// int input_raw (raw_t *raw, int format, uint8_t data);
// int input_rawf (raw_t *raw, int format, FILE *fp);
// int update_cmr (raw_t *raw, rtksvr_t *svr, obs_t *obs);
// int input_ubx (raw_t *raw, uint8_t data);
// int input_ubxf (raw_t *raw, FILE *fp);
// int input_oem4 (raw_t *raw, uint8_t data);
// int input_cnav (raw_t *raw, uint8_t data);
// int input_sbp (raw_t *raw, uint8_t data);
// int input_cres (raw_t *raw, uint8_t data);
// int input_stq (raw_t *raw, uint8_t data);
// int input_javad (raw_t *raw, uint8_t data);
// int input_nvs (raw_t *raw, uint8_t data);
// int input_bnx (raw_t *raw, uint8_t data);
// int input_rt17 (raw_t *raw, uint8_t data);
// int input_sbf (raw_t *raw, uint8_t data);
// int input_tersus(raw_t *raw, uint8_t data);
// int input_oem4f (raw_t *raw, FILE *fp);
// int input_cnavf (raw_t *raw, FILE *fp);
// int input_sbpf (raw_t *raw, FILE *fp);
// int input_cresf (raw_t *raw, FILE *fp);
// int input_stqf (raw_t *raw, FILE *fp);
// int input_javadf(raw_t *raw, FILE *fp);
// int input_nvsf (raw_t *raw, FILE *fp);
// int input_bnxf (raw_t *raw, FILE *fp);
// int input_rt17f (raw_t *raw, FILE *fp);
// int input_sbff (raw_t *raw, FILE *fp);
// int input_tersusf(raw_t *raw, FILE *fp);
// int gen_ubx (const char *msg, uint8_t *buff);
// int gen_stq (const char *msg, uint8_t *buff);
// int gen_nvs (const char *msg, uint8_t *buff);
/* rtcm functions ------------------------------------------------------------*/
int init_rtcm(rtcm_t *rtcm);
int init_rtcm_static(rtcm_t *rtcm, char index);
void free_rtcm(rtcm_t *rtcm);
int input_rtcm3(rtcm_t *rtcm, uint8_t data);
// int input_rtcm3f(rtcm_t *rtcm, FILE *fp);
// int input_rtcm2 (rtcm_t *rtcm, uint8_t data);
// int input_rtcm2f(rtcm_t *rtcm, FILE *fp);
// int gen_rtcm2 (rtcm_t *rtcm, int type, int sync);
// int gen_rtcm3 (rtcm_t *rtcm, int type, int subtype, int sync);
/* solution functions --------------------------------------------------------*/
// void initsolbuf(solbuf_t *solbuf, int cyclic, int nmax);
// void freesolbuf(solbuf_t *solbuf);
// void freesolstatbuf(solstatbuf_t *solstatbuf);
// sol_t *getsol(solbuf_t *solbuf, int index);
// int addsol(solbuf_t *solbuf, const sol_t *sol);
// int readsol (char *files[], int nfile, solbuf_t *sol);
// int readsolt(char *files[], int nfile, gtime_t ts, gtime_t te,
// double tint, int qflag, solbuf_t *sol);
// int readsolstat(char *files[], int nfile, solstatbuf_t *statbuf);
// int readsolstatt(char *files[], int nfile, gtime_t ts, gtime_t te,
// double tint, solstatbuf_t *statbuf);
// int inputsol(uint8_t data, gtime_t ts, gtime_t te, double tint,
// int qflag, const solopt_t *opt, solbuf_t *solbuf);
int outprcopts(uint8_t *buff, const prcopt_t *opt);
int outsolheads(uint8_t *buff, const solopt_t *opt);
int outsols(uint8_t *buff, const sol_t *sol, const double *rb,
const solopt_t *opt);
int outsolexs(uint8_t *buff, const sol_t *sol, const ssat_t *ssat,
const solopt_t *opt);
void outprcopt(FILE *fp, const prcopt_t *opt);
void outsolhead(FILE *fp, const solopt_t *opt);
void outsol(FILE *fp, const sol_t *sol, const double *rb,
const solopt_t *opt);
void outsolex(FILE *fp, const sol_t *sol, const ssat_t *ssat,
const solopt_t *opt);
int outnmea_rmc(uint8_t *buff, const sol_t *sol);
int outnmea_gga(uint8_t *buff, const sol_t *sol);
int outnmea_gsa(uint8_t *buff, const sol_t *sol,
const ssat_t *ssat);
int outnmea_gsv(uint8_t *buff, const sol_t *sol,
const ssat_t *ssat);
// /* google earth kml converter ------------------------------------------------*/
// int convkml(const char *infile, const char *outfile, gtime_t ts,
// gtime_t te, double tint, int qflg, double *offset,
// int tcolor, int pcolor, int outalt, int outtime);
// /* gpx converter -------------------------------------------------------------*/
// int convgpx(const char *infile, const char *outfile, gtime_t ts,
// gtime_t te, double tint, int qflg, double *offset,
// int outtrk, int outpnt, int outalt, int outtime);
/* sbas functions ------------------------------------------------------------*/
// int sbsreadmsg (const char *file, int sel, sbs_t *sbs);
// int sbsreadmsgt(const char *file, int sel, gtime_t ts, gtime_t te,
// sbs_t *sbs);
// void sbsoutmsg(FILE *fp, sbsmsg_t *sbsmsg);
// int sbsdecodemsg(gtime_t time, int prn, const uint32_t *words,
// sbsmsg_t *sbsmsg);
// int sbsupdatecorr(const sbsmsg_t *msg, nav_t *nav);
// int sbssatcorr(gtime_t time, int sat, const nav_t *nav, double *rs,
// double *dts, double *var);
// int sbsioncorr(gtime_t time, const nav_t *nav, const double *pos,
// const double *azel, double *delay, double *var);
// double sbstropcorr(gtime_t time, const double *pos, const double *azel,
// double *var);
/* options functions ---------------------------------------------------------*/
opt_t *searchopt(const char *name, const opt_t *opts);
int str2opt(opt_t *opt, const char *str);
int opt2str(const opt_t *opt, char *str);
int opt2buf(const opt_t *opt, char *buff);
int loadopts(const char *file, opt_t *opts);
int saveopts(const char *file, const char *mode, const char *comment,
const opt_t *opts);
void resetsysopts(void);
// void getsysopts(prcopt_t *popt, solopt_t *sopt, filopt_t *fopt);
// void setsysopts(const prcopt_t *popt, const solopt_t *sopt,
// const filopt_t *fopt);
void getsysopts(prcopt_t *popt, solopt_t *sopt);
void setsysopts(const prcopt_t *popt, const solopt_t *sopt);
/* stream data input and output functions ------------------------------------*/
void strinitcom(void);
void strinit(stream_t *stream);
void strlock(stream_t *stream);
void strunlock(stream_t *stream);
int stropen(stream_t *stream, int type, int mode, const char *path);
void strclose(stream_t *stream);
int strread(stream_t *stream, uint8_t *buff, int n);
int strwrite(stream_t *stream, uint8_t *buff, int n);
void strsync(stream_t *stream1, stream_t *stream2);
int strstat(stream_t *stream, char *msg);
int strstatx(stream_t *stream, char *msg);
void strsum(stream_t *stream, int *inb, int *inr, int *outb, int *outr);
void strsetopt(const int *opt);
gtime_t strgettime(stream_t *stream);
void strsendnmea(stream_t *stream, const sol_t *sol);
void strsendcmd(stream_t *stream, const char *cmd);
void strsettimeout(stream_t *stream, int toinact, int tirecon);
void strsetdir(const char *dir);
void strsetproxy(const char *addr);
/* integer ambiguity resolution ----------------------------------------------*/
int lambda(rtk_t *rtk, int n, int m, const double *a, const double *Q, double *F,
double *s);
int lambda_reduction(int n, const double *Q, double *Z);
int lambda_search(int n, int m, const double *a, const double *Q,
double *F, double *s);
int parlambda(rtk_t *rtk, int n, int m, const double *a, const double *Q, double *F, double *s);
/* standard positioning ------------------------------------------------------*/
int pntpos(const obsd_t *obs, int n, const nav_t *nav,
const prcopt_t *opt, sol_t *sol, double *azel,
ssat_t *ssat, char *msg);
/* precise positioning -------------------------------------------------------*/
void rtkinit(rtk_t *rtk, const prcopt_t *opt);
void rtkfree(rtk_t *rtk);
int rtkpos(rtk_t *rtk, const obsd_t *obs, int nobs, const nav_t *nav);
extern int rtkpos_static(rtk_t *rtk, obsd_t *obs[], int n, const nav_t *nav, char nr1, char nu1);
// int rtkopenstat(const char *file, int level);
// void rtkclosestat(void);
// int rtkoutstat(rtk_t *rtk, char *buff);
// /* precise point positioning -------------------------------------------------*/
// void pppos(rtk_t *rtk, const obsd_t *obs, int n, const nav_t *nav);
// int pppnx(const prcopt_t *opt);
// int pppoutstat(rtk_t *rtk, char *buff);
// int ppp_ar(rtk_t *rtk, const obsd_t *obs, int n, int *exc,
// const nav_t *nav, const double *azel, double *x, double *P);
/* post-processing positioning -----------------------------------------------*/
// int postpos(gtime_t ts, gtime_t te, double ti, double tu,
// const prcopt_t *popt, const solopt_t *sopt,
// const filopt_t *fopt, char **infile, int n, char *outfile,
// const char *rov, const char *base);
int postpos(gtime_t ts, gtime_t te, double ti, double tu,
const prcopt_t *popt, const solopt_t *sopt,
char **infile, int n, char *outfile,
const char *rov, const char *base);
/* stream server functions ---------------------------------------------------*/
// void strsvrinit (strsvr_t *svr, int nout);
// int strsvrstart(strsvr_t *svr, int *opts, int *strs, char **paths,
// char **logs, strconv_t **conv, char **cmds,
// char **cmds_priodic, const double *nmeapos);
// void strsvrstop (strsvr_t *svr, char **cmds);
// void strsvrstat (strsvr_t *svr, int *stat, int *log_stat, int *byte,
// int *bps, char *msg);
// strconv_t *strconvnew(int itype, int otype, const char *msgs, int staid,
// int stasel, const char *opt);
// void strconvfree(strconv_t *conv);
/* rtk server functions ------------------------------------------------------*/
int rtksvrinit(rtksvr_t *svr);
void rtksvrfree(rtksvr_t *svr);
int rtksvrstart(rtksvr_t *svr, int cycle, int buffsize, int *strs,
char **paths, int *formats, int navsel, char **cmds,
char **cmds_periodic, char **rcvopts, int nmeacycle,
int nmeareq, const double *nmeapos, prcopt_t *prcopt,
solopt_t *solopt, stream_t *moni, char *errmsg);
void rtksvrstop(rtksvr_t *svr, char **cmds);
int rtksvropenstr(rtksvr_t *svr, int index, int str, const char *path,
const solopt_t *solopt);
void rtksvrclosestr(rtksvr_t *svr, int index);
同步测试代码
2022-06-22 09:23:36 +08:00
// void rtksvrlock(rtksvr_t *svr);
// void rtksvrunlock(rtksvr_t *svr);
完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
int rtksvrostat(rtksvr_t *svr, int type, gtime_t *time, int *sat,
double *az, double *el, int **snr, int *vsat);
void rtksvrsstat(rtksvr_t *svr, int *sstat, char *msg);
int rtksvrmark(rtksvr_t *svr, const char *name, const char *comment);
// /* downloader functions ------------------------------------------------------*/
// int dl_readurls(const char *file, char **types, int ntype, url_t *urls,
// int nmax);
// int dl_readstas(const char *file, char **stas, int nmax);
// int dl_exec(gtime_t ts, gtime_t te, double ti, int seqnos, int seqnoe,
// const url_t *urls, int nurl, char **stas, int nsta,
// const char *dir, const char *usr, const char *pwd,
// const char *proxy, int opts, char *msg, FILE *fp);
// void dl_test(gtime_t ts, gtime_t te, double ti, const url_t *urls,
// int nurl, char **stas, int nsta, const char *dir,
// int ncol, int datefmt, FILE *fp);
/* GIS data functions --------------------------------------------------------*/
// int gis_read(const char *file, gis_t *gis, int layer);
// void gis_free(gis_t *gis);
/* application defined functions ---------------------------------------------*/
extern int showmsg(const char *format, ...);
extern void settspan(gtime_t ts, gtime_t te);
extern void settime(gtime_t time);
同步测试代码
2022-06-22 09:23:36 +08:00
int dbg_show_obs(const obsd_t *obs, int nobs, char mode, char *buffer);
完成串口调试 添加RTCM库
2022-06-14 19:43:20 +08:00
#endif /* RTKLIB_H */
Reference in New Issue Copy Permalink