sc_time.c

#include "main-header.h"
#include "sc_time.h"
#include "mculibrary.h"
#include "config.h"
 
#define TIME_REQUEST_SYNC_INTERVAL 300
// we can go for some time without sync before things break. after this time we refuse to give out time because chances are, it is just "too wrong"
#define TIME_MAX_AGE_NO_SYNC (60 * 60 * 24 * 2)
 
static long appstarted;
static uint8_t daytime;
static uint32_t last_time_stamp;        // timestamp as received (4 bytes: HHMMSSWD WD=WEEKDAY)
static uint32_t last_date_stamp;        // date as received (4 bytes: YYYYMMDD)
static uint32_t last_time_sync_req = 0; // timestamp sync was last requested
static uint32_t last_time_sync = 0;     // timestamp when time was last synced
 
static uint32_t old_last_time_sync = 0; // timestamp when time was last synced, but not updated as often
static uint32_t old_last_time_stamp;    // timestamp as received (4 bytes: HHMMSSWD WD=WEEKDAY)
static uint32_t old_last_date_stamp;    // date as received (4 bytes: YYYYMMDD)
static int32_t old_last_drift;
static struct sctime old_time;
static uint32_t last_published_time = 0;
static int adj_time = 0;                // time "per second" adjusted, multiplied by 100
static uint32_t ltd = 0;                // time diff since last update (to be used in conjunction with adj_time)
 
 
static int get_time_as_struct(struct sctime *time, uint32_t l_time_sync, uint32_t l_time_stamp, uint32_t l_date_stamp);
// set a new time
static void time_set_new_from_sync(uint32_t received, uint32_t bcdtime, uint32_t bcddate, uint32_t temp_override);
static void add_seconds_to_timestruct(struct sctime *nt, uint32_t add_secs);
 
 
 
void check_time_on_loop() {
  uint32_t now = mculib_get_seconds_since_boot();
 
  if (last_time_sync == 0) {
    if (get_seconds_since_start() < 60) {
      // wait a bit after starting before getting time..
      return;
    }
  } else {
    if ((now - last_time_sync < TIME_REQUEST_SYNC_INTERVAL) && (now >= last_time_sync)) {
      return;
    }
  }
  // only ask for sync at most every 5 seconds
  if ((now - last_time_sync_req <= 5) && (now >= last_time_sync_req)) {
    return;
  }
  send_clock_sync_request();
}
 
// returns true (1) if disabled
static int sync_disabled() {
  if ((last_time_sync != 0) && (config_get_flag(CONFIG_FLAGS_CLOCKSYNC_DISABLED))) {
    return 1;
  }
  return 0;
}
void send_clock_sync_request() {
  if (sync_disabled()) {
    return;
  }
  uint32_t now = mculib_get_seconds_since_boot();
 
  printf("[time] sending sync request...\r\n");
  struct command *com = alloc_command();
 
  if (com == NULL) {
    return;
  }
  com->target = CLOUD_SERVER;
  com->com = 59; // clock-sync
  last_time_sync_req = now;
  command_add_arg(com, "ls=%i", last_time_sync);
  command_add_arg(com, "sss=%i", get_seconds_since_start());
  command_add_arg(com, "ssb=%i", now);
  command_add_arg(com, "tz=%i", config_get_timezone());
  time_add_debug_to_command(com);
  int n = send_command(com);
 
  free_command(com);
  if (n != 0) {
    printf("[time] failed to send sync request: %i\r\n", n);
    return;
  }
}
 
// if temp_override is set, then do it even if disabled (server overrides)
static void time_set_new_from_sync(uint32_t received, uint32_t bcdtime, uint32_t bcddate, uint32_t temp_override) {
  struct sctime nt1, nt2;
  int n = get_localtime_as_struct(&nt1);
  uint32_t lt1 = last_time_sync;
 
  if ((temp_override) || (!sync_disabled())) {
    last_time_sync = received;
    last_time_stamp = bcdtime;
    last_date_stamp = bcddate;
  }
 
  // (re)set  the "old" timestamp
  if ((old_last_time_sync == 0) || ((received - old_last_time_sync) > 60 * 60 * 4)) {
    old_last_time_sync = received;
    old_last_time_stamp = bcdtime;
    old_last_date_stamp = bcddate;
  }
  uint32_t lt2 = received;
 
  if (n != 0) {
    printf("[time] not calculating drift because cannot calc time on old time\r\n");
    return;
  }
  // nt2 is now the _new_time
  n = get_time_as_struct(&nt2, received, bcdtime, bcddate);
  if (n != 0) {
    printf("[time] not calculating drift because cannot calc time on new time\r\n");
    return;
  }
  if ((nt1.month != nt2.month) || (nt1.month != nt2.month)) {
    // don't even try to compare across days.
    // next sync, there are aligned again, so it's not such a big deal.
    printf("[time] not calculating drift across two different dates\r\n");
    return;
  }
  // got valid timestructs nt1 and nt2, *before* and *after* setting the time
  uint32_t ne1 = nt1.second + (nt1.minute * 60) + (nt1.hour * 60 * 60);
  uint32_t ne2 = nt2.second + (nt2.minute * 60) + (nt2.hour * 60 * 60);
 
  adj_time = ne2 - ne1;
  ltd = lt2 - lt1;
 
  // calculate *OLD* drift
  if (old_last_time_sync < received) {
    convert_timestamps_to_time(old_last_time_stamp, old_last_date_stamp, &old_time);
    add_seconds_to_timestruct(&old_time, received - old_last_time_sync);
    if ((nt2.month == old_time.month) && (nt2.month == old_time.month)) {
      old_last_drift = old_time.second + (old_time.minute * 60) + (old_time.hour * 60 * 60) - ne2;
    }
  }
 
 
  printf("[time] set time diff: %i@%i, %i@%i (%i/%i)\r\n", ne1, lt1, ne2, lt2, adj_time, ltd);
}
 
/*
 * return: 1=ACK, 2=NACK, 0=nothing
 * the order of parsing (and exiting function) is relevant.
 * for example: the server might send mul/div without sync'ing time
 */
int time_command_received(struct command *com) {
  int res = 0;
  int n;
  uint32_t now = mculib_get_seconds_since_boot();
  uint32_t p1, p2;
  uint32_t dm;
 
  // ackreq?
  n = namedarg_uint32(com, "ar", &dm);
  if (n == 0) {
    res = 1;
  }
 
  // set multiplier, if exists
  n = namedarg_uint32(com, "mul", &dm);
  if (n == 0) {
    config_set_clock_mul(dm);
  }
 
  // set divisor, if exists
  n = namedarg_uint32(com, "div", &dm);
  if (n == 0) {
    config_set_clock_div(dm);
  }
 
  // parse time
  n = namedarg_uint32(com, "bcdtime", &p1);
  if (n != 0) {
    printf("[time] clock-info did not include bcdtime - ignored\r\n");
    return res;
  }
  // parse date
  n = namedarg_uint32(com, "bcddate", &p2);
  if (n != 0) {
    printf("[time] clock-info did not include bcddate - ignored\r\n");
    return res;
  }
 
  // is it a set-timezone request?
  uint32_t tz;
 
  n = namedarg_uint32(com, "settz", &tz);
  if (n == 0) {
    config_set_timezone(tz);
    printf("[time] set new timezone %i\r\n");
  }
 
  // parse timezone and ignore if it does not match our timezone
 
  n = namedarg_uint32(com, "tz", &tz);
  if (n != 0) {
    // no timezone? -- ignore
    printf("[time] clock-info did not include timezone - ignored\r\n");
    return res;
  }
  if (tz != config_get_timezone()) {
    printf("[time] received for time %i, but we are in %i - ignored\r\n", tz, config_get_timezone());
    return res;
  }
 
 
 
  time_set_new_from_sync(now, p1, p2, res);
 
  // if time_sync disabled, do not forward
  if (sync_disabled()) {
    return res;
  }
 
  uint32_t p;
 
  // parse daytime
  n = namedarg_uint32(com, "dt", &p);
  if (n == 0) {
    daytime = p;
  }
 
  n = namedarg_uint32(com, "fw", &p);
  if (n == 0) {
    // it was already forwarded.
    return 0;
  }
 
  // forward it
  struct command *ocom = alloc_command();
 
  if (ocom == NULL) {
    return 0;
  }
  ocom->target = BROADCAST;
  ocom->com = 59; // clock-sync
  command_add_arg(ocom, "fw=1");
  command_add_arg(ocom, "bcdtime=%D", last_time_stamp);
  command_add_arg(ocom, "bcddate=%D", last_date_stamp);
  command_add_arg(ocom, "dt=%i", (int)daytime);
  command_add_arg(ocom, "tz=%i", (int)tz);
  n = send_command(ocom);
  free_command(ocom);
  if (n != 0) {
    printf("[time] failed to forward sync request: %i\r\n", n);
    return res;
  }
  return res;
}
 
// given a month [1..12] - will return max days (ignoring leap years)
static uint32_t max_date_for_month(uint32_t month) {
  if ((month == 1) || (month == 3) || (month == 5) || (month == 7) || (month == 8) || (month == 10) || (month == 12)) {
    return 31;
  }
  if (month == 2) {
    return 28;
  }
  return 30;
}
 
// add some seconds to nt
// handles days/months/hours and weekdays.
// does not handle leap years.
// does not handle daylight saving
static void add_seconds_to_timestruct(struct sctime *nt, uint32_t add_secs) {
  uint32_t add_wdays = 0;
  uint32_t days = add_secs / (60 * 60 * 24);
 
  nt->day = nt->day + days;
  add_wdays = add_wdays + days;
  add_secs = add_secs - (days * 60 * 60 * 24);
 
  uint32_t hours = add_secs / (60 * 60);
 
  nt->hour = nt->hour + hours;
  add_secs = add_secs - (hours * 60 * 60);
 
  uint32_t secs = add_secs % 60;
 
  nt->second = nt->second + secs;
  if (nt->second >= 60) {
    nt->minute++;
    nt->second = nt->second - 60;
  }
  uint32_t mins = ((add_secs - (secs)) / 60) % 3600;
 
  nt->minute = nt->minute + mins;
  if (nt->minute >= 60) {
    nt->hour++;
    nt->minute = nt->minute - 60;
  }
  if (nt->hour >= 24) {
    nt->day++;
    add_wdays++;
    nt->hour = nt->hour - 24;
  }
  uint32_t mdm = max_date_for_month(nt->month);
 
  if (nt->day > mdm) {
    nt->month++;
    nt->day = nt->day - mdm;
  }
  nt->weekday = nt->weekday + (add_wdays % 7);
  if (nt->weekday > 7) {
    nt->weekday = nt->weekday - 7;
  }
}
 
uint32_t convert_time_to_timestamp(struct sctime *time) {
  uint32_t res = 0;
 
  res |= time->hour << 24;
  res |= time->minute << 16;
  res |= time->second << 8;
  res |= time->weekday;
  return res;
}
/*
 * returns:
 * 0 if time1 represents the same moment in time as time2
 * 1 if time1 is AFTER time2
 * 2 if time2 is BEFORE time2
 */
static uint8_t compare_time(struct sctime *time1, struct sctime *time2) {
  if (time1->year > time2->year) {
    return 1;
  }
  if (time1->year < time2->year) {
    return 2;
  }
  if (time1->month > time2->month) {
    return 1;
  }
  if (time1->month < time2->month) {
    return 2;
  }
  if (time1->day > time2->day) {
    return 1;
  }
  if (time1->day < time2->day) {
    return 2;
  }
  if (time1->hour > time2->hour) {
    return 1;
  }
  if (time1->hour < time2->hour) {
    return 2;
  }
  if (time1->minute > time2->minute) {
    return 1;
  }
  if (time1->minute < time2->minute) {
    return 2;
  }
  if (time1->second > time2->second) {
    return 1;
  }
  if (time1->second < time2->second) {
    return 2;
  }
  return 0;
}
int diff_time(struct sctime *time1, struct sctime *time2) {
  uint8_t reverse_sign = 0;
  int diff = 0;
  int m_days = 0;
  struct sctime *larger;
  struct sctime *smaller;
 
  larger = time1;
  smaller = time2;
  int r = compare_time(larger, smaller);
 
  if (r == 0) {
    // equal? no secs difference
    return 0;
  } else if (r == 1) {
    larger = time2;
    smaller = time1;
    reverse_sign = 1;
  }
 
  if (larger->month != smaller->month) {
    m_days = max_date_for_month(larger->month);
  }
  diff = diff + (m_days + smaller->day - larger->day) * 60 * 60 * 24;
  diff = diff + (smaller->hour - larger->hour) * 60 * 60;
  diff = diff + (smaller->minute - larger->minute) * 60;
  diff = diff + (smaller->second - larger->second);
 
  if (reverse_sign) {
    diff = 0 - diff;
  }
  return diff;
}
void convert_timestamps_to_time(uint32_t bcdtime, uint32_t bcddate, struct sctime *time) {
  time->hour = ((bcdtime >> 24) & 0xFF);
  time->minute = ((bcdtime >> 16) & 0xFF);
  time->second = ((bcdtime >> 8) & 0xFF);
  time->weekday = ((bcdtime) & 0xFF);
  time->year = ((bcddate >> 16) & 0xFFFF);
  time->month = ((bcddate >> 8) & 0xFF);
  time->day = ((bcddate) & 0xFF);
  time->timestamp = bcdtime;
  uint32_t now = mculib_get_seconds_since_boot();
  uint32_t since = now - last_time_sync;
 
  time->secs_since_last_sync = since;
  time->daytime = daytime;
}
static int get_time_as_struct(struct sctime *time, uint32_t l_time_sync, uint32_t l_time_stamp, uint32_t l_date_stamp) {
  if (l_time_sync == 0) {    // never synced?
    return 2;
  }
 
  uint32_t now = mculib_get_seconds_since_boot();
 
  if ((now < last_published_time) && (last_published_time - now < 50)) {
    now = last_published_time;
  }
  last_published_time = now;
 
  uint32_t since = now - l_time_sync;
 
  if (since > TIME_MAX_AGE_NO_SYNC) { // last sync too long ago?
    return 1;
  }
  if (l_time_sync > now) {
    since = 0;
  }
  convert_timestamps_to_time(l_time_stamp, l_date_stamp, time);
  // the internal clock is often very inaccurate. External crystals (and their placement) cost money,
  // instead we keep track of how "off" the clock is when we synchronise with the server and adjust
  // our calculation accordingly to compensate for the inaccurate clock
  if (config_get_clock_mul() != 0) {
    since = since * config_get_clock_mul();
  }
  if (config_get_clock_div() != 0) {
    since = since / config_get_clock_div();
  }
  add_seconds_to_timestruct(time, since);
  return 0;
}
// return 0==ok, otherwise error
int get_localtime_as_struct(struct sctime *time) {
  return get_time_as_struct(time, last_time_sync, last_time_stamp, last_date_stamp);
}
 
void clocksync_enable(uint8_t e) {
  if (e) {
    printf("clocksync enabled\r\n");
    config_set_flag(CONFIG_FLAGS_CLOCKSYNC_DISABLED, 0);
  } else {
    printf("clocksync disabled\r\n");
    config_set_flag(CONFIG_FLAGS_CLOCKSYNC_DISABLED, 1);
  }
}
 
void time_add_debug_to_command(struct command *com) {
  struct sctime lt;
  int n = get_localtime_as_struct(&lt);
 
  if (n == 0) {
    command_add_arg(com, "time=%i:%i:%i", lt.hour, lt.minute, lt.second);
    command_add_arg(com, "timestamp=%i", lt.timestamp);
    command_add_arg(com, "syncage=%i", lt.secs_since_last_sync);
    command_add_arg(com, "date=%i-%i-%i", lt.year, lt.month, lt.day);
    command_add_arg(com, "now=%i", mculib_get_seconds_since_boot());
  }
  uint32_t *CNWRTC_BASE_TR = (uint32_t *)0x40002800;
  // Capture seconds and minutes 0-9, in BCD format
  uint32_t stupidcal = (*CNWRTC_BASE_TR);
 
  command_add_arg(com, "rtc=%i", stupidcal);
  CNWRTC_BASE_TR = (uint32_t *)0x40002804;
  // Capture seconds and minutes 0-9, in BCD format
  stupidcal = (*CNWRTC_BASE_TR);
  command_add_arg(com, "rtd=%i", stupidcal);
  command_add_arg(com, "dr=%i", adj_time);
  command_add_arg(com, "ltd=%i", ltd);
  command_add_arg(com, "f=%i/%i", config_get_clock_mul(), config_get_clock_div());
  command_add_arg(com, "ols=%i", old_last_time_sync);
  command_add_arg(com, "oldr=%i", old_last_drift);
}
 
void sctime_init() {
  appstarted = mculib_get_seconds_since_boot();
}
uint32_t get_seconds_since_start() {
  return mculib_get_seconds_since_boot() - appstarted;
}
void clocksync_help() {
  uint32_t now = mculib_get_seconds_since_boot();
  struct sctime nt;
  int n = get_localtime_as_struct(&nt);
 
  printf("Clocksync help:\r\n");
  printf("Now (boot): %i\r\n", now);
  printf("Now (strt): %i\r\n", (now - appstarted));
  printf("Multiplier: %i\r\n", config_get_clock_mul());
  printf("Divisor   : %i\r\n", config_get_clock_div());
  printf("ltd       : %i\r\n", ltd);
  printf("adj_time  : %i\r\n", adj_time);
  printf("last sync : %i (%i)\r\n", last_time_sync, (now - last_time_sync));
  if (n == 0) {
    printf("Time      : %i:%i:%i (%s)\r\n", nt.hour, nt.minute, nt.second, (nt.daytime ? "day":"night"));
  } else {
    printf("Time      : unavailable (%i)\r\n", n);
  }
  printf("Timezone  : %i\r\n", config_get_timezone());
  printf("Enabled   : %s\r\n", (sync_disabled() ? "No" : "Yes"));
}