Index: scripts/update_package_script/utilities.py
===================================================================
diff -u -r988824ec54f3d9d4ff92d60d2be09fe8ad09ee29 -r239e4187b87deffb844cf29a350a980252cba042
--- scripts/update_package_script/utilities.py	(.../utilities.py)	(revision 988824ec54f3d9d4ff92d60d2be09fe8ad09ee29)
+++ scripts/update_package_script/utilities.py	(.../utilities.py)	(revision 239e4187b87deffb844cf29a350a980252cba042)
@@ -3,9 +3,19 @@
 import time
 import can
 import struct
+from time import sleep
 from enum import Enum, unique
 from can.interfaces.socketcan.socketcan import SocketcanBus
 
+class CANMessageListener(can.Listener):
+
+    def __init__(self):
+        self.raw_can_messages = list()
+
+    def on_message_received(self, msg: can.Message):
+        self.raw_can_messages.append(msg)
+
+
 class SWUpdateEnum(Enum):
     @classmethod
     def has_value(cls, value):
@@ -35,7 +45,7 @@
     NUM_OF_STACKS = 2
 
 @unique
-class UpdateStacksTargets(SWUpdateEnum):
+class UpdateStacksDestinations(SWUpdateEnum):
     TARGET_FIRMWARE = 0
     TARGET_FPGA = 1
     NUM_OF_TARGETS = 2
@@ -87,6 +97,7 @@
     _NUM_OF_BYTES_PER_CAN_FRAME = 8
     _CAN_INTERFACE = 'can0'
     _SEND_CMD_MAIL_BOX = 0x601
+    _BROADCAST_UPDATE_MAIL_BOX = 0x606
     _CAN_MSG_WAIT_FOR_RESP_S = 3.0
     _RESP_MSG_ACK = 1
     _RESP_MSG_NACK = 0
@@ -112,12 +123,15 @@
         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._msg_ack_nack_status[self.SEND_MSG_ACK_STATUS_KEY_NAME] = [CanCommStatus.CAN_COMM_NOT_STARTED.value, 0]
+        self._msg_ack_nack_status[self.UPDATE_MSG_ACK_STATUS_KEY_NAME] = [CanCommStatus.CAN_COMM_NOT_STARTED.value, 0]
         self.file_handle = open(os.path.join(os.getcwd(), 'ack_log.log'), 'w')
 
         self._prepare_update_mail_boxes(self._update_mail_boxes)
 
+        self._can_listener = CANMessageListener()
+        self._notifier = can.Notifier(self._can_bus, [self._can_listener])
+
     def get_msg_ack_nack_status(self, msg_type: str):
         """
         Publicly accessible method to get the ack or nack status of a message
@@ -126,7 +140,7 @@
 
         @return The status of the provided message type (e.g. ready, failed, ...)
         """
-        return self._msg_ack_nack_status[msg_type]
+        return self._msg_ack_nack_status[msg_type][0]
 
     def clear_msg_ack_nack_status(self, msg_type: str):
         """
@@ -136,7 +150,7 @@
 
         @return none
         """
-        self._msg_ack_nack_status[msg_type] = CanCommStatus.CAN_COMM_NOT_STARTED.value
+        self._msg_ack_nack_status[msg_type][0] = CanCommStatus.CAN_COMM_NOT_STARTED.value
 
     def send_command_msg(self, cmd: int, stack: int, destination: int):
         """
@@ -155,6 +169,7 @@
         # 4 bytes as message CRC
         self._stack = stack
         message_id_count = self._get_current_message_count()
+        self._msg_ack_nack_status[self.SEND_MSG_ACK_STATUS_KEY_NAME][1] = message_id_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)
@@ -183,6 +198,7 @@
         # XXX bytes of the binary (default is 256 bytes)
         mail_box = self._update_mail_boxes[UpdateStacks(stack).name][self._STACK_SEND_UPDATE_MAIL_BOX]
         message_id_count = self._get_current_message_count()
+        self._msg_ack_nack_status[self.UPDATE_MSG_ACK_STATUS_KEY_NAME][1] = message_id_count
         self._total_msg_count += 1
         self._msg_sw_update_index += 1
         temp = bytes()
@@ -202,26 +218,38 @@
                 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]
-                self._send_can_message(mail_box, bytes_to_send, self.UPDATE_MSG_ACK_STATUS_KEY_NAME,
-                                       wait_for_resp_s=0)
+                self._send_can_message(mail_box, bytes_to_send, self.UPDATE_MSG_ACK_STATUS_KEY_NAME)
         # Once send was complete, wait for the CAN response
         self._get_bootloader_ack_nack_resp(self.UPDATE_MSG_ACK_STATUS_KEY_NAME)
 
+    def send_update_available_broadcast_message(self, stop_event, interval: int):
+
+        count = 1
+        while not stop_event.is_set():
+            count += 1
+            message_id_count = self._get_current_message_count()
+            can_msg_bytes = self._convert_data_to_bytes('<H', message_id_count)
+            can_msg_bytes += self._convert_data_to_bytes('<H', 0)
+            crc_32 = self._get_crc32(can_msg_bytes)
+            can_msg_bytes += self._convert_data_to_bytes('<I', crc_32)
+            self._send_can_message(self._BROADCAST_UPDATE_MAIL_BOX, can_msg_bytes, '')
+            stop_event.wait(interval)
+
     ######################## PRIVATE/CLASS/STATIC METHODS ##############################
 
-    def _send_can_message(self, mail_box: int, data: bytes, msg_type: str, wait_for_resp_s: float = 0.0):
+    def _send_can_message(self, mail_box: int, data: bytes, msg_type: str):
         """
-        Publicly accessible method to send an update message to the bootloader
+        Privately accessible method to send a CAN message.
 
-        @param target: The target stack (TD, DD)
+        @param mail_box: The CAN mailbox (e.g. 0x601)
         @param data: The data in bytes
-        @param update_payload_len: The number of bytes to write
+        @param msg_type: The message type to write (e.g. command or update)
 
         @return none
         """
-        self._msg_ack_nack_status[msg_type] = CanCommStatus.CAN_COMM_IN_PROGRESS.value
+        if msg_type != '': self._msg_ack_nack_status[msg_type][0] = 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) # TODO handle can write error
+        self._can_bus.send(packet) # TODO handle can write error?
 
     def _get_bootloader_ack_nack_resp(self, msg_type: str):
         """
@@ -232,33 +260,34 @@
         @return none
         """
         start_time = time.time()
+        can_comm_status = None
         while True:
             # Keep running and wait for the CAN bus message response
-            # TODO do we need to setup a can listener?
-            message = self._can_bus.recv()
+            if time.time() - start_time > self._CAN_MSG_WAIT_FOR_RESP_S:
+                can_comm_status = CanCommStatus.CAN_COMM_TIME_OUT.value
+                break
+            if len(self._can_listener.raw_can_messages) == 0: continue
+            message = self._can_listener.raw_can_messages.pop(0)
+            # print("Popped message", message)
             can_comm_status = CanCommStatus.CAN_COMM_IN_PROGRESS.value
-            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
             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:
+            msg_id_count = self._msg_ack_nack_status[msg_type][1]
+            if hex(resp_mail_box) == hex(message.arbitration_id) and msg_id_back == msg_id_count:
                 calc_crc = self._get_crc32(message.data[:self._RESP_CRC_START_INDEX])
                 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:
                     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
 
-        self._msg_ack_nack_status[msg_type] = can_comm_status
+        self._msg_ack_nack_status[msg_type][0] = can_comm_status
         if msg_type == self.SEND_MSG_ACK_STATUS_KEY_NAME:
             # If the message that was acked, was the command, enable the update message that it is ready to be used
-            self._msg_ack_nack_status[self.UPDATE_MSG_ACK_STATUS_KEY_NAME] = CanCommStatus.CAN_COMM_READY.value \
+            self._msg_ack_nack_status[self.UPDATE_MSG_ACK_STATUS_KEY_NAME][0] = 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))