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

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

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

[复制链接]
XinLiYF 发布时间：2018-2-2 21:41
GPS，UTC和本地时间的显示器
2 F3 Y) k9 w5 M, X" N

& w" ]5 A9 Q& |3 J$ R2 I* f转载来源：GPS，UTC和本地时间的显示器8 F. R1 F# N* U

$ C8 k$ Q: K$ n8 V% x8 OGitHub仓库：http://github.com/XinLiGitHub/GpsUtcAndLocalTime
, X4 L+ _" `, Y8 GPS：博文不再更新，后续更新会在GitHub仓库进行。
) |' q& h1 P: s- x& v" p+ w' A. {% Q
      GPS，UTC和本地时间的显示器。程序中涉及到朱利安日期的转换，详细介绍见维基百科[Julian day](http://en.wikipedia.org/wiki/Julian_day)。; y: \$ e8 v8 i2 H

7 k# A, b6 w* W  u1，开发环境/ @$ z* E0 v. [6 ~. e. {
      1，操作系统：Windows 10 专业版, G6 N' u6 Q$ Y( Y, x) v5 [% K! w& z
      2，IDE：Visual Studio 2015 专业版- k0 O9 t  M* p( t. R
$ X7 f  z5 \6 F0 _" {; q7 a" q9 }
2，程序源码
' f9 v' I7 w% J3 u3 T9 E$ x      DateTime.h文件- Z+ h* U7 k0 V

' d( H; s$ S/ G0 T8 P( G
  1. /****************************************************************
    6 J2 n+ ~6 N; g# O; H; B+ z
  2. * Copyright (C) 2017, XinLi, all right reserved., h( ^2 x  A+ B. q2 x% r
  3. * File name:    DateTime.h! l( h6 u4 Q0 A8 ^- t
  4. * Date:         2017.10.17
    5 e5 b3 I, n; C
  5. * Description:  Date and time module header file.
    - h, n( b5 u0 t% {6 h9 d( I
  6. *****************************************************************/
    5 m. |+ A  A$ o; b0 ~
  7. 8 a- L% T' v* `% s+ J
  8. #ifndef __DATETIME_H
    + T/ k# H+ `" D: G7 g
  9. #define __DATETIME_H
    - ]& X! z1 i% a5 H& i- G
  10. ' m  K; s9 q, Y( i" o
  11. /****************************************************************
    6 @3 ~, f6 l! a( N
  12. *                        Header include
    4 |) q1 q: M9 a, @
  13. *****************************************************************/
    7 N+ @; e# {; P  Z; Q4 f& w: s! h. z
  14.   W, n7 ?6 C# Z) g) q8 ^

  15. 0 V3 J+ _. l4 [& v; D# G
  16. /****************************************************************
    ' O, b' D: W" s! M: ^
  17. *                       Macro definition! d/ X$ R# U. T$ q% U6 M
  18. *****************************************************************/
    5 e3 L3 |0 D  n
  19.   @% p- ]8 Z! g

  20. 3 i$ w; J# @7 e% ~
  21. /****************************************************************' B% s* t* c1 R" W6 q
  22. *                       Type definition# h# f9 L2 o, Q3 p3 q
  23. *****************************************************************/
    & Z# {+ Y, R' r, d2 G

  24. ) o$ g+ R- I4 n8 \; u3 m! Z
  25.   U4 D0 b( p% }5 G, D4 z
  26. /****************************************************************
    * _/ @* r+ a! j0 [( ?
  27. *                     Structure definition
    % [* t: |4 `. w$ H& ^+ ^
  28. *****************************************************************/
    ' n3 z/ U1 a( k6 ~
  29. typedef struct
    , O; r0 L  b4 M& B
  30. {/ Y. n2 s; n* e3 b/ m: H
  31.   int year;
    3 A0 k0 v7 w9 `* A5 X3 _
  32.   int month;! `- B" f, _& j* q' n
  33.   int day;1 w- s  _) h8 v- ^" T" j! _- T8 b
  34.   int hour;
    ) m" Z! N; F* b7 a$ O
  35.   int minute;
    / B6 Y  g7 E7 W- k, L4 f! x& K$ x
  36.   int second;8 R2 q) e; E; X
  37. }DateTime;$ F5 _& S7 h& j" ?& f

  38. # C2 A6 {/ C7 F  l+ Q9 ?. M. U
  39. typedef struct
    2 R, m  ^9 M1 P, r
  40. {0 ~  z; q' i( J
  41.   int week;& A$ I& x4 z3 l+ s2 T
  42.   int second;
    ' m; w9 ^( }$ C9 [# M
  43. }GpsWeekSecond;; Z7 v* Z( k- s3 I

  44. ) A9 S, G5 s+ J: ], ]
  45. " d* Z& y- n& {0 H/ g7 g3 E
  46. #ifdef __cplusplus5 r7 z* _6 A2 Q4 ^5 a5 N) j% P
  47. extern "C" {& P% l: F0 d3 R; D; H, o1 V
  48. #endif  /* __cplusplus */& z& Y9 [- H4 K* @4 t* A

  49. " R) N% }/ Y+ U2 y3 S0 |
  50. /****************************************************************! J+ \# O$ S  x( B2 x3 B9 ?
  51. *                     Variable declaration( S. B5 I- W% y2 w) C5 b
  52. *****************************************************************/- R  l5 p3 t  f  q* K* @* Y
  53. . D$ |" A! J: E& b
  54. - `% j; o0 `3 ^8 I8 R
  55. /****************************************************************
    ; d) k% t% l( U+ m1 ^+ {) j$ R
  56. *                     Function declaration) b! x( q1 r, {: T# H
  57. *****************************************************************/
    % l6 n1 n) |1 u8 [
  58. DateTime GregorianCalendarDateAddYear(DateTime time, int year);0 d3 Z' u# Y; X' j) g  K; K5 q
  59. DateTime GregorianCalendarDateAddMonth(DateTime time, int month);+ K' i2 \) p- A, ]
  60. DateTime GregorianCalendarDateAddWeek(DateTime time, int week);
    4 }' w& G6 |2 ^7 }2 F/ S& Q3 [( H
  61. DateTime GregorianCalendarDateAddDay(DateTime time, int day);" ]4 N  z  l+ g9 w& e
  62. DateTime GregorianCalendarDateAddHour(DateTime time, int hour);
    2 T. a+ v- g: I2 T
  63. DateTime GregorianCalendarDateAddMinute(DateTime time, int minute);
    , n# C3 n# f' E  H% d( a# |- z5 _
  64. DateTime GregorianCalendarDateAddSecond(DateTime time, int second);$ W; x" ?4 X, Z/ \
  65. GpsWeekSecond GregorianCalendarDateToGpsWeekSecond(DateTime time);
    " R! z2 o% Q& z+ j
  66. double GregorianCalendarDateToJulianDate(DateTime time);/ s1 H7 A% r  `
  67. double GregorianCalendarDateToModifiedJulianDate(DateTime time);
    4 o5 F( [4 o3 J8 `1 o8 Z
  68. GpsWeekSecond GpsWeekSecondAddYear(GpsWeekSecond time, int year);
    . f( t4 D1 [6 [' ?  Y
  69. GpsWeekSecond GpsWeekSecondAddMonth(GpsWeekSecond time, int month);( Q/ |8 [* |( c# N. r4 L/ P7 x
  70. GpsWeekSecond GpsWeekSecondAddWeek(GpsWeekSecond time, int week);$ O( }  o3 w7 g/ S! q  T: N5 T
  71. GpsWeekSecond GpsWeekSecondAddDay(GpsWeekSecond time, int day);
    # A& ^, \& A& G3 U
  72. GpsWeekSecond GpsWeekSecondAddHour(GpsWeekSecond time, int hour);$ b/ }0 ?8 l% g$ t) u- l
  73. GpsWeekSecond GpsWeekSecondAddMinute(GpsWeekSecond time, int minute);
    * C& v( ?" d8 E
  74. GpsWeekSecond GpsWeekSecondAddSecond(GpsWeekSecond time, int second);
    7 o4 |: [8 d9 R. _
  75. DateTime GpsWeekSecondToGregorianCalendarDate(GpsWeekSecond time);/ A# _3 v7 X9 ?3 k$ F
  76. double GpsWeekSecondToJulianDate(GpsWeekSecond time);
    $ m9 I7 R7 U* {7 o
  77. double GpsWeekSecondToModifiedJulianDate(GpsWeekSecond time);
    7 K, _& m& D. n) e6 E
  78. double JulianDateAddYear(double jd, int year);
    : I  Z3 n: _5 A+ w
  79. double JulianDateAddMonth(double jd, int month);
    4 ]( O6 T* C0 C1 K# C
  80. double JulianDateAddWeek(double jd, int week);
    9 i) Q4 ~  {& `1 A1 S
  81. double JulianDateAddDay(double jd, int day);
      I- N9 H$ _; y& H0 D
  82. double JulianDateAddHour(double jd, int hour);; i/ E) |+ L/ O
  83. double JulianDateAddMinute(double jd, int minute);
    . ^' r" J; U5 u
  84. double JulianDateAddSecond(double jd, int second);
    , z/ Q% @+ {7 e5 H+ r
  85. DateTime JulianDateToGregorianCalendarDate(double jd);
    6 A0 {# g& O3 [! w
  86. GpsWeekSecond JulianDateToGpsWeekSecond(double jd);
    4 z/ l6 e6 L9 H) W" d
  87. double JulianDateToModifiedJulianDate(double jd);
    3 I" J$ L! _7 F" i
  88. double ModifiedJulianDateAddYear(double mjd, int year);
    4 t/ H5 g, A$ ~
  89. double ModifiedJulianDateAddMonth(double mjd, int month);
    8 |" N9 D% w; Y$ W: D2 I. R
  90. double ModifiedJulianDateAddWeek(double mjd, int week);0 J: F0 P2 |. b$ B
  91. double ModifiedJulianDateAddDay(double mjd, int day);
    + h) F, j- W" a0 j
  92. double ModifiedJulianDateAddHour(double mjd, int hour);; j7 m' ?8 M# R3 h: r
  93. double ModifiedJulianDateAddMinute(double mjd, int minute);
    2 w9 {+ a/ O5 G- g" M4 [7 U4 ?0 I
  94. double ModifiedJulianDateAddSecond(double mjd, int second);: S. K/ P4 Z. O, U# q
  95. DateTime ModifiedJulianDateToGregorianCalendarDate(double mjd);
    1 r9 W" E( F4 V" ]6 A; P' x
  96. GpsWeekSecond ModifiedJulianDateToGpsWeekSecond(double mjd);
    ! d3 T0 _. G+ D! V
  97. double ModifiedJulianDateToJulianDate(double mjd);
    5 X: }$ s! R% A# c

  98. 4 B/ B6 t. j2 c! D
  99. #ifdef __cplusplus& [/ Q0 W3 D. {1 T
  100. }
    4 _, F( i" |# [9 I! w
  101. #endif  /* __cplusplus */  a' m; ]6 O. g& k1 x9 F( p

  102. : z2 D2 _+ _2 k) `: s
  103. #endif  /* __DATETIME_H */
    & k) P9 Y) @. o  F# I0 R8 U, y
复制代码

7 ~0 Y4 B9 z& _+ g# e9 v0 Z      DateTime.c文件4 A4 N; z8 u1 ~1 A: ~9 P
  1. /****************************************************************5 x* A6 i- s5 O
  2. * Copyright (C) 2017, XinLi, all right reserved.. K! ^: m3 S: e. A0 q1 o
  3. * File name:    DateTime.c
    6 w6 U5 t# P1 o8 j. G1 I' E$ V
  4. * Date:         2017.10.176 ]: X% {* d% F2 P9 i* z
  5. * Description:  Date and time module source file.
    6 N0 B) e8 t# i* N8 O
  6. *****************************************************************/
    " @% V4 g; C2 K# O. H# O& x7 O- k+ x
  7. 4 K5 V' u  R3 L2 z, W4 ~8 I
  8. /****************************************************************$ w+ P' Z8 j+ Y7 C- X2 @* H
  9. *                        Header include
    ! e" m- h# C5 P6 J* A) e/ q  |  D
  10. *****************************************************************/; I2 u9 l; e; Z4 }
  11. #include "DateTime.h"
    ( g9 y1 K7 d9 k1 j
  12. ( I1 b9 I7 y1 r8 q: }: s
  13. /****************************************************************7 @7 z% f) T% x+ g
  14. *                       Global variables* M7 z% D* i4 G* Q! W
  15. *****************************************************************/
    " i) W* |. D1 I$ O
  16. 9 C0 U. t( i; x/ a! {' \7 R
  17. # _7 R/ @3 k/ |% I0 j
  18. /****************************************************************
    5 S% ^  ?9 y* }8 ]8 n
  19. *                     Function declaration
    " l5 F8 d9 j9 t( X- z, W6 U
  20. *****************************************************************/
    & ]' q8 A' F! q" T# Z, E, o
  21. : l; V9 o- ^: @- w/ W

  22. 5 m- A- j/ w/ j- s) c* x( a& _: u
  23. /****************************************************************0 H6 M' t7 O! V" O3 a
  24. *                     Function definition, k$ N$ j1 |7 @, D, Z  A  f3 F
  25. *****************************************************************/4 R, P/ j: z4 R2 H7 d( [: e6 E

  26. * J- A7 [* e  ]. F! h) V( J7 \
  27. /****************************************************************& Y8 [+ X% E0 o) ~" g7 d8 j
  28. * Function:    GregorianCalendarDateAddYear
    9 v  y4 [2 m5 J" Q2 v4 Q3 u' H
  29. * Description: Gregorian calendar date add year.
    & D  l  v/ J5 @; n* u$ o4 x
  30. * Input:       time: Gregorian calendar date.
    " y, N9 Q* l0 F5 D" p
  31. *              year: The number of year to add.
    3 d5 R: Y" [$ V0 {8 O
  32. * Output:6 m, ^* `9 `( m/ M5 o+ O
  33. * Return:      Gregorian calendar date.
    . {8 s0 h9 P/ j- _: l  Z
  34. *****************************************************************/
    0 j$ |9 X8 o4 [, K$ \: j/ _
  35. DateTime GregorianCalendarDateAddYear(DateTime time, int year)
      Y: S; U* U* t1 _
  36. {
    " v/ D/ P0 x2 E) v9 ?
  37.   time.year += year;% C( z' J. C4 ]3 G3 F' b
  38. % ^5 a' w, r, h1 L7 F7 N
  39.   if(time.month == 2)' Q: A$ _$ o9 D% @* W+ i" }: [& b
  40.   {
    ' E) m5 i  Y  j; D6 P$ v; K" ~
  41.     int mday = 0;
    / ?( E: Y1 a# n& [& V
  42. 3 H5 @- d% I0 u- ?
  43.     if((((time.year % 4) == 0) && ((time.year % 100) != 0)) || ((time.year % 400) == 0))' O' y* d! r, t# ^; H' f
  44.     {
    7 w) y9 G% e" y) ~) @* A. |* F" W4 F
  45.       mday = 29;* M5 V  K5 M/ R) \' U% E
  46.     }
    - N( |* ]# Q! D4 c, a
  47.     else, K3 H% p  i9 O2 y; R
  48.     {$ l; y7 G) ^2 v: c4 F
  49.       mday = 28;
    # T2 T  h! E* J, m
  50.     }$ j$ U( y6 ]$ }& `
  51. ' Y. g3 ~4 I, G/ A# }7 U2 d, A7 B3 L
  52.     if(time.day > mday)
    . M0 z0 t, D% q. a$ H4 _2 v8 u
  53.     {
    & ^9 j5 g* _& v0 P% C  G2 Y
  54.       time.month += 1;
    / G1 x" L5 {4 V$ a
  55.       time.day   -= mday;2 V# C( `. C8 K2 _0 \. t
  56.     }
    & i) J7 Z6 v2 ^' A! W5 z% y: g7 c; p. Z( ~
  57.   }: P- M4 E0 N9 N/ u, U

  58.   X, Q( F' `8 O7 q4 z! H
  59.   return time;% t% S6 @: L$ Q7 ?( I' |
  60. }3 n% ~$ D# N4 n5 ?7 X/ D1 u

  61. ! P1 `( E: X# \! @" n
  62. /****************************************************************
    - u% f* W& |2 Y! M, E6 T" m
  63. * Function:    GregorianCalendarDateAddMonth, }" k: ]1 ^& H' L0 y) J) O
  64. * Description: Gregorian calendar date add month.
    & r3 e/ {2 E$ z; v! A
  65. * Input:       time:  Gregorian calendar date.
    . U3 h9 g$ L7 N3 ~. b4 K2 l4 _% Z
  66. *              month: The number of month to add.7 v. H& ?- Q3 d# L0 g3 z" u
  67. * Output:
    & G3 B, j/ h: O/ @" t! i$ T: T2 m
  68. * Return:      Gregorian calendar date.
    % ^6 L2 X% h9 `; t# J% n
  69. *****************************************************************/
    $ |. g3 ?/ F/ i, n8 x
  70. DateTime GregorianCalendarDateAddMonth(DateTime time, int month)
    & V0 G- U, [* h1 r/ l# {' P6 s
  71. {
    6 O3 J; T7 h' l$ s; ^
  72.   time.year  += month / 12;) T9 J2 t* s2 ]( S" O
  73.   time.month += month % 12;1 Z* q) p' T& ^0 G# C) i

  74. ' f- B# h& a3 [0 J. o$ ^
  75.   if(time.month > 12)0 t+ L1 q" w6 s
  76.   {
    1 H$ w# n; `" R
  77.     time.year  += 1;" F' h( v7 S& h$ i( }
  78.     time.month -= 12;
    5 M1 v5 r8 p; M6 t$ A6 E0 y! x% c* \4 [
  79.   }
    3 \$ P  ~% C- K: s1 B' F

  80. ! k; T( J8 Z3 c+ C
  81.   int mday = 0;
      r- w6 |1 ?- u! b3 ?& W0 @9 W7 q% W
  82. - L6 b$ o; J# `6 E# w  ]( u  t
  83.   if((time.month == 1) || (time.month == 3) || (time.month == 5) || (time.month == 7) ||
    ) {5 [! T7 f- u
  84.      (time.month == 8) || (time.month == 10) || (time.month == 12))
    8 D# v8 k# A* H8 Z) J5 |3 @
  85.   {
    . Z6 u9 p; A" N, v
  86.     mday = 31;$ ~, W9 ^# s, c
  87.   }
    0 [- `( ~* a  q; `
  88.   else if((time.month == 4) || (time.month == 6) || (time.month == 9) || (time.month == 11))
    9 @$ K5 \, a" `0 [/ a$ O
  89.   {
    ( Q* }: X8 g( u. ^: g# G' K$ g
  90.     mday = 30;! q6 A3 m( N% t! X; y6 g) B
  91.   }% H' e, S' n; k8 Z# S1 |. D5 A( T
  92.   else' w& n* s: ?8 }7 d" D
  93.   {" ^2 `8 u$ b2 v: A- ~: w: s
  94.     if((((time.year % 4) == 0) && ((time.year % 100) != 0)) || ((time.year % 400) == 0))3 e6 i$ j5 V9 S* k" B6 o9 z
  95.     {
    . C( S1 n  Z4 o
  96.       mday = 29;
    3 A7 r% h, b5 }& X7 M9 F
  97.     }1 `. _: P0 Q& |2 \6 L- o
  98.     else
    " j" W% N  D9 [) }2 M! K6 [
  99.     {# K: Y0 t) b6 f5 t- I
  100.       mday = 28;
    ) x" j9 V! H1 {6 e- T
  101.     }
    + ?* D5 e% r" o/ Q, D( y. h; v( @
  102.   }
    ( q3 X. I$ Y# K7 s. Y- w& v' v* W
  103. 5 Y1 [1 {, R* m: D7 h" k
  104.   if(time.day > mday)
    & Z$ z6 g( d: `" P+ D
  105.   {
    7 E! G/ E* h% L, N7 k) l; _( ^
  106.     time.month += 1;
    ' H9 }# L% A9 p1 ]( J( x* j( e
  107.     time.day   -= mday;
    ! P/ B5 P, p2 c4 C! e! L
  108. ) I, r1 Q/ l( c( U6 V, s. [
  109.     if(time.month > 12)
    ( o* @) |6 _. L  w
  110.     {
    $ W, _0 D( f& q8 S
  111.       time.year  += 1;
    . w0 w% }6 s. J. j) I
  112.       time.month -= 12;
    ) q. c$ A7 E6 Z7 X5 q
  113.     }
    # {# L) l7 J' [4 E" h1 O
  114.   }
    ( x6 ?2 G5 j/ v2 h% ^

  115. 9 e' r+ U3 s5 ?8 o# ^, a
  116.   return time;/ s* A$ j# O2 i
  117. }+ o5 H+ A# C9 [' C2 X* F

  118. 9 _0 e# e( O6 ~8 q2 W4 _
  119. /****************************************************************
    ) i, G& G$ z% T2 C$ h! {( Y5 x3 C
  120. * Function:    GregorianCalendarDateAddWeek5 A- g" o7 y- C: D! W. x
  121. * Description: Gregorian calendar date add week.& b6 F3 M$ ]4 q- e# M0 ]) G2 Y7 h
  122. * Input:       time: Gregorian calendar date.
    . ^- z( {4 z+ R  N3 n; R
  123. *              week: The number of week to add.; i( f; X" o6 \: Z/ C, {, P# m
  124. * Output:8 ~: T) E, d0 q9 D' u
  125. * Return:      Gregorian calendar date.
    " t- K4 S, ]+ C% s* A2 E: m3 b3 z
  126. *****************************************************************/) Z2 f1 m: b) w+ O  V
  127. DateTime GregorianCalendarDateAddWeek(DateTime time, int week)
    + e, H' Y& ~0 e, x! i+ N
  128. {
    4 N: C) O* B7 e- t
  129.   double jd = GregorianCalendarDateToJulianDate(time) + week * 7.0;, w' A! i5 R. o/ E9 S/ S) j
  130. 9 o: F2 I' ~! _" d5 R8 I
  131.   return JulianDateToGregorianCalendarDate(jd);
    % j9 b/ @4 A: v
  132. }
    $ i& i# e/ A5 ?* _1 O
  133. / p8 a8 H/ n2 E; r
  134. /****************************************************************
    . e* J6 X; P9 K$ ^/ V; W
  135. * Function:    GregorianCalendarDateAddDay; ~0 u1 h- _1 M  d4 g% k& o9 y
  136. * Description: Gregorian calendar date add day., O; u8 x$ I; B2 {) t) U! n
  137. * Input:       time: Gregorian calendar date.) m% U  @% S7 X8 I
  138. *              day:  The number of day to add.8 r3 e1 L8 L+ T9 I  t3 `+ k
  139. * Output:: b: A3 J# m  Q& ^: ]8 U+ ?
  140. * Return:      Gregorian calendar date.  _. K3 B, o! ~2 u, c4 a) e
  141. *****************************************************************/4 z0 Z5 H9 m0 m. w. e- @8 H
  142. DateTime GregorianCalendarDateAddDay(DateTime time, int day)2 z- R2 s* r  T6 ]
  143. {
    1 |1 C& R6 C( L  b: W7 K, P
  144.   double jd = GregorianCalendarDateToJulianDate(time) + day;
    / p/ t% @! h3 p* }, Z. m+ ^
  145. 8 _# d$ p. \9 r
  146.   return JulianDateToGregorianCalendarDate(jd);
    9 b$ C% }; ?9 l
  147. }2 P1 q1 ?2 C# i9 ]

  148. . w0 }! P1 q& l7 [1 E$ \0 t
  149. /****************************************************************
    5 J7 }+ P% C6 K) N( \0 T
  150. * Function:    GregorianCalendarDateAddHour
    # I  B" ]' H+ [& d9 y4 @( T. x9 I
  151. * Description: Gregorian calendar date add hour.
    , f5 O7 n$ t9 O1 A. L
  152. * Input:       time: Gregorian calendar date.
    5 \/ {( A7 l; j5 k2 R: M/ e" m- ~8 y
  153. *              hour: The number of hour to add.3 N* u: b% l2 K1 ^2 E0 `! G
  154. * Output:
    ( h; f/ |3 `/ c, N- j1 }' L
  155. * Return:      Gregorian calendar date.  i3 T" T2 L4 O7 u
  156. *****************************************************************/- j4 P0 n/ V4 V1 N  C2 q) K
  157. DateTime GregorianCalendarDateAddHour(DateTime time, int hour)
    0 ~- N6 O* n6 @$ T# c3 t
  158. {! F4 ?. H. G; ~1 z1 o* g
  159.   time.hour += hour;4 y1 Z) v% h+ }( M0 m2 R

  160.   {7 e) O1 P. ^
  161.   double jd = GregorianCalendarDateToJulianDate(time);
    " O3 ]# f% @2 j# r+ f/ V
  162. : K* \% A3 |# J' l3 P* P" j4 h
  163.   return JulianDateToGregorianCalendarDate(jd);, x  i- r( Q; i9 [" {. o6 I6 l
  164. }
    / p( I; [" T" W- ]& e' c+ s' j
  165. 7 z- T+ c% L7 K0 `+ A5 w# s3 @/ n( B2 l  t" t
  166. /****************************************************************8 ~5 X! Y6 x, k1 T$ d
  167. * Function:    GregorianCalendarDateAddMinute( X- H% ^4 e8 e8 l7 o# }7 \  o0 u
  168. * Description: Gregorian calendar date add minute.
    . K) _0 P( \$ E% X! Y5 ?
  169. * Input:       time:   Gregorian calendar date./ ?: v' }; s* u: e! A* W5 a' ]6 t. j
  170. *              minute: The number of minute to add.; w2 T3 Z4 e4 ^9 P- Z7 d2 h& J
  171. * Output:
    1 p- |5 z' f1 ^  K
  172. * Return:      Gregorian calendar date.
    : }$ R) s9 y) n
  173. *****************************************************************/* l' }0 K2 J' [0 \! N5 S, ~
  174. DateTime GregorianCalendarDateAddMinute(DateTime time, int minute)5 X( H) m; X9 d  ?4 |8 R. ^. J: T
  175. {
    / y& P: \6 s. R, V0 W# M+ F! \
  176.   time.minute += minute;
    " s9 r  ]% q: i' D' g
  177. 2 p5 ^* t8 n8 d, M6 h" B# p( Y
  178.   double jd = GregorianCalendarDateToJulianDate(time);
    6 D4 A) \" V8 Z7 I

  179. 9 u' a: {2 j; Q9 P: B  ?0 V
  180.   return JulianDateToGregorianCalendarDate(jd);
    ) ^% G9 l5 ?9 ]6 X/ _- G. F
  181. }
    2 k, f, B9 Q" u" M1 l" X: l) b

  182. * C: ]* z8 |' h5 Y
  183. /****************************************************************  L' s) T0 N; o8 t7 U
  184. * Function:    GregorianCalendarDateAddSecond
    8 W7 \+ |! \: A# ?
  185. * Description: Gregorian calendar date add second., O$ w2 ~: q1 w! x, x
  186. * Input:       time:   Gregorian calendar date.4 \3 Q+ d; X) d" }% K+ Z5 B
  187. *              second: The number of seconds to add., p3 A, Q2 p7 r2 A) A
  188. * Output:
    9 G' U( y" m5 O$ S
  189. * Return:      Gregorian calendar date.
    % [! P/ G. g. u% P
  190. *****************************************************************/+ g$ n! F3 U! {' Z; H  a* a2 @
  191. DateTime GregorianCalendarDateAddSecond(DateTime time, int second)
    & ^4 a5 F" s. d7 o8 d
  192. {
    ' k2 b  e! f9 G5 R2 y) ^
  193.   time.second += second;
    " ]$ b$ M5 }8 z6 C( T
  194. . J! R. w1 `! D" |
  195.   double jd = GregorianCalendarDateToJulianDate(time);
    - r# d( V6 O3 E
  196. + [- j/ K1 a  M3 @; l
  197.   return JulianDateToGregorianCalendarDate(jd);
    , `/ C  j- n8 q  M6 Q* |
  198. }
    " B( S- |/ L0 q4 Y& K7 S- f

  199. ) D  }# @( Q. @/ y9 w
  200. /****************************************************************
    " d+ P% ~! {* Z+ E( W% N/ l4 I) X
  201. * Function:    GregorianCalendarDateToGpsWeekSecond
    & n* a; `% |6 G9 f! I3 c4 G
  202. * Description: Gregorian calendar date to gps week and second.5 e8 ?: U  D5 K. k$ Q6 t( y
  203. * Input:       time: Gregorian calendar date.
    ' U! R7 ?: c4 Q* y8 v& c' u9 `
  204. * Output:
    : |2 |: g& `6 U6 {# F) l2 B- H
  205. * Return:      Gps week and second.: f; i. @: k2 ]8 C2 J- r+ I
  206. *****************************************************************/# V" O* _- A8 p* t2 Z
  207. GpsWeekSecond GregorianCalendarDateToGpsWeekSecond(DateTime time)( j; d, S9 |# m
  208. {
    , h' h1 }3 h1 k& t( F
  209.   double jd = GregorianCalendarDateToJulianDate(time);
    7 s. J2 v4 J) G; m

  210. ! X2 l5 p" _0 |8 i, H
  211.   return JulianDateToGpsWeekSecond(jd);
    7 f. i  \' Q3 U4 @: ~2 }
  212. }" O2 z% V' E9 J

  213.   o# e/ e% a3 E( U
  214. /****************************************************************
    $ ?% k. v, X* R8 Y
  215. * Function:    GregorianCalendarDateToJulianDate
    7 U; f! U# T" I
  216. * Description: Gregorian calendar date to julian date.
    * C5 o) ]* Y. u9 C& C
  217. * Input:       time: Gregorian calendar date., E2 a1 Y/ k( U; Y
  218. * Output:. ^# @8 V0 m/ X" N; q6 o% q
  219. * Return:      Julian date.
    8 x. m' L  _; w. `+ u/ u# H
  220. *****************************************************************/
    % F; Q& c" P0 f, T$ S# i+ M' Z
  221. double GregorianCalendarDateToJulianDate(DateTime time)! `) @! F( U: L- M# \
  222. {/ l* \5 m7 K+ U# ?. L
  223.   int jdn = (1461 * (time.year + 4800 + (time.month - 14) / 12)) / 4
    / `8 @7 u! J7 T! L
  224.           + (367 * (time.month - 2 - 12 * ((time.month - 14) / 12))) / 12- N% `$ X2 |# n, w, Y
  225.           - (3 * ((time.year + 4900 + (time.month - 14) / 12) / 100)) / 4
    # |9 n# i( x6 o; i! G
  226.           + time.day - 32075;, ]  J6 |% s! ~- z. J. F+ ]- r

  227. 3 k) R7 o1 C) t* q* H3 ]: j
  228.   double jd = jdn + ((time.hour - 12) * 3600.0 + time.minute * 60.0 + time.second) / 86400.0;2 ?7 Z+ a1 `% K5 g% f

  229. 4 S  m" M1 b) A, x5 W
  230.   return jd;) J+ D. p' _; W  ^! k  J# ]% o
  231. }
    % g  z3 U9 ?0 i1 J! Q3 i& P+ M

  232. ( d" x" D. S6 o7 n, `& Q$ ~
  233. /****************************************************************
    5 N/ ]3 N, v; N$ |# s) A
  234. * Function:    GregorianCalendarDateToModifiedJulianDate
    $ F0 T. h! U) y% d5 U- m; t6 p/ L
  235. * Description: Gregorian calendar date to modified julian date.: ?1 t2 c% h" R7 d8 h8 u2 O9 Q8 `  q
  236. * Input:       time: Gregorian calendar date.
    . t8 F0 B& q  o; T
  237. * Output:
    4 w0 C/ N1 U6 i3 D3 |
  238. * Return:      Modified julian date.2 B1 W  u& N0 u
  239. *****************************************************************/# Q8 i' V( G1 {1 n
  240. double GregorianCalendarDateToModifiedJulianDate(DateTime time)* e* h) ~& W) M
  241. {
      U& [  c6 e7 I& @1 P8 p2 h' a. p0 Z
  242.   return GregorianCalendarDateToJulianDate(time) - 2400000.5;
    0 w' w, ^. `0 x0 h1 G7 U
  243. }
    ) U% p; I/ D6 m  A2 U2 @: v

  244. ! d& F+ l+ P/ h  l; Y
  245. /****************************************************************4 I( H& d1 B. T- z5 L0 ]
  246. * Function:    GpsWeekSecondAddYear
      V$ P/ [1 k9 i3 @
  247. * Description: Gps week and second add year.; T6 ]3 N' d' b% M6 V3 ?& ?( N
  248. * Input:       time: Gps week and second.8 b! `3 J+ X, D3 E% P& T7 J) V' Q
  249. *              year: The number of year to add.
    - h! h, C5 R6 t6 p& A
  250. * Output:/ l; X6 l& ?3 f- p- t8 ?
  251. * Return:      Gps week and second.
    , V, e2 C$ l3 J% ]! k4 A" K
  252. *****************************************************************/; i. x3 P& |0 x  U
  253. GpsWeekSecond GpsWeekSecondAddYear(GpsWeekSecond time, int year)
    . t7 d0 H" j- k. o! J# f
  254. {  ~( x: L2 d7 v  v0 g
  255.   DateTime date = GpsWeekSecondToGregorianCalendarDate(time);
    * e4 ~7 S: o! ^1 t

  256. ; k* T$ s0 t5 S* P- {8 N
  257.   date = GregorianCalendarDateAddYear(date, year);
    ) |# y. u4 _* t1 H. H$ b& k8 T7 [
  258. - H0 Z4 [, G1 f0 z) @# Q- @* d
  259.   return GregorianCalendarDateToGpsWeekSecond(date);
    5 ^# e8 b1 b. S
  260. }# J6 Y5 `6 p3 ~, k# ]$ I1 w9 r" A
  261. 2 s8 d* X4 d+ p5 b) Q/ U3 o( _' a
  262. /****************************************************************) F. A* Z( D9 r* i2 l
  263. * Function:    GpsWeekSecondAddMonth; @# {* h5 A; @: j
  264. * Description: Gps week and second add month.9 _7 }, ~0 v( v: O& t  X, u
  265. * Input:       time:  Gps week and second.
    : i7 N9 f" \% m4 {
  266. *              month: The number of month to add.
    . ~4 F; C* O6 T6 ~4 z
  267. * Output:! q* C: w0 l7 o7 A
  268. * Return:      Gps week and second.
    6 g9 N+ o' S4 G1 n- ~
  269. *****************************************************************/
    * h8 Z% w  \7 Y+ _3 W
  270. GpsWeekSecond GpsWeekSecondAddMonth(GpsWeekSecond time, int month)
    ; q% g' D. G. b7 l
  271. {
    + x8 Q7 ]3 g0 v6 `% p( p6 b
  272.   DateTime date = GpsWeekSecondToGregorianCalendarDate(time);
    / @* m% c) Y- E* g" b5 Y
  273. 8 ^9 R% R3 x+ N: ?: O3 A$ B
  274.   date = GregorianCalendarDateAddMonth(date, month);# ]3 u3 @5 o8 ~8 [$ N
  275. 1 ^* k: g: h6 z" F  y/ v. P5 J( T
  276.   return GregorianCalendarDateToGpsWeekSecond(date);
    ; q4 R& q2 C- V' `; r2 }
  277. }" h  ]$ R* H6 u- y$ x' a3 B% U6 z
  278. 7 y8 ]( d( }0 \" L# t# a
  279. /****************************************************************5 z$ q! ^  ^* }: s2 |  ~- n6 n% p
  280. * Function:    GpsWeekSecondAddWeek
    # Z, b- {# i/ R
  281. * Description: Gps week and second add week.- w8 l; B- s6 ^5 k- ]0 m& i  w8 @
  282. * Input:       time: Gps week and second.
    " J) |& P* {4 x1 ~/ k7 t
  283. *              week: The number of week to add.
    & g# R# M6 Q/ P$ e! z
  284. * Output:& L0 O# K$ L" J$ h. M1 ]
  285. * Return:      Gps week and second.
    6 y- N1 I' U" T8 b; w0 J/ T
  286. *****************************************************************/
    7 @" Q& y! t! q8 z+ i4 }% n
  287. GpsWeekSecond GpsWeekSecondAddWeek(GpsWeekSecond time, int week)
    5 @6 u% I+ W, M
  288. {( B) L' {6 R# j  }6 s
  289.   time.week += week;
    * X" j/ X/ z7 C. C# {+ E: i% p& E
  290. 9 z0 I$ L9 \. Q( }3 m1 F" B
  291.   return time;
    ' Y9 p/ `: S6 [/ k+ E- k
  292. }
    + `$ K& L, t5 ?& r" J! B1 {9 n

  293. # ^! K4 \& \- b5 Y& U8 S) h$ i! r
  294. /****************************************************************
    0 s) k3 ]5 w' N4 E. {5 m7 c5 L
  295. * Function:    GpsWeekSecondAddDay) a- ]! m8 k: e4 X; x+ K! e
  296. * Description: Gps week and second add day.. f7 B/ }5 U  Q, m+ C0 x  {9 i
  297. * Input:       time: Gps week and second.
    4 f2 I- O( m& X; U! P8 W! I
  298. *              day:  The number of day to add.
    ! ~  K2 w; I9 E$ H& p3 ~* j9 E% Q
  299. * Output:
    ! k" u& C( I  J- k# i: U/ q. _3 y
  300. * Return:      Gps week and second.
    6 S( m3 G3 y: ~1 t- o
  301. *****************************************************************/  k: o$ L8 R! i8 ~
  302. GpsWeekSecond GpsWeekSecondAddDay(GpsWeekSecond time, int day)3 z% @: \4 F% Q6 r$ U/ o6 @
  303. {
    2 ?0 x; t# `" e' z7 F$ c
  304.   time.week   += day / 7;
    - v8 Z1 N; o% S; y1 m
  305.   time.second += day % 7 * 86400;% i! T' N; a) _; f
  306. & z& Q8 z% W# ^  P; a7 d4 c9 D
  307.   if(time.second > 604799)
    - O, q, \- c8 b% N5 _3 [( h8 o
  308.   {$ r+ K! R" Z3 |0 V3 e0 v
  309.     time.week   += 1;; e0 u5 X& c2 Q; n/ P
  310.     time.second -= 604800;
      `( T( l6 Z. j" C+ [) p+ J4 `
  311.   }' W' t. w  f! n
  312. 9 M8 g) x1 L% p- }
  313.   return time;5 {, }- {! g5 l6 B) o1 |
  314. }
    - X  t) n# _) M5 l

  315. . I9 W! a7 |$ h2 K7 ?$ Z
  316. /****************************************************************9 R5 T) E! b3 X/ O: q  ?: `
  317. * Function:    GpsWeekSecondAddHour
    7 B9 G/ s3 K$ w& u
  318. * Description: Gps week and second add hour.
    + |% `7 x" H+ p3 ~" O' f
  319. * Input:       time: Gps week and second.
    ) P9 `; |; O- s3 S
  320. *              hour: The number of hour to add.
    . Q. v* s7 G4 q6 G( P* N
  321. * Output:
      N( Y% v. n, f4 b3 H8 u
  322. * Return:      Gps week and second." I2 q6 c+ G. U& P6 G
  323. *****************************************************************/
    % z7 `8 Q9 I' p+ J+ n' {
  324. GpsWeekSecond GpsWeekSecondAddHour(GpsWeekSecond time, int hour)
    5 T: z1 O. b( j. v4 A* X
  325. {( C3 Q, X) \" l! r" V, P9 k
  326.   time.week   += hour / 168;6 x$ s( ~! Y9 ?4 h$ _
  327.   time.second += hour % 168 * 3600;( x) F, c3 l- i' j. S
  328. " H& @; N0 O$ L. A2 y- r% X" T0 y
  329.   if(time.second > 604799)
    0 ^8 M4 ]' }; R' y
  330.   {% R+ s/ X$ v* U0 E
  331.     time.week   += 1;: x# |+ }- ^! e! |! A/ o  ~
  332.     time.second -= 604800;* H$ }& c! ]6 x+ o' o
  333.   }
      W6 }. H: q- T& l$ J$ a
  334.   
      T! @5 d" D2 v" l
  335.   return time;
    ! e" T# l- ]  c$ x( e0 H% F* M/ M
  336. }
    9 V% l: Z& j( t+ g

  337. 0 ^) z4 F# {, r* q3 H! s& B2 {
  338. /****************************************************************6 w  R( b, l: c: @
  339. * Function:    GpsWeekSecondAddMinute- N6 w- |' x/ @' @7 K* a
  340. * Description: Gps week and second add minute.
    ' E- m$ D: h* \, w
  341. * Input:       time:   Gps week and second.% c8 T  n6 L& x  ^5 c
  342. *              minute: The number of minute to add.- T& v# |% v+ ]) Z1 @6 a% G
  343. * Output:
    # a( X( k1 m$ m, o8 ]' o( z+ r
  344. * Return:      Gps week and second.: z- W3 l/ F; w/ m; F7 p
  345. *****************************************************************/, O- `% r1 t& Z# ~
  346. GpsWeekSecond GpsWeekSecondAddMinute(GpsWeekSecond time, int minute)
    / X- K& u! J1 b2 O
  347. {2 i8 ?* [6 S$ t
  348.   time.week   += minute / 10080;; {, S6 @# j* ^8 i( d
  349.   time.second += minute % 10080 * 60;- {; I9 b3 W1 D$ q  H# L0 V
  350.   / B, U4 M; \0 J! P1 ]* A3 a, a
  351.   if(time.second > 604799)+ U( z+ w9 I, ^! \5 S7 k
  352.   {( q4 t7 R3 U# D6 b8 S- y/ A& X
  353.     time.week   += 1;
    ! y+ r1 g, ?  L, k0 \+ y
  354.     time.second -= 604800;( p6 E' F1 f+ x0 P4 e0 s: J& b! L
  355.   }
    - ]$ \, `# T4 o) k% W- R! ^& \
  356.   ( B, M+ ~2 c" S  t  E! z
  357.   return time;+ ?6 S" T2 `4 [! U" Q% o' K
  358. }+ D, ]- T5 S7 J+ U

  359. ; h2 w9 z; [3 H4 p
  360. /****************************************************************# k4 h; X4 |* d6 o
  361. * Function:    GpsWeekSecondAddSecond9 U$ X9 u- F9 S* o
  362. * Description: Gps week and second add second." _# Z, o9 Z2 [. S) e" K3 u7 N
  363. * Input:       time:   Gps week and second.
    . W! o6 ^. h- f5 v
  364. *              second: The number of second to add.
    3 I" b) p& B0 Z* J9 s0 Z6 \1 m
  365. * Output:  C1 m7 F5 K6 n: P2 ?
  366. * Return:      Gps week and second.  T1 [2 i- P. |: F' ^# U3 h$ V
  367. *****************************************************************/
    - m- _' @) D0 Y2 \2 Y: r( M
  368. GpsWeekSecond GpsWeekSecondAddSecond(GpsWeekSecond time, int second)
    4 f$ Y4 z  ^7 D/ ?0 {/ G( N* [8 @
  369. {
    ' G( q6 \% Y( a% x6 C0 m
  370.   time.week   += second / 604800;
    , S( X- l! z3 S; S( R7 Y1 p
  371.   time.second += second % 604800;0 u7 J  r  Y0 @! ~$ j( b+ z

  372. + |) A' r# P  D2 K# p
  373.   if(time.second > 604799)
    ) i1 n6 l5 d; g* r' x$ Q1 t
  374.   {
    $ O6 I- ~' l" B$ G6 T$ ^( `" w& P) {
  375.     time.week   += 1;
    ; |) t9 Q! j$ |, D5 X* R
  376.     time.second -= 604800;/ F  |# Y& m. F- e/ r$ ]+ j
  377.   }
    5 a5 I4 N8 W7 }' `
  378.   
    7 d% _7 @( p5 d2 H; h" ]6 g
  379.   return time;  p0 y) T9 G, X# B
  380. }
    ' a- _) f1 ]0 k) v/ e
  381. 2 J* X& \) C2 f+ q5 D
  382. /****************************************************************
    7 I, u0 f9 x* _. L
  383. * Function:    GpsWeekSecondToGregorianCalendarDate3 w5 c' V& D8 ]! k/ K' ~9 Q1 w
  384. * Description: Gps week and second to gregorian calendar date.
      D/ V0 h8 `; Q' `3 ?; ~  F9 e& K
  385. * Input:       time: Gps week and second.
    & r6 D9 ~  Q1 i, d  A
  386. * Output:
      C" N1 e; {8 d3 W/ n  |! `) f/ K) z5 y, [8 q
  387. * Return:      Gregorian calendar date.
    1 u1 w2 z) |& {, \- V
  388. *****************************************************************/
    9 c3 p* u' |; d
  389. DateTime GpsWeekSecondToGregorianCalendarDate(GpsWeekSecond time)' v1 s9 u+ ?5 h  D
  390. {0 F) l8 S" ^' }! k
  391.   double jd = GpsWeekSecondToJulianDate(time);
    2 ?$ N4 s$ x, {! v* ?8 y. k7 b
  392.   a$ V. H2 g8 z- ?0 l4 |0 b8 m
  393.   return JulianDateToGregorianCalendarDate(jd);
    4 A( U: k+ p$ {
  394. }
    1 F- \' e' {+ A% V/ R" Q0 }3 \
  395. & _* i$ i; ~& W2 v) }
  396. /****************************************************************
    3 O& E/ K/ X% O! j
  397. * Function:    GpsWeekSecondToJulianDate
    & M8 `) D; m9 F9 l0 g4 _
  398. * Description: Gps week and second to julian date.& S" f9 E& E( n, p. ~9 s) b9 e
  399. * Input:       time: Gps week and second.$ ~0 w  o8 a1 M4 E( x
  400. * Output:) u, c" q: `) S3 [" O
  401. * Return:      Julian date.
    , J' z  l0 g6 Q
  402. *****************************************************************/
    4 ^4 P& q' I  ^7 A9 b( ~
  403. double GpsWeekSecondToJulianDate(GpsWeekSecond time)1 I( L3 t. C, {0 Z; b* j0 T: \
  404. {
    & I, _; ^  l7 y( U/ I9 y
  405.   double jd = 2444244.5 + time.week * 7.0 + time.second / 86400.0;
    ' _; p7 j' o2 _  b0 J5 W( W

  406. + a% M/ C4 p) r- g- d) r
  407.   return jd;
    . c; d8 _/ C; W6 Z  T3 `
  408. }/ j/ E; h+ V. d! q9 ^/ F( w/ X3 u

  409. ! Q& Z( H" \3 ~' K; z
  410. /****************************************************************/ J* O3 f7 E/ @$ Z! \' C7 @
  411. * Function:    GpsWeekSecondToModifiedJulianDate
    ( a, P' P+ u8 |; n6 }& }9 I2 o
  412. * Description: Gps week and second to modified julian date.! m) h  I! z* S
  413. * Input:       time: Gps week and second./ Q4 l$ F/ _) w( E
  414. * Output:
    " |' A# Q7 j" U+ l
  415. * Return:      Modified julian date." q9 T7 }, S9 f; i1 `% `
  416. *****************************************************************/" d) Z) c: K4 \0 N$ _" [
  417. double GpsWeekSecondToModifiedJulianDate(GpsWeekSecond time)& w. C" ~" Q5 m6 j+ I! U
  418. {
    0 U. {" S0 D% J
  419.   return GpsWeekSecondToJulianDate(time) - 2400000.5;0 i- S1 d8 P0 ]- Q% D
  420. }! l; g. x1 ^8 M; K+ E8 w1 `  |( W0 z
  421.   Y! E3 b0 q% n- B8 C/ z
  422. /****************************************************************
    5 W, O; E, x* c- y- _+ g$ f
  423. * Function:    JulianDateAddYear
    - |8 d2 |/ I+ }' z) G2 R$ J% }3 c9 P
  424. * Description: Julian date add year.
    7 a& _9 B2 _2 h' {8 U1 l1 I
  425. * Input:       jd:   Julian date.
    & j: F- A) }8 E1 z. i
  426. *              year: The number of year to add.) T* W: ]; m; N' F
  427. * Output:
    ' V8 p8 \6 g  G" s. q0 K( I
  428. * Return:      Julian date.
    0 E) C8 L$ o( j1 `
  429. *****************************************************************/
    & u5 A' L9 m, m# g' A3 K: q
  430. double JulianDateAddYear(double jd, int year). M! Y" P3 b/ W& j7 O5 l
  431. {
    5 ~/ S: J" k% h0 Z. m( T; `" w/ }
  432.   DateTime date = JulianDateToGregorianCalendarDate(jd);
    1 b1 X, T1 X+ }: d! n( f1 X. a! b" f
  433. % d3 [9 U/ `# x# F  d/ z
  434.   date = GregorianCalendarDateAddYear(date, year);7 j9 M4 @$ }) A& M0 X
  435. ; I1 j, n3 t* {: J3 i7 G: g
  436.   return GregorianCalendarDateToJulianDate(date);3 j1 c* E2 I7 F: h0 T# A* W* p
  437. }4 s* P+ I2 M" A8 y! f
  438. 6 u8 B; L  n" ?
  439. /****************************************************************' G5 k' c4 S* G: h5 Y9 }5 G! J! y
  440. * Function:    JulianDateAddMonth* g8 {- h/ O9 f; {/ _3 i* K% P! w
  441. * Description: Julian date add month.
    ( c7 V! r' e, R5 Z, m$ r
  442. * Input:       jd:    Julian date.2 C+ n8 j/ h: r& l  h/ ?
  443. *              month: The number of month to add.
    4 S6 L# m1 _' g) f! O
  444. * Output:
    & u+ h! Z$ F- A- k
  445. * Return:      Julian date.7 }) w' t/ Y' p9 W- E/ O
  446. *****************************************************************/: d( u1 Z8 g% E4 H+ k3 B
  447. double JulianDateAddMonth(double jd, int month)
    2 U: |8 {+ l2 O
  448. {
    7 _8 k- e) u4 ]
  449.   DateTime date = JulianDateToGregorianCalendarDate(jd);
    " D* {( Z3 F7 F& F. O) |, u- `
  450. / `7 m' J" h( K( W
  451.   date = GregorianCalendarDateAddMonth(date, month);/ l! @7 k% U6 m- W' d2 P2 }

  452. ) n8 |6 I! X9 x2 H
  453.   return GregorianCalendarDateToJulianDate(date);
    8 M. I( B4 F1 w1 X# k4 r3 S
  454. }$ X- _3 _6 Y3 X8 x1 F- P; C+ r

  455.   J! }; h+ c& j9 j; F8 i; i
  456. /****************************************************************
    3 I( ^2 I5 {; ?, W/ o! j: I! B
  457. * Function:    JulianDateAddWeek
    3 l- I2 W8 K$ j% |
  458. * Description: Julian date add week.
    0 ]; Q1 K' N6 l, N
  459. * Input:       jd:   Julian date.3 Z9 t  y5 O2 v9 R, g9 F
  460. *              week: The number of week to add.
    , [  f' X4 L/ Z& k% i0 Q
  461. * Output:' M* B  g; @: I" Q. j0 y* u
  462. * Return:      Julian date.
    ( u. U: }% H5 g* g0 n5 c$ m  ?# ]. q
  463. *****************************************************************/  \  ]; B+ b! I. B% Q7 e
  464. double JulianDateAddWeek(double jd, int week)9 Q. c* d% u3 b" _/ ^2 m
  465. {
    ' r: D# m" W6 Q2 E+ Z/ b. f
  466.   jd += week * 7.0;8 U0 ~* h9 G& M' _6 i  V

  467. , T8 b7 U# s" l% |1 A: W
  468.   return jd;
    / ]0 }, [# @! |# a0 J3 j, ?! X
  469. }
    2 d# r" C1 z! Y1 L8 p7 @
  470. $ R3 u8 w- W& D5 p7 S9 z6 s4 f
  471. /****************************************************************
    6 ?: t% d+ Q( i
  472. * Function:    JulianDateAddDay9 |6 m2 @4 ?6 ]3 f% r( G  W
  473. * Description: Julian date add day.5 Y& z& G3 t) u! r( c
  474. * Input:       jd:  Julian date.  s& x; s& z4 k6 I) j- w) F5 ?
  475. *              day: The number of day to add.
    & q" A& _" f% j$ F
  476. * Output:- e( y& ]9 k- X5 Z( I
  477. * Return:      Julian date.
    . {9 u5 \1 I0 M0 U9 i
  478. *****************************************************************/
    % i: e& @& N0 G  F% L2 a
  479. double JulianDateAddDay(double jd, int day)
    4 i* }9 X  {" P( O( K+ f! S+ E4 Y0 W
  480. {
    . {/ m- h3 j& x9 J9 {5 R. m" a$ ^6 F
  481.   jd += day;
    - y! @) W" d2 @0 p$ X+ S8 W

  482. % a: T2 Q  B; M9 O9 J4 X8 S% _
  483.   return jd;* i4 C" J2 b, N; K& ?( z" }. v0 ^
  484. }' s7 j; t/ Z0 v2 }( r5 U5 n* S  X
  485. ( P6 Y9 [( |% S& Q5 W; W  b1 E$ A
  486. /****************************************************************5 p0 B1 T9 z4 Z0 V% Z0 Y
  487. * Function:    JulianDateAddHour
    6 ?  N& I$ k, F# U
  488. * Description: Julian date add hour.
    ' s' L# D# ~9 N$ Y
  489. * Input:       jd:   Julian date., @- ?' t8 T$ L# E: Y
  490. *              hour: The number of hour to add.  R; _% p! j- n; u) w
  491. * Output:
    9 F0 j. F3 E+ e; ]
  492. * Return:      Julian date.! d$ M+ q' l3 o) w4 n; i0 m* E, p1 ]
  493. *****************************************************************// D* H, \2 `& R) ?
  494. double JulianDateAddHour(double jd, int hour)
    ; q- X9 y' s% y* U1 f. z
  495. {
    8 Y+ F7 d) A) S! O
  496.   jd += hour / 24.0;. E0 u2 G6 L- O3 {# z" G7 C
  497. 9 {, D. |! G  y, j  H
  498.   return jd;
      P' O6 @8 ?, G' w) ^2 V- s' ~8 F6 }
  499. }
    ( [# |" h% M4 Q' x

  500. 0 l% z0 [# h. d2 f, F0 J) ?* p3 t
  501. /****************************************************************
    , s: K$ R7 O# k& r; Y1 }
  502. * Function:    JulianDateAddMinute2 I- ^% s5 M% X9 O% ?
  503. * Description: Julian date add minute.8 I( i7 j) _; j4 L) p" j0 G
  504. * Input:       jd:     Julian date.
    2 ]. K. L+ p$ z, y6 j  n
  505. *              minute: The number of minute to add." H: D$ c  v1 A% d
  506. * Output:
    ! O1 A' G! D6 A8 M& C
  507. * Return:      Julian date.% }- b1 q/ i( ^* o5 n; _: X
  508. *****************************************************************/
    , \0 X9 }+ R0 ?
  509. double JulianDateAddMinute(double jd, int minute)* B9 q% Y1 j/ ~
  510. {* u; X1 M1 s) r' t, p% J# P3 _
  511.   jd += minute / 1440.0;6 u# }1 j/ N' h- g/ Y4 G( S* S
  512. & b4 j: m8 z/ j5 g6 o$ T2 D
  513.   return jd;
    ( v$ @  Y: a+ M) F# _
  514. }& E* O% i: {  m$ N" r2 i; ~

  515. & a: Z% t" \# ~, H- z9 R# G' \
  516. /****************************************************************: ^: t) R* \- E1 {0 b' N
  517. * Function:    JulianDateAddSecond
    : r3 t; I) L, K& T  s( m+ b9 C
  518. * Description: Julian date add second.
    8 l( e4 }0 [, E' L" \# U9 e0 h0 ]
  519. * Input:       jd:     Julian date.
    * G# w& j) t" t( P
  520. *              second: The number of second to add.4 d. |5 v& u+ K( `2 F8 r
  521. * Output:1 g; G& w. `) C2 }
  522. * Return:      Julian date.% h3 C' ]6 U8 }- Z
  523. *****************************************************************/$ R% n4 b( y! P$ E% x" m
  524. double JulianDateAddSecond(double jd, int second)
    9 }& v2 ]0 C8 @( G- z5 g" \
  525. {
    8 L# G6 ?0 P0 p" k
  526.   jd += second / 86400.0;
    $ Q. W( g: s( H
  527. 3 ?' c# {* v5 R# \8 j
  528.   return jd;4 P& X6 r# O, d0 S6 k( e" m6 \
  529. }2 e. e) |2 ]: }% f0 u7 k

  530. # e9 m, q! s4 b+ h+ z( F
  531. /****************************************************************$ D0 i, Y5 [, ]6 Q. f7 W( t
  532. * Function:    JulianDateToGregorianCalendarDate6 x" r6 j5 d0 H% y: O9 r8 X8 c
  533. * Description: Julian date to gregorian calendar date.
    9 x; D3 k$ o2 \
  534. * Input:       jd: Julian date.. z9 C  d8 @) z: V) \  _0 W6 {8 {
  535. * Output:
    5 U' _* `9 G2 W
  536. * Return:      Gregorian calendar date.& G" ~& J( P: R8 o5 {. t5 O& {
  537. *****************************************************************/
    1 I0 _, B) z1 V9 o3 Y$ b; t) g
  538. DateTime JulianDateToGregorianCalendarDate(double jd)
      V, ]' U5 A. \5 R
  539. {+ B; ~0 q& g" ~/ U
  540.   int y = 4716;5 I) e6 ^; G" L0 l4 O3 L  n# y
  541.   int j = 1401;
    9 d, t; K) P$ S: J! o% g- |$ R
  542.   int m = 2;" q! A1 b( p5 v( y5 y- a2 R
  543.   int n = 12;2 u* u' Q5 t4 U+ G% {) x# t: C
  544.   int r = 4;* q% @& ^4 g) G$ t1 c4 e5 Y
  545.   int p = 1461;
    + L" h/ L8 F, N6 z+ }
  546.   int v = 3;# F6 t" t9 z5 ?3 Q0 f0 H
  547.   int u = 5;, p% Y8 o, |/ [% e4 m/ l( T, T$ w: n) w
  548.   int s = 153;
    / I% _9 |& E: M. D( u6 H/ p
  549.   int w = 2;9 _5 m* v  p4 O. K
  550.   int b = 274277;4 J6 z+ c. U! ]: @8 ?% q
  551.   int c = -38;
    $ v  i& \+ R& h$ r8 [& K( i) T
  552. , y" d6 A7 _' D: h
  553.   int jdn = (int)(jd + 0.5);
    ; u* f; N; O9 n3 [" J: e0 C
  554.   int f   = jdn + j + (((4 * jdn + b) / 146097) * 3) / 4 + c;
    / Y1 |8 v- a" q( W, @
  555.   int e   = r * f + v;
    % n$ k/ A3 b2 L; J; N( o
  556.   int g   = (e % p) / r;/ n" |2 J- i( B8 h* f
  557.   int h   = u * g + w;
    9 I4 n+ g8 f; a9 S/ ~

  558. " J! n& x! ^' [. ~
  559.   DateTime time = {0};
    5 G' z. a2 [  [: z, u" _: X
  560. ' Q0 [- H" _6 |" c
  561.   time.day    = (h % s) / u + 1;
    ) J  _" V/ c& s9 I' o5 l
  562.   time.month  = (h / s + m) % n + 1;- y6 h3 c# P" V& I( a
  563.   time.year   = e / p - y + (n + m - time.month) / n;" [- g- I! ~/ C! Z. z
  564.   time.hour   = (int)((jd + 0.5 - jdn) * 86400.5) / 3600;8 |+ |2 k& D+ O5 T+ w9 q. |! o& z
  565.   time.minute = (int)((jd + 0.5 - jdn) * 86400.5 - time.hour * 3600) / 60;7 _9 |" ]% B$ o! r% ]
  566.   time.second = (int)((jd + 0.5 - jdn) * 86400.5 - time.hour * 3600 - time.minute * 60);
    : c! c0 h7 k" k
  567. 0 U6 `6 P6 g; H5 e" @# Y" `1 E  l
  568.   return time;
    , U% W! o  N0 N: K- K4 `% G
  569. }
    8 F( N; P; x% |1 C/ x6 @: q

  570. 0 `2 f! `- A& M: B
  571. /****************************************************************
    " N* {; M2 p+ D6 S9 j0 u5 y3 o9 g
  572. * Function:    JulianDateToGpsWeekSecond
    1 w- x0 [" I# Y* y% p
  573. * Description: Julian date to gps week and second.5 ?; _  g$ o* J* P( i3 l
  574. * Input:       jd: Julian date.
    - G2 P! V2 l, C( R0 ]
  575. * Output:2 i# X3 V( v1 o: Y( J
  576. * Return:      Gps week and second.
    " _" U& u  L2 j( l6 `' R$ E2 c9 q
  577. *****************************************************************/
    ; b) r: q9 D! N! g$ |
  578. GpsWeekSecond JulianDateToGpsWeekSecond(double jd)" x3 L0 N4 o) V6 @# b% v
  579. {1 b% q8 ?% I  l) X
  580.   GpsWeekSecond time = {0};* y. T% E1 U; s% l
  581.   DateTime      date = JulianDateToGregorianCalendarDate(jd);" M) U2 {3 X6 B' N4 V1 M7 W& F2 N
  582. * e7 _2 {0 z0 s& E) ^
  583.   time.week   = (int)(jd - 2444244.5) / 7;
    ( g( e% y" t; ?4 t* i
  584.   time.second = ((int)(jd - 2444244.5) - time.week * 7) * 86400 + date.hour * 3600 + date.minute * 60 + date.second;2 e: O$ m" {: b4 ~$ h' b: p& K

  585. ! H" f5 O: Z0 {6 {. `0 y3 L
  586.   return time;/ \) J) R% n( O( a
  587. }
    0 ^, w7 A  F0 _+ |
  588. * [& c" i& d. }0 U$ N5 [* G
  589. /****************************************************************
    / L# v. n6 S  a2 z" ~: ^
  590. * Function:    JulianDateToModifiedJulianDate
    & y5 G3 b8 Y  K' T+ E2 }9 M$ Z
  591. * Description: Julian date to modified julian date.
    5 p( g6 x! F+ m; w7 i3 j
  592. * Input:       jd: Julian date.
    2 N: {1 Q% M9 A- @% @
  593. * Output:
    # k: p7 ?  I2 V+ _0 O
  594. * Return:      Modified julian date.
    & @# Y- G4 A' e% f' J
  595. *****************************************************************/  y" K, ^, m# n1 Z
  596. double JulianDateToModifiedJulianDate(double jd)
    7 \" D- C2 g8 b9 o5 O; E
  597. {6 A% z2 k$ w: f1 \8 L4 F
  598.   double mjd = jd - 2400000.5;: W- U1 F! y' h0 D% O+ S' X. X

  599. - J0 I" a* e0 P2 J1 G) x9 w: Y
  600.   return mjd;* k4 V( C; X2 x0 d. g4 C& }
  601. }- Z. o, h" w0 ^- D

  602. ! ^; B7 G$ a  ?/ o  H* q
  603. /****************************************************************2 c$ ^+ M. P8 _" O! ^
  604. * Function:    ModifiedJulianDateAddYear$ z1 W; d5 p5 G
  605. * Description: Modified julian date add year.
    . |- A: G7 L6 A2 w% V6 o: c. i
  606. * Input:       mjd:  Modified julian date.
    6 U+ s+ }; z+ w; v8 ]
  607. *              year: The number of year to add.: x& S. K* V8 f2 {9 _
  608. * Output:
    ( z3 u. J0 M, D; w/ U6 w
  609. * Return:      Modified julian date.0 ?0 T4 ^7 R. j. Z  M
  610. *****************************************************************/0 Q/ P- F. I! G" c
  611. double ModifiedJulianDateAddYear(double mjd, int year)# ?: a7 C5 c; A# r% b. b
  612. {# ^0 _' N8 O: j3 b- P
  613.   DateTime date = ModifiedJulianDateToGregorianCalendarDate(mjd);
    " F# E: K4 R. I1 n0 j( \" G; v/ N& R

  614. ! k% o- A' @, I6 d7 g8 X) p
  615.   date = GregorianCalendarDateAddYear(date, year);' z) e% h* ~- i% M4 N) H* @* {: ?

  616. 9 J/ y- {: R- \
  617.   return GregorianCalendarDateToModifiedJulianDate(date);
    ! k. y- i/ T( q: \/ @9 Q
  618. }9 ]7 f9 X; P% W2 k# T/ b. r
  619. ' R7 D) O! H: n7 s  O# m
  620. /****************************************************************
      m9 G) V: q. _
  621. * Function:    ModifiedJulianDateAddMonth
    8 s8 H8 I$ M0 X# A! q; H) }7 Y
  622. * Description: Modified julian date add month.( U& h& V* k) ]. ?  H# o
  623. * Input:       mjd:   Modified julian date.) f$ D. U" D( v. p* W
  624. *              month: The number of month to add.
    . q9 ~5 Y- T" w& Q, d9 @% N( j$ R0 z
  625. * Output:
    & E. f: F( ~1 n& y: N
  626. * Return:      Modified julian date.
    1 r& p$ t, V! I/ |. H
  627. *****************************************************************/
    9 Q1 M+ |# g" G! ]+ [
  628. double ModifiedJulianDateAddMonth(double mjd, int month)
    : j5 z8 F9 R# M
  629. {, y8 C0 C$ P- `3 `5 A
  630.   DateTime date = ModifiedJulianDateToGregorianCalendarDate(mjd);
    $ _/ D) J' I! i* I
  631. 9 U1 ~4 Y5 D. G
  632.   date = GregorianCalendarDateAddMonth(date, month);7 y% x; V5 P* N: [# N  l

  633. * X. R$ o/ }) y" i
  634.   return GregorianCalendarDateToModifiedJulianDate(date);) c, l/ _! {  N$ j$ j/ L& E
  635. }& F$ b! e; N" @7 ~: K

  636. & J! H8 e  {6 i9 ~. y1 e: I
  637. /****************************************************************
    & t% j4 I* _8 s; U
  638. * Function:    ModifiedJulianDateAddWeek
    9 z: M' f* Q" n' ^" u
  639. * Description: Modified julian date add week.1 l- N' [/ ?5 K3 \$ M2 b4 P
  640. * Input:       mjd:  Modified julian date.
    2 i& ~" U! P$ k  x: T. y
  641. *              week: The number of week to add.
    2 z8 x: x) ~7 l. V) M. s
  642. * Output:; t5 z2 E# b$ g! g' y( {
  643. * Return:      Modified julian date.
      O; r! E+ e% x9 {0 s- x& A
  644. *****************************************************************/  J" y0 e1 N% f" Z6 b0 [4 u
  645. double ModifiedJulianDateAddWeek(double mjd, int week)- t* b, [0 i% [: Z' ?
  646. {$ t' u+ P# L2 j7 v% F7 W  d
  647.   mjd += week * 7.0;
    # W4 B5 j) G9 |% V7 M2 p5 m
  648. 2 v: W1 @5 y3 _1 Q
  649.   return mjd;; x2 m( |2 X2 l  Z4 W) R) k, ^
  650. }4 x0 K- F: \0 e/ b
  651. ; s0 R# O0 L& X4 g
  652. /****************************************************************
    7 y4 J) `& T( r) h( w
  653. * Function:    ModifiedJulianDateAddDay9 Z3 r4 N& V0 M
  654. * Description: Modified julian date add day.
    2 F5 _: h; N" e: ]  \
  655. * Input:       mjd: Modified julian date.
    ! p- G7 S& h9 t* \1 C$ e: I
  656. *              day: The number of day to add.6 n3 v% H4 t2 S- d" o4 t
  657. * Output:' D- O' }) _3 p2 A' k, {0 z
  658. * Return:      Modified julian date.
      g3 ~6 T2 o+ t6 @
  659. *****************************************************************/
    : X" N4 u3 T: S: G# P9 T
  660. double ModifiedJulianDateAddDay(double mjd, int day)
    + l0 h" z" w1 ?6 z) T
  661. {& b4 R# Z! @8 s) W
  662.   mjd += day;/ [* Z1 m1 v/ _# Y* j$ ]. E
  663. , K# L9 I$ h, V7 L+ a( T. L
  664.   return mjd;
    : U+ t3 o: s: q7 x  P
  665. }- m1 ]! o4 O* v: d  |' n% F! R& y$ l

  666. 5 Y3 S: k$ F2 I
  667. /****************************************************************
    6 w/ V  X. M( V5 V, E, V& N
  668. * Function:    ModifiedJulianDateAddHour
    4 s$ \0 f  x. O- g  @$ z
  669. * Description: Modified julian date add hour.- w6 |' V* d; l& J! E' d1 e
  670. * Input:       mjd:  Modified julian date.
    # F0 d) C4 E1 ?5 v
  671. *              hour: The number of hour to add.
    , F' q( i) M* Z8 u; V* _$ F1 @. V
  672. * Output:
    8 b3 P& u" ]4 ?: P# b/ w% v  r
  673. * Return:      Modified julian date.
    2 `, ]/ K4 x2 h& J7 g
  674. *****************************************************************/
    + m/ A" e* M3 S- @0 I
  675. double ModifiedJulianDateAddHour(double mjd, int hour)
    # c2 {- L1 O! K3 y( k/ p) T6 L
  676. {
    $ Z8 `" w6 w* J5 Z, R/ m
  677.   mjd += hour / 24.0;
    3 A1 t7 @: S4 o; ~: e
  678. 2 K) Q3 Q: o' K' N8 k" o2 E% \
  679.   return mjd;2 D; }! I6 T$ A0 O* b% k
  680. }- w3 M3 I; G" K8 `' e# E
  681. 1 }/ x5 Q, ^5 p+ A; W" R
  682. /****************************************************************! S! @& a- v  {% V
  683. * Function:    ModifiedJulianDateAddMinute* |6 A+ C) E- v; c% c" N
  684. * Description: Modified julian date add minute.7 S8 H# C6 X' u) _0 U
  685. * Input:       mjd:    Modified julian date.
    1 X+ Q# x! I" g% ]) ]. u5 B! R, j
  686. *              minute: The number of minute to add.0 e5 J' g& g1 ]0 R& @" F0 Y, `1 r
  687. * Output:( j' w% P& m7 `; d$ @& ]
  688. * Return:      Modified julian date.
    ) s: b: O2 V% Z6 d* U& o1 J" W
  689. *****************************************************************/
    . e; o: u& g0 r  w, \. [
  690. double ModifiedJulianDateAddMinute(double mjd, int minute)
    * n( d2 B2 {- Z( W2 I; s
  691. {
    % O; ~9 A3 G: }% v2 c+ V; U8 J
  692.   mjd += minute / 1440.0;; l+ V' N8 l' x

  693. . ?" c) W: P) Y  c' ]
  694.   return mjd;7 A8 }1 w9 z! `. Z8 d; b
  695. }- P4 W: l; _; K
  696. ! ]2 i& ?7 Y% j. w9 `: j+ e# U
  697. /****************************************************************; K7 F9 {7 ~/ f3 v$ u6 C2 m
  698. * Function:    ModifiedJulianDateAddSecond+ ]/ {* u8 G  z/ L9 c
  699. * Description: Modified julian date add second.
    . w# P' f' i8 W4 |! y5 f
  700. * Input:       mjd:    Modified julian date.+ ?3 G$ `% W7 ~$ {2 ~) i
  701. *              second: The number of second to add.
    5 c4 D7 `* E' j+ \9 R: z, y! |
  702. * Output:
    # g" ^+ Z: D% p3 Q
  703. * Return:      Modified julian date.( x8 z" a0 U9 |* K5 j0 y
  704. *****************************************************************/
      Y+ i  ^+ l% N. [% m
  705. double ModifiedJulianDateAddSecond(double mjd, int second)3 Q$ w! ]- k( o. y1 g
  706. {2 y" S3 y% p* ^* H, @; `
  707.   mjd += second / 86400.0;  _% ?0 l( p& ]! ]" {# R+ A

  708. ( A& x7 o% ^' Z) T$ J8 ^6 X
  709.   return mjd;# \: Z( S, S% z4 q: ^1 a3 l
  710. }: V1 _" L$ A0 D
  711. : x2 F2 r' I" k8 |
  712. /****************************************************************
      i! t3 t, w  @* j! M
  713. * Function:    ModifiedJulianDateToGregorianCalendarDate
    ; f4 x. v! ^; g! o# \) ~, t7 F
  714. * Description: Modified julian date to gregorian calendar date., U( k- z/ W6 n1 v+ v
  715. * Input:       mjd: Modified julian date.% z3 b/ C  R& z) f
  716. * Output:
    * M2 q/ n: N) {, H; C' t# o
  717. * Return:      Gregorian calendar date.
    + c& H4 E! _- |8 v% C
  718. *****************************************************************/) [5 A% N' U7 v3 ^
  719. DateTime ModifiedJulianDateToGregorianCalendarDate(double mjd)* a8 [+ O' y+ B9 Z
  720. {: V8 J' e  V1 L+ M0 n% N
  721.   return JulianDateToGregorianCalendarDate(mjd + 2400000.5);, |% z1 Z9 z) E8 Y+ Q* ~
  722. }: l1 E) Q: h2 |) z

  723. 5 P; z3 n3 E  x6 T- r  s( B
  724. /****************************************************************& \- _% Z7 q& O6 B
  725. * Function:    ModifiedJulianDateToGpsWeekSecond
    1 C9 r6 d5 O, j1 m
  726. * Description: Modified julian date to gps week and second.0 {( j5 b7 b9 h8 L; ?
  727. * Input:       mjd: Modified julian date.
    , `' V% C6 @) m2 F
  728. * Output:
    8 C5 {% u: O( n
  729. * Return:      Gps week and second.
    4 q# k5 M# h6 B, i5 \
  730. *****************************************************************/
    9 q6 d, h" y* D& \7 U! q
  731. GpsWeekSecond ModifiedJulianDateToGpsWeekSecond(double mjd)- h8 o) L7 m# P8 t5 r, e. W9 s
  732. {' \9 f; Y& b) g1 H
  733.   return JulianDateToGpsWeekSecond(mjd + 2400000.5);5 K$ T+ ?3 w# i1 _0 O( j" q
  734. }
    ) x; z1 B0 z% P
  735. ( E! x& [5 P& o& v
  736. /****************************************************************
    6 O% |' |, F- ~+ o/ o7 x8 X
  737. * Function:    ModifiedJulianDateToJulianDate5 T% K" H2 Y" i, ?7 J0 g# r
  738. * Description: Modified julian date to julian date., a( c' U' }% W. J- w% [
  739. * Input:       mjd: Modified julian date.& D' F  U$ f, H3 L" L( u! s& F
  740. * Output:8 `% G0 p: O% _; I: E" \
  741. * Return:      Julian date.6 m: D; B) b+ k, p+ q0 E: o
  742. *****************************************************************/
    & P- p4 L3 [. s! K1 k- {/ {
  743. double ModifiedJulianDateToJulianDate(double mjd)9 V! v/ F. H! I9 `. U( G
  744. {
    # k/ Y6 `2 E" F
  745.   double jd = mjd + 2400000.5;
    7 ~. i1 q* g# [, x2 g* a
  746. + M. F& [1 u0 o# K" v* H5 P
  747.   return jd;% Y3 H9 o" z, P7 V6 E
  748. }
    # [6 t( A: ]! ~$ k9 I
复制代码
/ D3 l0 w9 A0 s3 c$ ~% M
      main.c文件
$ i! d! q2 s. J7 u: t7 M
  1. /****************************************************************& e# p* \  y# l6 E" T9 D( z9 ~
  2. * Copyright (C) 2017, XinLi, all right reserved.! M) T$ k5 I; O+ t5 x
  3. * File name:    main.c: {6 G- D) [6 _! g
  4. * Date:         2017.10.17
    . n* u! v1 O! M: U7 B
  5. * Description:  GPS, UTC and local time displays.
    " I2 S# Z- I: U* B% j
  6. *****************************************************************/
    + T. I1 h' U: }5 ^8 i, v' }

  7. ( u9 L8 {) a1 E* E
  8. /****************************************************************4 i8 Z) P2 X3 U6 m( N9 A( j
  9. *                        Header include: K3 K* \9 y  Q: v' E- |0 O, \, @
  10. *****************************************************************/( C0 m! m' g$ B+ ~* E( I  X
  11. #include "DateTime.h"  c% }0 u& r: ?2 C$ x! o% g
  12. #include <stdint.h>
      H" s; l$ V; l+ H4 Y6 s# l# E
  13. #include <stdio.h>( q& e& C  U* m( v2 x
  14. #include <time.h>9 d! O  j1 ~! a7 j
  15. #include <windows.h>& ~; R+ h7 ?1 }& `8 Q
  16. - d6 s+ }, m% _5 |$ t; B& q
  17. /****************************************************************
    * p$ H  b/ B" A6 C
  18. *                       Global variables
    7 F3 {( Y; G8 T
  19. *****************************************************************/2 I  }$ ^; {1 _5 O6 G2 V- f
  20. 2 m; ]" R1 C2 M& {8 @# H

  21. ) X: J; g. K7 P& t$ Q# ?( ~! k4 V7 R8 k
  22. /****************************************************************
    * K/ n1 Y- T* [9 u' S4 I! `1 k1 D
  23. *                     Function declaration8 g+ z: z* X- c7 B. s  k7 t9 L
  24. *****************************************************************/3 q2 |5 s- x+ `0 m4 \6 q. T- g
  25. static void gotoxy(int x, int y);. H4 [( `3 w% m( K* L( E

  26. 8 z" y" C1 O0 _; _+ O$ b
  27. /****************************************************************
    3 ]( X( a/ e9 A: T
  28. *                     Function definition
    ' B! _$ s* @: ?) T6 |
  29. *****************************************************************/
      @( u8 q) @6 B6 w" s
  30. & E4 l4 h: _9 o3 f0 f3 b: H: i
  31. /****************************************************************% [- \1 A! b7 Y
  32. * Function:    main
    % B5 O1 i) y: Q; ^
  33. * Description: Program entry.  I- h7 w7 [4 n) P0 N8 J( `7 w' @9 g! @
  34. * Input:
    + _  i6 m. B. l, i/ X
  35. * Output:
    " H3 e" }+ W9 U% J
  36. * Return:& P1 Q% Z" }& [8 d7 \
  37. *****************************************************************/
    ! L" T4 x9 L. H7 @
  38. int main(void)0 ]$ z' x8 `/ r1 M2 D
  39. {8 S, d, e/ k1 Y( z# }
  40.   for(;;)
    9 V) G' h/ @$ U; i+ h+ ^7 ^
  41.   {. m1 B0 P4 ~& i, W* v# Q* G
  42.     time_t        times     = 0;
    : T0 s2 ~) c) g
  43.     double        mjd       = 0.0;+ J8 c0 ~8 x5 l3 O
  44.     DateTime      utctime   = {.year = 1970, .month = 1, .day = 1, .hour = 0, .minute = 0, .second = 0};; p! U* Z/ i$ s8 L& ]
  45.     DateTime      localtime = {.year = 1970, .month = 1, .day = 1, .hour = 8, .minute = 0, .second = 0};
    . B3 t6 \7 d% P- o: i2 @
  46.     DateTime      gpstime   = {.year = 1970, .month = 1, .day = 1, .hour = 0, .minute = 0, .second = 0};" G& A; \( E4 D  w0 P! m
  47.     GpsWeekSecond gpstimews = {0};
    3 L% W  R! U2 x5 [5 z0 A
  48. & \! m% B1 s/ W& @" P3 L
  49.     time(×);
    4 T8 d2 A" G/ j4 z
  50. ) C/ {' T7 s2 s# x/ m; e
  51.     if(times > INT32_MAX)7 Q1 L4 b! H8 B
  52.     {
    6 B/ L0 w( A4 z) B: |* N
  53.       utctime = GregorianCalendarDateAddSecond(utctime, INT32_MAX);- Y; a# Y5 K7 a3 w
  54.       utctime = GregorianCalendarDateAddSecond(utctime, (int)(times - INT32_MAX));
    3 M, e$ \. G6 u6 O  Z
  55.     }: q! @: C; C4 E8 Z" K$ e
  56.     else* F+ d& q2 q% o
  57.     {* T6 z7 R3 {" v& J* i2 S) s+ V
  58.       utctime = GregorianCalendarDateAddSecond(utctime, (int)times);
    0 V+ B% _+ i+ p% ?$ `: n
  59.     }
    + L1 ^3 S% }  ^" T
  60. ( k1 w0 u  n- Z5 _% a' j5 Q7 d
  61.     mjd       = GregorianCalendarDateToModifiedJulianDate(utctime);
    2 [- b2 N6 X/ d9 N, y( x
  62.     localtime = GregorianCalendarDateAddHour(utctime, 8);
    . l1 B& A) i/ g# Z: x
  63.     gpstime   = GregorianCalendarDateAddSecond(utctime, 18);5 s; Q7 V- r& o3 \
  64.     gpstimews = GregorianCalendarDateToGpsWeekSecond(gpstime);' p0 \8 E/ ^" H2 s$ O
  65. / t  R! l3 d2 j) b6 A
  66.     gotoxy(0, 0);5 C6 H  Z, n, M% d' j- R4 z/ M

  67. ; f! f6 h- f( f% _6 b. g9 e
  68.     printf("Local | %d-%.2d-%.2d %.2d:%.2d:%.2d | timezone UTC+8\n",
      o! q$ x" Q+ h1 m( E, w" o
  69.            localtime.year, localtime.month, localtime.day,
    # r6 s2 o: K) p- C$ y# G- j* m
  70.            localtime.hour, localtime.minute, localtime.second);2 k# z2 r% W6 D

  71. 4 J1 ^( X9 z6 W) g& e7 A
  72.     printf("UTC   | %d-%.2d-%.2d %.2d:%.2d:%.2d | MJD %.5f\n",2 I' `6 D' o$ S: T7 ?  L' V
  73.            utctime.year, utctime.month, utctime.day,
    : u3 h! G/ o2 N$ t/ M  Z( s7 f  v) ^
  74.            utctime.hour, utctime.minute, utctime.second,/ J% Z" _0 P% {3 H, L* |! ~  S) @
  75.            mjd);* a* y! L8 H& t6 r

  76. 0 y+ u3 s# ?1 N
  77.     printf("GPS   | %d-%.2d-%.2d %.2d:%.2d:%.2d | week %d %d s\n",
    $ G- Z/ O0 {( y9 q8 A
  78.            gpstime.year, gpstime.month, gpstime.day,# |' z* X9 k' p" k6 q! B7 A. R
  79.            gpstime.hour, gpstime.minute, gpstime.second,
    1 S8 P. Q0 a. c+ Y3 h% n, M0 F
  80.            gpstimews.week, gpstimews.second);
    4 o( |" `2 s. N  D: p

  81. , m: M8 m9 M! u$ s2 A
  82.     Sleep(100);. Z: I3 _4 n: e* @  \/ n
  83.   }
      P5 }  h! s$ G
  84. }
    % E+ [" d% k7 q2 }1 x( m

  85. , W+ W1 C6 J1 y9 p
  86. /****************************************************************# t: r% I; u. B4 Y: z
  87. * Function:    gotoxy! p6 p  @. F5 Z" z  s
  88. * Description: Move the cursor to the specified position on the text screen.
    $ Q7 ?5 y8 W/ @. h  j# y
  89. * Input:       x: X axis coordinates.
    7 f6 ^( O. M; z3 Y2 L4 U) c3 C
  90. *              y: Y axis coordinates.
    % K2 ]* E) J) Q, {# q7 R
  91. * Output:
    ( p& f) E9 M- G; ?8 M
  92. * Return:
    ' X: T+ r) b$ l* b2 y
  93. *****************************************************************/
    8 }9 ?( O6 o8 f7 c
  94. static void gotoxy(int x, int y)
    7 X* }+ s) S+ t0 L" e6 r
  95. {/ O  \) k7 ]) T6 g3 r
  96.   COORD  pos  = {x, y};
    1 p: Y6 t4 F5 k1 i" Q6 ?
  97.   HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    0 w7 [: V2 F  u
  98.   SetConsoleCursorPosition(hOut, pos);& w7 d  D  q  p5 e1 d
  99. }( r- [$ d* R7 C9 T: r
复制代码
, T# d4 i: f9 Q, R2 F
3，运行效果& u1 T# Y) f* y
RunningResult.jpg & J8 W+ d$ {( G8 s5 M( a3 Z
) D" g: [  y" I6 Q1 q) U
赞 收藏 评论2 发布时间：2018-2-2 21:41

举报

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

所属标签

STM32团队

STM32团队

意法半导体微控制器和微处理器拥有广泛的产品线，包含低成本的8位单片机和基于ARM® Cortex®-M0、M0+、M3、M4、M33、M7及A7内核并具备丰富外设选择的32位微控制器及微处理器。关注该话题即可发布文章！

最新内容

关于
意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电（SPD）
区域控制单元（ZCU）与分区架构
关注我们
st-img 微信公众号
st-img 手机版