delcom-clock

#!/usr/bin/python3
# A program to control a Delcom Engineering USB Numeric Display (USB ID 0fc5:1227)
# Note that this is the old display type.
# http://www.delcomproducts.com/products_USBNDisplay.asp
# Copyright 2010, 2014, 2017 Stuart Pook http://www.pook.it/
# https://github.com/stuart12/delcom-clock

# Tested on Python and Linux 4.19 and 5.2
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

# https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/usb/misc_usbsevseg.txt
# https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/usb/misc/usbsevseg.c

import os
import os.path
import sys
import argparse
import time
import select
import stat
import math
import logging
import pwd
import grp
import syslog
import signal
import functools
import errno

DIGITS = 8 # digits in the clock (compiled into kernel)

def excepthook(*args):
  logging.getLogger().error('Uncaught exception:', exc_info=args)
sys.excepthook = excepthook

def myname():
    return sys.argv[0]

def info(mess):
    logging.info(mess)

def message(mess):
    logging.debug(mess)

def error(do_syslog, mess):
    logging.error(mess)
    print(myname(), mess, file=sys.stderr)
    if do_syslog:
        syslog.syslog(syslog.LOG_ERR, mess)

def set_parameter(device, parameter, value):
    message("set_parameter(%s, %s, %s)" % (device, parameter, value))
    name = os.path.join(device, parameter)
    message("setting " + name + " to " + value)
    f = open(name, "w")
    f.write(value + "\n")
    f.close()
    message("set " + name + " to " + value)

def signal_handler(short_device, do_syslog, signal, frame):
    mess = "%s: exiting on signal %d" % (short_device, signal)
    if do_syslog:
        syslog.syslog(syslog.LOG_INFO, mess)
    else:
        message(mess)
    sys.exit(1)

def octal_int(x):
    return int(x, 8)

def get_options():
    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter,
        description="show the time on a Delcom Engineering USB Numeric Display")
    parser.set_defaults(loglevel='warn')
    parser.add_argument("-v", "--verbose", dest='loglevel', action="store_const", const='debug', help="debug loglevel")
    parser.add_argument("-l", "--loglevel", metavar="LEVEL", help="set logging level")
    parser.add_argument("--usbsevseg", default="/sys/bus/usb/drivers/usbsevseg", metavar="PATH", help="sys path to displays")
    parser.add_argument("--chown", default=None, metavar="USER", help="owner of control pipe")
    parser.add_argument("--group", default=None, metavar="GROUP", help="group of control pipe")
    parser.add_argument("--mode", type=octal_int, default=None, metavar="MODE", help="group of control pipe")
    parser.add_argument("--control", default=None, metavar="PATH", help="named pipe for control")
    parser.add_argument('-s', "--syslog", action="store_true", help="send errors to syslog")
    parser.add_argument("--update", type=int, metavar="SECONDS", default=1, help="delay between updates")
    parser.add_argument("--format", metavar="PATTERN", help="strftime pattern for display")
    parser.add_argument("--pformat", default="{:02d}.{:02d}.{:02d}", metavar="FORMAT", help="python format pattern for display")
    parser.add_argument("--parg", metavar="TYPE:KEY", action='append', help="what value to format")
    parser.add_argument("--fork", action="store_true", help="fork")
    parser.add_argument('--off', action="store_true", help="start off")
    parser.add_argument('-n', '--only_format', action="store_true", help="just format the output string")
    parser.add_argument("--mqttbroker", default="localhost", help="mqtt broker")
    parser.add_argument("--mqttclientid", default="delcom_clock", help="client_id for mqtt broker")
    parser.add_argument("--mqttuser", help="mqtt password")
    parser.add_argument("--mqttpassword", help="mqtt password")
    parser.add_argument("--mqttpasswdfile", metavar="FILENAME", help="file containing mqtt password")
    parser.add_argument('display', nargs=1, help='display name')
    options = parser.parse_args()
    if options.parg is None:
        options.parg = ['time:hour', 'time:min', 'time:sec']
    return options

def get_value(pattern, localtime, mqtt):
    type, id = pattern.split(':', 1)
    if type == 'time':
        return getattr(localtime, 'tm_' + id)
    if type == 'mqtt':
        logging.debug("mqtt value is %s (id=%s)", mqtt, id)
        try:
            return mqtt['data'][id]
        except KeyError:
            logging.warning('no mqtt payload received for %s in %s', id, mqtt)
            return 0.01

def format_output(localtime, format, pformat, pargs, mqtt):
    if format:
        return time.strftime(format, localtime)[-DIGITS:]
    args = [ get_value(c, localtime, mqtt) for c in pargs ]
    logging.debug("format %s (%s)", pformat, args)
    return pformat.format(*args)

def split_text(now, format, pformat, pargs, mqtt):
    text = format_output(now, format, pformat, pargs, mqtt)
    str = ''
    decimals = ''
    pending = ''
    for c in text:
        if c == '.':
            assert pending != ''
            pending = '1'
        else:
            decimals += pending
            str += c
            pending = '0'
    decimals += pending
    assert len(decimals) == len(str), "len(%s) != len(%s)" % (decimals, str)
    return str, decimals, text

def on_message(client, userdata, message):
    logging.debug("received a message on %s %s (userdata %s)", message.topic, message.payload, userdata)
    userdata['data'][message.topic] = float(message.payload)

def on_connect(client, userdata, flags, rc):
    if rc == 0:
        logging.info("connected to mqtt broker %s", userdata)
        for t in userdata['topics']:
            client.subscribe(t)
    else:
        logging.warning("failed to connect to mqtt broker %s %d", userdata, rc)

def on_disconnect(client, userdata, rc):
    logging.warning("disconnected from mqtt broker %s %d", userdata, rc)
    userdata['data'] = {}

def get_password(password, password_file):
    if password:
        return password
    with open(password_file) as f:
        logging.debug("reading password from %s", password_file)
        return f.readline().strip('\n')

def mqtt_setup(mqttbroker, mqttuser, mqttclientid, mqttpassword, mqttpasswdfile, pargs):
    topics = [s[1] for u in pargs for s in (u.split(':'), ) if s[0] == 'mqtt']
    logging.debug("mqtt topics %s", topics)
    if not topics:
        return None, None
    import paho.mqtt.client as mqttClient
    client = mqttClient.Client(client_id=mqttclientid, userdata=mqttbroker)
    client.username_pw_set(mqttuser, password=get_password(mqttpassword, mqttpasswdfile))
    client.on_connect = on_connect
    client.on_disconnect = on_disconnect
    client.on_message = on_message
    userdata = { 'topics': topics, 'data': {} }
    client.user_data_set(userdata)
    logging.debug("will connect to mqtt broker %s as %s with%s password", mqttbroker, mqttuser, "" if mqttpassword else "out")
    return client, userdata

def mqttconnect(client, broker):
    if client:
        try:
            client.connect(broker)
        except ConnectionRefusedError as ex:
            logging.warning("failed initial connection to mqtt broker %s (%s)", broker, ex)
            return client
        logging.info("initial connection to mqtt broker %s OK", broker)
        client.loop_start()
    return None

def run(options):
    mqttclient, mqtt = mqtt_setup(options.mqttbroker, options.mqttuser, options.mqttclientid, options.mqttpassword, options.mqttpasswdfile, options.parg)
    if options.only_format:
        if mqtt is not None: # hack
            time.sleep(5)
        text, decimals, full = split_text(time.localtime(time.time()), options.format, options.pformat, options.parg, mqtt)
        print(text, decimals, full)
        exit(0)

    do_syslog = options.syslog or options.fork

    device = os.path.join(options.usbsevseg, options.display[0])
    short_device = os.path.basename(device)

    logging.debug("device " + short_device)

    info("starting " + device)

    if do_syslog:
        syslog.openlog("delcom-clock",  0,  syslog.LOG_DAEMON)
        syslog.syslog(syslog.LOG_INFO, "%s: starting %s (%s)" % (short_device, device, options.display[0]))

    for s in [ signal.SIGINT, signal.SIGTERM, signal.SIGHUP ]:
        signal.signal(s, functools.partial(signal_handler, short_device, do_syslog))

    poller = select.poll()

    try:
        level = os.path.join(device, "../power/level")
        message("opening " + level)
        power = open(level)
        message("opened " + level)
        power_required = "auto\n"
        old_power = power.readline()
        power.close()
        if options.fork and os.fork() != 0:
            sys.exit(0)
            
        if old_power != power_required:
            message("power was " + old_power)
            power = open(level, "w")
            message("opened " + level)
            power.write(power_required)
            power.close()
            magic_delay = 5.0
            message("sleeping " + str(magic_delay))
            time.sleep(magic_delay)
            message("slept " + str(magic_delay))
            
        set_parameter(device, "powered", "1")
        set_parameter(device, "mode_msb", "8")
        set_parameter(device, "mode_lsb", "255")
        set_parameter(device, "textmode", "ascii")

        text_filename = os.path.join(device, "text")
        text = open(text_filename, "w", buffering=1)
        decimals = open(os.path.join(device, "decimals"), "w", buffering=1)
    except Exception as e:
        syslog.syslog(syslog.LOG_ERR,  short_device + ": initialisation error: " + str(e))
        raise

    command_gap = 25
    time.sleep(command_gap / 1000.0)

    try:
        if options.off:
            print("1" + "0" * (DIGITS - 1), file=decimals)
            time.sleep(0.75 + command_gap / 1000.0)
            print("0" * DIGITS, file=decimals)
        else:
            print("8" * DIGITS, file=text)
            time.sleep(command_gap / 1000.0 )
            print("1" * DIGITS, file=decimals)
            time.sleep(0.75 +command_gap / 1000.0)
            print("1" * DIGITS, file=decimals)
    except Exception as e:
        syslog.syslog(syslog.LOG_ERR,  "error on " + device + ": " + str(e))
        raise

    #set_parameter(device, "decimals", decimals)
    time.sleep(command_gap / 1000.0)

    try:
        if options.control:
            if not os.path.exists(options.control):
                os.mkfifo(options.control, 0o660)
                gid = -1
                uid = -1
                if options.chown:
                    uids = pwd.getpwnam(options.chown)
                    uid = uids.pw_uid
                    gid = uids.pw_gid
                if options.group:
                    gid = grp.getgrnam(options.group).gr_gid
                if uid != -1 or gid != -1:
                    logging.debug("chown %s %d:%d", options.control, uid, gid)
                    os.chown(options.control, uid, gid)
                if options.mode:
                    logging.debug("chmod %s %o", options.control, options.mode)
                    os.chmod(options.control, options.mode)
            message("opening for read " + options.control)
            control_fd = os.open(options.control, os.O_RDONLY | os.O_NONBLOCK)
            if not stat.S_ISFIFO(os.fstat(control_fd)[stat.ST_MODE]):
                sys.exit(options.control + " is not a pipe");
            poller.register(control_fd)
            keep_it_open_so_do_not_block = os.open(options.control, os.O_WRONLY)
            message("opened " + options.control)
    except Exception as e:
        syslog.syslog(syslog.LOG_ERR, "error setting up control " + options.control + ": " + str(e))
        raise

    logging.info("starting %s every %f", options.format, options.update)
    if do_syslog:
        syslog.syslog(syslog.LOG_INFO, "%s: updating %s every %d seconds controlled by %s" % (short_device, options.format, options.update, options.control))
    on = not options.off
    while True:
        now = time.time()
        localtime = time.localtime(now)
        out, dots, _ = split_text(localtime, options.format, options.pformat, options.parg, mqtt)
        try:
            print(out if on else "", file=text)
            time.sleep(command_gap / 1000.0)
            print(dots if on else "", file=decimals)
        except OSError as ex:
            error(do_syslog, "failed to write: %s: %s" % (text_filename, ex))
            if ex.errno == errno.ENODEV:
                error(do_syslog, "exit(0) after ENODEV")
                sys.exit(0)
            raise

        mqttclient = mqttconnect(mqttclient, options.mqttbroker)
        now = time.time()

        # this line is the hardest to get right
        delay = options.update - now % 60 % options.update
        rdelay =  int(math.ceil(delay * 1000))
        if rdelay < command_gap + 1:
            message("rdelay too small " + str(rdelay))
            rdelay = command_gap
        message('[' + out + "] delay=" + str(delay) + " " + str(now) + " " + str(localtime.tm_sec) + ' ' + str(now % 60) + " " + str(rdelay))
        read = poller.poll(rdelay)
        if read != []:
            message("something to read")
            s = os.read(read[0][0],  100)
            message("read " + str(s))
            old_on = on
            for c in s:
                if c == ord("0"):
                    on = False
                elif c == ord("1"):
                    on = True
                elif c == ord('~'):
                    on = not on
                elif c == ord('!'):
                    messages = ["", out]
                    for m in [not on, on]:
                        time.sleep(4 * command_gap / 1000.0)
                        print(messages[int(m)], file=text)
                elif c == ord('\n'):
                    pass
                else:
                    message("unexpected read " + str(c))
            time.sleep(command_gap / 1000.0)

def main():
    options = get_options()
    numeric_level = getattr(logging, options.loglevel.upper(), None)
    if not isinstance(numeric_level, int):
        sys.exit('Invalid log level: %s' % options.loglevel)
    logging.basicConfig(level=numeric_level)
    logging.debug("starting")
    run(options)

if __name__ == "__main__":
    main()