Index: dialin/dg/calibration_record.py
===================================================================
diff -u -rbe687b87ec7dbbb312fc9dc67fd422119e43e64c -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc
--- dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision be687b87ec7dbbb312fc9dc67fd422119e43e64c)
+++ dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
@@ -48,26 +48,20 @@
         self.current_message = 0
         self.total_messages = 0
         self.received_msg_length = 0
+        self._is_getting_cal_in_progress = False
         self.cal_data = 0
         self._raw_cal_record = []
-        self._write_fw_data_to_excel = True
-        self._is_getting_cal_in_progress = False
         self._utilities = NVOpsUtils(logger=self.logger)
-        # DG calibration_record main record
-        self.dg_calibration_record = OrderedDict()
+        # DG Calibration_record main record
+        self.dg_calibration_record = self._prepare_dg_calibration_record()
 
         if self.can_interface is not None:
 
             channel_id = DenaliChannels.dg_to_dialin_ch_id
             msg_id = MsgIds.MSG_ID_DG_SEND_CALIBRATION_RECORD.value
             self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                        self._handler_dg_calibration_sync)
-        # Prepare the calibration_record record by putting sub-dictionaries together
-        self._prepare_dg_calibration_record()
 
-        # Prepare the excel report and workspace
-        self._utilities.prepare_excel_report('DG', 'Calibration')
-
     def is_reading_record_done(self):
         """
         Handles getting the status of reading record
@@ -78,41 +72,47 @@
 
     def get_dg_calibration_record(self):
         """
-        Handles getting DG calibration data from firmware.
+        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
 
-        # If getting the calibration is in progress, do not start another process
-        if not self._is_getting_cal_in_progress:
-            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_dg_fw_calibration_record()
-
-    def _request_dg_fw_calibration_record(self):
+    def cmd_request_dg_calibration_record(self):
         """
         Handles getting DG calibration_record record from firmware.
 
-        @return: 1 if successful, zero otherwise
+        @return: True if successful, False otherwise
         """
-        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
-                                              message_id=MsgIds.MSG_ID_DG_GET_CALIBRATION_RECORD.value)
 
-        self.logger.debug('Getting DG calibration record')
+        self.logger.debug("Requesting a dg calibration record...")
 
-        received_message = self.can_interface.send(message)
+        if not self._is_getting_cal_in_progress:
+            self._is_getting_cal_in_progress = True
 
-        # 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:
+            message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
+                                                  message_id=MsgIds.MSG_ID_DG_GET_CALIBRATION_RECORD.value)
+
+            received_message = self.can_interface.send(message, time_out=5)
+
+            # 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]
+
             self.logger.debug("Timeout!!!!")
-            return False
 
-    @_publish(["current_message", "total_messages", "received_msg_length", "service_data"])
+        self.logger.debug("Request cancelled: an existing request is in progress.")
+        return False
+
     def _handler_dg_calibration_sync(self, message):
         """
         Handles published DG calibration_record record messages. DG calibration records are captured for
@@ -122,6 +122,7 @@
 
         @return: None
         """
+        self.logger.debug("DG calibration sync handler...")
         curr = struct.unpack('i', bytearray(
             message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0]
         total = struct.unpack('i', bytearray(
@@ -142,40 +143,35 @@
 
         # Continue getting calibration_record records until the all the calibration_record messages are received.
         # Concatenate the calibration_record records to each other.
-        if self.current_message <= self.total_messages:
+        if self.current_message < self.total_messages:
             self._raw_cal_record += (message['message'][self._RECORD_START_INDEX +
                                                         self._RECORD_SPECS_BYTES:end_of_data_index])
-            if self.current_message == self.total_messages:
-                # Done with getting all the calibration data.
-                self._is_getting_cal_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.dg_calibration_record,
-                                                                self._raw_cal_record,
-                                                                write_to_excel=self._write_fw_data_to_excel)
+        elif self.current_message == self.total_messages:
+            # Done with getting all the calibration data.
+            self._is_getting_cal_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.dg_calibration_record, self._raw_cal_record)
+            self._handler_received_complete_dg_calibration_record()
 
-    def set_dg_calibration_record(self):
+    @_publish(["dg_calibration_record"])
+    def _handler_received_complete_dg_calibration_record(self):
         """
+        Publishes the received calibration record
+
+        @return: None
+        """
+        self.logger.debug("Received a complete dg calibration record.")
+
+    def cmd_set_dg_calibration_record(self, dg_calibration_record: OrderedDict):
+        """
         Handles updating the DG calibration record with the newest calibration_record data of a hardware and
         sends it to FW.
 
-        @return: none
+        @return: True upon success, False otherwise
         """
-        # 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_dg_calibration_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)
 
-        # Write the excel record
-        self._utilities.write_excel_record_to_calibration_record(self.dg_calibration_record)
+        record_packets = self._utilities.prepare_record_to_send_to_fw(dg_calibration_record)
 
-        record_packets = self._utilities.prepare_record_to_send_to_fw(self.dg_calibration_record)
-
         self.logger.debug('Setting DG calibration started')
 
         # Update all the data packets with the last message count since is the number of messages that firmware
@@ -198,12 +194,17 @@
                 self.logger.debug("Timeout!!!!")
                 return False
 
+        self.logger.debug("Finished sending DG calibration record.")
+        return True
+
     def _prepare_dg_calibration_record(self):
         """
-        Handles assembling the sub dictionaries of each hardware group to make the main DG calibration record.
+        Handles assembling the sub dictionaries of each hardware group to make a DG calibration record.
 
-        @return: None
+        @return: (OrderedDict) the assembled record
         """
+        result = OrderedDict()
+
         groups_byte_size = 0
         # Call the other functions to get the dictionaries of each hardware group. All the dictionaries are
         # ordered dictionaries to maintain the order in which they are inserted. The results are a tuple, the first
@@ -219,7 +220,7 @@
             # Update the groups bytes size so far to be use to padding later
             groups_byte_size += byte_size
             # Update the calibration record
-            self.dg_calibration_record.update(record)
+            result.update(record)
 
         # Build the CRC of the main calibration_record record
         record_crc = OrderedDict({'crc': ['<H', self._DEFAULT_CRC_VALUE]})
@@ -234,17 +235,26 @@
         padding = OrderedDict({'padding': ['<B', [self._DEFAULT_CRC_VALUE] * padding_size]})
 
         # Update the dictionary with the padding and record crc dictionaries
-        self.dg_calibration_record.update(padding)
-        self.dg_calibration_record.update(record_crc)
+        result.update(padding)
+        result.update(record_crc)
+        return result
 
     def _prepare_pressure_sensors_cal_record(self):
         """
         Handles creating the calibration dictionary of the pressure sensors hardware group.
 
         @return: pressure sensors hardware group dictionary and the byte size of this hardware group
         """
-        hardware_names = ['ppi', 'ppo', 'prd', 'pdr', 'reserved_1', 'reserved_2', 'reserved_3', 'reserved_4',
-                          'reserved_5', 'reserved_6']
+        hardware_names = ['ppi',
+                          'ppo',
+                          'prd',
+                          'pdr',
+                          'reserved_1',
+                          'reserved_2',
+                          'reserved_3',
+                          'reserved_4',
+                          'reserved_5',
+                          'reserved_6']
         group_byte_size = 0
         group_name = 'pressure_sensors'
         hardware_group = OrderedDict({group_name: OrderedDict()})
Index: dialin/dg/dialysate_generator.py
===================================================================
diff -u -re8afa8d6323ede293e1fb094a461555fcf7ce0d9 -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc
--- dialin/dg/dialysate_generator.py	(.../dialysate_generator.py)	(revision e8afa8d6323ede293e1fb094a461555fcf7ce0d9)
+++ dialin/dg/dialysate_generator.py	(.../dialysate_generator.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
@@ -324,10 +324,7 @@
         Constraints:
             Must be logged into DG.
 
-        \returns response message if received, False if no response received
-
-        @return: 1 if successful, zero otherwise
-
+        @return: None
         """
 
         message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
Index: dialin/dg/scheduled_runs_record.py
===================================================================
diff -u -rdd42e4d9cfe821b0a755ccc86cc1a4a2a3dd2f37 -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc
--- dialin/dg/scheduled_runs_record.py	(.../scheduled_runs_record.py)	(revision dd42e4d9cfe821b0a755ccc86cc1a4a2a3dd2f37)
+++ dialin/dg/scheduled_runs_record.py	(.../scheduled_runs_record.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
@@ -1,12 +1,11 @@
-
 import struct
-import datetime
 import time
 import math
 from collections import OrderedDict
 from ..common.msg_defs import MsgIds, MsgFieldPositions
 from ..protocols.CAN import (DenaliMessage, DenaliChannels)
-from ..utils.base import _AbstractSubSystem, DialinEnum
+from ..utils.base import _AbstractSubSystem, _publish
+from ..utils.nv_ops_utils import NVOpsUtils
 from logging import Logger
 
 
@@ -44,8 +43,9 @@
     PAYLOAD_TOTAL_MSG_INDEX = 1
     PAYLOAD_SCHEDULED_RUNS_BYTES_INDEX = 2
 
-    # DG scheduled runs main record as an ordered dictionary
-    DG_SCHEDULED_RUNS_RECORD = OrderedDict()
+    # Delay in between each payload transfer
+    _PAYLOAD_TRANSFER_DELAY_S = 0.2
+    _DIALIN_RECORD_UPDATE_DELAY_S = 0.2
 
     def __init__(self, can_interface, logger: Logger):
         """
@@ -61,51 +61,49 @@
         self.total_messages = 0
         self.received_msg_length = 0
         self._is_getting_runs_in_progress = False
+        self._write_fw_data_to_excel = True
         self.cal_data = 0
         self.raw_scheduled_runs_record = []
+        self._utilities = NVOpsUtils(logger=self.logger)
 
+        # DG scheduled runs main record as an ordered dictionary
+        self.dg_scheduled_runs_record = self._prepare_dg_scheduled_runs_record()
+
         if self.can_interface is not None:
 
             channel_id = DenaliChannels.dg_to_dialin_ch_id
             msg_id = MsgIds.MSG_ID_DG_SEND_SCHEDULED_RUNS_RECORD.value
             self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                        self._handler_dg_scheduled_runs_record)
-        # Prepare the scheduled runs record by putting sub-dictionaries together
-        self._prepare_dg_scheduled_runs_record()
 
-    def get_dg_scheduled_runs_record(self):
+    def cmd_request_dg_scheduled_runs_record(self):
         """
         Handles getting DG scheduled runs record from firmware.
 
-        @return: None
+        @return: 1 upon success, False otherwise
         """
         if self._is_getting_runs_in_progress is not True:
             self._is_getting_runs_in_progress = True
             # Clear the list for the next call
             self.raw_scheduled_runs_record.clear()
-            # Run the firmware commands to get the system record
-            self._request_dg_fw_scheduled_runs_record()
 
-    def _request_dg_fw_scheduled_runs_record(self):
-        """
-        Handles getting DG scheduled runs record from firmware.
+            message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
+                                                  message_id=MsgIds.MSG_ID_DG_GET_SCHEDULED_RUNS_RECORD.value)
 
-        @return: None
-        """
-        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
-                                              message_id=MsgIds.MSG_ID_DG_GET_SCHEDULED_RUNS_RECORD.value)
+            self.logger.debug('Getting DG scheduled runs record')
 
-        self.logger.debug('Getting DG scheduled runs 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_dg_scheduled_runs_record(self, message):
         """
@@ -144,7 +142,17 @@
                 self._is_getting_runs_in_progress = False
                 # If all the messages have been received, call another function to process the raw data
                 self._update_dg_scheduled_record_from_fw()
+                self._handler_received_complete_dg_scheduled_runs_record()
 
+    @_publish(["dg_scheduled_runs_record"])
+    def _handler_received_complete_dg_scheduled_runs_record(self):
+        """
+        Publishes the received scheduled runs record
+
+        @return: None
+        """
+        self.logger.debug("Received a complete dg scheduled runs record.")
+
     def _update_dg_scheduled_record_from_fw(self):
         """
         Handles parsing the scheduled runs messages that were received from DG firmware.
@@ -159,38 +167,39 @@
         # DG_Calibration : {pressure_sensors : { ppi : { gain: ['<f', 12.3], offset: ['<f', 5.67]}}, ...}
         # Get the list of keys of the main dictionary (i.e. pressure_sensors, temperature_sensors, ....}
         # These keys are the list of hardware groups
-        for group in self.DG_SCHEDULED_RUNS_RECORD.keys():
+        for group in self.dg_scheduled_runs_record.keys():
             # All the hardware groups (i.e pressure sensors) are nested dictionaries, except the final CRC. So it is
             # unpacked exceptionally here. The CRC is an unsigned 16-bit (short).
             if group == 'crc':
                 # Get the data type ( it must be '<H')
-                data_type = self.DG_SCHEDULED_RUNS_RECORD[group][self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
+                data_type = self.dg_scheduled_runs_record[group][self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
                 # Check the data type of the crc
                 value_bytes = self._get_data_type_bytes(data_type)
                 # Unpack the data
                 data = struct.unpack(data_type, self.raw_scheduled_runs_record[raw_payload_temp_start_index:
                                                                     raw_payload_temp_start_index + value_bytes])[0]
-                self.DG_SCHEDULED_RUNS_RECORD[group][self.SCHEDULED_RUNS_VALUE_INDEX] = data
+                self.dg_scheduled_runs_record[group][self.SCHEDULED_RUNS_VALUE_INDEX] = data
             elif group == 'padding':
                 # Get the data type
-                data_type = self.DG_SCHEDULED_RUNS_RECORD[group][self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
+                data_type = self.dg_scheduled_runs_record[group][self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
                 # Check the data type of the padding values (they are unsigned chars)
                 value_bytes = self._get_data_type_bytes(data_type)
                 # Get the length of the padding list
-                padding_length = len(self.DG_SCHEDULED_RUNS_RECORD[group][self.SCHEDULED_RUNS_VALUE_INDEX])
+                padding_length = len(self.dg_scheduled_runs_record[group][self.SCHEDULED_RUNS_VALUE_INDEX])
                 # Add the length of the padding bytes to the payload start address
                 raw_payload_temp_start_index += padding_length * value_bytes
             # The rest of the groups are hardware which are layered dictionaries
             else:
                 # If the value is not a CRC, it is nested dictionary of different hardware groups
                 # Loop through the values of each key to get the list of the hardware in a hardware group (i.e
                 # pressure_sensors have ppi, ppo, ...)
-                for hardware_group in self.DG_SCHEDULED_RUNS_RECORD[group].keys():
-                    # Each hardware has a set of calibration_record values (i.e ppi: {gain: ['<f',  12.3]}. Loop though those
-                    for hardware in self.DG_SCHEDULED_RUNS_RECORD[group][hardware_group]:
+                for hardware_group in self.dg_scheduled_runs_record[group].keys():
+                    # Each hardware has a set of calibration_record values (i.e ppi: {gain: ['<f',  12.3]}.
+                    # Loop though those
+                    for hardware in self.dg_scheduled_runs_record[group][hardware_group]:
                         # The values of the dictionary of each hardware is a list of its data type as well as its value
                         # which the first index is data type
-                        data_type = self.DG_SCHEDULED_RUNS_RECORD[group][hardware_group][hardware][
+                        data_type = self.dg_scheduled_runs_record[group][hardware_group][hardware][
                             self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
                         value_bytes = self._get_data_type_bytes(data_type)
                         # Unpack the values to written to the dictionary
@@ -199,15 +208,16 @@
                                                                             value_bytes])[0]
                         # Update the index of the raw payload for the next read
                         raw_payload_temp_start_index += value_bytes
-                        self.DG_SCHEDULED_RUNS_RECORD[group][hardware_group][hardware]\
+                        self.dg_scheduled_runs_record[group][hardware_group][hardware]\
                                                      [self.SCHEDULED_RUNS_VALUE_INDEX] = data
 
     def _prepare_dg_scheduled_runs_record(self):
         """
         Handles assembling the sub dictionaries of each hardware group to make the main DG system record.
 
-        @return: None
+        @return: (OrderedDict) the assembled dg scheduled runs record
         """
+
         scheduled_runs = self._prepare_scheduled_runs()
 
         # Build the CRC of the main record
@@ -227,7 +237,8 @@
         # Create the padding dictionary as list of unsigned char. All the elements are 0.
         padding = OrderedDict({'padding': ['<B', [self.DEFAULT_SCHEDULED_RUNS_PADDING_VALUE] * padding_size]})
 
-        self.DG_SCHEDULED_RUNS_RECORD = {**scheduled_runs[0], **padding, **record_crc}
+        result = OrderedDict({**scheduled_runs[0], **padding, **record_crc})
+        return result
 
     def _prepare_scheduled_runs(self):
         """
@@ -291,131 +302,23 @@
 
         return number_of_bytes
 
-    def set_dg_scheduled_runs_record(self):
+    def cmd_set_dg_scheduled_runs_record(self, dg_scheduled_runs_record: OrderedDict):
         """
         Handles updating the DG system record with the newest calibration_record data of a hardware and sends it to FW.
 
-        @return: none
+        @return: True upon success, False otherwise
         """
 
-        # This list contains different data packet lists
-        # i.e. [[message 1, payload], [message 2, payload], ...]
-        scheduled_runs_record_packets = []
-        current_payload_length = 0
-        current_message_count = 1
-        temp_buffer = [0, 0, 0]
+        record_packets = self._utilities.prepare_record_to_send_to_fw(dg_scheduled_runs_record)
 
-        # Loop through the DG calibration_record dictionary
-        for group in self.DG_SCHEDULED_RUNS_RECORD.keys():
+        self.logger.debug('Setting DG scheduled runs started')
 
-            # NOTE: crc and padding are checked separately since they do not have layered dictionaries
-            # If the group is the final CRC of the dictionary
-            if group == 'crc':
-                data_type = self.DG_SCHEDULED_RUNS_RECORD[group][self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
-
-                current_payload_length += self._get_data_type_bytes(data_type)
-                temp_buffer[self.CURRENT_MESSAGE_NUM_INDEX] = struct.pack('<i', current_message_count)
-                temp_buffer[self.PAYLOAD_SCHEDULED_RUNS_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-                temp_buffer.append(struct.pack(data_type, self.DG_SCHEDULED_RUNS_RECORD[group]
-                                                                                    [self.SCHEDULED_RUNS_VALUE_INDEX]))
-                scheduled_runs_record_packets.append(temp_buffer)
-
-            # If the group is padding, and the length of padding is not 0
-            elif group == 'padding':
-                if len(self.DG_SCHEDULED_RUNS_RECORD[group][self.SCHEDULED_RUNS_VALUE_INDEX]) != 0:
-                    # Get the data type and calculate the number of bytes
-                    data_type = self.DG_SCHEDULED_RUNS_RECORD[group][self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
-                    data_type_bytes = self._get_data_type_bytes(data_type)
-                    # If there are padding zeros, they are in a list. loop through the list and add them to temp buffer
-                    for pad in self.DG_SCHEDULED_RUNS_RECORD[group][self.SCHEDULED_RUNS_VALUE_INDEX]:
-                        if self.TARGET_BYTES_TO_SEND_TO_FW - current_payload_length > self.MIN_PAYLOAD_BYTES_SPACE:
-                            current_payload_length += data_type_bytes
-                            temp_buffer[self.PAYLOAD_TOTAL_MSG_INDEX] = struct.pack('<i', 0)
-                            temp_buffer.append(struct.pack(data_type, pad))
-                        else:
-                            temp_buffer[self.PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
-                            temp_buffer[self.PAYLOAD_SCHEDULED_RUNS_BYTES_INDEX] = \
-                                                                            struct.pack('<i', current_payload_length)
-                            scheduled_runs_record_packets.append(temp_buffer)
-
-                            current_message_count += 1
-                            current_payload_length = data_type_bytes
-                            temp_buffer = [struct.pack('<i', current_message_count), struct.pack('<i', 0),
-                                           struct.pack('<i', current_payload_length),
-                                           struct.pack(data_type, pad)]
-            else:
-                # Dictionaries of the hardware. Loop through each hardware group and through each hardware
-                # (i.e. pressure_sensors : ppi, ppo, ...)
-                for hardware_group in self.DG_SCHEDULED_RUNS_RECORD[group].keys():
-                    for hardware in self.DG_SCHEDULED_RUNS_RECORD[group][hardware_group]:
-                        # Get the data type and calculate the number of bytes
-                        data_type = self.DG_SCHEDULED_RUNS_RECORD[group][hardware_group][hardware] \
-                            [self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
-                        data_type_bytes = self._get_data_type_bytes(data_type)
-                        # If minimum number of bytes space is still available in current temp buffer, continue inserting
-                        # data into the buffer.
-                        if self.TARGET_BYTES_TO_SEND_TO_FW - current_payload_length > self.MIN_PAYLOAD_BYTES_SPACE:
-
-                            current_payload_length += data_type_bytes
-                            # Insert a 4-byte 0 to the index of the total messages. This is a place holder and it will
-                            # be updated with the right value later.
-                            temp_buffer[self.PAYLOAD_TOTAL_MSG_INDEX] = struct.pack('<i', 0)
-                            # Append the current value of the dictionary into the temp buffer. There is still space left
-                            temp_buffer.append(struct.pack(data_type, self.DG_SCHEDULED_RUNS_RECORD[group][hardware_group]
-                                                                        [hardware][self.SCHEDULED_RUNS_VALUE_INDEX]))
-                        else:
-                            # There is not enough space left in this temp buffer. Update the current message count and
-                            # the total number of bytes that were packed in this data packet.
-                            temp_buffer[self.PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
-                            temp_buffer[self.PAYLOAD_SCHEDULED_RUNS_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-                            # Append the temp buffer list into the main list to be process later
-                            scheduled_runs_record_packets.append(temp_buffer)
-                            # Increment the current message count as a new temp buffer is created for the next data
-                            # packet. Update the current payload length with the latest addition to the new temp buffer.
-                            current_message_count += 1
-                            current_payload_length = data_type_bytes
-                            # Create a new temp buffer and add the current message count, total length of payload so far
-                            # and the data that there was not enough space in the previous data packet.
-                            temp_buffer = [struct.pack('<i', current_message_count), struct.pack('<i', 0),
-                                           struct.pack('<i', current_payload_length),
-                                           struct.pack(data_type, self.DG_SCHEDULED_RUNS_RECORD[group][hardware_group]
-                                           [hardware][self.SCHEDULED_RUNS_VALUE_INDEX])]
-
-        # Creating a byte array variable and add all the data packets
-        # to one to calculate the final CRC
-        data = b''
-        for cal in scheduled_runs_record_packets:
-            # If the data packet is the last one in the list, ignore the last element of the
-            # packet since it is the final CRC of the entire dictionary. The final CRC itself
-            # is not included in the CRC calculations.
-            # The actual calibration_record data is started from the 3rd element of the data packet.
-            # The first 3 are current message, total messages, and the payload length of the current packet.
-            if scheduled_runs_record_packets.index(cal) == len(scheduled_runs_record_packets) - 1:
-                data += b''.join(cal[self.SCHEDULED_RECORDS_SPECS_BYTE_ARRAY:-1])
-            else:
-                # Get all the elements including the last one
-                data += b''.join(cal[self.SCHEDULED_RECORDS_SPECS_BYTE_ARRAY:])
-
-        # Calculate the 16-bit crc.
-        crc = crc_16(data)
-        # Convert the crc into a 2-byte value
-        record_crc = struct.pack('<H', crc)
-        # Insert the CRC into the last element of the last data packet
-        scheduled_runs_record_packets[-1][-1] = record_crc
-
-        print('CRC: ', hex(crc)) #TODO remove
-
-        self.logger.debug('DG scheduled runs record update started')
-
         # Update all the data packets with the last message count since is the number of messages that firmware
         # should receive
-        for packet in scheduled_runs_record_packets:
+        for packet in record_packets:
             # Sleep to let the firmware receive and process the data
-            time.sleep(0.2)
-            # Add the number of total messages to each data packet. This was delayed
-            # until now since it was not known how many message will it take to pack all the
-            # calibration_record data.
-            packet[1] = struct.pack('<i', current_message_count)
+            time.sleep(self._PAYLOAD_TRANSFER_DELAY_S)
+
             # Convert the list packet to a bytearray
             payload = b''.join(packet)
 
@@ -428,4 +331,7 @@
             # If there is no content...
             if received_message is None:
                 self.logger.debug("Timeout!!!!")
-                return False
\ No newline at end of file
+                return False
+
+        self.logger.debug("Finished sending DG scheduled runs record.")
+        return True
Index: dialin/dg/service_record.py
===================================================================
diff -u -rbe687b87ec7dbbb312fc9dc67fd422119e43e64c -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc
--- dialin/dg/service_record.py	(.../service_record.py)	(revision be687b87ec7dbbb312fc9dc67fd422119e43e64c)
+++ dialin/dg/service_record.py	(.../service_record.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
@@ -30,7 +30,6 @@
     _RTC_RAM_MAX_BYTES_TO_WRITE = 64
 
     _PAYLOAD_TRANSFER_DELAY_S = 0.2
-    _DIALIN_RECORD_UPDATE_DELAY_S = 0.2
 
     def __init__(self, can_interface, logger: Logger):
         """
@@ -47,66 +46,46 @@
         self.received_msg_length = 0
         self.service_data = 0
         self._is_getting_service_in_progress = False
-        self._write_fw_data_to_excel = True
         self._raw_service_record = []
-        self._utilities = NVOpsUtils()
-        # Service main record
-        self.dg_service_record = OrderedDict()
+        self._utilities = NVOpsUtils(logger=self.logger)
+        self.dg_service_record = self._prepare_dg_service_record()
 
         if self.can_interface is not None:
             channel_id = DenaliChannels.dg_to_dialin_ch_id
             msg_id = MsgIds.MSG_ID_DG_SEND_SERVICE_RECORD.value
             self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                        self._handler_dg_service_sync)
-        # Prepare the service record by putting sub-dictionaries together
-        self._prepare_dg_service_record()
 
-        # Prepare the excel report and workspace
-        self._utilities.prepare_excel_report('DG', 'Service')
-
-    def get_dg_service_record(self):
+    def cmd_request_dg_service_record(self):
         """
         Handles getting DG 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_dg_fw_service_record()
+            message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
+                                                  message_id=MsgIds.MSG_ID_DG_GET_SERVICE_RECORD.value)
 
-    def is_reading_record_done(self):
-        """
-        Handles getting the status of reading record
+            self.logger.debug('Getting DG service record')
 
-        @return: True if reading is done otherwise False
-        """
-        return self._utilities.get_writing_to_excel_status()
+            received_message = self.can_interface.send(message)
 
-    def _request_dg_fw_service_record(self):
-        """
-        Handles getting DG service record from firmware.
+            # If there is content...
+            if received_message is not None:
+                self.logger.debug("Received FW ACK after requesting DG service record.")
+                # response payload is OK or not OK
+                return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
+            else:
+                self.logger.debug("Timeout!!!!")
+                return False
 
-        @return: None
-        """
-        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
-                                              message_id=MsgIds.MSG_ID_DG_GET_SERVICE_RECORD.value)
+        self.logger.debug("Request cancelled: an existing request is in progress.")
+        return False
 
-        self.logger.debug('Getting DG service record')
-
-        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_dg_service_sync(self, message):
         """
         Handles published DG service record messages. DG service records are captured for
@@ -143,29 +122,26 @@
                 # 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.dg_service_record, self._raw_service_record,
-                                                                write_to_excel=self._write_fw_data_to_excel)
+                self._utilities.process_received_record_from_fw(self.dg_service_record, self._raw_service_record)
+                self._handler_received_complete_dg_service_record()
 
-    def set_dg_service_record(self):
+    @_publish(["dg_service_record"])
+    def _handler_received_complete_dg_service_record(self):
         """
+        Publishes the received service record
+
+        @return: None
+        """
+        self.logger.debug("Received a complete dg service record.")
+
+    def cmd_set_dg_service_record(self, dg_service_record: OrderedDict):
+        """
         Handles updating the DG service record and sends it to FW.
 
         @return: True upon success, False otherwise
         """
-        # 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_dg_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)
+        record_packets = self._utilities.prepare_record_to_send_to_fw(dg_service_record)
 
-        self._utilities.write_excel_record_to_calibration_record(self.dg_service_record)
-        record_packets = self._utilities.prepare_record_to_send_to_fw(self.dg_service_record)
-
         self.logger.debug('Setting DG service record')
 
         # Update all the data packets with the last message count since is the number of messages that firmware
@@ -188,14 +164,17 @@
                 self.logger.debug("Timeout!!!!")
                 return False
 
+        self.logger.debug("Finished sending DG service record.")
         return True
 
     def _prepare_dg_service_record(self):
         """
-        Handles assembling the sub dictionaries of each group to make the main HD service record.
+        Handles assembling the sub dictionaries of each group to make a blank dg service record.
 
-        @return: None
+        @return: (OrderedDict) the assembled dg service record
         """
+        record = OrderedDict()
+
         groups_byte_size = 0
         # create a list of the functions of the sub dictionaries
         functions = [self._prepare_service_record()]
@@ -204,7 +183,7 @@
             # Update the groups bytes size so far to be use to padding later
             groups_byte_size += function[1]
             # Update the calibration record
-            self.dg_service_record.update(function[0])
+            record.update(function[0])
 
         # Build the CRC of the main calibration_record record
         record_crc = OrderedDict({'crc': ['<H', self._DEFAULT_CRC_VALUE]})
@@ -219,8 +198,9 @@
         padding = OrderedDict({'padding': ['<B', [self._DEFAULT_CRC_VALUE] * padding_size]})
 
         # Update the dictionary with the padding and record crc dictionaries
-        self.dg_service_record.update(padding)
-        self.dg_service_record.update(record_crc)
+        record.update(padding)
+        record.update(record_crc)
+        return record
 
     def _prepare_service_record(self):
         """
Index: dialin/dg/system_record.py
===================================================================
diff -u -rbe687b87ec7dbbb312fc9dc67fd422119e43e64c -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc
--- dialin/dg/system_record.py	(.../system_record.py)	(revision be687b87ec7dbbb312fc9dc67fd422119e43e64c)
+++ dialin/dg/system_record.py	(.../system_record.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
@@ -51,68 +51,54 @@
         self.total_messages = 0
         self.received_msg_length = 0
         self._is_getting_sys_in_progress = False
-        self._write_fw_data_to_excel = True
         self.sys_data = 0
         self._raw_system_record = []
-        self._utilities = NVOpsUtils()
+        self._utilities = NVOpsUtils(logger=self.logger)
         # System main record
-        self.dg_system_record = OrderedDict()
+        self.dg_system_record = self._prepare_dg_system_record()
 
         if self.can_interface is not None:
             channel_id = DenaliChannels.dg_to_dialin_ch_id
             msg_id = MsgIds.MSG_ID_DG_SEND_SYSTEM_RECORD.value
             self.can_interface.register_receiving_publication_function(channel_id, msg_id, self._handler_dg_system_sync)
 
-        # Prepare the system record by putting sub-dictionaries together
-        self._prepare_dg_system_record()
-
-        # Prepare the excel report and workspace
-        self._utilities.prepare_excel_report('DG', 'System')
-
     def get_dg_system_record(self):
         """
         Handles getting HD calibration_record data from firmware.
 
         @return: None
         """
+
+    def cmd_request_dg_system_record(self):
+        """
+        Handles getting DG system record from firmware.
+
+        @return: 1 upon success, False otherwise
+        """
         if self._is_getting_sys_in_progress is not True:
             # Receiving the system record is in progress
             self._is_getting_sys_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_dg_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_dg_ch_id,
+                                                  message_id=MsgIds.MSG_ID_DG_GET_SYSTEM_RECORD.value)
 
-        @return: True if reading is done otherwise False
-        """
-        return self._utilities.get_writing_to_excel_status()
+            self.logger.debug('Getting DG system record')
 
-    def _request_dg_fw_system_record(self):
-        """
-        Handles getting DG system record from firmware.
+            received_message = self.can_interface.send(message)
 
-        @return: None
-        """
-        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
-                                              message_id=MsgIds.MSG_ID_DG_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 DG 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_dg_system_sync(self, message):
         """
         Handles published DG system record messages. HD system records are captured for
@@ -149,29 +135,26 @@
                 # Done with receiving the messages
                 self._is_getting_sys_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.dg_system_record, self._raw_system_record,
-                                                                write_to_excel=self._write_fw_data_to_excel)
+                self._utilities.process_received_record_from_fw(self.dg_system_record, self._raw_system_record)
+                self._handler_received_complete_dg_system_record()
 
-    def set_dg_system_record(self):
+    @_publish(["dg_system_record"])
+    def _handler_received_complete_dg_system_record(self):
         """
-        Handles updating the DG system and sends it to FW.
+        Publishes the received system 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_dg_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)
+        self.logger.debug("Received a complete dg system record.")
 
-        self._utilities.write_excel_record_to_calibration_record(self.dg_system_record)
-        record_packets = self._utilities.prepare_record_to_send_to_fw(self.dg_system_record)
+    def cmd_set_dg_system_record(self, dg_system_record: OrderedDict):
+        """
+        Handles updating the DG system and sends it to FW.
 
+        @return: True upon success, False otherwise
+        """
+        record_packets = self._utilities.prepare_record_to_send_to_fw(dg_system_record)
+
         self.logger.debug('Setting DG system record')
 
         # Update all the data packets with the last message count since is the number of messages that firmware
@@ -194,12 +177,17 @@
                 self.logger.debug("Timeout!!!!")
                 return False
 
+        self.logger.debug("Finished sending DG service record.")
+        return True
+
     def _prepare_dg_system_record(self):
         """
         Handles assembling the sub dictionaries of each group to make the main DG system record.
 
-        @return: None
+        @return: (OrderedDict) the assembled dg system record
         """
+        result = OrderedDict()
+
         groups_byte_size = 0
         # create a list of the functions of the sub dictionaries
         functions = [self._prepare_system_record()]
@@ -208,7 +196,7 @@
             # Update the groups bytes size so far to be use to padding later
             groups_byte_size += function[1]
             # Update the calibration record
-            self.dg_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]})
@@ -223,9 +211,11 @@
         padding = OrderedDict({'padding': ['<B', [self._DEFAULT_CRC_VALUE] * padding_size]})
 
         # Update the dictionary with the padding and record crc dictionaries
-        self.dg_system_record.update(padding)
-        self.dg_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/hd/calibration_record.py
===================================================================
diff -u -rbe687b87ec7dbbb312fc9dc67fd422119e43e64c -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc
--- dialin/hd/calibration_record.py	(.../calibration_record.py)	(revision be687b87ec7dbbb312fc9dc67fd422119e43e64c)
+++ dialin/hd/calibration_record.py	(.../calibration_record.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
@@ -50,8 +50,8 @@
         self._write_fw_data_to_excel = True
         self.cal_data = 0
         self._raw_cal_record = []
-        self._utilities = NVOpsUtils()
-        # Calibration main record
+        self._utilities = NVOpsUtils(logger=self.logger)
+        # HD Calibration main record
         self.hd_calibration_record = OrderedDict()
 
         if self.can_interface is not None:
@@ -60,11 +60,19 @@
             msg_id = MsgIds.MSG_ID_HD_SEND_CALIBRATION_RECORD.value
             self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                        self._handler_hd_calibration_sync)
+
         # Prepare the calibration_record record by putting sub-dictionaries together
-        self._prepare_hd_calibration_record()
+        self._setup_base_calibration_record()
 
+    def init_excel_report(self, directory: str):
+        """
+        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', 'Calibration')
+        self._utilities.prepare_excel_report('HD', 'Calibration', directory)
 
     def is_reading_record_done(self):
         """
@@ -192,7 +200,7 @@
                 self.logger.debug("Timeout!!!!")
                 return False
 
-    def _prepare_hd_calibration_record(self):
+    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/hemodialysis_device.py
===================================================================
diff -u -r045eb4c25850caf5b77a3fabcb0e6eefa7407380 -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc
--- dialin/hd/hemodialysis_device.py	(.../hemodialysis_device.py)	(revision 045eb4c25850caf5b77a3fabcb0e6eefa7407380)
+++ dialin/hd/hemodialysis_device.py	(.../hemodialysis_device.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
@@ -176,7 +176,6 @@
         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("requesting HD calibration data.")
 
         # Send message
@@ -281,10 +280,7 @@
         Constraints:
             Must be logged into HD.
 
-        \returns response message if received, False if no response received
-
-        @return: 1 if successful, zero otherwise
-
+        @return: None
         """
 
         message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
Index: dialin/hd/service_record.py
===================================================================
diff -u -rbe687b87ec7dbbb312fc9dc67fd422119e43e64c -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc
--- dialin/hd/service_record.py	(.../service_record.py)	(revision be687b87ec7dbbb312fc9dc67fd422119e43e64c)
+++ dialin/hd/service_record.py	(.../service_record.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
@@ -51,7 +51,7 @@
         self._write_fw_data_to_excel = True
         self.service_data = 0
         self._raw_service_record = []
-        self._utilities = NVOpsUtils()
+        self._utilities = NVOpsUtils(logger=self.logger)
         # Service main record
         self.hd_service_record = OrderedDict()
 
@@ -63,8 +63,15 @@
         # Prepare the service record by putting sub-dictionaries together
         self._prepare_hd_service_record()
 
+    def init_excel_report(self, directory: str):
+        """
+        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')
+        self._utilities.prepare_excel_report('HD', 'Service', directory)
 
     def is_reading_record_done(self):
         """
Index: dialin/hd/syringe_pump.py
===================================================================
diff -u -r62df70b019fa433c8f345d2e1699e6c8f204af2c -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc
--- dialin/hd/syringe_pump.py	(.../syringe_pump.py)	(revision 62df70b019fa433c8f345d2e1699e6c8f204af2c)
+++ dialin/hd/syringe_pump.py	(.../syringe_pump.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
@@ -23,6 +23,7 @@
 from ..common.hd_defs import HeparinStates, SyringePumpStates, SyringePumpOperations
 from logging import Logger
 
+
 class HDSyringePump(_AbstractSubSystem):
     """
     HDSyringePump
@@ -324,7 +325,7 @@
         """
 
         rst = integer_to_bytearray(reset)
-        rat = integer_to_bytearray(rate)
+        rat = float_to_bytearray(rate)
         payload = rst + rat
 
         message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
@@ -400,7 +401,7 @@
         """
 
         rst = integer_to_bytearray(reset)
-        vol = integer_to_bytearray(volts)
+        vol = float_to_bytearray(volts)
         payload = rst + vol
 
         message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
@@ -438,7 +439,7 @@
         """
 
         rst = integer_to_bytearray(reset)
-        vol = integer_to_bytearray(volts)
+        vol = float_to_bytearray(volts)
         payload = rst + vol
 
         message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
@@ -476,7 +477,7 @@
         """
 
         rst = integer_to_bytearray(reset)
-        vol = integer_to_bytearray(volume)
+        vol = float_to_bytearray(volume)
         payload = rst + vol
 
         message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
Index: dialin/hd/system_record.py
===================================================================
diff -u -rbe687b87ec7dbbb312fc9dc67fd422119e43e64c -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc
--- dialin/hd/system_record.py	(.../system_record.py)	(revision be687b87ec7dbbb312fc9dc67fd422119e43e64c)
+++ dialin/hd/system_record.py	(.../system_record.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
@@ -63,11 +63,19 @@
             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):
+        """
+        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')
+        self._utilities.prepare_excel_report('HD', 'System', directory)
 
     def get_hd_system_record(self):
         """
Index: dialin/protocols/CAN.py
===================================================================
diff -u -r82e32ae00355b2245a2660569935de152a883799 -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc
--- dialin/protocols/CAN.py	(.../CAN.py)	(revision 82e32ae00355b2245a2660569935de152a883799)
+++ dialin/protocols/CAN.py	(.../CAN.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
@@ -15,6 +15,8 @@
 ############################################################################
 
 import threading
+from collections import deque
+
 import can
 import math
 from time import sleep
@@ -445,14 +447,16 @@
 
         self.logger = logger
         self.log_can = log_can
+        self.message_queue = deque()
 
         # try to setup can bus and exit if the can bus has not ben setup to use.
         try:
             self.bus = can.interfaces.socketcan.SocketcanBus(channel=can_interface)
             if self.bus is not None:
-                self.serial_listener_thread = threading.Thread(target=self.listener, daemon=True)
+                self.canbus_thread = threading.Thread(target=self.listener, daemon=True)
+                self.message_queue_thread = threading.Thread(target=self.handle_messages, daemon=True)
             else:
-                self.serial_listener_thread = None
+                self.canbus_thread = None
                 s = "Can connection is not valid"
                 self.logger.debug(s)
                 sys.exit(s)
@@ -488,8 +492,9 @@
             return
         else:
             self.run = True
-            if self.serial_listener_thread is not None:
-                self.serial_listener_thread.start()
+            if self.canbus_thread is not None:
+                self.canbus_thread.start()
+                self.message_queue_thread.start()
                 self.logger.info("Can listener has started.")
             else:
                 self.logger.error("Cannot start listener...")
@@ -512,7 +517,25 @@
             message = self.listener_buffer.get_message(0.0)
 
             if message is not None:
+                self.message_queue.append(message)
 
+            else:  # no new packets in receive buffer
+                # We have received nothing, let's sleep 1 msec and let's check again
+                sleep(0.001)
+
+    def handle_messages(self):
+        """
+        Handles messages added to the dialin canbus message queue
+        @return: None
+        """
+
+        while True:
+
+            if len(self.message_queue) == 0:
+                sleep(0.001)
+            else:
+                message: dict = self.message_queue.popleft()
+
                 if message.dlc == DenaliMessage.PACKET_LENGTH:
                     # We have received a legit can message of 8 bytes
                     can_data = [b for b in message.data]
@@ -600,10 +623,6 @@
                         # Done with this message, let's get the next one
                         self.messages = None
 
-            else:  # no new packets in receive buffer
-                # We have received nothing, let's sleep 1 msec and let's check again
-                sleep(0.001)
-
     def register_receiving_publication_function(self, channel_id, message_id, function):
         """
         Assign a function with packet parameter to an sync request id, e.g.,
Index: dialin/utils/nv_ops_utils.py
===================================================================
diff -u -rbe687b87ec7dbbb312fc9dc67fd422119e43e64c -r04d9678a26c46fe1567d9e8eecd80414a94ee4bc
--- dialin/utils/nv_ops_utils.py	(.../nv_ops_utils.py)	(revision be687b87ec7dbbb312fc9dc67fd422119e43e64c)
+++ dialin/utils/nv_ops_utils.py	(.../nv_ops_utils.py)	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
@@ -2,6 +2,7 @@
 import time
 from logging import Logger
 from typing import List
+from collections import OrderedDict
 
 from .excel_ops import *
 
@@ -88,22 +89,25 @@
         # of the group.
         self._temp_groups_data_to_calculate_crc = []
 
-    def prepare_excel_report(self, firmware_stack, record_name):
+    def prepare_excel_report(self, firmware_stack: str, record_name: str, directory: str):
         """
         Publicly accessible function to prepare the excel report
 
-        @param firmware_stack: firmware stack name such as HD or DG
-        @param record_name: record type to check such as calibration, system, ...
-
+        @param firmware_stack: (str) firmware stack name (e.g. "HD" or "DG")
+        @param record_name: (str) record type to check such as calibration, system, ...
+        @param directory: (str) the directory in which to write the excel doc
         @return none
         """
 
         path = ''
         is_report_found = False
-        # Create the workspace name
-        workspace_name = str(firmware_stack) + '_NV_Records'
 
-        self.create_workspace(workspace_name)
+        if not os.path.isdir(directory):
+            # Create the directory and go to it
+            os.mkdir(directory)
+
+        self._workspace_dir = directory
+
         self._record_name = record_name
         self._firmware_stack = firmware_stack
 
@@ -177,6 +181,7 @@
 
                 row += 1
 
+
             save_report(self._excel_workbook, self._workspace_dir, self._firmware_stack)
             # Signal reading is done
             self._is_writing_to_excel_done = True
@@ -185,7 +190,7 @@
 
     def write_excel_record_to_calibration_record(self, calibration_record: dict):
         """
-        Publicly accessible function to write excel record to a calibration record
+        Writes an excel record to a calibration record
 
         @param calibration_record: (dict) the calibration record to write
         @return True if reading to firmware records to excel is done otherwise False
@@ -274,28 +279,6 @@
 
         return self._is_read_done
 
-    def create_workspace(self, dir_name):
-        """
-        Publicly accessible function to get create a workspace for the script that is running.
-
-        @param dir_name: Name of the workspace directory
-
-        @return none
-        """
-        # Get the root directory of the current script
-        scripts_root_dir = os.path.dirname(os.path.dirname(__file__))
-        # Get the root directory of the entire scripts folder. The workspace that holds the
-        # code review reports and clones other scripts and repositories must be outside of the scripts
-        root_dir = os.path.dirname(os.path.dirname(scripts_root_dir))
-        # Create the address of the workspace
-        self._workspace_dir = os.path.join(root_dir, dir_name)
-        # If the path does not exist, make it, otherwise, change to that directory
-        if not os.path.isdir(self._workspace_dir):
-            # Create the directory and go to it
-            os.mkdir(self._workspace_dir)
-        # TODO: Fix this
-        os.chdir(self._workspace_dir)
-
     @staticmethod
     def get_current_time_in_epoch():
         """
@@ -325,13 +308,12 @@
         time_struct = time.strptime(data_time, '%Y-%m-%d %H:%M:%S')
         return int(time.mktime(time_struct))
 
-    def process_received_record_from_fw(self, cal_record: dict, fw_raw_records_bytes: List[int], write_to_excel: bool = True):
+    def process_received_record_from_fw(self, cal_record: dict, fw_raw_records_bytes: List[int]):
         """
         Handles processing the received record from firmware
 
         @param cal_record: (dict) calibration record from firmware
         @param fw_raw_records_bytes: (List[int]) list of the firmware record from firmware in bytes
-        @param write_to_excel: (bool) flag to whether write the latest data to the excel document (default is True)
 
         @return: none
         """
@@ -346,7 +328,7 @@
             # These keys are the list of hardware groups
             for group in cal_record.keys():
                 # All the hardware groups (i.e pressure sensors) are nested dictionaries, except the final CRC. So it is
-                # unpacked exceptionally here. The CRC is an unsigned 16-bit (short).
+                # unpacked here. The CRC is an unsigned 16-bit (short).
                 if group == 'crc':
                     # Get the data type ( it must be '<H')
                     data_type = cal_record[group][self._DATA_TYPE_INDEX]
@@ -386,62 +368,68 @@
                             cal_record = values[0]
                             raw_payload_temp_start_index = values[1]
 
-            if write_to_excel:
-                # Write the received data into excel
-                self.write_fw_record_to_excel(cal_record)
-            else:
-                self._is_read_done = True
+            self._is_read_done = True
         except Exception as e:
             self.logger.error("Failed to process received record from fw: {0}".format(e))
 
-    def _process_fw_record(self, calibration_record: dict, fw_raw_records_bytes, group, key, read_start_index, inner_key=None):
+    def _process_fw_record(self,
+                           calibration_record: dict,
+                           fw_raw_records_bytes: bytearray,
+                           group: str,
+                           key: str,
+                           read_start_index: int,
+                           inner_key=None):
         """
         Handles processing the received record from firmware
 
-        @param calibration_record: dictionary that is being updated from firmware
-        @param fw_raw_records_bytes: list of the firmware record from firmware in bytes
-        @param group: record group (i.e CRC, padding)
-        @param key: key of the dialin record dictionary
-        @param read_start_index: index to read the next set of byte(s) from fw raw records
-        @param inner_key: the key to an inner dictionary that is the value of the provided key (i.e. pressure: {ppi :
+        @param calibration_record: (dict) that is being updated from firmware
+        @param fw_raw_records_bytes: (bytearray) of the firmware record from firmware in bytes
+        @param group: (str) record group (i.e CRC, padding)
+        @param key: (str) key of the calibration record dictionary
+        @param read_start_index: (int) index to read the next set of byte(s) from fw raw records
+        @param inner_key: (str) the key to an inner dictionary that is the value of the provided key (i.e. pressure: {ppi :
         [0,1]})
 
         @return: calibration record dictionary that is updated and read start index as a tuple
         """
-        # The values of the dictionary of each hardware is a list of its data type as well as its value
-        # which the first index is data type
-        data = ''
-        if inner_key is None:
-            data_type = calibration_record[group][key][self._DATA_TYPE_INDEX]
-            current_value = calibration_record[group][key][self._DATA_VALUE_INDEX]
-        else:
-            data_type = calibration_record[group][key][inner_key][self._DATA_TYPE_INDEX]
-            current_value = calibration_record[group][key][inner_key][self._DATA_VALUE_INDEX]
+        try:
+            # The values of the dictionary of each hardware is a list of its data type as well as its value
+            # which the first index is data type
+            data = ''
+            if inner_key is None:
+                data_type = calibration_record[group][key][self._DATA_TYPE_INDEX]
+                current_value = calibration_record[group][key][self._DATA_VALUE_INDEX]
+            else:
+                data_type = calibration_record[group][key][inner_key][self._DATA_TYPE_INDEX]
+                current_value = calibration_record[group][key][inner_key][self._DATA_VALUE_INDEX]
 
-        value_bytes = self.get_data_type_bytes(data_type)
+            value_bytes = self.get_data_type_bytes(data_type)
 
-        if data_type == '<c':
-            for ch in current_value:
+            if data_type == '<c':
+                for ch in current_value:
+                    # Unpack the values to be written to the dictionary
+                    raw = struct.unpack(data_type, fw_raw_records_bytes[read_start_index:read_start_index + value_bytes])[0]
+                    # Check if the the values is a character first, otherwise it can be received as a byte that was
+                    # not a character from firmware
+                    try:
+                        data += raw.decode("utf-8", errors="ignore")
+                    except UnicodeDecodeError:
+                        data += 'X'
+                    read_start_index += value_bytes
+            else:
                 # Unpack the values to be written to the dictionary
-                raw = struct.unpack(data_type, fw_raw_records_bytes[read_start_index:read_start_index + value_bytes])[0]
-                # Check if the the values is a character first, otherwise it can be received as a byte that was not a
-                # character from firmware
-                try:
-                    data += raw.decode("utf-8", errors="ignore")
-                except UnicodeDecodeError:
-                    data += 'X'
+                data = struct.unpack(data_type, fw_raw_records_bytes[read_start_index: read_start_index + value_bytes])[0]
+                # Update the index of the raw payload for the next read
                 read_start_index += value_bytes
-        else:
-            # Unpack the values to be written to the dictionary
-            data = struct.unpack(data_type, fw_raw_records_bytes[read_start_index: read_start_index + value_bytes])[0]
-            # Update the index of the raw payload for the next read
-            read_start_index += value_bytes
 
-        if inner_key is None:
-            calibration_record[group][key][self._DATA_VALUE_INDEX] = data if data_type != '<f' else round(data, 4)
-        else:
-            calibration_record[group][key][inner_key][self._DATA_VALUE_INDEX] = data if data_type != '<f' else round(data, 4)
+            if inner_key is None:
+                calibration_record[group][key][self._DATA_VALUE_INDEX] = data if data_type != '<f' else round(data, 4)
+            else:
+                calibration_record[group][key][inner_key][self._DATA_VALUE_INDEX] = data if data_type != '<f' else round(data, 4)
 
+        except Exception as e:
+            self.logger.error("Failed to process fw record: {0}".format(e))
+
         return calibration_record, read_start_index
 
     def prepare_record_to_send_to_fw(self, dialin_record):
@@ -553,101 +541,110 @@
 
         return self._record_packets_to_send_to_fw
 
-    def _prepare_record_packets_for_fw(self, dialin_record, group, key, temp_buffer, current_payload_length,
-                                       current_message_count, inner_dict_key=None):
+    def _prepare_record_packets_for_fw(self, dialin_record: OrderedDict,
+                                       group: str,
+                                       key: str,
+                                       temp_buffer: List,
+                                       current_payload_length: int,
+                                       current_message_count: int,
+                                       inner_dict_key: str = None):
         """
-        Handles preparing the record packets that are prepared to be sent to firmware
+        Prepares the record packets prior to sending to firmware
 
-        @param dialin_record: the dictionary that is process to be sent down
-        @param group: dictionary group that is being processed (i.e service_records)
+        @param dialin_record: (OrderedDict) the dictionary that is process to be sent down
+        @param group: (str) dictionary group that is being processed (i.e service_records)
         @param key: dictionary key of the current group
-        @param temp_buffer: temporary buffer that is holding the values to be converted to bytes
-        @param current_payload_length: current payload length of the temporary buffer (before it gets to
+        @param temp_buffer: List temporary buffer that is holding the values to be converted to bytes
+        @param current_payload_length: (int) current payload length of the temporary buffer (before it gets to
         maximum allowed)
-        @param current_message_count: current message number of all the payloads
-        @param inner_dict_key: key of a nested dictionary (if it exists)
+        @param current_message_count: (int) current message number of all the payloads
+        @param inner_dict_key: (str) key of a nested dictionary if exists, None otherwise
 
         @return: temp buffer, current message count, current payload length
         """
-        # No inner key so no nested dictionary
-        if inner_dict_key is None:
-            data_type = dialin_record[group][key][self._DATA_TYPE_INDEX]
-            data_type_bytes = self.get_data_type_bytes(data_type)
-            current_value = dialin_record[group][key][self._DATA_VALUE_INDEX]
-            # This is used only for the data types of <c which is a character. If the data type is a character,
-            # it should come with a length as the third element of the list. If the third element does not
-            # exist, assume the len is 1. This value is only used when the data type is a <c.
-            char_len = 1 if len(dialin_record[group][key]) <= self._DICT_VALUE_LIST_LEN else \
-                dialin_record[group][key][self._CHAR_LENGTH_INDEX]
-        else:
-            data_type = dialin_record[group][key][inner_dict_key][self._DATA_TYPE_INDEX]
-            data_type_bytes = self.get_data_type_bytes(data_type)
-            current_value = dialin_record[group][key][inner_dict_key][self._DATA_VALUE_INDEX]
-            # This is used only for the data types of <c which is a character. If the data type is a character,
-            # it should come with a length as the third element of the list. If the third element does not
-            # exist, assume the len is 1. This value is only used when the data type is a <c.
-            char_len = 1 if len(dialin_record[group][key][inner_dict_key]) <= self._DICT_VALUE_LIST_LEN else \
-                dialin_record[group][key][inner_dict_key][self._CHAR_LENGTH_INDEX]
+        try:
+            # No inner key so no nested dictionary
+            if inner_dict_key is None:
+                data_type = dialin_record[group][key][self._DATA_TYPE_INDEX]
+                data_type_bytes = self.get_data_type_bytes(data_type)
+                current_value = dialin_record[group][key][self._DATA_VALUE_INDEX]
+                # This is used only for the data types of <c which is a character. If the data type is a character,
+                # it should come with a length as the third element of the list. If the third element does not
+                # exist, assume the len is 1. This value is only used when the data type is a <c.
+                char_len = 1 if len(dialin_record[group][key]) <= self._DICT_VALUE_LIST_LEN else \
+                    dialin_record[group][key][self._CHAR_LENGTH_INDEX]
+            else:
+                data_type = dialin_record[group][key][inner_dict_key][self._DATA_TYPE_INDEX]
+                data_type_bytes = self.get_data_type_bytes(data_type)
+                current_value = dialin_record[group][key][inner_dict_key][self._DATA_VALUE_INDEX]
+                # This is used only for the data types of <c which is a character. If the data type is a character,
+                # it should come with a length as the third element of the list. If the third element does not
+                # exist, assume the len is 1. This value is only used when the data type is a <c.
+                char_len = 1 if len(dialin_record[group][key][inner_dict_key]) <= self._DICT_VALUE_LIST_LEN else \
+                    dialin_record[group][key][inner_dict_key][self._CHAR_LENGTH_INDEX]
 
-        # If the data type is a <c which is a character, multiply the data type bytes
-        # to the character length
-        if data_type == '<c':
-            data_type_bytes *= char_len
-
-        # If the key or the inner key is crc, it means the entire part of the
-        # dictionary until the CRC is collected.
-        if key == 'crc' or inner_dict_key == 'crc':
-            pass
-        else:
-            # if the data type is <c, convert each character to ascii and append it into the temp list
+            # If the data type is a <c which is a character, multiply the data type bytes
+            # to the character length
             if data_type == '<c':
-                for ch in current_value:
-                    self._temp_groups_data_to_calculate_crc.append(struct.pack(data_type, ch.encode('ascii')))
+                data_type_bytes *= char_len
+
+            # If the key or the inner key is crc, it means the entire part of the
+            # dictionary until the CRC is collected.
+            if key == 'crc' or inner_dict_key == 'crc':
+                pass
             else:
-                # Append the latest data into the temp buffer
-                self._temp_groups_data_to_calculate_crc.append(struct.pack(data_type, current_value))
+                # if the data type is <c, convert each character to ascii and append it into the temp list
+                if data_type == '<c':
+                    for ch in current_value:
+                        self._temp_groups_data_to_calculate_crc.append(struct.pack(data_type, ch.encode('ascii')))
+                else:
+                    # Append the latest data into the temp buffer
+                    self._temp_groups_data_to_calculate_crc.append(struct.pack(data_type, current_value))
 
-        # If minimum number of bytes space is still available in current temp buffer, continue inserting
-        # data into the buffer.
-        if self._TARGET_BYTES_TO_SEND_TO_FW - current_payload_length > self._MIN_PAYLOAD_BYTES_SPACE:
-            current_payload_length += data_type_bytes
-            # Insert a 4-byte 0 to the index of the total messages. This is a place holder and it will
-            # be updated with the right value later.
-            temp_buffer[self._PAYLOAD_TOTAL_MSG_INDEX] = struct.pack('<i', 0)
+            # If minimum number of bytes space is still available in current temp buffer, continue inserting
+            # data into the buffer.
+            if self._TARGET_BYTES_TO_SEND_TO_FW - current_payload_length > self._MIN_PAYLOAD_BYTES_SPACE:
+                current_payload_length += data_type_bytes
+                # Insert a 4-byte 0 to the index of the total messages. This is a place holder and it will
+                # be updated with the right value later.
+                temp_buffer[self._PAYLOAD_TOTAL_MSG_INDEX] = struct.pack('<i', 0)
 
-            # If the data type is a <c, loop through the current value
-            # convert each character to its equivalent ascii number and pack it.
-            if data_type == '<c':
-                for ch in current_value:
-                    temp_buffer.append(struct.pack(data_type, ch.encode('ascii')))
-            else:
-                temp_buffer.append(struct.pack(data_type, current_value))
+                # If the data type is a <c, loop through the current value
+                # convert each character to its equivalent ascii number and pack it.
+                if data_type == '<c':
+                    for ch in current_value:
+                        temp_buffer.append(struct.pack(data_type, ch.encode('ascii')))
+                else:
+                    temp_buffer.append(struct.pack(data_type, current_value))
 
-            temp_buffer[self._PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
-            temp_buffer[self._PAYLOAD_TOTAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-        else:
-            # There is not enough space left in this temp buffer. Update the current message count and
-            # the total number of bytes that were packed in this data packet.
-            temp_buffer[self._PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
-            temp_buffer[self._PAYLOAD_TOTAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-            # Append the temp buffer list into the main list to be process later
-            self._record_packets_to_send_to_fw.append(temp_buffer)
-            # Increment the current message count as a new temp buffer is created for the next data
-            # packet. Update the current payload length with the latest addition to the new temp buffer.
-            current_message_count += 1
-            current_payload_length = data_type_bytes
-            # Create a new temp buffer and add the current message count, total length of payload so far
-            # and the data that there was not enough space in the previous data packet.
-            temp_buffer = [struct.pack('<i', current_message_count), struct.pack('<i', 0),
-                           struct.pack('<i', current_payload_length)]
-            # If the data type is a <c, loop through the current value
-            # convert each character to its equivalent ascii number and pack it
-            if data_type == '<c':
-                for ch in current_value:
-                    temp_buffer.append(struct.pack(data_type, ch.encode('ascii')))
+                temp_buffer[self._PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
+                temp_buffer[self._PAYLOAD_TOTAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
             else:
-                temp_buffer.append(struct.pack(data_type, current_value))
+                # There is not enough space left in this temp buffer. Update the current message count and
+                # the total number of bytes that were packed in this data packet.
+                temp_buffer[self._PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
+                temp_buffer[self._PAYLOAD_TOTAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                # Append the temp buffer list into the main list to be process later
+                self._record_packets_to_send_to_fw.append(temp_buffer)
+                # Increment the current message count as a new temp buffer is created for the next data
+                # packet. Update the current payload length with the latest addition to the new temp buffer.
+                current_message_count += 1
+                current_payload_length = data_type_bytes
+                # Create a new temp buffer and add the current message count, total length of payload so far
+                # and the data that there was not enough space in the previous data packet.
+                temp_buffer = [struct.pack('<i', current_message_count), struct.pack('<i', 0),
+                               struct.pack('<i', current_payload_length)]
+                # If the data type is a <c, loop through the current value
+                # convert each character to its equivalent ascii number and pack it
+                if data_type == '<c':
+                    for ch in current_value:
+                        temp_buffer.append(struct.pack(data_type, ch.encode('ascii')))
+                else:
+                    temp_buffer.append(struct.pack(data_type, current_value))
 
+        except Exception as e:
+            self.logger.error("Failed to prepare record packets for fw: {0}".format(e))
+
         # Return the latest calculated values as tuple
         return temp_buffer, current_message_count, current_payload_length
 
@@ -675,7 +672,8 @@
 
         return byte_size
 
-    def crc_16(self, data):
+    @classmethod
+    def crc_16(cls, data):
         """
         generates crc16 for the provided data
         @param data: byte of data
@@ -689,7 +687,7 @@
             # Make the sure variables are 16-bit integers
             left = (crc << 8) & 0x0000FFFF
             right = (crc >> 8) & 0x0000FFFF
-            crc = left ^ self.CRC_16_TABLE[data[i] ^ (right & 0x00FF)]
+            crc = left ^ cls.CRC_16_TABLE[data[i] ^ (right & 0x00FF)]
             l -= 1
             i += 1
 
Index: tests/test_calibration.py
===================================================================
diff -u
--- tests/test_calibration.py	(revision 0)
+++ tests/test_calibration.py	(revision 04d9678a26c46fe1567d9e8eecd80414a94ee4bc)
@@ -0,0 +1,182 @@
+import sys
+import struct
+
+from dialin import HD, AbstractObserver
+
+sys.path.append("../")
+from dialin.dg.dialysate_generator import DG
+from dialin.utils.nv_ops_utils import NVOpsUtils
+from time import sleep
+
+
+def process_calibration_record(read=False):
+
+    cal = dg.calibration_record
+    print(cal.tmp_record)
+
+    try:
+        if read:
+            cal.cmd_request_dg_calibration_record()
+            while True:
+                sleep(0.5)
+                if cal.cal_data != 0:
+                    if cal.is_reading_record_done():
+                        break
+        else:
+            cal.cmd_set_dg_calibration_record()
+
+        print(cal.tmp_record)
+
+    except KeyboardInterrupt:
+        pass
+
+
+def process_system_record(read=False):
+
+    sys = dg.system_record
+    print(sys.dg_system_record)
+
+    try:
+        if read:
+            sys.get_dg_system_record()
+            while True:
+                sleep(0.5)
+                if sys.is_reading_record_done():
+                    if sys.is_reading_record_done():
+                        break
+        else:
+            sys.set_dg_system_record()
+
+        print(sys.dg_system_record)
+
+    except KeyboardInterrupt:
+        pass
+
+
+def process_service_record(read=False):
+
+    sys = dg.service_record
+    print(sys.dg_service_record)
+
+    try:
+        if read:
+            sys.cmd_request_dg_service_record()
+            while True:
+                sleep(0.5)
+                if sys.is_reading_record_done():
+                    if sys.is_reading_record_done():
+                        break
+        else:
+            sys.set_dg_service_record()
+
+        print(sys.dg_service_record)
+
+    except KeyboardInterrupt:
+        pass
+
+def test_crc():
+    val = NVOpsUtils.crc_16(b''.join([
+        struct.pack("<f", 0.0),
+        struct.pack("<f", 0.0),
+        struct.pack("<f", 0.0),
+        struct.pack("<f", 1.0),
+        struct.pack("<f", 0.0),
+        struct.pack("<i", 0),
+    ]))
+    print(val)
+    val = NVOpsUtils.crc_16(b''.join([
+        struct.pack("<f", float("nan")),
+        struct.pack("<f", float("nan")),
+        struct.pack("<f", float("nan")),
+        struct.pack("<f", float("nan")),
+        struct.pack("<f", float("nan")),
+        struct.pack("<i", -1),
+    ]))
+    print(val)
+
+
+class Observer(AbstractObserver):
+    def __init__(self, prop):
+        self.received = False
+        self.prop = prop
+
+    def update(self, message):
+        print("Message: {0}".format(message))
+        self.received = message.get(self.prop, False)
+
+def test_dg_calibration_record():
+    dg = DG(log_level="DEBUG")
+    if dg.cmd_log_in_to_dg():
+        print(dg.cmd_ui_request_dg_version())
+        dg.calibration_record.cmd_request_dg_calibration_record()
+        observer = Observer("dg_calibration_record")
+        dg.calibration_record.attach(observer)
+        while not observer.received:
+            sleep(0.2)
+
+        print(dg.dg_version)
+        print(dg.fpga_version)
+
+        dg.calibration_record.cmd_set_dg_calibration_record(dg.calibration_record.dg_calibration_record)
+
+
+def test_dg_service_record():
+    dg = DG(log_level="DEBUG")
+    if dg.cmd_log_in_to_dg():
+        dg.cmd_ui_request_dg_version()
+        dg.service_record.cmd_request_dg_service_record()
+        observer = Observer("dg_service_record")
+        dg.service_record.attach(observer)
+        while not observer.received:
+            sleep(0.2)
+
+        print(dg.dg_version)
+        print(dg.fpga_version)
+
+        dg.service_record.cmd_set_dg_service_record(dg.service_record.dg_service_record)
+
+
+def test_dg_system_record():
+    dg = DG(log_level="DEBUG")
+    if dg.cmd_log_in_to_dg():
+        dg.cmd_ui_request_dg_version()
+        dg.system_record.cmd_request_dg_system_record()
+        observer = Observer("dg_system_record")
+        dg.system_record.attach(observer)
+        while not observer.received:
+            sleep(0.2)
+
+        print(dg.dg_version)
+        print(dg.fpga_version)
+
+        dg.system_record.cmd_set_dg_system_record(dg.system_record.dg_system_record)
+
+
+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)
+
+
+if __name__ == "__main__":
+    # test_dg_calibration_record()
+    # test_dg_service_record()
+    # test_dg_system_record()
+    test_dg_scheduled_runs_record()
+
+
+
+
+
+
+
Fisheye: Tag 04d9678a26c46fe1567d9e8eecd80414a94ee4bc refers to a dead (removed) revision in file `tests/test_dg.py'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 04d9678a26c46fe1567d9e8eecd80414a94ee4bc refers to a dead (removed) revision in file `tests/test_dg_records.py'.
Fisheye: No comparison available.  Pass `N' to diff?