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)