def i2c_crol_handle(params):
if i2c_bus_list is None:
get_i2c_bus_list()
help_info = "i2c crol(<bus_name>,<state>)$\r\n\
\tbus_name=("+",".join(i2c_bus_list) +")$\r\n\
\tstate=(0,1)$\r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parameters analysis '''
base_param_index = 0
params_count = len(params)
for index in range(base_param_index, params_count):
if index == base_param_index + 0:
bus_name = params[index]
if bus_name not in i2c_bus_list:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s bus_name error"%index)
elif index == base_param_index + 1:
state = int(params[index])
if state not in [0,1]:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s state error"%index)
else:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"error ,params should less than %s "%index)
#doing
result = Xavier.call("i2c_crol",bus_name, state)
if result is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],"execute error")
return Utility.handle_done()
def programmer_abort_handle(params):
help_info = "programmer abort(<channel>)$\r\n\
\tchannel:" + str(
json.dumps(
list(_g_fwdl_config_list['support_channel'].keys()))).replace(
'"', '') + "$\r\n"
base_param_index = 0
''' help '''
if utility.is_ask_for_help(params) is True:
return utility.handle_done(help_info)
param_count = len(params)
if param_count > 1:
return utility.handle_error(
utility.handle_errorno['handle_errno_parameter_invalid'].value,
"param length error")
for index in range(base_param_index, param_count):
if index == base_param_index:
regular_expression = re.match(r'ch(\w+)', params[index])
if regular_expression is None:
return utility.handle_error(
utility.handle_errorno['handle_errno_parameter_invalid'],
"param error")
channel = int(regular_expression.group(1), 10) - 1
if (channel > 3 or channel < 0):
return utility.handle_error(
utility.handle_errorno['handle_errno_parameter_invalid'],
"param error")
abord_process_cmd = fwdl_executing_main_file + str(channel + 1)
os.system("killall -9 " + abord_process_cmd)
return utility.handle_done()
def frequency_measure_handle(params):
help_info = "frequency measure(<vref>,<measure_time>)\r\n\
\tvref: () mV, float data $\r\n\
\tmeasure_time: ()ms, float data $\r\n\
"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parameters analysis '''
params_count = len(params)
if params_count != 2:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
vref = float(params[0])
time = int(params[1])
vref = (vref, 'mV')
measure_time = (time, 'ms')
#doing
global freq_board_name
result = Xavier.call('eval', freq_board_name, 'frequency_measure', vref,
measure_time)
if result is False:
return Utility.handle_done("-1.000000 Hz")
out_msg = '%f %s' % (result['freq'][0], result['freq'][1])
return Utility.handle_done(out_msg)
def hello_write_handle(params):
help_info = "hello write(<device type>, <msg>)$\r\n\
\tdevice type=(board,chip)$\r\n\
\tmsg: string"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parameters analysis '''
params_count = len(params)
if params_count != 2:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param length error")
#param: device type
device_type = params[0]
global demo_device
if device_type not in demo_device:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"device type error")
device_id = demo_device[device_type]["id"]
#param: msg
param_msg = str(params[1])
# logger.error("param_msg %s" % param_msg)
#done
result = Xavier.call('eval',device_id,'write', param_msg)
if result is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],"execute error")
#return msg
return Utility.handle_done()
def ina231_register_write_handle(params):
help_info = "ina231 register write(<channel>,<addr>,<data1>,<data2>)$\r\n\
\tchannel :(psu1,psu2,psu3)\r\n"
''' params init '''
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parametr analysis '''
params_count = len(params)
if params_count != 4:
return Utility.handle_error(Utility.handle_errorno["handle_errno_parameter_invalid"] ,\
"param length error" )
channel = params[0]
if channel not in ina231_channel:
return Utility.handle_error(Utility.handle_errorno["handle_errno_parameter_invalid"] ,\
"param channel error" )
addr = int(params[1], 16)
write_content = []
write_content.append(int(params[2], 16))
write_content.append(int(params[3], 16))
ret = Xavier.call("eval", test_base_board_name, "ina231_register_write",
ina231_channel[channel], addr, write_content)
if ret is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],\
"execute error")
output_str = str(ret)
return Utility.handle_done()
def hdq_slave_read_handle(params):
if hdq_bus_list is None:
get_hdq_bus_list()
help_info = "hdq slave read(<bus_name>)$\r\n\
\tbus_name=(" + ",".join(hdq_bus_list) + ")$\r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parameters analysis '''
params_count = len(params)
if params_count != 1:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
#bus
bus_name = params[0]
if bus_name not in hdq_bus_list:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"bus name param error")
#doing
addr, data = Xavier.call("hdq_slave_read", bus_name)
if False in (addr, data):
return Utility.handle_error(
Utility.handle_errorno['handle_errno_execute_failure'],
"execute error")
#packet result
out_msg = 'addr:%s, data:%s' % (addr, data)
return Utility.handle_done(out_msg)
def dac_voltage_set_handle(params):
help_info = "dac set(<channel>,<value>)$\r\n\
\t channel(" + help_str + ")\tvalue: (if ad5761: (0~10000) unit:mv,else :(0~5000) unit:mv) $\r\n"
''' params init '''
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parametr analysis '''
if len(params) != 2:
return Utility.handle_error(Utility.handle_errorno["handle_errno_parameter_invalid"],\
"param length error" )
channel = params[0]
if channel not in dac_list:
return Utility.handle_error(Utility.handle_errorno["handle_errno_parameter_invalid"] ,\
"channel parameter error" )
volt_value = float(params[1])
if channel == "psu3_voltage" or channel == "psu2_voltage":
if volt_value < 0 or volt_value > 10000:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],\
"param voltage value error" + str(volt_value))
elif channel == "base_board":
if volt_value < 0 or volt_value > 3300:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],\
"param voltage value error" + str(volt_value))
else:
if volt_value < 0 or volt_value > 5000:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],\
"param voltage value error" + str(volt_value))
ret = Xavier.call("eval", test_base_board_name, "voltage_set", channel,
volt_value)
if ret == False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],\
"execute error")
return Utility.handle_done()
def hello_handle(params):
help_info = "hello([index])$\r\n\
\index=(0,1,2,3), or none\r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parameters analysis '''
params_count = len(params)
if params_count > 1:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param length error")
if params_count == 0:
index = 0
else:
index = int(params[0],10)
if index < 0 or index > 3:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"index param value error")
result=["Hello Xavier !", "Hello Xavier 1 !", "Hello Xavier 2 !"]
out_msg=''
if index >= 3:
return Utility.handle_done()
else:
out_msg = result[index]
return Utility.handle_done(out_msg)
def uart_close_handle(params):
UART_CHANNEL_LIST = get_uart_device_list()
uart_string = ''
for uart_name in UART_CHANNEL_LIST.keys():
uart_string += uart_name
uart_string += ","
help_info = "uart close(<channel>})$\r\n\
\tchannel=(" + uart_string[:-1] + ")$"
'''help'''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
'''params analysis '''
param_count = len(params)
if param_count != 1:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'] -
param_count, "param count error")
channel = params[0]
if channel not in UART_CHANNEL_LIST:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"channel param error")
result = Xavier.call("uart_close", channel)
if result == False:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_execute_failure'],
"execute error")
return Utility.handle_done()
def datalogger_samplerate_get_handle(params):
help_info = "datalogger samplerate get(<channel>)$\r\n\
\tchannel:(chanA,chanB) \r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
'''parameters analysis'''
params_count = len(params)
if params_count != 1:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
channel = params[0]
if channel != "chanA" and channel != "chanB":
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param channel error")
global datalogger_board_name
result = Xavier.call('eval', datalogger_board_name, 'adc_samplerate_get',
adc_channel[channel])
if result is False:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_execute_failure'],
"execute error")
return Utility.handle_done(str(result))
def protect_flag_status_handle(params):
help_info = "protect flag{<channel>,<gpio>})$\r\n\
\tchannel :(psu1,psu2,psu3)$\r\n\
\tgpio:(ocp,ovp)$\r\n\
"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' params analysis '''
param_count = len(params)
if (param_count !=2):
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param length error")
channel = params[0]
if channel !='psu1' and channel !='psu2' and channel !='psu3':
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param channel error")
gpio_name = params[1]
if gpio_name !='ocp' and gpio_name !='ovp' :
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param gpio name error")
'''doing'''
ret=Xavier.call("eval",test_base_board_name,"protect_flag_status",channel,gpio_name)
if ret is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'], "get value fail ")
output_message =gpio_name+'=' +str(ret[0][1])
return Utility.handle_done(output_message)
def hello_read_handle(params):
help_info = "hello read(<device type>)$\r\n\
\device type=(board,chip)\r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parameters analysis '''
params_count = len(params)
if params_count != 1:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param length error")
#device type
device_type = params[0]
global demo_device
if device_type not in demo_device:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"device type error")
device_id = demo_device[device_type]["id"]
#done
result = Xavier.call('eval',device_id,'read')
#return msg
out_msg = result
return Utility.handle_done(out_msg)
def protectwavemeasure_handle(params):
help_info = "protect wave measure{<channel>,<mesure_time>})$\r\n\
\tchannel :("+protectwavemeasure_help+")\r\n\
\tmeasure time:(1-30000)ms,default 300ms$\r\n\
"
#\t v:vpp$\r\n\
''' init information '''
measure_time = 300
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' params analysis '''
param_count = len(params)
if (param_count !=2):
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param length error")
measure_time = int(params[1],10)
if measure_time < 1 or measure_time > 30000:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param measure time error")
'''doing'''
channel = params[0]
if channel not in protectwavemeasure_channel :
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param channel error")
ret=Xavier.call("eval",test_base_board_name,"protectwavemeasure_fun",channel,measure_time)
if ret is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'], "get value fail ")
output_message = str(ret[1])+"uS"
return Utility.handle_done(output_message)
def audio_upload_handle(params):
help_info = "audio upload(measure_time)$\r\n\
\tmeasure_time:set audio measure time:(1~2000ms)"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' params analysis '''
params_count = len(params)
if params_count != 1:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
result = Xavier.call('eval', datalogger_board_name, 'datalogger_close')
measure_time = int(params[0])
if measure_time < 1 or measure_time > 2000:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param measure time error")
''' open '''
result = Xavier.call('eval', datalogger_board_name, 'audio_upload',
measure_time)
result = Xavier.call('eval', datalogger_board_name, 'datalogger_close')
if result is False:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_execute_failure'],
"execute error")
return Utility.handle_done()
def ina231_voltage_read_handle(params):
help_info = "ina231 voltage read(<channel>,<sample_res>)$\r\n\
\tchannel :(psu1,psu2,psu3)\r\n\
\tsample_res: sample_register "
''' params init '''
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parametr analysis '''
params_count = len(params)
if params_count != 2:
return Utility.handle_error(Utility.handle_errorno["handle_errno_parameter_invalid"] ,\
"param length error" )
channel = params[0]
if channel not in ina231_channel:
return Utility.handle_error(Utility.handle_errorno["handle_errno_parameter_invalid"] ,\
"param channel error" )
res = float(params[1])
ret = Xavier.call("eval", test_base_board_name,
"shunt_and_bus_voltage_read", ina231_channel[channel],
res)
if ret is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],\
"execute error")
output_str = str(ret[0]) + "mA" + str(ret[1]) + "mV"
return Utility.handle_done(output_str)
def datalogger_measure_handle(params):
help_info = "datalogger measure(<channel,count>)$\r\n\
\tchannel:(voltage,current),count:(1-500)\r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parameters analysis '''
params_count = len(params)
if params_count != 2:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
channel = params[0]
#data count
count = int(params[1], 10)
#doing
global datalogger_board_name
result = Xavier.call('eval', datalogger_board_name, 'datalogger_measure',
adc_channel[channel], count)
if result is False:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_execute_failure'],
"execute error")
#packet result
out_msg = 'rms=%f%s,average=%f%s,max=%f%s,min=%f%s' % (
result["rms"][0], result["rms"][1], result["average"][0],
result["average"][1], result["max"][0], result["max"][1],
result["min"][0], result["min"][1])
return Utility.handle_done(out_msg)
def datalogger_read_handle(params):
help_info = "datalogger read(<reg_addr>)$\r\n\
\treg_addr:(0x00-0xff)\r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parameters analysis '''
params_count = len(params)
if params_count != 1:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
#adc register address
reg_addr = int(params[0], 16)
#doing
global datalogger_board_name
result = Xavier.call('eval', datalogger_board_name, 'adc_register_read',
reg_addr)
if result is False:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_execute_failure'],
"execute error")
#packet result
out_msg = '0x%04x' % (result)
return Utility.handle_done(out_msg)
def datalogger_write_handle(params):
help_info = "datalogger write(<registor>, <data>)$\r\n\
: registor=(0x00-0xff),data=(0x00-0xfffff)$\r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
'''parameters analysis'''
params_count = len(params)
if params_count != 2:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
reg_addr = int(params[0], 16)
data = int(params[1], 16)
#doing
global datalogger_board_name
result = Xavier.call('eval', datalogger_board_name, 'adc_register_write',
reg_addr, data)
if result is False:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_execute_failure'],
"execute error")
return Utility.handle_done()
def spi_slave_enable_handle(params):
if spi_bus_list is None:
get_spi_bus_list()
help_info = "spi slave enable(<bus_name>)$\r\n\
\tbus_name=("+",".join(spi_bus_list) +")$\r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parameters analysis '''
base_param_index = 0
params_count = len(params)
if params_count < 1:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param length error")
for index in range(params_count):
if index == base_param_index + 0:
bus_name = params[index]
if bus_name not in spi_bus_list:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s bus_name error"%index)
else:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"error ,params should less than %s "%index)
#doing
result = Xavier.call("spi_slave_enable",bus_name)
if result is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],"execute error")
return Utility.handle_done()
def eeprom_string_read_handle(params):
if eeprom_id_list is None:
get_eeprom_id_list()
help_info = "eeprom string read(<board-name>,<type>,<address>,<count>) $\r\n\
\tboard-name:(" + ",".join(eeprom_id_list) + ")$\r\n\
\ttype:(at01,at02,at04,at08,at16,at128,at256,at512,$\r\n\
\t\tcat01,cat02,cat04,cat08,cat16)$\r\n\
\taddress =(0x00-0xHHHH)$\r\n\
\tcount=(1-100)$\r\n"
#help
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
param_count = len(params)
if param_count != 4:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_parameter_invalid"],
"param length error")
for index in range(0, param_count):
if index == 0:
board_name = params[0]
elif index == 1:
type = params[1]
elif index == 2:
address = int(params[index], 16)
elif index == 3:
length = int(params[index], 10)
else:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_parameter_invalid"],
"param error")
if board_name not in eeprom_id_list:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_parameter_invalid"],
"param board_name error")
if length < 0 or length > 100:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_parameter_invalid"],
"read data is too long")
result = Xavier.call('eeprom_read', board_name, address, length)
if result is False:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_execute_failure"],
"read failed")
msg = ""
msg += '\"'
for index in range(0, len(result)):
if result[index] >= 0x00 or result[index] <= 0x7F:
msg += chr(result[index])
else:
msg += " "
msg += '\"'
msg += '\0'
return Utility.handle_done(msg)
def i2c_write_handle(params):
if i2c_bus_list is None:
get_i2c_bus_list()
help_info = "i2c write(<bus_name>,<slave_addr>,<write_length>,<write_content>)$\r\n\
\tbus_name=(" + ",".join(i2c_bus_list) + ")$\r\n\
\tslave_addr=(0x00-0x7F), slave device 7 bits address$\r\n\
\write_length=(0-32)$\r\n\
\twrite_content: format =[data_1,data_2,...,data_n], data_n=(0x00-0xff)$\r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parameters analysis '''
params_count = len(params)
if params_count < 4:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
#bus
bus_name = params[0]
if bus_name not in i2c_bus_list:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"bus name param error")
#slave device address
slave_addr = int(params[1], 16)
if slave_addr > 0x7f:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"slave device address param error")
#write data count
write_length = int(params[2])
if write_length > 32 or write_length < 1:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"write length bytes param error")
#write datas
if (params_count != (write_length + 3)):
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
write_datas = []
for index in range(3, 3 + write_length):
write_datas.append(int(params[index], 16))
#doing
result = Xavier.call("i2c_write", bus_name, slave_addr, write_datas)
if result is False:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_execute_failure'],
"execute error")
#packet result
return Utility.handle_done()
def update_handle(params):
help_info = "update(<mode>)$\r\n\
\t mode:(check,clean)$\r\n\
\t check: check the update file. default:mode=check$\r\n\
\t clean: clean the update folder"
mode = "check"
''' help '''
if utility.is_ask_for_help(params) is True:
return utility.handle_done(help_info)
if len(params) == 1:
mode = params[0]
elif len(params) > 1:
return utility.handle_error(
utility.handle_errorno['handle_errno_parameter_invalid'],
"param error")
if mode != "clean" and mode != "check":
return utility.handle_error(
utility.handle_errorno['handle_errno_parameter_invalid'],
"param error")
if mode == "clean":
os.chdir("/opt/seeing/tftpboot")
os.system("rm * ")
return utility.handle_done()
result = ""
count = 0
# update_file_string
update_file = ''
for parent, dirnames, filenames in os.walk(update_file_path):
for filename in filenames:
if update_file_string in filename:
update_file = filename
result += filename
result += "\r\n"
count += 1
if count > 1:
return utility.handle_error(utility.handle_errorno['handle_errno_crc_checksum_failure'],\
"too many update file\r\n" + result)
elif count <= 0:
return utility.handle_done("no update file")
# check the file md5sum
os.chdir("/opt/seeing/tftpboot")
os.system("mkdir checkfile")
command_string = "tar zxvfm "
command_string += update_file
command_string += " -C checkfile"
os.system(command_string)
os.chdir("checkfile")
res = os.system("md5sum -c md5.txt")
if (res != 0):
return utility.handle_error(utility.handle_errorno['handle_errno_crc_checksum_failure'],\
"md5 check file error")
return utility.handle_done(update_file + " ok")
def io_read_handle(params):
if board_id is None:
_get_board_id()
if io_relevant_config is None:
_get_io_relevant_config()
help_info = "io read({<count>,<content>})$\r\n\
\tcount: (1-32) $\r\n\
\tcontent=(bitX,..bitX),X=(" +str(io_relevant_config["min_bit_num"])\
+"-" + str(io_relevant_config["max_bit_num"]) +")\r\n "
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
result_dict = OrderedDict()
operation_bit = []
output_str = ""
''' parametr analysis '''
param_count = int(params[0], 10)
if not (param_count >= 1 and param_count <= 32):
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
for index in range(1, param_count + 1):
''' 用正则表达式匹配字符串 '''
regular_expression = re.match(r'bit(\w+)', params[index])
''' 判断是否匹配成功 '''
if regular_expression is None:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param error")
''' 提取成功匹配的值 '''
bit_number = int(regular_expression.group(1), 10)
if bit_number >= io_relevant_config[
"min_bit_num"] and bit_number <= io_relevant_config[
"max_bit_num"]:
operation_bit.append("bit" + str(bit_number))
else:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param error")
''' doing '''
result_dict = Xavier.call('io_get', board_id, *operation_bit)
if (result_dict.has_key("error")):
return Utility.handle_error(
Utility.handle_errorno['handle_errno_execute_failure'],
"execute error")
else:
# output_str = _chips_bits_sort_str("bits",result_dict)
for i in range(0, len(operation_bit)):
output_str += operation_bit[i] + "=" + str(
result_dict[operation_bit[i]])
if i != len(operation_bit) - 1:
output_str += ","
return Utility.handle_done(output_str)
def spi_config_handle(params):
if spi_bus_list is None:
get_spi_bus_list()
help_info = "spi config(<bus_name>,<clk_frequency>,<clk_type>{,<wait_time_us>,<spi_clk_polarity>})$\r\n\
\tbus_name=("+",".join(spi_bus_list) +")$\r\n\
\tclk_frequency:(0-100 000 000)Hz $\r\n\
\tclk_type:(pos or neg), $\r\n\
\t 'pos' --sclk posedge send data, sclk negedge receive data$\r\n\
\t 'neg' --sclk negedge send data, sclk posedge receive data$ \r\n\
\twait_time_us: the wait time for new spi access, default=1 $\r\n\
\tspi_clk_polarity(str): $\r\n\
\t 'high' --when CS is high, the SCLK is high $\r\n\
\t 'low' --when CS is high, the SCLK is low $\r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parameters analysis '''
base_param_index = 0
wait_time_us = 1
spi_clk_polarity = 'high'
params_count = len(params)
if params_count < 3:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param length error")
for index in range(params_count):
if index == base_param_index + 0:
bus_name = params[index]
if bus_name not in spi_bus_list:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s bus_name error"%index)
elif index == base_param_index + 1:
clk_frequency = int(params[index])
if clk_frequency < 0:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s clk_frequency error"%index)
elif index == base_param_index + 2:
clk_type = params[index]
if clk_type not in {"pos", "neg"}:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s clk_type error"%index)
elif index == base_param_index + 3:
wait_time_us = int(params[index])
if wait_time_us not in range(0,10000):
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s wait_time_us error"%index)
elif index == base_param_index + 4:
spi_clk_polarity = params[index]
if spi_clk_polarity not in ['high','low']:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s spi_clk_polarity error"%index)
else:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"error ,params should less than %s "%index)
#doing
result = Xavier.call("spi_config",bus_name, clk_frequency ,clk_type, wait_time_us, spi_clk_polarity)
if result is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],"execute error")
#packet result
return Utility.handle_done()
def eeprom_string_write_handle(params):
if eeprom_id_list is None:
get_eeprom_id_list()
help_info = "eeprom string write(<board-name>,<type>,<address>,\"<string>\")$\r\n\
\tboard-name:(" + ",".join(eeprom_id_list) + ")$\r\n\
\ttype:(at01,at02,at04,at08,at16,at128,at256,at512,$\r\n\
\t\tcat01,cat02,cat04,cat08,cat16)$\r\n\
\taddress =(0x00-0xHHHH)$\r\n\
\tstring: a string $\r\n"
#help
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
param_count = len(params)
if param_count < 4:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_parameter_invalid"],
"param length error")
buf = ""
for index in range(0, param_count):
if index == 0:
board_name = params[0]
elif index == 1:
type = params[1]
elif index == 2:
address = int(params[index], 16)
elif index >= 3:
if buf != "":
buf += ","
buf += params[index]
else:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_parameter_invalid"],
"param error")
if board_name not in eeprom_id_list:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_parameter_invalid"],
"param board_name error")
if len(buf) > 200:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_parameter_invalid"],
"write data is too long")
content = []
for index in range(0, len(buf)):
if (buf[index] != '\"') and (buf[index] != '\0'):
content += [ord(buf[index])]
if Xavier.call('eeprom_write', board_name, address, content) is True:
return Utility.handle_done()
else:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_execute_failure"],
"message execute failed")
def temperature_read_handle(params):
help_info = "temperature read()$\r\n"
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
ret = Xavier.call("eval", test_base_board_name, "temperature_read")
return Utility.handle_done("%s" % (str(ret)))
def io_set_handle(params):
if board_id is None:
_get_board_id()
if io_relevant_config is None:
_get_io_relevant_config()
help_info = "io set({<count>,<content>})$\r\n\
\tcount: (1-32) $\r\n\
\tcontent=(bitX=Y,..bitX=Y),X=(" +str(io_relevant_config["min_bit_num"])\
+"-" + str(io_relevant_config["max_bit_num"]) +"),Y=(0,1)\r\n "
#start_param = time.time()
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
ioes = {}
''' params analysis '''
params_count = len(params)
param_count = int(params[0], 10)
if param_count < 1 or param_count > 32:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
if params_count != param_count + 1:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
for index in range(1, param_count + 1):
''' 用正则表达式匹配字符串 '''
regular_expression = re.match(r'bit(\w+)=(\w+)', params[index])
''' 判断是否匹配成功 '''
if regular_expression is None:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param error")
''' 提取成功匹配的值 '''
bit_number = int(regular_expression.group(1), 10)
bit_state = (int(regular_expression.group(2), 10)) & 0x01
if bit_number >= io_relevant_config[
"min_bit_num"] and bit_number <= io_relevant_config[
"max_bit_num"]:
ioes['bit' + str(bit_number)] = bit_state
else:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param error")
''' doing '''
if (Xavier.call('io_set', board_id, ioes)):
return Utility.handle_done()
else:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_execute_failure'],
"execute error")
def spi_write_and_read_handle(params):
if spi_bus_list is None:
get_spi_bus_list()
help_info = "spi write and read(<bus_name>,<write_len>,<write_datas>{,<cs_extend>})$\r\n\
\tbus_name=("+",".join(spi_bus_list) +")$\r\n\
\twrite_len: (1-32) $\r\n\
\twrite_datas:(0x1f,0x33,...) hex $\r\n\
\tcs_extend: (0-8), default =0 $\r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' default info '''
cs_extend = 0
''' parameters analysis '''
base_param_index = 0
write_datas = []
params_count = len(params)
if params_count < 2:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param length error")
for index in range(base_param_index, params_count):
if index == base_param_index + 0:
bus_name = params[index]
if bus_name not in spi_bus_list:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s bus_name error"%index)
elif index == base_param_index + 1:
write_len = int(params[index])
if write_len not in range(1,32+1):
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s write_len error"%index)
if params_count < write_len + index + 1:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"the num of write_datas error")
elif index in range(base_param_index + 2, base_param_index + 2 + write_len):
try:
write_datas.append(int(params[index], 16))
except Exception as e:
logger.error("write datas error :" + repr(e))
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s write data error"%index)
elif index == base_param_index + 2 + write_len :
cs_extend = int(params[index])
if cs_extend not in range(0,8+1):
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s cs_extend error"%index)
else:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"error ,params should less than %s "%index)
#doing
result = Xavier.call("spi_write_and_read",bus_name, write_datas, cs_extend)
if result is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],"execute error")
#packet result
out_msg = ''
for data in result:
out_msg += '0x%02x,'%(data)
return Utility.handle_done(out_msg[:-1])
def uart_config_handle(params):
UART_CHANNEL_LIST = get_uart_device_list()
uart_string = ''
for uart_name in UART_CHANNEL_LIST.keys():
uart_string += uart_name
uart_string += ","
help_info = "uart config(<channel>,<baud>,<bits>,<stop>,<parity>,{<timestamp>})$\r\n\
\tchannel=("+uart_string[:-1] +")$\r\n\
\tbaud=(115200,38400,19200,9600,4800,2400,1200,300)$\r\n\
\tbits=(5,6,7,8)$\r\n\
\tstop=(1,1.5,2)$\r\n\
\tparity=(odd,even,none)$\r\n\
\ttimestamp=(ON,OFF)$\r\n\
\t\tdefault:OFF"
'''help'''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
timestamp = "OFF"
'''params analysis '''
param_count = len(params)
if param_count < 5 or param_count > 6:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'] - param_count,"param count error")
for index in range(0, param_count):
if index == 0:
channel = params[index]
elif index == 1:
baud = int(params[index])
elif index == 2:
bits = int(params[index])
elif index == 3:
stop = float(params[index])
elif index == 4:
parity = params[index].upper()
elif index == 5:
timestamp = params[index]
else :
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'] - index,"param error")
logger.info(str(channel) + " " + str(baud) + " " + str(bits) + " " + str(stop) + " " + str(parity) + " " + str(timestamp))
if channel not in UART_CHANNEL_LIST:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"channel param error")
if timestamp.upper() == "OFF":
timestamp = "NONE"
else:
timestamp = "TS"
logger.warning("cmd uart")
result = Xavier.call("uart_param_config",channel, baud, bits, parity, stop, timestamp)
if result == False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],"execute error")
return Utility.handle_done()
def net_read_handle(params):
help_info = "net read({<module>})$\r\n\
\tmodule= (mac,ip,mask,gate,net,user) $\r\n"
''' help '''
if utility.is_ask_for_help(params) is True:
return utility.handle_done(help_info)
''' parametr analysis '''
if len(params) != 1:
return utility.handle_error(
utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
network_information = net.read_network_information()
output_str = ''
mode = network_information["mode"]
if params[0] == 'mac':
output_str = output_str + 'mac: ' + '%s' % (
network_information[mode]["mac"])
elif params[0] == 'ip':
output_str = output_str + 'ip: ' + '%s' % (
network_information[mode]["ip"])
elif params[0] == 'gate':
output_str = output_str + 'gate: ' + '%s' % (
network_information[mode]["gateway"])
elif params[0] == 'mask':
output_str = output_str + 'mask: ' + '%s' % (
network_information[mode]["mask"])
elif params[0] == 'net':
output_str = output_str + '%s,' % (mode)
output_str = output_str + 'mac: ' + '%s,' % (
network_information[mode]["mac"])
output_str = output_str + 'ip: ' + '%s,' % (
network_information[mode]["ip"])
output_str = output_str + 'gate: ' + '%s,' % (
network_information[mode]["gateway"])
output_str = output_str + 'mask: ' + '%s' % (
network_information[mode]["mask"])
elif params[0] == 'user':
mode = 'user'
output_str = output_str + '%s,' % (mode)
output_str = output_str + 'mac: ' + '%s,' % (
network_information[mode]["mac"])
output_str = output_str + 'ip: ' + '%s,' % (
network_information[mode]["ip"])
output_str = output_str + 'gate: ' + '%s,' % (
network_information[mode]["gateway"])
output_str = output_str + 'mask: ' + '%s' % (
network_information[mode]["mask"])
else:
return utility.handle_error(
utility.handle_errorno['handle_errno_parameter_invalid'],
"param error")
return utility.handle_done(output_str)
