From 43376996a1b65aa20fb160c104d5ff8e8ee7525d Mon Sep 17 00:00:00 2001 From: Jean-Baptiste Boric Date: Sun, 7 Jun 2020 16:46:15 +0200 Subject: [PATCH] [python] Add RTC functions in time module --- python/port/genhdr/qstrdefs.in.h | 5 + python/port/mod/time/modtime.cpp | 267 ++++++++++++++++++++++++++- python/port/mod/time/modtime.h | 14 ++ python/port/mod/time/modtime_table.c | 16 ++ 4 files changed, 300 insertions(+), 2 deletions(-) diff --git a/python/port/genhdr/qstrdefs.in.h b/python/port/genhdr/qstrdefs.in.h index 3d9462424..6660d8c54 100644 --- a/python/port/genhdr/qstrdefs.in.h +++ b/python/port/genhdr/qstrdefs.in.h @@ -492,8 +492,13 @@ Q(isvisible) Q(colormode) // utime QSTRs +Q(localtime) +Q(mktime) Q(time) +Q(setlocaltime) +Q(setrtcmode) Q(sleep) +Q(rtcmode) Q(monotonic) // file QSTRs diff --git a/python/port/mod/time/modtime.cpp b/python/port/mod/time/modtime.cpp index 2462e3d02..58ae09b49 100644 --- a/python/port/mod/time/modtime.cpp +++ b/python/port/mod/time/modtime.cpp @@ -1,10 +1,11 @@ extern "C" { #include "modtime.h" +#include +#include } +#include #include #include "../../helpers.h" -#include -#include mp_obj_t modtime_sleep(mp_obj_t seconds_o) { #if MICROPY_PY_BUILTINS_FLOAT @@ -18,3 +19,265 @@ mp_obj_t modtime_sleep(mp_obj_t seconds_o) { mp_obj_t modtime_monotonic() { return mp_obj_new_float(Ion::Timing::millis() / 1000.0); } + +// +// Omega extensions, based off MicroPython's modutime.c +// + +// LEAPOCH corresponds to 2000-03-01, which is a mod-400 year, immediately +// after Feb 29. We calculate seconds as a signed integer relative to that. +// +// Our timebase is relative to 2000-01-01. + +constexpr int LEAPOCH = ((31 + 29) * 86400); + +constexpr int DAYS_PER_400Y = (365 * 400 + 97); +constexpr int DAYS_PER_100Y = (365 * 100 + 24); +constexpr int DAYS_PER_4Y = (365 * 4 + 1); + +static const uint16_t days_since_jan1[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 }; + +bool timeutils_is_leap_year(mp_uint_t year) { + return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0; +} + +// month is one based +mp_uint_t timeutils_days_in_month(mp_uint_t year, mp_uint_t month) { + mp_uint_t mdays = days_since_jan1[month] - days_since_jan1[month - 1]; + if (month == 2 && timeutils_is_leap_year(year)) { + mdays++; + } + return mdays; +} + +// compute the day of the year, between 1 and 366 +// month should be between 1 and 12, date should start at 1 +mp_uint_t timeutils_year_day(mp_uint_t year, mp_uint_t month, mp_uint_t date) { + mp_uint_t yday = days_since_jan1[month - 1] + date; + if (month >= 3 && timeutils_is_leap_year(year)) { + yday += 1; + } + return yday; +} + +Ion::RTC::DateTime timeutils_seconds_since_2000_to_struct_time(mp_uint_t t) { + Ion::RTC::DateTime tm; + + // The following algorithm was adapted from musl's __secs_to_tm and adapted + // for differences in MicroPython's timebase. + + mp_int_t seconds = t - LEAPOCH; + + mp_int_t days = seconds / 86400; + seconds %= 86400; + if (seconds < 0) { + seconds += 86400; + days -= 1; + } + tm.tm_hour = seconds / 3600; + tm.tm_min = seconds / 60 % 60; + tm.tm_sec = seconds % 60; + + mp_int_t wday = (days + 2) % 7; // Mar 1, 2000 was a Wednesday (2) + if (wday < 0) { + wday += 7; + } + tm.tm_wday = wday; + + mp_int_t qc_cycles = days / DAYS_PER_400Y; + days %= DAYS_PER_400Y; + if (days < 0) { + days += DAYS_PER_400Y; + qc_cycles--; + } + mp_int_t c_cycles = days / DAYS_PER_100Y; + if (c_cycles == 4) { + c_cycles--; + } + days -= (c_cycles * DAYS_PER_100Y); + + mp_int_t q_cycles = days / DAYS_PER_4Y; + if (q_cycles == 25) { + q_cycles--; + } + days -= q_cycles * DAYS_PER_4Y; + + mp_int_t years = days / 365; + if (years == 4) { + years--; + } + days -= (years * 365); + + tm.tm_year = 2000 + years + 4 * q_cycles + 100 * c_cycles + 400 * qc_cycles; + + // Note: days_in_month[0] corresponds to March + static const int8_t days_in_month[] = {31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 29}; + + mp_int_t month; + for (month = 0; days_in_month[month] <= days; month++) { + days -= days_in_month[month]; + } + + tm.tm_mon = month + 2; + if (tm.tm_mon >= 12) { + tm.tm_mon -= 12; + tm.tm_year++; + } + tm.tm_mday = days + 1; // Make one based + tm.tm_mon++; // Make one based + return tm; +} + +// returns the number of seconds, as an integer, since 2000-01-01 +mp_uint_t timeutils_seconds_since_2000(Ion::RTC::DateTime tm) { + return + tm.tm_sec + + tm.tm_min * 60 + + tm.tm_hour * 3600 + + (timeutils_year_day(tm.tm_year, tm.tm_mon, tm.tm_mday) - 1 + + ((tm.tm_year - 2000 + 3) / 4) // add a day each 4 years starting with 2001 + - ((tm.tm_year - 2000 + 99) / 100) // subtract a day each 100 years starting with 2001 + + ((tm.tm_year - 2000 + 399) / 400) // add a day each 400 years starting with 2001 + ) * 86400 + + (tm.tm_year - 2000) * 31536000; +} + +mp_uint_t timeutils_mktime(Ion::RTC::DateTime tm) { + // Normalize the tuple. This allows things like: + // + // tm_tomorrow = list(time.localtime()) + // tm_tomorrow[2] += 1 # Adds 1 to mday + // tomorrow = time.mktime(tm_tomorrow) + // + // And not have to worry about all the weird overflows. + // + // You can subtract dates/times this way as well. + + tm.tm_min += tm.tm_sec / 60; + if ((tm.tm_sec = tm.tm_sec % 60) < 0) { + tm.tm_sec += 60; + tm.tm_min--; + } + + tm.tm_hour += tm.tm_min / 60; + if ((tm.tm_min = tm.tm_min % 60) < 0) { + tm.tm_min += 60; + tm.tm_hour--; + } + + tm.tm_mday += tm.tm_hour / 24; + if ((tm.tm_hour = tm.tm_hour % 24) < 0) { + tm.tm_hour += 24; + tm.tm_mday--; + } + + tm.tm_mon--; // make month zero based + tm.tm_year += tm.tm_mon / 12; + if ((tm.tm_mon = tm.tm_mon % 12) < 0) { + tm.tm_mon += 12; + tm.tm_year--; + } + tm.tm_mon++; // back to one based + + while (tm.tm_mday < 1) { + if (--tm.tm_mon == 0) { + tm.tm_mon = 12; + tm.tm_year--; + } + tm.tm_mday += timeutils_days_in_month(tm.tm_year, tm.tm_mon); + } + while ((mp_uint_t)tm.tm_mday > timeutils_days_in_month(tm.tm_year, tm.tm_mon)) { + tm.tm_mday -= timeutils_days_in_month(tm.tm_year, tm.tm_mon); + if (++tm.tm_mon == 13) { + tm.tm_mon = 1; + tm.tm_year++; + } + } + return timeutils_seconds_since_2000(tm); +} + +mp_obj_t modtime_localtime(size_t n_args, const mp_obj_t *args) { + Ion::RTC::DateTime tm; + if (n_args == 0 || args[0] == mp_const_none) { + tm = Ion::RTC::dateTime(); + } else { + mp_int_t seconds = mp_obj_get_int(args[0]); + tm = timeutils_seconds_since_2000_to_struct_time(seconds); + } + mp_obj_t tuple[8] = { + tuple[0] = mp_obj_new_int(tm.tm_year), + tuple[1] = mp_obj_new_int(tm.tm_mon), + tuple[2] = mp_obj_new_int(tm.tm_mday), + tuple[3] = mp_obj_new_int(tm.tm_hour), + tuple[4] = mp_obj_new_int(tm.tm_min), + tuple[5] = mp_obj_new_int(tm.tm_sec), + tuple[6] = mp_obj_new_int(tm.tm_wday), + tuple[7] = mp_obj_new_int(timeutils_year_day(tm.tm_year, tm.tm_mon, tm.tm_mday)), + }; + return mp_obj_new_tuple(8, tuple); +} + +mp_obj_t modtime_mktime(mp_obj_t tuple) { + size_t len; + mp_obj_t *elem; + + mp_obj_get_array(tuple, &len, &elem); + + // localtime generates a tuple of len 8. CPython uses 9, so we accept both. + if (len < 8 || len > 9) { + mp_raise_TypeError("mktime needs a tuple of length 8 or 9"); + } + + Ion::RTC::DateTime tm { + (int)mp_obj_get_int(elem[5]), + (int)mp_obj_get_int(elem[4]), + (int)mp_obj_get_int(elem[3]), + (int)mp_obj_get_int(elem[2]), + (int)mp_obj_get_int(elem[1]), + (int)mp_obj_get_int(elem[0]), + }; + + return mp_obj_new_int_from_uint(timeutils_mktime(tm)); +} + +mp_obj_t modtime_time(void) { + return mp_obj_new_int(timeutils_seconds_since_2000(Ion::RTC::dateTime())); +} + +// Omega private extensions. + +mp_obj_t modtime_rtcmode(void) { + return mp_obj_new_int((int)Ion::RTC::mode()); +} + +mp_obj_t modtime_setrtcmode(mp_obj_t mode) { + mp_int_t intMode = mp_obj_get_int(mode); + if (intMode < (int)Ion::RTC::Mode::Disabled || intMode > (int)Ion::RTC::Mode::HSE) { + mp_raise_ValueError("mode must be between 0 and 2"); + } + Ion::RTC::setMode((Ion::RTC::Mode)intMode); + return mp_const_none; +} + +mp_obj_t modtime_setlocaltime(mp_obj_t tuple) { + size_t len; + mp_obj_t *elem; + + mp_obj_get_array(tuple, &len, &elem); + + if (len < 5) { + mp_raise_TypeError("setlocaltime needs a tuple of length >= 5"); + } + + Ion::RTC::DateTime tm { + len > 5 ? (int)mp_obj_get_int(elem[5]) : 0, + (int)mp_obj_get_int(elem[4]), + (int)mp_obj_get_int(elem[3]), + (int)mp_obj_get_int(elem[2]), + (int)mp_obj_get_int(elem[1]), + (int)mp_obj_get_int(elem[0]), + }; + + Ion::RTC::setDateTime(tm); + return mp_const_none; +} diff --git a/python/port/mod/time/modtime.h b/python/port/mod/time/modtime.h index fdcd7b229..f52ebaffc 100644 --- a/python/port/mod/time/modtime.h +++ b/python/port/mod/time/modtime.h @@ -2,3 +2,17 @@ mp_obj_t modtime_sleep(mp_obj_t seconds_o); mp_obj_t modtime_monotonic(); + +// +// Omega extensions. +// + +mp_obj_t modtime_localtime(size_t n_args, const mp_obj_t *args); +mp_obj_t modtime_mktime(mp_obj_t tuple); +mp_obj_t modtime_time(void); + +// Omega private extensions. + +mp_obj_t modtime_rtcmode(void); +mp_obj_t modtime_setrtcmode(mp_obj_t mode); +mp_obj_t modtime_setlocaltime(mp_obj_t tuple); diff --git a/python/port/mod/time/modtime_table.c b/python/port/mod/time/modtime_table.c index 18c828012..7aa18a190 100644 --- a/python/port/mod/time/modtime_table.c +++ b/python/port/mod/time/modtime_table.c @@ -3,10 +3,26 @@ MP_DEFINE_CONST_FUN_OBJ_1(modtime_sleep_obj, modtime_sleep); MP_DEFINE_CONST_FUN_OBJ_0(modtime_monotonic_obj, modtime_monotonic); +STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(modtime_localtime_obj, 0, 1, modtime_localtime); +MP_DEFINE_CONST_FUN_OBJ_1(modtime_mktime_obj, modtime_mktime); +MP_DEFINE_CONST_FUN_OBJ_0(modtime_time_obj, modtime_time); + +MP_DEFINE_CONST_FUN_OBJ_0(modtime_rtcmode_obj, modtime_rtcmode); +MP_DEFINE_CONST_FUN_OBJ_1(modtime_setrtcmode_obj, modtime_setrtcmode); +MP_DEFINE_CONST_FUN_OBJ_1(modtime_setlocaltime_obj, modtime_setlocaltime); + STATIC const mp_rom_map_elem_t modtime_module_globals_table[] = { { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_time) }, { MP_ROM_QSTR(MP_QSTR_sleep), MP_ROM_PTR(&modtime_sleep_obj) }, { MP_ROM_QSTR(MP_QSTR_monotonic), MP_ROM_PTR(&modtime_monotonic_obj) }, + + { MP_ROM_QSTR(MP_QSTR_localtime), MP_ROM_PTR(&modtime_localtime_obj) }, + { MP_ROM_QSTR(MP_QSTR_mktime), MP_ROM_PTR(&modtime_mktime_obj) }, + { MP_ROM_QSTR(MP_QSTR_time), MP_ROM_PTR(&modtime_time_obj) }, + + { MP_ROM_QSTR(MP_QSTR_rtcmode), MP_ROM_PTR(&modtime_rtcmode_obj) }, + { MP_ROM_QSTR(MP_QSTR_setrtcmode), MP_ROM_PTR(&modtime_setrtcmode_obj) }, + { MP_ROM_QSTR(MP_QSTR_setlocaltime), MP_ROM_PTR(&modtime_setlocaltime_obj) }, }; STATIC MP_DEFINE_CONST_DICT(modtime_module_globals, modtime_module_globals_table);