请选择 进入手机版 | 继续访问电脑版

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

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

[复制链接]
XinLiYF 发布时间:2018-3-7 20:34
GPS,UTC和本地时间的显示器+ v; ]; O. F3 `5 u1 ~% E
& L6 h. D. T0 s
转载来源:GPS,UTC和本地时间的显示器
5 h' X8 k. p9 c. C8 m: U$ B3 `8 G0 }7 g2 E  q8 l: k' g+ Z
GitHub仓库:http://github.com/XinLiGitHub/GpsUtcAndLocalTime
/ H* p) H" q* U. K9 GPS:博文不再更新,后续更新会在GitHub仓库进行。$ w2 q7 Q' P4 H* S
% h( {3 h/ i8 A3 O. y
      GPS,UTC和本地时间的显示器。程序中涉及到朱利安日期的转换,详细介绍见维基百科[Julian day](http://en.wikipedia.org/wiki/Julian_day)。0 l2 {3 ~( E) I7 `( X
  `3 ?  n1 A* z
1,开发环境2 t! k- Q+ S2 @+ I; f
      1,操作系统:Windows 10 专业版# V( S0 B  L& d: ~# @
      2,IDE:Visual Studio 2015 专业版% t6 Y* k( ~. n, r* I
" M) M' i. @- K
2,程序源码
0 b7 @$ d/ s/ D0 f2 n      DateTime.h文件
$ h+ Q# j, G' t- S- D
9 H2 A2 u( F& Z, \  ~6 \
  1. /****************************************************************
    $ p2 f, l3 }7 V3 E: i
  2. * Copyright (C) 2017, XinLi, all right reserved.0 l# B5 q! j" E% c) p* j
  3. * File name:    DateTime.h
    1 b6 p& q3 R6 Z
  4. * Date:         2017.10.17! Y: C2 ^. x  n" `
  5. * Description:  Date and time module header file.
    . |1 P# z  k0 ]' J+ |
  6. *****************************************************************/6 v+ v% ?+ f9 b9 q+ ~% D) N
  7. + W3 g! g  l3 E/ H+ W
  8. #ifndef __DATETIME_H
    % x! B; u* }$ J  L% `3 A
  9. #define __DATETIME_H9 y; m# K4 e( }1 R+ `

  10. - g( X, E6 R& S) y; K+ J
  11. /****************************************************************
    " s0 E4 C. G) n" \0 a8 X7 U
  12. *                        Header include
    # S" W7 l9 y' S4 Z9 b# h
  13. *****************************************************************/$ b9 v4 I& a3 p/ ]7 e% L; U; U8 c: M
  14. ) j& n( `" }7 u8 r. {! N8 U

  15. " T' e2 X5 e) _, z4 y
  16. /****************************************************************
    % j; e. t; P! x! T
  17. *                       Macro definition
      |) G0 L7 a* f* m. I& x- `1 V
  18. *****************************************************************/' j1 P9 P9 v: L! W: Y/ Y6 \

  19. 9 Y( @8 P  Q$ j/ P

  20. ! X3 ~- [4 \# ]; t" @2 ~
  21. /***************************************************************** b$ O5 {  `9 N( f
  22. *                       Type definition4 K/ [) r1 b4 \
  23. *****************************************************************/
    0 [4 `8 C* ~8 u- q' k: Y* W

  24. 4 j9 H# R9 R$ e2 K# H7 n: |9 n

  25. & b3 S7 ]6 M& z# U
  26. /****************************************************************7 t& X+ U. E& G) M6 Y
  27. *                     Structure definition
    0 G- k* K( L6 q$ s+ X9 ^# c
  28. *****************************************************************/  s$ a9 a0 [: z- a+ C
  29. typedef struct
    & U* D- z+ ?; H0 l+ Q, `8 e0 V
  30. {
    ! f3 v! f: E1 p; A6 J) F5 e
  31.   int year;3 g8 r- m. T6 ^8 q& d
  32.   int month;
    8 ~/ s* b3 a' `
  33.   int day;
    , m9 @/ B( S0 {( {# e& i& [
  34.   int hour;9 Q* g( |1 z; H- A) X$ c8 Y3 H
  35.   int minute;
    # t  e/ G3 N" O9 u; o7 [7 y
  36.   int second;
    6 p; A. P1 B4 N/ C* V
  37. }DateTime;3 z) q1 J# Q# n# G( ~9 }
  38. , f7 P. j( d: |! O1 U
  39. typedef struct+ H* C% r" J9 o! U( ^
  40. {7 y3 w! W# h2 Z8 |, `
  41.   int week;" r& H" m3 j  ^! o- S7 S+ \
  42.   int second;/ d. Q4 T4 R2 C/ _
  43. }GpsWeekSecond;
      b5 L$ f$ S1 A: L) U
  44. $ c$ M* x7 {! C/ Q  x! \

  45. * X% f; E9 a( a# i
  46. #ifdef __cplusplus  O) q3 h6 [4 O5 S0 d
  47. extern "C" {, f" J+ Z1 ?& M. Q" v) U
  48. #endif  /* __cplusplus */
    $ R4 {; t% X3 v: Y% ]% {5 u
  49. 4 D7 v& d9 U2 m# m: X- |2 F7 ^
  50. /****************************************************************
    ( k0 D4 ]% F  F
  51. *                     Variable declaration" u9 p% \6 v2 `5 f# D
  52. *****************************************************************/
    7 p9 x/ h+ K/ R, t1 l

  53. - o3 m* x6 D. v  x

  54. 8 R4 a& H4 Z3 ^3 {4 b! n
  55. /****************************************************************9 e$ R5 y  R. w, D! ^  r8 F. q" a' _: ?
  56. *                     Function declaration+ B! N8 s9 n6 I. F' [8 X( x
  57. *****************************************************************/* v" |: t0 Z) D* A
  58. DateTime GregorianCalendarDateAddYear(DateTime time, int year);7 ?4 ^( V4 Z/ A. K6 l
  59. DateTime GregorianCalendarDateAddMonth(DateTime time, int month);
    & i! I) i5 _( ^4 G
  60. DateTime GregorianCalendarDateAddWeek(DateTime time, int week);
    & q6 X  U' v; P2 \" ?1 w, r
  61. DateTime GregorianCalendarDateAddDay(DateTime time, int day);1 z4 ^" `# a" L/ l% O) C
  62. DateTime GregorianCalendarDateAddHour(DateTime time, int hour);
    5 ~* C0 y1 {8 [: R
  63. DateTime GregorianCalendarDateAddMinute(DateTime time, int minute);
    ' D3 Z1 \7 o; F
  64. DateTime GregorianCalendarDateAddSecond(DateTime time, int second);
    - K' q/ X% Y- x6 I8 G* i! G' [. b
  65. GpsWeekSecond GregorianCalendarDateToGpsWeekSecond(DateTime time);
    8 i6 E! a. Y/ w8 ]' u9 p- {( x
  66. double GregorianCalendarDateToJulianDate(DateTime time);: E+ h; k1 T  M0 @
  67. double GregorianCalendarDateToModifiedJulianDate(DateTime time);% p" O8 X! _) k# _& s! X3 Y
  68. GpsWeekSecond GpsWeekSecondAddYear(GpsWeekSecond time, int year);2 R$ R5 J+ Z0 P5 p7 a/ j( Y- A
  69. GpsWeekSecond GpsWeekSecondAddMonth(GpsWeekSecond time, int month);/ m" n4 h: T. m) x
  70. GpsWeekSecond GpsWeekSecondAddWeek(GpsWeekSecond time, int week);
    ) o& Z! K2 b3 r. M1 M+ o
  71. GpsWeekSecond GpsWeekSecondAddDay(GpsWeekSecond time, int day);
    ; s' R/ G3 v8 B. O' J3 r
  72. GpsWeekSecond GpsWeekSecondAddHour(GpsWeekSecond time, int hour);
    ( H& D) K# \, X- p" U1 P4 ?* B# D
  73. GpsWeekSecond GpsWeekSecondAddMinute(GpsWeekSecond time, int minute);
    9 N; b5 X; s/ D  S
  74. GpsWeekSecond GpsWeekSecondAddSecond(GpsWeekSecond time, int second);$ D9 j' b' G8 B/ g
  75. DateTime GpsWeekSecondToGregorianCalendarDate(GpsWeekSecond time);7 Y8 u" L" h+ f
  76. double GpsWeekSecondToJulianDate(GpsWeekSecond time);
    " O! t. ]$ _1 R4 P/ ~, c2 m9 M
  77. double GpsWeekSecondToModifiedJulianDate(GpsWeekSecond time);
    * D" G5 p( m9 i' B8 Q+ U+ h
  78. double JulianDateAddYear(double jd, int year);
    ) b7 P  K. ]% `+ c4 ]
  79. double JulianDateAddMonth(double jd, int month);. v; ?  [$ B. W0 p
  80. double JulianDateAddWeek(double jd, int week);
    0 x6 t# i" h# W; I2 I2 ^3 @
  81. double JulianDateAddDay(double jd, int day);
    $ F4 O8 y' q0 a8 M5 w
  82. double JulianDateAddHour(double jd, int hour);
    " H* r" g  R- T' {0 _# H
  83. double JulianDateAddMinute(double jd, int minute);
    + ]* l/ D) J) M8 m; J
  84. double JulianDateAddSecond(double jd, int second);) U( S& K' c+ r$ y. G7 C
  85. DateTime JulianDateToGregorianCalendarDate(double jd);9 h. G% o9 U- I8 p
  86. GpsWeekSecond JulianDateToGpsWeekSecond(double jd);
    ; O/ f# h; r7 ?8 x" S4 q
  87. double JulianDateToModifiedJulianDate(double jd);; v7 }5 K% ~0 o  H# b
  88. double ModifiedJulianDateAddYear(double mjd, int year);, o# v2 ^3 {& V4 G! M! t' X
  89. double ModifiedJulianDateAddMonth(double mjd, int month);
    : U! Q  ?5 Z( b0 H' v
  90. double ModifiedJulianDateAddWeek(double mjd, int week);
    * \; R7 q/ B' J. D9 p. }
  91. double ModifiedJulianDateAddDay(double mjd, int day);
    + Z" |" w0 d2 ~, j/ k/ e
  92. double ModifiedJulianDateAddHour(double mjd, int hour);
    : E" G" T8 V  @3 e
  93. double ModifiedJulianDateAddMinute(double mjd, int minute);8 n' _: D$ e1 w
  94. double ModifiedJulianDateAddSecond(double mjd, int second);
    - ^+ Y% ~+ p- O# G3 c
  95. DateTime ModifiedJulianDateToGregorianCalendarDate(double mjd);- y1 I* r1 l# P% P2 a- T
  96. GpsWeekSecond ModifiedJulianDateToGpsWeekSecond(double mjd);
    3 j0 i# [7 r6 _: k' E) u; n, o+ F
  97. double ModifiedJulianDateToJulianDate(double mjd);5 l: Q/ ~) y+ Y( {- l. c
  98. * t) H- n3 D; g& T; ^, ~
  99. #ifdef __cplusplus2 M  n4 |! |4 x9 ]" E( R
  100. }  Z. @. @5 {% s& r; _8 L, \
  101. #endif  /* __cplusplus */% U* u9 j9 X. x) x
  102. , G  D6 Z( z" O+ W
  103. #endif  /* __DATETIME_H */2 ]: a- k! u6 m2 e# @: m' h* c
复制代码

$ W3 ^" h0 e: X8 y: q; L" L1 k      DateTime.c文件) l- E- Z9 |" v
  1. /****************************************************************
    - |% p9 D2 h# [7 u$ C: a
  2. * Copyright (C) 2017, XinLi, all right reserved.
    5 J- B% S1 c+ P( M% @
  3. * File name:    DateTime.c& p# ~% ^1 o2 ?9 r! k
  4. * Date:         2017.10.17- ]. y2 {8 \: u& F
  5. * Description:  Date and time module source file.7 w/ ^4 o6 [( f. o7 J' c/ r
  6. *****************************************************************/
    / O- S3 a% M. V2 x% X

  7. & _8 y8 d) ^1 w( Q* m% M
  8. /****************************************************************1 J5 |7 C7 x+ c; i& l( ~( y7 v
  9. *                        Header include
    9 D- b2 x& Q, ~2 t  Q/ V) I
  10. *****************************************************************/
    # i- _# b8 k& F2 I! @  Y
  11. #include "DateTime.h". B. o3 ~. n% X% x$ m

  12. 9 v5 X; M! Q+ Y
  13. /****************************************************************
    ; h: J+ c1 q- `& o( c- F
  14. *                       Global variables
    0 ]! w; i- ?, `  D3 ~
  15. *****************************************************************/) c. \7 I! p, o
  16. + }, }4 u) _8 e5 j) O/ m( s* I0 F

  17. + J# A- Y( c1 q( z5 v
  18. /****************************************************************3 i+ b0 R9 V/ [8 `# _' h+ J" T7 a
  19. *                     Function declaration6 {- i+ n: W9 U- E
  20. *****************************************************************/# F; Z1 ~# X4 G) e9 k- D  j8 a# O

  21. : W. h, ?7 G3 U4 k& N" {
  22. 9 `- t2 P: \: l
  23. /****************************************************************, A! g  W+ e, {. Q
  24. *                     Function definition" \; {2 k- e% ?' C, Z
  25. *****************************************************************/2 M( D! J1 {5 _. E
  26. , I( m% |% d) N5 _7 R
  27. /****************************************************************
    5 a& E$ {- u1 Q
  28. * Function:    GregorianCalendarDateAddYear" N- b' j. P  D4 `( H; q4 }2 K
  29. * Description: Gregorian calendar date add year.
    8 r, R  C+ B8 Z0 ?# z
  30. * Input:       time: Gregorian calendar date.: q3 l+ T: V# a9 K/ w3 H
  31. *              year: The number of year to add.
    ) e' s& X2 k4 V$ j; A& K  A
  32. * Output:
    , e, W3 |' u+ t7 M  D
  33. * Return:      Gregorian calendar date.
    6 H, `* I# {1 N' @
  34. *****************************************************************/
    ( D5 Z) p( i* O6 V! {9 o$ m
  35. DateTime GregorianCalendarDateAddYear(DateTime time, int year); x% X) c: v. s. h% z+ `
  36. {
    , g) m# B4 Y- ~8 z- i
  37.   time.year += year;
    8 ^/ I$ E6 r  y

  38. 8 p, c( d0 I6 W3 T/ Q7 l8 f, z/ J
  39.   if(time.month == 2)
    8 {8 i9 Q) ?/ y9 ~1 O! ~
  40.   {
    / u2 j0 t' y- w7 s" x
  41.     int mday = 0;
    ; _- c7 r4 g5 U8 l" p" v

  42. . j* G2 U  l7 [8 ~7 B4 h; A7 L, b
  43.     if((((time.year % 4) == 0) && ((time.year % 100) != 0)) || ((time.year % 400) == 0))
    , V4 g8 A$ Z; O8 ?0 Q4 B
  44.     {
    9 t$ C. g: O3 y
  45.       mday = 29;4 v* B! O$ w. p0 B
  46.     }
    % E; j; A9 X! l; i9 L3 O$ z" b# N
  47.     else
    * z+ o4 d8 a2 C
  48.     {
    5 r; t& _4 x; u8 j- {. Q
  49.       mday = 28;, c& q: `3 p) ]
  50.     }
    " V: |0 e* ^6 c: i/ F# ?

  51. " l4 z7 f- y' u) L
  52.     if(time.day > mday)# @4 W2 I$ @1 y& e: b: k1 m
  53.     {
    5 t* o( [. ~3 W/ D  C4 b8 Q7 L
  54.       time.month += 1;
    ' @5 Y; e/ w6 I9 O: o
  55.       time.day   -= mday;; l, e4 W) i% M8 T: m7 C& f
  56.     }, f) h- {! F% q, x' G
  57.   }# n' [3 }/ i( Y1 G" Z6 J# z

  58.   c: }) w  U" C2 r% p
  59.   return time;
    & N2 \7 s1 R7 b4 Z5 N, p
  60. }" W7 ?7 t) j/ }; Y5 a9 c; p
  61. + }! G2 [! s" W6 c# H
  62. /****************************************************************# m1 t6 \( v# R. O6 H# p
  63. * Function:    GregorianCalendarDateAddMonth8 x# A/ o) u& T+ N! @3 \
  64. * Description: Gregorian calendar date add month.0 \" U8 ~' v- D; U
  65. * Input:       time:  Gregorian calendar date.. v3 O3 |2 e. O) F  N
  66. *              month: The number of month to add.
    7 i/ b  o( G) U4 P
  67. * Output:) k, \8 v) O4 |2 m
  68. * Return:      Gregorian calendar date.' {' K+ w! f$ d& x; n8 Q# J( m, m* N
  69. *****************************************************************/& x1 e0 S% b' O3 F' d) r/ Z/ o
  70. DateTime GregorianCalendarDateAddMonth(DateTime time, int month)
    5 @9 B6 z  i% o: O  _5 `& h1 P; s. u( ~
  71. {
    * U4 `5 W5 o. b7 [" l' p
  72.   time.year  += month / 12;8 m1 B3 F. V1 ^5 L8 [7 m
  73.   time.month += month % 12;( f9 P6 V* |) E9 s; m9 \) w
  74. ( I9 ?8 W% a5 d' `6 {
  75.   if(time.month > 12)& G* M) {: d1 z5 l
  76.   {
    2 X9 N0 l7 N( R' a) ?" s
  77.     time.year  += 1;  |0 N. J1 z7 w. R5 M6 _3 r8 Z: M
  78.     time.month -= 12;
    8 \! y3 c0 |) L3 a/ g
  79.   }
    4 g6 P2 q- w3 ?; B2 F6 t' `
  80. 2 Y# R1 S. B! p/ k
  81.   int mday = 0;
    8 v/ B% P, l, c; m- z& k4 f
  82. - ^" ^0 \. u+ E2 q/ M. C
  83.   if((time.month == 1) || (time.month == 3) || (time.month == 5) || (time.month == 7) ||
    * Z; v( u, O0 I: f0 i  u( j' p
  84.      (time.month == 8) || (time.month == 10) || (time.month == 12))
    . d+ M- o5 ~/ F, K+ p5 b" Z3 W" B
  85.   {: c2 C( U% Y1 r, R& n' y3 O
  86.     mday = 31;
      q6 W) h9 I/ P
  87.   }
    8 E  v4 D- _2 {  L: [9 q. M4 \
  88.   else if((time.month == 4) || (time.month == 6) || (time.month == 9) || (time.month == 11))
    : X! f: u- q2 R9 k0 c( o5 q
  89.   {2 [5 w4 ?/ m' H/ c% v& h
  90.     mday = 30;
    - n$ E1 t! `' [  l9 V. W1 _" ]
  91.   }
    * J6 }3 p, R3 z2 l
  92.   else
    3 d8 U3 x( w5 p
  93.   {: Z$ K; [2 k1 P4 t: s& N" m
  94.     if((((time.year % 4) == 0) && ((time.year % 100) != 0)) || ((time.year % 400) == 0)), M. P. [- E6 G; o* ?3 h9 i( e5 X
  95.     {" x* @5 W' v( k% r" s
  96.       mday = 29;
    ! G( p7 G6 W  D8 h! ~5 m' F
  97.     }
    . j7 e0 I. O: l, m5 [
  98.     else8 b1 L) R. G, [7 M1 f
  99.     {
    - t6 v2 D- [9 @5 s% v& |& H
  100.       mday = 28;0 ~( ^3 E# j# v0 _, j
  101.     }3 H9 k" w- f0 p4 c. h* N8 X3 d6 N, Z
  102.   }
    ( q$ L9 w8 a0 D3 C

  103. ; n$ W1 a  l, T+ t
  104.   if(time.day > mday)- q9 K+ K- x3 `
  105.   {
    * }  d1 u7 w4 j9 O# |
  106.     time.month += 1;
    / c7 E0 O8 [# W" ?9 Q" p* \
  107.     time.day   -= mday;& O/ n4 p. m* c( {; M( a* a
  108. . j7 M6 Z3 P6 f+ @. x: r; h
  109.     if(time.month > 12)! n7 g+ g' {$ |0 k
  110.     {
    : ]( N. Z* ?  {7 [/ F# Z% O" V
  111.       time.year  += 1;6 |% A2 L2 _5 Y! z; M
  112.       time.month -= 12;7 _, {5 e8 r& S9 A
  113.     }
    8 s( l  C! t- O1 U: ^, i
  114.   }# X% b3 ~7 i% N1 \0 {/ e# d! ~* p* J

  115. & l9 G3 H! C# h& N* z8 Y$ k! s
  116.   return time;
    ! M" P) V# O4 ^1 ^7 S. v) w/ C
  117. }# A' j1 C% Q- w+ r9 ^& y
  118. 2 ~, L$ T$ G, C2 \
  119. /****************************************************************
    + P; Y: t/ ?+ P/ S5 O% E; Z
  120. * Function:    GregorianCalendarDateAddWeek4 {' h9 H) O; H" j% \+ x! g7 F# ?
  121. * Description: Gregorian calendar date add week.
    8 |+ f* t! K! k. l. X6 f0 b3 Z
  122. * Input:       time: Gregorian calendar date.0 t/ [0 y- k3 [; d6 v% {4 G9 I
  123. *              week: The number of week to add.
    $ q$ o+ r3 j; E8 F  l+ U0 @* {7 P
  124. * Output:
    , v0 K9 k0 E' v  @; B, g1 j1 U
  125. * Return:      Gregorian calendar date.
    3 K. a; `& g% B0 W0 h. v+ A
  126. *****************************************************************/
    ' x1 ?  Z5 K! c4 V$ d; l
  127. DateTime GregorianCalendarDateAddWeek(DateTime time, int week)
    & p  i& s+ S) {: G9 M8 f6 U
  128. {" u* A! u: q8 z4 E! l: k
  129.   double jd = GregorianCalendarDateToJulianDate(time) + week * 7.0;# C+ q1 ~5 G; A* `* M

  130. - c5 c9 h1 y$ s) m+ Q7 }- X& z5 z
  131.   return JulianDateToGregorianCalendarDate(jd);7 k$ @" I# V3 `2 A$ m
  132. }9 }: H: M) T' u$ X$ l( D
  133. : E* Y! D3 W3 F4 R( [% d
  134. /****************************************************************
    / b5 t- m4 q" H' `
  135. * Function:    GregorianCalendarDateAddDay! Z; E0 z" U6 U1 `- H1 O- r# F
  136. * Description: Gregorian calendar date add day.
    # ]$ F; t$ W7 h' L
  137. * Input:       time: Gregorian calendar date.
    + P. Q, e2 I  v. ]  K6 }
  138. *              day:  The number of day to add.
    $ _3 U+ b) Q0 Q4 Y' F2 q! l  S
  139. * Output:. g/ q" x& x# ^3 t
  140. * Return:      Gregorian calendar date.3 T  c/ r1 X1 C  v; {( w' t8 G
  141. *****************************************************************/
    9 A. i* H$ U# K& y: J  k
  142. DateTime GregorianCalendarDateAddDay(DateTime time, int day)* R* d  F: S9 z/ @0 d
  143. {
    ! X* Z: z' j% Q% w* X7 }, D
  144.   double jd = GregorianCalendarDateToJulianDate(time) + day;
    . Y1 [2 ^- }# V) N# t. F
  145. : u* x& k- r& E( O" {8 h" m
  146.   return JulianDateToGregorianCalendarDate(jd);
    " A! N, I% y! T! ~2 b2 w  v# ?
  147. }
    ; A; e- Y- K; K. e+ ?
  148. ) V0 x# y9 }: L+ S/ w
  149. /****************************************************************
    9 R, @# P! |& V0 z& R$ X- Y' T3 j
  150. * Function:    GregorianCalendarDateAddHour' ]' ~% T$ h0 k4 Q6 k) w) B. q
  151. * Description: Gregorian calendar date add hour.
    ( w! v* ]) G8 D9 k
  152. * Input:       time: Gregorian calendar date.
    2 ?9 F  i- `/ i3 R, ]' J, v& x
  153. *              hour: The number of hour to add.9 N9 J1 f8 [5 z2 n
  154. * Output:
    1 O/ ?( `$ r" K" V7 R7 H% }' a2 D
  155. * Return:      Gregorian calendar date.
    4 q, g: [* \& l1 Q( E  q9 h
  156. *****************************************************************/
    * Y8 k$ @6 f, c
  157. DateTime GregorianCalendarDateAddHour(DateTime time, int hour)
    1 M. x# d5 b' B7 H2 E. X
  158. {
    * ~( t. Y+ p/ U* a3 S8 j  ]1 ]
  159.   time.hour += hour;: J7 `( S" B8 s% B2 N6 j

  160. 4 U2 l  p6 f! O/ P9 t' P
  161.   double jd = GregorianCalendarDateToJulianDate(time);
    + d" h+ b0 G" s6 Q

  162. ' \& }! ]& {) @, [- r
  163.   return JulianDateToGregorianCalendarDate(jd);
    ; B) b& D0 |- s) I/ e' ]
  164. }2 y4 b3 D/ t8 H, a' ?2 k
  165. 6 p9 l  ?, V0 U
  166. /****************************************************************
    . m* w+ @* }0 }6 A* v' w. ~
  167. * Function:    GregorianCalendarDateAddMinute
    6 x" ^6 V3 Z% P) W. }" Q; Q
  168. * Description: Gregorian calendar date add minute.$ W+ i5 a) q* W4 A1 f
  169. * Input:       time:   Gregorian calendar date.( o, c5 ^( K3 P% f; j8 r) ~' |- g# S
  170. *              minute: The number of minute to add.; E' ^: P6 A, e
  171. * Output:" M* |, J6 i( U; j' @6 d- o
  172. * Return:      Gregorian calendar date.8 ]! [. J& c: P$ s" d" i! R
  173. *****************************************************************/0 C; r: c8 ^' ?; S1 S9 b" U4 o
  174. DateTime GregorianCalendarDateAddMinute(DateTime time, int minute)3 o: B  Y$ v3 M3 B- A
  175. {
    , _0 t% a7 }4 j3 t5 N8 T+ C
  176.   time.minute += minute;
    % a' [2 }9 H- \$ d1 N. V) R; N
  177. - D0 l6 ~% @# p: Q8 \
  178.   double jd = GregorianCalendarDateToJulianDate(time);/ @7 P& I8 \6 ]5 V0 E

  179. $ n( C0 t3 \% d% f. X
  180.   return JulianDateToGregorianCalendarDate(jd);" F0 Q# z0 q* U/ C, A
  181. }
    8 e( {9 m; D- p: }* o  g4 K

  182. . `: Q1 z+ c# z  B) B
  183. /****************************************************************
    # k0 t$ B2 o5 |8 e' E9 y5 L  w) S
  184. * Function:    GregorianCalendarDateAddSecond# n! l+ N. B7 C7 }; h
  185. * Description: Gregorian calendar date add second.5 @9 v" c; E: o# {3 H9 f
  186. * Input:       time:   Gregorian calendar date./ J$ j% p7 ^' y
  187. *              second: The number of seconds to add.' ?8 i- ]& r+ F( a
  188. * Output:( {$ @5 e3 K9 c2 e
  189. * Return:      Gregorian calendar date.0 U. f; R* L2 m" x3 z
  190. *****************************************************************/
    $ [6 \8 D; Z; k. d3 Z1 ]+ ~5 z9 `
  191. DateTime GregorianCalendarDateAddSecond(DateTime time, int second)
    ; f! e6 h2 ^% c! X+ j+ @
  192. {% }1 `9 E. h% b+ x' j7 D% r# w
  193.   time.second += second;
    2 O/ {1 \# ]+ W4 c% W7 O% f# n
  194. $ \7 U  |1 V. b0 t0 [3 {4 L- D
  195.   double jd = GregorianCalendarDateToJulianDate(time);
    ) a/ y7 d+ {! m9 k$ D" w
  196. ; t9 }+ h) W* f
  197.   return JulianDateToGregorianCalendarDate(jd);! B: r! a9 O6 {7 r, A, m: d  d" B% {
  198. }+ x* {/ s. U% r. s7 H+ E

  199. ; ?" i7 W+ @3 X! [. {' |$ X
  200. /****************************************************************
    8 V2 ~2 a0 U0 d/ ~/ p4 J3 W9 u
  201. * Function:    GregorianCalendarDateToGpsWeekSecond. K) b5 n2 I, v+ x: i
  202. * Description: Gregorian calendar date to gps week and second.4 S7 ~' J! i" w' p2 C9 w
  203. * Input:       time: Gregorian calendar date.! d% i" B# N" h. ]3 g6 {5 z
  204. * Output:. N4 M% y: t$ F6 T4 n. Y
  205. * Return:      Gps week and second.  \8 i! {9 G# r" @, H* ]
  206. *****************************************************************/
    4 V6 d( [4 J; S( b8 B: u/ j2 @9 A% B
  207. GpsWeekSecond GregorianCalendarDateToGpsWeekSecond(DateTime time)+ l$ F1 j4 C9 j7 J2 F5 Q- [
  208. {6 s! G. P6 G) o  k; M- ?
  209.   double jd = GregorianCalendarDateToJulianDate(time);
    # ^( w4 Q- S- L5 f* ^9 A
  210. 9 ^5 F* P6 T4 I
  211.   return JulianDateToGpsWeekSecond(jd);9 K# Q4 x$ V" p
  212. }  H/ r) Y, \+ j! F! D( X
  213. " ?5 Y1 W; q; m4 }4 @( w, y" j* i* ?
  214. /****************************************************************
    ; x- ~# {& D, r% l: O; \
  215. * Function:    GregorianCalendarDateToJulianDate3 T- L0 ]6 g0 A( m% g
  216. * Description: Gregorian calendar date to julian date.
    , E3 k. r9 M6 a
  217. * Input:       time: Gregorian calendar date.1 b% \$ a9 z4 c$ U3 f. u) B" m$ j
  218. * Output:
    8 R* F" j/ W" U( R" t% `
  219. * Return:      Julian date.
    2 \1 i7 t" j6 N
  220. *****************************************************************/9 o2 l) E$ J- `0 T
  221. double GregorianCalendarDateToJulianDate(DateTime time)# J7 X  e$ s3 Q) O; l" y1 i4 V
  222. {
    & c+ ~& o# i3 y2 j$ W+ H
  223.   int jdn = (1461 * (time.year + 4800 + (time.month - 14) / 12)) / 46 j- c: d8 t' F, M  g0 b
  224.           + (367 * (time.month - 2 - 12 * ((time.month - 14) / 12))) / 123 }' _$ w4 `' E. s* u3 I
  225.           - (3 * ((time.year + 4900 + (time.month - 14) / 12) / 100)) / 43 f" }; f/ i: F3 D- _
  226.           + time.day - 32075;
    1 H( Y. K3 H( _% F' |) \7 J
  227. . @- k3 C( V, k; \% o* L
  228.   double jd = jdn + ((time.hour - 12) * 3600.0 + time.minute * 60.0 + time.second) / 86400.0;
    2 k) ~3 d0 x$ b# _3 L
  229. % @4 s$ E* x- W- a% N9 P
  230.   return jd;
    & ^# O" f3 G- ^& T
  231. }- }7 A' x8 l. k% _; d' ?' f
  232. ! c/ w* s: r5 Z( ]
  233. /****************************************************************. ~4 t  S! v# T% R# ~* j
  234. * Function:    GregorianCalendarDateToModifiedJulianDate. e' E7 l0 j; t5 K5 b) X- H7 s
  235. * Description: Gregorian calendar date to modified julian date.8 q4 w5 `8 B2 c0 Q) `0 @' H1 N
  236. * Input:       time: Gregorian calendar date.
    0 M4 H& N& u- @! J- `- P, J
  237. * Output:+ I  d6 `. x# _* G$ q2 a# i! `
  238. * Return:      Modified julian date.% W" j/ j: t/ c
  239. *****************************************************************/4 P) K4 ^. \5 r/ e- L4 s
  240. double GregorianCalendarDateToModifiedJulianDate(DateTime time)* p5 `1 Z2 B7 a' i( \, _
  241. {8 V5 c* E  g. ^: Q+ Q- i* R: B
  242.   return GregorianCalendarDateToJulianDate(time) - 2400000.5;0 ]$ a: v$ D1 Z4 z9 {! ~7 x
  243. }. z3 n* A5 `9 c8 e* v, t
  244. ; \" t9 s. e6 s  J  E
  245. /****************************************************************& n% U4 Y; f! l
  246. * Function:    GpsWeekSecondAddYear) \/ Z: e5 A9 C' |
  247. * Description: Gps week and second add year.
    * M9 c5 C$ v* ]8 ], Z- n
  248. * Input:       time: Gps week and second.
    1 v" G2 @8 M9 U( O/ s
  249. *              year: The number of year to add.0 y' L# c4 Q8 V6 k5 ]4 A# D! [
  250. * Output:
      I! u) h: i0 p
  251. * Return:      Gps week and second.' O  Q9 j1 M2 M5 {* y' H3 U
  252. *****************************************************************/
    ! U# o% a& v1 D$ Y7 j
  253. GpsWeekSecond GpsWeekSecondAddYear(GpsWeekSecond time, int year)8 Z* r- d' `8 j$ V
  254. {
    ; ^1 h4 z, w/ ~- ?: J/ U
  255.   DateTime date = GpsWeekSecondToGregorianCalendarDate(time);
    # h; `& C9 N, A' m. Q/ Z

  256. * k" V$ _5 S$ t6 L2 \
  257.   date = GregorianCalendarDateAddYear(date, year);
    2 p- j" {. w9 i& j$ S
  258. 4 O! ?- O2 F/ w8 l0 t5 G6 l
  259.   return GregorianCalendarDateToGpsWeekSecond(date);6 L- g& \! }$ Z* f1 D% B0 c: {
  260. }
    0 |7 Q) W2 i  X' V0 U4 F+ ^* F2 n8 m
  261. 0 ~9 T, q9 @; b  L) Z% d( B
  262. /****************************************************************
    ( ~4 q, i5 n5 h3 E) C7 F. y& z, a
  263. * Function:    GpsWeekSecondAddMonth
    . G9 u: C; O; B' W9 H
  264. * Description: Gps week and second add month.
    * U: U" l! ?9 L! b* e+ j
  265. * Input:       time:  Gps week and second.
    ' ~2 O5 f9 `1 F; x6 @- n
  266. *              month: The number of month to add.- D$ E7 ~5 {5 F! w2 |
  267. * Output:; H) {# b: t' g/ i4 P4 K$ G0 ]/ T
  268. * Return:      Gps week and second.) P$ `8 Y9 Y: k& y4 Q. U
  269. *****************************************************************/' Y! x9 i  d) H8 d. D
  270. GpsWeekSecond GpsWeekSecondAddMonth(GpsWeekSecond time, int month)2 R( n; l+ J: e0 ]; W8 f
  271. {
    3 `" B7 S% H  K4 ]: F" M: [
  272.   DateTime date = GpsWeekSecondToGregorianCalendarDate(time);
    ' g3 {. y  Y* w  r9 W

  273. 8 e" x) {+ l* [) _" c% J9 T
  274.   date = GregorianCalendarDateAddMonth(date, month);
    ; @5 s  y- @; `* B& A. F

  275. % g' s8 ]# D2 Q% c$ O
  276.   return GregorianCalendarDateToGpsWeekSecond(date);" L. S6 J5 h; z1 r) J
  277. }
      e7 {% }  ^" J  v- e- B
  278. - @7 ]! o- Q! N* X  k. D. G: Z
  279. /****************************************************************9 u6 R4 Y; ]% k& \6 o
  280. * Function:    GpsWeekSecondAddWeek& M! m, @4 l5 o: U
  281. * Description: Gps week and second add week.
    0 O7 W1 i6 r6 K8 Z/ u
  282. * Input:       time: Gps week and second.. p3 Z3 C+ e! c
  283. *              week: The number of week to add.' r7 r8 M$ b% Q0 \3 p# o% C
  284. * Output:7 m. z$ F% P. ~
  285. * Return:      Gps week and second.+ B( D6 b% `6 g/ N7 P2 i# V" o( ~- x
  286. *****************************************************************/' `/ E* [* n0 N
  287. GpsWeekSecond GpsWeekSecondAddWeek(GpsWeekSecond time, int week)
    2 f/ p- V0 Q6 G+ @; M
  288. {  }4 H9 J: D+ F6 S% _
  289.   time.week += week;6 C$ Y$ m8 c1 C
  290. ( u% f: `& S8 g+ a' A# |6 c
  291.   return time;5 b: k# N  c8 }9 R: c
  292. }
    7 u! S6 ^9 x/ S% L& w

  293. , s9 V# \2 J+ z8 C
  294. /****************************************************************) t8 p' ^8 J& ~9 h; J! f& L
  295. * Function:    GpsWeekSecondAddDay& C9 H1 n4 ?9 Y
  296. * Description: Gps week and second add day.& f) ]' C1 @# ~
  297. * Input:       time: Gps week and second.
    5 z* ^: y1 Z4 d; G/ D
  298. *              day:  The number of day to add.
    - Y$ e( v" A) y  @7 N( \- s9 C
  299. * Output:5 y. c% L. ?4 q
  300. * Return:      Gps week and second.
    1 B7 K* S4 Y$ o$ r7 Y
  301. *****************************************************************/+ v% j7 _; o; N, I, G3 {
  302. GpsWeekSecond GpsWeekSecondAddDay(GpsWeekSecond time, int day)  n$ X' l8 N2 j" g) y1 _8 U/ J
  303. {1 q" d- g$ S( G4 V* ~% G, b
  304.   time.week   += day / 7;
    . E( X4 ?' v, z. `4 n# m$ p
  305.   time.second += day % 7 * 86400;
    ( p4 B4 Z, U) w- Q9 w+ i. o1 Q

  306. * }1 r, r; ?! M4 a0 y* w. X
  307.   if(time.second > 604799); S' X/ j# v; t+ N1 T9 m4 }
  308.   {& d) J4 r8 ^3 x2 q8 v
  309.     time.week   += 1;1 a5 G' H& ~$ {0 ~0 _% t  E
  310.     time.second -= 604800;
    0 u: t3 g4 H# \- T9 G) M& J6 T# O
  311.   }& D, c, A# W& d  E; @: H

  312. # w& _- x2 i, ?# w8 `0 x
  313.   return time;$ k- {4 ~, w7 j0 ~
  314. }1 h0 u$ ^8 n# g5 Y/ h7 ^

  315. " O) c. u4 N% O" t$ n
  316. /****************************************************************
    6 l$ N  J. ?* d' l
  317. * Function:    GpsWeekSecondAddHour+ P, K/ C" v% n( c/ ?' b7 @0 I
  318. * Description: Gps week and second add hour.7 h! t5 Y# [, Z( k
  319. * Input:       time: Gps week and second.
    $ S$ U; n9 Z- M
  320. *              hour: The number of hour to add.1 a- _1 ?1 ]6 m% c2 |# h
  321. * Output:
    ) v2 s0 m7 V: Y# k( |
  322. * Return:      Gps week and second.- S8 J# O5 x2 E9 m4 z' V, Q; q! C
  323. *****************************************************************/
    * a6 Z6 t" m" f4 C! v
  324. GpsWeekSecond GpsWeekSecondAddHour(GpsWeekSecond time, int hour)3 I; b7 {! o' C$ s5 M9 r
  325. {) W; ^6 L* b: n: r/ V* a
  326.   time.week   += hour / 168;
    - d& i- |7 H7 z# V$ Q9 J* S
  327.   time.second += hour % 168 * 3600;
    - n7 F, F' `7 i) C1 G! F: c
  328. 5 J; A+ C* S1 m4 O1 O
  329.   if(time.second > 604799)) I- ]4 Y+ G. T2 N1 f
  330.   {# Y# M8 Z: n+ }- S$ |
  331.     time.week   += 1;
    ( z" ]* s- n. S1 V1 g, y3 z4 f
  332.     time.second -= 604800;% ^9 H% A! V5 v' s$ X+ C- m9 O' d, B7 s
  333.   }
    & N( W5 c8 a9 t0 c$ M7 ?  [6 j: G
  334.   
    4 n; S; C- B2 e
  335.   return time;
    3 s2 V+ U1 w: J4 d
  336. }
    - `% r: c' h! \# k) Z/ z

  337. 7 T* a2 u+ A8 h  m4 F
  338. /****************************************************************" s8 b2 _% t- Y
  339. * Function:    GpsWeekSecondAddMinute
    3 X) F& L- R" u6 u  p0 R
  340. * Description: Gps week and second add minute., {! S  A- i; ]" o) x# ~3 ]
  341. * Input:       time:   Gps week and second.
    / }# B1 j0 y' W* D6 |7 [* {
  342. *              minute: The number of minute to add.
    7 }+ w6 @9 b' R7 ?' F2 \
  343. * Output:
    6 v+ N% x; u9 Z" w5 K& G# E
  344. * Return:      Gps week and second.
    7 ^1 b2 j" t% x5 w. E1 A6 c
  345. *****************************************************************/& z; t( `* N$ Z' Y2 Q
  346. GpsWeekSecond GpsWeekSecondAddMinute(GpsWeekSecond time, int minute)7 I% r2 t2 K. s  {
  347. {3 V; s3 v! w- z* Z
  348.   time.week   += minute / 10080;
    / d; Z9 n" j( V4 B% k7 T
  349.   time.second += minute % 10080 * 60;: r9 r# r$ i- i6 u$ `4 S( M) Y
  350.   " [7 X8 J" Y" w. q8 q) F
  351.   if(time.second > 604799)
    % Z, u1 D8 L7 F/ K
  352.   {0 _6 O+ ]0 _- E: W
  353.     time.week   += 1;. M+ s4 k/ e0 e9 S5 F2 J
  354.     time.second -= 604800;0 ?: S2 c  \5 L0 H7 K6 I1 S
  355.   }
    7 W2 G6 `: T% ]# l1 b
  356.   
    7 l- K9 U+ f  S; J/ q, A
  357.   return time;
    - S' L" D. W' B# g0 g7 c2 `
  358. }
    # E/ A5 Z7 q  W8 Y8 |5 w$ _/ C! D2 O* j
  359. & x* x1 M- {% {# [
  360. /****************************************************************
    + q. x, j" I6 u- D# C2 @3 ~( U
  361. * Function:    GpsWeekSecondAddSecond
    ( L# c$ d" s( ~; U
  362. * Description: Gps week and second add second.
    6 I, x" `3 f/ p0 O$ H
  363. * Input:       time:   Gps week and second.; I1 x9 u  b1 |5 ?( P( g$ M
  364. *              second: The number of second to add.0 E0 y5 v# }. |: o$ \
  365. * Output:0 ]/ m( W: x! S" S. ?1 N( i
  366. * Return:      Gps week and second.
    8 o( G( s9 u( E& Q
  367. *****************************************************************/8 _' d9 t) q3 W& g$ u: T& b2 |5 j- F
  368. GpsWeekSecond GpsWeekSecondAddSecond(GpsWeekSecond time, int second)
    . G) Y+ j4 u/ I5 \0 H# ~# Y
  369. {1 n* T% _7 _" Y& Y
  370.   time.week   += second / 604800;
    9 S* |. R- r/ t  ^
  371.   time.second += second % 604800;* i) Z1 l( [9 {: q3 \. q
  372. 8 n6 f2 s+ x* R' _
  373.   if(time.second > 604799)
    - l) h( s0 m6 K& \$ W
  374.   {4 @( ~4 {% A# s5 h, @" ?+ g( [
  375.     time.week   += 1;+ f  Q  ]6 t% {+ F) I  O+ |; s. c- Q
  376.     time.second -= 604800;
    $ `3 x, P* Q5 x  n8 b0 g( e$ f
  377.   }! {- `/ w: ^3 `  L2 x
  378.   
    9 U6 o! [" D0 }+ w8 b& {
  379.   return time;
      h4 |3 }, C4 r% v8 _7 _
  380. }. R. k$ c. E  l
  381. $ j/ Z# X& R+ j& {
  382. /****************************************************************5 J9 r- I1 u6 r& H
  383. * Function:    GpsWeekSecondToGregorianCalendarDate
      J. A# h& n: ?/ c) \: p
  384. * Description: Gps week and second to gregorian calendar date.
    % t0 H* O' z0 t/ f$ m. j
  385. * Input:       time: Gps week and second.+ c/ b: Z( d5 N0 V# Z: B
  386. * Output:: k9 O' q/ h9 l
  387. * Return:      Gregorian calendar date.+ l4 }- R& y" q' d4 G3 [, y
  388. *****************************************************************/
    3 ~' t2 @; J; p
  389. DateTime GpsWeekSecondToGregorianCalendarDate(GpsWeekSecond time)/ \) F8 x: X. X9 |% w! K, [  G$ H: u
  390. {
    6 N( q0 ?. w% l) k9 L+ Y
  391.   double jd = GpsWeekSecondToJulianDate(time);1 P, A5 O, k. Q4 P$ K

  392. * r5 K6 K$ r; ?3 s/ Z8 _
  393.   return JulianDateToGregorianCalendarDate(jd);
    ! \- d7 `  W' `! H  [* |; c8 d
  394. }6 @! P5 G4 V' W- t& k

  395. ( d4 R# a% l2 q% T1 _( S" F' X
  396. /****************************************************************
    0 l2 n8 o. i  F( G, i9 T
  397. * Function:    GpsWeekSecondToJulianDate
    , l+ C# V7 R6 l, j, T  j8 t
  398. * Description: Gps week and second to julian date., c9 |, |7 O# p7 X& u
  399. * Input:       time: Gps week and second.$ |+ O6 I$ H; ~, L' _9 R
  400. * Output:
    9 s: `3 Q% a* r" k  S- \) J3 I
  401. * Return:      Julian date." j# j. I7 w& T
  402. *****************************************************************/
    2 t, q& Q7 B5 i" O( x% G* f
  403. double GpsWeekSecondToJulianDate(GpsWeekSecond time)
    ! P4 r# G5 s6 @9 v1 y1 c" v
  404. {
    8 d7 O1 _# H4 j+ J  A# i* U+ h
  405.   double jd = 2444244.5 + time.week * 7.0 + time.second / 86400.0;1 o9 U7 h; v/ D3 I1 f1 P8 A4 `

  406. % u4 E. I# t, e& l4 }1 A2 Q
  407.   return jd;
    % v. G- P) n5 F4 c4 v2 k
  408. }$ ~% i+ Y$ i" I) u* n
  409. 7 d' j, H0 h: V, I/ T; \$ q% W
  410. /****************************************************************
    ( P+ m/ j+ g3 |7 `( ?
  411. * Function:    GpsWeekSecondToModifiedJulianDate
    3 w  {2 z# @0 P5 k8 Z, }( F
  412. * Description: Gps week and second to modified julian date.+ n3 N: e/ `; V' E" ^- _
  413. * Input:       time: Gps week and second.
    1 r; }8 `8 r. L
  414. * Output:2 c1 t+ E3 }- f2 e! M8 m* U
  415. * Return:      Modified julian date.! p/ l# z' c$ B
  416. *****************************************************************/: j' r" E  m8 h; N
  417. double GpsWeekSecondToModifiedJulianDate(GpsWeekSecond time)
    6 }7 k- Q7 ^( L, a' [
  418. {# y5 j; b+ Z# S
  419.   return GpsWeekSecondToJulianDate(time) - 2400000.5;
    0 _% D) Q6 E$ O' i' c) D
  420. }# P! ]4 N; @: X4 V& g
  421. # {9 e9 U+ x. P7 O; O* i
  422. /****************************************************************' B; I6 a- @! y8 p% E9 y& j
  423. * Function:    JulianDateAddYear  ^3 k' |9 a( i9 O; o/ K
  424. * Description: Julian date add year.) H6 ?- f7 F  [+ F9 \; E! m: O9 R
  425. * Input:       jd:   Julian date.9 V: b( E4 z0 d" F
  426. *              year: The number of year to add.
    $ J- G! K7 E  s# W4 W2 }2 V
  427. * Output:$ n; t+ Q$ f/ d9 ~; z
  428. * Return:      Julian date.
    : j, l) p/ J7 n+ o
  429. *****************************************************************/% P  J7 l' _9 d9 i6 N. Q
  430. double JulianDateAddYear(double jd, int year)
    & E! ~+ H( ^) m$ d9 \* x2 ~. Z
  431. {0 v& _- |0 j5 `
  432.   DateTime date = JulianDateToGregorianCalendarDate(jd);
    ; \9 l. i) I  U3 c+ T

  433. * q' m  F& |2 \4 b  M
  434.   date = GregorianCalendarDateAddYear(date, year);
    5 d5 u+ U: S( j, r. U4 k
  435. ( Q! M/ i9 X4 Q+ l
  436.   return GregorianCalendarDateToJulianDate(date);& _' R( J+ t6 @
  437. }- N" {$ i& ^4 `& z8 }
  438. " s2 w3 j; m: s- n9 W
  439. /****************************************************************
    3 M  ^* y2 J8 G2 a/ P8 c: V7 A
  440. * Function:    JulianDateAddMonth
    4 F8 H2 J8 k: Q7 B5 y6 ~- k& `! g
  441. * Description: Julian date add month.  [  p' _. R+ q) F$ T* j+ F
  442. * Input:       jd:    Julian date.
    ! i& U3 ?: y. x
  443. *              month: The number of month to add.
    + ^/ _7 D* l/ v( Z2 @7 y# t6 W
  444. * Output:& |/ _9 c) t8 `( E
  445. * Return:      Julian date.
    1 s6 w8 o* d+ h
  446. *****************************************************************/2 @( U. W/ R; C. a& ]" g
  447. double JulianDateAddMonth(double jd, int month)9 A& i1 F4 M/ [/ H3 x
  448. {
    ( l: O: R* Z. d9 d
  449.   DateTime date = JulianDateToGregorianCalendarDate(jd);2 B9 b/ H; v% N; c' `

  450. 4 v- C3 I/ z  ]/ c" n# i& ]
  451.   date = GregorianCalendarDateAddMonth(date, month);5 O/ P2 w: Y- T4 i* c4 n- E9 B
  452. ) w2 m) g1 I* |! o
  453.   return GregorianCalendarDateToJulianDate(date);
    ' w1 \1 p( V: n# V7 {! i4 c
  454. }
    . m# R$ _$ ^" Y1 Q, Q" G( G* V! E
  455. 8 v( s& i3 |/ f+ Z* d
  456. /****************************************************************
    ) X# y6 F% v6 N3 x# D0 c5 k* V
  457. * Function:    JulianDateAddWeek
    $ y3 O) p. Y( F; C# t! G
  458. * Description: Julian date add week.+ P7 C( {& _% U
  459. * Input:       jd:   Julian date.
    ! P# v1 d' s! J( r, \2 w. T8 \6 W
  460. *              week: The number of week to add.
    ) G. G7 [" U0 w: n; S
  461. * Output:* m/ K! @7 O+ Y* q1 \
  462. * Return:      Julian date.' U$ ?! Y. M' K$ i1 H
  463. *****************************************************************/
    ; ]( W' G) j' S, o& H7 m3 n
  464. double JulianDateAddWeek(double jd, int week)
    % t/ t2 B# |/ e5 W
  465. {
    - U1 W; n3 _# @
  466.   jd += week * 7.0;0 T6 H7 \/ a% Y+ @+ h1 C# X* H8 [" Y
  467. 5 `9 x2 h3 ~9 ^6 J; p
  468.   return jd;7 T- Z4 K  L0 [  D" ]
  469. }
    3 ~6 g. ~! P5 @. X  d

  470. ) r* L8 r- |# {) S/ @3 l. R
  471. /****************************************************************
    # G0 j% ~; \6 @; q
  472. * Function:    JulianDateAddDay, T8 q. f% |- F5 q% r  ~7 l) ~: ?+ b
  473. * Description: Julian date add day.0 i, R8 K$ i. `9 _5 ?" w' t
  474. * Input:       jd:  Julian date.
    $ M/ x: ]; Q3 G9 k5 Z8 u
  475. *              day: The number of day to add.
    ! }1 I& O8 v+ T
  476. * Output:) B8 C& |6 u6 d3 R( K
  477. * Return:      Julian date.7 n3 k+ J+ R2 G% H# c5 d8 t/ ~
  478. *****************************************************************/6 ]. e; ?; x0 n8 b; K
  479. double JulianDateAddDay(double jd, int day)
    2 h7 C2 |8 D2 L& A
  480. {
    % v: y0 C; u3 ]' c& V
  481.   jd += day;7 P) V! D4 k, j$ L: Z7 B
  482. , Z3 z) @) }) b: ~; y- S& r
  483.   return jd;  i' m" c$ @; K3 X" U# J! X5 n4 V: e
  484. }
    $ o, y  y# y1 w6 [6 [
  485. ' _0 C& b3 n2 S1 ~
  486. /****************************************************************/ Y- d" h' z. O4 j, z0 j% H
  487. * Function:    JulianDateAddHour
    - _! Q4 F7 l( y7 A% y3 Q; [  ^1 I
  488. * Description: Julian date add hour.
      r/ F- N) N; x# o% z; V
  489. * Input:       jd:   Julian date.3 U! R# a. v9 M$ `0 ]4 B. S3 F
  490. *              hour: The number of hour to add.6 S5 V5 }0 I9 t# h- g! @  Y9 z: J
  491. * Output:! ^4 J( }8 f  A' M' G( o8 @- ]3 h, d1 d# S
  492. * Return:      Julian date./ D- F! L4 j4 w$ r) v2 o2 ?" y
  493. *****************************************************************/  ~6 y' o7 V+ f
  494. double JulianDateAddHour(double jd, int hour)$ E3 X9 r/ F1 v
  495. {( z% ~' n- C  M7 S' R) E' Y4 O) ]
  496.   jd += hour / 24.0;. ], h$ J- G9 _  }

  497. 5 Z  _- o- f8 I4 ~
  498.   return jd;* {; k& B2 t! o+ X- P: |# T, f
  499. }
    4 [! z2 U( k  _0 `  I' H
  500. 4 v) S, B% @/ @/ h# H# k3 d
  501. /****************************************************************9 O- e1 q2 f9 A
  502. * Function:    JulianDateAddMinute# a7 {8 Z9 [: F' l  N
  503. * Description: Julian date add minute.
    7 x; J; T0 x/ P6 e. x
  504. * Input:       jd:     Julian date.
    + t9 K4 I; \* O. D% Y3 m( s) h
  505. *              minute: The number of minute to add.; M: O6 c+ m: |! t
  506. * Output:1 o% J2 j/ B1 E- z" E1 P% R' A
  507. * Return:      Julian date.6 g) c0 q! q4 h; A/ D
  508. *****************************************************************/
    + j1 j( A2 {* ?0 R" P: [) U
  509. double JulianDateAddMinute(double jd, int minute)
    7 p/ I& m3 m/ ]& ^/ y: V. P
  510. {
    2 r* A; r. [! k
  511.   jd += minute / 1440.0;
    3 C' `; i. U! z+ F

  512. ( d8 P9 S- i9 S. D
  513.   return jd;( J  \3 p+ A/ y  c1 z: C) C, d3 b
  514. }
    1 w3 B) p# K8 y  P, n  \

  515. & z* D+ P8 h/ k4 Z7 v/ X9 t
  516. /****************************************************************! g1 m" e. j( S' N+ ]9 R5 {
  517. * Function:    JulianDateAddSecond' b( i8 P* C4 `
  518. * Description: Julian date add second.4 a9 a+ ~( D# p
  519. * Input:       jd:     Julian date.6 Y$ |/ v2 E. a, Y0 K) m* l  E3 g
  520. *              second: The number of second to add.
    6 P& w8 o4 ?" ]! j4 k" E4 T, i
  521. * Output:# H9 z. u- v0 M" _  L$ p1 [$ ~
  522. * Return:      Julian date.
    - d( a0 U$ [4 o3 r2 }
  523. *****************************************************************/- m4 {/ E0 T& s
  524. double JulianDateAddSecond(double jd, int second)
    8 ~, C/ c% D: ?" p, U" u& H
  525. {
    " M8 L! y1 B& {9 w/ ?8 y8 E" V0 H0 G* @
  526.   jd += second / 86400.0;  v! z+ B8 P( Y' {8 A

  527. * q& B% C! p  _( ]9 R5 P% {3 n6 n) s
  528.   return jd;
    . c" }* h. ^) `4 _7 Q5 X% J
  529. }: Q; w# g, c4 N; @: p7 `# h9 [8 l6 s9 }+ G/ m

  530. $ f& z6 N9 u/ E: H$ I
  531. /****************************************************************. A4 r0 u, a- `
  532. * Function:    JulianDateToGregorianCalendarDate
    8 m8 u- M# E; E$ t5 X' C3 i2 L
  533. * Description: Julian date to gregorian calendar date.5 m7 |3 `& }" m0 O' |9 h/ ]
  534. * Input:       jd: Julian date.
    2 K4 L" u- e5 @" o3 V' h
  535. * Output:2 F  h  G! B0 z* R& ^- W
  536. * Return:      Gregorian calendar date.
    ( ?* N- e) s, b* I7 B/ s  F0 N6 R7 u
  537. *****************************************************************/
    + y. Z2 U, R/ I/ e' @: G
  538. DateTime JulianDateToGregorianCalendarDate(double jd)! ?$ y4 @! Z/ _9 u1 z, g
  539. {
    & R9 Y' i6 u( W" \- k
  540.   int y = 4716;! ~+ }* U& U) u3 G6 s& S4 o, B
  541.   int j = 1401;- R; T' ~* `  J/ z$ L% Y* E3 {2 h  W
  542.   int m = 2;# i9 s# T% P! S. j5 T
  543.   int n = 12;
    ( N* [* ]( [, F2 Z$ s$ C) U
  544.   int r = 4;' ^6 \1 w/ [, }$ q- q  S) w
  545.   int p = 1461;. i) |6 W+ y2 o/ B
  546.   int v = 3;
      U' x8 z  j* B% r8 r
  547.   int u = 5;
    9 q. j$ v% n0 x" `/ _* e- ~
  548.   int s = 153;; R, X; \' g1 p  Y9 \7 g
  549.   int w = 2;* C! ~/ l8 A; T4 u' H
  550.   int b = 274277;7 C) l9 }4 I& ]6 d- D
  551.   int c = -38;( y& T' s6 C5 \1 r' b
  552. 4 q& \, r* A6 b$ C
  553.   int jdn = (int)(jd + 0.5);
    " l. Z; [" O2 ~) M+ `$ g
  554.   int f   = jdn + j + (((4 * jdn + b) / 146097) * 3) / 4 + c;
    ; U& M7 B7 p1 A8 ]0 i2 g  F+ V
  555.   int e   = r * f + v;+ E! o" P' B5 p$ i  t0 Z/ c
  556.   int g   = (e % p) / r;
    # R& N: y! _3 R+ _
  557.   int h   = u * g + w;
    7 j) V) ~2 g' k, y. ?' o2 d1 V2 y
  558. + L7 ^+ c" Q9 H$ W
  559.   DateTime time = {0};$ W; f. K7 H0 L6 a' z! G% q7 y

  560. 1 H, H# \" o" V
  561.   time.day    = (h % s) / u + 1;
    ' N4 L' M/ c1 D7 R1 k0 }# N
  562.   time.month  = (h / s + m) % n + 1;# H5 H" L# q0 }. k0 N; m
  563.   time.year   = e / p - y + (n + m - time.month) / n;# _9 Y: `4 b, r3 W. Q- b, N' \
  564.   time.hour   = (int)((jd + 0.5 - jdn) * 86400.5) / 3600;4 D  }+ |$ B' U8 w; u
  565.   time.minute = (int)((jd + 0.5 - jdn) * 86400.5 - time.hour * 3600) / 60;. U, D1 {( C1 v3 c: k( L/ O
  566.   time.second = (int)((jd + 0.5 - jdn) * 86400.5 - time.hour * 3600 - time.minute * 60);; L8 ^  h3 n' D  a
  567. 0 F2 x! w+ M- a6 T! D
  568.   return time;
      ?7 M6 t8 G" x% y) k
  569. }! |7 T3 a5 P5 [. O/ n9 s" `
  570. ( q, M9 J; K  j" Q6 D
  571. /****************************************************************: l: z: A2 V: s/ l* a/ J
  572. * Function:    JulianDateToGpsWeekSecond9 U3 B3 e, I- L1 }2 `& ]& D
  573. * Description: Julian date to gps week and second.' S2 f& x  x5 \! |1 C0 p8 I3 T* V5 v1 H
  574. * Input:       jd: Julian date.* o% F# l1 z3 L5 S2 J
  575. * Output:  V' \, |, u( X2 Z4 l
  576. * Return:      Gps week and second.& o/ [) Y: m; O7 U9 [! _
  577. *****************************************************************/4 i0 ^! a: w. q
  578. GpsWeekSecond JulianDateToGpsWeekSecond(double jd): Y/ x0 a/ L7 n
  579. {7 [8 n( \$ k0 e7 d' ]' B, d
  580.   GpsWeekSecond time = {0};- h. e4 X7 S0 V
  581.   DateTime      date = JulianDateToGregorianCalendarDate(jd);8 ^! S# K' p- r4 z/ y

  582. 4 ~4 D9 p: R+ c0 P3 h3 C  ]1 ^
  583.   time.week   = (int)(jd - 2444244.5) / 7;! E+ s1 A1 s0 S: V8 N2 h
  584.   time.second = ((int)(jd - 2444244.5) - time.week * 7) * 86400 + date.hour * 3600 + date.minute * 60 + date.second;, @4 Q) `4 \) C7 x% b
  585. / `7 a+ F6 J$ t; q6 P0 y; W: f
  586.   return time;6 v1 P; |7 M8 y0 B" p% D
  587. }- V/ Z' d- Z- y3 ?+ B
  588. % s: c# Q" z( t9 A0 f
  589. /****************************************************************' v7 d8 u5 W- E( D
  590. * Function:    JulianDateToModifiedJulianDate
    # A+ [6 W& |# _& O- q
  591. * Description: Julian date to modified julian date.$ J5 Q4 a/ v, q7 V: e
  592. * Input:       jd: Julian date.: N9 s; T  n' D9 B
  593. * Output:
    2 _8 {- a. a5 {, O- ?
  594. * Return:      Modified julian date.
    8 Z7 p% d. p8 I7 j, D) P: i
  595. *****************************************************************/  q5 w; y- n) t- P
  596. double JulianDateToModifiedJulianDate(double jd)
    ; O9 x& I; B7 ^# i, W9 w+ X, b0 N% I
  597. {; S1 Y4 h: r! V' S
  598.   double mjd = jd - 2400000.5;3 `( U* t  k4 Z( E

  599. ) p0 S. O* J  q% V0 }" n+ \
  600.   return mjd;; Q: C( r8 [5 ^: ~" T( [
  601. }) U( z# P& A1 i6 M' I2 u& O

  602. . m. n$ E+ C# i. z% |: I1 N
  603. /****************************************************************
    4 j) m: ^7 y/ K$ F
  604. * Function:    ModifiedJulianDateAddYear
    % j5 Q" B% f3 I( l1 h
  605. * Description: Modified julian date add year.
    / m+ l* ]! K2 n# Y( }8 q) ?' ]  k7 P
  606. * Input:       mjd:  Modified julian date.
    5 v. o6 h( ?. R- ?
  607. *              year: The number of year to add./ v, S" u6 w# @! s7 Q/ A
  608. * Output:
    8 n7 H3 T- x% }1 w: \0 N& ]
  609. * Return:      Modified julian date.% w! S1 {" F+ j: w5 h
  610. *****************************************************************/
    & N$ S" [2 G  }+ Q* r% I) l
  611. double ModifiedJulianDateAddYear(double mjd, int year)
    : A) X. {2 J4 n8 W
  612. {  e8 S! D5 a  s) x) z- w1 g9 s
  613.   DateTime date = ModifiedJulianDateToGregorianCalendarDate(mjd);
    4 h- U: Q$ B) X; e+ Z
  614. # K) A* B8 D% f
  615.   date = GregorianCalendarDateAddYear(date, year);2 ?. v: ~% r' k5 ~
  616. 5 t9 v3 [+ z  K0 y8 F6 O# {: ]- G
  617.   return GregorianCalendarDateToModifiedJulianDate(date);
    ( o+ }" s, D& c; ]# H9 \
  618. }
      d  L2 H$ I- v- O. \3 i5 O5 P& W, C4 U
  619. ) U4 q3 }; T" g" _3 r% O
  620. /****************************************************************, R3 w( Q( s6 r
  621. * Function:    ModifiedJulianDateAddMonth
    " T. E! v+ b6 e2 N0 P
  622. * Description: Modified julian date add month.
    & u1 I0 w; F; z7 [
  623. * Input:       mjd:   Modified julian date.
    : y8 U: Q3 m, k' k4 d4 j( w
  624. *              month: The number of month to add.
    , m) L  v+ x+ D* b( N1 o
  625. * Output:
    + S; ]2 D3 O" [, [. l5 Q
  626. * Return:      Modified julian date.
    , [: p7 Q7 C) N2 p9 m- i# m
  627. *****************************************************************/
    $ Q% q# O' U+ s! ?& c: N  H" ^
  628. double ModifiedJulianDateAddMonth(double mjd, int month)
    + |1 l' g( l% h& W: U# x8 c
  629. {
    # v8 x+ }; e2 {- n, V# _/ p
  630.   DateTime date = ModifiedJulianDateToGregorianCalendarDate(mjd);
    9 @, W4 d* w. E3 m5 o" i
  631. & M/ g' g. M' A+ E  T
  632.   date = GregorianCalendarDateAddMonth(date, month);9 q9 g4 L5 u/ b) G) x* g7 o

  633. ) R& C1 A0 l2 X- s5 B& N5 S+ z
  634.   return GregorianCalendarDateToModifiedJulianDate(date);
    % v3 I. O& l9 M3 G% Q2 E% y
  635. }
    $ Z" B# J% p" J
  636. 1 y. @8 M+ _1 F- z
  637. /****************************************************************
    % _! h* c  m: C/ v0 r+ h' Q
  638. * Function:    ModifiedJulianDateAddWeek
    $ |+ F/ b) V3 A4 w- u1 o
  639. * Description: Modified julian date add week.4 P' o6 H3 Z4 k% \* W3 R9 ~
  640. * Input:       mjd:  Modified julian date.
    ) j  F, J; a7 x2 |$ O" _
  641. *              week: The number of week to add.
    $ R. t; h" w' d( V5 [
  642. * Output:$ j9 R! Q8 p: l3 k
  643. * Return:      Modified julian date.
    % C) M& E2 |+ k2 F2 F  r: }, L; u
  644. *****************************************************************/; U( r% H* z& _7 }7 e
  645. double ModifiedJulianDateAddWeek(double mjd, int week)
    ( S* R! F& \$ l6 `
  646. {' s2 q! |4 m. M
  647.   mjd += week * 7.0;
    + R; d* j! v6 a" L0 Z, n

  648. 5 v; V9 I# _# T
  649.   return mjd;
    " z# p' Z/ E" ]
  650. }
    8 d: x# c' i) V) [% [+ B

  651. # [9 ?  |( r- j0 l
  652. /****************************************************************' H" Z4 g5 C( |( X8 ~  x4 E
  653. * Function:    ModifiedJulianDateAddDay
    . K$ {9 d& C: `0 h) b2 |
  654. * Description: Modified julian date add day.
    ) V% o7 t! d( D
  655. * Input:       mjd: Modified julian date.8 a- N% V* D, C1 _
  656. *              day: The number of day to add.3 t7 `: q  j+ x# s& L( m/ A1 k
  657. * Output:
    ! V  O3 C! y5 k; y* L1 r
  658. * Return:      Modified julian date.& E/ n0 k5 x, @9 X( ?* v4 {
  659. *****************************************************************/: r- ?7 t" X8 J+ k3 g( K# j% G- M
  660. double ModifiedJulianDateAddDay(double mjd, int day)( q: V5 z) S# @, w+ s, G/ a, @0 C
  661. {: A5 c3 K' E1 l. Q$ O
  662.   mjd += day;
    : W0 v2 D% q" n3 Y3 r0 d; R3 Z( \

  663. 5 W( y' ~" v1 C8 w5 _( s
  664.   return mjd;& |% [. C- |: u
  665. }  y; T" o2 o& T6 f5 f9 A

  666. ' ^8 D7 W0 g$ ?2 p% W5 s: U3 d
  667. /****************************************************************( |1 @) N% {0 M* ~+ B, @+ w
  668. * Function:    ModifiedJulianDateAddHour  E, @0 a# y; ~4 O
  669. * Description: Modified julian date add hour.
    # b: P! n! T# j+ i# l
  670. * Input:       mjd:  Modified julian date.6 E" e; {7 C, K$ R6 D
  671. *              hour: The number of hour to add.
    # v: e, b- F/ R7 Q. K
  672. * Output:6 j1 {7 f" P- ]" G. q! i! y6 Q
  673. * Return:      Modified julian date.
    . j$ G9 i% o6 B% N; U2 R$ ]& j9 V
  674. *****************************************************************/* o5 E+ D% c3 o; c5 n
  675. double ModifiedJulianDateAddHour(double mjd, int hour)
    : [2 U% {1 D8 _0 `* b
  676. {
    - _, q& f+ B5 \* A3 _. i! @& H9 Y
  677.   mjd += hour / 24.0;2 m; c1 ]  Q+ `2 P
  678. ) B0 E  O, |' [$ Z9 T3 T) r7 D" q
  679.   return mjd;- }6 Z  F, ]3 s2 V/ X9 x  c
  680. }
    6 j! r+ @1 G. r# |) V' P

  681. ) R5 J7 ]  x7 H; b' P/ M1 I/ w
  682. /****************************************************************' `2 r, ^" J1 ]  K% F8 U: V" O
  683. * Function:    ModifiedJulianDateAddMinute3 R( q- z7 W  d3 k4 R
  684. * Description: Modified julian date add minute.
    * u9 O! l9 G7 C6 R" c
  685. * Input:       mjd:    Modified julian date.+ O* a* Z! Y  H
  686. *              minute: The number of minute to add.
    ' B2 D3 y0 K( [" ]
  687. * Output:  M& B/ Z  b0 j3 J  C
  688. * Return:      Modified julian date.
    & g/ E& u. N. j* u; C. F
  689. *****************************************************************/
    1 j8 F- k7 N# ]  C! b3 _
  690. double ModifiedJulianDateAddMinute(double mjd, int minute)' A( O8 E& ~* T3 z
  691. {8 z( Z! u$ Q/ h. \) v/ v- |9 y
  692.   mjd += minute / 1440.0;
    6 x* \+ b9 x' y/ G

  693. " G0 D8 f8 V+ ?3 @
  694.   return mjd;6 J3 y5 Q2 V0 K
  695. }8 l2 l3 c3 M0 {1 P0 h
  696. 3 @+ s- y- O/ |: z, M
  697. /****************************************************************2 R3 A5 u) f# u+ Y6 j+ P
  698. * Function:    ModifiedJulianDateAddSecond
    $ ^  B7 z, ?. l. B
  699. * Description: Modified julian date add second.
    8 U/ c. \7 C9 q  q) q
  700. * Input:       mjd:    Modified julian date.3 m& W6 i, Z: _0 F6 k& c$ X
  701. *              second: The number of second to add.3 w" @( W+ P# H4 S( z4 g0 N% s
  702. * Output:* p7 i; {  j8 H3 L8 w
  703. * Return:      Modified julian date.
    6 P3 ^4 F% W  Q/ h9 [
  704. *****************************************************************/
    * S) j9 L  h/ s' J
  705. double ModifiedJulianDateAddSecond(double mjd, int second)8 k* k# F  f) |
  706. {% f) O4 ~% O' V- K( U: A
  707.   mjd += second / 86400.0;8 y& i: \! @- P& H

  708. ' Q6 C% p( ?2 X) x- Z* E
  709.   return mjd;
    % `/ O$ w8 k' r  s) [& y+ j
  710. }
    7 W% Q5 z, h  {
  711. 6 X% G' g/ `5 J4 n% Y1 g5 i
  712. /****************************************************************
    ; [0 ^3 f# d0 m! K& d  j9 l" [  O; y
  713. * Function:    ModifiedJulianDateToGregorianCalendarDate
    - H1 X& j% W) J8 Z& A
  714. * Description: Modified julian date to gregorian calendar date.& `" K) p5 H! b. P; b4 I6 y/ D3 N( n
  715. * Input:       mjd: Modified julian date.6 G0 L0 e' H$ v! ^/ D
  716. * Output:
    + N1 e" X: [1 X4 i) M! R
  717. * Return:      Gregorian calendar date.
    8 I) M: {" i1 s$ S0 U) a$ ?
  718. *****************************************************************/
    3 Z6 Q3 N* x, A8 s
  719. DateTime ModifiedJulianDateToGregorianCalendarDate(double mjd)
    " M" {) t* e2 \, q6 Y7 N
  720. {$ T- O& n5 h9 k+ b+ |, T
  721.   return JulianDateToGregorianCalendarDate(mjd + 2400000.5);
    - j8 M! R1 c8 m1 ~, p
  722. }8 q! G, B2 N) x! Z8 m( b- U
  723. 6 W9 _1 E3 j# d% G" e* |
  724. /****************************************************************: E! ]% K( E6 t0 p) \) P# f
  725. * Function:    ModifiedJulianDateToGpsWeekSecond
    4 o$ \0 Q: P7 E) _+ G" F$ G
  726. * Description: Modified julian date to gps week and second.! [4 [) F  w: @0 w. P3 @  n: G: S1 L
  727. * Input:       mjd: Modified julian date.
    7 M# c: k" N' n% `& |% f( F: F8 a
  728. * Output:9 Q- H7 A3 v$ Y0 A1 w
  729. * Return:      Gps week and second.% |5 U5 ]4 `3 _* s
  730. *****************************************************************/' \& W6 G9 d1 w: f: r. D
  731. GpsWeekSecond ModifiedJulianDateToGpsWeekSecond(double mjd)
    - H7 e7 ?1 Z  o
  732. {
    3 K4 p7 k/ g- D( L4 P; U( q
  733.   return JulianDateToGpsWeekSecond(mjd + 2400000.5);- B( Q! D5 D+ O3 D
  734. }/ y6 j7 s! x) @6 \1 ]& e

  735. ) [' M- {% l! A$ R9 T+ |7 W( \
  736. /****************************************************************. ~. W) I3 ~1 ]+ E# M
  737. * Function:    ModifiedJulianDateToJulianDate8 n( b1 E6 r- l/ L# Z" S7 H3 l( f
  738. * Description: Modified julian date to julian date.
    * K. R4 ]3 C- y. x# w. I
  739. * Input:       mjd: Modified julian date.  e. Y7 C! Y' z2 |: e
  740. * Output:$ d/ m) ^& E* ~+ v* s7 @
  741. * Return:      Julian date.
    * B  K' m( w  A
  742. *****************************************************************/( @: Q' r( S7 D+ s) L% `0 E6 Z
  743. double ModifiedJulianDateToJulianDate(double mjd)
    # i' v- M" {. c! M
  744. {
    ( O0 H: ~* @) A7 C0 v9 u
  745.   double jd = mjd + 2400000.5;5 ]- x) k8 e9 `
  746. / Z# \7 T9 P/ g; ^+ Y7 x. \
  747.   return jd;
      X' h! K" j* s4 Q* Y' R" s( u" ]" F
  748. }
    / |' T; c0 X2 B, A& s; p; _
复制代码

; W& b, I: S  D: F# `3 {# M: Q      main.c文件
- f3 d6 U& f0 S, I: O  j
  1. /****************************************************************
    / X6 o4 s' O; G9 L- `* u
  2. * Copyright (C) 2017, XinLi, all right reserved.: U- b9 r( v, b2 }# n
  3. * File name:    main.c
    9 o) \; Y6 u2 @: e; v/ k# s
  4. * Date:         2017.10.17
    : A& {" V* o0 s; G
  5. * Description:  GPS, UTC and local time displays.
    ; z3 u( ?- g; b+ [+ @
  6. *****************************************************************/
    " o% u  M3 G: F3 n$ S0 a

  7. ; G1 ~5 m0 H, b  h
  8. /****************************************************************" ^& {( W7 X, m3 w5 z, d) [
  9. *                        Header include
    $ l; p- o8 s% r
  10. *****************************************************************/
      y$ T  r% }$ x* i
  11. #include "DateTime.h"
    4 u% n, h) s/ T, _4 D# K/ v3 L. ~
  12. #include <stdint.h>
    8 S! e$ `! l1 e4 c9 ]9 H
  13. #include <stdio.h>6 f; c3 E) @, R! q" O: H
  14. #include <time.h>
    ' ~" Q5 w1 x' h1 ^
  15. #include <windows.h>
    - r( l$ f* T' r# U

  16. 4 y9 ]# n( J2 h4 _0 ~* }6 R% {
  17. /****************************************************************# s; J  N, [+ z7 w, E8 _, i& ?
  18. *                       Global variables+ J4 q5 d, c) z' t: b: g
  19. *****************************************************************/6 L. S! S" f* w7 k" q
  20.   Q* C) u( w- _5 o5 \

  21. ( ?2 x  J7 b$ N4 f: D# \
  22. /****************************************************************. ~$ \/ h, k, Y/ \% J- |3 J6 P
  23. *                     Function declaration
    0 G/ C' l. X9 F3 t6 q9 p0 @' ?4 }
  24. *****************************************************************/' I9 }  t( g, a* o# l
  25. static void gotoxy(int x, int y);, x: i' [9 G6 A

  26. % p$ N4 X7 Q- X4 n$ [8 Q
  27. /****************************************************************9 N  H1 n+ I2 I0 Z* B% g1 N* v
  28. *                     Function definition
    ! a4 Y3 B  B# W' I& A- |8 j0 J
  29. *****************************************************************/# X3 M& E; U6 f! \" Q5 r  N' T

  30. # E* D" M: m9 f
  31. /****************************************************************
    5 E) e5 E4 t- {+ v5 q
  32. * Function:    main
    0 p0 c. H! R! L/ c9 ^
  33. * Description: Program entry.
    # m5 F  \5 N) D
  34. * Input:
      h: o, C: _1 I) W& D8 [- w
  35. * Output:
    6 ]$ x- ]( G3 _! |& K
  36. * Return:
    " i0 {! \) i9 m7 @
  37. *****************************************************************/
      S# B! Y, ~5 G$ K/ c' W
  38. int main(void)
    * \1 o/ |+ P: _1 o5 p+ i$ L7 v2 I& p
  39. {
    / ]+ z# v! ?2 q9 s6 h0 O7 P  w
  40.   for(;;); C; o: I6 A( c  m6 j% i2 O
  41.   {, h) z5 n# Z" X$ P9 Z
  42.     time_t        times     = 0;
    5 @! P' y* X, ^; n" j4 k: e
  43.     double        mjd       = 0.0;4 g% ]1 N$ ]$ ~
  44.     DateTime      utctime   = {.year = 1970, .month = 1, .day = 1, .hour = 0, .minute = 0, .second = 0};
    ' A% U* Z9 ^" k- Y/ u3 ]  s
  45.     DateTime      localtime = {.year = 1970, .month = 1, .day = 1, .hour = 8, .minute = 0, .second = 0};
      K3 S7 Q) J6 O- `
  46.     DateTime      gpstime   = {.year = 1970, .month = 1, .day = 1, .hour = 0, .minute = 0, .second = 0};
    ( e( `) w5 F4 X$ u5 [; r2 F+ p
  47.     GpsWeekSecond gpstimews = {0};# B3 Y" w/ [& U4 Q( P$ ?; E
  48. / |; V  }$ A. z) D6 F: P$ i7 j
  49.     time(×);! i  `  ^/ W# p# o' j( d7 o3 I
  50. 1 k5 \# D1 m' v
  51.     if(times > INT32_MAX)+ u; o& T. {, u: g( k$ N
  52.     {, L! _/ s: u: `# V3 H
  53.       utctime = GregorianCalendarDateAddSecond(utctime, INT32_MAX);
      Q6 a- _/ {3 M9 y* A+ d6 D
  54.       utctime = GregorianCalendarDateAddSecond(utctime, (int)(times - INT32_MAX));5 x# ?1 J% q1 T
  55.     }
    8 _0 `, W* B5 O4 n
  56.     else
    3 J9 J: U& l8 Q+ g# {0 Q7 V
  57.     {0 k9 R2 f& L9 O; c! g
  58.       utctime = GregorianCalendarDateAddSecond(utctime, (int)times);
    3 u* q- C6 @1 D8 G0 p2 C& C
  59.     }
    5 t  _8 e0 i! K& B
  60. , w' m% _, V& x( w$ G
  61.     mjd       = GregorianCalendarDateToModifiedJulianDate(utctime);
    4 N0 v( b  j% P4 y5 [. B
  62.     localtime = GregorianCalendarDateAddHour(utctime, 8);
    0 t" N" K& Y- i9 V/ F' Q. M$ N
  63.     gpstime   = GregorianCalendarDateAddSecond(utctime, 18);
    # B( d8 R5 B( B2 g0 e* Z
  64.     gpstimews = GregorianCalendarDateToGpsWeekSecond(gpstime);4 O7 @% i9 K% x# @

  65.   g  N3 p2 O. @6 L6 T
  66.     gotoxy(0, 0);* T9 W6 W5 S. B  H2 h$ p  E4 C
  67. % s- Y! j; \4 m. W% m/ W
  68.     printf("Local | %d-%.2d-%.2d %.2d:%.2d:%.2d | timezone UTC+8\n",
      G/ `! A5 e5 W( o0 [, j2 E4 w
  69.            localtime.year, localtime.month, localtime.day,
    0 R& y2 o) m3 x9 o+ _5 g
  70.            localtime.hour, localtime.minute, localtime.second);* x# ]5 X' W/ t4 o

  71. % c2 a: t( I" H0 W8 S( H
  72.     printf("UTC   | %d-%.2d-%.2d %.2d:%.2d:%.2d | MJD %.5f\n",
    % t7 G! x( l/ R8 V' y
  73.            utctime.year, utctime.month, utctime.day,! e4 W3 Q4 f; w: F
  74.            utctime.hour, utctime.minute, utctime.second,. \/ `( v' w2 K- B8 P" ~
  75.            mjd);
    9 k$ q! X5 t2 r6 L& H9 d2 H
  76. + d# r6 D% B8 j$ A
  77.     printf("GPS   | %d-%.2d-%.2d %.2d:%.2d:%.2d | week %d %d s\n",3 h, K' t4 e; k- v2 @: F
  78.            gpstime.year, gpstime.month, gpstime.day,
    1 l# b( z9 I( t7 U
  79.            gpstime.hour, gpstime.minute, gpstime.second,! N- B% ]$ j% F+ P3 j
  80.            gpstimews.week, gpstimews.second);3 ]7 g8 D  ?) L- y* `9 I2 t

  81. + q6 ]" x; I/ l' x
  82.     Sleep(100);
    3 G5 n" }; i2 t# `5 j; [
  83.   }
    7 m  @, e" f3 z" q6 a- `; t
  84. }
    : Y' \( h8 Y9 Z- y

  85. + C8 N( B- |% w+ g. X  O, \6 c
  86. /****************************************************************
    9 u4 M2 V+ m: d8 |$ v9 Z$ X. d2 k
  87. * Function:    gotoxy1 h0 g& D0 o: _! o/ u  |
  88. * Description: Move the cursor to the specified position on the text screen.; j- H- J. t! W! X
  89. * Input:       x: X axis coordinates.2 D7 X% U# T8 r# c5 U% R( D
  90. *              y: Y axis coordinates.
    2 c8 f0 ]. l' M/ e
  91. * Output:
    5 k" Z1 P0 x2 R* [9 e
  92. * Return:6 T* `6 c" S& T
  93. *****************************************************************/' }% Y$ \" \2 d) y6 S
  94. static void gotoxy(int x, int y)
    9 ]4 G( s* ?/ Y
  95. {( ^3 l9 d7 a; Z; g. g
  96.   COORD  pos  = {x, y};
    $ `3 Y! x! S/ s: t6 J/ T
  97.   HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);0 C! v% m% T* |# t- Q) X, S
  98.   SetConsoleCursorPosition(hOut, pos);, y% s4 D: |8 i
  99. }* O( Z3 _* Q) S2 [8 ?& i1 p
复制代码
3 y1 f8 m! Z1 r: O2 s; M/ V- U7 G
3,运行效果& u7 G: d& S: F7 ?& U
3 U4 h: `& C- N! J% j3 U
) ^! p) B7 ]* }2 A& Z9 w
% H6 k" v( f7 A. T
收藏 1 评论7 发布时间:2018-3-7 20:34

举报

7个回答
XinLiYF 回答时间:2018-3-7 20:35:11
可以直接移植到嵌入式端,非常方便。
xuanyuan1993 回答时间:2018-3-7 21:57:55
牛逼牛逼,回复拿分
maxtch 回答时间:2018-3-7 22:19:13
有必要如此折腾吗?不论是 C# 还是传统 C,标准库都有完整的时间与时区支持,不必自己劳心费神再写一遍了。
XinLiYF 回答时间:2018-3-7 22:50:51
maxtch 发表于 2018-3-7 22:191 W1 E6 I1 H; {. k$ e
有必要如此折腾吗?不论是 C# 还是传统 C,标准库都有完整的时间与时区支持,不必自己劳心费神再写一遍了。 ...

6 L9 Q3 F% @$ i3 D' d7 M朱利安日期,GPS周和周内秒,一般的库都没有吧,除非是专门做导航的库才会有这些。写这个是为了方便的在嵌入式端使用。
jjbboox 回答时间:2018-3-8 10:23:39
本帖最后由 jjbboox 于 2018-3-8 10:25 编辑
0 T- {' C: _0 i7 g5 ]: Z+ Z- I3 W* M0 m
直接 #include <time.h>不就OK了?
7 x$ V& S8 ]) S% _) c1 OC51才需要自己实现,stm32的环境,何须如此麻烦。
+ F% t$ }) }: `  S, w以上。
0 G: P; X2 p) x
5 n) H6 f1 v# V- {$ m
maxtch 回答时间:2018-3-8 11:38:10
XinLiYF 发表于 2018-3-7 22:50  |3 s; y1 P, H/ V
朱利安日期,GPS周和周内秒,一般的库都没有吧,除非是专门做导航的库才会有这些。写这个是为了方便的在 ...
) G% q0 f. R# C$ C6 v" x7 ?) |# z
儒略历和格里历的转换一般支持时区转换的库都有。(那个不叫朱利安日期……)至于 GPS 周和周内秒,如果用现有库的话,也只要可以和 UNIX 时间戳互转就可以了,没那么复杂。
XinLiYF 回答时间:2018-3-8 13:31:08
maxtch 发表于 2018-3-8 11:38
. G1 r- M& v& _6 n* s! s儒略历和格里历的转换一般支持时区转换的库都有。(那个不叫朱利安日期……)至于 GPS 周和周内秒,如果 ...

& F' ~" A% r) ~. |$ e8 ?/ a朱利安日期有这样叫的,是 Julian Date 音译过来的。

所属标签

相似分享

关于意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新和工艺
招聘信息
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
关注我们
st-img 微信公众号
st-img 手机版