rainbow/iris/burrow-iris.py

   1 #!/usr/bin/env python
   2 # Iris -- the Burrow's goddess of rainbow
   3 # Controls LEDs on the Rainbow according to the state of the house
   4 # (c) 2022 Martin Mareš <mj@ucw.cz>
   5
   6 import argparse
   7 import asyncio
   8 import asyncio_mqtt
   9 from datetime import datetime, timedelta
  10 import logging
  11 from logging.handlers import SysLogHandler
  12 import ssl
  13 import sys
  14
  15
  16 class State:
  17     def __init__(self, mqtt):
  18         self.attrs = {}
  19         self.leds = ["?"] * 12
  20         self.new_leds = ["?"] * 12
  21         self.mqtt = mqtt
  22
  23     def set_now(self):
  24         self.now = datetime.now()
  25
  26     def received_msg(self, topic, val):
  27         self.attrs[topic] = val
  28         logger.debug(f'MQTT: {topic} -> {val}')
  29
  30     def get(self, key, default=None):
  31         topic = "burrow/" + key
  32         return self.attrs.get(topic, default)
  33
  34     def get_status(self, key, default=None):
  35         topic = "status/" + key
  36         return self.attrs.get(topic, default)
  37
  38     def get_sensor(self, key, default=None, timeout=120):
  39         topic = "burrow/" + key
  40         if topic in self.attrs:
  41             s = self.attrs[topic].split(" ")
  42             if len(s) >= 2 and timeout is not None and int(s[1]) < self.now.timestamp() - timeout:
  43                 logger.debug(f"< {key} EXPIRED")
  44                 return default
  45             else:
  46                 logger.debug(f"< {key} = {s[0]}")
  47                 return float(s[0])
  48         else:
  49             logger.debug(f"< {key} UNDEFINED")
  50             return default
  51
  52     async def set(self, key, val):
  53         global mq
  54         topic = "burrow/" + key
  55         logger.debug(f'> {key} = {val}')
  56         await self.mqtt.publish(topic, val, retain=True)
  57
  58     def set_led(self, i, color=None):
  59         if color is None:
  60             self.new_leds[i] = ""
  61         else:
  62             r, g, b = color
  63             self.new_leds[i] = f"{r} {g} {b} iris"
  64
  65     async def update_leds(self):
  66         for i in range(len(self.leds)):
  67             if self.new_leds[i] != self.leds[i]:
  68                 await self.set(f"lights/rainbow/{i}", self.new_leds[i])
  69                 self.leds[i] = self.new_leds[i]
  70
  71
  72 st = None       # Current State
  73 led_event = None
  74
  75
  76 def boiler_led():
  77     stat = st.get_status('bsb', 'ok')
  78     if stat != 'ok':
  79         return (1, 1, 0)
  80
  81     err = st.get_sensor('heating/error', 0, timeout=None)
  82     if err > 0:
  83         return (1, 0, 0)
  84
  85     if st.get_sensor('heating/circuit1/pump', 0, timeout=3600) > 0:
  86         return (0.2, 0, 0.2)
  87
  88     if st.get_sensor('heating/circuit2/active', 0, timeout=3600) > 0:
  89         return (0, 0.3, 0)
  90
  91     if st.get_sensor('heating/water/active', 0, timeout=3600) > 0:
  92         return (0, 0, 0.3)
  93
  94     return None
  95
  96
  97 def catarium_led():
  98     temp = st.get_sensor('temp/catarium')
  99     if temp is None:
 100         return (1, 0, 0)
 101
 102     if temp < 22:
 103         return (0, 0, 1)
 104
 105     if temp < 23:
 106         return (0, 0.5, 0.5)
 107
 108     if temp > 26:
 109         return (0.1, 0.1, 0)
 110
 111     return None
 112
 113
 114 def temperature_led():
 115     for sensor in ['loft', 'ursarium', 'garage']:   # FIXME: terarium
 116         if st.get_sensor(f"temp/{sensor}", timeout=3600) is None:
 117             return (1, 0, 0)
 118
 119     return None
 120
 121
 122 def ac_led():
 123     ac = st.get_sensor('air/ac-on')
 124     if ac == 1:
 125         return (0, 1, 0)
 126     else:
 127         return None
 128
 129
 130 def recalc_leds():
 131     st.set_led(11, None)
 132     st.set_led(10, boiler_led())
 133     st.set_led(9, catarium_led())
 134     # st.set_led(8, temperature_led())
 135     st.set_led(8, ac_led())
 136
 137
 138 async def mqtt_process_msg(topic, val):
 139     st.received_msg(topic, val)
 140     led_event.set()
 141
 142
 143 async def mqtt_loop():
 144     sctx = ssl.SSLContext(ssl.PROTOCOL_TLS)
 145     sctx.verify_mode = ssl.CERT_REQUIRED
 146     sctx.load_cert_chain('/etc/burrow-mqtt/client.crt', '/etc/burrow-mqtt/client.key')
 147     sctx.load_verify_locations(cafile='/etc/burrow-mqtt/ca.crt')
 148
 149     will = asyncio_mqtt.Will(topic='status/iris', payload='dead', qos=1, retain=True)
 150
 151     async with asyncio_mqtt.Client(client_id='iris', hostname="burrow-mqtt", port=8883, tls_context=sctx, will=will) as mqtt:
 152         global st
 153         st = State(mqtt)
 154         async with mqtt.unfiltered_messages() as messages:
 155             await mqtt.subscribe("burrow/air/ac-on")
 156             await mqtt.subscribe("burrow/heating/#")
 157             await mqtt.subscribe("burrow/temp/#")
 158             await mqtt.publish("status/iris", "ok", retain=True)
 159             async for msg in messages:
 160                 await mqtt_process_msg(msg.topic, msg.payload.decode())
 161
 162
 163 async def mqtt_watcher():
 164     while True:
 165         try:
 166             logger.info("Starting MQTT")
 167             await mqtt_loop()
 168         except asyncio_mqtt.MqttError as error:
 169             logger.error(f"MQTT error: {error}")
 170         await asyncio.sleep(10)
 171
 172
 173 async def led_watcher():
 174     while True:
 175         await led_event.wait()
 176         led_event.clear()
 177         logger.debug('Recalculating LEDs')
 178         if st is not None:
 179             st.set_now()
 180             recalc_leds()
 181             await st.update_leds()
 182             await asyncio.sleep(0.1)
 183
 184
 185 async def main():
 186     global loop, led_event
 187     loop = asyncio.get_event_loop()
 188     led_event = asyncio.Event()
 189     coros = [
 190         loop.create_task(mqtt_watcher()),
 191         loop.create_task(led_watcher()),
 192     ]
 193     for coro in asyncio.as_completed(coros):
 194         done = await coro
 195         done.result()       # The coroutine probably died of an exception, which is raised here.
 196
 197
 198 parser = argparse.ArgumentParser(description='The Goddess of Rainbow in the Burrow')
 199 parser.add_argument('--debug', default=False, action='store_true', help='Run in debug mode')
 200 args = parser.parse_args()
 201
 202 logger = logging.getLogger()
 203 if args.debug:
 204     formatter = logging.Formatter(fmt="%(asctime)s %(name)s.%(levelname)s: %(message)s", datefmt='%Y-%m-%d %H:%M:%S')
 205     log_handler = logging.StreamHandler(stream=sys.stdout)
 206     logger.setLevel(logging.DEBUG)
 207     logging.getLogger('mqtt').setLevel(logging.DEBUG)
 208 else:
 209     formatter = logging.Formatter(fmt="%(message)s")        # systemd will handle the rest
 210     log_handler = SysLogHandler('/dev/log', facility=SysLogHandler.LOG_LOCAL1)
 211     log_handler.ident = 'burrow-iris: '
 212     logger.setLevel(logging.INFO)
 213 log_handler.setFormatter(formatter)
 214 logger.addHandler(log_handler)
 215
 216
 217 asyncio.run(main())