Index: dialin/common/msg_defs.py
===================================================================
diff -u -r1e51132e2b4eae6110d673bd4af934235cd76e36 -r43e8345862c72340680c045e53b310aa291513a6
--- dialin/common/msg_defs.py	(.../msg_defs.py)	(revision 1e51132e2b4eae6110d673bd4af934235cd76e36)
+++ dialin/common/msg_defs.py	(.../msg_defs.py)	(revision 43e8345862c72340680c045e53b310aa291513a6)
@@ -216,10 +216,15 @@
     MSG_ID_DG_RO_FLOW_RATE_OVERRIDE = 0xA030                    # DG RO flow rate override
     MSG_ID_DG_RO_PUMP_TARGET_FLOW_OVERRIDE = 0xA031             # DG RO pump target flow rate override
     MSG_ID_DG_RO_PUMP_TARGET_PRESSURE_OVERRIDE = 0xA032         # DG RO pump target pressure override
-    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_DG_SET_CALIBRATION_RECORD = 0xA033                   # DG set calibration record
+    MSG_ID_DG_GET_CALIBRATION_RECORD = 0xA034                   # DG get calibration record
+    MSG_ID_DG_SEND_CALIBRATION_RECORD = 0xA035                  # DG send calibration record from firmware
+    MSG_ID_DG_SET_SYSTEM_RECORD = 0xA036                        # DG send system record
+    MSG_ID_DG_GET_SYSTEM_RECORD = 0xA037                        # DG get system record
+    MSG_ID_DG_SEND_SYSTEM_RECORD = 0xA038                       # DG send system record from firmware
+    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_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 -r1e51132e2b4eae6110d673bd4af934235cd76e36 -r43e8345862c72340680c045e53b310aa291513a6
--- dialin/dg/calibration.py	(.../calibration.py)	(revision 1e51132e2b4eae6110d673bd4af934235cd76e36)
+++ dialin/dg/calibration.py	(.../calibration.py)	(revision 43e8345862c72340680c045e53b310aa291513a6)
@@ -69,13 +69,13 @@
         if self.can_interface is not None:
 
             channel_id = DenaliChannels.dg_to_dialin_ch_id
-            msg_id = MsgIds.MSG_ID_DG_SEND_CALIBRATION_DATA.value
+            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_data(self):
+    def get_dg_calibration_record(self):
         """
         Handles getting DG calibration data from firmware.
 
@@ -84,16 +84,16 @@
         # 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_data()
+        self._request_dg_fw_calibration_record()
 
-    def _request_dg_fw_calibration_data(self):
+    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_DATA.value)
+                                              message_id=MsgIds.MSG_ID_DG_GET_CALIBRATION_RECORD.value)
 
         self.logger.debug('Getting DG calibration record')
 
@@ -709,7 +709,7 @@
             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_DATA.value,
+                                                  message_id=MsgIds.MSG_ID_DG_SET_CALIBRATION_RECORD.value,
                                                   payload=payload)
 
             received_message = self.can_interface.send(message)
Index: dialin/dg/dialysate_generator.py
===================================================================
diff -u -r1e51132e2b4eae6110d673bd4af934235cd76e36 -r43e8345862c72340680c045e53b310aa291513a6
--- dialin/dg/dialysate_generator.py	(.../dialysate_generator.py)	(revision 1e51132e2b4eae6110d673bd4af934235cd76e36)
+++ dialin/dg/dialysate_generator.py	(.../dialysate_generator.py)	(revision 43e8345862c72340680c045e53b310aa291513a6)
@@ -32,7 +32,8 @@
 from .uv_reactors import UVReactors
 from .concentrate_pumps import ConcentratePumps
 from .calibration import DGCalibration
-from .system_record import DGSystem
+from .system_record import DGSystemRecord
+from .service_record import DGServicRecord
 from ..utils.conversions import integer_to_bytearray
 from ..protocols.CAN import (DenaliCanMessenger, DenaliMessage, DenaliChannels)
 from ..utils.base import _AbstractSubSystem, _publish, _LogManager
@@ -151,7 +152,8 @@
         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)
+        self.system_record = DGSystemRecord(self.can_interface, self.logger)
+        self.service_record = DGServicRecord(self.can_interface, self.logger)
 
     def get_version(self):
         """
Index: dialin/dg/service_record.py
===================================================================
diff -u
--- dialin/dg/service_record.py	(revision 0)
+++ dialin/dg/service_record.py	(revision 43e8345862c72340680c045e53b310aa291513a6)
@@ -0,0 +1,406 @@
+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
+from enum import unique
+
+
+@unique
+class ServiceLocation(DialinEnum):
+    SERVICE_LOCATION_FACTORY = 0
+    SERVICE_LOCATION_FIELD = 1
+
+
+class DGServicRecord(_AbstractSubSystem):
+    """
+
+    Dialysate Generator (DG) Dialin API sub-class for service record commands.
+    """
+
+    SERVICE_RECORD_START_INDEX = 6
+    SERVICE_RECORD_SPECS_BYTES = 12
+    SERVICE_RECORDS_SPECS_BYTE_ARRAY = 3
+
+    DEFAULT_SERVICE_LOCATION = ServiceLocation.SERVICE_LOCATION_FACTORY.value
+    DEFAULT_MFG_DATE = 0
+    DEFAULT_SERVICE_DATE_VALUE = 0
+    DEFAULT_SERVICE_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
+
+    SERVICE_DATA_TYPE_INDEX = 0
+    SERVICE_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_SERVICE_BYTES_INDEX = 2
+
+    # DG system main record as an ordered dictionary
+    DG_SERVICE_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_service_record = []
+
+        if self.can_interface is not None:
+
+            channel_id = DenaliChannels.dg_to_dialin_ch_id
+            msg_id = MsgIds.MSG_ID_DG_SEND_SERVICE_RECORD.value
+            self.can_interface.register_receiving_publication_function(channel_id, msg_id,
+                                                                       self._handler_dg_service_record)
+        # Prepare the service record by putting sub-dictionaries together
+        self._prepare_dg_service_record()
+
+    def get_dg_service_record(self):
+        """
+        Handles getting DG service record from firmware.
+
+        @return: None
+        """
+        # Clear the list for the next call
+        self.raw_service_record.clear()
+        # Run the firmware commands to get the service record
+        self._request_dg_fw_service_record()
+
+    def _request_dg_fw_service_record(self):
+        """
+        Handles getting DG service record from firmware.
+
+        @return: None
+        """
+        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
+                                              message_id=MsgIds.MSG_ID_DG_GET_SERVICE_RECORD.value)
+
+        self.logger.debug('Getting DG service 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_service_record(self, message):
+        """
+        Handles published DG service record messages. DG system records are captured for processing and
+        updating the DG service record.
+
+        @param message:  published DG system 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 system record payload is from the start index + 12 bytes for the current message + total
+        # messages + the length of system record. The rest is the CAN messaging CRC that is not needed to be kept.
+        end_of_data_index = self.SERVICE_RECORD_START_INDEX + self.SERVICE_RECORD_SPECS_BYTES + self.length
+
+        # Get the calibration data only
+        self.cal_data = message['message'][self.SERVICE_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_service_record += (message['message'][self.SERVICE_RECORD_START_INDEX +
+                                                           self.SERVICE_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_service_record_from_fw()
+
+    def _update_dg_service_record_from_fw(self):
+        """
+        Handles parsing the system 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_service_record = bytearray(self.raw_service_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_SERVICE_RECORD.keys():
+            # All the hardware groups (i.e mfg date) 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_SERVICE_RECORD[group][self.SERVICE_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_service_record[raw_payload_temp_start_index:
+                                                                        raw_payload_temp_start_index + value_bytes])[0]
+                self.DG_SERVICE_RECORD[group][self.SERVICE_VALUE_INDEX] = data
+            elif group == 'padding':
+                # Get the data type
+                data_type = self.DG_SERVICE_RECORD[group][self.SERVICE_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_SERVICE_RECORD[group][self.SERVICE_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 system record which are layered dictionaries
+            else:
+                # If the value is not a CRC, it is nested dictionary of different system record values.
+                for key in self.DG_SERVICE_RECORD[group].keys():
+
+                    # 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_SERVICE_RECORD[group][key][self.SERVICE_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_service_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_SERVICE_RECORD[group][key][self.SERVICE_VALUE_INDEX] = data
+
+    def _prepare_dg_service_record(self):
+        """
+        Handles assembling the sub dictionaries of each group to make the main DG service record.
+
+        @return: None
+        """
+        groups_byte_size = 0
+        service_records = OrderedDict({'service_record':
+                                      {'service_location': ['<B', self.DEFAULT_SERVICE_LOCATION],
+                                       'service_date': ['<i', self.DEFAULT_SERVICE_DATE_VALUE],
+                                       'crc': ['<H', self.DEFAULT_SERVICE_CRC_VALUE]}})
+
+        for record in service_records.keys():
+            groups_byte_size += self._calculate_group_byte_size(service_records[record])
+
+        # Build the CRC of the main system record
+        cal_record_crc = OrderedDict({'crc': ['<H', self.DEFAULT_SERVICE_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 RTC RAM (64) is 0, not padding is needed
+        # Else padding = (ceil(dictionary bytes/max write to RTC RAM (64)) * max write to RTC RAM (64))-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_SYS_PADDING_VALUE] * padding_size]})
+
+        self.DG_SERVICE_RECORD = {**service_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.SERVICE_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_service_data(self):
+        """
+        Handles updating the DG service record with the newest data and sends it to FW.
+
+        @return: none
+        """
+
+        # This list contains different data packet lists
+        # i.e. [[message 1, payload], [message 2, payload], ...]
+        service_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_SERVICE_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_SERVICE_RECORD[group][self.SERVICE_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_SERVICE_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                temp_buffer.append(struct.pack(data_type, self.DG_SERVICE_RECORD[group][self.SERVICE_VALUE_INDEX]))
+                service_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_SERVICE_RECORD[group][self.SERVICE_VALUE_INDEX]) != 0:
+                    # Get the data type and calculate the number of bytes
+                    data_type = self.DG_SERVICE_RECORD[group][self.SERVICE_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_SERVICE_RECORD[group][self.SERVICE_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_SERVICE_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                            service_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_SERVICE_RECORD[group].keys():
+
+                    data_type = self.DG_SERVICE_RECORD[group][key][self.SERVICE_DATA_TYPE_INDEX]
+                    data_type_bytes = self._get_data_type_bytes(data_type)
+                    current_value = self.DG_SERVICE_RECORD[group][key][self.SERVICE_VALUE_INDEX]
+
+                    # 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)
+
+                        temp_buffer.append(struct.pack(data_type, current_value))
+
+                        temp_buffer[self.PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
+                        temp_buffer[self.PAYLOAD_SERVICE_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_SERVICE_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                        # Append the temp buffer list into the main list to be process later
+                        service_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, current_value)]
+
+        # Creating a byte array variable and add all the data packets
+        # to one to calculate the final CRC
+        data = b''
+        for svc in service_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 service_record_packets.index(svc) == len(service_record_packets) - 1:
+                data += b''.join(svc[self.SERVICE_RECORDS_SPECS_BYTE_ARRAY:-1])
+            else:
+                # Get all the elements including the last one
+                data += b''.join(svc[self.SERVICE_RECORDS_SPECS_BYTE_ARRAY:])
+
+        # Calculate the 16-bit crc.
+        crc = crc_16(data)
+        # Convert the crc into a 2-byte value
+        service_record_crc = struct.pack('<H', crc)
+        # Insert the CRC into the last element of the last data packet
+        service_record_packets[-1][-1] = service_record_crc
+
+        print('CRC: ', hex(crc))  # TODO remove
+
+        self.logger.debug('DG service 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 service_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_SERVICE_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 -r1e51132e2b4eae6110d673bd4af934235cd76e36 -r43e8345862c72340680c045e53b310aa291513a6
--- dialin/dg/system_record.py	(.../system_record.py)	(revision 1e51132e2b4eae6110d673bd4af934235cd76e36)
+++ dialin/dg/system_record.py	(.../system_record.py)	(revision 43e8345862c72340680c045e53b310aa291513a6)
@@ -7,7 +7,7 @@
 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 ..utils.base import _AbstractSubSystem, DialinEnum
 from logging import Logger
 from enum import unique
 
@@ -17,7 +17,7 @@
     MFG_LOCATION_FACTORY = 0
 
 
-class DGSystem(_AbstractSubSystem):
+class DGSystemRecord(_AbstractSubSystem):
     """
 
     Dialysate Generator (DG) Dialin API sub-class for system record commands.
@@ -30,7 +30,7 @@
     MAX_PART_NUMBER_BYTES = 10
     MAX_SERIAL_NUMBER_BYTES = 15
 
-    DEFAULT_CHAR_VALUES = '1'
+    DEFAULT_CHAR_VALUES = 'X'
     DEFAULT_MFG_LOCATION = MFGLocation.MFG_LOCATION_FACTORY.value
     DEFAULT_MFG_DATE = 0
     DEFAULT_SYS_TIME_VALUE = 0
@@ -44,6 +44,7 @@
 
     SYSTEM_DATA_TYPE_INDEX = 0
     SYSTEM_VALUE_INDEX = 1
+    SYSTEM_CHAR_LENGTH_INDEX = 2
 
     TARGET_BYTES_TO_SEND_TO_FW = 150
     MIN_PAYLOAD_BYTES_SPACE = 4
@@ -71,28 +72,160 @@
         self.total_messages = 0
         self.length = 0
         self.cal_data = 0
-        self.raw_cal_record = []
+        self.raw_sys_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
+            msg_id = MsgIds.MSG_ID_DG_SEND_SYSTEM_RECORD.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
+        # Prepare the system record by putting sub-dictionaries together
         self._prepare_dg_system_record()
 
-    def _handler_dg_system_record(self):
-        pass
+    def get_dg_system_record(self):
+        """
+        Handles getting DG system record from firmware.
 
+        @return: None
+        """
+        # Clear the list for the next call
+        self.raw_sys_record.clear()
+        # Run the firmware commands to get the system record
+        self._request_dg_fw_system_record()
+
+    def _request_dg_fw_system_record(self):
+        """
+        Handles getting DG system record from firmware.
+
+        @return: None
+        """
+        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
+                                              message_id=MsgIds.MSG_ID_DG_GET_SYSTEM_RECORD.value)
+
+        self.logger.debug('Getting DG system 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_system_record(self, message):
+        """
+        Handles published DG system record messages. DG system records are captured for processing and
+        updating the DG system record.
+
+        @param message:  published DG system 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 system record payload is from the start index + 12 bytes for the current message + total
+        # messages + the length of system record. The rest is the CAN messaging CRC that is not needed to be kept.
+        end_of_data_index = self.SYSTEM_RECORD_START_INDEX + self.SYSTEM_RECORD_SPECS_BYTES + self.length
+
+        # Get the calibration data only
+        self.cal_data = message['message'][self.SYSTEM_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_sys_record += (message['message'][self.SYSTEM_RECORD_START_INDEX +
+                                                       self.SYSTEM_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_system_record_from_fw()
+
+    def _update_dg_system_record_from_fw(self):
+        """
+        Handles parsing the system 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_sys_record = bytearray(self.raw_sys_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_SYSTEM_RECORD.keys():
+            # All the hardware groups (i.e mfg date) 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_SYSTEM_RECORD[group][self.SYSTEM_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_sys_record[raw_payload_temp_start_index:
+                                                                    raw_payload_temp_start_index + value_bytes])[0]
+                self.DG_SYSTEM_RECORD[group][self.SYSTEM_VALUE_INDEX] = data
+            elif group == 'padding':
+                # Get the data type
+                data_type = self.DG_SYSTEM_RECORD[group][self.SYSTEM_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_SYSTEM_RECORD[group][self.SYSTEM_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 system record which are layered dictionaries
+            else:
+                # If the value is not a CRC, it is nested dictionary of different system record values.
+                for key in self.DG_SYSTEM_RECORD[group].keys():
+                    data = ''
+                    # 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_SYSTEM_RECORD[group][key][self.SYSTEM_DATA_TYPE_INDEX]
+                    value_bytes = self._get_data_type_bytes(data_type)
+                    current_value = self.DG_SYSTEM_RECORD[group][key][self.SYSTEM_VALUE_INDEX]
+
+                    if data_type == '<c':
+                        for vl in current_value:
+                            # Unpack the values to written to the dictionary
+                            raw = struct.unpack(data_type, self.raw_sys_record[raw_payload_temp_start_index:
+                                                                               raw_payload_temp_start_index +
+                                                                               value_bytes])[0]
+                            data += raw.decode("utf-8")
+                            #self.DG_SERVICE_RECORD[group][key][self.SERVICE_VALUE_INDEX][current_value.index(vl)] = data
+                            raw_payload_temp_start_index += value_bytes
+                    else:
+                        # Unpack the values to written to the dictionary
+                        data = struct.unpack(data_type, self.raw_sys_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_SYSTEM_RECORD[group][key][self.SYSTEM_VALUE_INDEX] = data
+
     def _prepare_dg_system_record(self):
+        """
+        Handles assembling the sub dictionaries of each hardware group to make the main DG system record.
 
+        @return: None
+        """
         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]}})
+         {'top_level_pn':  ['<c', self.DEFAULT_CHAR_VALUES * self.MAX_PART_NUMBER_BYTES, self.MAX_PART_NUMBER_BYTES],
+          'top_level_sn': ['<c', self.DEFAULT_CHAR_VALUES * self.MAX_SERIAL_NUMBER_BYTES, 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])
@@ -127,8 +260,8 @@
             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
+            if data_type == '<c':
+                byte_size += current_byte_size * group[key][self.SYSTEM_CHAR_LENGTH_INDEX]
             else:
                 byte_size += current_byte_size
         return byte_size
@@ -157,7 +290,7 @@
 
         return number_of_bytes
 
-    def set_system_data(self):
+    def set_dg_system_record(self):
         """
         Handles updating the DG system record with the newest calibration data of a hardware and sends it to FW.
 
@@ -170,7 +303,6 @@
         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():
@@ -211,15 +343,12 @@
             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 data_type == '<c':
+                        data_type_bytes *= self.DG_SYSTEM_RECORD[group][key][self.SYSTEM_CHAR_LENGTH_INDEX]
 
                     # If minimum number of bytes space is still available in current temp buffer, continue inserting
                     # data into the buffer.
@@ -229,16 +358,14 @@
                         # 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:
+                        if data_type == '<c':
                             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)
+                        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.
@@ -254,10 +381,9 @@
                         # 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:
+                        if data_type == '<c':
                             for i in current_value:
-                                temp_buffer.append(struct.pack(data_type, i))
-                            is_data_list = False
+                                temp_buffer.append(struct.pack(data_type, i.encode('ascii')))
                         else:
                             temp_buffer.append(struct.pack(data_type, current_value))
 
@@ -279,13 +405,13 @@
         # Calculate the 16-bit crc.
         crc = crc_16(data)
         # Convert the crc into a 2-byte value
-        cal_record_crc = struct.pack('<H', crc)
+        system_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
+        sys_record_packets[-1][-1] = system_record_crc
 
         print('CRC: ', hex(crc)) #TODO remove
 
-        self.logger.debug('DG system update started')
+        self.logger.debug('DG system record update started')
 
         # Update all the data packets with the last message count since is the number of messages that firmware
         # should receive
@@ -301,7 +427,7 @@
             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,
+                                                  message_id=MsgIds.MSG_ID_DG_SET_SYSTEM_RECORD.value,
                                                   payload=payload)
 
             received_message = self.can_interface.send(message)
Index: tests/test_dg_calibration.py
===================================================================
diff -u -r1e51132e2b4eae6110d673bd4af934235cd76e36 -r43e8345862c72340680c045e53b310aa291513a6
--- tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision 1e51132e2b4eae6110d673bd4af934235cd76e36)
+++ tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision 43e8345862c72340680c045e53b310aa291513a6)
@@ -19,7 +19,7 @@
     #print(cal.DG_CALIBRATION_RECORD)
     #exit(0)
 
-    status = False
+    status = True
     cal.DG_CALIBRATION_RECORD['pumps']['concentrate_1']['step_speed_2_flow_ratio'][1] = 34.2
     cal.DG_CALIBRATION_RECORD['pumps']['drain']['cal_time'][1] = 96321
     cal.DG_CALIBRATION_RECORD['pumps']['ro']['gain_3_ratio'][1] = 45.69
@@ -29,12 +29,12 @@
     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)
+    print(cal.DG_CALIBRATION_RECORD)
 
     try:
         if status:
             dara = []
-            cal.get_dg_calibration_data()
+            cal.get_dg_calibration_record()
             while True:
                 sleep(0.2)
                 #print(cal.current_message, cal.total_messages, cal.cal_data)
Index: tests/test_dg_service_record.py
===================================================================
diff -u
--- tests/test_dg_service_record.py	(revision 0)
+++ tests/test_dg_service_record.py	(revision 43e8345862c72340680c045e53b310aa291513a6)
@@ -0,0 +1,32 @@
+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)
+
+    srvc = dg.service_record
+
+    srvc.DG_SERVICE_RECORD['service_record']['crc'][1] = 51236
+    print((srvc.DG_SERVICE_RECORD))
+    #print(len(sys.DG_SERVICE_RECORD['system_record']['top_level_pn'][1]))
+
+    #srvc.get_dg_service_record()
+
+    #while True:
+    #    sleep(0.2)
+    #    if srvc.current_message == srvc.total_messages:
+    #        break
+
+    #print(srvc.DG_SERVICE_RECORD)
+    #print((sys.DG_SERVICE_RECORD['system_record']['top_level_pn'][1]))
+
+    srvc.set_dg_service_data()
+
+    #print(cal.DG_SERVICE_RECORD['system_record']['top_level_sn'][1])
\ No newline at end of file
Index: tests/test_dg_system_record.py
===================================================================
diff -u -r1e51132e2b4eae6110d673bd4af934235cd76e36 -r43e8345862c72340680c045e53b310aa291513a6
--- tests/test_dg_system_record.py	(.../test_dg_system_record.py)	(revision 1e51132e2b4eae6110d673bd4af934235cd76e36)
+++ tests/test_dg_system_record.py	(.../test_dg_system_record.py)	(revision 43e8345862c72340680c045e53b310aa291513a6)
@@ -1,5 +1,3 @@
-from ctypes import *
-from collections import OrderedDict
 from dialin.dg.dialysate_generator import DG
 from dialin.ui import crc
 from time import sleep
@@ -13,9 +11,20 @@
         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.DG_SYSTEM_RECORD_RECORD['system_record']['top_level_pn'][1] = 'DEN-SN-Y20'
+    print((sys.DG_SYSTEM_RECORD_RECORD))
+    #print(len(sys.DG_SYSTEM_RECORD_RECORD['system_record']['top_level_pn'][1]))
 
-    sys.set_system_data()
+    sys.get_dg_service_record()
 
-    #print(cal.DG_SYSTEM_RECORD['system_record']['top_level_sn'][1])
+    while True:
+        sleep(0.2)
+        if sys.current_message == sys.total_messages:
+            break
+
+    #print(sys.DG_SYSTEM_RECORD_RECORD)
+    print((sys.DG_SYSTEM_RECORD_RECORD['system_record']['top_level_pn'][1]))
+
+    #sys.set_dg_system_record()
+
+    #print(cal.DG_SYSTEM_RECORD_RECORD['system_record']['top_level_sn'][1])