[参考译文] EK-TM4C1294XL：需要示例代码

请从 www.ti.com/.../SW-EK-TM4C129EXL 下载 SW-SECURE-IOT 演示软件包。

另请阅读此帖子。 e2e.ti.com/.../2017227

我无法在其中获取 SW-SECURE-IOT 演示示示示例.. 我也下载了它。 请为我提供相关的示例代码  

谢谢你

我安装了相同的东西、但没有 Keil 版本的代码。 只有文本文件。

谢谢你

我找到了 Keil 的代码、但无法从 UDP 获取回调。 请尝试解决该问题
谢谢你

/**
*@文件
* SNTP 客户端模块
*
*


#include "lwip/opt.h"

#include "ntp.h"

#include "lwip/timers.h"
#include "lwip/udp.h"
#include "lwip/dns.h"
#include "lwip/ip_addr.h"
#include "lwip/pbuf.h"

#include
#include

extern struct TM RTC；

uint8_t ntp_send_cmnd_set；

extern tConfigParameters g_sParameters；

#if LWIP_UDP

/**这是用于套接字或原始 API 的简单"SNTP 客户端。
*这是 RFC 4330中指定的 SNTPv4的最小实施。
*
*有关某些公共 NTP 服务器的列表，请参见以下链接：
* support.ntp.org/.../NTPPoolServers
*
*@待办事项：
*-在运行时设置/更改服务器
*-完成 SNTP_CHECK_RESPONSE 检查3和4
*-支持广播/多播模式？
*


#define SNTP Server_DNS 0

/**决定是为套接字还是原始 API 构建 SNTP
*套接字 API SNTP 客户端是一种极小的实现、但不是
*完全符合 SNTPv4 RFC，特别是关于服务器负载和错误
*正在进行。 *
#ifndef SNTP 插槽
#define SNTP 套接字 0
#endif

#if SNTP_SOCKET
#include "lwip/sockets.h"
#endif

/**
* SNTP 调试：启用 SNTP 调试。
*
#ifndef SNTP 调试
#define SNTP_DEBUG LWIP_DBG_OFF
#endif

/** SNTP 服务器端口*/
#ifndef SNTP 端口
#define SNTP 端口 123.
#endif

/**将其设置为1，以允许 SNTP 服务器_address 是 DNS 名称*/
#ifndef SNTP 服务器_DNS
#define SNTP 服务器_DNS 0
#endif

/**将其设置为1以支持多台服务器*/
#ifndef SNTP 支持_多服务器
#define SNTP 支持_多服务器0
#endif

/** SNTP 服务器地址：
*-作为"u32_t"格式的 IPv4地址
*-如果 SNTP Server_DNS 设置为1、则作为 DNS 名称
*可能包含多个服务器名称(例如"pool.ntp.org","second.time.server")
*
#ifndef SNTP 服务器_ADDRESS
#if Sntp_Server_dns
#define Sntp_Server_address " pool.ntp.org "
其他
#define Sntp_Server_address 128.138.140.44"
#endif
#endif

/**完整性检查：
*将其定义为
*- 0关闭完整性检查(默认；较小代码)
*->= 1以检查响应数据包的地址和端口、以确保
* 响应来自我们向其发送请求的服务器。
*->=2、以检查返回的 originate Timestamp 与发送时间戳之间的关系
* 发送到服务器(以确保对较旧请求的响应)。
*->= 3 @TODO：如果 LI、Stratum 或 Transmit Timestamp 中有任何一个、请放弃回复
* 字段为0或模式字段不为4 (单播)或5 (广播)。
*->= 4 @TODO：检查根延迟和根分散字段是否各有
* 大于或等于0且小于无穷大、其中无穷大为
* 现在是一个舒适的数字、就像一秒。 此检查避免使用
* 同步源已过期很长时间的服务器。
*
#ifndef SNTP 检查_响应
#define SNTP CHECK_RESPONSE 2.
#endif

/**根据 RFC，这应是随机延迟
*在1到5分钟(以毫秒为单位)之间、以防止负载峰值。
*这可以定义为随机生成函数、
*它必须以毫秒为单位返回延迟 u32_t
*默认情况下已关闭。
*
#ifndef SNTP_STARTUP_DELAY
#define SNTP_STARTUP_DELAY 1
#endif

/** SNTP 接收超时-以毫秒为单位
*也用作重试超时-不应太低。
*默认值为3秒。
*
#ifndef SNTP_RECV_TIMEOUT
#define Sntp_RECV_TIMEOUT 5000
#endif

/** SNTP 更新延迟-以毫秒为单位
*默认为1小时。
*
#ifndef SNTP 更新延迟
#define Sntp_update_delay 900000 //3600000
#endif
#if (SNTP 更新延迟< 15000)&&！SNTP_suppress_delay_check
错误"SNTPv4 RFC 4330强制要求最短更新时间为15秒！"
#endif

/** SNTP 宏更改系统时间和/或更新 RTC 时钟*/
#ifndef SNTP_SET_SYSTEM_TIME
#define SNTP_SET_SYSTEM_TIME (sec)((void) sec)
#endif

/** SNTP 宏可更改系统时间，包括微秒*/
#ifdef SNTP_SET_SYSTEM_TIME_US
#define SNTP CAL_TIME_US 1
#define SNTP_RECEIVE_TIME_SIZE 2.
其他
#define SNTP_SET_SYSTEM_TIME_US (秒、us)
#define SNTP CAL_TIME_US 0
#define SNTP_RECEIVE_TIME_SIZE 1
#endif

/**用于获取系统时间的 SNTP 宏，与 SNTP_CHECK_RESPONSE >=2配合使用
*发送请求并进行比较以响应。
*
#ifndef SNTP_GET_SYSTEM_TIME
#define SNTP_GET_SYSTEM_TIME (秒、us) 执行｛(秒)= 0；(us)= 0；｝while (0)
#endif

/**如果响应，则默认重试超时(以毫秒为单位)
接收到的*无效。
*这在每次重试时加倍、直到达到 SNTP_RETRY 超时_MAX。
*
#ifndef SNTP 重试_超时
#define Sntp_retry_TIMEOUT Sntp_RECV_TIMEOUT
#endif

/**最大重试超时(以毫秒为单位)。 *
#ifndef SNTP 重试_超时_MAX
#define SNTP_RETRY TIMEOUT_MAX (SNTP 重试_超时* 10)
#endif

/**增加每次发送重试的重试超时时间
*默认为 on 以符合 RFC。
*
#ifndef SNTP 重试_超时_EXP
#define SNTP_RETRY TIMEOUT_EXP 1
#endif

/*此文件的各种调试级别*/
#define SNTP_DEBUG_TRACE (SNTP_DEBUG | LWIP_DBG_TRACE)
#define SNTP_DEBUG_STATE (SNTP_DEBUG | LWIP_DBG_STATE)
#define SNTP_DEBUG_WARN (SNTP_DEBUG | LWIP_DBG_LEVEL_WARNING)
#define SNTP_DEBUG_WARN_STATE (SNTP_DEBUG | LWIP_DBG_LEVEL_WARNING | LWIP_DBG_STATE)
#define Sntp_debug_serious (SNTP_DEBUG | LWIP_DBG_LEVEL_SEARD)

#define SNTP_ERR_KOD 1

/* SNTP 协议定义*/
#define SNTP_MSG_LEN 48

#define SNTP_OFFSET_LI_VN_MODE 0
#define SNTP_LI_MASK 0xC0
#define SNTP_LI_NO_WARNING 0x00
#define SNTP_LI_LAST_MINUE_61_SEC 0x01
#define SNTP_LI_LAST_MINUE_59_SEC 0x02
#define SSTP_LI_ALARM_Condition 0x03 /*(时钟未同步)*/

#define SNTP_VERSION_MASK 0x38
#define SNTP 版本 (4/* NTP 版本4*/<<3)

#define SNTP_MODE_MASK 0x07
#define SNTP MODE_CLIENT 0x03
#define SNTP MODE_SERVER 0x04
#define SNTP_MODE_broadcast 0x05

#define SNTP_OFFSET_STRAUM 1
#define SNTP_STRAUM_KOD 0x00

#define SNTP_OFFSET_original_time 24.
#define SNTP_OFFSET_RECEIVE_TIME 32.
#define SNTP_OFFSET_Transmit time_40

/* 1900到1970之间的秒数*/
#define DIFF_SEC_1900_1970 (2208988800UL)

/**
* SNTP 数据包格式(不带可选字段)
*时间戳编码为64位：
*-自1970年1月1日00：00以来32位秒
*- 32位秒小数(0填充)
*如果设置了秒部分中的 MSB、则基于秒
*在2036年2月7日06：28：16日。
*
#ifdef Pack_struct_use_includes
#包括"arch/bpstruct.h"
#endif
PACK_STRUCT_BEGIN
struct sntp_msg｛
PACK_STRUCT_FIELD (u8_t li_vn_mode)；
PACK_STRUCT_FIELD (u8_t 平流层)；
PACK_STRUCT_FIELD (u8_t 投票)；
PACK_STRUCT_FIELD (u8_t 精度)；
PACK_STRUCT_FIELD (u32_t root_delay)；
PACK_STRUCT_FIELD (u32_t 根分散)；
PACK_STRUCT_FIELD (u32_t 参考标识符)；
PACK_STRUCT_FIELD (u32_t 参考时间戳[2])；
PACK_STRUCT_FIELD (u32_t original_timestamp[2])；
PACK_STRUCT_FIELD (u32_t 接收时间戳[2])；
PACK_STRUCT_FIELD (u32_t Transmit _timestamp[2])；
} PACK_STRUCT_STRUCT;
PACK_STRUCT_END
#ifdef Pack_struct_use_includes
#包括"arch/epstruct.h"
#endif




/*函数原型*/
静态空 SNTP 请求(空*arg)；

/** SNTP 客户端使用的 UDP PCB */
struct udp_pcb* ntp_pcb；
/**服务器的地址*/
静态 char* SNTP 服务器地址[]=｛SNTP 服务器地址｝；
#if SNTP_support_multiple_servers
/**当前使用的服务器(初始化为0)*/
静态 u8_t SNTP 当前服务器；
静态 u8_t SNTP num_servers = sizeof (SNTP 服务器_地址)/sizeof (char*)；
#else /* ntp_support_multiple_servers */
#define SNTP CURRENT_SERVER 0
#endif /* ntp_support_multiple_servers */

#if SNTP_RETRY 超时_EXP
#define SNTP_RESET_RETRY () SNTP_RETRY 超时= SNTP_RETRY 超时
/**重试时间，用 SNTP 重试_TIMEOUT 初始化，每次重试时加倍。 *
静态 u32_t SNTP 重试_超时；
#else /* SNTP 重试_超时_EXP */
#define SNTP RESET_RETRY 超时()
#define SNTP_RETRY SNTP_TIMEOUT SNTP_RETRY 超时
#endif // SNTP_RETRY 超时_EXP */

#if SNTP_CHECK_RESPONSE >=1.
/**保存最后一个服务器地址以与响应进行比较*/
静态 IP_addr_t SNTP 最后服务器地址；
#endif /* SNTP CHECK_RESPONSE >=1 */

#if SNTP_CHECK_RESPONSE >=2.
/**保存发送的最后一个时间戳(由服务器发回)
*与响应中的*/进行比较
静态 u32_t SNTP 上一步_时间戳_seted[2]；
#endif /* SNTP CHECK_RESPONSE >=2 */

/**
*已接收时间戳的 SNTP 处理
*
静态空
SNTP 过程(u32_t *接收_时间戳)
｛

/*将 SNTP 时间(基于1900)转换为 UNIX GMT 时间(基于1970)
*@TODO：如果 MSB 为1、则 SNTP 时间基于2036！
*
time_t =(ntohl (receive_timestamp[0])- DIFF_SEC_1900_1970)；

memcpy (&RTC、localtime (&t)、sizeof (struct tm))；

HibernateCalendarSet (&RTC)；


UARTprintf("******** time_t：%x **** \r\n"、t)；

#if SNTP_CAL_TIME_US
u32_t us = ntohl (receive_timestamp[1])/ 4295；
sntp_set_system_time_us (t、us)；
/*显示从 GMT 时间开始的本地时间*/
LWIP_DEBUGF (SNTP_DEBUG_TRACE、("SNTP_Process：%s、%"U32_F" us"、ctime (&t)、us))；

#else /* SNTP CAL_TIME_US */

/*更改系统时间和/或更新 RTC 时钟*/
sntp_set_system_time (t)；
/*显示从 GMT 时间开始的本地时间*/
LWIP_DEBUGF (SNTP 调试跟踪、("SNTP_Process：%s"、ctim（&t)))；
#endif /* SNTP CAL_TIME_US */
｝

/**
*初始化要发送到服务器的请求结构。
*
无效
SNTP 初始化请求(结构 SNTP_msg *请求)
｛
memset (req、0、SNTP_MSG_LEN)；
REQ->LI_vn_MODE = SNTP_LI_NO_WARNING | SNTP_VERSION | SNTP_MODE_CLIENT；

#if SNTP_CHECK_RESPONSE >=2.
｛
u32_t SNTP_TIME_sec、SNTP_TIME_us；
/*填写传输时间戳并将其保存在'ntp_last_timestamp_sent '中*/
sntp_get_system_time (sntp_time_sec、sntp_time_us)；
SNTP_LAST_TIMESTAMP_SENT [0]= htonl (SNTP_TIME_sec + DIFF_SEC_1900_1970)；
REQ->Transmit _TIMESTAMP[0]= SNTP_LAST_TIMESTAMP_SENT [0]；
//我们发送/保存我们而不是小数以加快速度... *
SNTP_LAST_TIMESTAMP_SENT [1]= htonl (SNTP_TIME_us)；
REQ->Transmit TIMESTAMP[1]= SNTP_LAST_TIMESTAMP_SENT [1]；
｝
#endif /* SNTP CHECK_RESPONSE >=2 */
｝

#if SNTP_SOCKET

/**
*通过套接字发送 SNTP 请求。
*这是一个非常小的实施方案，并不完全符合
*发送到 SNTPv4 RFC，特别是关于服务器加载和错误处理。
*
静态空
SNTP 请求(空*arg)
｛
内部 袜子；
struct sockaddr_in local；
struct sockaddr_in to；
内部 托伦；
内部 尺寸；
内部 超时；
struct sntp_msg sntpsg；
ip_addr_t SNTP 服务器地址；

LWIP_unused_arg (arg)；

/*如果我们有有效的 SNTP 服务器地址... *
if (ipaddr_aton (SNTP 服务器地址、&Sntp_server_address))｛
/*创建新套接字*/
sock = lwip_socket (AF_iNet、SOCK_DGRAM、0)；
if (sock >= 0)｛
/*准备本地地址*/
memset (局部、0、sizeof (局部))；
local.sin 系列 = AF_iNet；
local.sin 端口 = PP_HTONS (INADDR_ANY)；
local.sin_addr.s_addr = PP_HTONL (INADDR_ANY)；

/*绑定到本地地址*/
if (lwip_bind (sock、(struct sockaddr *)&local、sizeof (local)= 0)｛
/*设置 recv 超时*/
超时= SNTP RECV_TIMEOUT；
lwip_setsockopt (sock、SOL_socket、SO_RCVTIMEO、(char *)&timeout、sizeof (timeout))；

/*准备 SNTP 请求*/
SNTP 初始化请求(&sntpsg)；

/*准备 SNTP 服务器地址*/
memset (&to、0、sizeof (to))；
更改为.sin 系列 = AF_iNet；
TO.SIN_PORT = PP_HTONS (SNTP 端口)；
iNet_addr_from _ipaddr (&to .sin addr、&Sntp_server_address)；

uint32_t ind = 0；

for (ind = 0；ind < 48；ind++)
UARTprintf ("%x "、sntpsg[ind])；

/*将 SNTP 请求发送到服务器*/
if (lwip_sendto (sock、&sntpsg、SNTP MSG_LEN、0、(struct sockaddr *)&to、 sizeof (to)>= 0)｛
/*接收 SNTP 服务器响应*/
tolen = sizeof (to)；
size = lwip_recvfrom (sock、&sntpsg、sntp_msg_LEN、0、(struct sockaddr *)&to、 (socklen_t *)&tolen)；
/*如果响应大小良好*/
if (size == SNTP MSG_LEN)｛
/*如果这是 SNTP 响应... *
if ((((sntpsg.li_vn_mode 和 sntp_mode_mask)== sntp_mode_Server)||
(((sntpmsg.li_vn_mode 和 sntp_mode_mask)== sntp_mode_broadcast))｛
/*进行时间处理*/
SNTP 过程(sntpsg.receive_timestamp)；
｝否则｛
LWIP_DEBUGF (SNTP_DEBUG_WARN、("SNTP_REQUEST：非响应帧代码\n")；
｝
｝
｝否则｛
LWIP_DEBUGF (SNTP_DEBUG_WARN、("SNTP_REQUEST：NOT sendTO=%i\n"、errno))；
｝
｝
/*关闭套接字*/
闭袋(袜子)；
｝
｝
｝



/**
* SNTP 线程
*
静态空
sntp_thread (void *arg)
｛
LWIP_unused_arg (arg)；
while (1)｛
SNTP_REQUEST (空)；
SYS_mSLEEP (SNTP 更新_延迟)；
｝
｝

/**
*使用套接字时初始化此模块
*
无效
SNTP_INIT (空)
｛
SYS_THREAD_NEW ("SNTP_THREAD"、SNTP_THread、NULL、DEFAULT_THREAD_STACKSIZE、DEFAULT_THREAD_PRIO)；
｝

#else /* SNTP 套接字*/

/**
*重试：发送新请求(并增加重试超时)。
*
*@未使用 param arg (仅在符合 sys_timeout 时才需要)
*
静态空
SNTP 重试(void* arg)
｛
LWIP_unused_arg (arg)；

LWIP_DEBUGF (SNTP_DEBUG_STATE、("SNTP_RETRY：下一个请求将在%"U32_F" ms"中发送、\n"、
SNTP 重试_超时))；

/*设置计时器以发送重试并增加重试延迟*/
SYS_TIMEOUT (SNTP_RETRY、SNTP_REQUEST、NULL)；

#if SNTP_RETRY 超时_EXP
｛
u32_t new_retry_timeout；
/*增加下次重试的超时*/
new_retry_timeout = SNTP 重试_超时<< 1；
/*限制为最大超时并防止溢出*/
if ((new_retry_timeout <= SNTP 重试_超时_MAX)&&
(new_retry_timeout > SNTP_retry_timeout)｛
SNTP 重试_超时= NEW _RETRY 超时；
｝
｝
#endif // SNTP_RETRY 超时_EXP */
｝

#if SNTP_support_multiple_servers
/**
*如果收到 Kiss-of－death (或另一个数据包解析错误)，
*尝试下一台服务器或重试当前服务器并增加重试次数
*如果只有一台服务器可用，则超时。
*
*@未使用 param arg (仅在符合 sys_timeout 时才需要)
*
静态空
sntp_try_next 服务器(void* arg)
｛
LWIP_unused_arg (arg)；

if (SNTP num_servers > 1)｛
/*新服务器：重置重试超时*/
sntp_reset_retry_timeout ()；
SNTP 当前服务器++；
if (SNTP 当前服务器>= SNTP nnum_servers)｛
SNTP 当前服务器= 0；
｝
LWIP_DEBUGF (SNTP 调试状态、("SNTP 尝试下一个服务器：向服务器发送请求%"U16_F")、
(u16_t) SNTP 当前服务器)；
/*立即向下一台服务器发送请求*/
SNTP_REQUEST (空)；
｝否则｛
SNTP_RETRY (空)；
｝
｝
#else /* ntp_support_multiple_servers */
/*如果仅支持一台服务器，则始终在出现错误时重试*/
#define SNTP_Try 下一个服务器 SNTP 重试
#endif /* ntp_support_multiple_servers */

针对 SNTP PCB 的/** UDP recv 回调*/
静态空
sntp_recv (void *arg、struct udp_pcb* pcb、struct pbuf *p、ip_addr_t *addr、u16_t port)
｛
U8_t 模式；
U8_t 平流；
u32_t 接收时间戳[SNTP 接收时间大小]；
ERR_t 错误；

LWIP_unused_arg (arg)；
LWIP_Unused_ARG (PCB)；

接收到的数据包：停止重试超时*/
SYS_unTIMEOUT (SNTP_Try 下一个服务器、空)；
SYS_unTIMEOUT (SNTP_REQUEST、NULL)；

ERR = ERR_ARG；
#if SNTP_CHECK_RESPONSE >=1.
/*检查服务器地址和端口*/
if (ip_addr_cmp (addr、&sntp_last_server_address)&&
(端口=SNTP_PORT)
#else /* SNTP CHECK_RESPONSE >=1 */
LWIP_unused_arG (addr)；
LWIP_Unused_ARG (端口)；
#endif /* SNTP CHECK_RESPONSE >=1 */
｛
/*处理响应*/
if (p->tot_len =SNTP_MSG_LEN)｛
pbuf_copy_partial (p、&mode、1、SNTP offset_LI_VN_mode)；
MODE &= SNTP_MODE_MASK；
/*如果这是 SNTP 响应... *
if ((mode == SNTP mode_Server)||
(MODE = SNTP_MODE_broadcast))｛
pbuf_copy_partial (p、&stratum、1、sntp_offset_stratum)；
if (st和平 流== SNTP 平流_KOD)｛
/* Kiss-of -death 数据包。 使用另一台服务器或增加 update_delay。 *
ERR = SNTP_ERR_KOD；
LWIP_DEBUGF (SNTP_DEBUG_STATE、("SNTP_REV：接收到的 Kiss-of -death)\n");
｝否则｛
#if SNTP_CHECK_RESPONSE >=2.
/*对照 SNTP_LAST_TIMESTAMP_SENT *检查 original_timestamp
u32_t original_timestamp[2]；
pbuf_copy_partial (p、&original_timestamp、8、SNTP_offset_original_time)；
如果((original_timestamp[0]！= SNTP 最后_时间戳_sent [0])||
(original_timestamp[1]！= SNTP_LAST_TIMESTAMP_SENT [1])
｛
LWIP_DEBUGF (SNTP_DEBUG_WARN、("SNTP_RECOV：响应中的无效时间戳\n)；
｝否则
#endif /* SNTP CHECK_RESPONSE >=2 */
/*@TODO：在此处添加 SNTP_CHECK_RESPONSE 的代码>=3和>=4 */
｛
/*正确答案*/
ERR = ERR_OK；
pbuf_copy_partial (p、&receive_timestamp、sntp_receive_time_size * 4、sntp_offset_receive_time)；
｝
｝
｝否则｛
LWIP_DEBUGF (SNTP_DEBUG_WARN、("SNTP_recv：响应中的无效模式：%"U16_F"\n"、(U16_t)模式)；
｝
｝否则｛
LWIP_DEBUGF (SNTP DEBUG_WARN、("SNTP 恢复：无效数据包长度：%"U16_F"\n"、p->t_len)；
｝
｝
pbuf_free (p)；
如果(err =ERR_OK)｛
/*正确响应，重置重试超时*/
sntp_reset_retry_timeout ()；

SNTP 过程(接收_时间戳)；

/*为下一个请求设置超时*/
SYS_TIMEOUT (((u32_t) SNTP_UPDATE_DELAY、SNTP_REQUEST、NULL)；
LWIP_DEBUGF (SNTP_DEBUG_STATE、("SNTP_REV：计划下一次时间请求：%"U32_F" ms"、
(u32_t) SNTP 更新延迟)；
｝否则、如果(err = SNTP ERR_KOD)｛
/* Kiss-of -death 数据包。 使用另一台服务器或增加 update_delay。 *
sntp_try_next 服务器(空)；
｝否则｛
/*另一个错误，请重试同一台服务器*/
SNTP_RETRY (空)；
｝
｝

/**实际向服务器发送 SNTP 请求。
*
*@param server_addr 解析了 SNTP 服务器的 IP 地址
*
静态空
SNTP 发送请求(IP_addr_t *服务器_addr)
｛
struct pbuf* p;
P = pbuf_alloc (PBUF_transport、SNTP MSG_LEN、PBUF_RAM)；
if (p！= NULL)｛

struct sntp_msg *sntpsg =(struct sntp_msg *) p->payload；

uint8_t SNTP 数据包[]=｛0x1B、0x00、0x06、0xEC、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x49、0x4E、0x49、0x52、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00、0x00

//uint8_t*My_packet =(uint8_t*) p->有效载荷；

memcpy (p->payload、ntp_packet、48)；

LWIP_DEBUGF (SNTP_DEBUG_STATE、("SNTP_SEND_REQUEST：向服务器发送请求\n")；
/*初始化请求消息*/
//sntp_initialize_request (sntpmsg)；



uint32_t len = 0；
UARTprintf ("payload \r\n")；
//for (len = 0；len < p->len；len++)
//UARTprintf ("%s"、p->PAYLOAD)；
/*发送请求*/
UARTprintf ("服务器地址：%X\r\n"、server_addr)；
udp_sendto (sntp_pcb、p、server_addr、sntp_port)；
/*设置接收超时：尝试下一台服务器或在超时时时重试*/
SYS_TIMEOUT (((u32_t) SNTP_RECV_TIMEOUT、SNTP_Try 下一个服务器、空)；

#if SNTP_CHECK_RESPONSE >=1.
/*保存服务器地址以在 SNTP 中进行验证*/
ip_addr_set (&sntp_last_server_address、server_addr)；
#endif /* SNTP CHECK_RESPONSE >=1 */
｝否则｛
LWIP_DEBUGF (SNTP_DEBUG_SEARY、("SNTP_SEND_REQUEST：内存不足、在%"U32_F" ms\n"中重试、
(u32_t) SNTP 重试_超时)；
/*内存不足：设置计时器以发送重试*/
SYS_TIMEOUT (((u32_t) SNTP_RETRY 超时、SNTP_REQUEST、NULL)；
｝
｝

#if Sntp_Server_dns
/**
*使用 DNS 名称作为服务器地址时、DNS 找到回调。
*
静态空
sntp_dns_found (const char* hostname、ip_addr_t *ipaddr、void *arg)
｛
LWIP_unused_arG (主机名)；
LWIP_unused_arg (arg)；

if (ipaddr！= NULL)｛
/*地址已解决，发送请求*/
LWIP_DEBUGF (SNTP_DEBUG_STATE、("SNTP_DNS_FOUND：服务器地址已解析、正在发送请求\n")；
sntp_send_request (ipaddr)；
｝否则｛
/* DNS 解析失败->尝试另一台服务器*/
LWIP_DEBUGF (SNTP 调试_WARN_STATE、("SNTP DNS_FOUND：解析服务器地址失败、正在尝试下一个服务器\n")；
sntp_try_next 服务器(空)；
｝
｝
#endif /* SNTP 服务器_DNS */

/**
*通过原始 API 发送 SNTP 请求。
*
*@未使用 param arg (仅在符合 sys_timeout 时才需要)
*
静态空
SNTP 请求(空*arg)
｛
ip_addr_t SNTP 服务器地址；
ERR_t 错误；

UARTprintf("******** 发送 Reqst ******** \r\n")；
LWIP_unused_arg (arg)；

/*初始化 SNTP 服务器地址*/
#if Sntp_Server_dns
ERR = DNS_gethostbyname ((static char*) g_s、&SNTP_server_address、
SNTP_DNS_Found、NULL)；


if (err =ERR_INPROGRESS)｛
/* DNS 请求已发送，等待 SNTP_DNS_FOUND 被调用*/
UARTprintf ("DNS 未解析\r\n")；
LWIP_DEBUGF (SNTP_DEBUG_STATE、("SNTP_REQUEST：正在等待解析服务器地址。\n"）；
返回；
｝
#else /* SNTP 服务器_DNS */
ERR = ipaddr_aton (g_sParameters.ntp_Server_IP、&sntp_server_address)
？ ERR_OK：ERR_ARG；

#endif /* SNTP 服务器_DNS */

如果(err =ERR_OK)｛

UARTprintf ("***发送 NTP 请求***\r\n")；

SNTP 发送请求(&SNTP 服务器地址)；
｝否则｛
/*地址转换失败，请尝试另一台服务器*/
LWIP_DEBUGF (SNTP 调试_WARN_STATE、("SNTP 请求：无效的服务器地址、正在尝试下一个服务器。\n")；
SYS_TIMEOUT (((u32_t) SNTP_RETRY 超时、SNTP_Try 下一个服务器、空)；
｝
｝

/**
*使用原始 API 时初始化此模块。
*即时或在 SNTP_STARTUP_DELAY 之后发送输出请求。
*
无效
SNTP_INIT (空)
｛
SYS_unTIMEOUT (SNTP_REQUEST、NULL)；

sntp_reset_retry_timeout ()；

SNTP = UDP_NEW ()；

UARTprintf (“**** SNTP：%x **** \r\n"、SNTP)；

if (SNTP！= NULL)｛
UDP_recv (SNTP_PCB、SNTP_recv、NULL)；
#if SNTP_STARTUP_DELAY
SYS_TIMEOUT (1、SNTP_REQUEST、NULL)；
其他
SNTP_REQUEST (空)；
#endif
｝
｝

#endif /* SNTP 套接字*/

#endif // LWIP_UDP */


这是我的代码..