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

: I5 @* C" ^" o% c1 U转载来源：GPS，UTC和本地时间的显示器

0 l0 N& E: J3 p* N" cGitHub仓库：http://github.com/XinLiGitHub/GpsUtcAndLocalTime
" Y  R. ^8 n. h; }0 EPS：博文不再更新，后续更新会在GitHub仓库进行。

      GPS，UTC和本地时间的显示器。程序中涉及到朱利安日期的转换，详细介绍见维基百科[Julian day](http://en.wikipedia.org/wiki/Julian_day)。
  Y  Q- u( t6 c, [9 \1 B
1，开发环境
      1，操作系统：Windows 10 专业版
      2，IDE：Visual Studio 2015 专业版

2，程序源码
      DateTime.h文件

1. /****************************************************************
   
2. * Copyright (C) 2017, XinLi, all right reserved.
   
3. * File name:    DateTime.h
   ; U- Z  r+ X9 t) T* r9 L, w/ H& B3 S
4. * Date:         2017.10.17
   0 {  L/ R# z2 k! S7 H, N5 p
5. * Description:  Date and time module header file.
   $ P  ~6 [6 l7 I! E+ W) z4 A9 T' g! v
6. *****************************************************************/
   
7. 
   & _% E0 \3 f  ~* c& i( O! t
8. #ifndef __DATETIME_H
   
9. #define __DATETIME_H
   , G, K. r% m. H7 E( r
10. 
    
11. /****************************************************************
    " w. @, z, k' V5 K3 Y$ k, G( E& {! C
12. *                        Header include
    9 W1 B7 w( J% ^9 L& m1 j  P4 u
13. *****************************************************************/
    
14. 
    " C. O* N8 Q4 ^& w  ?) y; L8 i, `' t
15. 
    , ^1 B$ P, y- @% s9 t
16. /****************************************************************
    0 A9 J3 t) k* U: g- H3 s
17. *                       Macro definition
    
18. *****************************************************************/
    
19. 
    
20. 
    
21. /****************************************************************
    
22. *                       Type definition
    9 w& K! {7 R  ~9 k5 t8 m" s
23. *****************************************************************/
    - g5 V; Q% Z' R* U+ x+ q
24. 
    
25. 
    - Q) b" ~  w( J& h* U
26. /****************************************************************
    2 _' M! r) p5 G: H
27. *                     Structure definition
    
28. *****************************************************************/
    
29. typedef struct
    " I5 K. H. |6 J0 u
30. {
    
31.   int year;
    
32.   int month;
    9 w; G% ?0 I* n4 I( {9 S; T/ |
33.   int day;
    
34.   int hour;
    
35.   int minute;
    
36.   int second;
    
37. }DateTime;
    ; Z; V2 i2 \1 [( v% k1 Z" f
38. 
    9 u6 J' k- Q7 h% x2 B+ q
39. typedef struct
    $ w; W8 e. O6 T# ^3 j
40. {
    
41.   int week;
    
42.   int second;
    
43. }GpsWeekSecond;
    
44. 
    
45. 
    
46. #ifdef __cplusplus
    
47. extern "C" {
    . {! r: x7 M! E/ J. u) e
48. #endif  /* __cplusplus */
    ; D. |8 \7 O* ~/ H$ w
49. 
    ; E( w6 B* o6 U7 d
50. /****************************************************************
    
51. *                     Variable declaration
    
52. *****************************************************************/
    
53. 
    % [$ k6 s5 a3 m- a0 G! s) g7 }6 d
54. 
    
55. /****************************************************************
    
56. *                     Function declaration
    " e: m1 M& L0 G) n
57. *****************************************************************/
    
58. DateTime GregorianCalendarDateAddYear(DateTime time, int year);
    1 @4 \. `& V, Y1 j, W& e& b
59. DateTime GregorianCalendarDateAddMonth(DateTime time, int month);
      o- \* T. |$ P/ C
60. DateTime GregorianCalendarDateAddWeek(DateTime time, int week);
    
61. DateTime GregorianCalendarDateAddDay(DateTime time, int day);
    / U1 ]. y& v4 o
62. DateTime GregorianCalendarDateAddHour(DateTime time, int hour);
    & v+ `: b" y7 A' f' ^8 B0 g1 ^3 z
63. DateTime GregorianCalendarDateAddMinute(DateTime time, int minute);
    
64. DateTime GregorianCalendarDateAddSecond(DateTime time, int second);
    4 \5 F) E. x: I2 |! v6 v, e
65. GpsWeekSecond GregorianCalendarDateToGpsWeekSecond(DateTime time);
    
66. double GregorianCalendarDateToJulianDate(DateTime time);
    1 T1 a1 {% \1 D) ~; z. M+ B
67. double GregorianCalendarDateToModifiedJulianDate(DateTime time);
    
68. GpsWeekSecond GpsWeekSecondAddYear(GpsWeekSecond time, int year);
    
69. GpsWeekSecond GpsWeekSecondAddMonth(GpsWeekSecond time, int month);
    % D! c# Q9 O) d
70. GpsWeekSecond GpsWeekSecondAddWeek(GpsWeekSecond time, int week);
    
71. GpsWeekSecond GpsWeekSecondAddDay(GpsWeekSecond time, int day);
    
72. GpsWeekSecond GpsWeekSecondAddHour(GpsWeekSecond time, int hour);
    
73. GpsWeekSecond GpsWeekSecondAddMinute(GpsWeekSecond time, int minute);
    
74. GpsWeekSecond GpsWeekSecondAddSecond(GpsWeekSecond time, int second);
    
75. DateTime GpsWeekSecondToGregorianCalendarDate(GpsWeekSecond time);
    
76. double GpsWeekSecondToJulianDate(GpsWeekSecond time);
    
77. double GpsWeekSecondToModifiedJulianDate(GpsWeekSecond time);
    6 J1 S& f  B% i7 I0 w& o
78. double JulianDateAddYear(double jd, int year);
    
79. double JulianDateAddMonth(double jd, int month);
    ' E5 Q# y; _  R) O2 ?
80. double JulianDateAddWeek(double jd, int week);
    
81. double JulianDateAddDay(double jd, int day);
    
82. double JulianDateAddHour(double jd, int hour);
    * q) x: C- ?9 p: t! A2 r
83. double JulianDateAddMinute(double jd, int minute);
    1 }0 p6 O2 O4 `# u) o; n
84. double JulianDateAddSecond(double jd, int second);
    
85. DateTime JulianDateToGregorianCalendarDate(double jd);
    / U7 u+ O; s. a8 s9 L* F* M8 M
86. GpsWeekSecond JulianDateToGpsWeekSecond(double jd);
    
87. double JulianDateToModifiedJulianDate(double jd);
    
88. double ModifiedJulianDateAddYear(double mjd, int year);
    
89. double ModifiedJulianDateAddMonth(double mjd, int month);
    : w2 t9 m7 z- M9 ?! ?3 U
90. double ModifiedJulianDateAddWeek(double mjd, int week);
    
91. double ModifiedJulianDateAddDay(double mjd, int day);
    
92. double ModifiedJulianDateAddHour(double mjd, int hour);
    # b7 j% r* X+ o" y+ }6 v+ ]
93. double ModifiedJulianDateAddMinute(double mjd, int minute);
    
94. double ModifiedJulianDateAddSecond(double mjd, int second);
    
95. DateTime ModifiedJulianDateToGregorianCalendarDate(double mjd);
    - ^# i+ S4 d  a
96. GpsWeekSecond ModifiedJulianDateToGpsWeekSecond(double mjd);
    3 D: A: {, A: y8 z( ]
97. double ModifiedJulianDateToJulianDate(double mjd);
    9 H' h/ d( Q4 t6 y; c
98. 
    
99. #ifdef __cplusplus
    # ^1 u0 ~3 b' ~4 {
100. }
     
101. #endif  /* __cplusplus */
     
102. 
     
103. #endif  /* __DATETIME_H */
     

复制代码

. |+ V7 b& Y3 V* \4 H( ~      DateTime.c文件

1. /****************************************************************
   
2. * Copyright (C) 2017, XinLi, all right reserved.
     u6 q+ ^- k& D, ~4 C* N# R) k
3. * File name:    DateTime.c
   
4. * Date:         2017.10.17
   
5. * Description:  Date and time module source file.
   + l6 O+ T1 Y% B# E* X/ w3 H- s
6. *****************************************************************/
   ! G& X9 n! u; B. q
7. 
   $ q6 J) A4 h) f. b
8. /****************************************************************
   . l8 H4 H9 Z$ m
9. *                        Header include
   
10. *****************************************************************/
    
11. #include "DateTime.h"
    
12. 
    
13. /****************************************************************
    ! G- R4 J8 E. t8 q+ c
14. *                       Global variables
    
15. *****************************************************************/
    
16. 
    
17. 
    
18. /****************************************************************
      {5 ^4 L9 @  f' {% t
19. *                     Function declaration
    * r& s/ ~# p* \' q
20. *****************************************************************/
      F, V- T0 s& N
21. 
    
22. 
    
23. /****************************************************************
    
24. *                     Function definition
    
25. *****************************************************************/
    5 ?  t0 `) t% Q8 ~  z
26. 
    
27. /****************************************************************
    
28. * Function:    GregorianCalendarDateAddYear
    1 M# t# E% }+ x4 i
29. * Description: Gregorian calendar date add year.
    - J4 {& n0 Y, t
30. * Input:       time: Gregorian calendar date.
    + o% q9 y3 [+ p% c" u" m
31. *              year: The number of year to add.
    
32. * Output:
    2 e( S* ~0 p1 K$ D) ?) b6 v7 j
33. * Return:      Gregorian calendar date.
    6 i/ U* k, T* Y* N; E% E9 l3 [
34. *****************************************************************/
    
35. DateTime GregorianCalendarDateAddYear(DateTime time, int year)
    & k" x8 C' H! i2 {
36. {
    
37.   time.year += year;
    
38. 
    1 a; ]) v. _, i- Y% c
39.   if(time.month == 2)
    
40.   {
    $ b4 T* [6 Q- [$ K5 h4 [
41.     int mday = 0;
    
42. 
    
43.     if((((time.year % 4) == 0) && ((time.year % 100) != 0)) || ((time.year % 400) == 0))
    - A* P. ]6 C0 ^% L$ J; G
44.     {
    3 m$ Z4 F" s+ `" A! j4 c1 D) U
45.       mday = 29;
    5 C! n! l: Z% l. k! a
46.     }
    
47.     else
    , G; m4 v6 o8 Z
48.     {
    
49.       mday = 28;
    
50.     }
    7 n' v* K. B) P* w: w
51. 
    
52.     if(time.day > mday)
    5 I7 p- ]* B0 |. K/ n7 {
53.     {
    : U/ R' i! t% C2 y" t6 e$ b$ q
54.       time.month += 1;
    + c2 I: b8 Y! |7 }
55.       time.day   -= mday;
    
56.     }
    : B2 R8 V- T0 y
57.   }
    % I4 U5 y( |7 ?  g9 x$ H
58. 
    
59.   return time;
    % A/ E  M; z9 w) \
60. }
    
61. 
    
62. /****************************************************************
    # g4 I* n* o; S8 N' u9 ]
63. * Function:    GregorianCalendarDateAddMonth
    6 y4 V2 r0 ]; q: a6 k, k; ~
64. * Description: Gregorian calendar date add month.
    ! M  L& n8 W2 d- O4 y" [6 S! B& y
65. * Input:       time:  Gregorian calendar date.
    ( ~& Y. c6 G3 T; c; d
66. *              month: The number of month to add.
    
67. * Output:
    8 s4 {' W* y& w+ F' q0 R
68. * Return:      Gregorian calendar date.
    
69. *****************************************************************/
    
70. DateTime GregorianCalendarDateAddMonth(DateTime time, int month)
    6 ^9 G, R2 T7 J/ ~1 u+ s1 I) J
71. {
    
72.   time.year  += month / 12;
    ( h6 ]! l  T7 a3 Y
73.   time.month += month % 12;
    ) @' E. ~1 W. f$ S. E5 H/ O
74. 
    
75.   if(time.month > 12)
    
76.   {
    ' u9 v# A" e0 [$ q1 J! K
77.     time.year  += 1;
    
78.     time.month -= 12;
    + |" Q( L+ K4 y; _3 M8 ]& R
79.   }
    
80. 
      P& b1 U7 G; U
81.   int mday = 0;
      i) U/ z7 k% g# p" i( _0 u
82. 
    
83.   if((time.month == 1) || (time.month == 3) || (time.month == 5) || (time.month == 7) ||
    0 w+ v! q# z) A, l/ [8 e
84.      (time.month == 8) || (time.month == 10) || (time.month == 12))
    : V7 r7 q5 W( R# s6 I) B
85.   {
    
86.     mday = 31;
    
87.   }
    
88.   else if((time.month == 4) || (time.month == 6) || (time.month == 9) || (time.month == 11))
    7 N+ m' X% o% H1 {( e5 I1 V7 o! R
89.   {
    
90.     mday = 30;
    5 F* v  h- H* o1 [, n
91.   }
    $ I7 P( Y$ ?) w9 q6 O% r
92.   else
    : o: b4 n( U+ b+ W4 C
93.   {
    : Y5 _4 X7 [5 W& `8 j7 j4 m
94.     if((((time.year % 4) == 0) && ((time.year % 100) != 0)) || ((time.year % 400) == 0))
    
95.     {
    ! p: U: s. C" N. U" a
96.       mday = 29;
      @" ~$ J0 `. n( h# s
97.     }
    " l4 q) N+ B6 @: }/ S
98.     else
    
99.     {
    ! r- I; _6 \5 h, p3 D
100.       mday = 28;
     
101.     }
     - u* }6 S% F) O
102.   }
     3 u5 W$ L' W  ~; u5 n* Q
103. 
     
104.   if(time.day > mday)
     3 H# E& Z; _: m% }2 T" \* {
105.   {
     
106.     time.month += 1;
     6 b. O# I* ^7 A; o# R
107.     time.day   -= mday;
     1 L/ d/ l2 E/ V( e, O) E: j
108. 
     
109.     if(time.month > 12)
     
110.     {
     
111.       time.year  += 1;
     ( s0 Y  R# _! }% M( t; Q, v
112.       time.month -= 12;
       }5 U2 e9 D3 K' K
113.     }
     
114.   }
     # c: a# h  Z+ C( B* `0 B
115. 
     
116.   return time;
     & b' O; A7 S) p% ^7 n
117. }
     
118. 
     
119. /****************************************************************
     & S# _. C2 F% c- o+ |1 q8 `( A
120. * Function:    GregorianCalendarDateAddWeek
     
121. * Description: Gregorian calendar date add week.
     
122. * Input:       time: Gregorian calendar date.
     
123. *              week: The number of week to add.
     
124. * Output:
     ! A7 y1 f% N& g/ F5 M  w5 B: a
125. * Return:      Gregorian calendar date.
     
126. *****************************************************************/
     ! X5 z# @% {  H8 d( F' W/ B# h8 {
127. DateTime GregorianCalendarDateAddWeek(DateTime time, int week)
     ) d$ v) Z) ]7 ~! Y0 q2 O! j
128. {
     / r# X+ }6 L4 z1 Z: h+ q6 U/ d; C
129.   double jd = GregorianCalendarDateToJulianDate(time) + week * 7.0;
     
130. 
     0 y- c0 d9 Q0 f7 U! Z9 I
131.   return JulianDateToGregorianCalendarDate(jd);
     5 {0 I7 c6 `# M. Z  M
132. }
     
133. 
     7 Y# S4 X' G  y# J
134. /****************************************************************
     
135. * Function:    GregorianCalendarDateAddDay
     
136. * Description: Gregorian calendar date add day.
     0 e! r. F/ Z( l% T# A
137. * Input:       time: Gregorian calendar date.
     $ D. [5 i4 u( M) M+ g) J
138. *              day:  The number of day to add.
     
139. * Output:
     
140. * Return:      Gregorian calendar date.
     
141. *****************************************************************/
     " L, w0 r- O2 v: Z$ q
142. DateTime GregorianCalendarDateAddDay(DateTime time, int day)
     0 c% x; D0 V4 ^) _7 G9 I
143. {
     
144.   double jd = GregorianCalendarDateToJulianDate(time) + day;
     7 y, q0 W: j* S' ]% V( D* a0 g0 V- n
145. 
     
146.   return JulianDateToGregorianCalendarDate(jd);
     . e- b- V0 p, y: p7 Y2 g- q/ i
147. }
     & Z5 w/ a4 e% s* ~
148. 
     8 q* b' E/ r: j4 M" f& F3 Q) r; ?- C1 E
149. /****************************************************************
     
150. * Function:    GregorianCalendarDateAddHour
     ( _  P+ A1 {* s+ p# v
151. * Description: Gregorian calendar date add hour.
     # r" l8 W9 X& n8 U4 @3 H; P4 m7 H
152. * Input:       time: Gregorian calendar date.
     
153. *              hour: The number of hour to add.
     
154. * Output:
     
155. * Return:      Gregorian calendar date.
     
156. *****************************************************************/
     # o9 u  }9 l# X* J! _
157. DateTime GregorianCalendarDateAddHour(DateTime time, int hour)
     # U4 M. I$ F7 Z* w" p# ^
158. {
     
159.   time.hour += hour;
     
160. 
     
161.   double jd = GregorianCalendarDateToJulianDate(time);
     
162. 
     
163.   return JulianDateToGregorianCalendarDate(jd);
     8 y7 N% `3 d/ V1 C" ~4 W
164. }
     3 P' X9 t4 u/ [& k  U( R
165. 
     9 w) @4 Z' y% g1 N( ~
166. /****************************************************************
     
167. * Function:    GregorianCalendarDateAddMinute
     ! o& G6 a! Y- m/ O. Q, {
168. * Description: Gregorian calendar date add minute.
     * v  `: w$ O# p( F) h: e
169. * Input:       time:   Gregorian calendar date.
     + R5 H) e5 Q/ _: i: r2 U
170. *              minute: The number of minute to add.
     6 {: Z2 ~: b6 Q( l* N
171. * Output:
     . n/ B# P7 H2 ?) O
172. * Return:      Gregorian calendar date.
     
173. *****************************************************************/
     5 V3 a5 [7 v% P" D1 g
174. DateTime GregorianCalendarDateAddMinute(DateTime time, int minute)
     9 R( {1 Y0 }5 `4 `' F
175. {
     
176.   time.minute += minute;
     9 e8 x( i* n* {  [
177. 
     
178.   double jd = GregorianCalendarDateToJulianDate(time);
     8 Y# W, b* Q" N& z4 B9 S
179. 
     
180.   return JulianDateToGregorianCalendarDate(jd);
     
181. }
     9 V4 T9 ]) x) J/ a
182. 
     + _3 @* W3 K+ o3 ^
183. /****************************************************************
     0 ^2 {- H9 J$ y. J0 e6 o
184. * Function:    GregorianCalendarDateAddSecond
     " c3 l  X4 M8 Y2 v: z9 E! q- m
185. * Description: Gregorian calendar date add second.
     
186. * Input:       time:   Gregorian calendar date.
     $ T* h# i3 N1 ~( ^$ k- m6 c) x
187. *              second: The number of seconds to add.
     . I, b: x* t. B5 f% L% n2 v
188. * Output:
     
189. * Return:      Gregorian calendar date.
     & X3 G# \* v, Z. F9 G* s
190. *****************************************************************/
     8 P. V* ~7 N4 ~" \2 @. x
191. DateTime GregorianCalendarDateAddSecond(DateTime time, int second)
     4 e' s* t' N3 d
192. {
     2 _  O" ^9 H! E' S) \5 l. x
193.   time.second += second;
     : {8 Q5 E2 k% P, m; l
194. 
     - T5 P( L# u  [. u% P/ z; q: W
195.   double jd = GregorianCalendarDateToJulianDate(time);
     
196. 
     
197.   return JulianDateToGregorianCalendarDate(jd);
     
198. }
     ( Q! `2 {2 }; [) J6 k( X5 B  [
199. 
     
200. /****************************************************************
     % W/ G; }9 a2 r6 h; X5 Z0 |* d
201. * Function:    GregorianCalendarDateToGpsWeekSecond
     
202. * Description: Gregorian calendar date to gps week and second.
     
203. * Input:       time: Gregorian calendar date.
       x9 {' a) w) B2 g5 C3 k
204. * Output:
     # ?/ G6 [, L3 A2 C5 U
205. * Return:      Gps week and second.
     ! _5 I7 h5 K& w* W% _" _6 V
206. *****************************************************************/
     
207. GpsWeekSecond GregorianCalendarDateToGpsWeekSecond(DateTime time)
     # F& n% g; z: f. Q
208. {
     
209.   double jd = GregorianCalendarDateToJulianDate(time);
     6 L8 D- o- `# i1 |1 Z3 G% ~
210. 
     % u- K! o/ ]7 ?4 j) M0 o) E- d9 @
211.   return JulianDateToGpsWeekSecond(jd);
     0 o! ^9 t5 Y7 _: ]' T
212. }
     3 ~9 H* v$ p  [. v6 D' K
213. 
     
214. /****************************************************************
     
215. * Function:    GregorianCalendarDateToJulianDate
     ; u/ E  N& {- j+ P2 |
216. * Description: Gregorian calendar date to julian date.
     + b+ j6 k/ J( j2 |' ]) Z
217. * Input:       time: Gregorian calendar date.
     
218. * Output:
     8 l8 d2 j, y$ j% O7 q, Q
219. * Return:      Julian date.
     1 Z  {, R* B4 y" O# a8 D3 }
220. *****************************************************************/
     9 n4 v. W% b$ q, ]: D5 F5 M: L2 w- {
221. double GregorianCalendarDateToJulianDate(DateTime time)
     4 u/ Y: r* [. u% U9 M  f
222. {
     5 z5 [+ ~; S) O$ F& i
223.   int jdn = (1461 * (time.year + 4800 + (time.month - 14) / 12)) / 4
     * J' |. a1 P/ X
224.           + (367 * (time.month - 2 - 12 * ((time.month - 14) / 12))) / 12
     ' ]' A- K/ e4 {% s
225.           - (3 * ((time.year + 4900 + (time.month - 14) / 12) / 100)) / 4
     # }2 r6 x$ }" q; I
226.           + time.day - 32075;
     
227. 
     
228.   double jd = jdn + ((time.hour - 12) * 3600.0 + time.minute * 60.0 + time.second) / 86400.0;
     " s( S* H' J+ L5 ~" V; o: C
229. 
     & w0 C: |( w" ?  O' j- M5 j9 I) u, g
230.   return jd;
     
231. }
     
232. 
     
233. /****************************************************************
     : C7 u5 v7 P5 U  e, Z1 Y6 D# X+ {
234. * Function:    GregorianCalendarDateToModifiedJulianDate
     " I* ~! _  d* {: s
235. * Description: Gregorian calendar date to modified julian date.
     
236. * Input:       time: Gregorian calendar date.
     
237. * Output:
     5 w( a( f$ P$ O" ~0 V
238. * Return:      Modified julian date.
     
239. *****************************************************************/
     
240. double GregorianCalendarDateToModifiedJulianDate(DateTime time)
     
241. {
     ; n9 S# J( @7 n# q' e" f! I
242.   return GregorianCalendarDateToJulianDate(time) - 2400000.5;
     
243. }
     ; M: A* H' o5 B- @/ G
244. 
     1 W" X" k4 G8 b: Q
245. /****************************************************************
     : D' X/ }8 ?0 T/ ?5 v  r% J+ V
246. * Function:    GpsWeekSecondAddYear
     
247. * Description: Gps week and second add year.
     1 z9 S, L* f5 _/ D, c2 i1 S
248. * Input:       time: Gps week and second.
     
249. *              year: The number of year to add.
     
250. * Output:
     " a4 ], i2 n, O3 I9 i  m: p
251. * Return:      Gps week and second.
     % o6 |; |1 Z' u6 e/ e) i, i2 [
252. *****************************************************************/
     . c3 }3 O* B6 i6 m+ j' ]5 ^
253. GpsWeekSecond GpsWeekSecondAddYear(GpsWeekSecond time, int year)
     3 z" X( a( g4 g3 Z" f
254. {
     
255.   DateTime date = GpsWeekSecondToGregorianCalendarDate(time);
     
256. 
     4 N3 |3 E" L! v$ g! E
257.   date = GregorianCalendarDateAddYear(date, year);
     
258. 
       L( g: y, r* v' M" ]2 [
259.   return GregorianCalendarDateToGpsWeekSecond(date);
     
260. }
     
261. 
     9 t: U) x  p8 H1 T6 Y- K
262. /****************************************************************
     0 I0 f# S1 Y+ g# [1 ~& P# w0 P# j
263. * Function:    GpsWeekSecondAddMonth
     6 c  m7 N% g1 |0 B; c
264. * Description: Gps week and second add month.
     
265. * Input:       time:  Gps week and second.
     * ^, N& p- F$ O3 ~! y0 J
266. *              month: The number of month to add.
     # a! f# Q& B0 J: B: S& y/ e, S, r
267. * Output:
     5 [: I5 H( _2 Y9 }3 @5 Z
268. * Return:      Gps week and second.
     ! T& P8 \- d: }( R
269. *****************************************************************/
     
270. GpsWeekSecond GpsWeekSecondAddMonth(GpsWeekSecond time, int month)
     - H: t; H0 p1 T
271. {
     
272.   DateTime date = GpsWeekSecondToGregorianCalendarDate(time);
     
273. 
     
274.   date = GregorianCalendarDateAddMonth(date, month);
     ( x; q) _9 a: g0 i8 Y
275. 
     ' Y4 K+ l( ?- M* X
276.   return GregorianCalendarDateToGpsWeekSecond(date);
     1 u; g: v. N1 ]4 v5 p
277. }
     
278. 
     
279. /****************************************************************
     
280. * Function:    GpsWeekSecondAddWeek
     
281. * Description: Gps week and second add week.
     , U. y( E0 i1 {5 E  A5 ~
282. * Input:       time: Gps week and second.
     
283. *              week: The number of week to add.
     
284. * Output:
     3 Q1 T; {* i& G; X
285. * Return:      Gps week and second.
     
286. *****************************************************************/
     
287. GpsWeekSecond GpsWeekSecondAddWeek(GpsWeekSecond time, int week)
     
288. {
     " [" ~4 k$ _. ?1 c' B; h/ J
289.   time.week += week;
     
290. 
     . D$ _3 J6 ~* a& E1 o" Y; N( ]( ?
291.   return time;
     
292. }
     
293. 
     
294. /****************************************************************
     ' q( V: Z/ C! d5 b
295. * Function:    GpsWeekSecondAddDay
     
296. * Description: Gps week and second add day.
     
297. * Input:       time: Gps week and second.
     
298. *              day:  The number of day to add.
     - r/ `/ X$ q* v7 u
299. * Output:
     
300. * Return:      Gps week and second.
     
301. *****************************************************************/
     , t/ z0 {8 h& v/ c/ v7 K0 L
302. GpsWeekSecond GpsWeekSecondAddDay(GpsWeekSecond time, int day)
     
303. {
     1 k2 L* X* s) M/ Z1 S
304.   time.week   += day / 7;
     
305.   time.second += day % 7 * 86400;
     1 C8 M0 R! Z" p6 L/ d- T! j
306. 
     
307.   if(time.second > 604799)
     ' e+ p6 t, E9 L
308.   {
     8 g* V7 _( W& Z( J
309.     time.week   += 1;
     
310.     time.second -= 604800;
     - T& s$ ?3 d9 ~/ T4 _$ H
311.   }
     
312. 
     
313.   return time;
     ) A3 B( h% _4 y2 s, I7 ^* q
314. }
     
315. 
     4 @7 z7 E; V) I0 J
316. /****************************************************************
     
317. * Function:    GpsWeekSecondAddHour
     
318. * Description: Gps week and second add hour.
     * G& z2 y7 `% y, u
319. * Input:       time: Gps week and second.
     
320. *              hour: The number of hour to add.
     
321. * Output:
     
322. * Return:      Gps week and second.
     
323. *****************************************************************/
     
324. GpsWeekSecond GpsWeekSecondAddHour(GpsWeekSecond time, int hour)
     6 G$ t$ S2 g& a5 Z( G/ P3 V
325. {
     
326.   time.week   += hour / 168;
     
327.   time.second += hour % 168 * 3600;
     
328. 
     
329.   if(time.second > 604799)
     
330.   {
     
331.     time.week   += 1;
     1 z' N" Q" G# p2 D4 d
332.     time.second -= 604800;
     6 b( v, Z% w6 Y  M. E0 `
333.   }
     
334.   
     
335.   return time;
     
336. }
     
337. 
     
338. /****************************************************************
     4 s. Y# I4 g) l0 m7 L5 q7 v* ^
339. * Function:    GpsWeekSecondAddMinute
     
340. * Description: Gps week and second add minute.
     2 W# {* W8 G! p# o! X& D/ R
341. * Input:       time:   Gps week and second.
     * d& f; V# t- F+ v2 f. v( o
342. *              minute: The number of minute to add.
     
343. * Output:
     3 ?& ]  @- P& \( U
344. * Return:      Gps week and second.
     
345. *****************************************************************/
     7 {$ A# [; G1 I5 X
346. GpsWeekSecond GpsWeekSecondAddMinute(GpsWeekSecond time, int minute)
     
347. {
     / W7 b% P' b) _# q& v4 T0 @; v, R
348.   time.week   += minute / 10080;
     / f# D& M6 T: g" N
349.   time.second += minute % 10080 * 60;
     
350.   
     6 t, S; I, d5 w7 `: u9 N
351.   if(time.second > 604799)
     5 _% w' J8 O1 ^; g+ V
352.   {
     
353.     time.week   += 1;
     
354.     time.second -= 604800;
     3 I* B4 i1 H/ m% t- t
355.   }
     
356.   
     
357.   return time;
     
358. }
     ; o2 o1 _/ i8 W
359. 
     - D* b3 o* B# J9 A0 s
360. /****************************************************************
     
361. * Function:    GpsWeekSecondAddSecond
     , A- W' {. p% b8 p6 e. T
362. * Description: Gps week and second add second.
     
363. * Input:       time:   Gps week and second.
     ; g* j( F& {& _( l' u4 {. E1 V% M
364. *              second: The number of second to add.
     
365. * Output:
     5 o/ }1 B/ N8 _: }: U
366. * Return:      Gps week and second.
     3 K% O/ `$ W  h9 V# a; f7 P* N
367. *****************************************************************/
     
368. GpsWeekSecond GpsWeekSecondAddSecond(GpsWeekSecond time, int second)
     
369. {
     
370.   time.week   += second / 604800;
     4 H( U1 T3 i! i: `
371.   time.second += second % 604800;
     7 T0 \& w$ v3 A* V. v$ e# c8 N
372. 
     
373.   if(time.second > 604799)
     
374.   {
     ( e! r( |! E2 \. y% W; D
375.     time.week   += 1;
     ; v& n: @8 v& a- a  A- V7 n
376.     time.second -= 604800;
     
377.   }
     
378.   
     * S; z) q. G" l- @. R, U, j/ R
379.   return time;
     
380. }
     
381. 
       p; J. U/ A) W9 J- e
382. /****************************************************************
     
383. * Function:    GpsWeekSecondToGregorianCalendarDate
     ' N9 A# N; C, q7 r; T% U
384. * Description: Gps week and second to gregorian calendar date.
     : p. y7 i1 R$ N9 o/ n6 G
385. * Input:       time: Gps week and second.
     - l: F7 k" q: F7 H
386. * Output:
     + O# I  s2 D" B; n$ p. \. E# Q: O5 f
387. * Return:      Gregorian calendar date.
     
388. *****************************************************************/
     
389. DateTime GpsWeekSecondToGregorianCalendarDate(GpsWeekSecond time)
     
390. {
     
391.   double jd = GpsWeekSecondToJulianDate(time);
     
392. 
     
393.   return JulianDateToGregorianCalendarDate(jd);
     
394. }
     
395. 
     $ v- J9 ~2 W1 k9 m8 D
396. /****************************************************************
     # R: d8 V9 g- l8 a& q( p+ N
397. * Function:    GpsWeekSecondToJulianDate
     
398. * Description: Gps week and second to julian date.
     ' Y* G8 m! R, P$ a! \
399. * Input:       time: Gps week and second.
       G) B' x' y0 f6 G* }$ ^
400. * Output:
     
401. * Return:      Julian date.
     
402. *****************************************************************/
     - R" W: k+ A; K$ \4 K
403. double GpsWeekSecondToJulianDate(GpsWeekSecond time)
     
404. {
     
405.   double jd = 2444244.5 + time.week * 7.0 + time.second / 86400.0;
     
406. 
     
407.   return jd;
     ! a8 G+ z; u. C& E0 w# z; ~+ u
408. }
     ' R  ?  Q* z; t- S* v" O
409. 
     
410. /****************************************************************
     
411. * Function:    GpsWeekSecondToModifiedJulianDate
     ! q5 j( j' M0 V, {
412. * Description: Gps week and second to modified julian date.
     4 E. j( ]+ g% C  I4 `/ N
413. * Input:       time: Gps week and second.
     9 _. y! D+ E+ `2 S
414. * Output:
     ' p, S8 \- _  z4 q( G2 ~6 |7 T4 N& n, Y
415. * Return:      Modified julian date.
     
416. *****************************************************************/
     
417. double GpsWeekSecondToModifiedJulianDate(GpsWeekSecond time)
     : ^' `( t% |; W: o' Q( @
418. {
     
419.   return GpsWeekSecondToJulianDate(time) - 2400000.5;
     
420. }
     
421. 
     
422. /****************************************************************
     ) `5 A0 }2 D) Y7 d& a) Y' D' T
423. * Function:    JulianDateAddYear
     8 W5 u4 N4 `; _1 _. E4 G9 c
424. * Description: Julian date add year.
     - V& B2 z6 D% l9 @& p0 t
425. * Input:       jd:   Julian date.
     & W. {8 N$ N* H: |
426. *              year: The number of year to add.
     
427. * Output:
     
428. * Return:      Julian date.
     ' ]7 Y% J$ {, o* a# \
429. *****************************************************************/
     $ Y! B, ]) m4 \! A! O. U
430. double JulianDateAddYear(double jd, int year)
     
431. {
     
432.   DateTime date = JulianDateToGregorianCalendarDate(jd);
     ( L+ f: B) f) N$ R+ t, O
433. 
     
434.   date = GregorianCalendarDateAddYear(date, year);
     
435. 
     1 r) a- R8 t7 s
436.   return GregorianCalendarDateToJulianDate(date);
     
437. }
     
438. 
     
439. /****************************************************************
     1 F# b6 F( o6 k
440. * Function:    JulianDateAddMonth
     
441. * Description: Julian date add month.
     
442. * Input:       jd:    Julian date.
     2 z! [; Q2 p% i- C4 V6 R/ z
443. *              month: The number of month to add.
     
444. * Output:
     ) C. Z3 [. O1 K/ Y( M
445. * Return:      Julian date.
     
446. *****************************************************************/
     0 N2 _: _: L& Y
447. double JulianDateAddMonth(double jd, int month)
     6 B4 t6 a$ t, P; H2 N# u. q
448. {
     : ^# c4 q6 F" y5 |. s
449.   DateTime date = JulianDateToGregorianCalendarDate(jd);
       P8 F  L/ U& q0 F$ F2 o8 ^5 D# j
450. 
     0 Y4 D" o: R# P  F
451.   date = GregorianCalendarDateAddMonth(date, month);
     ' \$ L8 J( j9 ^: s; K5 P
452. 
     
453.   return GregorianCalendarDateToJulianDate(date);
     
454. }
     ; ?8 B9 W$ j( I: ^
455. 
     8 O' O( [" Z; [. _
456. /****************************************************************
     4 F- X% l" Y' u) I# Y9 z
457. * Function:    JulianDateAddWeek
     
458. * Description: Julian date add week.
       U5 u% p2 L' Q0 [6 Z7 f( K* u
459. * Input:       jd:   Julian date.
     0 m; o$ E, @( m  I$ J. X7 Q3 {
460. *              week: The number of week to add.
     
461. * Output:
     
462. * Return:      Julian date.
     5 b: W& B0 a7 ]' T- p4 q" w8 P9 {
463. *****************************************************************/
     
464. double JulianDateAddWeek(double jd, int week)
     ! e5 R, }7 s6 H
465. {
       k, f8 ]; B# `/ @0 _2 i8 {+ {- J0 q
466.   jd += week * 7.0;
     
467. 
     
468.   return jd;
     * O: A5 a: Y4 F. B
469. }
     
470. 
     
471. /****************************************************************
     
472. * Function:    JulianDateAddDay
     
473. * Description: Julian date add day.
     
474. * Input:       jd:  Julian date.
     
475. *              day: The number of day to add.
     & Q$ Q3 K4 G( i- u* [
476. * Output:
     2 C1 m# X3 w! ?' p3 X+ g
477. * Return:      Julian date.
     # ~9 E& w" f$ }2 t% p
478. *****************************************************************/
     
479. double JulianDateAddDay(double jd, int day)
     + f8 b& Q% }+ S' l
480. {
     * @) P% J) n' A+ L% s7 N) f
481.   jd += day;
     & X  ^1 i: A& R* @6 z1 c
482. 
     / h" U  F7 ~. u3 K0 j' q) G+ I
483.   return jd;
     
484. }
     4 C. x( h. D9 b8 q. T
485. 
     ( Q2 Z" }$ B7 e( A0 Z
486. /****************************************************************
     
487. * Function:    JulianDateAddHour
     
488. * Description: Julian date add hour.
     2 y( L0 ~% x6 a) h' e3 a$ E
489. * Input:       jd:   Julian date.
     4 [& T. \6 H$ a2 X' j' I
490. *              hour: The number of hour to add.
     , P3 o) \# w7 U9 `
491. * Output:
     
492. * Return:      Julian date.
     
493. *****************************************************************/
     ' j: l/ U8 W  s0 a; i0 T9 F
494. double JulianDateAddHour(double jd, int hour)
     ' J2 d% i2 d* ?6 Y" H
495. {
     
496.   jd += hour / 24.0;
     , h$ }' ~7 l- Y& h6 _6 H3 J4 a
497. 
     
498.   return jd;
     
499. }
     ) t$ B$ N/ b  u
500. 
     
501. /****************************************************************
     
502. * Function:    JulianDateAddMinute
     
503. * Description: Julian date add minute.
     
504. * Input:       jd:     Julian date.
     4 P  p/ e3 C; @* \
505. *              minute: The number of minute to add.
     
506. * Output:
     3 X4 l% v0 i7 {8 W$ Y% N
507. * Return:      Julian date.
     " h0 H2 u) v( ?2 o' W
508. *****************************************************************/
     
509. double JulianDateAddMinute(double jd, int minute)
     
510. {
     
511.   jd += minute / 1440.0;
     ) E: m; \8 m1 z3 q$ w0 s
512. 
     
513.   return jd;
     
514. }
     - g5 m) y  ~8 b" ~5 y' A) A" _6 S
515. 
     + {  f& M6 `& C$ \' ~1 z1 {
516. /****************************************************************
     ; ^3 [* V0 A, G9 r" z6 Z/ I
517. * Function:    JulianDateAddSecond
     ; Z: ?7 C* F- j
518. * Description: Julian date add second.
     
519. * Input:       jd:     Julian date.
     3 Z# d! X; r4 S( O
520. *              second: The number of second to add.
     0 m, W! q- D$ x- M
521. * Output:
     
522. * Return:      Julian date.
     
523. *****************************************************************/
     
524. double JulianDateAddSecond(double jd, int second)
     ; Y7 T2 d3 u6 b
525. {
     * i8 t2 j8 j2 q$ X9 N7 q5 }9 l
526.   jd += second / 86400.0;
     2 L* k# [' J. i5 i1 K/ S
527. 
     " z6 P6 x' v3 T! g: B0 L; t) ]# g
528.   return jd;
     ( G! I# c  ^8 u% `
529. }
     
530. 
     
531. /****************************************************************
     ' M6 s: J  E; V& X3 }1 O& _- v
532. * Function:    JulianDateToGregorianCalendarDate
     
533. * Description: Julian date to gregorian calendar date.
     ; p; J2 g/ Y/ R2 K. u" B1 t
534. * Input:       jd: Julian date.
     
535. * Output:
     
536. * Return:      Gregorian calendar date.
     
537. *****************************************************************/
     5 @* t: I9 h! {5 L& y
538. DateTime JulianDateToGregorianCalendarDate(double jd)
     3 G! }) Z) ~& t" k
539. {
     ) y2 X7 P3 W; Y
540.   int y = 4716;
     
541.   int j = 1401;
     
542.   int m = 2;
     
543.   int n = 12;
     
544.   int r = 4;
     
545.   int p = 1461;
     
546.   int v = 3;
     4 h+ O# W+ D( R1 w. |5 Z
547.   int u = 5;
     ; b% Z& U. Y& B
548.   int s = 153;
     , o: X- `+ Q5 |4 L2 Z& W$ M  [
549.   int w = 2;
     * a2 H) }* |. k# N1 ]) W
550.   int b = 274277;
     
551.   int c = -38;
     
552. 
     4 Y! B3 \$ J7 B6 b8 e( L$ N1 i
553.   int jdn = (int)(jd + 0.5);
     
554.   int f   = jdn + j + (((4 * jdn + b) / 146097) * 3) / 4 + c;
     
555.   int e   = r * f + v;
     . k( Y5 R: ~/ g( f
556.   int g   = (e % p) / r;
     6 u# J9 N1 T; {
557.   int h   = u * g + w;
     
558. 
     
559.   DateTime time = {0};
     5 \  h, ?9 v2 C5 _& ]1 M& M' [
560. 
     
561.   time.day    = (h % s) / u + 1;
     
562.   time.month  = (h / s + m) % n + 1;
     7 r6 H- W# y/ B. ]( X6 h: _8 N- z; k
563.   time.year   = e / p - y + (n + m - time.month) / n;
     ! t& P* I; i+ M9 N. j
564.   time.hour   = (int)((jd + 0.5 - jdn) * 86400.5) / 3600;
     
565.   time.minute = (int)((jd + 0.5 - jdn) * 86400.5 - time.hour * 3600) / 60;
     ; p: x: V# I+ W  T# a% |- T
566.   time.second = (int)((jd + 0.5 - jdn) * 86400.5 - time.hour * 3600 - time.minute * 60);
       o: B0 J9 \& z5 J: K* l
567. 
     ; A; C: F  Z. L5 p( W& a, [
568.   return time;
     
569. }
     , ~4 k3 `5 S1 `$ G0 ^
570. 
     
571. /****************************************************************
     $ P6 j) y7 o. a& `! i# h5 G% h
572. * Function:    JulianDateToGpsWeekSecond
     
573. * Description: Julian date to gps week and second.
     
574. * Input:       jd: Julian date.
     / t  R8 Z1 H3 k5 R
575. * Output:
     % L5 h. l: E# W# H
576. * Return:      Gps week and second.
     + }$ N) `; [6 m' N! U
577. *****************************************************************/
     0 f5 m3 \1 q9 s7 m' G+ W$ O$ K
578. GpsWeekSecond JulianDateToGpsWeekSecond(double jd)
     
579. {
     ; v- F- t3 o/ i( B% x0 M/ D( k$ z
580.   GpsWeekSecond time = {0};
     # U/ x2 V1 }- X" r
581.   DateTime      date = JulianDateToGregorianCalendarDate(jd);
     # ]9 A8 I! |% j- Q2 c5 s
582. 
     9 Z# `$ m, b- m  G; k4 [
583.   time.week   = (int)(jd - 2444244.5) / 7;
     / P4 Y7 Z4 L) r% D7 J
584.   time.second = ((int)(jd - 2444244.5) - time.week * 7) * 86400 + date.hour * 3600 + date.minute * 60 + date.second;
     
585. 
     : m" a1 V% }7 x
586.   return time;
     
587. }
     " W: d9 y8 j$ I7 H' S) L7 J* w# \1 }4 G
588. 
     - f- R2 L" A/ N6 A
589. /****************************************************************
     
590. * Function:    JulianDateToModifiedJulianDate
     
591. * Description: Julian date to modified julian date.
     
592. * Input:       jd: Julian date.
     $ a+ F; ^3 P" T8 [5 B0 [5 E, v+ d9 G
593. * Output:
     3 J4 u( G# S* n% x
594. * Return:      Modified julian date.
     
595. *****************************************************************/
     & H1 i" i  E7 [
596. double JulianDateToModifiedJulianDate(double jd)
     
597. {
     8 C; E  A) w- q( f) W0 T
598.   double mjd = jd - 2400000.5;
     
599. 
     / d" m% i8 S% m$ A
600.   return mjd;
     
601. }
     : q. b& P7 V" C, F0 B! E
602. 
     8 o0 |8 q, a( F7 |9 V
603. /****************************************************************
     3 y4 Y; U# P! H
604. * Function:    ModifiedJulianDateAddYear
     
605. * Description: Modified julian date add year.
     
606. * Input:       mjd:  Modified julian date.
     % A4 x" I$ Y2 M, S/ t
607. *              year: The number of year to add.
     
608. * Output:
     ( q; q  r  {9 }! W
609. * Return:      Modified julian date.
     
610. *****************************************************************/
     ( ^# K9 h# k) `+ ]. ~5 u7 V/ [6 _
611. double ModifiedJulianDateAddYear(double mjd, int year)
     ' h% V  R, i7 H7 d2 ], o# x
612. {
     
613.   DateTime date = ModifiedJulianDateToGregorianCalendarDate(mjd);
     
614. 
     : S2 q2 u: w& c1 D8 A. }
615.   date = GregorianCalendarDateAddYear(date, year);
     0 C- u7 l; G1 r& z7 y1 |: @) M) `
616. 
       ~  H4 G, m2 v0 k3 L% j+ s2 n
617.   return GregorianCalendarDateToModifiedJulianDate(date);
     
618. }
     
619. 
     
620. /****************************************************************
     ) u3 T" B. x' k* _+ Q" I- D# i
621. * Function:    ModifiedJulianDateAddMonth
     6 u5 l% S  @, }7 V# c% z
622. * Description: Modified julian date add month.
     0 N* B7 L5 j" `7 n
623. * Input:       mjd:   Modified julian date.
     5 u, Y# a# u3 Z$ n- r' v
624. *              month: The number of month to add.
     
625. * Output:
     
626. * Return:      Modified julian date.
     
627. *****************************************************************/
     
628. double ModifiedJulianDateAddMonth(double mjd, int month)
     ' F. @7 T  q/ u- w. H) M. t
629. {
     
630.   DateTime date = ModifiedJulianDateToGregorianCalendarDate(mjd);
     6 Q$ a; R7 V  _1 [5 a/ B( k
631. 
     7 y  H$ H% O1 Z3 r
632.   date = GregorianCalendarDateAddMonth(date, month);
     4 D( A  j; E9 E0 u
633. 
     ) u( o# g$ C. q" F9 ^3 U
634.   return GregorianCalendarDateToModifiedJulianDate(date);
     
635. }
     ( V' c1 Z; m0 |8 c  s' t3 o" {1 w
636. 
     6 G: E' P* M3 Y) K5 e
637. /****************************************************************
     
638. * Function:    ModifiedJulianDateAddWeek
     
639. * Description: Modified julian date add week.
     
640. * Input:       mjd:  Modified julian date.
     
641. *              week: The number of week to add.
     & M# w+ t9 L% Q( A- L8 b
642. * Output:
     % b) W0 Q5 Z0 U. _$ Y7 H
643. * Return:      Modified julian date.
     
644. *****************************************************************/
     % v' w/ x6 \6 e/ h6 A2 Y
645. double ModifiedJulianDateAddWeek(double mjd, int week)
     
646. {
     % @$ C- C2 `/ m- F& _3 T5 s" J
647.   mjd += week * 7.0;
     / C) L, j8 A4 }/ O8 d
648. 
     % D3 x9 m1 p, d+ t* v, t
649.   return mjd;
     
650. }
     ) K( a& m5 c* a: e. E
651. 
     
652. /****************************************************************
     : H- o3 }+ T8 ^( ^5 k3 P9 w
653. * Function:    ModifiedJulianDateAddDay
     
654. * Description: Modified julian date add day.
     0 R% W4 g. ^# Q: O& |
655. * Input:       mjd: Modified julian date.
     0 P+ f1 |# g2 S3 n5 a8 ~
656. *              day: The number of day to add.
     ) X0 P( v- e' E
657. * Output:
     2 k* ~# `% P8 D; D4 q
658. * Return:      Modified julian date.
     . n1 F/ h+ X  T  [4 F0 z
659. *****************************************************************/
     
660. double ModifiedJulianDateAddDay(double mjd, int day)
     8 i# a0 L1 G0 b
661. {
     
662.   mjd += day;
     
663. 
     + c- g+ ?& Y% _+ e0 v, y
664.   return mjd;
     ( @, d5 O! v; J3 I9 M
665. }
     
666. 
     
667. /****************************************************************
     ! @& P% n+ I3 |
668. * Function:    ModifiedJulianDateAddHour
     4 F! G- _( J6 w& v" A% n
669. * Description: Modified julian date add hour.
     
670. * Input:       mjd:  Modified julian date.
     
671. *              hour: The number of hour to add.
     2 c% Z4 d1 ]2 k. A( t) t1 H
672. * Output:
     ' V6 }: {# m( J2 Y' ~9 x
673. * Return:      Modified julian date.
     
674. *****************************************************************/
     
675. double ModifiedJulianDateAddHour(double mjd, int hour)
     
676. {
     . z, v7 x# R) j7 |& Z
677.   mjd += hour / 24.0;
     
678. 
     , m, F# Z; n! B1 `+ h
679.   return mjd;
     
680. }
     
681. 
     
682. /****************************************************************
     ! N/ W/ A* W' e7 v
683. * Function:    ModifiedJulianDateAddMinute
     - C: O% Z& C+ `6 K- V) _% \
684. * Description: Modified julian date add minute.
     
685. * Input:       mjd:    Modified julian date.
     . x4 s# j: o4 ^! _4 q
686. *              minute: The number of minute to add.
     ; S) X- S  y" [! s9 _
687. * Output:
     ) Y- C% V( m. G' s" H
688. * Return:      Modified julian date.
     
689. *****************************************************************/
     
690. double ModifiedJulianDateAddMinute(double mjd, int minute)
     
691. {
     & Y% a4 }" F6 J7 Z9 I
692.   mjd += minute / 1440.0;
     
693. 
     $ W, x" _' i( X8 a2 \
694.   return mjd;
       O& n  y! [/ T2 G# E: y8 N3 U
695. }
     9 V3 P( t0 K5 q' Q0 }
696. 
     8 R6 r2 T5 c" J7 _- T0 ?
697. /****************************************************************
     9 ~5 Z9 S6 @, ^7 H7 k6 o
698. * Function:    ModifiedJulianDateAddSecond
     . [% G" p+ {! |0 T, c" l
699. * Description: Modified julian date add second.
     
700. * Input:       mjd:    Modified julian date.
     9 m7 }' x& P( U$ Z
701. *              second: The number of second to add.
     ( M  e$ ^. b3 A7 O  j8 I, j
702. * Output:
     & |: D* U0 w* @6 f! d& z
703. * Return:      Modified julian date.
     
704. *****************************************************************/
     2 G8 B9 L/ A- \
705. double ModifiedJulianDateAddSecond(double mjd, int second)
     ! R" S) q3 C( O4 N
706. {
     * m& o/ i& G- {+ g2 W  q
707.   mjd += second / 86400.0;
     
708. 
     ; S- C. O0 k  V' ]+ g
709.   return mjd;
     - Z  f) V- h; z; v6 n' N
710. }
     
711. 
     
712. /****************************************************************
     
713. * Function:    ModifiedJulianDateToGregorianCalendarDate
     ' D5 Z6 y) Y) B( }  T
714. * Description: Modified julian date to gregorian calendar date.
     ; W+ m1 @  O" _4 m
715. * Input:       mjd: Modified julian date.
     % G+ v3 p' G& \3 V4 B
716. * Output:
     : V- b3 r7 F. p* H* x2 o
717. * Return:      Gregorian calendar date.
     
718. *****************************************************************/
     - F' d- V7 d8 J% F6 v4 [) p
719. DateTime ModifiedJulianDateToGregorianCalendarDate(double mjd)
     . p/ P' j2 w; f' n; A6 u+ J
720. {
     + |& c( r; z6 J# o8 E% U; X6 ~' a
721.   return JulianDateToGregorianCalendarDate(mjd + 2400000.5);
     
722. }
     
723. 
     $ ~  z! ?, V9 R! a$ e
724. /****************************************************************
     ) ~  ^2 w0 _5 [# B8 B. _1 P, `
725. * Function:    ModifiedJulianDateToGpsWeekSecond
     
726. * Description: Modified julian date to gps week and second.
     
727. * Input:       mjd: Modified julian date.
     
728. * Output:
     
729. * Return:      Gps week and second.
     
730. *****************************************************************/
     * a& T' u4 T  y6 |
731. GpsWeekSecond ModifiedJulianDateToGpsWeekSecond(double mjd)
     
732. {
     
733.   return JulianDateToGpsWeekSecond(mjd + 2400000.5);
     
734. }
     : n/ c- P8 l7 |! P' ~% C
735. 
     
736. /****************************************************************
     
737. * Function:    ModifiedJulianDateToJulianDate
     ' L- C0 b# D/ ^+ l, ^. a
738. * Description: Modified julian date to julian date.
     
739. * Input:       mjd: Modified julian date.
     7 R/ B! H1 a4 }2 t+ z% T+ x
740. * Output:
     
741. * Return:      Julian date.
     1 ]/ h5 @8 Z$ M3 P4 l4 M
742. *****************************************************************/
     % I6 w7 ]  c$ y# W- ~4 l9 E
743. double ModifiedJulianDateToJulianDate(double mjd)
     
744. {
     
745.   double jd = mjd + 2400000.5;
     
746. 
     , H- {. h' J1 P: e9 V2 i8 c
747.   return jd;
     
748. }
     4 E/ S1 M( }+ m( ?( ?8 H, P% ^, _

复制代码

      main.c文件

1. /****************************************************************
   - a2 D" t/ h% X! N
2. * Copyright (C) 2017, XinLi, all right reserved.
   8 k: v! v3 E1 k
3. * File name:    main.c
   
4. * Date:         2017.10.17
   . r9 m& p# p. k% s& f
5. * Description:  GPS, UTC and local time displays.
   
6. *****************************************************************/
   
7. 
   
8. /****************************************************************
   
9. *                        Header include
   
10. *****************************************************************/
    
11. #include "DateTime.h"
    0 [" ?4 L9 I) n& W6 q
12. #include <stdint.h>
    
13. #include <stdio.h>
    ( t* x# q! D# P/ h
14. #include <time.h>
    0 S2 z  f' v, u# }
15. #include <windows.h>
    
16. 
    1 p8 j# u2 [+ i) b
17. /****************************************************************
    7 ]# L& Y8 N  t( r' l! ^/ x
18. *                       Global variables
    
19. *****************************************************************/
    
20. 
    
21. 
    * p" U/ b$ v# K( O6 k: s
22. /****************************************************************
    
23. *                     Function declaration
    , A% w0 ^7 b$ K- @( ~
24. *****************************************************************/
    9 v) y) f7 D' \3 I: N$ {) R, ~
25. static void gotoxy(int x, int y);
    ! a8 A1 \& v4 Z' {
26. 
    
27. /****************************************************************
    
28. *                     Function definition
    
29. *****************************************************************/
    
30. 
    ; _; P8 S6 v  H) g1 ?
31. /****************************************************************
    ) C0 c$ r# Q/ j7 k& M5 [
32. * Function:    main
    
33. * Description: Program entry.
    0 P2 `6 ~+ D, a: s, ]  w! ^
34. * Input:
    0 Z+ w5 H" U6 u% a
35. * Output:
      Z* z' f$ i( G5 c
36. * Return:
    ( I' t+ R1 _8 x8 H
37. *****************************************************************/
    0 w$ |, c+ o' p# b
38. int main(void)
    2 y* i% Y6 P- y4 b" X
39. {
    
40.   for(;;)
    + E1 k+ J4 c4 I) R4 l3 p
41.   {
    
42.     time_t        times     = 0;
    
43.     double        mjd       = 0.0;
    7 k( x+ G0 m' [+ _+ [
44.     DateTime      utctime   = {.year = 1970, .month = 1, .day = 1, .hour = 0, .minute = 0, .second = 0};
      J  w$ ]3 S( g/ W' i
45.     DateTime      localtime = {.year = 1970, .month = 1, .day = 1, .hour = 8, .minute = 0, .second = 0};
    
46.     DateTime      gpstime   = {.year = 1970, .month = 1, .day = 1, .hour = 0, .minute = 0, .second = 0};
    3 I1 ]7 g* k) C2 f8 n/ N- Q( @
47.     GpsWeekSecond gpstimews = {0};
    
48. 
    # `8 J; k! n! G$ _& F
49.     time(×);
    8 E4 t' V- z# m
50. 
    9 u) P5 P, t0 s1 t3 y
51.     if(times > INT32_MAX)
    
52.     {
    
53.       utctime = GregorianCalendarDateAddSecond(utctime, INT32_MAX);
    
54.       utctime = GregorianCalendarDateAddSecond(utctime, (int)(times - INT32_MAX));
    ; A/ ~" t: @! v0 A$ M1 j% j; u
55.     }
    2 v" Y4 H" i( c( X! ]  z
56.     else
    
57.     {
    8 S  J; a4 E6 ?. h7 {' x7 \
58.       utctime = GregorianCalendarDateAddSecond(utctime, (int)times);
    ( `. z. Q' D) {/ t% l
59.     }
    8 F; r6 `( l7 _5 ?: c- h
60. 
    
61.     mjd       = GregorianCalendarDateToModifiedJulianDate(utctime);
    
62.     localtime = GregorianCalendarDateAddHour(utctime, 8);
    ( Q8 f# u% P; z. D7 N5 ]* [/ M' I% Z
63.     gpstime   = GregorianCalendarDateAddSecond(utctime, 18);
    
64.     gpstimews = GregorianCalendarDateToGpsWeekSecond(gpstime);
    7 S5 z; @* a' k1 U8 Z  W5 @
65. 
    
66.     gotoxy(0, 0);
    
67. 
    ; Z. `0 G& Q* y# t" \
68.     printf("Local | %d-%.2d-%.2d %.2d:%.2d:%.2d | timezone UTC+8\n",
    
69.            localtime.year, localtime.month, localtime.day,
    
70.            localtime.hour, localtime.minute, localtime.second);
    
71. 
    
72.     printf("UTC   | %d-%.2d-%.2d %.2d:%.2d:%.2d | MJD %.5f\n",
    " V+ {2 U# G' b5 N( M6 ~
73.            utctime.year, utctime.month, utctime.day,
    
74.            utctime.hour, utctime.minute, utctime.second,
    ) d) m+ h0 Z2 F
75.            mjd);
    
76. 
    
77.     printf("GPS   | %d-%.2d-%.2d %.2d:%.2d:%.2d | week %d %d s\n",
    ( ?) ?( J' x9 B3 H- T3 E/ m2 T
78.            gpstime.year, gpstime.month, gpstime.day,
    : U0 [& p( q. C6 I' n) P# D$ L, [1 H; g
79.            gpstime.hour, gpstime.minute, gpstime.second,
    3 K1 z. ]1 H* S0 V
80.            gpstimews.week, gpstimews.second);
    / K5 ]7 z! L2 o" q* g- G( i
81. 
    
82.     Sleep(100);
    3 r: y( [. [3 g* n) W. `
83.   }
    
84. }
    
85. 
    
86. /****************************************************************
    
87. * Function:    gotoxy
    5 p' O! W& |: L- l' O3 {
88. * Description: Move the cursor to the specified position on the text screen.
    . V" r) h' s8 P- f6 G8 R" f
89. * Input:       x: X axis coordinates.
      H* A6 n  s0 Q6 x6 Z# ^
90. *              y: Y axis coordinates.
    
91. * Output:
    + I( v+ L& }9 n6 s/ M
92. * Return:
    
93. *****************************************************************/
    
94. static void gotoxy(int x, int y)
    5 U0 X4 P/ B3 z8 G0 U; ]* i
95. {
    7 Y4 {! E* z- }$ p
96.   COORD  pos  = {x, y};
    
97.   HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    
98.   SetConsoleCursorPosition(hOut, pos);
    
99. }
    

复制代码

3，运行效果
3 N+ z, i: @* [/ T0 u6 u

- T% r* p0 h! C0 j! Y

可以直接移植到嵌入式端，非常方便。

牛逼牛逼，回复拿分

有必要如此折腾吗？不论是 C# 还是传统 C，标准库都有完整的时间与时区支持，不必自己劳心费神再写一遍了。

maxtch 发表于 2018-3-7 22:19
有必要如此折腾吗？不论是 C# 还是传统 C，标准库都有完整的时间与时区支持，不必自己劳心费神再写一遍了。 ...

. J1 o( Q  i; l9 u' l. G朱利安日期，GPS周和周内秒，一般的库都没有吧，除非是专门做导航的库才会有这些。写这个是为了方便的在嵌入式端使用。

; r2 g1 |4 G/ m0 x! C9 O
直接 #include <time.h>不就OK了？
C51才需要自己实现，stm32的环境，何须如此麻烦。
3 C( b3 ^# |2 x( I: H6 C8 e7 v2 y以上。
0 r0 K+ R/ M  W. R3 z4 r8 ~
" p7 S: [! x" L: \4 ]

XinLiYF 发表于 2018-3-7 22:50
朱利安日期，GPS周和周内秒，一般的库都没有吧，除非是专门做导航的库才会有这些。写这个是为了方便的在 ...

儒略历和格里历的转换一般支持时区转换的库都有。（那个不叫朱利安日期……）至于 GPS 周和周内秒，如果用现有库的话，也只要可以和 UNIX 时间戳互转就可以了，没那么复杂。

maxtch 发表于 2018-3-8 11:38
儒略历和格里历的转换一般支持时区转换的库都有。（那个不叫朱利安日期……）至于 GPS 周和周内秒，如果 ...

朱利安日期有这样叫的，是 Julian Date 音译过来的。