pylon 485 implementation inprogress

Author: HotNoob

classes/Object.py

@@ -0,0 +1,3 @@
+#hack to allow generic objects
+class Object(object):
+    pass

classes/protocol_settings.py

@@ -199,7 +199,7 @@ def __init__(self, protocol : str, settings_dir : str = 'protocols'):
         for registry_type in Registry_Type:
             self.load_registry_map(registry_type)
 
-    def get_registry_map(self, registry_type : Registry_Type) -> list[registry_map_entry]:
+    def get_registry_map(self, registry_type : Registry_Type = Registry_Type.ZERO) -> list[registry_map_entry]:
         return self.registry_map[registry_type]
 
     def get_registry_ranges(self, registry_type : Registry_Type) -> list[registry_map_entry]:
@@ -394,6 +394,9 @@ def determine_delimiter(first_row) -> str:
                 else:
                     range_match = range_regex.search(row['register'])
                     if not range_match:
+                        if row['register'][0] == 'x':
+                            register = int.from_bytes(bytes.fromhex(row['register'][1:]), byteorder='big')
+                            
                         register = int(row['register'])
                     else:
                         reverse = range_match.group('reverse')

classes/transports/serial_frame_client.py

@@ -1,3 +1,4 @@
+from typing import Callable
 import serial
 import threading
 import time
@@ -6,7 +7,7 @@
 class serial_frame_client():
     ''' basic serial client implenting a empty SOI/EOI frame'''
     client : serial.Serial
-    running : bool
+    running : bool = False
     soi : bytes
     '''start of information'''
     eoi : bytes
@@ -15,22 +16,109 @@ class serial_frame_client():
 
     max_frame_size : int = 256
 
+    port : str = '/dev/ttyUSB0'
+    baud :  int = 9600
 
-    def __init__(self) -> None:
-        self.client = serial.Serial('/dev/ttyUSB0', 9600)
-        pass
+    timeout : float = 30
+    ''' timeout in seconds '''
 
-    def checksum(self, data : bytes) -> bytes:
-        return b''
+    #region asyncronous
+    asynchronous : bool = False
+    ''' if set, runs main loop'''
+
+    on_message : Callable[[bytes], None] = None
+    ''' async mode only'''
+
+    thread : threading.Thread
+    ''' main thread for read loop'''
+
+    callback_lock : threading.Lock = threading.Lock()
+    '''lock for callback'''
+    #endregion asyncronous
+
+
+    def __init__(self, port : str , baud : int , soi : bytes, eoi : bytes) -> None:
+        self.port = port
+        self.baud = baud
+        self.client = serial.Serial(port, baud)
+
+    def connect(self):
+        if self.asynchronous:
+            self.running = True
+            self.pending_frames = []
+            self.thread = threading.Thread(target=self.read_thread)
+            self.thread.daemon = True
+            self.thread.start()
+        return True
 
     def write(self, data : bytes):
         ''' write data, excluding SOI and EOI bytes'''
         data = self.soi + data + self.eoi
         self.client.write()
 
-    def read(self):
+    def read(self, reset_buffer = True, frames = 1) -> list[bytes] | bytes:
+        ''' returns list of frames, if frames > 1 '''
         buffer = bytearray()
+        self.pending_frames.clear()
+
+        #for shatty order sensitive protocols. 
+        # Clear input buffers
+        if reset_buffer:
+            self.client.reset_input_buffer()
+        
+        timedout = time.time() + self.timeout
+        frameCount = 0
+
+        while time.time() < timedout:
+            # Read data from serial port
+            data = self.client.read()
+
+            # Check if data is available
+            if data:
+                # Append data to buffer
+                buffer += data
+
+                # Find SOI index in buffer
+                soi_index = buffer.find(self.soi)
+
+                # Process all occurrences of SOI in buffer
+                while soi_index != -1:
+                    # Remove data before SOI sequence
+                    buffer = buffer[soi_index:]
+
+                    # Find EOI index in buffer
+                    eoi_index = buffer.find(self.eoi)
+
+                    if eoi_index != -1:
+                        
+                        frame = buffer[len(self.soi):eoi_index]
+                        if frames == 1:
+                            return frame
+                        
+                        if frameCount > 1:
+                            # Extract and store the complete frame
+                            self.pending_frames.append(frame)
+
+                            if self.pending_frames.count() == frames:
+                                return self.pending_frames
+
+                        # Remove the processed data from the buffer
+                        buffer = buffer[eoi_index + len(self.eoi) : ]
+
+                        # Find next SOI index in the remaining buffer
+                        soi_index = buffer.find(self.soi)
+                        
+                    else:
+                        # If no EOI is found and buffer size exceeds max_frame_size, clear buffer
+                        if len(buffer) > self.max_frame_size:
+                            buffer.clear()
+                        break #no eoi, continue waiting
+
+            time.sleep(0.01)
 
+    def read_thread(self):
+        buffer = bytearray()
+        self.running = True
         while self.running:
             # Read data from serial port
             data = self.client.read()
@@ -66,6 +154,12 @@ def read(self):
                             buffer.clear()
                         break #no eoi, continue waiting
 
+                #can probably be in the loop, but being cautious
+                for frame in self.pending_frames:
+                    with self.callback_lock:
+                        if self.on_message:
+                            self.on_message(frame)
+
             time.sleep(0.01)
 
 

classes/transports/serial_pylon.py

@@ -1,11 +1,37 @@
+from enum import Enum
+import struct
+
+from ..Object import Object
+
 from .serial_frame_client import serial_frame_client
 from .transport_base import transport_base
 
 
+
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from configparser import SectionProxy
-    from classes.protocol_settings import protocol_settings
+    from classes.protocol_settings import protocol_settings, registry_map_entry
+
+
+class return_codes(Enum):
+    NORMAL                  = 0x00
+    VERSION_ERROR           = 0x01
+    CHECKSUM_ERROR          = 0x02
+    LCHECKSUM_ERROR         = 0x03
+    INVALID_CID2            = 0x04
+    COMMAND_FORMAT_ERROR    = 0X05
+    INVALID_DATA            = 0X06
+    ADDRESS_ERROR           = 0X90
+    COMMUNICATION_ERROR     = 0X91
+    UNKNOWN_ERROR           = -1
+
+    @classmethod
+    def fromByte(cls, value : bytes):
+        try:
+            return cls(value)  # Attempt to access the Enum member
+        except ValueError:
+            return return_codes.UNKNOWN_ERROR
 
 class serial_pylon(transport_base):
     ''' for a lack of a better name'''
@@ -17,13 +43,14 @@ class serial_pylon(transport_base):
     client : serial_frame_client
 
     #this format is pretty common; i need a name for it.
-    SOI : bytes = b'\x7e'
-    VER : bytes = b'\x00'
+    SOI : bytes = b'\x7e' # aka b"~"
+    VER : bytes = b'\x00' # aka b"\r"
     ''' version has to be fetched first '''
     ADR : bytes
     CID1 : bytes
     CID2 : bytes
     LENGTH : bytes
+    ''' 2 bytes - include LENID & LCHKSUM'''
     INFO : bytes
     CHKSUM : bytes
     EOI : bytes = b'\x0d'
@@ -39,12 +66,107 @@ def __init__(self, settings : 'SectionProxy', protocolSettings : 'protocol_setti
 
         address : int = settings.getint("address", 0)
         self.addresses = [address]
+
+        self.ADR = struct.pack('B', address)
+        #todo, multi address support later
+
+        self.client = serial_frame_client(self.port, self.baudrate, self.SOI, self.EOI)
+
         pass
 
     def connect(self):
+        self.client.connect()
         #3.1 Get protocol version
         if self.VER == b'\x00':
             #get VER for communicating
             #SOI VER ADR 46H 4FH LENGT INFO CHKSUM EOI
+            version = self.read_variable('version')
+            if version:
+                self.VER = version
+            pass
+
+    def read_variable(self, variable_name : str, entry : 'registry_map_entry' = None):
+        ##clean for convinecne  
+        if variable_name:
+            variable_name = variable_name.strip().lower().replace(' ', '_')
+
+        registry_map = self.protocolSettings.get_registry_map()
+
+        if entry == None:
+            for e in registry_map:
+                if e.variable_name == variable_name:
+                    entry = e
+                    break
 
-    
+
+        if entry:
+            #entry.concatenate this protocol probably doesnt require concatenate, since info is variable length.
+            command = entry.register #CID1 and CID2 combined creates a single ushort
+            self.send_command(command)  
+            return self.decode_frame(self.client.read())
+
+        return None
+    
+    def checksum(self, frame: bytes):
+        assert isinstance(frame, bytes)
+
+        sum = 0
+        for byte in frame:
+            sum += byte
+        sum = ~sum
+        sum %= 0x10000
+        sum += 1
+        return sum
+
+
+    def decode_frame(self, raw_frame: bytes) -> bytes:
+        frame_data = raw_frame[0:len(raw_frame) - 5]
+        frame_chksum = raw_frame[len(raw_frame) - 5:-1]
+
+        got_frame_checksum = self.checksum(frame_data)
+        assert got_frame_checksum == int(frame_chksum, 16)
+
+        data = Object()
+        data.ver = frame_data[0:2]
+        data.adr = frame_data[2:4]
+        data.cid1 = frame_data[4:6]
+        data.cid2 = frame_data[6:8]
+        data.infolength = frame_data[8:12]
+        data.info = frame_data[12:]
+
+        #on return, cid2 holds a return error code. so reads are time sensitive. will have to write syncronis functions in client
+        #fromByte
+        returnCode = return_codes.fromByte(data.cid2)
+        if returnCode != return_codes.NORMAL:
+            self._log.warning(f"Serial Pylon Error code {returnCode}")
+
+        #todo, process info
+        return data.info
+
+    
+    def build_frame(self, command : int, info: bytes = b''):
+        ''' builds frame without soi and eoi; that is left for frame client'''
+
+        info_length = 0
+
+        lenid = len(info)
+        if lenid != 0:
+            lenid_sum = (lenid & 0xf) + ((lenid >> 4) & 0xf) + ((lenid >> 8) & 0xf)
+            lenid_modulo = lenid_sum % 16
+            lenid_invert_plus_one = 0b1111 - lenid_modulo + 1
+
+            info_length = (lenid_invert_plus_one << 12) + lenid
+
+        self.LENGTH = struct.pack('<H', info_length)
+
+        frame : bytes = self.VER + self.ADR +struct.pack('<H', command) + self.LENGTH + info
+
+        frame_chksum = self.checksum(frame)
+        frame = frame + struct.pack('<H', frame_chksum) 
+        
+        
+    def send_command(self, cmd, info: bytes = b''):
+        data = self.build_frame(cmd, info)
+        self.client.write(data)
+
+        

protocols/pylon_rs485_v2.8.registry_map.csv

@@ -1,2 +1,2 @@
 variable name,data type,register,documented name,description,writable,values,unit,note
-,,0,version,protocol version,,0~255,,
+,BYTE,x464F,version,protocol version,,0~255,,