Index: dialin/dg/service_record.py
===================================================================
diff -u -r43e8345862c72340680c045e53b310aa291513a6 -ra3be707a0f11b8f01ff32199b60b6162238b6e64
--- dialin/dg/service_record.py	(.../service_record.py)	(revision 43e8345862c72340680c045e53b310aa291513a6)
+++ dialin/dg/service_record.py	(.../service_record.py)	(revision a3be707a0f11b8f01ff32199b60b6162238b6e64)
@@ -7,6 +7,7 @@
 from ..common.msg_defs import MsgIds, MsgFieldPositions
 from ..protocols.CAN import (DenaliMessage, DenaliChannels)
 from ..utils.base import _AbstractSubSystem, DialinEnum
+from ..utils.utils import Utils
 from logging import Logger
 from enum import unique
 
@@ -27,10 +28,10 @@
     SERVICE_RECORD_SPECS_BYTES = 12
     SERVICE_RECORDS_SPECS_BYTE_ARRAY = 3
 
-    DEFAULT_SERVICE_LOCATION = ServiceLocation.SERVICE_LOCATION_FACTORY.value
+    _DEFAULT_SERVICE_LOCATION = ServiceLocation.SERVICE_LOCATION_FACTORY.value
     DEFAULT_MFG_DATE = 0
-    DEFAULT_SERVICE_DATE_VALUE = 0
-    DEFAULT_SERVICE_CRC_VALUE = 0
+    _DEFAULT_DATE_VALUE = 0
+    _DEFAULT_CRC_VALUE = 0
     DEFAULT_SYS_PADDING_VALUE = 0
 
     CURRENT_MESSAGE_NUM_INDEX = 0
@@ -44,15 +45,13 @@
     TARGET_BYTES_TO_SEND_TO_FW = 150
     MIN_PAYLOAD_BYTES_SPACE = 4
 
-    RTC_RAM_MAX_BYTES_TO_WRITE = 64
+    _RTC_RAM_MAX_BYTES_TO_WRITE = 64
 
+    _PAYLOAD_TRANSFER_DELAY = 0.2
     PAYLOAD_CURRENT_MSG_INDEX = 0
     PAYLOAD_TOTAL_MSG_INDEX = 1
     PAYLOAD_SERVICE_BYTES_INDEX = 2
 
-    # DG system main record as an ordered dictionary
-    DG_SERVICE_RECORD = OrderedDict()
-
     def __init__(self, can_interface, logger: Logger):
         """
 
@@ -61,13 +60,16 @@
 
         super().__init__()
 
+        self.utilities = Utils()
         self.can_interface = can_interface
         self.logger = logger
         self.current_message = 0
         self.total_messages = 0
         self.length = 0
         self.cal_data = 0
         self.raw_service_record = []
+        # DG system main record as an ordered dictionary
+        self.dg_service_record = OrderedDict()
 
         if self.can_interface is not None:
 
@@ -206,191 +208,43 @@
         """
         groups_byte_size = 0
         service_records = OrderedDict({'service_record':
-                                      {'service_location': ['<B', self.DEFAULT_SERVICE_LOCATION],
-                                       'service_date': ['<i', self.DEFAULT_SERVICE_DATE_VALUE],
-                                       'crc': ['<H', self.DEFAULT_SERVICE_CRC_VALUE]}})
+                                      {'service_location': ['<B', self._DEFAULT_SERVICE_LOCATION],
+                                       'service_date': ['<i', self._DEFAULT_DATE_VALUE],
+                                       'crc': ['<H', self._DEFAULT_CRC_VALUE]}})
 
         for record in service_records.keys():
-            groups_byte_size += self._calculate_group_byte_size(service_records[record])
+            groups_byte_size += self.utilities.calculate_group_byte_size(service_records[record])
 
         # Build the CRC of the main system record
-        cal_record_crc = OrderedDict({'crc': ['<H', self.DEFAULT_SERVICE_CRC_VALUE]})
-        groups_byte_size += self._calculate_group_byte_size(cal_record_crc)
+        cal_record_crc = OrderedDict({'crc': ['<H', self._DEFAULT_CRC_VALUE]})
 
-        # Calculate the padding size:
-        # If bytes in the dictionary % max write bytes to RTC RAM (64) is 0, not padding is needed
-        # Else padding = (ceil(dictionary bytes/max write to RTC RAM (64)) * max write to RTC RAM (64))-dictionary bytes
-        if (groups_byte_size % self.RTC_RAM_MAX_BYTES_TO_WRITE) == 0:
-            padding_size = 0
-        else:
-            padding_size = (math.ceil(groups_byte_size / self.RTC_RAM_MAX_BYTES_TO_WRITE) *
-                            self.RTC_RAM_MAX_BYTES_TO_WRITE) - groups_byte_size
+        # Get the groups byte size
+        groups_byte_size += self.utilities.calculate_group_byte_size(cal_record_crc)
+
+        # Get the padding size to create a dictionary from it
+        padding_size = self.utilities.calculate_padding_byte_size(groups_byte_size, self._RTC_RAM_MAX_BYTES_TO_WRITE)
+
         # Create the padding dictionary as list of unsigned char. All the elements are 0.
         padding = OrderedDict({'padding': ['<B', [self.DEFAULT_SYS_PADDING_VALUE] * padding_size]})
 
-        self.DG_SERVICE_RECORD = {**service_records, **padding, **cal_record_crc}
+        self.dg_service_record = {**service_records, **padding, **cal_record_crc}
 
-    def _calculate_group_byte_size(self, group):
-        """
-        Handles calculating the byte size of the values of the provided dictionary.
-
-        @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][self.SERVICE_DATA_TYPE_INDEX]
-            current_byte_size = self._get_data_type_bytes(data_type)
-            byte_size += current_byte_size
-
-        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.
-        This is a static method.
-
-        @param data: the data to be converted to bytes in number
-        @return: calculated byte size
-        """
-        number_of_bytes = 0
-        # Unsigned integer = i
-        # Signed integer = I
-        # Float = f. All 4 bytes.
-        if data == '<i' or data == '<f':
-            number_of_bytes = 4
-        # Unsigned short = H. 2 bytes.
-        elif data == '<H':
-            number_of_bytes = 2
-        # Unsigned char = B. 1 byte.
-        elif data == '<B' or data == '<c':
-            number_of_bytes = 1
-
-        return number_of_bytes
-
     def set_dg_service_data(self):
         """
         Handles updating the DG service record with the newest data and sends it to FW.
 
         @return: none
         """
+        # Get the processed record packets
+        record_packets = self.utilities.prepare_record_to_send_to_fw(self.dg_service_record)
 
-        # This list contains different data packet lists
-        # i.e. [[message 1, payload], [message 2, payload], ...]
-        service_record_packets = []
-        current_payload_length = 0
-        current_message_count = 1
-        temp_buffer = [0, 0, 0]
-
-        # Loop through the DG calibration dictionary
-        for group in self.DG_SERVICE_RECORD.keys():
-
-            # NOTE: crc and padding are checked separately since they do not have layered dictionaries
-            # If the group is the final CRC of the dictionary
-            if group == 'crc':
-                data_type = self.DG_SERVICE_RECORD[group][self.SERVICE_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_SERVICE_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-                temp_buffer.append(struct.pack(data_type, self.DG_SERVICE_RECORD[group][self.SERVICE_VALUE_INDEX]))
-                service_record_packets.append(temp_buffer)
-
-            # If the group is padding, and the length of padding is not 0
-            elif group == 'padding':
-                if len(self.DG_SERVICE_RECORD[group][self.SERVICE_VALUE_INDEX]) != 0:
-                    # Get the data type and calculate the number of bytes
-                    data_type = self.DG_SERVICE_RECORD[group][self.SERVICE_DATA_TYPE_INDEX]
-                    data_type_bytes = self._get_data_type_bytes(data_type)
-                    # If there are padding zeros, they are in a list. loop through the list and add them to temp buffer
-                    for pad in self.DG_SERVICE_RECORD[group][self.SERVICE_VALUE_INDEX]:
-                        if self.TARGET_BYTES_TO_SEND_TO_FW - current_payload_length > self.MIN_PAYLOAD_BYTES_SPACE:
-                            current_payload_length += data_type_bytes
-                            temp_buffer[self.PAYLOAD_TOTAL_MSG_INDEX] = struct.pack('<i', 0)
-                            temp_buffer.append(struct.pack(data_type, pad))
-                        else:
-                            temp_buffer[self.PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
-                            temp_buffer[self.PAYLOAD_SERVICE_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-                            service_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, pad)]
-            else:
-                for key in self.DG_SERVICE_RECORD[group].keys():
-
-                    data_type = self.DG_SERVICE_RECORD[group][key][self.SERVICE_DATA_TYPE_INDEX]
-                    data_type_bytes = self._get_data_type_bytes(data_type)
-                    current_value = self.DG_SERVICE_RECORD[group][key][self.SERVICE_VALUE_INDEX]
-
-                    # 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:
-                        current_payload_length += data_type_bytes
-                        # Insert a 4-byte 0 to the index of the total messages. This is a place holder and it will
-                        # be updated with the right value later.
-                        temp_buffer[self.PAYLOAD_TOTAL_MSG_INDEX] = struct.pack('<i', 0)
-
-                        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_SERVICE_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-                    else:
-                        # There is not enough space left in this temp buffer. Update the current message count and
-                        # the total number of bytes that were packed in this data packet.
-                        temp_buffer[self.PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
-                        temp_buffer[self.PAYLOAD_SERVICE_BYTES_INDEX] = struct.pack('<i', current_payload_length)
-                        # Append the temp buffer list into the main list to be process later
-                        service_record_packets.append(temp_buffer)
-                        # Increment the current message count as a new temp buffer is created for the next data
-                        # packet. Update the current payload length with the latest addition to the new temp buffer.
-                        current_message_count += 1
-                        current_payload_length = data_type_bytes
-                        # Create a new temp buffer and add the current message count, total length of payload so far
-                        # and the data that there was not enough space in the previous data packet.
-                        temp_buffer = [struct.pack('<i', current_message_count), struct.pack('<i', 0),
-                                       struct.pack('<i', current_payload_length),
-                                       struct.pack(data_type, current_value)]
-
-        # Creating a byte array variable and add all the data packets
-        # to one to calculate the final CRC
-        data = b''
-        for svc in service_record_packets:
-            # If the data packet is the last one in the list, ignore the last element of the
-            # packet since it is the final CRC of the entire dictionary. The final CRC itself
-            # is not included in the CRC calculations.
-            # The actual calibration data is started from the 3rd element of the data packet.
-            # The first 3 are current message, total messages, and the payload length of the current packet.
-            if service_record_packets.index(svc) == len(service_record_packets) - 1:
-                data += b''.join(svc[self.SERVICE_RECORDS_SPECS_BYTE_ARRAY:-1])
-            else:
-                # Get all the elements including the last one
-                data += b''.join(svc[self.SERVICE_RECORDS_SPECS_BYTE_ARRAY:])
-
-        # Calculate the 16-bit crc.
-        crc = crc_16(data)
-        # Convert the crc into a 2-byte value
-        service_record_crc = struct.pack('<H', crc)
-        # Insert the CRC into the last element of the last data packet
-        service_record_packets[-1][-1] = service_record_crc
-
-        print('CRC: ', hex(crc))  # TODO remove
-
         self.logger.debug('DG service record update started')
 
-        # Update all the data packets with the last message count since is the number of messages that firmware
-        # should receive
-        for packet in service_record_packets:
+        for packet in record_packets:
+
             # Sleep to let the firmware receive and process the data
-            time.sleep(0.2)
-            # Add the number of total messages to each data packet. This was delayed
-            # until now since it was not known how many message will it take to pack all the
-            # calibration data.
-            packet[1] = struct.pack('<i', current_message_count)
+            time.sleep(self._PAYLOAD_TRANSFER_DELAY)
+
             # Convert the list packet to a bytearray
             payload = b''.join(packet)
 
@@ -403,4 +257,4 @@
             # If there is no content...
             if received_message is None:
                 self.logger.debug("Timeout!!!!")
-                return False
\ No newline at end of file
+                return False
Index: dialin/dg/system_record.py
===================================================================
diff -u -re36d87e663d95c79214f66b5db9aa6d6e8b47adf -ra3be707a0f11b8f01ff32199b60b6162238b6e64
--- dialin/dg/system_record.py	(.../system_record.py)	(revision e36d87e663d95c79214f66b5db9aa6d6e8b47adf)
+++ dialin/dg/system_record.py	(.../system_record.py)	(revision a3be707a0f11b8f01ff32199b60b6162238b6e64)
@@ -203,7 +203,7 @@
                                                                                raw_payload_temp_start_index +
                                                                                value_bytes])[0]
                             data += raw.decode("utf-8")
-                            #self.DG_SERVICE_RECORD[group][key][self.SERVICE_VALUE_INDEX][current_value.index(vl)] = data
+                            #self.DG_SERVICE_RECORD[group][key][self._DATA_VALUE_INDEX][current_value.index(vl)] = data
                             raw_payload_temp_start_index += value_bytes
                     else:
                         # Unpack the values to written to the dictionary
Index: dialin/utils/utils.py
===================================================================
diff -u
--- dialin/utils/utils.py	(revision 0)
+++ dialin/utils/utils.py	(revision a3be707a0f11b8f01ff32199b60b6162238b6e64)
@@ -0,0 +1,215 @@
+
+import struct
+import time
+import math
+from ..ui.crc import crc_16
+
+
+class Utils:
+
+    _RECORD_START_INDEX = 6
+    _RECORD_SPECS_BYTES = 12
+    _RECORD_SPECS_BYTE_ARRAY = 3
+
+    DEFAULT_MFG_DATE = 0
+    DEFAULT_SERVICE_DATE_VALUE = 0
+    DEFAULT_SERVICE_CRC_VALUE = 0
+    DEFAULT_SYS_PADDING_VALUE = 0
+
+    CURRENT_MESSAGE_NUM_INDEX = 0
+    TOTAL_MESSAGES_NUM_INDEX = 4
+    PAYLOAD_LENGTH_INDEX = 8
+    PAYLOAD_START_INDEX = 12
+
+    _DATA_TYPE_INDEX = 0
+    _DATA_VALUE_INDEX = 1
+
+    _TARGET_BYTES_TO_SEND_TO_FW = 150
+    _MIN_PAYLOAD_BYTES_SPACE = 4
+
+    _PAYLOAD_CURRENT_MSG_INDEX = 0
+    _PAYLOAD_TOTAL_MSG_INDEX = 1
+    _PAYLOAD_TOTAL_BYTES_INDEX = 2
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def process_records_received_from_fw(records_dict, fw_records_bytes):
+        pass
+
+    def prepare_record_to_send_to_fw(self, dialin_record):
+
+        # This list contains different data packet lists
+        # i.e. [[message 1, payload], [message 2, payload], ...]
+        record_packets = []
+        current_payload_length = 0
+        current_message_count = 1
+        temp_buffer = [0, 0, 0]
+
+        # Loop through the DG calibration dictionary
+        for group in dialin_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]
+
+                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]))
+                record_packets.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:
+                    # Get the data type and calculate the number of bytes
+                    data_type = dialin_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 self._TARGET_BYTES_TO_SEND_TO_FW - current_payload_length > self._MIN_PAYLOAD_BYTES_SPACE:
+                            current_payload_length += data_type_bytes
+                            temp_buffer[self._PAYLOAD_TOTAL_MSG_INDEX] = struct.pack('<i', 0)
+                            temp_buffer.append(struct.pack(data_type, pad))
+                        else:
+                            temp_buffer[self._PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
+                            temp_buffer[self._PAYLOAD_TOTAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                            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, pad)]
+            else:
+                for key in dialin_record[group].keys():
+
+                    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]
+
+                    # 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:
+                        current_payload_length += data_type_bytes
+                        # Insert a 4-byte 0 to the index of the total messages. This is a place holder and it will
+                        # be updated with the right value later.
+                        temp_buffer[self._PAYLOAD_TOTAL_MSG_INDEX] = struct.pack('<i', 0)
+
+                        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)
+                    else:
+                        # There is not enough space left in this temp buffer. Update the current message count and
+                        # the total number of bytes that were packed in this data packet.
+                        temp_buffer[self._PAYLOAD_CURRENT_MSG_INDEX] = struct.pack('<i', current_message_count)
+                        temp_buffer[self._PAYLOAD_TOTAL_BYTES_INDEX] = struct.pack('<i', current_payload_length)
+                        # Append the temp buffer list into the main list to be process later
+                        record_packets.append(temp_buffer)
+                        # Increment the current message count as a new temp buffer is created for the next data
+                        # packet. Update the current payload length with the latest addition to the new temp buffer.
+                        current_message_count += 1
+                        current_payload_length = data_type_bytes
+                        # Create a new temp buffer and add the current message count, total length of payload so far
+                        # and the data that there was not enough space in the previous data packet.
+                        temp_buffer = [struct.pack('<i', current_message_count), struct.pack('<i', 0),
+                                       struct.pack('<i', current_payload_length),
+                                       struct.pack(data_type, current_value)]
+
+        # Creating a byte array variable and add all the data packets
+        # to one to calculate the final CRC
+        data = b''
+        for svc in record_packets:
+            # If the data packet is the last one in the list, ignore the last element of the
+            # packet since it is the final CRC of the entire dictionary. The final CRC itself
+            # is not included in the CRC calculations.
+            # The actual calibration data is started from the 3rd element of the data packet.
+            # The first 3 are current message, total messages, and the payload length of the current packet.
+            if record_packets.index(svc) == len(record_packets) - 1:
+                data += b''.join(svc[self._RECORD_SPECS_BYTE_ARRAY:-1])
+            else:
+                # Get all the elements including the last one
+                data += b''.join(svc[self._RECORD_SPECS_BYTE_ARRAY:])
+
+        # Calculate the 16-bit crc.
+        crc = crc_16(data)
+        # Convert the crc into a 2-byte value
+        record_crc = struct.pack('<H', crc)
+        # Insert the CRC into the last element of the last data packet
+        record_packets[-1][-1] = record_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 record_packets:
+
+            # 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)
+
+        return record_packets
+
+    def calculate_group_byte_size(self, group):
+        """
+        Handles calculating the byte size of the values of the provided dictionary.
+
+        @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][self._DATA_TYPE_INDEX]
+            current_byte_size = self.get_data_type_bytes(data_type)
+            byte_size += current_byte_size
+
+        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.
+        This is a static method.
+
+        @param data: the data to be converted to bytes in number
+        @return: calculated byte size
+        """
+        number_of_bytes = 0
+        # Unsigned integer = i
+        # Signed integer = I
+        # Float = f. All 4 bytes.
+        if data == '<i' or data == '<f':
+            number_of_bytes = 4
+        # Unsigned short = H. 2 bytes.
+        elif data == '<H':
+            number_of_bytes = 2
+        # Unsigned char = B. 1 byte.
+        elif data == '<B' or data == '<c':
+            number_of_bytes = 1
+
+        return number_of_bytes
+
+    @staticmethod
+    def calculate_padding_byte_size(total_byte_size, max_buffer_size):
+        """
+        Handles calculating the padding length based on the provided buffer sizes
+
+        @param total_byte_size: total byte size of a record dictionary
+        @param max_buffer_size: max buffer size that is allowed to be used in the dictionary
+
+        @return: padding size in bytes
+        """
+
+        # Calculate the padding size:
+        # If bytes in the dictionary % max write bytes to RTC RAM (64) or EEPROM (16) is 0, not padding is needed
+        # Else padding = (ceil(dictionary bytes/max write) * max write)-dictionary bytes
+        if (total_byte_size % max_buffer_size) == 0:
+            padding_size = 0
+        else:
+            padding_size = (math.ceil(total_byte_size / max_buffer_size) * max_buffer_size) - total_byte_size
+
+        return padding_size
\ No newline at end of file
Index: tests/test_dg_service_record.py
===================================================================
diff -u -r43e8345862c72340680c045e53b310aa291513a6 -ra3be707a0f11b8f01ff32199b60b6162238b6e64
--- tests/test_dg_service_record.py	(.../test_dg_service_record.py)	(revision 43e8345862c72340680c045e53b310aa291513a6)
+++ tests/test_dg_service_record.py	(.../test_dg_service_record.py)	(revision a3be707a0f11b8f01ff32199b60b6162238b6e64)
@@ -13,9 +13,9 @@
 
     srvc = dg.service_record
 
-    srvc.DG_SERVICE_RECORD['service_record']['crc'][1] = 51236
-    print((srvc.DG_SERVICE_RECORD))
-    #print(len(sys.DG_SERVICE_RECORD['system_record']['top_level_pn'][1]))
+    srvc.dg_service_record['service_record']['crc'][1] = 718
+    print((srvc.dg_service_record))
+    #print(len(sys.dg_service_record['system_record']['top_level_pn'][1]))
 
     #srvc.get_dg_service_record()
 
@@ -24,9 +24,9 @@
     #    if srvc.current_message == srvc.total_messages:
     #        break
 
-    #print(srvc.DG_SERVICE_RECORD)
-    #print((sys.DG_SERVICE_RECORD['system_record']['top_level_pn'][1]))
+    #print(srvc.dg_service_record)
+    #print((sys.dg_service_record['system_record']['top_level_pn'][1]))
 
     srvc.set_dg_service_data()
 
-    #print(cal.DG_SERVICE_RECORD['system_record']['top_level_sn'][1])
\ No newline at end of file
+    #print(cal.dg_service_record['system_record']['top_level_sn'][1])
\ No newline at end of file