libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[DeviceDriver][RTC] Remove RT_DEVICE_CTRL_RTC_GET_TIME_US and RT_DEVICE_CTRL_RTC_SET_TIME_US. Add RT_DEVICE_CTRL_RTC_GET_TIMEVAL and RT_DEVICE_CTRL_RTC_SET_TIMEVAL. The RT_DEVICE_CTRL_RTC_GET_TIMEVAL cmd can get second time and microsecond time.

This commit is contained in:
armink 2021-09-29 17:12:27 +08:00
parent 1e36db0c38
commit ff0b6d241b
2 changed files with 42 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
components/drivers/include/drivers/rtc.h
View File

@ -15,12 +15,12 @@
#include <rtdef.h> #include <rtdef.h>
#define RT_DEVICE_CTRL_RTC_GET_TIME 0x10 /**< get second time */ #define RT_DEVICE_CTRL_RTC_GET_TIME 0x20 /**< get second time */
#define RT_DEVICE_CTRL_RTC_SET_TIME 0x11 /**< set second time */ #define RT_DEVICE_CTRL_RTC_SET_TIME 0x21 /**< set second time */
#define RT_DEVICE_CTRL_RTC_GET_TIME_US 0x12 /**< get microsecond time */ #define RT_DEVICE_CTRL_RTC_GET_TIMEVAL 0x22 /**< get timeval for gettimeofday */
#define RT_DEVICE_CTRL_RTC_SET_TIME_US 0x13 /**< set microsecond time */ #define RT_DEVICE_CTRL_RTC_SET_TIMEVAL 0x23 /**< set timeval for gettimeofday */
#define RT_DEVICE_CTRL_RTC_GET_ALARM 0x14 /**< get alarm */ #define RT_DEVICE_CTRL_RTC_GET_ALARM 0x24 /**< get alarm */
#define RT_DEVICE_CTRL_RTC_SET_ALARM 0x15 /**< set alarm */ #define RT_DEVICE_CTRL_RTC_SET_ALARM 0x25 /**< set alarm */
struct rt_rtc_ops struct rt_rtc_ops
{ {

148
components/libc/compilers/common/time.c
View File

@ -18,21 +18,23 @@
* 2021-02-12 Meco Man move all of the functions located in <clock_time.c> to this file * 2021-02-12 Meco Man move all of the functions located in <clock_time.c> to this file
* 2021-03-15 Meco Man fixed a bug of leaking memory in asctime() * 2021-03-15 Meco Man fixed a bug of leaking memory in asctime()
* 2021-05-01 Meco Man support fixed timezone * 2021-05-01 Meco Man support fixed timezone
* 2021-07-21 Meco Man implement that change/set timezone APIs
*/ */
#include "sys/time.h" #include "sys/time.h"
#include <sys/errno.h>
#include <rtthread.h> #include <rtthread.h>
#include <rthw.h>
#ifdef RT_USING_DEVICE #ifdef RT_USING_DEVICE
#include <rtdevice.h> #include <rtdevice.h>
#endif #endif
#define DBG_TAG "time" #define DBG_TAG "TIME"
#define DBG_LVL DBG_INFO #define DBG_LVL DBG_INFO
#include <rtdbg.h> #include <rtdbg.h>
#ifndef RT_LIBC_FIXED_TIMEZONE
#define RT_LIBC_FIXED_TIMEZONE 8 /* UTC+8 */
#endif
/* seconds per day */ /* seconds per day */
#define SPD 24*60*60 #define SPD 24*60*60
@ -101,7 +103,7 @@ static rt_err_t get_timeval(struct timeval *tv)
if (rt_device_open(device, 0) == RT_EOK) if (rt_device_open(device, 0) == RT_EOK)
{ {
rst = rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &tv->tv_sec); rst = rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &tv->tv_sec);
rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME_US, &tv->tv_usec); rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIMEVAL, tv);
rt_device_close(device); rt_device_close(device);
} }
} }
@ -147,7 +149,7 @@ static int set_timeval(struct timeval *tv)
if (rt_device_open(device, 0) == RT_EOK) if (rt_device_open(device, 0) == RT_EOK)
{ {
rst = rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIME, &tv->tv_sec); rst = rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIME, &tv->tv_sec);
rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIME_US, &tv->tv_usec); rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIMEVAL, tv);
rt_device_close(device); rt_device_close(device);
} }
} }
@ -199,7 +201,7 @@ struct tm *gmtime_r(const time_t *timep, struct tm *r)
r->tm_mon = i; r->tm_mon = i;
r->tm_mday += work - __spm[i]; r->tm_mday += work - __spm[i];
r->tm_isdst = tz_is_dst(); r->tm_isdst = 0;
return r; return r;
} }
RTM_EXPORT(gmtime_r); RTM_EXPORT(gmtime_r);
@ -215,7 +217,7 @@ struct tm* localtime_r(const time_t* t, struct tm* r)
{ {
time_t local_tz; time_t local_tz;
local_tz = *t + tz_get() * 3600; local_tz = *t + RT_LIBC_FIXED_TIMEZONE * 3600;
return gmtime_r(&local_tz, r); return gmtime_r(&local_tz, r);
} }
RTM_EXPORT(localtime_r); RTM_EXPORT(localtime_r);
@ -232,36 +234,13 @@ time_t mktime(struct tm * const t)
time_t timestamp; time_t timestamp;
timestamp = timegm(t); timestamp = timegm(t);
timestamp = timestamp - 3600 * tz_get(); timestamp = timestamp - 3600 * RT_LIBC_FIXED_TIMEZONE;
return timestamp; return timestamp;
} }
RTM_EXPORT(mktime); RTM_EXPORT(mktime);
char* asctime_r(const struct tm *t, char *buf) char* asctime_r(const struct tm *t, char *buf)
{ {
/* Checking input validity */
if (rt_strlen(days) <= (t->tm_wday << 2) || rt_strlen(months) <= (t->tm_mon << 2))
{
LOG_W("asctime_r: the input parameters exceeded the limit, please check it.");
*(int*) buf = *(int*) days;
*(int*) (buf + 4) = *(int*) months;
num2str(buf + 8, t->tm_mday);
if (buf[8] == '0')
buf[8] = ' ';
buf[10] = ' ';
num2str(buf + 11, t->tm_hour);
buf[13] = ':';
num2str(buf + 14, t->tm_min);
buf[16] = ':';
num2str(buf + 17, t->tm_sec);
buf[19] = ' ';
num2str(buf + 20, 2000 / 100);
num2str(buf + 22, 2000 % 100);
buf[24] = '\n';
buf[25] = '\0';
return buf;
}
/* "Wed Jun 30 21:49:08 1993\n" */ /* "Wed Jun 30 21:49:08 1993\n" */
*(int*) buf = *(int*) (days + (t->tm_wday << 2)); *(int*) buf = *(int*) (days + (t->tm_wday << 2));
*(int*) (buf + 4) = *(int*) (months + (t->tm_mon << 2)); *(int*) (buf + 4) = *(int*) (months + (t->tm_mon << 2));
@ -446,7 +425,7 @@ int gettimeofday(struct timeval *tv, struct timezone *tz)
if(tz != RT_NULL) if(tz != RT_NULL)
{ {
tz->tz_dsttime = DST_NONE; tz->tz_dsttime = DST_NONE;
tz->tz_minuteswest = -(tz_get() * 60); tz->tz_minuteswest = -(RT_LIBC_FIXED_TIMEZONE * 60);
} }
if (tv != RT_NULL && get_timeval(tv) == RT_EOK) if (tv != RT_NULL && get_timeval(tv) == RT_EOK)
@ -469,6 +448,7 @@ int settimeofday(const struct timeval *tv, const struct timezone *tz)
* Thus, the following is purely of historic interest. * Thus, the following is purely of historic interest.
*/ */
if (tv != RT_NULL if (tv != RT_NULL
&& tv->tv_sec >= 0
&& tv->tv_usec >= 0 && tv->tv_usec >= 0
&& set_timeval((struct timeval *)tv) == RT_EOK) && set_timeval((struct timeval *)tv) == RT_EOK)
{ {
@ -487,47 +467,33 @@ RTM_EXPORT(difftime);
RTM_EXPORT(strftime); RTM_EXPORT(strftime);
#ifdef RT_USING_POSIX #ifdef RT_USING_POSIX
static struct timeval _timevalue;
#ifdef RT_USING_RTC static int clock_time_system_init()
static volatile struct timeval _timevalue;
static int _rt_clock_time_system_init()
{ {
register rt_base_t level; time_t time;
time_t time = 0;
rt_tick_t tick; rt_tick_t tick;
rt_device_t device; rt_device_t device;
time = 0;
device = rt_device_find("rtc"); device = rt_device_find("rtc");
if (device != RT_NULL) if (device != RT_NULL)
{ {
/* get realtime seconds */ /* get realtime seconds */
if(rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &time) == RT_EOK) rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &time);
{
level = rt_hw_interrupt_disable();
tick = rt_tick_get(); /* get tick */
_timevalue.tv_usec = (tick%RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK;
_timevalue.tv_sec = time - tick/RT_TICK_PER_SECOND - 1;
rt_hw_interrupt_enable(level);
return 0;
}
} }
level = rt_hw_interrupt_disable(); /* get tick */
_timevalue.tv_usec = 0; tick = rt_tick_get();
_timevalue.tv_sec = 0;
rt_hw_interrupt_enable(level);
return -1; _timevalue.tv_usec = (tick%RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK;
_timevalue.tv_sec = time - tick/RT_TICK_PER_SECOND - 1;
return 0;
} }
INIT_COMPONENT_EXPORT(_rt_clock_time_system_init); INIT_COMPONENT_EXPORT(clock_time_system_init);
#endif /* RT_USING_RTC */
int clock_getres(clockid_t clockid, struct timespec *res) int clock_getres(clockid_t clockid, struct timespec *res)
{ {
#ifndef RT_USING_RTC
LOG_W("Cannot find a RTC device to save time!");
return -1;
#else
int ret = 0; int ret = 0;
if (res == RT_NULL) if (res == RT_NULL)
@ -557,16 +523,11 @@ int clock_getres(clockid_t clockid, struct timespec *res)
} }
return ret; return ret;
#endif /* RT_USING_RTC */
} }
RTM_EXPORT(clock_getres); RTM_EXPORT(clock_getres);
int clock_gettime(clockid_t clockid, struct timespec *tp) int clock_gettime(clockid_t clockid, struct timespec *tp)
{ {
#ifndef RT_USING_RTC
LOG_W("Cannot find a RTC device to save time!");
return -1;
#else
int ret = 0; int ret = 0;
if (tp == RT_NULL) if (tp == RT_NULL)
@ -579,14 +540,11 @@ int clock_gettime(clockid_t clockid, struct timespec *tp)
{ {
case CLOCK_REALTIME: case CLOCK_REALTIME:
{ {
int tick; /* get tick */
register rt_base_t level; int tick = rt_tick_get();
level = rt_hw_interrupt_disable();
tick = rt_tick_get(); /* get tick */
tp->tv_sec = _timevalue.tv_sec + tick / RT_TICK_PER_SECOND; tp->tv_sec = _timevalue.tv_sec + tick / RT_TICK_PER_SECOND;
tp->tv_nsec = (_timevalue.tv_usec + (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK) * 1000; tp->tv_nsec = (_timevalue.tv_usec + (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK) * 1000;
rt_hw_interrupt_enable(level);
} }
break; break;
@ -610,17 +568,11 @@ int clock_gettime(clockid_t clockid, struct timespec *tp)
} }
return ret; return ret;
#endif /* RT_USING_RTC */
} }
RTM_EXPORT(clock_gettime); RTM_EXPORT(clock_gettime);
int clock_settime(clockid_t clockid, const struct timespec *tp) int clock_settime(clockid_t clockid, const struct timespec *tp)
{ {
#ifndef RT_USING_RTC
LOG_W("Cannot find a RTC device to save time!");
return -1;
#else
register rt_base_t level;
int second; int second;
rt_tick_t tick; rt_tick_t tick;
rt_device_t device; rt_device_t device;
@ -628,36 +580,34 @@ int clock_settime(clockid_t clockid, const struct timespec *tp)
if ((clockid != CLOCK_REALTIME) || (tp == RT_NULL)) if ((clockid != CLOCK_REALTIME) || (tp == RT_NULL))
{ {
rt_set_errno(EINVAL); rt_set_errno(EINVAL);
return -1; return -1;
} }
/* get second */ /* get second */
second = tp->tv_sec; second = tp->tv_sec;
/* get tick */
tick = rt_tick_get();
level = rt_hw_interrupt_disable();
tick = rt_tick_get(); /* get tick */
/* update timevalue */ /* update timevalue */
_timevalue.tv_usec = MICROSECOND_PER_SECOND - (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK; _timevalue.tv_usec = MICROSECOND_PER_SECOND - (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK;
_timevalue.tv_sec = second - tick/RT_TICK_PER_SECOND - 1; _timevalue.tv_sec = second - tick/RT_TICK_PER_SECOND - 1;
rt_hw_interrupt_enable(level);
/* update for RTC device */ /* update for RTC device */
device = rt_device_find("rtc"); device = rt_device_find("rtc");
if (device != RT_NULL) if (device != RT_NULL)
{ {
/* set realtime seconds */ /* set realtime seconds */
if(rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIME, &second) == RT_EOK) rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIME, &second);
{
return 0;
}
} }
else
return -1;
return -1; return 0;
#endif /* RT_USING_RTC */
} }
RTM_EXPORT(clock_settime); RTM_EXPORT(clock_settime);
int rt_timespec_to_tick(const struct timespec *time) int clock_time_to_tick(const struct timespec *time)
{ {
int tick; int tick;
int nsecond, second; int nsecond, second;
@ -688,32 +638,6 @@ int rt_timespec_to_tick(const struct timespec *time)
return tick; return tick;
} }
RTM_EXPORT(rt_timespec_to_tick); RTM_EXPORT(clock_time_to_tick);
#endif /* RT_USING_POSIX */ #endif /* RT_USING_POSIX */
/* timezone */
#ifndef RT_LIBC_DEFAULT_TIMEZONE
#define RT_LIBC_DEFAULT_TIMEZONE 8
#endif
static volatile int8_t _current_timezone = RT_LIBC_DEFAULT_TIMEZONE;
void tz_set(int8_t tz)
{
register rt_base_t level;
level = rt_hw_interrupt_disable();
_current_timezone = tz;
rt_hw_interrupt_enable(level);
}
int8_t tz_get(void)
{
return _current_timezone;
}
int8_t tz_is_dst(void)
{
return 0;
}