Merge pull request #78 from brefra/dynamic_load_timeout

Dynamic load timeout

Author: thomasdelaet

setup.py

@@ -2,7 +2,7 @@
 
 setup(
     name="python-velbus",
-    version="2.1.3",
+    version="2.1.4",
     url="https://github.com/thomasdelaet/python-velbus",
     license="MIT",
     author="Thomas Delaet",

velbus/controller.py

@@ -153,7 +153,7 @@ def module_loaded():
                     self._load_finished = True
                     callback()
 
-            def timeout_expired():
+            def final_timeout_expired():
                 if not self._load_finished:
                     modules_not_loaded = []
                     for module in self._modules:
@@ -170,10 +170,33 @@ def timeout_expired():
                         del self._modules[module]
                     callback()
 
-            # 180 second timeout for loading modules
-            self.load_timeout = threading.Timer(360, timeout_expired).start()
+            def first_retry():
+                if not self._load_finished:
+                    # First load failed, do 2nd retry for failed modules
+                    _missing_modules = 0
+                    for module in self._modules:
+                        if not self._modules[module].loaded:
+                            self.logger.warning(
+                                "Failed to load module "
+                                + str(self._modules[module].get_module_name())
+                                + " at address "
+                                + str(self._modules[module].get_module_address())
+                                + ", retry initiated."
+                            )
+                            # Trigger load without callback
+                            self._modules[module].load(None)
+                            _missing_modules += 1
+                    # Set final timeout
+                    threading.Timer(
+                        (_missing_modules * 10) + 1, final_timeout_expired
+                    ).start()
+
+            # Set first timeout to 10 second for each module to trigger a retry
+            threading.Timer((len(self._modules) * 10) + 1, first_retry).start()
+
             for module in self._modules:
                 self._modules[module].load(module_loaded)
+                time.sleep(1)  # Throttle loading modules
 
         for address in range(0, 256):
             message = ModuleTypeRequestMessage(address)

velbus/module.py

@@ -4,6 +4,7 @@
 import string
 import struct
 from velbus.messages.read_data_from_memory import ReadDataFromMemoryMessage
+from datetime import datetime, timedelta
 from velbus.messages.memory_data import MemoryDataMessage
 from velbus.messages.channel_name_part1 import ChannelNamePart1Message
 from velbus.messages.channel_name_part1 import ChannelNamePart1Message2
@@ -39,7 +40,9 @@ def __init__(self, module_type, module_name, module_address, controller):
 
         self._loaded_callbacks = []
         self.loaded = False
+        self._loading_triggered = False
 
+        self._last_channel_name_msg = datetime.utcnow()
         self._controller = controller
         self._controller.subscribe(self.on_message)
 
@@ -148,18 +151,33 @@ def load(self, callback):
         """
         Retrieve names of channels
         """
-        if not self._is_submodule():
-            # load the data from memory ( the stuff that we need)
-            self._load_memory()
-        # load the module status
-        self._request_module_status()
-        if not self._is_submodule():
-            # load the channel names
-            self._request_channel_name()
-        if callback:
-            self._loaded_callbacks.append(callback)
-        # load the module specific stuff
-        self._load()
+        if not self.loaded:
+            if not self._loading_triggered:
+                self._loading_triggered = True
+                if not self._is_submodule():
+                    # load the data from memory ( the stuff that we need)
+                    self._load_memory()
+                # load the module status
+                self._request_module_status()
+                if not self._is_submodule():
+                    # load the channel names
+                    self._request_channel_name()
+                # load the module specific stuff
+                self._load()
+            else:
+                # Request channel names if last received
+                if (
+                    not self._is_submodule()
+                    and not self._name_messages_complete()
+                    and self._last_channel_name_msg
+                    < datetime.utcnow() - timedelta(seconds=10)
+                ):
+                    self._request_channel_name()
+            if callback:
+                self._loaded_callbacks.append(callback)
+        else:
+            if callback:
+                callback()
 
     def loading_in_progress(self):
         return not self._name_messages_complete()
@@ -185,6 +203,7 @@ def _name_count_needed(self):
         return self.number_of_channels() * 3
 
     def _process_channel_name_message(self, part, message):
+        self._last_channel_name_msg = datetime.utcnow()
         channel = message.channel
         if self._is_submodule():
             channel = channel - (self.number_of_channels() * self.sub_module)