Adds ALL-Link Group support as controlled state (nugget#114)

mstovenour · mstovenour · commit b514906066a1 · 2019-11-25T11:40:01.000-06:00
* This is only the sending half of the Issue nugget#114 implementation * Discovers PLM ALL-Link group controllers and exposes as states so each group is a "switch" in Home Assistant * Sends ALL-Link group cleanups to each responder * Does not flood the network with unnecessary status polls * Correctly reports device state for ALL-Link group recall (0x11) from responder's ALDB stored recall level. Requires device aldb scan to get devices updated correctly; will work OK without the scan but individual devices should be hidden on the UI. * Requires an update to the Home Assistant Insteon platform
diff --git a/insteonplm/devices/__init__.py b/insteonplm/devices/__init__.py
@@ -24,6 +24,7 @@
     MESSAGE_ACK,
     MESSAGE_TYPE_BROADCAST_MESSAGE,
     MESSAGE_TYPE_DIRECT_MESSAGE,
+    MESSAGE_TYPE_ALL_LINK_CLEANUP,
     MESSAGE_FLAG_DIRECT_MESSAGE_NAK_0XA0,
     MESSAGE_STANDARD_MESSAGE_RECEIVED_0X50,
     MESSAGE_EXTENDED_MESSAGE_RECEIVED_0X51
@@ -203,6 +204,77 @@ def product_data_request(self):
                            COMMAND_PRODUCT_DATA_REQUEST_0X03_0X00)
         self._send_msg(msg)
 
+    def ALL_Link_cleanup(self, group, cmd_tuple):
+        """Send an ALL-Link cleanup message to this device.
+
+        The device object for the device being cleaned up must send this
+        message so the messaging lock will correctly sequence the cleanup with
+        other device activities (e.g. reading ALDB)
+        """
+        _LOGGER.debug('Sending ALL-Link Cleanup to %s for ALL-Link group 0x%x',
+                      self.address.human, group)
+        flags = MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, 0, 3, 3)
+        msg = StandardSend(self._address, cmd_tuple, cmd2=group, flags=flags)
+        self._send_msg(msg, self._handle_ALL_Link_cleanup_ack)
+
+    def _handle_ALL_Link_cleanup_ack(self, msg):
+        _LOGGER.debug('Received ALL-Link Cleanup ACK from %s; ALL-Link group '
+                      '0x%x; looking for responder states',
+                      msg.address.human, msg.cmd2)
+        # Search Device's ALDB for ID: target and group: cmd2
+        # Get responder group list and recall_level
+        responders = self._find_group_responder_states(msg.target, msg.cmd2)
+
+        for responder in responders:
+            _LOGGER.debug('Calling %s:0x%x:handle_ALL_Link_cleanup_ack',
+                          self._address.human, responder)
+            if hasattr(self.states[responder], 'handle_ALL_Link_cleanup_ack'):
+                self.states[responder].handle_ALL_Link_cleanup_ack(
+                    msg, responders[responder])
+            else:
+                _LOGGER.warning('Device %s:0x%x has no '
+                                'handle_ALL_Link_cleanup_ack() method.  '
+                                'Cannot perform ALL-Link cleanup',
+                                self._address.human, responder)
+
+    def _find_group_responder_states(self, ctl, ctl_group):
+        _LOGGER.debug('Looking for responder to controller %s:0x%x',
+                      ctl.human, ctl_group)
+        responders = {}
+        if self._aldb:
+            for rec_num in self._aldb:
+                rec = self._aldb[rec_num]
+                # Need to match either group 0 or 1 for ctl group 0 or 1
+                # compare rec.group using 0x01 if rec.group is 0x00
+                rec_group = rec.group if rec.group != 0x00 else 0x01
+                # compare ctl_group using 0x01 if ctl_group
+                # is 0x00
+                ctl_group = ctl_group if ctl_group != 0x00 else 0x01
+                if (rec.control_flags.is_responder and
+                        rec.address == ctl and
+                        rec_group == ctl_group):
+                    # responder group should be 0x01 even if recorded
+                    # as 0x00
+                    group = rec.data3 if rec.data3 != 0x00 else 0x01
+                    _LOGGER.debug('Found responder state %s:0x%x recall '
+                                  'level 0x%x for controller %s:0x%x. Actual '
+                                  'responder state 0x%x', self.address.human,
+                                  rec.data3, rec.data1, ctl.human,
+                                  rec.group, group)
+                    responders[group] = rec.data1
+            if not responders:
+                _LOGGER.warning('No responders found in ALDB %s',
+                                self.address.human)
+        else:
+            if self._aldb.status == ALDBStatus.LOADED:
+                _LOGGER.warning('No responders found; ALDB is empty %s',
+                                self.address.human)
+            else:
+                _LOGGER.warning('No responders found; ALDB is not loaded %s',
+                                self.address.human)
+
+        return responders
+
     def assign_to_all_link_group(self, group=0x01):
         """Assign a device to an All-Link Group.
 
@@ -685,13 +757,25 @@ def receive_message(self, msg):
                     self._directACK_received_queue.put_nowait(msg)
                 else:
                     _LOGGER.debug('But Direct ACK not expected')
+            elif (hasattr(msg, 'flags') and
+                  hasattr(msg.flags, 'isAllLinkCleanupACK') and
+                  msg.flags.isAllLinkCleanupACK):
+                _LOGGER.debug('Got ALL-Link Cleanup ACK message. Already in '
+                              'queue: %d, Queueing %s:%s',
+                              self._directACK_received_queue.qsize(),
+                              id(msg), msg)
+                if self._send_msg_lock.locked():
+                    self._directACK_received_queue.put_nowait(msg)
+                else:
+                    _LOGGER.debug('But ALL-Link Cleanup ACK not expected')
 
             callbacks = self._message_callbacks.get_callbacks_from_message(msg)
             for callback in callbacks:
                 _LOGGER.debug('Scheduling msg callback: %s', callback)
                 self._plm.loop.call_soon(callback, msg)
         else:
             _LOGGER.debug('msg is duplicate: %s', id(msg))
+
         self._last_communication_received = datetime.datetime.now()
         _LOGGER.debug('Ending Device.receive_message')
 
@@ -1348,6 +1432,11 @@ def find_matching_link(self, mode, group, addr):
               reverse direction.
         group: All-Link group number
         addr:  Inteon address of the linked device
+
+        NOTE: This function is flawed because it assumes there is only one
+        matching link.  There could be multiple responders on a single device
+        that are tied to the ALL-Link group (e.g. turn on two relays).  Should
+        return a list of matching records.
         """
         found_rec = None
         mode_test = None
diff --git a/insteonplm/plm.py b/insteonplm/plm.py
@@ -31,6 +31,7 @@
                               byte_to_unitcode,
                               rawX10_to_bytes,
                               x10_command_type)
+from insteonplm.states.allLinkGroup import AllLinkGroup
 
 __all__ = ('PLM, Hub')
 _LOGGER = logging.getLogger(__name__)
@@ -395,6 +396,42 @@ def _find_scene(self, group):
                         device_list.append(device.address)
         return device_list
 
+    def trigger_All_Link_group(self, group, cmd_tuple):
+        """Trigger an All-Link Group using command in cmd_tupl."""
+        from .messages.standardSend import StandardSend
+        from .messages.messageFlags import MessageFlags
+        from .constants import MESSAGE_TYPE_ALL_LINK_BROADCAST
+
+        target = Address(bytearray([0x00, 0x00, group]))
+        flags = MessageFlags.template(MESSAGE_TYPE_ALL_LINK_BROADCAST, 0, 3, 3)
+        # ALL-Link broadcast cmd2 is always 0x00
+        msg = StandardSend(target, cmd_tuple, cmd2=0x00, flags=flags)
+        self.send_msg(msg)
+        _LOGGER.debug('Broadcast ALL-Link Group 0x%x cmd1: 0x%x cmd2: 0x%x',
+                      group, cmd_tuple['cmd1'], 0x00)
+
+        # Find all the responders to this PLM ALL-Link Group from PLM ALDB
+        device_list = self._find_group_controlled_devices(group)
+
+        for device in device_list:
+            _LOGGER.debug('Sending Cleanup to %s for ALL-Link group 0x%x',
+                          device.address.human, group)
+            # find responder entries in the device's ALDB
+            device.ALL_Link_cleanup(group, cmd_tuple)
+
+    def _find_group_controlled_devices(self, group):
+        """Identify all devices where PLM is controller for ALL-Link group."""
+        device_list = []
+
+        for rec_num in self._aldb:
+            rec = self._aldb[rec_num]
+            if (rec.control_flags.is_controller and rec.group == group):
+                if rec.address.id not in device_list:
+                    device = self._devices[rec.address.id]
+                    device_list.append(device)
+
+        return device_list
+
     async def _setup_devices(self):
         await self.devices.load_saved_device_info()
         _LOGGER.info('Found %d saved devices',
@@ -689,6 +726,11 @@ def _handle_all_link_record_response(self, msg):
             _LOGGER.debug('Device %s already loaded from saved data or '
                           'overrides', msg.address.hex)
 
+        # If this is a controller entry, create a allLinkGroup state.  These
+        # entries are used for PLM controlled scenes.
+        if msg.isController:
+            self._add_controller(msg.group)
+
         self._next_all_link_rec_nak_retries = 0
         self._get_next_all_link_record()
 
@@ -706,8 +748,34 @@ def _handle_get_next_all_link_record_nak(self, msg):
             callback = self._cb_load_all_link_db_done.pop()
             callback()
 
+        # If PLM has ALL-Link group states add PLM to the linkedDevices class
+        # iterator This will trigger the client call back for a new device
+        if self._stateList:
+            self.devices[self._address.id] = self
+
         self._get_device_info()
 
+    def _add_controller(self, group):
+        """Add ALL-Link Group state object to the IM device.
+
+        State object represents controller entries in the PLM ALDB.  This
+        exposes PLM ALL-Link groups as controllable states.
+
+        Parameters:
+        group: ALL-Link group number
+
+        Returns:
+        None
+
+        """
+        if group not in self._stateList:
+            # Only add group state on the first occurance in the ALDB
+            _LOGGER.info('Creating IM state for ALL-Link group 0x%x', group)
+            self._stateList[group] = AllLinkGroup(
+                self._address, "ALL-LinkGroup{}".format(group), group,
+                self._send_msg, self._message_callbacks, 0x00,
+                self.trigger_All_Link_group)
+
     def _get_device_info(self):
         _LOGGER.debug('Starting _get_device_info')
         # Remove saved records for devices found in the ALDB
diff --git a/insteonplm/states/__init__.py b/insteonplm/states/__init__.py
@@ -120,4 +120,8 @@ def _update_subscribers(self, val):
         """Save state value and notify listeners of the change."""
         self._value = val
         for callback in self._observer_callbacks:
+            _LOGGER.debug('_update_subscribers state %s:0x%x updating '
+                          'subscribers with level 0x%x', self.address.human,
+                          self.group, val)
+
             callback(self._address, self._group, val)
diff --git a/insteonplm/states/allLinkGroup.py b/insteonplm/states/allLinkGroup.py
@@ -0,0 +1,163 @@
+"""Dimmable light states."""
+import logging
+
+from insteonplm.constants import (
+    COMMAND_LIGHT_ON_0X11_NONE,
+    COMMAND_LIGHT_ON_FAST_0X12_NONE,
+    COMMAND_LIGHT_OFF_0X13_0X00,
+    COMMAND_LIGHT_OFF_FAST_0X14_0X00,
+    COMMAND_LIGHT_BRIGHTEN_ONE_STEP_0X15_0X00,
+    COMMAND_LIGHT_DIM_ONE_STEP_0X16_0X00,
+    COMMAND_LIGHT_START_MANUAL_CHANGEDOWN_0X17_0X00,
+    COMMAND_LIGHT_START_MANUAL_CHANGEUP_0X17_0X01,
+    COMMAND_LIGHT_STOP_MANUAL_CHANGE_0X18_0X00,
+    COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00,
+    COMMAND_LIGHT_INSTANT_CHANGE_0X21_NONE,
+    MESSAGE_TYPE_ALL_LINK_CLEANUP)
+from insteonplm.messages.standardSend import StandardSend
+from insteonplm.messages.standardReceive import StandardReceive
+from insteonplm.messages.messageFlags import MessageFlags
+from insteonplm.states import State
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class AllLinkGroup(State):
+    """Device state representing an IM ALL-Link Group.
+
+    Available methods are:
+    on()
+    off()
+    brighten()
+    dim()
+    """
+
+    def __init__(self, address, statename, group, send_message_method,
+                 message_callbacks, defaultvalue, ALL_Link_cleanup_method):
+        """Init the State Class."""
+        super().__init__(address, statename, group, send_message_method,
+                         message_callbacks, defaultvalue)
+
+        self._updatemethod = None
+        self._ALL_Link_cleanup_method = ALL_Link_cleanup_method
+        self._register_messages()
+
+    # pylint: disable=too-many-locals
+    def _register_messages(self):
+        _LOGGER.debug('Registering callbacks for allLinkGroup PLM: %s '
+                      'Group: 0x%x', self._address.human, self._group)
+        template_on_cleanup = StandardReceive.template(
+            commandtuple=COMMAND_LIGHT_ON_0X11_NONE,
+            address=self._address,
+            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
+            cmd2=self._group)
+        template_on_fast_cleanup = StandardReceive.template(
+            commandtuple=COMMAND_LIGHT_ON_FAST_0X12_NONE,
+            address=self._address,
+            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
+            cmd2=self._group)
+        template_off_cleanup = StandardReceive.template(
+            commandtuple=COMMAND_LIGHT_OFF_0X13_0X00,
+            address=self._address,
+            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
+            cmd2=self._group)
+        template_off_fast_cleanup = StandardReceive.template(
+            commandtuple=COMMAND_LIGHT_OFF_FAST_0X14_0X00,
+            address=self._address,
+            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
+            cmd2=self._group)
+        template_brighten_cleanup = StandardReceive.template(
+            commandtuple=COMMAND_LIGHT_BRIGHTEN_ONE_STEP_0X15_0X00,
+            address=self._address,
+            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
+            cmd2=self._group)
+        template_dim_cleanup = StandardReceive.template(
+            commandtuple=COMMAND_LIGHT_DIM_ONE_STEP_0X16_0X00,
+            address=self._address,
+            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
+            cmd2=self._group)
+        template_manual_start_down_cleanup = StandardReceive.template(
+            commandtuple=COMMAND_LIGHT_START_MANUAL_CHANGEDOWN_0X17_0X00,
+            address=self._address,
+            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
+            cmd2=self._group)
+        template_manual_start_up_cleanup = StandardReceive.template(
+            commandtuple=COMMAND_LIGHT_START_MANUAL_CHANGEUP_0X17_0X01,
+            address=self._address,
+            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
+            cmd2=self._group)
+        template_manual_cleanup = StandardReceive.template(
+            commandtuple=COMMAND_LIGHT_STOP_MANUAL_CHANGE_0X18_0X00,
+            address=self._address,
+            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
+            cmd2=self._group)
+        template_instant_cleanup = StandardReceive.template(
+            commandtuple=COMMAND_LIGHT_INSTANT_CHANGE_0X21_NONE,
+            address=self._address,
+            flags=MessageFlags.template(MESSAGE_TYPE_ALL_LINK_CLEANUP, None),
+            cmd2=self._group)
+
+        self._message_callbacks.add(template_on_cleanup,
+                                    self._on_message_received)
+        self._message_callbacks.add(template_on_fast_cleanup,
+                                    self._on_message_received)
+        self._message_callbacks.add(template_off_cleanup,
+                                    self._manual_change_received)
+        self._message_callbacks.add(template_off_fast_cleanup,
+                                    self._manual_change_received)
+        self._message_callbacks.add(template_brighten_cleanup,
+                                    self._manual_change_received)
+        self._message_callbacks.add(template_dim_cleanup,
+                                    self._manual_change_received)
+        self._message_callbacks.add(template_manual_start_down_cleanup,
+                                    self._manual_change_received)
+        self._message_callbacks.add(template_manual_start_up_cleanup,
+                                    self._manual_change_received)
+        self._message_callbacks.add(template_manual_cleanup,
+                                    self._manual_change_received)
+        self._message_callbacks.add(template_instant_cleanup,
+                                    self._manual_change_received)
+
+    def on(self):
+        """Braodcast All-Link Recall for this state's group."""
+        self._ALL_Link_cleanup_method(self.group, COMMAND_LIGHT_ON_0X11_NONE)
+        self._update_subscribers(0xff)
+
+    def off(self):
+        """Braodcast All-Link off for this state's group."""
+        self._ALL_Link_cleanup_method(self.group, COMMAND_LIGHT_OFF_0X13_0X00)
+        self._update_subscribers(0x00)
+
+    def brighten(self):
+        """Braodcast All-Link Brighten for this state's group."""
+        self._ALL_Link_cleanup_method(
+            self.group,
+            COMMAND_LIGHT_BRIGHTEN_ONE_STEP_0X15_0X00)
+
+    def dim(self):
+        """Braodcast All-Link Dim for this state's group."""
+        self._ALL_Link_cleanup_method(self.group,
+                                      COMMAND_LIGHT_DIM_ONE_STEP_0X16_0X00)
+
+    def _on_message_received(self, msg):
+        cmd2 = msg.cmd2 if msg.cmd2 else 255
+        self._update_subscribers(cmd2)
+
+    # pylint: disable=unused-argument
+    def _off_message_received(self, msg):
+        self._update_subscribers(0x00)
+
+    # pylint: disable=unused-argument
+    def _manual_change_received(self, msg):
+        self._send_status_request()
+
+    def _send_status_request(self):
+        """Send a status request message to the device."""
+        status_command = StandardSend(self._address,
+                                      COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00)
+        self._send_method(status_command,
+                          self._status_message_received)
+
+    def _status_message_received(self, msg):
+        _LOGGER.debug("DimmableSwitch status message received called")
+        self._update_subscribers(msg.cmd2)
diff --git a/insteonplm/states/dimmable.py b/insteonplm/states/dimmable.py
diff --git a/insteonplm/states/onOff.py b/insteonplm/states/onOff.py
