VxWorks中如何实现时间同步

在嵌入式领域，时间同步是非常重要的一项功能。本示例展示了如何在VxWorks系统下使用NTP协议实现时间同步。使用NTP协议可以从网络时间服务器上获取时间信息进行同步。

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>

#define NTP_PORT                     123
#define NTP_MAX_LI_VN_MODE           0x1C
#define NTP_MAX_STRATUM              15
#define NTP_MAX_POLL                 10
#define NTP_MIN_PRECISION            -20
#define NTP_MAX_PRECISION            20
#define NTP_MAX_DELAY                0.1
#define NTP_BIND_TIMEOUT_SEC         3
#define NTP_MANAGE_INTERVAL_SEC      5
#define NTP_TIME_EPOCH_OFFSET        2208988800ull

static void ntpManageTask(int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10);
static BOOL ntpBind(int *pSockFd);
static BOOL ntpGetServerAddr(int sockFd, struct sockaddr_in *pServerAddr, char *pServerName);
static BOOL ntpBuildQuery(char *pQuery, int queryLen);
static BOOL ntpParseReply(char *pReply, int replyLen, struct timespec *pTimeStamp);
static BOOL ntpUpdateLocalTime(struct timespec *pTimeStamp);

//启动时间同步管理任务
void ntpStartSync(void)
{
    taskSpawn("tNtpSync", NTP_TASK_PRIORITY, NTP_TASK_OPTIONS,
              NTP_TASK_STACK_SIZE, (FUNCPTR)ntpManageTask,
              0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}

//时间同步管理任务
static void ntpManageTask(int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10)
{
    struct timespec ts;
    int sockFd;
    struct sockaddr_in serverAddr;
    char serverName[NTP_SERVER_NAME_LEN];

    memset(&ts, 0, sizeof(ts));

    //创建NTP套接字并绑定
    if (FALSE == ntpBind(&sockFd)) {
        goto TASK_EXIT;
    }

    //设置服务器名称
    strncpy(serverName, NTP_SERVER_DEFAULT, sizeof(serverName));

    while (1) {
        //获取服务器地址
        if (FALSE == ntpGetServerAddr(sockFd, &serverAddr, serverName)) {
            goto TASK_EXIT;
        }

        //构建NTP报文查询服务器时间
        if (FALSE == ntpBuildQuery(NTP_QUERY_DEFAULT, sizeof(NTP_QUERY_DEFAULT))) {
            goto TASK_EXIT;
        }

        //发送查询报文并解析响应报文
        if (FALSE == ntpParseReply(NTP_REPLY_DEFAULT, sizeof(NTP_REPLY_DEFAULT), &ts)) {
            goto TASK_EXIT;
        }

        //更新本地时间
        if (FALSE == ntpUpdateLocalTime(&ts)) {
            goto TASK_EXIT;
        }

        //更新下一次同步的服务器名称
        strncpy(serverName, NTP_SERVER_DEFAULT, sizeof(serverName));

        //等待下一次同步时间
        taskDelay(NTP_MANAGE_INTERVAL_SEC * sysClkRateGet());
    }

TASK_EXIT:
    printf("NTP manage task exit.\n");

    if (sockFd >= 0) {
        close(sockFd);
    }
}

//绑定NTP套接字
static BOOL ntpBind(int *pSockFd)
{
    struct sockaddr_in sockAddr;
    struct timeval timeVal;
    fd_set fdSet;
    int sockFd = -1;
    int ret = -1;

    //创建NTP套接字
    sockFd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (sockFd < 0) {
        printf("create NTP socket fail, errno=%d.\n", errno);
        return FALSE;
    }

    timeVal.tv_sec = NTP_BIND_TIMEOUT_SEC;
    timeVal.tv_usec = 0;

    FD_ZERO(&fdSet);
    FD_SET(sockFd, &fdSet);

    //设置套接字绑定超时时间
    setsockopt(sockFd, SOL_SOCKET, SO_RCVTIMEO, &timeVal, sizeof(timeVal));

    memset(&sockAddr, 0, sizeof(sockAddr));
    sockAddr.sin_family = AF_INET;
    sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    sockAddr.sin_port = htons(NTP_PORT);

    //绑定NTP套接字
    ret = bind(sockFd, (struct sockaddr *)&sockAddr, sizeof(sockAddr));
    if (ret < 0) {
        printf("bind NTP socket fail, errno=%d.\n", errno);
        close(sockFd);
        return FALSE;
    }

    *pSockFd = sockFd;

    return TRUE;
}

//获取服务器地址
static BOOL ntpGetServerAddr(int sockFd, struct sockaddr_in *pServerAddr, char *pServerName)
{
    struct hostent *pHostEnt;
    BOOL isNumeric;
    in_addr_t serverAddr;
    int ret;

    //判断服务器名称为IP地址的情况
    isNumeric = inet_pton(AF_INET, pServerName, &serverAddr);
    if (isNumeric) {
        pServerAddr->sin_addr.s_addr = serverAddr;
    } else {
        //查询DNS服务器获取IP地址
        pHostEnt = gethostbyname(pServerName);
        if (NULL == pHostEnt) {
            printf("get NTP server address fail, errno=%d.\n", errno);
            return FALSE;
        }

        memcpy(&pServerAddr->sin_addr, pHostEnt->h_addr_list[0], pHostEnt->h_length);
    }

    //设置服务器套接字地址族和端口号
    pServerAddr->sin_family = AF_INET;
    pServerAddr->sin_port = htons(NTP_PORT);

    return TRUE;
}

//构建NTP报文查询服务器时间
static BOOL ntpBuildQuery(char *pQuery, int queryLen)
{
    uint8_t *pPacket = (uint8_t *)pQuery;
    struct timespec ts;
    time_t secs;
    uint32_t frac;
    int ret;

    //校验报文长度
    if (queryLen != NTP_QUERY_LEN) {
        printf("invalid query length.\n");
        return FALSE;
    }

    //构建64位的NTP时间戳
    clock_gettime(CLOCK_REALTIME, &ts);
    secs = ts.tv_sec + NTP_TIME_EPOCH_OFFSET;
    frac = (uint64_t)ts.tv_nsec * ((uint32_t)1 << 32) / 1000000000;

    //填充NTP报文头部
    pPacket[0] = NTP_MAX_LI_VN_MODE;
    pPacket[1] = NTP_MAX_STRATUM;
    pPacket[2] = NTP_MAX_POLL;
    pPacket[3] = NTP_MIN_PRECISION;
    memcpy(pPacket + 4, &precision, sizeof(precision));
    memcpy(pPacket + 8, &delay, sizeof(delay));
    memcpy(pPacket + 12, &pcs, sizeof(pcs));
    memcpy(pPacket + 16, &ocs, sizeof(ocs));

    ret = htonl((uint32_t)secs);
    memcpy(pPacket + 40, &ret, sizeof(ret));

    ret = htonl((uint32_t)frac);
    memcpy(pPacket + 44, &ret, sizeof(ret));

    return TRUE;
}

//解析NTP响应报文
static BOOL ntpParseReply(char *pReply, int replyLen, struct timespec *pTimeStamp)
{
    struct timespec ts;
    uint8_t *pPacket = (uint8_t *)pReply;
    uint32_t secPart;
    uint32_t fracPart;
    int ret;

    //校验报文长度
    if (replyLen != NTP_REPLY_LEN) {
        printf("invalid reply length.\n");
        return FALSE;
    }

    //解析服务器返回的NTP时间戳
    memcpy(&secPart, pPacket + 40, sizeof(secPart));
    memcpy(&fracPart, pPacket + 44, sizeof(fracPart));

    ts.tv_sec = ntohl(secPart) - NTP_TIME_EPOCH_OFFSET;
    ts.tv_nsec = ((uint64_t)ntohl(fracPart) * 1000000000) >> 32;

    *pTimeStamp = ts;

    return TRUE;
}

//更新本地时间
static BOOL ntpUpdateLocalTime(struct timespec *pTimeStamp)
{
    struct timespec ts;
    int ret;

    clock_gettime(CLOCK_REALTIME, &ts);
    ts.tv_sec = pTimeStamp->tv_sec;
    ts.tv_nsec = pTimeStamp->tv_nsec;

    //设置系统时间
    ret = clock_settime(CLOCK_REALTIME, &ts);
    if (ret < 0) {
        printf("set system time fail, errno=%d.\n", errno);
        return FALSE;
    }

    return TRUE;
}

免责申明：文章和图片全部来源于公开网络，如有侵权，请通知删除 server@dude6.com