def save_curr_data(self):
""""
adds self.curr_data to self.data_arr with a timestamp
if it is not heartbeat
creates a memory_error and adds it self.mem_errors
if self.curr_data.msg_code == 'ECC_CHECKED'
clears self.curr_data
"""
curr_time = str(Time.get_curr_time())
self.curr_data.time = curr_time
self.curr_data.extract_data_payload()
#add end index
self.curr_data.data_payload += GlobalConstants.END_CODE
self.curr_data.complete_data += GlobalConstants.END_CODE
self.classify_data()
print(str(curr_time) + ' saving data: ' + self.curr_data.complete_data)
self.curr_data.payload_len = len(self.curr_data.data_payload)
self.data_cnt += 1
self.prev_data = self.curr_data
self.curr_data = Data()
def __init__(self):
self.prev_data = None
self.data_arr = []
self.mem_error_storage = MemErrorStorage()
self.reset_storage = ResetStorage()
self.curr_data = Data()
self.last_heartbeat = None
self.data_cnt = 0
class DataStorage:
def __init__(self):
self.prev_data = None
self.data_arr = []
self.mem_error_storage = MemErrorStorage()
self.reset_storage = ResetStorage()
self.curr_data = Data()
self.last_heartbeat = None
self.data_cnt = 0
def save_curr_data(self):
""""
adds self.curr_data to self.data_arr with a timestamp
if it is not heartbeat
creates a memory_error and adds it self.mem_errors
if self.curr_data.msg_code == 'ECC_CHECKED'
clears self.curr_data
"""
curr_time = str(Time.get_curr_time())
self.curr_data.time = curr_time
self.curr_data.extract_data_payload()
#add end index
self.curr_data.data_payload += GlobalConstants.END_CODE
self.curr_data.complete_data += GlobalConstants.END_CODE
self.classify_data()
print(str(curr_time) + ' saving data: ' + self.curr_data.complete_data)
self.curr_data.payload_len = len(self.curr_data.data_payload)
self.data_cnt += 1
self.prev_data = self.curr_data
self.curr_data = Data()
def classify_data(self):
data_type = self.curr_data.purpose
if not data_type == 'HEARTBEAT':
self.data_arr.append(self.curr_data)
if data_type == 'ECC_CHECKED':
self.mem_error_storage.add(self.curr_data.data_payload_value)
elif data_type == 'RESET_RESPONSE':
payload_int = Calculator.get_int(self.curr_data.data_payload_value)
reset_purpose = GlobalConstants.RESET_PURPOSES[payload_int]
reset_packet = ResetData(reset_purpose)
self.reset_storage.add(reset_packet)
def reset_curr_data(self):
self.prev_data = Data()
self.curr_data = Data()
def get_data(self, id):
for data in self.data_arr:
if data.data_index == id:
return data
return None
def test_extract_data_counter(self):
header = 'aa' \
'0019' \
'00000001' \
'00000000' \
'00'
data = Data()
data.extract_data_counter(header)
self.assertEqual('00000001', data.data_index_hex)
self.assertEqual(1, data.data_index)
def test_extract_packet_length(self):
header = 'aa' \
'0019' \
'00000000' \
'00000000' \
'00'
data = Data()
data.extract_packet_length(header)
self.assertEqual('0019', data.packet_len)
self.assertEqual(50, data.len_of_hex)
def check_heartbeat(self, curr_data_item: Data):
"""
if current data is HEARTBEAT_RESPONSE, extracts HEARTBEAT_ID
and notifies observers
:param curr_data_item:
"""
HEARTBEAT_RESPONSE_CODE = GlobalConstants.MESSAGE_CODE_DICT[
'HEARTBEAT_RESPONSE']
if curr_data_item.msg_code == HEARTBEAT_RESPONSE_CODE:
curr_data_item.extract_data_payload()
heartbeat = curr_data_item.data_payload_value
heartbeat = Calculator.get_int(heartbeat)
self.heartbeat_received_id = heartbeat
self.notify()
def analyse_data(self):
data = ''
expected_data_len = GlobalConstants.HEX_DIGITS_PER_BYTE * GlobalConstants.MAX_PACKET_LEN + 1
data_len_hex = ''
while True:
if not self.serial_port: continue
new_data = self.read_data_queue.get()
if new_data:
if self.new_data_to_read:
if new_data == GlobalConstants.START_CODE:
data += new_data
self.new_data_to_read = False
else:
if len(data) < expected_data_len:
data += new_data
# extract
if GlobalConstants.PACKET_LEN_START_INDEX <= len(
data) <= GlobalConstants.PACKET_LEN_END_INDEX:
data_len_hex += new_data
if len(data) == GlobalConstants.DATA_COUNTER_END_INDEX:
expected_data_len = Calculator.get_int(
data_len_hex
) * GlobalConstants.HEX_DIGITS_PER_BYTE
if len(data) == expected_data_len:
data_packet = Data(data)
self.analyse_data_purpose(data_packet)
# clear data
self.new_data_to_read = True
data = ''
expected_data_len = GlobalConstants.HEX_DIGITS_PER_BYTE * GlobalConstants.MAX_PACKET_LEN + 1
data_len_hex = ''
def test_check_data_index(self):
header = 'aa' \
'0019' \
'00000000' \
'00000000' \
'01'
unordered_payload = '000066660002333300033333'
data = Data()
data.add_header_info(header)
data.data_payload = unordered_payload
data_processing_thread = DataProcessingThread(Queue())
self.assertFalse(data_processing_thread.analyse_data_payload(data))
unordered_payload = '000066660000333300033333'
data.data_payload = unordered_payload
self.assertFalse(data_processing_thread.analyse_data_payload(data))
ordered_payload = '000066660001333300023333'
data.data_payload = ordered_payload
self.assertTrue(data_processing_thread.analyse_data_payload(data))
def test_extract_message_code(self):
header = 'aa' \
'0019' \
'00000000' \
'00000000' \
'00'
data = Data()
data.extract_message_code(header)
self.assertEqual(
GlobalConstants.MESSAGE_CODE_DICT['HEARTBEAT_REQUEST'],
data.msg_code)
header = 'aa' \
'0019' \
'00000000' \
'00000000' \
'01'
data.extract_message_code(header)
self.assertEqual(
GlobalConstants.MESSAGE_CODE_DICT['HEARTBEAT_RESPONSE'],
data.msg_code)
header = 'aa' \
'0019' \
'00000000' \
'00000000' \
'02'
data.extract_message_code(header)
self.assertEqual(GlobalConstants.MESSAGE_CODE_DICT['RESET_REQUEST'],
data.msg_code)
header = 'aa' \
'0019' \
'00000000' \
'00000000' \
'03'
data.extract_message_code(header)
self.assertEqual(GlobalConstants.MESSAGE_CODE_DICT['RESET_RESPONSE'],
data.msg_code)
header = 'aa' \
'0019' \
'00000000' \
'00000000' \
'04'
data.extract_message_code(header)
self.assertEqual(GlobalConstants.MESSAGE_CODE_DICT['ECC_CHECKED'],
data.msg_code)
header = 'aa' \
'0019' \
'00000000' \
'00000000' \
'05'
data.extract_message_code(header)
self.assertEqual(
GlobalConstants.MESSAGE_CODE_DICT['ECC_PERIOD_CHANGE'],
data.msg_code)
def reset_curr_data(self):
self.prev_data = Data()
self.curr_data = Data()
def analyse_data_purpose(self, data_packet: Data):
data_packet.extract_data_payload()
data_payload = data_packet.data_payload_value
if data_packet.purpose == 'HEARTBEAT_REQUEST':
heartbeat = self.analyse_heartbeat(data_payload)
self.send_data_stream(heartbeat)