Index: dialin/dg/flush.py
===================================================================
diff -u -r01db18a18769df2048346f868412fc8a12631fc0 -r7c9dd1487f23d6bf314dcff09b77a25d9a26d1c2
--- dialin/dg/flush.py	(.../flush.py)	(revision 01db18a18769df2048346f868412fc8a12631fc0)
+++ dialin/dg/flush.py	(.../flush.py)	(revision 7c9dd1487f23d6bf314dcff09b77a25d9a26d1c2)
@@ -66,33 +66,3 @@
         self.overall_elapsed_time = int(elapsed_time / 1000)
         self.state_elapsed_time = int(state_elapsed_time / 1000)
 
-    def cmd_start_stop_flush(self, start=True):
-        """
-        Constructs and sends the start/stop DG flush command
-
-        @param start: (bool) True = start flush, False = stop flush.
-        @return: non-zero integer if successful, False otherwise
-        """
-        # 1 is to start
-        if start:
-            cmd = 1
-            str = "Starting"
-        else:
-            cmd = 0
-            str = "Stopping"
-        payload = integer_to_bytearray(cmd)
-        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
-                                              message_id=MsgIds.MSG_ID_DG_START_STOP_FLUSH.value,
-                                              payload=payload)
-
-        self.logger.debug(str + " DG flush mode")
-
-        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
Index: dialin/dg/scheduled_runs_record.py
===================================================================
diff -u -rdd42e4d9cfe821b0a755ccc86cc1a4a2a3dd2f37 -r7c9dd1487f23d6bf314dcff09b77a25d9a26d1c2
--- dialin/dg/scheduled_runs_record.py	(.../scheduled_runs_record.py)	(revision dd42e4d9cfe821b0a755ccc86cc1a4a2a3dd2f37)
+++ dialin/dg/scheduled_runs_record.py	(.../scheduled_runs_record.py)	(revision 7c9dd1487f23d6bf314dcff09b77a25d9a26d1c2)
@@ -7,6 +7,7 @@
 from ..common.msg_defs import MsgIds, MsgFieldPositions
 from ..protocols.CAN import (DenaliMessage, DenaliChannels)
 from ..utils.base import _AbstractSubSystem, DialinEnum
+from ..utils.nv_ops_utils import NVOpsUtils
 from logging import Logger
 
 
@@ -44,8 +45,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,9 +63,14 @@
         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()
 
+        # DG scheduled runs main record as an ordered dictionary
+        self.dg_scheduled_runs_record = OrderedDict()
+
         if self.can_interface is not None:
 
             channel_id = DenaliChannels.dg_to_dialin_ch_id
@@ -159,38 +166,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,7 +207,7 @@
                                                                             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):
@@ -227,7 +235,7 @@
         # 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}
+        self.dg_scheduled_runs_record = {**scheduled_runs[0], **padding, **record_crc}
 
     def _prepare_scheduled_runs(self):
         """
@@ -298,124 +306,30 @@
         @return: none
         """
 
-        # 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]
+        # 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_scheduled_runs_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)
 
-        # Loop through the DG calibration_record dictionary
-        for group in self.DG_SCHEDULED_RUNS_RECORD.keys():
+        # Write the excel record
+        self._utilities.write_excel_record_to_dialin_record(self.dg_scheduled_runs_record)
 
-            # 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]
+        record_packets = self._utilities.prepare_record_to_send_to_fw(self.dg_scheduled_runs_record)
 
-                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)
+        self.logger.debug('Setting DG scheduled runs started')
 
-            # 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)
 
Index: tests/dg_heat_disinfect_test.py
===================================================================
diff -u -r01db18a18769df2048346f868412fc8a12631fc0 -r7c9dd1487f23d6bf314dcff09b77a25d9a26d1c2
--- tests/dg_heat_disinfect_test.py	(.../dg_heat_disinfect_test.py)	(revision 01db18a18769df2048346f868412fc8a12631fc0)
+++ tests/dg_heat_disinfect_test.py	(.../dg_heat_disinfect_test.py)	(revision 7c9dd1487f23d6bf314dcff09b77a25d9a26d1c2)
@@ -3,8 +3,6 @@
 import sys
 sys.path.append("..")
 from dialin.dg.dialysate_generator import DG
-from dialin.hd.hemodialysis_device import HD
-from dialin.dg.hd_proxy import DGHDProxy
 from dialin.dg.heat_disinfect import HeatDisinfectStates, CancellationModes
 from dialin.dg.drain_pump import DrainPumpStates
 from dialin.dg.thermistors import ThermistorsNames
@@ -95,10 +93,17 @@
 
 def get_heaters_info():
 
-    info = ('Pri_main_DC, {:5.3f}, Pri_small_DC, {:5.3f}, Pri_int_temp, {:5.3f}, Trimmer_DC, {:5.3f}, '.
+    info = ('Pri_main_DC, {:5.3f}, Pri_small_DC, {:5.3f}, Pri_int_temp, {:5.3f}, Prim_CJ_temp, {:5.3f}, '
+            'Prim_TC_temp, {:5.3f}, Trimmer_DC, {:5.3f}, Trim_int_temp, {:5.3f}, Trim_CJ_temp, {:5.3f}, '
+            'Trim_TC_temp, {:5.3f}'.
             format(dg.heaters.main_primary_heater_duty_cycle, dg.heaters.small_primary_heater_duty_cycle,
                    dg.temperature_sensors.temperature_sensors[TemperatureSensorsNames.PRIMARY_HEATER_INTERNAL.name],
-                   dg.heaters.trimmer_heater_duty_cycle))
+                   dg.temperature_sensors.temperature_sensors[TemperatureSensorsNames.PRIMARY_HEATER_COLD_JUNCTION.name],
+                   dg.temperature_sensors.temperature_sensors[TemperatureSensorsNames.PRIMARY_HEATER_THERMOCOUPLE.name],
+                   dg.heaters.trimmer_heater_duty_cycle,
+                   dg.temperature_sensors.temperature_sensors[TemperatureSensorsNames.TRIMMER_HEATER_INTERNAL.name],
+                   dg.temperature_sensors.temperature_sensors[TemperatureSensorsNames.TRIMMER_HEATER_COLD_JUNCTION.name],
+                   dg.temperature_sensors.temperature_sensors[TemperatureSensorsNames.TRIMMER_HEATER_THERMOCOUPLE.name]))
     return info
 
 
@@ -132,7 +137,7 @@
 
     complete_counter = 1
     f = open("/home/fw/projects/dialin/tests/Heat_disinfect.log", "w")
-    dg.hd_proxy.cmd_start_stop_heat_disinfect()
+    #dg.hd_proxy.cmd_start_stop_heat_disinfect()
     try:
         while True: