[嵌入式开发模块]Network Time Protocol(NTP)模块

矫情吗；* 2022-01-28 19:47 438阅读 0赞

文章目录

  • 前言
  • 源码
    • NTP.h
    • NTP.c
    • NetworkLib.h
    • NetworkLib.c
    • NTPTimeHelper.h
    • NTPTimeHelper.c
  • 示例
  • 更新历史

前言

NTP协议是用于在TCP/IP网络上进行对时的一个协议。

要是你是搜到的这个博客，估计根本也就不需要介绍了，这是运用很广的一个协议，我们windows上的时间对时就是用它实现的。

简单来说，整个对时过程就是客户端发送一个包，向NTP服务器索要当前时间，这个请求包中可选的带上自己发送包时的时间戳，然后服务器在答复包中加上收到请求时以及发出答复时自己时间戳， 然后客户端收到答复包时再记录下时间戳；然后，假定网络延迟在来回时相同，通过一点计算就能消除网络传输延时算出真正的当前时间并更新自己的时间戳。当然，这是完整的NTP过程，对于精度要求不高的场合，直接把客户端答复的时间戳赋值给自己就行，又名SNTP(S即Simple)。

这里给出一个自己写的模块，不依赖于网络协议栈，提供底层的NTP包封装和解析，目前只提供SNTP解析，因为实际上对于我目前的需求也够了。

顺带一提。之所以会弄这个模块是因为在基于W5500进行开发时，其提供的NTP库写得我特别难受，耦合特别严重。就一个很简单的需求愣是要独占一个SOCKET，而且接口用起来很不友好，于是干脆就照着自己搞一个吧，所以代码中会有一小部分的相同部分。

源码

NTP.h

  1. /*
  2. ******************************************************************************************
  3. *
  4. *                              NETWORK TIME PROTOCOL MODULE
  5. *                                         NTP模块
  6. *
  7. * File : NTP.h
  8. * By   : Lin Shijun(http://blog.csdn.net/lin_strong)
  9. * Date:  2019/04/01
  10. * Version: V1.0 
  11. * History: 
  12. * NOTE(s): 1. the module is to provide interfaces for network time protocol.
  13. *          2. the current version only provide the interface for resolving SNTP
  14. *          3. the parameter 'buf' in the signature refers to the original network stream,
  15. *        and 'msg' refers to the packet parameters which are compatible with the local
  16. *        system. In big-endian system, they are the same.
  17. *          4. To use the module:
  18. *        a. prepare a NTPMSG variable or a buffer which is big enough to hold the NTPMSG.
  19. *        b. use NtpMsg_initRequest to init the buffer as NTP request message.
  20. *        c. initialize a socket as udp and call sendto() to send the whole message to
  21. *            NTP server with port NTP_PORT. Then wait for the respond from NTP server.
  22. *        d. If got respond, resolve the frame with NtpMsg_resolveCurTimeSNTP, then you
  23. *            will get the current (NTP) time stamp.
  24. *        e. call NtpTime_toDatetime with the time stamp to get a readable datetime.
  25. ******************************************************************************************
  26. */
  28. #ifndef _NTP_H
  29. #define _NTP_H
  31. /*
  32. *******************************************************************************************
  33. *                                       INCLUDES
  34. *******************************************************************************************
  35. */
  37. #include <stdint.h>
  39. /*
  40. *******************************************************************************************
  41. *                                     CONSTANT 常量
  42. *******************************************************************************************
  43. */
  45. //  00 no warning
  46. //  01 last minute has 61 seconds
  47. //  10 last minute has 59 seconds
  48. //  11 alarm condition (clock not synchronized)
  49. #define NTP_LI_NOWARNING  0
  50. #define NTP_LI_61s        1
  51. #define NTP_LI_59s        2
  52. #define NTP_LI_ALARM      3
  54. #define NTP_VERSION       4
  56. #define NTP_MODE_0          0  // reserved
  57. #define NTP_MODE_SYMACTIVE  1  // symmetric active
  58. #define NTP_MODE_SYMPASSIVE 2  // symmetric passive
  59. #define NTP_MODE_CLIENT     3  // client
  60. #define NTP_MODE_SERVER     4  // server
  61. #define NTP_MODE_BROADCAST  5  // broadcast
  62. #define NTP_MODE_6          6  // reserved for NTP control message
  63. #define NTP_MODE_7          7  // reserved for private use
  65. #define DAYS_LEAPYEAR       366
  66. #define DAYS_COMMYEAR       365
  67. #define SECS_PERMIN         60UL
  68. #define SECS_PERHOUR        (60  * SECS_PERMIN)
  69. #define SECS_PERDAY         (24  * SECS_PERHOUR)
  70. #define SECS_LEAPYEAR       (DAYS_LEAPYEAR * SECS_PERDAY)
  71. #define SECS_COMMYEAR       (DAYS_COMMYEAR * SECS_PERDAY)
  72. #define SECS_1900to1970     0x83aa7e80
  73. #define SECS_1900to2019     0xdfd52c00
  74. // NTP server Domain name of windows
  75. #define NTPSERVER_NAME_WINDOWS  "time.windows.com"
  76. // NTP server IP Address of National Time Service Center Chinese Academy Of Scences
  77. #define NTPSERVER_IP_CHINA  210,72,145,44
  78. #define NTP_PORT            123            // NTP server port number
  79. #define EPOCH               1900           // NTP start year
  81. /*
  82. *******************************************************************************************
  83. *                                     TYPE DEFINITION
  84. *******************************************************************************************
  85. */
  87. typedef uint32_t NtpSeconds;
  89. typedef struct DATETIME_STRUCT{
  91.   uint16_t yy;
  92.   uint8_t  mo;
  93.   uint8_t  dd;
  94.   uint8_t  hh;
  95.   uint8_t  mm;
  96.   uint8_t  ss;
  97. } Datetime;
  99. typedef struct NTPTIME_STRUCT{
  101.   NtpSeconds sec;
  102.   uint32_t   frac;  // fractions
  103. } NtpTime;
  105. typedef struct NTPMSG_STRUCT{
  107.   // Leap Indicator (LI): This is a two-bit code warning of an impending leap second to be inserted/deleted
  108.   // in the last minute of the current day, with bit 0 and bit 1, respectively. (see NTP_LI_XXXX)
  109.   //unsigned int LI  :2;
  110.   // Version Number (VN): This is a three-bit integer indicating the NTP version number, currently three (4).
  111.   //unsigned int VN  :3;
  112.   // Mode: This is a three-bit integer indicating the mode. (see NTP_MODE_XXX)
  113.   //unsigned int Mode:3; 
  114.   // fields  | LI |  VN | Mode |
  115.   // bitPos  | XX | XXX | XXX  |
  116.   uint8_t Flag;
  117.   // Stratum: This is a eight-bit integer indicating the stratum level of the local clock, with values 
  118.   // defined as follows:
  119.   // 0 unspecified
  120.   // 1 primary reference (e.g., radio clock)
  121.   // 2-255 secondary reference (via NTP)
  122.   // The values that can appear in this field range from zero to NTP.INFIN inclusive
  123.   uint8_t Stratum;
  124.   // Poll Interval: This is an eight-bit signed integer indicating the maximum interval between successive
  125.   // messages, in seconds to the nearest power of two. The values that can appear in this field range from 
  126.   // NTP.MINPOLL to NTP.MAXPOLL inclusive.
  127.   int8_t  Poll;
  128.   // Precision: This is an eight-bit signed integer indicating the precision of the local clock, in seconds
  129.   // to the nearest power of two.
  130.   int8_t  Precision;
  131. //  int8_t       Precision;
  132.   // Root Delay: This is a 32-bit signed fixed-point number indicating the total roundtrip delay to the
  133.   // primary reference source, in seconds with fraction point between bits 15 and 16. Note that this
  134.   // variable can take on both positive and negative values, depending on clock precision and skew.
  135.   int32_t RootDelay;
  136.   // Root Dispersion: This is a 32-bit signed fixed-point number indicating the maximum error relative
  137.   // to the primary reference source, in seconds with fraction point between bits 15 and 16. Only
  138.   // positive values greater than zero are possible.
  139.   int32_t RootDisp;
  140.   // Reference Clock Identifier: This is a 32-bit code identifying the particular reference clock.
  141.   char    ClkID[4];
  142.   // Reference Timestamp: This is the local time at which the local clock was last set or corrected, in
  143.   // 64-bit timestamp format.
  144.   NtpTime RefStamp;
  145.   // Originate Timestamp: This is the local time at which the request departed the client host for the
  146.   // service host, in 64-bit timestamp format.
  147.   NtpTime OrgStamp;
  148.   // Receive Timestamp: This is the local time at which the request arrived at the service host, in 64-bit
  149.   // timestamp format.
  150.   NtpTime RxStamp;
  151.   // Transmit Timestamp: This is the local time at which the reply departed the service host for the client
  152.   // host, in 64-bit timestamp format.
  153.   NtpTime TxStamp;
  154.   // Authenticator (optional): When the NTP authentication mechanism is implemented, this contains
  155.   // the authenticator information defined in Appendix C.
  156. } NTPMSG;
  158. /*
  159. *******************************************************************************************
  160. *                                     INTERFACES
  161. *******************************************************************************************
  162. */
  164. // initialize the NTP message frame to request time.
  165. // description: initialize the buffer to the NTP frame which will be sended to request time.
  166. // parameter  : buf        the buffer to store the frame.
  167. //              orgStamp   the local time at which the request departed the client host for the
  168. //                         service host. NULL if not used.
  169. // return     : length of the message
  170. // note       :
  171. uint16_t NtpMsg_initRequest(uint8_t * buf, NtpTime const * orgStamp);
  172. // resolve the current time from the NTP message just received.(SNTP)
  173. // description: resolve the current time from the NTP message just received.
  174. // parameter  : buf    the NTP message just received.
  175. //              ret    return the current time stamp.
  176. // return     :
  177. // note       : after call this function, you can pass ret->sec to  NtpTime_toDatetime to 
  178. //              get the date time.
  179. void NtpMsg_resolveCurTimeSNTP(uint8_t const * buf, NtpTime * ret);
  180. // set the first byte of NTP message
  181. // description: used to set the first byte of NTP message
  182. // parameter  : buf    the NTP message buffer.
  183. //              LI     see NTP_LI_XXX
  184. //              VN     expect NTP_VERSION
  185. //              Mode   see NTP_MODE_XXX
  186. // return     :
  187. // note       : 
  188. void NtpMsg_setFlag(NTPMSG * buf,uint8_t LI, uint8_t VN, uint8_t Mode);
  189. // NTP second to Datetime
  190. // description: used to resolve the NTP second in NTP timestamp to the human readable datetime.
  191. // parameter  : seconds    the NTP seconds.
  192. //              ret        return the resolve result.
  193. // return     :
  194. // note       : 
  195. void NtpTime_toDatetime(NtpSeconds seconds, Datetime * ret);
  197. #endif // _NTP_H

NTP.c

  1. /*
  2. ******************************************************************************************
  3. *
  4. *                              NETWORK TIME PROTOCOL MODULE
  5. *                                         NTP模块
  6. *
  7. * File : NTP.c
  8. * By   : Lin Shijun(http://blog.csdn.net/lin_strong)
  9. * Date:  2019/04/01
  10. * Version: V1.0 
  11. * History: 
  12. * NOTE(s): 
  13. ******************************************************************************************
  14. */
  16. /*
  17. *******************************************************************************************
  18. *                                       INCLUDES
  19. *******************************************************************************************
  20. */
  22. #include <string.h>
  23. #include "NTP.h"
  24. #include "NetworkLib.h"
  26. /*
  27. *******************************************************************************************
  28. *                                     CONFIGURATION 配置
  29. *******************************************************************************************
  30. */
  31. /*
  32. 00)UTC-12:00 Baker Island, Howland Island (both uninhabited)
  33. 01) UTC-11:00 American Samoa, Samoa
  34. 02) UTC-10:00 (Summer)French Polynesia (most), United States (Aleutian Islands, Hawaii)
  35. 03) UTC-09:30 Marquesas Islands
  36. 04) UTC-09:00 Gambier Islands;(Summer)United States (most of Alaska)
  37. 05) UTC-08:00 (Summer)Canada (most of British Columbia), Mexico (Baja California)
  38. 06) UTC-08:00 United States (California, most of Nevada, most of Oregon, Washington (state))
  39. 07) UTC-07:00 Mexico (Sonora), United States (Arizona); (Summer)Canada (Alberta)
  40. 08) UTC-07:00 Mexico (Chihuahua), United States (Colorado)
  41. 09) UTC-06:00 Costa Rica, El Salvador, Ecuador (Galapagos Islands), Guatemala, Honduras
  42. 10) UTC-06:00 Mexico (most), Nicaragua;(Summer)Canada (Manitoba, Saskatchewan), United States (Illinois, most of Texas)
  43. 11) UTC-05:00 Colombia, Cuba, Ecuador (continental), Haiti, Jamaica, Panama, Peru
  44. 12) UTC-05:00 (Summer)Canada (most of Ontario, most of Quebec)
  45. 13) UTC-05:00 United States (most of Florida, Georgia, Massachusetts, most of Michigan, New York, North Carolina, Ohio, Washington D.C.)
  46. 14) UTC-04:30 Venezuela
  47. 15) UTC-04:00 Bolivia, Brazil (Amazonas), Chile (continental), Dominican Republic, Canada (Nova Scotia), Paraguay,
  48. 16) UTC-04:00 Puerto Rico, Trinidad and Tobago
  49. 17) UTC-03:30 Canada (Newfoundland)
  50. 18) UTC-03:00 Argentina; (Summer) Brazil (Brasilia, Rio de Janeiro, Sao Paulo), most of Greenland, Uruguay
  51. 19) UTC-02:00 Brazil (Fernando de Noronha), South Georgia and the South Sandwich Islands
  52. 20) UTC-01:00 Portugal (Azores), Cape Verde
  53. 21) UTC±00:00 Cote d'Ivoire, Faroe Islands, Ghana, Iceland, Senegal; (Summer) Ireland, Portugal (continental and Madeira)
  54. 22) UTC±00:00 Spain (Canary Islands), Morocco, United Kingdom
  55. 23) UTC+01:00 Angola, Cameroon, Nigeria, Tunisia; (Summer)Albania, Algeria, Austria, Belgium, Bosnia and Herzegovina,
  56. 24) UTC+01:00 Spain (continental), Croatia, Czech Republic, Denmark, Germany, Hungary, Italy, Kinshasa, Kosovo,
  57. 25) UTC+01:00 Macedonia, France (metropolitan), the Netherlands, Norway, Poland, Serbia, Slovakia, Slovenia, Sweden, Switzerland
  58. 26) UTC+02:00 Libya, Egypt, Malawi, Mozambique, South Africa, Zambia, Zimbabwe, (Summer)Bulgaria, Cyprus, Estonia,
  59. 27) UTC+02:00 Finland, Greece, Israel, Jordan, Latvia, Lebanon, Lithuania, Moldova, Palestine, Romania, Syria, Turkey, Ukraine
  60. 28) UTC+03:00 Belarus, Djibouti, Eritrea, Ethiopia, Iraq, Kenya, Madagascar, Russia (Kaliningrad Oblast), Saudi Arabia,
  61. 29) UTC+03:00 South Sudan, Sudan, Somalia, South Sudan, Tanzania, Uganda, Yemen
  62. 30) UTC+03:30 (Summer)Iran
  63. 31) UTC+04:00 Armenia, Azerbaijan, Georgia, Mauritius, Oman, Russia (European), Seychelles, United Arab Emirates
  64. 32) UTC+04:30 Afghanistan
  65. 33) UTC+05:00 Kazakhstan (West), Maldives, Pakistan, Uzbekistan
  66. 34) UTC+05:30 India, Sri Lanka
  67. 35) UTC+05:45 Nepal
  68. 36) UTC+06:00 Kazakhstan (most), Bangladesh, Russia (Ural: Sverdlovsk Oblast, Chelyabinsk Oblast)
  69. 37) UTC+06:30 Cocos Islands, Myanmar
  70. 38) UTC+07:00 Jakarta, Russia (Novosibirsk Oblast), Thailand, Vietnam
  71. 39) UTC+08:00 China, Hong Kong, Russia (Krasnoyarsk Krai), Malaysia, Philippines, Singapore, Taiwan, most of Mongolia, Western Australia
  72. 40) UTC+09:00 Korea, East Timor, Russia (Irkutsk Oblast), Japan
  73. 41) UTC+09:30 Australia (Northern Territory);(Summer)Australia (South Australia))
  74. 42) UTC+10:00 Russia (Zabaykalsky Krai); (Summer)Australia (New South Wales, Queensland, Tasmania, Victoria)
  75. 43) UTC+10:30 Lord Howe Island
  76. 44) UTC+11:00 New Caledonia, Russia (Primorsky Krai), Solomon Islands
  77. 45) UTC+11:30 Norfolk Island
  78. 46) UTC+12:00 Fiji, Russia (Kamchatka Krai);(Summer)New Zealand
  79. 47) UTC+12:45 (Summer)New Zealand
  80. 48) UTC+13:00 Tonga
  81. 49) UTC+14:00 Kiribati (Line Islands)
  82. */
  83. // timezone china
  84. static const uint8_t time_zone = 39;
  86. /*
  87. *******************************************************************************************
  88. *                              LOCAL FUNCTION DECLARATION
  89. *******************************************************************************************
  90. */
  92. // get the local ntp timestamp for the standard one, depends on the timezone.
  93. static NtpSeconds _stdTimeSecToLocal(NtpSeconds sec);
  95. /*
  96. *******************************************************************************************
  97. *                                 IMPLEMENTATIONS
  98. *******************************************************************************************
  99. */
  101. uint16_t NtpMsg_initRequest(uint8_t * buf, NtpTime const * orgStamp){
  103.   NTPMSG * pMsg = (NTPMSG *)buf;
  104.   (void)memset(buf,0,sizeof(NTPMSG));
  105.   NtpMsg_setFlag(pMsg,NTP_LI_NOWARNING, NTP_VERSION, NTP_MODE_CLIENT);
  106.   if(orgStamp != NULL){
  108.     (void)NetworkStream_putUint32((uint8_t *)&pMsg->OrgStamp.sec, orgStamp->sec);
  109.     (void)NetworkStream_putUint32((uint8_t *)&pMsg->OrgStamp.frac, orgStamp->frac);
  110.   }
  111.   return sizeof(NTPMSG);
  112. }
  114. void NtpMsg_resolveCurTimeSNTP(uint8_t const * buf, NtpTime * ret){
  116.   NTPMSG const * pMsg = (NTPMSG const *)buf;
  117.   (void)NetworkStream_getUint32((uint8_t *)&pMsg->TxStamp.sec, &ret->sec);
  118.   (void)NetworkStream_getUint32((uint8_t *)&pMsg->TxStamp.frac, &ret->frac);
  119. }
  121. void NtpMsg_setFlag(NTPMSG * buf,uint8_t LI, uint8_t VN, uint8_t Mode){
  123.   *(uint8_t *)buf = (LI << 6) + ((VN & 0x07) << 3) + (Mode & 0x07);
  124. }
  126. static const uint8_t daytab[2][13] = {
  128.   {
  129.      0,31,28,31,30,31,30,31,31,30,31,30,31 },
  130.   {
  131.      0,31,29,31,30,31,30,31,31,30,31,30,31 }
  132. };
  134. void _DayLeftInAYearToMonthAndDay(uint16_t dayLeft,uint8_t isLeapYear,uint8_t * mon,uint8_t * day){
  136.   uint8_t monthCur = 1;
  137.   while(dayLeft >= daytab[isLeapYear][monthCur]){
  139.     dayLeft -= daytab[isLeapYear][monthCur];
  140.     ++monthCur;
  141.   }
  142.   *mon = monthCur;
  143.   *day = dayLeft + 1;
  144. }
  146. void NtpTime_toDatetime(NtpSeconds sec, Datetime * ret){
  148.   uint8_t isLeap;
  149.   uint32_t dayLeft;
  150.   uint16_t yearCur;
  152.   sec = _stdTimeSecToLocal(sec);
  153.   if(sec >= SECS_1900to2019){
  155.     sec -= SECS_1900to2019;
  156.     yearCur = 2019;
  157.   }else{
  159.     yearCur = EPOCH;
  160.   }
  162.   dayLeft = sec / (SECS_PERDAY);
  164.   for(;;){
  166.     isLeap = (yearCur % 400 == 0 || (yearCur % 100 != 0 && yearCur % 4 == 0));
  167.     if(dayLeft < (uint32_t)(DAYS_COMMYEAR + isLeap))
  168.       break;
  169.     dayLeft -= (uint32_t)(DAYS_COMMYEAR + isLeap);
  170.     ++yearCur;
  171.   }
  173.   ret->yy = yearCur;
  175.   _DayLeftInAYearToMonthAndDay((uint16_t)dayLeft,isLeap,&ret->mo,&ret->dd);
  176.   sec %= SECS_PERDAY;
  177.   ret->hh = (uint8_t)(sec / SECS_PERHOUR);
  178.   sec %= SECS_PERHOUR;
  179.   ret->mm = (uint8_t)(sec / SECS_PERMIN);
  180.   ret->ss = (uint8_t)(sec % SECS_PERMIN);
  181. }
  183. /*
  184. *******************************************************************************************
  185. *                              LOCAL FUNCTION IMPLEMENTATION
  186. *******************************************************************************************
  187. */
  189. static NtpSeconds _stdTimeSecToLocal(NtpSeconds sec){
  191.   switch (time_zone){
  193.   case 0:
  194.     sec -= 12 * SECS_PERHOUR;
  195.     break;
  196.   case 1:
  197.     sec -= 11 * SECS_PERHOUR;
  198.     break;
  199.   case 2:
  200.     sec -= 10 * SECS_PERHOUR;
  201.     break;
  202.   case 3:
  203.     sec -= (9 * SECS_PERHOUR+30 * SECS_PERMIN);
  204.     break;
  205.   case 4:
  206.     sec -= 9 * SECS_PERHOUR;
  207.     break;
  208.   case 5:
  209.   case 6:
  210.     sec -= 8 * SECS_PERHOUR;
  211.     break;
  212.   case 7:
  213.   case 8:
  214.     sec -= 7 * SECS_PERHOUR;
  215.     break;
  216.   case 9:
  217.   case 10:
  218.     sec -= 6 * SECS_PERHOUR;
  219.     break;
  220.   case 11:
  221.   case 12:
  222.   case 13:
  223.     sec -= 5 * SECS_PERHOUR;
  224.     break;
  225.   case 14:
  226.     sec -= (4 * SECS_PERHOUR + 30 * SECS_PERMIN);
  227.     break;
  228.   case 15:
  229.   case 16:
  230.     sec -= 4 * SECS_PERHOUR;
  231.     break;
  232.   case 17:
  233.     sec -= (3 * SECS_PERHOUR + 30 * SECS_PERMIN);
  234.     break;
  235.   case 18:
  236.     sec -= 3 * SECS_PERHOUR;
  237.     break;
  238.   case 19:
  239.     sec -= 2 * SECS_PERHOUR;
  240.     break;
  241.   case 20:
  242.     sec -= 1 * SECS_PERHOUR;
  243.     break;
  244.   case 21:
  245.   case 22:
  246.     break;
  247.   case 23:
  248.   case 24:
  249.   case 25:
  250.     sec += 1 * SECS_PERHOUR;
  251.     break;
  252.   case 26:
  253.   case 27:
  254.     sec += 2 * SECS_PERHOUR;
  255.     break;
  256.   case 28:
  257.   case 29:
  258.     sec += 3 * SECS_PERHOUR;
  259.     break;
  260.   case 30:
  261.     sec += (3 * SECS_PERHOUR + 30 * SECS_PERMIN);
  262.     break;
  263.   case 31:
  264.     sec += 4 * SECS_PERHOUR;
  265.     break;
  266.   case 32:
  267.     sec += (4 * SECS_PERHOUR + 30 * SECS_PERMIN);
  268.     break;
  269.   case 33:
  270.     sec += 5 * SECS_PERHOUR;
  271.     break;
  272.   case 34:
  273.     sec += (5 * SECS_PERHOUR + 30 * SECS_PERMIN);
  274.     break;
  275.   case 35:
  276.     sec += (5 * SECS_PERHOUR + 45 * SECS_PERMIN);
  277.     break;
  278.   case 36:
  279.     sec += 6 * SECS_PERHOUR;
  280.     break;
  281.   case 37:
  282.     sec += (6 * SECS_PERHOUR + 30 * SECS_PERMIN);
  283.     break;
  284.   case 38:
  285.     sec += 7 * SECS_PERHOUR;
  286.     break;
  287.   case 39:
  288.     sec += 8 * SECS_PERHOUR;
  289.     break;
  290.   case 40:
  291.     sec += 9 * SECS_PERHOUR;
  292.     break;
  293.   case 41:
  294.     sec += (9 * SECS_PERHOUR + 30 * SECS_PERMIN);
  295.     break;
  296.   case 42:
  297.     sec += 10 * SECS_PERHOUR;
  298.     break;
  299.   case 43:
  300.     sec += (10 * SECS_PERHOUR + 30 * SECS_PERMIN);
  301.     break;
  302.   case 44:
  303.     sec += 11 * SECS_PERHOUR;
  304.     break;
  305.   case 45:
  306.     sec += (11 * SECS_PERHOUR + 30 * SECS_PERMIN);
  307.     break;
  308.   case 46:
  309.     sec += 12 * SECS_PERHOUR;
  310.     break;
  311.   case 47:
  312.     sec += (12 * SECS_PERHOUR + 45 * SECS_PERMIN);
  313.     break;
  314.   case 48:
  315.     sec += 13 * SECS_PERHOUR;
  316.     break;
  317.   case 49:
  318.     sec += 14 * SECS_PERHOUR;
  319.     break;
  320.   }
  321.   return sec;
  322. }

NetworkLib.h

  1. #ifndef _NETWORK_LIB_H
  2. #define _NETWORK_LIB_H
  4. #include <stdint.h>
  7. // to help produce better code
  8. // #define _CPU_BIGENDIAN
  9. // or 
  10. // #define _CPU_LITTLEENDIAN
  12. // NetworkStream_getUintXX
  13. // description: get uintXX from the network stream ns and return the pointer to the
  14. //              next position in the stream.
  15. // parameter  : ns    the stream to get uintXX.
  16. //              ret   return the result through the pointer.
  17. // return     : the pointer to the next position in the stream.
  18. // note       : the interface will handle the byte order for you.
  19. uint8_t const * NetworkStream_getUint16(uint8_t const * ns,uint16_t * ret);
  20. uint8_t const * NetworkStream_getUint32(uint8_t const * ns,uint32_t * ret);
  21. // NetworkStream_putUintXX
  22. // description: put uintXX to the network stream ns and return the pointer to the
  23. //              next position in the stream.
  24. // parameter  : ns    the stream to get uintXX.
  25. //              val   the value to be put.
  26. // return     : the pointer to the next position in the stream.
  27. // note       : the interface will handle the byte order for you.
  28. uint8_t * NetworkStream_putUint16(uint8_t * ns,uint16_t val);
  29. uint8_t * NetworkStream_putUint32(uint8_t * ns,uint32_t val);
  30. // whether the cpu is big endian system.
  31. // return     : 1  if is big endian.
  32. //              0  if is little endian.
  33. int isBigEndianSys(void);
  35. #ifdef _CPU_BIGENDIAN
  36. #define htonl(h)   (h)
  37. #define htons(h)   (h)
  38. #define ntohl(n)   (n)
  39. #define ntohs(n)   (n)
  40. #else
  41. #define htonl(h)   NetworkLib_htonl(h)
  42. #define htons(h)   NetworkLib_htons(h)
  43. #define ntohl(n)   NetworkLib_ntohl(n)
  44. #define ntohs(n)   NetworkLib_ntohs(n)
  45. #endif
  47. uint32_t NetworkLib_htonl(uint32_t hostlong);
  48. uint16_t NetworkLib_htons(uint16_t hostshort);
  49. uint32_t NetworkLib_ntohl(uint32_t netlong);
  50. uint16_t NetworkLib_ntohs(uint16_t netshort);
  52. #endif

NetworkLib.c

  1. #include <stdio.h>
  2. #include "NetworkLib.h"
  4. #ifdef _CPU_BIGENDIAN
  5. #define _isBigEndianSys()  1
  6. #endif
  8. #ifdef _CPU_LITTLEENDIAN
  9. #define _isBigEndianSys()  0
  10. #endif
  12. #define BigLittleSwap16(A)  ((((uint16_t)(A) & 0xff00) >> 8) | \
  13.                             (((uint16_t)(A) & 0x00ff) << 8))
  15. #define BigLittleSwap32(A)  ((((uint32_t)(A) & 0xff000000) >> 24) | \
  16.                             (((uint32_t)(A) & 0x00ff0000) >> 8) | \
  17.                             (((uint32_t)(A) & 0x0000ff00) << 8) | \
  18.                             (((uint32_t)(A) & 0x000000ff) << 24))
  20. #ifndef _isBigEndianSys
  21. #define _isBigEndianSys()  (*(uint8_t *)&_flag == 0)
  22. static const uint16_t _flag = 1;
  23. #endif
  25. int isBigEndianSys(void){
  27.   return _isBigEndianSys();
  28. }
  30. uint8_t const * NetworkStream_getUint16(uint8_t const * ns,uint16_t * ret){
  32.   if(_isBigEndianSys()){
  34.     * ret = *(uint16_t *)ns;
  35.   }else{
  37.     ((uint8_t *)ret)[0] = ns[1];
  38.     ((uint8_t *)ret)[1] = ns[0];
  39.   }
  40.   return ns + sizeof(uint16_t);
  41. }
  43. uint8_t const * NetworkStream_getUint32(uint8_t const * ns,uint32_t * ret){
  45.   if(_isBigEndianSys()){
  47.     * ret = *(uint32_t *)ns;
  48.   }else{
  50.     ((uint8_t *)ret)[0] = ns[3];
  51.     ((uint8_t *)ret)[1] = ns[2];
  52.     ((uint8_t *)ret)[2] = ns[1];
  53.     ((uint8_t *)ret)[3] = ns[0];
  54.   }
  55.   return ns + sizeof(uint32_t);
  56. }
  58. uint8_t * NetworkStream_putUint16(uint8_t * ns,uint16_t val){
  60.   if(_isBigEndianSys()){
  62.     *(uint16_t *)ns = val;
  63.   }else{
  65.     ns[0] = ((uint8_t *)&val)[1];
  66.     ns[1] = ((uint8_t *)&val)[0];
  67.   }
  68.   return ns + sizeof(uint16_t);
  69. }
  70. uint8_t * NetworkStream_putUint32(uint8_t * ns,uint32_t val){
  72.   if(_isBigEndianSys()){
  74.     *(uint32_t *)ns = val;
  75.   }else{
  77.     ns[0] = ((uint8_t *)&val)[3];
  78.     ns[1] = ((uint8_t *)&val)[2];
  79.     ns[2] = ((uint8_t *)&val)[1];
  80.     ns[3] = ((uint8_t *)&val)[0];
  81.   }
  82.   return ns + sizeof(uint32_t);
  83. }
  85. uint32_t NetworkLib_htonl(uint32_t hostlong){
  87.   if(_isBigEndianSys()){
  89.     return hostlong;
  90.   }else{
  92.     return BigLittleSwap32(hostlong);
  93.   }
  94. }
  96. uint16_t NetworkLib_htons(uint16_t hostshort){
  98.   if(_isBigEndianSys()){
  100.     return hostshort;
  101.   }else{
  103.     return BigLittleSwap16(hostshort);
  104.   }
  105. }
  107. uint32_t NetworkLib_ntohl(uint32_t netlong){
  109.   if(_isBigEndianSys()){
  111.     return netlong;
  112.   }else{
  114.     return BigLittleSwap32(netlong);
  115.   }
  116. }
  117. uint16_t NetworkLib_ntohs(uint16_t netshort){
  119.   if(_isBigEndianSys()){
  121.     return netshort;
  122.   }else{
  124.     return BigLittleSwap16(netshort);
  125.   }
  126. }

NTPTimeHelper.h

  1. /*
  2. *******************************************************************************************
  3. *
  4. *                                   NTP TIME HELPER MODULE
  5. *
  6. * File : NTPTimeHelper.h
  7. * By   : Lin Shijun(https://blog.csdn.net/lin_strong)
  8. * Date:  2019/09/26
  9. * version: V1.0
  10. * History: 
  11. * note   : the convert interfaces for NTP time.
  12. *********************************************************************************************
  13. */
  14. #ifndef _NTPTimeHelper_H
  15. #define _NTPTimeHelper_H
  17. #include "NTP.h"
  18. #include <time.h>
  19. typedef struct POSIXTIME_STRUCT{
  21.    time_t sec;     //秒
  22.    uint32_t usec;  //微秒
  23. } PosixTime;
  25. void NtpTimeToPosixTime(PosixTime *dst, const NtpTime *src);
  26. void PosixTimeToNtpTime(NtpTime *dst, const PosixTime *src);
  28. #endif

NTPTimeHelper.c

  1. /*
  2. *******************************************************************************************
  3. *
  4. *                                   NTP TIME HELPER MODULE
  5. *
  6. * File : NTPTimeHelper.c
  7. * By   : Lin Shijun(https://blog.csdn.net/lin_strong)
  8. * Date:  2019/09/26
  9. * version: V1.0
  10. * History: 
  11. * note   : the convert interfaces for NTP time.
  12. *********************************************************************************************
  13. */
  14. #include "NTPTimeHelper.h"
  16. #pragma MESSAGE DISABLE C5919
  17. void NtpTimeToPosixTime(PosixTime *dst, const NtpTime *src){
  19.   int valid;
  20.   if(dst == NULL || src == NULL)
  21.     return;
  22.   valid = (src->sec >= SECS_1900to1970);
  23.   dst->sec = (valid)? src->sec - SECS_1900to1970: 0;
  24.   // 1000000/0x100000000 = 0.0002328306436538696...
  25.   dst->usec = (valid)? (uint32_t)((double)src->frac * (double)0.0002328306436538696): 0;
  26. }
  28. void PosixTimeToNtpTime(NtpTime *dst, const PosixTime *src){
  30.   int valid;
  31.   if(dst == NULL || src == NULL)
  32.     return;
  33.   valid = (src->sec <= (0xFFFFFFFF - SECS_1900to1970));
  34.   dst->sec  = (valid)? src->sec + SECS_1900to1970: 0;
  35.   // 0x100000000/1000000 = 4294.967296
  36.   dst->frac = (valid)?(uint32_t)((double)src->usec * 4294.967296): 0;
  37. }

示例

使用起来就是这句话：
初始化一个请求包用UDP发往NTP服务器对应端口，然后等待答复包并解析出结果。

以下示例基于W5500的官方io库+uCOSII，已略去如创建任务、初始化网络等不重要的代码：

  1. #include "NTP.h"
  2. #define UDP_SOCKET 5
  4. static uint8_t NtpServerIP[4] = {
  5.     NTPSERVER_IP_CHINA};
  6. static uint8_t udpBuf[200];
  8. static void ConsoleTask (void *p_arg){
  10.   ……
  11.   for(;;){
  13.     c = (uint8_t)getchar();
  14.     if(c == 'n'){
  16.       (void)NtpMsg_initRequest(udpBuf,NULL);
  17.       (void)printf("Send Ntp request\r\n");
  18.       (void)sendto(UDP_SOCKET,udpBuf,sizeof(NTPMSG),NtpServerIP,NTP_PORT);
  19.     }
  20.   }
  21. }
  23. static void UdpRxTask(void *p_arg){
  25.   uint8_t dip[4];
  26.   uint16_t dport;
  27.   int32_t len;
  28.   static Datetime dt;
  29.   NtpTime t;
  30.   (void)p_arg;
  31.   for(;;){
  33.     // 假设网络已经初始化完成 
  34.     ……
  35.     (void)printf("UDPRx task initing socket.\r\n");
  36.     switch(socket(UDP_SOCKET,Sn_MR_UDP,MDNS_PORT,0)){
  38.       case SOCKERR_SOCKINIT:
  39.         (void)printf("UDPRx init socket fail, network not ready.\r\n");
  40.         (void)OSTimeDlyHMSM(0,0,2,0);
  41.         continue;
  42.       case UDP_SOCKET:
  43.         (void)printf("UDPRx init socket success.\r\n");
  44.         break;
  45.       default:
  46.         (void)printf("UDPRx init socket fail, unknown error.\r\n");
  47.         (void)OSTimeDlyHMSM(0,0,2,0);
  48.         continue;
  49.     }
  50.     for(;;){
  52.       (void)printf("UDPRx task is wating for data!\r\n");
  53.       len = recvfrom(UDP_SOCKET,udpBuf,sizeof(udpBuf),dip,&dport);
  54.       if(len > 0){
  56.          (void)printf("UDPRx received data from %u.%u.%u.%u:%u\r\n",dip[0], dip[1], dip[2], dip[3],dport);
  57.         if(len >= sizeof(NTPMSG) && dport == NTP_PORT){
  59.           printf("NTP packet.\r\n");
  60.           NtpMsg_resolveCurTimeSNTP((NTPMSG *)udpBuf, &t);
  61.           NtpTime_toDatetime(t.sec,&dt);
  62.           printf("%4u-%2u-%2u %2u:%2u:%2u\r\n",dt.yy,dt.mo,dt.dd,dt.hh,dt.mm,dt.ss);
  63.         }
  64.       }else if(len < 0){
  66.         (void)printf("UDPRx found socket err.\r\n");
  67.         break;
  68.       }
  69.     }
  70.   }
  71. }

因为是独立的模块，你可以根据自己的需求自己决定如何整合NTP功能至项目中，比如，其实可以多个基于UDP的功能(比如DNS，其实我也写了，可能后面会发)都使用同一个UDP SOCKET，通过对方的IP和/或端口号来区分是哪个功能。

测试结果：
在这里插入图片描述至于后面那个TimeHelper，则是用于NTP时间戳和Unix时间戳互转的接口。当你需要使用time.h时自然明白它的作用了。就不示例了。

更新历史

2019/05/29 第一版
2019/10/02 增加NTPTimeHelper模块。并更新了NetworkLib，增加了点功能。

发表评论

表情：
评论列表 （有 0 条评论，438人围观）

还没有评论，来说两句吧...

相关阅读