GPS，UTC和本地时间的显示器

[复制链接]

XinLiYF 发布时间：2018-3-7 20:34

文章
文章封面:	-
文章简介:	-

GPS，UTC和本地时间的显示器

转载来源：GPS，UTC和本地时间的显示器

GitHub仓库：http://github.com/XinLiGitHub/GpsUtcAndLocalTime
PS：博文不再更新，后续更新会在GitHub仓库进行。

   GPS，UTC和本地时间的显示器。程序中涉及到朱利安日期的转换，详细介绍见维基百科[Julian day](http://en.wikipedia.org/wiki/Julian_day)。

1，开发环境
   1，操作系统：Windows 10 专业版
   2，IDE：Visual Studio 2015 专业版

2，程序源码
   DateTime.h文件

/****************************************************************
; ^5 ?$ M) Y# {4 g4 R
* Copyright (C) 2017, XinLi, all right reserved.
" @- b% W4 ]! z( i! c8 G
* File name: DateTime.h
& F0 t0 e, I' s2 b
* Date: 2017.10.17) M2 |+ R/ _' Q. b- a0 B s; p
* Description: Date and time module header file.
6 G( b% R& f( [9 a
*****************************************************************/. T! J, ~& O( G0 q
/ |4 b( m) x b2 M4 _
#ifndef __DATETIME_H
#define __DATETIME_H
( @6 n# _+ ^* E7 w+ g' P$ l
5 _4 [2 Z" T j g5 x/ x' c! g
/****************************************************************
$ X( M8 m1 M i+ U7 o
* Header include1 |! k1 \8 [( h
*****************************************************************/; x+ |% E# h; c
# C8 `) s8 V3 G6 e- I7 _
$ t2 }" ~0 [! _) e
/**************************************************************** a7 i; n. j: }* L
* Macro definition8 z6 H' A$ m" u, m9 n
*****************************************************************/
4 W2 Q" a4 W2 `, g: {! B& I. v
& k* g& i& r9 T8 S y3 J% W+ _1 X
! |3 V+ S1 Y! X; O
/****************************************************************
* B1 b4 d6 E) c) {
* Type definition: o( ?2 D) U% I* B
*****************************************************************/0 x; g0 F2 X6 w; |9 j, q
- \2 u! {$ j$ ^* S
1 u4 p$ w4 c9 m
/****************************************************************& H. d( S3 o3 n4 M s; `" Y
* Structure definition' l! j! x; z; A2 W
*****************************************************************/: ?8 q5 c% H+ J3 O
typedef struct1 k0 A. Q/ ?5 q4 b' y! y% r9 J5 c7 r
{
- M5 \1 G( `% u) s4 g) c6 k
int year;9 b2 c- ?$ ~ o) d+ T
int month;
) ~0 V5 H: P' N) i& Q3 T" ?1 t# f T
int day;
1 R- Y8 M" N' O" {
int hour;
: u- W3 }8 k7 l2 J
int minute;1 E0 i" n9 i2 s* Y
int second;8 K- ?% b! j! E3 ?$ x! p6 _5 i
}DateTime;
. U7 a. R2 h. r+ N4 ?
+ Y M, ^6 I/ |- I" ?3 H. p
typedef struct( |0 U/ M$ Y- d: T2 {- J
{
i' g! [% L# ?; O4 ]/ z3 j; k$ O
int week;% v( U& l; s3 U2 y6 O, C) x, O i& j
int second;2 P( o6 w9 }) R# V% C7 D
}GpsWeekSecond;% ?5 |" e0 T+ c3 C8 m. y! q* H
- Y5 i1 A, f. E! @* i8 a' y8 p
8 O7 ~3 C9 v$ a: z
#ifdef __cplusplus% l3 G/ P5 l5 p f1 U
extern "C" {
6 M$ y: d. m3 b! b; @0 T, A
#endif /* __cplusplus */
2 _5 _1 J: z2 W
6 u& ]- a8 Y% ]9 X
/****************************************************************" O) s2 _7 Q2 T4 ]( H; k
* Variable declaration2 a# q' t* G6 m M2 L
*****************************************************************/: U# k* V% t$ E- Q6 M
* B( f) q4 W$ j" U+ Q H0 B
5 i( I: W( `# s
/****************************************************************8 J B! t" g2 }, x9 V
* Function declaration7 t# @- s. O, M5 B5 O8 o0 v6 i' F
*****************************************************************/
# `2 Z/ [: s5 l/ ^) v- G
DateTime GregorianCalendarDateAddYear(DateTime time, int year);, F s. t ~5 u6 O6 c
DateTime GregorianCalendarDateAddMonth(DateTime time, int month);
$ @% \: y1 \: S' C* x' l
DateTime GregorianCalendarDateAddWeek(DateTime time, int week);' i9 U' w) \( F& f+ Y
DateTime GregorianCalendarDateAddDay(DateTime time, int day);. y9 b$ Z1 ~' x
DateTime GregorianCalendarDateAddHour(DateTime time, int hour);! E& ]8 _. |4 \9 ~/ @
DateTime GregorianCalendarDateAddMinute(DateTime time, int minute);
. W# i0 |; g3 Q _- ], ~
DateTime GregorianCalendarDateAddSecond(DateTime time, int second);9 B. U0 ^8 E+ {# U5 D# Q
GpsWeekSecond GregorianCalendarDateToGpsWeekSecond(DateTime time);
! Y0 P) K8 L% d
double GregorianCalendarDateToJulianDate(DateTime time);8 m1 w. |1 q% ^
double GregorianCalendarDateToModifiedJulianDate(DateTime time);6 w" Q" N6 F. X
GpsWeekSecond GpsWeekSecondAddYear(GpsWeekSecond time, int year);% a/ T, |1 q* O! K
GpsWeekSecond GpsWeekSecondAddMonth(GpsWeekSecond time, int month);
* ?# l0 M7 T$ K9 @
GpsWeekSecond GpsWeekSecondAddWeek(GpsWeekSecond time, int week);
3 q5 R) r2 N7 [0 ~/ |" E' V
GpsWeekSecond GpsWeekSecondAddDay(GpsWeekSecond time, int day);, G) ?4 V: ^0 d2 ]7 F' ~ b1 l4 z
GpsWeekSecond GpsWeekSecondAddHour(GpsWeekSecond time, int hour);
* r" J! G& L' `
GpsWeekSecond GpsWeekSecondAddMinute(GpsWeekSecond time, int minute);3 ?6 D$ `* h, M9 Z7 v% E
GpsWeekSecond GpsWeekSecondAddSecond(GpsWeekSecond time, int second);. N4 ~9 ^; |$ b. d* C$ A' k' ~
DateTime GpsWeekSecondToGregorianCalendarDate(GpsWeekSecond time);( X& k; \3 P* M' V+ L8 f
double GpsWeekSecondToJulianDate(GpsWeekSecond time);
- i% H, C( I! s( S6 A
double GpsWeekSecondToModifiedJulianDate(GpsWeekSecond time);8 L. ]' ~* g' F3 ~( w. n+ W, ]
double JulianDateAddYear(double jd, int year);
4 g9 y) e0 z, J1 \' ]$ ?
double JulianDateAddMonth(double jd, int month);3 N: o! \' [& i9 `1 ?( @& m
double JulianDateAddWeek(double jd, int week);
* v0 c/ i( n4 |3 ]1 J( g
double JulianDateAddDay(double jd, int day);; O9 o6 V8 Y% P" U( Z9 k
double JulianDateAddHour(double jd, int hour);
W* q5 a$ L& N0 _1 U$ M# ]
double JulianDateAddMinute(double jd, int minute);
. w% _ v/ W! R6 R; }
double JulianDateAddSecond(double jd, int second);. @, a8 r. C, e, e% B$ G( Q
DateTime JulianDateToGregorianCalendarDate(double jd);+ d, Q) q+ J. t2 M# q" u2 P# D6 v
GpsWeekSecond JulianDateToGpsWeekSecond(double jd);
0 D; [$ w% R" r, _8 [9 E7 s0 d! e
double JulianDateToModifiedJulianDate(double jd);2 p- L' [* I1 @ d4 Q
double ModifiedJulianDateAddYear(double mjd, int year);
0 r$ ~! Z! O; A
double ModifiedJulianDateAddMonth(double mjd, int month);
' Y _3 I! y+ C$ ^. k8 O
double ModifiedJulianDateAddWeek(double mjd, int week);
; n' ] x/ D9 f& u$ Y
double ModifiedJulianDateAddDay(double mjd, int day);
/ S o0 h1 s( Z. a# S3 g) \
double ModifiedJulianDateAddHour(double mjd, int hour);1 D5 r& e' i+ y3 P4 r
double ModifiedJulianDateAddMinute(double mjd, int minute);
( E- I4 x; N$ N* o
double ModifiedJulianDateAddSecond(double mjd, int second);
7 d# q8 n4 q% t' E' e) A1 y$ h
DateTime ModifiedJulianDateToGregorianCalendarDate(double mjd);
: c, g: F9 u% J) \8 O
GpsWeekSecond ModifiedJulianDateToGpsWeekSecond(double mjd);- u9 N& g* q3 V' j, o5 {0 U0 p) C
double ModifiedJulianDateToJulianDate(double mjd);
* {9 T& H" A/ f# }2 B6 k
( U+ r" L# M {* t: i6 b& a B
#ifdef __cplusplus5 p f) k* D# g
}
/ C) y; p/ V; k g
#endif /* __cplusplus */( u' s! p+ @" R" m# g7 O! s
3 r1 E6 ^8 y! B
#endif /* __DATETIME_H */0 T1 d9 Q" q' N% d- W' I. A @5 M

复制代码

DateTime.c文件

/****************************************************************
5 ]# h: Z% Q7 q. E9 {) _" a; s
* Copyright (C) 2017, XinLi, all right reserved.
2 f. B& t$ G$ N; K0 R! j- ]
* File name: DateTime.c
6 ~4 L" q) [, p- ]* n0 i
* Date: 2017.10.17& _5 R# m m" }4 d/ s
* Description: Date and time module source file.
" n' b4 j |: Q/ J
*****************************************************************/
$ K5 u, S; |! K( N6 h
4 ]+ H8 b U* q3 D% b3 G* q
/****************************************************************
6 k7 w: J% Q7 b# ^5 ]1 J
* Header include" v5 I- J9 C' _1 h! L4 W: ^
*****************************************************************/! ^ x. k; F: S. Y
#include "DateTime.h"
# b3 B; F' R. P% H
8 Q2 }5 C# n+ N# h; l$ r( m2 w
/****************************************************************
& j4 B( g- @2 _& x8 O* K
* Global variables
4 A- J, c }4 o0 a" M# l
*****************************************************************/+ J# O1 K9 m" u# ~
& l R8 H$ c4 V) N: ]4 U
! k' n$ @& c2 B. r2 K& t
/****************************************************************
/ K' |. o- _9 E# t5 }& y/ F9 L
* Function declaration* L( ?# B: L/ l
*****************************************************************/: H1 K) X. q0 C* {9 B$ a5 l) b
% |4 t# L9 {# d r
& g; E4 ~5 ?5 V# ]7 r
/****************************************************************
- L- _+ S" C$ A. x" L4 y: F) G) V
* Function definition( c& _. G& ~# e; X& P
*****************************************************************/
! n0 H' R& i6 ^: Z) x
, s" K+ N+ X* U
/****************************************************************. r3 i5 ? ], f; ^
* Function: GregorianCalendarDateAddYear
+ @4 q! W. L/ s( h: z' m
* Description: Gregorian calendar date add year.# Q* v* Y9 J1 b; M _& o7 |: u
* Input: time: Gregorian calendar date.
E. r! A) U3 N; ^
* year: The number of year to add.
0 L1 i" v) a" x4 z" P2 m
* Output:+ k! b' s$ Z! k& ?
* Return: Gregorian calendar date.
: X# N2 |0 u) I4 N/ \5 z2 F. t% r
*****************************************************************/
2 d/ y% l& I. @3 e" {
DateTime GregorianCalendarDateAddYear(DateTime time, int year)5 b) }) R) \& Y" @. P- {
{
$ D% z$ P8 |2 ~- d8 l
time.year += year;
0 n0 U4 A/ s- l# L! k: b
9 w6 Q, i- k! E- B* n! S- x4 N$ z# y
if(time.month == 2)8 ~. j& K9 b. O; J, @% `
{& E4 P; X z3 d/ M
int mday = 0;# c# }: W2 x0 N# y3 Y
6 I% j4 x% o9 X9 Z, I4 l
if((((time.year % 4) == 0) && ((time.year % 100) != 0)) || ((time.year % 400) == 0))
$ Z$ L( ]& }; B( \0 W, ]/ ~# O
{$ h: C' A$ u' ?
mday = 29;
3 v6 `4 P! s5 {, R
}
/ G) |# D% ]. O7 N. D' ~! }+ I- m
else& j- |9 B- q2 J, U9 U4 ~; F. C; S
{( Q; S, b: }0 V3 b% w9 ~
mday = 28;
3 P. y& ?. [& O* ~- n% N6 R
}
( }- }7 d. V+ p# R
8 A2 ~5 W, R6 q$ c x
if(time.day > mday)" \0 r8 Z' G9 M- e6 U
{
% W! p3 l- I. t; g8 X( c6 u
time.month += 1;
4 n! j Z$ F( |1 Y: t0 |
time.day -= mday;! |! Q* H( a( p) B& f* k3 _
}
. \ Z( k9 U4 q# _& o2 f! Z( H% s
}
& z6 I* a6 ]5 r
7 a, B+ y+ Q/ V& I2 w
return time;; ^% Y3 K' L- F; F: V
}
5 A+ `' Y, i: k) ?5 m2 F
7 R0 g$ m7 Z/ D5 C
/****************************************************************- `. O' h' j6 \1 U0 h2 T, ]" o
* Function: GregorianCalendarDateAddMonth
, a; U6 r+ J% s* q" A
* Description: Gregorian calendar date add month.; q1 ]0 A! p; ?' w B4 [- }3 z: H+ M
* Input: time: Gregorian calendar date.
' O, g, W% v/ J/ V) w; n3 Y
* month: The number of month to add.
! {) R) W7 o+ M4 D2 y/ A8 p" A
* Output:
2 Z/ B9 x5 j# p" E, A" _2 \9 g
* Return: Gregorian calendar date.
& C5 P2 b1 P" K" T- W+ X
*****************************************************************/, a# q( J$ `5 k/ J% l4 k8 F2 @, u
DateTime GregorianCalendarDateAddMonth(DateTime time, int month)( f" h- {0 [4 g* n
{' z4 w9 A9 ~3 I4 y9 s0 M
time.year += month / 12;+ a7 a' w) y5 s d/ ^
time.month += month % 12;
6 j" N9 a6 p' D) q: p' L! |+ r
4 f0 m! o$ I" d9 q
if(time.month > 12)
. r0 \" c! W8 {, i5 F* }
{( Y- |: k; X( _6 l) m M; J, B
time.year += 1;
1 j1 W1 l' g: n6 ]
time.month -= 12;
; Q b8 l. R& D9 U* w
}/ C: @! E& s- Q$ O4 l9 v7 W: L. r
8 J- u! \, i D8 e) T9 D# E% i( ?
int mday = 0;
* t5 a& I0 }* r: M
' r$ a1 d( e" I# B" C
if((time.month == 1) || (time.month == 3) || (time.month == 5) || (time.month == 7) ||7 i5 |* y* F2 `! D( u* ]
(time.month == 8) || (time.month == 10) || (time.month == 12))% u9 k" i' S) e5 @5 _0 `* L. D
{
6 Z* ^" o! x& O9 r
mday = 31;& _' Y" e& O+ X! E
}
/ [+ ?/ b2 F. f' [: J
else if((time.month == 4) || (time.month == 6) || (time.month == 9) || (time.month == 11))
. O4 R3 Z& Q' X/ X
{
$ [1 j, b; }- |2 N! Q L( ]4 ~3 a4 V
mday = 30;
1 d# X: Z( u! U, E W6 L$ M
}
- x3 F4 \2 {2 c! O0 {
else3 }4 v! K) ^, G2 _7 F/ z( h
{
1 O7 u1 `8 ~' j2 b
if((((time.year % 4) == 0) && ((time.year % 100) != 0)) || ((time.year % 400) == 0))
1 k" `* N4 b2 C" `
{( @$ [5 z: \7 s8 |3 y1 P
mday = 29;: i+ x. Q3 F' k5 u
}
9 z, ^$ S: G# } R7 B
else
/ @+ b3 ?% c: {2 i$ K9 n% M( ^+ H% [
{1 [ p' i" _0 \- c
mday = 28;& p' x0 w. }! g, @& r4 a" M% O6 _
}7 O/ N% R# a; Z P* U% T3 a
}) F' l4 x/ ]' p3 j! A' J
6 a" B; C/ g* \
if(time.day > mday)
. L C9 a, G4 B/ }& v
{
2 P" c! J( @% Y
time.month += 1;
* u# |; ]! {$ O. j% }# @6 a
time.day -= mday;
B( w8 x# _' q
4 \9 I& ^0 \. I( V
if(time.month > 12)3 g$ |9 S M. x% c0 x
{8 }8 d2 Z; B: i* V- h
time.year += 1;
6 l1 W" C' F& _3 F L
time.month -= 12;
( Y7 i1 i9 {6 W4 `
}
. M* x" s7 L6 Q6 T
}
( P- c$ h5 J5 M/ j
+ _: {6 b$ D! G
return time;
2 x3 F) ]2 C; w( R
}
8 C* B) J: F3 G/ g9 i6 {& ~' `
" i/ ^+ @% h! M% {9 y; q" @) T" d
/****************************************************************$ U9 I5 r ~% X
* Function: GregorianCalendarDateAddWeek
; R7 n% t) p. w3 w9 K7 R& D
* Description: Gregorian calendar date add week.6 n+ d2 m: B7 i! C8 g
* Input: time: Gregorian calendar date.
3 p) |+ I7 h+ W6 \
* week: The number of week to add.
$ b& q7 U* Z! |$ s
* Output:
+ h, z5 l3 ^" }. A) O8 c% ^
* Return: Gregorian calendar date. } T0 L* d' b$ `
*****************************************************************/ D3 I2 d) H* F' `4 B! Q; a7 S7 V
DateTime GregorianCalendarDateAddWeek(DateTime time, int week)
* T! U i! P) k1 v7 O
{; ?, e1 I1 \+ ]% I2 N9 A/ m
double jd = GregorianCalendarDateToJulianDate(time) + week * 7.0;
/ e9 A2 V+ v* R/ h7 ~, P# m! r
+ F; X. i1 j! e. ~4 G
return JulianDateToGregorianCalendarDate(jd);' z/ h# Q1 H: b% c
}1 n4 l, I: Y& B
+ O$ l4 I: b, T/ X
/****************************************************************7 C3 v u$ _& E5 s& A
* Function: GregorianCalendarDateAddDay/ A7 t- ~ f( i7 j
* Description: Gregorian calendar date add day.
0 V" n3 y! @% Q; Y# o9 P! A, U
* Input: time: Gregorian calendar date.9 x* i4 D' ^4 ~& J% ^" \$ X& c
* day: The number of day to add.
1 ]$ C# ^8 ?. H' u' K6 |
* Output:, }# a4 q$ N( B9 I, }' i
* Return: Gregorian calendar date.
1 l7 w9 L; M6 @4 C
*****************************************************************/
?3 ]: k4 v$ F' W! b! h) q% j4 p
DateTime GregorianCalendarDateAddDay(DateTime time, int day)" G5 W+ q4 b- m( u; s4 r) @
{
2 T& ?: {: i" S" @" D, O% h1 f. ^
double jd = GregorianCalendarDateToJulianDate(time) + day;* k& W& k2 J: }& d9 {2 a" V. Q$ a# N
1 R* I, z' C) q- s0 c3 R& H
return JulianDateToGregorianCalendarDate(jd);$ A- ?& k+ m( R% q
}
9 T' d b/ a; t! I
4 k) j7 r7 ]/ W' ] |
/****************************************************************4 z7 g4 v4 F4 i2 E. x. u
* Function: GregorianCalendarDateAddHour- H0 E* H1 O6 m7 r
* Description: Gregorian calendar date add hour.
# [- P l9 X0 M$ ^8 [; Z: q
* Input: time: Gregorian calendar date.
1 { o# P( |7 P y1 \8 _
* hour: The number of hour to add.
9 [" V y8 P t' E% H* x8 S
* Output:6 J5 V1 C$ B6 Y4 P9 B. k
* Return: Gregorian calendar date.6 a0 i' D3 }( ^
*****************************************************************/
' j; y! b' \* l x: ~
DateTime GregorianCalendarDateAddHour(DateTime time, int hour)' i+ P; P, U3 Y) s- ~4 x
{, j, k7 R5 ?5 L/ R0 J. }
time.hour += hour;
4 T; b7 s& _9 q, C, v* v0 Q
0 x" M, T7 ?+ N. f+ R0 ~
double jd = GregorianCalendarDateToJulianDate(time);' x b4 j" i+ b
# |+ g# j9 \" L% d' V
return JulianDateToGregorianCalendarDate(jd);
6 l; v5 C; s' ?1 u
}
! H; ^9 P8 S# _$ P" U
/ V( V7 a% u4 _3 w$ m
/****************************************************************
: _ Z% E/ p% W5 |; ^( [2 \
* Function: GregorianCalendarDateAddMinute
1 p& ~9 K( s7 h0 n
* Description: Gregorian calendar date add minute.$ ~8 b0 j2 {5 Q" V6 y& y9 ?& }7 }. l
* Input: time: Gregorian calendar date.: S K+ b- A- P0 h7 W5 O$ o6 w
* minute: The number of minute to add.+ N6 x: P- o/ o& Z2 i
* Output:
6 d/ |; o/ P9 y! P# B# s; u
* Return: Gregorian calendar date.6 e* J/ D: o9 ?# O7 |9 I( Z
*****************************************************************/4 s) ~1 E5 l% T' Z0 K' X+ D
DateTime GregorianCalendarDateAddMinute(DateTime time, int minute)% C- O9 ^! v) }7 S3 e
{" R) M- w% v- j; c% A( c3 _
time.minute += minute;0 O: \/ O' H. D& }
7 c, [: _2 f3 |# ^
double jd = GregorianCalendarDateToJulianDate(time);8 E* }- Z* |0 I
; v4 h9 a; U- m% n& i6 G" d8 Y7 O
return JulianDateToGregorianCalendarDate(jd);: c9 l7 Z# M) F8 k8 }5 X# {+ B
}: B* S$ ~9 U8 X- G: V
: X1 p9 e9 r, p
/****************************************************************
' b& |3 g1 J1 e4 K) I. `2 `
* Function: GregorianCalendarDateAddSecond3 ~! V; K) r% ^+ S
* Description: Gregorian calendar date add second.
& s/ \6 j4 @6 z0 v( c
* Input: time: Gregorian calendar date.
: p/ x X8 Y C
* second: The number of seconds to add.
* Output:
2 `! u6 T* f6 a: W6 a
* Return: Gregorian calendar date.) p ~2 H4 B {" u& F x) @8 M
*****************************************************************/' ]& S2 M. }& A
DateTime GregorianCalendarDateAddSecond(DateTime time, int second)4 X* M2 U: Y* S* N/ z
{' b3 K! ~2 H! u* v
time.second += second;
8 ~0 c7 {, @9 L9 v# K
- _% T# o2 f& }0 j( }
double jd = GregorianCalendarDateToJulianDate(time);" y% H9 M. X0 [9 x1 ~- j" j
8 e, B7 V9 {% a! X
return JulianDateToGregorianCalendarDate(jd);6 @ P7 _' x5 D& s5 w
}
, B: @( T z$ V+ t
0 q5 C A4 d0 V8 ?2 r3 k
/****************************************************************
; J" X" ^, `- Y) {8 C1 i
* Function: GregorianCalendarDateToGpsWeekSecond7 b c) F I5 `; P
* Description: Gregorian calendar date to gps week and second.$ o [( C3 f; c
* Input: time: Gregorian calendar date.
8 F/ q& K' t) q; E
* Output:
* C: l9 a. d/ n: a8 ?
* Return: Gps week and second.& G! O2 Y$ u& J! d+ Y, `7 O
*****************************************************************/7 K2 q) K3 @, L) S, f% M1 z
GpsWeekSecond GregorianCalendarDateToGpsWeekSecond(DateTime time) h b- R2 F% @: K& X* k
{
/ v* V& D$ p3 }7 L9 K
double jd = GregorianCalendarDateToJulianDate(time);/ w$ f% q& M/ ]+ _- f ^, }7 N6 t
" b& A& v. m7 u, q' U& [! @ j
return JulianDateToGpsWeekSecond(jd);
4 y- M# R2 s+ W) ~, x
}
0 @! M7 F# R/ ^, J) Z, y; f/ d
* b/ G; W5 O3 \$ l+ Z
/****************************************************************
. P/ Z4 P5 }9 ?
* Function: GregorianCalendarDateToJulianDate) w: ]! _) U8 o
* Description: Gregorian calendar date to julian date., X) S" K8 @ ?) h
* Input: time: Gregorian calendar date.
- @' c f9 f$ @8 T9 h; y- O
* Output:
- l3 v# S9 p' _
* Return: Julian date.
9 ~6 S ]: D" ^# g+ p6 |
*****************************************************************/) U6 f7 p9 h! ~4 E
double GregorianCalendarDateToJulianDate(DateTime time)
1 g6 P* R) o& E5 T1 N9 y( f" e% x
{5 ?* p, _1 }1 I: K
int jdn = (1461 * (time.year + 4800 + (time.month - 14) / 12)) / 4
4 V/ j1 n3 e2 j1 v/ M
+ (367 * (time.month - 2 - 12 * ((time.month - 14) / 12))) / 12
' `& G6 L% }* x7 C6 P1 j, p
- (3 * ((time.year + 4900 + (time.month - 14) / 12) / 100)) / 4; n2 `& J' @* M
+ time.day - 32075;1 e; g2 {) B+ ]6 G" D+ L
1 J Y# ^. x E* W' S5 V* U
double jd = jdn + ((time.hour - 12) * 3600.0 + time.minute * 60.0 + time.second) / 86400.0; O; z5 n3 c3 T u9 |
' s3 P; J T: W! T4 q8 Z
return jd;4 Q* E6 w8 E% M: N' K6 t" Z. q. U# g% t+ x
}/ U0 |9 J, b6 @9 w$ O
' m' L9 h `+ s
/****************************************************************3 d5 `2 |* c9 Z+ M& ^; g" Z
* Function: GregorianCalendarDateToModifiedJulianDate
/ D2 ?6 c' Z, u* _7 B8 c
* Description: Gregorian calendar date to modified julian date.4 s! P; \4 T6 x7 k
* Input: time: Gregorian calendar date.
$ v* v4 }0 y' K9 r) G
* Output:
) l, e- t( @0 c" R+ w
* Return: Modified julian date.. ?) w8 x z: C
*****************************************************************/
5 h4 T ]7 t+ Z" \0 @9 X6 z: b
double GregorianCalendarDateToModifiedJulianDate(DateTime time)
1 B: u( q" s' F4 E1 }4 X
{
8 N& L7 w' G w' G( p/ M
return GregorianCalendarDateToJulianDate(time) - 2400000.5;
' T/ A& \7 {+ K
}1 I3 a' g0 B$ |" d: @: @3 Z" f- {% P
; B( M* u) G7 {4 H0 R- W8 j
/****************************************************************# H, V r3 ?' [* f5 m6 N* a& |
* Function: GpsWeekSecondAddYear2 f3 o5 r& b3 a, p( r
* Description: Gps week and second add year.
$ b4 h3 b% l7 T" i
* Input: time: Gps week and second.
e1 w M5 k' C' i0 h4 r# G
* year: The number of year to add.0 a ^+ z- ]5 A/ L% b! b
* Output:2 H' t2 t2 w2 T J' j/ p' n9 L
* Return: Gps week and second.* d+ s9 q8 _* `, e n7 C9 H
*****************************************************************/
" V# O3 ^2 n( C
GpsWeekSecond GpsWeekSecondAddYear(GpsWeekSecond time, int year)
& @. x" D) [+ Y2 f0 Y' Z( D
{7 e) n! u0 _+ k! A) A$ M7 ^
DateTime date = GpsWeekSecondToGregorianCalendarDate(time);
- x6 v9 l9 y* k: J
. x' i* Y( f0 q, v: Q
date = GregorianCalendarDateAddYear(date, year);2 X( V" Z' O" L, j
" V: _9 G. ]6 |4 p3 p: f
return GregorianCalendarDateToGpsWeekSecond(date);6 x( G/ @7 s- r. Y5 P) t" z y
}
$ L& r- k( h2 ]( D6 F# Q. i" z/ L
$ w/ J) Q& H3 k5 X/ Q0 N2 n1 T6 H
/****************************************************************' j) R; P9 d2 d1 m3 E$ T+ n. ? b
* Function: GpsWeekSecondAddMonth
3 B2 z. ], W. n- O
* Description: Gps week and second add month.
3 o) S' X- t7 z* P- Q9 f
* Input: time: Gps week and second.
( c7 H( t! J9 z3 K2 g% S4 r
* month: The number of month to add.
+ ^3 _/ ^% E. h0 q; z7 K
* Output:
% J8 ~" x. A# s" U& Z
* Return: Gps week and second.
/ l4 I3 F% \( R
*****************************************************************/$ h4 u9 V. C5 g. s
GpsWeekSecond GpsWeekSecondAddMonth(GpsWeekSecond time, int month) \5 O3 i2 W5 ?5 Y4 e
{
1 D7 K5 M6 i& ]9 x, Z$ T
DateTime date = GpsWeekSecondToGregorianCalendarDate(time);3 I4 [3 K5 I: T7 B
. H5 L) T0 r: z. `5 ~9 t
date = GregorianCalendarDateAddMonth(date, month);: R$ I2 S# x; Q4 q% h4 W/ i/ R
4 W. O3 I0 |4 W7 E$ s) T
return GregorianCalendarDateToGpsWeekSecond(date);0 f) K- U/ S$ |. W( k
}
8 @* a5 B2 ?$ D) Z+ @4 o% Y2 D
, A) d. i, O S
/****************************************************************
: z# B# u+ P1 A# _0 {
* Function: GpsWeekSecondAddWeek0 Z" l% K0 [4 j1 p, W
* Description: Gps week and second add week., i$ k h: V! z7 h
* Input: time: Gps week and second." m1 ]* L' F: j7 a
* week: The number of week to add.
. m: D* M' I; S. D' ~
* Output:8 y# Z3 e( W" }2 O
* Return: Gps week and second.( p$ y" _$ K/ ]2 N
*****************************************************************/
, x! l$ i" R& u4 B& p/ T3 G1 {" h' Z# x
GpsWeekSecond GpsWeekSecondAddWeek(GpsWeekSecond time, int week)2 [, K2 R* |1 C7 K; M
{
+ g+ J8 T6 X/ l+ I1 `* R$ a. }
time.week += week;& H9 T! O% L4 ^4 L0 {
' K" A2 |' F) d* j, `
return time;
! C% s9 C! r, K4 S% K" h
}
8 s: R; y. K2 z& G b: \& j+ s. c
- U1 `. E8 |5 Q) V5 T3 b
/****************************************************************9 A! s: V- t& g, |& x. T- c6 p* n
* Function: GpsWeekSecondAddDay1 G3 V4 L6 B! Y% h2 u% o
* Description: Gps week and second add day.( k9 k% K: [; H3 r
* Input: time: Gps week and second.
1 E& V: x# Z/ }
* day: The number of day to add.
7 W* a) e" ]4 n$ J6 o. ^# z
* Output:0 H, f& B4 r. K4 i3 o
* Return: Gps week and second.. J! e' W+ S; C$ T" C8 R
*****************************************************************/
1 X1 R- i# \8 u9 e
GpsWeekSecond GpsWeekSecondAddDay(GpsWeekSecond time, int day): k) ], m# a/ R+ s3 k& w
{3 N9 \( I0 m. D! v u
time.week += day / 7;
; Y1 J6 a p0 I3 A1 t" L4 R* l
time.second += day % 7 * 86400;( U# @2 d# q0 L1 x0 u, ^" w8 y+ z
: [6 E9 `5 }: \& ^% L) ]5 z
if(time.second > 604799)
( `# _" L6 e2 {0 D2 l$ C* {
{
, W) A% X k: V/ }$ a
time.week += 1;0 y; a1 n9 h9 E; w9 F9 c2 f
time.second -= 604800;
5 o( n5 f0 E# z# n4 o# x3 t2 }, c+ u3 n
}* h3 z7 L8 K6 A% _9 ], ~4 p
$ a8 ` _2 h% ]' h
return time;
7 z% M _+ a0 G- W" F, m
}& s, p K4 v4 n1 ]7 o
3 O' U' v9 H/ c' W9 A- ?9 Z2 w
/****************************************************************
* h/ z8 P+ [4 N9 {" F! R# Z; M5 H
* Function: GpsWeekSecondAddHour/ Q3 T# p/ D6 D2 a/ U1 G/ t
* Description: Gps week and second add hour.
5 W. Y6 ^* z1 a V3 E2 H" E2 a; T
* Input: time: Gps week and second.
' z+ X& e2 Z1 m9 j
* hour: The number of hour to add.
/ z8 U4 w" B* p1 G# S3 F( O) F* \6 b' {
* Output:; \: B) I4 }6 G3 X2 W- [: z
* Return: Gps week and second.
9 B% `6 @+ n1 E/ Y6 a" k# ?" O
*****************************************************************/
8 i5 ^ G4 O+ J# T3 {/ J8 L
GpsWeekSecond GpsWeekSecondAddHour(GpsWeekSecond time, int hour)
9 F2 \; b# k6 h- e4 R Q( k
{
2 N5 }$ b- q+ \2 W( C: J3 G
time.week += hour / 168;
n2 `6 U+ y+ f& Z" R6 B( g
time.second += hour % 168 * 3600;. S, ?3 _ ^! ?. I5 Z) [1 D
' g! a, k( U! k/ V, P3 M3 z
if(time.second > 604799), _) x+ O% i* w3 u1 x
{
; u, @0 j( z4 v* a# X% K
time.week += 1;
4 @, H9 ~+ ]4 e. j& k
time.second -= 604800;! D2 ?& u2 o% U; e
}
; b: ?- L$ H- v
% ]; u( W3 i$ }4 K
return time;
1 Y! y7 H3 I, n7 S
}
# f& {+ L; l1 T% K, ~
, h& b+ \2 e+ \; E* u8 R( M( o
/****************************************************************
" `3 S, {5 @7 n7 ^! V- z' C
* Function: GpsWeekSecondAddMinute/ X& i Z" D: i# C S
* Description: Gps week and second add minute.
- S$ c4 N6 x# w- g# b5 m4 s
* Input: time: Gps week and second.
. J4 d# B( d- C3 A8 P7 G d3 ]
* minute: The number of minute to add.$ p0 [/ f3 M) R% k& Y* a
* Output:- A% Q" W0 m2 @
* Return: Gps week and second.0 Q. u% u# h" N O0 r: ~
*****************************************************************/* }& p( q9 x( b6 R
GpsWeekSecond GpsWeekSecondAddMinute(GpsWeekSecond time, int minute)4 \# g5 s( L7 I
{
7 s: ]2 p9 e$ a2 b1 }" o
time.week += minute / 10080;
- E% L& ?) o- H. X& J
time.second += minute % 10080 * 60;
6 F% @5 G0 f; i1 B
! Z I/ ]+ B( K* C# ]$ @4 |
if(time.second > 604799)4 f a% n: u3 @' f3 a
{0 b% G9 U8 P2 x* T( u$ \# W
time.week += 1;
/ U& e \9 z) {8 B/ @$ l$ X
time.second -= 604800;
' \1 r/ G# l) N" z3 Z
}* ~, `! c, I- h* K- X A- W
) W5 J I% Z3 Z" U* M
return time;
4 C% _' N: [# m3 f. k" h! ^
}2 h0 |: ?4 s: R) s3 {' l% I
! D1 ~7 |5 O& l( \
/****************************************************************
( l7 p% Z9 u9 E* L* |
* Function: GpsWeekSecondAddSecond
1 `6 ^- _- {6 \+ M) s
* Description: Gps week and second add second.- _7 ^& `" X6 a% f* E
* Input: time: Gps week and second.) K( B( P( O% N. P) T
* second: The number of second to add.
( _. y6 Z- }" C" g$ R0 s
* Output:6 P5 d% }1 F+ V- m6 }
* Return: Gps week and second.5 T2 c# W B, b+ Y& u$ d
*****************************************************************/
P' E' Q% P1 S! t5 @
GpsWeekSecond GpsWeekSecondAddSecond(GpsWeekSecond time, int second)! J8 D+ \" g2 L3 ^( X9 f, A" Q
{
& W2 h+ y% j- c
time.week += second / 604800;
; s Q1 K. {7 i* n' R/ u) i8 T
time.second += second % 604800;
' O* I( J5 A8 c5 R: }% w% k* o
; B" h; p* O5 a: v0 Q9 j/ N% o
if(time.second > 604799)
! Q/ H j; {) V( w7 l" B$ o
{
9 {. `* u4 X, _- E. [# I; b
time.week += 1;
) \) Z* h: C4 U; Z1 {( _+ S$ n1 |. W
time.second -= 604800;
# q" u' C- y( j: P: t6 M9 L
}
4 M$ n8 O& Q5 b7 a5 X; z
% f9 n0 T- |& o; R/ g
return time;4 C7 e" n+ \; r+ c- A" f5 U
}
* y% K( v( I! M- ~1 `
/ y0 r! Z! u7 t1 ^' ~# R0 O, s
/****************************************************************
6 q5 \0 b8 \* u
* Function: GpsWeekSecondToGregorianCalendarDate m! m2 S0 ]4 F
* Description: Gps week and second to gregorian calendar date.
; v8 W) ? c! M( }: a( {
* Input: time: Gps week and second.
. c% M) L$ N( k6 ~- j4 R8 s
* Output:2 M! ~ C# ~3 }# P7 G" f
* Return: Gregorian calendar date.
, V' p7 x3 F9 D; T8 {
*****************************************************************/* k3 b& E) ~0 E; ]2 g% e
DateTime GpsWeekSecondToGregorianCalendarDate(GpsWeekSecond time)$ D" D" ]& g" {$ n
{) `5 |1 T7 H {2 K/ k# q/ Q9 h
double jd = GpsWeekSecondToJulianDate(time);- T) j0 r4 W1 X9 r8 I
5 k" q+ v! l6 z0 P W7 x0 w0 U& D8 ~
return JulianDateToGregorianCalendarDate(jd);
$ u5 C, q8 m9 Z- k+ G% M
}0 M# V( V* T, s+ p8 Q
* S: G, V; w8 g+ N
/****************************************************************
! s2 V& q5 ~* m/ L( E# y+ C
* Function: GpsWeekSecondToJulianDate
% }+ h" y$ s' b/ V* G/ B; W" X
* Description: Gps week and second to julian date.( V8 B7 E7 A+ V/ M# ?
* Input: time: Gps week and second.
5 f% a) O. A4 @
* Output:
2 D6 c. u: }6 S* p
* Return: Julian date.. ]& g# W0 [3 |
*****************************************************************/9 A' @' Z( x" {+ m* j
double GpsWeekSecondToJulianDate(GpsWeekSecond time)
6 Z2 ^7 p# Z6 M+ O3 P! m. a' U% c
{! g8 F1 D. [6 e. [
double jd = 2444244.5 + time.week * 7.0 + time.second / 86400.0; A, |- y7 p [/ y
' I1 r) X0 `: d
return jd;
+ A" ^0 V4 A" O+ M0 e2 P
}0 M- [" m6 z0 r2 j
7 M3 B, F- l- W( ]$ o
/****************************************************************
/ q+ m1 Z. D& p p
* Function: GpsWeekSecondToModifiedJulianDate
7 G* K+ i; z# m1 U' H" ]. q4 S
* Description: Gps week and second to modified julian date.) T# {$ E. Z! w- p
* Input: time: Gps week and second.
& r4 |9 k8 F- s4 o) z" H
* Output:5 @; ]! s$ x0 B7 t A8 R
* Return: Modified julian date." T' T% h* M/ U; z7 U9 D
*****************************************************************/
# l) z, T- W( }. a. P7 `- y# C
double GpsWeekSecondToModifiedJulianDate(GpsWeekSecond time)% h3 z7 u5 C' q% W* W4 t
{
, _! S- B2 I& C" V: w7 _3 e$ J
return GpsWeekSecondToJulianDate(time) - 2400000.5;
; o, y5 y( e0 o0 I" A4 f
}) J9 o$ f. R b. c* [- x `
/ R0 e+ K9 l% v+ T
/***************************************************************** z% G5 W7 S3 J4 A J
* Function: JulianDateAddYear
" f7 X; m4 s0 I5 q- i8 a* ]6 S* B' r3 Y
* Description: Julian date add year.* m% \/ h. w% e" ]6 a
* Input: jd: Julian date.
* year: The number of year to add., L8 U* `1 g& D6 n
* Output:
' ?* D3 g h1 m+ ]
* Return: Julian date., z- [; u) L0 m! g& [
*****************************************************************/
7 M5 e) [8 i, \
double JulianDateAddYear(double jd, int year)
' V" s P. |2 \" i& }* m( Y% f
{% k& X! m2 O: W3 ~3 i; S3 X7 R( ~( V
DateTime date = JulianDateToGregorianCalendarDate(jd);% l% {7 K( c9 s3 O( N* C6 M
6 t1 d7 k6 F6 r, R; ?9 j1 f9 X0 I
date = GregorianCalendarDateAddYear(date, year);
8 F; A; L: D. d3 y7 `
$ E7 q, B: B, ^/ P+ F
return GregorianCalendarDateToJulianDate(date);
. ~% S3 P& l- M
}3 {. d+ s! _: q( y; ]3 H
* u+ g. n6 W$ S- ^+ T% A
/****************************************************************% }& V2 }6 D4 I; Q# P3 x/ @, o _
* Function: JulianDateAddMonth
. @8 L7 B5 x3 n
* Description: Julian date add month./ {, y# L s6 q/ e2 R/ e, X
* Input: jd: Julian date./ O8 ^! `1 A2 o- g
* month: The number of month to add.7 X0 K) ^0 Y+ y3 ]/ R: V
* Output:% }5 e0 M9 V9 g- ~
* Return: Julian date.
7 j' @( m. Z0 k- Q
*****************************************************************/
# g) E: ^/ H2 s i! {
double JulianDateAddMonth(double jd, int month)
% I7 U) \% R% ?( Z$ q
{
9 P+ V9 k, R" i% g+ ?: K
DateTime date = JulianDateToGregorianCalendarDate(jd);
$ W$ x% v# ?0 v
2 s$ `9 I( i, z( ^; t$ s5 j/ M# B3 }
date = GregorianCalendarDateAddMonth(date, month);+ F* P& i7 g& @, b( @. g
: l( L, E4 K- z1 d* Z, @
return GregorianCalendarDateToJulianDate(date);
% _/ r3 l% r3 P! J; K
}
: e! p2 a5 v! t6 U# B1 `' l+ b+ ]
8 E& r) b6 N' q% c: n! n
/****************************************************************
5 }& V5 ]) P; c0 s5 z
* Function: JulianDateAddWeek J- t6 x, N( D
* Description: Julian date add week.
9 o5 ]8 t+ L F3 L @
* Input: jd: Julian date.
9 M* i. V! O% x) O& ^3 a
* week: The number of week to add.7 C5 h2 p" y% @% q0 ^
* Output:
" u1 C+ g. F# M3 e" V3 C
* Return: Julian date.- J* a6 Q6 n3 v& o! C
*****************************************************************/" y/ Q" n# N9 ^$ ]
double JulianDateAddWeek(double jd, int week)
+ W/ e7 @; v; J. p
{
2 @- ?: @- p- _) h- _& [
jd += week * 7.0;
- n% \0 u3 i" u) s" e9 A( P
* v1 n9 v; x8 o! s+ I& Z/ n: z
return jd;( I; l3 {0 J9 t& b+ z7 H
}$ r: h" t) M: H) d) t3 Q; y
0 t/ c! @9 T0 ]$ ?6 Q& W! N# @) M
/****************************************************************8 [& `& k' f. l6 s! `
* Function: JulianDateAddDay
5 N$ W, K# Q+ r. V* L2 ~
* Description: Julian date add day.
6 ^: b5 ` u% Q3 C, S1 d6 c$ O
* Input: jd: Julian date.
* Z6 d6 B4 c8 @
* day: The number of day to add., U9 ?# T) }! e' W2 {' B
* Output:
* z2 S$ A+ I& b
* Return: Julian date.
4 ], q- f6 h, f X' x
*****************************************************************/6 ^7 u$ l0 ?" B k
double JulianDateAddDay(double jd, int day)
7 W8 I1 j7 K' d) n$ J: y
{
; s, |& M2 Y8 g2 T9 d; O
jd += day;! S. W- ^1 }, X& a
4 D8 T0 B W4 a' P& T; Z4 ]9 v
return jd;
, O9 T; V V0 W" t8 b7 l Z& Z8 E
}4 I0 {7 W$ w# v* v9 N; [( F3 e6 F
/ ]- ^" i- N- s! c% w6 p! L
/****************************************************************
! _- x; D4 Z& v7 v4 r7 Q
* Function: JulianDateAddHour
/ y: X# V, {4 ~( l0 Q" H
* Description: Julian date add hour.
( E0 @; p& s9 i! k4 `
* Input: jd: Julian date.3 y+ L4 J# K2 b7 z T
* hour: The number of hour to add.
& g9 x+ D+ F. e& R# a* H
* Output:# `' |9 n% j' H) d0 d4 @
* Return: Julian date.
8 Z9 p0 _$ ]5 [) X' r, c( g5 `
*****************************************************************/
K) @; N) K! j7 O/ e
double JulianDateAddHour(double jd, int hour)3 B" N; L" V3 p2 | E$ ?- J
{1 ^1 R- F3 ~' p% k8 @5 c
jd += hour / 24.0;2 R! T% p8 T" L: j) i- v6 y! Y1 X0 M
6 Y- B; j) e4 V* F1 V e- D. r/ D
return jd;& Y# @1 N: {9 s$ Z
}% H# {0 h9 q* k# {4 W* H3 Y4 q
# \$ F2 y$ |* z- |9 M$ L
/****************************************************************( C" @" z, |9 n5 G' e$ S
* Function: JulianDateAddMinute7 @" t8 ~& }# i: ]2 ~8 d4 i
* Description: Julian date add minute.3 q3 A$ I8 ?0 Q: N% v+ m
* Input: jd: Julian date.' X' y0 o5 s6 J+ ]3 X
* minute: The number of minute to add.
) Y; O, U3 c7 d9 Q
* Output:! ~) [: \4 r! g
* Return: Julian date." @9 U. z9 `) l- n1 ~
*****************************************************************/1 z; b0 {- B- T, p5 Q9 \
double JulianDateAddMinute(double jd, int minute)
9 }; X& M [( x" J3 E- h( H: O
{
8 E) u3 ^/ ?. r/ V& n. h) Y
jd += minute / 1440.0;
5 [/ G) w6 _3 E3 @6 X
9 B. j$ I& T' I4 G
return jd;
2 m+ A0 }( J% I
}
) W' e. Q+ i0 n1 ?2 {6 K" `
& R# M) P* t& N3 b
/****************************************************************0 n6 x% |6 Q3 p& w
* Function: JulianDateAddSecond6 {2 \4 `) U& O9 O1 E
* Description: Julian date add second.
. u9 ^: q$ m4 Y" o% o; C
* Input: jd: Julian date./ X/ b( E" U4 ]7 C: c
* second: The number of second to add.
- V, e, `7 J! b. U- p4 d
* Output:2 V7 h% J5 a k+ T1 @8 R; M7 ^' S5 B' H
* Return: Julian date.
" K% H' x( {, Y) f1 j. d3 O
*****************************************************************/2 D5 S# F" w0 y7 {- _
double JulianDateAddSecond(double jd, int second)
* v$ H( ], N2 q! k2 H( i, V
{7 k* J- _5 G$ L$ C' j5 q8 X6 y
jd += second / 86400.0;
" a G# k& D/ G$ E
$ z, ?. H' e' i. W. ?3 P
return jd;1 ]1 s) Z- ^) Z( n2 O& Z* G
}
% P5 M9 l5 X$ q; x
& @) ^# W; C- a
/****************************************************************$ }( P: I2 I( X' }4 m2 C9 g
* Function: JulianDateToGregorianCalendarDate @* Z+ t0 [. a/ a: \# Z- ]
* Description: Julian date to gregorian calendar date.
! z7 }! h8 R* o/ R
* Input: jd: Julian date.4 r7 L& b9 Q: n+ Y `6 F
* Output:! `# f5 Y. r: ? h4 Y8 x
* Return: Gregorian calendar date.# [1 i; o3 E+ C8 Z& o4 P" R5 p+ P
*****************************************************************/2 D; M/ Z0 c( r+ x- Z2 f1 b
DateTime JulianDateToGregorianCalendarDate(double jd)
/ v0 K7 a1 H( z" W6 }/ `* I& z; T
{
+ ], q* v* b0 L" U5 a
int y = 4716;/ V+ N G. z7 S3 @% c/ O& l
int j = 1401;. E6 L/ A) J: g$ o0 F
int m = 2;
4 {: c$ E, f7 k4 M" p' P
int n = 12;3 }) b; ~$ D# V9 @0 v
int r = 4;& J7 O3 k& Z1 o: M: r. W# m
int p = 1461;
p+ y' a* B3 q, R& s
int v = 3;" x) E) \% ]# ?! W, q: T
int u = 5;
0 {- ]9 b2 I! R
int s = 153;
( U+ P+ W7 M2 j4 \/ H
int w = 2;
% i1 K& N2 X2 U9 ?7 ]: f) z
int b = 274277;
4 @" l# A; Z2 r5 N# q
int c = -38;; f6 m/ Q2 K1 K' o
% R9 P) Q% Q4 C; r
int jdn = (int)(jd + 0.5);* u; `- Z. F7 K0 ?5 Z
int f = jdn + j + (((4 * jdn + b) / 146097) * 3) / 4 + c;
( {( k( ~7 _) a, x9 r: [( N6 q
int e = r * f + v;1 J. r1 @ E- O
int g = (e % p) / r;
$ w( N3 ]' Q% @1 d; [
int h = u * g + w;1 g3 f! F+ p/ F) R, H
$ Q! S: `) W" Q2 }4 N/ d5 q7 \
DateTime time = {0};2 l* G" ` A) ^+ U4 v' `4 R# b z
3 {# o+ F2 Z: q' h# b
time.day = (h % s) / u + 1;3 ]( {: G3 M- a! W1 U
time.month = (h / s + m) % n + 1;
: C( n1 t7 N1 D9 i9 x% Y9 D
time.year = e / p - y + (n + m - time.month) / n;9 h. V! r# z# ~9 {* A3 a3 l( }
time.hour = (int)((jd + 0.5 - jdn) * 86400.5) / 3600;+ _5 L/ }; ?, s# I- }
time.minute = (int)((jd + 0.5 - jdn) * 86400.5 - time.hour * 3600) / 60;2 \1 g' ]% t/ ~0 x$ }' c% h4 s/ _1 ~9 s
time.second = (int)((jd + 0.5 - jdn) * 86400.5 - time.hour * 3600 - time.minute * 60);) G' e5 D2 ^! p0 q
" Z `: O* {6 |' j" Q0 x& i$ S
return time;
. Y6 ]: k! L' V8 V- B# A2 D! [
}8 p# R' m) S4 [, ]+ z( z. s
5 d4 z9 l: A0 T$ C
/****************************************************************3 ^' b, L1 U2 I0 ^1 Y/ V4 d
* Function: JulianDateToGpsWeekSecond
; \1 ^8 O" J* F1 F
* Description: Julian date to gps week and second.
m, C1 {9 }$ Y0 E5 q r! j
* Input: jd: Julian date.
F' O4 g+ |- q8 P+ B, ?) Z/ M+ |
* Output:! q# {0 b& w" \ l
* Return: Gps week and second.
% H" j, _- ~" s8 C* w
*****************************************************************/6 X! s! ?" O6 H6 E5 `4 |; m
GpsWeekSecond JulianDateToGpsWeekSecond(double jd) p% ], v4 Z& P% K8 }
{
1 {& n. }# o7 U W
GpsWeekSecond time = {0};
6 V- B3 w4 _9 B& c
DateTime date = JulianDateToGregorianCalendarDate(jd);
" I% P' u1 \1 x! O% g; [
: y& l' T' c2 _" G6 I& M. L& l
time.week = (int)(jd - 2444244.5) / 7;
$ I" `9 Z; k l F2 V* O
time.second = ((int)(jd - 2444244.5) - time.week * 7) * 86400 + date.hour * 3600 + date.minute * 60 + date.second;
) H: ]% A( E8 [# }- w
/ y9 ?: Q# R! S7 J1 a5 [# W6 p
return time;
% V1 l( D) h/ i% m0 h( N
}0 P6 M9 K) ~7 u! @+ C& R3 C
% B( r C7 b$ X& x9 G4 P, h* O6 ?
/****************************************************************
: U4 a( r0 m& g$ F3 s" @. {- p/ a( z
* Function: JulianDateToModifiedJulianDate
5 D, ^2 E, l- F5 w# P2 H
* Description: Julian date to modified julian date.
3 u8 D6 C% u' ~- a1 M
* Input: jd: Julian date." [! R0 V/ z% t
* Output:0 M+ y8 z" w! v! Y* |
* Return: Modified julian date.
( B8 ]8 E4 J; W2 _0 a' d4 T2 u
*****************************************************************/
( W/ f8 Y Q6 z Y5 w5 D- Q# W1 n
double JulianDateToModifiedJulianDate(double jd). Z+ y7 u9 }, [$ c7 t
{
! ~: a, W1 v& f, h ?3 n1 f: }# r+ ~
double mjd = jd - 2400000.5;
1 Q- L3 G5 Q7 I4 d" k8 k
* {6 `; @! D o/ U
return mjd;( `8 b ?. s( I6 d- Q
}
4 q& q7 _4 u! A* l
" |0 I0 n: C0 z. k( B
/****************************************************************4 I) Z6 g; f- T- z
* Function: ModifiedJulianDateAddYear
% Q/ U8 L+ {+ x- ~- ~
* Description: Modified julian date add year." t5 @* |/ c1 c1 [
* Input: mjd: Modified julian date.
$ s. X; O. j1 V" f; i0 L
* year: The number of year to add.
* f4 E }; G2 B4 S: w
* Output:
; l+ Q" T3 R! O
* Return: Modified julian date.2 A# M4 i/ ~# `- F( J
*****************************************************************/% m- G: q+ n* h8 j) ]3 n
double ModifiedJulianDateAddYear(double mjd, int year) _, t' i- l! L5 M
{/ A' W6 K# C9 H Y; X# i7 `5 e% d
DateTime date = ModifiedJulianDateToGregorianCalendarDate(mjd);# u: L M: h' Z& q& }
f+ V. n( L1 H- ~4 _: [0 o7 q
date = GregorianCalendarDateAddYear(date, year);
, H; }! O7 ]4 t# F8 g8 E5 j0 c, A
* V) r" g- {+ M# o- X
return GregorianCalendarDateToModifiedJulianDate(date);
+ M/ _+ ^& ?1 a* o' c$ q& y
}% J" O3 @2 J$ j* x1 {. i
* j3 o3 j3 l( c+ q" ~
/****************************************************************
) r6 i' o9 _/ |& x9 J9 p: ?8 k, }
* Function: ModifiedJulianDateAddMonth' ]5 @- M4 h* i2 |& m3 u5 Z0 j
* Description: Modified julian date add month. ?; V6 m5 r% Z; I+ m
* Input: mjd: Modified julian date.
8 r1 ` Z& [! `2 F0 X0 `
* month: The number of month to add.
+ I. S+ x; J3 h( g) E
* Output:
( I( X8 _6 x% E* N8 l
* Return: Modified julian date.
( _3 E" Y- r) f
*****************************************************************/% v: e0 E& o6 }9 B
double ModifiedJulianDateAddMonth(double mjd, int month)1 [( M6 Z6 i( K/ ~; l
{! }6 b' H( p% n( A ~+ l& [8 C
DateTime date = ModifiedJulianDateToGregorianCalendarDate(mjd);
" T- C/ |! o0 v
Z) v' q: f4 N1 x: U" r
date = GregorianCalendarDateAddMonth(date, month);$ {# Z0 N+ ^0 D1 ~2 j: ]
! W% o1 a V7 t' o* U& y7 s
return GregorianCalendarDateToModifiedJulianDate(date);
) K4 Z, _6 o9 F' `
}; n' s7 Y0 t8 m9 e" z0 ^
6 Z- c1 F# ]/ f# [! A* v
/****************************************************************' T1 y! \* h' A/ c2 R* i: ~
* Function: ModifiedJulianDateAddWeek
' C8 L$ `0 U- b9 {- [: ^
* Description: Modified julian date add week.: O# D8 A1 k7 K6 {5 G& A
* Input: mjd: Modified julian date.
* V* _; J& o0 i1 a: _+ s6 {
* week: The number of week to add.- U* Q, J. D& [" ]
* Output:
# @ K# t+ N; ?
* Return: Modified julian date." G4 d, e3 s$ L5 Z+ j
*****************************************************************/$ k( p0 G) q: m# B
double ModifiedJulianDateAddWeek(double mjd, int week)
$ E4 Y+ f% \/ X" \5 V! K
{
, ], @7 b1 K7 W& }2 L, F$ @
mjd += week * 7.0;% R: h1 o1 X: `" w% q0 p
7 u7 }" {- l" g' I$ v
return mjd;
" H, h: `& Q" t( ]/ {: J" z9 y( Z, i6 R
}
9 x' Y" Y+ f! H( x5 w
' y5 e0 c1 F( _" n. W% Z
/****************************************************************( i# _2 F4 x+ G c: V3 ]
* Function: ModifiedJulianDateAddDay- X' C% F4 M" M' B
* Description: Modified julian date add day.
" b) J% q) u% V2 Y0 V0 P
* Input: mjd: Modified julian date.
1 d1 c8 Y3 M9 G+ f3 h+ F
* day: The number of day to add.0 u. Y3 @( {1 A% v9 Y
* Output:7 T L. p( v a: o8 a
* Return: Modified julian date.
0 s! C3 N/ h4 x) s# ]3 i
*****************************************************************/
; B) b& I x/ j. I& G* e% `$ m ]
double ModifiedJulianDateAddDay(double mjd, int day)
. F0 Q# X) Q/ M3 K$ F. D
{
, y2 c% |& ^) T# M9 @/ B1 z
mjd += day;) U2 W0 j7 W. Z
; E& D$ K' u7 V4 s- ~( ~$ K/ w$ m
return mjd;! J0 B, j1 \. ?0 M0 _
}& ?8 A# t, `) e; A( G6 v4 n% l
+ c, V3 ?1 a, s
/****************************************************************, e# l: p) _; v4 w1 b, M
* Function: ModifiedJulianDateAddHour+ O. D+ d9 Z0 ]- ~6 S! I" i1 n) ]
* Description: Modified julian date add hour.
. U. ? C! L/ r, H: g7 [
* Input: mjd: Modified julian date.5 {* _# n. e) u" n
* hour: The number of hour to add., r. Z' u6 ~6 A
* Output:. m. ?. f& x' ^& k6 h0 T. g8 ?
* Return: Modified julian date.# q! j6 g! j! L- P7 ` Z4 ]: n1 P
*****************************************************************/
4 l+ ~( s1 N' G/ n; V1 ^. \& f$ M
double ModifiedJulianDateAddHour(double mjd, int hour)
8 V+ Q+ e% P/ Q) x- B, Z
{
i; o/ E" L- i; ]0 v6 {
mjd += hour / 24.0;
; y5 x/ S; p" m
$ H! u) C2 v X1 P z2 L+ m2 H
return mjd;
% o3 o. ]! a# p9 _- B
}
! K0 h4 M- R8 b, x9 V
2 T& j* J; f- r0 z5 b3 C
/****************************************************************
+ T+ o& _; D5 l7 s# w
* Function: ModifiedJulianDateAddMinute
1 f: A* ^6 |; ~# x- {$ c
* Description: Modified julian date add minute.5 b, c# \$ t. G$ z! l
* Input: mjd: Modified julian date.0 I- ~3 ?: Y- s9 [2 {6 o& S9 x
* minute: The number of minute to add." }" g# c: \7 n8 }. o$ K
* Output:
' q N X% I3 R( T# v
* Return: Modified julian date.2 E x' E: [: a1 h! A
*****************************************************************/
T( I" ~# l7 M! g
double ModifiedJulianDateAddMinute(double mjd, int minute)
5 p2 |! d0 s) T! {+ R& ]5 Q
{0 z K4 Y6 t2 F! p
mjd += minute / 1440.0;' |5 m3 N* ~% ] |6 z+ y1 z( |
& p6 M9 ^# @8 ~5 k# _! ?: ~
return mjd;
% m3 d+ X) b* g( N
}
) \. H" G O0 J* p. z! Y
. b# z7 y6 W3 C
/****************************************************************
6 \6 p; e3 z/ U8 Z" R
* Function: ModifiedJulianDateAddSecond& V% @7 M0 @+ H% E& g, M! m, ^
* Description: Modified julian date add second.; X1 ^5 B$ t f; a" N6 @
* Input: mjd: Modified julian date.: Z# F/ q. _! D) g
* second: The number of second to add.
; c/ d) g; d! U' b8 R" k7 M
* Output:' G9 t3 D1 ]7 F9 [
* Return: Modified julian date.7 S9 R/ h! B/ m8 ^9 Y3 m/ K+ f
*****************************************************************/6 L" H1 O0 r) W7 Y) c
double ModifiedJulianDateAddSecond(double mjd, int second)
" _8 W7 u% }+ ^2 R; {! Q% |
{; {% {* D; n2 k
mjd += second / 86400.0;5 V+ G K: E) m5 F F, p* X
+ k. T) W7 ]! @2 A8 H) ^; b
return mjd;- l3 m. s$ p% L8 b# _5 U# l2 E6 u
}3 ?$ q$ D- I$ M& o. Q- |
" ~1 h0 _4 R' R; N* `# |8 l9 D
/****************************************************************- {& [1 _, w- H
* Function: ModifiedJulianDateToGregorianCalendarDate
- H" z) W/ Q4 @1 e5 D
* Description: Modified julian date to gregorian calendar date.
, @, o& S, p: h* q. U
* Input: mjd: Modified julian date.
) m$ U9 @! q/ f8 E5 I9 {
* Output:
; s; ?" J( o$ Y
* Return: Gregorian calendar date.
+ u$ x9 g: i5 [. P% Y
*****************************************************************/
& f; G5 N! B r7 m) H, _
DateTime ModifiedJulianDateToGregorianCalendarDate(double mjd)
7 X4 K8 V, o7 D
{
* J) R9 r; K) l0 U3 A* t' c
return JulianDateToGregorianCalendarDate(mjd + 2400000.5);
; m3 c B- H# e' u' C
}
; q$ g6 @! n. N; {: a8 o. H! L/ J. R
$ |! t, e0 r( _$ H' B0 s$ l2 G" _
/****************************************************************& C5 Q4 P( m/ c2 Z3 T
* Function: ModifiedJulianDateToGpsWeekSecond1 O! M: K$ Q% r5 v7 c$ s9 m5 V8 W+ x
* Description: Modified julian date to gps week and second.
/ v& u8 e% q _5 L
* Input: mjd: Modified julian date.
; s9 |( c* n- U
* Output:! ]2 B Q* w3 Z1 S8 B/ j
* Return: Gps week and second., X7 |5 W# w$ x7 w& s& V
*****************************************************************/
; {1 n% ?' Q$ ]; E4 ^) w
GpsWeekSecond ModifiedJulianDateToGpsWeekSecond(double mjd)+ L. g' U# z/ f: T8 E
{
, r: I- j. M2 r2 D' P2 v
return JulianDateToGpsWeekSecond(mjd + 2400000.5);
; K: p. C: J1 \4 h$ J
}
# x; L- A1 u1 q) Q; u6 \
! W5 h& a4 V" e$ c6 Z. ?, ?# h$ Z- Y
/****************************************************************
8 J: _ D8 m0 @- d/ x4 }# q
* Function: ModifiedJulianDateToJulianDate
4 A+ \0 N' X% q$ i* @6 Q" q6 p- X
* Description: Modified julian date to julian date.5 J4 V/ ^* r0 M. F$ r$ E: M# F- D
* Input: mjd: Modified julian date.
% a& t2 I% d/ f9 p' h! x9 Q! D! C
* Output:$ R5 |4 n/ Z+ `, r+ R4 k
* Return: Julian date.
/ G) ?! k7 X6 k: e& o u
*****************************************************************/
( ?1 @: g% G0 s* ]" c
double ModifiedJulianDateToJulianDate(double mjd)
9 @8 h5 Y3 l: h# a; [* i& Z% M9 e
{
. W4 `2 m4 V8 v. n4 M9 ~
double jd = mjd + 2400000.5;. `' y- M; f" w- e, |2 D
. V* Y0 e8 W- i: \( ]0 G% e6 I! N
return jd;
+ B. ?6 |3 }9 G1 o$ k
}
& x/ C- i$ t. _. t& X' Y! y( T" v

复制代码

main.c文件

/****************************************************************$ l4 g; T& X6 q) Y- Y! {
* Copyright (C) 2017, XinLi, all right reserved.
2 T/ ?( ^" T- ]; K1 I; ]( e2 h
* File name: main.c
3 I: i0 ^$ y4 e4 A5 a
* Date: 2017.10.17) L {2 D: J' t
* Description: GPS, UTC and local time displays.
5 Y9 w* t( z9 c
*****************************************************************/8 T' r0 o5 F0 y2 l. g7 l
* N9 M8 s% s3 x
/****************************************************************7 \; u1 E3 x. q) h; z7 c
* Header include
0 c8 q( z, C" }0 ~0 v- D3 V* U+ e* c
*****************************************************************/
; }" y1 t& I+ `
#include "DateTime.h"
+ I3 U4 ~# Y6 o& @7 B
#include <stdint.h> p, l7 q/ J Q: U% |7 J+ X$ d- K
#include <stdio.h>
2 d! s$ m; t! L7 d7 y# r7 z
#include <time.h>5 Z8 _2 d0 ]7 I; A% Y4 w# V3 N3 w$ t
#include <windows.h>
+ g a! m* n0 Z1 U
4 H f5 U" B& M+ L6 s" q* h
/****************************************************************
' X8 F6 ?6 F4 g# W$ C- X. f
* Global variables5 E0 S& B& B# _3 Q) X+ K5 \8 o7 ?
*****************************************************************/
6 ~2 X/ y4 D* ^3 r
1 ]4 R" i% M; I) E. H
/ U+ E8 t, Z6 O. f- a! W$ n
/****************************************************************
; I: ?# T( [5 |. D) X p r0 ]- |
* Function declaration
! Y# ?) k. k4 X" l: {5 y
*****************************************************************/
7 B9 L$ N ~% ~" M& w/ R6 X
static void gotoxy(int x, int y);
# k7 \& U+ C3 j# P# \4 F& N
* R; O7 s9 v& m% V' i) o6 S Y/ D
/****************************************************************
. h5 g2 s# `( n' o5 N
* Function definition: Z2 h8 @% J3 f" b' {& j& Z8 v
*****************************************************************/5 z: v n3 ~) \9 y
+ U2 H' w8 p- y1 A3 [; N
/****************************************************************
+ @/ b- A6 C4 K6 G) k J; g# I
* Function: main( e" \, k5 L8 N
* Description: Program entry./ ]; c) b% \2 O- d# l/ N0 _" A) Y
* Input:
9 b D7 c4 p5 b5 l8 y* C
* Output:, W! X7 {& H/ N) l3 x
* Return:0 \, i/ _5 T' R* e/ Z
*****************************************************************/
$ ^ i7 M+ f* p3 |2 J- r) U
int main(void)
$ Z# G `" Y- v5 K" X
{$ B5 w6 D, D+ b; r0 }
for(;;) I5 S4 m/ x7 N1 M% [( \
{
7 L3 |+ x, c8 t! b& v
time_t times = 0;9 D4 N' Y% [; d+ L$ V4 d
double mjd = 0.0;7 _; Z8 E1 k/ D" }- f$ t: Z
DateTime utctime = {.year = 1970, .month = 1, .day = 1, .hour = 0, .minute = 0, .second = 0};6 Y. f9 y2 W5 r8 y5 t" y1 w7 q
DateTime localtime = {.year = 1970, .month = 1, .day = 1, .hour = 8, .minute = 0, .second = 0};
& O# ?( @' n, K1 \6 l" s3 }9 q! R
DateTime gpstime = {.year = 1970, .month = 1, .day = 1, .hour = 0, .minute = 0, .second = 0};
8 j, D( I0 @* O1 B. q
GpsWeekSecond gpstimews = {0};
, J& |; R; Z, z! C
( ~& O3 R% C2 {5 c: C- S3 B" S. e# y
time(×);
/ y' K* ^2 B' W
; \) b5 ?# G; H. O t- V7 @! p
if(times > INT32_MAX)1 f: _ v7 f& L1 u. t
{. E# `! u9 M6 e
utctime = GregorianCalendarDateAddSecond(utctime, INT32_MAX);& e6 u" f9 y/ s5 }6 {# [
utctime = GregorianCalendarDateAddSecond(utctime, (int)(times - INT32_MAX));
, _5 Y1 |; X! U4 ]6 d/ K
}, X9 \( r( @+ f' u; X- D& _
else
$ [% d0 m# E9 k/ }
{
) ^8 [3 \7 F: m# i, z( j- E
utctime = GregorianCalendarDateAddSecond(utctime, (int)times);0 R- G( _) r) o; `9 m
}
% |: H% {) q& {% F
* M8 o5 Y9 H. v1 O W0 B: b
mjd = GregorianCalendarDateToModifiedJulianDate(utctime);; l( J$ N" E1 G8 {6 o
localtime = GregorianCalendarDateAddHour(utctime, 8);, x9 F* ^7 M, d
gpstime = GregorianCalendarDateAddSecond(utctime, 18);
; v. `. i8 Q2 P/ w" O
gpstimews = GregorianCalendarDateToGpsWeekSecond(gpstime);5 X( i) h4 G2 f# f: \$ _. {- M
9 Z& Z5 G% \7 r
gotoxy(0, 0);
( }) q! O, a; o* J9 d# @
$ |, F# w3 @$ v* T1 z
printf("Local | %d-%.2d-%.2d %.2d:%.2d:%.2d | timezone UTC+8\n",
: C& o9 V0 Y1 H; U
localtime.year, localtime.month, localtime.day,: J# k# t7 K. g" y$ D& I5 b- m" j
localtime.hour, localtime.minute, localtime.second);% n3 D: I' s! R: f) V- n
# ^! y4 t5 \7 J) W: _7 C1 A
printf("UTC | %d-%.2d-%.2d %.2d:%.2d:%.2d | MJD %.5f\n",% k1 s( @* p i' D, w
utctime.year, utctime.month, utctime.day,
* D( z& e, V/ I2 f: o
utctime.hour, utctime.minute, utctime.second,1 [0 t+ z" m4 @
mjd);/ h) M& i4 J2 s* j
8 d- h2 a' Z) g3 X @9 |
printf("GPS | %d-%.2d-%.2d %.2d:%.2d:%.2d | week %d %d s\n",* _* p# B8 H a
gpstime.year, gpstime.month, gpstime.day,3 C6 F- `- `: D- {% m
gpstime.hour, gpstime.minute, gpstime.second,
0 T: Z+ N2 S2 c$ m' ~
gpstimews.week, gpstimews.second);
2 {% y- B4 M, [# F
. `, F3 Y# V( C. `" X, d; B! O) k
Sleep(100);
5 b2 }( q; s6 e! @# G
}' Q c, V' n7 D; Y
}3 D0 j# _+ C/ u+ ] P; B; @
. x7 @9 l9 S& f
/****************************************************************
- g% e& T! D& o
* Function: gotoxy
; R, R9 c* ? v8 u
* Description: Move the cursor to the specified position on the text screen.. c, z7 p: ^2 \; a) W
* Input: x: X axis coordinates.
. {5 s. M6 d9 V2 W& ~; i
* y: Y axis coordinates.
; W2 y& g, F- |7 z7 l7 O* Z
* Output:
% W) M, d* U% |6 H" U
* Return:5 [, \! ^+ x5 W. K
*****************************************************************/& K1 B. j7 G1 p0 n
static void gotoxy(int x, int y)
+ Z" r2 }9 d3 E A+ _& P
{
2 x$ G3 a# Z0 M/ V' s# a1 I/ l
COORD pos = {x, y};
+ S2 R0 F2 [% I( v/ K- _/ }$ Q; G
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
7 F* n0 B: N; L4 ]# H, K1 L& D
SetConsoleCursorPosition(hOut, pos);
0 `* Q7 M0 }0 p/ ~) y2 O
}
6 W @& x! I) C) n+ {8 t; q