Index: scripts/update_package_script/utilities.py
===================================================================
diff -u -ra8de2deaeffb523ed9d706a40726cc92c2a0edd2 -r13a167417e54fb156c1fd9ac581a961f1c3d57bb
--- scripts/update_package_script/utilities.py	(.../utilities.py)	(revision a8de2deaeffb523ed9d706a40726cc92c2a0edd2)
+++ scripts/update_package_script/utilities.py	(.../utilities.py)	(revision 13a167417e54fb156c1fd9ac581a961f1c3d57bb)
@@ -1,7 +1,7 @@
 import can
 import struct
-from time import  sleep
 from enum import unique
+from time import sleep
 from can.interfaces.socketcan.socketcan import SocketcanBus
 from scripts.base.base import Base, SWUpdateEnum, SWUpdateTargets
 
@@ -13,6 +13,13 @@
     SW_UPDATE_VERIFY = 3
     NUM_OF_SW_UPDATE_CMDS = 4
 
+class CanCommStatus(SWUpdateEnum):
+    CAN_COMM_NOT_STARTED = 0
+    CAN_COMM_IN_PROGRESS = 1
+    CAN_COMM_SUCCESSFUL = 2
+    CAN_COMM_TIME_OUT = 3
+    NUM_OF_CAN_COMM_STATES = 4
+
 class Utilities(Base):
 
     _CRC32_TABLE = (
@@ -58,6 +65,7 @@
     _CAN_INTERFACE = "can0"
     _SEND_CMD_MAIL_BOX = 0x601
     _RESP_CMD_MAIL_BOX = 0x606
+    _MIN_CAN_WAIT_FOR_RESP_S = 0.5
 
     SEND_MSG_ACK_STATUS_KEY_NAME = 'cmd'
     UPDATE_MSG_ACK_STATUS_KEY_NAME = 'update'
@@ -71,74 +79,73 @@
         self._update_mail_boxes = self._prepare_update_mail_boxes()
         self._msg_ack_nack_status = dict()
 
-        self._msg_ack_nack_status[self.SEND_MSG_ACK_STATUS_KEY_NAME] = 0
-        self._msg_ack_nack_status[self.UPDATE_MSG_ACK_STATUS_KEY_NAME] = 0
+        self._msg_ack_nack_status[self.SEND_MSG_ACK_STATUS_KEY_NAME] = CanCommStatus.CAN_COMM_NOT_STARTED.value
+        self._msg_ack_nack_status[self.UPDATE_MSG_ACK_STATUS_KEY_NAME] = CanCommStatus.CAN_COMM_NOT_STARTED.value
 
     def get_msg_ack_nack_status(self, msg_type: str):
         return self._msg_ack_nack_status[msg_type]
 
     def clear_msg_ack_nack_status(self, msg_type: str):
-        self._msg_ack_nack_status[msg_type] = 0
+        self._msg_ack_nack_status[msg_type] = CanCommStatus.CAN_COMM_NOT_STARTED.value
 
     def send_command_msg(self, cmd: int, target: int):
 
-        can_frame = list()
-        can_frame_bytes = b''
-        self._msg_id_count += 1
-        can_frame.append(struct.pack('B', self._msg_id_count))
+        self._msg_id_count = self._msg_id_count + 1 if self._msg_id_count < 0xFF else 0
+        can_msg_bytes = self._convert_data_to_bytes('<B', self._msg_id_count)
         cmd_combo = (target << self._SHIFT_BITS_BY_A_NIBBLE) | (cmd & 0xF)
-        can_frame.append(struct.pack('B', cmd_combo))
-        random_value = 0  # In case cybersecurity was needed
-        random_value = struct.pack('H', random_value)
-        can_frame.append(random_value)
-        can_frame_bytes += b''.join(can_frame)
-        print(can_frame, can_frame_bytes)
+        can_msg_bytes += self._convert_data_to_bytes('<B', cmd_combo)
+        can_msg_bytes += self._convert_data_to_bytes('<H', 0) # This is the random value it is 0 for now
         crc_32 = 0 #self._get_crc32(can_frame_bytes) # TODO what is wrong with this?
-        can_frame.append(struct.pack('I', crc_32))
-        can_frame_bytes = b''.join(can_frame)
-        packet = can.Message(arbitration_id=self._SEND_CMD_MAIL_BOX, data=can_frame_bytes, is_extended_id=False)
-        self._can_bus.send(packet, 0)
+        can_msg_bytes += self._convert_data_to_bytes('<I', crc_32)
 
-        message = self._can_bus.recv(0.5) #TODO is this good? change it
-        self._msg_ack_nack_status[self.SEND_MSG_ACK_STATUS_KEY_NAME] = -1 if message is None else 1
-        print(self._msg_ack_nack_status)
+        self._send_can_message(self._SEND_CMD_MAIL_BOX, can_msg_bytes, self.SEND_MSG_ACK_STATUS_KEY_NAME,
+                               wait_for_resp_s=self._MIN_CAN_WAIT_FOR_RESP_S)
+        sleep(0.1)
+        self._msg_ack_nack_status[self.SEND_MSG_ACK_STATUS_KEY_NAME] = CanCommStatus.CAN_COMM_SUCCESSFUL.value # TODO remove
 
-    def send_software_update_msg(self, target: int, data: list):
-        mail_box = self._update_mail_boxes[target]
-        can_frame = list()
-        can_msg_bytes = b''
-        can_frame_bytes = b''
-        self._msg_id_count += 1
-        can_frame.append(struct.pack('B', self._msg_id_count))
-        can_frame.append(struct.pack('B', target))
+    def send_software_update_msg(self, target: int, data: list, signature_msg: bool = False):
+
+        mail_box = self._update_mail_boxes[target][0]
+        time_out_s = self._update_mail_boxes[target][1]
+        self._msg_id_count = self._msg_id_count + 1 if self._msg_id_count < 0xFF else 0
         self._msg_sw_update_index += 1
-        can_frame.append(struct.pack('H', self._msg_sw_update_index))
-        can_msg_bytes += b''.join(can_frame)
-        crc_32 = 0 #self._get_crc32(can_frame_bytes) # TODO what is wrong with this?
-        can_frame.append(struct.pack('I', crc_32))
-        can_msg_bytes = b''.join(can_frame)
-        test = list()
-        for b in data:
-            test.append(struct.pack('B', b))
-        can_msg_bytes += b''.join(test)
-        print(len(can_msg_bytes), can_msg_bytes, len(data))
+        crc_32 = 12340
+        temp = bytes()
+        can_msg_bytes = self._convert_data_to_bytes('<B', self._msg_id_count)
+        can_msg_bytes += self._convert_data_to_bytes('<B', target)
+        if signature_msg is False:
+            can_msg_bytes += self._convert_data_to_bytes('<H', self._msg_sw_update_index)
+        else:
+            # struct does not accept 0xFFFF for 2 bytes pack
+            can_msg_bytes += self._convert_data_to_bytes('<B', 0xFF)
+            can_msg_bytes += self._convert_data_to_bytes('<B', 0xFF)
 
-        for byte in can_msg_bytes:
-            can_frame_bytes += bytes([byte])
-            if can_msg_bytes.index(byte) % 8 == 0 and can_msg_bytes.index(byte) != 0:
+        for b in data: temp += self._convert_data_to_bytes('<B', b)
 
-                packet = can.Message(arbitration_id=mail_box, data=can_frame_bytes, is_extended_id=False)
-                print(can_frame_bytes, mail_box, packet, len(can_frame_bytes), can_msg_bytes.index(byte))
-                self._can_bus.send(packet, 0)
-                sleep(0.1)
-                # TODO send the message
-                can_frame_bytes = b''
+        #crc_32 = self._get_crc32(can_msg_bytes + temp) # TODO figure out
+        can_msg_bytes += self._convert_data_to_bytes('<I', crc_32)
+        can_msg_bytes += temp
+        can_msg_bytes_len = len(can_msg_bytes)
 
+        for byte_index in range(0, can_msg_bytes_len):
+            if (byte_index % self._NUM_OF_BYTES_PER_CAN_FRAME == 0 and byte_index != 0) or \
+                byte_index == can_msg_bytes_len - 1:
+                byte_index = can_msg_bytes_len if byte_index == can_msg_bytes_len - 1 else byte_index
+                bytes_to_send = can_msg_bytes[byte_index - self._NUM_OF_BYTES_PER_CAN_FRAME: byte_index]
+                #print(bytes_to_send, byte_index)
+                resp_time_out_s = time_out_s if byte_index == can_msg_bytes_len - 1 else 0.0
+                self._send_can_message(mail_box, bytes_to_send, self.UPDATE_MSG_ACK_STATUS_KEY_NAME,
+                                       wait_for_resp_s=resp_time_out_s)
 
 
+        # TODO this is only here for testing and is to simulate the ack from FW REMOVE
+        sleep(0.1)
+        self._msg_ack_nack_status[self.UPDATE_MSG_ACK_STATUS_KEY_NAME] = CanCommStatus.CAN_COMM_SUCCESSFUL.value
+        #packet = can.Message(arbitration_id=0x606, data=[0]*8, is_extended_id=False)
+        #self._can_bus.send(packet, 0)
+        #message = self._can_bus.recv(0.1)
+        # TODO this is only here for testing and is to simulate the ack from FW REMOVE
 
-        #print(data, len(data), can_frame_bytes)
-
     @classmethod
     def _get_crc32(cls, data):
 
@@ -147,7 +154,7 @@
         i = 0
 
         while length > 0:
-            print(i, length, crc, data[i], data[i] ^ (crc >> cls._SHIFT_24_BITS))
+            #print(i, length, crc, data[i], data[i] ^ (crc >> cls._SHIFT_24_BITS), crc << cls._SHIFT_8_BITS_FOR_BYTE_SHIFT)
             crc = (crc << cls._SHIFT_8_BITS_FOR_BYTE_SHIFT) ^ cls._CRC32_TABLE[data[i] ^ (crc >> cls._SHIFT_24_BITS)]
             i += 1
             length -= 1
@@ -158,12 +165,29 @@
     def _prepare_update_mail_boxes():
 
         temp = dict()
-        temp[SWUpdateTargets.TARGET_TD.value] = 0x602
-        temp[SWUpdateTargets.TARGET_TD_FPGA.value] = 0x602
-        temp[SWUpdateTargets.TARGET_DD.value] = 0x603
-        temp[SWUpdateTargets.TARGET_DD_FPGA.value] = 0x603
-        temp[SWUpdateTargets.TARGET_RO.value] = 0x604
-        temp[SWUpdateTargets.TARGET_RO_FPGA.value] = 0x604
+        temp[SWUpdateTargets.TARGET_TD.value]      = (0x602, 0.5)
+        temp[SWUpdateTargets.TARGET_TD_FPGA.value] = (0x602, 0.5) # TODO add more timeout for FPGAs
+        temp[SWUpdateTargets.TARGET_DD.value]      = (0x603, 0.5)
+        temp[SWUpdateTargets.TARGET_DD_FPGA.value] = (0x603, 0.5)
+        temp[SWUpdateTargets.TARGET_RO.value]      = (0x604, 0.5)
+        temp[SWUpdateTargets.TARGET_RO_FPGA.value] = (0x604, 0.5)
 
         return temp
 
+    @staticmethod
+    def _convert_data_to_bytes(conversion: str, data: int):
+        return struct.pack(conversion, data)
+
+    def _send_can_message(self, mail_box: int, data: bytes, msg_type: str, wait_for_resp_s: float = 0.0):
+
+        self._msg_ack_nack_status[msg_type] = CanCommStatus.CAN_COMM_IN_PROGRESS.value
+        packet = can.Message(arbitration_id=mail_box, data=data, is_extended_id=False)
+        self._can_bus.send(packet, 0)
+
+        #sleep(0.2)
+        #self._msg_ack_nack_status[msg_type] = CanCommStatus.CAN_COMM_SUCCESSFUL.value
+        #if wait_for_resp_s >= self._MIN_CAN_WAIT_FOR_RESP_S:
+        #    message = self._can_bus.recv(wait_for_resp_s) #TODO is this good? change it
+        #    self._msg_ack_nack_status[msg_type] = CanCommStatus.CAN_COMM_TIME_OUT.value if message is None \
+        #                                          else CanCommStatus.CAN_COMM_SUCCESSFUL.value
+            #print(message, self._msg_ack_nack_status[msg_type])