def __init__(self, type, packet: str, extra_data=''):
if type in GlobalConstants.COM_ERROR_TYPES:
self.type = type
self.time = Time.get_curr_time_ns()
self.time_hour = Time.get_curr_time()
self.packet = packet
self.extra_data = extra_data
def send_data_packet(self, data: bytearray):
if not self.com_interface.is_connected():
return False
data_str = Calculator.get_hex_str(data)
curr_time = Time.get_curr_time()
print(str(curr_time) + ' sent data: ' + data_str)
DataPacketFactory.adjust_data_cnt(data, self.sent_counter)
self.com_interface.send_data(data)
self.last_sent_time = Time.get_curr_time_ns()
if self.sent_counter >= GlobalConstants.DATA_INDEX_MAX:
self.sent_counter = 0
else:
self.sent_counter += 1
return True
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 log_end(self, packets_received):
"""
to be called at the end of the test
logs an end message with end timestamp and total number of packets received
:param packets_received: total number of all packets received
"""
curr_time = Time.get_curr_time()
self.logger.log('\nTest ended at: ' + str(curr_time))
self.logger.log(', packets received: ' + str(packets_received))
def log_error(self, error: ComError, err_cnt, packets_received_num=1):
err_percent = ComErrorLogger.get_error_percentage(
err_cnt, packets_received_num)
msg = '\n' + str(err_cnt) + '. ' + error.type
msg += ' for ' + error.packet + '\n'
msg += 'STATS: time: ' + str(Time.get_curr_time())
msg += ', error percentage: ' + str(err_percent) + '*10^(-3)%,\n'
freq = self.get_error_frequency(err_cnt, error.time)
msg += 'error frequency: ' + freq
msg += error.extra_data
self.logger.log(msg)
def update(self, subject: Subject) -> None:
"""
:param subject: in this case DataProcessingThread class
"""
heartbeat_received = subject.heartbeat_received_id
if heartbeat_received != '' and heartbeat_received == self.last_heartbeat_sent_id:
self.heartbeat_received = True
curr_time = Time.get_curr_time()
print(
str(curr_time) + ' heartbeats matching, heartbeat received: ' +
str(heartbeat_received))
def __init__(self, data: str, index: int):
self.data = data
self.faulty_addresses = []
self.time = Time.get_curr_time()
self.mem_error_id = 0
self.error_num = 0
self.overflow = False
self.index = index
self.extract_mem_error_id()
self.extract_err_cnt()
self.check_overflow()
self.extract_addresses()
def __init__(self):
self.logger = Logger(self.FILE_NAME)
self.start = Time.get_curr_time_ns()
self.logger.log(' COMMUNICATION ERRORS:\n')
def __init__(self, type: str):
reset_purposes = list(GlobalConstants.RESET_PURPOSES.values())
if type in reset_purposes:
self.type = type
self.time_hour = Time.get_curr_time()
def log(self, reset: ResetData, cnt: int):
msg = '\n[' + str(cnt) + '] '
msg += 'RESET PURPOSE: ' + reset.type + '\n'
msg += 'STATS: time: ' + str(Time.get_curr_time())
self.logger.log(msg)
def has_timeout_passed(self):
cur_time = Time.get_curr_time_ns()
time_passed = cur_time - self.last_sent_time
if time_passed < (self.timeout * self.NANOSECONDS_PER_MILI_SECOND):
return False
return True
def __init__(self):
#self.start = self.get_curr_time()
self.logger = Logger(self.FILE_NAME)
self.start = Time.get_curr_time_ns()
self.logger.log('MEMORY ERRORS:\n')
def log_start(self):
date = str(Time.get_curr_time())
self.f_manager.file_write("\nStarted at: " + date)