Index: dialin/dg/calibration_record.py
===================================================================
diff -u -r5fe81152c836440fe3c41308ebcc02cfbedce2cd -r7cd740bfb30cafa48847843cd09c3ee346b882a4
--- dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision 5fe81152c836440fe3c41308ebcc02cfbedce2cd)
+++ dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision 7cd740bfb30cafa48847843cd09c3ee346b882a4)
@@ -48,6 +48,7 @@
         self.length = 0
         self.cal_data = 0
         self._raw_cal_record = []
+        self._write_fw_data_to_excel = True
         self._utilities = NVOpsUtils()
         # DG calibration_record main record
         self.dg_calibration_record = OrderedDict()
@@ -65,8 +66,12 @@
         self._utilities.prepare_excel_report('DG', 'Calibration')
 
     def is_reading_record_done(self):
+        """
+        Handles getting the status of reading record
 
-        return self._utilities.get_reading_status()
+        @return: True if reading is done otherwise False
+        """
+        return self._utilities.get_writing_to_excel_status()
 
     def get_dg_calibration_record(self):
         """
@@ -134,8 +139,49 @@
                                                         self._RECORD_SPECS_BYTES:end_of_data_index])
             if self.current_message == self.total_messages:
                 # 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._utilities.process_received_record_from_fw(self.dg_calibration_record, self._raw_cal_record,
+                                                                write_to_excel=self._write_fw_data_to_excel)
 
+    def set_dg_calibration_record(self):
+        """
+        Handles updating the DG calibration record with the newest calibration_record data of a hardware and
+        sends it to FW.
+
+        @return: none
+        """
+        # Read the data from firmware but do not update the excel document
+        self._write_fw_data_to_excel = False
+        self.get_dg_calibration_record()
+
+        while self._utilities.get_reading_record_status() is not True:
+            time.sleep(0.2)
+
+        self._utilities.write_excel_record_to_dialin_record(self.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
+        # should receive
+        for packet in record_packets:
+            # Sleep to let the firmware receive and process the data
+            time.sleep(self._PAYLOAD_TRANSFER_DELAY)
+
+            # Convert the list packet to a bytearray
+            payload = b''.join(packet)
+
+            message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
+                                                  message_id=MsgIds.MSG_ID_DG_SET_CALIBRATION_RECORD.value,
+                                                  payload=payload)
+
+            received_message = self.can_interface.send(message)
+
+            # If there is no content...
+            if received_message is None:
+                self.logger.debug("Timeout!!!!")
+                return False
+
     def _prepare_dg_calibration_record(self):
         """
         Handles assembling the sub dictionaries of each hardware group to make the main DG calibration record.
@@ -497,38 +543,3 @@
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
-
-    def set_dg_calibration_record(self):
-        """
-        Handles updating the DG calibration record with the newest calibration_record data of a hardware and
-        sends it to FW.
-
-        @return: none
-        """
-
-        self._utilities.write_excel_record_to_dialin_record(self.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
-        # should receive
-        for packet in record_packets:
-            # Sleep to let the firmware receive and process the data
-            time.sleep(self._PAYLOAD_TRANSFER_DELAY)
-
-            # Convert the list packet to a bytearray
-            payload = b''.join(packet)
-
-            message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
-                                                  message_id=MsgIds.MSG_ID_DG_SET_CALIBRATION_RECORD.value,
-                                                  payload=payload)
-
-            received_message = self.can_interface.send(message)
-
-            # If there is no content...
-            if received_message is None:
-                self.logger.debug("Timeout!!!!")
-                return False
-
Index: dialin/dg/system_record.py
===================================================================
diff -u -r5fe81152c836440fe3c41308ebcc02cfbedce2cd -r7cd740bfb30cafa48847843cd09c3ee346b882a4
--- dialin/dg/system_record.py	(.../system_record.py)	(revision 5fe81152c836440fe3c41308ebcc02cfbedce2cd)
+++ dialin/dg/system_record.py	(.../system_record.py)	(revision 7cd740bfb30cafa48847843cd09c3ee346b882a4)
@@ -48,17 +48,21 @@
         self.length = 0
         self.sys_data = 0
         self.raw_system_record = []
-        self.utilities = NVOpsUtils()
+        self._utilities = NVOpsUtils()
         # System main record
         self.dg_system_record = OrderedDict()
 
         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.
@@ -70,6 +74,14 @@
         # 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
+
+        @return: True if reading is done otherwise False
+        """
+        return self._utilities.get_writing_to_excel_status()
+
     def _request_dg_fw_system_record(self):
         """
         Handles getting DG system record from firmware.
@@ -125,7 +137,7 @@
                                                           self._RECORD_SPECS_BYTES:end_of_data_index])
             if self.current_message == self.total_messages:
                 # 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)
+                self._utilities.process_received_record_from_fw(self.dg_system_record, self.raw_system_record)
 
     def _prepare_dg_system_record(self):
         """
@@ -147,10 +159,10 @@
         record_crc = OrderedDict({'crc': ['<H', self._DEFAULT_CRC_VALUE]})
 
         # Get the groups byte size
-        groups_byte_size += self.utilities.calculate_group_byte_size(record_crc)
+        groups_byte_size += self._utilities.calculate_group_byte_size(record_crc)
 
         # Get the padding size to create a dictionary from it
-        padding_size = self.utilities.calculate_padding_byte_size(groups_byte_size, self._EEPROM_MAX_BYTES_TO_WRITE)
+        padding_size = self._utilities.calculate_padding_byte_size(groups_byte_size, self._EEPROM_MAX_BYTES_TO_WRITE)
 
         # Create the padding dictionary as list of unsigned char. All the elements are 0.
         padding = OrderedDict({'padding': ['<B', [self._DEFAULT_CRC_VALUE] * padding_size]})
@@ -173,7 +185,7 @@
                               'mfg_date': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}})
 
         for record in system_records.keys():
-            groups_byte_size += self.utilities.calculate_group_byte_size(system_records[record])
+            groups_byte_size += self._utilities.calculate_group_byte_size(system_records[record])
 
         return system_records, groups_byte_size
 
@@ -183,7 +195,8 @@
 
         @return: none
         """
-        record_packets = self.utilities.prepare_record_to_send_to_fw(self.dg_system_record)
+        self._utilities.write_excel_record_to_dialin_record(self.dg_system_record)
+        record_packets = self._utilities.prepare_record_to_send_to_fw(self.dg_system_record)
 
         self.logger.debug('Setting DG system record')
 
Index: dialin/utils/excel_ops.py
===================================================================
diff -u -r5fe81152c836440fe3c41308ebcc02cfbedce2cd -r7cd740bfb30cafa48847843cd09c3ee346b882a4
--- dialin/utils/excel_ops.py	(.../excel_ops.py)	(revision 5fe81152c836440fe3c41308ebcc02cfbedce2cd)
+++ dialin/utils/excel_ops.py	(.../excel_ops.py)	(revision 7cd740bfb30cafa48847843cd09c3ee346b882a4)
@@ -30,7 +30,11 @@
 
     @staticmethod
     def get_an_excel_workbook():
+        """
+       This function returns an excel workbook object
 
+        @return excel workbook object
+        """
         return Workbook()
 
     @staticmethod
@@ -45,9 +49,21 @@
 
         @return none
         """
-        # Create a tab and name the tab with the name of the projects dictionary
-        workbook_obj.create_sheet(title=title, index=index)
+        # Assume the new sheet does not exist
+        is_sheet_name_available = False
 
+        # Loop through the list of the sheet names in the excel
+        for sheet_name in workbook_obj.sheetnames:
+            # If the requested title exists in the excel document, set as True
+            # and break out of the loop.
+            if title == sheet_name:
+                is_sheet_name_available = True
+                break
+        # If the requested sheet does not exist, create it
+        if is_sheet_name_available is False:
+            # Create a tab and name the tab with the name of the projects dictionary
+            workbook_obj.create_sheet(title=title, index=index)
+
         # If the first tab is Sheet or Sheet1, remove it
         # The other tabs must be created first before removing the default tab
         if workbook_obj.sheetnames[0] == 'Sheet' or workbook_obj.sheetnames[0] == 'Sheet1':
@@ -129,19 +145,27 @@
 
     @staticmethod
     def load_excel_report(path):
+        """
+       This function returns an object of a currently existing excel workbook
 
+        @return loaded excel workbook object
+        """
         return load_workbook(path)
 
     @staticmethod
     def get_cell_value(workbook_obj, project, row, col):
+        """
+       This function returns the value of a written excel cell
 
+        @return excel workbook object
+        """
         # Set the active worksheet to the provided worksheet
         active_sheet = workbook_obj[project]
+        # Get the cell object
         cell_obj = active_sheet.cell(row=row, column=col)
-
+        # Convert it to the actual value
         return cell_obj.value
 
-
     @staticmethod
     def merge_cells(workbook_obj, project, start_row, start_col, end_row, end_col):
         """
Index: dialin/utils/nv_ops_utils.py
===================================================================
diff -u -r5fe81152c836440fe3c41308ebcc02cfbedce2cd -r7cd740bfb30cafa48847843cd09c3ee346b882a4
--- dialin/utils/nv_ops_utils.py	(.../nv_ops_utils.py)	(revision 5fe81152c836440fe3c41308ebcc02cfbedce2cd)
+++ dialin/utils/nv_ops_utils.py	(.../nv_ops_utils.py)	(revision 7cd740bfb30cafa48847843cd09c3ee346b882a4)
@@ -10,7 +10,7 @@
 class NVOpsUtils:
     """
 
-    Dialysate Generator (DG) Dialin API sub-class for utilities commands. The commands are used to process
+    Dialysate Generator (DG) Dialin API sub-class for _utilities commands. The commands are used to process
     the calibration_record records, service records, system records, and the scheduled runs records. The records are
     prepared to be sent to firmware to be received from firmware.
     """
@@ -38,6 +38,7 @@
         self._excel_workbook = ''
         self._record_name = ''
         self._firmware_stack = ''
+        self._is_writing_to_excel_done = False
         self._is_read_done = False
 
         self.excel_ops = ExcelOps()
@@ -58,16 +59,36 @@
 
         @return none
         """
+
+        path = ''
+        is_report_found = False
         # Create the workspace name
         workspace_name = str(firmware_stack) + '_NV_Records'
 
         self.create_workspace(workspace_name)
-
-        # Get an excel workbook object
-        self._excel_workbook = self.excel_ops.get_an_excel_workbook()
-
         self._record_name = record_name
         self._firmware_stack = firmware_stack
+
+        # List all the files in the workspace directory
+        for file in os.listdir(self._workspace_dir):
+            # If the file has an extension of .xlsx
+            if file.endswith('.xlsx'):
+                # Check if the firmware stack (i.e. DG) is in the file and name of the file
+                # does not have lock in it. When the file is open, there is a hidden lock file
+                # in there and it is ignored
+                if self._firmware_stack in str(file) and 'lock' not in str(file):
+                    # Create the file path and exit the loop
+                    path = os.path.join(self._workspace_dir, file)
+                    is_report_found = True
+                    break
+
+        if is_report_found:
+            # Load the excel workbook
+            self._excel_workbook = self.excel_ops.load_excel_report(path)
+        else:
+            # Get an excel workbook object
+            self._excel_workbook = self.excel_ops.get_an_excel_workbook()
+
         # Setup worksheet and create the current tab
         self.excel_ops.setup_excel_worksheet(self._excel_workbook, self._record_name)
 
@@ -82,19 +103,28 @@
             col = 1
             if isinstance(dialin_record[group], dict):
 
-                self.excel_ops.write_to_excel(self._excel_workbook, self._record_name, row, col, group, bold=True)
+                self.excel_ops.write_to_excel(self._excel_workbook, self._record_name, row, col, group, bold=True,
+                                              max_col_len=len(group))
 
                 for hardware in dialin_record[group].keys():
                     list_of_keys = list(dialin_record[group].keys())
+
                     col = 2
                     self.excel_ops.write_to_excel(self._excel_workbook, self._record_name, row, col, hardware)
                     col += 1
-                    for spec in dialin_record[group][hardware]:
-                        spec_value = dialin_record[group][hardware][spec][1]
-                        self.excel_ops.write_to_excel(self._excel_workbook, self._record_name, row, col, spec)
-                        col += 1
+
+                    if isinstance(dialin_record[group][hardware], dict):
+                        for spec in dialin_record[group][hardware]:
+
+                            spec_value = dialin_record[group][hardware][spec][1]
+
+                            self.excel_ops.write_to_excel(self._excel_workbook, self._record_name, row, col, spec)
+                            col += 1
+                            self.excel_ops.write_to_excel(self._excel_workbook, self._record_name, row, col, spec_value)
+                            col += 1
+                    else:
+                        spec_value = dialin_record[group][hardware][1]
                         self.excel_ops.write_to_excel(self._excel_workbook, self._record_name, row, col, spec_value)
-                        col += 1
 
                     if list_of_keys.index(hardware) == len(list_of_keys) - 1:
                         self.excel_ops.merge_cells(self._excel_workbook, self._record_name, start_row, start_col,
@@ -104,7 +134,8 @@
             row += 1
 
         self.excel_ops.save_report(self._excel_workbook, self._workspace_dir, self._firmware_stack)
-        self._is_read_done = True
+        # Signal reading is done
+        self._is_writing_to_excel_done = True
 
     def write_excel_record_to_dialin_record(self, dialin_record):
         """
@@ -114,54 +145,46 @@
 
         @return True if reading to firmware records to excel is done otherwise False
         """
-
-        path = ''
         row = 1
-        # List all the files in the workspace directory
-        for file in os.listdir(self._workspace_dir):
-            # If the file has an extension of .xlsx
-            if file.endswith('.xlsx'):
-                # Check if the firmware stack (i.e. DG) is in the file and name of the file
-                # does not have lock in it. When the file is open, there is a hidden lock file
-                # in there and it is ignored
-                if self._firmware_stack in str(file) and 'lock' not in str(file):
-                    # Create the file path and exit the loop
-                    path = os.path.join(self._workspace_dir, file)
-                    break
 
-        # Load the excel workbook
-        self._excel_workbook = self.excel_ops.load_excel_report(path)
-
         for group in dialin_record.keys():
 
             col = 1
             cell_value = self.excel_ops.get_cell_value(self._excel_workbook, self._record_name, row, col)
 
             if cell_value == group:
                 print(cell_value)
-                col = 4
+
                 if isinstance(dialin_record[group], dict):
                     for hardware in dialin_record[group].keys():
-                        for spec in dialin_record[group][hardware]:
-                            cell_value = self.excel_ops.get_cell_value(self._excel_workbook, self._record_name, row,
-                                                                       col)
-                            print(spec, cell_value)
-                            dialin_record[group][hardware][spec][1] = cell_value
-                            col += 2
+                        if isinstance(dialin_record[group][hardware], dict):
+                            col = 4
+                            for spec in dialin_record[group][hardware]:
+                                cell_value = self.excel_ops.get_cell_value(self._excel_workbook, self._record_name, row,
+                                                                           col)
+                                dialin_record[group][hardware][spec][1] = cell_value
+                                col += 2
+                        else:
+                            col = 3
+                            for spec in dialin_record[group][hardware]:
+                                cell_value = self.excel_ops.get_cell_value(self._excel_workbook, self._record_name, row,
+                                                                           col)
+                                dialin_record[group][hardware][1] = cell_value
 
                         row += 1
-                        col = 4
 
             row += 1
-        #print(self.excel_ops.get_cell_value(self._excel_workbook, self._record_name, 1, 1))
 
-    def get_reading_status(self):
+    def get_writing_to_excel_status(self):
         """
         Publicly accessible function to get the reading status
 
         @return True if reading to firmware records to excel is done otherwise False
         """
+        return self._is_writing_to_excel_done
 
+    def get_reading_record_status(self):
+
         return self._is_read_done
 
     def create_workspace(self, dir_name):
@@ -194,12 +217,13 @@
         """
         return int(datetime.datetime.now().timestamp())
 
-    def process_received_record_from_fw(self, dialin_record, fw_raw_records_bytes):
+    def process_received_record_from_fw(self, dialin_record, fw_raw_records_bytes, write_to_excel=True):
         """
         Handles processing the received record from firmware
 
         @param dialin_record: dictionary that is being updated from firmware
         @param fw_raw_records_bytes: list of the firmware record from firmware in bytes
+        @param write_to_excel: flag to whether write the latest data to the excel document (default is True)
 
         @return: none
         """
@@ -253,7 +277,11 @@
                         dialin_record = values[0]
                         raw_payload_temp_start_index = values[1]
 
-        self.write_fw_record_to_excel(dialin_record)
+        if write_to_excel:
+            # Write the received data into excel
+            self.write_fw_record_to_excel(dialin_record)
+        else:
+            self._is_read_done = True
 
     def _process_fw_record(self, dialin_record, fw_raw_records_bytes, group, key, read_start_index, inner_key=None):
         """
@@ -583,4 +611,4 @@
         else:
             padding_size = (math.ceil(total_byte_size / max_buffer_size) * max_buffer_size) - total_byte_size
 
-        return padding_size
\ No newline at end of file
+        return padding_size
Index: tests/test_dg_calibration.py
===================================================================
diff -u -r5fe81152c836440fe3c41308ebcc02cfbedce2cd -r7cd740bfb30cafa48847843cd09c3ee346b882a4
--- tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision 5fe81152c836440fe3c41308ebcc02cfbedce2cd)
+++ tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision 7cd740bfb30cafa48847843cd09c3ee346b882a4)
@@ -28,7 +28,7 @@
     cal.dg_calibration_record['fans']['fan_2']['reserved_space_2'][1] = 456.25
     cal.dg_calibration_record['accelerometer_sensor']['accelerometer']['y_offset'][1] = 678.9
     """
-    status = False
+    status = True
 
     print(cal.dg_calibration_record)
 
Index: tests/test_dg_system_record.py
===================================================================
diff -u -r97c98d84604e3700dd446235e91a5ebe2db08022 -r7cd740bfb30cafa48847843cd09c3ee346b882a4
--- tests/test_dg_system_record.py	(.../test_dg_system_record.py)	(revision 97c98d84604e3700dd446235e91a5ebe2db08022)
+++ tests/test_dg_system_record.py	(.../test_dg_system_record.py)	(revision 7cd740bfb30cafa48847843cd09c3ee346b882a4)
@@ -12,15 +12,15 @@
     sleep(2)
 
     sys = dg.system_record
-    #sys.dg_system_record['system_record']['top_level_pn'][1] = 'DEN-SN-Y20'
+    sys.dg_system_record['system_record']['top_level_pn'][1] = 'DEN-SN-Y20'
     print(sys.dg_system_record)
     test = True
 
     if test:
         sys.get_dg_system_record()
         while True:
             sleep(0.2)
-            if sys.current_message == sys.total_messages:
+            if sys.is_reading_record_done():
                 break
     else:
         sys.set_dg_system_record()
Index: tests/test_hd_records.py
===================================================================
diff -u -r5fe81152c836440fe3c41308ebcc02cfbedce2cd -r7cd740bfb30cafa48847843cd09c3ee346b882a4
--- tests/test_hd_records.py	(.../test_hd_records.py)	(revision 5fe81152c836440fe3c41308ebcc02cfbedce2cd)
+++ tests/test_hd_records.py	(.../test_hd_records.py)	(revision 7cd740bfb30cafa48847843cd09c3ee346b882a4)
@@ -28,9 +28,9 @@
     #print(sys.dg_system_record)
 
     #sys.dg_service_record['system_record']['top_level_pn'][1] = 'abcd-12345'
-    #sys.dg_service_record['system_record']['mfg_date'][1] = utilities.get_current_time_in_epoch()
+    #sys.dg_service_record['system_record']['mfg_date'][1] = _utilities.get_current_time_in_epoch()
 
-    #srv.dg_service_record['service_record']['service_date'][1] = utilities.get_current_time_in_epoch()
+    #srv.dg_service_record['service_record']['service_date'][1] = _utilities.get_current_time_in_epoch()
 
 
     status = True