You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
433 lines
11 KiB
433 lines
11 KiB
import os,sys,time
|
|
import cli
|
|
from conf import *
|
|
from skyeye_common_module import *
|
|
import se_system as ss
|
|
import threading
|
|
from fuzzywuzzy import fuzz
|
|
import fault_inject as fi
|
|
import se_func as sf
|
|
import skyeye_autotest_command as sac
|
|
import pytimer
|
|
import skyeye_common_module as scm
|
|
|
|
|
|
MO_READ = 1
|
|
MO_WRITE = 2
|
|
|
|
OP_CHAR_TYPE = 1
|
|
OP_SHORT_TYPE = 2
|
|
OP_WORD_TYPE = 4
|
|
OP_DWORD_TYPE = 8
|
|
|
|
TY_INT = "int"
|
|
TY_FLOAT = "float"
|
|
TY_DOUBLE = "double"
|
|
|
|
def SE_define_conf(filename):
|
|
try:
|
|
Config = json_conf(parent = None, filename = filename)
|
|
if Config.get_init_result() == False:
|
|
print ("load_config error")
|
|
return False
|
|
Config.instance()
|
|
SetGlobalConfig(Config)
|
|
define_json_file[0] = os.path.join(os.getcwd(), filename)
|
|
except:
|
|
print ("load_config error")
|
|
return False
|
|
|
|
def SE_load_binary(cpuname,filename):
|
|
if os.path.isfile(filename)==False:
|
|
print ("No such binary file")
|
|
return False
|
|
if SkyEyeLoadBinary(cpuname,filename)!=1:
|
|
print ("load_binary error")
|
|
return False
|
|
binary_l[cpuname] = os.path.join(os.getcwd(), filename)
|
|
|
|
def SE_init_ok():
|
|
SkyEyePrepareToRun()
|
|
if ss.system ==None:
|
|
ss.CreateClass()
|
|
|
|
def SE_run_script(filename):
|
|
fullfilename = os.path.realpath(filename)
|
|
if not os.path.exists(fullfilename):
|
|
print ("%s file does not exists!" % fullfilename)
|
|
return False
|
|
fp = open(fullfilename,'r')
|
|
lines = fp.readlines()
|
|
fp.close()
|
|
cmd = cli.GetCommand("run-command")
|
|
if cmd == None:
|
|
SE_print("Can not find command: run-command")
|
|
return False
|
|
for line in lines:
|
|
line = line.strip(' \n')
|
|
if line == "" or line[0] == '#' or "run-pyfile" in line:
|
|
continue
|
|
try:
|
|
ret=cmd.run(line)
|
|
except Exception as e:
|
|
SE_print(e)
|
|
return False
|
|
return True
|
|
|
|
def SE_run():
|
|
SkyEyeRun()
|
|
|
|
def SE_stop():
|
|
SkyEyeStop()
|
|
|
|
def SE_stop_autotest():
|
|
if sac.ac != None:
|
|
sac.ac.autotest_run = False
|
|
|
|
def SE_reset():
|
|
SkyEyeReset()
|
|
|
|
def SE_restart():
|
|
SE_reset()
|
|
SE_define_conf(define_json_file[0])
|
|
for binary in binary_l.keys():
|
|
SE_load_binary(binary,os.path.normpath(binary_l[binary]))
|
|
SE_init_ok()
|
|
|
|
def SE_running_status():
|
|
return SkyEyeRunningStatus()
|
|
|
|
def SE_pre_conf_obj(classname, objname):
|
|
SkyEyePreConfObj(objname,classname)
|
|
obj = ss.SkyEyeBaseClass(objname,classname,None)
|
|
return obj
|
|
|
|
def SE_sleep(s):
|
|
time.sleep(s)
|
|
|
|
log=None
|
|
|
|
def SE_print(data):
|
|
global log
|
|
if log == None:
|
|
return
|
|
r_obj=ss.__redirection__()
|
|
r_obj.set_out()
|
|
print (data)
|
|
r_obj.reset()
|
|
log.WriteText(r_obj.buff)
|
|
|
|
def SE_compare(actual_out,expect_out,accuracy):
|
|
sj_output=actual_out
|
|
try:
|
|
fp1=open(sj_output,'r')
|
|
except:
|
|
SE_print('The actual output file was not found')
|
|
return
|
|
actual=fp1.read()
|
|
fp1.close()
|
|
rmlist=['\t','\r',' ','\n']
|
|
for i in rmlist:
|
|
actual=actual.replace(i,'')
|
|
expect_out=expect_out.replace(i,'')
|
|
if len(actual)==0:
|
|
SE_print('The actual output file is empty')
|
|
return
|
|
if len(expect_out)==0:
|
|
SE_print('The desired output is empty')
|
|
return
|
|
accuracy_list=[]
|
|
accuracy_list.append(fuzz.ratio(actual,expect_out))
|
|
accuracy_list.append(fuzz.partial_ratio(actual,expect_out))
|
|
if accuracy!=100:
|
|
accuracy_list.append(fuzz.token_set_ratio(actual,expect_out))
|
|
max_accuracy = max(accuracy_list)
|
|
if max_accuracy >= accuracy:
|
|
SE_print("Proofreading success")
|
|
return True
|
|
else:
|
|
SE_print('Check failure. expect accuracy: %d%% max actual accuracy: %d%%'%(accuracy,max_accuracy))
|
|
return False
|
|
|
|
def SE_set_fault_inject(machname,addr,bit,mode):
|
|
return fi.skyeye_set_fj_by_aadr(machname,addr,bit,mode)
|
|
|
|
def SE_get_fault_inject():
|
|
return fi.skyeye_get_fj()
|
|
|
|
def SE_clear_fault_injece(machname,addr,bit,mode):
|
|
return fi.skyeye_clear_fj_by_addr(machname,addr,bit,mode)
|
|
|
|
def SE_set_register_value(machname,addr,value):
|
|
return sf.set_reg_value_by_addr(machname,addr,value)
|
|
|
|
def SE_get_register_value(machname,addr):
|
|
return sf.get_reg_value_by_addr(machname,addr)
|
|
|
|
def SE_get_simulation_time(cpuname):
|
|
return SkyEyeGetSimulationRunTime(cpuname)
|
|
|
|
def SE_enable_parse_symbol(cpuname,binary):
|
|
cmd = cli.GetCommand("parse-symbol")
|
|
if cmd == None:
|
|
SE_print("Can not find command: parse-symbol")
|
|
return False
|
|
try:
|
|
ret=cmd.run([cpuname,binary])
|
|
except Exception as e:
|
|
SE_print(e)
|
|
return False
|
|
return ret
|
|
|
|
def SE_get_global_variable_addr(cpuname,varname):
|
|
return SkyEyeGetSymbolAddr(cpuname,varname)
|
|
|
|
def SE_get_global_variable_value(cpuname,varname,value_bytes_number,value_type):
|
|
if value_type == TY_INT:
|
|
return SkyEyeGetSymbolValue(cpuname,varname,value_bytes_number)
|
|
elif value_type == TY_FLOAT:
|
|
return SkyEyeGetFloatSymbolValue(cpuname,varname,value_bytes_number)
|
|
elif value_type == TY_DOUBLE:
|
|
return SkyEyeGetDoubleSymbolValue(cpuname,varname,value_bytes_number)
|
|
else:
|
|
pass
|
|
|
|
|
|
|
|
|
|
def SE_set_global_variable_value(cpuname,varname,value,value_bytes_number,value_type):
|
|
if value_type == TY_INT:
|
|
return SkyEyeSetSymbolValue(cpuname,varname,value,value_bytes_number)
|
|
elif value_type == TY_FLOAT:
|
|
return SkyEyeSetFloatSymbolValue(cpuname,varname,value,value_bytes_number)
|
|
elif value_type == TY_DOUBLE:
|
|
return SkyEyeSetDoubleSymbolValue(cpuname,varname,value,value_bytes_number)
|
|
else:
|
|
pass
|
|
|
|
def SE_log_output(filename,content):
|
|
now_time = time.strftime('%m%d%H%M%S',time.localtime(time.time()))
|
|
new_filename = filename+"_"+now_time+".txt"
|
|
try:
|
|
fp = open(new_filename,"w")
|
|
fp.write(content)
|
|
fp.close()
|
|
except:
|
|
print ("Write file failed")
|
|
|
|
def SE_out_error_log(log):
|
|
if sac.ac != None:
|
|
sac.ac.error_test.append([sac.ac.error_reset(sac.ac.test_info),log])
|
|
|
|
def SE_run_to_time(cpuname,time_s):
|
|
sf.run_to_time(cpuname,time_s)
|
|
|
|
def SE_create_breakpoint(cpuname,addr):
|
|
try:
|
|
SkyEyeCreateBreakpoint(cpuname,addr)
|
|
except Exception as e:
|
|
SE_print(e)
|
|
|
|
def SE_get_current_pc(cpuname):
|
|
try:
|
|
return SkyEyeGetPcByCoreName(cpuname)
|
|
except Exception as e:
|
|
SE_print(e)
|
|
|
|
def SE_get_cpu_freq(cpuname):
|
|
try:
|
|
return SkyEyeGetCpuFreq(cpuname)
|
|
except Exception as e:
|
|
SE_print(e)
|
|
|
|
def SE_read_byte(cpuname,addr):
|
|
try:
|
|
return SkyEyeReadByte(cpuname,addr)
|
|
except Exception as e:
|
|
SE_print(e)
|
|
|
|
def SE_read_dword(cpuname,addr):
|
|
try:
|
|
return SkyEyeReadDWord(cpuname,addr)
|
|
except Exception as e:
|
|
SE_print(e)
|
|
def SE_write_byte(cpuname,addr,value):
|
|
try:
|
|
return SkyEyeWriteByte(cpuname,addr,value)
|
|
except Exception as e:
|
|
SE_print(e)
|
|
|
|
def SE_write_dword(cpuname,addr,value):
|
|
try:
|
|
return SkyEyeWriteDWord(cpuname,addr,value)
|
|
except Exception as e:
|
|
SE_print(e)
|
|
|
|
def SE_sync_callback(cpuname,my_callback,argument):
|
|
return pytimer.PyTmrCreate(cpuname,0,pytimer.TMR_ONE_SHOT,my_callback, argument)
|
|
|
|
def SE_create_timer(cpuname,time_ms,my_callback,argument):
|
|
return pytimer.PyTmrCreate(cpuname,time_ms,pytimer.TMR_ONE_SHOT,my_callback, argument)
|
|
|
|
def SE_delete_timer(tmr):
|
|
try:
|
|
return pytimer.PyTmrDelete(tmr)
|
|
except:
|
|
return False
|
|
|
|
def SE_set_watch_on_pc(cpuname,pc_addr,my_callback,argument):
|
|
return pytimer.PySetWatchOnPc(cpuname,pc_addr,my_callback,argument)
|
|
|
|
def SE_del_watch_on_pc(watch):
|
|
try:
|
|
return pytimer.PyUnWatchOnPc(watch)
|
|
except:
|
|
return False
|
|
|
|
def SE_set_watch_on_mem(ms_name,mm_type,addr,data_type,length,my_callback,argument):
|
|
return pytimer.PySetWatchOnMem(ms_name,mm_type,addr,data_type,length,my_callback,argument)
|
|
|
|
def SE_del_watch_on_mem(watch):
|
|
try:
|
|
return pytimer.PyUnWatchOnMem(watch)
|
|
except:
|
|
return False
|
|
|
|
def SE_get_func_addr(cpuname,funcname):
|
|
try:
|
|
return SkyEyeGetFuncAddr(cpuname,funcname)
|
|
except Exception as e:
|
|
SE_print(e)
|
|
|
|
def SE_get_func_length(cpuname,funcname):
|
|
try:
|
|
return SkyEyeGetFuncLength(cpuname,funcname)
|
|
except Exception as e:
|
|
SE_print(e)
|
|
|
|
def SE_load_file(memoryname, filename, pc_addr):
|
|
if os.path.isfile(filename)==False:
|
|
print ("No such binary file")
|
|
return False
|
|
if SkyEyeNewLoadFile(memoryname, filename, pc_addr) != 1:
|
|
print ("load_file error")
|
|
return False
|
|
|
|
def SE_cpu_load_file(cpuname, filename, pc_addr):
|
|
if os.path.isfile(filename)==False:
|
|
print ("No such binary file")
|
|
return False
|
|
if SkyEyeLoadFile(cpuname, filename, pc_addr) != 1:
|
|
print ("load_file error")
|
|
return False
|
|
|
|
def SE_term_wait_for_string(termname, string):
|
|
return SkyEyeTermWaitForString(termname, string)
|
|
|
|
def SE_term_write(termname, string):
|
|
return SkyEyeTermWrite(termname, string)
|
|
|
|
def SE_term_wait_then_write(termname, wait_string, write_string):
|
|
return SkyEyeTermWaitThenWrite(termname, wait_string, write_string)
|
|
|
|
def SE_get_device_register_list(machname, devicename):
|
|
regs = []
|
|
RegNum = SkyEyeGetDevRegNum(machname,devicename)
|
|
for regid in range(0,RegNum):
|
|
regs.append(SkyEyeGetDevRegNameById(machname,devicename,regid))
|
|
return regs
|
|
|
|
def SE_Device_skyEyeGetDevRegNum(machname,devicename):
|
|
return SkyEyeGetDevRegNum(machname,devicename)
|
|
|
|
def SE_SkyEyeGetModules():
|
|
return SkyEyeGetModules()
|
|
|
|
def SE_get_regs(machname,devname):
|
|
return fi.get_device_register_info(machname,devname)
|
|
|
|
def SE_get_registers(devicename):
|
|
reg_list = []
|
|
reg_list1=[]
|
|
reg_attr_dic1 = {}
|
|
try:
|
|
num = scm.SkyEyeGetDevRegNum(None, devicename)
|
|
except:
|
|
return None
|
|
for i in range(0, num):
|
|
try:
|
|
name = scm.SkyEyeGetDevRegNameById(None, devicename, i)
|
|
if name == None:
|
|
continue
|
|
except:
|
|
return None
|
|
try:
|
|
value = scm.SkyEyeGetDevRegValueById(None, devicename, i)
|
|
except:
|
|
return None
|
|
try:
|
|
offset = scm.SkyEyeGetDevRegOffsetById(None, devicename, i)
|
|
except:
|
|
return None
|
|
if offset == 0xffffffff:
|
|
offset = i * 4
|
|
|
|
reg_attr_dic={}
|
|
|
|
reg_attr_dic["offset"] = offset
|
|
reg_attr_dic["size"] = 4
|
|
reg_attr_dic["value"] = value
|
|
reg_attr_dic["name"] = name
|
|
reg_list.append(reg_attr_dic)
|
|
|
|
reg_attr_dic1[devicename] = reg_list
|
|
# reg_list1.append(reg_attr_dic1)
|
|
return reg_attr_dic1
|
|
|
|
def SE_ReadDevice4(device, offset):
|
|
return SkyEyeReadDevice4(device, offset)
|
|
|
|
def SE_WriteDevice4(device, offset,data):
|
|
return SkyEyeWriteDevice4(device, offset,data)
|
|
|
|
def SE_Test_regs_read_wirte(test_num,device,reg_name, offset,alter_value,expect):
|
|
alter_value=int(alter_value)
|
|
init_vaule= SkyEyeReadDWord(device,offset)
|
|
a=SE_write_dword(device, offset,alter_value)
|
|
actual_value = SkyEyeReadDWord(device,offset)
|
|
if actual_value == expect:
|
|
result = "true"
|
|
else:
|
|
result = "false"
|
|
return [test_num,device,reg_name,hex(eval(str(offset))),hex(eval(str(init_vaule))),hex(eval(str(alter_value))),hex(eval(str(expect))),hex(eval(str(actual_value))),result]
|
|
|
|
def SE_get_simulation_device_info():
|
|
result='false'
|
|
error=None
|
|
device_info={}
|
|
config = GetGlobalConfig()
|
|
if config!=None:
|
|
mach_list=config.get_mach_list()
|
|
for machname in mach_list:
|
|
device_info[machname]={}
|
|
device_list = config.get_device_list_by_mach(machname)
|
|
dev_list=[]
|
|
if device_list != None:
|
|
for device in device_list:
|
|
cls = config.get_device_classname(machname, device)
|
|
base=SkyEyeGetClassType(cls)
|
|
if "image" in cls or "memory_space" in cls or "ram" in cls or "_core" in cls:
|
|
pass
|
|
else:
|
|
dev_list.append(device)
|
|
device_info[machname]=dev_list
|
|
result=device_info
|
|
device_list=[]
|
|
for j,k in result.items():
|
|
device_list.extend(k)
|
|
else:
|
|
error="The config is None"
|
|
return device_list
|
|
|
|
def SE_Quit():
|
|
SkyEyeQuit()
|