Index: scripts/update_package_script/utilities.py
===================================================================
diff -u -radea121e63d4eabb225c26bc1efd6741c59e0df3 -r988824ec54f3d9d4ff92d60d2be09fe8ad09ee29
--- scripts/update_package_script/utilities.py	(.../utilities.py)	(revision adea121e63d4eabb225c26bc1efd6741c59e0df3)
+++ scripts/update_package_script/utilities.py	(.../utilities.py)	(revision 988824ec54f3d9d4ff92d60d2be09fe8ad09ee29)
@@ -15,8 +15,7 @@
 class SWUpdateCommands(SWUpdateEnum):
     SW_UPDATE_START = 0
     SW_UPDATE_ABORT = 1
-    SW_UPDATE_RUN_APP = 2
-    SW_UPDATE_VERIFY = 3
+    SW_UPDATE_VERIFY = 2
     NUM_OF_SW_UPDATE_CMDS = 4
 
 @unique
@@ -30,13 +29,17 @@
     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 UpdateStacks(SWUpdateEnum):
+    STACK_TD = 0
+    STACK_DD = 1
+    NUM_OF_STACKS = 2
 
+@unique
+class UpdateStacksTargets(SWUpdateEnum):
+    TARGET_FIRMWARE = 0
+    TARGET_FPGA = 1
+    NUM_OF_TARGETS = 2
+
 class Utilities:
     """
     Software update utilities class
@@ -84,16 +87,18 @@
     _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
     _RESP_MSG_ID_INDEX = 0
-    _RESP_ACK_NACK_INDEX = 1
+    _RESP_ACK_NACK_INDEX = 2
     _RESP_CRC_START_INDEX = 4
     SEND_MSG_ACK_STATUS_KEY_NAME = 'cmd'
     UPDATE_MSG_ACK_STATUS_KEY_NAME = 'update'
 
+    _STACK_SEND_UPDATE_MAIL_BOX = 'send'
+    _STACK_RCV_RESP_MAIL_BOX = 'receive'
+
     def __init__(self):
         """
          Utilities class constructor
@@ -102,15 +107,17 @@
         self._can_bus = SocketcanBus(channel=self._CAN_INTERFACE)
         self._msg_id_count = 0
         self._msg_sw_update_index = 0
-        self._update_mail_boxes = self._prepare_update_mail_boxes()
+        self._update_mail_boxes = dict()
         self._msg_ack_nack_status = dict()
         self._total_msg_count = 0
+        self._stack = 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
-
         self.file_handle = open(os.path.join(os.getcwd(), 'ack_log.log'), 'w')
 
+        self._prepare_update_mail_boxes(self._update_mail_boxes)
+
     def get_msg_ack_nack_status(self, msg_type: str):
         """
         Publicly accessible method to get the ack or nack status of a message
@@ -131,12 +138,13 @@
         """
         self._msg_ack_nack_status[msg_type] = CanCommStatus.CAN_COMM_NOT_STARTED.value
 
-    def send_command_msg(self, cmd: int, target: int):
+    def send_command_msg(self, cmd: int, stack: int, destination: int):
         """
         Publicly accessible method to send a command message to the bootloader
 
         @param cmd: The command to send (e.g. update, verify)
-        @param target: The target stack (TD, DD)
+        @param stack: The stack (TD, DD)
+        @param target: The destination (Firmware, FPGA)
 
         @return none
         """
@@ -145,18 +153,19 @@
         # 1 byte with command a nibble and target as a nibble
         # 2 bytes as random value for cybersecurity. It is 0 now.
         # 4 bytes as message CRC
-        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)
+        self._stack = stack
+        message_id_count = self._get_current_message_count()
+        can_msg_bytes = self._convert_data_to_bytes('<H', message_id_count)
+        cmd_combo = (stack << self._SHIFT_BITS_BY_A_NIBBLE) | (cmd & 0xF)
         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
+        can_msg_bytes += self._convert_data_to_bytes('<B', destination)
         crc_32 = self._get_crc32(can_msg_bytes)
         can_msg_bytes += self._convert_data_to_bytes('<I', crc_32)
         # Send the can message. Keep waiting until there is a response from bootloader
         self._send_can_message(self._SEND_CMD_MAIL_BOX, can_msg_bytes, self.SEND_MSG_ACK_STATUS_KEY_NAME)
         self._get_bootloader_ack_nack_resp(self.SEND_MSG_ACK_STATUS_KEY_NAME)
 
-    def send_software_update_msg(self, target: int, data: bytes, update_payload_len: int):
+    def send_software_update_msg(self, stack: int, data: bytes, update_payload_len: int):
         """
         Publicly accessible method to send an update message to the bootloader
 
@@ -172,14 +181,12 @@
         # 2 bytes as payload length (the length of the binaries to send)
         # 4 bytes as message CRC
         # XXX bytes of the binary (default is 256 bytes)
-        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
+        mail_box = self._update_mail_boxes[UpdateStacks(stack).name][self._STACK_SEND_UPDATE_MAIL_BOX]
+        message_id_count = self._get_current_message_count()
         self._total_msg_count += 1
         self._msg_sw_update_index += 1
         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)
+        can_msg_bytes = self._convert_data_to_bytes('<H', message_id_count)
         can_msg_bytes += self._convert_data_to_bytes('<H', update_payload_len)
 
         for b in data: temp += self._convert_data_to_bytes('<B', b)
@@ -195,13 +202,12 @@
                 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]
-                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)
+                                       wait_for_resp_s=0)
         # Once send was complete, wait for the CAN response
         self._get_bootloader_ack_nack_resp(self.UPDATE_MSG_ACK_STATUS_KEY_NAME)
 
-    ######################## PRIVATE METHOD ##############################
+    ######################## PRIVATE/CLASS/STATIC METHODS ##############################
 
     def _send_can_message(self, mail_box: int, data: bytes, msg_type: str, wait_for_resp_s: float = 0.0):
         """
@@ -234,9 +240,11 @@
             if message is None: continue
             # If received the message from the corresponding response message and the message ID count is the same as was sent
             # then check the CRC of the received message. If passed, check whether the message as acked or not and update the status
-            if self._RESP_CMD_MAIL_BOX == hex(message.arbitration_id) and message.data[self._RESP_MSG_ID_INDEX] == self._msg_id_count:
+            resp_mail_box = self._update_mail_boxes[UpdateStacks(self._stack).name][self._STACK_RCV_RESP_MAIL_BOX]
+            msg_id_back = self._convert_bytes_to_data('<H', message.data[self._RESP_MSG_ID_INDEX:self._RESP_ACK_NACK_INDEX])
+            if hex(resp_mail_box) == hex(message.arbitration_id) and msg_id_back == 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]
+                payload_crc = self._convert_bytes_to_data('<I', message.data[self._RESP_CRC_START_INDEX:])
                 if calc_crc == payload_crc:
                     if message.data[self._RESP_ACK_NACK_INDEX] == self._RESP_MSG_ACK: can_comm_status = CanCommStatus.CAN_COMM_READY.value
                 else:
@@ -276,17 +284,13 @@
 
         return crc
 
-    @staticmethod
-    def _prepare_update_mail_boxes():
+    def _prepare_update_mail_boxes(self, update_mail_boxes: dict):
 
-        temp = dict()
-        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)
+        update_mail_boxes[UpdateStacks.STACK_TD.name] = {self._STACK_SEND_UPDATE_MAIL_BOX: 0x603,
+                                                         self._STACK_RCV_RESP_MAIL_BOX: 0x602}
+        update_mail_boxes[UpdateStacks.STACK_DD.name] = {self._STACK_SEND_UPDATE_MAIL_BOX: 0x605,
+                                                         self._STACK_RCV_RESP_MAIL_BOX: 0x604}
 
-        return temp
-
     @staticmethod
     def _convert_data_to_bytes(conversion: str, data: int):
         """
@@ -298,3 +302,25 @@
         @return The converted data into bytes
         """
         return struct.pack(conversion, data)
+
+    @staticmethod
+    def _convert_bytes_to_data(conversion: str, data: bytes):
+        """
+        Class method to convert bytes into data
+
+        @param conversion: The conversion of type (e.g. <B, <H)
+        @param data: The bytes of data to conver
+
+        @return The converted data
+        """
+        converted = struct.unpack(conversion, data)
+        # If the conversion was successful, get the zeroth element of the tuple otherwise return 0xFFFFFF
+        converted = converted[0] if len(converted) != 0 else 0xFFFFFF
+
+        return converted
+
+    def _get_current_message_count(self):
+
+        self._msg_id_count = self._msg_id_count + 1 if self._msg_id_count < 0xFFFF else 0
+
+        return self._msg_id_count