Index: dialin/hd/calibration_record.py
===================================================================
diff -u -rd384151f5e4718f092f9cafbf537fbca34b44e07 -r885e2476a98df337598e4cd128b339ca9d7783eb
--- dialin/hd/calibration_record.py	(.../calibration_record.py)	(revision d384151f5e4718f092f9cafbf537fbca34b44e07)
+++ dialin/hd/calibration_record.py	(.../calibration_record.py)	(revision 885e2476a98df337598e4cd128b339ca9d7783eb)
@@ -31,6 +31,7 @@
     _EEPROM_MAX_BYTES_TO_WRITE = 16
     # 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):
         """
@@ -46,9 +47,10 @@
         self.total_messages = 0
         self.received_msg_length = 0
         self._is_getting_cal_in_progress = False
+        self._write_fw_data_to_excel = True
         self.cal_data = 0
         self.raw_cal_record = []
-        self.utilities = NVOpsUtils()
+        self._utilities = NVOpsUtils()
         # Calibration main record
         self.hd_calibration_record = OrderedDict()
 
@@ -132,7 +134,8 @@
                 # Done with receiving the messages
                 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.hd_calibration_record, self.raw_cal_record)
+                self._utilities.process_received_record_from_fw(self.hd_calibration_record, self.raw_cal_record,
+                                                                write_to_excel=self._write_fw_data_to_excel)
 
     def _prepare_hd_calibration_record(self):
         """
@@ -157,10 +160,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]})
@@ -190,7 +193,7 @@
                            'max_current_limit': ['<f', self._DEFAULT_OFFSET_VALUE],
                            'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             # Calculate the size of the bytes in this hardware group
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
@@ -212,7 +215,7 @@
             hardware[i] = {'counts_to_position': ['<f', self._DEFAULT_RATIO_VALUE],
                            'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             # Calculate the size of the bytes in this hardware group
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
@@ -237,7 +240,7 @@
                            'offset': ['<f', self._DEFAULT_OFFSET_VALUE], 'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
                            'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             # Calculate the size of the bytes in this hardware group
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
@@ -262,7 +265,7 @@
                            'offset': ['<f', self._DEFAULT_OFFSET_VALUE], 'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
                            'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             # Calculate the size of the bytes in this hardware group
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
@@ -287,7 +290,7 @@
                            'offset': ['<f', self._DEFAULT_OFFSET_VALUE], 'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
                            'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             # Calculate the size of the bytes in this hardware group
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
@@ -312,7 +315,7 @@
                            'offset': ['<f', self._DEFAULT_OFFSET_VALUE], 'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
                            'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             # Calculate the size of the bytes in this hardware group
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
@@ -337,7 +340,7 @@
                            'offset': ['<f', self._DEFAULT_OFFSET_VALUE], 'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
                            'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             # Calculate the size of the bytes in this hardware group
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
@@ -361,7 +364,7 @@
                            'z_offset': ['<f', self._DEFAULT_OFFSET_VALUE],
                            'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             # Calculate the size of the bytes in this hardware group
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
@@ -373,8 +376,21 @@
 
         @return: none
         """
-        record_packets = self.utilities.prepare_record_to_send_to_fw(self.hd_calibration_record)
+        # Read the data from firmware but do not update the excel document
+        # At this step, another read from firmware is requested internally to update the dictionary.
+        # The values in the dictionary is compared against the excel report and if they are different, it automatically
+        # sets the calibration time and calculates the CRC for that group. By default once a read from firmware is
+        # requested, the excel report is updated automatically.
+        self._write_fw_data_to_excel = False
+        self.get_hd_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_dialin_record(self.hd_calibration_record)
+        record_packets = self._utilities.prepare_record_to_send_to_fw(self.hd_calibration_record)
+
         self.logger.debug('Setting HD calibration record')
 
         # Update all the data packets with the last message count since is the number of messages that firmware