def read_sensor_register(self, sensor_driver, register, length=1):
"""Read sensor register value(s)
Args:
sensor_driver(SensorDriver): sensor driver instance
register(int): Register value where reading starts
length(int): how many bytes to read. Defaults to 1
Returns:
array.array: sensor register values as binary array
Note:
Sensor must be first added with add_sensor() before this operation can be done.
"""
_, sensor_resource = self.found_sensors[sensor_driver.name]
bus1_name = sensor_driver.selected_connectivity
if bus1_name == BUS1_I2C:
target = sensor_resource[CFG_TARGET]
sad = sensor_resource[CFG_SAD]
with DelayedKeyboardInterrupt():
return self.kx_adapter.adapter_read_sensor_register_i2c(
target, sad, register, length)
elif bus1_name == BUS1_SPI:
target = sensor_resource[CFG_TARGET]
cs = sensor_resource[CFG_CS]
if sensor_resource[CFG_SPI_PROTOCOL] == 1:
# With Kionix components, MSB must be set 1 to indicate reading
register = register | 1 << 7
with DelayedKeyboardInterrupt():
return self.kx_adapter.adapter_read_sensor_register_spi(
target, cs, register, length)
raise EvaluationKitException('Unable read sensor register.')
def write_sensor_register(self, sensor_driver, register, values):
"""Write sensor register value(s)
Args:
sensor_driver(SensorDriver): sensor driver instance
register(int): Register value where writing starts
values ?
Note:
Sensor must be first added with add_sensor() before this operation can be done.
"""
# TODO 2 check that connection is active
_, sensor_resource = self.found_sensors[sensor_driver.name]
bus1_name = sensor_driver.selected_connectivity
if bus1_name == BUS1_I2C:
target = sensor_resource[CFG_TARGET]
sad = sensor_resource[CFG_SAD]
with DelayedKeyboardInterrupt():
return self.kx_adapter.adapter_write_sensor_register_i2c(
target, sad, register, values)
elif bus1_name == BUS1_SPI:
target = sensor_resource[CFG_TARGET]
cs = sensor_resource[CFG_CS]
if sensor_resource[CFG_SPI_PROTOCOL] == 1:
# When using SPI, Kionix sensors require that the address' MSB is
# cleared to indicate that this is a write.
register &= ~(1 << 7)
with DelayedKeyboardInterrupt():
# TODO 3 CS polarity is hard coded active low. Need to be configurable if active high devices in use
return self.kx_adapter.adapter_write_sensor_register_spi(
target, cs, register, values)
else:
raise EvaluationKitException(
'Unable write data to sensor register.')
def write_gpio_pin(self, gpio_pin, value):
"""Set GPIO line value based don HW index
Args:
gpio_pin(int): pin index (physical index)
value(int): 0 or 1
"""
assert isinstance(gpio_pin, int)
assert value in [0, 1]
# Update _pin_mode_cache.
current_state = self._pin_mode_cache.get(gpio_pin, None)
if current_state != _GPIO_STATE_OUTPUT:
LOGGER.debug("Changing pin %d mode from %s to %s" %
(gpio_pin, current_state, _GPIO_STATE_OUTPUT))
self._pin_mode_cache[gpio_pin] = _GPIO_STATE_OUTPUT
with DelayedKeyboardInterrupt():
return self.kx_adapter.adapter_write_gpio(gpio_pin, value)
def read_gpio_pin(self, gpio_pin, pull=NOPULL):
"""Read GPIO line value based on HW index
Args:
gpio_pin(int): pin index (physical index)
pull(int): NOPULL, PULLDOWN, PULLUP = range(3). Defalults to NOPULL
"""
current_state = self._pin_mode_cache.get(gpio_pin, None)
if current_state != (_GPIO_STATE_INPUT, pull):
LOGGER.debug("Changing pin %d mode from %s to %s" %
(gpio_pin, current_state, _GPIO_STATE_INPUT))
LOGGER.debug("Changing pull to %s" % pull)
self.kx_adapter.configure_pin_as_input(gpio_pin=gpio_pin,
drivemode=pull)
self._pin_mode_cache[gpio_pin] = (_GPIO_STATE_INPUT, pull)
with DelayedKeyboardInterrupt():
return self.kx_adapter.adapter_read_gpio(gpio_pin)
def read_data_stream(self,
loop=None,
console=True,
log_file_name=None,
callback=None,
max_timeout_count=0,
additional_info=None):
"""Main loop for reading stream data after data streams are activated.
Args:
loop(int/None): Number of values to read. If None then infinite loop until KeyboardInterrupt is received (defaults to None)
concole(bool): print values to console (defaults to True)
log_file_name(string/None): Log file to write. (defaults to None)
callback(function): function to call after new data is received.
max_timeout_count(int/None): break after bus2 time out count is reached. If none then loop forever regardless timeouts
additional_info(string): info passed to SensorDataLogger instance
"""
count = 0 # count of received data samples
timeout_count = 0 # how many timeouts received
data_logger = SensorDataLogger(console=console,
log_file_name=log_file_name,
additional_info=additional_info)
# subscribe sensor data from FW
self._start_streaming()
# On FW1 channels are known only after that _start_streaming()
# print out header text, replace text "ch" with channel number
for channel, request in iter(self.msg_ind_dict.items()):
data_logger.add_channel(request.msg_hdr, channel)
data_logger.start()
try:
# main loop for reading the data
while (loop is None) or (count < loop):
with DelayedKeyboardInterrupt():
# TODO 3 error handling if message was not macro message : macro_index >= EVKIT_MSG_MACRO_IND_BASE etc. logic
macro_index, resp = self.adapter.receive_message()
if resp is None:
LOGGER.debug("Timeout when receiving data")
timeout_count += 1
if max_timeout_count is not None \
and timeout_count >= max_timeout_count:
raise ProtocolBus1Exception(
'Timeout when receiving data. Max timeout count reached.'
)
continue
# find correct message type to get information how message is interpreted
received_messsage_type = self.msg_ind_dict[macro_index]
if len(resp) != received_messsage_type.msg_size:
LOGGER.error(
"Length of received message was wrong (%d). Expected (%d)"
% (len(resp), received_messsage_type.msg_size))
else:
fmt = self.msg_ind_dict[macro_index].msg_fmt
# unpack the raw data
data = struct.unpack(fmt, resp)
# rotate if 3d data
data = self.msg_ind_dict[
macro_index].axis_mapper.map_xyz_axis(data)
# log the data
data_logger.feed_values(data)
count += 1
if callback is not None:
# callback function returns False if need to stop reading
if callback(data) is False:
break
except KeyboardInterrupt:
# CTRL+C will stop data reading
pass
finally:
# after CTRL+C or other exception, print end time stamp and stop reading sensor data
# unsibscribe data from FW
self._stop_streaming()
data_logger.stop()
if count == 0:
LOGGER.error("No stream data received.")