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