From d072ea6ff5dc120163be3c3124198f7241e2a916 Mon Sep 17 00:00:00 2001
From: Ikubimu <ikerubidemunoz@gmail.com>
Date: Thu, 2 Jan 2025 19:00:52 +0100
Subject: [PATCH 1/5] added class decoder which deserialize packets

---
 src/services/communications/Decoder_Data.py | 144 ++++++++++++++++++++
 1 file changed, 144 insertions(+)
 create mode 100644 src/services/communications/Decoder_Data.py

diff --git a/src/services/communications/Decoder_Data.py b/src/services/communications/Decoder_Data.py
new file mode 100644
index 0000000..8448764
--- /dev/null
+++ b/src/services/communications/Decoder_Data.py
@@ -0,0 +1,144 @@
+import threading
+import struct
+import re
+
+import DatagramSocket
+
+
+class Decoder:
+    def __init__(self, package_data, ds): #package_data its a array that contains string id and string with all measurements
+        self.dict_measurement_types = {} #key string id of each measurament, contains an array from types
+        self.dict_measurement_names = {} #contains array of names of each variable
+        self.dict_measurement_value = {} #contains the value of each measurement
+        self.ds = ds #datagramsocket
+        
+        for data in package_data:
+            id = data[0]
+            measurements = data[1].split(',')
+            arr_measuremets = []
+            arr_names = []
+            for measure in measurements:
+                pair = measure.split(':')
+                arr_names.append(pair[0])
+                arr_measuremets.append(pair[1])
+                self.dict_measurement_value[pair[0]] = None
+
+            self.dict_measurement_types[id] = arr_measuremets
+            self.dict_measurement_names[id] = arr_names
+
+        self.recv_packet_thread = threading.Thread(target=self._recv_packet, daemon=True)
+        self.recv_packet_running = False
+    
+    def start(self):
+        self.recv_packet_running = True
+        self.recv_packet_thread.start()
+
+    def _recv_packet(self):
+        buff = bytearray()
+        id_packet = 0
+        bytes_count = 0
+        bytes_size = 0
+        wait_new_packet = True
+
+        while self.recv_packet_running:
+            raw_data = self.ds.get_packet() #get_packet must to be blocking
+            if wait_new_packet:
+                id_packet = struct.unpack('<H',raw_data[:2])[0]
+                buff += raw_data[2:]
+                
+                bytes_size = self.calculate_byte_size(self.dict_measurement_types[id_packet])
+                bytes_count += len(raw_data) - 2
+                wait_new_packet = False
+            else:
+                buff += raw_data
+                bytes_count += len(raw_data)
+
+            if bytes_count < bytes_size:
+                continue
+            else:
+                if bytes_count == bytes_size:
+                    self.deserialize(buff, id_packet)
+
+                buff.clear()
+                bytes_count = 0
+                bytes_size = 0
+                wait_new_packet = True  
+
+
+            
+                
+    def deserialize(self, buffer, id_packet):
+
+        for type, name in zip(self.dict_measurement_types[id_packet], self.dict_measurement_names[id_packet]):
+            data = None
+            match type:
+                case "bool":
+                    data = struct.unpack('<B', buffer[:1])
+                    buffer = buffer[1:]
+                case "uint8":
+                    data = struct.unpack('<B', buffer[:1])
+                    buffer = buffer[1:]
+                case "int8":
+                    data = struct.unpack('<b', buffer[:1])
+                    buffer = buffer[1:]
+                case "uint16":
+                    data = struct.unpack('<H', buffer[:2])
+                    buffer = buffer[2:]
+                case "int16":
+                    data = struct.unpack('<h', buffer[:2])
+                    buffer = buffer[2:]
+                case "uint32":
+                    data = struct.unpack('<I', buffer[:4])
+                    buffer = buffer[2:]
+                case "int32":
+                    data = struct.unpack('<i', buffer[:4])
+                    buffer = buffer[4:]
+                case "float32":
+                    data = struct.unpack('<f', buffer[:4])
+                    buffer = buffer[4:]
+                case "uint64":
+                    data = struct.unpack('<Q', buffer[:8])
+                    buffer = buffer[8:]
+                case "int64":
+                    data = struct.unpack('<q', buffer[:8])
+                    buffer = buffer[8:]
+                case "float64":
+                    data = struct.unpack('<d', buffer[:8])
+                    buffer = buffer[8:]
+                case _:
+                    if 'enum' in type:
+                        value_data = struct.unpack('<B', buffer[:1])
+                        buffer = buffer[1:]
+                        valores = re.search(r'\((.*?)\)', type).split(',')
+                        data = valores[value_data]
+                        
+                    else:
+                        raise ValueError(f"Unsupported data type: {type}")
+            
+            self.dict_measurement_value[name] = data
+            
+
+    def calculate_byte_size(self, measurements):
+
+        size = 0
+        for measure in measurements:
+            if measure == 'uint8' or measure == 'int8' or measure == 'bool' or 'enum' in measure:
+                size += 1
+            elif measure == 'uint16' or measure == 'int16':
+                size += 2
+            elif measure == 'uint32' or measure == 'int32' or measure == 'float32':
+                size += 4
+            elif measure == 'uint64' or measure == 'int64' or measure == 'float64':
+                size += 8
+              
+        return size
+    
+    def __getitem__(self, key):
+        return self.dict_measurement_value[key]
+
+    def stop(self):
+        self.recv_packet_running = False
+        self.recv_packet_thread.join()
+
+    def __del__(self):
+        self.stop()

From 99774d23edd52163669dcdcd20c3a113272dccf9 Mon Sep 17 00:00:00 2001
From: Ikubimu <ikerubidemunoz@gmail.com>
Date: Thu, 2 Jan 2025 22:23:56 +0100
Subject: [PATCH 2/5] change DatagramSocket thread, now get_data is blocking

---
 src/services/communications/DatagramSocket.py | 35 +++++++------------
 src/services/communications/Decoder_Data.py   |  2 ++
 2 files changed, 15 insertions(+), 22 deletions(-)

diff --git a/src/services/communications/DatagramSocket.py b/src/services/communications/DatagramSocket.py
index 054e808..90f2ec7 100644
--- a/src/services/communications/DatagramSocket.py
+++ b/src/services/communications/DatagramSocket.py
@@ -18,25 +18,7 @@ def __init__(self, lip, lport, rip, rport):
         self._sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
         self._sock.bind((self.local_ip,self.local_port))
         self._sock.settimeout(TIMEOUT_TIME) 
-        self._running = True
-        self._recv_thread = threading.Thread(target=self._receive, daemon=True)
-        self._recv_thread.start()      
-    
-    def _receive(self): 
-        while self._running:
-            try:
-                data,address = self._sock.recvfrom(MAX_SIZE_PACKET)
-                if address == (self.remote_ip,self.remote_port): #check if the receiving message comes from the ip address correct
-                    self._queue_packet_received.put(data)
-            except socket.timeout:
-                continue
-            except OSError as e:
-                if self._running == False:
-                    return
-                print(f"Error while receiving data: {e}")
-                break
-        self._running = False
-               
+        self._running = False                  
                
     def transmit(self, buf: bytes) -> int: 
         bytes_sent = 0
@@ -50,9 +32,18 @@ def transmit(self, buf: bytes) -> int:
         return bytes_sent
     
     def get_packet(self) -> Optional[bytes]:
-        if self._queue_packet_received.empty():
-            return None
-        return self._queue_packet_received.get()
+        while self._running:
+            try:
+                data,address = self._sock.recvfrom(MAX_SIZE_PACKET)
+                if address == (self.remote_ip,self.remote_port): #check if the receiving message comes from the ip address correct
+                    return data
+            except socket.timeout:
+                continue
+            except OSError as e:
+                if self._running == False:
+                    return
+                print(f"Error while receiving data: {e}")
+                break
     
     def stop(self):
         if not self._running:
diff --git a/src/services/communications/Decoder_Data.py b/src/services/communications/Decoder_Data.py
index 8448764..8f4aa5b 100644
--- a/src/services/communications/Decoder_Data.py
+++ b/src/services/communications/Decoder_Data.py
@@ -31,6 +31,7 @@ def __init__(self, package_data, ds): #package_data its a array that contains st
     
     def start(self):
         self.recv_packet_running = True
+        self.ds._running = True
         self.recv_packet_thread.start()
 
     def _recv_packet(self):
@@ -139,6 +140,7 @@ def __getitem__(self, key):
     def stop(self):
         self.recv_packet_running = False
         self.recv_packet_thread.join()
+        self.ds.stop()
 
     def __del__(self):
         self.stop()

From d6c5b779908b173f83008e92fbec8c2acb0a5e35 Mon Sep 17 00:00:00 2001
From: Ikubimu <ikerubidemunoz@gmail.com>
Date: Fri, 3 Jan 2025 11:04:36 +0100
Subject: [PATCH 3/5] testing decoder and fix errors

---
 src/services/communications/Decoder_Data.py | 33 ++++++++++++---------
 src/test_decoder/test_decoder_recieve.py    | 19 ++++++++++++
 src/test_decoder/test_decoder_send.py       | 23 ++++++++++++++
 3 files changed, 61 insertions(+), 14 deletions(-)
 create mode 100644 src/test_decoder/test_decoder_recieve.py
 create mode 100644 src/test_decoder/test_decoder_send.py

diff --git a/src/services/communications/Decoder_Data.py b/src/services/communications/Decoder_Data.py
index 8f4aa5b..f301184 100644
--- a/src/services/communications/Decoder_Data.py
+++ b/src/services/communications/Decoder_Data.py
@@ -74,43 +74,43 @@ def deserialize(self, buffer, id_packet):
             data = None
             match type:
                 case "bool":
-                    data = struct.unpack('<B', buffer[:1])
+                    data = 'True' if struct.unpack('<B', buffer[:1])[0] else 'False'
                     buffer = buffer[1:]
                 case "uint8":
-                    data = struct.unpack('<B', buffer[:1])
+                    data = struct.unpack('<B', buffer[:1])[0]
                     buffer = buffer[1:]
                 case "int8":
-                    data = struct.unpack('<b', buffer[:1])
+                    data = struct.unpack('<b', buffer[:1])[0]
                     buffer = buffer[1:]
                 case "uint16":
-                    data = struct.unpack('<H', buffer[:2])
+                    data = struct.unpack('<H', buffer[:2])[0]
                     buffer = buffer[2:]
                 case "int16":
-                    data = struct.unpack('<h', buffer[:2])
+                    data = struct.unpack('<h', buffer[:2])[0]
                     buffer = buffer[2:]
                 case "uint32":
-                    data = struct.unpack('<I', buffer[:4])
+                    data = struct.unpack('<I', buffer[:4])[0]
                     buffer = buffer[2:]
                 case "int32":
-                    data = struct.unpack('<i', buffer[:4])
+                    data = struct.unpack('<i', buffer[:4])[0]
                     buffer = buffer[4:]
                 case "float32":
-                    data = struct.unpack('<f', buffer[:4])
+                    data = struct.unpack('<f', buffer[:4])[0]
                     buffer = buffer[4:]
                 case "uint64":
-                    data = struct.unpack('<Q', buffer[:8])
+                    data = struct.unpack('<Q', buffer[:8])[0]
                     buffer = buffer[8:]
                 case "int64":
-                    data = struct.unpack('<q', buffer[:8])
+                    data = struct.unpack('<q', buffer[:8])[0]
                     buffer = buffer[8:]
                 case "float64":
-                    data = struct.unpack('<d', buffer[:8])
+                    data = struct.unpack('<d', buffer[:8])[0]
                     buffer = buffer[8:]
                 case _:
                     if 'enum' in type:
-                        value_data = struct.unpack('<B', buffer[:1])
+                        value_data = struct.unpack('<B', buffer[:1])[0]
                         buffer = buffer[1:]
-                        valores = re.search(r'\((.*?)\)', type).split(',')
+                        valores = (re.search(r'\((.*?)\)', type)).group(1).split('-')
                         data = valores[value_data]
                         
                     else:
@@ -135,7 +135,12 @@ def calculate_byte_size(self, measurements):
         return size
     
     def __getitem__(self, key):
-        return self.dict_measurement_value[key]
+        
+        if key in self.dict_measurement_value:
+            return self.dict_measurement_value[key]
+        else:
+            print("The key is not include in the dictionary")
+            return None
 
     def stop(self):
         self.recv_packet_running = False
diff --git a/src/test_decoder/test_decoder_recieve.py b/src/test_decoder/test_decoder_recieve.py
new file mode 100644
index 0000000..820fd26
--- /dev/null
+++ b/src/test_decoder/test_decoder_recieve.py
@@ -0,0 +1,19 @@
+from src.services.communications.DatagramSocket import DatagramSocket
+from src.services.communications.Decoder_Data import Decoder
+import time
+
+
+
+ds = DatagramSocket('127.0.0.1', 8800, '127.0.0.1', 8801)
+
+package_data = [(100, "temp:float32,is_active:bool,state:enum(idle-fault)"), (101, "preasure:int32")] #I assume that it's the format, it might change
+dec = Decoder(package_data, ds)
+dec.start()
+
+while 1:
+    time.sleep(1)
+    temp = dec['temp']
+    is_active = dec['is_active']
+    state = dec['state']
+    preasure = dec['preasure']
+    print(f'T={temp} A={is_active} S={state} P={preasure}')
\ No newline at end of file
diff --git a/src/test_decoder/test_decoder_send.py b/src/test_decoder/test_decoder_send.py
new file mode 100644
index 0000000..9a612d1
--- /dev/null
+++ b/src/test_decoder/test_decoder_send.py
@@ -0,0 +1,23 @@
+import socket
+import struct
+
+sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
+
+id = 100
+tem = 10.0
+is_active = True
+state = 1
+
+binary_packet = struct.pack('<H',id)
+binary_packet+=struct.pack('<f', tem)
+binary_packet+=struct.pack('<B', is_active)
+binary_packet+=struct.pack('<B', state)
+
+sock.bind(('127.0.0.1', 8801))
+sock.sendto(binary_packet, ('localhost', 8800))
+
+id = 101
+pres = 32
+binary_packet_1 = struct.pack('<H', id)
+binary_packet_1 += struct.pack('<i', pres)
+sock.sendto(binary_packet_1, ('localhost', 8800))

From 350cf4cce6f4b68e2f82f0334fceb91cdbbef69a Mon Sep 17 00:00:00 2001
From: Ikubimu <ikerubidemunoz@gmail.com>
Date: Fri, 17 Jan 2025 19:05:33 +0100
Subject: [PATCH 4/5] update class for receive new dict

---
 .../services/communications/DatagramSocket.py |  1 +
 .../services/communications/Decoder_Data.py   | 44 +++++++++----------
 src/vmcu/test_decoder/test_decoder_recieve.py |  7 +--
 3 files changed, 27 insertions(+), 25 deletions(-)

diff --git a/src/vmcu/services/communications/DatagramSocket.py b/src/vmcu/services/communications/DatagramSocket.py
index 90f2ec7..21f23b1 100644
--- a/src/vmcu/services/communications/DatagramSocket.py
+++ b/src/vmcu/services/communications/DatagramSocket.py
@@ -32,6 +32,7 @@ def transmit(self, buf: bytes) -> int:
         return bytes_sent
     
     def get_packet(self) -> Optional[bytes]:
+        self._running = True
         while self._running:
             try:
                 data,address = self._sock.recvfrom(MAX_SIZE_PACKET)
diff --git a/src/vmcu/services/communications/Decoder_Data.py b/src/vmcu/services/communications/Decoder_Data.py
index f301184..43d572a 100644
--- a/src/vmcu/services/communications/Decoder_Data.py
+++ b/src/vmcu/services/communications/Decoder_Data.py
@@ -4,20 +4,34 @@
 
 import DatagramSocket
 
-
+def calculate_byte_size(self, measurements):
+
+    size = 0
+    for measure in measurements:
+        if measure == 'uint8' or measure == 'int8' or measure == 'bool' or 'enum' in measure:
+            size += 1
+        elif measure == 'uint16' or measure == 'int16':
+            size += 2
+        elif measure == 'uint32' or measure == 'int32' or measure == 'float32':
+            size += 4
+        elif measure == 'uint64' or measure == 'int64' or measure == 'float64':
+            size += 8
+              
+    return size
 class Decoder:
     def __init__(self, package_data, ds): #package_data its a array that contains string id and string with all measurements
         self.dict_measurement_types = {} #key string id of each measurament, contains an array from types
         self.dict_measurement_names = {} #contains array of names of each variable
         self.dict_measurement_value = {} #contains the value of each measurement
+        self.dict_measurement_size = {} #contains size for each packet 
         self.ds = ds #datagramsocket
-        
-        for data in package_data:
-            id = data[0]
-            measurements = data[1].split(',')
+
+        for id, measurements in package_data.items():
+            
+            measurements_split = measurements.split(',')
             arr_measuremets = []
             arr_names = []
-            for measure in measurements:
+            for measure in measurements_split:
                 pair = measure.split(':')
                 arr_names.append(pair[0])
                 arr_measuremets.append(pair[1])
@@ -25,13 +39,13 @@ def __init__(self, package_data, ds): #package_data its a array that contains st
 
             self.dict_measurement_types[id] = arr_measuremets
             self.dict_measurement_names[id] = arr_names
+            self.dict_measurement_size[id] = calculate_byte_size(arr_measuremets)
 
         self.recv_packet_thread = threading.Thread(target=self._recv_packet, daemon=True)
         self.recv_packet_running = False
     
     def start(self):
         self.recv_packet_running = True
-        self.ds._running = True
         self.recv_packet_thread.start()
 
     def _recv_packet(self):
@@ -47,7 +61,7 @@ def _recv_packet(self):
                 id_packet = struct.unpack('<H',raw_data[:2])[0]
                 buff += raw_data[2:]
                 
-                bytes_size = self.calculate_byte_size(self.dict_measurement_types[id_packet])
+                bytes_size = self.dict_measurement_size[id_packet]
                 bytes_count += len(raw_data) - 2
                 wait_new_packet = False
             else:
@@ -119,20 +133,6 @@ def deserialize(self, buffer, id_packet):
             self.dict_measurement_value[name] = data
             
 
-    def calculate_byte_size(self, measurements):
-
-        size = 0
-        for measure in measurements:
-            if measure == 'uint8' or measure == 'int8' or measure == 'bool' or 'enum' in measure:
-                size += 1
-            elif measure == 'uint16' or measure == 'int16':
-                size += 2
-            elif measure == 'uint32' or measure == 'int32' or measure == 'float32':
-                size += 4
-            elif measure == 'uint64' or measure == 'int64' or measure == 'float64':
-                size += 8
-              
-        return size
     
     def __getitem__(self, key):
         
diff --git a/src/vmcu/test_decoder/test_decoder_recieve.py b/src/vmcu/test_decoder/test_decoder_recieve.py
index 820fd26..24832ed 100644
--- a/src/vmcu/test_decoder/test_decoder_recieve.py
+++ b/src/vmcu/test_decoder/test_decoder_recieve.py
@@ -1,12 +1,13 @@
-from src.services.communications.DatagramSocket import DatagramSocket
-from src.services.communications.Decoder_Data import Decoder
+from vmcu.services.communications.DatagramSocket import DatagramSocket
+from vmcu.services.communications.Decoder_Data import Decoder
 import time
 
 
 
 ds = DatagramSocket('127.0.0.1', 8800, '127.0.0.1', 8801)
 
-package_data = [(100, "temp:float32,is_active:bool,state:enum(idle-fault)"), (101, "preasure:int32")] #I assume that it's the format, it might change
+
+package_data = {100:"temp:float32,is_active:bool,state:enum(idle-fault)", 101:"preasure:int32"} #I assume that it's the format, it might change
 dec = Decoder(package_data, ds)
 dec.start()
 

From 0af19e40e2ae5df5253b618e0c8371b83003d8b2 Mon Sep 17 00:00:00 2001
From: Ikubimu <ikerubidemunoz@gmail.com>
Date: Mon, 20 Jan 2025 16:03:42 +0100
Subject: [PATCH 5/5] fix buffer implementation to manage multiple packages

---
 .../services/communications/Decoder_Data.py   | 55 +++++++++++--------
 1 file changed, 31 insertions(+), 24 deletions(-)

diff --git a/src/vmcu/services/communications/Decoder_Data.py b/src/vmcu/services/communications/Decoder_Data.py
index 43d572a..2d86976 100644
--- a/src/vmcu/services/communications/Decoder_Data.py
+++ b/src/vmcu/services/communications/Decoder_Data.py
@@ -2,9 +2,7 @@
 import struct
 import re
 
-import DatagramSocket
-
-def calculate_byte_size(self, measurements):
+def calculate_byte_size(measurements):
 
     size = 0
     for measure in measurements:
@@ -51,33 +49,42 @@ def start(self):
     def _recv_packet(self):
         buff = bytearray()
         id_packet = 0
-        bytes_count = 0
         bytes_size = 0
         wait_new_packet = True
 
         while self.recv_packet_running:
-            raw_data = self.ds.get_packet() #get_packet must to be blocking
-            if wait_new_packet:
-                id_packet = struct.unpack('<H',raw_data[:2])[0]
-                buff += raw_data[2:]
-                
-                bytes_size = self.dict_measurement_size[id_packet]
-                bytes_count += len(raw_data) - 2
-                wait_new_packet = False
-            else:
+            try:
+                raw_data = self.ds.get_packet()
                 buff += raw_data
-                bytes_count += len(raw_data)
-
-            if bytes_count < bytes_size:
-                continue
-            else:
-                if bytes_count == bytes_size:
-                    self.deserialize(buff, id_packet)
-
+                if wait_new_packet:
+                    id_packet = struct.unpack('<H',buff[:2])[0]
+                    buff = buff[2:]
+                    
+                    bytes_size = self.dict_measurement_size[id_packet]
+                    wait_new_packet = False
+
+                while len(buff) >= bytes_size and len(buff)>0:
+                    data_buff = buff[:bytes_size]
+                    buff = buff[bytes_size:]
+                    self.deserialize(data_buff, id_packet)
+
+                    if len(buff) >= 2:
+                        id_packet = struct.unpack('<H',buff[:2])[0]
+                        buff = buff[2:]
+                        bytes_size = self.dict_measurement_size[id_packet]
+                    else:  
+                        bytes_size = 0
+                        wait_new_packet = True
+            except KeyError as e:
+                print(f"Error to obtain key: {e}")
+                buff.clear()
+                bytes_size=0
+                wait_new_packet = True
+            except struct.error as e:
+                print(f'Unpacking error: {e}')
                 buff.clear()
-                bytes_count = 0
-                bytes_size = 0
-                wait_new_packet = True  
+                bytes_size=0
+                wait_new_packet = True