Time.hh

Go to the documentation of this file.

#ifndef COSA_TIME_HH
#define COSA_TIME_HH

#include "Cosa/Types.h"
#include "Cosa/BCD.h"
#include "Cosa/IOStream.hh"

// Weekday numbers (1..7)
enum {
  SUNDAY = 1,
  MONDAY = 2,
  TUESDAY = 3,
  WEDNESDAY = 4,
  THURSDAY = 5,
  FRIDAY = 6,
  SATURDAY = 7
};

// NTP epoch year and weekday (Monday)
const uint16_t NTP_EPOCH_YEAR = 1900;
const uint8_t  NTP_EPOCH_WEEKDAY = MONDAY;

// POSIX epoch year and weekday (Thursday)
const uint16_t POSIX_EPOCH_YEAR = 1970;
const uint8_t  POSIX_EPOCH_WEEKDAY = THURSDAY;

// Y2K epoch year and weekday (Saturday)
const uint16_t Y2K_EPOCH_YEAR = 2000;
const uint8_t  Y2K_EPOCH_WEEKDAY = SATURDAY;

typedef uint32_t clock_t;

const uint32_t SECONDS_PER_DAY = 86400L;
const uint16_t SECONDS_PER_HOUR = 3600;
const uint8_t SECONDS_PER_MINUTE = 60;
const uint8_t DAYS_PER_WEEK = 7;

#if (ARDUINO > 150)

constexpr clock_t operator "" _h(unsigned long long h)
{
  return (h * SECONDS_PER_HOUR);
}

constexpr clock_t operator "" _min(unsigned long long min)
{
  return (min * SECONDS_PER_MINUTE);
}

constexpr clock_t operator "" _s(unsigned long long s)
{
  return (s);
}
#endif

struct time_t {
  uint8_t seconds;              
  uint8_t minutes;              
  uint8_t hours;                
  uint8_t day;                  
  uint8_t date;                 
  uint8_t month;                
  uint8_t year;                 

  void to_binary()
    __attribute__((always_inline))
  {
    ::to_binary(&seconds, sizeof(time_t));
  }

  void to_bcd()
    __attribute__((always_inline))
  {
    ::to_bcd(&seconds, sizeof(time_t));
  }

  time_t() {}

  time_t(clock_t c, int8_t zone = 0);

  operator clock_t() const;

  void set_day()
  {
    day = weekday_for(days());
  }

  uint16_t days() const;

  uint16_t day_of_year() const;

  uint16_t full_year() const
  {
    return full_year(year);
  }

  static uint16_t full_year(uint8_t year)
  {
    uint16_t y = year;

    if (y < pivot_year)
      y += 100 * (epoch_year()/100 + 1);
    else
      y += 100 * (epoch_year()/100);

    return y;
  }

  bool is_leap() const
  {
    return is_leap(full_year());
  }

  static bool is_leap(uint16_t year)
  {
    if (year % 4) return false;
    uint16_t y = year % 400;
    return (y == 0) || ((y != 100) && (y != 200) && (y != 300));
  }

  static uint16_t days_per(uint16_t year)
  {
    return (365 + is_leap(year));
  }

  static uint8_t weekday_for(uint16_t dayno)
  {
    return ((dayno+epoch_weekday-1) % DAYS_PER_WEEK) + 1;
  }

  bool is_valid() const
  {
    return
      ((year <= 99) &&
       (1 <= month) && (month <= 12) &&
       ((1 <= date) &&
        ((date <= pgm_read_byte(&days_in[month])) ||
         ((month == 2) && is_leap() && (date == 29)))) &&
       (1 <= day) && (day <= 7) &&
       (hours <= 23) &&
       (minutes <= 59) &&
       (seconds <= 59));
  }

  static void epoch_year(uint16_t y)
  {
    s_epoch_year = y;
    epoch_offset = s_epoch_year % 100;
    pivot_year = epoch_offset;
  }

  static uint16_t epoch_year()
  {
    return (s_epoch_year);
  }

  static uint8_t epoch_weekday;

  static uint8_t pivot_year;

  static void use_fastest_epoch();

  bool parse(str_P s);

  static const uint8_t days_in[] PROGMEM;

protected:
  static uint16_t s_epoch_year;
  static uint8_t epoch_offset;
} __attribute__((packed));

IOStream& operator<<(IOStream& outs, const time_t& t);

#endif