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 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 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 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 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_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 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 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 _get_board_channel():
channel_list = []
boards = Xavier.call("get_boards")
for board in boards.values():
if 'daq_channel' in board.keys():
for channel in board['daq_channel']:
channel_list.append(channel)
return channel_list
def get_hdq_bus_list():
global hdq_bus_list
hdq_bus_list = {}
buses = Xavier.call("get_buses")
for name, bus in buses.iteritems():
if bus['bus'] == 'hdq':
hdq_bus_list[name] = bus
return hdq_bus_list
def get_i2c_bus_list():
global i2c_bus_list
i2c_bus_list = {}
buses = Xavier.call("get_buses")
for name, bus in buses.iteritems():
if bus['bus'] == 'i2c':
i2c_bus_list[name] = bus
return i2c_bus_list
def get_spi_bus_list():
global spi_bus_list
spi_bus_list = {}
buses = Xavier.call("get_buses")
for name, bus in buses.iteritems():
if bus['bus'] == 'spi':
spi_bus_list[name] = bus
return spi_bus_list
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 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_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 get_uart_device_list():
global uart_device_list
if uart_device_list is None:
uart_device_list = {}
buses = Xavier.call("get_buses")
for name, bus in buses.iteritems():
if bus['bus'] == 'uart':
uart_device_list[name] = bus
return uart_device_list
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 eeprom_write_handle(params):
if eeprom_id_list is None:
get_eeprom_id_list()
help_info = "eeprom write(<board-name>,<type>,<address>,<count>,<content>)$\r\n\
\tboard-name:(" + ",".join(eeprom_id_list) + ")$\r\n\
\ttype:(at01,at02,at04,at08,at16,at128,at256,at512,$\r\n\
\t\tcat01,at02,cat04,cat08,cat16)$\r\n\
\taddress:(0x0000-0xHHHH)v\r\n\
\tcount:(1-100)$\r\n\
\tcontent=(HH,HH,...HH)$\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 < 5:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_parameter_invalid"],
"param length error")
content = []
for index in range(0, param_count):
if index == 0:
board_name = params[index]
elif index == 1:
type = params[index]
elif index == 2:
address = int(params[index], 16)
elif index == 3:
length = int(params[index], 10)
else:
if len(content) < length:
content += [int(params[index], 16)]
else:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_parameter_invalid"],
"num of data error")
if board_name not in eeprom_id_list:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_parameter_invalid"] - 1,
"param error")
if length < 0 or length > 100:
return Utility.handle_error(
Utility.handle_errorno["handle_errno_parameter_invalid"] - 2,
"read data is too long")
if length != len(content):
return Utility.handle_error(
Utility.handle_errorno["handle_errno_parameter_invalid"] - 3,
"num of data error")
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 i2c_read_handle(params):
if i2c_bus_list is None:
get_i2c_bus_list()
help_info = "i2c read(<bus_name>,<slave_addr>,<read_length>)$\r\n\
\tbus_name=(" + ",".join(i2c_bus_list) + ")$\r\n\
\tslave_addr=(0x00-0x7F), slave device 7 bits address$\r\n\
\read_length=(0-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 != 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 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")
#read data count
read_length = int(params[2])
if read_length > 32 or read_length < 1:
return Utility.handle_error(
Utility.handle_errorno['handle_errno_parameter_invalid'],
"read length bytes param error")
#doing
result = Xavier.call("i2c_read", bus_name, slave_addr, 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 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 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_read_handle(params):
if spi_bus_list is None:
get_spi_bus_list()
help_info = "spi read(<bus_name>,<read_length>{,<cs_extend>})$\r\n\
\tbus_name=("+",".join(spi_bus_list) +")$\r\n\
\tread_length=(0-32)$\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
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(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:
read_length = int(params[index])
if read_length not in range(0,32+1):
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s read_length error"%index)
elif index == base_param_index + 2:
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_read",bus_name, read_length, cs_extend)
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 io_set(io_dict):
'''set cat9555 pin output state
Arguments:
io_dict {"bit1":0, "bit2":1} --
Returns:
bool -- [True:sucess,False:fail]
'''
if board_id is None:
_get_board_id()
if io_relevant_config is None:
_get_io_relevant_config()
if True == Xavier.call('io_set', board_id, io_dict):
return True
else:
return False
def spi_slave_config_handle(params):
if spi_bus_list is None:
get_spi_bus_list()
help_info = "spi slave config(<bus_name>,<spi_clk_cpha_cpol>,<spi_byte_cfg>)$\r\n\
\tspi_clk_cpha_cpol: 'Mode_0' --CPHA=0, CPOL=0, when CS is high, the SCLK is low, first edge sample $\r\n\
\t 'Mode_1' --CPHA=0, CPOL=1, when CS is high, the SCLK is high, first edge sample $\r\n\
\t 'Mode_2' --CPHA=1, CPOL=0, when CS is high, the SCLK is low, second edge sample $\r\n\
\t 'Mode_3' --CPHA=1, CPOL=1, when CS is high, the SCLK is high, second edge sample $\r\n\
\tspi_byte_cfg: '1' --spi slave receive data or send data is 1byte $\r\n\
\t '2' --spi slave receive data or send data is 2byte $\r\n\
\t '3' --spi slave receive data or send data is 3byte $\r\n\
\t '4' --spi slave receive data or send data is 4byte $\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 < 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:
tspi_clk_cpha_cpol = params[index]
if tspi_clk_cpha_cpol not in {"Mode_0","Mode_1","Mode_2","Mode_3"}:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s tspi_clk_cpha_cpol error"%index)
elif index == base_param_index + 2:
spi_byte_cfg = params[index]
if spi_byte_cfg not in ["1","2","3","4"]:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s spi_byte_cfg 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_config",bus_name, tspi_clk_cpha_cpol ,spi_byte_cfg)
if result is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],"execute error")
#packet result
return Utility.handle_done()
def spi_slave_read_handle(params):
if spi_bus_list is None:
get_spi_bus_list()
help_info = "spi slave read(<bus_name>,<address>,<read_length>)$\r\n\
\tbus_name=("+",".join(spi_bus_list) +")$\r\n\
\taddress=hex address,0xXXXX $\r\n\
\tread_length=(0-32) $\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 < 2:
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:
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:
read_length = int(params[index])
if read_length not in range(0,32+1):
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param %s read_length 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_read",bus_name, address, 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 error")
#packet result
out_msg = ''
for data in result:
out_msg += '0x%02x,'%(data)
return Utility.handle_done(out_msg[:-1])
def io_read(io_list):
'''read cat9555 pin state
Arguments:
io_list ["bit1", "bit2"] --
Returns:
sucess: result_dict eg.{"bit1":0, "bit2":0}
fail : False
'''
if board_id is None:
_get_board_id()
if io_relevant_config is None:
_get_io_relevant_config()
result_dict = Xavier.call('io_get', board_id, *io_list)
if "error" not in result_dict:
return result_dict
else:
return False
def _get_io_relevant_config():
global io_relevant_config
io_relevant_config = {}
bit_dict = {}
chip_dict = {}
io_chip_dict = Xavier.call('get_extendio')
for name, description in io_chip_dict[board_id].items():
if "bit" in name:
bit_dict[name] = description
elif "cp" in name:
chip_dict[name] = description
bit_sorted_list = _chips_bits_sort("bits", bit_dict)
chip_sorted_list = _chips_bits_sort("chips", chip_dict)
io_relevant_config["chips_num"] = len(chip_dict)
io_relevant_config["min_bit_num"] = bit_sorted_list[0]
io_relevant_config["max_bit_num"] = bit_sorted_list[len(bit_dict) - 1]
io_relevant_config["min_chip_num"] = chip_sorted_list[0]
io_relevant_config["max_chip_num"] = chip_sorted_list[len(chip_dict) - 1]
def gpio_read_handle(params):
help_info = "gpio read({<count>,<content>})$\r\n\
\tcount: (1-32) $\r\n\
\tcontent=(bitX,..bitX),X=(1~272)\r\n "
''' help '''
if Utility.is_ask_for_help(params) is True:
return Utility.handle_done(help_info)
''' parameters analysis '''
read_io_list = []
params_count = len(params)
bit_count = int(params[0],10)
if bit_count < 1 or bit_count > 32:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param length error")
if params_count != bit_count + 1:
return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"param length error")
for index in range(1, bit_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)
read_io_list.append([bit_number])
'''doing'''
result = Xavier.call('eval', board_name, 'get_io', read_io_list)
if result is False:
return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],"execute error")
result_str = ""
for num_val in result:
result_str += "bit%d" %num_val[0] + "=%d," %num_val[1]
result_str = result_str[:-1]
return Utility.handle_done(result_str)
