Added MacroPad RPC Home Assistant code

makermelissa · makermelissa · commit b9e24ba61abd · 2021-08-06T11:29:38.000-07:00
diff --git a/MacroPad_RPC_Home_Assistant/code.py b/MacroPad_RPC_Home_Assistant/code.py
@@ -0,0 +1,98 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: Unlicense
+"""
+Home Assistant Remote Procedure Call for MacroPad.
+"""
+import time
+import displayio
+import terminalio
+from adafruit_display_shapes.rect import Rect
+from rpc import RpcClient, RpcError
+from adafruit_display_text import label
+from adafruit_macropad import MacroPad
+from secrets import secrets
+
+macropad = MacroPad()
+rpc = RpcClient()
+
+COMMAND_TOPIC = "macropad/peripheral"
+SUBSCRIBE_TOPICS = ("stat/demoswitch/POWER", "stat/office-light/POWER")
+ENCODER_ITEM = 0
+KEY_LABELS = ("Demo", "Office")
+UPDATE_DELAY = 0.25
+NEOPIXEL_COLORS = {
+    "OFF": 0xff0000,
+    "ON": 0x00ff00,
+}
+
+class MqttError(Exception):
+    """For MQTT Specific Errors"""
+    pass
+# Set up displayio group with all the labels
+group = displayio.Group()
+for key_index in range(12):
+    x = key_index % 3
+    y = key_index // 3
+    group.append(label.Label(terminalio.FONT, text=(str(KEY_LABELS[key_index]) if key_index < len(KEY_LABELS) else ''), color=0xFFFFFF,
+                             anchored_position=((macropad.display.width - 1) * x / 2,
+                                                macropad.display.height - 1 -
+                                                (3 - y) * 12),
+                             anchor_point=(x / 2, 1.0)))
+group.append(Rect(0, 0, macropad.display.width, 12, fill=0xFFFFFF))
+group.append(label.Label(terminalio.FONT, text='Home Assistant', color=0x000000,
+                         anchored_position=(macropad.display.width//2, -2),
+                         anchor_point=(0.5, 0.0)))
+macropad.display.show(group)
+
+def rpc_call(function, *args, **kwargs):
+    response = rpc.call(function, *args, **kwargs)
+    if response["error"]:
+        if response["error_type"]:
+            raise MqttError(response["message"])
+        raise RpcError(response["message"])
+    return response["return_val"]
+
+def mqtt_init():
+    rpc_call("mqtt_init", secrets["mqtt_broker"], username=secrets["mqtt_username"], password=secrets["mqtt_password"], port=secrets["mqtt_port"])
+    rpc_call("mqtt_connect")
+
+def update_key(key_number):
+    switch_state = rpc_call("mqtt_get_last_value", SUBSCRIBE_TOPICS[key_number])
+    if switch_state is not None:
+        macropad.pixels[key_number] = NEOPIXEL_COLORS[switch_state]
+    else:
+        macropad.pixels[key_number] = None
+
+mqtt_init()
+last_macropad_encoder_value = macropad.encoder
+
+for key_number, topic in enumerate(SUBSCRIBE_TOPICS):
+    rpc_call("mqtt_subscribe", topic)
+    update_key(key_number)
+
+while True:
+    output = {}
+
+    key_event = macropad.keys.events.get()
+    if key_event and key_event.pressed:
+        output["key_number"] = key_event.key_number
+
+    if macropad.encoder != last_macropad_encoder_value:
+        output["encoder"] = macropad.encoder - last_macropad_encoder_value
+        last_macropad_encoder_value = macropad.encoder
+
+    macropad.encoder_switch_debounced.update()
+    if macropad.encoder_switch_debounced.pressed and "key_number" not in output and ENCODER_ITEM is not None:
+        output["key_number"] = ENCODER_ITEM
+
+    if output:
+        try:
+            rpc_call("mqtt_publish", COMMAND_TOPIC, output)
+            if "key_number" in output:
+                time.sleep(UPDATE_DELAY)
+                update_key(output["key_number"])
+        except MqttError:
+            mqtt_init()
+        except RpcError as err_msg:
+            print(err_msg)
diff --git a/MacroPad_RPC_Home_Assistant/rpc.py b/MacroPad_RPC_Home_Assistant/rpc.py
@@ -0,0 +1,126 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: Unlicense
+"""
+USB CDC Remote Procedure Call class
+"""
+
+import time
+import json
+try:
+    import serial
+    import adafruit_board_toolkit.circuitpython_serial
+    json_decode_exception = json.decoder.JSONDecodeError
+except ImportError:
+    import usb_cdc as serial
+    json_decode_exception = ValueError
+
+RESPONSE_TIMEOUT=1
+DATA_TIMEOUT=0.2
+
+class RpcError(Exception):
+    """For RPC Specific Errors"""
+    pass
+
+class _Rpc:
+    def __init__(self):
+        self._serial = None
+
+    @staticmethod
+    def create_response_packet(error=False, error_type="RPC", message=None, return_val=None):
+        return {
+            "error": error,
+            "error_type": error_type if error else None,
+            "message": message,
+            "return_val": return_val
+        }
+
+    @staticmethod
+    def create_request_packet(function, args=[], kwargs={}):
+        return {
+            "function": function,
+            "args": args,
+            "kwargs": kwargs
+        }
+
+    def _wait_for_packet(self, timeout=None):
+        incoming_packet = b""
+        if timeout is not None:
+            response_start_time = time.monotonic()
+        while True:
+            if incoming_packet:
+                data_start_time = time.monotonic()
+            while not self._serial.in_waiting:
+                if incoming_packet and (time.monotonic() - data_start_time) >= DATA_TIMEOUT:
+                    incoming_packet = b""
+                if not incoming_packet and timeout is not None:
+                    if (time.monotonic() - response_start_time) >= timeout:
+                        return self.create_response_packet(error=True, message="Timed out waiting for response")
+                time.sleep(0.001)
+            data = self._serial.read(self._serial.in_waiting)
+            if data:
+                try:
+                    incoming_packet += data
+                    packet = json.loads(incoming_packet)
+                    # json can try to be clever with missing braces, so make sure we have everything
+                    if sorted(tuple(packet.keys())) == sorted(self._packet_format()):
+                        return packet
+                except json_decode_exception:
+                    pass # Incomplete packet
+
+class RpcClient(_Rpc):
+    def __init__(self):
+        super().__init__()
+        self._serial = serial.data
+    
+    def _packet_format(self):
+        return self.create_response_packet().keys()
+
+    def call(self, function, *args, **kwargs):
+        packet = self.create_request_packet(function, args, kwargs)
+        self._serial.write(bytes(json.dumps(packet), "utf-8"))
+        # Wait for response packet to indicate success
+        return self._wait_for_packet(RESPONSE_TIMEOUT)
+
+class RpcServer(_Rpc):
+    def __init__(self, handler, baudrate=9600):
+        super().__init__()
+        self._serial = self.init_serial(baudrate)
+        self._handler = handler
+
+    def _packet_format(self):
+        return self.create_request_packet(None).keys()
+
+    def init_serial(self, baudrate):
+        port = self.detect_port()
+
+        return serial.Serial(
+            port,
+            baudrate,
+            parity='N',
+            rtscts=False,
+            xonxoff=False,
+            exclusive=True,
+        )
+
+    def detect_port(self):
+        """
+        Detect the port automatically
+        """
+        comports = adafruit_board_toolkit.circuitpython_serial.data_comports()
+        ports = [comport.device for comport in comports]
+        if len(ports) >= 1:
+            if len(ports) > 1:
+                print("Multiple devices detected, using the first detected port.")
+            return ports[0]
+        raise RuntimeError("Unable to find any CircuitPython Devices with the CDC Data port enabled.")
+
+    def loop(self, timeout=None):
+        packet = self._wait_for_packet(timeout)
+        if "error" not in packet:
+            response_packet = self._handler(packet)
+            self._serial.write(bytes(json.dumps(response_packet), "utf-8"))
+    
+    def close_serial(self):
+        if self._serial is not None:
+            self._serial.close()
diff --git a/MacroPad_RPC_Home_Assistant/rpc_ha_server.py b/MacroPad_RPC_Home_Assistant/rpc_ha_server.py
@@ -0,0 +1,107 @@
+import time
+import json
+import ssl
+import socket
+import adafruit_minimqtt.adafruit_minimqtt as MQTT
+from rpc import RpcServer
+
+mqtt_client = None
+mqtt_connected = False
+last_mqtt_messages = {}
+
+# For program flow purposes, we do not want these functions to be called remotely
+PROTECTED_FUNCTIONS = ["main", "handle_rpc"]
+
+def connect(mqtt_client, userdata, flags, rc):
+    global mqtt_connected
+    mqtt_connected = True
+
+def disconnect(mqtt_client, userdata, rc):
+    global mqtt_connected
+    mqtt_connected = False
+
+def message(client, topic, message):
+    last_mqtt_messages[topic] = message
+
+class MqttError(Exception):
+    """For MQTT Specific Errors"""
+    pass
+
+# Default to 1883 as SSL on CPython is not currently supported
+def mqtt_init(broker, port=1883, username=None, password=None):
+    global mqtt_client, mqtt_connect_info
+    mqtt_client = MQTT.MQTT(
+        broker=broker,
+        port=port,
+        username=username,
+        password=password,
+        socket_pool=socket,
+        ssl_context=ssl.create_default_context(),
+    )
+
+    mqtt_client.on_connect = connect
+    mqtt_client.on_disconnect = disconnect
+    mqtt_client.on_message = message
+
+def mqtt_connect():
+    mqtt_client.connect()
+
+def mqtt_publish(topic, payload):
+    if mqtt_client is None:
+        raise MqttError("MQTT is not initialized")
+    try:
+        return_val = mqtt_client.publish(topic, json.dumps(payload))
+    except BrokenPipeError:
+        time.sleep(0.5)
+        mqtt_client.connect()
+        return_val = mqtt_client.publish(topic, json.dumps(payload))
+    return return_val
+
+def mqtt_subscribe(topic):
+    if mqtt_client is None:
+        raise MqttError("MQTT is not initialized")
+    return mqtt_client.subscribe(topic)
+
+def mqtt_get_last_value(topic):
+    """Return the last value we have received regarding a topic"""
+    if topic in last_mqtt_messages.keys():
+        return last_mqtt_messages[topic]
+    return None
+
+def handle_rpc(packet):
+    """This function will verify good data in packet,
+    call the method with parameters, and generate a response
+    packet as the return value"""
+    func_name = packet['function']
+    if func_name in PROTECTED_FUNCTIONS:
+        return rpc.create_response_packet(error=True, message=f"{func_name}'() is a protected function and can not be called.")
+    if func_name not in globals():
+        return rpc.create_response_packet(error=True, message=f"Function {func_name}() not found")
+    try:
+        return_val = globals()[func_name](*packet['args'], **packet['kwargs'])
+    except MqttError as err:
+        return rpc.create_response_packet(error=True, error_type="MQTT", message=str(err))
+
+    packet = rpc.create_response_packet(return_val=return_val)
+    return packet
+
+def main():
+    """Command line, entry point"""
+    global mqtt_connected
+    while True:
+        rpc.loop(0.25)
+        if mqtt_connected and mqtt_client is not None:
+            try:
+                mqtt_client.loop(0.5)
+            except AttributeError:
+                mqtt_connected = False
+
+if __name__ == '__main__':
+    rpc = RpcServer(handle_rpc)
+    try:
+        print(f"Listening for RPC Calls, to stop press \"CTRL+C\"")
+        main()
+    except KeyboardInterrupt:
+        print("")
+        print(f"Caught interrupt, exiting...")
+    rpc.close_serial()
