async def _write_mqtt(self, knx_group, knx_val, debug_msg):
if not self._mqtt_client:
return
objects = []
request_status = False
for item in self.obj_list:
if item["knx_group"] == knx_group:
objects.append(item)
request_status = "request_status" in item
for o in objects:
if "publish_topic" in o:
topic = o["publish_topic"]
prev_val = o["value"]
if "valmap" in o:
payload = o["valmap"][knx_val]
else:
payload = knx_val
log.info(f"{debug_msg} topic {topic} updating {prev_val}=>{knx_val} ({payload})")
try:
await self._mqtt_client.publish(topic, payload, qos=1, retain=True)
o["value"] = knx_val
except MqttCodeError as error:
log.error(f"{debug_msg} MqttCodeError {error} on topic {topic}")
if objects and request_status and "status_object" in self.cfg and self._mqtt_client and not knx_group in self.status_pending_for_groups:
so = self.cfg["status_object"]
delay = so.get("delay", 10.0)
topic = so["topic"]
payload = so["payload"]
await asyncio.sleep(delay)
try:
await self._mqtt_client.publish(topic, payload, qos=1, retain=True)
log.debug(f"{debug_msg} requested status topic {topic} payload=>{payload}")
self.status_pending_for_groups.append(knx_group)
except MqttCodeError as error:
log.error(f"{debug_msg} MqttCodeError {error} on topic {topic}")
async def ups_client(self, loop):
try:
host, port = self.cfg["host"], self.cfg["port"]
self.ups_reader, self.ups_writer = await asyncio.open_connection(
host, port, loop=loop)
except gaierror as e:
log.error(
f"{self.device_name} can't connect to {host}:{port}. {e!r}")
async def rs485_connection(self, loop):
baudrate = "baudRate" in self.cfg and self.cfg["baudRate"] or 115200
dev = self.cfg["serialDevice"]
try:
self._reader, self._writer = await serial_asyncio.open_serial_connection(
loop=loop, url=dev, baudrate=baudrate)
log.info(
f"{self.device_name} Successfully opened {dev} @ {baudrate} baud."
)
except SerialException as e:
log.error(f"{self.device_name} Can't open {dev}. {e!r}")
async def send_knx(self, sequence):
async with self._knx_lock:
xml = '<write>' + sequence + '</write>\n\x04'
log.debug("sending to knx:{!r}".format(xml))
self.knx_client_writer.write(xml.encode(encoding='utf_8'))
await self.knx_client_writer.drain()
data = await asyncio.wait_for(self.knx_client_reader.readline(),
timeout=30.0)
decoded = data.decode()
if "<write status='error'>" in decoded:
log.error("LinKNX {}".format(decoded[1:-1]))
else:
log.debug("LinKNX {!r}".format(decoded))
async def knx_server_handler(self, reader, writer):
data = await reader.readline()
cmd = data.decode()
addr = writer.get_extra_info('peername')
log.debug("Received %r from %r" % (cmd, addr))
parse_errors = []
for callback in self.knx_read_cbs:
if not await callback(cmd):
parse_errors.append(callback)
if parse_errors:
log.error(
"Couldn't parse linknx command: {!r} in callback {!r}".format(
cmd, parse_errors))
writer.close()
def __init__(self, argv):
if len(sys.argv) > 1 and sys.argv[1]:
cfg_file = sys.argv[1]
else:
cfg_file = sys.path[0] + '/config.json'
try:
with open(cfg_file) as json_data_file:
self.cfg = json.load(json_data_file)
except FileNotFoundError:
message = "Couldn't open the config file " + cfg_file
log.error(message, sys.exc_info()[0])
sys.exit(0)
setLogLevel(self.cfg["sys"]["verbosity"])
self.knx_client_reader = None
self.knx_client_writer = None
self._knx_lock = asyncio.Lock()
self.loop = asyncio.get_event_loop()
self.knx_read_cbs = []
self.value_direct_cbs = []