精华内容
下载资源
问答
  • 你在播放幻灯片时,是不是想过:要是有时间显示在一旁,能提示我掌控时间该多好...我想起了Vista系统windows边栏中美丽的小时钟,我用时钟小工具解决了在播放幻灯片显示时钟问题。我的方法是:将时钟工具从边栏中

    你在播放幻灯片时,是不是想过:要是有时间显示在一旁,能提示我掌控时间该多好啊!我作为一个教师就在想如何解决这个问题。

    一开始我编辑幻灯片母板,在母板页脚中插入日期时间,结果只能看到幻灯片开始播放时的时间!这是一个静态时间,没用。然后我想到了使用VB编写一个时钟显示小程序。可是我找不到将程序置于前端的设计方法。只要幻灯片一开始播放(全屏),时钟就不见了踪影。我想起了Vista系统windows边栏中美丽的小时钟,我用时钟小工具解决了在播放幻灯片显示时钟问题。我的方法是:将时钟工具从边栏中拖出,关闭边栏,设置时钟前端显示。此时你播放幻灯片时,时钟就停留在你的播放屏幕上了,效果见图1所示,你还可以将它拖到你想要放的任意位置呢。

        图 1 幻灯片播放同步显示时钟

    1 幻灯片播放同步显示时钟

     

     如果你使用的是Windows 7,则在程序中打开并添加桌面小工具,设计前端显示即可。而如果你还在使用XP,则应该解决引入小工具的问题,使用诸如“超级兔子的桌面秀”之类的工具,添加小工具后对其进行简单设计就可以了。

     

    展开全文
  • 局域网内实现高精度设备时钟同步

    千次阅读 2018-05-28 18:42:39
    有时候,需要在局域网内保证各个设备之间时间是同步的,使用PTP协议是个很好的选择,如果有物理层级别的同步支持,可以达到微妙,甚至纳秒级别。...
    有时候,需要在局域网内保证各个设备之间时间是同步的,使用PTP协议是个很好的选择,如果有物理层级别的同步支持,可以达到微妙,甚至纳秒级别。
    展开全文
  • Qt实现NTP时钟同步

    千次阅读 2014-03-18 14:12:11
    //表示本地时钟层次水平  qint8 POLL=4; //测试间隔  qint8 PREC=-6; //表示本地时钟精度  QDateTime Epoch(QDate(1900, 1, 1));  qint32 second=quint32(Epoch.secsTo(QDateTime::currentDateTime()))...
    

    QT 写的从网络NTP 服务器获得网络时间的方法(4)

    #include "tttt.h"
    #include "ui_tttt.h"
    #include <QHostInfo>
    #include <QDateTime>
    #include <QAudioFormat>
    //#include <winsock2.h>

    tttt::tttt(QWidget *parent) :
            QMainWindow(parent),
            ui(new Ui::tttt)
    {
        ui->setupUi(this);
        connect(ui->pushButton,SIGNAL(clicked()),this,SLOT(on_pushbutton_clicked()));

    }

    tttt::~tttt()
    {
        delete ui;
    }

    void tttt::changeEvent(QEvent *e)
    {
        QMainWindow::changeEvent(e);
        switch (e->type()) {
        case QEvent::LanguageChange:
            ui->retranslateUi(this);
            break;
        default:
            break;
        }
    }
    void tttt::on_pushbutton_clicked()
    {
        QHostInfo info=QHostInfo::fromName("time.windows.com");
        QString ipAddress=info.addresses().first().toString();
        udpsocket=new QUdpSocket(this);
        connect(udpsocket,SIGNAL(connected()),this,SLOT(connectsucess()));
        connect(udpsocket,SIGNAL(readyRead()),this,SLOT(readingDataGrams()));
        udpsocket->connectToHost("time.windows.com",123);
    }
    void tttt::connectsucess()
    {
        ui->pushButton->setEnabled(false);
        qint8 LI=0;  //无预告
        qint8 VN=3;  //版本号
        qint8 MODE=3; //客户端几
        qint8 STRATUM=0;//表示本地时钟层次水平
        qint8 POLL=4; //测试间隔
        qint8 PREC=-6; //表示本地时钟精度
        QDateTime Epoch(QDate(1900, 1, 1));
        qint32 second=quint32(Epoch.secsTo(QDateTime::currentDateTime()));
        ui->label->setText("Connected");
        qint32 temp=0;
        QByteArray timeRequest(48, 0);
        timeRequest[0]=(LI <<6) | (VN <<3) | (MODE);
        timeRequest[1]=STRATUM;
        timeRequest[2]=POLL;
        timeRequest[3]=PREC & 0xff;
        timeRequest[5]=1;
        timeRequest[9]=1;

    //40到43字节保存原始时间戳,即客户端发送的时间
        timeRequest[40]=(temp=(second&0xff000000)>>24);
        temp=0;
        timeRequest[41]=(temp=(second&0x00ff0000)>>16);
        temp=0;
        timeRequest[42]=(temp=(second&0x0000ff00)>>8);
        temp=0;
        timeRequest[43]=((second&0x000000ff));
        udpsocket->flush();
        udpsocket->write(timeRequest);
        udpsocket->flush();
    }
    void tttt::readingDataGrams()
    {

        ui->label->setText("Reading...");
        QByteArray newTime;
        QDateTime Epoch(QDate(1900, 1, 1));
        QDateTime unixStart(QDate(1970, 1, 1));
        do
        {
            newTime.resize(udpsocket->pendingDatagramSize());
            udpsocket->read(newTime.data(), newTime.size());
        }while(udpsocket->hasPendingDatagrams());

        QByteArray TransmitTimeStamp ;
        TransmitTimeStamp=newTime.right(8);
        quint32 seconds=TransmitTimeStamp[0];
        quint8 temp=0;
        for(int j=1;j<=3;j++)
        {
            seconds=seconds<<8;
            temp=TransmitTimeStamp[j];
            seconds=seconds+temp;
        }
        QDateTime time;
        time.setTime_t(seconds-Epoch.secsTo(unixStart));
        ui->textEdit->append(time.toString());
        this->udpsocket->disconnectFromHost();
        this->udpsocket->close();
        ui->pushButton->setEnabled(true);

    }

    展开全文
  • 模拟NTP协议实现时钟同步

    万次阅读 2011-11-12 20:59:11
    Network Time Protocol(NTP)是用来使计算机时间同步化的一种协议,它可以使计算机对其服务器或时钟源(如石英钟,GPS等等)做同步化,它可以提供高精准度的时间校正(LAN上与标准间差小于1毫秒,WAN上几十毫秒),...
     
    

        Network Time Protocol(NTP)是用来使计算机时间同步化的一种协议,它可以使计算机对其服务器或时钟源(如石英钟,GPS等等)做同步化,它可以提供高精准度的时间校正(LAN上与标准间差小于1毫秒,WAN上几十毫秒),且可介由加密确认的方式来防止恶毒的协议攻击。

        NTP提供准确时间,首先要有准确的时间来源,这一时间应该是国际标准时间UTC。 NTP获得UTC的时间来源可以是原子钟、天文台、卫星,也可以从Internet上获取。这样就有了准确而可靠的时间源。时间是按NTP服务器的等级传播。按照距离外部UTC 源的远近将所有服务器归入不同的Stratun(层)中。Stratum-1在顶层,有外部UTC接入,而Stratum-2则从Stratum-1获取时间,Stratum-3从Stratum-2获取时间,以此类推,但Stratum层的总数限制在15以内。所有这些服务器在逻辑上形成阶梯式的架构并相互连接,而Stratum-1的时间服务器是整个系统的基础。

        进行网络协议实现时最重要的是了解协议数据格式。NTP数据包有48个字节,其中NTP包头16字节,时间戳32个字节。其协议格式如下图所示。

     

        其协议字段的含义如下所示。

          LI:跳跃指示器,警告在当月最后一天的最终时刻插入的迫近闺秒(闺秒)。

          VN:版本号。

          Mode:工作模式。该字段包括以下值:0-预留;1-对称行为;3-客户机;4-服务器;5-广播;6-NTP控制信息。NTP协议具有3种工作模式,分别为主/被动对称模式、客户/服务器模式、广播模式。在主/被动对称模式中,有一对一的连接,双方均可同步对方或被对方同步,先发出申请建立连接的一方工作在主动模式下,另一方工作在被动模式下;客户/服务器模式与主/被动模式基本相同,惟一区别在于客户方可被服务器同步,但服务器不能被客户同步;在广播模式中,有一对多的连接,服务器不论客户工作在何种模式下,都会主动发出时间信息,客户根据此信息调整自己的时间。

         Stratum:对本地时钟级别的整体识别。

         Poll:有符号整数表示连续信息间的最大间隔。

         Precision:有符号整数表示本地时钟精确度。

         Root Delay:表示到达主参考源的一次往复的总延迟,它是有15~16位小数部分的符号定点小数。

         Root Dispersion:表示一次到达主参考源的标准误差,它是有15~16位小数部分的无符号定点小数。

         Reference Identifier:识别特殊参考源。

          Originate Timestamp:这是向服务器请求分离客户机的时间,采用64位时标格式。

         Receive Timestamp:这是向服务器请求到达客户机的时间,采用64位时标格式。

         Transmit Timestamp:这是向客户机答复分离服务器的时间,采用64位时标格式。

         Authenticator(Optional):当实现了NTP认证模式时,主要标识符和信息数字域就包括已定义的信息认证代码(MAC)信息。

    ---------------------------------------------------------------------------------------------------------------------------

        以上对NTP协议原理的描述来自网络,感谢网络上的朋友!

        以下是我写的模拟NTP协议进行时钟同步的Demo程序。完整的代码可从这里下载: http://download.csdn.net/detail/chexlong/3787414

    NTP.h

    #ifndef NTP_H
    #define NTP_H
    
    #include <winsock2.h>
    #include <stdio.h>
    #include <time.h>
    #pragma comment(lib, "WS2_32")	// 链接到WS2_32.lib
    
    
    #define LI 0
    #define VN 3
    #define MODE 3
    #define STRATUM 0
    #define POLL 4 
    #define PREC -6
    
    #define JAN_1970      0x83aa7e80      /* 2208988800 1970 - 1900 in seconds */
    #define NTPFRAC(x) (4294 * (x) + ((1981 * (x))>>11))
    #define USEC(x) (((x) >> 12) - 759 * ((((x) >> 10) + 32768) >> 16))
    
    typedef struct ntptime_t 
    {
    	unsigned int coarse;
    	unsigned int fine;
    }ntptime;
    
    typedef struct ntp_packet_t
    {
    	//header
    	unsigned int leap_year_indicator:2;
    	unsigned int version_number:3;
    	unsigned int mode:3;
    	unsigned int stratum :8;
    	unsigned int poll :8;
    	unsigned int precision :8;
    
    	unsigned int root_delay;
    	unsigned int root_dispersion;
    	unsigned int reference_identifier;
    
    	//时间戳
    	ntptime  reference_timestamp; //T4
    	ntptime originate_timestamp;  //T1
    	ntptime receive_timestamp;    //T2
    	ntptime transmit_timestamp;   //T3
    }ntp_packet;
    
    typedef union
    {
    	ntp_packet ntp;
    	char c[48];
    }NTP_PACKET_T;
    
    void GetNTPTime(ntptime *ntpTime)
    {
    	SYSTEMTIME sysTime;
    	FILETIME fileTime;
    	GetSystemTime(&sysTime);
    	SystemTimeToFileTime(&sysTime,&fileTime);
    	ntpTime->coarse = fileTime.dwHighDateTime;
    	ntpTime->fine = fileTime.dwLowDateTime;
    }
    
    
    SOCKET CreateSock(char *psLocalIP, unsigned short usLocalPort, unsigned int iTimeOut)
    {
    	//创建套节字
    	SOCKET sock = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    	if( INVALID_SOCKET == sock )
    	{
    		printf("Failed socket() %d \n", ::WSAGetLastError());
    		return 0;
    	}
    
    	if (0 != iTimeOut)
    	{
    		//设置套接字发送,接收超时时间
    		int iRet = setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char*)&iTimeOut, sizeof(iTimeOut));
    		iRet = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char*)&iTimeOut, sizeof(iTimeOut));
    	}
    
    	//绑定本地地址
    	sockaddr_in addrLocal;
    	memset(&addrLocal, 0, sizeof(addrLocal));
    	addrLocal.sin_family = AF_INET;
    	addrLocal.sin_addr.s_addr = htonl(INADDR_ANY);
    	addrLocal.sin_port = htons(usLocalPort);
    
    	if ( 0 != bind(sock, (struct sockaddr*)&addrLocal, sizeof(addrLocal)) )
    	{
    		printf("Failed bind() %d \n", ::WSAGetLastError());
    		closesocket(sock);
    		return 0;
    	}
    
    	return sock;
    }
    
    #endif

     

    Base64.h

    #ifndef BASE64_H
    #define BASE64_H
    
    const int pr2six[256]={
    	64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
    	64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,62,64,64,64,63,
    	52,53,54,55,56,57,58,59,60,61,64,64,64,64,64,64,64,0,1,2,3,4,5,6,7,8,9,
    	10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,64,64,64,64,64,64,26,27,
    	28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,
    	64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
    	64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
    	64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
    	64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
    	64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
    	64,64,64,64,64,64,64,64,64,64,64,64,64
    };
    
    char six2pr[64] = {
    	'A','B','C','D','E','F','G','H','I','J','K','L','M',
    	'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
    	'a','b','c','d','e','f','g','h','i','j','k','l','m',
    	'n','o','p','q','r','s','t','u','v','w','x','y','z',
    	'0','1','2','3','4','5','6','7','8','9','+','/'
    };
    
    void Base64Decode(const char *bufcoded, char * dst,int *nbytes)
    {
    	int nbytesdecoded;
    	const char *bufin = bufcoded;
    	unsigned char *bufout = (unsigned char*)dst;
    	int nprbytes;
    
    	/* Figure out how many characters are in the input buffer.
    	* If this would decode into more bytes than would fit into
    	* the output buffer, adjust the number of input bytes downwards.
    	*/
    	//bufin = bufcoded;
    	while(pr2six[(int)*(bufin++)] <= 63){}
    	nprbytes = (int)(bufin - bufcoded - 1);
    	nbytesdecoded = ((nprbytes+3)/4) * 3;
    
    	bufin = bufcoded;
    
    	while (nprbytes > 0)
    	{
    		*(bufout++) =
    			(unsigned char) (pr2six[(int)*bufin] << 2 | pr2six[(int)bufin[1]] >> 4);
    		*(bufout++) =
    			(unsigned char) (pr2six[(int)bufin[1]] << 4 | pr2six[(int)bufin[2]] >> 2);
    		*(bufout++) =
    			(unsigned char) (pr2six[(int)bufin[2]] << 6 | pr2six[(int)bufin[3]]);
    		bufin += 4;
    		nprbytes -= 4;
    	}
    
    	if(nprbytes & 03)
    	{
    		if(pr2six[(int)bufin[-2]] > 63)
    			nbytesdecoded -= 2;
    		else
    			nbytesdecoded -= 1;
    	}
    	dst[nbytesdecoded] = '\0';
    	if ( nbytes )
    	{
    		*nbytes = nbytesdecoded;
    	}
    }
    
    void Base64Encode(const unsigned char *bufin, unsigned int nbytes, char * dst)
    {
    	unsigned char *outptr = (unsigned char *)dst;
    	unsigned int i;
    
    	for (i=0; i<nbytes; i += 3)
    	{
    		*(outptr++) = six2pr[*bufin >> 2];            /* c1 */
    		*(outptr++) = six2pr[((*bufin << 4) & 060) | ((bufin[1] >> 4) & 017)]; /*c2*/
    		*(outptr++) = six2pr[((bufin[1] << 2) & 074) | ((bufin[2] >> 6) & 03)];/*c3*/
    		*(outptr++) = six2pr[bufin[2] & 077];         /* c4 */
    
    		bufin += 3;
    	}
    
    	/* If nbytes was not a multiple of 3, then we have encoded too
    	* many characters.  Adjust appropriately.
    	*/
    	if(i == nbytes+1)
    	{
    		/* There were only 2 bytes in that last group */
    		outptr[-1] = '=';
    	} 
    	else if(i == nbytes+2)
    	{
    		/* There was only 1 byte in that last group */
    		outptr[-1] = '=';
    		outptr[-2] = '=';
    	}
    
    	*(outptr++) = '\0';
    
    	//size_t len = outptr - 1 - (unsigned char*)dst;
    }
    
    
    #endif


    NTPClient.cpp

    #include "../Include/NTP.h"
    #include "../Include/Base64.h"
    
    //NTP请求包打包
    int CreateNtpPacket(NTP_PACKET_T &ntpPacket)
    {
    	static unsigned long ulNTPId = 0;
    	ulNTPId++;
    	char szBuf[1024];
    	int iDataLen;
    
    	ntpPacket.ntp.leap_year_indicator = LI;
    	ntpPacket.ntp.version_number = VN;
    	ntpPacket.ntp.mode = MODE;
    	ntpPacket.ntp.stratum = STRATUM;
    	ntpPacket.ntp.poll = POLL;
    	ntpPacket.ntp.precision = (PREC&0xFF);
    	ntpPacket.ntp.root_delay = htonl(1<<16);
    	ntpPacket.ntp.root_dispersion = htonl(1<<16);
    	ntpPacket.ntp.reference_identifier = 0;
    
    	ntpPacket.ntp.reference_timestamp.coarse = 0;
    	ntpPacket.ntp.reference_timestamp.fine = 0;
    	GetNTPTime(&ntpPacket.ntp.originate_timestamp);
    	ntpPacket.ntp.receive_timestamp.coarse = 0;
    	ntpPacket.ntp.receive_timestamp.fine = 0;
    	ntpPacket.ntp.transmit_timestamp.coarse = 0;
    	ntpPacket.ntp.transmit_timestamp.fine = 0;
    
    	return 0;
    }
    
    int NtpRequest(SOCKET &sock)
    {
    	int iRet;
    	sock = CreateSock("127.0.0.1", 4567, 5000);
    	if ( 0 == sock )
    	{
    		printf("Failed create sock1 \n");
    		return -1;
    	}
    
    	//填写远程地址信息
    	sockaddr_in addrRemote; 
    	addrRemote.sin_family = AF_INET;
    	addrRemote.sin_port = htons(5678);
    	addrRemote.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    
    	while (true)
    	{
    		char szTimeValue[128];
    		char szbuf[128];
    		memset(szTimeValue,0,128);
    		memset(szbuf,0,128);
    
    		NTP_PACKET_T ntpPacket;
    		memset(&ntpPacket,0,sizeof(ntpPacket));
    		CreateNtpPacket(ntpPacket);
    
    		//Base64进行编码
    		Base64Encode((unsigned char *)ntpPacket.c, sizeof(ntpPacket), szTimeValue);
    
    		//发送NTP请求数据包
    		iRet = ::sendto(sock, szTimeValue, strlen(szTimeValue), 0, (sockaddr*)&addrRemote, sizeof(addrRemote));
    		if ( SOCKET_ERROR == iRet )
    		{
    			printf("Failed sendto() sock %d \n", ::WSAGetLastError());
    			closesocket(sock);
    		}
    		else
    		{
    			printf("Successed sendto sock = %d, data lenth = %d \n", sock, iRet);
    		}
    
    		memset(szTimeValue,0,sizeof(szTimeValue));
    		int nLen = sizeof(addrRemote);
    	
    		//接收NTP请求应答消息
    		iRet = ::recvfrom(sock, szbuf, 128, 0, (sockaddr*)&addrRemote, &nLen); 
    		
    		if(iRet > 0)
    		{
    			szbuf[iRet] = '\0';
    			printf(" 接收到数据(%s):%s \n", ::inet_ntoa(addrRemote.sin_addr), szbuf);
    
    			//Base54解码
    			Base64Decode(szbuf, szTimeValue, 0);
    			if ( '\0' == szTimeValue[0] )
    			{
    				printf("time value is empty. \n");
    				closesocket(sock);
    				::WSACleanup();	
    				return -1;
    			}
    			memset(&ntpPacket,0,sizeof(ntpPacket));
    			memcpy(ntpPacket.c,szTimeValue,sizeof(ntpPacket));
    
    			//设置本地系统时钟
    			SYSTEMTIME sysTime;
    			struct tm *tm1 = _localtime32((__time32_t*)&ntpPacket.ntp.transmit_timestamp.coarse);
    			sysTime.wYear = tm1->tm_year+1900;
    			sysTime.wMonth = tm1->tm_mon+1;
    			sysTime.wDay = tm1->tm_mday;
    			sysTime.wHour = tm1->tm_hour;
    			sysTime.wMinute = tm1->tm_min;
    			sysTime.wSecond = tm1->tm_sec;
    			sysTime.wMilliseconds = 0;
    			//SetLocalTime(&sysTime);
    
    			printf("NTP ok, %4d-%02d-%02d %02d:%02d:%02d %d \n", sysTime.wYear,sysTime.wMonth,sysTime.wDay,sysTime.wHour,sysTime.wMinute,sysTime.wSecond,sysTime.wMilliseconds);
    		}
    		else
    		{
    			printf("Failed recvfrom() sock %d \n", ::WSAGetLastError());
    		}
    
    		Sleep(5000);
    	}
    
    }
    
    int main(int argc, char* argv[])
    {
    	int iRet;
    	WSADATA wsaData;
    	WORD sockVersion = MAKEWORD(2, 2);
    	if(::WSAStartup(sockVersion, &wsaData) != 0)
    	{
    		exit(0);
    	}
    	
    	SOCKET sock;
    	iRet = NtpRequest(sock);
    	if (0 != iRet)
    	{
    		printf("ntp request failed. \n");
    	}
    
    	system("pause");
    
    	closesocket(sock);
    	::WSACleanup();	
    
    	return 0;
    }


    NTPServer.cpp

    #include "../Include/Base64.h"
    #include "../Include/NTP.h"
    
    int StartNtpServer(SOCKET &sock)
    {
    	int iRet;
    	sock = CreateSock("127.0.0.1", 5678, 0);
    	if ( 0 == sock )
    	{
    		printf("Failed create sock1 \n");
    		return -1;
    	}
    
    	sockaddr_in addrRemote; 
    
    	char szTimeValue[128];
    	char szbuf[128];
    	memset(szTimeValue,0,128);
    	memset(szbuf,0,128);
    	NTP_PACKET_T ntpPacket;
    
    	while (true)
    	{
    		memset(&addrRemote,0,sizeof(addrRemote));
    		int nLen = sizeof(addrRemote);
    
    		//接收来自客户端的NTP请求消息
    		iRet = ::recvfrom(sock, szbuf, 128, 0, (sockaddr*)&addrRemote, &nLen); 
    		if(iRet > 0)
    		{
    			szbuf[iRet] = '\0';
    			printf(" 接收到数据(%s):%s \n", ::inet_ntoa(addrRemote.sin_addr), szbuf);
    		}
    
    		//base64解码消息
    		Base64Decode(szbuf, szTimeValue, 0);
    		
    		//构造NTP请求应答数据包
    		memset(&ntpPacket,0,sizeof(ntpPacket));
    		memcpy(ntpPacket.c,szTimeValue,sizeof(ntpPacket));
    		ntpPacket.ntp.mode = 4;
    		ntpPacket.ntp.transmit_timestamp.coarse = _time32(NULL);
    		memset(szTimeValue,0,sizeof(szTimeValue));
    
    		//Base64编码NTP请求应答消息
    		Base64Encode((unsigned char *)ntpPacket.c,sizeof(NTP_PACKET_T),szTimeValue);
    
    		//填写远程地址信息
    		addrRemote.sin_family = AF_INET;
    		addrRemote.sin_port = htons(4567);
    		addrRemote.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    
    		//发送NTP请求应答消息
    		iRet = ::sendto(sock, szTimeValue, strlen(szTimeValue), 0, (sockaddr*)&addrRemote, sizeof(addrRemote));
    		if ( SOCKET_ERROR == iRet )
    		{
    			printf("Failed sendto() sock %d \n", ::WSAGetLastError());
    			closesocket(sock);
    			return -1;
    		}
    		else
    		{
    			printf("Successed sendto sock = %d, data lenth = %d \n", sock, iRet);
    		}
    	}
    
    	return 0;
    }
    
    int main(int argc, char* argv[])
    {
    	WSADATA wsaData;
    	WORD sockVersion = MAKEWORD(2, 2);
    	if(::WSAStartup(sockVersion, &wsaData) != 0)
    	{
    		exit(0);
    	}
    	
    	SOCKET sock;
    	int iRet = StartNtpServer(sock);
    	if (0 != iRet)
    	{
    		printf("start ntp server failed. \n");
    	}
    
    	system("pause");
    	closesocket(sock);
    	::WSACleanup();	
    	return 0;
    }
    
    


        上述代码代码在VC2005环境中已测试通过,以下是客户端和服务端程序截图:

    客户端

    服务端

    展开全文
  • 2.学习同步时钟FIFO、二时钟异步FIFO的分析以及编写。 3.以实例体验如何将实际需求分析转换成代码。 FIFO(First In First Out)队列通常在数字系统中实现两个模块间数据的暂存,达到减少两模块之间的速度依赖,...
  • 时钟同步方案

    千次阅读 2019-07-05 12:07:50
    方案 1:粗略方案   在客户端初始化的时候,拉取一次时间接口。 ...记此时的服务器时间为server_init_time,同时获取到当前客户端的时间, 记为local_init_time。... 客户端需要有root权限,才能修改时钟
  • Linux NTP时钟同步

    千次阅读 2018-11-01 00:32:04
    一、为什么要了解时钟同步时钟同步在大数据方向,用到的地方很多。举个例子来说吧,像Zookeeper、RegionServer服务都是需要实时和各节点进行通信的。假如各节点差超过30s,那么RegionServer会由于Zookeeper会话...
  • 16 ,时钟同步

    千次阅读 2019-06-07 22:29:56
    1 ,为什么要做时钟同步 :     因为我们的三台机器各自有自己的时间,他们的时间可能互不相同,为了让他们三个的时间一致,我们需要做时钟同步操作。 2 ,原理 :     让...
  • 利用NTP实现 系统的全网时钟同步

    千次阅读 2008-12-12 15:55:00
    利用NTP实现 系统的全网时钟同步一. 引言网管系统时钟的同步对于网管系统至关重要,关系到网管数据的采集,故障的分析,计费的准确及业务的统计,对于全网全程分析更有着重要意义。网管中某些系统的全网认证协议,...
  • 多台机器的时钟同步

    2019-09-23 09:57:11
    时钟同步的方式有两种:第一种同步方式通过网络进行时钟同步,第二种方式通过某台机器进行同步。 本文将以第二种方式介绍三台机器之间的时间同步具体的操作步骤: 本文是以centos6.5作为服务器搭建的三台机器...
  • Centos7 NTP时钟同步配置

    万次阅读 2017-03-25 22:05:44
    Centos7 NTP时钟同步配置NTP在Linux下有两种时钟同步方式:直接同步(也称跳跃同步)和平滑同步(也称微调同步)。直接同步使用ntpdate命令进行同步,直接进行时间变更。如果服务器上存在一个12点运行的任务,当前服务器...
  • PTP时钟和NTP时钟同步有什么区别

    千次阅读 2020-07-29 15:11:27
    PTP时钟 理论上任何PTP时钟都能实现主时钟和从时钟的功能,但一个PTP通信子网内只能有一个主时钟。整个系统中的最优时钟为...每个系统只有一个GMC,且每个子网内只有一个主时钟,从时钟与主时钟保持时钟同步。 下图所示
  • 解决方案1:使用TimeZone 解决方案2:使用setProperty例:System.setProperty(“user.timezone”,”Asia/Shanghai”);
  • 系统时钟和硬件时钟同步

    千次阅读 2015-01-22 16:34:29
    硬件时钟调整与系统时钟一致://system("hwclock -w")int SyncSystemClockToHw(void) { struct timeval tv; struct tm tm_time; int fd; int ret = 0; ret = access("/dev/rtc1",F_OK); if(0 == ret) { fd...
  • Windows时钟同步(时间同步)问题 在系统部署的过程中间,时钟同步(时间同步)问题是必须的,这里只说明了Windows时钟同步(时间同步)的问题 1、时钟服务器的设置 windows server 2...
  • 三台机器的时钟同步

    千次阅读 2018-07-13 22:03:34
    1.1 时钟同步第一种方式直接通过网络方式进行联网配置使用定时任务:定时进行时钟同步 date查看本地时间 date -s “日期” ntpdate us.pool.ntp.org 这个命令就可以和时钟服务器进行通信。crontab -e 编辑定时...
  • 以太网的时钟同步(1588时钟)

    万次阅读 2011-09-09 21:42:14
    该协议特别适合于以太网,可以实现微秒级高精度的时钟同步。 以太网的时钟同步 IEEE1588定义了一个在测量和控制网络中,与网络交流、本地计算和分配对象有关的精确同步时钟的协议(PTP)。此协议并不是排外的,但
  • 什么是时钟同步

    千次阅读 2010-04-25 20:08:00
    时钟同步是使收端的时钟频率与发端的时钟频率相同, 若收端时钟的获得采取定时钟提取的方式,即从接收到的信息码流中提取时钟成份,便可实现时钟同步。帧同步是保证收发两端相应各话路要对准。对于PCM30/32路系统,...
  • Windows时钟同步问题

    千次阅读 2011-11-02 10:59:17
    Windows时钟同步问题 在系统部署的过程中间,时钟同步问题是必须的,这里只说明了windows时钟同步的问题 1、时钟服务器的设置  windows server 2000以上版本有时间服务程序运行-〉计算机配置-〉管理模板-〉系统-...
  • IEEE1588精密时钟(PTP网络时钟服务器)在数字化变电站时钟同步方面的应用 IEEE1588精密时钟(PTP网络时钟服务器)在数字化变电站时钟同步方面的应用 本文由安徽京准公司提供,未经授权请勿转载@@@ 【摘要】本文介绍...
  • ntpd时钟同步服务

    千次阅读 2015-06-16 10:34:59
    ntpd时钟同步服务 目录 参考: CentOS配置时间同步NTP: http://www.crsay.com/wiki/wiki.php/server/centos/ntp-set解决ntp的错误 no server suitable for synchronization found: ...
  • NTP时钟同步原理及误差简析

    万次阅读 2018-12-10 15:33:27
    在我们某试验系统方案设计中,由于...但要求WP4000变频功率测试系统与其它系统之间保持同步,在同步性要求不是特别高的情况下,可以采用NTP时钟同步的方式进行多系统间的同步,以下就NTP时钟同步系统误差进行简析...
  • 通过增加两个寄存器来实现时钟同步 对于fifo来说,无论是写地址在读时钟下同步,还是读地址在写时钟下同步,被同步地址都会是延迟两个时钟周期之前的地址,所以在进行比较判断的时刻,参与判断的同步地址总是小于...
  • PTP时钟同步服务器工作原理与介绍

    千次阅读 2020-09-30 17:35:27
    PTP时钟同步服务器工作原理与介绍 1、引言  以太网技术由于其开放性好、价格低廉和使用方便等特点,已经广泛应用于电信级别的网络中,以太网的数据传输速度也从早期的10M提高到100M,GE,10GE,40GE,100GE正式产品...
  • ntp时钟同步服务

    千次阅读 2019-04-08 18:37:20
    因为公司内部服务器不能上外网,内部没有同一时间标准,因此时间的同步有了需求。目前所使用的就是 Network Time Protocol 协议。即网络时间协议。 NTP 工作请求 (1)客户端将采用随机端口向 NTP 服务器 (UDP:123) ...
  • 计算机网络系统 NTP时钟同步服务器 IP地址汇总 中国国家授时中心的时间服务器IP地址及时间同步方法(附多个时间服务器地址) 大家都知道计算机电脑的时间是由一块电池供电保持的,而且准确度比较差经常出现走时不准...
  • 计算机网络时间同步(时钟同步)的重要性 本文由北京华人开创科技公司提供 要转载需授权 授权联系159-0109-2122 微
  • 西门子PCS7系统NTP网络时钟同步(NTP时钟发生器)介绍 HR-901GB时钟服务器由安徽京准科技研制开发, 西门子PCS7系统时钟同步模式介绍 PCS7系统基于TIA构建方式,在整个系统下包含了AS 自动化系统,OS 服务器/客户端...
  • IEEE1588精确网络时钟同步协议简介

    千次阅读 2020-03-10 16:43:12
    [首发于cnblogs,转载请注明。... 在阅读本文之前,假定您对以太网和NTP有...IEEE1588是一个主要运行于以太网的网络时钟同步协议,主要目标是在局域网范围内实现高于微秒级的同步精度。与常见的时钟同步协议NTP相比,区...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,101
精华内容 30,440
关键字:

时钟同步怎么实现