Index: scripts/update_package_script/utilities.py
===================================================================
diff -u -rfb0e5e63dfae201ddd3c41f76bcedf4d778b723c -r4e5c95d8cea4d29a61c3c49e5e4b2b6f76bcddb1
--- scripts/update_package_script/utilities.py	(.../utilities.py)	(revision fb0e5e63dfae201ddd3c41f76bcedf4d778b723c)
+++ scripts/update_package_script/utilities.py	(.../utilities.py)	(revision 4e5c95d8cea4d29a61c3c49e5e4b2b6f76bcddb1)
@@ -1,15 +1,17 @@
 
 import os.path
 import time
-
 import can
 import struct
-
-from enum import unique
-from time import sleep
+from enum import Enum, unique
 from can.interfaces.socketcan.socketcan import SocketcanBus
-from scripts.base.base import SWUpdateEnum, SWUpdateTargets
 
+class SWUpdateEnum(Enum):
+
+    @classmethod
+    def has_value(cls, value):
+        return value in cls._value2member_map_
+
 @unique
 class SWUpdateCommands(SWUpdateEnum):
     SW_UPDATE_START = 0
@@ -28,6 +30,14 @@
     CAN_COMM_CRC_FAILED = 5
     NUM_OF_CAN_COMM_STATES = 6
 
+@unique
+class SWUpdateTargets(SWUpdateEnum):
+    TARGET_TD = 0
+    TARGET_TD_FPGA = 1
+    TARGET_DD = 2
+    TARGET_DD_FPGA = 3
+    NUM_OF_TARGETS = 4
+
 class Utilities:
 
     _CRC32_TABLE = (
@@ -68,16 +78,16 @@
     _SHIFT_8_BITS_FOR_BYTE_SHIFT = 8
     _SHIFT_24_BITS = 24
     _SHIFT_BITS_BY_A_NIBBLE = 4
-
     _NUM_OF_BYTES_PER_CAN_FRAME = 8
     _CAN_INTERFACE = 'can0'
     _SEND_CMD_MAIL_BOX = 0x601
     _RESP_CMD_MAIL_BOX = '0x602'
     _CAN_MSG_WAIT_FOR_RESP_S = 3.0
     _RESP_MSG_ACK = 1
     _RESP_MSG_NACK = 0
-    _MIN_CAN_WAIT_FOR_RESP_S = 0.5  # TODO remvoe
-
+    _RESP_MSG_ID_INDEX = 0
+    _RESP_ACK_NACK_INDEX = 1
+    _RESP_CRC_START_INDEX = 4
     SEND_MSG_ACK_STATUS_KEY_NAME = 'cmd'
     UPDATE_MSG_ACK_STATUS_KEY_NAME = 'update'
 
@@ -111,11 +121,10 @@
         crc_32 = self._get_crc32(can_msg_bytes)
         can_msg_bytes += self._convert_data_to_bytes('<I', crc_32)
 
-        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)
+        self._send_can_message(self._SEND_CMD_MAIL_BOX, can_msg_bytes, self.SEND_MSG_ACK_STATUS_KEY_NAME)
         self._get_fw_ack_nack_resp(self.SEND_MSG_ACK_STATUS_KEY_NAME)
 
-    def send_software_update_msg(self, target: int, data: bytes, update_payload_len: int, signature_msg: bool = False):
+    def send_software_update_msg(self, target: int, data: bytes, update_payload_len: int):
 
         mail_box = self._update_mail_boxes[target][0]
         time_out_s = self._update_mail_boxes[target][1]
@@ -125,20 +134,15 @@
         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 not signature_msg:
-            can_msg_bytes += self._convert_data_to_bytes('<H', update_payload_len)
-        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)
+        can_msg_bytes += self._convert_data_to_bytes('<H', update_payload_len)
 
         for b in data: temp += self._convert_data_to_bytes('<B', b)
 
         crc_32 = self._get_crc32(can_msg_bytes + temp)
         can_msg_bytes += self._convert_data_to_bytes('<I', crc_32)
         can_msg_bytes += temp
         can_msg_bytes_len = len(can_msg_bytes)
-        if len(data) != 256: print(can_msg_bytes)
+        if len(data) != 256: print(can_msg_bytes) # TODO for debugging purposes only remove
         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:
@@ -185,32 +189,24 @@
 
         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)
+        self._can_bus.send(packet, 0) # TODO handle can write error
 
-        #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])
-
     def _get_fw_ack_nack_resp(self, msg_type: str):
 
         start_time = time.time()
         while True:
             message = self._can_bus.recv()
             can_comm_status = CanCommStatus.CAN_COMM_IN_PROGRESS.value
             if message is None: continue
-            #print("A", message, "D", hex(message.arbitration_id), message.data[0], self._msg_id_count)
-            if self._RESP_CMD_MAIL_BOX == hex(message.arbitration_id) and message.data[0] == self._msg_id_count:
-                calc_crc = self._get_crc32(message.data[:4])
-                payload_crc = struct.unpack('<I', message.data[4:])[0]
+            if self._RESP_CMD_MAIL_BOX == hex(message.arbitration_id) and message.data[self._RESP_MSG_ID_INDEX] == self._msg_id_count:
+                calc_crc = self._get_crc32(message.data[:self._RESP_CRC_START_INDEX])
+                payload_crc = struct.unpack('<I', message.data[self._RESP_CRC_START_INDEX:])[0]
                 if calc_crc == payload_crc:
-                    if message.data[1] == self._RESP_MSG_ACK: can_comm_status = CanCommStatus.CAN_COMM_READY.value
+                    if message.data[self._RESP_ACK_NACK_INDEX] == self._RESP_MSG_ACK: can_comm_status = CanCommStatus.CAN_COMM_READY.value
                 else:
                     can_comm_status = CanCommStatus.CAN_COMM_CRC_FAILED.value
                 break
+            # TODO investigate and implement a CAN listener
             #if time.time() - start_time > self._CAN_MSG_WAIT_FOR_RESP_S:
             #    can_comm_status = CanCommStatus.CAN_COMM_TIME_OUT.value
             #    break
@@ -221,4 +217,3 @@
                 if can_comm_status == CanCommStatus.CAN_COMM_READY.value else CanCommStatus.CAN_COMM_NOT_STARTED.value
         self.file_handle.write("Msg ID: {}, Msg Type: {}, Comm Status: {}\r".format(self._msg_id_count, msg_type,
                                                                                     CanCommStatus(can_comm_status).name))
-        #print("break", msg_type, self._msg_ack_nack_status[msg_type])