Index: scripts/update_package_script/utilities.py
===================================================================
diff -u -ra99d0580e0f14cdf80321e963a7121a2225d2c4f -rfb0e5e63dfae201ddd3c41f76bcedf4d778b723c
--- scripts/update_package_script/utilities.py	(.../utilities.py)	(revision a99d0580e0f14cdf80321e963a7121a2225d2c4f)
+++ scripts/update_package_script/utilities.py	(.../utilities.py)	(revision fb0e5e63dfae201ddd3c41f76bcedf4d778b723c)
@@ -1,11 +1,14 @@
+
 import os.path
+import time
 
 import can
 import struct
+
 from enum import unique
 from time import sleep
 from can.interfaces.socketcan.socketcan import SocketcanBus
-from scripts.base.base import Base, SWUpdateEnum, SWUpdateTargets
+from scripts.base.base import SWUpdateEnum, SWUpdateTargets
 
 @unique
 class SWUpdateCommands(SWUpdateEnum):
@@ -15,13 +18,15 @@
     SW_UPDATE_VERIFY = 3
     NUM_OF_SW_UPDATE_CMDS = 4
 
+@unique
 class CanCommStatus(SWUpdateEnum):
     CAN_COMM_NOT_STARTED = 0
     CAN_COMM_IN_PROGRESS = 1
     CAN_COMM_SUCCESSFUL = 2
     CAN_COMM_TIME_OUT = 3
     CAN_COMM_READY = 4
-    NUM_OF_CAN_COMM_STATES = 5
+    CAN_COMM_CRC_FAILED = 5
+    NUM_OF_CAN_COMM_STATES = 6
 
 class Utilities:
 
@@ -65,10 +70,13 @@
     _SHIFT_BITS_BY_A_NIBBLE = 4
 
     _NUM_OF_BYTES_PER_CAN_FRAME = 8
-    _CAN_INTERFACE = "can0"
+    _CAN_INTERFACE = 'can0'
     _SEND_CMD_MAIL_BOX = 0x601
-    _RESP_CMD_MAIL_BOX = 0x606
-    _MIN_CAN_WAIT_FOR_RESP_S = 0.5
+    _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
 
     SEND_MSG_ACK_STATUS_KEY_NAME = 'cmd'
     UPDATE_MSG_ACK_STATUS_KEY_NAME = 'update'
@@ -105,11 +113,7 @@
 
         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)
-        # TODO remove for testing only
-        sleep(0.7)
-        self._msg_ack_nack_status[self.SEND_MSG_ACK_STATUS_KEY_NAME] = CanCommStatus.CAN_COMM_SUCCESSFUL.value
-        self._msg_ack_nack_status[self.UPDATE_MSG_ACK_STATUS_KEY_NAME] = CanCommStatus.CAN_COMM_READY.value
-        # TODO remove
+        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):
 
@@ -134,6 +138,7 @@
         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)
         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:
@@ -143,19 +148,10 @@
                 self._send_can_message(mail_box, bytes_to_send, self.UPDATE_MSG_ACK_STATUS_KEY_NAME,
                                        wait_for_resp_s=resp_time_out_s)
 
-        #while True:
-        #    message = self._can_bus.recv()
-        #    if message is not None:
-        #        print(message)
-        #        if '0x606' == hex(message.arbitration_id) and message.data[0] == self._msg_id_count:
-        #            print(self._msg_id_count, message)
-        #            write_data = str(self._msg_id_count) + ', ' + str(message) + '\r'
-        #            self.file_handle.write(write_data)
-        #            self._msg_ack_nack_status[self.UPDATE_MSG_ACK_STATUS_KEY_NAME] = CanCommStatus.CAN_COMM_READY.value
-        #            break
+        self._get_fw_ack_nack_resp(self.UPDATE_MSG_ACK_STATUS_KEY_NAME)
 
     @classmethod
-    def _get_crc32(cls, data):
+    def _get_crc32(cls, data: bytes):
 
         crc = 0
         length = len(data)
@@ -174,12 +170,10 @@
     def _prepare_update_mail_boxes():
 
         temp = dict()
-        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)
+        temp[SWUpdateTargets.TARGET_TD.value]      = (0x603, 0.5)
+        temp[SWUpdateTargets.TARGET_TD_FPGA.value] = (0x603, 0.5) # TODO add more timeout for FPGAs
+        temp[SWUpdateTargets.TARGET_DD.value]      = (0x604, 0.5)
+        temp[SWUpdateTargets.TARGET_DD_FPGA.value] = (0x604, 0.5)
 
         return temp
 
@@ -200,3 +194,31 @@
         #    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 calc_crc == payload_crc:
+                    if message.data[1] == self._RESP_MSG_ACK: can_comm_status = CanCommStatus.CAN_COMM_READY.value
+                else:
+                    can_comm_status = CanCommStatus.CAN_COMM_CRC_FAILED.value
+                break
+            #if time.time() - start_time > self._CAN_MSG_WAIT_FOR_RESP_S:
+            #    can_comm_status = CanCommStatus.CAN_COMM_TIME_OUT.value
+            #    break
+
+        self._msg_ack_nack_status[msg_type] = can_comm_status
+        if msg_type == self.SEND_MSG_ACK_STATUS_KEY_NAME:
+            self._msg_ack_nack_status[self.UPDATE_MSG_ACK_STATUS_KEY_NAME] = CanCommStatus.CAN_COMM_READY.value \
+                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])