世纪秒：2000年1月1日0时0分0秒到现在的秒数

74 阅读 0 评论 49 点赞

我是靠谱客的博主感性大山，这篇文章主要介绍世纪秒：2000年1月1日0时0分0秒到现在的秒数，现在分享给大家，希望可以做个参考。

#ifnded _DATETIME_H_
#define _DATETIME_H_

typedef unsigned char z_u8;
typedef signed char z_s8;
typedef unsigned short z_u16;
typedef signed short z_s16;
typedef unsigned int z_u32;
typedef signed int z_s32;
typedef enum { z_false, z_true, } z_bool;

enum
{
TIME_BCD_FORMAT,
TIME_HEX_FORMAT,
};

enum
{
BEFORE_BASE_TIME,
AFTER_BASE_TIME,
};

enum
{
TIME_DATA_LEN = 6,
};

typedef struct
{
z_u8 u8Year;
z_u8 u8Month;
z_u8 u8Day;
}Date_TypeDef;

typedef struct
{
z_u8 u8Hour;
z_u8 u8Minute;
z_u8 u8Second;
}Time_TypeDef;

//计算pDate日期距离2000年1月1日共有多少天
z_u32 GetDayNumByDate(Date_TypeDef *pDate);

//计算pTime时间共有多少秒
z_u32 GetSecondNumByTime(Time_TypeDef *pTime);

//计算pDate日期pTime时间距离共有多少秒
z_u32 GetSecondNumByDateTime(Date_TypeDef *pDate, Time_TypeDef *pTime);

//将u32DayNum天数转换成年月日
z_bool DayNumToDate(z_u32 u32DayNum, Date_TypeDef *pDate);

//将u32SecondNum秒数转换成时分秒
z_bool SecondNumToTime(z_u32 u32SecondNum, Time_TypeDef *pTime);

//将u32SecondNum秒数转换成年月日时分秒
z_bool SecondNumToDateTime(z_u32 u32SecondNum, Date_TypeDef *pDate, Time_TypeDef *pTime);

//将BCD时间格式转换成十六进制时间格式
z_u8 TimeFormat_BcdToHex(z_uchar *pBcd, z_uchar *pHex);

//将成十六进制时间格式BCD时间格式转换
z_u8 TimeFormat_HexToBcd(z_uchar *pHex, z_uchar *pBcd);

//将十六进制时间转化为日期时间格式
z_bool HexDateTimeToDateTimeType(z_uchar *pHex, Date_TypeDef *pDate, Time_TypeDef *pTime);

//将BCD时间转化为日期时间格式
z_bool BcdDateTimeToDateTimeType(z_uchar *pBcd, Date_TypeDef *pDate, Time_TypeDef *pTime);

//将日期时间格式转化为十六进制格式
z_bool DateTimeTypeToHexDateTime(Date_TypeDef *pDate, Time_TypeDef *pTime, z_uchar *pHex);

//将日期时间格式转化为BCD时间格式
z_bool DateTimeTypeToBcdDateTime(Date_TypeDef *pDate, Time_TypeDef *pTime, z_uchar *pBcd);

//计算Base秒数前/后Inter秒的秒数
z_u32 GetSecondsWithInter(z_u8 u8AfterOrBefore, z_u32 u32BaseSeconds, z_u32 u32InterSeconds);

//计算Base日期时间前/后Inter时间间隔后的时间，存放于Result中
z_bool GetDateTimeTypeWithInter(z_u8 u8AfterOrBefore, Date_TypeDef *pBaseDate, Time_TypeDef *pBaseTime,
Date_TypeDef *pInterDate, Time_TypeDef *pInterTime,Date_TypeDef *pResultDate, Time_TypeDef *pResultTime);

//====================================================================================================
//函数名 : GetDateTimeWithInter
//函数功能 : 计算得到u8CodeType编码方式的pNow时间的u8BeforOrAfter的pInterval的时间，存储于pTime中
//输入 : z_u8 u8CodeType --- 时间编码方式
// : z_uchar *pBase --- 基准时间
// : z_u8 u8BeforOrAfter --- 前后标志
// : z_uchar *pInterTime --- 间隔时间
//输出 : z_uchar *pTime --- 获得的结果时间
//返回值 : z_u8 --- 成功与否 1 成功， 0失败
//====================================================================================================
z_bool GetDateTimeWithInter(z_u8 u8CodeType, z_uchar *pBase, z_u8 u8BeforOrAfter, z_uchar *pInter, z_uchar *pTime);

#endif

datetime.c文件
[cpp] view plain copy print?在CODE上查看代码片派生到我的代码片
/**************************************************************************************************************
* 时间，给了我们起点，从此，我们开始创造历史 *
**************************************************************************************************************/

/**************************************************************************************************************
* 重定义数据类型 *
**************************************************************************************************************/
#include <stdio.h>
#include "datetime.h"

static z_u32 YearTable[100] = {0, 366, 731, 1096, 1461, 1827, 2192, 2557, 2922, 3288,
3653, 4018, 4383, 4749, 5114, 5479, 5844, 6210, 6575, 6940,
7305, 7671, 8036, 8401, 8766, 9132, 9497, 9862, 10227, 10593,
10958, 11323, 11688, 12054, 12419, 12784, 13149, 13515, 13880, 14245,
14610, 14976, 15341, 15706, 16071, 16437, 16802, 17167, 17532, 17898,
18263, 18628, 18993, 19359, 19724, 20089, 20454, 20820, 21185, 21550,
21915, 22281, 22646, 23011, 23376, 23742, 24107, 24472, 24837, 25203,
25568, 25933, 26298, 26664, 27029, 27394, 27759, 28125, 28490, 28855,
29220, 29586, 29951, 30316, 30681, 31047, 31412, 31777, 32142, 32508,
32873, 33238, 33603, 33969, 34334, 34699, 35064, 35430, 35795, 36160 };
//非闰年日历天表
static z_u32 gMonthTable1[13] = {0,31,59,90,120,151,181,212,243,273,304,334, 365};
//闰年日历天表
static z_u32 gMonthTable2[13] = {0,31,60,91,121,152,182,213,244,274,305,335, 366};
//判断某年是否是闰年
#define isLeapYear(u16Year) (((((u16Year)%4==0)&&((u16Year)%100!=0))||((u16Year)%400==0)) ? z_true : z_false)

//计算pDate日期距离2000年1月1日共有多少天
z_u32 GetDayNumByDate(Date_TypeDef *pDate)
{
z_u32 u32DayNum = 0;

u32DayNum += YearTable[pDate->u8Year];
u32DayNum += isLeapYear(2000 + pDate->u8Year) ? gMonthTable2[pDate->u8Month-1] : gMonthTable1[pDate->u8Month-1];
u32DayNum += pDate->u8Day;

return u32DayNum;
}
//计算pTime时间共有多少秒
z_u32 GetSecondNumByTime(Time_TypeDef *pTime)
{
z_u32 u32SecondNum = 0;

u32SecondNum += pTime->u8Hour * 60 * 60;
u32SecondNum += pTime->u8Minute * 60;
u32SecondNum += pTime->u8Second;

return u32SecondNum;
}
//计算pDate日期pTime时间距离共有多少秒
z_u32 GetSecondNumByDateTime(Date_TypeDef *pDate, Time_TypeDef *pTime)
{
z_u32 u32DayNum = 0;
z_u32 u32SecondNum = 0;

u32DayNum = GetDayNumByDate(pDate);

u32SecondNum += u32DayNum * 24 * 60 * 60;

u32SecondNum += GetSecondNumByTime(pTime);

return u32SecondNum;
}
//将u32DayNum天数转换成年月日
z_bool DayNumToDate(z_u32 u32DayNum, Date_TypeDef *pDate)
{
z_bool bRetVal = z_false;
z_u8 u8Loop = 0;

if((0 < u32DayNum) && (NULL != pDate))
{
for(u8Loop = u32DayNum/367; u32DayNum > YearTable[u8Loop]; u8Loop++);
pDate->u8Year = u8Loop;

u32DayNum -= YearTable[pDate->u8Year - 1];

if(isLeapYear(2000 + pDate->u8Year))
{
for(u8Loop = u32DayNum/32; u32DayNum > gMonthTable2[u8Loop]; u8Loop++);
pDate->u8Month = u8Loop;
pDate->u8Day = u32DayNum - gMonthTable2[pDate->u8Month - 1];
}
else
{
for(u8Loop = u32DayNum/32; u32DayNum > gMonthTable1[u8Loop]; u8Loop++);
pDate->u8Month = u8Loop;
pDate->u8Day = u32DayNum - gMonthTable1[pDate->u8Month - 1];
}

bRetVal = z_true;
}

return bRetVal;
}
//将u32SecondNum秒数转换成时分秒
z_bool SecondNumToTime(z_u32 u32SecondNum, Time_TypeDef *pTime)
{
if((0 < u32SecondNum) && (NULL != pTime))
{
pTime->u8Hour = u32SecondNum / (60 * 60);
u32SecondNum = u32SecondNum % (60 * 60);

pTime->u8Minute = u32SecondNum / 60;
pTime->u8Second = u32SecondNum % 60;
}

return z_true;
}
//将u32SecondNum秒数转换成年月日时分秒
z_bool SecondNumToDateTime(z_u32 u32SecondNum, Date_TypeDef *pDate, Time_TypeDef *pTime)
{
z_bool bRetVal = z_false;

if ((0 < u32SecondNum) && (NULL != pDate) && (NULL != pTime))
{
bRetVal = DayNumToDate(u32SecondNum / (24 * 60 * 60), pDate);
bRetVal = SecondNumToTime(u32SecondNum % (24 * 60 * 60), pTime);

bRetVal = z_true;
}

return bRetVal;
}

//将BCD时间格式转换成十六进制时间格式
z_u8 TimeFormat_BcdToHex(z_uchar *pBcd, z_uchar *pHex)
{
z_u8 u8Loop = 0;

for(u8Loop = 0; u8Loop < TIME_DATA_LEN; u8Loop++)
{
pHex[u8Loop] = (pBcd[u8Loop] / 16 * 10) + (pBcd[u8Loop] % 16);
}

return 1;
}
//将成十六进制时间格式BCD时间格式转换
z_u8 TimeFormat_HexToBcd(z_uchar *pHex, z_uchar *pBcd)
{
z_u8 u8Loop = 0;

for(u8Loop = 0; u8Loop < TIME_DATA_LEN; u8Loop++)
{
pBcd[u8Loop] = (pHex[u8Loop] / 10 * 16) + (pHex[u8Loop] % 10);
}

return 1;
}
//将十六进制时间转化为日期时间格式
z_bool HexDateTimeToDateTimeType(z_uchar *pHex, Date_TypeDef *pDate, Time_TypeDef *pTime)
{
z_bool bRetVal = z_true;

pDate->u8Year = pHex[0];
pDate->u8Month = pHex[1];
pDate->u8Day = pHex[2];
pTime->u8Hour = pHex[3];
pTime->u8Minute = pHex[4];
pTime->u8Second = pHex[5];

return bRetVal;
}
//将BCD时间转化为日期时间格式
z_bool BcdDateTimeToDateTimeType(z_uchar *pBcd, Date_TypeDef *pDate, Time_TypeDef *pTime)
{
z_bool bRetVal = z_true;
z_uchar aucHex[6] = {0};

TimeFormat_BcdToHex(pBcd, aucHex);
bRetVal = HexDateTimeToDateTimeType(aucHex, pDate, pTime);

return bRetVal;
}
//将日期时间格式转化为十六进制格式
z_bool DateTimeTypeToHexDateTime(Date_TypeDef *pDate, Time_TypeDef *pTime, z_uchar *pHex)
{
z_bool bRetVal = z_true;

pHex[0] = pDate->u8Year;
pHex[1] = pDate->u8Month;
pHex[2] = pDate->u8Day;
pHex[3] = pTime->u8Hour;
pHex[4] = pTime->u8Minute;
pHex[5] = pTime->u8Second;

return bRetVal;
}
//将日期时间格式转化为BCD时间格式
z_bool DateTimeTypeToBcdDateTime(Date_TypeDef *pDate, Time_TypeDef *pTime, z_uchar *pBcd)
{
z_bool bRetVal = z_true;
z_uchar aucHex[6] = {0};

bRetVal = DateTimeTypeToHexDateTime(pDate, pTime, aucHex);
TimeFormat_HexToBcd(aucHex, pBcd);

return bRetVal;
}
//计算Base秒数前/后Inter秒的秒数
z_u32 GetSecondsWithInter(z_u8 u8AfterOrBefore, z_u32 u32BaseSeconds, z_u32 u32InterSeconds)
{
z_u32 u32ResultSeconds = 0xFFFFFFFF;

switch(u8AfterOrBefore)
{
case BEFORE_BASE_TIME:
if(u32BaseSeconds > u32InterSeconds)
{
u32ResultSeconds = u32BaseSeconds - u32InterSeconds;
}
break;
case AFTER_BASE_TIME:
if(u32BaseSeconds + u32InterSeconds < 0xFFFFFFFF)
{
u32ResultSeconds = u32BaseSeconds + u32InterSeconds;
}
break;
default:
break;
}

return u32ResultSeconds;
}

//计算Base日期时间前/后Inter时间间隔后的时间，存放于Result中
z_bool GetDateTimeTypeWithInter(z_u8 u8AfterOrBefore, Date_TypeDef *pBaseDate, Time_TypeDef *pBaseTime,
Date_TypeDef *pInterDate, Time_TypeDef *pInterTime,Date_TypeDef *pResultDate, Time_TypeDef *pResultTime)
{
z_bool bRetVal = z_false;
z_u32 u32BaseSeconds = 0;
z_u32 u32InterSeconds = 0;
z_u32 u32ResultSeconds = 0;

u32BaseSeconds = GetSecondNumByDateTime(pBaseDate, pBaseTime);
u32InterSeconds = GetSecondNumByDateTime(pInterDate, pInterTime);
u32ResultSeconds = GetSecondsWithInter(u8AfterOrBefore, u32BaseSeconds, u32InterSeconds);

if(u32ResultSeconds != 0xFFFFFFFF)
{
bRetVal = SecondNumToDateTime(u32ResultSeconds, pResultDate, pResultTime);
}

return bRetVal;
}

//====================================================================================================
//函数名 : GetDateTimeWithInter
//函数功能 : 计算得到u8CodeType编码方式的pNow时间的u8BeforOrAfter的pInterval的时间，存储于pTime中
//输入 : z_u8 u8CodeType --- 时间编码方式
// : z_uchar *pBase --- 基准时间
// : z_u8 u8BeforOrAfter --- 前后标志
// : z_uchar *pInterTime --- 间隔时间
//输出 : z_uchar *pTime --- 获得的结果时间
//返回值 : z_u8 --- 成功与否 1 成功， 0失败
//====================================================================================================
z_bool GetDateTimeWithInter(z_u8 u8CodeType, z_uchar *pBase, z_u8 u8BeforOrAfter, z_uchar *pInter, z_uchar *pTime)
{
z_bool bRetVal = z_false;

Date_TypeDef tBaseDate = {0,0,0};
Time_TypeDef tBaseTime = {0,0,0};
Date_TypeDef tInterDate = {0,0,0};
Time_TypeDef tInterTime = {0,0,0};
Date_TypeDef tResultDate = {0,0,0};
Time_TypeDef tResultTime = {0,0,0};

switch(u8CodeType)
{
case TIME_BCD_FORMAT:
if( ! BcdDateTimeToDateTimeType(pBase, &tBaseDate, &tBaseTime)) break;
if( ! BcdDateTimeToDateTimeType(pInter, &tInterDate, &tInterTime)) break;
if( ! GetDateTimeTypeWithInter(u8BeforOrAfter, &tBaseDate, &tBaseTime,
&tInterDate, &tInterTime, &tResultDate, &tResultTime)) break;
if( ! DateTimeTypeToBcdDateTime(&tResultDate, &tResultTime, pTime)) break;
bRetVal = z_true;
break;
case TIME_HEX_FORMAT:
if( ! HexDateTimeToDateTimeType(pBase, &tBaseDate, &tBaseTime)) break;
if( ! HexDateTimeToDateTimeType(pInter, &tInterDate, &tInterTime)) break;
if( ! GetDateTimeTypeWithInter(u8BeforOrAfter, &tBaseDate, &tBaseTime,
&tInterDate, &tInterTime, &tResultDate, &tResultTime)) break;
if( ! DateTimeTypeToHexDateTime(&tResultDate, &tResultTime, pTime)) break;
bRetVal = z_true;
break;
default:
break;
}

return bRetVal;
}

#if 1 //测试函数
z_bool DateTimeTest(void)
{
z_bool bRetVal = z_false;

static z_u8 u8CodeType = TIME_BCD_FORMAT;
static z_uchar tpBase[6] = {0x14, 0x05, 0x29, 0x11, 0x09, 0x45};
static z_u8 u8BeforOrAfter = BEFORE_BASE_TIME;
static z_uchar tInter[6] = {0x00, 0x00, 0x02, 0x00, 0x00, 0x00};
static z_uchar tTime[6] = {0};

bRetVal = GetDateTimeWithInter(u8CodeType, tpBase, u8BeforOrAfter, tInter, tTime);

return bRetVal;
}