Index: dialin/dg/calibration.py
===================================================================
diff -u -r2ffe0dce8601f75d920e64fb2e0eb412726fa864 -r5dabfb699311d0b04353c3db846aba742568bcc1
--- dialin/dg/calibration.py	(.../calibration.py)	(revision 2ffe0dce8601f75d920e64fb2e0eb412726fa864)
+++ dialin/dg/calibration.py	(.../calibration.py)	(revision 5dabfb699311d0b04353c3db846aba742568bcc1)
@@ -147,9 +147,7 @@
 
         @return: None
         """
-        value_bytes = 0
         raw_payload_temp_start_index = 0
-        data = ''
         # 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)
 
@@ -161,14 +159,24 @@
             # 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')
+                # 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 = 2 if data_type == '<H' else 4
+                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
@@ -180,25 +188,15 @@
                         # which the first index is data type
                         data_type = self.DG_CALIBRATION_RECORD[group][hardware_group][hardware][
                                     self.CALIBRATION_DATA_TYPE_INDEX]
-
-                        # The characters are needed for the unpack method the struct class and the integers are needed
-                        # to offset the index of the byte array for the next value to be parsed
-                        if data_type == '<f' or data_type == '<i':
-                            value_bytes = 4
-                        elif data_type == '<H':
-                            value_bytes = 2
-
+                        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
 
-                        # TODO For testing only remove
-                        print(raw_payload_temp_start_index, group, hardware_group, hardware, data)
-                        # TODO Remove the code for testing only
-
     def _prepare_dg_calibration_record(self):
         """
         Handles assembling the sub dictionaries of each hardware group to make the main DG calibration record.
@@ -219,7 +217,6 @@
         # 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] + \
                            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
Index: tests/test_dg_calibration.py
===================================================================
diff -u -r2ffe0dce8601f75d920e64fb2e0eb412726fa864 -r5dabfb699311d0b04353c3db846aba742568bcc1
--- tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision 2ffe0dce8601f75d920e64fb2e0eb412726fa864)
+++ tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision 5dabfb699311d0b04353c3db846aba742568bcc1)
@@ -14,52 +14,34 @@
     sleep(2)
     cal = dg.calibration
 
-    """"
-    pres_sensors = OrderedDict()
-    pres_sensors['ppi'] = {'gain': ['<f', 12.1], 'offset': ['<f', 2.2], 'cal_time': ['<i', 12345]}
-    pres_sensors['ppo'] = {'gain': ['<f', 12.1], 'offset': ['<f', 2.2], 'cal_time': ['<i', 12345]}
-    pres_sensors['prd'] = {'gain': ['<f', 12.1], 'offset': ['<f', 2.2], 'cal_time': ['<i', 12345]}
-    pres_sensors['pdr'] = {'gain': ['<f', 12.1], 'offset': ['<f', 2.2], 'cal_time': ['<i', 12345]}
-
-    flow_sensor = OrderedDict()
-    flow_sensor['fmp'] = {'gain': ['<f', 4.2], 'offset': ['<f', 10.8], 'cal_time': ['<i', 12345]}
-
-    load_cells = OrderedDict()
-    load_cells['a1'] = {'gain': ['<f', 4.2], 'offset': ['<f', 10.8], 'cal_time': ['<i', 12345]}
-
-
-    sensors = OrderedDict(**pres_sensors, **flow_sensor)
-    print(sensors)
-    print(type(sensors))
-    print(type(pres_sensors))
-    """
-
-    #cal.set_dg_calibration_data(pres_sensors)
-
     f = open("DG_Calibration.log", "w")
 
     #print(cal.DG_CALIBRATION_RECORD)
-    #dara = []
-    #cal.get_dg_calibration_data()
 
+    status = True
+
     #cal.DG_CALIBRATION_RECORD['pressure_sensors']['ppi']['gain'][1] = 34.2
     #print(cal.DG_CALIBRATION_RECORD)
 
     try:
-        """
-        while True:
-            sleep(0.2)
-            #print(cal.current_message, cal.total_messages, cal.cal_data)
+        if status:
+            dara = []
+            cal.get_dg_calibration_data()
+            while True:
+                sleep(0.2)
+                #print(cal.current_message, cal.total_messages, cal.cal_data)
 
-            if cal.cal_data != 0:
-                f.write(str(cal.cal_data) + '\r')
-                dara.append(cal.cal_data)
+                if cal.cal_data != 0:
+                    f.write(str(cal.cal_data) + '\r')
+                    dara.append(cal.cal_data)
 
-                if cal.current_message == cal.total_messages:
-                    f.close()
-                    break
-        """
-        cal.set_dg_calibration_data()
+                    if cal.current_message == cal.total_messages:
+                        f.close()
+                        break
+        else:
+            cal.set_dg_calibration_data()
 
+        print(cal.DG_CALIBRATION_RECORD)
+
     except KeyboardInterrupt:
         f.close()