前言
本文将介绍一个基于 STM32F7 的网络时间同步客户端例程。在开始介绍程序之前，我们先来了解一下什么是网络时间同步，和 NTP 协议等相关概念。
5 l+ B2 \$ L/ q) L+ Z通常在计算机工作前，我们会预先设定好系统的时间。但如果网络中多台计算机（或者处于多个网络中的计算机）需要协同工作的时候，这些计算机的时间就需要保持同步。如果两个计算机（或者两个网络）的时间不同步，有可能会出现，比如你
会收到 5 分钟之后才会被发出的邮件。所以在这种情况下需要通过某种办法将网络上各设备的时间进行同步。
说到这里，我们也知道了网络时间同步，是指将计算机或者设备的时间与网络上的时间源保持一致。时间源是由网络上的时间服务器提供。本文介绍的是 NTP 客户端，NTP 协议是 TCP/IP 协议中的应用层协议。NTP 的全称是 Network Time Protocol, 它是用来同步网络中个计算机的时间的协议。它的目的是在国际互联网上传递统一、标准的时间。具体的实现方案是在网络上指定若干时钟源网站，为用户提供授时服务，并且这些网站间应该能够相互比对，提高准确度。
- O4 V) N* o' f. U, f8 ]NTP 简介
7 ^) I! y0 Z& v; y* }NTP 工作原理
这里借用网上的一个图来简单的说下 NTP 的工作原理：假设设备 A 和设备 B 通过网络连接，它们都有各自的时间系统，需要通过网络进行同步。假设同步前设备 A 的时间是 10:00:00 AM, 设备 B 的时间是 11:00:00AM，相差 1 个小时。
设备 B 作为 NTP 时间服务器，设备 A 需要将自己的时间与设备 B 同步。

& m+ K( [6 `& H9 g; i1. 首先设备 A 向设备 B（服务器）发送一个 NTP 报文，该报文带有它离开设备 A 时的时间戳 10:00:00AM(T1)
2. 该 NTP 报文到达设备 B，设备 B 加上当前自己的时间，也就 11:00:01AM(T2)
3. 设备 B 回复设备 A，并加上报文离开时的时间戳 11:00:02(T3)
4. 设备 A 收到设备 B 的回复，此时，设备 A 的当地时间是 10:00:03(T4)

* J2 j# `7 V& b9 u
5 }9 m$ u9 j) r
! o! }0 w  x1 Z: j8 Q4 b6 s# ^- w通过这个过程，设备 A 得到了四个时间戳。假设 NTP 报文从设备 A 到设备 B，和从设备 B 回到设备 A 的时间是对等的，利用这四个时间戳，设备 A 就可以计算出和设备 B 的时间差，从而来更新自己的系统时间。
    NTP 报文的往返时延 Delay = (T4-T1)-(T3-T2)
, C7 O+ k$ f: Q' W0 l) A# D   设备 A 相对设备 B 的时间差 Offset=((T2-T1)+(T3-T4))/2

2 [5 p$ i8 J4 kNTP 的工作模式和工作模型
  R, _0 i  j+ ]0 `NTP 有三种工作模式：主/被动模式，客户端/服务器模式和广播模式。主/被动模式下，连接双方可以互相同步，客户端/服务器模式下，只能客户端被服务器同步。广播模式，是一对多的连接，服务器主动发出时间信息，客户由此调整自己的时间。

$ J( z0 W1 e8 l  v3 wNTP 采用分层结构进行工作（如下图）。最顶层（0 层）是时间同步网络的基准时间参考源，它位于整个同步网络的顶层。
直接连接到 0 层时钟源的计算机属于第 1 层，从第 1 层接受时间的计算机属于第 2 层，以此类推。每一层的号码代表了这一层到顶层时钟源的距离。参考时钟源的层数从 0 到 15，16 表示未同步的设备。下层设备可以同时应用几个上层设备的时间作为参考，也可以引用同层设备的时间作为参考。
& N' _3 u) F. l* ?
0 F) W( m6 K. Y6 x+ y1 U

NTP 时间戳
NTP 以 UTC 作为标准时间。UTC 是以原子时秒长为基础的时间计量系统。
: U' J$ n. \/ H& n1 |* H/ `4 \NTP 时间戳，是从 1900 年 1 月 1 日 0 时 0 分 0 秒开始所经过的秒数。NTP 的时间戳通过一个 64 比特的无符号定点数来表示。
# C: P7 B2 p8 a6 X" ]前 32 比特表示整数部分，后 32 比特表示小数部分，以秒为单位。


! p& K; X/ T& u9 X. D
) M/ n( C7 ~5 U6 e因为只有 32 位表示秒数， 。所以 136 年为一个周期，当到 2036 年时，数据会溢出。NTP 协议中定义了 Era Number 来解决这个问题。从 1900 年 1 月 1 日开始的第一个 136 年，Era Number 为 0，之后的每 136 年加 1。但 Era Number 的值本身并不能从 NTP 的数据中得出，需要从外部采用一些方法来解决。

NTP 报文格式
$ ^) X3 J& C' G4 i2 J) J, X7 _8 l下图所示是 NTP 报文的格式：
( T3 F, P  }  x, y6 p$ }
0 o6 K# {  a# r+ c

   LI 闰秒标识器，占 2 个比特位。预警最近的分钟里将要被插入或者删除的闰秒秒数。
   版本号，占 3 个比特位。现在为版本 4.
$ v6 ~1 o- f& G1 t- f& |. {4 r   模式，占 3 个比特位。
% I0 V1 `' b8 Z3 L% Q8 q   Stratum(层) ，占 8 个比特位。表示当前时钟的层。
. P& ]+ J0 E4 X% [0 r6 `% v+ T   轮询（Poll）间隔，占 8 个比特位。表示连续信息之间的最大间隔。
+ D. j% c, z) o8 Z$ @) d2 M   本地时钟精度，占 8 个比特位。
   原始时间戳 Originate Timestamp，64 比特。客户端发出 NTP 报文的时间。
   接收时间戳 Receive Timestamp，64 比特。服务器端接收到 NTP 报文的时间。
0 {! S3 k0 {  E& }8 H  T   发送时间戳 Transmit Timestamp，64 比特。服务器端发送应答的时间。
3 V. ~2 o# j% {9 b) m; P! s( J8 w
+ v! a9 ~& i4 j/ l4 a* K( LNTP,SNTP 和 IEEE1588(PTP)的区别
: z/ Y+ k* H2 p' U' ?$ e% e5 |大多数环境中，NTP 可以提供 1~50ms 的可靠时钟源。但对于很多系统来说，并不需要这么高精度的同步，而且完全实现NTP 协议太复杂了，所以 SNTP（Simple Network Time Protocol）应运而生。SNTP 基于 NTP 协议，和 NTP 的数据帧格式
; M; m! B. z7 ?9 H% f" P5 \% |% k6 P是一样的，计算时间偏差以及数据包往返时延的方法也一眼。区别就是 SNPT 没有 NTP 中复杂的同步算法。SNTP 提供的同步时间精度比 NTP 低。SNTP 与 NTP 协议具有互操作性，SNTP 客户端可以与 NTP 服务器协同工作，NTP 客户端也可以接
受 SNTP 服务器发出的授时信息。
& z$ k- `! Y$ \, M3 \! K/ s- ?
IEEE1588 协议是专门针对工业应用提出的精确时钟同步协议。它能提供微秒级的时间同步。

. }5 I; j# _1 G9 p& U) I9 O$ M与 IEEE1588 相比，NTP/SNTP 授时精度不高的原因在于打时间戳的位置。NTP/SNTP 是在应用层写入或者读出时间戳，客户端发起授时请求，先从应用层到物理层，经过网络传输，到达服务器端再从物理层到应用层被读出，这三个阶段都存在不
确定性。反之亦然，造成 NTP/SNTP 的精度不会很高。
. _: ^$ J: f, E( O5 R+ w6 c) y! L而 IEEE1588 的时间戳的获取位置是在物理层，可以避免报文处理时间的不一致性。STM32 的以太网外设支持 IEEE1588 协议提供高精度的同步，在每个帧的发送或接收时给出 64 位时间戳，与 NTP 的时间戳格式相同。关于 IEEE1588 的实现可以
  n* l, X9 m) C参考 ST 的另一篇 AN3411。
0 C) O2 T; ^  p1 l: f- t
NTP 客户端代码实现
0 B% N6 ?# [9 D3 v9 V: O本代码基于 STM32F7Cube 库，通过 NTP 协议从远程 NTP 时间服务器上读取时间，并同步本地 RTC 的实时时钟。程序使用了 STM32F746 的以太网和 RTC 两个外设，应用 FreeRTOS 操作系统，TCP/IP 编程部分使用 netconn 接口函数。

实时时钟 RTC
STM32F7 的实时时钟是一个独立的 BCD 定时器/计数器。可以提供具有可编程闹钟中断功能的日历时钟/日历。两个 32 位寄存器包含二进码十进数格式 (BCD) 的秒、分钟、小时（12 或 24 小时制）、星期几、日期、月份和年份。此外，还可提供二进制格式的亚秒值。系统可以自动将月份的天数补偿为 28、29（闰年）、30 和 31 天。并且还可以进行夏令时补偿。此外，还可以使用数字校准功能对晶振精度的偏差进行补偿。
, Z3 L& B  O, ^6 W/ N备份域复位后，所有 RTC 寄存器都会受到保护，以防止可能的非正常写访问。
6 L: y7 l8 }6 I0 n2 ^0 Z9 a4 c: ^5 [无论器件状态如何（运行模式、低功耗模式或处于复位状态），只要电源电压保持在工作范围内，RTC 便不会停止工作。
0 a; w4 G" K1 {! A在本代码中，首先将 RTC 初始化到默认的时间 2014 年 2 月 18 号，2 点 0 分 0 秒。当收到 NTP 服务器的响应后，利用收到的时间修改 RTC 的值，完成同步。
2 [2 n1 x9 |4 Q1 ^* h3 G5 j* m下面是 RTC 相关的函数：
RTC_Init 和 RTC_CalendarConfig，在 main 函数中调用

1. if (HAL_RTC_Init(&RtcHandle) != HAL_OK)
   
2. {
   
3. /* Initialization Error */
   
4. while(1) {};
   ! p0 N7 a0 g; _/ f( B6 |
5. }
   * J6 _0 z' t; U* O# `! l
6. }
   + X% f2 E, D8 L, j
7. /**
   
8. 
   
9. * @brief Configure the current time and date.
   
10. * @param None
    + x" N! P) K1 C
11. * @retval None
    ' P* O, }9 {6 f8 B) S3 i
12.   */
    
13.   static void RTC_CalendarConfig(void)
    ! N( W+ e7 y" q3 H$ x- a
14.   {
    
15.   RTC_DateTypeDef sdatestructure;
    2 `( W9 d9 ]- W  s& V( a
16.   RTC_TimeTypeDef stimestructure;
    
17.   /*##-1- Configure the Date #################################################*/
    8 o5 H& x- b4 Y* q$ l. ^7 b3 i# Q
18.   /* Set Date: Tuesday February 18th 2014 */
    
19.   sdatestructure.Year = 0x14;
    7 _' S. c& K; m/ n" A
20.   sdatestructure.Month = RTC_MONTH_FEBRUARY;
    ) ]  ?% l1 @1 [, f8 `, Q6 ]
21.   sdatestructure.Date = 0x18;
    
22.   sdatestructure.WeekDay = RTC_WEEKDAY_TUESDAY;
    ! r! i9 j. ?2 a
23. 
    9 ?" f, S: V% b+ M
24. if(HAL_RTC_SetDate(&RtcHandle,&sdatestructure,RTC_FORMAT_BCD) != HAL_OK)
    
25. {
    " U" K: B: S! g  q8 g7 A0 f
26. /* Initialization Error */
    
27. while(1) {};
    & Q. R* Y% i" d1 T( e6 q) M
28. }
    1 @$ D, e( `$ t, U7 p1 x
29. /*##-2- Configure the Time #################################################*/
    
30. /* Set Time: 02:00:00 */
    
31. stimestructure.Hours = 0x02;
    " I" Y2 x- @% R; o9 p8 P# T
32. stimestructure.Minutes = 0x00;
    4 _3 k2 `8 i4 n8 ?% b; f
33. stimestructure.Seconds = 0x00;
    
34. stimestructure.TimeFormat = RTC_HOURFORMAT12_AM;
    " \8 Q0 n# S! T/ k% ]2 y
35. stimestructure.DayLightSaving = RTC_DAYLIGHTSAVING_NONE ;
    ) P, w0 z# C2 K4 H" L* v: |: w' e+ b
36. stimestructure.StoreOperation = RTC_STOREOPERATION_RESET;
    . L- d" ^. E) A! e" [
37. if (HAL_RTC_SetTime(&RtcHandle, &stimestructure, RTC_FORMAT_BCD) != HAL_OK)
    
38. {
    
39. /* Initialization Error */
    6 m. q6 Y2 ~* E; T; T
40. while(1) {};
    
41. }
    
42. /*##-3- Writes a data in a RTC Backup data Register1 #######################*/
    ; d: Q" t; G& p+ n2 t; H; ?
43. HAL_RTCEx_BKUPWrite(&RtcHandle, RTC_BKP_DR1, 0x32F2);
    
44. }

复制代码

  z6 S, t2 ~/ s* z- M* E  ^RTC_CalendarUpdate 函数，更新 RTC 的值，在 NTP 进程中调用。

1. /**
   1 T! j, P: g* z# u
2. * @brief Update the current time and date according to the time get from NTP server.
   
3. * @param newtime. pointer to newtime
   / o3 o! X- i) ?* D4 t& \* |
4. * @retval None
   ; S' I1 S% W5 F
5.   */
   
6.   void RTC_CalendarUpdate(struct tm * newtime)
   % Y% Y- H( X, l3 R! a2 w0 d
7.   {
   . @5 G6 t4 L/ l, F' w0 `
8.   RTC_DateTypeDef sdatestructure;
   6 f! W# _% S! h# H
9.   RTC_TimeTypeDef stimestructure;
   
10. 
    . y: K: Z  K. P2 w, l. \
11. /*##-1- Configure the Date #################################################*/
    ' F0 c# z" N" h8 R/ W1 U% J
12. sdatestructure.Year = newtime->tm_year+1900-2000;
    " Y: f) u- e. v( T
13. sdatestructure.Month = newtime->tm_mon +1;
    
14. sdatestructure.Date = newtime->tm_mday;
    
15. sdatestructure.WeekDay = newtime->tm_wday;
    
16. 
    8 U' C2 r* W# C5 o1 Z# R3 Y
17. if(HAL_RTC_SetDate(&RtcHandle,&sdatestructure,RTC_FORMAT_BIN) != HAL_OK)
    : w! o) D, `$ k( A2 d/ c, C- q4 z
18. {
    . [5 U. z2 b( M* E  ?7 h
19. /* Initialization Error */
    
20. while(1) {};
    
21. }
    
22. /*##-2- Configure the Time #################################################*/
    5 y) \4 d$ F. i7 ^8 \& d/ b/ d
23. stimestructure.Hours = newtime->tm_hour;
    9 N: i* ^/ Y+ L& r# r1 `
24. stimestructure.Minutes = newtime->tm_min;
    
25. stimestructure.Seconds = newtime->tm_sec;
    2 K! E4 r4 M$ {3 m" a) G
26. stimestructure.TimeFormat = RTC_HOURFORMAT12_AM;
    
27. stimestructure.DayLightSaving = RTC_DAYLIGHTSAVING_NONE ;
    
28. stimestructure.StoreOperation = RTC_STOREOPERATION_RESET;
    
29. if (HAL_RTC_SetTime(&RtcHandle, &stimestructure, RTC_FORMAT_BIN) != HAL_OK)
    
30. {
    6 j, x1 ?( Q; O7 E1 s
31. /* Initialization Error */
    " }4 i  Z+ \0 R3 J7 t
32. while(1) {};
    
33. }
    5 O6 W8 e/ o9 y) E* ?
34. /*##-3- Writes a data in a RTC Backup data Register1 #######################*/
    
35. HAL_RTCEx_BKUPWrite(&RtcHandle, RTC_BKP_DR1, 0x32F2);
    . n# p0 I& ?7 p1 D) s4 R$ T1 S
36. }
    

复制代码

" Y0 I6 K8 B: GNTP 部分
7 Z# H* S# \& C% SNTP 协议基于 UDP 进行传输，使用的 UDP 端口号为 123。使用 LwIP 实现 NTP 协议，要记得在 Lwipopts.h 里将LWIP_UDP 宏定义打开。
+ s- W( B+ L; T2 H! F) k下面是一个简单的 NTP 通信流程：
8 }/ n& O# i7 t1 D
! K7 t0 C( k- t: O
; z* p& q: W( e' ^: `  G
/ ~6 F' O- _0 c& f# g3 w' PNTP 通信相关代码：
* R+ n; |/ ?4 s$ ]# O8 b! b建立 NTP Client 的服务进程

1. void ntp_client_init(void)
   
2. {
   
3. sys_thread_new("ntp_thread", ntp_thread, NULL, DEFAULT_THREAD_STACKSIZE,
   
4. NTP_THREAD_PRIO);
   
5. }

复制代码

. _8 K; m; h# R% ^( Hntp_thread，ntp_request 与 ntp_process，完成与服务器的通信以及 NTP 时间格式到可读的年月日格式的转换。

1. static void ntp_thread(void *arg)
   : D$ L4 s8 j6 I, O8 ^
2. {
   8 I# Y8 x4 J" I- Z2 I  J
3. while(1)
   ' H+ D7 W. X8 M( ?$ N
4. {
   # {3 f- h0 z7 p# Z8 Y0 B7 J5 ^
5. /*#-send ntp request ##############################*/
   0 u# j) _! w4 O. M/ d- X
6. ntp_request();
   4 d5 [3 b4 V6 L$ I% F9 F. s0 M- }+ h
7. 
   
8. /*#-update local time #############################*/
   
9. printf("RTC time before update\n");
   
10. RTC_CalendarShow();
    
11. 
    
12. RTC_CalendarUpdate(synchronized_local_time);
    & _2 l0 o7 d5 r- U% M* q3 p
13. 
    
14. /*display local time*/
    
15. printf("RTC time after update\n");
    ( X; @' ^( a% t+ M$ {
16. RTC_CalendarShow();
    
17. 
    
18. /*#-delay 1min ######################################*/
    $ k/ ~, H/ ~. U2 C* W7 p5 x$ a
19. osDelay(60*1000);
      B3 l- {" G$ ~, t& [: H+ {
20. }
    + N1 k0 ^" a, F( q6 W. Q* b% T
21. 
    
22. }
    
23. static void ntp_request(void)
    * Q+ D; F+ v6 B
24. {
    
25. struct netconn * conn= NULL;
    $ w- u# s5 m% s; o
26. struct netbuf * buf = NULL;
    
27. uint8_t ntp_request_buf[NTP_PKT_LEN];
    ' o3 H* s7 k' [. |
28. uint8_t* ntp_receive_buf_p;
    
29. uint16_t buf_len;
    7 ~; Q, U. r* S- C2 R
30. err_t err;
    
31. //get ntp server address
    
32. #if USE_DNS
    * H; t- T; q+ ^$ E# f
33. if(netconn_gethostbyname(ntp_server_list[0],&ntp_server_addr)!=ERR_OK)
    
34. {
    / M- l2 d( {1 V. ~* [- Y( d
35. IP4_ADDR(&ntp_server_addr, NTP_Server_ADDR0, NTP_Server_ADDR1, NTP_Server_ADDR2,
    - _' t# d6 t0 ]3 h% I
36. NTP_Server_ADDR3);
      V. X1 w; k! \) N% }
37. }
    9 C4 M2 T: b* w, S
38. #else
    
39. IP4_ADDR(&ntp_server_addr, NTP_Server_ADDR0, NTP_Server_ADDR1, NTP_Server_ADDR2,
    , r% \  n0 z1 ~5 n9 C# C- `
40. NTP_Server_ADDR3);
    
41. #endif
    * Q8 S) K/ h0 ?* d( U" o5 [2 J, [
42. 
    ) @9 s7 X( v! d
43. //Create new netconn
    
44. conn = netconn_new(NETCONN_UDP);
    . Z: l, }: L' v6 }) E& M7 {/ o: i! a
45. 
    2 r) ~% h' v8 W
46. if(conn!= NULL)
    8 E: }: E! v9 n' q$ a
47. {
    
48. buf = netbuf_new();
    / X) N. m# K4 P7 v
49. if(buf != NULL)
    
50. {
    
51. //initialize ntp packet to 0
    
52. memset(ntp_request_buf, 0, NTP_PKT_LEN);
    4 v+ [( R8 L$ d& R5 `9 ^, h) @$ `& Y
53. //buid ntp packet
    
54. ntp_request_buf[0] = NTP_LI_NO_WARNING|NTP_VERSION|NTP_MODE_CLIENT;
    5 o, D" S8 v9 B8 w1 k
55. 
    
56. err = netbuf_ref(buf,ntp_request_buf,NTP_PKT_LEN);
    
57. if(err ==ERR_OK)
    
58. {
    
59. //connect to NTP server
    
60. err = netconn_connect(conn,&ntp_server_addr,NTP_PORT);
    
61. if(err == ERR_OK)
    
62. {
    ! t" K6 s5 M  ]3 H! k
63. //Org_Timestamp, read current local time
    # K- x0 N2 g, Y/ W- s8 {
64. Org_Timestamp = ntp_get_currenttime();
    
65. 
    
66. //send ntp request to ntp server
    
67. if(netconn_send(conn,buf)!=ERR_OK)
    
68. {
    " o& J: B, i: K6 B- D
69. 
    
70. }
    . L* M1 g; t% N! W* ~
71. netbuf_delete( buf );
    
72. //reveive ntp response
    
73. netconn_recv(conn,&buf);
    4 }6 K, H+ N, T2 ~% U6 n
74. 
    
75. //Destination_Timestamp,read current local time
    
76. Destination_Timestamp = ntp_get_currenttime();
    8 {! n# M  Y1 r) j. [# S% M( T
77. 
    
78. netbuf_data(buf,(void**)&ntp_receive_buf_p,&buf_len);
    
79. 
    7 i6 D/ C/ s) f& d: [: k8 _
80. //check ntp packet
    
81. if(buf_len==NTP_PKT_LEN)
    
82. {
    
83. if(((ntp_receive_buf_p[0]& NTP_MODE_MASK) == NTP_MODE_SERVER)||
    
84. ((ntp_receive_buf_p[0] & NTP_MODE_MASK) == NTP_MODE_BROADCAST))
    7 Z. z- E7 w. |& N! z* a- a
85. {
    2 \( ?) F  ~1 p/ N2 i6 H
86. // extract time from packet
    
87. Receive_Timestamp = ntp_receive_buf_p[RECEIVE_TS_OFFSET]<<24 |
    
88. ntp_receive_buf_p[RECEIVE_TS_OFFSET+1]<<16|
    ( l2 t; Z1 x& U. y/ |9 b
89. ntp_receive_buf_p[RECEIVE_TS_OFFSET+2]<<8
    
90. |ntp_receive_buf_p[RECEIVE_TS_OFFSET+3];
    ' L' R$ _9 w5 ]1 z# E/ [9 }2 {
91. Transmit_Timestamp = ntp_receive_buf_p[TRANSMIT_TS_OFFSET]<<24 |
    
92. ntp_receive_buf_p[TRANSMIT_TS_OFFSET+1]<<16|
    
93. ntp_receive_buf_p[TRANSMIT_TS_OFFSET+2]<<8
    ( X$ P0 |  ^7 z0 y; u3 e
94. |ntp_receive_buf_p[TRANSMIT_TS_OFFSET+3];
    
95. // start conver time format
    
96. ntp_process(Transmit_Timestamp);
    
97. }
    & |: K! e* N  u8 f4 t4 r
98. }
    , m/ w: j, d  G1 r" J, h
99. 
    * k3 h1 ?  i! J, w* m
100. netconn_close(conn);
     
101. netconn_delete(conn);
     
102. netbuf_delete( buf );
     
103. }
     
104. else
     : v! Y2 Y8 w+ I2 ?  S" M! Y: k, M" T
105. {
     
106. netconn_delete(conn);
     
107. netbuf_delete( buf );
     1 x9 R8 h, \' k3 v9 G' c: ^# ~$ C
108. }
     
109. }
     9 W9 r! s& i8 i0 T) K
110. else//
     
111. {
     
112. netconn_delete(conn);
     ; ^' [9 F3 B2 K! G7 j
113. netbuf_delete( buf );
     ; n) @/ A" Q) h5 H7 p& y) e
114. 
     
115. }
     
116. }
     
117. else //buf ==NULL
     
118. {
     
119. netconn_delete(conn);
     9 I/ [5 k, ~9 d( v8 ~
120. }
     
121. }
     0 M7 S5 L- Q; A9 m. D7 N
122. //process
     
123. }
       L/ [  D( i3 O( ^$ N. S
124. /**
     
125. * @brief process the time obtained from NTP server.
     # L5 s3 i% G( P+ N  h+ M2 I* N. M! [
126. Change it to a human-readable format. And consider the timezone
     
127. The NTP timestamp use 1900 as epoch, but the input param of gmtime() function
     + e' T1 |+ W: y: a3 f$ E
128. consider 1970 as epoch.
     . _4 X' Y% o8 s' o8 D
129. * @param None
     9 c$ y6 L4 z, h, L# v
130. * @retval None
     
131. */
     # m: u+ i- G: M: {* K) _# X: @% F
132. static void ntp_process(uint32_t timestamp)
     
133. {
     7 x3 b" J1 w- E+ g/ Q% i8 l/ t
134. uint32_t local_ntp_timestamp;
     # o) d- M: j& C* K& U
135. //minus the difference value of 1900 epoch and 1970 epoch
     
136. local_ntp_timestamp = timestamp - DIFF_SEC_1900_1970;
     
137. 
     2 C$ q' F. j  o" b
138. //consider the time zone
     
139. local_ntp_timestamp += SEC_TIME_ZONE;
     
140. 
     : t! Z, Q7 O3 |& ~8 L
141. //conver to human-readable format
     * d$ l5 l& M7 \5 X% j. J! o$ I; [
142. synchronized_local_time = gmtime(&local_ntp_timestamp);
     
143. }
     

复制代码

" q" r! q3 Y* v% ~# s% |4 c编程要点
* u: e+ H! h. C前面已经介绍过 NTP 的时间格式是以 1900 年 1 月 1 日零时为元年，以秒为单位来表示某个时刻的时间的。所以从 NTP 报文中提取到当前的时间后(NTP 格式)，还需要转换成可读的时间格式（年月日，时分秒）。C 标准函数库里已经提供了对应的转换函数 gmtime。但 gmtime 处理的时间是以 1970 年 1 月 1 日零时为元年，所以在调用 gmtime 之前先要减去这 70 年的时间差。另外 NTP 时间是不考虑时区的，所以还需要程序将本地的时区考虑进去。
* ^9 C  e: o1 L# v0 j在编写客户端程序的时候，另外一个需要注意的地方就是发起授时请求的间隔时间。这个间隔时间不宜太短，太频繁的请求会加重服务器的负担，导致不能及时获得响应。这个时间间隔应该根据具体系统的精度来计算最大的请求时间间隔，最小间
& l( e" D/ ^6 ~4 u) t6 h) \隔不能小于 15 秒。在 RFC4330-SNTP verion4 中更详细的描述了 NTP/SNTP 客户端实现时应该注意的事项。

9 G. j. T8 ^  M) g2 X$ }9 b测试结果
将该程序在 STM32F746 Nucleo 板上进行测试。
硬件连接方式：STM32F746Nucelo 板连接到 PC，PC 通过无线上网，将无线连接的属性的高级配置中，设置“允许其他网络用户通过此计算机的 Internet 连接来连接”。PC 的有线网口的 IP 地址设为：192.168.0.1。STM32 测试板通过 PC 连接到
# S7 C6 J* f7 O9 f- v5 N2 ?7 j! }Internet。STM32F746Nucelo 板的 IP 地址设为：192.168.0.8. 网关设为：192.168.0.1.
程序向远程网络时间服务器 1.cn.pool.ntp.org 发起请求，再根据服务器的反馈修改本地时间。
下面是程序执行的打印信息，和 wireshark 捕获的通信过程。
同步前的时间是：2014 年 2 月 18 日，2:00:00
同步后的时间是：2016 年 7 月 14 日，11:18:26



2 v% I3 t9 D5 B0 T, a& O* \( c利用 RTC 的亚秒字段实现高精度同步
! r( D. c$ W/ ^( h! x- U: s7 |前面的例程里，只用到 NTP 时间中的前 32 位。只同步到了秒。STM32F7 的 RTC 还可以实现亚秒字段的高精度远程时钟同步。
在读取 RTC 亚秒字段后（RTC_SSR 或 RTC_TSSSR）,即可计算远程时钟的时间与本地 RTC 之间的精准时间差。之后，可使用 RTC_SHIFTR 对 RTC 的时钟进行零点几秒的“平移”，经过调整后可消除此偏差。
RTC_SSR 包含同步预分频器计数器的值。这样，便可计算分辨率低至 1/(PREDIV_S + 1)秒的 RTC 的准确时间。因此，可通过增大同步预分频器的值 (PREDIV_S[14:0]) 来提高分辨率。将 PREDIV_S 设置为 0x7FFF 时，可得到允许的最大分辨率
# o1 ~: o1 q* ]& C（30.52 μs，时钟频率为 32768 Hz）。
0 U* u( g; k( y" V/ R& V/ X6 j
; g/ U# L3 o8 g+ `8 {2 {$ V* @5 L提高本地时间的精度：RTC 频率校准
RTC 的时间精度与所用的时钟频率相关，想得到高精度的计时，就需要有精确的时钟频率。RTC 的精密数字校准寄存器可以帮助校准外部时钟频率。具体的校准方法可以参看 STM32F7 的参考手册 RTC 章节。
8 ]) R5 \, o. r  Q% l
3 q) Q- r! A5 i0 h5 l, N