Index: dialin/dg/calibration_record.py
===================================================================
diff -u -ree278f5a643613b8e7acbc44c3e70ead692cd0f0 -r3e0a859c326e8d99732e055a6ec42fab4ebbba3a
--- dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision ee278f5a643613b8e7acbc44c3e70ead692cd0f0)
+++ dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision 3e0a859c326e8d99732e055a6ec42fab4ebbba3a)
@@ -196,7 +196,14 @@
         self.logger.debug("Received a complete dg calibration record.")
 
     def cmd_set_dg_calibration_excel_to_fw(self, report_address: str):
-        # TODO header
+        """
+        Handles setting the calibration data that is in an excel report to the firmware.
+
+        @param report_address: (str) the address in which its data must be written to excel
+
+        @return: none
+        """
+
         # Request the DG calibration record and set and observer class to callback when the calibration record is read
         # back
         self.cmd_request_dg_calibration_record()
Index: dialin/utils/nv_ops_utils.py
===================================================================
diff -u -ree278f5a643613b8e7acbc44c3e70ead692cd0f0 -r3e0a859c326e8d99732e055a6ec42fab4ebbba3a
--- dialin/utils/nv_ops_utils.py	(.../nv_ops_utils.py)	(revision ee278f5a643613b8e7acbc44c3e70ead692cd0f0)
+++ dialin/utils/nv_ops_utils.py	(.../nv_ops_utils.py)	(revision 3e0a859c326e8d99732e055a6ec42fab4ebbba3a)
@@ -219,14 +219,12 @@
         try:
             row = 1
             # Let's say the calibration record is:
-            # TODO make this
-            # This loop gets the first set of keys of the calibration record
+            # Get the keys of the calibration group {'pressure_sensors': 'ppi', {'fourth_order': ['<f', 0.0], ... }
             for group in calibration_record.keys():
 
                 start_row = row
                 start_col = 1
                 col = 1
-                # TODo add comment here
                 if isinstance(calibration_record[group], dict):
                     # Write the data to excel
                     write_to_excel(self._excel_workbook, self._record_name, row, col, group, bold=True,
@@ -247,10 +245,14 @@
                                 write_to_excel(self._excel_workbook, self._record_name, row, col, spec,
                                                protect_cell=True)
                                 col += 1
+                                # If the spec value that is read is crc, then the value must be protected too. This is
+                                # to make sure the crc is not changed by accident by the user so the calibration fails
+                                # in the firmware
+                                protect = False if spec is not self._CRC_NAME else True
                                 # Write the value to the excel and make the cell protection to false. The actual
                                 # calibration value should be edited
                                 write_to_excel(self._excel_workbook, self._record_name, row, col, spec_value,
-                                               protect_cell=False)
+                                               protect_cell=protect)
                                 col += 1
                         else:
                             # The hardware value is not a CRC. Write it to excel
@@ -259,8 +261,7 @@
                                            protect_cell=False)
                         # If all the hardware of a hardware group is written to excel, merge and center the
                         if list_of_keys.index(hardware) == len(list_of_keys) - 1:
-                            merge_cells(self._excel_workbook, self._record_name,
-                                        start_row, start_col, row, start_col)
+                            merge_cells(self._excel_workbook, self._record_name, start_row, start_col, row, start_col)
                         row += 1
 
                 row += 1
@@ -284,119 +285,77 @@
             self._excel_workbook = load_excel_report(report_address)
             row = 1
             col = 1
-            # This is like
+            # Get the keys of the calibration group {'pressure_sensors': 'ppi', {'fourth_order': ['<f', 0.0], ... }
             for group in record.keys():
+                # Get the current value of the excel cell
                 cell_value = get_cell_value(self._excel_workbook, record_tab, row, col)
+                # Check if the cell value is a string and if it is, lower case it for comparison
                 cell_value = cell_value.lower() if isinstance(cell_value, str) else cell_value
+                # Check if the current cell value is equal to the group name of the record (i.e. pressure_sensors group
+                # are both in the excel and firmware record. Also, if the group name is padding ignore because it is not
+                # needed to be read from excel
                 if cell_value == group and group is not self._PADDING_GROUP_NAME:
+                    # check if the hardware group is a dictionary
                     if isinstance(record[group], dict):
+                        # The actual data in the excel starts from column 4
                         col = 4
                         for hardware in record[group].keys():
+                            # Loop through the hardware groups and check if it is a dictionary (i.e.
+                            # 'ppi', {'fourth_order': ['<f', 0.0], ... }
                             if isinstance(record[group][hardware], dict):
                                 for spec in record[group][hardware]:
                                     cell_value = get_cell_value(self._excel_workbook, record_tab, row, col)
-
+                                    # Write the cell value that is read into the firmware record.
                                     record[group][hardware][spec][1] = cell_value
-
+                                    # Check if the cell value is a string and if it is lower case it for comparison
                                     cell_value = cell_value.lower() if isinstance(cell_value, str) else cell_value
-                                    #print(group, hardware, spec, type(cell_value), cell_value, row)
+                                    # Check if the current spec in the hardware group is cal_time and whether it is
+                                    # None or empty or if it has the word 'new' in the value of the cal_time.
+                                    # When a new calibration value is entered, the cal_time is set to 'new' which is
+                                    # case-insensitive.
                                     if spec == self._CAL_TIME_NAME and cell_value is None or cell_value is '' or \
                                         cell_value == self._NEW_CAL_TIME_SIGNAL:
-
+                                        # So there is a new calibration value. Get the current time in epoch
+                                        # The time in epoch is set to the calibration record to be sent to the firmware
                                         epoch = self.get_current_time_in_epoch()
                                         date_time = self.get_current_date_time(epoch)
                                         record[group][hardware][spec][1] = epoch
-
+                                        # Once the epoch time is set to the calibration record, calculate the crc of the
+                                        # that hardware group and update the crc to be sent to the firmware
                                         crc = self.get_group_record_crc(record[group][hardware])
                                         record[group][hardware][self._CRC_NAME][1] = crc
+                                        # Update the excel report with the newest crc and calibration time
+                                        # Calibration time is converted to date and time.
+                                        # The date and time is the current column number
                                         write_to_excel(self._excel_workbook, record_tab, row, col, date_time)
-                                        write_to_excel(self._excel_workbook, record_tab, row, col + 2, crc)
+                                        # The crc value is 2 columns after the cal_time value. The crc is protected to
+                                        # make sure it is not changed by the user. These crcs are checked upon POST in
+                                        # the firmware
+                                        write_to_excel(self._excel_workbook, record_tab, row, col + 2, crc,
+                                                       protect_cell=True)
+                                        # Save the excel report
                                         self._excel_workbook.save(filename=report_address)
                                     elif spec == self._CAL_TIME_NAME and isinstance(cell_value, str):
+                                        # If the cal_time is in date time and a string, convert that to epoch. This is
+                                        # a date that has been there before so it is only converted to epoch and crc is
+                                        # not calculated
                                         epoch_time = self.get_date_time_in_epoch(cell_value)
                                         record[group][hardware][spec][1] = epoch_time
+                                    # Increment the column by two to get the next value
                                     col += 2
-
+                                # Increment the row to get the next hardware of the same group
                                 row += 1
+                                # Reset the column to 4 to start reading the next hardware in the same group
                                 col = 4
+                        # Go back to the first column to start from the beginning
                         col = 1
+                        # Once a hardware group is finished, (i.e. the pressure_sensors group) increment the row
+                        # by one. There is an empty row in between each hardware group
                         row += 1
 
         except Exception as e:
             self.logger.error("Failed to load the excel record as a calibration record: {0}".format(e))
 
-    def write_excel_record_to_calibration_record_old(self, calibration_record: dict):
-        """
-        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
-        """
-        try:
-            temp_buffer = []
-            is_value_different = False
-            row = 1
-            for group in calibration_record.keys():
-
-                col = 1
-                cell_value = get_cell_value(self._excel_workbook, self._record_name, row, col)
-
-                if cell_value == group:
-
-                    if isinstance(calibration_record[group], dict):
-                        for hardware in calibration_record[group].keys():
-                            if isinstance(calibration_record[group][hardware], dict):
-                                col = 4
-                                for spec in calibration_record[group][hardware]:
-                                    cell_value = get_cell_value(self._excel_workbook, self._record_name, row, col)
-                                    # Check if the cell value is not none. If it is none,
-                                    # it cannot be converted to a number like float or integer
-                                    is_cell_value_valid = True if cell_value is not None else False
-                                    if 'crc' not in spec and 'time' not in spec and is_cell_value_valid:
-                                        temp_buffer.append(
-                                            struct.pack(calibration_record[group][hardware][spec][0], cell_value))
-                                        if calibration_record[group][hardware][spec][1] != cell_value:
-                                            is_value_different = True
-                                            calibration_record[group][hardware][spec][1] = cell_value
-
-                                    if is_value_different and 'time' in spec:
-                                        epoch_time = self.get_current_time_in_epoch()
-                                        calibration_record[group][hardware][spec][1] = epoch_time
-                                        temp_buffer.append(
-                                            struct.pack(calibration_record[group][hardware][spec][0], epoch_time))
-                                        date_time = self.get_current_date_time(epoch_time)
-                                        write_to_excel(self._excel_workbook, self._record_name, row, col, date_time)
-                                    elif 'time' in spec and isinstance(cell_value, str) and is_cell_value_valid:
-                                        epoch_time = self.get_date_time_in_epoch(cell_value)
-                                        calibration_record[group][hardware][spec][1] = epoch_time
-
-                                    if is_value_different and 'crc' in spec:
-                                        # Convert the data in the temp buffer to bytes and calculate its crc.
-                                        data = b''.join(temp_buffer)
-                                        crc_value = self.crc_16(data)
-                                        # Clear the temp buffer for the next round of data
-                                        is_value_different = False
-                                        calibration_record[group][hardware][spec][1] = crc_value
-                                        write_to_excel(self._excel_workbook, self._record_name, row, col, crc_value)
-                                    col += 2
-                            else:
-                                col = 3
-                                for _ in calibration_record[group][hardware]:
-                                    cell_value = get_cell_value(self._excel_workbook, self._record_name, row, col)
-                                    # Check if the cell value is not none. If it is none,
-                                    # it cannot be converted to a number like float or integer
-                                    is_cell_value_valid = True if cell_value is not None else False
-                                    if is_cell_value_valid:
-                                        calibration_record[group][hardware][1] = cell_value
-                            temp_buffer.clear()
-                            row += 1
-                row += 1
-
-            save_report(self._excel_workbook, self._workspace_dir, self._firmware_stack)
-
-        except Exception as e:
-            self.logger.error("Failed to load the excel record as a calibration record: {0}".format(e))
-
     @staticmethod
     def get_processed_characters(record: list) -> bytearray:
         """
Index: tests/peter/test_dg_records.py
===================================================================
diff -u -ree278f5a643613b8e7acbc44c3e70ead692cd0f0 -r3e0a859c326e8d99732e055a6ec42fab4ebbba3a
--- tests/peter/test_dg_records.py	(.../test_dg_records.py)	(revision ee278f5a643613b8e7acbc44c3e70ead692cd0f0)
+++ tests/peter/test_dg_records.py	(.../test_dg_records.py)	(revision 3e0a859c326e8d99732e055a6ec42fab4ebbba3a)
@@ -351,7 +351,7 @@
 def test_dg_excel_report():
     dg = DG(log_level="DEBUG")
     if dg.cmd_log_in_to_dg():
-        #dg.calibration_record.cmd_get_dg_calibration_record_report()
+        dg.calibration_record.cmd_get_dg_calibration_record_report()
         dg.calibration_record.cmd_set_dg_calibration_excel_to_fw('/home/fw/projects/DG_NV_Records/2022-02-09-DG-Record.xlsx')