BroadcastTimeDefs.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_BROADCASTTIMEDEFS_HXX_
#define _OPENLCB_BROADCASTTIMEDEFS_HXX_
 
#include <time.h>
 
#include "openlcb/Defs.hxx"
 
namespace openlcb
{
 
struct BroadcastTimeDefs
{
    static constexpr NodeID DEFAULT_FAST_CLOCK_ID = 0x010100000100ULL;
 
    static constexpr NodeID DEFAULT_REALTIME_CLOCK_ID = 0x010100000101ULL;
 
    static constexpr NodeID ALTERNATE_CLOCK_1_ID = 0x010100000102ULL;
 
    static constexpr NodeID ALTERNATE_CLOCK_2_ID = 0x010100000103ULL;
 
    enum EventType
    {
        REPORT_TIME = 0, 
        REPORT_DATE,     
        REPORT_YEAR,     
        REPORT_RATE,     
        SET_TIME,        
        SET_DATE,        
        SET_YEAR,        
        SET_RATE,        
        QUERY,           
        STOP,            
        START,           
        DATE_ROLLOVER,   
        UNDEFINED,       
    };
 
    enum
    {
        EVENT_ID_MASK      = 0xFFFFFFFFFFFF0000, 
        EVENT_SUFFIX_MASK  = 0x000000000000FFFF, 
        EVENT_TYPE_MASK    = 0x000000000000F000, 
        EVENT_HOURS_MASK   = 0x0000000000001F00, 
        EVENT_MINUTES_MASK = 0x00000000000000FF, 
        EVENT_MONTH_MASK   = 0x0000000000000F00, 
        EVENT_DAY_MASK     = 0x00000000000000FF, 
        EVENT_YEAR_MASK    = 0x0000000000000FFF, 
        EVENT_RATE_MASK    = 0x0000000000000FFF, 
 
        EVENT_HOURS_SHIFT   = 8, 
        EVENT_MINUTES_SHIFT = 0, 
        EVENT_MONTH_SHIFT   = 8, 
        EVENT_DAY_SHIFT     = 0, 
        EVENT_YEAR_SHIFT    = 0, 
        EVENT_RATE_SHIFT    = 0, 
 
        TIME_EVENT_BASE_SUFFIX     = 0x0000, 
        DATE_EVENT_BASE_SUFFIX     = 0x2000, 
        YEAR_EVENT_BASE_SUFFIX     = 0x3000, 
        RATE_EVENT_BASE_SUFFIX     = 0x4000, 
        QUERY_EVENT_SUFFIX         = 0xF000, 
        STOP_EVENT_SUFFIX          = 0xF001, 
        START_EVENT_SUFFIX         = 0xF002, 
        DATE_ROLLOVER_EVENT_SUFFIX = 0xF003, 
 
        EVENT_SET_SUFFIX_MASK = 0x8000, 
    };
 
    enum
    {
        SUNDAY = 0, 
        MONDAY, 
        TUESDAY, 
        WEDNESDAY, 
        THURSDAY, 
        FRIDAY, 
        SATURDAY, 
    };
 
    static EventType get_event_type(uint16_t suffix)
    {
        switch (suffix & EVENT_TYPE_MASK)
        {
            case 0x0000:
            case 0x1000:
                if (valid_time(suffix))
                {
                    return REPORT_TIME;
                }
                break;
            case 0x2000:
                if (valid_date(suffix))
                {
                    return REPORT_DATE;
                }
                break;
            case 0x3000:
                return REPORT_YEAR;
            case 0x4000:
                return REPORT_RATE;
            case 0x8000:
            case 0x9000:
                if (valid_time(suffix))
                {
                    return SET_TIME;
                }
                break;
            case 0xA000:
                if (valid_date(suffix))
                {
                    return SET_DATE;
                }
                break;
            case 0xB000:
                return SET_YEAR;
            case 0xC000:
                return SET_RATE;
            case 0xF000:
                switch (suffix & 0xFFF)
                {
                    case 0x000:
                        return QUERY;
                    case 0x001:
                        return STOP;
                    case 0x002:
                        return START;
                    case 0x003:
                        return DATE_ROLLOVER;
                    default:
                        break;
                }                        
            default:
                break;
        }
        return UNDEFINED;
    }
 
    static bool valid_time(uint16_t suffix)
    {
        return (((suffix & EVENT_HOURS_MASK) >> EVENT_HOURS_SHIFT) <= 23 &&
                ((suffix & EVENT_MINUTES_MASK) >> EVENT_MINUTES_SHIFT) <= 59);
    }
 
    static bool valid_date(uint16_t suffix)
    {
        return (((suffix & EVENT_MONTH_MASK) >> EVENT_MONTH_SHIFT) >= 1 &&
                ((suffix & EVENT_MONTH_MASK) >> EVENT_MONTH_SHIFT) <= 12 &&
                ((suffix & EVENT_DAY_MASK) >> EVENT_DAY_SHIFT) >= 1 &&
                ((suffix & EVENT_DAY_MASK) >> EVENT_DAY_SHIFT) <= 31);
    }
 
    static int event_to_min(uint64_t event)
    {
        unsigned min = (event & EVENT_MINUTES_MASK) >> EVENT_MINUTES_SHIFT;
        if (min <= 59)
        {
            return min;
        }
        return -1;
    }
    
    static int event_to_hour(uint64_t event)
    {
        unsigned hour = (event & EVENT_HOURS_MASK) >> EVENT_HOURS_SHIFT;
        if (hour <= 23)
        {
            return hour;
        }
        return -1;
    }
    
    static int event_to_day(uint64_t event)
    {
        unsigned day = (event & EVENT_DAY_MASK) >> EVENT_DAY_SHIFT;
        if (day >= 1 && day <= 31)
        {
            return day;
        }
        return -1;
    }
    
    static int event_to_month(uint64_t event)
    {
        unsigned month = (event & EVENT_MONTH_MASK) >> EVENT_MONTH_SHIFT;
        if (month >= 1 && month <= 12)
        {
            return month;
        }
        return -1;
    }
    
    static int event_to_year(uint64_t event)
    {
        return (event & EVENT_YEAR_MASK) >> EVENT_YEAR_SHIFT;
    }
    
    static int16_t event_to_rate(uint64_t event)
    {
        union Rate
        {
            uint16_t rate_;
            int16_t srate_;
        };
 
        Rate rate;
        
        rate.rate_ = (event & EVENT_RATE_MASK) >> EVENT_RATE_SHIFT;
        if (rate.rate_ & 0x0800)
        {
            // sign extend negative value
            rate.rate_ |= 0xF000;
        }
 
        return rate.srate_;
    }
 
    static uint64_t time_to_event(uint64_t event_base, int hours, int minutes)
    {
        HASSERT(minutes >= 0 && minutes <= 59);
        HASSERT(hours >= 0 && hours <= 23);
 
        return event_base + TIME_EVENT_BASE_SUFFIX +
               (hours << EVENT_HOURS_SHIFT) + (minutes << EVENT_MINUTES_SHIFT);
    }
 
    static uint64_t date_to_event(uint64_t event_base, int month, int day)
    {
        HASSERT(month >= 1 && month <= 12);
        HASSERT(day >= 1 && day <= 31);
 
        return event_base + DATE_EVENT_BASE_SUFFIX +
               (month << EVENT_MONTH_SHIFT) + (day << EVENT_DAY_SHIFT);
    }
 
    static uint64_t year_to_event(uint64_t event_base, int year)
    {
        HASSERT(year >= 0 && year <= 4095);
 
        return event_base + YEAR_EVENT_BASE_SUFFIX + (year << EVENT_YEAR_SHIFT);
    }
 
    static uint64_t rate_to_event(uint64_t event_base, int16_t rate)
    {
        HASSERT(rate >= -2048 && rate < 2048);
 
        union Rate
        {
            uint16_t rate_;
            int16_t srate_;
        };
 
        Rate r;
        r.srate_ = rate;
 
        return event_base + RATE_EVENT_BASE_SUFFIX +
               ((r.rate_ & EVENT_RATE_MASK) << EVENT_RATE_SHIFT);
    }
 
    static std::string time_to_string(int hour, int min);
 
    static std::string rate_quarters_to_string(int16_t rate);
 
    static std::string date_to_string(int year, int month, int day);
    
    static bool string_to_time(const std::string &stime, int *hour, int *min);
    
    static int16_t string_to_rate_quarters(const std::string &srate);
 
    static bool string_to_date(
        const std::string &sdate, int *year, int *month, int *day);
 
    static bool canonicalize_time_string(std::string *stime);
 
    static bool canonicalize_rate_string(std::string* srate);
 
    static bool canonicalize_date_string(std::string* sdate);
};
 
}  // namespace openlcb
 
#endif // _OPENLCB_BROADCASTTIMEDEFS_HXX_