Index: dialin/dg/calibration_record.py
===================================================================
diff -u -re36d87e663d95c79214f66b5db9aa6d6e8b47adf -ra26b886c2bbe75c1292afa150a63d1d9b8026b3b
--- dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision e36d87e663d95c79214f66b5db9aa6d6e8b47adf)
+++ dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision a26b886c2bbe75c1292afa150a63d1d9b8026b3b)
@@ -8,6 +8,7 @@
 from ..common.msg_defs import MsgIds, MsgFieldPositions
 from ..protocols.CAN import (DenaliMessage, DenaliChannels)
 from ..utils.base import _AbstractSubSystem, _publish
+from ..utils.utils import Utils
 from logging import Logger
 
 
@@ -17,18 +18,18 @@
     Dialysate Generator (DG) Dialin API sub-class for calibration commands.
     """
 
-    CALIBRATION_RECORD_START_INDEX = 6
-    CALIBRATION_RECORD_SPECS_BYTES = 12
+    _RECORD_START_INDEX = 6
+    _RECORD_SPECS_BYTES = 12
     CALIBRATION_RECORDS_SPECS_BYTE_ARRAY = 3
-    DEFAULT_GAIN_VALUE = 1
-    DEFAULT_OFFSET_VALUE = 0
+    _DEFAULT_GAIN_VALUE = 1
+    _DEFAULT_OFFSET_VALUE = 0
     DEFAULT_RATIO_VALUE = 1
     DEFAULT_VOLUME_VALUE = 0
     DEFAULT_CONCENTRATE_VALUE = 1
     DEFAULT_BICARB_VALUE = 1
-    DEFAULT_CALIBRATION_VALUE = 1
-    DEFAULT_CAL_TIME_VALUE = 0
-    DEFAULT_CAL_CRC_VALUE = 0
+    _DEFAULT_CALIBRATION_VALUE = 1
+    _DEFAULT_TIME_VALUE = 0
+    _DEFAULT_CRC_VALUE = 0
 
     CURRENT_MESSAGE_NUM_INDEX = 0
     TOTAL_MESSAGES_NUM_INDEX = 4
@@ -41,15 +42,13 @@
     TARGET_BYTES_TO_SEND_TO_FW = 150
     MIN_PAYLOAD_BYTES_SPACE = 4
 
-    EEPROM_MAX_BYTES_TO_WRITE = 16
+    _EEPROM_MAX_BYTES_TO_WRITE = 16
 
     PAYLOAD_CURRENT_MSG_INDEX = 0
     PAYLOAD_TOTAL_MSG_INDEX = 1
     PAYLOAD_CAL_BYTES_INDEX = 2
+    _PAYLOAD_TRANSFER_DELAY = 0.2
 
-    # DG calibration main record
-    DG_CALIBRATION_RECORD = OrderedDict()
-
     def __init__(self, can_interface, logger: Logger):
         """
 
@@ -65,6 +64,9 @@
         self.length = 0
         self.cal_data = 0
         self.raw_cal_record = []
+        self.utilities = Utils()
+        # DG calibration main record
+        self.dg_calibration_record = OrderedDict()
 
         if self.can_interface is not None:
 
@@ -129,76 +131,20 @@
         self.length = length
         # The end of calibration record payload is from the start index + 12 bytes for the current message + total
         # messages + the length of calibration. The rest is the CAN messaging CRC that is not needed to be kept
-        end_of_data_index = self.CALIBRATION_RECORD_START_INDEX + self.CALIBRATION_RECORD_SPECS_BYTES + self.length
+        end_of_data_index = self._RECORD_START_INDEX + self._RECORD_SPECS_BYTES + self.length
 
         # Get the calibration data only
-        self.cal_data = message['message'][self.CALIBRATION_RECORD_START_INDEX:end_of_data_index]
+        self.cal_data = message['message'][self._RECORD_START_INDEX:end_of_data_index]
 
         # Continue getting calibration records until the all the calibration messages are received. Concatenate the
         # calibration records to each other
         if self.current_message <= self.total_messages:
-            self.raw_cal_record += (message['message'][self.CALIBRATION_RECORD_START_INDEX +
-                                                       self.CALIBRATION_RECORD_SPECS_BYTES:end_of_data_index])
+            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._update_dg_calibration_record_from_fw()
+                self.utilities.process_received_record_from_fw(self.dg_calibration_record, self.raw_cal_record)
 
-    def _update_dg_calibration_record_from_fw(self):
-        """
-        Handles parsing the calibration messages that were received from DG firmware.
-
-        @return: None
-        """
-        raw_payload_temp_start_index = 0
-        # Convert the concatenated raw data into a byte array since the struct library requires byte arrays.
-        self.raw_cal_record = bytearray(self.raw_cal_record)
-
-        # Loop through the keys for the main calibration dictionary
-        # DG_Calibration : {pressure_sensors : { ppi : { gain: ['<f', 12.3], offset: ['<f', 5.67]}}, ...}
-        # Get the list of keys of the main dictionary (i.e. pressure_sensors, temperature_sensors, ....}
-        # These keys are the list of hardware groups
-        for group in self.DG_CALIBRATION_RECORD.keys():
-            # All the hardware groups (i.e pressure sensors) are nested dictionaries, except the final CRC. So it is
-            # unpacked exceptionally here. The CRC is an unsigned 16-bit (short).
-            if group == 'crc':
-                # Get the data type ( it must be '<H')
-                data_type = self.DG_CALIBRATION_RECORD[group][self.CALIBRATION_DATA_TYPE_INDEX]
-                # Check the data type of the crc
-                value_bytes = self._get_data_type_bytes(data_type)
-                # Unpack the data
-                data = struct.unpack(data_type, self.raw_cal_record[raw_payload_temp_start_index:
-                                                                    raw_payload_temp_start_index + value_bytes])[0]
-                self.DG_CALIBRATION_RECORD[group][self.CALIBRATION_VALUE_INDEX] = data
-            elif group == 'padding':
-                # Get the data type
-                data_type = self.DG_CALIBRATION_RECORD[group][self.CALIBRATION_DATA_TYPE_INDEX]
-                # Check the data type of the padding values (they are unsigned chars)
-                value_bytes = self._get_data_type_bytes(data_type)
-                # Get the length of the padding list
-                padding_length = len(self.DG_CALIBRATION_RECORD[group][self.CALIBRATION_VALUE_INDEX])
-                # Add the length of the padding bytes to the payload start address
-                raw_payload_temp_start_index += padding_length * value_bytes
-            # The rest of the groups are hardware which are layered dictionaries
-            else:
-                # If the value is not a CRC, it is nested dictionary of different hardware groups
-                # Loop through the values of each key to get the list of the hardware in a hardware group (i.e
-                # pressure_sensors have ppi, ppo, ...)
-                for hardware_group in self.DG_CALIBRATION_RECORD[group].keys():
-                    # Each hardware has a set of calibration values (i.e ppi: {gain: ['<f',  12.3]}. Loop though those
-                    for hardware in self.DG_CALIBRATION_RECORD[group][hardware_group]:
-                        # The values of the dictionary of each hardware is a list of its data type as well as its value
-                        # which the first index is data type
-                        data_type = self.DG_CALIBRATION_RECORD[group][hardware_group][hardware][
-                                    self.CALIBRATION_DATA_TYPE_INDEX]
-                        value_bytes = self._get_data_type_bytes(data_type)
-                        # Unpack the values to written to the dictionary
-                        data = struct.unpack(data_type, self.raw_cal_record[raw_payload_temp_start_index:
-                                                                            raw_payload_temp_start_index +
-                                                                            value_bytes])[0]
-                        # Update the index of the raw payload for the next read
-                        raw_payload_temp_start_index += value_bytes
-                        self.DG_CALIBRATION_RECORD[group][hardware_group][hardware][self.CALIBRATION_VALUE_INDEX] = data
-
     def _prepare_dg_calibration_record(self):
         """
         Handles assembling the sub dictionaries of each hardware group to make the main DG calibration record.
@@ -220,28 +166,26 @@
         filters = self._prepare_filters_record()
         fans = self._prepare_fans_record()
         # Build the CRC of the main calibration record
-        cal_record_crc = OrderedDict({'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]})
+        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] + self._get_data_type_bytes(cal_record_crc['crc']
-                                                                                  [self.CALIBRATION_DATA_TYPE_INDEX])
-        # Calculate the padding size:
-        # If bytes in the dictionary % max write bytes to EEPROM (16) is 0, not padding is needed
-        # Else padding = (ceil(dictionary bytes/max write to EEPROM (16)) * max write to EEPROM (16)) - dictionary bytes
-        if (groups_byte_size % self.EEPROM_MAX_BYTES_TO_WRITE) == 0:
-            padding_size = 0
-        else:
-            padding_size = (math.ceil(groups_byte_size / self.EEPROM_MAX_BYTES_TO_WRITE) *
-                            self.EEPROM_MAX_BYTES_TO_WRITE) - groups_byte_size
+                           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)
+
+        # 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)
+
         # Create the padding dictionary as list of unsigned char. All the elements are 0.
-        padding = OrderedDict({'padding': ['<B', [self.DEFAULT_CAL_CRC_VALUE] * padding_size]})
+        padding = OrderedDict({'padding': ['<B', [self._DEFAULT_CRC_VALUE] * padding_size]})
 
         # Insert the sub dictionaries into the main calibration record. The dictionaries are the element 0.
         # The padding and CRC dictionaries are created without using tuples.
-        self.DG_CALIBRATION_RECORD = {**pressure[0], **flow[0], **load_cells[0], **temperature[0], **conductivity[0],
+        self.dg_calibration_record = {**pressure[0], **flow[0], **load_cells[0], **temperature[0], **conductivity[0],
                                       **pumps[0], **volumes[0], **acid[0], **bicarb[0], **filters[0], **fans[0],
-                                      **padding, **cal_record_crc}
+                                      **padding, **record_crc}
 
     def _prepare_pressure_sensors_cal_record(self):
         """
@@ -258,10 +202,10 @@
 
         for i in hardware_names:
 
-            hardware[i] = {'gain': ['<f', self.DEFAULT_GAIN_VALUE], 'offset': ['<f', self.DEFAULT_OFFSET_VALUE],
-                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            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._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
@@ -280,11 +224,11 @@
 
         for i in hardware_names:
 
-            hardware[i] = {'gain': ['<f', self.DEFAULT_GAIN_VALUE], 'offset': ['<f', self.DEFAULT_OFFSET_VALUE],
-                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            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._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
@@ -303,11 +247,11 @@
 
         for i in hardware_names:
 
-            hardware[i] = {'gain': ['<f', self.DEFAULT_GAIN_VALUE], 'offset': ['<f', self.DEFAULT_OFFSET_VALUE],
-                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            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._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
@@ -329,11 +273,11 @@
 
         for i in hardware_names:
 
-            hardware[i] = {'gain': ['<f', self.DEFAULT_GAIN_VALUE], 'offset': ['<f', self.DEFAULT_OFFSET_VALUE],
-                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            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._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
@@ -352,11 +296,11 @@
 
         for i in hardware_names:
 
-            hardware[i] = {'gain': ['<f', self.DEFAULT_GAIN_VALUE], 'offset': ['<f', self.DEFAULT_OFFSET_VALUE],
-                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            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._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
@@ -377,21 +321,21 @@
             # Different pumps have different calibration values
             if i == 'concentrate_1' or i == 'concentrate_2':
                 hardware[i] = {'step_speed_2_flow_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
-                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
-                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+                               'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
+                               'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             elif i == 'drain':
                 hardware[i] = {'voltage_2_speed_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
                                'step_speed_2_flow_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
-                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
-                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+                               'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
+                               'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             elif i == 'ro':
                 hardware[i] = {'gain_1_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
                                'gain_2_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
                                'gain_3_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
-                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
-                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+                               'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
+                               'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
-            group_byte_size += self._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
@@ -412,26 +356,26 @@
         for i in hardware_names:
             if i == 'drain_line':
                 hardware[i] = {'volume': ['<f', self.DEFAULT_VOLUME_VALUE],
-                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
-                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+                               'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
+                               'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             elif i == 'pre_ro_purge':
                 hardware[i] = {'pressure_2_flow_ratio': ['<f', self.DEFAULT_RATIO_VALUE],
                                'volume': ['<f', self.DEFAULT_VOLUME_VALUE],
-                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
-                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+                               'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
+                               'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             elif i == 'reservoir_1' or i == 'reservoir_2':
                 hardware[i] = {'reservoir_volume': ['<f', self.DEFAULT_VOLUME_VALUE],
                                'normal_fill_volume': ['<f', self.DEFAULT_VOLUME_VALUE],
                                'max_residual_fluid': ['<f', self.DEFAULT_VOLUME_VALUE],
                                'reservoir_unfilled_weight': ['<f', self.DEFAULT_VOLUME_VALUE],
-                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
-                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+                               'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
+                               'crc': ['<H', self._DEFAULT_CRC_VALUE]}
             else:
                 hardware[i] = {'volume': ['<f', self.DEFAULT_VOLUME_VALUE],
-                               'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE],
-                               'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+                               'cal_time': ['<i', self._DEFAULT_TIME_VALUE],
+                               'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
-            group_byte_size += self._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
@@ -452,9 +396,9 @@
             hardware[i] = {'acid_conc_mix_ratio': ['<f', self.DEFAULT_CONCENTRATE_VALUE],
                            'start_volume': ['<f', self.DEFAULT_VOLUME_VALUE],
                            'reserved_space': ['<f', self.DEFAULT_VOLUME_VALUE],
-                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+                           'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
-            group_byte_size += self._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
@@ -475,9 +419,9 @@
             hardware[i] = {'bicarb_conc_mix_ratio': ['<f', self.DEFAULT_CONCENTRATE_VALUE],
                            'start_volume': ['<f', self.DEFAULT_VOLUME_VALUE],
                            'reserved_space': ['<f', self.DEFAULT_VOLUME_VALUE],
-                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+                           'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
-            group_byte_size += self._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
@@ -495,12 +439,12 @@
         hardware = OrderedDict()
 
         for i in hardware_names:
-            hardware[i] = {'reserved_space_1': ['<f', self.DEFAULT_CALIBRATION_VALUE],
-                           'reserved_space_2': ['<f', self.DEFAULT_CALIBRATION_VALUE],
-                           'reserved_space_3': ['<f', self.DEFAULT_CALIBRATION_VALUE],
-                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            hardware[i] = {'reserved_space_1': ['<f', self._DEFAULT_CALIBRATION_VALUE],
+                           'reserved_space_2': ['<f', self._DEFAULT_CALIBRATION_VALUE],
+                           'reserved_space_3': ['<f', self._DEFAULT_CALIBRATION_VALUE],
+                           'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
 
-            group_byte_size += self._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
@@ -518,195 +462,53 @@
         hardware = OrderedDict()
 
         for i in hardware_names:
-            hardware[i] = {'reserved_space_1': ['<f', self.DEFAULT_CALIBRATION_VALUE],
-                           'reserved_space_2': ['<f', self.DEFAULT_CALIBRATION_VALUE],
-                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            hardware[i] = {'reserved_space_1': ['<f', self._DEFAULT_CALIBRATION_VALUE],
+                           '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._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 _calculate_group_byte_size(self, group):
-        """
-        Handles calculating the byte size of the values of the provided dictionary.
-
-        @param group: the dictionary that is passed to calculate the byte size
-        @return: calculated byte size
-        """
-        byte_size = 0
-        for key in group.keys():
-            data_type = group[key][self.CALIBRATION_DATA_TYPE_INDEX]
-            byte_size += self._get_data_type_bytes(data_type)
-
-        return byte_size
-
-    @staticmethod
-    def _get_data_type_bytes(data):
-        """
-        Handles converting the string representation of the bytes of the data types in a struct to numbers.
-        This is a static method.
-
-        @param data: the data to be converted to bytes in number
-        @return: calculated byte size
-        """
-        number_of_bytes = 0
-        # Unsigned integer = i
-        # Signed integer = I
-        # Float = f. All 4 bytes.
-        if data == '<i' or data == '<f':
-            number_of_bytes = 4
-        # Unsigned short = H. 2 bytes.
-        elif data == '<H':
-            number_of_bytes = 2
-        # Unsigned char = B. 1 byte.
-        elif data == '<B':
-            number_of_bytes = 1
-
-        return number_of_bytes
-
     def set_dg_calibration_data(self):
         """
         Handles updating the DG calibration record with the newest calibration data of a hardware and sends it to FW.
 
         @return: none
         """
         # TODO remove for testing only
-        self.DG_CALIBRATION_RECORD['pressure_sensors']['ppi']['offset'] = ['<f', 23.0]
-        self.DG_CALIBRATION_RECORD['pressure_sensors']['ppi']['gain'] = ['<f', 6.7]
+        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]
+        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])
+        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]
+        self.dg_calibration_record['pressure_sensors']['pdr']['crc'][1] = crc_test
+        self.dg_calibration_record['conductivity_sensors']['reserved_2']['offset'] = ['<f', 159.25]
         # TODO remove for testing only
 
-        # This list contains different data packet lists
-        # i.e. [[message 1, payload], [message 2, payload], ...]
-        cal_record_packets = []
-        current_payload_length = 0
-        current_message_count = 1
-        temp_buffer = [0, 0, 0]
+        record_packets = self.utilities.prepare_record_to_send_to_fw(self.dg_calibration_record)
 
-        # Loop through the DG calibration dictionary
-        for group in self.DG_CALIBRATION_RECORD.keys():
-
-            # NOTE: crc and padding are checked separately since they do not have layered dictionaries
-            # If the group is the final CRC of the dictionary
-            if group == 'crc':
-                data_type = self.DG_CALIBRATION_RECORD[group][self.CALIBRATION_DATA_TYPE_INDEX]
-
-                current_payload_length += self._get_data_type_bytes(data_type)
-                temp_buffer[self.PAYLOAD_CAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-                temp_buffer.append(struct.pack(data_type, self.DG_CALIBRATION_RECORD[group]
-                                                                                    [self.CALIBRATION_VALUE_INDEX]))
-                cal_record_packets.append(temp_buffer)
-            # If the group is padding, and the length of padding is not 0
-            elif group == 'padding':
-                if len(self.DG_CALIBRATION_RECORD[group][self.CALIBRATION_VALUE_INDEX]) != 0:
-                    # Get the data type and calculate the number of bytes
-                    data_type = self.DG_CALIBRATION_RECORD[group][self.CALIBRATION_DATA_TYPE_INDEX]
-                    data_type_bytes = self._get_data_type_bytes(data_type)
-                    # If there are padding zeros, they are in a list. loop through the list and add them to temp buffer
-                    for pad in self.DG_CALIBRATION_RECORD[group][self.CALIBRATION_VALUE_INDEX]:
-                        if self.TARGET_BYTES_TO_SEND_TO_FW - current_payload_length > self.MIN_PAYLOAD_BYTES_SPACE:
-                            current_payload_length += data_type_bytes
-                            temp_buffer[self.PAYLOAD_TOTAL_MSG_INDEX] = struct.pack('<i', 0)
-                            temp_buffer.append(struct.pack(data_type, pad))
-                        else:
-                            temp_buffer[self.PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
-                            temp_buffer[self.PAYLOAD_CAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-                            cal_record_packets.append(temp_buffer)
-
-                            current_message_count += 1
-                            current_payload_length = data_type_bytes
-                            temp_buffer = [struct.pack('<i', current_message_count), struct.pack('<i', 0),
-                                           struct.pack('<i', current_payload_length),
-                                           struct.pack(data_type, pad)]
-            else:
-                # Dictionaries of the hardware. Loop through each hardware group and through each hardware
-                # (i.e. pressure_sensors : ppi, ppo, ...)
-                for hardware_group in self.DG_CALIBRATION_RECORD[group].keys():
-                    for hardware in self.DG_CALIBRATION_RECORD[group][hardware_group]:
-                        # Get the data type and calculate the number of bytes
-                        data_type = self.DG_CALIBRATION_RECORD[group][hardware_group][hardware]\
-                                                              [self.CALIBRATION_DATA_TYPE_INDEX]
-                        data_type_bytes = self._get_data_type_bytes(data_type)
-                        # If minimum number of bytes space is still available in current temp buffer, continue inserting
-                        # data into the buffer.
-                        if self.TARGET_BYTES_TO_SEND_TO_FW - current_payload_length > self.MIN_PAYLOAD_BYTES_SPACE:
-
-                            current_payload_length += data_type_bytes
-                            # Insert a 4-byte 0 to the index of the total messages. This is a place holder and it will
-                            # be updated with the right value later.
-                            temp_buffer[self.PAYLOAD_TOTAL_MSG_INDEX] = struct.pack('<i', 0)
-                            # Append the current value of the dictionary into the temp buffer. There is still space left
-                            temp_buffer.append(struct.pack(data_type, self.DG_CALIBRATION_RECORD[group][hardware_group]
-                                                                            [hardware][self.CALIBRATION_VALUE_INDEX]))
-                        else:
-                            # There is not enough space left in this temp buffer. Update the current message count and
-                            # the total number of bytes that were packed in this data packet.
-                            temp_buffer[self.PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
-                            temp_buffer[self.PAYLOAD_CAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-                            # Append the temp buffer list into the main list to be process later
-                            cal_record_packets.append(temp_buffer)
-                            # Increment the current message count as a new temp buffer is created for the next data
-                            # packet. Update the current payload length with the latest addition to the new temp buffer.
-                            current_message_count += 1
-                            current_payload_length = data_type_bytes
-                            # Create a new temp buffer and add the current message count, total length of payload so far
-                            # and the data that there was not enough space in the previous data packet.
-                            temp_buffer = [struct.pack('<i', current_message_count), struct.pack('<i', 0),
-                                           struct.pack('<i', current_payload_length),
-                                           struct.pack(data_type, self.DG_CALIBRATION_RECORD[group][hardware_group]
-                                                                             [hardware][self.CALIBRATION_VALUE_INDEX])]
-        # Creating a byte array variable and add all the data packets
-        # to one to calculate the final CRC
-        data = b''
-        for cal in cal_record_packets:
-            # If the data packet is the last one in the list, ignore the last element of the
-            # packet since it is the final CRC of the entire dictionary. The final CRC itself
-            # is not included in the CRC calculations.
-            # The actual calibration data is started from the 3rd element of the data packet.
-            # The first 3 are current message, total messages, and the payload length of the current packet.
-            if cal_record_packets.index(cal) == len(cal_record_packets) - 1:
-                data += b''.join(cal[self.CALIBRATION_RECORDS_SPECS_BYTE_ARRAY:-1])
-            else:
-                # Get all the elements including the last one
-                data += b''.join(cal[self.CALIBRATION_RECORDS_SPECS_BYTE_ARRAY:])
-
-        # Calculate the 16-bit crc.
-        crc = crc_16(data)
-        # Convert the crc into a 2-byte value
-        cal_record_crc = struct.pack('<H', crc)
-        # Insert the CRC into the last element of the last data packet
-        cal_record_packets[-1][-1] = cal_record_crc
-
-        print('CRC: ', hex(crc)) #TODO remove
-
         self.logger.debug('DG calibration started')
 
         # Update all the data packets with the last message count since is the number of messages that firmware
         # should receive
-        for packet in cal_record_packets:
+        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 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
+            #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 -ra3be707a0f11b8f01ff32199b60b6162238b6e64 -ra26b886c2bbe75c1292afa150a63d1d9b8026b3b
--- dialin/dg/service_record.py	(.../service_record.py)	(revision a3be707a0f11b8f01ff32199b60b6162238b6e64)
+++ dialin/dg/service_record.py	(.../service_record.py)	(revision a26b886c2bbe75c1292afa150a63d1d9b8026b3b)
@@ -1,9 +1,7 @@
 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
@@ -145,61 +143,8 @@
                                                            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()
+                self.utilities.process_received_record_from_fw(self.dg_service_record, self.raw_service_record)
 
-    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.
@@ -216,18 +161,18 @@
             groups_byte_size += self.utilities.calculate_group_byte_size(service_records[record])
 
         # Build the CRC of the main system record
-        cal_record_crc = OrderedDict({'crc': ['<H', self._DEFAULT_CRC_VALUE]})
+        record_crc = OrderedDict({'crc': ['<H', self._DEFAULT_CRC_VALUE]})
 
         # Get the groups byte size
-        groups_byte_size += self.utilities.calculate_group_byte_size(cal_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._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]})
 
-        self.dg_service_record = {**service_records, **padding, **cal_record_crc}
+        self.dg_service_record = {**service_records, **padding, **record_crc}
 
     def set_dg_service_data(self):
         """
Index: dialin/utils/utils.py
===================================================================
diff -u -ra3be707a0f11b8f01ff32199b60b6162238b6e64 -ra26b886c2bbe75c1292afa150a63d1d9b8026b3b
--- dialin/utils/utils.py	(.../utils.py)	(revision a3be707a0f11b8f01ff32199b60b6162238b6e64)
+++ dialin/utils/utils.py	(.../utils.py)	(revision a26b886c2bbe75c1292afa150a63d1d9b8026b3b)
@@ -6,21 +6,18 @@
 
 
 class Utils:
+    """
 
+    Dialysate Generator (DG) Dialin API sub-class for utilities commands. The commands are used to process
+    the calibration records, service records, system records, and the scheduled runs records. The records are prepared
+    to be sent to firmware to be received from firmware.
+    """
     _RECORD_START_INDEX = 6
     _RECORD_SPECS_BYTES = 12
     _RECORD_SPECS_BYTE_ARRAY = 3
 
-    DEFAULT_MFG_DATE = 0
-    DEFAULT_SERVICE_DATE_VALUE = 0
-    DEFAULT_SERVICE_CRC_VALUE = 0
-    DEFAULT_SYS_PADDING_VALUE = 0
+    _CURRENT_MESSAGE_NUM_INDEX = 0
 
-    CURRENT_MESSAGE_NUM_INDEX = 0
-    TOTAL_MESSAGES_NUM_INDEX = 4
-    PAYLOAD_LENGTH_INDEX = 8
-    PAYLOAD_START_INDEX = 12
-
     _DATA_TYPE_INDEX = 0
     _DATA_VALUE_INDEX = 1
 
@@ -32,17 +29,111 @@
     _PAYLOAD_TOTAL_BYTES_INDEX = 2
 
     def __init__(self):
-        pass
 
-    @staticmethod
-    def process_records_received_from_fw(records_dict, fw_records_bytes):
-        pass
+        # This list contains different data packet lists
+        # i.e. [[message 1, payload], [message 2, payload], ...]
+        self._record_packets_to_send_to_fw = []
 
+    def process_received_record_from_fw(self, dialin_record, fw_raw_records_bytes):
+        """
+        Handles processing the received record from firmware
+
+        @param dialin_record: dictionary that is being updated from firmware
+        @param fw_raw_records_bytes: list of the firmware record from firmware in bytes
+
+        @return: none
+        """
+        raw_payload_temp_start_index = 0
+        # Convert the concatenated raw data into a byte array since the struct library requires byte arrays.
+        fw_raw_records_bytes = bytearray(fw_raw_records_bytes)
+
+        # 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 dialin_record.keys():
+            # All the hardware groups (i.e pressure sensors) are nested dictionaries, except the final CRC. So it is
+            # unpacked exceptionally here. The CRC is an unsigned 16-bit (short).
+            if group == 'crc':
+                # Get the data type ( it must be '<H')
+                data_type = dialin_record[group][self._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, fw_raw_records_bytes[raw_payload_temp_start_index:
+                                                                     raw_payload_temp_start_index + value_bytes])[0]
+                dialin_record[group][self._DATA_VALUE_INDEX] = data
+            elif group == 'padding':
+                # Get the data type
+                data_type = dialin_record[group][self._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(dialin_record[group][self._DATA_VALUE_INDEX])
+                # Add the length of the padding bytes to the payload start address
+                raw_payload_temp_start_index += padding_length * value_bytes
+            # The rest of the groups are hardware which are layered dictionaries
+            else:
+                values = 0
+                # If the value is not a CRC, it is nested dictionary of different hardware groups
+                # Loop through the values of each key to get the list of the hardware in a hardware group (i.e
+                # pressure_sensors have ppi, ppo, ...)
+                for key in dialin_record[group].keys():
+                    # Loop through the keys. Check if the value of the key itself is a dictionary
+                    if isinstance(dialin_record[group][key], dict):
+                        # Check if the values of the key are dictionaries themselves. If yes, loop through them.
+                        for inner_key in dialin_record[group][key]:
+                            values = self._process_fw_record(dialin_record, fw_raw_records_bytes, group, key,
+                                                             raw_payload_temp_start_index, inner_key=inner_key)
+                            dialin_record = values[0]
+                            raw_payload_temp_start_index = values[1]
+                    else:
+                        values = self._process_fw_record(dialin_record, fw_raw_records_bytes, group, key,
+                                                         raw_payload_temp_start_index)
+                        dialin_record = values[0]
+                        raw_payload_temp_start_index = values[1]
+
+    def _process_fw_record(self, dialin_record, fw_raw_records_bytes, group, key, read_start_index, inner_key=None):
+        """
+        Handles processing the received record from firmware
+
+        @param dialin_record: dictionary that is being updated from firmware
+        @param fw_raw_records_bytes: list of the firmware record from firmware in bytes
+        @param group: record group (i.e CRC, padding)
+        @param key: key of the dialin record dictionary
+        @param read_start_index: index to read the next set of byte(s) from fw raw records
+        @param inner_key: the key to an inner dictionary that is the value of the provided key (i.e. pressure: {ppi :
+        [0,1})
+
+        @return: dialin record dictionary that is updated and read start index as a tuple
+        """
+        # 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
+        if inner_key is None:
+            data_type = dialin_record[group][key][self._DATA_TYPE_INDEX]
+        else:
+            data_type = dialin_record[group][key][inner_key][self._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, 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
+
+        if inner_key is None:
+            dialin_record[group][key][self._DATA_VALUE_INDEX] = data
+        else:
+            dialin_record[group][key][inner_key][self._DATA_VALUE_INDEX] = data
+
+        return dialin_record, read_start_index
+
     def prepare_record_to_send_to_fw(self, dialin_record):
+        """
+        Handles preparing the record to be sent to firmware
 
-        # This list contains different data packet lists
-        # i.e. [[message 1, payload], [message 2, payload], ...]
-        record_packets = []
+        @param dialin_record: the dictionary that is processed to be sent down
+
+        @return: record packets in bytes
+        """
         current_payload_length = 0
         current_message_count = 1
         temp_buffer = [0, 0, 0]
@@ -56,10 +147,10 @@
                 data_type = dialin_record[group][self._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._CURRENT_MESSAGE_NUM_INDEX] = struct.pack('<i', current_message_count)
                 temp_buffer[self._PAYLOAD_TOTAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
                 temp_buffer.append(struct.pack(data_type, dialin_record[group][self._DATA_VALUE_INDEX]))
-                record_packets.append(temp_buffer)
+                self._record_packets_to_send_to_fw.append(temp_buffer)
 
             # If the group is padding, and the length of padding is not 0
             elif group == 'padding':
@@ -76,59 +167,48 @@
                         else:
                             temp_buffer[self._PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
                             temp_buffer[self._PAYLOAD_TOTAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-                            record_packets.append(temp_buffer)
+                            self._record_packets_to_send_to_fw.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:
+                processed_values = 0
                 for key in dialin_record[group].keys():
-
-                    data_type = dialin_record[group][key][self._DATA_TYPE_INDEX]
-                    data_type_bytes = self.get_data_type_bytes(data_type)
-                    current_value = dialin_record[group][key][self._DATA_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_TOTAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                    # Loop through the keys. Check if the value of the key itself is a dictionary
+                    if isinstance(dialin_record[group][key], dict):
+                        # If it is a dictionary, loop through the inner keys and process them
+                        for inner_key in dialin_record[group][key]:
+                            processed_values = self._prepare_record_packets_for_fw(dialin_record, group, key,
+                                                                                   temp_buffer, current_payload_length,
+                                                                                   current_message_count,
+                                                                                   inner_dict_key=inner_key)
+                            # Update the local variables
+                            temp_buffer = processed_values[0]
+                            current_message_count = processed_values[1]
+                            current_payload_length = processed_values[2]
                     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_TOTAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-                        # Append the temp buffer list into the main list to be process later
-                        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)]
+                        # The value of the key is not a dictionary itself
+                        processed_values = self._prepare_record_packets_for_fw(dialin_record, group, key, temp_buffer,
+                                                                               current_payload_length,
+                                                                               current_message_count)
+                        # Update the local variables
+                        temp_buffer = processed_values[0]
+                        current_message_count = processed_values[1]
+                        current_payload_length = processed_values[2]
 
         # Creating a byte array variable and add all the data packets
         # to one to calculate the final CRC
         data = b''
-        for svc in record_packets:
+        for svc in self._record_packets_to_send_to_fw:
             # 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 record_packets.index(svc) == len(record_packets) - 1:
+            if self._record_packets_to_send_to_fw.index(svc) == len(self._record_packets_to_send_to_fw) - 1:
                 data += b''.join(svc[self._RECORD_SPECS_BYTE_ARRAY:-1])
             else:
                 # Get all the elements including the last one
@@ -139,20 +219,77 @@
         # Convert the crc into a 2-byte value
         record_crc = struct.pack('<H', crc)
         # Insert the CRC into the last element of the last data packet
-        record_packets[-1][-1] = record_crc
+        self._record_packets_to_send_to_fw[-1][-1] = record_crc
 
         print('CRC: ', hex(crc))  # TODO remove
 
         # 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:
+        for packet in self._record_packets_to_send_to_fw:
 
             # 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 data.
             packet[1] = struct.pack('<i', current_message_count)
 
-        return record_packets
+        return self._record_packets_to_send_to_fw
 
+    def _prepare_record_packets_for_fw(self, dialin_record, group, key, temp_buffer, current_payload_length,
+                                       current_message_count, inner_dict_key=None):
+        """
+        Handles preparing the record packets that are prepared to be sent to firmware
+
+        @param dialin_record: the dictionary that is process to be sent down
+        @param group: dictionary group that is being processed (i.e service_records)
+        @param key: dictionary key of the current group
+        @param temp_buffer: temporary buffer that is holding the values to be converted to bytes
+        @param current_payload_length: current payload length of the temporary buffer (before it gets to maximum allowed)
+        @param current_message_count: current message number of all the payloads
+        @param inner_dict_key: key of a nested dictionary (if it exists)
+
+        @return: temp buffer, current message count, current payload length
+        """
+        # No inner key so no nested dictionary
+        if inner_dict_key is None:
+            data_type = dialin_record[group][key][self._DATA_TYPE_INDEX]
+            data_type_bytes = self.get_data_type_bytes(data_type)
+            current_value = dialin_record[group][key][self._DATA_VALUE_INDEX]
+        else:
+            data_type = dialin_record[group][key][inner_dict_key][self._DATA_TYPE_INDEX]
+            data_type_bytes = self.get_data_type_bytes(data_type)
+            current_value = dialin_record[group][key][inner_dict_key][self._DATA_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_TOTAL_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_TOTAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+            # Append the temp buffer list into the main list to be process later
+            self._record_packets_to_send_to_fw.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)]
+
+        # Return the latest calculated values as tuple
+        return temp_buffer, current_message_count, current_payload_length
+
     def calculate_group_byte_size(self, group):
         """
         Handles calculating the byte size of the values of the provided dictionary.
@@ -196,7 +333,7 @@
     @staticmethod
     def calculate_padding_byte_size(total_byte_size, max_buffer_size):
         """
-        Handles calculating the padding length based on the provided buffer sizes
+        Handles calculating the padding length based on the provided buffer sizes. This is a static method.
 
         @param total_byte_size: total byte size of a record dictionary
         @param max_buffer_size: max buffer size that is allowed to be used in the dictionary
Index: tests/test_dg_calibration.py
===================================================================
diff -u -r43e8345862c72340680c045e53b310aa291513a6 -ra26b886c2bbe75c1292afa150a63d1d9b8026b3b
--- tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision 43e8345862c72340680c045e53b310aa291513a6)
+++ tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision a26b886c2bbe75c1292afa150a63d1d9b8026b3b)
@@ -19,18 +19,20 @@
     #print(cal.DG_CALIBRATION_RECORD)
     #exit(0)
 
-    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
-    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
-    print(cal.DG_CALIBRATION_RECORD)
+    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
+
+    print(cal.dg_calibration_record)
+
     try:
         if status:
             dara = []
@@ -49,7 +51,7 @@
         else:
             cal.set_dg_calibration_data()
 
-        print(cal.DG_CALIBRATION_RECORD)
+        print(cal.dg_calibration_record)
 
     except KeyboardInterrupt:
         f.close()
Index: tests/test_dg_service_record.py
===================================================================
diff -u -ra3be707a0f11b8f01ff32199b60b6162238b6e64 -ra26b886c2bbe75c1292afa150a63d1d9b8026b3b
--- tests/test_dg_service_record.py	(.../test_dg_service_record.py)	(revision a3be707a0f11b8f01ff32199b60b6162238b6e64)
+++ tests/test_dg_service_record.py	(.../test_dg_service_record.py)	(revision a26b886c2bbe75c1292afa150a63d1d9b8026b3b)
@@ -13,7 +13,7 @@
 
     srvc = dg.service_record
 
-    srvc.dg_service_record['service_record']['crc'][1] = 718
+    srvc.dg_service_record['service_record']['crc'][1] = 5522
     print((srvc.dg_service_record))
     #print(len(sys.dg_service_record['system_record']['top_level_pn'][1]))
 
@@ -24,7 +24,7 @@
     #    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()