Revert "Improve support of two rs485 inputs at once and single output transport"

Author: HotNoob

MULTIPROCESSING.md

@@ -265,7 +265,7 @@ class protocol_settings:
     _log : logging.Logger = None
 
 
-    def __init__(self, protocol : str, transport_settings : "SectionProxy" = None, settings_dir : str = "protocols", unique_id : str = None):
+    def __init__(self, protocol : str, transport_settings : "SectionProxy" = None, settings_dir : str = "protocols"):
 
         #apply log level to logger
         self._log_level = getattr(logging, logging.getLevelName(logging.getLogger().getEffectiveLevel()), logging.INFO)
@@ -275,7 +275,6 @@ def __init__(self, protocol : str, transport_settings : "SectionProxy" = None, s
         self.protocol = protocol
         self.settings_dir = settings_dir
         self.transport_settings = transport_settings
-        self.unique_id = unique_id  # Store unique identifier for this instance
 
         #load variable mask
         self.variable_mask = []

classes/protocol_settings.py

@@ -2,7 +2,6 @@
 from configparser import SectionProxy
 from typing import TextIO
 import time
-import logging
 
 from defs.common import strtobool
 
@@ -22,7 +21,6 @@ class influxdb_out(transport_base):
     include_device_info: bool = True
     batch_size: int = 100
     batch_timeout: float = 10.0
-    force_float: bool = True  # Force all numeric fields to be floats to avoid InfluxDB type conflicts
 
     client = None
     batch_points = []
@@ -39,7 +37,6 @@ def __init__(self, settings: SectionProxy):
         self.include_device_info = strtobool(settings.get("include_device_info", fallback=self.include_device_info))
         self.batch_size = settings.getint("batch_size", fallback=self.batch_size)
         self.batch_timeout = settings.getfloat("batch_timeout", fallback=self.batch_timeout)
-        self.force_float = strtobool(settings.get("force_float", fallback=self.force_float))
 
         self.write_enabled = True  # InfluxDB output is always write-enabled
         super().__init__(settings)
@@ -106,17 +103,14 @@ def write_data(self, data: dict[str, str], from_transport: transport_base):
         for key, value in data.items():
             # Check if we should force float formatting based on protocol settings
             should_force_float = False
-            unit_mod_found = None
 
             # Try to get registry entry from protocol settings to check unit_mod
             if hasattr(from_transport, 'protocolSettings') and from_transport.protocolSettings:
                 # Check both input and holding registries
                 for registry_type in [Registry_Type.INPUT, Registry_Type.HOLDING]:
                     registry_map = from_transport.protocolSettings.get_registry_map(registry_type)
                     for entry in registry_map:
-                        # Match by variable_name (which is lowercase)
-                        if entry.variable_name.lower() == key.lower():
-                            unit_mod_found = entry.unit_mod
+                        if entry.variable_name == key:
                             # If unit_mod is not 1.0, this value should be treated as float
                             if entry.unit_mod != 1.0:
                                 should_force_float = True
@@ -130,28 +124,14 @@ def write_data(self, data: dict[str, str], from_transport: transport_base):
                 # Try to convert to float first
                 float_val = float(value)
 
-                # Always use float for InfluxDB to avoid type conflicts
-                # InfluxDB is strict about field types - once a field is created as integer,
-                # it must always be integer. Using float avoids this issue.
-                if self.force_float:
+                # If it's an integer but should be forced to float, or if it's already a float
+                if should_force_float or not float_val.is_integer():
                     fields[key] = float_val
                 else:
-                    # Only use integer if it's actually an integer and we're not forcing floats
-                    if float_val.is_integer():
-                        fields[key] = int(float_val)
-                    else:
-                        fields[key] = float_val
-                
-                # Log data type conversion for debugging
-                if self._log.isEnabledFor(logging.DEBUG):
-                    original_type = type(value).__name__
-                    final_type = type(fields[key]).__name__
-                    self._log.debug(f"Field {key}: {value} ({original_type}) -> {fields[key]} ({final_type}) [unit_mod: {unit_mod_found}]")
-                
+                    fields[key] = int(float_val)
             except (ValueError, TypeError):
                 # If conversion fails, store as string
                 fields[key] = str(value)
-                self._log.debug(f"Field {key}: {value} -> string (conversion failed)")
 
         # Create InfluxDB point
         point = {

classes/transports/influxdb_out.py

@@ -112,10 +112,7 @@ def __init__(self, settings : "SectionProxy") -> None:
             #must load after settings
             self.protocol_version = settings.get("protocol_version")
             if self.protocol_version:
-                # Create a unique protocol settings instance for each transport to avoid shared state
-                unique_id = f"{self.transport_name}_{self.protocol_version}"
-                self._log.debug(f"Creating protocol settings with unique_id: {unique_id}")
-                self.protocolSettings = protocol_settings(self.protocol_version, transport_settings=settings, unique_id=unique_id)
+                self.protocolSettings = protocol_settings(self.protocol_version, transport_settings=settings)
 
                 if self.protocolSettings:
                     self.protocol_version = self.protocolSettings.protocol