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!")
