Index: dialin/common/msg_defs.py
===================================================================
diff -u -r43e8345862c72340680c045e53b310aa291513a6 -re36d87e663d95c79214f66b5db9aa6d6e8b47adf
--- dialin/common/msg_defs.py	(.../msg_defs.py)	(revision 43e8345862c72340680c045e53b310aa291513a6)
+++ dialin/common/msg_defs.py	(.../msg_defs.py)	(revision e36d87e663d95c79214f66b5db9aa6d6e8b47adf)
@@ -225,6 +225,9 @@
     MSG_ID_DG_SET_SERVICE_RECORD = 0xA03A                       # DG set service record that is sent from Dialin
     MSG_ID_DG_GET_SERVICE_RECORD = 0xA039                       # DG get service record that is requested from Dialin
     MSG_ID_DG_SEND_SERVICE_RECORD = 0xA03B                      # DG send service record that is requested from Dialin
+    MSG_ID_DG_GET_SCHEDULED_RUNS_RECORD = 0xA03C                # DG get scheduled runs that is requested from Dialin
+    MSG_ID_DG_SET_SCHEDULED_RUNS_RECORD = 0xA03D                # DG set scheduled runs that is received from Dialin
+    MSG_ID_DG_SEND_SCHEDULED_RUNS_RECORD = 0xA03E               # DG send scheduled runs to CAN bus to be received in Dialin (equivalent to publish)
 
     MSG_ID_HD_DEBUG_EVENT = 0xFFF1                              # HD debug event text to be logged in event log
     MSG_ID_DG_DEBUG_EVENT = 0xFFF2                              # DG debug event text to be logged in event log
Fisheye: Tag e36d87e663d95c79214f66b5db9aa6d6e8b47adf refers to a dead (removed) revision in file `dialin/dg/calibration.py'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: dialin/dg/calibration_record.py
===================================================================
diff -u
--- dialin/dg/calibration_record.py	(revision 0)
+++ dialin/dg/calibration_record.py	(revision e36d87e663d95c79214f66b5db9aa6d6e8b47adf)
@@ -0,0 +1,720 @@
+
+import struct
+import datetime
+import time
+import math
+from collections import OrderedDict
+from ..ui.crc import crc_16
+from ..common.msg_defs import MsgIds, MsgFieldPositions
+from ..protocols.CAN import (DenaliMessage, DenaliChannels)
+from ..utils.base import _AbstractSubSystem, _publish
+from logging import Logger
+
+
+class DGCalibration(_AbstractSubSystem):
+    """
+
+    Dialysate Generator (DG) Dialin API sub-class for calibration commands.
+    """
+
+    CALIBRATION_RECORD_START_INDEX = 6
+    CALIBRATION_RECORD_SPECS_BYTES = 12
+    CALIBRATION_RECORDS_SPECS_BYTE_ARRAY = 3
+    DEFAULT_GAIN_VALUE = 1
+    DEFAULT_OFFSET_VALUE = 0
+    DEFAULT_RATIO_VALUE = 1
+    DEFAULT_VOLUME_VALUE = 0
+    DEFAULT_CONCENTRATE_VALUE = 1
+    DEFAULT_BICARB_VALUE = 1
+    DEFAULT_CALIBRATION_VALUE = 1
+    DEFAULT_CAL_TIME_VALUE = 0
+    DEFAULT_CAL_CRC_VALUE = 0
+
+    CURRENT_MESSAGE_NUM_INDEX = 0
+    TOTAL_MESSAGES_NUM_INDEX = 4
+    PAYLOAD_LENGTH_INDEX = 8
+    PAYLOAD_START_INDEX = 12
+
+    CALIBRATION_DATA_TYPE_INDEX = 0
+    CALIBRATION_VALUE_INDEX = 1
+
+    TARGET_BYTES_TO_SEND_TO_FW = 150
+    MIN_PAYLOAD_BYTES_SPACE = 4
+
+    EEPROM_MAX_BYTES_TO_WRITE = 16
+
+    PAYLOAD_CURRENT_MSG_INDEX = 0
+    PAYLOAD_TOTAL_MSG_INDEX = 1
+    PAYLOAD_CAL_BYTES_INDEX = 2
+
+    # DG calibration main record
+    DG_CALIBRATION_RECORD = OrderedDict()
+
+    def __init__(self, can_interface, logger: Logger):
+        """
+
+        @param can_interface: Denali CAN Messenger object
+        """
+
+        super().__init__()
+
+        self.can_interface = can_interface
+        self.logger = logger
+        self.current_message = 0
+        self.total_messages = 0
+        self.length = 0
+        self.cal_data = 0
+        self.raw_cal_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 by putting sub-dictionaries together
+        self._prepare_dg_calibration_record()
+
+    def get_dg_calibration_record(self):
+        """
+        Handles getting DG calibration data from firmware.
+
+        @return: None
+        """
+        # Clear the list for the next call
+        self.raw_cal_record.clear()
+        # Run the firmware commands to get the calibration record
+        self._request_dg_fw_calibration_record()
+
+    def _request_dg_fw_calibration_record(self):
+        """
+        Handles getting DG calibration record from firmware.
+
+        @return: None
+        """
+        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')
+
+        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", "length", "cal_data"]) #TODO do we need to publish these?
+    def _handler_dg_calibration_sync(self, message):
+        """
+        Handles published DG calibration record messages. DG calibration records are captured for processing and
+        updating the DG calibration record.
+
+        @param message:  published DG calibration record data message
+
+        @return: None
+        """
+        curr = struct.unpack('i', bytearray(
+            message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0]
+        total = struct.unpack('i', bytearray(
+            message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0]
+        length = struct.unpack('i', bytearray(
+            message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3]))[0]
+
+        self.current_message = curr
+        self.total_messages = total
+        self.length = length
+        # The end of calibration record payload is from the start index + 12 bytes for the current message + total
+        # messages + the length of calibration. The rest is the CAN messaging CRC that is not needed to be kept
+        end_of_data_index = self.CALIBRATION_RECORD_START_INDEX + self.CALIBRATION_RECORD_SPECS_BYTES + self.length
+
+        # Get the calibration data only
+        self.cal_data = message['message'][self.CALIBRATION_RECORD_START_INDEX:end_of_data_index]
+
+        # Continue getting calibration records until the all the calibration messages are received. Concatenate the
+        # calibration records to each other
+        if self.current_message <= self.total_messages:
+            self.raw_cal_record += (message['message'][self.CALIBRATION_RECORD_START_INDEX +
+                                                       self.CALIBRATION_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._update_dg_calibration_record_from_fw()
+
+    def _update_dg_calibration_record_from_fw(self):
+        """
+        Handles parsing the calibration messages that were received from DG firmware.
+
+        @return: None
+        """
+        raw_payload_temp_start_index = 0
+        # Convert the concatenated raw data into a byte array since the struct library requires byte arrays.
+        self.raw_cal_record = bytearray(self.raw_cal_record)
+
+        # Loop through the keys for the main calibration dictionary
+        # 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_CALIBRATION_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_CALIBRATION_RECORD[group][self.CALIBRATION_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_cal_record[raw_payload_temp_start_index:
+                                                                    raw_payload_temp_start_index + value_bytes])[0]
+                self.DG_CALIBRATION_RECORD[group][self.CALIBRATION_VALUE_INDEX] = data
+            elif group == 'padding':
+                # Get the data type
+                data_type = self.DG_CALIBRATION_RECORD[group][self.CALIBRATION_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_CALIBRATION_RECORD[group][self.CALIBRATION_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_CALIBRATION_RECORD[group].keys():
+                    # Each hardware has a set of calibration values (i.e ppi: {gain: ['<f',  12.3]}. Loop though those
+                    for hardware in self.DG_CALIBRATION_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_CALIBRATION_RECORD[group][hardware_group][hardware][
+                                    self.CALIBRATION_DATA_TYPE_INDEX]
+                        value_bytes = self._get_data_type_bytes(data_type)
+                        # Unpack the values to written to the dictionary
+                        data = struct.unpack(data_type, self.raw_cal_record[raw_payload_temp_start_index:
+                                                                            raw_payload_temp_start_index +
+                                                                            value_bytes])[0]
+                        # Update the index of the raw payload for the next read
+                        raw_payload_temp_start_index += value_bytes
+                        self.DG_CALIBRATION_RECORD[group][hardware_group][hardware][self.CALIBRATION_VALUE_INDEX] = data
+
+    def _prepare_dg_calibration_record(self):
+        """
+        Handles assembling the sub dictionaries of each hardware group to make the main DG calibration record.
+
+        @return: None
+        """
+        # 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
+        # element is the dictionary that was built and the second element is the byte size of the dictionary.
+        pressure = self._prepare_pressure_sensors_cal_record()
+        flow = self._prepare_flow_sensors_cal_record()
+        load_cells = self._prepare_load_cells_record()
+        temperature = self._prepare_temperature_sensors_record()
+        conductivity = self._prepare_conductivity_sensors_record()
+        pumps = self._prepare_pumps_record()
+        volumes = self._prepare_volume_record()
+        acid = self._prepare_acid_concentrates_record()
+        bicarb = self._prepare_bicarb_concentrates_record()
+        filters = self._prepare_filters_record()
+        fans = self._prepare_fans_record()
+        # Build the CRC of the main calibration record
+        cal_record_crc = OrderedDict({'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]})
+
+        # The second element of the hardware groups are the byte sizes, add them to calculate the overall byte size.
+        groups_byte_size = pressure[1] + flow[1] + load_cells[1] + temperature[1] + conductivity[1] + pumps[1] + \
+            volumes[1] + acid[1] + bicarb[1] + filters[1] + fans[1] + self._get_data_type_bytes(cal_record_crc['crc']
+                                                                                  [self.CALIBRATION_DATA_TYPE_INDEX])
+        # Calculate the padding size:
+        # If bytes in the dictionary % max write bytes to EEPROM (16) is 0, not padding is needed
+        # Else padding = (ceil(dictionary bytes/max write to EEPROM (16)) * max write to EEPROM (16)) - dictionary bytes
+        if (groups_byte_size % self.EEPROM_MAX_BYTES_TO_WRITE) == 0:
+            padding_size = 0
+        else:
+            padding_size = (math.ceil(groups_byte_size / self.EEPROM_MAX_BYTES_TO_WRITE) *
+                            self.EEPROM_MAX_BYTES_TO_WRITE) - groups_byte_size
+        # Create the padding dictionary as list of unsigned char. All the elements are 0.
+        padding = OrderedDict({'padding': ['<B', [self.DEFAULT_CAL_CRC_VALUE] * padding_size]})
+
+        # Insert the sub dictionaries into the main calibration record. The dictionaries are the element 0.
+        # The padding and CRC dictionaries are created without using tuples.
+        self.DG_CALIBRATION_RECORD = {**pressure[0], **flow[0], **load_cells[0], **temperature[0], **conductivity[0],
+                                      **pumps[0], **volumes[0], **acid[0], **bicarb[0], **filters[0], **fans[0],
+                                      **padding, **cal_record_crc}
+
+    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']
+        group_byte_size = 0
+        group_name = 'pressure_sensors'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+
+            hardware[i] = {'gain': ['<f', self.DEFAULT_GAIN_VALUE], 'offset': ['<f', self.DEFAULT_OFFSET_VALUE],
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            # Calculate the size of the bytes in this hardware group
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
+    def _prepare_flow_sensors_cal_record(self):
+        """
+        Handles creating the calibration dictionary of the flow sensors hardware group.
+
+        @return: flow sensors hardware group dictionary and the byte size of this hardware group
+        """
+        hardware_names = ['flow_sensor', 'reserved_1', 'reserved_2', 'reserved_3']
+        group_byte_size = 0
+        group_name = 'flow_sensors'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+
+            hardware[i] = {'gain': ['<f', self.DEFAULT_GAIN_VALUE], 'offset': ['<f', self.DEFAULT_OFFSET_VALUE],
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+
+            # Calculate the size of the bytes in this hardware group
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
+    def _prepare_load_cells_record(self):
+        """
+        Handles creating the calibration dictionary of the load cells hardware group.
+
+        @return: load cells hardware group dictionary and the byte size of this hardware group
+        """
+        hardware_names = ['load_cell_a1', 'load_cell_a2', 'load_cell_b1', 'load_cell_b2']
+        group_byte_size = 0
+        group_name = 'load_cells'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+
+            hardware[i] = {'gain': ['<f', self.DEFAULT_GAIN_VALUE], 'offset': ['<f', self.DEFAULT_OFFSET_VALUE],
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+
+            # Calculate the size of the bytes in this hardware group
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
+    def _prepare_temperature_sensors_record(self):
+        """
+        Handles creating the calibration dictionary of the temperature sensors hardware group.
+
+        @return: temperature sensors hardware group dictionary and the byte size of this hardware group
+        """
+        hardware_names = ['fpga_board', 'load_cell_a1_b1', 'load_cell_a2_b2', 'thdo_rtd', 'tdi_rtd', 'internal_cond',
+                          'onboard_ntc', 'power_supply_1', 'power_supply_2', 'outlet_redundant', 'inlet_dialysate',
+                          'inlet_primary_heater', 'outlet_primary_heater', 'cond_sensor_1', 'cond_sensor_2',
+                          'reserved_1', 'reserved_2', 'reserved_3', 'reserved_4', 'reserved_5']
+        group_byte_size = 0
+        group_name = 'temperature_sensors'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+
+            hardware[i] = {'gain': ['<f', self.DEFAULT_GAIN_VALUE], 'offset': ['<f', self.DEFAULT_OFFSET_VALUE],
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+
+            # Calculate the size of the bytes in this hardware group
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
+    def _prepare_conductivity_sensors_record(self):
+        """
+        Handles creating the calibration dictionary of the conductivity sensors hardware group.
+
+        @return: conductivity sensors hardware group dictionary and the byte size of this hardware group
+        """
+        hardware_names = ['cpi', 'cpo', 'cd1', 'cd2', 'reserved_1', 'reserved_2']
+        group_byte_size = 0
+        group_name = 'conductivity_sensors'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+
+            hardware[i] = {'gain': ['<f', self.DEFAULT_GAIN_VALUE], 'offset': ['<f', self.DEFAULT_OFFSET_VALUE],
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+
+            # Calculate the size of the bytes in this hardware group
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
+    def _prepare_pumps_record(self):
+        """
+        Handles creating the calibration dictionary of the DG pumps.
+
+        @return: DG pumps hardware group dictionary and the byte size of this hardware group
+        """
+        hardware_names = ['concentrate_1', 'concentrate_2', 'drain', 'ro']
+        group_byte_size = 0
+        group_name = 'pumps'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+            # Different pumps have different calibration values
+            if i == 'concentrate_1' or i == 'concentrate_2':
+                hardware[i] = {'step_speed_2_flow_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
+                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
+                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            elif i == 'drain':
+                hardware[i] = {'voltage_2_speed_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
+                               'step_speed_2_flow_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
+                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
+                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            elif i == 'ro':
+                hardware[i] = {'gain_1_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
+                               'gain_2_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
+                               'gain_3_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
+                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
+                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
+    def _prepare_volume_record(self):
+        """
+        Handles creating the calibration dictionary of the DG volumes.
+
+        @return: DG volumes hardware group dictionary and the byte size of this hardware group
+        """
+        hardware_names = ['drain_line', 'pre_ro_purge', 'reservoir_1', 'reservoir_2', 'reserved_1', 'reserved_2',
+                          'reserved_3', 'reserved_4']
+        group_byte_size = 0
+        group_name = 'volumes'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+            if i == 'drain_line':
+                hardware[i] = {'volume': ['<f', self.DEFAULT_VOLUME_VALUE],
+                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
+                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            elif i == 'pre_ro_purge':
+                hardware[i] = {'pressure_2_flow_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
+                               'volume': ['<f', self.DEFAULT_VOLUME_VALUE],
+                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
+                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            elif i == 'reservoir_1' or i == 'reservoir_2':
+                hardware[i] = {'reservoir_volume': ['<f', self.DEFAULT_VOLUME_VALUE],
+                               'normal_fill_volume': ['<f', self.DEFAULT_VOLUME_VALUE],
+                               'max_residual_fluid': ['<f', self.DEFAULT_VOLUME_VALUE],
+                               'reservoir_unfilled_weight': ['<f', self.DEFAULT_VOLUME_VALUE],
+                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
+                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            else:
+                hardware[i] = {'volume': ['<f', self.DEFAULT_VOLUME_VALUE],
+                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
+                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
+    def _prepare_acid_concentrates_record(self):
+        """
+        Handles creating the calibration dictionary of the DG acid concentrates.
+
+        @return: DG acid concentrates hardware group dictionary and the byte size of this hardware group
+        """
+        hardware_names = ['acid_conc_1', 'acid_conc_2', 'acid_conc_3', 'acid_conc_4', 'acid_conc_5']
+        group_byte_size = 0
+        group_name = 'acid_concentrates'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+            hardware[i] = {'acid_conc_mix_ratio': ['<f', self.DEFAULT_CONCENTRATE_VALUE],
+                           'start_volume': ['<f', self.DEFAULT_VOLUME_VALUE],
+                           'reserved_space': ['<f', self.DEFAULT_VOLUME_VALUE],
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
+    def _prepare_bicarb_concentrates_record(self):
+        """
+        Handles creating the calibration dictionary of the DG bicarb concentrates.
+
+        @return: DG bicarb concentrates hardware group dictionary and the byte size of this hardware group
+        """
+        hardware_names = ['bicarb_conc_1', 'bicarb_conc_2', 'bicarb_conc_3', 'bicarb_conc_4', 'bicarb_conc_5']
+        group_byte_size = 0
+        group_name = 'bicarb_concentrates'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+            hardware[i] = {'bicarb_conc_mix_ratio': ['<f', self.DEFAULT_CONCENTRATE_VALUE],
+                           'start_volume': ['<f', self.DEFAULT_VOLUME_VALUE],
+                           'reserved_space': ['<f', self.DEFAULT_VOLUME_VALUE],
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
+    def _prepare_filters_record(self):
+        """
+        Handles creating the calibration dictionary of the DG filters.
+
+        @return: DG filters hardware group dictionary and the byte size of this hardware group
+        """
+        hardware_names = ['ro_filter', 'ultra_filter', 'sediment_filter', 'carbon_filter', 'carbon_polish_filter']
+        group_byte_size = 0
+        group_name = 'filters'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+            hardware[i] = {'reserved_space_1': ['<f', self.DEFAULT_CALIBRATION_VALUE],
+                           'reserved_space_2': ['<f', self.DEFAULT_CALIBRATION_VALUE],
+                           'reserved_space_3': ['<f', self.DEFAULT_CALIBRATION_VALUE],
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
+    def _prepare_fans_record(self):
+        """
+        Handles creating the calibration dictionary of the DG fans.
+
+        @return: DG fans hardware group dictionary and the byte size of this hardware group
+        """
+        hardware_names = ['fan_1', 'fan_2']
+        group_byte_size = 0
+        group_name = 'fans'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+            hardware[i] = {'reserved_space_1': ['<f', self.DEFAULT_CALIBRATION_VALUE],
+                           'reserved_space_2': ['<f', self.DEFAULT_CALIBRATION_VALUE],
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
+    def _calculate_group_byte_size(self, group):
+        """
+        Handles calculating the byte size of the values of the provided dictionary.
+
+        @param group: the dictionary that is passed to calculate the byte size
+        @return: calculated byte size
+        """
+        byte_size = 0
+        for key in group.keys():
+            data_type = group[key][self.CALIBRATION_DATA_TYPE_INDEX]
+            byte_size += self._get_data_type_bytes(data_type)
+
+        return byte_size
+
+    @staticmethod
+    def _get_data_type_bytes(data):
+        """
+        Handles converting the string representation of the bytes of the data types in a struct to numbers.
+        This is a static method.
+
+        @param data: the data to be converted to bytes in number
+        @return: calculated byte size
+        """
+        number_of_bytes = 0
+        # Unsigned integer = i
+        # Signed integer = I
+        # Float = f. All 4 bytes.
+        if data == '<i' or data == '<f':
+            number_of_bytes = 4
+        # Unsigned short = H. 2 bytes.
+        elif data == '<H':
+            number_of_bytes = 2
+        # Unsigned char = B. 1 byte.
+        elif data == '<B':
+            number_of_bytes = 1
+
+        return number_of_bytes
+
+    def set_dg_calibration_data(self):
+        """
+        Handles updating the DG calibration record with the newest calibration data of a hardware and sends it to FW.
+
+        @return: none
+        """
+        # TODO remove for testing only
+        self.DG_CALIBRATION_RECORD['pressure_sensors']['ppi']['offset'] = ['<f', 23.0]
+        self.DG_CALIBRATION_RECORD['pressure_sensors']['ppi']['gain'] = ['<f', 6.7]
+        cal_time = int(datetime.datetime.now().timestamp())
+        self.DG_CALIBRATION_RECORD['pressure_sensors']['ppi']['cal_time'] = ['<i', cal_time]
+
+        offset = struct.pack(self.DG_CALIBRATION_RECORD['pressure_sensors']['pdr']['offset'][0],
+                             self.DG_CALIBRATION_RECORD['pressure_sensors']['pdr']['offset'][1])
+        gain = struct.pack(self.DG_CALIBRATION_RECORD['pressure_sensors']['pdr']['gain'][0],
+                           self.DG_CALIBRATION_RECORD['pressure_sensors']['pdr']['gain'][1])
+        time_2 = struct.pack(self.DG_CALIBRATION_RECORD['pressure_sensors']['pdr']['cal_time'][0],
+                             self.DG_CALIBRATION_RECORD['pressure_sensors']['pdr']['cal_time'][1])
+        data_byte = b''
+        data_byte = offset + gain + time_2
+        crc_test = crc_16(data_byte)
+        self.DG_CALIBRATION_RECORD['pressure_sensors']['pdr']['crc'][1] = crc_test
+        self.DG_CALIBRATION_RECORD['conductivity_sensors']['reserved_2']['offset'] = ['<f', 159.25]
+        # TODO remove for testing only
+
+        # This list contains different data packet lists
+        # i.e. [[message 1, payload], [message 2, payload], ...]
+        cal_record_packets = []
+        current_payload_length = 0
+        current_message_count = 1
+        temp_buffer = [0, 0, 0]
+
+        # Loop through the DG calibration dictionary
+        for group in self.DG_CALIBRATION_RECORD.keys():
+
+            # 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_CALIBRATION_RECORD[group][self.CALIBRATION_DATA_TYPE_INDEX]
+
+                current_payload_length += self._get_data_type_bytes(data_type)
+                temp_buffer[self.PAYLOAD_CAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                temp_buffer.append(struct.pack(data_type, self.DG_CALIBRATION_RECORD[group]
+                                                                                    [self.CALIBRATION_VALUE_INDEX]))
+                cal_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_CALIBRATION_RECORD[group][self.CALIBRATION_VALUE_INDEX]) != 0:
+                    # Get the data type and calculate the number of bytes
+                    data_type = self.DG_CALIBRATION_RECORD[group][self.CALIBRATION_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_CALIBRATION_RECORD[group][self.CALIBRATION_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_CAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                            cal_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_CALIBRATION_RECORD[group].keys():
+                    for hardware in self.DG_CALIBRATION_RECORD[group][hardware_group]:
+                        # Get the data type and calculate the number of bytes
+                        data_type = self.DG_CALIBRATION_RECORD[group][hardware_group][hardware]\
+                                                              [self.CALIBRATION_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_CALIBRATION_RECORD[group][hardware_group]
+                                                                            [hardware][self.CALIBRATION_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_CAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                            # Append the temp buffer list into the main list to be process later
+                            cal_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_CALIBRATION_RECORD[group][hardware_group]
+                                                                             [hardware][self.CALIBRATION_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 cal_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 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 cal_record_packets.index(cal) == len(cal_record_packets) - 1:
+                data += b''.join(cal[self.CALIBRATION_RECORDS_SPECS_BYTE_ARRAY:-1])
+            else:
+                # Get all the elements including the last one
+                data += b''.join(cal[self.CALIBRATION_RECORDS_SPECS_BYTE_ARRAY:])
+
+        # Calculate the 16-bit crc.
+        crc = crc_16(data)
+        # Convert the crc into a 2-byte value
+        cal_record_crc = struct.pack('<H', crc)
+        # Insert the CRC into the last element of the last data packet
+        cal_record_packets[-1][-1] = cal_record_crc
+
+        print('CRC: ', hex(crc)) #TODO remove
+
+        self.logger.debug('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 cal_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 data.
+            packet[1] = struct.pack('<i', current_message_count)
+            # Convert the list packet to a bytearray
+            payload = b''.join(packet)
+            print(len(payload), payload) # TODO remove
+
+            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/dialysate_generator.py
===================================================================
diff -u -r43e8345862c72340680c045e53b310aa291513a6 -re36d87e663d95c79214f66b5db9aa6d6e8b47adf
--- dialin/dg/dialysate_generator.py	(.../dialysate_generator.py)	(revision 43e8345862c72340680c045e53b310aa291513a6)
+++ dialin/dg/dialysate_generator.py	(.../dialysate_generator.py)	(revision e36d87e663d95c79214f66b5db9aa6d6e8b47adf)
@@ -31,9 +31,10 @@
 from .fans import Fans
 from .uv_reactors import UVReactors
 from .concentrate_pumps import ConcentratePumps
-from .calibration import DGCalibration
+from .calibration_record import DGCalibration
 from .system_record import DGSystemRecord
 from .service_record import DGServicRecord
+from .scheduled_runs_record import DGScheduledRunsRecord
 from ..utils.conversions import integer_to_bytearray
 from ..protocols.CAN import (DenaliCanMessenger, DenaliMessage, DenaliChannels)
 from ..utils.base import _AbstractSubSystem, _publish, _LogManager
@@ -154,6 +155,7 @@
         self.calibration = DGCalibration(self.can_interface, self.logger)
         self.system_record = DGSystemRecord(self.can_interface, self.logger)
         self.service_record = DGServicRecord(self.can_interface, self.logger)
+        self.scheduled_runs_record = DGScheduledRunsRecord(self.can_interface, self.logger)
 
     def get_version(self):
         """
Index: dialin/dg/scheduled_runs_record.py
===================================================================
diff -u
--- dialin/dg/scheduled_runs_record.py	(revision 0)
+++ dialin/dg/scheduled_runs_record.py	(revision e36d87e663d95c79214f66b5db9aa6d6e8b47adf)
@@ -0,0 +1,426 @@
+
+import struct
+import datetime
+import time
+import math
+from collections import OrderedDict
+from ..ui.crc import crc_16
+from ..common.msg_defs import MsgIds, MsgFieldPositions
+from ..protocols.CAN import (DenaliMessage, DenaliChannels)
+from ..utils.base import _AbstractSubSystem, DialinEnum
+from logging import Logger
+
+
+class DGScheduledRunsRecord(_AbstractSubSystem):
+    """
+
+    Dialysate Generator (DG) Dialin API sub-class for scheduled runs commands.
+    """
+
+    SCHEDULED_RUNS_RECORD_START_INDEX = 6
+    SCHEDULED_RECORD_SPECS_BYTES = 12
+    SCHEDULED_RECORDS_SPECS_BYTE_ARRAY = 3
+
+    MAX_PART_NUMBER_BYTES = 10
+    MAX_SERIAL_NUMBER_BYTES = 15
+
+    DEFAULT_SCHEDULED_RUNS_DATE_VALUE = 0
+    DEFAULT_SCHEDULED_RUNS_CRC_VALUE = 0
+    DEFAULT_SCHEDULED_RUNS_PADDING_VALUE = 0
+
+    CURRENT_MESSAGE_NUM_INDEX = 0
+    TOTAL_MESSAGES_NUM_INDEX = 4
+    PAYLOAD_LENGTH_INDEX = 8
+    PAYLOAD_START_INDEX = 12
+
+    SCHEDULED_RUNS_DATA_TYPE_INDEX = 0
+    SCHEDULED_RUNS_VALUE_INDEX = 1
+
+    TARGET_BYTES_TO_SEND_TO_FW = 150
+    MIN_PAYLOAD_BYTES_SPACE = 4
+
+    RTC_RAM_MAX_BYTES_TO_WRITE = 64
+
+    PAYLOAD_CURRENT_MSG_INDEX = 0
+    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()
+
+    def __init__(self, can_interface, logger: Logger):
+        """
+
+        @param can_interface: Denali CAN Messenger object
+        """
+
+        super().__init__()
+
+        self.can_interface = can_interface
+        self.logger = logger
+        self.current_message = 0
+        self.total_messages = 0
+        self.length = 0
+        self.cal_data = 0
+        self.raw_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):
+        """
+        Handles getting DG scheduled runs record from firmware.
+
+        @return: None
+        """
+        # 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.
+
+        @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')
+
+        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
+
+    def _handler_dg_scheduled_runs_record(self, message):
+        """
+        Handles published DG scheduled runs record messages. DG scheduled runs records are captured for processing and
+        updating the DG scheduled runs record.
+
+        @param message:  published DG scheduled runs record data message
+
+        @return: None
+        """
+        curr = struct.unpack('i', bytearray(
+            message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0]
+        total = struct.unpack('i', bytearray(
+            message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0]
+        length = struct.unpack('i', bytearray(
+            message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3]))[0]
+
+        self.current_message = curr
+        self.total_messages = total
+        self.length = length
+        # The end of scheduled runs record payload is from the start index + 12 bytes for the current message + total
+        # messages + the length of scheduled runs record. The rest is the CAN messaging CRC and is not needed.
+        end_of_data_index = self.SCHEDULED_RUNS_RECORD_START_INDEX + self.SCHEDULED_RECORD_SPECS_BYTES + self.length
+
+        # Get the scheduled runs data only
+        self.cal_data = message['message'][self.SCHEDULED_RUNS_RECORD_START_INDEX:end_of_data_index]
+
+        # Continue getting calibration records until the all the messages are received. Concatenate the
+        # calibration records to each other
+        if self.current_message <= self.total_messages:
+            self.raw_scheduled_runs_record += (message['message'][self.SCHEDULED_RUNS_RECORD_START_INDEX +
+                                                                  self.SCHEDULED_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._update_dg_scheduled_record_from_fw()
+
+    def _update_dg_scheduled_record_from_fw(self):
+        """
+        Handles parsing the scheduled runs messages that were received from DG firmware.
+
+        @return: None
+        """
+        raw_payload_temp_start_index = 0
+        # Convert the concatenated raw data into a byte array since the struct library requires byte arrays.
+        self.raw_scheduled_runs_record = bytearray(self.raw_scheduled_runs_record)
+
+        # Loop through the keys for the main calibration dictionary
+        # 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():
+            # 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]
+                # 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
+            elif group == 'padding':
+                # Get the data type
+                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])
+                # 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 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][
+                            self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
+                        value_bytes = self._get_data_type_bytes(data_type)
+                        # Unpack the values to written to the dictionary
+                        data = struct.unpack(data_type, self.raw_scheduled_runs_record[raw_payload_temp_start_index:
+                                                                            raw_payload_temp_start_index +
+                                                                            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.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
+        """
+        scheduled_runs = self._prepare_scheduled_runs()
+
+        # Build the CRC of the main record
+        record_crc = OrderedDict({'crc': ['<H', self.DEFAULT_SCHEDULED_RUNS_CRC_VALUE]})
+
+        # The second element of the hardware groups are the byte sizes, add them to calculate the overall byte size.
+        groups_byte_size = scheduled_runs[1] + self._get_data_type_bytes(record_crc['crc']
+                                                                                 [self.SCHEDULED_RUNS_DATA_TYPE_INDEX])
+        # Calculate the padding size:
+        # If bytes in the dictionary % max write bytes to EEPROM (16) is 0, not padding is needed
+        # Else padding = (ceil(dictionary bytes/max write to EEPROM (16)) * max write to EEPROM (16)) - dictionary bytes
+        if (groups_byte_size % self.RTC_RAM_MAX_BYTES_TO_WRITE) == 0:
+            padding_size = 0
+        else:
+            padding_size = (math.ceil(groups_byte_size / self.RTC_RAM_MAX_BYTES_TO_WRITE) *
+                            self.RTC_RAM_MAX_BYTES_TO_WRITE) - groups_byte_size
+        # 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}
+
+    def _prepare_scheduled_runs(self):
+        """
+        Handles creating the scheduled service dictionary.
+
+        @return: scheduled service dictionary and the byte size of this hardware group
+        """
+        hardware_names = ['flush', 'heat_disinfect', 'chemical_disinfect']
+        group_byte_size = 0
+        group_name = 'scheduled_runs'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+
+            hardware[i] = {'last_run_date': ['<i', self.DEFAULT_SCHEDULED_RUNS_DATE_VALUE],
+                           'crc': ['<H', self.DEFAULT_SCHEDULED_RUNS_CRC_VALUE]}
+            # Calculate the size of the bytes in this hardware group
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
+    def _calculate_group_byte_size(self, group):
+        """
+        Handles calculating the byte size of the values of the provided dictionary.
+
+        @param group: the dictionary that is passed to calculate the byte size
+        @return: calculated byte size
+        """
+        byte_size = 0
+
+        for key in group.keys():
+            data_type = group[key][self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
+            current_byte_size = self._get_data_type_bytes(data_type)
+            byte_size += current_byte_size
+
+        return byte_size
+
+    @staticmethod
+    def _get_data_type_bytes(data):
+        """
+        Handles converting the string representation of the bytes of the data types in a struct to numbers.
+        This is a static method.
+
+        @param data: the data to be converted to bytes in number
+        @return: calculated byte size
+        """
+        number_of_bytes = 0
+        # Unsigned integer = i
+        # Signed integer = I
+        # Float = f. All 4 bytes.
+        if data == '<i' or data == '<f':
+            number_of_bytes = 4
+        # Unsigned short = H. 2 bytes.
+        elif data == '<H':
+            number_of_bytes = 2
+        # Unsigned char = B. 1 byte.
+        elif data == '<B' or data == '<c':
+            number_of_bytes = 1
+
+        return number_of_bytes
+
+    def set_dg_scheduled_runs_record(self):
+        """
+        Handles updating the DG system record with the newest calibration data of a hardware and sends it to FW.
+
+        @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]
+
+        # Loop through the DG calibration dictionary
+        for group in self.DG_SCHEDULED_RUNS_RECORD.keys():
+
+            # 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 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:
+            # 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 data.
+            packet[1] = struct.pack('<i', current_message_count)
+            # 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_SCHEDULED_RUNS_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
\ No newline at end of file
Index: dialin/dg/system_record.py
===================================================================
diff -u -r43e8345862c72340680c045e53b310aa291513a6 -re36d87e663d95c79214f66b5db9aa6d6e8b47adf
--- dialin/dg/system_record.py	(.../system_record.py)	(revision 43e8345862c72340680c045e53b310aa291513a6)
+++ dialin/dg/system_record.py	(.../system_record.py)	(revision e36d87e663d95c79214f66b5db9aa6d6e8b47adf)
@@ -231,8 +231,8 @@
             groups_byte_size += self._calculate_group_byte_size(system_records[record])
 
         # Build the CRC of the main system record
-        cal_record_crc = OrderedDict({'crc': ['<H', self.DEFAULT_SYS_CRC_VALUE]})
-        groups_byte_size += self._calculate_group_byte_size(cal_record_crc)
+        record_crc = OrderedDict({'crc': ['<H', self.DEFAULT_SYS_CRC_VALUE]})
+        groups_byte_size += self._calculate_group_byte_size(record_crc)
 
         # Calculate the padding size:
         # If bytes in the dictionary % max write bytes to EEPROM (16) is 0, not padding is needed
@@ -245,7 +245,7 @@
         # Create the padding dictionary as list of unsigned char. All the elements are 0.
         padding = OrderedDict({'padding': ['<B', [self.DEFAULT_SYS_PADDING_VALUE] * padding_size]})
 
-        self.DG_SYSTEM_RECORD = {**system_records, **padding, **cal_record_crc}
+        self.DG_SYSTEM_RECORD = {**system_records, **padding, **record_crc}
 
     def _calculate_group_byte_size(self, group):
         """
Index: tests/test_dg_scheduled_runs.py
===================================================================
diff -u
--- tests/test_dg_scheduled_runs.py	(revision 0)
+++ tests/test_dg_scheduled_runs.py	(revision e36d87e663d95c79214f66b5db9aa6d6e8b47adf)
@@ -0,0 +1,28 @@
+from dialin.dg.dialysate_generator import DG
+from dialin.ui import crc
+from time import sleep
+import struct
+
+if __name__ == "__main__":
+    # Create an instance of the DG Class
+    dg = DG(log_level='DEBUG')
+
+    if dg.cmd_log_in_to_dg() == 0:
+        exit(1)
+    sleep(2)
+
+    sch = dg.scheduled_runs_record
+
+    sch.DG_SCHEDULED_RUNS_RECORD['scheduled_runs']['heat_disinfect']['last_run_date'][1] = 34567
+    print(sch.DG_SCHEDULED_RUNS_RECORD)
+
+    sch.get_dg_scheduled_runs_record()
+
+    while True:
+        sleep(0.2)
+        if sch.current_message == sch.total_messages:
+            break
+
+    print(sch.DG_SCHEDULED_RUNS_RECORD)
+
+    #sch.set_dg_scheduled_runs_record()
\ No newline at end of file