Index: dialin/dg/calibration_record.py
===================================================================
diff -u -ra2cdbc7e007c6bd73e12344b4c89356a20b53f4f -rab49c2b2e6bd03745f5a910780791d4b18000fd1
--- dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision a2cdbc7e007c6bd73e12344b4c89356a20b53f4f)
+++ dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision ab49c2b2e6bd03745f5a910780791d4b18000fd1)
@@ -105,7 +105,7 @@
             self.logger.debug("Timeout!!!!")
             return False
 
-    @_publish(["current_message", "total_messages", "length", "cal_data"])
+    @_publish(["current_message", "total_messages", "length", "sys_data"])
     def _handler_dg_calibration_sync(self, message):
         """
         Handles published DG calibration_record record messages. DG calibration_record records are captured for
Index: dialin/hd/calibration_record.py
===================================================================
diff -u -ra2cdbc7e007c6bd73e12344b4c89356a20b53f4f -rab49c2b2e6bd03745f5a910780791d4b18000fd1
--- dialin/hd/calibration_record.py	(.../calibration_record.py)	(revision a2cdbc7e007c6bd73e12344b4c89356a20b53f4f)
+++ dialin/hd/calibration_record.py	(.../calibration_record.py)	(revision ab49c2b2e6bd03745f5a910780791d4b18000fd1)
@@ -90,7 +90,7 @@
             self.logger.debug("Timeout!!!!")
             return False
 
-    @_publish(["current_message", "total_messages", "length", "cal_data"])
+    @_publish(["current_message", "total_messages", "length", "sys_data"])
     def _handler_hd_calibration_sync(self, message):
         """
         Handles published HD calibration_record record messages. DG calibration_record records are captured for
@@ -137,7 +137,7 @@
         functions = [self._prepare_pumps_record(), self._prepare_valves_record(),
                      self._prepare_occlusion_sensors_record(), self._prepare_flow_sensors_record(),
                      self._prepare_pressure_sensors_record(), self._prepare_temperature_sensors_record(),
-                     self._prepare_heparin_force_record()]
+                     self._prepare_heparin_force_sensor_record(), self._prepare_accelerometer_sensor_record()]
 
         for function in functions:
             # Update the groups bytes size so far to be use to padding later
@@ -303,7 +303,7 @@
 
         return hardware_group, group_byte_size
 
-    def _prepare_heparin_force_record(self):
+    def _prepare_heparin_force_sensor_record(self):
         """
         Handles creating the calibration_record dictionary of the heparin force sensor hardware group.
 
@@ -328,6 +328,30 @@
 
         return hardware_group, group_byte_size
 
+    def _prepare_accelerometer_sensor_record(self):
+        """
+        Handles creating the calibration_record dictionary of the accelerometer sensor hardware group.
+
+        @return: accelerometer sensor hardware group dictionary and the byte size of this hardware group
+        """
+        hardware_names = ['accelerometer']
+
+        group_byte_size = 0
+        group_name = 'accelerometer_sensor'
+        hardware_group = OrderedDict({group_name: OrderedDict()})
+        hardware = OrderedDict()
+
+        for i in hardware_names:
+            hardware[i] = {'x_offset': ['<f', self._DEFAULT_OFFSET_VALUE],
+                           'y_offset': ['<f', self._DEFAULT_OFFSET_VALUE],
+                           'z_offset': ['<f', self._DEFAULT_OFFSET_VALUE],
+                           'cal_time': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}
+            # Calculate the size of the bytes in this hardware group
+            group_byte_size += self.utilities.calculate_group_byte_size(hardware[i])
+        hardware_group[group_name] = hardware
+
+        return hardware_group, group_byte_size
+
     def set_hd_calibration_record(self):
         """
         Handles updating the HD calibration_record record with the newest calibration_record data of a hardware and
@@ -337,7 +361,7 @@
         """
         record_packets = self.utilities.prepare_record_to_send_to_fw(self.hd_calibration_record)
 
-        self.logger.debug('HD calibration_record started')
+        self.logger.debug('Setting HD calibration record')
 
         # Update all the data packets with the last message count since is the number of messages that firmware
         # should receive
@@ -347,7 +371,6 @@
 
             # Convert the list packet to a bytearray
             payload = b''.join(packet)
-            #print(len(payload), payload) # TODO remove
 
             message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                                   message_id=MsgIds.MSG_ID_HD_SET_CALIBRATION_RECORD.value,
Index: dialin/hd/system_record.py
===================================================================
diff -u -ra2cdbc7e007c6bd73e12344b4c89356a20b53f4f -rab49c2b2e6bd03745f5a910780791d4b18000fd1
--- dialin/hd/system_record.py	(.../system_record.py)	(revision a2cdbc7e007c6bd73e12344b4c89356a20b53f4f)
+++ dialin/hd/system_record.py	(.../system_record.py)	(revision ab49c2b2e6bd03745f5a910780791d4b18000fd1)
@@ -5,25 +5,30 @@
 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
+from ..utils.base import _AbstractSubSystem, _publish, DialinEnum
 from ..utils.utils import Utils
 from logging import Logger
+from enum import unique
 
 
+
+@unique
+class MFGLocation(DialinEnum):
+    MFG_LOCATION_FACTORY = 0
+
+
 class HDSystem(_AbstractSubSystem):
     """
 
-    Hemodialysis Device (HD) Dialin API sub-class for calibration_record commands.
+    Hemodialysis Device (HD) Dialin API sub-class for system record commands.
     """
 
     _RECORD_START_INDEX = 6
     _RECORD_SPECS_BYTES = 12
-    _DEFAULT_GAIN_VALUE = 1
-    _DEFAULT_OFFSET_VALUE = 0
-    _DEFAULT_RATIO_VALUE = 1
-    _DEFAULT_VOLUME_VALUE = 0
-    _DEFAULT_CONCENTRATE_VALUE = 1
-    _DEFAULT_CALIBRATION_VALUE = 1
+    _DEFAULT_CHAR_VALUE = 'X'
+    _DEFAULT_MFG_LOCATION = MFGLocation.MFG_LOCATION_FACTORY.value
+    _MAX_PN_BYTES = 10
+    _MAX_SN_BYTES = 15
     _DEFAULT_TIME_VALUE = 0
     _DEFAULT_CRC_VALUE = 0
 
@@ -37,3 +42,170 @@
         """
 
         super().__init__()
+
+        self.can_interface = can_interface
+        self.logger = logger
+        self.current_message = 0
+        self.total_messages = 0
+        self.length = 0
+        self.sys_data = 0
+        self.raw_system_record = []
+        self.utilities = Utils()
+        # System main record
+        self.hd_system_record = OrderedDict()
+
+        if self.can_interface is not None:
+            channel_id = DenaliChannels.hd_to_dialin_ch_id
+            msg_id = MsgIds.MSG_ID_HD_SEND_SYSTEM_RECORD.value
+            self.can_interface.register_receiving_publication_function(channel_id, msg_id, self._handler_hd_system_sync)
+        # Prepare the calibration_record record by putting sub-dictionaries together
+        self._prepare_hd_system_record()
+
+    def get_hd_system_record(self):
+        """
+        Handles getting HD calibration_record data from firmware.
+
+        @return: None
+        """
+        # Clear the list for the next call
+        self.raw_system_record.clear()
+        # Run the firmware commands to get the record
+        self._request_hd_fw_system_record()
+
+    def _request_hd_fw_system_record(self):
+        """
+        Handles getting HD system record from firmware.
+
+        @return: None
+        """
+        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
+                                              message_id=MsgIds.MSG_ID_HD_GET_SYSTEM_RECORD.value)
+
+        self.logger.debug('Getting HD system record')
+
+        received_message = self.can_interface.send(message)
+
+        # If there is content...
+        if received_message is not None:
+            # response payload is OK or not OK
+            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
+        else:
+            self.logger.debug("Timeout!!!!")
+            return False
+
+    @_publish(["current_message", "total_messages", "length", "sys_data"])
+    def _handler_hd_system_sync(self, message):
+        """
+        Handles published HD system record messages. HD system records are captured for
+        processing and updating the HD system record.
+
+        @param message:  published HD system record data message
+
+        @return: None
+        """
+        curr = struct.unpack('i', bytearray(
+            message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0]
+        total = struct.unpack('i', bytearray(
+            message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0]
+        length = struct.unpack('i', bytearray(
+            message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3]))[0]
+
+        self.current_message = curr
+        self.total_messages = total
+        self.length = length
+        # The end of calibration_record record payload is from the start index + 12 bytes for the current message +total
+        # messages + the length of calibration_record. The rest is the CAN messaging CRC that is not needed to be kept
+        end_of_data_index = self._RECORD_START_INDEX + self._RECORD_SPECS_BYTES + self.length
+
+        # Get the data only and not specs of it (i.e current message number)
+        self.sys_data = message['message'][self._RECORD_START_INDEX:end_of_data_index]
+
+        # Continue getting calibration_record records until the all the calibration_record messages are received.
+        # Concatenate the calibration_record records to each other
+        if self.current_message <= self.total_messages:
+            self.raw_system_record += (message['message'][self._RECORD_START_INDEX +
+                                                          self._RECORD_SPECS_BYTES:end_of_data_index])
+            if self.current_message == self.total_messages:
+                # If all the messages have been received, call another function to process the raw data
+                self.utilities.process_received_record_from_fw(self.hd_system_record, self.raw_system_record)
+
+    def _prepare_hd_system_record(self):
+        """
+        Handles assembling the sub dictionaries of each group to make the main HD system record.
+
+        @return: None
+        """
+        groups_byte_size = 0
+        # create a list of the functions of the sub dictionaries
+        functions = [self._prepare_system_record()]
+
+        for function in functions:
+            # Update the groups bytes size so far to be use to padding later
+            groups_byte_size += function[1]
+            # Update the calibration record
+            self.hd_system_record.update(function[0])
+
+        # Build the CRC of the main calibration_record record
+        record_crc = OrderedDict({'crc': ['<H', self._DEFAULT_CRC_VALUE]})
+
+        # Get the groups byte size
+        groups_byte_size += self.utilities.calculate_group_byte_size(record_crc)
+
+        # Get the padding size to create a dictionary from it
+        padding_size = self.utilities.calculate_padding_byte_size(groups_byte_size, self._EEPROM_MAX_BYTES_TO_WRITE)
+
+        # Create the padding dictionary as list of unsigned char. All the elements are 0.
+        padding = OrderedDict({'padding': ['<B', [self._DEFAULT_CRC_VALUE] * padding_size]})
+
+        # Update the dictionary with the padding and record crc dictionaries
+        self.hd_system_record.update(padding)
+        self.hd_system_record.update(record_crc)
+
+    def _prepare_system_record(self):
+        """
+        Handles creating the system record dictionary.
+
+        @return: system record dictionary and the byte size of this group
+        """
+        groups_byte_size = 0
+        system_records = OrderedDict({'system_record':
+                             {'top_level_pn': ['<c', self._DEFAULT_CHAR_VALUE * self._MAX_PN_BYTES, self._MAX_PN_BYTES],
+                              'top_level_sn': ['<c', self._DEFAULT_CHAR_VALUE * self._MAX_SN_BYTES, self._MAX_SN_BYTES],
+                              'mfg_location': ['<B', self._DEFAULT_MFG_LOCATION],
+                              'mfg_date': ['<i', self._DEFAULT_TIME_VALUE], 'crc': ['<H', self._DEFAULT_CRC_VALUE]}})
+
+        for record in system_records.keys():
+            groups_byte_size += self.utilities.calculate_group_byte_size(system_records[record])
+
+        return system_records, groups_byte_size
+
+    def set_hd_system_record(self):
+        """
+        Handles updating the HD system and sends it to FW.
+
+        @return: none
+        """
+        record_packets = self.utilities.prepare_record_to_send_to_fw(self.hd_system_record)
+
+        self.logger.debug('Setting HD system record')
+
+        # Update all the data packets with the last message count since is the number of messages that firmware
+        # should receive
+        for packet in record_packets:
+            # Sleep to let the firmware receive and process the data
+            time.sleep(self._PAYLOAD_TRANSFER_DELAY)
+
+            # Convert the list packet to a bytearray
+            payload = b''.join(packet)
+            # print(len(payload), payload) # TODO remove
+
+            message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
+                                                  message_id=MsgIds.MSG_ID_HD_SET_SYSTEM_RECORD.value,
+                                                  payload=payload)
+
+            received_message = self.can_interface.send(message)
+
+            # If there is no content...
+            if received_message is None:
+                self.logger.debug("Timeout!!!!")
+                return False
\ No newline at end of file
Index: dialin/utils/utils.py
===================================================================
diff -u -ra2cdbc7e007c6bd73e12344b4c89356a20b53f4f -rab49c2b2e6bd03745f5a910780791d4b18000fd1
--- dialin/utils/utils.py	(.../utils.py)	(revision a2cdbc7e007c6bd73e12344b4c89356a20b53f4f)
+++ dialin/utils/utils.py	(.../utils.py)	(revision ab49c2b2e6bd03745f5a910780791d4b18000fd1)
@@ -1,6 +1,6 @@
 
 import struct
-import time
+import datetime
 import math
 from ..ui.crc import crc_16
 
@@ -9,8 +9,8 @@
     """
 
     Dialysate Generator (DG) Dialin API sub-class for utilities commands. The commands are used to process
-    the calibration_record records, service records, system records, and the scheduled runs records. The records are prepared
-    to be sent to firmware to be received from firmware.
+    the calibration_record 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
@@ -20,6 +20,8 @@
 
     _DATA_TYPE_INDEX = 0
     _DATA_VALUE_INDEX = 1
+    _CHAR_LENGTH_INDEX = 2
+    _DICT_VALUE_LIST_LEN = 2
 
     _TARGET_BYTES_TO_SEND_TO_FW = 150
     _MIN_PAYLOAD_BYTES_SPACE = 4
@@ -34,6 +36,19 @@
         # i.e. [[message 1, payload], [message 2, payload], ...]
         self._record_packets_to_send_to_fw = []
 
+        # Buffer that is used to keep the groups data except the crc to convert them to bytes and calculate the crc
+        # of the group.
+        self._temp_groups_data_to_calculate_crc = []
+
+    @staticmethod
+    def get_current_time_in_epoch():
+        """
+        Returns the current date and time in epoch in integer format. This is a static method.
+
+        @return: data and time in epoch in integer format
+        """
+        return int(datetime.datetime.now().timestamp())
+
     def process_received_record_from_fw(self, dialin_record, fw_raw_records_bytes):
         """
         Handles processing the received record from firmware
@@ -62,7 +77,8 @@
                 # 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
+                # Convert the crc to hex
+                dialin_record[group][self._DATA_VALUE_INDEX] = hex(data)
             elif group == 'padding':
                 # Get the data type
                 data_type = dialin_record[group][self._DATA_TYPE_INDEX]
@@ -74,7 +90,6 @@
                 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, ...)
@@ -109,16 +124,32 @@
         """
         # 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 = ''
         if inner_key is None:
             data_type = dialin_record[group][key][self._DATA_TYPE_INDEX]
+            current_value = dialin_record[group][key][self._DATA_VALUE_INDEX]
         else:
             data_type = dialin_record[group][key][inner_key][self._DATA_TYPE_INDEX]
+            current_value = dialin_record[group][key][inner_key][self._DATA_VALUE_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 data_type == '<c':
+            for ch in current_value:
+                # Unpack the values to be written to the dictionary
+                raw = struct.unpack(data_type, fw_raw_records_bytes[read_start_index: read_start_index +
+                                                                                      value_bytes])[0]
+                data += raw.decode("utf-8")
+                read_start_index += value_bytes
+        else:
+            # 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 the key or inner key is crc, convert the value to hex
+            if key == 'crc' or inner_key == 'crc':
+                data = hex(data)
+
         if inner_key is None:
             dialin_record[group][key][self._DATA_VALUE_INDEX] = data
         else:
@@ -175,7 +206,6 @@
                                            struct.pack('<i', current_payload_length),
                                            struct.pack(data_type, pad)]
             else:
-                processed_values = 0
                 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):
@@ -220,9 +250,9 @@
         record_crc = struct.pack('<H', crc)
         # Insert the CRC into the last element of the last data packet
         self._record_packets_to_send_to_fw[-1][-1] = record_crc
+        # Update the record's crc in hex format
+        dialin_record['crc'][self._DATA_VALUE_INDEX] = hex(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 self._record_packets_to_send_to_fw:
@@ -253,11 +283,48 @@
             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]
+            # This is used only for the data types of <c which is a character. If the data type is a character,
+            # it should come with a length as the third element of the list. If the third element does not exist,
+            # assume the len is 1. This value is only used when the data type is a <c.
+            char_len = 1 if len(dialin_record[group][key]) <= self._DICT_VALUE_LIST_LEN else \
+                dialin_record[group][key][self._CHAR_LENGTH_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]
+            # This is used only for the data types of <c which is a character. If the data type is a character,
+            # it should come with a length as the third element of the list. If the third element does not exist,
+            # assume the len is 1. This value is only used when the data type is a <c.
+            char_len = 1 if len(dialin_record[group][key][inner_dict_key]) <= self._DICT_VALUE_LIST_LEN else \
+                dialin_record[group][key][inner_dict_key][self._CHAR_LENGTH_INDEX]
 
+        # If the data type is a <c which is a character, multiply the data type bytes
+        # to the character length
+        if data_type == '<c':
+            data_type_bytes *= char_len
+
+        # If the key or the inner key is crc, it means the entire part of the
+        # dictionary until the CRC is collected.
+        if key == 'crc' or inner_dict_key == 'crc':
+            # Convert the data in the temp buffer to byte and calculate its crc.
+            data = b''.join(self._temp_groups_data_to_calculate_crc)
+            current_value = crc_16(data)
+            # Clear the temp buffer for the next round of data
+            self._temp_groups_data_to_calculate_crc.clear()
+            # Check what layer of keys we are in and update the record dictionary with the CRC
+            if inner_dict_key is None:
+                dialin_record[group][key][self._DATA_VALUE_INDEX] = hex(current_value)
+            else:
+                dialin_record[group][key][inner_dict_key][self._DATA_VALUE_INDEX] = hex(current_value)
+        else:
+            # if the data type is <c, convert each character to ascii and append it into the temp list
+            if data_type == '<c':
+                for ch in current_value:
+                    self._temp_groups_data_to_calculate_crc.append(struct.pack(data_type, ch.encode('ascii')))
+            else:
+                # Append the latest data into the temp buffer
+                self._temp_groups_data_to_calculate_crc.append(struct.pack(data_type, current_value))
+
         # 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:
@@ -266,7 +333,13 @@
             # 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))
+            # If the data type is a <c, loop through the current value
+            # convert each character to its equivalent ascii number and pack it.
+            if data_type == '<c':
+                for ch in current_value:
+                    temp_buffer.append(struct.pack(data_type, ch.encode('ascii')))
+            else:
+                temp_buffer.append(struct.pack(data_type, current_value))
 
             temp_buffer[self._PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
             temp_buffer[self._PAYLOAD_TOTAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
@@ -284,8 +357,14 @@
             # 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)]
+                           struct.pack('<i', current_payload_length)]
+            # If the data type is a <c, loop through the current value
+            # convert each character to its equivalent ascii number and pack it
+            if data_type == '<c':
+                for ch in current_value:
+                    temp_buffer.append(struct.pack(data_type, ch.encode('ascii')))
+            else:
+                temp_buffer.append(struct.pack(data_type, current_value))
 
         # Return the latest calculated values as tuple
         return temp_buffer, current_message_count, current_payload_length
@@ -302,8 +381,16 @@
         for key in group.keys():
             data_type = group[key][self._DATA_TYPE_INDEX]
             current_byte_size = self.get_data_type_bytes(data_type)
-            byte_size += current_byte_size
 
+            # If data type is a '<c' which is a char, the length must be provided
+            # to know how many characters (bytes) should be considered.
+            # The characters length should be provided as the third element of the list so check if the length of
+            # the list is greater than 2. If yes, use the length value, otherwise ignore the length of characters.
+            if data_type == '<c' and len(group[key]) > self._DICT_VALUE_LIST_LEN:
+                byte_size += current_byte_size * group[key][self._CHAR_LENGTH_INDEX]
+            else:
+                byte_size += current_byte_size
+
         return byte_size
 
     @staticmethod
Index: tests/test_dg_calibration.py
===================================================================
diff -u -ra2cdbc7e007c6bd73e12344b4c89356a20b53f4f -rab49c2b2e6bd03745f5a910780791d4b18000fd1
--- tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision a2cdbc7e007c6bd73e12344b4c89356a20b53f4f)
+++ tests/test_dg_calibration.py	(.../test_dg_calibration.py)	(revision ab49c2b2e6bd03745f5a910780791d4b18000fd1)
@@ -21,37 +21,37 @@
 
     status = False
 
-    cal.hd_calibration_record['pumps']['concentrate_1']['step_speed_2_flow_ratio'][1] = 34.2
-    cal.hd_calibration_record['pumps']['drain']['cal_time'][1] = 96321
-    cal.hd_calibration_record['pumps']['ro']['gain_3_ratio'][1] = 45.69
-    cal.hd_calibration_record['volumes']['drain_line']['volume'][1] = 125.8
-    cal.hd_calibration_record['volumes']['drain_line']['crc'][1] = 78
-    cal.hd_calibration_record['volumes']['pre_ro_purge']['volume'][1] = 125.8
-    cal.hd_calibration_record['volumes']['reservoir_1']['max_residual_fluid'][1] = 85.36
-    cal.hd_calibration_record['bicarb_concentrates']['bicarb_conc_3']['reserved_space'][1] = 85.36
-    cal.hd_calibration_record['fans']['fan_2']['reserved_space_2'][1] = 456.25
+    cal.hd_system_record['pumps']['concentrate_1']['step_speed_2_flow_ratio'][1] = 34.2
+    cal.hd_system_record['pumps']['drain']['cal_time'][1] = 96321
+    cal.hd_system_record['pumps']['ro']['gain_3_ratio'][1] = 45.69
+    cal.hd_system_record['volumes']['drain_line']['volume'][1] = 125.8
+    cal.hd_system_record['volumes']['drain_line']['crc'][1] = 78
+    cal.hd_system_record['volumes']['pre_ro_purge']['volume'][1] = 125.8
+    cal.hd_system_record['volumes']['reservoir_1']['max_residual_fluid'][1] = 85.36
+    cal.hd_system_record['bicarb_concentrates']['bicarb_conc_3']['reserved_space'][1] = 85.36
+    cal.hd_system_record['fans']['fan_2']['reserved_space_2'][1] = 456.25
 
-    print(cal.hd_calibration_record)
+    print(cal.hd_system_record)
 
     try:
         if status:
             dara = []
-            cal.get_hd_calibration_record()
+            cal.get_hd_system_record()
             while True:
                 sleep(0.2)
-                #print(cal.current_message, cal.total_messages, cal.cal_data)
+                #print(cal.current_message, cal.total_messages, cal.sys_data)
 
-                if cal.cal_data != 0:
-                    f.write(str(cal.cal_data) + '\r')
-                    dara.append(cal.cal_data)
+                if cal.sys_data != 0:
+                    f.write(str(cal.sys_data) + '\r')
+                    dara.append(cal.sys_data)
 
                     if cal.current_message == cal.total_messages:
                         f.close()
                         break
         else:
-            cal.set_hd_calibration_record()
+            cal.set_hd_system_record()
 
-        print(cal.hd_calibration_record)
+        print(cal.hd_system_record)
 
     except KeyboardInterrupt:
         f.close()
Index: tests/test_hd_records.py
===================================================================
diff -u -ra2cdbc7e007c6bd73e12344b4c89356a20b53f4f -rab49c2b2e6bd03745f5a910780791d4b18000fd1
--- tests/test_hd_records.py	(.../test_hd_records.py)	(revision a2cdbc7e007c6bd73e12344b4c89356a20b53f4f)
+++ tests/test_hd_records.py	(.../test_hd_records.py)	(revision ab49c2b2e6bd03745f5a910780791d4b18000fd1)
@@ -1,6 +1,8 @@
 import sys
+import struct
 sys.path.append("..")
 from dialin.hd.hemodialysis_device import HD
+from dialin.utils.utils import Utils
 
 from time import sleep
 
@@ -13,36 +15,45 @@
     sleep(2)
 
     cal = hd.calibration_record
+    utilities = Utils()
 
-    print(cal.hd_calibration_record)
+    sys = hd.system_record
 
-    #cal.hd_calibration_record['pumps']['bp']['pwm_to_speed'][1] = 17.0
-
     #print(cal.hd_calibration_record)
 
-    status = False
+    cal.hd_calibration_record['accelerometer_sensor']['accelerometer']['x_offset'][1] = 952.12
+    cal.hd_calibration_record['accelerometer_sensor']['accelerometer']['y_offset'][1] = 45.2
+    cal.hd_calibration_record['accelerometer_sensor']['accelerometer']['z_offset'][1] = 712.58
+    cal.hd_calibration_record['accelerometer_sensor']['accelerometer']['cal_time'][1] = utilities.get_current_time_in_epoch()
+    print(sys.hd_system_record)
+
+    #sys.hd_system_record['system_record']['top_level_pn'][1] = 'abcd-12345'
+    #sys.hd_system_record['system_record']['mfg_date'][1] = utilities.get_current_time_in_epoch()
+
+    status = True
     try:
         if status:
             dara = []
-            cal.get_hd_calibration_record()
+            #cal.get_hd_calibration_record()
+            sys.get_hd_system_record()
             while True:
                 sleep(0.2)
-                #print(cal.current_message, cal.total_messages, cal.cal_data)
+                #print(cal.current_message, cal.total_messages, cal.sys_data)
 
-                if cal.cal_data != 0:
-                    #f.write(str(cal.cal_data) + '\r')
-                    dara.append(cal.cal_data)
+                if sys.sys_data != 0:
+                    #f.write(str(cal.sys_data) + '\r')
+                    #dara.append(cal.sys_data)
 
-                    if cal.current_message == cal.total_messages:
+                    if sys.current_message == sys.total_messages:
                         #f.close()
                         break
         else:
-            cal.set_hd_calibration_record()
+            #cal.set_hd_calibration_record()
+            sys.set_hd_system_record()
 
-        print(cal.hd_calibration_record)
+        #print(cal.hd_calibration_record)
+        print(sys.hd_system_record)
 
     except KeyboardInterrupt:
         #f.close()
         pass
-
-    #cal.set_hd_calibration_record()
\ No newline at end of file