你的浏览器版本过低，可能导致网站不能正常访问！
为了你能正常使用网站功能，请使用这些浏览器。

st-img
chrome st-img
firefox st-img
safari st-img
ie8及以上

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

[复制链接]
XinLiYF 发布时间：2018-2-2 21:41
GPS，UTC和本地时间的显示器! X1 d: d+ i' R; Z! i* _
) d) D. v7 V8 h  Q
转载来源：GPS，UTC和本地时间的显示器& c6 w% C' s+ F7 j

6 o- C- W/ Y9 [+ x- a. t' ~2 RGitHub仓库：http://github.com/XinLiGitHub/GpsUtcAndLocalTime
* `% e& t+ [) y: A2 ?2 u; tPS：博文不再更新，后续更新会在GitHub仓库进行。1 _8 G+ V9 d; R. D5 G. C% J

" j4 O0 \, k/ m- U, m      GPS，UTC和本地时间的显示器。程序中涉及到朱利安日期的转换，详细介绍见维基百科[Julian day](http://en.wikipedia.org/wiki/Julian_day)。9 k2 @9 p+ F* v7 j
( s& p/ o! Y* N% z5 j0 h- r
1，开发环境
- O; Z% y) D, }% O" o6 Q7 {      1，操作系统：Windows 10 专业版; k9 o, s9 P" f4 q  U
      2，IDE：Visual Studio 2015 专业版
: l# ]) u  P* k" M  G
+ X0 l# k0 A* k7 s, ?  I2，程序源码
* ]" Q0 ~9 d; l8 X0 @- f      DateTime.h文件
, H  `3 H5 v; N. e: d2 w" \/ n  M3 Y9 `" f
  1. /****************************************************************8 Z5 t- V+ k" Q9 Y5 u  m* r
  2. * Copyright (C) 2017, XinLi, all right reserved.
    / a7 A4 D" a# b7 r
  3. * File name:    DateTime.h
    2 v5 T9 w) {4 O/ b5 N
  4. * Date:         2017.10.17
    ' v+ A: b  Z+ O
  5. * Description:  Date and time module header file.
    - i$ Y( s' g$ F- c. n, D' E+ Y
  6. *****************************************************************/! n' T5 y: }9 u' J
  7. ) ]; l& ?! H6 g; _# {8 |$ w
  8. #ifndef __DATETIME_H
    3 u0 P0 k' B( @& H2 A, f; Y' B
  9. #define __DATETIME_H. g  v2 H2 K1 {9 v1 W4 B
  10. % u4 V0 K7 Y, x$ ?+ G
  11. /****************************************************************
    . A1 S" Y" `' g, |% s  W) @
  12. *                        Header include% ?1 i. q$ k1 {
  13. *****************************************************************/) r8 w# M0 h; O: Q) e+ d% Q
  14. - t$ d! X/ A0 m( }: \. v8 I& \
  15. 7 W2 |4 I5 G  k% z- c4 o" P! r
  16. /****************************************************************/ i+ L$ }' `- o! l# _( h
  17. *                       Macro definition
    ) y. H1 J+ y7 E/ ?7 S0 M, Y& P
  18. *****************************************************************/& E. r& E( X* g% P

  19. / e! Z" p1 {+ B
  20. / W, e: B1 I- U. k+ X8 S; r
  21. /****************************************************************
    , N9 x. R- F( Q
  22. *                       Type definition6 W; o0 Z  B: b) @' v+ K
  23. *****************************************************************/9 l  @$ I* t9 v, M3 c

  24. ! N6 `( I) n, u6 W+ `

  25. . Q- I" g" m; R, ~8 Q3 A! B
  26. /****************************************************************
    0 h% V3 {; k5 X+ q7 B7 B  D% m. L
  27. *                     Structure definition6 Z' a; W6 Q0 W0 h5 ]0 s4 S
  28. *****************************************************************// @# ~& O" a/ d7 C) A
  29. typedef struct
    ; C2 G1 {3 q5 q$ w& h0 R. h" v) Y
  30. {
    8 X  g* D) r0 b; {# w3 k
  31.   int year;! [0 q8 S4 J( ?; a1 U
  32.   int month;
    / Z  |4 [0 x) q# O
  33.   int day;
    3 o( y+ K, J- a+ a4 y# F
  34.   int hour;
    3 z3 F0 A2 K. _! `* @( z: N7 q
  35.   int minute;) g2 {% L$ v& f" r9 j; m0 i
  36.   int second;! m' G  ^8 g& V9 H; w
  37. }DateTime;
    7 o# [8 ~, P* B2 Y- g. y0 H
  38. - M( m! b; Q9 ~3 F( N
  39. typedef struct$ X9 y& l2 ^' B
  40. {! }3 r' k# s  W+ ~2 O2 I7 o6 f
  41.   int week;
    6 K+ b* Q9 i& k% u
  42.   int second;; A" D! W" ~, S; V" a
  43. }GpsWeekSecond;
    : R' o8 H# l" g6 y: }1 k2 D4 c
  44. " w# J( F: S6 ~. y" R
  45. ' e0 H$ s0 G: M9 m$ Q& Y" p
  46. #ifdef __cplusplus
    ! Z3 e3 ]4 M8 N; z8 A$ j! h
  47. extern "C" {7 }0 Y5 [& F. [
  48. #endif  /* __cplusplus */; {; ?% n/ ~/ U8 [! k& P

  49. / y+ o1 r  [9 h& J! P0 I4 k! N$ C
  50. /****************************************************************
    , t  o9 i0 `9 O! v' W+ m0 ]
  51. *                     Variable declaration
    - @( {& `  R, V" j( B( ~
  52. *****************************************************************/
    * I4 Y3 o: m* Z% p
  53. ! U$ |, C  g: @8 ]; X2 p/ q
  54. - t4 W: i8 t2 D: e+ y3 H$ [
  55. /****************************************************************, @" {$ A+ l1 J& l" }
  56. *                     Function declaration8 L" L0 g1 F; I$ _
  57. *****************************************************************/
    1 [8 _  \5 I$ f7 k- T
  58. DateTime GregorianCalendarDateAddYear(DateTime time, int year);
    ! O5 ^/ h4 I8 g. }! s1 g
  59. DateTime GregorianCalendarDateAddMonth(DateTime time, int month);
    ( k" K* E' U# A* e5 a) M/ x
  60. DateTime GregorianCalendarDateAddWeek(DateTime time, int week);
    ( g5 k0 b/ T0 X% M- E7 k1 w
  61. DateTime GregorianCalendarDateAddDay(DateTime time, int day);
    5 m( X- T" R  ]  A
  62. DateTime GregorianCalendarDateAddHour(DateTime time, int hour);
    - ^) `3 f1 h4 J& z) L, G9 `
  63. DateTime GregorianCalendarDateAddMinute(DateTime time, int minute);
    8 g+ Q0 J3 N5 J0 y7 x& P! U/ h" h
  64. DateTime GregorianCalendarDateAddSecond(DateTime time, int second);1 `9 p" W  Z" ]
  65. GpsWeekSecond GregorianCalendarDateToGpsWeekSecond(DateTime time);
    - {+ x; R( T- d3 D4 }4 D& R
  66. double GregorianCalendarDateToJulianDate(DateTime time);
    * l- ]$ y+ M# G
  67. double GregorianCalendarDateToModifiedJulianDate(DateTime time);
    * g+ q/ j8 Y# e$ `: b
  68. GpsWeekSecond GpsWeekSecondAddYear(GpsWeekSecond time, int year);* G" R# u. w% J8 J; i! f2 F
  69. GpsWeekSecond GpsWeekSecondAddMonth(GpsWeekSecond time, int month);
    0 j7 U0 m3 T5 [$ s( T
  70. GpsWeekSecond GpsWeekSecondAddWeek(GpsWeekSecond time, int week);
    ; X- n& V! l  t, P2 V8 l% x
  71. GpsWeekSecond GpsWeekSecondAddDay(GpsWeekSecond time, int day);
    + b) n. Z6 ?8 [, k, J, \5 A/ V) y1 k
  72. GpsWeekSecond GpsWeekSecondAddHour(GpsWeekSecond time, int hour);2 l: K7 l9 _) h4 w
  73. GpsWeekSecond GpsWeekSecondAddMinute(GpsWeekSecond time, int minute);' V: j* x5 J: X" ~' j
  74. GpsWeekSecond GpsWeekSecondAddSecond(GpsWeekSecond time, int second);
    ! G8 L: l. f# w" [$ c
  75. DateTime GpsWeekSecondToGregorianCalendarDate(GpsWeekSecond time);
      f7 U( D' o! M- a3 m1 ?  N2 `0 `! \4 ?9 `
  76. double GpsWeekSecondToJulianDate(GpsWeekSecond time);, j. Z) C3 T) y" q. b8 u# \+ M
  77. double GpsWeekSecondToModifiedJulianDate(GpsWeekSecond time);7 y4 i0 w  L* [
  78. double JulianDateAddYear(double jd, int year);
    * v$ |7 Q' r: s* |
  79. double JulianDateAddMonth(double jd, int month);" c9 r. Y7 N+ X1 K' [+ u
  80. double JulianDateAddWeek(double jd, int week);
    9 a5 X2 o5 f. q3 G) F6 y1 a: I
  81. double JulianDateAddDay(double jd, int day);7 m/ |1 M* f7 ?. i  }9 e0 F9 ]
  82. double JulianDateAddHour(double jd, int hour);
    . K% q! d  ^& `
  83. double JulianDateAddMinute(double jd, int minute);7 K' I% d5 z0 _7 P0 |7 b
  84. double JulianDateAddSecond(double jd, int second);
    0 G) m3 f3 {& K) L& S4 z
  85. DateTime JulianDateToGregorianCalendarDate(double jd);
    1 c' C2 F9 \! r1 _4 N+ G! z
  86. GpsWeekSecond JulianDateToGpsWeekSecond(double jd);  x0 h6 {5 o) y& n. u$ w
  87. double JulianDateToModifiedJulianDate(double jd);3 x" L* |( r2 N6 e2 J8 |: F
  88. double ModifiedJulianDateAddYear(double mjd, int year);
    $ z. z  E- e" k& F' u- r
  89. double ModifiedJulianDateAddMonth(double mjd, int month);6 Q9 b" h; ?, s/ f1 C/ B
  90. double ModifiedJulianDateAddWeek(double mjd, int week);. S2 z( Z! B) C; n# d0 r
  91. double ModifiedJulianDateAddDay(double mjd, int day);: a9 Q6 V) M0 X. d2 G
  92. double ModifiedJulianDateAddHour(double mjd, int hour);4 c; f; J& }2 z5 |0 |
  93. double ModifiedJulianDateAddMinute(double mjd, int minute);& s, U) y' W, C0 _$ q6 G& V% J
  94. double ModifiedJulianDateAddSecond(double mjd, int second);
    , p- T2 D& ?# `% B0 g; {3 `, X
  95. DateTime ModifiedJulianDateToGregorianCalendarDate(double mjd);; H0 b9 E4 Q* m# _/ }
  96. GpsWeekSecond ModifiedJulianDateToGpsWeekSecond(double mjd);
    9 k  M9 B6 D& w. n( A6 x; D/ x$ ]
  97. double ModifiedJulianDateToJulianDate(double mjd);
    " k  c* g4 `4 J1 n2 D
  98. 2 b1 E8 }: Z+ P
  99. #ifdef __cplusplus2 Q3 J. D8 j. S- p) h
  100. }
    , G- h' F6 e$ m% e6 q8 y
  101. #endif  /* __cplusplus */' g& s$ I3 d9 O$ L/ o# `" c6 a

  102. 7 b+ L# `1 n, k
  103. #endif  /* __DATETIME_H */
    - K- s  ~  A8 T) ^
复制代码
7 ~7 h" {; |+ I. L) t3 J, ]
      DateTime.c文件
& @& t; m  ]5 G5 S' A
  1. /****************************************************************
    " ]4 \  L  ?, o. ~
  2. * Copyright (C) 2017, XinLi, all right reserved.
    ) R$ I/ N7 k0 b- [3 N
  3. * File name:    DateTime.c6 `4 l$ G: X& @# M  R7 |
  4. * Date:         2017.10.17
    / `" m' H: w& m3 |6 ^7 ]( ^9 Y
  5. * Description:  Date and time module source file.
    ; C% q1 d9 {! b5 |9 ?
  6. *****************************************************************/( H& I3 V' H5 `$ \6 b) o
  7. 3 v7 I9 |/ N0 a5 c
  8. /****************************************************************
    $ ]1 Z) ?2 h5 z7 @# |5 u
  9. *                        Header include
    8 G" n. a* H4 ]: p. ]: U
  10. *****************************************************************/
    ( J5 V9 N% K& }5 H
  11. #include "DateTime.h"
    * Z; c' l$ M8 q/ r  n) `4 K

  12. - u" `& t9 h3 X" L
  13. /****************************************************************3 M* A: Z: i6 e2 f
  14. *                       Global variables2 H) y- ~1 W! \
  15. *****************************************************************/
    5 j. g$ I. u- g5 U" L8 z

  16. . b. T, F) @  l7 x

  17.   z; l/ G: E: L7 ]
  18. /****************************************************************& M$ ~' Q, V3 E" v3 p* t, b2 n
  19. *                     Function declaration; B" {8 E9 S/ f7 c3 e6 u* K
  20. *****************************************************************/8 r) [0 w( s0 C

  21. 8 x. ?6 o) R. m& A: w7 r2 p) P: X

  22. 5 ^3 X$ O* J1 o- }& {- |5 A
  23. /****************************************************************
    . ^) m; h7 x( T8 C! d
  24. *                     Function definition
    2 h5 ?, L3 z5 z- Q# O
  25. *****************************************************************/
    8 s  `0 H' a) l" Q' {1 W# y/ p$ Q

  26. 2 ?- Q- Q5 ~( m
  27. /****************************************************************
    / s( V9 s) v$ C! `/ ?
  28. * Function:    GregorianCalendarDateAddYear
    & M/ v1 S. I. m
  29. * Description: Gregorian calendar date add year.8 W0 o" P( t4 Y5 X
  30. * Input:       time: Gregorian calendar date.
    / O7 ]  F) u7 j
  31. *              year: The number of year to add.- A7 p, ]& H2 ^, U, N" R" r, W
  32. * Output:
    0 [; Z9 ^' f/ I7 F) U; `
  33. * Return:      Gregorian calendar date.
    # A; u* q4 y  F* p4 v# N9 K
  34. *****************************************************************/
    6 j# i# ?) E% V/ _7 t
  35. DateTime GregorianCalendarDateAddYear(DateTime time, int year)2 b! ?7 `$ B' x# G+ P2 I# l3 I
  36. {; N5 X: w2 F, F. \: ?& v
  37.   time.year += year;5 B: f1 `6 Q+ ~& X& a+ R
  38. # @& l4 p3 G7 X% j+ w5 n4 s
  39.   if(time.month == 2)2 m6 e5 R  U& j5 p/ `
  40.   {
    $ ~2 P8 ~" X! ~
  41.     int mday = 0;
    . u2 t4 }2 h# _! D6 a

  42. $ o" [3 x4 V* |- R' a
  43.     if((((time.year % 4) == 0) && ((time.year % 100) != 0)) || ((time.year % 400) == 0))% g1 P+ P+ {  K
  44.     {
    3 [' C$ q0 |7 G- t
  45.       mday = 29;
    $ T1 c) P  P& p. g' f5 n/ p
  46.     }
    4 f8 d1 e1 s; Y$ b8 X, k4 f
  47.     else
    ( Y/ `+ `' Z% f' C, x1 ]/ O
  48.     {
    . k# J3 n7 k! i! v; H; W( S& K
  49.       mday = 28;. U+ n- I3 \5 D) d( M
  50.     }
    + \' i5 H, |. N' b. O& Q

  51. ! V  ?2 i+ k, n$ d0 e) }
  52.     if(time.day > mday): F2 ~. E1 H3 x
  53.     {9 c0 m" T3 e9 d( v
  54.       time.month += 1;
    + `( }. [  B$ A8 n
  55.       time.day   -= mday;0 ^& Z8 z$ \6 k8 t; ?& ~1 u
  56.     }  d" x9 k) i8 F9 f# r4 F% q: U
  57.   }
    % }+ C, d9 `; H( n% ~# A" b
  58. ( [) [2 e- W& U* }6 a2 B0 u
  59.   return time;
    8 `0 t- r! E/ a4 V* s
  60. }
    1 Z$ A, ~! H- c

  61. * f" P$ J" s% Y$ C: n
  62. /****************************************************************
    # ]( b0 ]! d- L" i& A
  63. * Function:    GregorianCalendarDateAddMonth, a; a; O6 W1 d/ X
  64. * Description: Gregorian calendar date add month.6 A& A) }9 Z$ j
  65. * Input:       time:  Gregorian calendar date.) V0 |0 v) f0 }# j0 M, g
  66. *              month: The number of month to add.
    ) X* Y, y( W; `& ?$ j" @
  67. * Output:
    4 R* N* Y; m( [; F6 \! ]  b* M7 T- Q
  68. * Return:      Gregorian calendar date.
    4 H- [! F* o1 ~; a- Z3 ?
  69. *****************************************************************/2 Y9 h+ v- G# ?( s; {
  70. DateTime GregorianCalendarDateAddMonth(DateTime time, int month)4 L7 y& J, V% H; L. T$ \9 B0 R( I2 [
  71. {
    * {% ^9 [0 ~" N: l: z
  72.   time.year  += month / 12;' G$ w$ _: z) b& x
  73.   time.month += month % 12;# O% r0 U7 g6 |( Y' h
  74. . V$ ~7 x+ C! f3 v4 t5 F
  75.   if(time.month > 12)3 o+ K& Q1 ]( _& `
  76.   {6 G8 V+ p1 j+ j! `+ A6 d
  77.     time.year  += 1;/ B' P; a+ j) S' g9 U7 }6 }
  78.     time.month -= 12;
    % }% G! I  E+ y: U. ]( [$ O* l
  79.   }
    . S' H; W+ S6 n3 `' d( }- W

  80. , ~2 i  e1 H# T, ^: f
  81.   int mday = 0;
    , G% V  N& n: r7 U4 K' ?/ M6 m/ z

  82. ) [3 J5 p4 ?9 u8 a/ g8 T% Z
  83.   if((time.month == 1) || (time.month == 3) || (time.month == 5) || (time.month == 7) ||+ o/ ?9 ~, L8 x9 I0 Q9 ^4 {' \2 [
  84.      (time.month == 8) || (time.month == 10) || (time.month == 12))
    : B4 p7 i8 K. W
  85.   {# ?  o: u- @% I1 K, ~
  86.     mday = 31;$ k: [) E- j6 y
  87.   }
    / O  q0 F: a# l8 G" M6 u8 X
  88.   else if((time.month == 4) || (time.month == 6) || (time.month == 9) || (time.month == 11))
    0 P' r# G7 S# G) y) Y2 N3 P: q6 n
  89.   {
    ; ^( S, j- I8 p4 t
  90.     mday = 30;
    0 S6 G2 C- F4 S5 R0 s2 ?2 X2 `+ f/ M/ C
  91.   }
    ( H. C/ V0 M+ F) ]
  92.   else+ Y: ^3 O, U. b; C. [+ Y
  93.   {
    8 M0 q# G, G5 `; r) t3 r
  94.     if((((time.year % 4) == 0) && ((time.year % 100) != 0)) || ((time.year % 400) == 0))
    " d. J: F% y+ o0 r$ ]# q
  95.     {
    / W$ y  h. f2 q. x; O' a( G+ Z
  96.       mday = 29;
    ; \' a  l" U% v0 T% a, j
  97.     }) u1 b4 m& g/ T. w$ P* f
  98.     else
    2 {$ N2 B! W: _1 p& l9 @3 c! K
  99.     {
    . I5 U( a! c1 {) _6 V  F0 x
  100.       mday = 28;
    ! }  p) a& \# E1 l2 J' y/ v, i9 t2 }, q
  101.     }! B8 l: w, |' p+ G2 s  J
  102.   }! ^$ ]9 n& X9 T5 h/ c

  103. 6 ~9 D. Z  l# h  Q3 r1 T1 ^
  104.   if(time.day > mday)
    7 T/ J; |; U1 d
  105.   {$ u9 Z) n4 f' E! v. d
  106.     time.month += 1;
    + u: w3 e5 w3 ?7 E6 e* {' y! h
  107.     time.day   -= mday;
    + k: ^6 ~! _5 ?7 T4 \8 D" @
  108. ; H' c+ Z7 M1 B! u2 @
  109.     if(time.month > 12)4 f: c* [4 k( b
  110.     {# z' n7 h4 k! x
  111.       time.year  += 1;, J- ~" g& o: e" z' B. Y. Q3 Q
  112.       time.month -= 12;5 ]" ]% b5 u# I* f
  113.     }! `# v3 D$ s8 G! ~7 p
  114.   }
    # R' b' ?6 t0 ]7 V

  115. 6 t6 u- ^* V. }5 Z6 D
  116.   return time;6 t* Z. T- B' s
  117. }. s; O# O. `. ?8 p* Y
  118. 7 B/ Y% \5 d5 @: Y
  119. /****************************************************************$ T. T9 a7 a1 n1 V  K
  120. * Function:    GregorianCalendarDateAddWeek. `2 l) H* I7 N# ^8 g2 F  H
  121. * Description: Gregorian calendar date add week.& ^4 w3 y7 {+ c/ s. M( x
  122. * Input:       time: Gregorian calendar date.
    # E0 z+ G& e; g& r: e4 u
  123. *              week: The number of week to add.
    ; Q9 W) {% e7 O, L! s0 E+ a
  124. * Output:
    6 X+ `  l9 Z- |% O
  125. * Return:      Gregorian calendar date.
    , [- h- y4 k9 ]. Y
  126. *****************************************************************/
    7 h! g( c7 a& N, U1 R) p
  127. DateTime GregorianCalendarDateAddWeek(DateTime time, int week)6 F1 f* C! i) K8 L
  128. {
    6 _' a. [, e+ b6 r* i( Q
  129.   double jd = GregorianCalendarDateToJulianDate(time) + week * 7.0;
    4 Z8 v) |, F0 _2 D  f

  130. 8 |; }! u. J$ {9 i
  131.   return JulianDateToGregorianCalendarDate(jd);0 B; B/ \* T& F
  132. }0 {1 I9 m, K. b* G/ y6 }; V& I
  133. ( s1 q: G1 D" r3 }. h5 V. T
  134. /****************************************************************
    ) a; \- F; K# W. `. l
  135. * Function:    GregorianCalendarDateAddDay7 o2 _# S7 z2 J0 m
  136. * Description: Gregorian calendar date add day.' A% v; X( `5 Y! O# W
  137. * Input:       time: Gregorian calendar date.0 O/ {3 o) U* R3 d1 A# J* o- P, g
  138. *              day:  The number of day to add.5 _" m; {  _% `* y* A7 v% M
  139. * Output:& ^7 G3 I6 U. k( Q- T1 s" j
  140. * Return:      Gregorian calendar date.
    1 Z' L3 F0 [, B  x, P! ?8 M4 `
  141. *****************************************************************/
    5 D8 l6 \" b, ~( d7 p
  142. DateTime GregorianCalendarDateAddDay(DateTime time, int day)
    % c5 T$ H0 O) v2 c5 H
  143. {
    " [7 _& r' c" Z$ d
  144.   double jd = GregorianCalendarDateToJulianDate(time) + day;8 }9 H3 r% Z( [! l$ n
  145. * k1 E9 m0 u9 p4 I6 d' x
  146.   return JulianDateToGregorianCalendarDate(jd);, p# s) F0 g7 R2 J! v! R
  147. }2 W5 d; _! ^/ z
  148. . ]5 Y4 i2 K6 E4 X* ^3 f
  149. /****************************************************************
    7 K$ _& G4 I* N6 |, P
  150. * Function:    GregorianCalendarDateAddHour) x2 |7 `0 I3 T* R
  151. * Description: Gregorian calendar date add hour.( `" U$ `5 `, B
  152. * Input:       time: Gregorian calendar date.) s9 K7 y3 E) H
  153. *              hour: The number of hour to add.
    ! S# J  Z" U- G. X: l- F5 E
  154. * Output:3 ^9 e. w+ s$ o" _$ W
  155. * Return:      Gregorian calendar date.
    * N* U/ Q* u5 D# M( L
  156. *****************************************************************/
    3 e2 I! l- f! `3 H4 e1 h
  157. DateTime GregorianCalendarDateAddHour(DateTime time, int hour)% r/ a6 w% D7 A3 Y7 J
  158. {3 N( {9 Y. h7 y1 \  B
  159.   time.hour += hour;
    3 e# c0 r- t- V$ A
  160. , m% w- Q7 Q: l2 e) X
  161.   double jd = GregorianCalendarDateToJulianDate(time);- Y8 J6 v, d' T4 J4 [

  162.   \5 J2 p. D! @7 S4 N9 f
  163.   return JulianDateToGregorianCalendarDate(jd);( l; A- |4 y) x5 p6 S3 O
  164. }3 }9 L$ X& x0 b! M

  165. 5 ], U2 ?1 V1 \3 m( l
  166. /****************************************************************2 i# D3 |, l7 b3 e5 |
  167. * Function:    GregorianCalendarDateAddMinute1 \, ?$ I5 }3 k, Q1 _
  168. * Description: Gregorian calendar date add minute.: P* G- F* h8 G' x& S$ \( Q
  169. * Input:       time:   Gregorian calendar date.
    8 f2 S" c* F7 A' s9 Z1 H% `
  170. *              minute: The number of minute to add.0 B% A5 A; k- B1 A1 c! h9 C* ?. t
  171. * Output:
    ! ]. O) U9 L: E8 o: C
  172. * Return:      Gregorian calendar date.% G+ W- a# W9 Y0 ~! E( r
  173. *****************************************************************// B4 m9 ^6 k4 E% y* M, A+ J
  174. DateTime GregorianCalendarDateAddMinute(DateTime time, int minute); H2 q# |  }' d2 ?4 g2 A( W
  175. {
    ! w6 n  S% o8 [1 s% S
  176.   time.minute += minute;$ t  y" c+ L, y1 ~- ~* z2 q

  177. 3 ^+ P, Q% c% ?/ h! s  k0 N
  178.   double jd = GregorianCalendarDateToJulianDate(time);/ ~. w4 A# C6 N/ U. @& s& s

  179. ( C  r+ ]3 z; Q6 j+ I" F; c
  180.   return JulianDateToGregorianCalendarDate(jd);
    ' Z8 o$ }) @. y" [' R. x
  181. }! n1 g  z2 G" }+ L4 Y1 a7 c# @( r' i
  182. & n" E" X6 a8 n! F6 p1 |
  183. /****************************************************************& M: n" s/ B6 Y4 d' N
  184. * Function:    GregorianCalendarDateAddSecond# _/ l# Z1 o  k( b
  185. * Description: Gregorian calendar date add second.. g9 `4 ]& u( m: Q8 q
  186. * Input:       time:   Gregorian calendar date.! i' g% J: @: @5 i" O4 i( o& ]) k
  187. *              second: The number of seconds to add.1 x3 x: K; ~: v0 j9 E' q$ H- d% x
  188. * Output:
    , K9 _, Z' `9 C& h" H1 J
  189. * Return:      Gregorian calendar date.& P8 w" I/ [$ `- y5 z& i* U
  190. *****************************************************************/1 g; w* T: P. x5 X; Q5 a* G' M
  191. DateTime GregorianCalendarDateAddSecond(DateTime time, int second)' o+ Q1 h' {" D
  192. {
    , D; }1 B% U' ?' O1 u
  193.   time.second += second;
    ! R# u2 |" y1 Q- m
  194. 4 w- a  d% q: q3 H& H3 f/ N
  195.   double jd = GregorianCalendarDateToJulianDate(time);
    ( ]) {% P: P. P1 U1 h
  196. , F/ s) Q! N/ H3 R$ d& U9 `2 W* x
  197.   return JulianDateToGregorianCalendarDate(jd);
    ' {/ d/ C8 H$ F2 g. `3 e) x& k
  198. }$ P6 M3 v# c; |" y1 H0 P2 o/ t

  199. ! Z+ k" I, R% A% \$ c
  200. /****************************************************************
    - u* }* K% U/ V2 F/ V
  201. * Function:    GregorianCalendarDateToGpsWeekSecond
    5 a: E, f7 A5 H1 j' m
  202. * Description: Gregorian calendar date to gps week and second.1 P/ I: i: x9 ]# Z" x7 x) y
  203. * Input:       time: Gregorian calendar date.& x# i2 u4 q' ~$ D7 g& p/ y
  204. * Output:7 w4 }, s, s6 O4 ]; Y' m. V' l
  205. * Return:      Gps week and second.
    * n" ?, M  V4 f9 I, i: M0 C
  206. *****************************************************************/" e: G  p: f  A
  207. GpsWeekSecond GregorianCalendarDateToGpsWeekSecond(DateTime time)
    ' N+ P5 e; i" Y) R
  208. {- u: l# b( m3 ^1 e5 c
  209.   double jd = GregorianCalendarDateToJulianDate(time);
      Z# A) p/ V4 _* U( m8 l$ L- V
  210. , D1 w3 @& f- h! T& ]: Q: n+ z0 m
  211.   return JulianDateToGpsWeekSecond(jd);
    6 _9 L& Z9 E, b5 W* m7 B0 e
  212. }! w( P7 _0 i( {- w

  213. ) R4 \( a# }1 U- ~# s1 _
  214. /****************************************************************3 x& Q+ H* |" q4 b
  215. * Function:    GregorianCalendarDateToJulianDate
    . M; A; F) S9 z) U7 O- D
  216. * Description: Gregorian calendar date to julian date.
    6 g1 P8 Y: T9 x9 v0 M5 J9 E
  217. * Input:       time: Gregorian calendar date.
    % l" o* r% ^( O! F5 F& m
  218. * Output:: U* \( q; M# k: I" n5 Y, c% T7 N
  219. * Return:      Julian date.
    * P' u1 V( O$ t4 T" o' E+ v5 o
  220. *****************************************************************/
    ( Y, J4 z% _$ O; W( |
  221. double GregorianCalendarDateToJulianDate(DateTime time)
    9 K3 B9 L% \2 O: Q/ M
  222. {
    ; D% `* a7 M: [. k3 _
  223.   int jdn = (1461 * (time.year + 4800 + (time.month - 14) / 12)) / 4
    3 I, K, c& J0 Z9 H* `/ u' t% o# s
  224.           + (367 * (time.month - 2 - 12 * ((time.month - 14) / 12))) / 12
    3 \( O$ f/ [9 j" }- I  K9 v
  225.           - (3 * ((time.year + 4900 + (time.month - 14) / 12) / 100)) / 4
    : ?8 j7 R" I1 h! P  Q/ L" \  ]
  226.           + time.day - 32075;& k0 ?' z3 l# `

  227. 5 o0 W; u* Q9 {& N( |3 X) F
  228.   double jd = jdn + ((time.hour - 12) * 3600.0 + time.minute * 60.0 + time.second) / 86400.0;8 \; ?% j8 I8 s3 N

  229. , [2 P, d, A1 n) }6 ^( N
  230.   return jd;
    / X: T3 L' o% b5 C# P
  231. }' _) ?  t% Y! A5 e/ G: I/ r
  232. % X7 @' e; |* e3 O. c* b" K% i* s
  233. /****************************************************************
    0 |" q! z/ W1 ?& [5 D" n
  234. * Function:    GregorianCalendarDateToModifiedJulianDate
    ( d6 G% ]1 T) h) F: F3 q5 g
  235. * Description: Gregorian calendar date to modified julian date.
    # C5 X5 I# a$ F& Q; {
  236. * Input:       time: Gregorian calendar date.
    $ S1 e* D% j! E) R7 N
  237. * Output:
    6 D% r+ c; p6 t4 E
  238. * Return:      Modified julian date.
    1 y6 J- {" ~" K- y; z) N( d6 |+ E4 P
  239. *****************************************************************/+ C/ x. H6 `2 A. V, h
  240. double GregorianCalendarDateToModifiedJulianDate(DateTime time)% @( q) l4 ]' s4 u! @  k% ^
  241. {
    3 r, F% c/ ~3 H" F
  242.   return GregorianCalendarDateToJulianDate(time) - 2400000.5;
      a; `4 l  d$ q" j- a5 ]
  243. }
    : `9 z9 n" ?! s

  244. 3 r/ }; S- _5 m- F" u" j* f/ R9 H
  245. /****************************************************************3 w4 s2 ]4 ]9 S3 \0 _
  246. * Function:    GpsWeekSecondAddYear& |; O4 b( Q& {" {  \
  247. * Description: Gps week and second add year.& T9 @6 Z3 a! z/ T" w, ]
  248. * Input:       time: Gps week and second.
    6 z6 x/ }$ A$ [) I" s# z1 _
  249. *              year: The number of year to add.+ r+ V6 I. x5 k# ?" R% C) f
  250. * Output:
    4 m4 q9 A5 s& n8 U% _( |. [
  251. * Return:      Gps week and second.
    / {! Z' \& Y' Q
  252. *****************************************************************/
    ' k, a1 j; E7 l2 F% \
  253. GpsWeekSecond GpsWeekSecondAddYear(GpsWeekSecond time, int year)/ Q. d% T; A8 |* I. P5 v! Q
  254. {
    % Y+ i( D) p, s: m: p# t( _
  255.   DateTime date = GpsWeekSecondToGregorianCalendarDate(time);, N0 E( L7 b6 e) C1 a/ \8 O, q7 V
  256. ' N* r, h- r+ r4 H
  257.   date = GregorianCalendarDateAddYear(date, year);* m' h8 X9 J& D+ X' s! }1 ?" r

  258. % }. {$ _# ?" n4 @" k6 q9 c4 B0 ^
  259.   return GregorianCalendarDateToGpsWeekSecond(date);
    " ]. u6 R" O: _' |& Q
  260. }
    $ K- p6 @& w7 g0 {

  261. 5 s3 n8 b* s+ f8 ]) w$ j* H! Z
  262. /****************************************************************
    / O1 X- C+ Y7 v
  263. * Function:    GpsWeekSecondAddMonth5 W" P" i4 \/ I5 d
  264. * Description: Gps week and second add month.# Q% Q. p  t; T1 x! E" X" R
  265. * Input:       time:  Gps week and second.7 G8 c0 U: v! h% f) P' C; q* M5 R
  266. *              month: The number of month to add.) ]( r" v' d* {* v
  267. * Output:# D! Q$ J0 s, g1 m4 [4 O
  268. * Return:      Gps week and second.# P" u$ j' s8 z1 K' C" a0 Q
  269. *****************************************************************/
    8 s: W8 f. ^7 j% C) B& j" c) O
  270. GpsWeekSecond GpsWeekSecondAddMonth(GpsWeekSecond time, int month): s; p; Z" d  P" D; `5 E
  271. {+ y7 C, `0 k" W& b
  272.   DateTime date = GpsWeekSecondToGregorianCalendarDate(time);
    7 y% V6 Q! J' @
  273. 8 `" V/ ^+ V# d% Y
  274.   date = GregorianCalendarDateAddMonth(date, month);
    , q/ v7 q! b) N5 A- P

  275. - C1 a" k! q# H+ P7 d3 [6 ^& C
  276.   return GregorianCalendarDateToGpsWeekSecond(date);
    $ V9 {5 l3 s8 e' x: K
  277. }
    ; X" i$ p" h: _. W+ t9 U

  278. - W3 d8 O: L1 N0 D( r
  279. /****************************************************************
    8 C% ?. y5 V7 X% B4 q- H
  280. * Function:    GpsWeekSecondAddWeek
    * |3 r; q( c8 {, h% `# T8 z. |
  281. * Description: Gps week and second add week.
    . B6 V! h4 u# h: G( [9 P$ @* z
  282. * Input:       time: Gps week and second.
    $ e. t- @; ^) Y9 Q- G4 n
  283. *              week: The number of week to add., P% B( R3 s& O% ], `; M  Z! J4 V) H) d
  284. * Output:
    - `( {, M/ H" j# s5 M- P
  285. * Return:      Gps week and second.
    , u4 m( U8 t0 o/ x5 \, ?
  286. *****************************************************************/1 W' p0 N2 z) n; I1 v# g
  287. GpsWeekSecond GpsWeekSecondAddWeek(GpsWeekSecond time, int week)
    ) ]3 \9 ^$ a1 M0 J) o# e
  288. {# ^2 j# K. O5 Y) ?& y$ o  {
  289.   time.week += week;  `% J( Q# y7 m, t' G( c8 x

  290. % }. _' H2 c7 H
  291.   return time;
    8 E( _# {$ e1 r  b3 ?; O% O) Y
  292. }0 @0 K1 p" _' _. j- C7 K  R
  293. 1 z2 T7 e0 k+ }. ^1 F
  294. /****************************************************************. v% p1 [3 g6 g: C8 W& _5 v* t# y
  295. * Function:    GpsWeekSecondAddDay; Z$ Y; J' j% G* p2 _
  296. * Description: Gps week and second add day.' \% ~, y: L7 U5 A0 D' o' q7 k
  297. * Input:       time: Gps week and second.
    : g/ g1 o1 t7 a/ S& F
  298. *              day:  The number of day to add.
    ' W0 }7 c# i& K0 u( y+ B7 ~- e
  299. * Output:& A) m4 l! e; k. y% q. I! i
  300. * Return:      Gps week and second.
    . m& V+ o, @0 \  |& d! t& i; [
  301. *****************************************************************/
    ! c# Q# }0 o( ^$ k2 }. p6 h1 Q
  302. GpsWeekSecond GpsWeekSecondAddDay(GpsWeekSecond time, int day)! i, j# D. B' l, V3 U, @. x
  303. {
    9 q( H3 b' ]: v8 l% T
  304.   time.week   += day / 7;7 k) P9 h) {( f& i' o) w
  305.   time.second += day % 7 * 86400;
    0 _( I) _7 I. H$ N2 @* l

  306. ' L# W4 L& t% @& U0 R) [
  307.   if(time.second > 604799)
    ) n& i# e, v! t1 r. k
  308.   {( q5 M1 U( t4 x) S2 Q; v$ d/ Q) C
  309.     time.week   += 1;
    ( f' F; T/ k0 [1 Y$ k7 p% v
  310.     time.second -= 604800;2 p, ]2 W8 q8 {. e
  311.   }
    1 g$ Q$ N) U3 j5 d" S

  312. ; Y7 P7 d: t" a
  313.   return time;6 ^/ p- _' a4 w7 a* B) D- l
  314. }2 R/ v! m1 S* x5 e7 N+ R
  315. " o$ i: U4 K9 ^* `: u2 V+ n
  316. /****************************************************************- |: f# n# R4 J3 d" S
  317. * Function:    GpsWeekSecondAddHour
    3 ?* f) Z. f0 X; ]2 R9 N! V
  318. * Description: Gps week and second add hour.
    & p* P! o! F- M; e. q# A( F
  319. * Input:       time: Gps week and second.3 M& \2 K. m' {6 ]+ Y
  320. *              hour: The number of hour to add.9 q5 ~: M. k! a1 A. M
  321. * Output:
    ) `0 M% _1 T; ~' V- L) ?' a
  322. * Return:      Gps week and second.0 S) M8 |5 X4 J& L- k+ b" r
  323. *****************************************************************/  z( T3 l' r- a" X' f4 X; X
  324. GpsWeekSecond GpsWeekSecondAddHour(GpsWeekSecond time, int hour)
    # F$ V2 G2 i" z% H# f; n
  325. {
    1 ^* `" \6 W3 j4 \
  326.   time.week   += hour / 168;' M/ k6 F8 d9 k* O
  327.   time.second += hour % 168 * 3600;! @2 \3 B" \0 h9 [3 }
  328. 1 |) J: B8 o: s# v, C
  329.   if(time.second > 604799)* \! _  ^7 V- k: b( |) @' ~
  330.   {( c( A; e7 |3 Q) z% P; ^
  331.     time.week   += 1;& z) e' A( ^+ K+ |& Q) y
  332.     time.second -= 604800;2 g" W! F' {+ ^# Q% j" Y" _
  333.   }
    5 g$ k+ b0 k9 s$ a. j: n6 u
  334.   . ~5 m& k% z* K3 q* R: D) H- R( o
  335.   return time;& e  a3 Y' T; K8 O
  336. }
    ( R0 n. R6 D) B7 A" [
  337. 0 @+ L# ~- [1 s" L4 U
  338. /****************************************************************
    ! \9 i4 `  }! s, r6 j: G& T
  339. * Function:    GpsWeekSecondAddMinute4 A5 T9 J7 x$ f! U" k& M
  340. * Description: Gps week and second add minute.1 _; @( X$ }( H' e; L
  341. * Input:       time:   Gps week and second.
    7 h- M4 c  M/ n$ P% I
  342. *              minute: The number of minute to add.! @' S) N$ p- U  W! v1 V
  343. * Output:; Q  n' Q; ?3 t$ q. r4 v
  344. * Return:      Gps week and second.
    + A% ]2 w+ ]( x! d5 J
  345. *****************************************************************/
    ! l9 M3 b6 F1 W1 q7 T9 n
  346. GpsWeekSecond GpsWeekSecondAddMinute(GpsWeekSecond time, int minute)9 X5 i' b: V. }) X% N# y! `- _1 K  G
  347. {
    # d; }& a# _8 u+ w
  348.   time.week   += minute / 10080;" f# B. @& V6 F! t% g: L
  349.   time.second += minute % 10080 * 60;1 r8 d& ^. Q6 R, S# y0 Q2 `) x
  350.   
    ! f8 p, `' G1 q, ~, K
  351.   if(time.second > 604799)* Z3 U' m5 _+ {' c' {" u
  352.   {+ C% S/ u7 K& ~
  353.     time.week   += 1;
    ; n; X  u. y) A$ w
  354.     time.second -= 604800;
    - `7 b% g4 l4 `& h
  355.   }
    7 b$ p6 c9 q- N. G
  356.   
    / k0 \) I+ F% g
  357.   return time;
    9 K* H) e; @) ~2 z
  358. }6 I9 `" s0 R8 V0 N5 ~% D
  359. + L: S8 d4 g. A2 `5 J- j
  360. /****************************************************************
    " ~$ [! H! f, C* z: k( R
  361. * Function:    GpsWeekSecondAddSecond4 ^: k; w; f4 x0 n1 A, U, [. N, |% X0 d
  362. * Description: Gps week and second add second.
    9 d( k0 n' W6 h4 x  t
  363. * Input:       time:   Gps week and second.0 ^: p, m. T$ K
  364. *              second: The number of second to add.1 ]( E1 G6 S9 `5 ?
  365. * Output:
    - `* J8 H  J+ \8 s9 R7 t
  366. * Return:      Gps week and second.
    ' y7 n+ t8 G1 s  g6 V4 h
  367. *****************************************************************// _2 G7 C" Z, {8 W0 r5 D1 Q
  368. GpsWeekSecond GpsWeekSecondAddSecond(GpsWeekSecond time, int second)
    % n) f3 Y& f4 j! b+ I4 r
  369. {1 @3 [! A0 v2 W2 j0 K/ b3 x# I
  370.   time.week   += second / 604800;
    & _6 w# }, B' J* z) I* G
  371.   time.second += second % 604800;
    , _1 q$ G) j$ O- M5 }- |

  372. 4 o1 l# l; \2 B' ^
  373.   if(time.second > 604799)
    9 v$ u( a& Z# q8 p3 Y
  374.   {
    * \& x; ?7 Z' W1 g) H" q% f
  375.     time.week   += 1;* ~! B/ j5 p6 A) G2 k
  376.     time.second -= 604800;
    - o& I9 h. q# t" X! p
  377.   }! C" G  K( \6 }6 C: v1 J
  378.   5 h* s, R5 K3 q% t7 A0 u2 M
  379.   return time;
    5 O/ G, O2 \' _' e; A
  380. }/ w; h$ @" `: d" Y
  381. 6 `' }5 ~) b1 o5 |6 ]
  382. /****************************************************************4 q: m8 |( T/ J$ B* O9 H
  383. * Function:    GpsWeekSecondToGregorianCalendarDate  ]! ]# x2 @& G; q
  384. * Description: Gps week and second to gregorian calendar date., H3 }' c' n) {( [4 ^% j) g
  385. * Input:       time: Gps week and second.
    % `2 D6 A9 k& ^
  386. * Output:7 s/ v% `/ x/ t) W
  387. * Return:      Gregorian calendar date.5 c1 I) A- M4 M, E) y
  388. *****************************************************************/
    & w4 p3 ^  b; N
  389. DateTime GpsWeekSecondToGregorianCalendarDate(GpsWeekSecond time)
    . \4 D% _' F1 X# K4 y9 ?8 W
  390. {
    * i3 A$ M/ V- s
  391.   double jd = GpsWeekSecondToJulianDate(time);
    + Q+ R# @* [, y0 D, N& T! _; ~; e
  392. 4 N; d, f" m$ v9 [, J, v* T! w6 T
  393.   return JulianDateToGregorianCalendarDate(jd);
    8 U/ B$ O( f4 Z3 Z( r
  394. }  o% z5 A! F2 N+ i! O* k. c

  395. 0 }. w% U9 o( A
  396. /****************************************************************8 V$ A. I7 N( o" Q% a* h
  397. * Function:    GpsWeekSecondToJulianDate! @% p7 p9 m2 Y* P; n! B( I
  398. * Description: Gps week and second to julian date.
    $ F8 b, j9 w: I+ i2 R3 h) G
  399. * Input:       time: Gps week and second.
    ( J9 P5 [/ ]1 Z5 x, Y4 i, w# r
  400. * Output:
    , D6 M/ K" p) E+ o4 @2 @
  401. * Return:      Julian date.
    + e, b: z6 j# ]7 o8 t% r
  402. *****************************************************************/- E" [4 q7 L6 @/ S) J8 z% J  Z
  403. double GpsWeekSecondToJulianDate(GpsWeekSecond time)
    $ {; X4 }' ?( c* C* q
  404. {
    1 l) ~+ H8 d) o/ A8 z1 C
  405.   double jd = 2444244.5 + time.week * 7.0 + time.second / 86400.0;
    $ v! o4 h5 |3 \
  406. % H, U7 h) @' n, r6 M& z  ]
  407.   return jd;' U; ^  e4 A+ o$ i( u+ a- r  q' Q; E/ l
  408. }
    , `( x( w% b0 k

  409. & E; f8 O1 U- h/ \* d
  410. /****************************************************************$ ?% K- X2 t" F* a
  411. * Function:    GpsWeekSecondToModifiedJulianDate. T8 [( r- x; k# Z0 P
  412. * Description: Gps week and second to modified julian date.1 ^( i/ E2 Z+ c; m, |1 e
  413. * Input:       time: Gps week and second.' F  U3 g% }/ T1 z
  414. * Output:  A. B5 l6 X* w) q9 Z3 _9 H8 R3 \
  415. * Return:      Modified julian date.
    ; {3 R* o0 D  l. G& a& r, r2 V+ c+ z
  416. *****************************************************************/! F+ n5 C+ d9 N! V
  417. double GpsWeekSecondToModifiedJulianDate(GpsWeekSecond time)
    3 x- \% v3 f4 ~- w' S. |1 j( V# C
  418. {
    9 {# o) n  U; d3 H- K% u! e
  419.   return GpsWeekSecondToJulianDate(time) - 2400000.5;
    3 G# Q2 D, i$ D) b. o( ]; C
  420. }
    2 s8 p$ S) P) g* w6 s" C1 I

  421. % V7 X% d/ K, R4 d4 p: Q' C
  422. /****************************************************************
    / M$ l3 G0 `. s) T! P
  423. * Function:    JulianDateAddYear! k3 c- h" N/ ^9 y8 C: u6 }" y
  424. * Description: Julian date add year.
    6 B$ S& a" D% p, S0 H
  425. * Input:       jd:   Julian date.0 s* A" p" m0 ^, _& ^0 j+ Z2 h
  426. *              year: The number of year to add.9 F5 B" v6 f9 I( g; U
  427. * Output:
    ; L: g6 G8 H8 T' O; ~5 y/ G
  428. * Return:      Julian date.$ B! P! N) f' P* Y8 G; G( k4 ^
  429. *****************************************************************/, p/ S  o) W" _2 o- n, V- q" C
  430. double JulianDateAddYear(double jd, int year)4 |8 I! P$ G8 y# {; q  I8 g
  431. {) e3 H% L1 q" B5 e* @) q& O  A
  432.   DateTime date = JulianDateToGregorianCalendarDate(jd);$ J0 E8 P& k3 y* S1 C

  433.   o  Y3 Y4 Z% ?
  434.   date = GregorianCalendarDateAddYear(date, year);
    . g. a; N* \' `/ q" o. C" G1 M

  435. " a- ^% n& D; V4 g) W- N" t
  436.   return GregorianCalendarDateToJulianDate(date);
    ' P$ f- F+ Q/ g1 a0 ]7 U4 c( w
  437. }8 w) w# e, J7 c  }. d

  438. 1 m! ^& E* ^, d$ D# P% _9 ]
  439. /****************************************************************7 F! b- F8 d0 [! Q
  440. * Function:    JulianDateAddMonth
    * S' r9 ?' Z* S! A! |) h
  441. * Description: Julian date add month.
    , G) w6 ]* t9 T8 B+ F5 g! G
  442. * Input:       jd:    Julian date.7 t! Y/ ?! D8 v4 K# }( w
  443. *              month: The number of month to add.
    $ _( Z0 h, Y1 V7 T7 @$ [  o
  444. * Output:- ~; Q. D! r) c, g# v% y+ V* y  ^6 R% G, k
  445. * Return:      Julian date.2 ^6 G  ~+ `. Z. r
  446. *****************************************************************/
    6 v- ^* _$ z% `
  447. double JulianDateAddMonth(double jd, int month)4 C4 G* h7 @' v0 ?7 ]/ I
  448. {3 O, O# H. ?% v' V1 E& b  s
  449.   DateTime date = JulianDateToGregorianCalendarDate(jd);  |6 X+ v" p3 ^- X" K

  450. 6 y2 w! S$ A) e  [* T: Q3 Q; g0 d5 O, \
  451.   date = GregorianCalendarDateAddMonth(date, month);
    ) u$ }' ?% Q! j3 u
  452. + h! B6 @, l  O2 E  R2 l" h
  453.   return GregorianCalendarDateToJulianDate(date);
    ' f8 X, Y; [/ \4 n
  454. }4 c& b: h' o9 _8 |! L6 k

  455. & O; v  ^% h  F+ D6 H
  456. /****************************************************************
    " u- U( |) o( T9 n# l
  457. * Function:    JulianDateAddWeek' `) [8 c, r4 I: N
  458. * Description: Julian date add week.5 _9 T; t1 m6 f9 R/ F
  459. * Input:       jd:   Julian date.' j0 B/ z/ m3 t( C- Z9 [  H
  460. *              week: The number of week to add.
    % i8 f4 o$ u3 ]  G- y
  461. * Output:
    , k: `4 [9 c+ B) p
  462. * Return:      Julian date.9 s- S  j5 l! w% D& g8 A
  463. *****************************************************************/7 B" T- Q6 c" z5 S* K. T
  464. double JulianDateAddWeek(double jd, int week)  [3 @. S! ]0 _. [+ o6 W
  465. {
    6 d7 b1 ^2 @- k% e
  466.   jd += week * 7.0;
    # J, h% I% R4 K, D- K
  467. 8 C: a- I  T* x: b+ U+ U7 X' B
  468.   return jd;4 W5 k& w( [5 _' e7 C& L' N
  469. }( Y& T1 x3 d9 A# Z0 F8 e% D0 ~
  470. " k- g9 Q# f$ T& D. O" N0 p
  471. /****************************************************************8 ]# M0 Y1 a5 X3 b' c$ b
  472. * Function:    JulianDateAddDay
    1 P2 K; B0 ^( H$ \( X
  473. * Description: Julian date add day.. I& e" M2 i# @, N8 r" G
  474. * Input:       jd:  Julian date.
    1 e( M1 b6 s8 V
  475. *              day: The number of day to add.$ s  f4 C! B  H2 b, u
  476. * Output:
    8 l/ G4 ~/ j6 t6 o, J9 O3 f, x7 z
  477. * Return:      Julian date.# Z5 Y4 k9 t  r7 _* ^
  478. *****************************************************************/! e. \" Z: s3 e! i' X9 L& {+ E
  479. double JulianDateAddDay(double jd, int day)7 ^- v+ R2 Y- l+ v% n
  480. {
    * n' o8 {8 B5 ~9 ?8 w% x
  481.   jd += day;
    ! A5 `7 N$ W4 W
  482. 0 b3 \: Q# S# y9 K) o$ \' y% G
  483.   return jd;
    ; M1 l2 a* ~* M) Z( x1 i
  484. }
    7 Y' C* T: c/ R+ I9 S; P

  485. 4 ~: a, e8 `( ]' i3 }* D0 Z
  486. /****************************************************************
    , F  g- L1 S# @; T6 `/ w1 h: {' m
  487. * Function:    JulianDateAddHour
    ! }$ _( h. ~% V2 m' X/ s$ R2 V9 X# i
  488. * Description: Julian date add hour.: Y4 H' @. J5 y6 z* @  [6 Q
  489. * Input:       jd:   Julian date.* j" C: i# g! `8 s3 j
  490. *              hour: The number of hour to add.
    ; K7 ~  A: }+ W3 f2 D
  491. * Output:
    4 c+ b3 X2 J' S2 d- D
  492. * Return:      Julian date.
    1 u- J1 w2 T  l8 B3 \# ~! p
  493. *****************************************************************/5 f" x' }3 }5 i$ s+ I9 H) d; s
  494. double JulianDateAddHour(double jd, int hour)
      I0 K! c# u8 Z- I9 m- P. D( }. _
  495. {
    # j& b& Q" t& Z8 C  b) c7 _
  496.   jd += hour / 24.0;
    ! n- m4 W+ A; L- s/ \' h+ P4 e7 E

  497. - C# K; C; J6 ~, U
  498.   return jd;; j, v6 l+ O- ]3 t
  499. }0 n2 v6 O  Y, E# J5 U) a& K+ t
  500. 6 e5 h3 V3 M* @" w- u8 P
  501. /****************************************************************3 H! v! A# E: J% I$ W
  502. * Function:    JulianDateAddMinute* Z; T, d5 B) W& j
  503. * Description: Julian date add minute.1 d* C; r- L' i0 ~9 w; X8 }
  504. * Input:       jd:     Julian date.
    - s9 [+ R4 G* \! P! U( c$ b
  505. *              minute: The number of minute to add.
    6 K( i- ?' ]7 H5 `4 c& j7 V3 ?% Z) L4 Z
  506. * Output:" \. _( K8 y( o9 B
  507. * Return:      Julian date.
    ' s" \6 \$ b4 n! `* ]
  508. *****************************************************************/" |, P. v. V, O" T. d* I
  509. double JulianDateAddMinute(double jd, int minute)
    ; G( L0 G2 S% C, r; j
  510. {( }) q% ~% ]# t6 h
  511.   jd += minute / 1440.0;% H! P) D" g5 e+ n2 q% v" y+ d6 R

  512. * j9 o& ]8 }7 W
  513.   return jd;
    1 ^8 w* b, a. Z! b8 K2 Q
  514. }
    - w; b& j$ d7 F7 B
  515. % w6 J5 K% H, ^  W
  516. /****************************************************************- p/ j  D8 v5 ?5 Y+ W4 q2 q" M
  517. * Function:    JulianDateAddSecond
    " i. A7 Y* h. \: |) i8 z& ~! [
  518. * Description: Julian date add second.' U8 {- ^. e& b" B
  519. * Input:       jd:     Julian date.
    8 z  p! b; p' A" H$ r
  520. *              second: The number of second to add.% M/ T- a' t  ]. Y7 X
  521. * Output:
    9 t. l( E/ E3 ]" n6 S- I' F
  522. * Return:      Julian date.
    0 y! h- s/ y3 a; Z* s' B5 S
  523. *****************************************************************/. m0 A$ t( C1 c
  524. double JulianDateAddSecond(double jd, int second)! G8 ^! t5 j. T( S/ L. Q
  525. {; G, E! A% P; ^8 k/ n9 i
  526.   jd += second / 86400.0;, d* O* x* }1 Y! J; L) n# [

  527. 3 }! B! f% r" K8 X! N. S
  528.   return jd;
    ' L" ~; R0 i/ o1 B- H
  529. }
    " X0 e; y0 _8 n2 d, L# U3 `
  530. ) E. i5 c6 z6 [  A
  531. /****************************************************************# D1 o; T6 G, t6 g$ _
  532. * Function:    JulianDateToGregorianCalendarDate8 \- f6 Z: U8 A+ v5 |8 q- E  F
  533. * Description: Julian date to gregorian calendar date.' p: E, k/ N  n# h$ D! p# ~
  534. * Input:       jd: Julian date.$ D8 o+ _; d: \/ x  ^& F5 {
  535. * Output:7 ~' K& H- c6 J% P1 m# q/ ]0 n5 {
  536. * Return:      Gregorian calendar date.
    7 }2 l  l# E2 [4 @  A  S/ ?7 Y
  537. *****************************************************************/; e! ?2 m% w! v
  538. DateTime JulianDateToGregorianCalendarDate(double jd)6 q, p% H3 C8 o2 x9 w4 C8 ]5 t! I, D2 I
  539. {+ ?  G6 R1 `, B- M/ R
  540.   int y = 4716;
    # Y2 Q* u/ e2 M/ h8 n" r% F
  541.   int j = 1401;
    8 p& K  t  D/ c2 M
  542.   int m = 2;
    " p& e' C3 E' b4 ]) z0 m, H
  543.   int n = 12;
    3 g6 b3 p) o) P9 I$ U" \
  544.   int r = 4;4 q. B% ]2 I, H- E7 `6 B% r
  545.   int p = 1461;0 r# _( T# D6 i
  546.   int v = 3;, v0 C/ W3 d# e. b$ `) c
  547.   int u = 5;& y. u/ z; {, ~: p( k
  548.   int s = 153;
    7 l5 S0 S# a" [$ ^+ K! v* D# u5 |
  549.   int w = 2;
    * q6 i/ i9 F' C" x9 [
  550.   int b = 274277;
    4 V* K+ r$ U- f: N/ s
  551.   int c = -38;: s2 A' U9 K5 I/ }3 m! Z( B
  552. ' ^) t2 E' E& S* d; U1 u
  553.   int jdn = (int)(jd + 0.5);+ Z" a# @' B9 i& ]9 p$ ~6 ~
  554.   int f   = jdn + j + (((4 * jdn + b) / 146097) * 3) / 4 + c;
    $ f! Z9 ~6 d$ [& n; ~$ U1 ?2 X( B4 o
  555.   int e   = r * f + v;
    , s9 a& l+ D7 m% C  O) t/ D* m
  556.   int g   = (e % p) / r;- B1 K+ w3 L) m3 @* p: |
  557.   int h   = u * g + w;- t4 n  I  y/ }. ^, Z6 R
  558. 0 i$ n! Q7 o9 e/ Z
  559.   DateTime time = {0};
    1 {/ F3 z, r+ ]& Q5 D6 V

  560. & v6 m3 X: O3 x. N0 o6 a# x
  561.   time.day    = (h % s) / u + 1;
    $ e) _4 Y# {: x# j! I# E
  562.   time.month  = (h / s + m) % n + 1;, s. G! L3 X) N  Q
  563.   time.year   = e / p - y + (n + m - time.month) / n;9 k: }' r# _9 z* R5 `: Q; O
  564.   time.hour   = (int)((jd + 0.5 - jdn) * 86400.5) / 3600;6 l6 \3 b* Y: M% N, V) q
  565.   time.minute = (int)((jd + 0.5 - jdn) * 86400.5 - time.hour * 3600) / 60;
    . {) c4 [7 g3 H; C6 |1 x
  566.   time.second = (int)((jd + 0.5 - jdn) * 86400.5 - time.hour * 3600 - time.minute * 60);
    . C8 M/ z9 D9 J  s' w  t' v

  567. 1 Z1 w" N5 p* h: V) r
  568.   return time;0 W1 T2 U3 p8 H/ `% N7 u0 |7 b
  569. }
    " ]) x2 z5 H/ f

  570. + ]' Q  Q& U2 k. j" y* U" F( S2 k( ^
  571. /****************************************************************7 [0 |5 M8 G8 P
  572. * Function:    JulianDateToGpsWeekSecond9 y  Z! ]' ^1 {
  573. * Description: Julian date to gps week and second.2 s( Z# v: W  |: r8 j, {2 K
  574. * Input:       jd: Julian date.- _1 v( u4 y( Z6 \0 v
  575. * Output:( r1 N3 l. w4 t, w+ b6 F& X
  576. * Return:      Gps week and second., n7 T9 b* Y) T
  577. *****************************************************************/! o- n" H- O/ _! Y
  578. GpsWeekSecond JulianDateToGpsWeekSecond(double jd)9 N, x+ {- v5 b
  579. {
    % u9 |( c1 P. R& y2 U
  580.   GpsWeekSecond time = {0};
    ( b- U0 `+ Y. O/ R
  581.   DateTime      date = JulianDateToGregorianCalendarDate(jd);
    ' c) G$ Z/ e' D2 L. I
  582. 9 V0 |$ H3 m0 I9 N" I! u  u
  583.   time.week   = (int)(jd - 2444244.5) / 7;
    % d& ?5 N+ A1 K8 F: z9 d' [4 N
  584.   time.second = ((int)(jd - 2444244.5) - time.week * 7) * 86400 + date.hour * 3600 + date.minute * 60 + date.second;
    / |- W6 S7 _0 k

  585. - v3 V4 ~; S  ?8 x' Q5 T, i8 I
  586.   return time;
    , q. _' [9 s# A
  587. }7 w. ?# |) l8 o! k1 y) j0 n
  588. : s1 e- K" i& P2 R: f9 q
  589. /****************************************************************
    * ^; Y( m  }9 q" V0 g
  590. * Function:    JulianDateToModifiedJulianDate
      a0 E) `6 W0 W2 p
  591. * Description: Julian date to modified julian date.4 t. n3 L" v8 P0 g4 g' d; d$ ?  ~
  592. * Input:       jd: Julian date.. }# t. P1 ^0 U! z
  593. * Output:+ T& v* \+ ?0 ~" J1 R/ S
  594. * Return:      Modified julian date.
    7 z2 M4 _( u7 P/ }
  595. *****************************************************************/
    , y7 e* ~1 p; K* ~" m% ?; }
  596. double JulianDateToModifiedJulianDate(double jd), U2 H. w- e0 ^) S) ~
  597. {
    3 c$ [" `7 {* {
  598.   double mjd = jd - 2400000.5;
    + g/ c- m" V) h/ \" Z( V- O

  599. & p, r! W( H) J! x
  600.   return mjd;
      Q+ D0 ]' {. u8 F
  601. }! C, e5 K: }' Y( z

  602. 0 q2 [7 P- g0 f0 M  ^
  603. /****************************************************************0 N; p( Y5 F' s/ n# j+ q) Q
  604. * Function:    ModifiedJulianDateAddYear' x& l# ~( b- G2 o, j7 K: i
  605. * Description: Modified julian date add year.
    5 ~& S* M: ^9 K0 [/ t- T  U6 s
  606. * Input:       mjd:  Modified julian date.- p4 v9 u- ?' C/ t2 B  U# e2 b
  607. *              year: The number of year to add.! q" c3 H) q0 k  t2 {- W
  608. * Output:5 X% y; U7 S# M9 W& K
  609. * Return:      Modified julian date.5 h7 }' n5 t. i) l9 }
  610. *****************************************************************/
      p# u6 A* X! q' N. h
  611. double ModifiedJulianDateAddYear(double mjd, int year)
    ; q6 o, Z+ j( X; w) I7 R: ?
  612. {2 M$ B  t; p: ?$ ^, ?
  613.   DateTime date = ModifiedJulianDateToGregorianCalendarDate(mjd);
    9 W: C* ]: C0 r2 S/ ^+ Z

  614.   s1 J' j: V) ^
  615.   date = GregorianCalendarDateAddYear(date, year);8 n& X4 Z) w- f/ V# C, e
  616. ; l% Q+ ~* C2 S# x' `4 |9 @1 k7 w
  617.   return GregorianCalendarDateToModifiedJulianDate(date);. N2 B, w- e0 i
  618. }( j) X) G/ M& I1 _# h6 u7 N
  619. $ @5 s( P3 ]" t/ J3 o& l* h1 @  A
  620. /****************************************************************7 R# b7 P& z$ Y9 M  c4 b4 S& r
  621. * Function:    ModifiedJulianDateAddMonth8 e; X1 b8 \9 M1 O6 o
  622. * Description: Modified julian date add month.
    ; m3 A6 @$ ^  X' ~9 t& ~
  623. * Input:       mjd:   Modified julian date.
    . ^7 l, O; r$ U
  624. *              month: The number of month to add.
    : u' N4 Z3 c* {' Z
  625. * Output:
    9 m+ r6 E) {) d+ ?. L+ ~
  626. * Return:      Modified julian date.
    7 A2 a2 h  c2 q
  627. *****************************************************************/
    . m. |' {1 a4 y0 s3 O
  628. double ModifiedJulianDateAddMonth(double mjd, int month)& Z! {# B, B! y# V7 a  V* G- c- M
  629. {
    , Q# U6 A& H; I+ J
  630.   DateTime date = ModifiedJulianDateToGregorianCalendarDate(mjd);
    - }$ v+ T0 j, ~! k
  631. * ]+ T- Y' |) h" R- `
  632.   date = GregorianCalendarDateAddMonth(date, month);
    + n4 x6 q" |2 ], e; p* q( {

  633. 0 r# [, w- Q1 D5 X' q8 f
  634.   return GregorianCalendarDateToModifiedJulianDate(date);
    ; f7 n' h  ^+ f7 S0 {5 @
  635. }& c$ K" K" [, W2 z+ _
  636. $ ]; j( G( N# _" n+ H0 G
  637. /****************************************************************; V# b. H' z, M/ }
  638. * Function:    ModifiedJulianDateAddWeek
    . B% K+ l( k3 u: E4 J" Y
  639. * Description: Modified julian date add week.+ U/ ~& Z1 f! H& |; `) F; Q
  640. * Input:       mjd:  Modified julian date.
    . f5 P" A% g% l- d% \" A3 i/ i
  641. *              week: The number of week to add.
    . p$ U/ ]1 b1 y
  642. * Output:
    0 F( t9 W6 j0 t
  643. * Return:      Modified julian date.9 }1 o* T2 w3 ?* U
  644. *****************************************************************/
    0 v: O9 d# ?* Z) T0 Z
  645. double ModifiedJulianDateAddWeek(double mjd, int week)2 t/ b( `' e- }1 f
  646. {
    % E# N8 F. |" |# N) b& l" ]+ {+ n
  647.   mjd += week * 7.0;; k3 W( `1 v9 C3 y8 K7 ?- m

  648. 0 v5 W( h! a7 K
  649.   return mjd;
    ) X5 _, @8 L, b+ _1 f& y
  650. }' V! \* A& Y7 J; J

  651. 6 h( [4 X# g- K& Z4 l
  652. /****************************************************************
    5 Q5 L# N6 O6 X
  653. * Function:    ModifiedJulianDateAddDay
    - j- s+ D$ g* u0 t
  654. * Description: Modified julian date add day.1 H2 t1 F7 v$ h8 ^  w. @( t% w
  655. * Input:       mjd: Modified julian date.
    ) c& I# j0 p' r; b9 K: G) j9 R
  656. *              day: The number of day to add.
    * b+ n. a5 z+ d$ r. Z
  657. * Output:
    # I0 L" \: ]& b! n
  658. * Return:      Modified julian date., t; n8 C: V3 @6 ?, M; e! I
  659. *****************************************************************/. n6 I& Z' G" t8 V% A
  660. double ModifiedJulianDateAddDay(double mjd, int day)
    ! q. p' d* c' g4 b# R# G
  661. {6 o, }3 y1 g2 r
  662.   mjd += day;
    3 S% X% m' C6 l
  663. ; z9 d: u: Q. l% ?, }( Q& d$ z
  664.   return mjd;
    - V' K; c. `) A$ s) b
  665. }
    + J$ U9 J# Y: \
  666. * ~4 M* o/ U" D! W& N9 b+ ^) W
  667. /****************************************************************
    & G$ Y  m0 B/ ]
  668. * Function:    ModifiedJulianDateAddHour
    ; x% w% A4 H) P
  669. * Description: Modified julian date add hour.
    2 f+ ~; N$ k$ Y# ]
  670. * Input:       mjd:  Modified julian date.
    $ n( ^) k+ M3 v7 }
  671. *              hour: The number of hour to add.5 Q& F" G/ l6 T0 K+ k
  672. * Output:+ k" M7 u2 d: Q$ c  a5 B- @3 O4 v
  673. * Return:      Modified julian date.
    ) m: A2 }# Y7 p
  674. *****************************************************************/
    5 y$ u- j3 c4 k" N$ g6 d$ @
  675. double ModifiedJulianDateAddHour(double mjd, int hour)
    , n2 R4 r+ K& ^, Q; d) K! V" ]! U: H
  676. {
    1 f+ e; r6 `! s( y, k
  677.   mjd += hour / 24.0;
    7 t4 \8 O! i; c8 y
  678. 9 E, |' ?2 S. D; k
  679.   return mjd;, s  z. v3 |' G. V3 w  c( C" L
  680. }
    & o" Z! Y$ Q1 [9 Q0 p2 Q1 w  S

  681. " M2 W* ^2 d7 w9 L0 b9 K/ C; ~* d
  682. /****************************************************************
    % K" P( B% |  d6 X0 |
  683. * Function:    ModifiedJulianDateAddMinute
      F8 L+ t4 ]  ?: H( s2 V. `
  684. * Description: Modified julian date add minute.6 n! r9 a7 I# k
  685. * Input:       mjd:    Modified julian date.. m" S/ o  S7 X. r; o' N
  686. *              minute: The number of minute to add.
    # g) t) h5 A  V: X6 n6 I; u: c
  687. * Output:$ Y. @0 r/ m3 \8 F. v# O
  688. * Return:      Modified julian date.# f# j% L& D- _5 {1 t
  689. *****************************************************************/8 t; O2 r) S9 k) E# s
  690. double ModifiedJulianDateAddMinute(double mjd, int minute)6 u4 c6 h* ]# E6 m' |& o& k
  691. {( G* d; j' S; c1 v& E7 _8 K" p; r
  692.   mjd += minute / 1440.0;$ o, N) @) W' o
  693. 5 o' ?8 H" ~/ Z) U! ~) T/ n
  694.   return mjd;+ n: d4 u% x9 Y4 @
  695. }, E8 a( ^/ \: w- V- s4 L

  696. + i7 O! _  w+ f" a0 Q& P
  697. /****************************************************************
    1 `) p. F2 t# E3 `  L% [
  698. * Function:    ModifiedJulianDateAddSecond
    1 Q7 M. S0 m: e: _) `
  699. * Description: Modified julian date add second.
    ) [+ ?% }/ @; k+ w
  700. * Input:       mjd:    Modified julian date.$ p3 T* F; a5 }) E" t% S' K# D
  701. *              second: The number of second to add., L; |0 T3 O: ^& l
  702. * Output:: C- r5 U, e) \
  703. * Return:      Modified julian date.
    1 N) X) a) A0 z" j2 }+ [9 ^
  704. *****************************************************************/
    1 `9 O! ^6 Q6 P& G! B5 l
  705. double ModifiedJulianDateAddSecond(double mjd, int second)! {, N* J7 {. k; k# d
  706. {
    ! ~  m; c$ A- L! o- Z: g
  707.   mjd += second / 86400.0;
    # b8 q" r" @, H1 B5 U
  708. 2 f& C/ z& X1 z
  709.   return mjd;
    ; O' j; i9 z% f+ Q8 S
  710. }
    + u- {' H+ ?" k3 c; i' r2 ]
  711. . m3 f) W( @- F1 R3 r& i3 e
  712. /****************************************************************
    ; c8 L# z) Z0 r1 L
  713. * Function:    ModifiedJulianDateToGregorianCalendarDate) _4 Z4 U6 `! ~# k
  714. * Description: Modified julian date to gregorian calendar date.
    , W0 [1 ?% t3 V- d
  715. * Input:       mjd: Modified julian date.
    ( H! v( D! B/ K5 R; j( |( U' b4 u0 j2 n
  716. * Output:% E1 o+ f" e% U8 v
  717. * Return:      Gregorian calendar date.
    ) m( f& k: }# t- V# Z# v$ ?3 y
  718. *****************************************************************/- z4 {9 R4 r8 W9 {
  719. DateTime ModifiedJulianDateToGregorianCalendarDate(double mjd)% R7 H* m6 ?, q- Q4 D
  720. {
    ' f7 k! m8 `$ p$ j) E/ p# n
  721.   return JulianDateToGregorianCalendarDate(mjd + 2400000.5);, K* T% q- P7 b$ s7 ?
  722. }
    % v- u3 h" y# w- r9 E
  723. * @, c) y" B6 n' H: `
  724. /****************************************************************6 `; b, e7 V2 G0 F
  725. * Function:    ModifiedJulianDateToGpsWeekSecond, ?5 g8 g. e: x# H3 v) C! b
  726. * Description: Modified julian date to gps week and second.
    6 o) ^; c8 F7 @! d: W
  727. * Input:       mjd: Modified julian date., K. I; ^; T3 i# Y! ~' d
  728. * Output:
    : i6 A6 X5 ]6 ~' y2 x8 z  e, w
  729. * Return:      Gps week and second.
    % {! i: A7 D  ?( v
  730. *****************************************************************/
    ' B9 b" n" Q! g9 F1 p
  731. GpsWeekSecond ModifiedJulianDateToGpsWeekSecond(double mjd)
    ! O. L. |" {/ Y7 }* ^
  732. {& T( ~' H0 _. l* a" ]. ]
  733.   return JulianDateToGpsWeekSecond(mjd + 2400000.5);
    ; B: e, p# @8 g. F$ J1 `4 Q8 m
  734. }
    * J5 k( \" {0 P" {/ g

  735. , f( @: `( p2 k" A. J. Z
  736. /****************************************************************
    ; ]2 a* B) f. v5 b+ R+ W0 [
  737. * Function:    ModifiedJulianDateToJulianDate
    1 }2 ?# j6 J; e. ]. j) |7 ?
  738. * Description: Modified julian date to julian date.
    3 @: w6 q+ N6 t% }+ o2 B
  739. * Input:       mjd: Modified julian date.' N- W8 N$ d) K; c& n3 E2 x
  740. * Output:
    , W! q: h/ M" \7 W; {" r
  741. * Return:      Julian date.7 e. c6 B) d$ L7 l1 m
  742. *****************************************************************/; a( O! G8 n4 g/ D4 S3 m
  743. double ModifiedJulianDateToJulianDate(double mjd)) r1 d; h6 p4 x
  744. {& A* j1 L4 s1 J7 i% O4 C
  745.   double jd = mjd + 2400000.5;
    ' L  J7 h* }1 O8 {7 \# N& ?

  746. ( _! r0 n/ n7 p2 [3 l
  747.   return jd;4 ]- m5 P2 X0 b7 V2 @
  748. }
    3 b  \7 Y4 n. z- r8 g  h* j
复制代码
7 K" e# i! E8 _: A# ]3 |
      main.c文件7 P2 q9 n6 [5 o9 ^0 _* d8 a
  1. /****************************************************************1 G! W& i* p: t8 ?) \
  2. * Copyright (C) 2017, XinLi, all right reserved.
    ' Z0 h/ \4 M+ C5 [: ]
  3. * File name:    main.c. E7 b% p* V5 E4 B& ]
  4. * Date:         2017.10.17
      k% n4 x9 O; S
  5. * Description:  GPS, UTC and local time displays.: n' T3 {  i$ b
  6. *****************************************************************/
    4 E: B9 J- ^2 V8 e; O

  7. ' R% a; J8 X) ?- K
  8. /****************************************************************
    0 ~. V- K& `0 H( C% o
  9. *                        Header include
    " S( T1 |! l& M; l7 G6 o4 Y6 f( T
  10. *****************************************************************/
    - z! X- \" {0 u) @$ |6 j  L8 G8 r
  11. #include "DateTime.h"0 y/ Y+ Q" d) a, o' @6 K
  12. #include <stdint.h>
    0 Z8 h! p0 g( Z4 Y# y! \
  13. #include <stdio.h>% `5 E; P3 `  ~( ~1 ^: x
  14. #include <time.h>
    * ]# w+ W9 j( `3 c4 F! p+ |
  15. #include <windows.h>4 q! A9 @' {0 N- w5 m4 V! o# x* {* S

  16. 5 m& W$ |, Q& \1 L
  17. /****************************************************************
    - b9 ?5 k. d2 Q! E3 _# C
  18. *                       Global variables1 h% n. W# M3 f1 a- h
  19. *****************************************************************/
    1 H* A& }0 S" N5 t
  20. - y6 n5 s! {( X6 ^. P

  21. 6 d$ s8 a2 {3 s$ M9 ]
  22. /****************************************************************2 i# k; c% O. h5 L
  23. *                     Function declaration. `: I( ?1 j/ [
  24. *****************************************************************/- f7 _% E! x, O, U4 v& t
  25. static void gotoxy(int x, int y);
    ! q3 w$ {3 o  [# u

  26. ; s3 h" E7 M- j/ L' Q+ j% C
  27. /****************************************************************! i  R" X* D# C) a6 x% z1 n: b
  28. *                     Function definition
    # q" N9 c: J7 b1 k: ^- D% {
  29. *****************************************************************/2 S- f" u6 P$ }5 J
  30. " x+ r0 f8 d! Y; D+ W& D! C
  31. /****************************************************************
    ' c1 F6 O' [: }7 @
  32. * Function:    main
    3 e3 \* |" e1 z/ g
  33. * Description: Program entry.3 W5 X0 l# T$ m! V5 ?
  34. * Input:
    - E0 @3 E! ]) i% H- Z
  35. * Output:3 h- I' t6 n1 C, P' W- i& h/ n* O
  36. * Return:
    6 G, K6 |8 B) H4 c3 A( H, y- V: p
  37. *****************************************************************/: h9 A! N. w7 Z  Z
  38. int main(void)  s5 B$ p% i- {
  39. {/ P# g5 A, l) U: b
  40.   for(;;)
    1 C3 u6 A' f' r
  41.   {
    7 `. Z% K$ S. D
  42.     time_t        times     = 0;
    8 ~$ n3 ?6 I5 M% o
  43.     double        mjd       = 0.0;5 M" Y; y( v0 |+ G( K' S
  44.     DateTime      utctime   = {.year = 1970, .month = 1, .day = 1, .hour = 0, .minute = 0, .second = 0};! j1 x4 J( n# P0 Q
  45.     DateTime      localtime = {.year = 1970, .month = 1, .day = 1, .hour = 8, .minute = 0, .second = 0};
    . n! p- |1 q( m6 Y& D
  46.     DateTime      gpstime   = {.year = 1970, .month = 1, .day = 1, .hour = 0, .minute = 0, .second = 0};( ~! G; Z4 t4 x( V/ D. c
  47.     GpsWeekSecond gpstimews = {0};
    " R4 p, l8 g0 Y* v

  48. ; h* A3 l% T: J0 j5 T" M0 T: @
  49.     time(×);+ \  n, ^' L5 y* g, v) J0 ~+ a, T
  50. 4 y; A- W# {9 a9 L, A0 g
  51.     if(times > INT32_MAX)( S$ t9 A5 b6 H. [0 `" U
  52.     {) h; @( P6 L& _: L3 I% |
  53.       utctime = GregorianCalendarDateAddSecond(utctime, INT32_MAX);
    3 @  s( v1 c  j3 X. @
  54.       utctime = GregorianCalendarDateAddSecond(utctime, (int)(times - INT32_MAX));* r& v$ Z. [4 O7 m+ n
  55.     }
    ) ^; }. k4 O' M6 h/ X% o! X
  56.     else
    5 R0 p" v' v! E/ P2 k
  57.     {! }) S  u; s" H  D% f
  58.       utctime = GregorianCalendarDateAddSecond(utctime, (int)times);
    $ p$ E% L9 w, j: R# d7 v8 {# k
  59.     }
    5 c; X% X& e+ k6 b7 h" }7 X: r
  60. ' }3 s5 v8 {( r6 ^
  61.     mjd       = GregorianCalendarDateToModifiedJulianDate(utctime);
    6 `$ O, N4 `1 N, v! u  f  f
  62.     localtime = GregorianCalendarDateAddHour(utctime, 8);& r2 M* Q! |( e1 x9 M( P
  63.     gpstime   = GregorianCalendarDateAddSecond(utctime, 18);
    6 }3 j+ x5 ^3 p6 a3 v$ u0 q
  64.     gpstimews = GregorianCalendarDateToGpsWeekSecond(gpstime);# J; B% h# [+ B+ g$ t6 l

  65. ( H) Z# P) V/ ?4 O4 |7 N5 G% z, T; I
  66.     gotoxy(0, 0);
    % X, ?% ^4 ~& ^: i7 c! V# h1 }
  67. 8 F3 i& q# N$ a- ~
  68.     printf("Local | %d-%.2d-%.2d %.2d:%.2d:%.2d | timezone UTC+8\n",
    . e0 x- F/ R0 C1 [4 |
  69.            localtime.year, localtime.month, localtime.day,
    2 U1 \5 D' a( j. e; C. `
  70.            localtime.hour, localtime.minute, localtime.second);
    ; b# k! y3 ?; O+ A

  71. 1 Y4 G& a& i, V% ]8 X& G
  72.     printf("UTC   | %d-%.2d-%.2d %.2d:%.2d:%.2d | MJD %.5f\n",2 W* i9 o7 {8 v6 l. ~
  73.            utctime.year, utctime.month, utctime.day,: M5 z; K( S$ G$ K3 A) E
  74.            utctime.hour, utctime.minute, utctime.second,2 I7 r! T8 C) B; `. |
  75.            mjd);
    # r, x6 e9 P6 G
  76. 3 [+ f  g6 ?+ N7 L) N, S, N! C" o
  77.     printf("GPS   | %d-%.2d-%.2d %.2d:%.2d:%.2d | week %d %d s\n",7 {; D3 ~# X5 L
  78.            gpstime.year, gpstime.month, gpstime.day,
    - o% U9 `! n5 t( p- K9 I
  79.            gpstime.hour, gpstime.minute, gpstime.second,( H1 S) Q* i% l; G: j+ w
  80.            gpstimews.week, gpstimews.second);+ q; h( h- p, H6 f
  81. 1 c- J* D8 w/ I( w% f5 B
  82.     Sleep(100);, a5 M* O7 v" Q& P9 S+ {
  83.   }
    ; [. H, g; K, ]$ P) w* E& E
  84. }
    / L- l* T, `$ L

  85. $ @7 b- e# B, {/ `2 M
  86. /****************************************************************2 x# A5 q( ?% r- w) k5 P  y$ ^
  87. * Function:    gotoxy
    4 y: Q) D0 h  X( ]9 h' A
  88. * Description: Move the cursor to the specified position on the text screen.
    ; l5 Y0 K% y2 B- V- \, ~# Z, Y! X
  89. * Input:       x: X axis coordinates.7 D8 y+ U! e  p& O8 ]( h
  90. *              y: Y axis coordinates.
    ) X  c4 T8 H6 ~$ o3 Z1 f. T
  91. * Output:
    1 t, P5 T. @4 l& }$ t) E' _
  92. * Return:  p0 B3 A; w( s' e0 \2 `
  93. *****************************************************************/9 Q% ?2 N) j0 |2 `. w
  94. static void gotoxy(int x, int y)
    3 U) [2 y4 c% a7 M+ Y' V
  95. {
    ( ?3 u& A, u# r# R$ |
  96.   COORD  pos  = {x, y};
    " N- E1 O# b1 G. b! M
  97.   HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    ( r9 Q8 F- d5 I5 @: \& O5 _& \0 Q
  98.   SetConsoleCursorPosition(hOut, pos);$ O" D) l" Q) h. h2 L% h8 @5 G
  99. }
    7 |5 [) l1 K0 S3 J9 j- I1 T
复制代码
& m7 s# A6 _, v' w1 E! c4 p8 t
3，运行效果0 x1 Z1 E* P8 \7 G( E
RunningResult.jpg
& E( {* m: c1 V/ B
/ G7 y: G7 d# l  N* ~! i
赞 收藏 评论2 发布时间：2018-2-2 21:41

举报

2个回答
hawk123345 回答时间：2018-3-2 11:20:09
谢谢，学习了
赞 评论
XinLiYF 回答时间：2018-3-6 22:43:46
可以直接移植到嵌入式端，非常方便。
赞 评论

所属标签

关于
意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
STM32N6 AI生态系统
STM32MCU,MPU高性能GUI
ST ACEPACK电源模块
意法半导体生物传感器
STM32Cube扩展软件包
关注我们
st-img 微信公众号
st-img 手机版