move PikaStdDevice.Time to time

This commit is contained in:
lyon 2023-01-09 20:35:22 +08:00
parent dd2dce1e35
commit 79df1cf1cc
13 changed files with 528 additions and 432 deletions

View File

@ -98,49 +98,8 @@ class GPIO(BaseDev):
def platformRead(self): ... def platformRead(self): ...
class Time(BaseDev): # class Time(BaseDev):
def __init__(self): ... # use time module instead
def sleep(self, s: float):
"""Sleep for s seconds."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def time(self) -> float:
"""Get the current time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def time_ns(self) -> int:
"""Get the current time in nanoseconds."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def gmtime(self, unix_time: float):
"""Convert unix time to struct_time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def localtime(self, unix_time: float):
"""Convert unix time to struct_time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def mktime(self) -> int:
"""Convert struct_time to unix time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def asctime(self):
"""Convert struct_time to string."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def ctime(self, unix_time: float):
"""Convert unix time to string."""
@abstractmethod
def sleep_s(self, s: int): ...
@abstractmethod
def sleep_ms(self, ms: int): ...
@abstractmethod
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def platformGetTick(): ...
class ADC(BaseDev): class ADC(BaseDev):

View File

@ -1,5 +1,5 @@
#include "PikaStdDevice_Time.h" #include "_time.h"
#include "PikaStdDevice_common.h" #include "PikaVM.h"
#if defined(__linux) #if defined(__linux)
#include <unistd.h> #include <unistd.h>
#endif #endif
@ -7,7 +7,7 @@
#include <windows.h> #include <windows.h>
#endif #endif
void PikaStdDevice_Time_sleep_ms(PikaObj* self, int ms) { void _time_sleep_ms(PikaObj* self, int ms) {
#if defined(__linux) #if defined(__linux)
usleep(ms * 1000); usleep(ms * 1000);
#elif defined(_WIN32) #elif defined(_WIN32)
@ -16,7 +16,7 @@ void PikaStdDevice_Time_sleep_ms(PikaObj* self, int ms) {
__platform_sleep_ms(ms); __platform_sleep_ms(ms);
#endif #endif
} }
void PikaStdDevice_Time_sleep_s(PikaObj* self, int s) { void _time_sleep_s(PikaObj* self, int s) {
#if defined(__linux) #if defined(__linux)
sleep(s); sleep(s);
#elif defined(_WIN32) #elif defined(_WIN32)
@ -26,7 +26,7 @@ void PikaStdDevice_Time_sleep_s(PikaObj* self, int s) {
#endif #endif
} }
void PikaStdDevice_Time_platformGetTick(PikaObj* self) { void _time_platformGetTick(PikaObj* self) {
obj_setInt(self, "tick", __platform_getTick()); obj_setInt(self, "tick", __platform_getTick());
} }
@ -39,8 +39,8 @@ void PikaStdDevice_Time_platformGetTick(PikaObj* self) {
#include "stdint.h" #include "stdint.h"
#include "stdio.h" #include "stdio.h"
//结构体时间类型定义(来源c标准库corect_wtime.h) // 结构体时间类型定义(来源c标准库corect_wtime.h)
//无论是16位整数还是32位整数都满足需求 // 无论是16位整数还是32位整数都满足需求
typedef struct _tm { typedef struct _tm {
int tm_sec; // seconds after the minute - [0, 60] including leap second int tm_sec; // seconds after the minute - [0, 60] including leap second
int tm_min; // minutes after the hour - [0, 59] int tm_min; // minutes after the hour - [0, 59]
@ -53,16 +53,16 @@ typedef struct _tm {
int tm_isdst; // daylight savings time flag int tm_isdst; // daylight savings time flag
} _tm; } _tm;
//时间戳时间类型定义(来源c标准库time.h) // 时间戳时间类型定义(来源c标准库time.h)
//直接支持64位秒数时间附加时间精度为ns根据设备决定需要1GHz及以上时钟频率才能支持1ns级别时间精度 // 直接支持64位秒数时间附加时间精度为ns根据设备决定需要1GHz及以上时钟频率才能支持1ns级别时间精度
//内部时间比对数据类型,传递给外界的时候会使用浮点数,所以精度会降低 // 内部时间比对数据类型,传递给外界的时候会使用浮点数,所以精度会降低
//但内部使用复合数据类型比对,以实现平台支持的最小时间精度比较 // 但内部使用复合数据类型比对,以实现平台支持的最小时间精度比较
typedef struct { typedef struct {
int64_t tv_sec; // Seconds - >= 0 int64_t tv_sec; // Seconds - >= 0
int32_t tv_nsec; // Nanoseconds - [0, 999999999] int32_t tv_nsec; // Nanoseconds - [0, 999999999]
} _timespec; } _timespec;
//错误处理 // 错误处理
typedef int status; typedef int status;
#define TIME_OK 0 #define TIME_OK 0
@ -74,9 +74,9 @@ typedef int status;
#define TIME_LESS_THAN_1970 5 #define TIME_LESS_THAN_1970 5
#define TIME_ERROR_STRUCT_TIME 6 #define TIME_ERROR_STRUCT_TIME 6
//错误状态处理函数 // 错误状态处理函数
void status_deal(status s) { void status_deal(status s) {
//输出异常信息 // 输出异常信息
#define time_printf(...) __platform_printf(__VA_ARGS__) #define time_printf(...) __platform_printf(__VA_ARGS__)
time_printf("\n[Error-info]Checking a exception : "); time_printf("\n[Error-info]Checking a exception : ");
@ -108,59 +108,59 @@ void status_deal(status s) {
time_printf("\n"); time_printf("\n");
} }
//获取硬件平台的Unix时间戳,时间精度为1s级别 // 获取硬件平台的Unix时间戳,时间精度为1s级别
status time_get_unix_time(PikaObj* self, _timespec* this_timespec) { status time_get_unix_time(PikaObj* self, _timespec* this_timespec) {
this_timespec->tv_sec = (int64_t)(obj_getInt(self, "tick") / 1000); this_timespec->tv_sec = (int64_t)(obj_getInt(self, "tick") / 1000);
return TIME_OK; return TIME_OK;
} }
//获取硬件平台的Tick时间,时间精度为1s级别以下 // 获取硬件平台的Tick时间,时间精度为1s级别以下
//即1s的小数部分 // 即1s的小数部分
status time_get_tick_ns(PikaObj* self, _timespec* this_timespec) { status time_get_tick_ns(PikaObj* self, _timespec* this_timespec) {
this_timespec->tv_nsec = (obj_getInt(self, "tick") % 1000) * 1000000; this_timespec->tv_nsec = (obj_getInt(self, "tick") % 1000) * 1000000;
return TIME_OK; return TIME_OK;
} }
//标准time()方法,返回以浮点数表示的从 epoch 开始的秒数的时间值。 // 标准time()方法,返回以浮点数表示的从 epoch 开始的秒数的时间值。
// epoch 是 1970 年 1 月 1 日 00:00:00 (UTC) // epoch 是 1970 年 1 月 1 日 00:00:00 (UTC)
pika_float time_time(PikaObj* self) { pika_float time_time(PikaObj* self) {
status res = 0; //状态响应 status res = 0; // 状态响应
_timespec temp_timespec = {0}; _timespec temp_timespec = {0};
//调用硬件平台函数,获取当前时间 // 调用硬件平台函数,获取当前时间
res = time_get_unix_time(self, &temp_timespec); res = time_get_unix_time(self, &temp_timespec);
if (res) { if (res) {
status_deal(res); status_deal(res);
} //异常处理 } // 异常处理
res = time_get_tick_ns(self, &temp_timespec); res = time_get_tick_ns(self, &temp_timespec);
if (res) { if (res) {
status_deal(res); status_deal(res);
} //异常处理 } // 异常处理
//以浮点数返回时间float // 以浮点数返回时间float
return temp_timespec.tv_sec + return temp_timespec.tv_sec +
(pika_float)temp_timespec.tv_nsec / 1000000000; (pika_float)temp_timespec.tv_nsec / 1000000000;
} }
//标准time_ns()方法,返回以整数表示的从 epoch 开始的纳秒数的时间值。 // 标准time_ns()方法,返回以整数表示的从 epoch 开始的纳秒数的时间值。
// epoch 是 1970 年 1 月 1 日 00:00:00 (UTC) // epoch 是 1970 年 1 月 1 日 00:00:00 (UTC)
int64_t time_time_ns(PikaObj* self) { int64_t time_time_ns(PikaObj* self) {
status res = 0; //状态响应 status res = 0; // 状态响应
_timespec temp_timespec = {0}; _timespec temp_timespec = {0};
//调用硬件平台函数,获取当前时间 // 调用硬件平台函数,获取当前时间
res = time_get_unix_time(self, &temp_timespec); res = time_get_unix_time(self, &temp_timespec);
if (res) { if (res) {
status_deal(res); status_deal(res);
} //异常处理 } // 异常处理
res = time_get_tick_ns(self, &temp_timespec); res = time_get_tick_ns(self, &temp_timespec);
if (res) { if (res) {
status_deal(res); status_deal(res);
} //异常处理 } // 异常处理
//以浮点数返回时间float // 以浮点数返回时间float
return temp_timespec.tv_sec * 1000000000 + temp_timespec.tv_nsec; return temp_timespec.tv_sec * 1000000000 + temp_timespec.tv_nsec;
} }
//利用基姆拉尔森计算公式计算星期 // 利用基姆拉尔森计算公式计算星期
int time_get_week(const _tm* this_tm) { int time_get_week(const _tm* this_tm) {
//月份要+1 // 月份要+1
int month = this_tm->tm_mon + 1; int month = this_tm->tm_mon + 1;
int year = this_tm->tm_year; int year = this_tm->tm_year;
int day = this_tm->tm_mday; int day = this_tm->tm_mday;
@ -179,16 +179,16 @@ int time_get_week(const _tm* this_tm) {
return w; return w;
} }
//由Unix时间戳计算标准UTC时间 // 由Unix时间戳计算标准UTC时间
status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) { status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
int32_t total_day; int32_t total_day;
int32_t extra_second; int32_t extra_second;
int year_400, year_100, year_4, year_1; int year_400, year_100, year_4, year_1;
int february_offset, temp; //二月偏移量,零时变量 int february_offset, temp; // 二月偏移量,零时变量
//判断是否输入小于0的时间戳 // 判断是否输入小于0的时间戳
if (unix_time < 0) { if (unix_time < 0) {
//暂不支持小于0的时间戳 // 暂不支持小于0的时间戳
return TIME_LESS_THAN_ZERO; return TIME_LESS_THAN_ZERO;
} }
@ -198,31 +198,31 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
total_day = unix_time / DAY_SECOND; total_day = unix_time / DAY_SECOND;
extra_second = unix_time - total_day * DAY_SECOND; extra_second = unix_time - total_day * DAY_SECOND;
//为了减少额外闰年判断把时间往前推到1600年即闰年最大的一次公倍数开始计算判断 // 为了减少额外闰年判断把时间往前推到1600年即闰年最大的一次公倍数开始计算判断
// 1970-1600 = 370 年 370/4 -(370/100-1)=90 个闰年 // 1970-1600 = 370 年 370/4 -(370/100-1)=90 个闰年
// 1600 DAY_OFFSET 365*(1970-1600)+90 = 135140,7为修正天数 // 1600 DAY_OFFSET 365*(1970-1600)+90 = 135140,7为修正天数
#define YEAR_START (1600) //初始年份 #define YEAR_START (1600) // 初始年份
#define DAY_OFFSET (135140) //时间偏移量 #define DAY_OFFSET (135140) // 时间偏移量
total_day += DAY_OFFSET; total_day += DAY_OFFSET;
//从1600年到3200年有1600/4-(1600/100-1600/400)=388个闰年 // 从1600年到3200年有1600/4-(1600/100-1600/400)=388个闰年
//即 MAX_DAY 1600*365+388=584388 day // 即 MAX_DAY 1600*365+388=584388 day
#define MAX_DAY (584388) //最大可判断时间天数 #define MAX_DAY (584388) // 最大可判断时间天数
if (total_day > MAX_DAY) { if (total_day > MAX_DAY) {
//超过3200年的换算暂不支持 // 超过3200年的换算暂不支持
return TIME_OVER_3200; return TIME_OVER_3200;
} else { } else {
//从1600年开始天数都要多减一天因为1600年是闰年 // 从1600年开始天数都要多减一天因为1600年是闰年
//但是由于日期不包含当天时间即2月2号实际是2月1号+时:分:秒 // 但是由于日期不包含当天时间即2月2号实际是2月1号+时:分:秒
//所以算出来的日期要加上一天 // 所以算出来的日期要加上一天
//两者配合,无需加减 // 两者配合,无需加减
//从400年100年4年逐渐缩小范围 // 从400年100年4年逐渐缩小范围
// 400个公历年天数为365*400+97=146097天 // 400个公历年天数为365*400+97=146097天
// 400年内的100个公历年天数为365*100+24=36524天 // 400年内的100个公历年天数为365*100+24=36524天
// 100年内的4年365*4+1=1461天 // 100年内的4年365*4+1=1461天
#define DAY_OF_400Y (146097) #define DAY_OF_400Y (146097)
#define DAY_OF_100Y (36524) #define DAY_OF_100Y (36524)
#define DAY_OF_4Y (1461) #define DAY_OF_4Y (1461)
@ -230,56 +230,56 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
// 400年也要注意要实际401年才可 // 400年也要注意要实际401年才可
year_400 = (total_day - 366) / DAY_OF_400Y; year_400 = (total_day - 366) / DAY_OF_400Y;
total_day -= year_400 * DAY_OF_400Y; total_day -= year_400 * DAY_OF_400Y;
//计算400年内的情况 // 计算400年内的情况
year_100 = (total_day - 1) / DAY_OF_100Y; year_100 = (total_day - 1) / DAY_OF_100Y;
total_day -= year_100 * DAY_OF_100Y; total_day -= year_100 * DAY_OF_100Y;
//计算100年内的情况要到第二年的第一天才算即365+1 // 计算100年内的情况要到第二年的第一天才算即365+1
year_4 = (total_day - 366) / DAY_OF_4Y; year_4 = (total_day - 366) / DAY_OF_4Y;
//计算4年需要格外注意0-5-8年才会计算一个闰年因为它才包含了4这个闰年但并不包含8 // 计算4年需要格外注意0-5-8年才会计算一个闰年因为它才包含了4这个闰年但并不包含8
total_day -= year_4 * DAY_OF_4Y; total_day -= year_4 * DAY_OF_4Y;
//计算4年内的情况 // 计算4年内的情况
//需要减去1天因为当天是不存在的 // 需要减去1天因为当天是不存在的
//需要注意闰年会多一天 // 需要注意闰年会多一天
//所有闰年都放在这里来考虑,即只要当前是闰年,那么这里就会剩下第一年闰年和第四年闰年两种情况 // 所有闰年都放在这里来考虑,即只要当前是闰年,那么这里就会剩下第一年闰年和第四年闰年两种情况
if (year_100 == 4) { if (year_100 == 4) {
//第一年是闰年,此时为400*n+1年内 // 第一年是闰年,此时为400*n+1年内
year_1 = 0; year_1 = 0;
february_offset = 1; february_offset = 1;
} else if (total_day <= DAY_OF_1Y * 4) { } else if (total_day <= DAY_OF_1Y * 4) {
// 100*n+(4,8,...96)+1年都是从第二年算起非闰年 // 100*n+(4,8,...96)+1年都是从第二年算起非闰年
//非闰年,需要减去1天因为当天是不存在的 // 非闰年,需要减去1天因为当天是不存在的
year_1 = (total_day - 1) / DAY_OF_1Y; year_1 = (total_day - 1) / DAY_OF_1Y;
total_day -= year_1 * DAY_OF_1Y; total_day -= year_1 * DAY_OF_1Y;
february_offset = 0; february_offset = 0;
} else { } else {
//第四年是闰年 // 第四年是闰年
year_1 = 4; year_1 = 4;
total_day -= year_1 * DAY_OF_1Y; total_day -= year_1 * DAY_OF_1Y;
february_offset = 1; february_offset = 1;
} }
//计算出当前年份 // 计算出当前年份
this_tm->tm_year = this_tm->tm_year =
(year_400 * 400 + year_100 * 100 + year_4 * 4 + year_1) + (year_400 * 400 + year_100 * 100 + year_4 * 4 + year_1) +
YEAR_START; YEAR_START;
//保存一年的天数 // 保存一年的天数
this_tm->tm_yday = total_day; this_tm->tm_yday = total_day;
//剩下的天数为1年内的天数,直接计算月和日 // 剩下的天数为1年内的天数,直接计算月和日
//根据当前是否为闰年设置二月偏移量是否为1 // 根据当前是否为闰年设置二月偏移量是否为1
//能被4整除且不被100整除或者能被400整除 // 能被4整除且不被100整除或者能被400整除
//闰年需要减去一天再计算 // 闰年需要减去一天再计算
total_day -= february_offset; total_day -= february_offset;
//使用二分法快速定位月份使用平年计算在月份确定到2月时再考虑闰年 // 使用二分法快速定位月份使用平年计算在月份确定到2月时再考虑闰年
//判断是否在1-6月里面 // 判断是否在1-6月里面
// 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 // 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
if (total_day <= 181) { if (total_day <= 181) {
//判断是否在1-3月里面 // 判断是否在1-3月里面
if (total_day <= 90) { if (total_day <= 90) {
//判断是否在1-2月里面 // 判断是否在1-2月里面
if (total_day <= 59) { if (total_day <= 59) {
total_day += february_offset; //去掉二月的偏置 total_day += february_offset; // 去掉二月的偏置
if (total_day <= 31) { if (total_day <= 31) {
// 1月 // 1月
temp = 0; temp = 0;
@ -296,7 +296,7 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
} else { } else {
// 4-6月 // 4-6月
total_day -= 90; total_day -= 90;
//是否在4月里面 // 是否在4月里面
if (total_day <= 30) { if (total_day <= 30) {
// 4月 // 4月
temp = 3; temp = 3;
@ -315,9 +315,9 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
} }
} else { } else {
total_day -= 181; total_day -= 181;
//判断是否在7-9月里面 // 判断是否在7-9月里面
if (total_day <= 92) { if (total_day <= 92) {
//是否在7-8月 // 是否在7-8月
if (total_day <= 62) { if (total_day <= 62) {
if (total_day <= 31) { if (total_day <= 31) {
// 7月 // 7月
@ -335,7 +335,7 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
} else { } else {
// 10-12月 // 10-12月
total_day -= 92; total_day -= 92;
//是否在10-11月 // 是否在10-11月
if (total_day <= 61) { if (total_day <= 61) {
if (total_day <= 31) { if (total_day <= 31) {
// 10月 // 10月
@ -353,11 +353,11 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
} }
} }
//记录当前月份和天数 // 记录当前月份和天数
this_tm->tm_mon = temp; //月份 [0,11] this_tm->tm_mon = temp; // 月份 [0,11]
this_tm->tm_mday = total_day; //天数 this_tm->tm_mday = total_day; // 天数
//利用额外秒数计算时-分-秒 // 利用额外秒数计算时-分-秒
temp = extra_second / 3600; temp = extra_second / 3600;
this_tm->tm_hour = temp; this_tm->tm_hour = temp;
extra_second = extra_second - temp * 3600; extra_second = extra_second - temp * 3600;
@ -368,70 +368,70 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
this_tm->tm_sec = extra_second; this_tm->tm_sec = extra_second;
//计算出当前日期的星期数 // 计算出当前日期的星期数
this_tm->tm_wday = time_get_week(this_tm); this_tm->tm_wday = time_get_week(this_tm);
//夏令时不明 // 夏令时不明
this_tm->tm_isdst = -1; this_tm->tm_isdst = -1;
} }
return TIME_OK; return TIME_OK;
} }
//由标准UTC时间生成Unix时间戳 // 由标准UTC时间生成Unix时间戳
status utc_struct_time_to_unix_time(const _tm* this_tm, int64_t* unix_time) { status utc_struct_time_to_unix_time(const _tm* this_tm, int64_t* unix_time) {
int32_t total_day, total_leap_year, dyear; int32_t total_day, total_leap_year, dyear;
int february_offset; //二月偏移量,零时变量 int february_offset; // 二月偏移量,零时变量
// 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 // 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
//每个月份对应前面所有月的天数 // 每个月份对应前面所有月的天数
const int month_day[] = {0, 31, 59, 90, 120, 151, const int month_day[] = {0, 31, 59, 90, 120, 151,
181, 212, 243, 273, 304, 334}; 181, 212, 243, 273, 304, 334};
//每天总秒数一定将UTC时间年月转换成天数 // 每天总秒数一定将UTC时间年月转换成天数
//为了减少额外闰年判断把时间往前推到1600年即闰年最大的一次公倍数开始计算判断 // 为了减少额外闰年判断把时间往前推到1600年即闰年最大的一次公倍数开始计算判断
// 1970-1600 = 370 年 370/4 -(370/100-1)=90 个闰年 // 1970-1600 = 370 年 370/4 -(370/100-1)=90 个闰年
// 1600 DAY_OFFSET 365*(1970-1600)+90 = 135140,7为修正天数 // 1600 DAY_OFFSET 365*(1970-1600)+90 = 135140,7为修正天数
if (this_tm->tm_year < 1970) { if (this_tm->tm_year < 1970) {
//暂不支持1970之前的时间 // 暂不支持1970之前的时间
*unix_time = 0; *unix_time = 0;
return TIME_LESS_THAN_1970; return TIME_LESS_THAN_1970;
} }
if (this_tm->tm_year >= 3200) { if (this_tm->tm_year >= 3200) {
//暂不支持3200及以后的时间 // 暂不支持3200及以后的时间
*unix_time = 0; *unix_time = 0;
return TIME_OVER_3200; return TIME_OVER_3200;
} }
//计算总年数要去掉尾巴如年数20年那么实际应该4个闰年因为20这一年没有包含在里面 // 计算总年数要去掉尾巴如年数20年那么实际应该4个闰年因为20这一年没有包含在里面
//要减去一年来算闰年次数 // 要减去一年来算闰年次数
//先计算到相对1600年的天数再转换到1970年 // 先计算到相对1600年的天数再转换到1970年
dyear = this_tm->tm_year - YEAR_START - 1; dyear = this_tm->tm_year - YEAR_START - 1;
total_leap_year = dyear / 4 - (dyear / 100 - dyear / 400 - 1); total_leap_year = dyear / 4 - (dyear / 100 - dyear / 400 - 1);
//恢复减去的一年 // 恢复减去的一年
dyear += 1; dyear += 1;
total_day = dyear * 365 + total_leap_year; total_day = dyear * 365 + total_leap_year;
//减去1970到1600的总天数 // 减去1970到1600的总天数
total_day -= DAY_OFFSET; total_day -= DAY_OFFSET;
//增加月和日的总天数 // 增加月和日的总天数
//判断是否是闰年 // 判断是否是闰年
//能被4整除且不被100整除或者能被400整除 // 能被4整除且不被100整除或者能被400整除
if (((dyear % 4 == 0) && (dyear % 100 != 0)) || (dyear % 400 == 0)) { if (((dyear % 4 == 0) && (dyear % 100 != 0)) || (dyear % 400 == 0)) {
//闰年 // 闰年
february_offset = 1; february_offset = 1;
} else { } else {
february_offset = 0; february_offset = 0;
} }
//计算含月和日的总天数,日期要减去当天 // 计算含月和日的总天数,日期要减去当天
total_day += month_day[this_tm->tm_mon] + this_tm->tm_mday - 1; total_day += month_day[this_tm->tm_mon] + this_tm->tm_mday - 1;
//二月以上需要加上偏移量 // 二月以上需要加上偏移量
if (this_tm->tm_mon > 1) { if (this_tm->tm_mon > 1) {
total_day += february_offset; total_day += february_offset;
} }
//根据天数以及时分秒计算Unix时间戳 // 根据天数以及时分秒计算Unix时间戳
*unix_time = (int64_t)total_day * DAY_SECOND + this_tm->tm_hour * 3600 + *unix_time = (int64_t)total_day * DAY_SECOND + this_tm->tm_hour * 3600 +
this_tm->tm_min * 60 + this_tm->tm_sec; this_tm->tm_min * 60 + this_tm->tm_sec;
@ -447,41 +447,41 @@ void time_struct_format(const _tm* this_tm, char* str) {
this_tm->tm_wday, this_tm->tm_yday, this_tm->tm_isdst); this_tm->tm_wday, this_tm->tm_yday, this_tm->tm_isdst);
} }
//标准库函数gmtime,将以自 epoch 开始的秒数表示的时间转换为 UTC 的 struct_time // 标准库函数gmtime,将以自 epoch 开始的秒数表示的时间转换为 UTC 的 struct_time
void time_gmtime(pika_float unix_time, _tm* this_tm) { void time_gmtime(pika_float unix_time, _tm* this_tm) {
status res; status res;
//转化时间 // 转化时间
res = unix_time_to_utc_struct_time(this_tm, (int64_t)unix_time); res = unix_time_to_utc_struct_time(this_tm, (int64_t)unix_time);
if (res) { if (res) {
status_deal(res); //异常情况处理 status_deal(res); // 异常情况处理
//返回默认值 // 返回默认值
// note: 异常情况返回默认时间起始点 // note: 异常情况返回默认时间起始点
unix_time_to_utc_struct_time(this_tm, (int64_t)0); unix_time_to_utc_struct_time(this_tm, (int64_t)0);
} }
} }
//标准库函数localtime,将以自 epoch 开始的秒数表示的时间转换为当地时间的 // 标准库函数localtime,将以自 epoch 开始的秒数表示的时间转换为当地时间的
// struct_time // struct_time
void time_localtime(pika_float unix_time, _tm* this_tm, int locale) { void time_localtime(pika_float unix_time, _tm* this_tm, int locale) {
status res; status res;
int local_offset; int local_offset;
//获取本地时间偏移量(小时) // 获取本地时间偏移量(小时)
local_offset = locale * 60 * 60; local_offset = locale * 60 * 60;
//转化时间 // 转化时间
res = unix_time_to_utc_struct_time(this_tm, res = unix_time_to_utc_struct_time(this_tm,
(int64_t)unix_time + local_offset); (int64_t)unix_time + local_offset);
if (res) { if (res) {
status_deal(res); //异常情况处理 status_deal(res); // 异常情况处理
//这里处理的策略和标准库不同标准库最初始的时间是1970-1-1,00:00:00对于不同时区来说其值是不一样的 // 这里处理的策略和标准库不同标准库最初始的时间是1970-1-1,00:00:00对于不同时区来说其值是不一样的
//但本函数是要求各时区的起始时间不超过1970-1-1,00:00:00实际上UTC时间可以更前可靠的最早时间可到1600年 // 但本函数是要求各时区的起始时间不超过1970-1-1,00:00:00实际上UTC时间可以更前可靠的最早时间可到1600年
//对于西时区来说,时间会缺失 // 对于西时区来说,时间会缺失
unix_time_to_utc_struct_time(this_tm, (int64_t)0); unix_time_to_utc_struct_time(this_tm, (int64_t)0);
} }
} }
//检测结构体时间是否在合适的范围内,但不检查它的正确性 // 检测结构体时间是否在合适的范围内,但不检查它的正确性
status time_check_struct_time(const _tm* this_tm) { status time_check_struct_time(const _tm* this_tm) {
if (this_tm->tm_sec < 0 || this_tm->tm_sec > 60) { if (this_tm->tm_sec < 0 || this_tm->tm_sec > 60) {
return TIME_ERROR_STRUCT_TIME; return TIME_ERROR_STRUCT_TIME;
@ -507,47 +507,47 @@ status time_check_struct_time(const _tm* this_tm) {
return TIME_OK; return TIME_OK;
} }
//标准库函数mktime(t),将当地时间的 // 标准库函数mktime(t),将当地时间的
// struct_time转换为以自epoch开始的秒数表示的时间 // struct_time转换为以自epoch开始的秒数表示的时间
int64_t time_mktime(const _tm* this_tm, int locale) { int64_t time_mktime(const _tm* this_tm, int locale) {
status res; status res;
int local_offset; int local_offset;
int64_t unix_time; int64_t unix_time;
//获取本地时间偏移量(小时) // 获取本地时间偏移量(小时)
local_offset = locale * 60 * 60; local_offset = locale * 60 * 60;
//检测时间结构体范围正确性 // 检测时间结构体范围正确性
res = time_check_struct_time(this_tm); res = time_check_struct_time(this_tm);
if (res) { if (res) {
status_deal(res); status_deal(res);
return 0; return 0;
} //异常情况返回时间零点 } // 异常情况返回时间零点
//转化时间 // 转化时间
res = utc_struct_time_to_unix_time(this_tm, &unix_time); res = utc_struct_time_to_unix_time(this_tm, &unix_time);
if (res) { if (res) {
status_deal(res); status_deal(res);
return 0; return 0;
} //异常情况返回时间零点 } // 异常情况返回时间零点
//减去本地偏移时间 // 减去本地偏移时间
//可能出现负数,严格来说,这不影响什么! // 可能出现负数,严格来说,这不影响什么!
unix_time -= local_offset; unix_time -= local_offset;
//显示出来 // 显示出来
// time_printf("%I64d\n",unix_time); // time_printf("%I64d\n",unix_time);
//返回数据 // 返回数据
return unix_time; return unix_time;
} }
//标准库函数asctime() // 标准库函数asctime()
//把结构化时间struct_time元组表示为以下形式的字符串: `'Sun Jun 20 23:21:05 // 把结构化时间struct_time元组表示为以下形式的字符串: `'Sun Jun 20 23:21:05
// 1993'`。 // 1993'`。
void time_asctime(const _tm* this_tm) { void time_asctime(const _tm* this_tm) {
//星期缩写python标准库是三个字母这里并不相同 // 星期缩写python标准库是三个字母这里并不相同
const char* week[] = {"Sun", "Mon", "Tues", "Wed", "Thur", "Fri", "Sat"}; const char* week[] = {"Sun", "Mon", "Tues", "Wed", "Thur", "Fri", "Sat"};
//月份缩写 // 月份缩写
const char* month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", const char* month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sept", "Oct", "Nov", "Dec"}; "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"};
@ -559,7 +559,7 @@ void time_asctime(const _tm* this_tm) {
time_printf("%s\n", str); time_printf("%s\n", str);
} }
pika_float PikaStdDevice_Time_time(PikaObj* self) { pika_float _time_time(PikaObj* self) {
/* run platformGetTick() */ /* run platformGetTick() */
PIKA_PYTHON_BEGIN PIKA_PYTHON_BEGIN
/* clang-format off */ /* clang-format off */
@ -579,7 +579,7 @@ pika_float PikaStdDevice_Time_time(PikaObj* self) {
return time_time(self); return time_time(self);
} }
int PikaStdDevice_Time_time_ns(PikaObj* self) { int _time_time_ns(PikaObj* self) {
return time_time_ns(self); return time_time_ns(self);
} }
@ -603,7 +603,7 @@ void time_set_tm_value(PikaObj* self, const _tm* this_tm) {
#endif #endif
} }
void PikaStdDevice_Time_gmtime(PikaObj* self, pika_float unix_time) { void _time_gmtime(PikaObj* self, pika_float unix_time) {
#if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE #if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE
obj_setErrorCode(self, 1); obj_setErrorCode(self, 1);
obj_setSysOut( obj_setSysOut(
@ -613,14 +613,14 @@ void PikaStdDevice_Time_gmtime(PikaObj* self, pika_float unix_time) {
char str[200]; char str[200];
time_gmtime(unix_time, &this_tm); time_gmtime(unix_time, &this_tm);
time_set_tm_value(self, &this_tm); time_set_tm_value(self, &this_tm);
//格式化字符 // 格式化字符
time_struct_format(&this_tm, str); time_struct_format(&this_tm, str);
//显示出来 // 显示出来
time_printf("%s\n", str); time_printf("%s\n", str);
#endif #endif
} }
void PikaStdDevice_Time_localtime(PikaObj* self, pika_float unix_time) { void _time_localtime(PikaObj* self, pika_float unix_time) {
#if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE #if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE
obj_setErrorCode(self, 1); obj_setErrorCode(self, 1);
obj_setSysOut( obj_setSysOut(
@ -631,9 +631,9 @@ void PikaStdDevice_Time_localtime(PikaObj* self, pika_float unix_time) {
int locale = obj_getInt(self, "locale"); int locale = obj_getInt(self, "locale");
time_localtime(unix_time, &this_tm, locale); time_localtime(unix_time, &this_tm, locale);
time_set_tm_value(self, &this_tm); time_set_tm_value(self, &this_tm);
//格式化字符 // 格式化字符
time_struct_format(&this_tm, str); time_struct_format(&this_tm, str);
//显示出来 // 显示出来
time_printf("%s\n", str); time_printf("%s\n", str);
#endif #endif
} }
@ -656,7 +656,7 @@ void time_get_tm_value(PikaObj* self, _tm* this_tm) {
#endif #endif
} }
int PikaStdDevice_Time_mktime(PikaObj* self) { int _time_mktime(PikaObj* self) {
#if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE #if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE
obj_setErrorCode(self, 1); obj_setErrorCode(self, 1);
obj_setSysOut( obj_setSysOut(
@ -670,7 +670,7 @@ int PikaStdDevice_Time_mktime(PikaObj* self) {
#endif #endif
} }
void PikaStdDevice_Time_asctime(PikaObj* self) { void _time_asctime(PikaObj* self) {
#if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE #if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE
obj_setErrorCode(self, 1); obj_setErrorCode(self, 1);
obj_setSysOut( obj_setSysOut(
@ -681,7 +681,7 @@ void PikaStdDevice_Time_asctime(PikaObj* self) {
time_asctime(&this_tm); time_asctime(&this_tm);
#endif #endif
} }
void PikaStdDevice_Time_ctime(PikaObj* self, pika_float unix_time) { void _time_ctime(PikaObj* self, pika_float unix_time) {
#if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE #if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE
obj_setErrorCode(self, 1); obj_setErrorCode(self, 1);
obj_setSysOut( obj_setSysOut(
@ -694,7 +694,7 @@ void PikaStdDevice_Time_ctime(PikaObj* self, pika_float unix_time) {
#endif #endif
} }
void PikaStdDevice_Time___init__(PikaObj* self) { void _time___init__(PikaObj* self) {
#if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE #if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE
#else #else
_tm this_tm; _tm this_tm;
@ -704,7 +704,7 @@ void PikaStdDevice_Time___init__(PikaObj* self) {
#endif #endif
} }
void PikaStdDevice_Time_sleep(PikaObj* self, pika_float s) { void _time_sleep(PikaObj* self, pika_float s) {
Args* args = New_args(NULL); Args* args = New_args(NULL);
args_setInt(args, "ms", s * 1000); args_setInt(args, "ms", s * 1000);
obj_runNativeMethod(self, "sleep_ms", args); obj_runNativeMethod(self, "sleep_ms", args);

56
package/time/_time.pyi Normal file
View File

@ -0,0 +1,56 @@
from PikaObj import *
def __init__(self): ...
def sleep(self, s: float):
"""Sleep for s seconds."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def time(self) -> float:
"""Get the current time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def time_ns(self) -> int:
"""Get the current time in nanoseconds."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def gmtime(self, unix_time: float):
"""Convert unix time to struct_time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def localtime(self, unix_time: float):
"""Convert unix time to struct_time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def mktime(self) -> int:
"""Convert struct_time to unix time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def asctime(self):
"""Convert struct_time to string."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def ctime(self, unix_time: float):
"""Convert unix time to string."""
@abstractmethod
def sleep_s(self, s: int): ...
@abstractmethod
def sleep_ms(self, ms: int): ...
@abstractmethod
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def platformGetTick(): ...

41
package/time/time.py Normal file
View File

@ -0,0 +1,41 @@
import _time
def sleep(s: float):
return _time.sleep(s)
def sleep_s(s: int):
return _time.sleep_s(s)
def sleep_ms(ms: int):
return _time.sleep_ms(ms)
def time() -> float:
return _time.time()
def time_ns() -> int:
return _time.time_ns()
def gmtime(unix_time: float):
return _time.gmtime(unix_time)
def localtime(unix_time: float):
return _time.localtime(unix_time)
def mktime() -> int:
return _time.mktime()
def asctime() -> str:
return _time.asctime()
def ctime(unix_time: float) -> str:
return _time.ctime(unix_time)

View File

@ -98,49 +98,8 @@ class GPIO(BaseDev):
def platformRead(self): ... def platformRead(self): ...
class Time(BaseDev): # class Time(BaseDev):
def __init__(self): ... # use time module instead
def sleep(self, s: float):
"""Sleep for s seconds."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def time(self) -> float:
"""Get the current time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def time_ns(self) -> int:
"""Get the current time in nanoseconds."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def gmtime(self, unix_time: float):
"""Convert unix time to struct_time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def localtime(self, unix_time: float):
"""Convert unix time to struct_time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def mktime(self) -> int:
"""Convert struct_time to unix time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def asctime(self):
"""Convert struct_time to string."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def ctime(self, unix_time: float):
"""Convert unix time to string."""
@abstractmethod
def sleep_s(self, s: int): ...
@abstractmethod
def sleep_ms(self, ms: int): ...
@abstractmethod
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def platformGetTick(): ...
class ADC(BaseDev): class ADC(BaseDev):

View File

@ -7,14 +7,6 @@ class GPIO(PikaStdDevice.GPIO):
def eventTest(self): ... def eventTest(self): ...
class Time(PikaStdDevice.Time):
# override
def sleep_s(self, s: int): ...
def sleep_ms(self, ms: int): ...
def platformGetTick(): ...
def platformGetEventId(self): ...
class ADC(PikaStdDevice.ADC): class ADC(PikaStdDevice.ADC):
# override # override
def platformEnable(self): ... def platformEnable(self): ...

View File

@ -0,0 +1,56 @@
from PikaObj import *
def __init__(self): ...
def sleep(self, s: float):
"""Sleep for s seconds."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def time(self) -> float:
"""Get the current time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def time_ns(self) -> int:
"""Get the current time in nanoseconds."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def gmtime(self, unix_time: float):
"""Convert unix time to struct_time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def localtime(self, unix_time: float):
"""Convert unix time to struct_time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def mktime(self) -> int:
"""Convert struct_time to unix time."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def asctime(self):
"""Convert struct_time to string."""
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def ctime(self, unix_time: float):
"""Convert unix time to string."""
@abstractmethod
def sleep_s(self, s: int): ...
@abstractmethod
def sleep_ms(self, ms: int): ...
@abstractmethod
@PIKA_C_MACRO_IF("PIKA_STD_DEVICE_UNIX_TIME_ENABLE")
def platformGetTick(): ...

View File

@ -5,7 +5,7 @@ import GTestTask, TempDevTest
import cb_test import cb_test
import configparser import configparser
import test_module1, test_cmodule, test_module4, import_test import test_module1, test_cmodule, test_module4, import_test
import hashlib, hmac, aes, base64 import hashlib, hmac, aes, base64, time
mem = PikaStdLib.MemChecker() mem = PikaStdLib.MemChecker()
print('hello pikascript!') print('hello pikascript!')

View File

@ -1,18 +0,0 @@
#include "TemplateDevice_Time.h"
void TemplateDevice_Time_sleep_ms(PikaObj *self, int ms){
}
void TemplateDevice_Time_sleep_s(PikaObj *self, int s){
}
static volatile uint64_t tick_ms = 0;
void TemplateDevice_Time_platformGetTick(PikaObj *self){
tick_ms += 50;
obj_setInt(self, "tick", tick_ms);
}
void TemplateDevice_Time_platformGetEventId(PikaObj *self){
}

View File

@ -1,5 +1,5 @@
#include "PikaStdDevice_Time.h" #include "_time.h"
#include "PikaStdDevice_common.h" #include "PikaVM.h"
#if defined(__linux) #if defined(__linux)
#include <unistd.h> #include <unistd.h>
#endif #endif
@ -7,7 +7,7 @@
#include <windows.h> #include <windows.h>
#endif #endif
void PikaStdDevice_Time_sleep_ms(PikaObj* self, int ms) { void _time_sleep_ms(PikaObj* self, int ms) {
#if defined(__linux) #if defined(__linux)
usleep(ms * 1000); usleep(ms * 1000);
#elif defined(_WIN32) #elif defined(_WIN32)
@ -16,7 +16,7 @@ void PikaStdDevice_Time_sleep_ms(PikaObj* self, int ms) {
__platform_sleep_ms(ms); __platform_sleep_ms(ms);
#endif #endif
} }
void PikaStdDevice_Time_sleep_s(PikaObj* self, int s) { void _time_sleep_s(PikaObj* self, int s) {
#if defined(__linux) #if defined(__linux)
sleep(s); sleep(s);
#elif defined(_WIN32) #elif defined(_WIN32)
@ -26,7 +26,7 @@ void PikaStdDevice_Time_sleep_s(PikaObj* self, int s) {
#endif #endif
} }
void PikaStdDevice_Time_platformGetTick(PikaObj* self) { void _time_platformGetTick(PikaObj* self) {
obj_setInt(self, "tick", __platform_getTick()); obj_setInt(self, "tick", __platform_getTick());
} }
@ -39,8 +39,8 @@ void PikaStdDevice_Time_platformGetTick(PikaObj* self) {
#include "stdint.h" #include "stdint.h"
#include "stdio.h" #include "stdio.h"
//结构体时间类型定义(来源c标准库corect_wtime.h) // 结构体时间类型定义(来源c标准库corect_wtime.h)
//无论是16位整数还是32位整数都满足需求 // 无论是16位整数还是32位整数都满足需求
typedef struct _tm { typedef struct _tm {
int tm_sec; // seconds after the minute - [0, 60] including leap second int tm_sec; // seconds after the minute - [0, 60] including leap second
int tm_min; // minutes after the hour - [0, 59] int tm_min; // minutes after the hour - [0, 59]
@ -53,16 +53,16 @@ typedef struct _tm {
int tm_isdst; // daylight savings time flag int tm_isdst; // daylight savings time flag
} _tm; } _tm;
//时间戳时间类型定义(来源c标准库time.h) // 时间戳时间类型定义(来源c标准库time.h)
//直接支持64位秒数时间附加时间精度为ns根据设备决定需要1GHz及以上时钟频率才能支持1ns级别时间精度 // 直接支持64位秒数时间附加时间精度为ns根据设备决定需要1GHz及以上时钟频率才能支持1ns级别时间精度
//内部时间比对数据类型,传递给外界的时候会使用浮点数,所以精度会降低 // 内部时间比对数据类型,传递给外界的时候会使用浮点数,所以精度会降低
//但内部使用复合数据类型比对,以实现平台支持的最小时间精度比较 // 但内部使用复合数据类型比对,以实现平台支持的最小时间精度比较
typedef struct { typedef struct {
int64_t tv_sec; // Seconds - >= 0 int64_t tv_sec; // Seconds - >= 0
int32_t tv_nsec; // Nanoseconds - [0, 999999999] int32_t tv_nsec; // Nanoseconds - [0, 999999999]
} _timespec; } _timespec;
//错误处理 // 错误处理
typedef int status; typedef int status;
#define TIME_OK 0 #define TIME_OK 0
@ -74,9 +74,9 @@ typedef int status;
#define TIME_LESS_THAN_1970 5 #define TIME_LESS_THAN_1970 5
#define TIME_ERROR_STRUCT_TIME 6 #define TIME_ERROR_STRUCT_TIME 6
//错误状态处理函数 // 错误状态处理函数
void status_deal(status s) { void status_deal(status s) {
//输出异常信息 // 输出异常信息
#define time_printf(...) __platform_printf(__VA_ARGS__) #define time_printf(...) __platform_printf(__VA_ARGS__)
time_printf("\n[Error-info]Checking a exception : "); time_printf("\n[Error-info]Checking a exception : ");
@ -108,59 +108,59 @@ void status_deal(status s) {
time_printf("\n"); time_printf("\n");
} }
//获取硬件平台的Unix时间戳,时间精度为1s级别 // 获取硬件平台的Unix时间戳,时间精度为1s级别
status time_get_unix_time(PikaObj* self, _timespec* this_timespec) { status time_get_unix_time(PikaObj* self, _timespec* this_timespec) {
this_timespec->tv_sec = (int64_t)(obj_getInt(self, "tick") / 1000); this_timespec->tv_sec = (int64_t)(obj_getInt(self, "tick") / 1000);
return TIME_OK; return TIME_OK;
} }
//获取硬件平台的Tick时间,时间精度为1s级别以下 // 获取硬件平台的Tick时间,时间精度为1s级别以下
//即1s的小数部分 // 即1s的小数部分
status time_get_tick_ns(PikaObj* self, _timespec* this_timespec) { status time_get_tick_ns(PikaObj* self, _timespec* this_timespec) {
this_timespec->tv_nsec = (obj_getInt(self, "tick") % 1000) * 1000000; this_timespec->tv_nsec = (obj_getInt(self, "tick") % 1000) * 1000000;
return TIME_OK; return TIME_OK;
} }
//标准time()方法,返回以浮点数表示的从 epoch 开始的秒数的时间值。 // 标准time()方法,返回以浮点数表示的从 epoch 开始的秒数的时间值。
// epoch 是 1970 年 1 月 1 日 00:00:00 (UTC) // epoch 是 1970 年 1 月 1 日 00:00:00 (UTC)
pika_float time_time(PikaObj* self) { pika_float time_time(PikaObj* self) {
status res = 0; //状态响应 status res = 0; // 状态响应
_timespec temp_timespec = {0}; _timespec temp_timespec = {0};
//调用硬件平台函数,获取当前时间 // 调用硬件平台函数,获取当前时间
res = time_get_unix_time(self, &temp_timespec); res = time_get_unix_time(self, &temp_timespec);
if (res) { if (res) {
status_deal(res); status_deal(res);
} //异常处理 } // 异常处理
res = time_get_tick_ns(self, &temp_timespec); res = time_get_tick_ns(self, &temp_timespec);
if (res) { if (res) {
status_deal(res); status_deal(res);
} //异常处理 } // 异常处理
//以浮点数返回时间float // 以浮点数返回时间float
return temp_timespec.tv_sec + return temp_timespec.tv_sec +
(pika_float)temp_timespec.tv_nsec / 1000000000; (pika_float)temp_timespec.tv_nsec / 1000000000;
} }
//标准time_ns()方法,返回以整数表示的从 epoch 开始的纳秒数的时间值。 // 标准time_ns()方法,返回以整数表示的从 epoch 开始的纳秒数的时间值。
// epoch 是 1970 年 1 月 1 日 00:00:00 (UTC) // epoch 是 1970 年 1 月 1 日 00:00:00 (UTC)
int64_t time_time_ns(PikaObj* self) { int64_t time_time_ns(PikaObj* self) {
status res = 0; //状态响应 status res = 0; // 状态响应
_timespec temp_timespec = {0}; _timespec temp_timespec = {0};
//调用硬件平台函数,获取当前时间 // 调用硬件平台函数,获取当前时间
res = time_get_unix_time(self, &temp_timespec); res = time_get_unix_time(self, &temp_timespec);
if (res) { if (res) {
status_deal(res); status_deal(res);
} //异常处理 } // 异常处理
res = time_get_tick_ns(self, &temp_timespec); res = time_get_tick_ns(self, &temp_timespec);
if (res) { if (res) {
status_deal(res); status_deal(res);
} //异常处理 } // 异常处理
//以浮点数返回时间float // 以浮点数返回时间float
return temp_timespec.tv_sec * 1000000000 + temp_timespec.tv_nsec; return temp_timespec.tv_sec * 1000000000 + temp_timespec.tv_nsec;
} }
//利用基姆拉尔森计算公式计算星期 // 利用基姆拉尔森计算公式计算星期
int time_get_week(const _tm* this_tm) { int time_get_week(const _tm* this_tm) {
//月份要+1 // 月份要+1
int month = this_tm->tm_mon + 1; int month = this_tm->tm_mon + 1;
int year = this_tm->tm_year; int year = this_tm->tm_year;
int day = this_tm->tm_mday; int day = this_tm->tm_mday;
@ -179,16 +179,16 @@ int time_get_week(const _tm* this_tm) {
return w; return w;
} }
//由Unix时间戳计算标准UTC时间 // 由Unix时间戳计算标准UTC时间
status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) { status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
int32_t total_day; int32_t total_day;
int32_t extra_second; int32_t extra_second;
int year_400, year_100, year_4, year_1; int year_400, year_100, year_4, year_1;
int february_offset, temp; //二月偏移量,零时变量 int february_offset, temp; // 二月偏移量,零时变量
//判断是否输入小于0的时间戳 // 判断是否输入小于0的时间戳
if (unix_time < 0) { if (unix_time < 0) {
//暂不支持小于0的时间戳 // 暂不支持小于0的时间戳
return TIME_LESS_THAN_ZERO; return TIME_LESS_THAN_ZERO;
} }
@ -198,31 +198,31 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
total_day = unix_time / DAY_SECOND; total_day = unix_time / DAY_SECOND;
extra_second = unix_time - total_day * DAY_SECOND; extra_second = unix_time - total_day * DAY_SECOND;
//为了减少额外闰年判断把时间往前推到1600年即闰年最大的一次公倍数开始计算判断 // 为了减少额外闰年判断把时间往前推到1600年即闰年最大的一次公倍数开始计算判断
// 1970-1600 = 370 年 370/4 -(370/100-1)=90 个闰年 // 1970-1600 = 370 年 370/4 -(370/100-1)=90 个闰年
// 1600 DAY_OFFSET 365*(1970-1600)+90 = 135140,7为修正天数 // 1600 DAY_OFFSET 365*(1970-1600)+90 = 135140,7为修正天数
#define YEAR_START (1600) //初始年份 #define YEAR_START (1600) // 初始年份
#define DAY_OFFSET (135140) //时间偏移量 #define DAY_OFFSET (135140) // 时间偏移量
total_day += DAY_OFFSET; total_day += DAY_OFFSET;
//从1600年到3200年有1600/4-(1600/100-1600/400)=388个闰年 // 从1600年到3200年有1600/4-(1600/100-1600/400)=388个闰年
//即 MAX_DAY 1600*365+388=584388 day // 即 MAX_DAY 1600*365+388=584388 day
#define MAX_DAY (584388) //最大可判断时间天数 #define MAX_DAY (584388) // 最大可判断时间天数
if (total_day > MAX_DAY) { if (total_day > MAX_DAY) {
//超过3200年的换算暂不支持 // 超过3200年的换算暂不支持
return TIME_OVER_3200; return TIME_OVER_3200;
} else { } else {
//从1600年开始天数都要多减一天因为1600年是闰年 // 从1600年开始天数都要多减一天因为1600年是闰年
//但是由于日期不包含当天时间即2月2号实际是2月1号+时:分:秒 // 但是由于日期不包含当天时间即2月2号实际是2月1号+时:分:秒
//所以算出来的日期要加上一天 // 所以算出来的日期要加上一天
//两者配合,无需加减 // 两者配合,无需加减
//从400年100年4年逐渐缩小范围 // 从400年100年4年逐渐缩小范围
// 400个公历年天数为365*400+97=146097天 // 400个公历年天数为365*400+97=146097天
// 400年内的100个公历年天数为365*100+24=36524天 // 400年内的100个公历年天数为365*100+24=36524天
// 100年内的4年365*4+1=1461天 // 100年内的4年365*4+1=1461天
#define DAY_OF_400Y (146097) #define DAY_OF_400Y (146097)
#define DAY_OF_100Y (36524) #define DAY_OF_100Y (36524)
#define DAY_OF_4Y (1461) #define DAY_OF_4Y (1461)
@ -230,56 +230,56 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
// 400年也要注意要实际401年才可 // 400年也要注意要实际401年才可
year_400 = (total_day - 366) / DAY_OF_400Y; year_400 = (total_day - 366) / DAY_OF_400Y;
total_day -= year_400 * DAY_OF_400Y; total_day -= year_400 * DAY_OF_400Y;
//计算400年内的情况 // 计算400年内的情况
year_100 = (total_day - 1) / DAY_OF_100Y; year_100 = (total_day - 1) / DAY_OF_100Y;
total_day -= year_100 * DAY_OF_100Y; total_day -= year_100 * DAY_OF_100Y;
//计算100年内的情况要到第二年的第一天才算即365+1 // 计算100年内的情况要到第二年的第一天才算即365+1
year_4 = (total_day - 366) / DAY_OF_4Y; year_4 = (total_day - 366) / DAY_OF_4Y;
//计算4年需要格外注意0-5-8年才会计算一个闰年因为它才包含了4这个闰年但并不包含8 // 计算4年需要格外注意0-5-8年才会计算一个闰年因为它才包含了4这个闰年但并不包含8
total_day -= year_4 * DAY_OF_4Y; total_day -= year_4 * DAY_OF_4Y;
//计算4年内的情况 // 计算4年内的情况
//需要减去1天因为当天是不存在的 // 需要减去1天因为当天是不存在的
//需要注意闰年会多一天 // 需要注意闰年会多一天
//所有闰年都放在这里来考虑,即只要当前是闰年,那么这里就会剩下第一年闰年和第四年闰年两种情况 // 所有闰年都放在这里来考虑,即只要当前是闰年,那么这里就会剩下第一年闰年和第四年闰年两种情况
if (year_100 == 4) { if (year_100 == 4) {
//第一年是闰年,此时为400*n+1年内 // 第一年是闰年,此时为400*n+1年内
year_1 = 0; year_1 = 0;
february_offset = 1; february_offset = 1;
} else if (total_day <= DAY_OF_1Y * 4) { } else if (total_day <= DAY_OF_1Y * 4) {
// 100*n+(4,8,...96)+1年都是从第二年算起非闰年 // 100*n+(4,8,...96)+1年都是从第二年算起非闰年
//非闰年,需要减去1天因为当天是不存在的 // 非闰年,需要减去1天因为当天是不存在的
year_1 = (total_day - 1) / DAY_OF_1Y; year_1 = (total_day - 1) / DAY_OF_1Y;
total_day -= year_1 * DAY_OF_1Y; total_day -= year_1 * DAY_OF_1Y;
february_offset = 0; february_offset = 0;
} else { } else {
//第四年是闰年 // 第四年是闰年
year_1 = 4; year_1 = 4;
total_day -= year_1 * DAY_OF_1Y; total_day -= year_1 * DAY_OF_1Y;
february_offset = 1; february_offset = 1;
} }
//计算出当前年份 // 计算出当前年份
this_tm->tm_year = this_tm->tm_year =
(year_400 * 400 + year_100 * 100 + year_4 * 4 + year_1) + (year_400 * 400 + year_100 * 100 + year_4 * 4 + year_1) +
YEAR_START; YEAR_START;
//保存一年的天数 // 保存一年的天数
this_tm->tm_yday = total_day; this_tm->tm_yday = total_day;
//剩下的天数为1年内的天数,直接计算月和日 // 剩下的天数为1年内的天数,直接计算月和日
//根据当前是否为闰年设置二月偏移量是否为1 // 根据当前是否为闰年设置二月偏移量是否为1
//能被4整除且不被100整除或者能被400整除 // 能被4整除且不被100整除或者能被400整除
//闰年需要减去一天再计算 // 闰年需要减去一天再计算
total_day -= february_offset; total_day -= february_offset;
//使用二分法快速定位月份使用平年计算在月份确定到2月时再考虑闰年 // 使用二分法快速定位月份使用平年计算在月份确定到2月时再考虑闰年
//判断是否在1-6月里面 // 判断是否在1-6月里面
// 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 // 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
if (total_day <= 181) { if (total_day <= 181) {
//判断是否在1-3月里面 // 判断是否在1-3月里面
if (total_day <= 90) { if (total_day <= 90) {
//判断是否在1-2月里面 // 判断是否在1-2月里面
if (total_day <= 59) { if (total_day <= 59) {
total_day += february_offset; //去掉二月的偏置 total_day += february_offset; // 去掉二月的偏置
if (total_day <= 31) { if (total_day <= 31) {
// 1月 // 1月
temp = 0; temp = 0;
@ -296,7 +296,7 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
} else { } else {
// 4-6月 // 4-6月
total_day -= 90; total_day -= 90;
//是否在4月里面 // 是否在4月里面
if (total_day <= 30) { if (total_day <= 30) {
// 4月 // 4月
temp = 3; temp = 3;
@ -315,9 +315,9 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
} }
} else { } else {
total_day -= 181; total_day -= 181;
//判断是否在7-9月里面 // 判断是否在7-9月里面
if (total_day <= 92) { if (total_day <= 92) {
//是否在7-8月 // 是否在7-8月
if (total_day <= 62) { if (total_day <= 62) {
if (total_day <= 31) { if (total_day <= 31) {
// 7月 // 7月
@ -335,7 +335,7 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
} else { } else {
// 10-12月 // 10-12月
total_day -= 92; total_day -= 92;
//是否在10-11月 // 是否在10-11月
if (total_day <= 61) { if (total_day <= 61) {
if (total_day <= 31) { if (total_day <= 31) {
// 10月 // 10月
@ -353,11 +353,11 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
} }
} }
//记录当前月份和天数 // 记录当前月份和天数
this_tm->tm_mon = temp; //月份 [0,11] this_tm->tm_mon = temp; // 月份 [0,11]
this_tm->tm_mday = total_day; //天数 this_tm->tm_mday = total_day; // 天数
//利用额外秒数计算时-分-秒 // 利用额外秒数计算时-分-秒
temp = extra_second / 3600; temp = extra_second / 3600;
this_tm->tm_hour = temp; this_tm->tm_hour = temp;
extra_second = extra_second - temp * 3600; extra_second = extra_second - temp * 3600;
@ -368,70 +368,70 @@ status unix_time_to_utc_struct_time(_tm* this_tm, int64_t unix_time) {
this_tm->tm_sec = extra_second; this_tm->tm_sec = extra_second;
//计算出当前日期的星期数 // 计算出当前日期的星期数
this_tm->tm_wday = time_get_week(this_tm); this_tm->tm_wday = time_get_week(this_tm);
//夏令时不明 // 夏令时不明
this_tm->tm_isdst = -1; this_tm->tm_isdst = -1;
} }
return TIME_OK; return TIME_OK;
} }
//由标准UTC时间生成Unix时间戳 // 由标准UTC时间生成Unix时间戳
status utc_struct_time_to_unix_time(const _tm* this_tm, int64_t* unix_time) { status utc_struct_time_to_unix_time(const _tm* this_tm, int64_t* unix_time) {
int32_t total_day, total_leap_year, dyear; int32_t total_day, total_leap_year, dyear;
int february_offset; //二月偏移量,零时变量 int february_offset; // 二月偏移量,零时变量
// 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 // 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
//每个月份对应前面所有月的天数 // 每个月份对应前面所有月的天数
const int month_day[] = {0, 31, 59, 90, 120, 151, const int month_day[] = {0, 31, 59, 90, 120, 151,
181, 212, 243, 273, 304, 334}; 181, 212, 243, 273, 304, 334};
//每天总秒数一定将UTC时间年月转换成天数 // 每天总秒数一定将UTC时间年月转换成天数
//为了减少额外闰年判断把时间往前推到1600年即闰年最大的一次公倍数开始计算判断 // 为了减少额外闰年判断把时间往前推到1600年即闰年最大的一次公倍数开始计算判断
// 1970-1600 = 370 年 370/4 -(370/100-1)=90 个闰年 // 1970-1600 = 370 年 370/4 -(370/100-1)=90 个闰年
// 1600 DAY_OFFSET 365*(1970-1600)+90 = 135140,7为修正天数 // 1600 DAY_OFFSET 365*(1970-1600)+90 = 135140,7为修正天数
if (this_tm->tm_year < 1970) { if (this_tm->tm_year < 1970) {
//暂不支持1970之前的时间 // 暂不支持1970之前的时间
*unix_time = 0; *unix_time = 0;
return TIME_LESS_THAN_1970; return TIME_LESS_THAN_1970;
} }
if (this_tm->tm_year >= 3200) { if (this_tm->tm_year >= 3200) {
//暂不支持3200及以后的时间 // 暂不支持3200及以后的时间
*unix_time = 0; *unix_time = 0;
return TIME_OVER_3200; return TIME_OVER_3200;
} }
//计算总年数要去掉尾巴如年数20年那么实际应该4个闰年因为20这一年没有包含在里面 // 计算总年数要去掉尾巴如年数20年那么实际应该4个闰年因为20这一年没有包含在里面
//要减去一年来算闰年次数 // 要减去一年来算闰年次数
//先计算到相对1600年的天数再转换到1970年 // 先计算到相对1600年的天数再转换到1970年
dyear = this_tm->tm_year - YEAR_START - 1; dyear = this_tm->tm_year - YEAR_START - 1;
total_leap_year = dyear / 4 - (dyear / 100 - dyear / 400 - 1); total_leap_year = dyear / 4 - (dyear / 100 - dyear / 400 - 1);
//恢复减去的一年 // 恢复减去的一年
dyear += 1; dyear += 1;
total_day = dyear * 365 + total_leap_year; total_day = dyear * 365 + total_leap_year;
//减去1970到1600的总天数 // 减去1970到1600的总天数
total_day -= DAY_OFFSET; total_day -= DAY_OFFSET;
//增加月和日的总天数 // 增加月和日的总天数
//判断是否是闰年 // 判断是否是闰年
//能被4整除且不被100整除或者能被400整除 // 能被4整除且不被100整除或者能被400整除
if (((dyear % 4 == 0) && (dyear % 100 != 0)) || (dyear % 400 == 0)) { if (((dyear % 4 == 0) && (dyear % 100 != 0)) || (dyear % 400 == 0)) {
//闰年 // 闰年
february_offset = 1; february_offset = 1;
} else { } else {
february_offset = 0; february_offset = 0;
} }
//计算含月和日的总天数,日期要减去当天 // 计算含月和日的总天数,日期要减去当天
total_day += month_day[this_tm->tm_mon] + this_tm->tm_mday - 1; total_day += month_day[this_tm->tm_mon] + this_tm->tm_mday - 1;
//二月以上需要加上偏移量 // 二月以上需要加上偏移量
if (this_tm->tm_mon > 1) { if (this_tm->tm_mon > 1) {
total_day += february_offset; total_day += february_offset;
} }
//根据天数以及时分秒计算Unix时间戳 // 根据天数以及时分秒计算Unix时间戳
*unix_time = (int64_t)total_day * DAY_SECOND + this_tm->tm_hour * 3600 + *unix_time = (int64_t)total_day * DAY_SECOND + this_tm->tm_hour * 3600 +
this_tm->tm_min * 60 + this_tm->tm_sec; this_tm->tm_min * 60 + this_tm->tm_sec;
@ -447,41 +447,41 @@ void time_struct_format(const _tm* this_tm, char* str) {
this_tm->tm_wday, this_tm->tm_yday, this_tm->tm_isdst); this_tm->tm_wday, this_tm->tm_yday, this_tm->tm_isdst);
} }
//标准库函数gmtime,将以自 epoch 开始的秒数表示的时间转换为 UTC 的 struct_time // 标准库函数gmtime,将以自 epoch 开始的秒数表示的时间转换为 UTC 的 struct_time
void time_gmtime(pika_float unix_time, _tm* this_tm) { void time_gmtime(pika_float unix_time, _tm* this_tm) {
status res; status res;
//转化时间 // 转化时间
res = unix_time_to_utc_struct_time(this_tm, (int64_t)unix_time); res = unix_time_to_utc_struct_time(this_tm, (int64_t)unix_time);
if (res) { if (res) {
status_deal(res); //异常情况处理 status_deal(res); // 异常情况处理
//返回默认值 // 返回默认值
// note: 异常情况返回默认时间起始点 // note: 异常情况返回默认时间起始点
unix_time_to_utc_struct_time(this_tm, (int64_t)0); unix_time_to_utc_struct_time(this_tm, (int64_t)0);
} }
} }
//标准库函数localtime,将以自 epoch 开始的秒数表示的时间转换为当地时间的 // 标准库函数localtime,将以自 epoch 开始的秒数表示的时间转换为当地时间的
// struct_time // struct_time
void time_localtime(pika_float unix_time, _tm* this_tm, int locale) { void time_localtime(pika_float unix_time, _tm* this_tm, int locale) {
status res; status res;
int local_offset; int local_offset;
//获取本地时间偏移量(小时) // 获取本地时间偏移量(小时)
local_offset = locale * 60 * 60; local_offset = locale * 60 * 60;
//转化时间 // 转化时间
res = unix_time_to_utc_struct_time(this_tm, res = unix_time_to_utc_struct_time(this_tm,
(int64_t)unix_time + local_offset); (int64_t)unix_time + local_offset);
if (res) { if (res) {
status_deal(res); //异常情况处理 status_deal(res); // 异常情况处理
//这里处理的策略和标准库不同标准库最初始的时间是1970-1-1,00:00:00对于不同时区来说其值是不一样的 // 这里处理的策略和标准库不同标准库最初始的时间是1970-1-1,00:00:00对于不同时区来说其值是不一样的
//但本函数是要求各时区的起始时间不超过1970-1-1,00:00:00实际上UTC时间可以更前可靠的最早时间可到1600年 // 但本函数是要求各时区的起始时间不超过1970-1-1,00:00:00实际上UTC时间可以更前可靠的最早时间可到1600年
//对于西时区来说,时间会缺失 // 对于西时区来说,时间会缺失
unix_time_to_utc_struct_time(this_tm, (int64_t)0); unix_time_to_utc_struct_time(this_tm, (int64_t)0);
} }
} }
//检测结构体时间是否在合适的范围内,但不检查它的正确性 // 检测结构体时间是否在合适的范围内,但不检查它的正确性
status time_check_struct_time(const _tm* this_tm) { status time_check_struct_time(const _tm* this_tm) {
if (this_tm->tm_sec < 0 || this_tm->tm_sec > 60) { if (this_tm->tm_sec < 0 || this_tm->tm_sec > 60) {
return TIME_ERROR_STRUCT_TIME; return TIME_ERROR_STRUCT_TIME;
@ -507,47 +507,47 @@ status time_check_struct_time(const _tm* this_tm) {
return TIME_OK; return TIME_OK;
} }
//标准库函数mktime(t),将当地时间的 // 标准库函数mktime(t),将当地时间的
// struct_time转换为以自epoch开始的秒数表示的时间 // struct_time转换为以自epoch开始的秒数表示的时间
int64_t time_mktime(const _tm* this_tm, int locale) { int64_t time_mktime(const _tm* this_tm, int locale) {
status res; status res;
int local_offset; int local_offset;
int64_t unix_time; int64_t unix_time;
//获取本地时间偏移量(小时) // 获取本地时间偏移量(小时)
local_offset = locale * 60 * 60; local_offset = locale * 60 * 60;
//检测时间结构体范围正确性 // 检测时间结构体范围正确性
res = time_check_struct_time(this_tm); res = time_check_struct_time(this_tm);
if (res) { if (res) {
status_deal(res); status_deal(res);
return 0; return 0;
} //异常情况返回时间零点 } // 异常情况返回时间零点
//转化时间 // 转化时间
res = utc_struct_time_to_unix_time(this_tm, &unix_time); res = utc_struct_time_to_unix_time(this_tm, &unix_time);
if (res) { if (res) {
status_deal(res); status_deal(res);
return 0; return 0;
} //异常情况返回时间零点 } // 异常情况返回时间零点
//减去本地偏移时间 // 减去本地偏移时间
//可能出现负数,严格来说,这不影响什么! // 可能出现负数,严格来说,这不影响什么!
unix_time -= local_offset; unix_time -= local_offset;
//显示出来 // 显示出来
// time_printf("%I64d\n",unix_time); // time_printf("%I64d\n",unix_time);
//返回数据 // 返回数据
return unix_time; return unix_time;
} }
//标准库函数asctime() // 标准库函数asctime()
//把结构化时间struct_time元组表示为以下形式的字符串: `'Sun Jun 20 23:21:05 // 把结构化时间struct_time元组表示为以下形式的字符串: `'Sun Jun 20 23:21:05
// 1993'`。 // 1993'`。
void time_asctime(const _tm* this_tm) { void time_asctime(const _tm* this_tm) {
//星期缩写python标准库是三个字母这里并不相同 // 星期缩写python标准库是三个字母这里并不相同
const char* week[] = {"Sun", "Mon", "Tues", "Wed", "Thur", "Fri", "Sat"}; const char* week[] = {"Sun", "Mon", "Tues", "Wed", "Thur", "Fri", "Sat"};
//月份缩写 // 月份缩写
const char* month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", const char* month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sept", "Oct", "Nov", "Dec"}; "Jul", "Aug", "Sept", "Oct", "Nov", "Dec"};
@ -559,7 +559,7 @@ void time_asctime(const _tm* this_tm) {
time_printf("%s\n", str); time_printf("%s\n", str);
} }
pika_float PikaStdDevice_Time_time(PikaObj* self) { pika_float _time_time(PikaObj* self) {
/* run platformGetTick() */ /* run platformGetTick() */
PIKA_PYTHON_BEGIN PIKA_PYTHON_BEGIN
/* clang-format off */ /* clang-format off */
@ -579,7 +579,7 @@ pika_float PikaStdDevice_Time_time(PikaObj* self) {
return time_time(self); return time_time(self);
} }
int PikaStdDevice_Time_time_ns(PikaObj* self) { int _time_time_ns(PikaObj* self) {
return time_time_ns(self); return time_time_ns(self);
} }
@ -603,7 +603,7 @@ void time_set_tm_value(PikaObj* self, const _tm* this_tm) {
#endif #endif
} }
void PikaStdDevice_Time_gmtime(PikaObj* self, pika_float unix_time) { void _time_gmtime(PikaObj* self, pika_float unix_time) {
#if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE #if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE
obj_setErrorCode(self, 1); obj_setErrorCode(self, 1);
obj_setSysOut( obj_setSysOut(
@ -613,14 +613,14 @@ void PikaStdDevice_Time_gmtime(PikaObj* self, pika_float unix_time) {
char str[200]; char str[200];
time_gmtime(unix_time, &this_tm); time_gmtime(unix_time, &this_tm);
time_set_tm_value(self, &this_tm); time_set_tm_value(self, &this_tm);
//格式化字符 // 格式化字符
time_struct_format(&this_tm, str); time_struct_format(&this_tm, str);
//显示出来 // 显示出来
time_printf("%s\n", str); time_printf("%s\n", str);
#endif #endif
} }
void PikaStdDevice_Time_localtime(PikaObj* self, pika_float unix_time) { void _time_localtime(PikaObj* self, pika_float unix_time) {
#if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE #if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE
obj_setErrorCode(self, 1); obj_setErrorCode(self, 1);
obj_setSysOut( obj_setSysOut(
@ -631,9 +631,9 @@ void PikaStdDevice_Time_localtime(PikaObj* self, pika_float unix_time) {
int locale = obj_getInt(self, "locale"); int locale = obj_getInt(self, "locale");
time_localtime(unix_time, &this_tm, locale); time_localtime(unix_time, &this_tm, locale);
time_set_tm_value(self, &this_tm); time_set_tm_value(self, &this_tm);
//格式化字符 // 格式化字符
time_struct_format(&this_tm, str); time_struct_format(&this_tm, str);
//显示出来 // 显示出来
time_printf("%s\n", str); time_printf("%s\n", str);
#endif #endif
} }
@ -656,7 +656,7 @@ void time_get_tm_value(PikaObj* self, _tm* this_tm) {
#endif #endif
} }
int PikaStdDevice_Time_mktime(PikaObj* self) { int _time_mktime(PikaObj* self) {
#if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE #if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE
obj_setErrorCode(self, 1); obj_setErrorCode(self, 1);
obj_setSysOut( obj_setSysOut(
@ -670,7 +670,7 @@ int PikaStdDevice_Time_mktime(PikaObj* self) {
#endif #endif
} }
void PikaStdDevice_Time_asctime(PikaObj* self) { void _time_asctime(PikaObj* self) {
#if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE #if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE
obj_setErrorCode(self, 1); obj_setErrorCode(self, 1);
obj_setSysOut( obj_setSysOut(
@ -681,7 +681,7 @@ void PikaStdDevice_Time_asctime(PikaObj* self) {
time_asctime(&this_tm); time_asctime(&this_tm);
#endif #endif
} }
void PikaStdDevice_Time_ctime(PikaObj* self, pika_float unix_time) { void _time_ctime(PikaObj* self, pika_float unix_time) {
#if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE #if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE
obj_setErrorCode(self, 1); obj_setErrorCode(self, 1);
obj_setSysOut( obj_setSysOut(
@ -694,7 +694,7 @@ void PikaStdDevice_Time_ctime(PikaObj* self, pika_float unix_time) {
#endif #endif
} }
void PikaStdDevice_Time___init__(PikaObj* self) { void _time___init__(PikaObj* self) {
#if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE #if !PIKA_STD_DEVICE_UNIX_TIME_ENABLE
#else #else
_tm this_tm; _tm this_tm;
@ -704,7 +704,7 @@ void PikaStdDevice_Time___init__(PikaObj* self) {
#endif #endif
} }
void PikaStdDevice_Time_sleep(PikaObj* self, pika_float s) { void _time_sleep(PikaObj* self, pika_float s) {
Args* args = New_args(NULL); Args* args = New_args(NULL);
args_setInt(args, "ms", s * 1000); args_setInt(args, "ms", s * 1000);
obj_runNativeMethod(self, "sleep_ms", args); obj_runNativeMethod(self, "sleep_ms", args);

View File

@ -0,0 +1,41 @@
import _time
def sleep(s: float):
return _time.sleep(s)
def sleep_s(s: int):
return _time.sleep_s(s)
def sleep_ms(ms: int):
return _time.sleep_ms(ms)
def time() -> float:
return _time.time()
def time_ns() -> int:
return _time.time_ns()
def gmtime(unix_time: float):
return _time.gmtime(unix_time)
def localtime(unix_time: float):
return _time.localtime(unix_time)
def mktime() -> int:
return _time.mktime()
def asctime() -> str:
return _time.asctime()
def ctime(unix_time: float) -> str:
return _time.ctime(unix_time)

View File

@ -21,6 +21,12 @@ void pika_platform_printf(char* fmt, ...) {
} }
} }
static volatile uint64_t tick_ms = 0;
int64_t pika_platform_getTick(void) {
tick_ms += 50;
return tick_ms;
}
/* quick_malloc is always open */ /* quick_malloc is always open */
uint8_t __is_quick_malloc(void) { uint8_t __is_quick_malloc(void) {
// return 1; // return 1;

View File

@ -20,10 +20,12 @@ TEST(unix_time, time) {
pikaMemInfo.heapUsedMax = 0; pikaMemInfo.heapUsedMax = 0;
/* run */ /* run */
PikaObj* self = newRootObj("pikaMain", New_PikaMain); PikaObj* self = newRootObj("pikaMain", New_PikaMain);
extern unsigned char pikaModules_py_a[];
obj_linkLibrary(self, pikaModules_py_a);
obj_run(self, obj_run(self,
"mytime = TemplateDevice.Time()\n" "import time\n"
"t1= mytime.time()\n" "t1= time.time()\n"
"t2= mytime.time()\n"); "t2= time.time()\n");
/* 获取数据比对 */ /* 获取数据比对 */
float t1 = obj_getFloat(self, "t1"); float t1 = obj_getFloat(self, "t1");
float t2 = obj_getFloat(self, "t2"); float t2 = obj_getFloat(self, "t2");
@ -42,19 +44,21 @@ TEST(unix_time, unix_time) {
pikaMemInfo.heapUsedMax = 0; pikaMemInfo.heapUsedMax = 0;
/* run */ /* run */
PikaObj* self = newRootObj("pikaMain", New_PikaMain); PikaObj* self = newRootObj("pikaMain", New_PikaMain);
extern unsigned char pikaModules_py_a[];
obj_linkLibrary(self, pikaModules_py_a);
obj_run(self, obj_run(self,
"mytime = PikaStdDevice.Time()\n" "import time\n"
"mytime.localtime(0.0)\n"); "time.localtime(0.0)\n");
/* 获取数据比对 */ /* 获取数据比对 */
int tm_sec = obj_getInt(self, "mytime.tm_sec"); int tm_sec = obj_getInt(self, "time._time.tm_sec");
int tm_min = obj_getInt(self, "mytime.tm_min"); int tm_min = obj_getInt(self, "time._time.tm_min");
int tm_hour = obj_getInt(self, "mytime.tm_hour"); int tm_hour = obj_getInt(self, "time._time.tm_hour");
int tm_mday = obj_getInt(self, "mytime.tm_mday"); int tm_mday = obj_getInt(self, "time._time.tm_mday");
int tm_mon = obj_getInt(self, "mytime.tm_mon"); int tm_mon = obj_getInt(self, "time._time.tm_mon");
int tm_year = obj_getInt(self, "mytime.tm_year"); int tm_year = obj_getInt(self, "time._time.tm_year");
int tm_wday = obj_getInt(self, "mytime.tm_wday"); int tm_wday = obj_getInt(self, "time._time.tm_wday");
int tm_yday = obj_getInt(self, "mytime.tm_yday"); int tm_yday = obj_getInt(self, "time._time.tm_yday");
int tm_isdst = obj_getInt(self, "mytime.tm_isdst"); int tm_isdst = obj_getInt(self, "time._time.tm_isdst");
/* assert */ /* assert */
EXPECT_EQ(tm_sec, 0); EXPECT_EQ(tm_sec, 0);
EXPECT_EQ(tm_min, 0); EXPECT_EQ(tm_min, 0);
@ -62,7 +66,7 @@ TEST(unix_time, unix_time) {
EXPECT_EQ(tm_mday, 1); EXPECT_EQ(tm_mday, 1);
EXPECT_EQ(tm_mon, 0); // 1月 EXPECT_EQ(tm_mon, 0); // 1月
EXPECT_EQ(tm_year, 1970); EXPECT_EQ(tm_year, 1970);
EXPECT_EQ(tm_wday, 4); //周四 EXPECT_EQ(tm_wday, 4); // 周四
EXPECT_EQ(tm_yday, 1); EXPECT_EQ(tm_yday, 1);
EXPECT_EQ(tm_isdst, -1); EXPECT_EQ(tm_isdst, -1);
/* deinit */ /* deinit */
@ -72,7 +76,7 @@ TEST(unix_time, unix_time) {
#endif #endif
int compare(const _tm* t1, const _tm* t2) { int compare(const _tm* t1, const _tm* t2) {
int size = 8; //只比对前面8个数据 int size = 8; // 只比对前面8个数据
int* it1 = (int*)t1; int* it1 = (int*)t1;
int* it2 = (int*)t2; int* it2 = (int*)t2;
for (int i = 0; i < size; i++) { for (int i = 0; i < size; i++) {
@ -113,7 +117,7 @@ TEST(unix_time, iteration_form_1970_to_2070) {
temp2->tm_year += 1900; temp2->tm_year += 1900;
if (compare(&temp1, temp2)) { if (compare(&temp1, temp2)) {
printf("error!\n"); printf("error!\n");
//格式化字符 // 格式化字符
time_struct_format(&temp1, str); time_struct_format(&temp1, str);
printf("%s\n", str); printf("%s\n", str);
time_struct_format(temp2, str); time_struct_format(temp2, str);