Index: dialin/dg/calibration_record.py
===================================================================
diff -u -rf7927c4086e16a080e6ba1552e10f6d776c84e17 -r89f9210ef5bf37a6812c4dc06aaa636dd47b9d72
--- dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision f7927c4086e16a080e6ba1552e10f6d776c84e17)
+++ dialin/dg/calibration_record.py	(.../calibration_record.py)	(revision 89f9210ef5bf37a6812c4dc06aaa636dd47b9d72)
@@ -61,16 +61,28 @@
             self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                        self._handler_dg_calibration_sync)
 
+    def cmd_reset_dg_calibration_record(self) -> bool:
+        """
+        Handles resetting DG calibration record.
+
+        @return: True if successful, False otherwise
+        """
+        self._prepare_dg_calibration_record()
+        self.dg_calibration_record = self._utilities.reset_fw_record(self.dg_calibration_record)
+        status = self.cmd_set_dg_calibration_record(self.dg_calibration_record)
+
+        return status
+
     def cmd_request_dg_calibration_record(self) -> bool:
         """
         Handles getting DG calibration_record record from firmware.
 
         @return: True if successful, False otherwise
         """
-
         self.logger.debug("Requesting a dg calibration record...")
 
         if not self._is_getting_cal_in_progress:
+
             self._is_getting_cal_in_progress = True
             self._raw_cal_record.clear()
 
@@ -123,14 +135,11 @@
                                                         self._RECORD_SPECS_BYTES:end_of_data_index])
 
             if self.current_message == self.total_messages:
-                # Done with getting all the calibration data.
+                # Check if the requested read was just for comparing the results before writing to firmware back
                 self._is_getting_cal_in_progress = False
                 # If all the messages have been received, call another function to process the raw data
                 self._utilities.process_received_record_from_fw(self.dg_calibration_record, self._raw_cal_record)
                 self._handler_received_complete_dg_calibration_record()
-                # TODO remove
-                print(self.dg_calibration_record)
-                # TODO remove
 
     @_publish(["dg_calibration_record"])
     def _handler_received_complete_dg_calibration_record(self):
@@ -141,17 +150,16 @@
         """
         self.logger.debug("Received a complete dg calibration record.")
 
-    def cmd_set_dg_calibration_record(self, dg_calibration_record: OrderedDict) -> bool:
+    def cmd_set_dg_calibration_record(self, previous_record: OrderedDict) -> bool:
         """
         Handles updating the DG calibration record with the newest calibration_record data of a hardware and
         sends it to FW.
 
-        @param dg_calibration_record: (OrderedDict) the dg calibration record to be sent
+        @param previous_record: (OrderedDict) the dg calibration record to be sent
         @return: True upon success, False otherwise
         """
-
-        record_packets = self._utilities.prepare_record_to_send_to_fw(dg_calibration_record)
-
+        # Pass the new changes as well as the previous calibration record
+        record_packets = self._utilities.prepare_record_to_send_to_fw(self.dg_calibration_record)
         self.logger.debug('Setting DG calibration started')
 
         # Update all the data packets with the last message count since is the number of messages that firmware
@@ -190,11 +198,11 @@
         # 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.
         records_with_sizes = [self._prepare_pressure_sensors_cal_record(), self._prepare_flow_sensors_cal_record(),
-                     self._prepare_load_cells_record(), self._prepare_temperature_sensors_record(),
-                     self._prepare_conductivity_sensors_record(), self._prepare_pumps_record(),
-                     self._prepare_volume_record(), self._prepare_acid_concentrates_record(),
-                     self._prepare_bicarb_concentrates_record(), self._prepare_filters_record(),
-                     self._prepare_fans_record(), self._prepare_accelerometer_sensor_record()]
+                              self._prepare_load_cells_record(), self._prepare_temperature_sensors_record(),
+                              self._prepare_conductivity_sensors_record(), self._prepare_pumps_record(),
+                              self._prepare_volume_record(), self._prepare_acid_concentrates_record(),
+                              self._prepare_bicarb_concentrates_record(), self._prepare_filters_record(),
+                              self._prepare_fans_record(), self._prepare_accelerometer_sensor_record()]
 
         for record, byte_size in records_with_sizes:
             # Update the groups bytes size so far to be use to padding later
Index: dialin/dg/hd_proxy.py
===================================================================
diff -u -rf7927c4086e16a080e6ba1552e10f6d776c84e17 -r89f9210ef5bf37a6812c4dc06aaa636dd47b9d72
--- dialin/dg/hd_proxy.py	(.../hd_proxy.py)	(revision f7927c4086e16a080e6ba1552e10f6d776c84e17)
+++ dialin/dg/hd_proxy.py	(.../hd_proxy.py)	(revision 89f9210ef5bf37a6812c4dc06aaa636dd47b9d72)
@@ -113,7 +113,7 @@
             Given drain to volume must be between 0 and 1950 mL.
 
         @param volume:  unsigned int - volume (in mL) to drain the inactive reservoir to.
-        @param tareLoadCell:  bool - flag indicates to tare loadcell.
+        @param tare_load_cell:  bool - flag indicates to tare loadcell.
         @return: 1 if successful, zero otherwise
         """
 
Index: dialin/dg/service_record.py
===================================================================
diff -u -r8a13a85045edfcf69bf0e728d294f04b924d732c -r89f9210ef5bf37a6812c4dc06aaa636dd47b9d72
--- dialin/dg/service_record.py	(.../service_record.py)	(revision 8a13a85045edfcf69bf0e728d294f04b924d732c)
+++ dialin/dg/service_record.py	(.../service_record.py)	(revision 89f9210ef5bf37a6812c4dc06aaa636dd47b9d72)
@@ -21,6 +21,8 @@
     Hemodialysis Device (HD) Dialin API sub-class for service record commands.
     """
 
+    # The default service time interval is 6 months in seconds
+    _DEFAULT_SERVICE_INTERVAL_S = 15768000
     _RECORD_SPECS_BYTES = 12
     _DEFAULT_SERVICE_LOCATION = ServiceLocation.SERVICE_LOCATION_FACTORY.value
     _DEFAULT_TIME_VALUE = 0
@@ -56,6 +58,18 @@
             self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                        self._handler_dg_service_sync)
 
+    def cmd_reset_dg_service_record(self) -> bool:
+        """
+        Handles resetting DG service record.
+
+        @return: True if successful, False otherwise
+        """
+        self._prepare_dg_service_record()
+        self.dg_service_record = self._utilities.reset_fw_record(self.dg_service_record)
+        status = self.cmd_set_dg_service_record(self.dg_service_record)
+
+        return status
+
     def cmd_request_dg_service_record(self) -> int:
         """
         Handles getting DG service record from firmware.
@@ -212,7 +226,8 @@
         groups_byte_size = 0
         service_records = OrderedDict({'service_record':
                                       {'service_location': ['<B', self._DEFAULT_SERVICE_LOCATION],
-                                       'service_date': ['<i', self._DEFAULT_TIME_VALUE],
+                                       'last_service_date': ['<i', self._DEFAULT_TIME_VALUE],
+                                       'service_interval': ['<i', self._DEFAULT_SERVICE_INTERVAL_S],
                                        'crc': ['<H', self._DEFAULT_CRC_VALUE]}})
 
         for record in service_records.keys():
Index: dialin/dg/system_record.py
===================================================================
diff -u -r8a13a85045edfcf69bf0e728d294f04b924d732c -r89f9210ef5bf37a6812c4dc06aaa636dd47b9d72
--- dialin/dg/system_record.py	(.../system_record.py)	(revision 8a13a85045edfcf69bf0e728d294f04b924d732c)
+++ dialin/dg/system_record.py	(.../system_record.py)	(revision 89f9210ef5bf37a6812c4dc06aaa636dd47b9d72)
@@ -22,7 +22,7 @@
     """
 
     _RECORD_SPECS_BYTES = 12
-    _DEFAULT_CHAR_VALUE = 'X'
+    _DEFAULT_CHAR_VALUE = '-'
     _DEFAULT_MFG_LOCATION = MFGLocation.MFG_LOCATION_FACTORY.value
     _MAX_PN_BYTES = 10
     _MAX_SN_BYTES = 15
@@ -62,6 +62,18 @@
             msg_id = MsgIds.MSG_ID_DG_SEND_SYSTEM_RECORD.value
             self.can_interface.register_receiving_publication_function(channel_id, msg_id, self._handler_dg_system_sync)
 
+    def cmd_reset_dg_system_record(self) -> bool:
+        """
+        Handles resetting DG system record.
+
+        @return: True if successful, False otherwise
+        """
+        self._prepare_dg_system_record()
+        self.dg_system_record = self._utilities.reset_fw_system_service_record(self.dg_system_record)
+        status = self.cmd_set_dg_system_record(self.dg_system_record)
+
+        return status
+
     def cmd_request_dg_system_record(self) -> int:
         """
         Handles getting DG system record from firmware.
Index: dialin/hd/calibration_record.py
===================================================================
diff -u -r6e20f4690ce887c351d8c65546f93311e5df6ad1 -r89f9210ef5bf37a6812c4dc06aaa636dd47b9d72
--- dialin/hd/calibration_record.py	(.../calibration_record.py)	(revision 6e20f4690ce887c351d8c65546f93311e5df6ad1)
+++ dialin/hd/calibration_record.py	(.../calibration_record.py)	(revision 89f9210ef5bf37a6812c4dc06aaa636dd47b9d72)
@@ -52,7 +52,7 @@
         self._raw_cal_record = []
         self._utilities = NVOpsUtils(logger=self.logger)
         # HD Calibration main record
-        self.hd_calibration_record = self._setup_base_calibration_record()
+        self.hd_calibration_record = self.setup_base_calibration_record()
 
         if self.can_interface is not None:
 
@@ -173,7 +173,7 @@
         self.logger.debug("Finished sending HD calibration record.")
         return True
 
-    def _setup_base_calibration_record(self):
+    def setup_base_calibration_record(self):
         """
         Handles assembling the sub dictionaries of each hardware group to make the main HD calibration_record record.
 
@@ -247,7 +247,7 @@
         hardware_names = ['vbv', 'vba', 'vdi', 'vdo']
 
         group_byte_size = 0
-        group_name = 'vales'
+        group_name = 'valves'
         hardware_group = OrderedDict({group_name: OrderedDict()})
         hardware = OrderedDict()
 
Index: dialin/hd/system_record.py
===================================================================
diff -u -r2e392c92d55178f457a67423ba8c503a86dcf3c8 -r89f9210ef5bf37a6812c4dc06aaa636dd47b9d72
--- dialin/hd/system_record.py	(.../system_record.py)	(revision 2e392c92d55178f457a67423ba8c503a86dcf3c8)
+++ dialin/hd/system_record.py	(.../system_record.py)	(revision 89f9210ef5bf37a6812c4dc06aaa636dd47b9d72)
@@ -23,7 +23,7 @@
     """
 
     _RECORD_SPECS_BYTES = 12
-    _DEFAULT_CHAR_VALUE = 'X'
+    _DEFAULT_CHAR_VALUE = '-'
     _DEFAULT_MFG_LOCATION = MFGLocation.MFG_LOCATION_FACTORY.value
     _MAX_PN_BYTES = 10
     _MAX_SN_BYTES = 15
@@ -57,7 +57,7 @@
         self._raw_system_record = []
         self._utilities = NVOpsUtils(logger=self.logger)
         # System main record
-        self.hd_system_record = self._prepare_hd_system_record()
+        self.hd_system_record = self.prepare_hd_system_record()
 
         if self.can_interface is not None:
             channel_id = DenaliChannels.hd_to_dialin_ch_id
@@ -175,7 +175,7 @@
         self.logger.debug("Finished sending HD system record.")
         return True
 
-    def _prepare_hd_system_record(self):
+    def prepare_hd_system_record(self):
         """
         Handles assembling the sub dictionaries of each group to make the main HD system record.
 
Index: dialin/utils/nv_ops_utils.py
===================================================================
diff -u -r691a604eec8e3d0dd7d4b5e217ee5ee143e8e27e -r89f9210ef5bf37a6812c4dc06aaa636dd47b9d72
--- dialin/utils/nv_ops_utils.py	(.../nv_ops_utils.py)	(revision 691a604eec8e3d0dd7d4b5e217ee5ee143e8e27e)
+++ dialin/utils/nv_ops_utils.py	(.../nv_ops_utils.py)	(revision 89f9210ef5bf37a6812c4dc06aaa636dd47b9d72)
@@ -3,7 +3,6 @@
 from logging import Logger
 from typing import List
 from collections import OrderedDict
-
 from .excel_ops import *
 
 
@@ -98,7 +97,6 @@
         @param directory: (str) the directory in which to write the excel doc
         @return none
         """
-
         path = ''
         is_report_found = False
 
@@ -181,7 +179,6 @@
 
                 row += 1
 
-
             save_report(self._excel_workbook, self._workspace_dir, self._firmware_stack)
             # Signal reading is done
             self._is_writing_to_excel_done = True
@@ -211,10 +208,9 @@
                             if isinstance(calibration_record[group][hardware], dict):
                                 col = 4
                                 for spec in calibration_record[group][hardware]:
-                                    cell_value = get_cell_value(self._excel_workbook, self._record_name, row,
-                                                                               col)
-                                    # Check if the cell value is not none. If it is none, it cannot be converted to a number
-                                    # like float or integer
+                                    cell_value = get_cell_value(self._excel_workbook, self._record_name, row, col)
+                                    # Check if the cell value is not none. If it is none, it cannot be converted to a
+                                    # number like float or integer
                                     is_cell_value_valid = True if cell_value is not None else False
                                     if 'crc' not in spec and 'time' not in spec and is_cell_value_valid:
                                         temp_buffer.append(struct.pack(calibration_record[group][hardware][spec][0], cell_value))
@@ -276,10 +272,92 @@
         Gets the reading record status
         @return: True if done, false otherwise
         """
-
         return self._is_read_done
 
     @staticmethod
+    def get_processed_characters(record: list) -> bytearray:
+        """
+        Gets the list of the characters and makes sure their length is to the define length
+
+        @param record: (list) the list that contains the characters, data type and the target character length
+        @return characters (bytearray) that are converted to bytearrays
+        """
+        data_type = record[0]
+        char = record[1]
+        char_len = record[2]
+        temp = bytearray()
+
+        if len(char) > char_len:
+            char = char[:char_len]
+        elif len(char) < char_len:
+            for i in range(len(char), char_len):
+                char += '-'
+
+        for ch in char:
+            temp += struct.pack(data_type, ch.encode('ascii'))
+
+        return temp
+
+    @staticmethod
+    def reset_fw_record(record: OrderedDict) -> OrderedDict:
+        """
+        Gets a record and updated the calibration date and crc
+
+        @param record: (dict) the record to calculate the calibration time and crc
+        @return record (OrderedDict) the record with updated calibration time and crc
+        """
+
+        for key, value in record.items():
+            if isinstance(value, dict):
+                for sub_key, sub_value in value.items():
+                    if sub_key == 'cal_time':
+                        sub_value['cal_time'][1] = NVOpsUtils.get_current_time_in_epoch()
+                    crc = NVOpsUtils.get_group_record_crc(sub_value)
+                    sub_value['crc'][1] = crc
+
+        return record
+
+    @staticmethod
+    def reset_fw_system_service_record(record: OrderedDict) -> OrderedDict:
+        """
+        Gets a record and updated the calibration date and crc
+
+        @param record: (dict) the record to calculate the calibration time and crc
+        @return record (OrderedDict) the record with updated calibration time and crc
+        """
+        for key, value in record.items():
+            if isinstance(value, dict):
+                crc = NVOpsUtils.get_group_record_crc(value)
+                value['crc'][1] = crc
+
+        return record
+
+    @staticmethod
+    def get_group_record_crc(group_record: dict) -> int:
+        """
+        Gets a group record and calculates the crc for the group
+
+        @param group_record: (dict) the record to calculate the crc
+        @return crc (int) the calculated crc
+        """
+        value_in_bytes = b''
+        temp = []
+        print(group_record)
+        for key, value in group_record.items():
+            if key is not 'crc':
+                data_type = value[0]
+                value = value[1]
+                if data_type == '<c':
+                    [temp.append(struct.pack(data_type, i.encode('ascii'))) for i in value]
+                else:
+                    temp.append(struct.pack(data_type, value))
+
+        value_in_bytes += b''.join(temp)
+        crc_value = NVOpsUtils.crc_16(value_in_bytes)
+
+        return crc_value
+
+    @staticmethod
     def get_current_time_in_epoch():
         """
         Returns the current date and time in epoch in integer format. This is a static method.
@@ -432,11 +510,11 @@
 
         return calibration_record, read_start_index
 
-    def prepare_record_to_send_to_fw(self, dialin_record):
+    def prepare_record_to_send_to_fw(self, new_record):
         """
         Handles preparing the record to be sent to firmware
 
-        @param dialin_record: the dictionary that is processed to be sent down
+        @param new_record: the dictionary that is processed to be sent down
 
         @return: record packets in bytes
         """
@@ -447,26 +525,26 @@
 
         try:
             # Loop through the DG calibration_record dictionary
-            for group in dialin_record.keys():
+            for group in new_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 = dialin_record[group][self._DATA_TYPE_INDEX]
+                    data_type = new_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._PAYLOAD_TOTAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-                    temp_buffer.append(struct.pack(data_type, dialin_record[group][self._DATA_VALUE_INDEX]))
+                    temp_buffer.append(struct.pack(data_type, new_record[group][self._DATA_VALUE_INDEX]))
                     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':
-                    if len(dialin_record[group][self._DATA_VALUE_INDEX]) != 0:
+                    if len(new_record[group][self._DATA_VALUE_INDEX]) != 0:
                         # Get the data type and calculate the number of bytes
-                        data_type = dialin_record[group][self._DATA_TYPE_INDEX]
+                        data_type = new_record[group][self._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 dialin_record[group][self._DATA_VALUE_INDEX]:
+                        # If there are padding zeros, they are in a list. loop through and add them to temp buffer
+                        for pad in new_record[group][self._DATA_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)
@@ -482,13 +560,14 @@
                                                struct.pack('<i', current_payload_length),
                                                struct.pack(data_type, pad)]
                 else:
-                    for key in dialin_record[group].keys():
+                    for key in new_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):
+                        if isinstance(new_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,
+                            for inner_key in new_record[group][key]:
+                                processed_values = self._prepare_record_packets_for_fw(new_record,
+                                                                                       group, key, temp_buffer,
+                                                                                       current_payload_length,
                                                                                        current_message_count,
                                                                                        inner_dict_key=inner_key)
                                 # Update the local variables
@@ -497,7 +576,8 @@
                                 current_payload_length = processed_values[2]
                         else:
                             # The value of the key is not a dictionary itself
-                            processed_values = self._prepare_record_packets_for_fw(dialin_record, group, key, temp_buffer,
+                            processed_values = self._prepare_record_packets_for_fw(new_record, group,
+                                                                                   key, temp_buffer,
                                                                                    current_payload_length,
                                                                                    current_message_count)
                             # Update the local variables
@@ -528,7 +608,7 @@
             # 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] = crc
+            new_record['crc'][self._DATA_VALUE_INDEX] = crc
 
             # Update all the data packets with the last message count since is the number of messages that firmware
             # should receive
@@ -537,12 +617,13 @@
                 # 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)
-        except Exception as e:
-            self.logger.error("Could not prepare record to send to fw: {0}".format(e))
+        except: #Exception as e:
+            raise
+            #self.logger.error("Could not prepare record to send to fw: {0}".format(e))
 
         return self._record_packets_to_send_to_fw
 
-    def _prepare_record_packets_for_fw(self, dialin_record: OrderedDict,
+    def _prepare_record_packets_for_fw(self, new_record: OrderedDict,
                                        group: str,
                                        key: str,
                                        temp_buffer: List,
@@ -552,7 +633,7 @@
         """
         Prepares the record packets prior to sending to firmware
 
-        @param dialin_record: (OrderedDict) the dictionary that is process to be sent down
+        @param new_record: (OrderedDict) the dictionary that is processed to be sent down
         @param group: (str) dictionary group that is being processed (i.e service_records)
         @param key: dictionary key of the current group
         @param temp_buffer: List temporary buffer that is holding the values to be converted to bytes
@@ -566,42 +647,42 @@
         try:
             # 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 = new_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]
+                current_value = new_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]
+                char_len = 1 if len(new_record[group][key]) <= self._DICT_VALUE_LIST_LEN else \
+                    new_record[group][key][self._CHAR_LENGTH_INDEX]
             else:
-                data_type = dialin_record[group][key][inner_dict_key][self._DATA_TYPE_INDEX]
+                data_type = new_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]
+                current_value = new_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]
+                char_len = 1 if len(new_record[group][key][inner_dict_key]) <= self._DICT_VALUE_LIST_LEN else \
+                    new_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':
-                pass
-            else:
+            if key is not 'crc' or inner_dict_key is not 'crc':
+
                 # 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')))
+                    self._temp_groups_data_to_calculate_crc.\
+                        append(NVOpsUtils.get_processed_characters(new_record[group][key]))
                 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:
@@ -613,8 +694,7 @@
                 # 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')))
+                    temp_buffer.append(NVOpsUtils.get_processed_characters(new_record[group][key]))
                 else:
                     temp_buffer.append(struct.pack(data_type, current_value))
 
@@ -638,14 +718,13 @@
                 # 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')))
+                    temp_buffer.append(NVOpsUtils.get_processed_characters(new_record[group][key]))
                 else:
                     temp_buffer.append(struct.pack(data_type, current_value))
+        except: #Exception as e:
+            raise
+        #    self.logger.error("Failed to prepare record packets for fw: {0}".format(e))
 
-        except Exception as e:
-            self.logger.error("Failed to prepare record packets for fw: {0}".format(e))
-
         # Return the latest calculated values as tuple
         return temp_buffer, current_message_count, current_payload_length
 
Fisheye: Tag 89f9210ef5bf37a6812c4dc06aaa636dd47b9d72 refers to a dead (removed) revision in file `tests/peter/test_calibration.py'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: tests/peter/test_dg_records.py
===================================================================
diff -u
--- tests/peter/test_dg_records.py	(revision 0)
+++ tests/peter/test_dg_records.py	(revision 89f9210ef5bf37a6812c4dc06aaa636dd47b9d72)
@@ -0,0 +1,259 @@
+import copy
+import pprint
+import subprocess
+import sys
+import struct
+
+from dialin import HD, AbstractObserver
+
+sys.path.append("../../")
+from dialin.dg.dialysate_generator import DG
+from dialin.utils.nv_ops_utils import NVOpsUtils
+from time import sleep
+
+"""
+def process_calibration_record(read=False):
+    dg = DG()
+
+    cal = dg.calibration_record
+    print(cal.tmp_record)
+
+    try:
+        if read:
+            cal.cmd_request_dg_calibration_record()
+            while True:
+                sleep(0.5)
+                if cal.cal_data != 0:
+                    if cal.is_reading_record_done():
+                        break
+        else:
+            cal.cmd_set_dg_calibration_record()
+
+        print(cal.tmp_record)
+
+    except KeyboardInterrupt:
+        pass
+
+
+def process_system_record(read=False):
+
+    sys = dg.system_record
+    print(sys.dg_system_record)
+
+    try:
+        if read:
+            sys.get_dg_system_record()
+            while True:
+                sleep(0.5)
+                if sys.is_reading_record_done():
+                    if sys.is_reading_record_done():
+                        break
+        else:
+            sys.set_dg_system_record()
+
+        print(sys.dg_system_record)
+
+    except KeyboardInterrupt:
+        pass
+
+
+def process_service_record(read=False):
+
+    sys = dg.service_record
+    print(sys.dg_service_record)
+
+    try:
+        if read:
+            sys.cmd_request_dg_service_record()
+            while True:
+                sleep(0.5)
+                if sys.is_reading_record_done():
+                    if sys.is_reading_record_done():
+                        break
+        else:
+            sys.set_dg_service_record()
+
+        print(sys.dg_service_record)
+
+    except KeyboardInterrupt:
+        pass
+
+
+def test_crc():
+    val = NVOpsUtils.crc_16(b''.join([
+        struct.pack("<f", 0.0),
+        struct.pack("<f", 0.0),
+        struct.pack("<f", 0.0),
+        struct.pack("<f", 1.0),
+        struct.pack("<f", 0.0),
+        struct.pack("<i", 0),
+    ]))
+    print(val)
+    val = NVOpsUtils.crc_16(b''.join([
+        struct.pack("<f", 1.0), # fourth order
+        struct.pack("<f", 1.0), # third order
+        struct.pack("<f", 1.0), # second order
+        struct.pack("<f", 1.0), # gain
+        struct.pack("<f", 0.0), # offset
+        struct.pack("<i", 0), # cal_time
+    ]))
+    print(val)
+
+     OrderedDict([('ppi',
+                            {'cal_time': ['<i', 0],
+                             'crc': ['<H', 26600],
+                             'fourth_order': ['<f', 0.0],
+                             'gain': ['<f', 1.0],
+                             'offset': ['<f', 0.0],
+                             'second_order': ['<f', 0.0],
+                             'third_order': ['<f', 0.0]}),
+                           ('ppo',
+                            {'cal_time': ['<i', 0],
+                             'crc': ['<H', 26600],
+                             'fourth_order': ['<f', 0.0],
+                             'gain': ['<f', 1.0],
+                             'offset': ['<f', 0.0],
+                             'second_order': ['<f', 0.0],
+                             'third_order': ['<f', 0.0]}),
+
+    val = NVOpsUtils.crc_16(b''.join([
+        struct.pack("<f", 1.0),
+        struct.pack("<f", 1.0),
+        struct.pack("<f", 0),
+        struct.pack("<f", 0),
+        struct.pack("<i", 0), # calibration time
+    ]))
+    print(val)
+    val = NVOpsUtils.crc_16(b''.join([
+        struct.pack("<f", 1.0),
+        struct.pack("<f", 0),
+        struct.pack("<f", 0),
+        struct.pack("<f", 1.0),
+        struct.pack("<f", 0),
+        struct.pack("<i", 0),  # cal_time
+    ]))
+    print(val)
+    val = NVOpsUtils.crc_16(b''.join([
+        struct.pack("<f", float("nan")),
+        struct.pack("<f", float("nan")),
+        struct.pack("<f", float("nan")),
+        struct.pack("<f", float("nan")),
+        struct.pack("<f", float("nan")),
+        struct.pack("<i", -1),  # cal_time
+    ]))
+    print(val)
+    """
+
+
+class Observer(AbstractObserver):
+    def __init__(self, prop):
+        self.received = False
+        self.prop = prop
+
+    def update(self, message):
+        print("Message: {0}".format(message))
+        self.received = message.get(self.prop, False)
+
+
+def test_dg_calibration_record():
+
+    dg = DG(log_level="DEBUG")
+    if dg.cmd_log_in_to_dg():
+        print(dg.cmd_ui_request_dg_version())
+        dg.calibration_record.cmd_request_dg_calibration_record()
+        observer = Observer("dg_calibration_record")
+        dg.calibration_record.attach(observer)
+        while not observer.received:
+            sleep(0.2)
+
+        # Get a snapshot of the current calibration record prior to modifying the dictionary with the latest values
+        previous_firmware_record = dg.calibration_record.dg_calibration_record
+
+        # Change the value(s) you are planning to change directly to the dictionary
+        dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppi"]["fourth_order"][1] = 1.0
+        dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppi"]["cal_time"][1] = \
+            NVOpsUtils.get_current_time_in_epoch()
+        dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppi"]["crc"][1] = \
+            NVOpsUtils.get_group_record_crc(dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppi"])
+
+        dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppo"]["second_order"][1] = 2.0
+        dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppo"]["cal_time"][1] = \
+            NVOpsUtils.get_current_time_in_epoch()
+        dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppo"]["crc"][1] = \
+            NVOpsUtils.get_group_record_crc(dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppo"])
+        dg.calibration_record.cmd_set_dg_calibration_record(dg.calibration_record.dg_calibration_record)
+
+        """
+        record_old_formatted = pprint.pformat(dg.calibration_record.dg_calibration_record, indent=4)
+        with open("/home/fw/projects/dialin/tests/peter/dg_cal_record.log", 'w') as f:
+            f.write(record_old_formatted)
+        print(dg.calibration_record.dg_calibration_record)
+
+        #subprocess.call("meld /home/fw/projects/dialin/tests/peter/dialin_test_record_old.log"
+        #                "     /home/fw/projects/dialin/tests/peter/dialin_test_record_new.log", shell=True)
+        """
+
+def test_dg_reset_record():
+    dg = DG(log_level="DEBUG")
+    if dg.cmd_log_in_to_dg():
+
+        #dg.calibration_record.cmd_reset_dg_calibration_record()
+        dg.system_record.cmd_reset_dg_system_record()
+        #dg.service_record.cmd_reset_dg_service_record()
+
+
+def test_dg_service_record():
+    dg = DG(log_level="DEBUG")
+    if dg.cmd_log_in_to_dg():
+
+        dg.cmd_ui_request_dg_version()
+        dg.service_record.cmd_request_dg_service_record()
+        observer = Observer("dg_service_record")
+        dg.service_record.attach(observer)
+        while not observer.received:
+            sleep(0.2)
+
+        print(dg.dg_version)
+        print(dg.fpga_version)
+
+        dg.service_record.cmd_set_dg_service_record(dg.service_record.dg_service_record)
+
+
+def test_dg_system_record():
+    dg = DG(log_level="DEBUG")
+    if dg.cmd_log_in_to_dg():
+
+        dg.cmd_ui_request_dg_version()
+        dg.system_record.cmd_request_dg_system_record()
+        observer = Observer("dg_system_record")
+        dg.system_record.attach(observer)
+        while not observer.received:
+            sleep(0.2)
+
+        dg.system_record.dg_system_record['system_record']['top_level_pn'][1] = 'abc-345'
+        dg.system_record.dg_system_record['system_record']['crc'][1] = \
+            NVOpsUtils.get_group_record_crc(dg.system_record.dg_system_record['system_record'])
+
+        print(dg.system_record.dg_system_record)
+        dg.system_record.cmd_set_dg_system_record(dg.system_record.dg_system_record)
+
+
+def test_dg_scheduled_runs_record():
+    dg = DG(log_level="DEBUG")
+    if dg.cmd_log_in_to_dg():
+        dg.scheduled_runs_record.cmd_request_dg_scheduled_runs_record()
+        observer = Observer("dg_scheduled_runs_record")
+        dg.scheduled_runs_record.attach(observer)
+        while not observer.received:
+            sleep(0.2)
+
+        dg.scheduled_runs_record.cmd_set_dg_scheduled_runs_record(dg.scheduled_runs_record.dg_scheduled_runs_record)
+
+
+if __name__ == "__main__":
+
+    #test_dg_reset_record()
+    #test_dg_calibration_record()
+    # test_dg_service_record()
+    test_dg_system_record()
+    # test_dg_scheduled_runs_record()
Index: tests/peter/test_hd_records.py
===================================================================
diff -u
--- tests/peter/test_hd_records.py	(revision 0)
+++ tests/peter/test_hd_records.py	(revision 89f9210ef5bf37a6812c4dc06aaa636dd47b9d72)
@@ -0,0 +1,111 @@
+import copy
+import pprint
+import subprocess
+import sys
+import struct
+
+from dialin import HD, AbstractObserver
+
+sys.path.append("../../")
+from dialin.dg.dialysate_generator import DG
+from dialin.utils.nv_ops_utils import NVOpsUtils
+from time import sleep
+
+
+class Observer(AbstractObserver):
+    def __init__(self, prop):
+        self.received = False
+        self.prop = prop
+
+    def update(self, message):
+        print("Message: {0}".format(message))
+        self.received = message.get(self.prop, False)
+
+def test_hd_calibration_record():
+    hd = HD(log_level="DEBUG")
+    if hd.cmd_log_in_to_hd(resend=False):
+        observer = Observer("hd_calibration_record")
+        hd.calibration_record.attach(observer)
+        hd.calibration_record.cmd_request_hd_calibration_record()
+        while not observer.received:
+            sleep(0.2)
+
+        hd.calibration_record.cmd_set_hd_calibration_record(hd.calibration_record.hd_calibration_record)
+
+        # store the old record after reading it from fw
+        record_old_formatted = pprint.pformat(hd.calibration_record.hd_calibration_record, indent=4)
+        with open("/home/fw/projects/dialin/tests/peter/hd_cal_record_old.log", 'w') as f:
+            f.write(record_old_formatted)
+
+        hd.calibration_record.hd_calibration_record["flow_sensors"]["fmb"]["third_order"][1] = 0.0
+        hd.calibration_record.hd_calibration_record["flow_sensors"]["fmb"]["cal_time"][1] = \
+            NVOpsUtils.get_current_time_in_epoch()
+        hd.calibration_record.hd_calibration_record["flow_sensors"]["fmb"]["crc"][1] = \
+            NVOpsUtils.get_group_record_crc(hd.calibration_record.hd_calibration_record["flow_sensors"]["fmb"])
+        print(hd.calibration_record.hd_calibration_record)
+        hd.calibration_record.cmd_set_hd_calibration_record(hd.calibration_record.hd_calibration_record)
+
+
+def test_hd_reset_calibration_record():
+    hd = HD(log_level="DEBUG")
+    if hd.cmd_log_in_to_hd(resend=False):
+        hd.calibration_record.setup_base_calibration_record()
+        print(hd.calibration_record.hd_calibration_record)
+        reset_record = NVOpsUtils.reset_fw_record(hd.calibration_record.hd_calibration_record)
+        print(reset_record)
+        hd.calibration_record.cmd_set_hd_calibration_record(reset_record)
+
+
+def test_hd_service_record():
+    hd = HD(log_level="DEBUG")
+    if hd.cmd_log_in_to_hd(resend=False):
+        observer = Observer("hd_service_record")
+        hd.service_record.attach(observer)
+        hd.service_record.cmd_request_hd_service_record()
+        while not observer.received:
+            sleep(0.2)
+
+        hd.service_record.cmd_set_hd_service_record(hd.service_record.hd_service_record)
+
+
+def test_hd_reset_system_record():
+    hd = HD(log_level="DEBUG")
+    if hd.cmd_log_in_to_hd(resend=False):
+        hd.system_record.prepare_hd_system_record()
+        hd.system_record.hd_system_record["system_record"]["crc"][1] = \
+            NVOpsUtils.get_group_record_crc(hd.system_record.hd_system_record["system_record"])
+        print(hd.system_record.hd_system_record)
+        hd.system_record.cmd_set_hd_system_record(hd.system_record.hd_system_record)
+
+
+def test_hd_system_record():
+    hd = HD(log_level="DEBUG")
+    if hd.cmd_log_in_to_hd(resend=False):
+        hd.ui.cmd_ui_request_hd_version()
+        observer = Observer("hd_system_record")
+        hd.system_record.attach(observer)
+        hd.system_record.cmd_request_hd_system_record()
+        while not observer.received:
+            sleep(0.2)
+
+        record_old_formatted = pprint.pformat(hd.system_record.hd_system_record, indent=4)
+        with open("/home/fw/projects/dialin/tests/peter/hd_sys_record_old.log", 'w') as f:
+            f.write(record_old_formatted)
+
+        hd.system_record.hd_system_record["system_record"]["top_level_pn"][1] = "ASD-S1234"
+        hd.system_record.hd_system_record["system_record"]["top_level_sn"][1] = "3"
+        hd.system_record.hd_system_record["system_record"]["mfg_location"][1] = 9
+        hd.system_record.hd_system_record["system_record"]["crc"][1] = \
+            NVOpsUtils.get_group_record_crc(hd.system_record.hd_system_record["system_record"])
+        print(hd.system_record.hd_system_record)
+        hd.system_record.cmd_set_hd_system_record(hd.system_record.hd_system_record)
+
+if __name__ == "__main__":
+
+    test_hd_reset_calibration_record()
+    #test_hd_calibration_record()
+    # test_hd_service_record()
+    #test_hd_reset_system_record()
+    #test_hd_system_record()
+    # test_crc()
+    # test_hd_system_record()