def handle_reg_0x0d(self, b): # Alarm 2 Day/Date
self.alarm2.m4 = bcd2int(b & 0b10000000) >> 7
self.putd(7, 7, [
Ann.BIT_AE,
['A2M4: %d' % self.alarm2.m4,
'A4: %d' % self.alarm2.m4, 'A4']
])
self.alarm2.dy_dt = 1 if bcd2int(b & 0b01000000) else 0
date = bcd2int(b & 0b00111111)
if self.alarm2.dy_dt:
self.putd(6, 6, [Ann.BIT_DY_DT, ['Day of week', 'DT', 'D']])
self.putd(5, 0, [
Ann.BIT_DAY, ['Day of week: %d' % date,
'DOW: %d' % date, 'D']
])
self.alarm2.dow = date
else:
self.putd(6, 6, [Ann.BIT_DY_DT, ['Day of month', 'DT', 'D']])
self.putd(5, 0, [
Ann.BIT_DATE,
['Day of month: %d' % date,
'DOM: %d' % date, 'D']
])
self.alarm2.dom = date
self.putd(7, 0, [Ann.REG_ALARM_2_DAY_DATE, ['Day/Date', 'Dy/Dt', 'D']])
def handle_reg_0x0c(self, b, rw): # Alarm2 Hours (1-12+AM/PM or 0-23)
self.putd(7, 0,
[Ann.REG_ALARM2_HOURS, ['Alarm2 Hours', 'Al2 Hr', 'A2H']])
self.a2m3 = 1 if (b & (1 << 7)) else 0
self.putd(7, 7, [Ann.BIT_A2M3, ['A2M3: %d' % self.a2m3, 'A2M3']])
if (b & (1 << 6)):
self.putd(
6, 6,
[Ann.BIT_12_24_HOURS, ['12-hour mode', '12h mode', '12h']])
self.a2ampm = 'PM' if (b & (1 << 5)) else 'AM'
self.putd(5, 5, [Ann.BIT_AM_PM, [self.a2ampm, self.a2ampm[0]]])
h = self.al2hours = bcd2int(b & 0x1f)
self.putd(4, 0,
[Ann.BIT_HOURS, ['Hour: %d' % h,
'H: %d' % h, 'H']])
else:
self.putd(
6, 6,
[Ann.BIT_12_24_HOURS, ['24-hour mode', '24h mode', '24h']])
self.a2ampm = ''
h = self.al2hours = bcd2int(b & 0x3f)
self.putd(5, 0,
[Ann.BIT_HOURS, ['Hour: %d' % h,
'H: %d' % h, 'H']])
self.inblock = 0x0c if self.inblock == 0x0b and self.blockmode == rw else -1
def handle_reg_0x09(self, b, rw): # Alarm1 Hours (1-12+AM/PM or 0-23)
self.putd(7, 0,
[Ann.REG_ALARM1_HOURS, ['Alarm1 Hours', 'Al1 Hr', 'A1H']])
self.a1m3 = 1 if (b & (1 << 7)) else 0
self.putd(7, 7, [Ann.BIT_A1M3, ['A1M3: %d' % self.a1m3, 'A1M3']])
if (b & (1 << 6)):
self.putd(
6, 6,
[Ann.BIT_12_24_HOURS, ['12-hour mode', '12h mode', '12h']])
self.a1ampm = 'PM' if (b & (1 << 5)) else 'AM'
self.putd(5, 5, [Ann.BIT_AM_PM, [self.a1ampm, self.a1ampm[0]]])
self.al1hours = bcd2int(b & 0x1f)
self.putd(4, 0, [
Ann.BIT_HOURS,
['Hour: %d' % self.al1hours,
'H: %d' % self.al1hours, 'H']
])
else:
self.putd(
6, 6,
[Ann.BIT_12_24_HOURS, ['24-hour mode', '24h mode', '24h']])
self.a1ampm = ''
self.al1hours = bcd2int(b & 0x3f)
self.putd(5, 0, [
Ann.BIT_HOURS,
['Hour: %d' % self.al1hours,
'H: %d' % self.al1hours, 'H']
])
self.inblock = 9 if self.inblock == 8 and self.blockmode == rw else -1
def handle_reg_0x02(self, b, rw): # Hours (1-12+AM/PM or 0-23)
self.putd(7, 0, [Ann.REG_HOURS, ['Hours', 'H']])
self.putr(7)
if (b & (1 << 6)):
self.putd(
6, 6,
[Ann.BIT_12_24_HOURS, ['12-hour mode', '12h mode', '12h']])
self.ampm = 'PM' if (b & (1 << 5)) else 'AM'
self.putd(5, 5, [Ann.BIT_AM_PM, [self.ampm, self.ampm[0]]])
self.hours = bcd2int(b & 0x1f)
self.putd(4, 0, [
Ann.BIT_HOURS,
['Hour: %d' % self.hours,
'H: %d' % self.hours, 'H']
])
else:
self.putd(
6, 6,
[Ann.BIT_12_24_HOURS, ['24-hour mode', '24h mode', '24h']])
self.ampm = ''
self.hours = bcd2int(b & 0x3f)
self.putd(5, 0, [
Ann.BIT_HOURS,
['Hour: %d' % self.hours,
'H: %d' % self.hours, 'H']
])
self.inblock = 2 if self.inblock == 1 and self.blockmode == rw else -1
def handle_reg_0x02(self, databyte):
"""Process hours (1-12+AM/PM or 0-23) and 12/24 hours mode.
- In case of 12 hours mode convert hours to 24 hours mode to instance
variable for formatting.
"""
# Bits row
self.putb(7)
mode12h = databyte >> TimeBits.MODE & 1
if mode12h:
# Bits row - 12h mode
ann = AnnBits.MODE
val = "12h"
annots = hlp.compose_annot(bits[ann], ann_value=val)
self.putd(TimeBits.MODE, TimeBits.MODE, [ann, annots])
# Bits row - AM/PM mode
pm = databyte >> TimeBits.AMPM & 1
pm_l = ("AM", "PM")[pm]
pm_s = pm_l[0].upper()
ann = AnnBits.AMPM
val = [pm, pm_l, pm_s]
annots = hlp.compose_annot(bits[ann], ann_value=val)
self.putd(TimeBits.AMPM, TimeBits.AMPM, [ann, annots])
# Bits row - hours
self.hour = hlp.bcd2int(databyte & 0x1f)
# Convert to 24h expression
self.hour %= 12
if pm:
self.hour += 12
ann = AnnBits.HOUR
val = self.hour
annots = hlp.compose_annot(bits[ann], ann_value=val)
self.putd(0, TimeBits.AMPM - 1, [ann, annots])
else:
# Bits row - 24h mode
ann = AnnBits.MODE
val = "24h"
annots = hlp.compose_annot(bits[ann], ann_value=val)
self.putd(TimeBits.MODE, TimeBits.MODE, [ann, annots])
# Bits row - hours
self.hour = hlp.bcd2int(databyte & 0x3f)
ann = AnnBits.HOUR
val = self.hour
annots = hlp.compose_annot(bits[ann], ann_value=val)
self.putd(0, TimeBits.MODE - 1, [ann, annots])
# Registers row
ann = AnnRegs.HOUR
act = self.format_rw()
annots = hlp.compose_annot(registers[ann], ann_action=act)
self.put(self.ssd, self.es, self.out_ann, [ann, annots])
def handle_reg_0x02(self, b): # Hours (1-12+AM/PM or 0-23)
self.putd(7, 0, [2, ['Hours', 'H']])
self.putr(7)
ampm_mode = True if (b & (1 << 6)) else False
if ampm_mode:
self.putd(6, 6, [13, ['12-hour mode', '12h mode', '12h']])
a = 'AM' if (b & (1 << 6)) else 'PM'
self.putd(5, 5, [14, [a, a[0]]])
h = self.hours = bcd2int(b & 0x1f)
self.putd(4, 0, [15, ['Hour: %d' % h, 'H: %d' % h, 'H']])
else:
self.putd(6, 6, [13, ['24-hour mode', '24h mode', '24h']])
h = self.hours = bcd2int(b & 0x3f)
self.putd(5, 0, [15, ['Hour: %d' % h, 'H: %d' % h, 'H']])
def handle_reg_0x05(self, b):
self.putr(6)
self.putr(5)
self.time.months = bcd2int(b & 0x0f)
self.putd(4, 0, [
Ann.BIT_MONTH,
['Month: %d' % self.time.months,
'M: %d' % self.time.months, 'M']
])
c = bcd2int(b & 0x80)
self.putd(7, 7,
[Ann.BIT_CENTURY, ['Century: %d' % c,
'C: %d' % c, 'C']])
self.putd(7, 0, [Ann.REG_MONTH, ['Month', 'Mon.', 'M']])
def handle_reg_0x02(self, b): # Hours (1-12+AM/PM or 0-23)
self.putd(7, 0, [2, ['Hours', 'H']])
self.putr(7)
ampm_mode = True if (b & (1 << 6)) else False
if ampm_mode:
self.putd(6, 6, [13, ['12-hour mode', '12h mode', '12h']])
a = 'PM' if (b & (1 << 5)) else 'AM'
self.putd(5, 5, [14, [a, a[0]]])
h = self.hours = bcd2int(b & 0x1f)
self.putd(4, 0, [15, ['Hour: %d' % h, 'H: %d' % h, 'H']])
else:
self.putd(6, 6, [13, ['24-hour mode', '24h mode', '24h']])
h = self.hours = bcd2int(b & 0x3f)
self.putd(5, 0, [15, ['Hour: %d' % h, 'H: %d' % h, 'H']])
def handle_reg_0x0a(self, b, rw): # Alarm1 Date or Day / day of week (1-7)
self.putd(7, 0, [
Ann.REG_ALARM1_DAY_DATE,
['Alarm1 Date or Day of week', 'Al1 Day / DOW', 'A1DD']
])
a1m4 = 1 if (b & (1 << 7)) else 0
self.putd(7, 7, [Ann.BIT_A1M4, ['A1M4: %d' % a1m4, 'A1M4']])
a1dydt = 1 if (b & (1 << 6)) else 0
self.putd(6, 6, [Ann.BIT_DAY_DATE, ['DYDT: %d' % a1dydt, 'DYDT']])
if a1dydt == 1:
w = bcd2int(b & 0x07)
ws = days_of_week[self.options['fdw']][w - 1]
self.putd(
2, 0,
[Ann.BIT_DAY, ['Weekday: %s' % ws,
'WD: %d' % w, 'WD', 'W']])
else:
da = bcd2int(b & 0x3f)
self.putd(
5, 0,
[Ann.BIT_DATE, ['Date / Day: %d' % da,
'D: %d' % da, 'D']])
#block
if self.inblock == 9 and self.blockmode == rw:
if (self.a1m1, self.a1m2, self.a1m3, a1m4) == (1, 1, 1, 1):
d = 'every second'
elif (self.a1m1, self.a1m2, self.a1m3, a1m4) == (0, 1, 1, 1):
d = 'every minute, second=%02d' % self.al1seconds
elif (self.a1m1, self.a1m2, self.a1m3, a1m4) == (0, 0, 1, 1):
d = 'every hour, mm:ss=%02d:%02d' % (self.al1minutes,
self.al1seconds)
elif (self.a1m1, self.a1m2, self.a1m3, a1m4) == (0, 0, 0, 1):
d = 'daily, hh:mm:ss=%02d:%02d:%02d%s' % (
self.al1hours, self.al1minutes, self.al1seconds,
self.a1ampm)
elif (self.a1m1, self.a1m2, self.a1m3, a1m4) == (0, 0, 0, 0):
if a1dydt == 1:
daydate = ws
else:
daydate = '%d. of every month' % da
d = '%s, %02d:%02d:%02d' % (daydate, self.al1hours,
self.al1minutes, self.al1seconds)
else:
d = 'invalid setting' #FIXME: print warning
d = 'Alarm1: ' + d
self.put(self.startreg, self.es, self.out_ann,
[Ann.BLOCK_ALARM1, ['%s %s' % (rw, d)]])
self.inblock = -1
def handle_reg_0x03(self, databyte):
"""Process weekday (1-7).
- Recalculate weekday in respect to starting weekday option to instance
variable for formatting.
"""
# Bits row - reserved
self.putb(3, 8)
# Bits row - calculate weekday
self.weekday = hlp.bcd2int(databyte & 0x07)
start_weekday_index = 0
for i, weekday in enumerate(weekdays):
if weekday == self.options["start_weekday"]:
start_weekday_index = i
break
start_weekday_index += self.weekday - 1
start_weekday_index %= 7
self.weekday = start_weekday_index
weekday = weekdays[self.weekday]
# Bits row - weekday
ann = AnnBits.WEEKDAY
val = weekday
annots = hlp.compose_annot(bits[ann], ann_value=val)
self.putd(0, 2, [ann, annots])
# Registers row
ann = AnnRegs.WEEKDAY
act = self.format_rw()
annots = hlp.compose_annot(registers[ann], ann_action=act)
self.put(self.ssd, self.es, self.out_ann, [ann, annots])
def handle_reg_0x04(self, b, rw): # Date (1-31)
self.putd(7, 0, [Ann.REG_DATE, ['Date', 'D']])
for i in (7, 6):
self.putr(i)
d = self.date = bcd2int(b & 0x3f)
self.putd(5, 0, [Ann.BIT_DATE, ['Date: %d' % d, 'D: %d' % d, 'D']])
self.inblock = 4 if self.inblock == 3 and self.blockmode == rw else -1
def handle_reg_0x00(self, b): # Seconds (0-59) / Clock halt bit
self.putd(7, 0, [0, ['Seconds', 'Sec', 'S']])
ch = 1 if (b & (1 << 7)) else 0
self.putd(7, 7, [9, ['Clock halt: %d' % ch, 'Clk hlt: %d' % ch,
'CH: %d' % ch, 'CH']])
s = self.seconds = bcd2int(b & 0x7f)
self.putd(6, 0, [10, ['Second: %d' % s, 'Sec: %d' % s, 'S: %d' % s, 'S']])
def handle_reg_0x0b(self, b): # Alarm 2 minutes
self.alarm2.m2 = bcd2int(b & 0b10000000) >> 7
self.putd(7, 7, [
Ann.BIT_AE,
['A2M2: %d' % self.alarm2.m2,
'A2: %d' % self.alarm2.m2, 'A2']
])
self.alarm2.minutes = bcd2int(b & 0b01111111)
self.putd(6, 0, [
Ann.BIT_MINUTES,
[
'Minutes: %d' % self.alarm2.minutes,
'Min: %d' % self.alarm2.minutes, 'M'
]
])
self.putd(7, 0, [Ann.REG_ALARM_2_MINS, ['Minutes', 'Mins', 'M']])
def handle_reg_0x00(self, b): # Seconds (0-59) / Clock halt bit
self.putd(7, 0, [0, ['Seconds', 'Sec', 'S']])
ch = 1 if (b & (1 << 7)) else 0
self.putd(7, 7, [9, ['Clock halt: %d' % ch, 'Clk hlt: %d' % ch,
'CH: %d' % ch, 'CH']])
s = self.seconds = bcd2int(b & 0x7f)
self.putd(6, 0, [10, ['Second: %d' % s, 'Sec: %d' % s, 'S: %d' % s, 'S']])
def handle_reg_0x03(self, b): # Minutes
self.putr(7)
m = self.minutes = bcd2int(b & 0x7f)
self.putd(6, 0,
[3, ['Minute: %d' % m,
'Min: %d' % m,
'M: %d' % m, 'M']])
def handle_reg_0x03(self, b): # Day / day of week (1-7)
self.putd(7, 0, [3, ['Day of week', 'Day', 'D']])
for i in (7, 6, 5, 4, 3):
self.putr(i)
w = self.days = bcd2int(b & 0x07)
ws = days_of_week[self.days - 1]
self.putd(2, 0, [16, ['Weekday: %s' % ws, 'WD: %s' % ws, 'WD', 'W']])
def handle_reg_0x07(self, b): # Alarm 1 seconds
self.alarm1.m1 = bcd2int(b & 0b10000000) >> 7
self.putd(7, 7, [
Ann.BIT_AE,
['A1M1: %d' % self.alarm1.m1,
'A1: %d' % self.alarm1.m1, 'A1']
])
self.alarm1.seconds = bcd2int(b & 0b01111111)
self.putd(6, 0, [
Ann.BIT_SECONDS,
[
'Seconds: %d' % self.alarm1.seconds,
'S: %d' % self.alarm1.seconds, 'S'
]
])
self.putd(7, 0, [Ann.REG_ALARM_1_SECS, ['Seconds', 'Secs', 'S']])
def handle_reg_0x09(self, b): # Alarm 1 hours
self.alarm1.m3 = bcd2int(b & 0b10000000) >> 7
self.putd(7, 7, [
Ann.BIT_AE,
['A1M3: %d' % self.alarm1.m3,
'A3: %d' % self.alarm1.m3, 'A3']
])
self.alarm1.hours = bcd2int(b & 0b01111111)
self.putd(6, 0, [
Ann.BIT_HOURS,
[
'Hours: %d' % self.alarm1.hours,
'HH: %d' % self.alarm1.hours, 'H'
]
])
self.putd(7, 0, [Ann.REG_ALARM_1_HOURS, ['Hours', 'Hrs.', 'H']])
def handle_reg_0x03(self, b): # Day / day of week (1-7)
self.putd(7, 0, [3, ['Day of week', 'Day', 'D']])
for i in (7, 6, 5, 4, 3):
self.putr(i)
w = self.days = bcd2int(b & 0x07)
ws = days_of_week[self.days - 1]
self.putd(2, 0, [16, ['Weekday: %s' % ws, 'WD: %s' % ws, 'WD', 'W']])
def handle_reg_0x01(self, b): # Minutes (0-59)
self.putd(7, 0, [1, ['Minutes', 'Min', 'M']])
self.putr(7)
m = self.minutes = bcd2int(b & 0x7f)
self.putd(6, 0,
[12, ['Minute: %d' % m,
'Min: %d' % m,
'M: %d' % m, 'M']])
def handle_reg_0x06(self, b):
self.time.years = bcd2int(b & 0xff)
self.putd(7, 0, [
Ann.BIT_YEAR,
['Year: %d' % self.time.years,
'Y: %d' % self.time.years, 'Y']
])
self.putd(7, 0, [Ann.REG_YEAR, ['Year', 'Yr.', 'Y']])
def handle_reg_0x07(self, b): # Months / century bit
c = 1 if (b & (1 << 7)) else 0
self.putd(7, 7, [13, ['Century bit: %d' % c, 'Century: %d' % c,
'Cent: %d' % c, 'C: %d' % c, 'C']])
self.putr(6)
self.putr(5)
m = self.months = bcd2int(b & 0x1f)
self.putd(4, 0, [7, ['Month: %d' % m, 'Mon: %d' % m, 'M: %d' % m, 'M']])
def handle_reg_0x05(self, b): # Month (1-12)
self.putd(7, 0, [5, ['Month', 'Mon', 'M']])
for i in (7, 6, 5):
self.putr(i)
m = self.months = bcd2int(b & 0x1f)
self.putd(4, 0,
[18, ['Month: %d' % m,
'Mon: %d' % m,
'M: %d' % m, 'M']])
def handle_reg_0x01(self, b): # Minutes (0-59)
self.putd(7, 0, [Ann.REG_MINUTES, ['Minutes', 'Min', 'M']])
self.putr(7)
m = self.minutes = bcd2int(b & 0x7f)
self.putd(6, 0, [
Ann.BIT_MINUTES,
['Minute: %d' % m,
'Min: %d' % m, 'M: %d' % m, 'M']
])
def handle_reg_0x0d(self, b, rw): # Alarm2 Date or Day / day of week (1-7)
self.putd(7, 0, [
Ann.REG_ALARM2_DAY_DATE,
['Alarm2 Date or Day of week', 'Al2 Day / DOW', 'A2DD']
])
a2m4 = 1 if (b & (1 << 7)) else 0
self.putd(7, 7, [Ann.BIT_A2M4, ['A2M4: %d' % a2m4, 'A2M4']])
a2dydt = 1 if (b & (1 << 6)) else 0
self.putd(6, 6, [Ann.BIT_DAY_DATE, ['DYDT: %d' % a2dydt, 'DYDT']])
if a2dydt == 1:
w = bcd2int(b & 0x07)
ws = days_of_week[self.options['fdw']][w - 1]
self.putd(
2, 0,
[Ann.BIT_DAY, ['Weekday: %s' % ws,
'WD: %d' % w, 'WD', 'W']])
else:
da = bcd2int(b & 0x3f)
self.putd(
5, 0,
[Ann.BIT_DATE, ['Date / Date: %d' % da,
'D: %d' % da, 'D']])
#block
if self.inblock == 0x0c and self.blockmode == rw:
if (self.a2m2, self.a2m3, a2m4) == (1, 1, 1):
d = 'every minute'
elif (self.a2m2, self.a2m3, a2m4) == (0, 1, 1):
d = 'every hour, minute=%02d' % self.al2minutes
elif (self.a2m2, self.a2m3, a2m4) == (0, 0, 1):
d = 'every day, hh:mm=%02d:%02d%s' % (
self.al2hours, self.al2minutes, self.a2ampm)
elif (self.a2m2, self.a2m3, a2m4) == (0, 0, 0):
if a2dydt == 1:
daydate = ws
else:
daydate = '%d. of month' % da
d = 'every %s, hh:mm=%02d:%02d' % (daydate, self.al2hours,
self.al2minutes)
else:
d = 'invalid setting' #FIXME: print warning
d = 'Alarm2: ' + d
self.put(self.startreg, self.es, self.out_ann,
[Ann.BLOCK_ALARM2, ['%s %s' % (rw, d)]])
self.inblock = -1
def handle_reg_0x04(self, b):
self.putr(7)
self.putr(6)
self.time.date = bcd2int(b & 0x7f)
self.putd(5, 0, [
Ann.BIT_DATE,
['Date: %d' % self.time.date,
'D: %d' % self.time.date, 'D']
])
self.putd(7, 0, [Ann.REG_DATE, ['Date', 'D', 'D']])
def handle_reg_0x01(self, b, rw): # Minutes (0-59)
self.putd(7, 0, [Ann.REG_MINUTES, ['Minutes', 'Min', 'M']])
self.putr(7)
m = self.minutes = bcd2int(b & 0x7f)
self.putd(6, 0, [
Ann.BIT_MINUTES,
['Minute: %d' % m,
'Min: %d' % m, 'M: %d' % m, 'M']
])
self.inblock = 1 if self.inblock == 0 and self.blockmode == rw else -1
def handle_reg_0x03(self, b, rw): # Day / day of week (1-7)
self.putd(7, 0, [Ann.REG_DAY, ['Day of week', 'Day', 'D']])
for i in (7, 6, 5, 4, 3):
self.putr(i)
self.days = bcd2int(b & 0x07)
ws = days_of_week[self.options['fdw']][self.days - 1]
self.putd(
2, 0,
[Ann.BIT_DAY, ['Weekday: %s' % ws,
'WD: %s' % ws, 'WD', 'W']])
self.inblock = 3 if self.inblock == 2 and self.blockmode == rw else -1
def put_field(self, numbits, line):
param = self.ookstring[self.decode_pos:self.decode_pos + numbits]
if 'rev' in self.displayas:
param = param[::-1] # Reversed from right.
if not 'E' in param: # Format if no errors.
if 'Hex' in self.displayas:
param = hex(int(param, 2))[2:]
elif 'BCD' in self.displayas:
param = bcd2int(int(param, 2))
self.putx([line, [str(param)]])
self.decode_pos += numbits
def handle_reg_0x00(self, b): # Seconds
self.putr(7)
self.time.seconds = bcd2int(b & 0x7f)
self.putd(6, 0, [
Ann.BIT_SECONDS,
[
'Second: %d' % self.time.seconds,
'Secs: %d' % self.time.seconds, 'S'
]
])
self.putd(7, 0, [Ann.REG_SECONDS, ['Seconds', 'Secs', 'S']])
def handle_reg_0x01(self, b):
self.putr(7)
self.time.minutes = bcd2int(b & 0x7f)
self.putd(6, 0, [
Ann.BIT_MINUTES,
[
'Minute: %d' % self.time.minutes,
'M: %d' % self.time.minutes, 'M'
]
])
self.putd(7, 0, [Ann.REG_MINUTES, ['Minutes', 'Mins', 'M']])
def handle_reg_0x00(self, b, rw): # Seconds (0-59)
self.putd(7, 0, [Ann.REG_SECONDS, ['Seconds', 'Sec', 'S']])
s = self.seconds = bcd2int(b & 0x7f)
self.putr(7)
self.putd(6, 0, [
Ann.BIT_SECONDS,
['Second: %d' % s,
'Sec: %d' % s, 'S: %d' % s, 'S']
])
#block
self.startreg = self.ss
self.inblock = 0
self.blockmode = rw
def handle_reg_0x08(self, b, rw): # Alarm1 Minutes (0-59)
self.putd(
7, 0,
[Ann.REG_ALARM1_MINUTES, ['Alarm1 Minutes', 'Al1 Min', 'A1M']])
self.a1m2 = 1 if (b & (1 << 7)) else 0
self.putd(7, 7, [Ann.BIT_A1M2, ['A1M2: %d' % self.a1m2, 'A1M2']])
m = self.al1minutes = bcd2int(b & 0x7f)
self.putd(6, 0, [
Ann.BIT_MINUTES,
['Minute: %d' % m,
'Min: %d' % m, 'M: %d' % m, 'M']
])
self.inblock = 8 if self.inblock == 7 and self.blockmode == rw else -1
def handle_reg_0x01(self, b): # Minutes (0-59)
self.putd(7, 0, [1, ['Minutes', 'Min', 'M']])
self.putr(7)
m = self.minutes = bcd2int(b & 0x7f)
self.putd(6, 0, [12, ['Minute: %d' % m, 'Min: %d' % m, 'M: %d' % m, 'M']])
def handle_reg_0x04(self, b): # Date (1-31)
self.putd(7, 0, [4, ['Date', 'D']])
for i in (7, 6):
self.putr(i)
d = self.date = bcd2int(b & 0x3f)
self.putd(5, 0, [17, ['Date: %d' % d, 'D: %d' % d, 'D']])
def handle_reg_0x05(self, b): # Month (1-12)
self.putd(7, 0, [5, ['Month', 'Mon', 'M']])
for i in (7, 6, 5):
self.putr(i)
m = self.months = bcd2int(b & 0x1f)
self.putd(4, 0, [18, ['Month: %d' % m, 'Mon: %d' % m, 'M: %d' % m, 'M']])
def handle_reg_0x06(self, b): # Year (0-99)
self.putd(7, 0, [6, ['Year', 'Y']])
y = self.years = bcd2int(b & 0xff)
self.years += 2000
self.putd(7, 0, [19, ['Year: %d' % y, 'Y: %d' % y, 'Y']])
def handle_reg_0x02(self, b): # Seconds / Voltage-low bit
vl = 1 if (b & (1 << 7)) else 0
self.putd(7, 7, [12, ['Voltage low: %d' % vl, 'Volt. low: %d' % vl,
'VL: %d' % vl, 'VL']])
s = self.seconds = bcd2int(b & 0x7f)
self.putd(6, 0, [2, ['Second: %d' % s, 'Sec: %d' % s, 'S: %d' % s, 'S']])
def handle_reg_0x03(self, b): # Minutes
self.putr(7)
m = self.minutes = bcd2int(b & 0x7f)
self.putd(6, 0, [3, ['Minute: %d' % m, 'Min: %d' % m, 'M: %d' % m, 'M']])
def handle_dcf77_bit(self, bit):
c = self.bitcount
# Create one annotation for each DCF77 bit (containing the 0/1 value).
# Use 'Unknown DCF77 bit x: val' if we're not sure yet which of the
# 0..58 bits it is (because we haven't seen a 'new minute' marker yet).
# Otherwise, use 'DCF77 bit x: val'.
s = 'B' if self.dcf77_bitnumber_is_known else 'Unknown b'
ann = 17 if self.dcf77_bitnumber_is_known else 18
self.putx([ann, ['%sit %d: %d' % (s, c, bit), '%d' % bit]])
# If we're not sure yet which of the 0..58 DCF77 bits we have, return.
# We don't want to decode bogus data.
if not self.dcf77_bitnumber_is_known:
return
# Collect bits 36-58, we'll need them for a parity check later.
if c in range(36, 58 + 1):
self.datebits.append(bit)
# Output specific "decoded" annotations for the respective DCF77 bits.
if c == 0:
# Start of minute: DCF bit 0.
if bit == 0:
self.putx([0, ['Start of minute (always 0)',
'Start of minute', 'SoM']])
else:
self.putx([19, ['Start of minute != 0', 'SoM != 0']])
elif c in range(1, 14 + 1):
# Special bits (civil warnings, weather forecast): DCF77 bits 1-14.
if c == 1:
self.tmp = bit
self.ss_block = self.ss_bit
else:
self.tmp |= (bit << (c - 1))
if c == 14:
s = bin(self.tmp)[2:].zfill(14)
self.putb([1, ['Special bits: %s' % s, 'SB: %s' % s]])
elif c == 15:
s = '' if (bit == 1) else 'not '
self.putx([2, ['Call bit: %sset' % s, 'CB: %sset' % s]])
# TODO: Previously this bit indicated use of the backup antenna.
elif c == 16:
s = '' if (bit == 1) else 'not '
x = 'yes' if (bit == 1) else 'no'
self.putx([3, ['Summer time announcement: %sactive' % s,
'Summer time: %sactive' % s,
'Summer time: %s' % x, 'ST: %s' % x]])
elif c == 17:
s = '' if (bit == 1) else 'not '
x = 'yes' if (bit == 1) else 'no'
self.putx([4, ['CEST: %sin effect' % s, 'CEST: %s' % x]])
elif c == 18:
s = '' if (bit == 1) else 'not '
x = 'yes' if (bit == 1) else 'no'
self.putx([5, ['CET: %sin effect' % s, 'CET: %s' % x]])
elif c == 19:
s = '' if (bit == 1) else 'not '
x = 'yes' if (bit == 1) else 'no'
self.putx([6, ['Leap second announcement: %sactive' % s,
'Leap second: %sactive' % s,
'Leap second: %s' % x, 'LS: %s' % x]])
elif c == 20:
# Start of encoded time: DCF bit 20.
if bit == 1:
self.putx([7, ['Start of encoded time (always 1)',
'Start of encoded time', 'SoeT']])
else:
self.putx([19, ['Start of encoded time != 1', 'SoeT != 1']])
elif c in range(21, 27 + 1):
# Minutes (0-59): DCF77 bits 21-27 (BCD format).
if c == 21:
self.tmp = bit
self.ss_block = self.ss_bit
else:
self.tmp |= (bit << (c - 21))
if c == 27:
m = bcd2int(self.tmp)
self.putb([8, ['Minutes: %d' % m, 'Min: %d' % m]])
elif c == 28:
# Even parity over minute bits (21-28): DCF77 bit 28.
self.tmp |= (bit << (c - 21))
parity = bin(self.tmp).count('1')
s = 'OK' if ((parity % 2) == 0) else 'INVALID!'
self.putx([9, ['Minute parity: %s' % s, 'Min parity: %s' % s]])
elif c in range(29, 34 + 1):
# Hours (0-23): DCF77 bits 29-34 (BCD format).
if c == 29:
self.tmp = bit
self.ss_block = self.ss_bit
else:
self.tmp |= (bit << (c - 29))
if c == 34:
self.putb([10, ['Hours: %d' % bcd2int(self.tmp)]])
elif c == 35:
# Even parity over hour bits (29-35): DCF77 bit 35.
self.tmp |= (bit << (c - 29))
parity = bin(self.tmp).count('1')
s = 'OK' if ((parity % 2) == 0) else 'INVALID!'
self.putx([11, ['Hour parity: %s' % s]])
elif c in range(36, 41 + 1):
# Day of month (1-31): DCF77 bits 36-41 (BCD format).
if c == 36:
self.tmp = bit
self.ss_block = self.ss_bit
else:
self.tmp |= (bit << (c - 36))
if c == 41:
self.putb([12, ['Day: %d' % bcd2int(self.tmp)]])
elif c in range(42, 44 + 1):
# Day of week (1-7): DCF77 bits 42-44 (BCD format).
# A value of 1 means Monday, 7 means Sunday.
if c == 42:
self.tmp = bit
self.ss_block = self.ss_bit
else:
self.tmp |= (bit << (c - 42))
if c == 44:
d = bcd2int(self.tmp)
dn = calendar.day_name[d - 1] # day_name[0] == Monday
self.putb([13, ['Day of week: %d (%s)' % (d, dn),
'DoW: %d (%s)' % (d, dn)]])
elif c in range(45, 49 + 1):
# Month (1-12): DCF77 bits 45-49 (BCD format).
if c == 45:
self.tmp = bit
self.ss_block = self.ss_bit
else:
self.tmp |= (bit << (c - 45))
if c == 49:
m = bcd2int(self.tmp)
mn = calendar.month_name[m] # month_name[1] == January
self.putb([14, ['Month: %d (%s)' % (m, mn),
'Mon: %d (%s)' % (m, mn)]])
elif c in range(50, 57 + 1):
# Year (0-99): DCF77 bits 50-57 (BCD format).
if c == 50:
self.tmp = bit
self.ss_block = self.ss_bit
else:
self.tmp |= (bit << (c - 50))
if c == 57:
self.putb([15, ['Year: %d' % bcd2int(self.tmp)]])
elif c == 58:
# Even parity over date bits (36-58): DCF77 bit 58.
parity = self.datebits.count(1)
s = 'OK' if ((parity % 2) == 0) else 'INVALID!'
self.putx([16, ['Date parity: %s' % s, 'DP: %s' % s]])
self.datebits = []
else:
raise Exception('Invalid DCF77 bit: %d' % c)
def handle_reg_0x04(self, b): # Hours
self.putr(7)
self.putr(6)
h = self.hours = bcd2int(b & 0x3f)
self.putd(5, 0, [4, ['Hour: %d' % h, 'H: %d' % h, 'H']])
def handle_reg_0x05(self, b): # Days
self.putr(7)
self.putr(6)
d = self.days = bcd2int(b & 0x3f)
self.putd(5, 0, [5, ['Day: %d' % d, 'D: %d' % d, 'D']])
def handle_reg_0x06(self, b): # Weekdays
for i in (7, 6, 5, 4, 3):
self.putr(i)
w = self.weekdays = bcd2int(b & 0x07)
self.putd(2, 0, [6, ['Weekday: %d' % w, 'WD: %d' % w, 'WD', 'W']])
def handle_reg_0x08(self, b): # Years
y = self.years = bcd2int(b & 0xff)
self.putx([8, ['Year: %d' % y, 'Y: %d' % y, 'Y']])
