Index: dialin/dg/calibration.py
===================================================================
diff -u -r4da359d875e41ceea5ed164a20636256da74e886 -r2ffe0dce8601f75d920e64fb2e0eb412726fa864
--- dialin/dg/calibration.py	(.../calibration.py)	(revision 4da359d875e41ceea5ed164a20636256da74e886)
+++ dialin/dg/calibration.py	(.../calibration.py)	(revision 2ffe0dce8601f75d920e64fb2e0eb412726fa864)
@@ -36,9 +36,14 @@
     CALIBRATION_VALUE_INDEX = 1
 
     TARGET_BYTES_TO_SEND_TO_FW = 150
+    MIN_PAYLOAD_BYTES_SPACE = 4
 
     EEPROM_MAX_BYTES_TO_WRITE = 16
 
+    PAYLOAD_CURRENT_MSG_INDEX = 0
+    PAYLOAD_TOTAL_MSG_INDEX = 1
+    PAYLOAD_CAL_BYTES_INDEX = 2
+
     # DG calibration main record
     DG_CALIBRATION_RECORD = OrderedDict()
 
@@ -212,22 +217,21 @@
         cal_record_crc = OrderedDict({'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]})
 
         # The second element of the hardware groups are the byte sizes, add them to calculate the overall byte size.
-        # The CRC for the entire dictionary is considered 2 bytes but if there is not type defined it is considered as
-        # 4 bytes.
         groups_byte_size = pressure[1] + flow[1] + load_cells[1] + temperature[1] + conductivity[1] + \
-                           self._get_data_type_bytes(cal_record_crc['crc'][0])
-        #groups_byte_size = 624
+                           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
-
+        # 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]})
 
-        print(padding, padding_size)
-
-        # Insert the sub dictionaries into the main calibration record
+        # Insert the sub dictionaries into the main calibration record. The dictionaries are the element 0.
         self.DG_CALIBRATION_RECORD = {**pressure[0], **flow[0], **load_cells[0], **temperature[0], **conductivity[0],
                                       **padding, **cal_record_crc}
 
@@ -363,8 +367,7 @@
         """
         byte_size = 0
         for key in group.keys():
-            data_type = group[key][0]
-
+            data_type = group[key][self.CALIBRATION_DATA_TYPE_INDEX]
             byte_size += self._get_data_type_bytes(data_type)
 
         return byte_size
@@ -373,15 +376,21 @@
     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
 
@@ -412,92 +421,119 @@
         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]
-        data_type_bytes = 0
 
         # 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][0]
+                data_type = self.DG_CALIBRATION_RECORD[group][self.CALIBRATION_DATA_TYPE_INDEX]
 
-                #current_payload_length += self._get_data_type_bytes(data_type)
-                if data_type == '<H':
-                    current_payload_length += 2
-                elif data_type == '<i':
-                    current_payload_length += 4
-
-                temp_buffer[2] = struct.pack('<i', current_payload_length)
-                temp_buffer.append(struct.pack(data_type, self.DG_CALIBRATION_RECORD[group][1]))
+                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][1]) != 0:
+                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)
 
-                    data_type = self.DG_CALIBRATION_RECORD[group][0]
-
-
+                            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:
 
-                        data_type = self.DG_CALIBRATION_RECORD[group][hardware_group][hardware][0]
-
-                        if data_type == '<f' or data_type == '<i':
-                            data_type_bytes = 4
-                        elif data_type == '<H':
-                            data_type_bytes = 2
-
-                        if self.TARGET_BYTES_TO_SEND_TO_FW - current_payload_length > 4:
-
                             current_payload_length += data_type_bytes
-                            temp_buffer[1] = struct.pack('<i', 0)
+                            # 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][1]))
+                                                                            [hardware][self.CALIBRATION_VALUE_INDEX]))
                         else:
-                            temp_buffer[0] = struct.pack('<i', current_message_count)
-                            temp_buffer[2] = struct.pack('<i', current_payload_length)
+                            # 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][1])]
-
-        # Creating a byte array variable and add all the data packets to one to calculate the final CRC
+                                                                             [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])
-                #print(cal[self.CALIBRATION_RECORDS_SPECS_BYTE_ARRAY:-1])
-                #print(cal[self.CALIBRATION_RECORDS_SPECS_BYTE_ARRAY:])
             else:
-                # The CRC is only for calibration data and not the specs, so the specs are
-                # removed from the byte array. The actual data start from the 3rd item
+                # 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)
-
-        print('CRC: ', hex(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:
-
+            # Sleep to let the firmware receive and process the data
             time.sleep(0.2)
-            # Add the number of total messages to each data packet
+            # Add the number of total messages to each data packet. This was delayed
+            # until now since it was not known how many message will it take to pack all the
+            # calibration data.
             packet[1] = struct.pack('<i', current_message_count)
             # Convert the list packet to a bytearray
             payload = b''.join(packet)
Index: tests/test_dg_calibration.py
===================================================================
diff -u -r4da359d875e41ceea5ed164a20636256da74e886 -r2ffe0dce8601f75d920e64fb2e0eb412726fa864
--- tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision 4da359d875e41ceea5ed164a20636256da74e886)
+++ tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision 2ffe0dce8601f75d920e64fb2e0eb412726fa864)
@@ -38,10 +38,13 @@
 
     f = open("DG_Calibration.log", "w")
 
-    print(cal.DG_CALIBRATION_RECORD)
+    #print(cal.DG_CALIBRATION_RECORD)
     #dara = []
     #cal.get_dg_calibration_data()
 
+    #cal.DG_CALIBRATION_RECORD['pressure_sensors']['ppi']['gain'][1] = 34.2
+    #print(cal.DG_CALIBRATION_RECORD)
+
     try:
         """
         while True: