Index: dialin/dg/calibration.py
===================================================================
diff -u -r6154b064dd181c32b09982c04ca9ddbca41bf509 -r4da359d875e41ceea5ed164a20636256da74e886
--- dialin/dg/calibration.py	(.../calibration.py)	(revision 6154b064dd181c32b09982c04ca9ddbca41bf509)
+++ dialin/dg/calibration.py	(.../calibration.py)	(revision 4da359d875e41ceea5ed164a20636256da74e886)
@@ -1,7 +1,10 @@
 
 import struct
+import datetime
+import time
+import math
 from collections import OrderedDict
-from ..utils.conversions import integer_to_bytearray
+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
@@ -16,6 +19,7 @@
 
     CALIBRATION_RECORD_START_INDEX = 6
     CALIBRATION_RECORD_SPECS_BYTES = 12
+    CALIBRATION_RECORDS_SPECS_BYTE_ARRAY = 3
     DEFAULT_GAIN_VALUE = 1
     DEFAULT_OFFSET_VALUE = 0
     DEFAULT_RATIO_VALUE = 1
@@ -28,6 +32,13 @@
     PAYLOAD_LENGTH_INDEX = 8
     PAYLOAD_START_INDEX = 12
 
+    CALIBRATION_DATA_TYPE_INDEX = 0
+    CALIBRATION_VALUE_INDEX = 1
+
+    TARGET_BYTES_TO_SEND_TO_FW = 150
+
+    EEPROM_MAX_BYTES_TO_WRITE = 16
+
     # DG calibration main record
     DG_CALIBRATION_RECORD = OrderedDict()
 
@@ -58,7 +69,7 @@
 
     def get_dg_calibration_data(self):
         """
-        Handles getting dg calibration data from firmware.
+        Handles getting DG calibration data from firmware.
 
         @return: None
         """
@@ -137,22 +148,22 @@
         # 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 though the keys for the main calibration dictionary
+        # 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][0]
+                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 = 2 if data_type == '<H' else 4
                 # 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
             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
@@ -162,23 +173,26 @@
                     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][0]
+                        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':
+                        elif data_type == '<H':
                             value_bytes = 2
 
                         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
 
-                        # For testing only remove TODO Remove
+                        # 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):
         """
@@ -187,144 +201,315 @@
         @return: None
         """
         # 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.
+        # 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()
         # Build the CRC of the main calibration record
-        cal_record_crc = OrderedDict({'crc': ['<h', self.DEFAULT_CAL_CRC_VALUE]})
+        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
+        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
+
+        padding = OrderedDict({'padding': ['<B', [self.DEFAULT_CAL_CRC_VALUE] * padding_size]})
+
+        print(padding, padding_size)
+
         # Insert the sub dictionaries into the main calibration record
-        self.DG_CALIBRATION_RECORD = {**pressure, **flow, **load_cells, **temperature, **conductivity, **cal_record_crc}
+        self.DG_CALIBRATION_RECORD = {**pressure[0], **flow[0], **load_cells[0], **temperature[0], **conductivity[0],
+                                      **padding, **cal_record_crc}
 
     def _prepare_pressure_sensors_cal_record(self):
         """
         Handles creating the calibration dictionary of the pressure sensors hardware group.
 
-        @return: pressure sensors hardware group dictionary
+        @return: pressure sensors hardware group dictionary and the byte size of this hardware group
         """
         hardware_names = ['ppi', 'ppo', 'prd', 'pdr', 'reserved_1', 'reserved_2', 'reserved_3', 'reserved_4',
                           'reserved_5', 'reserved_6']
+        group_byte_size = 0
         group_name = 'pressure_sensors'
         hardware_group = OrderedDict({group_name: OrderedDict()})
         hardware = OrderedDict()
 
         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]}
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
+            # Calculate the size of the bytes in this hardware group
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
 
         hardware_group[group_name] = hardware
 
-        return hardware_group
+        return hardware_group, group_byte_size
 
     def _prepare_flow_sensors_cal_record(self):
         """
         Handles creating the calibration dictionary of the flow sensors hardware group.
 
-        @return: flow sensors hardware group dictionary
+        @return: flow sensors hardware group dictionary and the byte size of this hardware group
         """
         hardware_names = ['flow_sensor', 'reserved_1', 'reserved_2', 'reserved_3']
+        group_byte_size = 0
         group_name = 'flow_sensors'
         hardware_group = OrderedDict({group_name: OrderedDict()})
         hardware = OrderedDict()
 
         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]}
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
 
+            # Calculate the size of the bytes in this hardware group
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+
         hardware_group[group_name] = hardware
 
-        return hardware_group
+        return hardware_group, group_byte_size
 
     def _prepare_load_cells_record(self):
         """
         Handles creating the calibration dictionary of the load cells hardware group.
 
-        @return: load cells hardware group dictionary
+        @return: load cells hardware group dictionary and the byte size of this hardware group
         """
         hardware_names = ['load_cell_a1', 'load_cell_a2', 'load_cell_b1', 'load_cell_b2']
+        group_byte_size = 0
         group_name = 'load_cells'
         hardware_group = OrderedDict({group_name: OrderedDict()})
         hardware = OrderedDict()
 
         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]}
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
 
+            # Calculate the size of the bytes in this hardware group
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+
         hardware_group[group_name] = hardware
 
-        return hardware_group
+        return hardware_group, group_byte_size
 
     def _prepare_temperature_sensors_record(self):
         """
         Handles creating the calibration dictionary of the temperature sensors hardware group.
 
-        @return: temperature sensors hardware group dictionary
+        @return: temperature sensors hardware group dictionary and the byte size of this hardware group
         """
         hardware_names = ['fpga_board', 'load_cell_a1_b1', 'load_cell_a2_b2', 'thdo_rtd', 'tdi_rtd', 'internal_cond',
                           'onboard_ntc', 'power_supply_1', 'power_supply_2', 'outlet_redundant', 'inlet_dialysate',
                           'inlet_primary_heater', 'outlet_primary_heater', 'cond_sensor_1', 'cond_sensor_2',
                           'reserved_1', 'reserved_2', 'reserved_3', 'reserved_4', 'reserved_5']
+        group_byte_size = 0
         group_name = 'temperature_sensors'
         hardware_group = OrderedDict({group_name: OrderedDict()})
         hardware = OrderedDict()
 
         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]}
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
 
+            # Calculate the size of the bytes in this hardware group
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+
         hardware_group[group_name] = hardware
 
-        return hardware_group
+        return hardware_group, group_byte_size
 
     def _prepare_conductivity_sensors_record(self):
         """
         Handles creating the calibration dictionary of the conductivity sensors hardware group.
 
-        @return: conductivity sensors hardware group dictionary
+        @return: conductivity sensors hardware group dictionary and the byte size of this hardware group
         """
         hardware_names = ['cpi', 'cpo', 'cd1', 'cd2', 'reserved_1', 'reserved_2']
+        group_byte_size = 0
         group_name = 'conductivity_sensors'
         hardware_group = OrderedDict({group_name: OrderedDict()})
         hardware = OrderedDict()
 
         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]}
+                           'cal_time': ['<i', self.DEFAULT_CAL_TIME_VALUE], 'crc': ['<H', self.DEFAULT_CAL_CRC_VALUE]}
 
+            # Calculate the size of the bytes in this hardware group
+            group_byte_size += self._calculate_group_byte_size(hardware[i])
+
         hardware_group[group_name] = hardware
 
-        return hardware_group
+        return hardware_group, group_byte_size
 
-    #TODO update this function
-    def set_dg_calibration_data(self, data):
+    def _calculate_group_byte_size(self, group):
+        """
+        Handles calculating the byte size of the values of the provided dictionary.
 
-        #test = {'sensors': {'ppi': {'gain': ['<f', 12.1], 'offset': ['<f', 2.2], 'cal_time': ['<i', 12345]}}}
+        @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][0]
 
-        gain = struct.pack(data['sensors']['ppi']['gain'][0], data['sensors']['ppi']['gain'][1])
-        offset = struct.pack(data['sensors']['ppi']['offset'][0], data['sensors']['ppi']['offset'][1])
-        cal_time = struct.pack(data['sensors']['ppi']['cal_time'][0], data['sensors']['ppi']['cal_time'][1])
-        payload = gain + offset + cal_time
+            byte_size += self._get_data_type_bytes(data_type)
 
-        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
-                                              message_id=MsgIds.MSG_ID_DG_SET_CALIBRATION_DATA.value,
-                                              payload=payload)
+        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.
+
+        @param data: the data to be converted to bytes in number
+        @return: calculated byte size
+        """
+        number_of_bytes = 0
+        if data == '<i' or data == '<f':
+            number_of_bytes = 4
+        elif data == '<H':
+            number_of_bytes = 2
+        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]
+        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
+
+        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():
+
+            # If the group is the final CRC of the dictionary
+            if group == 'crc':
+                data_type = self.DG_CALIBRATION_RECORD[group][0]
+
+                #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]))
+                cal_record_packets.append(temp_buffer)
+            elif group == 'padding':
+                if len(self.DG_CALIBRATION_RECORD[group][1]) != 0:
+
+                    data_type = self.DG_CALIBRATION_RECORD[group][0]
+
+
+            else:
+                for hardware_group in self.DG_CALIBRATION_RECORD[group].keys():
+                    for hardware in self.DG_CALIBRATION_RECORD[group][hardware_group]:
+
+                        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)
+                            temp_buffer.append(struct.pack(data_type, self.DG_CALIBRATION_RECORD[group][hardware_group]
+                                                                                                [hardware][1]))
+                        else:
+                            temp_buffer[0] = struct.pack('<i', current_message_count)
+                            temp_buffer[2] = 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, 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
+        data = b''
+        for cal in cal_record_packets:
+            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
+                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
+
         self.logger.debug('DG calibration started')
 
-        received_message = self.can_interface.send(message)
+        # 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:
 
-        # 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
+            time.sleep(0.2)
+            # Add the number of total messages to each data packet
+            packet[1] = struct.pack('<i', current_message_count)
+            # 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_DATA.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
Index: dialin/ui/crc.py
===================================================================
diff -u -re5b68dd61c18dd97545d5e527a7f0a8f84061cb6 -r4da359d875e41ceea5ed164a20636256da74e886
--- dialin/ui/crc.py	(.../crc.py)	(revision e5b68dd61c18dd97545d5e527a7f0a8f84061cb6)
+++ dialin/ui/crc.py	(.../crc.py)	(revision 4da359d875e41ceea5ed164a20636256da74e886)
@@ -33,6 +33,41 @@
     130, 179, 224, 209,  70, 119,  36,  21,  59,  10,  89, 104, 255, 206, 157, 172
 )
 
+crc_16_table = (
+    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
+    0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
+    0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
+    0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
+    0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
+    0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
+    0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
+    0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
+    0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
+    0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
+    0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
+    0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
+    0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
+    0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
+    0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
+    0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
+    0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
+    0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
+    0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
+    0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
+    0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
+    0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+    0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
+    0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
+    0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
+    0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
+    0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
+    0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
+    0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
+    0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
+    0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
+    0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
+)
+
 def crc8(vData):
     """
     generates crc8 for the data vData
@@ -60,3 +95,23 @@
     ba = bytearray.fromhex(str)
     x = '{:02X}'.format(crc8(ba), 'x')
     return x
+
+
+def crc_16(data):
+    """
+    generates crc16 for the provided data
+    @param data: byte of data
+    @return: (int) the crc code
+    """
+    crc = 0xFFFF
+    l = len(data)
+    i = 0
+
+    while l > 0:
+        # Make the sure variables are 16-bit integers
+        left = (crc << 8) & 0x0000FFFF
+        right = (crc >> 8) & 0x0000FFFF
+        crc = left ^ crc_16_table[data[i] ^ (right & 0x00FF)]
+        l -= 1
+        i += 1
+    return crc
Index: tests/test_dg_calibration.py
===================================================================
diff -u -r6154b064dd181c32b09982c04ca9ddbca41bf509 -r4da359d875e41ceea5ed164a20636256da74e886
--- tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision 6154b064dd181c32b09982c04ca9ddbca41bf509)
+++ tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision 4da359d875e41ceea5ed164a20636256da74e886)
@@ -1,6 +1,7 @@
 from ctypes import *
 from collections import OrderedDict
 from dialin.dg.dialysate_generator import DG
+from dialin.ui import crc
 from time import sleep
 import struct
 
@@ -10,7 +11,7 @@
 
     if dg.cmd_log_in_to_dg() == 0:
         exit(1)
-
+    sleep(2)
     cal = dg.calibration
 
     """"
@@ -37,11 +38,12 @@
 
     f = open("DG_Calibration.log", "w")
 
-    dara = []
+    print(cal.DG_CALIBRATION_RECORD)
+    #dara = []
+    #cal.get_dg_calibration_data()
 
-    cal.get_dg_calibration_data()
-
     try:
+        """
         while True:
             sleep(0.2)
             #print(cal.current_message, cal.total_messages, cal.cal_data)
@@ -53,17 +55,8 @@
                 if cal.current_message == cal.total_messages:
                     f.close()
                     break
-        #[print(i) for i in dara]
-        #value = struct.unpack('f', bytearray(dara[0][18:(18+4)]))[0]
-        #print(cal.DG_CALIBRATION_RECORD.keys())
+        """
+        cal.set_dg_calibration_data()
 
-        #load_cells = OrderedDict({'group_name': OrderedDict()})
-        #individual_sensor = OrderedDict()
-        #list1 = ['load_1', 'load_2', 'load_3']
-        #for i in list1:
-        #    individual_sensor[i] = {'gain': ['<f', 12.5], 'offset': ['<f', 13.2], 'cal_time': ['<i', 7]}
-        #load_cells['group_name'] = individual_sensor
-        #print(load_cells['group_name']['load_2']['cal_time'])
-
     except KeyboardInterrupt:
         f.close()