【GNSS】GNSS处理中的时间系统

最新推荐文章于 2023-03-13 10:42:55 发布
最新推荐文章于 2023-03-13 10:42:55 发布
阅读量3k 收藏 29
点赞数 4
分类专栏： C++ GNSS 文章标签： gnss c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32109917/article/details/113421842
版权
GNSS 同时被 2 个专栏收录
42 篇文章 38 订阅
订阅专栏
C++
26 篇文章 7 订阅
订阅专栏

精密GNSS数据处理中主要涉及三种时间类型：以地球自转为基础建立的世界时系统；基于物质内部的原子运动特性的原子时系统；基于天体动力学理论的动力学时系统。

概念介绍

世界时（UT）

世界时是指通过观测恒星的视运动表达的时间系统，如恒星时（ST）指以春分点为参考连续两次经过地方子午圈的时间间隔。格林尼治平恒星时（GMST）消去了章动影响。 同理，以太阳为参考称为太阳时。以真太阳时的平均角速度在天球赤道上作周年视运动的 平太阳作为参考的为平太阳时。若平太阳时起点为平子夜，称为世界时（UT0）。UT0 进行 极移改正后的世界时记为 UT1，在 UT1 上进行地球自转周期性变化（如潮汐）改正后的世 界时记为UT2。

儒略日（JD）

儒略日（Julian Day）是在儒略周期内以连续的日数计算时间的计时法，主要是天文学家在使用。

儒略日数（Julian Day Number，JDN）的计算是从格林威治标准时间的中午开始，包含一个整天的时间，起点的时间（0日）回溯至儒略历的公元前4713年1月1日中午12点（在格里历是公元前4714年11月24日），这个日期是三种多年周期的共同起点，且是历史上最接近现代的一个起点。例如，2000年1月1日的UT12:00是儒略日2,451,545。

儒略日期（Julian date，JD）是以格林威治标准时中午12:00的儒略日加上那一天的瞬时时间的分数。儒略日期是儒略日添加小数部分所表示的儒略日数。例如，2013年1月1日00:30:00（UT）是儒略日期2,456,293.520833。

儒略周期（Julian Period）是开始于公元前4713年，长达7980年的纪年法，被用于历史上各种不同历法的日期转换。公元2018年是儒略周期的6731年，下一个儒略周期将开始于公元3268年。

简化儒略日（MJD）

简化儒略日（Modified Julian Day，MJD），是将儒略日（Julian Day，MJD）进行简化后得到的新计时法。1957年，简化儒略日由史密松天体物理台（Smithsonian Astrophysical Observatory）引入。

儒略日2400000是1858年11月16日，因为JD从中午开始计算，所以简化儒略日的定义中引入偏移量0.5，这意味着MJD 0相当于1858年11月17日的凌晨。并且每一个简化儒略日都在世界时午夜开始和结束。

简化儒略日有两个目的：

  1. 日期从午夜而不是中午开始。

  2. 儒略日的数值由7位数减为5位数，节省计算机储存空间。

动力学时（DT）

动力学时指以天体动力学理论为基础，建立运动方程并进行编算，采用独立变量时间 参数定义的时间系统。以太阳系质心为坐标原点的 DT称为太阳质心动力学时（TDB），以 地球质心为原点的 DT 称为地球动力学时（TDT，1992 年后称为地球时 TT）。DT 是一种 连续均匀的时间系统。TT 的起始时刻为 1977 年 1 月 1 日 0 时。

原子时（TAI）

国际原子时（Temps Atomique International, TAI）指以世界时 1958 年 1 月 1 日 0 时为起点，以铯原子基态两级间跃迁辐射的 9192631770 周所需的时间作为 1 秒秒长定义的一 种连续均匀的时间系统。TT 与 TAI 的转换关系
T T = T A I + 32.184 TT=TAI+32.184 TT=TAI+32.184
协调世界时（UTC）也属于 TAI，但是 UTC 通过跳秒保持与 UT1 在时刻上相近（差异小于 0.9s），从而有了实际的物理意义。跳秒的发生时间通常在一年的 6 月 30 日或 12 月 31 日最后一分钟变为 61s 或 59s。截止 2020 年 1 月，UTC 和 TAI 之间总的跳秒数为 37s， 近期的一次跳秒在 2016 年 12 月 31 日。UTC 与 TAI 的转换公式为
T A I = U T C + l e a p s e c o n d TAI=UTC+leap_second TAI=UTC+leaps​econd
leap_second为跳秒，其数值由国际地球自转和参考系统服务（International Earth Rotation and Reference System Service, IERS）机构维持和发布。 各GNSS 的时间系统也是基于原子时，只是定义的 UTC 时间起点存在差异。

在这里插入图片描述
在这里插入图片描述

代码实现

声明

#ifndef _TIME_H
#define _TIME_H

#include <math.h>
#include <stdio.h>

/* 通用时间定义; */
struct COMMONTIME
{
	unsigned short Year;
	unsigned short Month;
	unsigned short Day;
	unsigned short Hour;
	unsigned short Minute;
	double Second;
};

/* 简化儒略日; */
struct MJDTIME
{
	int Days;
	double FracDay;

	MJDTIME()
	{
		Days = 0;
		FracDay = 0.0;
	}
};

/* 儒略日; */
struct JDTIME
{
	int Days;
	double FracDay;

	JDTIME()
	{
		Days = 0;
		FracDay = 0.0;
	}
};

/* GPS时间定义 */
struct GPSTIME
{
	unsigned short Week;
	double SecOfWeek;

	GPSTIME()
	{
		Week = 0;
		SecOfWeek = 0.0;
	}
};

/*通用时与简化儒略日;*/
bool CommonTime2MJDTime(COMMONTIME*Common, MJDTIME*MJD);
bool MJDTime2CommTime(MJDTIME*MJD,COMMONTIME*Common);

/*儒略日与简化儒略日;*/
bool JDTime2MJDTime(JDTIME*JD,MJDTIME*MJD);
bool MJDTime2JDTime(MJDTIME*MJD,JDTIME*JD);

/*儒略日与通用时;*/
bool JDTime2CommonTime(JDTIME*JD,COMMONTIME*Common);
bool CommonTime2JDTime(COMMONTIME*Common,JDTIME*JD);

/*GPST与通用时;*/
bool GPSTime2CommonTime(GPSTIME*GPS,COMMONTIME*Common);
bool CommonTime2GPSTime(COMMONTIME*Common,GPSTIME*GPS);

/*GPST与简化儒略日;*/
bool GPSTime2MJDTime(GPSTIME*GPS,MJDTIME*MJD);
bool MJDTime2GPSTime(MJDTIME*MJD,GPSTIME*GPS);

/*GPST与儒略日;*/
bool GPSTime2JDTime(GPSTIME*GPS,JDTIME*JD);
bool JDTime2GPSTime(JDTIME*JD,GPSTIME*GPS);

/*输出各种时间的函数;*/
bool PrintfCommon(COMMONTIME Common);
bool PrintfJD(JDTIME JD);
bool PrintfMJD(MJDTIME MJD);
bool PrintfGPST(GPSTIME GPS);

#endif

实现

/*--------------时间系统转换模板;---------------------

功能：提供儒略日，简化儒略日，GPST，通用时四个时间系统的任意两个间的相互转换功能;
包括;
//通用时与简化儒略日;
bool CommonTime2MJDTime;
bool MJDTime2CommTime;

//儒略日与简化儒略日;
bool JDTime2MJDTime;
bool MJDTime2JDTime;

//儒略日与通用时;
bool JDTime2CommonTime;
bool CommonTime2JDTime;

//GPST与通用时;
bool GPSTime2CommonTime;
bool CommonTime2GPSTime;

//GPST与简化儒略日;
bool GPSTime2MJDTime;
bool MJDTime2GPSTime;

//GPST与儒略日;
bool GPSTime2JDTime;
bool JDTime2GPSTime;

//输出各种时间的函数;
bool PrintfCommon;
bool PrintfJD;
bool PrintfMJD;
bool PrintfGPST;
-----------------------------------------------------*/


/*----------取小数部分;-------------------------
函数名称：FRAC
函数功能：输入一个浮点型变量，输出该变量的小数部分;
输入变量：;
	input 要取小数部分的浮点型变量;
输出变量：;
	return 浮点型变量的小数部分;

-------------------------------------------------*/
double FRAC(double input)
{
	return (input - (int)(input));
}

/*-----------------通用时与简化儒略日的相互转换;----------------------
函数名称：;
	bool CommonTime2MJDTime(COMMONTIME*Common, MJDTIME*MJD)
	bool MJDTime2CommTime(MJDTIME*MJD, COMMONTIME*Common)
函数功能：;
	实现通用时与简化儒略日之间的相互转换;
输入变量：;
	*Common 通用时结构体地址;*MJD 简化儒略日结构体地址;
输出变量：;
	*Common 通用时结构体地址;*MJD 简化儒略日结构体地址;
公式来源：;
	卫星导航算法与程序设计PPT
-------------------------------------------------------------------*/
bool CommonTime2MJDTime(const COMMONTIME Common, MJDTIME*MJD)
{
	int y, m = 0;
	double JD, UT = 0;
	JDTIME	jd;

	if (Common.Month<=2)
	{
		y = Common.Year - 1;
		m = Common.Month + 12;
	}
	if (Common.Month>2)
	{
		y = Common.Year;
		m = Common.Month;
	}
	UT = Common.Hour + Common.Minute / 60.0 + Common.Second / 3600.0;
	JD = (int)(365.25*y) + (int)(30.6001*(m + 1)) + Common.Day + UT / 24.0 + 1720981.5;
	MJD->Days = (int)(365.25*y) + (int)(30.6001*(m + 1)) + Common.Day + UT / 24.0 + 1720981.5-2400000.5;
	MJD->FracDay = (UT / 24.0 ) - (int)(UT / 24.0 );

	return true;
}
bool MJDTime2CommTime(const MJDTIME MJD, COMMONTIME*Common)
{

	int a, b, c, d, e = 0;
	double UTDay = 0;
	double UT = 0;
	a = (int)(MJD.Days+MJD.FracDay + 2400000.5+0.5);
	b = a + 1537;
	c = (int)((1.0*b - 122.1) / (365.25));
	d = (int)(365.25*c);
	e = (int)((b - d)*1.0 / 30.6001);
	UTDay = b - d - (int)(30.6001*e) + FRAC(MJD.Days + MJD.FracDay + 2400000.5 + 0.5);
	Common->Day = (int)(UTDay);
	Common->Month = e - 1 - 12 * (int)(e*1.0 / 14);
	Common->Year = c - 4715 - (int)((7 + Common->Month)*1.0 / 10.0);
	UT = (FRAC(UTDay) * 24.0);
	/*Common->Hour = (int)(UT);
	Common->Minute = (int)(FRAC(UT)*60.0);
	Common->Second = FRAC(UT)*60.0*60.0-Common->Minute*60.0;*/

	Common->Hour = int(MJD.FracDay * 24);
	Common->Minute = int((MJD.FracDay * 24 - Common->Hour) * 60);
	Common->Second = MJD.FracDay * 24 * 3600 - Common->Hour * 3600 - Common->Minute * 60;
	return true;
}

/*-----------------简化儒略日与儒略日的相互转换;----------------------
函数名称：;
bool JDTime2MJDTime(JDTIME*JD, MJDTIME*MJD)
bool MJDTime2JDTime(MJDTIME*MJD, JDTIME*JD)
函数功能：;
实现简化儒略日与儒略日的相互转换;
输入变量：;
	*JD 通用时结构体地址;*MJD 简化儒略日结构体地址;
输出变量：;
	*JD 通用时结构体地址;*MJD 简化儒略日结构体地址;
公式来源：;
卫星导航算法与程序设计PPT
-------------------------------------------------------------------*/
bool JDTime2MJDTime(const JDTIME JD, MJDTIME*MJD)
{

	MJD->Days = JD.Days - 2400000 - (int)(JD.FracDay - 0.5-1);
	MJD->FracDay = FRAC(JD.FracDay + 1 - 0.5);
	return true;
}
bool MJDTime2JDTime(const MJDTIME MJD, JDTIME*JD)
{
	
	JD->Days = MJD.Days + 2400000 + (int)(MJD.FracDay + 0.5);
	JD->FracDay = FRAC(MJD.FracDay+0.5);
	return true;
}

/*-----------------通用时与儒略日的相互转换;----------------------
函数名称：;
bool CommonTime2JDTime(COMMONTIME*Common, JDTIME*JD)
bool JDTime2CommTime(JDTIME*MJD, COMMONTIME*Common)
函数功能：;
实现通用时与儒略日之间的相互转换;
输入变量：;
	*Common 通用时结构体地址;*JD 儒略日结构体地址;
输出变量：;
	*Common 通用时结构体地址;*JD 儒略日结构体地址;
公式来源：;
卫星导航算法与程序设计PPT
-------------------------------------------------------------------*/
bool JDTime2CommonTime(const JDTIME JD, COMMONTIME*Common)
{
	MJDTIME MJD;
	MJD.Days = JD.Days - 2400000 - (int)(JD.FracDay - 0.5 - 1);
	MJD.FracDay = FRAC(JD.FracDay + 1 - 0.5);

	int a, b, c, d, e = 0;
	double UTDay = 0;
	double UT = 0;
	a = (int)(MJD.Days + MJD.FracDay + 2400000.5 + 0.5);
	b = a + 1537;
	c = (int)((1.0*b - 122.1) / (365.25));
	d = (int)(365.25*c);
	e = (int)((b - d)*1.0 / 30.6001);
	UTDay = b - d - (int)(30.6001*e) + FRAC(MJD.Days + MJD.FracDay + 2400000.5 + 0.5);
	Common->Day = (int)(UTDay);
	Common->Month = e - 1 - 12 * (int)(e*1.0 / 14);
	Common->Year = c - 4715 - (int)((7 + Common->Month)*1.0 / 10.0);
	UT = (FRAC(UTDay) * 24.0);
	Common->Hour = int(MJD.FracDay * 24);
	Common->Minute = int((MJD.FracDay * 24 - Common->Hour) * 60);
	Common->Second = MJD.FracDay * 24 * 3600 - Common->Hour * 3600 - Common->Minute * 60;
	return true;


}
bool CommonTime2JDTime(const COMMONTIME Common, JDTIME*JD)
{
	int y, m = 0;
	double TemptJD, UT = 0;
	if (Common.Month <= 2)
	{
		y = Common.Year - 1;
		m = Common.Month + 12;
	}
	if (Common.Month > 2)
	{
		y = Common.Year;
		m = Common.Month;
	}
	UT = Common.Hour + Common.Minute / 60.0 + Common.Second / 3600.0;
	TemptJD = (int)(365.25*y) + (int)(30.6001*(m + 1)) + Common.Day + UT / 24.0 + 1720981.5;
	JD->Days = (int)(TemptJD);
	JD->FracDay = (TemptJD)-JD->Days;
	return true;
}

/*-----------------通用时与GPST的相互转换;----------------------
函数名称：;
bool GPSTime2CommonTime(GPSTIME*GPS, COMMONTIME*Common)
bool CommonTime2GPSTime(COMMONTIME*Common, GPSTIME*GPS)
函数功能：;
实现通用时与GPST的相互转换;
输入变量：;
	*GPS,*Common;
公式来源：;
卫星导航算法与程序设计PPT
-------------------------------------------------------------------*/
bool GPSTime2CommonTime(const GPSTIME GPS, COMMONTIME*Common)
{
	MJDTIME MJD;
	MJD.Days = 44244 + GPS.Week * 7 + (int)(GPS.SecOfWeek / 86400.0);
	MJD.FracDay = FRAC(GPS.SecOfWeek / 86400.0);

	int a, b, c, d, e = 0;
	double UTDay = 0;
	double UT = 0;
	a = (int)(MJD.Days + MJD.FracDay + 2400000.5 + 0.5);
	b = a + 1537;
	c = (int)((1.0*b - 122.1) / (365.25));
	d = (int)(365.25*c);
	e = (int)((b - d)*1.0 / 30.6001);
	UTDay = b - d - (int)(30.6001*e) + FRAC(MJD.Days + MJD.FracDay + 2400000.5 + 0.5);
	Common->Day = (int)(UTDay);
	Common->Month = e - 1 - 12 * (int)(e*1.0 / 14);
	Common->Year = c - 4715 - (int)((7 + Common->Month)*1.0 / 10.0);
	UT = (FRAC(UTDay) * 24.0);

	Common->Hour = int(MJD.FracDay * 24);
	Common->Minute = int((MJD.FracDay * 24 - Common->Hour) * 60);
	Common->Second = MJD.FracDay * 24 * 3600 - Common->Hour * 3600 - Common->Minute * 60;
	return true;
	
}
bool CommonTime2GPSTime(const COMMONTIME Common, GPSTIME*GPS)
{
	MJDTIME MJD;
	int y, m = 0;
	double UT = 0;
	if (Common.Month <= 2)
	{
		y = Common.Year - 1;
		m = Common.Month + 12;
	}
	if (Common.Month>2)
	{
		y = Common.Year;
		m = Common.Month;
	}
	UT = Common.Hour + Common.Minute / 60.0 + Common.Second / 3600.0;
	MJD.Days = (int)(365.25*y) + (int)(30.6001*(m + 1)) + Common.Day + UT / 24.0 + 1720981.5 - 2400000.5;
	MJD.FracDay = (UT / 24.0) - (int)(UT / 24.0);

	GPS->Week = (int)((MJD.Days - 44244) / 7.0);
	GPS->SecOfWeek = MJD.Days*86400.0 - 44244 * 86400.0 - GPS->Week * 7*86400.0 + MJD.FracDay * 86400;
	return true;
}

/*-----------------简化儒略日与GPST的相互转换;----------------------
函数名称：;
	bool GPSTime2MJDTime(GPSTIME*GPS, MJDTIME*MJD)
	bool MJDTime2GPSTime(MJDTIME*MJD, GPSTIME*GPS)
函数功能：;
	简化儒略日与GPST的相互转换;

公式来源：;
	卫星导航算法与程序设计PPT
-------------------------------------------------------------------*/
bool GPSTime2MJDTime(const GPSTIME GPS, MJDTIME*MJD)
{
	double temptMJD;
	temptMJD = 44244 + GPS.Week * 7 + GPS.SecOfWeek / 86400;
	MJD->Days = (int)(temptMJD);
	MJD->FracDay = FRAC(temptMJD);
	return true;
}
bool MJDTime2GPSTime(const MJDTIME MJD, GPSTIME*GPS)
{
	GPS->Week = (int)((MJD.Days + MJD.FracDay  - 44244) / 7.0);
	GPS->SecOfWeek = (MJD.Days + MJD.FracDay  - 44244 - GPS->Week * 7) * 86400;
	return true;
}

/*-----------------儒略日与GPST的相互转换;----------------------
函数名称：;
bool GPSTime2JDTime(GPSTIME*GPS, JDTIME*JD)
bool JDTime2GPSTime(JDTIME*JD, GPSTIME*GPS)
函数功能：;
儒略日与GPST的相互转换;

公式来源：;
卫星导航算法与程序设计PPT
-------------------------------------------------------------------*/
bool GPSTime2JDTime(const GPSTIME GPS, JDTIME*JD)
{
	double temptJD;
	temptJD = 44244 + GPS.Week * 7 + GPS.SecOfWeek / 86400 + 2400000.5;
	JD->Days = (int)(temptJD);
	JD->FracDay = FRAC(temptJD);
	return true;
}
bool JDTime2GPSTime(const JDTIME JD, GPSTIME*GPS)
{
	GPS->Week = (int)((JD.Days + JD.FracDay - 2400000.5 - 44244) / 7.0);
	GPS->SecOfWeek = (JD.Days + JD.FracDay - 2400000.5 - 44244 - GPS->Week * 7) * 86400;
	return true;
}

/*------------------输出各种时间系统;--------------------
函数功能：输出各种时间系统的值，一个只能输出一个结构体的变量;
函数名称：;
	bool PrintfCommon(COMMONTIME Common) 输出通用时;
	bool PrintfJD(JDTIME JD) 输出儒略日;
	bool PrintfMJD(MJDTIME MJD) 输出简化儒略日;
	bool PrintfGPST(GPSTIME GPS) 输出GPST;
-----------------------------------------------------*/
bool PrintfCommon(COMMONTIME Common)
{

	if (Common.Day>31)
	{
		printf("number of day was wrong!\n");
		return false;
	}
	if (Common.Hour>24||Common.Hour<0)
	{
		printf("number of hour was wrong!\n");
		return false;
	}
	if (Common.Minute>60||Common.Minute<0)
	{
		printf("number of minute was wrong!\n");
		return false;
	}
	if (Common.Second>60||Common.Second<0)
	{
		printf("number of second was wrong!\n");
		return false;
	}
	printf("%d.%d.%d  %d:%d:%lf;\n", Common.Year, Common.Month, Common.Day, Common.Hour, Common.Minute, Common.Second);
	return true;
}

bool PrintfJD(JDTIME JD)
{
	printf("%lf;\n", JD.FracDay + JD.Days);
	return true;
}

bool PrintfMJD(MJDTIME MJD)
{
	printf("%lf;\n", MJD.FracDay + MJD.Days);
	return true;
}

bool PrintfGPST(GPSTIME GPS)
{
	if (GPS.SecOfWeek<0||GPS.SecOfWeek>604800)
	{
		printf("number of time of week was wrong!\n");
		return false;
	}
	printf("%d %d;\n", GPS.Week, GPS.SecOfWeek);
	return true;
}
小马甲的新马甲
关注
  • 4
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python版本的GNSS时间转换：公历与儒略日的互相转换，以及儒略日转为GPST。
qq_41051690的博客
08-13 1533
python版本的GNSS时间转化： 我自己定义了一个convert_time()类，可以通过类的调用实现时间转化，类似一个模块吧。 class convert_time(): def init(self, year, month, day, hour, minute, second): self.year = year self.month = month self.day = day self...
gnss时间转化
09-22
可以将时间转化为gps时间 儒略日 简化儒略日，同时北斗时间也可以转化为gps时间
GNSS 时间系统
一些笔记
08-19 5741
对 GNSS 中用到的时间系统的简介
GNSS时间系统
人无远虑，必有近忧
02-05 2535
1. 世界时（UT） 世界时是指通过观测恒星的视运动表达的时间系统，如恒星时（ST）指以春分点为参考连续两次经过地方子午圈的时间间隔。格林尼治平恒星时（GMST）消去了章动影响。 同理，以太阳为参考称为太阳时。以真太阳时的平均角速度在天球赤道上作周年视运动的平太阳作为参考的为平太阳时。若平太阳时起点为平子夜，称为世界时（UT0）。UT0 进行极移改正后的世界时记为 UT1，在 UT1 上进行地球自转周期性变化（如潮汐）改正后的世界时记为UT2。 2. 动力学时（DT） 动力学时指以天体动力学理论为基础
GNSS时间转换
yitian_00的博客
03-13 714
GNSS常用时间标示法的转换(包含算法部分和c/c++代码部分）
GNSS时间系统与UTC时间系统的正反算
06-08
基于MATLAB GUI设计，输入任意卫星系统时间信息即可计算其他卫星系统时间信息及UTC时间。输入UTC即可计算卫星系统时间。
laika:简单的Python GNSS处理库
04-20
Laika是一个开源的GNSS处理库。 Laika与和等项目相似，但是在Python中，Laika非常注重可读性，可用性和与其他优化程序的轻松集成。 Laika可以使用从各个分析组在线收集的数据来处理原始GNSS观测，以生成可用于位置/...
GNSS在线数据处理系统对比分析.pdf
08-15
#资源达人分享计划#
GNSS原理与应用
01-20
1.GNSS中美国GPS系统与中国北斗导航系统在定位原理上的不同之处？ GPS定位的基本原理：根据高速运动的卫星瞬间位置作为已知的起算数据，采用空间距离后方交会的方法，确定待测点的位置。目前GPS系统提供的定位精度是...
GNSS各种时间转换函数(Matlab代码)
11-06
有关GNSS时间系统转换的函数，涉及的小函数有： leapyear;norm_doy;doy2ymd;ymd2doy;ymd2mjd;doy2mjd;ymd2gpsweek;mjd2ydoy;sod2hms;hms2sod;sod2how; GNSS时间系统博文：...
GNSS时间转换工具
03-31
GNSS时间转换，支持utc,儒略日，gps时相互转换（源于GPSTK）
时间系统以及各GNSS系统时间的转换关系
x1471898145的博客
03-17 6333
时间系统 恒星时和太阳时都是以地球自转作为时间基准（或时间频率基准）的，区别在于量测自转时所选取的参考点不同。 恒星时 以春分点作为参考点。由于地球自转使春分点连续两次经过地方上子午圈的时间间隔为一恒星日。 由于岁差和章动的影响，地球自转轴在空间的方向是不断变化的，故春分点有真春分点和平春分点之分。相应的恒星时也有真恒星时和平恒星时之分。 真太阳时 以太阳中心作为参考点。太阳中心连续两次通过某地的子午圈的时间间隔称为一个真太阳日。 真太阳时不作为具备一个时间系统的基本条件 平太阳时 设一个假太阳，它和真太
本科生学习GNSS算法 中级教程（三）- rtklib多系统多频单点定位算法 - 多频残差计算以及新增配置
dong20081991的博客
08-30 910
rtklib多系统多频单点定位算法 - 多频残差计算以及新增配置
TAI与TDT的转换（经过stk检验）
算法小站
11-02 902
%×××××××××××××××××××××××××××××××××××××××××××××××× % TDT = Terrestial Dynamical Time. Was used 1984-2000 as a time-scale of % ephemerides from the Earth's surface. TDT = TAI + 32.184. Repla...
GNSS测量与数据处理复习资料（1-5）
weixin_44765473的博客
12-29 3662
GNSS测量与数据处理复习资料 文章目录GNSS测量与数据处理复习资料一、GNSS系统概述1、GNSS定位原理（1）距离测定原理（2） 点位测定原理2、GNSS系统组成（1）GPS（2）GLONASS（3）Galieo系统（4）BDS系统（北斗系统）二、GNSS时空基准1、概念理解2、GNSS时间系统及其相互转换关系三、GNSS卫星轨道1、开普勒行星运动三定律2、广播星历、精密星历以及历书概念3、卫星的无摄及受摄运动的概念4、卫星坐标的计算方法四、GNSS信号1、导航电文概念2、GNSS卫星信号的构成及调制
GNSS时间时区转换
SUGO1993的博客
04-28 1310
GNSS时间时区转换代码说明代码讨论 代码说明 一般情况下，从惯导设备或者卫星定位获取的时间都是以英国格林尼治时间为准的，即时区为0。而我们使用的时间一般是北京时间，即东八区的时间。所以要对GNSS时间进行时区转换。 对于0:00-15:59时间段的GNSS时间，北京时间直接在hour上加8即可。但是对16:00-23:59时间段的时间，还需要考虑当前的day是否为每月的最后一天，当前的month是否为每年的最后一月以及当前年是否为闰年等情况。 代码 参数说明： GNSS_Year：GNSS时间中的年 GN
GNSS原理与应用（三）——坐标系统与时间系统
unbiliverbal的博客
02-11 6575
测绘小生关于《GNSS原理与应用》中时间系统与坐标系统的笔记整理与个人拙见。
时区缩写备忘
weixin_34336526的博客
02-17 246
公司在很多国家有分公司，分布在不同时区，收藏一下，免得老是搞晕。 时区缩写： 标准时间代码 与GMT的偏移量 ...
【GNSS】单点定位程序总结 二 时间系统模块
小马甲的新马甲
02-05 820
宝藏就在这里，就看还在上这门课的学弟学妹能不能发现了 时间系统模块 1.1儒略日 时间定义与表示 儒略日（Julian day，JD）是指由公元前4713年1月1日，协调世界时中午12时开始所经过的天数，多为天文学家采用，用以作为天文学的单一历法，把不同历法的年表统一起来。如果计算相隔若干年的两个日期之间间隔的天数，利用儒略日就比较方便。 在程序中，用结构体JDTIME表示儒略日时间，结构体定义如下 1 2 3 4 5 6 7 .
GNSS 处理中的时间系统
最新发布
06-09
在GNSS（全球卫星导航系统）处理中，时间系统是非常重要的。GNSS接收机接收到卫星信号后，需要通过对卫星信号的接收时间和传输时间进行精确计算，才能确定接收机的位置。因此，为了实现高精度的定位，需要使用高精度的时间系统。 在GNSS中，通常使用的时间系统是GPS时（GPS Time）或GNSS时（GNSS Time）。GPS时是由美国GPS系统所定义的，而GNSS时是由其他全球卫星导航系统（如俄罗斯的GLONASS、欧洲的Galileo等）所定义的。这些时间系统都是基于原子钟的计时系统，具有非常高的精度和稳定性。 此外，由于地球自转速度的不均匀性，以及地球自转轴的漂移等因素的影响，需要对时间系统进行一定的校正。因此，通常还会引入UTC（协调世界时）或TAI（国际原子时）等标准时间系统来作为参考，以保证GNSS定位的精度和稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值