hwclock-spi

#!/usr/bin/python
# vim:set ts=4 sw=4 et:

import os
import datetime
import sys
import datetime
import fcntl
from ctypes import cdll, c_int, POINTER, c_void_p, Structure
import datetime
from contextlib import contextmanager

RTC_SPI_DEVICE = '/dev/spidev2.0'

SPI_IOC_WR_MODE = 0x40016b01
SPI_IOC_RD_MODE = 0x80016b01
SPI_IOC_WR_BITS_PER_WORD = 0x40016b03
SPI_IOC_RD_BITS_PER_WORD = 0x80016b03

DS3234_REG_SECONDS   = 0x00
DS3234_REG_MINUTES   = 0x01
DS3234_REG_HOURS     = 0x02
DS3234_REG_DAY       = 0x03
DS3234_REG_DATE      = 0x04
DS3234_REG_MONTH     = 0x05
DS3234_REG_YEAR      = 0x06
DS3234_REG_CONTROL   = 0x0E
DS3234_REG_CONT_STAT = 0x0F


class BcdOutOfRange(Exception):
    pass

def bcd2bin(bcd_val):
    return (bcd_val & 0xf) + (((bcd_val & 0xf0) >> 4) * 10)

def bin2bcd(bin_val):
    if not (bin_val >= 0 and bin_val <= 99):
        raise BcdOutOfRange('binary value not between 0 and 99') 
    return (bin_val % 10) | ((bin_val / 10) << 4)

class Ds3234SpiCommunicationError(Exception):
    pass

def _read_data(dev_fp, num_bytes=0):
    data = os.read(dev_fp.fileno(), num_bytes + 1)
    if data[0] != '\xff':
        raise Ds3234SpiCommunicationError('SPI read failed with status ' + \
                repr(data[0]))
    return data[1:]

def spi_ioctl_write(dev_fp, operation, value):
    data = chr(value)
    fcntl.ioctl(dev_fp.fileno(), operation, data)

def spi_ioctl_read(dev_fp, operation):
    data = chr(0)
    data = fcntl.ioctl(dev_fp.fileno(), operation, data)
    return ord(data[0])

@contextmanager
def open_spi(dev_fn):
    with open(dev_fn, 'r+b') as fp:
        yield fp

def init_spi(dev_fp):
    spi_ioctl_write(dev_fp, SPI_IOC_WR_MODE, 3)
    spi_ioctl_write(dev_fp, SPI_IOC_WR_BITS_PER_WORD, 8)

    tmp = _get_reg(dev_fp, DS3234_REG_CONTROL)
    _set_reg(dev_fp, DS3234_REG_CONTROL, tmp & 0x1c)

    tmp = _get_reg(dev_fp, DS3234_REG_CONT_STAT)
    _set_reg(dev_fp, DS3234_REG_CONT_STAT, tmp & 0x88)

def get_time(dev_fp):
    dt_buf = _get_regs(dev_fp, 0, 7)
    tm_sec = bcd2bin(dt_buf[0])
    tm_min = bcd2bin(dt_buf[1])
    tm_hour = bcd2bin(dt_buf[2] & 0x3f)
    tm_mday = bcd2bin(dt_buf[4])
    tm_mon = bcd2bin(dt_buf[5] & 0x1f)
    tm_year = bcd2bin(dt_buf[6]) + 2000
    try:
        return datetime.datetime(tm_year, tm_mon, tm_mday, tm_hour, tm_min,
                tm_sec)
    except ValueError:
        print >>sys.stderr, 'RTC information corrupt: year:{0} month{1}, day:{2} hour:{3} minute:{3} second:{4}'.format(
                tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec)
        sys.exit(1)

def _get_regs(dev_fp, addr, len):
    os.write(dev_fp.fileno(), chr(addr))
    return [ord(data) for data in _read_data(dev_fp, len)]

def _get_reg(dev_fp, addr):
    return _get_regs(dev_fp, addr, 1)[0]

def _set_reg(dev_fp, addr, val):
    data = chr(addr | 0x80)
    data += chr(val)
    os.write(dev_fp.fileno(), data)
    _read_data(dev_fp)

def set_time(dev_fp, dt):
    _set_reg(dev_fp, DS3234_REG_SECONDS, bin2bcd(dt.second))
    _set_reg(dev_fp, DS3234_REG_MINUTES, bin2bcd(dt.minute))
    _set_reg(dev_fp, DS3234_REG_HOURS, (bin2bcd(dt.hour) & 0x3f))
    _set_reg(dev_fp, DS3234_REG_DAY, bin2bcd(dt.isoweekday()))
    _set_reg(dev_fp, DS3234_REG_DATE, bin2bcd(dt.day))
    _set_reg(dev_fp, DS3234_REG_MONTH, bin2bcd(dt.month) & 0x1f)
    _set_reg(dev_fp, DS3234_REG_YEAR, bin2bcd(dt.year - 2000))

def _settimeofday(sec_since_epoc):
    libc = cdll['libc.so.6']
    libc.settimeofday.restype = c_int
    class timeval(Structure):
        _fields_ = [('tv_sec', c_int), ('tv_usec', c_int)]
    libc.settimeofday.argtypes = POINTER(timeval), c_void_p
    t = timeval()
    t.tv_sec = sec_since_epoc
    libc.settimeofday(t, None)

def settimeofday(dt_utc):
    sec_since_epoc = (dt_utc - datetime.datetime(1970, 1, 1)).total_seconds()
    _settimeofday(int(sec_since_epoc))

def get_dt_from_device():
    with open_spi(RTC_SPI_DEVICE) as dev:
        init_spi(dev)
        return get_time(dev)

def show_usage():
    print >>sys.stderr, "Usage: {0} --hctosys|--systohc|--show|--show-delta".format(sys.argv[0])
    sys.exit(1)

if len(sys.argv) != 2:
    show_usage()

mode = sys.argv[1]
if mode == '--hctosys':
    dt = get_dt_from_device()
    print "Setting date and time from RTC: {0}".format(dt)
    settimeofday(dt)
elif mode == '--show':
    dt = get_dt_from_device()
    print "Date and time in RTC: {0}".format(dt)
elif mode == '--show-delta':
    dt = get_dt_from_device()
    now = datetime.datetime.now()
    print "Date and time in system: {0}".format(now)
    print "Date and time in RTC:    {0}".format(dt)
    print "Delta between RTC and system: {0}".format((dt - now).total_seconds())
elif mode == '--systohc':
    dt = datetime.datetime.now()
    print "Writing date and time to RTC: {0}".format(dt)
    with open(RTC_SPI_DEVICE, 'r+b') as dev:
        init_spi(dev)
        set_time(dev, dt)
else:
    print >>sys.stderr, "error: unknown mode {0}".format(mode)
    show_usage()