Allow switches with persistent_conn and add mutex to guard polling

custom_components/bluetti_bt/__init__.py

@@ -28,11 +28,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     polling_interval = entry.data.get(CONF_POLLING_INTERVAL, 20)
     persistent_conn = entry.data.get(CONF_PERSISTENT_CONN, False)
 
-    # Prevent persistant connection and controls at same time
-    if use_controls is True and persistent_conn is True:
-        _LOGGER.warning("Enabling controls and persistant connection at the same time is currently not supported. Disabled persistant connection")
-        persistent_conn = False
-
     if address is None:
         return False
 

custom_components/bluetti_bt/coordinator.py

@@ -167,6 +167,9 @@ class PollingCoordinator(DataUpdateCoordinator):
             return None
         self.client = BleakClient(device)
 
+        # polling mutex to guard against switches
+        self.polling_lock = asyncio.Lock()
+
     async def _async_update_data(self):
         """Fetch data from API endpoint.
 
@@ -183,43 +186,22 @@ class PollingCoordinator(DataUpdateCoordinator):
 
         parsed_data: dict = {}
 
-        try:
+        async with self.polling_lock:
-            async with async_timeout.timeout(30):
+            try:
+                async with async_timeout.timeout(30):
 
-                # Reconnect if not connected
+                    # Reconnect if not connected
-                if not self.client.is_connected:
+                    if not self.client.is_connected:
-                    await self.client.connect()
+                        await self.client.connect()
 
-                # Attach notifier if needed
+                    # Attach notifier if needed
-                if not self.has_notifier:
+                    if not self.has_notifier:
-                    await self.client.start_notify(
+                        await self.client.start_notify(
-                        BluetoothClient.NOTIFY_UUID, self._notification_handler
+                            BluetoothClient.NOTIFY_UUID, self._notification_handler
-                    )
-                    self.has_notifier = True
-
-                for command in self.bluetti_device.polling_commands:
-                    try:
-                        body = command.parse_response(
-                            await self.async_send_command(command)
                         )
-                        parsed = self.bluetti_device.parse(
+                        self.has_notifier = True
-                            command.starting_address, body
-                        )
-                        self.logger.debug("Parsed data: %s", parsed)
-                        parsed_data.update(parsed)
 
-                    except ParseError:
+                    for command in self.bluetti_device.polling_commands:
-                        self.logger.warning("Got a parse exception...")
-                
-                # pack polling
-                for pack in range (1, self.bluetti_device.pack_num_max + 1):
-                    # Set current pack number
-                    await self.async_send_command(
-                        self.bluetti_device.build_setter_command('pack_num', pack)
-                        )
-                    
-                    for command in self.bluetti_device.pack_polling_commands:
-                        # Request & parse result for each pack
                         try:
                             body = command.parse_response(
                                 await self.async_send_command(command)
@@ -228,33 +210,55 @@ class PollingCoordinator(DataUpdateCoordinator):
                                 command.starting_address, body
                             )
                             self.logger.debug("Parsed data: %s", parsed)
-
+                            parsed_data.update(parsed)
-                            packNo = parsed.get('pack_num')
-                            if not isinstance(packNo, int) or packNo != pack:
-                                self.logger.debug("Parsed pack_num(%s) does not match expected '%s'", packNo, pack)
-                                continue
-
-                            for key, value in parsed.items():
-                                parsed_data.update({key+str(pack):value})
 
                         except ParseError:
                             self.logger.warning("Got a parse exception...")
                     
-        except TimeoutError:
+                    # pack polling
-            self.logger.debug("Polling timed out for device %s", mac_loggable(self._address))
+                    for pack in range (1, self.bluetti_device.pack_num_max + 1):
-            return None
+                        # Set current pack number
-        except BleakError as err:
+                        await self.async_send_command(
-            self.logger.warning("Bleak error: %s", err)
+                            self.bluetti_device.build_setter_command('pack_num', pack)
-            return None
+                            )
-        finally:
-            # Disconnect if connection not persistant
-            if not self.persistent_conn:
-                await self.client.disconnect()
                         
-        self.hass.data[DOMAIN][self.config_entry.entry_id][DATA_POLLING_RUNNING] = False
+                        for command in self.bluetti_device.pack_polling_commands:
+                            # Request & parse result for each pack
+                            try:
+                                body = command.parse_response(
+                                    await self.async_send_command(command)
+                                )
+                                parsed = self.bluetti_device.parse(
+                                    command.starting_address, body
+                                )
+                                self.logger.debug("Parsed data: %s", parsed)
 
-        # Pass data back to sensors
+                                packNo = parsed.get('pack_num')
-        return parsed_data
+                                if not isinstance(packNo, int) or packNo != pack:
+                                    self.logger.debug("Parsed pack_num(%s) does not match expected '%s'", packNo, pack)
+                                    continue
+
+                                for key, value in parsed.items():
+                                    parsed_data.update({key+str(pack):value})
+
+                            except ParseError:
+                                self.logger.warning("Got a parse exception...")
+                        
+            except TimeoutError:
+                self.logger.debug("Polling timed out for device %s", mac_loggable(self._address))
+                return None
+            except BleakError as err:
+                self.logger.warning("Bleak error: %s", err)
+                return None
+            finally:
+                # Disconnect if connection not persistant
+                if not self.persistent_conn:
+                    await self.client.disconnect()
+
+            self.hass.data[DOMAIN][self.config_entry.entry_id][DATA_POLLING_RUNNING] = False
+
+            # Pass data back to sensors
+            return parsed_data
 
     async def async_send_command(self, command: ReadHoldingRegisters) -> bytes:
         """Send command and return response"""
@@ -265,7 +269,7 @@ class PollingCoordinator(DataUpdateCoordinator):
             self.notify_response = bytearray()
 
             # Make request
-            self.logger.debug("Requesting %s (%s)", command)
+            self.logger.debug("Requesting %s", command)
             await self.client.write_gatt_char(
                 BluetoothClient.WRITE_UUID, bytes(command)
             )

custom_components/bluetti_bt/switch.py

@@ -99,6 +99,9 @@ class BluettiSwitch(CoordinatorEntity, SwitchEntity):
         super().__init__(coordinator)
 
         self._bluetti_device = bluetti_device
+        self._coordinator = coordinator
+        self._client = coordinator.client
+        self._polling_lock = coordinator.polling_lock
         e_name = f"{device_info.get('name')} {name}"
         self._address = address
         self._response_key = response_key
@@ -156,38 +159,32 @@ class BluettiSwitch(CoordinatorEntity, SwitchEntity):
 
     async def write_to_device(self, state: bool):
         """Write to device."""
-        device = bluetooth.async_ble_device_from_address(self.hass, self._address)
-        if device is None:
-            _LOGGER.error("Device %s not available", mac_loggable(self._address))
-            return
-
         command = self._bluetti_device.build_setter_command(self._response_key, state)
 
-        # Wait until polling is done
+        async with self._polling_lock:
-        while self.hass.data[DOMAIN][self._entry_id][DATA_POLLING_RUNNING] is True:
+            try:
-            _LOGGER.debug("Waiting for polling to finish...")
+                async with async_timeout.timeout(15):
-            asyncio.sleep(1)
+                    if not self._client.is_connected:
+                        await self._client.connect()
 
-        client = BleakClient(device)
+                    # Send command
-        try:
+                    _LOGGER.debug("Requesting %s (%s,%s)", command, self._response_key, state)
-            async with async_timeout.timeout(15):
+                    await self._client.write_gatt_char(
-                await client.connect()
+                        BluetoothClient.WRITE_UUID, bytes(command)
+                    )
 
-                # Send command
+                    # Wait until device has changed value, otherwise reading register might reset it
-                await client.write_gatt_char(
+                    await asyncio.sleep(5)
-                    BluetoothClient.WRITE_UUID, bytes(command)
-                )
 
-                # Wait until device has changed value, otherwise reading register might reset it
+            except TimeoutError:
-                await asyncio.sleep(5)
+                _LOGGER.error("Timed out for device %s", mac_loggable(self._address))
-
+                return None
-        except TimeoutError:
+            except BleakError as err:
-            _LOGGER.error("Timed out for device %s", mac_loggable(self._address))
+                _LOGGER.error("Bleak error: %s", err)
-            return None
+                return None
-        except BleakError as err:
+            finally:
-            _LOGGER.error("Bleak error: %s", err)
+                # Disconnect if connection not persistant
-            return None
+                if not self._coordinator.persistent_conn:
-        finally:
+                    await self._client.disconnect()
-            await client.disconnect()
 
         await self.coordinator.async_request_refresh()