debug and finish canbus ( working now )

Author: HotNoob

classes/protocol_settings.py

@@ -233,6 +233,8 @@ class protocol_settings:
     settings : dict[str, str]
     ''' default settings provided by protocol json '''
 
+    byteorder : str = "big"
+
     def __init__(self, protocol : str, settings_dir : str = 'protocols'):
         self.protocol = protocol
         self.settings_dir = settings_dir
@@ -266,6 +268,9 @@ def __init__(self, protocol : str, settings_dir : str = 'protocols'):
         else:
             self.transport = "modbus_rtu"
 
+        if "byteorder" in self.settings: #handle byte order for ints n stuff
+            self.byteorder = self.settings["byteorder"]
+
 
         for registry_type in Registry_Type:
             self.load_registry_map(registry_type)
@@ -321,13 +326,13 @@ def load__json(self, file : str = '', settings_dir : str = ''):
 
     def load__registry(self, path, registry_type : Registry_Type = Registry_Type.INPUT) -> list[registry_map_entry]: 
         registry_map : list[registry_map_entry] = []
-        register_regex = re.compile(r'(?P<register>(?:0?x[\dA-Z]+|[\d]+))\.(b(?P<bit>x?\d{1,2})|(?P<byte>x?\d{1,2}))')
+        register_regex = re.compile(r'(?P<register>(?:0?x[\da-z]+|[\d]+))\.(b(?P<bit>x?\d{1,2})|(?P<byte>x?\d{1,2}))')
 
         data_type_regex = re.compile(r'(?P<datatype>\w+)\.(?P<length>\d+)')
 
-        range_regex = re.compile(r'(?P<reverse>r|)(?P<start>(?:0?x[\dA-Z]+|[\d]+))[\-~](?P<end>(?:0?x[\dA-Z]+|[\d]+))')
+        range_regex = re.compile(r'(?P<reverse>r|)(?P<start>(?:0?x[\da-z]+|[\d]+))[\-~](?P<end>(?:0?x[\da-z]+|[\d]+))')
         ascii_value_regex = re.compile(r'(?P<regex>^\[.+\]$)')
-        list_regex = re.compile(r'\s*(?:(?P<range_start>(?:0?x[\dA-Z]+|[\d]+))-(?P<range_end>(?:0?x[\dA-Z]+|[\d]+))|(?P<element>[^,\s][^,]*?))\s*(?:,|$)')
+        list_regex = re.compile(r'\s*(?:(?P<range_start>(?:0?x[\da-z]+|[\d]+))-(?P<range_end>(?:0?x[\da-z]+|[\d]+))|(?P<element>[^,\s][^,]*?))\s*(?:,|$)')
 
 
         if not os.path.exists(path): #return empty is file doesnt exist.
@@ -471,6 +476,7 @@ def determine_delimiter(first_row) -> str:
                 register : int = -1
                 register_bit : int = 0
                 register_byte : int = -1
+                row['register'] = row['register'].lower() #ensure is all lower case
                 match = register_regex.search(row['register'])
                 if match:
                     register = strtoint(match.group('register'))
@@ -685,13 +691,13 @@ def process_register_bytes(self, registry : dict[int,bytes], entry : registry_ma
             register = register[:entry.data_type_size]
 
         if entry.data_type == Data_Type.UINT:
-            value = int.from_bytes(register[:4], byteorder='big', signed=False)
+            value = int.from_bytes(register[:4], byteorder=self.byteorder, signed=False)
         elif entry.data_type == Data_Type.INT:
-            value = int.from_bytes(register[:4], byteorder='big', signed=True)
+            value = int.from_bytes(register[:4], byteorder=self.byteorder, signed=True)
         elif entry.data_type == Data_Type.USHORT:
-            value = int.from_bytes(register[:2], byteorder='big', signed=False)
+            value = int.from_bytes(register[:2], byteorder=self.byteorder, signed=False)
         elif entry.data_type == Data_Type.SHORT:
-            value = int.from_bytes(register[:2], byteorder='big', signed=True)
+            value = int.from_bytes(register[:2], byteorder=self.byteorder, signed=True)
         elif entry.data_type == Data_Type._16BIT_FLAGS or entry.data_type == Data_Type._8BIT_FLAGS or entry.data_type == Data_Type._32BIT_FLAGS:
             #16 bit flags
             start_bit : int = 0
@@ -704,7 +710,7 @@ def process_register_bytes(self, registry : dict[int,bytes], entry : registry_ma
             #handle custom sizes, less than 1 register
             end_bit = flag_size + start_bit
 
-            if entry.documented_name+'_codes' in self.protocolSettings.codes:
+            if entry.documented_name+'_codes' in self.codes:
                 flags : list[str] = []
                 for i in range(start_bit, end_bit):  # Iterate over each bit position (0 to 15)
                     byte = i // 8 
@@ -713,8 +719,8 @@ def process_register_bytes(self, registry : dict[int,bytes], entry : registry_ma
                     # Check if the i-th bit is set
                     if (val >> bit) & 1:
                         flag_index = "b"+str(i)
-                        if flag_index in self.protocolSettings.codes[entry.documented_name+'_codes']:
-                            flags.append(self.protocolSettings.codes[entry.documented_name+'_codes'][flag_index])
+                        if flag_index in self.codes[entry.documented_name+'_codes']:
+                            flags.append(self.codes[entry.documented_name+'_codes'][flag_index])
 
                 value = ",".join(flags)
             else:
@@ -766,6 +772,22 @@ def process_register_bytes(self, registry : dict[int,bytes], entry : registry_ma
             except UnicodeDecodeError as e:
                 print("UnicodeDecodeError:", e)
 
+        #apply unit mod
+        if entry.unit_mod != float(1):
+            value = value * entry.unit_mod
+
+        #apply codes
+        if (entry.data_type != Data_Type._16BIT_FLAGS and
+            entry.documented_name+'_codes' in self.codes):
+            try:
+                cleanval = str(int(value))
+        
+                if cleanval in self.codes[entry.documented_name+'_codes']:
+                    value = self.codes[entry.documented_name+'_codes'][cleanval]
+            except:
+                #do nothing; try is for intval
+                value = value
+
         return value
 
 
@@ -859,7 +881,7 @@ def process_register_ushort(self, registry : dict[int, int], entry : registry_ma
                 bit_index = entry.register_bit
                 value = (registry[entry.register] >> bit_index) & bit_mask
         elif entry.data_type == Data_Type.ASCII:
-            value = registry[entry.register].to_bytes((16 + 7) // 8, byteorder='big') #convert to ushort to bytes
+            value = registry[entry.register].to_bytes((16 + 7) // 8, byteorder=self.byteorder) #convert to ushort to bytes
             try:
                 value = value.decode("utf-8") #convert bytes to ascii
             except UnicodeDecodeError as e:

classes/transports/canbus.py

@@ -2,6 +2,8 @@
 import time
 import can
 import asyncio
+import threading
+
 
 
 from .transport_base import transport_base
@@ -27,7 +29,13 @@ class canbus(transport_base):
     bus : can.BusABC = None
     ''' holds canbus interface'''
 
-    lock : asyncio.Lock = asyncio.Lock()
+    reader = can.AsyncBufferedReader()
+
+
+    thread : threading.Thread
+    ''' main thread for async loop'''
+
+    lock : threading.Lock = threading.Lock()
     loop : asyncio.AbstractEventLoop = None
 
     cache : dict [int,(bytes, float)] = {}
@@ -53,23 +61,38 @@ def __init__(self, settings : 'SectionProxy', protocolSettings : 'protocol_setti
         self.cacheTimeout = settings.getint(["cacheTimeout", "cache_timeout"], self.cacheTimeout)
 
         self.bus = can.interface.Bus(interface=self.interface, channel=self.port, bitrate=self.baudrate)
+        self.reader = can.AsyncBufferedReader()
+
 
         # Set up an event loop and run the async function
         self.loop = asyncio.get_event_loop()
-        self.loop.run_until_complete(self.read_bus(self.bus))
+
+        notifier = can.Notifier(self.bus, [self.reader], loop=self.loop)
+
+
+        thread = threading.Thread(target=self.start_loop)
+        thread.start()
+
+        self.connected = True
 
         self.init_after_connect()
-        
+    
+    def start_loop(self):
+        self.loop.run_until_complete(self.read_bus(self.bus))
 
     async def read_bus(self, bus : can.BusABC):
         ''' read canbus asynco and store results in cache'''
         while True:
-            msg : can.Message = await bus.recv()  # This will be non-blocking with asyncio
+            msg = await self.reader.get_message()  # This will be non-blocking with asyncio
             if msg:
                 print(f"Received message: {msg.arbitration_id:X}, data: {msg.data}")
 
-                async with self.lock:
-                    self.cache[msg.arbitration_id] = (msg.data, time.time())
+                with self.lock: 
+                    #convert bytearray to bytes; were working with bytes. 
+                    self.cache[msg.arbitration_id] = (bytes(msg.data), time.time())
+                
+            await asyncio.sleep(0.5)
+
 
     def clean_cache(self):
         current_time = time.time()
@@ -78,9 +101,9 @@ def clean_cache(self):
             # Create a list of keys to remove (don't remove while iterating)
             keys_to_delete = [msg_id for msg_id, (_, timestamp) in self.cache.items() if current_time - timestamp > self.cacheTimeout]
 
-        # Remove old messages from the dictionary
-        for key in keys_to_delete:
-            del self.cache[key]
+            # Remove old messages from the dictionary
+            for key in keys_to_delete:
+                del self.cache[key]
 
     def init_after_connect(self):
         return True
@@ -142,22 +165,20 @@ def write_data(self, data : dict[str, str]) -> None:
     def read_data(self) -> dict[str, str]:
         ''' because canbus is passive / broadcast, were just going to read from the cache '''
 
-        self.clean_cache() #clean cache of old data
-
         info = {}
-        #modbus - only read input/holding registries
-        for registry_type in (Registry_Type.ZERO):
 
-            #remove timestamp for processing
-            registry = {key: value[0] for key, value in self.cache.items()}
+        #remove timestamp for processing
+        registry = {key: value[0] for key, value in self.cache.items()}
 
-            new_info = self.protocolSettings.process_registery(registry, self.protocolSettings.get_registry_map(registry_type))
+        new_info = self.protocolSettings.process_registery(registry, self.protocolSettings.get_registry_map(Registry_Type.ZERO))
 
-            info.update(new_info) 
+        info.update(new_info) 
 
         if not info:
             self._log.info("Register/Cache is Empty; no new information reported.")
 
+        self.clean_cache() #clean cache of old data
+
         return info
 
     def read_variable(self, variable_name : str, registry_type : Registry_Type, entry : registry_map_entry = None):

classes/transports/transport_base.py

@@ -79,7 +79,7 @@ def _get_top_class_name(cls, cls_obj):
         else:
             return cls._get_top_class_name(cls_obj.__bases__[0])
 
-    def connect(self, transports : 'transport_base'):
+    def connect(self):
         pass
 
     def write_data(self, data : dict[str, registry_map_entry]):

defs/common.py

@@ -19,12 +19,24 @@ def strtoint(val : str) -> int:
 
     if isinstance(val, int): #is already int. 
         return val
+    
+    val = val.lower()
 
     if val and val[0] == 'x':
-        return int.from_bytes(bytes.fromhex(val[1:]), byteorder='big')
+        val = val[1:]
+        # Pad the string with a leading zero
+        if len(val) % 2 != 0:
+            val = '0' + val
+
+        return int.from_bytes(bytes.fromhex(val), byteorder='big')
 
     if val and val.startswith("0x"):
-        return int.from_bytes(bytes.fromhex(val[2:]), byteorder='big')
+        val = val[2:]
+        # Pad the string with a leading zero
+        if len(val) % 2 != 0:
+            val = '0' + val
+
+        return int.from_bytes(bytes.fromhex(val), byteorder='big')
 
     if not val: #empty
         return 0

protocols/sma/sma_sunny_island_v1.json

@@ -1,4 +1,5 @@
 {
     "transport" : "canbus",
-    "baud" : 500000
+    "baud" : 500000,
+    "byteorder" : "little"
 }