Index: dialin/dg/calibration_record.py
===================================================================
diff -u -re0aac8af8cd14024b89f241bb7b92ddd9bc4956e -r6895b99c133b8d5820df5610c3b12ac55a521998
--- dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision e0aac8af8cd14024b89f241bb7b92ddd9bc4956e)
+++ dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision 6895b99c133b8d5820df5610c3b12ac55a521998)
@@ -62,30 +62,6 @@
             self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                        self._handler_dg_calibration_sync)
 
-    def is_reading_record_done(self):
-        """
-        Handles getting the status of reading record
-
-        @return: True if reading is done otherwise False
-        """
-        return self._utilities.get_writing_to_excel_status()
-
-    def get_dg_calibration_record(self):
-        """
-        Gets the existing calibration record
-        @return: (OrderedDict) the calibration record, None if calibration record is being received
-        """
-        if not self._is_getting_cal_in_progress:
-            return self.dg_calibration_record
-        return None
-
-    def _reset_getting_calibration_record_in_progress(self):
-        """
-        Private method to set the cal in progress flag to False
-        @return: None
-        """
-        self._is_getting_cal_in_progress = False
-
     def cmd_request_dg_calibration_record(self):
         """
         Handles getting DG calibration_record record from firmware.
Index: dialin/hd/calibration_record.py
===================================================================
diff -u -re0aac8af8cd14024b89f241bb7b92ddd9bc4956e -r6895b99c133b8d5820df5610c3b12ac55a521998
--- dialin/hd/calibration_record.py	(.../calibration_record.py)	(revision e0aac8af8cd14024b89f241bb7b92ddd9bc4956e)
+++ dialin/hd/calibration_record.py	(.../calibration_record.py)	(revision 6895b99c133b8d5820df5610c3b12ac55a521998)
@@ -63,37 +63,32 @@
 
     def cmd_request_hd_calibration_record(self):
         """
-        Handles getting HD calibration_record data from firmware.
+        Handles getting HD calibration_record record from firmware.
 
-        @return: None
+        @return: 1 upon success, False otherwise
         """
         if self._is_getting_cal_in_progress is not True:
             self._is_getting_cal_in_progress = True
             # Clear the list for the next call
             self._raw_cal_record.clear()
-            # Run the firmware commands to get the calibration_record record
-            self._request_hd_fw_calibration_record()
 
-    def _request_hd_fw_calibration_record(self):
-        """
-        Handles getting HD calibration_record record from firmware.
+            message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
+                                                  message_id=MsgIds.MSG_ID_HD_GET_CALIBRATION_RECORD.value)
 
-        @return: 1 upon success, False otherwise
-        """
-        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
-                                              message_id=MsgIds.MSG_ID_HD_GET_CALIBRATION_RECORD.value)
+            self.logger.debug('Getting HD calibration record')
 
-        self.logger.debug('Getting HD calibration record')
+            received_message = self.can_interface.send(message)
 
-        received_message = self.can_interface.send(message)
+            # If there is content...
+            if received_message is not None:
+                # response payload is OK or not OK
+                return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
+            else:
+                self.logger.debug("Timeout!!!!")
+                return False
 
-        # If there is content...
-        if received_message is not None:
-            # response payload is OK or not OK
-            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
-        else:
-            self.logger.debug("Timeout!!!!")
-            return False
+        self.logger.debug("Request cancelled: an existing request is in progress.")
+        return False
 
     def _handler_hd_calibration_sync(self, message):
         """
@@ -153,7 +148,7 @@
         """
         record_packets = self._utilities.prepare_record_to_send_to_fw(hd_calibration_record)
 
-        self.logger.debug('Setting HD calibration record')
+        self.logger.debug("Setting HD calibration record")
 
         # Update all the data packets with the last message count since is the number of messages that firmware
         # should receive
@@ -175,6 +170,9 @@
                 self.logger.debug("Timeout!!!!")
                 return False
 
+        self.logger.debug("Finished sending HD calibration record.")
+        return True
+
     def _setup_base_calibration_record(self):
         """
         Handles assembling the sub dictionaries of each hardware group to make the main HD calibration_record record.
Index: dialin/hd/service_record.py
===================================================================
diff -u -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc -r6895b99c133b8d5820df5610c3b12ac55a521998
--- dialin/hd/service_record.py	(.../service_record.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
+++ dialin/hd/service_record.py	(.../service_record.py)	(revision 6895b99c133b8d5820df5610c3b12ac55a521998)
@@ -52,77 +52,49 @@
         self.service_data = 0
         self._raw_service_record = []
         self._utilities = NVOpsUtils(logger=self.logger)
-        # Service main record
-        self.hd_service_record = OrderedDict()
+        self.hd_service_record = self._prepare_hd_service_record()
 
         if self.can_interface is not None:
             channel_id = DenaliChannels.hd_to_dialin_ch_id
             msg_id = MsgIds.MSG_ID_HD_SEND_SERVICE_RECORD.value
             self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                        self._handler_hd_service_sync)
-        # Prepare the service record by putting sub-dictionaries together
-        self._prepare_hd_service_record()
 
-    def init_excel_report(self, directory: str):
+    def cmd_request_hd_service_record(self):
         """
-        Prepares the excel report in the provided directory
-        @param directory: (str) the directory
-        @return: None
-        """
-
-        # Prepare the excel report and workspace
-        self._utilities.prepare_excel_report('HD', 'Service', directory)
-
-    def is_reading_record_done(self):
-        """
-        Handles getting the status of reading record
-
-        @return: True if reading is done otherwise False
-        """
-        return self._utilities.get_writing_to_excel_status()
-
-    def get_hd_service_record(self):
-        """
         Handles getting HD service record from firmware.
 
-        @return: None
+        @return: 1 upon success, False otherwise
         """
         if self._is_getting_service_in_progress is not True:
             self._is_getting_service_in_progress = True
             # Clear the list for the next call
             self._raw_service_record.clear()
-            # Run the firmware commands to get the record
-            self._request_hd_fw_service_record()
 
-    def _request_hd_fw_service_record(self):
-        """
-        Handles getting HD service record from firmware.
+            message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
+                                                  message_id=MsgIds.MSG_ID_HD_GET_SERVICE_RECORD.value)
 
-        @return: None
-        """
-        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
-                                              message_id=MsgIds.MSG_ID_HD_GET_SERVICE_RECORD.value)
+            self.logger.debug('Getting HD service record')
 
-        self.logger.debug('Getting HD service record')
+            received_message = self.can_interface.send(message)
 
-        received_message = self.can_interface.send(message)
+            # If there is content...
+            if received_message is not None:
+                # response payload is OK or not OK
+                return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
+            else:
+                self.logger.debug("Timeout!!!!")
+                return False
 
-        # If there is content...
-        if received_message is not None:
-            # response payload is OK or not OK
-            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
-        else:
-            self.logger.debug("Timeout!!!!")
-            return False
+        self.logger.debug("Request cancelled: an existing request is in progress.")
+        return False
 
-    @_publish(["current_message", "total_messages", "received_msg_length", "service_data"])
     def _handler_hd_service_sync(self, message):
         """
         Handles published HD system record messages. HD system records are captured for
         processing and updating the HD system record.
 
         @param message:  published HD system record data message
-
         @return: None
         """
         curr = struct.unpack('i', bytearray(
@@ -152,31 +124,30 @@
                 # Done with receiving the messages
                 self._is_getting_service_in_progress = False
                 # If all the messages have been received, call another function to process the raw data
-                self._utilities.process_received_record_from_fw(self.hd_service_record, self._raw_service_record,
-                                                                write_to_excel=self._write_fw_data_to_excel)
+                self._utilities.process_received_record_from_fw(self.hd_service_record, self._raw_service_record)
+                self._handler_received_complete_hd_service_record()
 
-    def set_hd_service_record(self):
+    @_publish(["hd_service_record"])
+    def _handler_received_complete_hd_service_record(self):
         """
-        Handles updating the HD system and sends it to FW.
+        Publishes the received service record
 
-        @return: none
+        @return: None
         """
-        # Read the data from firmware but do not update the excel document
-        # At this step, another read from firmware is requested internally to update the dictionary.
-        # The values in the dictionary is compared against the excel report and if they are different, it automatically
-        # sets the calibration time and calculates the CRC for that group. By default once a read from firmware is
-        # requested, the excel report is updated automatically.
-        self._write_fw_data_to_excel = False
-        self.get_hd_service_record()
-        # Wait until reading calibration record from firmware is updated
-        while self._utilities.get_reading_record_status() is not True:
-            time.sleep(self._DIALIN_RECORD_UPDATE_DELAY_S)
+        self.logger.debug("Received a complete hd service record.")
 
-        self._utilities.write_excel_record_to_calibration_record(self.hd_service_record)
-        record_packets = self._utilities.prepare_record_to_send_to_fw(self.hd_service_record)
+    def cmd_set_hd_service_record(self, hd_service_record: OrderedDict):
+        """
+        Handles updating the HD system and sends it to FW.
 
+        @param hd_service_record: (OrderedDict) the hd service record to be sent
+        @return: True upon success, False otherwise
+        """
+
         self.logger.debug('Setting HD service record')
 
+        record_packets = self._utilities.prepare_record_to_send_to_fw(hd_service_record)
+
         # Update all the data packets with the last message count since is the number of messages that firmware
         # should receive
         for packet in record_packets:
@@ -197,12 +168,16 @@
                 self.logger.debug("Timeout!!!!")
                 return False
 
+        self.logger.debug("Finished sending HD service record.")
+        return True
+
     def _prepare_hd_service_record(self):
         """
         Handles assembling the sub dictionaries of each group to make the main HD service record.
 
-        @return: None
+        @return: (OrderedDict) an assembled hd service record
         """
+        result = OrderedDict()
         groups_byte_size = 0
         # create a list of the functions of the sub dictionaries
         functions = [self._prepare_service_record()]
@@ -211,7 +186,7 @@
             # Update the groups bytes size so far to be use to padding later
             groups_byte_size += function[1]
             # Update the calibration record
-            self.hd_service_record.update(function[0])
+            result.update(function[0])
 
         # Build the CRC of the main calibration_record record
         record_crc = OrderedDict({'crc': ['<H', self._DEFAULT_CRC_VALUE]})
@@ -226,9 +201,11 @@
         padding = OrderedDict({'padding': ['<B', [self._DEFAULT_CRC_VALUE] * padding_size]})
 
         # Update the dictionary with the padding and record crc dictionaries
-        self.hd_service_record.update(padding)
-        self.hd_service_record.update(record_crc)
+        result.update(padding)
+        result.update(record_crc)
 
+        return result
+
     def _prepare_service_record(self):
         """
         Handles creating the service record dictionary.
Index: dialin/hd/system_record.py
===================================================================
diff -u -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc -r6895b99c133b8d5820df5610c3b12ac55a521998
--- dialin/hd/system_record.py	(.../system_record.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
+++ dialin/hd/system_record.py	(.../system_record.py)	(revision 6895b99c133b8d5820df5610c3b12ac55a521998)
@@ -57,69 +57,42 @@
         self._raw_system_record = []
         self._utilities = NVOpsUtils(logger=self.logger)
         # System main record
-        self.hd_system_record = OrderedDict()
+        self.hd_system_record = self._prepare_hd_system_record()
 
         if self.can_interface is not None:
             channel_id = DenaliChannels.hd_to_dialin_ch_id
             msg_id = MsgIds.MSG_ID_HD_SEND_SYSTEM_RECORD.value
             self.can_interface.register_receiving_publication_function(channel_id, msg_id, self._handler_hd_system_sync)
 
-        # Prepare the system record by putting sub-dictionaries together
-        self._prepare_hd_system_record()
-
-    def init_excel_report(self, directory: str):
+    def cmd_request_hd_system_record(self):
         """
-        Prepares the excel report in the provided directory
-        @param directory: (str) the directory
-        @return: None
-        """
-
-        # Prepare the excel report and workspace
-        self._utilities.prepare_excel_report('HD', 'System', directory)
-
-    def get_hd_system_record(self):
-        """
         Handles getting HD calibration_record data from firmware.
 
-        @return: None
+        @return: 1 upon success, False otherwise
         """
         if self._is_getting_system_in_progress is not True:
             self._is_getting_system_in_progress = True
             # Clear the list for the next call
             self._raw_system_record.clear()
-            # Run the firmware commands to get the record
-            self._request_hd_fw_system_record()
 
-    def is_reading_record_done(self):
-        """
-        Handles getting the status of reading record
+            message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
+                                                  message_id=MsgIds.MSG_ID_HD_GET_SYSTEM_RECORD.value)
 
-        @return: True if reading is done otherwise False
-        """
-        return self._utilities.get_writing_to_excel_status()
+            self.logger.debug('Getting HD system record')
 
-    def _request_hd_fw_system_record(self):
-        """
-        Handles getting HD system record from firmware.
+            received_message = self.can_interface.send(message)
 
-        @return: None
-        """
-        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
-                                              message_id=MsgIds.MSG_ID_HD_GET_SYSTEM_RECORD.value)
+            # If there is content...
+            if received_message is not None:
+                # response payload is OK or not OK
+                return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
+            else:
+                self.logger.debug("Timeout!!!!")
+                return False
 
-        self.logger.debug('Getting HD system record')
+        self.logger.debug("Request cancelled: an existing request is in progress.")
+        return False
 
-        received_message = self.can_interface.send(message)
-
-        # If there is content...
-        if received_message is not None:
-            # response payload is OK or not OK
-            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
-        else:
-            self.logger.debug("Timeout!!!!")
-            return False
-
-    @_publish(["current_message", "total_messages", "received_msg_length", "service_data"])
     def _handler_hd_system_sync(self, message):
         """
         Handles published HD system record messages. HD system records are captured for
@@ -156,29 +129,27 @@
                 # Done with receiving the messages
                 self._is_getting_system_in_progress = False
                 # If all the messages have been received, call another function to process the raw data
-                self._utilities.process_received_record_from_fw(self.hd_system_record, self._raw_system_record,
-                                                                write_to_excel=self._write_fw_data_to_excel)
+                self._utilities.process_received_record_from_fw(self.hd_system_record, self._raw_system_record)
+                self._handler_received_complete_hd_system_record()
 
-    def set_hd_system_record(self):
+    @_publish(["hd_system_record"])
+    def _handler_received_complete_hd_system_record(self):
         """
+        Publishes the received system record
+
+        @return: None
+        """
+        self.logger.debug("Received a complete hd system record.")
+
+    def cmd_set_hd_system_record(self, hd_system_record: OrderedDict):
+        """
         Handles updating the HD system and sends it to FW.
 
+        @param hd_system_record: (OrderedDict) the hd system record to be sent
         @return: none
         """
-        # Read the data from firmware but do not update the excel document
-        # At this step, another read from firmware is requested internally to update the dictionary.
-        # The values in the dictionary is compared against the excel report and if they are different, it automatically
-        # sets the calibration time and calculates the CRC for that group. By default once a read from firmware is
-        # requested, the excel report is updated automatically.
-        self._write_fw_data_to_excel = False
-        self.get_hd_system_record()
-        # Wait until reading calibration record from firmware is updated
-        while self._utilities.get_reading_record_status() is not True:
-            time.sleep(self._DIALIN_RECORD_UPDATE_DELAY_S)
+        record_packets = self._utilities.prepare_record_to_send_to_fw(hd_system_record)
 
-        self._utilities.write_excel_record_to_calibration_record(self.hd_system_record)
-        record_packets = self._utilities.prepare_record_to_send_to_fw(self.hd_system_record)
-
         self.logger.debug('Setting HD system record')
 
         # Update all the data packets with the last message count since is the number of messages that firmware
@@ -201,12 +172,16 @@
                 self.logger.debug("Timeout!!!!")
                 return False
 
+        self.logger.debug("Finished sending HD system record.")
+        return True
+
     def _prepare_hd_system_record(self):
         """
         Handles assembling the sub dictionaries of each group to make the main HD system record.
 
-        @return: None
+        @return: (OrderedDict) the assembled hd system record
         """
+        result = OrderedDict()
         groups_byte_size = 0
         # create a list of the functions of the sub dictionaries
         functions = [self._prepare_system_record()]
@@ -215,7 +190,7 @@
             # Update the groups bytes size so far to be use to padding later
             groups_byte_size += function[1]
             # Update the calibration record
-            self.hd_system_record.update(function[0])
+            result.update(function[0])
 
         # Build the CRC of the main calibration_record record
         record_crc = OrderedDict({'crc': ['<H', self._DEFAULT_CRC_VALUE]})
@@ -230,9 +205,11 @@
         padding = OrderedDict({'padding': ['<B', [self._DEFAULT_CRC_VALUE] * padding_size]})
 
         # Update the dictionary with the padding and record crc dictionaries
-        self.hd_system_record.update(padding)
-        self.hd_system_record.update(record_crc)
+        result.update(padding)
+        result.update(record_crc)
 
+        return result
+
     def _prepare_system_record(self):
         """
         Handles creating the system record dictionary.
Index: dialin/protocols/CAN.py
===================================================================
diff -u -re0aac8af8cd14024b89f241bb7b92ddd9bc4956e -r6895b99c133b8d5820df5610c3b12ac55a521998
--- dialin/protocols/CAN.py	(.../CAN.py)	(revision e0aac8af8cd14024b89f241bb7b92ddd9bc4956e)
+++ dialin/protocols/CAN.py	(.../CAN.py)	(revision 6895b99c133b8d5820df5610c3b12ac55a521998)
@@ -231,7 +231,7 @@
         return int.from_bytes(seq, byteorder=DenaliMessage.BYTE_ORDER, signed=True)
 
     @staticmethod
-    def create_ack_message(message: dict, passive_mode: bool=False):
+    def create_ack_message(message: dict, passive_mode: bool = True):
         """
         Negates the sequence number and replaces the original message's sequence number with the
         negated sequence number to create the ACK message.
@@ -433,9 +433,9 @@
 
 class DenaliCanMessenger:
     START_BYTE = DenaliMessage.START_BYTE
-    DIALIN_MSG_RESP_TO = 0.1  # number of seconds to wait for a response to a sent command
+    DIALIN_MSG_RESP_TO = 0.5  # number of seconds to wait for a response to a send command
 
-    def __init__(self, can_interface: str, logger: Logger, log_can=False, passive_mode=False, console_out=False):
+    def __init__(self, can_interface: str, logger: Logger, log_can=False, passive_mode=True, console_out=False):
         """
         DenaliCanMessenger constructor
 
@@ -470,16 +470,15 @@
 
         self.passive_mode = passive_mode
         self.console_out = console_out
-        self.send_packet_request_id = -1
         self.send_event = threading.Event()
         self.long_message_builders = {}
         self.long_msg_channel_id_set = set()
         self.messages = None
-        self.last_sent_message = None
         self.command_response_message = None
         self.response_channel_id = -1
         self.run = False
         self.sync_response_dictionary = {}
+        self.pending_requests = {}
 
     def start(self):
         """
@@ -521,7 +520,7 @@
 
             else:  # no new packets in receive buffer
                 # We have received nothing, let's sleep 1 msec and let's check again
-                sleep(0.001)
+                sleep(0.00025)
 
     def handle_messages(self):
         """
@@ -532,7 +531,7 @@
         while True:
 
             if not self.message_queue:
-                sleep(0.001)
+                sleep(0.00025)
             else:
                 message: dict = self.message_queue.popleft()
 
@@ -605,14 +604,13 @@
                                 msg = DenaliMessage.create_ack_message(message=complete_dialin_message,
                                                                        passive_mode=self.passive_mode)
                                 if msg is not None:
-                                    self.send(msg, 0)
+                                    self.send(msg, 0, is_ack=True)
 
                             # We first check if this is a response to a send request that is pending
-                            if dialin_msg_id == self.send_packet_request_id:
+                            if self.pending_requests and dialin_msg_id in self.pending_requests:
 
-                                self.command_response_message = complete_dialin_message
+                                self.pending_requests[dialin_msg_id] = complete_dialin_message
                                 self.send_event.set()
-                                self.send_packet_request_id = -1
 
                             # If it is not, this is a publication message and we need to call it's register function
                             elif dialin_ch_id in self.sync_response_dictionary.keys() and \
@@ -641,27 +639,34 @@
         else:
             self.sync_response_dictionary[channel_id] = {message_id: function}
 
-    def send(self, built_message: dict, time_out: float = DIALIN_MSG_RESP_TO, resend: bool = False):
+    def send(self,
+             built_message: dict,
+             time_out: float = DIALIN_MSG_RESP_TO,
+             resend: bool = False,
+             is_ack: bool = False):
         """
         Sends a denali message
 
         @param built_message: (dict) message built using DialinMessage class
         @param time_out: (float) time it will wait for a response in seconds
         @param resend: (bool) Allow resending the message when no response is received. Disabled by default
+        @param is_ack: (bool) If we're sending an ACK, False by default
         @return: (dict) The denali packet. If a timeout occurs returns None
         """
 
         msg_sent = False
+        msg_id = -1
 
         # keep trying to send message until we get a response
         while not msg_sent:
-            self.last_sent_message = built_message
 
             channel_id = DenaliMessage.get_channel_id(built_message)
 
             padded_can_message_array = built_message['message']
 
-            self.send_packet_request_id = DenaliMessage.get_message_id(built_message)
+            msg_id = DenaliMessage.get_message_id(built_message)
+            if not is_ack and msg_id not in self.pending_requests:
+                self.pending_requests[msg_id] = None
 
             # A message can be longer than 8 bytes, so we need to split it
             # into 8 bytes packets.
@@ -682,29 +687,29 @@
                     self.do_log_can(packet, style="candump", channel=self.bus.channel, send=True)
                 self.bus.send(packet, 0)  # 0.1)
 
-            # Sending
-            self.command_response_message = None
-
             # After all messages have been sent, we clear a flag
             self.send_event.clear()
 
             # Block until the timeout completes or until the threading event's flag is set in self.listener,
             # indicating a response has been received
             self.send_event.wait(time_out)
 
-            msg_sent = True
+            # if we're sending an ack, nothing left to do
+            if is_ack:
+                return None
 
             # only resend the message if resend is enabled and we haven't received a response yet
-            if resend and self.command_response_message is None:
+            if resend and self.pending_requests.get(msg_id, None) is None:
                 msg_sent = False
                 self.logger.debug("No response. Re-sending message.")
+            else:
+                msg_sent = True
 
-            # We are ready to send again.  Reset request ID appropriately
-            self.send_packet_request_id = -1
+        response = self.pending_requests.get(msg_id, None)
+        if response is not None:
+            del self.pending_requests[msg_id]
+        return response
 
-        # This value is None or it has a message depending of the listener
-        return self.command_response_message
-
     def do_log_can(self, packet: can.Message, style="candump", channel="can0", send=True):
         """
         Logs all packets sent or received by dialin in candump, or non-candump style format
Index: tests/test_calibration.py
===================================================================
diff -u -re0aac8af8cd14024b89f241bb7b92ddd9bc4956e -r6895b99c133b8d5820df5610c3b12ac55a521998
--- tests/test_calibration.py	(.../test_calibration.py)	(revision e0aac8af8cd14024b89f241bb7b92ddd9bc4956e)
+++ tests/test_calibration.py	(.../test_calibration.py)	(revision 6895b99c133b8d5820df5610c3b12ac55a521998)
@@ -155,52 +155,64 @@
 def test_dg_scheduled_runs_record():
     dg = DG(log_level="DEBUG")
     if dg.cmd_log_in_to_dg():
-        dg.cmd_ui_request_dg_version()
         dg.scheduled_runs_record.cmd_request_dg_scheduled_runs_record()
         observer = Observer("dg_scheduled_runs_record")
         dg.scheduled_runs_record.attach(observer)
         while not observer.received:
             sleep(0.2)
 
-        print(dg.dg_version)
-        print(dg.fpga_version)
-
         dg.scheduled_runs_record.cmd_set_dg_scheduled_runs_record(dg.scheduled_runs_record.dg_scheduled_runs_record)
 
 
 def test_hd_calibration_record():
     hd = HD(log_level="DEBUG")
     if hd.cmd_log_in_to_hd(resend=False):
-        # hd.ui.cmd_ui_request_hd_version()
         observer = Observer("hd_calibration_record")
         hd.calibration_record.attach(observer)
         hd.calibration_record.cmd_request_hd_calibration_record()
         while not observer.received:
             sleep(0.2)
 
-        print(hd.ui.hd_version)
-        print(hd.ui.fpga_version)
+        hd.calibration_record.cmd_set_hd_calibration_record(hd.calibration_record.hd_calibration_record)
 
-        # hd.calibration_record.cmd_set_hd_calibration_record(hd.calibration_record.hd_calibration_record)
 
-
 def test_hd_service_record():
-    pass
+    hd = HD(log_level="DEBUG")
+    if hd.cmd_log_in_to_hd(resend=False):
+        observer = Observer("hd_service_record")
+        hd.service_record.attach(observer)
+        hd.service_record.cmd_request_hd_service_record()
+        while not observer.received:
+            sleep(0.2)
 
+        hd.service_record.cmd_set_hd_service_record(hd.service_record.hd_service_record)
 
+
 def test_hd_system_record():
-    pass
+    hd = HD(log_level="DEBUG")
+    if hd.cmd_log_in_to_hd(resend=False):
+        hd.ui.cmd_ui_request_hd_version()
+        observer = Observer("hd_system_record")
+        hd.system_record.attach(observer)
+        hd.system_record.cmd_request_hd_system_record()
+        while not observer.received:
+            sleep(0.2)
 
+        print(hd.ui.hd_version)
+        print(hd.ui.fpga_version)
 
+        hd.system_record.cmd_set_hd_system_record(hd.system_record.hd_system_record)
+
+
 if __name__ == "__main__":
     # test_dg_calibration_record()
     # test_dg_service_record()
     # test_dg_system_record()
     # test_dg_scheduled_runs_record()
 
-    test_hd_calibration_record()
+    # test_hd_calibration_record()
     # test_hd_service_record()
-    # test_hd_system_record()
+    test_hd_system_record()