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 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 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 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 spi_enable_handle(params):
if spi_bus_list is None:
get_spi_bus_list()
help_info = "spi 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_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 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 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 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 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_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 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 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)
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 programmer_erase_handle(params):
help_info = "programmer erase(<channel>,<chip type>,{<target_address>,<size>})$\r\n\
\tchannel:" + str(
json.dumps(
list(_g_fwdl_config_list['support_channel'].keys()))).replace(
'"', '') + "$\r\n\
\tchip type:" + str(json.dumps(_g_fwdl_config_list["support_chip"])).replace(
'"', '') + "$\r\n\
\ttarget_address:target_address;\r\n\
\tsize:erase size;\r\n"
''' init information '''
base_param_index = 0
''' 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 and param_count != 4:
return utility.handle_error(
utility.handle_errorno['handle_errno_parameter_invalid'].value,
"param length error")
target_address = None
erasesize = None
for index in range(base_param_index, param_count):
if index == base_param_index:
channel_str = params[index]
if index == base_param_index + 1:
chip_type = params[base_param_index + 1]
if index == base_param_index + 2:
target_address = params[base_param_index + 2]
if index == base_param_index + 3:
erasesize = params[base_param_index + 3]
executing_config_list = []
executing_config_dict = {}
if target_address != None and erasesize != None:
executing_config_dict["target_addr"] = target_address
executing_config_dict["size"] = erasesize
executing_config_list.append(executing_config_dict)
#-------------------doing------------------
ret_str = ""
if target_address != None and erasesize != None:
prog_state, prog_str = fwdl_executing_process(channel_str,
"erase_chip", chip_type,
executing_config_list)
else:
prog_state, prog_str = fwdl_executing_process(channel_str,
"erase_chip", chip_type)
ret_str += prog_str
if prog_state == False:
return utility.handle_error(
utility.handle_errorno['handle_errno_execute_failure'], ret_str)
return utility.handle_done(ret_str) #fwdl_executing_str idcode
def hdq_slave_write_handle(params):
if hdq_bus_list is None:
get_hdq_bus_list()
help_info = "hdq slave write(<bus_name>,<slave_addr>,<write_data)$\r\n\
\tbus_name=(" + ",".join(hdq_bus_list) + ")$\r\n\
\tslave_addr=(0x00-0x7F), slave device 7 bits address$\r\n\
\twrite_data=(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 != 3:
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")
#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_data = int(params[2])
if write_data > 0xff or write_data < 0:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"write data bytes param error")
#doing
addr = Xavier.call("hdq_slave_write", bus_name, slave_addr, write_data)
if addr is False:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_execute_failure'],
"execute error")
#packet result
out_msg = 'receive addr:0x%02x' % addr
return Utility.handle_done(out_msg)
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 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 __net_information_handle(module, net_information):
network_information = net.read_network_information()
if module != 'net':
'''
if "user" != network_information["mode"]:
return True
'''
if module == 'mac':
return net.set_network_information("user:mac", net_information)
if module == 'ip':
return net.set_network_information("user:ip", net_information)
if module == 'gate':
return net.set_network_information("user:gateway", net_information)
if module == 'mask':
return net.set_network_information("user:mask", net_information)
else:
if net_information == 'default':
return net.set_network_information("mode", "default")
elif net_information == 'user':
return net.set_network_information("mode", "user")
else:
return utility.handle_error(
utility.handle_errorno['handle_errno_parameter_invalid'],
"param error")
def audio_datalogger_open_handle(params):
help_info = "audio datalogger open()$\r\n"
''' init information '''
''' 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 !=0):
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param length error")
'''doing'''
ret=Xavier.call("eval",test_base_board_name,"audio_datalogger_open")
if ret is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'], "audio datalogger open fail ")
return Utility.handle_done()
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 datalogger_open_handle(params):
help_info = "datalogger open({<channel>,<mode>})$\r\n\
\tchannel=(chanA,chanB)\r\n\
\tmode=(ADC_MASTER,ADC_NORMAL),default ADC_NORMAL$\r\n"
''' 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 > 2:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
if params_count == 2:
modes = ["ADC_MASTER", "ADC_NORMAL"]
if params[1] not in modes:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"parameter mode error")
mode = params[1]
else:
mode = "ADC_NORMAL"
channel = params[0]
if channel != "chanA" and channel != "chanB":
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"param channel error")
''' doing '''
global datalogger_board_name
if mode == "ADC_MASTER":
''' close '''
result = Xavier.call('eval', datalogger_board_name, 'datalogger_close')
else:
''' open '''
result = Xavier.call('eval', datalogger_board_name, 'datalogger_open',
adc_channel[channel])
if result is False:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_execute_failure'],
"execute error")
return Utility.handle_done()
def logupload_close_handle(params):
help_info = "logupload close({<name>})$\r\n\
\tname: log's name $\r\n"
''' help '''
if utility.is_ask_for_help(params) is True:
return utility.handle_done(help_info)
''' parametr analysis '''
params_count = len(params)
if not params_count == 1:
return utility.handle_error(
utility.handle_errorno['handle_errno_parameter_invalid'],
"param length error")
name = params[0]
if False == isinstance(name, str):
return utility.handle_error(
utility.handle_errorno['handle_errno_parameter_invalid'],
"param error")
if False == _check_log_name(name):
return utility.handle_error(
utility.handle_errorno['handle_errno_parameter_invalid'],
"%s did not register information for upload" % (name))
context = zmq.Context()
# Socket to talk to clients
publisher = context.socket(zmq.PUB)
# bind port
try:
publisher.bind('tcp://*:22730')
msg = json.dumps(
{b'%s' % ((name.split(".log")[0]).upper()): {
b"upload": False
}})
for i in range(0, 3):
publisher.send(msg)
time.sleep(0.1)
except Exception:
return utility.handle_error(
utility.handle_errorno['handle_errno_execute_failure'],
"open log upload error[socket invalid]")
logger.info("logupload_close_handle success")
return utility.handle_done()
def i2c_rdwr_handle(params):
if i2c_bus_list is None:
get_i2c_bus_list()
help_info = "i2c rdwr(<bus_name>,<slave_addr>,<write_length>,<write_content>,<read_length>)$\r\n\
\tbus_name=("+",".join(i2c_bus_list) +")$\r\n\
\tslave_addr=(0x00-0x7F), slave device 7 bits address$\r\n\
\twrite_length=(1-32)$\r\n\
\twrite_content: format =[data_1,data_2,...,data_n], data_n=(0x00-0xff)$\r\n\
\tread_length=(1-32)$\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+1)):
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))
#read length
read_length=int(params[write_length+3])
#doing
result = Xavier.call("i2c_rdwr",bus_name, slave_addr, write_datas,read_length)
if result is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],"execute error")
elif len(result) != read_length:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],"execute error: read data length error")
#packet result
out_msg = ''
for data in result:
out_msg += '0x%02x,'%(data)
return Utility.handle_done(out_msg[:-1])
def audio_datalogger_close_handle(params):
help_info = "audio datalogger close()$\r\n"
''' init information '''
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
'''doing'''
ret=Xavier.call("eval",test_base_board_name,"audio_datalogger_close")
if ret is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'], "audio measure fail ")
return Utility.handle_done()
def dac_5761_write_register_handle(params):
help_info = "ad5761 register write(<addr>,<data>)$\r\n\
\t addr:register address $\r\n\
\t data:2byte data\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" )
addr = int(params[0], 16)
data = int(params[1], 16)
ret = Xavier.call("eval", test_base_board_name, "ad5761_write_register",
addr, data)
if ret == False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],\
"execute error")
return Utility.handle_done()
def spi_slave_write_handle(params):
if spi_bus_list is None:
get_spi_bus_list()
help_info = "spi slave write(<bus_name>,<address>,<write_len>,<write_datas>)$\r\n\
\tbus_name=("+",".join(spi_bus_list) +")$\r\n\
\taddress: (0xHHHH),hex data $\r\t\n\
\twrite_len: (1-32) $\r\n\
\twrite_datas:(0x1f,0x33,...) hex $\r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' 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 :
address = int(params[index], 16)
if address not in range(0,0xffff+1):
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s address error"%index)
elif index == base_param_index + 2:
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 + 3, base_param_index + 3 + 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)
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_write",bus_name, address, 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 wave_measure_get_handle(params):
help_info = "wave measure get{<timeout>})$\r\n\
\t timeout:(1-3000)ms\r\n\
"
#\t v:vpp$\r\n\
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 length error")
measure_time = int(params[0],10)
if measure_time < 1 or measure_time > 3000:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param measure time error")
'''doing'''
ret=Xavier.call("eval",test_base_board_name,"wave_measure_get",measure_time)
if ret is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'], "get value fail ")
output=str(ret[1])+'uS'
return Utility.handle_done(output)
def swd_rst_ctrl_set_handle(params):
help_info = "swd rst ctrl set(<channel>,<status>)$\r\n\
\tchannel:"+swd_gpio_help+"\
\tstatus=(H,L)\r\n"
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' params 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 swd_gpio :
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param channel error")
status=params[1]
if (status!='H' )and(status!='L' ):
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param status error")
if(Xavier.call("eval",test_base_board_name,"swdrstctrl",channel,status)):
pass
else:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],"execute error")
return Utility.handle_done()
def aid_init_handle(params):
help_info = "aid init(<channel>) $\r\n\
\tchannel=(AID_1,AID_2)\r\n"
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
if len(params) != 1:
return Utility.handle_error(Utility.handle_errorno["handle_errno_parameter_invalid"],\
"param length error" )
channel = params[0]
if channel not in AID_channel:
return Utility.handle_error(Utility.handle_errorno["handle_errno_parameter_invalid"] ,\
"channel parameter error" )
''' doing '''
result = Xavier.call('eval', test_base_board_name, 'aid_init', channel)
if result is False:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_execute_failure'],
"execute aid config error")
return Utility.handle_done()
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()
