def _handle_read_mag_accel(self, sequence, codec): # Create reference objects to pass into handler for out/inout parameters. results = erpc.Reference() status = erpc.Reference() # Read incoming parameters. # Invoke user implementation of remote function. self._handler.read_mag_accel(results, status) # Prepare codec for reply message. codec.reset() # Construct reply message. codec.start_write_message( erpc.codec.MessageInfo( type=erpc.codec.MessageType.kReplyMessage, service=interface.Iremote_control_app_0.SERVICE_ID, request=interface.Iremote_control_app_0.READ_MAG_ACCEL_ID, sequence=sequence)) if results.value is None: raise ValueError("results is None") results.value._write(codec) if status.value is None: raise ValueError("status is None") codec.write_bool(status.value)
def dac_adc(): # variables AdcConfig = erpc.Reference() resultDAC_ADC = erpc.Reference() numberToConvert = 0 # get ADC config client.adc_get_config(AdcConfig) AdcConfig_struct = AdcConfig.value # get Voltage to convert numberToConvert = input_fn("Please enter voltage <0V - 3.3V>: ") numberToConvert = float(numberToConvert) print("You entered", numberToConvert) # compute number of atomic steps for DAC numberToConvert = numberToConvert / (AdcConfig_struct.vref / AdcConfig_struct.atomicSteps) numberToConvert = int(numberToConvert) if numberToConvert >= 0 and numberToConvert <= 4096: if numberToConvert == 4096: numberToConvert = 4095 client.convert_dac_adc(numberToConvert, resultDAC_ADC) # compute voltage from value in ADC print("Read value from ADC: %f" % (resultDAC_ADC.value * (AdcConfig_struct.vref / AdcConfig_struct.atomicSteps))) print("---------------------") else: print("Value for DAC/ADC out of range")
def adc(): # variables AdcConfig = erpc.Reference() resultDAC_ADC = erpc.Reference() numberToConvert = 0 # get ADC config client.adc_get_config(AdcConfig) AdcConfig_struct = AdcConfig.value client.convert_dac_adc(0, resultDAC_ADC) # compute voltage from value in ADC print("Read value from ADC: %f" % (resultDAC_ADC.value * (AdcConfig_struct.vref / AdcConfig_struct.atomicSteps))) print("---------------------")
def runClient(transport): clientManager = erpc.client.ClientManager(transport, erpc.basic_codec.BasicCodec) client = erpc_dac_adc.client.dac_adcClient(clientManager) BoardName = erpc.Reference() client.board_get_name(BoardName) print(BoardName.value) while True: if BoardName.value == "FRDM-KL27Z": print("->Press '1' for ADC conversion") else: print("->Press '1' for DAC ADC conversion") print("->Press '2' for GPIO LED") print("->Press '3' for Accelerometer and Magnetometer") switchVal = input_fn() if switchVal == '1' and BoardName.value != "FRDM-KL27Z": dac_adc() elif switchVal == '1' and BoardName.value == "FRDM-KL27Z": adc() elif switchVal == '2': led_func(BoardName.value) elif switchVal == '3': accel_mag_func(BoardName.value) else: print("Invalid argument")
def runClient(transport): # create matrix multiply eRPC service clientManager = erpc.client.ClientManager(transport, erpc.basic_codec.BasicCodec) client = erpc_matrix_multiply.client.MatrixMultiplyServiceClient( clientManager) while True: # create matrices with random values matrix1 = fillMatrix(matrix_size, MAX_VALUE) matrix2 = fillMatrix(matrix_size, MAX_VALUE) # print matrices to the console print('\r\nMatrix #1\r\n=========') printMatrix(matrix1) print('\r\nMatrix #2\r\n=========') printMatrix(matrix2) # create result matrix as eRPC reference object resultMatrix = erpc.Reference() # send request to the server print('\r\neRPC request is sent to the server') client.erpcMatrixMultiply(matrix1, matrix2, resultMatrix) # print result matrix's value print('\r\nResult matrix\r\n=============') printMatrix(resultMatrix.value) # wait for key press print('\r\nPress Enter to initiate the next matrix multiplication') sys.stdout.flush() input_fn()
def _handle_convert_dac_adc(self, sequence, codec): # Create reference objects to pass into handler for out/inout parameters. result = erpc.Reference() # Read incoming parameters. numberToConvert = codec.read_uint32() codec.end_read_message() # Invoke user implementation of remote function. self._handler.convert_dac_adc(numberToConvert, result) # Prepare codec for reply message. codec.reset() # Construct reply message. codec.start_write_message( erpc.codec.MessageInfo( type=erpc.codec.MessageType.kReplyMessage, service=interface.Idac_adc.SERVICE_ID, request=interface.Idac_adc.CONVERT_DAC_ADC_ID, sequence=sequence)) if result.value is None: raise ValueError("result is None") codec.write_uint32(result.value) codec.end_write_message()
def _handle_rpc_ble_gatts_callback(self, sequence, codec): # Create reference objects to pass into handler for out/inout parameters. read_cb_data = erpc.Reference() # Read incoming parameters. gatt_if = codec.read_uint8() conn_id = codec.read_uint8() attrib_index = codec.read_uint16() event = codec.read_uint32() property = codec.read_uint16() write_cb_data = codec.read_binary() app_cb_data = codec.read_binary() # Invoke user implementation of remote function. _result = self._handler.rpc_ble_gatts_callback(gatt_if, conn_id, attrib_index, event, property, read_cb_data, write_cb_data, app_cb_data) # Prepare codec for reply message. codec.reset() # Construct reply message. codec.start_write_message(erpc.codec.MessageInfo( type=erpc.codec.MessageType.kReplyMessage, service=interface.Irpc_ble_callback.SERVICE_ID, request=interface.Irpc_ble_callback.RPC_BLE_GATTS_CALLBACK_ID, sequence=sequence)) if read_cb_data.value is None: raise ValueError("read_cb_data is None") codec.write_binary(read_cb_data.value) codec.write_uint32(_result)
def accel_mag_func(BoardName): # variables accelResults = erpc.Reference() client.read_senzor_mag_accel(accelResults) print("Read value from Accelerometer and Magnetometer:") print(" Accelerometer X axis: %f" % accelResults.value.A_x) print(" Accelerometer Y axis: %f" % accelResults.value.A_y) print(" Accelerometer Z axis: %f" % accelResults.value.A_z) if BoardName != "FRDM-KL25Z" and BoardName != "FRDM-KL27Z" and BoardName != "FRDM-KL43Z": print(" Magnetometer X axis: %f" % accelResults.value.M_x) print(" Magnetometer Y axis: %f" % accelResults.value.M_y) print(" Magnetometer Z axis: %f" % accelResults.value.M_z)
def _handle_erpcMatrixMultiply(self, sequence, codec): # Create reference objects to pass into handler for out/inout parameters. result_matrix = erpc.Reference() # Read incoming parameters. matrix1 = [] for _i0 in range(5): _v0 = [] for _i1 in range(5): _v1 = codec.read_int32() _v0.append(_v1) matrix1.append(_v0) matrix2 = [] for _i0 in range(5): _v0 = [] for _i1 in range(5): _v1 = codec.read_int32() _v0.append(_v1) matrix2.append(_v0) codec.end_read_message() # Invoke user implementation of remote function. self._handler.erpcMatrixMultiply(matrix1, matrix2, result_matrix) # Prepare codec for reply message. codec.reset() # Construct reply message. codec.start_write_message(erpc.codec.MessageInfo( type=erpc.codec.MessageType.kReplyMessage, service=interface.IMatrixMultiplyService.SERVICE_ID, request=interface.IMatrixMultiplyService.ERPCMATRIXMULTIPLY_ID, sequence=sequence)) if result_matrix.value is None: raise ValueError("result_matrix is None") for _i0 in result_matrix.value: for _i1 in _i0: codec.write_int32(_i1) codec.end_write_message()
def _handle_adc_get_config(self, sequence, codec): # Create reference objects to pass into handler for out/inout parameters. config = erpc.Reference() # Read incoming parameters. # Invoke user implementation of remote function. self._handler.adc_get_config(config) # Prepare codec for reply message. codec.reset() # Construct reply message. codec.start_write_message(erpc.codec.MessageInfo( type=erpc.codec.MessageType.kReplyMessage, service=interface.Idac_adc.SERVICE_ID, request=interface.Idac_adc.ADC_GET_CONFIG_ID, sequence=sequence)) if config.value is None: raise ValueError("config is None") config.value._write(codec)
def _handle_board_get_name(self, sequence, codec): # Create reference objects to pass into handler for out/inout parameters. name = erpc.Reference() # Read incoming parameters. # Invoke user implementation of remote function. self._handler.board_get_name(name) # Prepare codec for reply message. codec.reset() # Construct reply message. codec.start_write_message(erpc.codec.MessageInfo( type=erpc.codec.MessageType.kReplyMessage, service=interface.Idac_adc.SERVICE_ID, request=interface.Idac_adc.BOARD_GET_NAME_ID, sequence=sequence)) if name.value is None: raise ValueError("name is None") codec.write_string(name.value)
def accel_mag_func(BoardName): # variables accelResults = erpc.Reference() fxosInitFlag = False # check senzor initialization if fxosInitFlag == False: returnVal = client.init_mag_accel() client.read_senzor_mag_accel(accelResults) if returnVal == -1: print("Initializing magnetometer failed!") else: fxosInitFlag = True print("Read value from Accelerometer and Magnetometer:") print(" Accelerometer X axis: %f" % accelResults.value.A_x) print(" Accelerometer Y axis: %f" % accelResults.value.A_y) print(" Accelerometer Z axis: %f" % accelResults.value.A_z) if BoardName != "FRDM-KL25Z" and BoardName != "FRDM-KL27Z" and BoardName != "FRDM-KL43Z": print(" Magnetometer X axis: %f" % accelResults.value.M_x) print(" Magnetometer Y axis: %f" % accelResults.value.M_y) print(" Magnetometer Z axis: %f" % accelResults.value.M_z)
def _handle_read_senzor_mag_accel(self, sequence, inCodec, outCodec): # Create reference objects to pass into handler for out/inout parameters. results = erpc.Reference() # Read incoming parameters. inCodec.end_read_message() # Invoke user implementation of remote function. _result = self._handler.read_senzor_mag_accel(results) # Construct reply message. outCodec.start_write_message( erpc.codec.MessageInfo( type=erpc.codec.MessageType.kReplyMessage, service=interface.Idac_adc.SERVICE_ID, request=interface.Idac_adc.READ_SENZOR_MAG_ACCEL_ID, sequence=sequence)) if results.value is None: raise ValueError("results is None") results.value._write(outCodec) outCodec.end_write_message()
def clientThread(): # create client manager clientManager = erpc.client.ClientManager( transportArbitrator.shared_transport, erpc.basic_codec.BasicCodec) clientManager.arbitrator = transportArbitrator # create client client = erpc_remote_control_app_0.client.remote_control_app_0Client( clientManager) print('eRPC client has been created') # get board configuration boardConfig = erpc.Reference() client.get_board_config(boardConfig) if boardConfig is not None: print('Board configuration:') print('\tDAC: {s}'.format(s=boardConfig.value.DAC)) RGB = boardConfig.value.RGB print('\tLED: Red={r}, Green={g}, Blue={b}'.format(r=RGB[0], g=RGB[1], b=RGB[2])) print('\tMagnetometer: {s}'.format(s=boardConfig.value.MAG)) else: print('Could not get board configuration!') # get ADC config adcConfig = erpc.Reference() client.get_adc_config(adcConfig) print("ADC configuration:") print("\tVref={vref} V\n\tAtomic steps={steps}".format( vref=adcConfig.value.vref, steps=adcConfig.value.atomicSteps)) # menu loop while True: # print menu options print("\n---------------------------") print("eRPC Remote Control example") print("---------------------------") print("-> Press '1' for {dac}ADC conversion".format( dac="DAC-" if boardConfig.value.DAC else "")) print("-> Press '2' for GPIO LED") print("-> Press '3' for Accelerometer and Magnetometer values") print("Or press SW button on board") # wait for user input switchVal = input_fn() # DAC ADC conversion if switchVal == '1': result = erpc.Reference() voltage = 0 atomicSteps = 0 while True: # FRDM-KL27Z has only ADC, skip DAC conversion if boardConfig.value.DAC: # get voltage to convert try: voltage = float( input_fn("Enter voltage <0V - 3.3V>: ")) except ValueError: continue # compute number of atomic steps for DAC atomicSteps = int( voltage / (adcConfig.value.vref / adcConfig.value.atomicSteps)) # check if number to be converted is in range if 0 <= atomicSteps <= 4096: if atomicSteps == 4096: atomicSteps = 4095 # convert client.convert_dac_adc(atomicSteps, result) if boardConfig.value.DAC: print( "DAC is set for {V} V which is {steps} of atomic steps" .format(V=voltage, steps=atomicSteps)) # compute voltage from value in ADC adcVoltage = result.value * (adcConfig.value.vref / adcConfig.value.atomicSteps) print("ADC value: {adc} V".format(adc=adcVoltage)) # check if ADC read value is close to one set with DAC # if not, display info message about connecting theirs pins together if boardConfig.value.DAC and abs(adcVoltage - voltage) >= 0.2: print( "[info] Please connect DAC and ADC pins (described in board.readme) to check DAC value" ) # conversion done, exit loop break else: print("Value for DAC out of range") # GPIO LED elif switchVal == '2': print('Select which LED should be turned on:') print("--> Press '1' for red") print("--> Press '2' for green") if boardConfig.value.RGB[2]: print("--> Press '3' for blue") # wait for user input whichLed = int(input_fn()) if 1 <= whichLed <= 3: # turn on selected LED though one way request client.set_led(whichLed) # Accelerometer and Magnetometer elif switchVal == '3': # read values print("Read value from Accelerometer and Magnetometer:") result = erpc.Reference() status = erpc.Reference() client.read_mag_accel(result, status) if status.value: axis = result.value print("\tAccelerometer axis: x={x}, y={y}, z={z}".format( x=axis.A_x, y=axis.A_y, z=axis.A_z)) if boardConfig.value.MAG: print("\tMagnetometer axis: x={x}, y={y}, z={z}".format( x=axis.M_x, y=axis.M_y, z=axis.M_z)) else: print("Failed to read magnetometer and accelerometer data!")