Merge pull request #1 from jaredmauch/parallel_fix

Parallel fixes

Author: jaredmauch

classes/protocol_settings.py

@@ -7,6 +7,7 @@
 import os
 import re
 import time
+import copy
 from dataclasses import dataclass
 from enum import Enum
 from typing import TYPE_CHECKING, Union
@@ -224,6 +225,9 @@ class registry_map_entry:
     write_mode : WriteMode = WriteMode.READ
     ''' enable disable reading/writing '''
 
+    has_enum_mapping : bool = False
+    ''' indicates if this field has enum mappings that should be treated as strings '''
+
     def __str__(self):
         return self.variable_name
 
@@ -698,7 +702,8 @@ def process_row(row):
                                             value_regex=value_regex,
                                             read_command = read_command,
                                             read_interval=read_interval,
-                                            write_mode=writeMode
+                                            write_mode=writeMode,
+                                            has_enum_mapping=value_is_json
                                         )
                 registry_map.append(item)
 
@@ -807,6 +812,11 @@ def calculate_registry_ranges(self, map : list[registry_map_entry], max_register
             except ValueError:
                 pass
 
+        # Debug: log the parameters
+        import logging
+        log = logging.getLogger(__name__)
+        log.debug(f"calculate_registry_ranges: max_register={max_register}, max_batch_size={max_batch_size}, map_size={len(map)}, init={init}")
+
         start = -max_batch_size
         ranges : list[tuple] = []
 
@@ -884,6 +894,7 @@ def load_registry_map(self, registry_type : Registry_Type, file : str = "", sett
                 size = item.register
 
         self.registry_map_size[registry_type] = size
+        self._log.debug(f"load_registry_map: {registry_type.name} - loaded {len(self.registry_map[registry_type])} entries, max_register={size}")
         self.registry_map_ranges[registry_type] = self.calculate_registry_ranges(self.registry_map[registry_type], self.registry_map_size[registry_type], init=True)
 
     def process_register_bytes(self, registry : dict[int,bytes], entry : registry_map_entry):
@@ -1128,7 +1139,8 @@ def process_register_ushort(self, registry : dict[int, int], entry : registry_ma
                 value = registry[entry.register].to_bytes((16 + 7) // 8, byteorder=byte_order) #convert to ushort to bytes
                 value = value.hex() #convert bytes to hex
         elif entry.data_type == Data_Type.ASCII:
-            value = registry[entry.register].to_bytes((16 + 7) // 8, byteorder=byte_order) #convert to ushort to bytes
+            # For ASCII data, use little-endian byte order to read characters in correct order
+            value = registry[entry.register].to_bytes((16 + 7) // 8, byteorder="little") #convert to ushort to bytes
             try:
                 value = value.decode("utf-8") #convert bytes to ascii
             except UnicodeDecodeError as e:
@@ -1313,4 +1325,47 @@ def replace_vars(match):
         for r in results:
             print(evaluate_expression(r))
 
+    def reset_register_timestamps(self):
+        """Reset the next_read_timestamp values for all registry entries"""
+        for registry_type in Registry_Type:
+            if registry_type in self.registry_map:
+                for entry in self.registry_map[registry_type]:
+                    entry.next_read_timestamp = 0
+        self._log.debug(f"Reset timestamps for all registry entries in protocol {self.protocol}")
+
+    def __deepcopy__(self, memo):
+        """Custom deep copy implementation to handle non-copyable attributes"""
+        # Create a new instance
+        new_instance = protocol_settings.__new__(protocol_settings)
+        
+        # Copy basic attributes
+        new_instance.protocol = self.protocol
+        new_instance.settings_dir = self.settings_dir
+        new_instance.transport_settings = self.transport_settings
+        new_instance.byteorder = self.byteorder
+        
+        # Copy dictionaries and lists
+        new_instance.variable_mask = copy.deepcopy(self.variable_mask, memo)
+        new_instance.variable_screen = copy.deepcopy(self.variable_screen, memo)
+        new_instance.codes = copy.deepcopy(self.codes, memo)
+        new_instance.settings = copy.deepcopy(self.settings, memo)
+        
+        # Copy registry maps with deep copy of entries
+        new_instance.registry_map = {}
+        for registry_type, entries in self.registry_map.items():
+            new_instance.registry_map[registry_type] = copy.deepcopy(entries, memo)
+        
+        new_instance.registry_map_size = copy.deepcopy(self.registry_map_size, memo)
+        new_instance.registry_map_ranges = copy.deepcopy(self.registry_map_ranges, memo)
+        
+        # Copy transport
+        new_instance.transport = self.transport
+        
+        # Recreate logger (not copyable)
+        new_instance._log_level = self._log_level
+        new_instance._log = logging.getLogger(__name__)
+        new_instance._log.setLevel(new_instance._log_level)
+        
+        return new_instance
+
 #settings = protocol_settings('v0.14')