Index: dialin/common/msg_defs.py
===================================================================
diff -u -r6d387cadbda3027d23510126942eaa9f6317d357 -r1e51132e2b4eae6110d673bd4af934235cd76e36
--- dialin/common/msg_defs.py	(.../msg_defs.py)	(revision 6d387cadbda3027d23510126942eaa9f6317d357)
+++ dialin/common/msg_defs.py	(.../msg_defs.py)	(revision 1e51132e2b4eae6110d673bd4af934235cd76e36)
@@ -219,6 +219,7 @@
     MSG_ID_DG_SET_CALIBRATION_DATA = 0xA033                     # DG set calibration data
     MSG_ID_DG_GET_CALIBRATION_DATA = 0xA034                     # DG get calibration data
     MSG_ID_DG_SEND_CALIBRATION_DATA = 0xA035                    # DG send calibration data
+    MSG_ID_DG_SET_SYSTEM_DATA = 0xA036                          # DG send system data
 
     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
Index: dialin/dg/calibration.py
===================================================================
diff -u -ra2c50fa966d483afdcff983ef80b03d2d0e77b5b -r1e51132e2b4eae6110d673bd4af934235cd76e36
--- dialin/dg/calibration.py	(.../calibration.py)	(revision a2c50fa966d483afdcff983ef80b03d2d0e77b5b)
+++ dialin/dg/calibration.py	(.../calibration.py)	(revision 1e51132e2b4eae6110d673bd4af934235cd76e36)
@@ -24,6 +24,9 @@
     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
 
@@ -211,13 +214,18 @@
         temperature = self._prepare_temperature_sensors_record()
         conductivity = self._prepare_conductivity_sensors_record()
         pumps = self._prepare_pumps_record()
-        volumes = self._prepare_volume_records()
+        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] + self._get_data_type_bytes(cal_record_crc['crc'][self.CALIBRATION_DATA_TYPE_INDEX])
+            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
@@ -232,7 +240,8 @@
         # 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], **padding, **cal_record_crc}
+                                      **pumps[0], **volumes[0], **acid[0], **bicarb[0], **filters[0], **fans[0],
+                                      **padding, **cal_record_crc}
 
     def _prepare_pressure_sensors_cal_record(self):
         """
@@ -387,7 +396,7 @@
 
         return hardware_group, group_byte_size
 
-    def _prepare_volume_records(self):
+    def _prepare_volume_record(self):
         """
         Handles creating the calibration dictionary of the DG volumes.
 
@@ -427,6 +436,97 @@
 
         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.
Index: dialin/dg/dialysate_generator.py
===================================================================
diff -u -r1b2e845397cd3f595eaaf743567f09742c737a6d -r1e51132e2b4eae6110d673bd4af934235cd76e36
--- dialin/dg/dialysate_generator.py	(.../dialysate_generator.py)	(revision 1b2e845397cd3f595eaaf743567f09742c737a6d)
+++ dialin/dg/dialysate_generator.py	(.../dialysate_generator.py)	(revision 1e51132e2b4eae6110d673bd4af934235cd76e36)
@@ -32,6 +32,7 @@
 from .uv_reactors import UVReactors
 from .concentrate_pumps import ConcentratePumps
 from .calibration import DGCalibration
+from .system_record import DGSystem
 from ..utils.conversions import integer_to_bytearray
 from ..protocols.CAN import (DenaliCanMessenger, DenaliMessage, DenaliChannels)
 from ..utils.base import _AbstractSubSystem, _publish, _LogManager
@@ -150,6 +151,7 @@
         self.fans = Fans(self.can_interface, self.logger)
         self.uv_reactors = UVReactors(self.can_interface, self.logger)
         self.calibration = DGCalibration(self.can_interface, self.logger)
+        self.system_record = DGSystem(self.can_interface, self.logger)
 
     def get_version(self):
         """
Index: dialin/dg/system_record.py
===================================================================
diff -u
--- dialin/dg/system_record.py	(revision 0)
+++ dialin/dg/system_record.py	(revision 1e51132e2b4eae6110d673bd4af934235cd76e36)
@@ -0,0 +1,312 @@
+
+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, DialinEnum
+from logging import Logger
+from enum import unique
+
+
+@unique
+class MFGLocation(DialinEnum):
+    MFG_LOCATION_FACTORY = 0
+
+
+class DGSystem(_AbstractSubSystem):
+    """
+
+    Dialysate Generator (DG) Dialin API sub-class for system record commands.
+    """
+
+    SYSTEM_RECORD_START_INDEX = 6
+    SYSTEM_RECORD_SPECS_BYTES = 12
+    SYSTEM_RECORDS_SPECS_BYTE_ARRAY = 3
+
+    MAX_PART_NUMBER_BYTES = 10
+    MAX_SERIAL_NUMBER_BYTES = 15
+
+    DEFAULT_CHAR_VALUES = '1'
+    DEFAULT_MFG_LOCATION = MFGLocation.MFG_LOCATION_FACTORY.value
+    DEFAULT_MFG_DATE = 0
+    DEFAULT_SYS_TIME_VALUE = 0
+    DEFAULT_SYS_CRC_VALUE = 0
+    DEFAULT_SYS_PADDING_VALUE = 0
+
+    CURRENT_MESSAGE_NUM_INDEX = 0
+    TOTAL_MESSAGES_NUM_INDEX = 4
+    PAYLOAD_LENGTH_INDEX = 8
+    PAYLOAD_START_INDEX = 12
+
+    SYSTEM_DATA_TYPE_INDEX = 0
+    SYSTEM_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_SYS_BYTES_INDEX = 2
+
+    # DG system main record as an ordered dictionary
+    DG_SYSTEM_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_SET_SYSTEM_DATA.value
+            self.can_interface.register_receiving_publication_function(channel_id, msg_id,
+                                                                       self._handler_dg_system_record)
+        # Prepare the calibration record by putting sub-dictionaries together
+        self._prepare_dg_system_record()
+
+    def _handler_dg_system_record(self):
+        pass
+
+    def _prepare_dg_system_record(self):
+
+        groups_byte_size = 0
+        system_records = OrderedDict({'system_record':
+                          {'top_level_pn': ['<c', [self.DEFAULT_CHAR_VALUES] * self.MAX_PART_NUMBER_BYTES],
+                           'top_level_sn': ['<c', [self.DEFAULT_CHAR_VALUES] * self.MAX_SERIAL_NUMBER_BYTES],
+                           'mfg_location': ['<B', self.DEFAULT_MFG_LOCATION],
+                           'mfg_date': ['<i', self.DEFAULT_SYS_TIME_VALUE], 'crc': ['<H', self.DEFAULT_SYS_CRC_VALUE]}})
+
+        for record in system_records.keys():
+            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)
+
+        # 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_SYS_PADDING_VALUE] * padding_size]})
+
+        self.DG_SYSTEM_RECORD = {**system_records, **padding, **cal_record_crc}
+
+    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.SYSTEM_DATA_TYPE_INDEX]
+            current_byte_size = self._get_data_type_bytes(data_type)
+
+            if type(group[key][self.SYSTEM_VALUE_INDEX]) == list:
+                byte_size += len(group[key][self.SYSTEM_VALUE_INDEX]) * current_byte_size
+            else:
+                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_system_data(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], ...]
+        sys_record_packets = []
+        current_payload_length = 0
+        current_message_count = 1
+        temp_buffer = [0, 0, 0]
+        is_data_list = False
+
+        # Loop through the DG calibration dictionary
+        for group in self.DG_SYSTEM_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_SYSTEM_RECORD[group][self.SYSTEM_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_SYS_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                temp_buffer.append(struct.pack(data_type, self.DG_SYSTEM_RECORD[group][self.SYSTEM_VALUE_INDEX]))
+                sys_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_SYSTEM_RECORD[group][self.SYSTEM_VALUE_INDEX]) != 0:
+                    # Get the data type and calculate the number of bytes
+                    data_type = self.DG_SYSTEM_RECORD[group][self.SYSTEM_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_SYSTEM_RECORD[group][self.SYSTEM_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_SYS_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                            sys_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:
+                for key in self.DG_SYSTEM_RECORD[group].keys():
+
+                    list_of_keys = list(self.DG_SYSTEM_RECORD[group].keys())
+
+                    data_type = self.DG_SYSTEM_RECORD[group][key][self.SYSTEM_DATA_TYPE_INDEX]
+                    data_type_bytes = self._get_data_type_bytes(data_type)
+                    current_value = self.DG_SYSTEM_RECORD[group][key][self.SYSTEM_VALUE_INDEX]
+
+                    if type(current_value) == list:
+                        data_type_bytes *= len(current_value)
+                        is_data_list = True
+
+                    # 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
+                        if is_data_list:
+                            for i in current_value:
+                                temp_buffer.append(struct.pack(data_type, i.encode('ascii')))
+                            is_data_list = False
+                        else:
+                            temp_buffer.append(struct.pack(data_type, current_value))
+
+                        if list_of_keys.index(key) == len(list_of_keys) - 1:
+                            temp_buffer[self.PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
+                            temp_buffer[self.PAYLOAD_SYS_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                    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_SYS_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                        # Append the temp buffer list into the main list to be process later
+                        sys_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)]
+                        if is_data_list:
+                            for i in current_value:
+                                temp_buffer.append(struct.pack(data_type, i))
+                            is_data_list = False
+                        else:
+                            temp_buffer.append(struct.pack(data_type, current_value))
+
+        # Creating a byte array variable and add all the data packets
+        # to one to calculate the final CRC
+        data = b''
+        for cal in sys_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 sys_record_packets.index(cal) == len(sys_record_packets) - 1:
+                data += b''.join(cal[self.SYSTEM_RECORDS_SPECS_BYTE_ARRAY:-1])
+            else:
+                # Get all the elements including the last one
+                data += b''.join(cal[self.SYSTEM_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
+        sys_record_packets[-1][-1] = cal_record_crc
+
+        print('CRC: ', hex(crc)) #TODO remove
+
+        self.logger.debug('DG system 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 sys_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_SYSTEM_DATA.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: tests/test_dg_calibration.py
===================================================================
diff -u -ra2c50fa966d483afdcff983ef80b03d2d0e77b5b -r1e51132e2b4eae6110d673bd4af934235cd76e36
--- tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision a2c50fa966d483afdcff983ef80b03d2d0e77b5b)
+++ tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision 1e51132e2b4eae6110d673bd4af934235cd76e36)
@@ -27,6 +27,8 @@
     cal.DG_CALIBRATION_RECORD['volumes']['drain_line']['crc'][1] = 78
     cal.DG_CALIBRATION_RECORD['volumes']['pre_ro_purge']['volume'][1] = 125.8
     cal.DG_CALIBRATION_RECORD['volumes']['reservoir_1']['max_residual_fluid'][1] = 85.36
+    cal.DG_CALIBRATION_RECORD['bicarb_concentrates']['bicarb_conc_3']['reserved_space'][1] = 85.36
+    cal.DG_CALIBRATION_RECORD['fans']['fan_2']['reserved_space_2'][1] = 456.25
     #print(cal.DG_CALIBRATION_RECORD)
 
     try:
Index: tests/test_dg_system_record.py
===================================================================
diff -u
--- tests/test_dg_system_record.py	(revision 0)
+++ tests/test_dg_system_record.py	(revision 1e51132e2b4eae6110d673bd4af934235cd76e36)
@@ -0,0 +1,21 @@
+from ctypes import *
+from collections import OrderedDict
+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)
+    sys = dg.system_record
+    sys.DG_SYSTEM_RECORD['system_record']['top_level_sn'][1] = ['A', 'D', '-', '1', '4', '0', '0', '7', '0', '0', '0', 'G', '0', '0', '0']
+    print((sys.DG_SYSTEM_RECORD))
+
+    sys.set_system_data()
+
+    #print(cal.DG_SYSTEM_RECORD['system_record']['top_level_sn'][1])