高性能秒级定时器实现源码

最新推荐文章于 2020-09-09 12:52:33 发布
置顶 最新推荐文章于 2020-09-09 12:52:33 发布
阅读量976 收藏
点赞数
分类专栏： 开源计划 文章标签： 时钟 时间轮 源码 定时器 c/c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/freeland008/article/details/107508749
版权

1、本文展示秒级定时器的源码，源码是封装成C++类，然后再次封装成API函数的方式。

     用户开发手册地址：https://blog.csdn.net/freeland008/article/details/107508749

 

2、TimerVM.h和TimerVM.cpp是用c++类的方式实现了秒级时钟的封装，TimerMng.h、TimerMng.cpp实现了二次封装，更方便开发人员直接使用。

3、总体实现思路是使用双时间轮数组交换的方式。

 

4、TimerVM.h

#ifndef TIMERVM_H
#define TIMERVM_H

#include <time.h>

typedef void* HANDLE;

typedef struct _TIMERITEM
{	
	unsigned int dwTimes;	
	unsigned int dwTimeOut;
	time_t dtExpire;
	void* fp;
	void* pPara;			
	void* pPosArray;

	_TIMERITEM* pPrev;
	_TIMERITEM* pNext;
}TIMERITEM;
typedef TIMERITEM* LPTIMERITEM;

typedef struct _TIMERARRAY
{
	time_t dtStart;
	HANDLE* hArray;
	_TIMERARRAY()
	{
		dtStart = 0;
		hArray = NULL;
	}
}TIMERARRAY;
typedef TIMERARRAY* LPTIMERARRAY;

class CTimerMng
{ 
private:
	TIMERARRAY m_pTimerArrayA;
	TIMERARRAY m_pTimerArrayB;
	time_t m_dtLastCheck;
	int m_nArraySize;
public:
	LPTIMERARRAY m_pArrayOld;
	LPTIMERARRAY m_pArrayNew;
private:
	size_t m_nCount;	
	int m_nTimerOutCount;
	int m_nSetTimerCount;
	int m_nResetCycleTimerCount;
	int m_nResetOverTimerCount;
public:	
	LPTIMERITEM m_pResetList;
	LPTIMERITEM m_pOverList;
public:
	CTimerMng();
	~CTimerMng();
public:
	int Init(int nArraySize, time_t dtNow);
	int Destroy();
	LPTIMERITEM SetTimer(time_t dtNow, unsigned int dwTimeOut, unsigned int dwTimes, void* fp, void* pPara);	
	void ResetTimerCycle(LPTIMERITEM pItem);		
	void ResetTimerOver(LPTIMERITEM pItem);	
	void KillTimer(LPTIMERITEM pItem);
	void CheckTimeOut(time_t dtNow);
	void OnProcTimeOut(LPTIMERITEM pItem, time_t dtNow);		
	size_t GetCount(){return m_nCount;};
};

#endif

 

5、TimerVM.cpp

 

#include <stdio.h>
#include <stdlib.h>
#include "TimerVM.h"
#include "TimerMng.h"

CTimerMng :: CTimerMng()
{
	m_nCount = 0;		

	m_nTimerOutCount = 0;
	m_nSetTimerCount = 0;
	m_nResetCycleTimerCount = 0;
	 m_nResetOverTimerCount = 0;

	m_dtLastCheck = 0;
	m_pResetList = NULL;
	m_pOverList = NULL;

	m_pTimerArrayA.hArray = NULL;
	m_pTimerArrayB.hArray = NULL;
}

CTimerMng :: ~CTimerMng()
{
	Destroy();
}

int CTimerMng :: Init(int nArraySize, time_t dtNow)
{
	m_nArraySize = nArraySize;	

	m_pTimerArrayA.hArray = new HANDLE[m_nArraySize];
	int i;
	for (i = 0; i < m_nArraySize; i++)
	{
		m_pTimerArrayA.hArray[i] = NULL;
	}

	m_pTimerArrayB.hArray = new HANDLE[m_nArraySize];
	for (i = 0; i < m_nArraySize; i++)
	{
		m_pTimerArrayB.hArray[i] = NULL;
	}

	m_pArrayOld = &m_pTimerArrayA;
	m_pArrayNew = &m_pTimerArrayB;

	m_pArrayOld->dtStart = dtNow;
	m_pArrayNew->dtStart = m_pArrayOld->dtStart + m_nArraySize;

	m_dtLastCheck = dtNow;
	//		

	return 0;
}
/*
void CTimerMng :: Align(time_t dtNow)
{
	m_pArrayOld->dtStart = dtNow;
	m_pArrayNew->dtStart = m_pArrayOld->dtStart + m_nArraySize;

	m_dtLastCheck = dtNow;
}*/

int CTimerMng :: Destroy()
{	
	if(m_pTimerArrayA.hArray != NULL)
	{
		delete[] m_pTimerArrayA.hArray;
		m_pTimerArrayA.hArray = NULL;
	}

	if(m_pTimerArrayB.hArray != NULL)
	{
		delete[] m_pTimerArrayB.hArray;
		m_pTimerArrayB.hArray = NULL;
	}

	return 0;
}

LPTIMERITEM CTimerMng :: SetTimer(time_t dtNow, unsigned int nElapse, unsigned int dwTimes, void* fp, void* pPara)
{	
	if(nElapse == 0)
	{
		return NULL;
	}

	time_t dtExpire;
	dtExpire = dtNow + nElapse;

	LPTIMERITEM pItem;
	pItem = (LPTIMERITEM)malloc(sizeof(TIMERITEM));	

	pItem->dtExpire = dtExpire;
	pItem->dwTimeOut = nElapse;
	pItem->dwTimes = dwTimes;	
	pItem->pPara = pPara;	
	pItem->fp = fp;

	pItem->pPrev = NULL;
	pItem->pNext = NULL;

	void* pAddr;	
	if(dtExpire >= m_pArrayNew->dtStart)
	{	
		int nIndex;
		nIndex = dtExpire - m_pArrayNew->dtStart;		
		nIndex = nIndex%m_nArraySize;		

		if(m_pArrayNew->hArray[nIndex] == NULL)
		{				
			m_pArrayNew->hArray[nIndex] = pItem;
		}
		else			
		{
			LPTIMERITEM pTmp;
			pTmp = (LPTIMERITEM)(m_pArrayNew->hArray[nIndex]);			
			pItem->pNext = pTmp;
			pTmp->pPrev = pItem;
			m_pArrayNew->hArray[nIndex] = pItem;
		}		

		pAddr = &(m_pArrayNew->hArray[nIndex]);
	}
	else
	{		
		int nIndex;
		nIndex = dtExpire - m_pArrayOld->dtStart;	

		if(m_pArrayOld->hArray[nIndex] == NULL)
		{			
			m_pArrayOld->hArray[nIndex] = pItem;
		}
		else
		{			
			LPTIMERITEM pTmp;
			pTmp = (LPTIMERITEM)(m_pArrayOld->hArray[nIndex]);			
			pItem->pNext = pTmp;
			pTmp->pPrev = pItem;
			m_pArrayOld->hArray[nIndex] = pItem;
		}			

		pAddr = &(m_pArrayOld->hArray[nIndex]);
	}
	//

	pItem->pPosArray = pAddr;

	m_nCount++;

	m_nSetTimerCount++;

	return pItem;
}


void CTimerMng :: ResetTimerOver(LPTIMERITEM pItem)
{	
	void* pAddr;	
	if(pItem->dtExpire >= m_pArrayNew->dtStart)
	{		
		int nIndex;
		nIndex = pItem->dtExpire - m_pArrayNew->dtStart;	
		nIndex = nIndex%m_nArraySize;	

		if(m_pArrayNew->hArray[nIndex] == NULL)
		{				
			m_pArrayNew->hArray[nIndex] = pItem;
			pItem->pPrev = NULL;
			pItem->pNext = NULL;
		}
		else			
		{			
			LPTIMERITEM pTmp;
			pTmp = (LPTIMERITEM)(m_pArrayNew->hArray[nIndex]);
			pItem->pNext = pTmp;
			pItem->pPrev = NULL;
			pTmp->pPrev = pItem;
			m_pArrayNew->hArray[nIndex] = pItem;
		}		

		pAddr = &(m_pArrayNew->hArray[nIndex]);
	}
	else
	{		
		int nIndex;
		nIndex = pItem->dtExpire - m_pArrayOld->dtStart;	

		if(m_pArrayOld->hArray[nIndex] == NULL)
		{			
			m_pArrayOld->hArray[nIndex] = pItem;
			pItem->pPrev = NULL;
			pItem->pNext = NULL;
		}
		else
		{			
			LPTIMERITEM pTmp;
			pTmp = (LPTIMERITEM)(m_pArrayOld->hArray[nIndex]);			
			pItem->pNext = pTmp;
			pItem->pPrev = NULL;
			pTmp->pPrev = pItem;
			m_pArrayOld->hArray[nIndex] = pItem;
		}			

		pAddr = &(m_pArrayOld->hArray[nIndex]);
	}	
	
	pItem->pPosArray = pAddr;	

	m_nResetOverTimerCount++;
}

void CTimerMng :: ResetTimerCycle(LPTIMERITEM pItem)
{		
	time_t dtExpire;
	dtExpire = pItem->dtExpire + pItem->dwTimeOut;
	//
	void* pAddr;	
	if(dtExpire >= m_pArrayNew->dtStart)
	{
		int nIndex;
		nIndex = dtExpire - m_pArrayNew->dtStart;		
		nIndex = nIndex%m_nArraySize;		

		if(m_pArrayNew->hArray[nIndex] == NULL)
		{				
			m_pArrayNew->hArray[nIndex] = pItem;
			pItem->pPrev = NULL;
			pItem->pNext = NULL;
		}
		else			
		{			
			LPTIMERITEM pTmp;
			pTmp = (LPTIMERITEM)(m_pArrayNew->hArray[nIndex]);			
			pItem->pNext = pTmp;
			pItem->pPrev = NULL;
			pTmp->pPrev = pItem;
			m_pArrayNew->hArray[nIndex] = pItem;
		}		

		pAddr = &(m_pArrayNew->hArray[nIndex]);
	}
	else
	{
		int nIndex;
		nIndex = dtExpire - m_pArrayOld->dtStart;

		if(m_pArrayOld->hArray[nIndex] == NULL)
		{			
			m_pArrayOld->hArray[nIndex] = pItem;
			pItem->pPrev = NULL;
			pItem->pNext = NULL;
		}
		else
		{			
			LPTIMERITEM pTmp;
			pTmp = (LPTIMERITEM)(m_pArrayOld->hArray[nIndex]);			
			pItem->pNext = pTmp;
			pItem->pPrev = NULL;
			pTmp->pPrev = pItem;
			m_pArrayOld->hArray[nIndex] = pItem;
		}			

		pAddr = &(m_pArrayOld->hArray[nIndex]);
	}
	//	
	pItem->dtExpire = dtExpire;		

	pItem->pPosArray = pAddr;	

	m_nResetCycleTimerCount++;
}

void CTimerMng :: KillTimer(LPTIMERITEM pItem)
{
	void* pAddr;
	pAddr = pItem->pPosArray;

	if(pItem->pPrev == NULL)
	{
		if(pItem->pNext == NULL)
		{
			*(size_t *)pAddr = NULL;	
		}		
		else
		{
			LPTIMERITEM pNext;
			pNext = pItem->pNext;
			pNext->pPrev = NULL;
			*(size_t *)pAddr = (size_t)pNext;	
		}
	}
	else
	{
		if(pItem->pNext == NULL)
		{
			LPTIMERITEM pPrev;
			pPrev = pItem->pPrev;
			pPrev->pNext = NULL;			
		}		
		else
		{
			LPTIMERITEM pNext;
			pNext = pItem->pNext;

			LPTIMERITEM pPrev;
			pPrev = pItem->pPrev;

			pPrev->pNext = pNext;
			pNext->pPrev = pPrev;
		}
	}
	
	free(pItem);	

	m_nCount--;
}

void CTimerMng :: CheckTimeOut(time_t dtNow)
{	
	if(dtNow >= m_pArrayNew->dtStart)
	{
		if(m_dtLastCheck < m_pArrayNew->dtStart)	
		{
			time_t dtTime;
			for(dtTime = m_dtLastCheck + 1; dtTime < m_pArrayNew->dtStart; dtTime++)
			{					
				int nIndex;
				nIndex = dtTime - m_pArrayOld->dtStart;				
				if(nIndex >= m_nArraySize || nIndex < 0)
				{
					break;
				}
				
				HANDLE hList;
				hList = m_pArrayOld->hArray[nIndex];
				if(hList != NULL)
				{					
					OnProcTimeOut((LPTIMERITEM)hList, dtNow);
					m_pArrayOld->hArray[nIndex] = NULL;
				}								
			}						

			for(dtTime = m_pArrayNew->dtStart; dtTime <= dtNow; dtTime++)
			{								
				int nIndex;
				nIndex = dtTime - m_pArrayNew->dtStart;				
				if(nIndex >= m_nArraySize || nIndex < 0)
				{
					break;
				}
				
				HANDLE hList;
				hList = m_pArrayNew->hArray[nIndex];
				if(hList != NULL)
				{					
					OnProcTimeOut((LPTIMERITEM)hList, dtNow);
					m_pArrayNew->hArray[nIndex] = NULL;
				}								
			}			
		}
		else
		{
			time_t dtTime;
			for(dtTime = m_dtLastCheck + 1; dtTime <= dtNow; dtTime++)
			{			
				int nIndex;
				nIndex = dtTime - m_pArrayNew->dtStart;				
				if(nIndex >= m_nArraySize || nIndex < 0)
				{
					break;
				}
				
				HANDLE hList;
				hList = m_pArrayNew->hArray[nIndex];
				if(hList != NULL)
				{					
					OnProcTimeOut((LPTIMERITEM)hList, dtNow);
					m_pArrayNew->hArray[nIndex] = NULL;
				}										
			}			
		}
		//
		LPTIMERARRAY pTmp;
		pTmp = m_pArrayOld;
		m_pArrayOld = m_pArrayNew;
		m_pArrayNew = pTmp;
		m_pArrayNew->dtStart = m_pArrayOld->dtStart + m_nArraySize;
		//
	}
	else
	{
		time_t dtTime;
		for(dtTime = m_dtLastCheck + 1; dtTime <= dtNow; dtTime++)
		{		
			int nIndex;
			nIndex = dtTime - m_pArrayOld->dtStart;			
			if(nIndex >= m_nArraySize || nIndex < 0)
			{
				break;
			}
			
			HANDLE hList;
			hList = m_pArrayOld->hArray[nIndex];
			if(hList != NULL)
			{				
				OnProcTimeOut((LPTIMERITEM)hList, dtNow);
				m_pArrayOld->hArray[nIndex] = NULL;
			}								
		}		
	}

	m_dtLastCheck = dtNow;
	//	
	while(m_pResetList != NULL)
	{
		LPTIMERITEM pItem;		
		pItem = m_pResetList;		
		m_pResetList = m_pResetList->pNext;
		ResetTimerCycle(pItem);
	}	
	
	while(m_pOverList != NULL)
	{
		LPTIMERITEM pItem;		
		pItem = m_pOverList;		
		m_pOverList = m_pOverList->pNext;		
		ResetTimerOver(pItem);					
	}	
}

void CTimerMng :: OnProcTimeOut(LPTIMERITEM pItem, time_t dtNow)
{	
	while(pItem != NULL)
	{
		LPTIMERITEM pTmp;
		pTmp = pItem->pNext;

		if(dtNow < pItem->dtExpire)
		{				
			if(m_pOverList == NULL)
			{
				m_pOverList = pItem;
				m_pOverList->pNext = NULL;
			}
			else
			{				
				pItem->pNext = m_pOverList;
				m_pOverList = pItem;
			}
			pItem = pItem->pNext;
			pItem = pTmp;
			continue;
		}	
		
		//
		LPTIMEROUTPROC(pItem->fp)(this, pItem, pItem->pPara);
		//
		if(pItem->dwTimes != 0xFFFFFFFF)
		{
			pItem->dwTimes--;
		}		

		if(pItem->dwTimes > 0)
		{
			if(m_pResetList == NULL)
			{
				m_pResetList = pItem;
				m_pResetList->pNext = NULL;
			}
			else
			{				
				pItem->pNext = m_pResetList;
				m_pResetList = pItem;
			}
			
			pItem = pItem->pNext;
			pItem = pTmp;
			continue;					
		}
		
		//if(bAutoRelease == true)
		//{
			//MMFree(pItem, 0);
			free(pItem);
			m_nCount--;		
		//}				

		pItem = pTmp;		
		
		m_nTimerOutCount++;		
	}	
}

6、TimerMng.h

#ifndef TIMERMNG_H
#define TIMERMNG_H

#define TVMAPI extern "C"  __declspec(dllexport) 

typedef void* HANDLE;

typedef void (* LPTIMEROUTPROC)(HANDLE hTimerVM, HANDLE hTimerItem, void* pPara);

TVMAPI HANDLE TVSysCreate(int nArraySize, time_t dtNow);
TVMAPI int TVSysDestroy(HANDLE hTimerVM);
TVMAPI HANDLE TVSetTimerCycle(HANDLE hTimerVM, time_t dtNow, unsigned int dwCycle, unsigned int nTimes, LPTIMEROUTPROC pProc, void* pPara);
TVMAPI HANDLE TVSetTimerAtTime(HANDLE hTimerVM, time_t dtNow, char* sDateTime, LPTIMEROUTPROC pProc, void* pPara);
TVMAPI void TVKillTimer(HANDLE hTimerVM, HANDLE hTimerItem);
TVMAPI size_t TVGetCount(HANDLE hTimerVM);
TVMAPI void TVCheckTimeOut(HANDLE hTimerVM, time_t dtNow);

#endif

 

7、TimerMng.cpp

 

#include "TimerVM.h"
#include "TimerMng.h"
#include <time.h>
#include <string.h>
#include <stdlib.h>

TVMAPI HANDLE TVSysCreate(int nArraySize, time_t dtNow)
{
	if(nArraySize <= 1)
	{
		return NULL;
	}

	CTimerMng* pTimerMng;
	pTimerMng = new CTimerMng;
	pTimerMng->Init(nArraySize, dtNow);
	return pTimerMng;
}

TVMAPI int TVSysDestroy(HANDLE hTimerVM)
{
	CTimerMng* pTimerMng;
	pTimerMng = (CTimerMng *)hTimerVM;
	
	pTimerMng->Destroy();
	delete pTimerMng;

	return 0;
}

TVMAPI HANDLE TVSetTimerCycle(HANDLE hTimerVM, time_t dtNow, unsigned int nElapse, unsigned int nTimes, LPTIMEROUTPROC pProc, void* pPara)
{
	CTimerMng* pTimerMng;
	pTimerMng = (CTimerMng *)hTimerVM;
	return(pTimerMng->SetTimer(dtNow, nElapse, nTimes, pProc, pPara));	
}

TVMAPI HANDLE TVSetTimerAtTime(HANDLE hTimerVM, time_t dtNow, char* sExpire, LPTIMEROUTPROC pProc, void* pPara)
{
	CTimerMng* pTimerMng;
	pTimerMng = (CTimerMng *)hTimerVM;
	
	char sPart[5];

	tm SystemTime;

	memcpy(sPart, sExpire, 4);
	sPart[4] = '\0';
	SystemTime.tm_year = atoi(sPart) - 1900;

	strncpy(sPart, sExpire + 4, 2);
	sPart[2] = '\0';
	SystemTime.tm_mon = atoi(sPart) - 1;

	strncpy(sPart, sExpire + 6, 2);
	sPart[2] = '\0';
	SystemTime.tm_mday = atoi(sPart);

	strncpy(sPart, sExpire + 8, 2);
	sPart[2] = '\0';
	SystemTime.tm_hour = atoi(sPart);

	strncpy(sPart, sExpire + 10, 2);
	sPart[2] = '\0';
	SystemTime.tm_min = atoi(sPart);

	strncpy(sPart, sExpire + 12, 2);
	sPart[2] = '\0';
	SystemTime.tm_sec = atoi(sPart);

	SystemTime.tm_isdst = 0;

	time_t dtExpire;	
	dtExpire = mktime(&SystemTime);	

	if(dtExpire <= dtNow)
	{
		return NULL;
	}

	return(pTimerMng->SetTimer(dtNow, dtExpire - dtNow, 1, pProc, pPara));		
}

TVMAPI void TVKillTimer(HANDLE hTimerVM, HANDLE hTimerItem)
{
	CTimerMng* pTimerMng;
	pTimerMng = (CTimerMng *)hTimerVM;
	pTimerMng->KillTimer((LPTIMERITEM)hTimerItem);
}

TVMAPI size_t TVGetCount(HANDLE hTimerVM)
{
	CTimerMng* pTimerMng;
	pTimerMng = (CTimerMng *)hTimerVM;
	return pTimerMng->GetCount();	
}

TVMAPI void TVCheckTimeOut(HANDLE hTimerVM, time_t dtNow)
{
	CTimerMng* pTimerMng;
	pTimerMng = (CTimerMng *)hTimerVM;
	pTimerMng->CheckTimeOut(dtNow);		
}

 

编程农场
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
libevent源码分析之时间管理和定时器
游戏猫的博客
01-25 639
一、概述 libevent提供了高性能定时器的功能，方便执行延迟回调逻辑。 二、基本实现原理 在添加事件监听的时候，可以不指定fd和监听的事件，指定超时的时间，实现定时器功能。 定时器的底层实现包含两个部分： 最小堆：按事件的超时时间构造，超时时间最早的在堆顶。 通用超时队列：这个可以个性化设置每个队列的超时时间，添加事件时时间相同的放到同一个队列里，在最小堆里只添加一个队列首部的事件到最小堆。能避免大量事件都放到最小堆，导致最小堆添加、删除时性能变差的问题。 三、最小堆实现 最小堆的实现采用了典型的数
软定时器源码.rar
12-05
STM32ZET6是一款高性能的ARM Cortex-M4内核微控制器，广泛应用于各种工业和消费电子设备。本资源提供的"软定时器源码.rar"是基于STM32ZET6实现的软件定时器解决方案，它允许用户通过按键进行定时任务的设定与取消，...
你想要的 CF秒杀（源码）
02-21
易语言的源码（需要下载易语言 ）
易语言:游戏辅助 CF队伤“卡秒器“ 编程思路/开发者优化建议
热门推荐
LwinnerG的博客
09-09 1万+
本文是对于一款火热游戏 穿越火线的辅助软件"卡秒器"的原理分析和给开发者的优化建议 基本介绍 很多人看到"卡秒器"这个词语是陌生的 甚至于大多的游戏玩家看到也是非常陌生 但是如果 你玩这款游戏 并且玩了一段时间的开启队友伤害的爆破模式 那么你应该是非常的熟悉了. 需求介绍 在这款游戏开启队友伤害的爆破模式(以下简称队伤)里,有一些玩家的目标,并不是来击杀敌人取得胜利,而是以在初始的无敌时间结束的那一刻 抢先利用狙击枪狙杀队友为胜利. 这时候,我们就可以发现队伤的玩法. 两个队友之间 互相瞄准 等待无敌时间结
cf超强过检测源码
08-28
cf超强过检测.过320报毒正常易语言打开源码超强过检测飞天秒杀锁头
CF卡大白源码
07-01
CF卡大白源码
一键卡绝版源码
07-07
一键卡绝版源码
QT高精度定时器
08-23
在PC机上，如果项目中需要毫秒级甚至微秒级的定时器，可以考虑实现一个基于硬件定时器的高精度定时器类。这个类应该包含初始化、启动、停止、获取当前时间戳等基本功能，并确保在多线程环境下也能正常工作。需要注意...
Timer-Simple:小而简单的计时器（秒表）对象
06-09
名称 Timer::Simple - 小而简单的计时器（秒表）对象 版本 版本 1.006 概要 use Timer::Simple (); my $t = Timer::Simple->new(); do_something; print "something took: $t\n"; # or take more control my $timer = Timer::Simple->new(start => 0, string => 'human'); do_something_before; $timer->start; do_something_else; print "time so far: ", $t->elapsed, " seconds\n"; do_a_little_more; print "time so far: ", $t->elapsed, " s
时分秒时钟 图 + 程序
04-15
下下看吧,图和程序都有的...............
一个倒计时的demo
12-02
在这篇博客中的倒计时很简单的,大家可看看就明白了,然后在下面有两个方法 1.将时分秒转为秒数 2.将秒数转为时分秒 这个是网址: https://my.oschina.net/lijindou/blog/798710
精确到秒 增减日期时间、取日期时间间隔、日期时间比较大小、取某月有多少天、取年、取月、取日、取时、取分、取秒、精确到年月日时分秒
09-01
精确到秒 增减日期时间、取日期时间间隔、日期时间比较大小、取某月有多少天、取年、取月、取日、取时、取分、取秒、精确到年月日时分秒 使用教程见博客：http://blog.csdn.net/qq_24190041/article/details/77755930
vue js秒转天数小时分钟秒的实例代码
10-18
主要介绍了vue js秒转天数小时分钟秒的实例代码,代码简单易懂，非常不错，具有一定的参考借鉴价值，需要的朋友可以参考下
漂亮的定时器软件源码
07-28
在IT领域，C++是一种广泛使用的面向对象的编程语言，以其高性能、灵活性和丰富的库支持而闻名。在这款“漂亮的定时器”软件中，开发者可能利用了C++的面向对象特性，如类和对象，来实现计时器的核心功能，同时可能还...
7.1 基于定时器实现计时功能.rar
最新发布
03-02
GD32F303是一款基于ARM Cortex-M3内核的高性能单片机，广泛应用于各种工业控制、消费电子和物联网等领域。本文将详细介绍如何在GD32F303上利用定时器来实现计时功能，并结合提供的源码进行解析。 首先，我们要理解...
Java Timer源码解析（定时器源码解析）
许佳佳的博客
10-20 1302
Timer概述 Timer顾名思义就是定时器，用于处理一些需要延时处理的任务，延时时间可能是1s，也可能是5天。 一般使用方式如下： TimerTask task = new TimerTask() { @Override public void run() { Log.d("test", "timer...
stm32f4和mpu6050实现定位源码
11-22
stm32f4和mpu6050可以结合使用实现定位功能。stm32f4是一款基于ARM Cortex-M4内核的微控制器，具有丰富的外设接口和高性能的特点。mpu6050是一款集成了三轴加速度计和三轴陀螺仪的传感器，能够提供准确的加速度和角速度数据。 在实现定位功能的源码中，首先需要使用stm32f4的GPIO、I2C等外设接口来连接mpu6050传感器，然后通过I2C总线通信来读取mpu6050的加速度和角速度数据。接着，利用stm32f4的定时器或者定时中断来进行数据的采集和处理，计算出姿态角度和位置信息。 在计算姿态角度时，可以利用加速度计和陀螺仪的数据进行姿态解算，并结合四元数、欧拉角等方法得到准确的姿态信息。在计算位置信息时，可以利用姿态角度以及初始位置和速度信息进行航迹推算，得到物体的实时位置。 除此之外，还可以利用stm32f4的串口或者无线通信模块将位置信息传输到上位机或者其他设备，实现远程监控和数据分析。 通过结合stm32f4和mpu6050的硬件优势，结合精确的姿态解算和航迹推算算法，可以实现高精度的定位功能。在编写源码时需要考虑到数据采集、处理和通信的实时性和稳定性，以确保系统的可靠性和稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值