Index: dialin/common/msg_defs.py
===================================================================
diff -u -ra2cdbc7e007c6bd73e12344b4c89356a20b53f4f -r97c98d84604e3700dd446235e91a5ebe2db08022
--- dialin/common/msg_defs.py	(.../msg_defs.py)	(revision a2cdbc7e007c6bd73e12344b4c89356a20b53f4f)
+++ dialin/common/msg_defs.py	(.../msg_defs.py)	(revision 97c98d84604e3700dd446235e91a5ebe2db08022)
@@ -92,8 +92,8 @@
     MSG_ID_UI_PRESSURE_LIMITS_CHANGE_REQUEST = 0x46             # UI request to change pressure limits
     MSG_ID_HD_PRESSURE_LIMITS_CHANGE_RESPONSE = 0x47            # HD response to change pressure limits request
     MSG_ID_DG_FANS_DATA = 0x48                                  # DG broadcast fans data
-    MSG_ID_HD_CALIBRATION_DATA = 0x49                           # HD broadcast calibration_record data
-    MSG_ID_DG_CALIBRATION_DATA = 0x4A                           # DG broadcast calibration_record data
+    MSG_ID___AVAILABLE_4 = 0x49                           # HD broadcast calibration_record data
+    MSG_ID___AVAILABLE_5 = 0x4A                           # DG broadcast calibration_record data
     MSG_ID_UI_HEPARIN_PAUSE_RESUME_REQUEST = 0x4B               # UI request to pause/resume Heparin delivery
     MSG_ID_HD_HEPARIN_PAUSE_RESUME_RESPONSE = 0x4C              # HD response to pause/resume Heparing delivery request
     MSG_ID_HD_HEPARIN_DATA_BROADCAST = 0x4D                     # HD broadcast of Heparin delivery data
@@ -146,9 +146,9 @@
     MSG_ID_HD_ACCEL_OVERRIDE = 0x8027                           # HD accelerometer sensor override request
     MSG_ID_HD_ACCEL_MAX_OVERRIDE = 0x8028                       # HD accelerometer sensor max. override request
     MSG_ID_HD_ACCEL_SEND_INTERVAL_OVERRIDE = 0x8029             # HD accelerometer data broadcast interval override request
-    MSG_ID_HD_ACCEL_SET_CALIBRATION = 0x802A                    # HD accelerometer set calibration_record factors request
-    MSG_ID_HD_BLOOD_FLOW_SET_CALIBRATION = 0x802B               # Blood flow set calibration_record factors request
-    MSG_ID_HD_DIALYSATE_FLOW_SET_CALIBRATION = 0x802C           # Dialysate flow set calibration_record factors request
+    MSG_ID___AVAILABLE_6 = 0x802A                               # This msg ID is available for use
+    MSG_ID___AVAILABLE_7 = 0x802B                               # This msg ID is available for use
+    MSG_ID___AVAILABLE_8 = 0x802C                               # This msg ID is available for use
     MSG_ID_HD_SET_PARAMETER_TREATMENT_PARAMETER = 0x802D        # Set a treatment parameter (will change actual setting, not an override)
     MSG_ID_HD_VALVES_HOME = 0x802E                              # Home an HD Valve
     MSG_ID_HD_VALVES_POSITION_OVERRIDE = 0x802F                 # Set an HD valve to a position in counts
@@ -163,8 +163,8 @@
     MSG_ID_DIAL_IN_PUMP_HOME_CMD = 0x8038                       # Dialysate inlet pump home command
     MSG_ID_DIAL_OUT_PUMP_HOME_CMD = 0x8039                      # Dialysate outlet pump home command
     MSG_ID_SUPER_CLEAR_ALARMS_CMD = 0x803A                      # Clears all alarms (even if non-recoverable or fault)
-    MSG_ID_HD_REQUEST_CALIBRATION_DATA = 0x803B                 # Requests calibration_record data from HD
-    MSG_ID_HD_ERASE_CALIBRATION_DATA = 0x803C                   # Requests calibration_record data on HD be erased
+    MSG_ID___AVAILABLE_9 = 0x803B                               # This msg ID is available for use
+    MSG_ID___AVAILABLE_10 = 0x803C                              # This msg ID is available for use
     MSG_ID_HD_SET_CALIBRATION_RECORD = 0x803D                   # HD set calibration_record record that is received from Dialin
     MSG_ID_HD_GET_CALIBRATION_RECORD = 0x803E                   # HD get calibration_record record that is requested from Dialin
     MSG_ID_HD_SEND_CALIBRATION_RECORD = 0x803F                  # HD send calibration_record record to CAN bus to be received in Dialin (equivalent to publish)
@@ -173,7 +173,7 @@
     MSG_ID_HD_SEND_SYSTEM_RECORD = 0x8042                       # HD send system record to CAN bus to be received in Dialin (equivalent to publish)
     MSG_ID_HD_GET_SERVICE_RECORD = 0x8043                       # HD get service record that is requested from Dialin
     MSG_ID_HD_SET_SERVICE_RECORD = 0x8044                       # HD set service record that is received from Dialin
-    MSG_ID_Hd_SEND_SERVICE_RECORD = 0x8045                      # HD send service record to CAN bus to be received in Dialin (equivalent to publish)
+    MSG_ID_HD_SEND_SERVICE_RECORD = 0x8045                      # HD send service record to CAN bus to be received in Dialin (equivalent to publish)
 
     MSG_ID_DG_TESTER_LOGIN_REQUEST = 0XA000                     # DG tester log-in
     MSG_ID_DG_ALARM_STATE_OVERRIDE = 0xA001                     # DG alarm state override message ID
@@ -200,7 +200,7 @@
     MSG_ID_DG_ACCEL_OVERRIDE = 0xA017                           # DG accelerometer sensor override request
     MSG_ID_DG_ACCEL_MAX_OVERRIDE = 0xA018                       # DG accelerometer sensor max. override request
     MSG_ID_DG_ACCEL_SEND_INTERVAL_OVERRIDE = 0xA019             # DG accelerometer data broadcast interval override request
-    MSG_ID_DG_ACCEL_SET_CALIBRATION = 0xA01A                    # DG accelerometer set calibration_record factors request
+    MSG_ID___AVAILABLE_11 = 0xA01A                              # This msg ID is available for use
     MSG_ID_RO_PUMP_SET_PWM = 0xA01B                             # RO pump set PWM for open loop
     MSG_ID_DRAIN_PUMP_SET_DELTA_PRESSURE_OVERRIDE = 0xA01C      # Drain pump set delta pressure override
     MSG_ID_HEAT_DISINFECT_RECIRC_PATH_DURATION_MINS = 0xA01D    # Heat disinfection recirculation path duration in minutes
Index: dialin/dg/calibration_record.py
===================================================================
diff -u -rab49c2b2e6bd03745f5a910780791d4b18000fd1 -r97c98d84604e3700dd446235e91a5ebe2db08022
--- dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision ab49c2b2e6bd03745f5a910780791d4b18000fd1)
+++ dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision 97c98d84604e3700dd446235e91a5ebe2db08022)
@@ -14,33 +14,21 @@
 class DGCalibration(_AbstractSubSystem):
     """
 
-    Dialysate Generator (DG) Dialin API sub-class for calibration_record commands.
+    Dialysate Generator (DG) Dialin API sub-class for calibration commands.
     """
 
     _RECORD_START_INDEX = 6
     _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_BICARB_VALUE = 1
     _DEFAULT_CALIBRATION_VALUE = 1
     _DEFAULT_TIME_VALUE = 0
     _DEFAULT_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_TRANSFER_DELAY = 0.2
@@ -59,8 +47,8 @@
         self.total_messages = 0
         self.length = 0
         self.cal_data = 0
-        self.raw_cal_record = []
-        self.utilities = Utils()
+        self._raw_cal_record = []
+        self._utilities = Utils()
         # DG calibration_record main record
         self.dg_calibration_record = OrderedDict()
 
@@ -75,12 +63,12 @@
 
     def get_dg_calibration_record(self):
         """
-        Handles getting DG calibration_record data from firmware.
+        Handles getting DG calibration data from firmware.
 
         @return: None
         """
         # Clear the list for the next call
-        self.raw_cal_record.clear()
+        self._raw_cal_record.clear()
         # Run the firmware commands to get the calibration_record record
         self._request_dg_fw_calibration_record()
 
@@ -93,7 +81,7 @@
         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 record')
+        self.logger.debug('Getting DG calibration record')
 
         received_message = self.can_interface.send(message)
 
@@ -105,10 +93,10 @@
             self.logger.debug("Timeout!!!!")
             return False
 
-    @_publish(["current_message", "total_messages", "length", "sys_data"])
+    @_publish(["current_message", "total_messages", "length", "service_data"])
     def _handler_dg_calibration_sync(self, message):
         """
-        Handles published DG calibration_record record messages. DG calibration_record records are captured for
+        Handles published DG calibration_record record messages. DG calibration records are captured for
         processing and updating the DG calibration_record record.
 
         @param message:  published DG calibration_record record data message
@@ -125,67 +113,64 @@
         self.current_message = curr
         self.total_messages = total
         self.length = length
-        # The end of calibration_record record payload is from the start index + 12 bytes for the current message + total
+        # The end of calibration_record record payload is from the start index + 12 bytes for the current message +total
         # messages + the length of calibration_record. The rest is the CAN messaging CRC that is not needed to be kept
         end_of_data_index = self._RECORD_START_INDEX + self._RECORD_SPECS_BYTES + self.length
 
         # Get the calibration_record data only
         self.cal_data = message['message'][self._RECORD_START_INDEX:end_of_data_index]
 
-        # Continue getting calibration_record records until the all the calibration_record messages are received. Concatenate the
-        # calibration_record records to each other
+        # Continue getting calibration_record records until the all the calibration_record messages are received.
+        # Concatenate the calibration_record records to each other.
         if self.current_message <= self.total_messages:
-            self.raw_cal_record += (message['message'][self._RECORD_START_INDEX +
-                                                       self._RECORD_SPECS_BYTES:end_of_data_index])
+            self._raw_cal_record += (message['message'][self._RECORD_START_INDEX +
+                                                        self._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.utilities.process_received_record_from_fw(self.dg_calibration_record, self.raw_cal_record)
+                self._utilities.process_received_record_from_fw(self.dg_calibration_record, self._raw_cal_record)
 
     def _prepare_dg_calibration_record(self):
         """
-        Handles assembling the sub dictionaries of each hardware group to make the main DG calibration_record record.
+        Handles assembling the sub dictionaries of each hardware group to make the main DG calibration record.
 
         @return: None
         """
+        groups_byte_size = 0
         # 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()
+        functions = [self._prepare_pressure_sensors_cal_record(), self._prepare_flow_sensors_cal_record(),
+                     self._prepare_load_cells_record(), self._prepare_temperature_sensors_record(),
+                     self._prepare_conductivity_sensors_record(), self._prepare_pumps_record(),
+                     self._prepare_volume_record(), self._prepare_acid_concentrates_record(),
+                     self._prepare_bicarb_concentrates_record(), self._prepare_filters_record(),
+                     self._prepare_fans_record(), self._prepare_accelerometer_sensor_record()]
+
+        for function in functions:
+            # Update the groups bytes size so far to be use to padding later
+            groups_byte_size += function[1]
+            # Update the calibration record
+            self.dg_calibration_record.update(function[0])
+
         # Build the CRC of the main calibration_record record
         record_crc = OrderedDict({'crc': ['<H', self._DEFAULT_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]
-
         # Get the groups byte size
-        groups_byte_size += self.utilities.calculate_group_byte_size(record_crc)
+        groups_byte_size += self._utilities.calculate_group_byte_size(record_crc)
 
         # Get the padding size to create a dictionary from it
-        padding_size = self.utilities.calculate_padding_byte_size(groups_byte_size, self._EEPROM_MAX_BYTES_TO_WRITE)
+        padding_size = self._utilities.calculate_padding_byte_size(groups_byte_size, self._EEPROM_MAX_BYTES_TO_WRITE)
 
         # Create the padding dictionary as list of unsigned char. All the elements are 0.
         padding = OrderedDict({'padding': ['<B', [self._DEFAULT_CRC_VALUE] * padding_size]})
 
-        # Insert the sub dictionaries into the main calibration_record 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, **record_crc}
+        # Update the dictionary with the padding and record crc dictionaries
+        self.dg_calibration_record.update(padding)
+        self.dg_calibration_record.update(record_crc)
 
     def _prepare_pressure_sensors_cal_record(self):
         """
-        Handles creating the calibration_record dictionary of the pressure sensors hardware group.
+        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
         """
@@ -201,14 +186,14 @@
             hardware[i] = {'gain': ['<f', self._DEFAULT_GAIN_VALUE], 'offset': ['<f', self._DEFAULT_OFFSET_VALUE],
                            'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             # Calculate the size of the bytes in this hardware group
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
 
     def _prepare_flow_sensors_cal_record(self):
         """
-        Handles creating the calibration_record dictionary of the flow sensors hardware group.
+        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
         """
@@ -224,14 +209,14 @@
                            'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
             # Calculate the size of the bytes in this hardware group
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
 
     def _prepare_load_cells_record(self):
         """
-        Handles creating the calibration_record dictionary of the load cells hardware group.
+        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
         """
@@ -247,14 +232,14 @@
                            'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
             # Calculate the size of the bytes in this hardware group
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
 
     def _prepare_temperature_sensors_record(self):
         """
-        Handles creating the calibration_record dictionary of the temperature sensors hardware group.
+        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
         """
@@ -273,14 +258,14 @@
                            'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
             # Calculate the size of the bytes in this hardware group
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
 
     def _prepare_conductivity_sensors_record(self):
         """
-        Handles creating the calibration_record dictionary of the conductivity sensors hardware group.
+        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
         """
@@ -296,14 +281,14 @@
                            'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
             # Calculate the size of the bytes in this hardware group
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
 
     def _prepare_pumps_record(self):
         """
-        Handles creating the calibration_record dictionary of the DG pumps.
+        Handles creating the calibration dictionary of the DG pumps.
 
         @return: DG pumps hardware group dictionary and the byte size of this hardware group
         """
@@ -331,14 +316,14 @@
                                'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
                                'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
 
     def _prepare_volume_record(self):
         """
-        Handles creating the calibration_record dictionary of the DG volumes.
+        Handles creating the calibration dictionary of the DG volumes.
 
         @return: DG volumes hardware group dictionary and the byte size of this hardware group
         """
@@ -371,14 +356,14 @@
                                'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
                                'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
 
     def _prepare_acid_concentrates_record(self):
         """
-        Handles creating the calibration_record dictionary of the DG acid concentrates.
+        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
         """
@@ -394,14 +379,14 @@
                            'reserved_space': ['<f', self._DEFAULT_VOLUME_VALUE],
                            'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
 
     def _prepare_bicarb_concentrates_record(self):
         """
-        Handles creating the calibration_record dictionary of the DG bicarb concentrates.
+        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
         """
@@ -412,19 +397,19 @@
         hardware = OrderedDict()
 
         for i in hardware_names:
-            hardware[i] = {'bicarb_conc_mix_ratio': ['<f', self._DEFAULT_CONCENTRATE_VALUE],
+            hardware[i] = {'bicarb_conc_mix_ratio': ['<f', self._DEFAULT_BICARB_VALUE],
                            'start_volume': ['<f', self._DEFAULT_VOLUME_VALUE],
                            'reserved_space': ['<f', self._DEFAULT_VOLUME_VALUE],
                            'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
 
     def _prepare_filters_record(self):
         """
-        Handles creating the calibration_record dictionary of the DG filters.
+        Handles creating the calibration dictionary of the DG filters.
 
         @return: DG filters hardware group dictionary and the byte size of this hardware group
         """
@@ -440,14 +425,14 @@
                            'reserved_space_3': ['<f', self._DEFAULT_CALIBRATION_VALUE],
                            'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
 
     def _prepare_fans_record(self):
         """
-        Handles creating the calibration_record dictionary of the DG fans.
+        Handles creating the calibration dictionary of the DG fans.
 
         @return: DG fans hardware group dictionary and the byte size of this hardware group
         """
@@ -462,41 +447,47 @@
                            'reserved_space_2': ['<f', self._DEFAULT_CALIBRATION_VALUE],
                            'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
-            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
         hardware_group[group_name] = hardware
 
         return hardware_group, group_byte_size
 
+    def _prepare_accelerometer_sensor_record(self):
+        """
+        Handles creating the calibration dictionary of the accelerometer sensor hardware group.
+
+        @return: accelerometer sensor hardware group dictionary and the byte size of this hardware group
+        """
+        hardware_names = ['accelerometer']
+
+        group_byte_size = 0
+        group_name = 'accelerometer_sensor'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+            hardware[i] = {'x_offset': ['<f', self._DEFAULT_OFFSET_VALUE],
+                           'y_offset': ['<f', self._DEFAULT_OFFSET_VALUE],
+                           'z_offset': ['<f', self._DEFAULT_OFFSET_VALUE],
+                           'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
+            # Calculate the size of the bytes in this hardware group
+            group_byte_size += self._utilities.calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
     def set_dg_calibration_record(self):
         """
-        Handles updating the DG calibration_record record with the newest calibration_record data of a hardware and
+        Handles updating the DG calibration record with the newest calibration_record 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
+        record_packets = self._utilities.prepare_record_to_send_to_fw(self.dg_calibration_record)
 
-        record_packets = self.utilities.prepare_record_to_send_to_fw(self.dg_calibration_record)
+        self.logger.debug('Setting DG calibration started')
 
-        self.logger.debug('DG calibration_record started')
-
         # Update all the data packets with the last message count since is the number of messages that firmware
         # should receive
         for packet in record_packets:
@@ -505,7 +496,6 @@
 
             # 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,
Index: dialin/dg/service_record.py
===================================================================
diff -u -ra2cdbc7e007c6bd73e12344b4c89356a20b53f4f -r97c98d84604e3700dd446235e91a5ebe2db08022
--- dialin/dg/service_record.py	(.../service_record.py)	(revision a2cdbc7e007c6bd73e12344b4c89356a20b53f4f)
+++ dialin/dg/service_record.py	(.../service_record.py)	(revision 97c98d84604e3700dd446235e91a5ebe2db08022)
@@ -4,7 +4,7 @@
 from collections import OrderedDict
 from ..common.msg_defs import MsgIds, MsgFieldPositions
 from ..protocols.CAN import (DenaliMessage, DenaliChannels)
-from ..utils.base import _AbstractSubSystem, DialinEnum
+from ..utils.base import _AbstractSubSystem, DialinEnum, _publish
 from ..utils.utils import Utils
 from logging import Logger
 from enum import unique
@@ -19,36 +19,17 @@
 class DGService(_AbstractSubSystem):
     """
 
-    Dialysate Generator (DG) Dialin API sub-class for service record commands.
+    Hemodialysis Device (HD) Dialin API sub-class for service record commands.
     """
 
-    SERVICE_RECORD_START_INDEX = 6
-    SERVICE_RECORD_SPECS_BYTES = 12
-    SERVICE_RECORDS_SPECS_BYTE_ARRAY = 3
-
+    _RECORD_START_INDEX = 6
+    _RECORD_SPECS_BYTES = 12
     _DEFAULT_SERVICE_LOCATION = ServiceLocation.SERVICE_LOCATION_FACTORY.value
-    DEFAULT_MFG_DATE = 0
-    _DEFAULT_DATE_VALUE = 0
+    _DEFAULT_TIME_VALUE = 0
     _DEFAULT_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_TRANSFER_DELAY = 0.2
-    PAYLOAD_CURRENT_MSG_INDEX = 0
-    PAYLOAD_TOTAL_MSG_INDEX = 1
-    PAYLOAD_SERVICE_BYTES_INDEX = 2
 
     def __init__(self, can_interface, logger: Logger):
         """
@@ -58,23 +39,22 @@
 
         super().__init__()
 
-        self.utilities = Utils()
         self.can_interface = can_interface
         self.logger = logger
         self.current_message = 0
         self.total_messages = 0
         self.length = 0
-        self.cal_data = 0
+        self.service_data = 0
         self.raw_service_record = []
-        # DG system main record as an ordered dictionary
+        self.utilities = Utils()
+        # Service main record
         self.dg_service_record = OrderedDict()
 
         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)
+                                                                       self._handler_dg_service_sync)
         # Prepare the service record by putting sub-dictionaries together
         self._prepare_dg_service_record()
 
@@ -86,7 +66,7 @@
         """
         # Clear the list for the next call
         self.raw_service_record.clear()
-        # Run the firmware commands to get the service record
+        # Run the firmware commands to get the record
         self._request_dg_fw_service_record()
 
     def _request_dg_fw_service_record(self):
@@ -110,12 +90,13 @@
             self.logger.debug("Timeout!!!!")
             return False
 
-    def _handler_dg_service_record(self, message):
+    @_publish(["current_message", "total_messages", "length", "service_data"])
+    def _handler_dg_service_sync(self, message):
         """
-        Handles published DG service record messages. DG system records are captured for processing and
-        updating the DG service record.
+        Handles published DG service record messages. DG service records are captured for
+        processing and updating the DG service record.
 
-        @param message:  published DG system record data message
+        @param message: published DG service record data message
 
         @return: None
         """
@@ -129,38 +110,39 @@
         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
+        # The end of calibration_record record payload is from the start index + 12 bytes for the current message +total
+        # messages + the length of calibration_record. The rest is the CAN messaging CRC that is not needed to be kept
+        end_of_data_index = self._RECORD_START_INDEX + self._RECORD_SPECS_BYTES + self.length
 
-        # Get the calibration_record data only
-        self.cal_data = message['message'][self.SERVICE_RECORD_START_INDEX:end_of_data_index]
+        # Get the data only and not specs of it (i.e current message number)
+        self.service_data = message['message'][self._RECORD_START_INDEX:end_of_data_index]
 
-        # Continue getting calibration_record records until the all the calibration_record messages are received. Concatenate the
-        # calibration_record records to each other
+        # Continue getting calibration_record records until the all the calibration_record messages are received.
+        # Concatenate the calibration_record 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])
+            self.raw_service_record += (message['message'][self._RECORD_START_INDEX +
+                                                           self._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.utilities.process_received_record_from_fw(self.dg_service_record, self.raw_service_record)
 
     def _prepare_dg_service_record(self):
         """
-        Handles assembling the sub dictionaries of each group to make the main DG service record.
+        Handles assembling the sub dictionaries of each group to make the main HD 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_DATE_VALUE],
-                                       'crc': ['<H', self._DEFAULT_CRC_VALUE]}})
+        # create a list of the functions of the sub dictionaries
+        functions = [self._prepare_service_record()]
 
-        for record in service_records.keys():
-            groups_byte_size += self.utilities.calculate_group_byte_size(service_records[record])
+        for function in functions:
+            # Update the groups bytes size so far to be use to padding later
+            groups_byte_size += function[1]
+            # Update the calibration record
+            self.dg_service_record.update(function[0])
 
-        # Build the CRC of the main system record
+        # Build the CRC of the main calibration_record record
         record_crc = OrderedDict({'crc': ['<H', self._DEFAULT_CRC_VALUE]})
 
         # Get the groups byte size
@@ -170,23 +152,42 @@
         padding_size = self.utilities.calculate_padding_byte_size(groups_byte_size, self._RTC_RAM_MAX_BYTES_TO_WRITE)
 
         # 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]})
+        padding = OrderedDict({'padding': ['<B', [self._DEFAULT_CRC_VALUE] * padding_size]})
 
-        self.dg_service_record = {**service_records, **padding, **record_crc}
+        # Update the dictionary with the padding and record crc dictionaries
+        self.dg_service_record.update(padding)
+        self.dg_service_record.update(record_crc)
 
-    def set_dg_service_data(self):
+    def _prepare_service_record(self):
         """
-        Handles updating the DG service record with the newest data and sends it to FW.
+        Handles creating the service record dictionary.
 
+        @return: service record dictionary and the byte size of this group
+        """
+        groups_byte_size = 0
+        service_records = OrderedDict({'service_record':
+                                      {'service_location': ['<B', self._DEFAULT_SERVICE_LOCATION],
+                                       'service_date': ['<i', self._DEFAULT_TIME_VALUE],
+                                       'crc': ['<H', self._DEFAULT_CRC_VALUE]}})
+
+        for record in service_records.keys():
+            groups_byte_size += self.utilities.calculate_group_byte_size(service_records[record])
+
+        return service_records, groups_byte_size
+
+    def set_dg_service_record(self):
+        """
+        Handles updating the DG service record and sends it to FW.
+
         @return: none
         """
-        # Get the processed record packets
         record_packets = self.utilities.prepare_record_to_send_to_fw(self.dg_service_record)
 
-        self.logger.debug('DG service record update started')
+        self.logger.debug('Setting DG service record')
 
+        # Update all the data packets with the last message count since is the number of messages that firmware
+        # should receive
         for packet in record_packets:
-
             # Sleep to let the firmware receive and process the data
             time.sleep(self._PAYLOAD_TRANSFER_DELAY)
 
@@ -202,4 +203,4 @@
             # If there is no content...
             if received_message is None:
                 self.logger.debug("Timeout!!!!")
-                return False
+                return False
\ No newline at end of file
Index: dialin/dg/system_record.py
===================================================================
diff -u -ra2cdbc7e007c6bd73e12344b4c89356a20b53f4f -r97c98d84604e3700dd446235e91a5ebe2db08022
--- dialin/dg/system_record.py	(.../system_record.py)	(revision a2cdbc7e007c6bd73e12344b4c89356a20b53f4f)
+++ dialin/dg/system_record.py	(.../system_record.py)	(revision 97c98d84604e3700dd446235e91a5ebe2db08022)
@@ -1,13 +1,11 @@
 
 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 ..utils.base import _AbstractSubSystem, DialinEnum, _publish
+from ..utils.utils import Utils
 from logging import Logger
 from enum import unique
 
@@ -20,44 +18,21 @@
 class DGSystemRecord(_AbstractSubSystem):
     """
 
-    Dialysate Generator (DG) Dialin API sub-class for system record commands.
+    Hemodialysis Device (HD) Dialin API sub-class for system record commands.
     """
 
-    SYSTEM_RECORD_START_INDEX = 6
-    SYSTEM_RECORD_SPECS_BYTES = 12
-    SYSTEM_RECORDS_SPECS_BYTE_ARRAY = 3
+    _RECORD_START_INDEX = 6
+    _RECORD_SPECS_BYTES = 12
+    _DEFAULT_CHAR_VALUE = 'X'
+    _DEFAULT_MFG_LOCATION = MFGLocation.MFG_LOCATION_FACTORY.value
+    _MAX_PN_BYTES = 10
+    _MAX_SN_BYTES = 15
+    _DEFAULT_TIME_VALUE = 0
+    _DEFAULT_CRC_VALUE = 0
 
-    MAX_PART_NUMBER_BYTES = 10
-    MAX_SERIAL_NUMBER_BYTES = 15
+    _EEPROM_MAX_BYTES_TO_WRITE = 16
+    _PAYLOAD_TRANSFER_DELAY = 0.2
 
-    DEFAULT_CHAR_VALUES = 'X'
-    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
-    SYSTEM_CHAR_LENGTH_INDEX = 2
-
-    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):
         """
 
@@ -71,27 +46,28 @@
         self.current_message = 0
         self.total_messages = 0
         self.length = 0
-        self.cal_data = 0
-        self.raw_sys_record = []
+        self.sys_data = 0
+        self.raw_system_record = []
+        self.utilities = Utils()
+        # System main record
+        self.dg_system_record = OrderedDict()
 
         if self.can_interface is not None:
-
             channel_id = DenaliChannels.dg_to_dialin_ch_id
             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)
+            self.can_interface.register_receiving_publication_function(channel_id, msg_id, self._handler_dg_system_sync)
         # Prepare the system record by putting sub-dictionaries together
         self._prepare_dg_system_record()
 
     def get_dg_system_record(self):
         """
-        Handles getting DG system record from firmware.
+        Handles getting HD calibration_record data 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.raw_system_record.clear()
+        # Run the firmware commands to get the record
         self._request_dg_fw_system_record()
 
     def _request_dg_fw_system_record(self):
@@ -115,10 +91,11 @@
             self.logger.debug("Timeout!!!!")
             return False
 
-    def _handler_dg_system_record(self, message):
+    @_publish(["current_message", "total_messages", "length", "service_data"])
+    def _handler_dg_system_sync(self, message):
         """
-        Handles published DG system record messages. DG system records are captured for processing and
-        updating the DG system record.
+        Handles published DG system record messages. HD system records are captured for
+        processing and updating the DG system record.
 
         @param message:  published DG system record data message
 
@@ -134,297 +111,90 @@
         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
+        # The end of calibration_record record payload is from the start index + 12 bytes for the current message +total
+        # messages + the length of calibration_record. The rest is the CAN messaging CRC that is not needed to be kept
+        end_of_data_index = self._RECORD_START_INDEX + self._RECORD_SPECS_BYTES + self.length
 
-        # Get the calibration_record data only
-        self.cal_data = message['message'][self.SYSTEM_RECORD_START_INDEX:end_of_data_index]
+        # Get the data only and not specs of it (i.e current message number)
+        self.sys_data = message['message'][self._RECORD_START_INDEX:end_of_data_index]
 
-        # Continue getting calibration_record records until the all the calibration_record messages are received. Concatenate the
-        # calibration_record records to each other
+        # Continue getting calibration_record records until the all the calibration_record messages are received.
+        # Concatenate the calibration_record 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])
+            self.raw_system_record += (message['message'][self._RECORD_START_INDEX +
+                                                          self._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()
+                self.utilities.process_received_record_from_fw(self.dg_system_record, self.raw_system_record)
 
-    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_record 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._DATA_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.
+        Handles assembling the sub dictionaries of each 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, 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]}})
+        # create a list of the functions of the sub dictionaries
+        functions = [self._prepare_system_record()]
 
-        for record in system_records.keys():
-            groups_byte_size += self._calculate_group_byte_size(system_records[record])
+        for function in functions:
+            # Update the groups bytes size so far to be use to padding later
+            groups_byte_size += function[1]
+            # Update the calibration record
+            self.dg_system_record.update(function[0])
 
-        # Build the CRC of the main system record
-        record_crc = OrderedDict({'crc': ['<H', self.DEFAULT_SYS_CRC_VALUE]})
-        groups_byte_size += self._calculate_group_byte_size(record_crc)
+        # Build the CRC of the main calibration_record record
+        record_crc = OrderedDict({'crc': ['<H', self._DEFAULT_CRC_VALUE]})
 
-        # 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]})
+        # Get the groups byte size
+        groups_byte_size += self.utilities.calculate_group_byte_size(record_crc)
 
-        self.DG_SYSTEM_RECORD = {**system_records, **padding, **record_crc}
+        # Get the padding size to create a dictionary from it
+        padding_size = self.utilities.calculate_padding_byte_size(groups_byte_size, self._EEPROM_MAX_BYTES_TO_WRITE)
 
-    def _calculate_group_byte_size(self, group):
-        """
-        Handles calculating the byte size of the values of the provided dictionary.
+        # Create the padding dictionary as list of unsigned char. All the elements are 0.
+        padding = OrderedDict({'padding': ['<B', [self._DEFAULT_CRC_VALUE] * padding_size]})
 
-        @param group: the dictionary that is passed to calculate the byte size
-        @return: calculated byte size
-        """
-        byte_size = 0
+        # Update the dictionary with the padding and record crc dictionaries
+        self.dg_system_record.update(padding)
+        self.dg_system_record.update(record_crc)
 
-        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 data_type == '<c':
-                byte_size += current_byte_size * group[key][self.SYSTEM_CHAR_LENGTH_INDEX]
-            else:
-                byte_size += current_byte_size
-        return byte_size
-
-    @staticmethod
-    def _get_data_type_bytes(data):
+    def _prepare_system_record(self):
         """
-        Handles converting the string representation of the bytes of the data types in a struct to numbers.
-        This is a static method.
+        Handles creating the system record dictionary.
 
-        @param data: the data to be converted to bytes in number
-        @return: calculated byte size
+        @return: system record dictionary and the byte size of this group
         """
-        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
+        groups_byte_size = 0
+        system_records = OrderedDict({'system_record':
+                             {'top_level_pn': ['<c', self._DEFAULT_CHAR_VALUE * self._MAX_PN_BYTES, self._MAX_PN_BYTES],
+                              'top_level_sn': ['<c', self._DEFAULT_CHAR_VALUE * self._MAX_SN_BYTES, self._MAX_SN_BYTES],
+                              'mfg_location': ['<B', self._DEFAULT_MFG_LOCATION],
+                              'mfg_date': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}})
 
-        return number_of_bytes
+        for record in system_records.keys():
+            groups_byte_size += self.utilities.calculate_group_byte_size(system_records[record])
 
+        return system_records, groups_byte_size
+
     def set_dg_system_record(self):
         """
-        Handles updating the DG system record with the newest calibration_record data of a hardware and sends it to FW.
+        Handles updating the DG system and sends it to FW.
 
         @return: none
         """
+        record_packets = self.utilities.prepare_record_to_send_to_fw(self.dg_system_record)
 
-        # 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]
+        self.logger.debug('Setting DG system record')
 
-        # Loop through the DG calibration_record 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():
-
-                    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 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.
-                    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 data_type == '<c':
-                            for i in current_value:
-                                temp_buffer.append(struct.pack(data_type, i.encode('ascii')))
-                        else:
-                            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_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 data_type == '<c':
-                            for i in current_value:
-                                temp_buffer.append(struct.pack(data_type, i.encode('ascii')))
-                        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_record data is started from the 3rd element of the data packet.
-            # The first 3 are current message, total messages, and the payload length of the current packet.
-            if 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
-        system_record_crc = struct.pack('<H', crc)
-        # Insert the CRC into the last element of the last data packet
-        sys_record_packets[-1][-1] = system_record_crc
-
-        print('CRC: ', hex(crc)) #TODO remove
-
-        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
-        for packet in sys_record_packets:
+        for packet in record_packets:
             # Sleep to let the firmware receive and process the data
-            time.sleep(0.2)
-            # Add the number of total messages to each data packet. This was delayed
-            # until now since it was not known how many message will it take to pack all the
-            # calibration_record data.
-            packet[1] = struct.pack('<i', current_message_count)
+            time.sleep(self._PAYLOAD_TRANSFER_DELAY)
+
             # 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_RECORD.value,
Index: dialin/hd/calibration_record.py
===================================================================
diff -u -rab49c2b2e6bd03745f5a910780791d4b18000fd1 -r97c98d84604e3700dd446235e91a5ebe2db08022
--- dialin/hd/calibration_record.py	(.../calibration_record.py)	(revision ab49c2b2e6bd03745f5a910780791d4b18000fd1)
+++ dialin/hd/calibration_record.py	(.../calibration_record.py)	(revision 97c98d84604e3700dd446235e91a5ebe2db08022)
@@ -90,7 +90,7 @@
             self.logger.debug("Timeout!!!!")
             return False
 
-    @_publish(["current_message", "total_messages", "length", "sys_data"])
+    @_publish(["current_message", "total_messages", "length", "service_data"])
     def _handler_hd_calibration_sync(self, message):
         """
         Handles published HD calibration_record record messages. DG calibration_record records are captured for
Index: dialin/hd/service_record.py
===================================================================
diff -u -ra2cdbc7e007c6bd73e12344b4c89356a20b53f4f -r97c98d84604e3700dd446235e91a5ebe2db08022
--- dialin/hd/service_record.py	(.../service_record.py)	(revision a2cdbc7e007c6bd73e12344b4c89356a20b53f4f)
+++ dialin/hd/service_record.py	(.../service_record.py)	(revision 97c98d84604e3700dd446235e91a5ebe2db08022)
@@ -4,7 +4,7 @@
 from collections import OrderedDict
 from ..common.msg_defs import MsgIds, MsgFieldPositions
 from ..protocols.CAN import (DenaliMessage, DenaliChannels)
-from ..utils.base import _AbstractSubSystem, DialinEnum
+from ..utils.base import _AbstractSubSystem, _publish, DialinEnum
 from ..utils.utils import Utils
 from logging import Logger
 from enum import unique
@@ -19,36 +19,17 @@
 class HDService(_AbstractSubSystem):
     """
 
-    Dialysate Generator (DG) Dialin API sub-class for service record commands.
+    Hemodialysis Device (HD) Dialin API sub-class for service record commands.
     """
 
-    SERVICE_RECORD_START_INDEX = 6
-    SERVICE_RECORD_SPECS_BYTES = 12
-    SERVICE_RECORDS_SPECS_BYTE_ARRAY = 3
-
+    _RECORD_START_INDEX = 6
+    _RECORD_SPECS_BYTES = 12
     _DEFAULT_SERVICE_LOCATION = ServiceLocation.SERVICE_LOCATION_FACTORY.value
-    DEFAULT_MFG_DATE = 0
-    _DEFAULT_DATE_VALUE = 0
+    _DEFAULT_TIME_VALUE = 0
     _DEFAULT_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_TRANSFER_DELAY = 0.2
-    PAYLOAD_CURRENT_MSG_INDEX = 0
-    PAYLOAD_TOTAL_MSG_INDEX = 1
-    PAYLOAD_SERVICE_BYTES_INDEX = 2
 
     def __init__(self, can_interface, logger: Logger):
         """
@@ -57,3 +38,169 @@
         """
 
         super().__init__()
+
+        self.can_interface = can_interface
+        self.logger = logger
+        self.current_message = 0
+        self.total_messages = 0
+        self.length = 0
+        self.service_data = 0
+        self.raw_service_record = []
+        self.utilities = Utils()
+        # Service main record
+        self.hd_service_record = OrderedDict()
+
+        if self.can_interface is not None:
+            channel_id = DenaliChannels.hd_to_dialin_ch_id
+            msg_id = MsgIds.MSG_ID_HD_SEND_SERVICE_RECORD.value
+            self.can_interface.register_receiving_publication_function(channel_id, msg_id,
+                                                                       self._handler_hd_service_sync)
+        # Prepare the service record by putting sub-dictionaries together
+        self._prepare_hd_service_record()
+
+    def get_hd_service_record(self):
+        """
+        Handles getting HD 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 record
+        self._request_hd_fw_service_record()
+
+    def _request_hd_fw_service_record(self):
+        """
+        Handles getting HD service record from firmware.
+
+        @return: None
+        """
+        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
+                                              message_id=MsgIds.MSG_ID_HD_GET_SERVICE_RECORD.value)
+
+        self.logger.debug('Getting HD 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
+
+    @_publish(["current_message", "total_messages", "length", "service_data"])
+    def _handler_hd_service_sync(self, message):
+        """
+        Handles published HD system record messages. HD system records are captured for
+        processing and updating the HD system record.
+
+        @param message:  published HD 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 calibration_record record payload is from the start index + 12 bytes for the current message +total
+        # messages + the length of calibration_record. The rest is the CAN messaging CRC that is not needed to be kept
+        end_of_data_index = self._RECORD_START_INDEX + self._RECORD_SPECS_BYTES + self.length
+
+        # Get the data only and not specs of it (i.e current message number)
+        self.service_data = message['message'][self._RECORD_START_INDEX:end_of_data_index]
+
+        # Continue getting calibration_record records until the all the calibration_record messages are received.
+        # Concatenate the calibration_record records to each other
+        if self.current_message <= self.total_messages:
+            self.raw_service_record += (message['message'][self._RECORD_START_INDEX +
+                                                           self._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.utilities.process_received_record_from_fw(self.hd_service_record, self.raw_service_record)
+
+    def _prepare_hd_service_record(self):
+        """
+        Handles assembling the sub dictionaries of each group to make the main HD service record.
+
+        @return: None
+        """
+        groups_byte_size = 0
+        # create a list of the functions of the sub dictionaries
+        functions = [self._prepare_service_record()]
+
+        for function in functions:
+            # Update the groups bytes size so far to be use to padding later
+            groups_byte_size += function[1]
+            # Update the calibration record
+            self.hd_service_record.update(function[0])
+
+        # Build the CRC of the main calibration_record record
+        record_crc = OrderedDict({'crc': ['<H', self._DEFAULT_CRC_VALUE]})
+
+        # Get the groups byte size
+        groups_byte_size += self.utilities.calculate_group_byte_size(record_crc)
+
+        # Get the padding size to create a dictionary from it
+        padding_size = self.utilities.calculate_padding_byte_size(groups_byte_size, self._RTC_RAM_MAX_BYTES_TO_WRITE)
+
+        # Create the padding dictionary as list of unsigned char. All the elements are 0.
+        padding = OrderedDict({'padding': ['<B', [self._DEFAULT_CRC_VALUE] * padding_size]})
+
+        # Update the dictionary with the padding and record crc dictionaries
+        self.hd_service_record.update(padding)
+        self.hd_service_record.update(record_crc)
+
+    def _prepare_service_record(self):
+        """
+        Handles creating the service record dictionary.
+
+        @return: service record dictionary and the byte size of this group
+        """
+        groups_byte_size = 0
+        service_records = OrderedDict({'service_record':
+                                      {'service_location': ['<B', self._DEFAULT_SERVICE_LOCATION],
+                                       'service_date': ['<i', self._DEFAULT_TIME_VALUE],
+                                       'crc': ['<H', self._DEFAULT_CRC_VALUE]}})
+
+        for record in service_records.keys():
+            groups_byte_size += self.utilities.calculate_group_byte_size(service_records[record])
+
+        return service_records, groups_byte_size
+
+    def set_hd_service_record(self):
+        """
+        Handles updating the HD system and sends it to FW.
+
+        @return: none
+        """
+        record_packets = self.utilities.prepare_record_to_send_to_fw(self.hd_service_record)
+
+        self.logger.debug('Setting HD service record')
+
+        # Update all the data packets with the last message count since is the number of messages that firmware
+        # should receive
+        for packet in record_packets:
+            # Sleep to let the firmware receive and process the data
+            time.sleep(self._PAYLOAD_TRANSFER_DELAY)
+
+            # Convert the list packet to a bytearray
+            payload = b''.join(packet)
+
+            message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
+                                                  message_id=MsgIds.MSG_ID_HD_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/hd/system_record.py
===================================================================
diff -u -rab49c2b2e6bd03745f5a910780791d4b18000fd1 -r97c98d84604e3700dd446235e91a5ebe2db08022
--- dialin/hd/system_record.py	(.../system_record.py)	(revision ab49c2b2e6bd03745f5a910780791d4b18000fd1)
+++ dialin/hd/system_record.py	(.../system_record.py)	(revision 97c98d84604e3700dd446235e91a5ebe2db08022)
@@ -2,7 +2,6 @@
 import datetime
 import time
 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
@@ -58,7 +57,7 @@
             channel_id = DenaliChannels.hd_to_dialin_ch_id
             msg_id = MsgIds.MSG_ID_HD_SEND_SYSTEM_RECORD.value
             self.can_interface.register_receiving_publication_function(channel_id, msg_id, self._handler_hd_system_sync)
-        # Prepare the calibration_record record by putting sub-dictionaries together
+        # Prepare the system record by putting sub-dictionaries together
         self._prepare_hd_system_record()
 
     def get_hd_system_record(self):
@@ -93,7 +92,7 @@
             self.logger.debug("Timeout!!!!")
             return False
 
-    @_publish(["current_message", "total_messages", "length", "sys_data"])
+    @_publish(["current_message", "total_messages", "length", "service_data"])
     def _handler_hd_system_sync(self, message):
         """
         Handles published HD system record messages. HD system records are captured for
@@ -197,7 +196,6 @@
 
             # 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_hd_ch_id,
                                                   message_id=MsgIds.MSG_ID_HD_SET_SYSTEM_RECORD.value,
Index: dialin/utils/utils.py
===================================================================
diff -u -rab49c2b2e6bd03745f5a910780791d4b18000fd1 -r97c98d84604e3700dd446235e91a5ebe2db08022
--- dialin/utils/utils.py	(.../utils.py)	(revision ab49c2b2e6bd03745f5a910780791d4b18000fd1)
+++ dialin/utils/utils.py	(.../utils.py)	(revision 97c98d84604e3700dd446235e91a5ebe2db08022)
@@ -142,7 +142,7 @@
                 data += raw.decode("utf-8")
                 read_start_index += value_bytes
         else:
-            # Unpack the values to written to the dictionary
+            # Unpack the values to be written to the dictionary
             data = struct.unpack(data_type, fw_raw_records_bytes[read_start_index: read_start_index + value_bytes])[0]
             # Update the index of the raw payload for the next read
             read_start_index += value_bytes
Index: tests/test_dg_calibration.py
===================================================================
diff -u -rab49c2b2e6bd03745f5a910780791d4b18000fd1 -r97c98d84604e3700dd446235e91a5ebe2db08022
--- tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision ab49c2b2e6bd03745f5a910780791d4b18000fd1)
+++ tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision 97c98d84604e3700dd446235e91a5ebe2db08022)
@@ -16,42 +16,40 @@
 
     f = open("DG_Calibration.log", "w")
 
-    #print(cal.DG_CALIBRATION_RECORD)
-    #exit(0)
+    status = True
 
-    status = False
+    """
+    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
+    cal.dg_calibration_record['volumes']['drain_line']['volume'][1] = 125.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
+    cal.dg_calibration_record['accelerometer_sensor']['accelerometer']['y_offset'][1] = 678.9
+    """
 
-    cal.hd_system_record['pumps']['concentrate_1']['step_speed_2_flow_ratio'][1] = 34.2
-    cal.hd_system_record['pumps']['drain']['cal_time'][1] = 96321
-    cal.hd_system_record['pumps']['ro']['gain_3_ratio'][1] = 45.69
-    cal.hd_system_record['volumes']['drain_line']['volume'][1] = 125.8
-    cal.hd_system_record['volumes']['drain_line']['crc'][1] = 78
-    cal.hd_system_record['volumes']['pre_ro_purge']['volume'][1] = 125.8
-    cal.hd_system_record['volumes']['reservoir_1']['max_residual_fluid'][1] = 85.36
-    cal.hd_system_record['bicarb_concentrates']['bicarb_conc_3']['reserved_space'][1] = 85.36
-    cal.hd_system_record['fans']['fan_2']['reserved_space_2'][1] = 456.25
+    print(cal.dg_calibration_record)
 
-    print(cal.hd_system_record)
-
     try:
         if status:
             dara = []
-            cal.get_hd_system_record()
+            cal.get_dg_calibration_record()
             while True:
-                sleep(0.2)
-                #print(cal.current_message, cal.total_messages, cal.sys_data)
 
-                if cal.sys_data != 0:
-                    f.write(str(cal.sys_data) + '\r')
-                    dara.append(cal.sys_data)
+                if cal.cal_data != 0:
+                    #f.write(str(cal.service_data) + '\r')
+                    #dara.append(cal.service_data)
 
                     if cal.current_message == cal.total_messages:
                         f.close()
                         break
         else:
-            cal.set_hd_system_record()
+            cal.set_dg_calibration_record()
 
-        print(cal.hd_system_record)
+        print(cal.dg_calibration_record)
 
     except KeyboardInterrupt:
         f.close()
Index: tests/test_dg_service_record.py
===================================================================
diff -u -ra26b886c2bbe75c1292afa150a63d1d9b8026b3b -r97c98d84604e3700dd446235e91a5ebe2db08022
--- tests/test_dg_service_record.py	(.../test_dg_service_record.py)	(revision a26b886c2bbe75c1292afa150a63d1d9b8026b3b)
+++ tests/test_dg_service_record.py	(.../test_dg_service_record.py)	(revision 97c98d84604e3700dd446235e91a5ebe2db08022)
@@ -1,6 +1,7 @@
 from dialin.dg.dialysate_generator import DG
 from dialin.ui import crc
 from time import sleep
+from dialin.utils.utils import Utils
 import struct
 
 if __name__ == "__main__":
@@ -11,22 +12,24 @@
         exit(1)
     sleep(2)
 
+    utilities = Utils()
     srvc = dg.service_record
 
-    srvc.dg_service_record['service_record']['crc'][1] = 5522
+    #srvc.dg_service_record['service_record']['service_date'][1] = utilities.get_current_time_in_epoch()
     print((srvc.dg_service_record))
     #print(len(sys.dg_service_record['system_record']['top_level_pn'][1]))
 
-    #srvc.get_dg_service_record()
+    srvc.get_dg_service_record()
 
-    #while True:
-    #    sleep(0.2)
-    #    if srvc.current_message == srvc.total_messages:
-    #        break
+    while True:
+        sleep(0.2)
+        if srvc.current_message == srvc.total_messages:
+            break
 
-    print(srvc.dg_service_record)
+    #print(srvc.dg_service_record)
     #print((sys.dg_service_record['system_record']['top_level_pn'][1]))
 
-    srvc.set_dg_service_data()
+    #srvc.set_dg_service_record()
+    print(srvc.dg_service_record)
 
     #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 -r43e8345862c72340680c045e53b310aa291513a6 -r97c98d84604e3700dd446235e91a5ebe2db08022
--- tests/test_dg_system_record.py	(.../test_dg_system_record.py)	(revision 43e8345862c72340680c045e53b310aa291513a6)
+++ tests/test_dg_system_record.py	(.../test_dg_system_record.py)	(revision 97c98d84604e3700dd446235e91a5ebe2db08022)
@@ -10,21 +10,19 @@
     if dg.cmd_log_in_to_dg() == 0:
         exit(1)
     sleep(2)
+
     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.dg_system_record['system_record']['top_level_pn'][1] = 'DEN-SN-Y20'
+    print(sys.dg_system_record)
+    test = True
 
-    sys.get_dg_service_record()
+    if test:
+        sys.get_dg_system_record()
+        while True:
+            sleep(0.2)
+            if sys.current_message == sys.total_messages:
+                break
+    else:
+        sys.set_dg_system_record()
 
-    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])
+    print(sys.dg_system_record)
Index: tests/test_hd_records.py
===================================================================
diff -u -rab49c2b2e6bd03745f5a910780791d4b18000fd1 -r97c98d84604e3700dd446235e91a5ebe2db08022
--- tests/test_hd_records.py	(.../test_hd_records.py)	(revision ab49c2b2e6bd03745f5a910780791d4b18000fd1)
+++ tests/test_hd_records.py	(.../test_hd_records.py)	(revision 97c98d84604e3700dd446235e91a5ebe2db08022)
@@ -15,44 +15,50 @@
     sleep(2)
 
     cal = hd.calibration_record
+    sys = hd.system_record
+    srv = hd.service_record
     utilities = Utils()
 
-    sys = hd.system_record
-
     #print(cal.hd_calibration_record)
-
+    print(srv.dg_service_record)
     cal.hd_calibration_record['accelerometer_sensor']['accelerometer']['x_offset'][1] = 952.12
     cal.hd_calibration_record['accelerometer_sensor']['accelerometer']['y_offset'][1] = 45.2
     cal.hd_calibration_record['accelerometer_sensor']['accelerometer']['z_offset'][1] = 712.58
     cal.hd_calibration_record['accelerometer_sensor']['accelerometer']['cal_time'][1] = utilities.get_current_time_in_epoch()
-    print(sys.hd_system_record)
+    #print(sys.dg_system_record)
 
-    #sys.hd_system_record['system_record']['top_level_pn'][1] = 'abcd-12345'
-    #sys.hd_system_record['system_record']['mfg_date'][1] = utilities.get_current_time_in_epoch()
+    #sys.dg_service_record['system_record']['top_level_pn'][1] = 'abcd-12345'
+    #sys.dg_service_record['system_record']['mfg_date'][1] = utilities.get_current_time_in_epoch()
 
+    #srv.dg_service_record['service_record']['service_date'][1] = utilities.get_current_time_in_epoch()
+
+
     status = True
     try:
         if status:
             dara = []
             #cal.get_hd_calibration_record()
-            sys.get_hd_system_record()
+            #sys.get_hd_system_record()
+            srv.get_dg_service_record()
             while True:
                 sleep(0.2)
-                #print(cal.current_message, cal.total_messages, cal.sys_data)
+                #print(cal.current_message, cal.total_messages, cal.service_data)
 
-                if sys.sys_data != 0:
-                    #f.write(str(cal.sys_data) + '\r')
-                    #dara.append(cal.sys_data)
+                if srv.service_data != 0:
+                    #f.write(str(cal.service_data) + '\r')
+                    #dara.append(cal.service_data)
 
-                    if sys.current_message == sys.total_messages:
+                    if srv.current_message == srv.total_messages:
                         #f.close()
                         break
         else:
             #cal.set_hd_calibration_record()
-            sys.set_hd_system_record()
+            #sys.set_hd_system_record()
+            srv.set_dg_service_record()
 
         #print(cal.hd_calibration_record)
-        print(sys.hd_system_record)
+        #print(sys.dg_system_record)
+        print(srv.dg_service_record)
 
     except KeyboardInterrupt:
         #f.close()