From d48c30ee41b40ca97d7ff964fca47e3e3a4400eb Mon Sep 17 00:00:00 2001 From: Eric Tsai Date: Wed, 12 Dec 2018 23:54:55 -0800 Subject: [PATCH] Added more example scripts --- examples/acc_threshold_detector.py | 120 +++++++++++++++++++++++++++++ examples/calibrate.py | 51 ++++++++++++ examples/multi_device.py | 4 +- 3 files changed, 173 insertions(+), 2 deletions(-) create mode 100644 examples/acc_threshold_detector.py create mode 100644 examples/calibrate.py diff --git a/examples/acc_threshold_detector.py b/examples/acc_threshold_detector.py new file mode 100644 index 0000000..45b1ec0 --- /dev/null +++ b/examples/acc_threshold_detector.py @@ -0,0 +1,120 @@ +# usage: python acc_threshold_detector [mac] +from __future__ import print_function +from mbientlab.metawear import MetaWear, libmetawear, parse_value +from mbientlab.metawear.cbindings import * +from time import sleep +from threading import Event + +# CURRENT: +# Sample accelerometer at 50Hz +# Use the rms to combine X,Y,Z +# Use the average to downsample to about 4Hz (averaging 8 samples) +# Use the threshold detector to detect a bump +# Also log all the event and download it later + +print("Searching for device...") +d = MetaWear(sys.argv[1]) +d.connect() +print("Connected to " + d.address) +print("Configuring device") +libmetawear.mbl_mw_settings_set_connection_parameters(d.board, 7.5, 7.5, 0, 6000) +sleep(1.0) + +e = Event() +def create_voidp(create, resource): + result = [None] + def handler(ctx, pointer): + result[0] = RuntimeError("Could not create " + resource) if pointer == None else pointer + e.set() + + callback_wrapper = FnVoid_VoidP_VoidP(handler) + create(callback_wrapper) + e.wait() + + e.clear() + if (result[0] is RuntimeError): + raise result[0] + return result[0] + +def end_event_record(evt): + result = [None] + def handler(ctx, pointer, status): + if (status != Const.STATUS_OK): + result[0] = RuntimeError("Event recording returned a non-zero status (%d)" % (status)) + e.set() + + callback_wrapper = FnVoid_VoidP_VoidP_Int(handler) + libmetawear.mbl_mw_event_end_record(evt, None, callback_wrapper) + e.wait() + + e.clear() + if (result[0] is RuntimeError): + raise result[0] + +try: + # setup accelerometer (odr 50Hz and 2Gs) + libmetawear.mbl_mw_acc_bmi160_set_odr(d.board, AccBmi160Odr._50Hz) + libmetawear.mbl_mw_acc_set_range(d.board, 2.0) + libmetawear.mbl_mw_acc_write_acceleration_config(d.board) + + # start to setup rms->avg->thresh->log chain + acc_signal = libmetawear.mbl_mw_acc_get_acceleration_data_signal(d.board) + + # create RMS - root mean square of acc X,Y,Z + rms = create_voidp(lambda fn: libmetawear.mbl_mw_dataprocessor_rms_create(acc_signal, None, fn), "RMS") + print("RMS created") + + # setup averager - averages over 8 RMS samples @ 50Hz + avg = create_voidp(lambda fn: libmetawear.mbl_mw_dataprocessor_average_create(rms, 8, None, fn), "averager") + print("Averager created") + + # setup event on avg - reset averager + libmetawear.mbl_mw_event_record_commands(avg) + libmetawear.mbl_mw_dataprocessor_average_reset(avg) + end_event_record(avg) + + # setup threshold detector - detect anything above 1 + ths = create_voidp(lambda fn: libmetawear.mbl_mw_dataprocessor_threshold_create(avg, ThresholdMode.BINARY, 1.0, 0.0, None, fn), "threshold detector") + print("Threshold detector created") + + # setup logger - log the final signal of the averaged data + ths_logger = create_voidp(lambda fn: libmetawear.mbl_mw_datasignal_log(ths, None, fn), "threshold logger") + print("Threshold logger created") + + # start accelerometer and event logging + libmetawear.mbl_mw_acc_enable_acceleration_sampling(d.board) + libmetawear.mbl_mw_acc_start(d.board) + libmetawear.mbl_mw_logging_start(d.board, 0) + + # change this to any time amount you want + print("Logging data for 10s") + sleep(10.0) + + libmetawear.mbl_mw_acc_stop(d.board) + libmetawear.mbl_mw_acc_disable_acceleration_sampling(d.board) + libmetawear.mbl_mw_logging_stop(d.board) + + def progress_update_handler(context, entries_left, total_entries): + if (entries_left == 0): + e.set() + + fn_wrapper = FnVoid_VoidP_UInt_UInt(progress_update_handler) + download_handler= LogDownloadHandler(context = None, \ + received_progress_update = fn_wrapper, \ + received_unknown_entry = cast(None, FnVoid_VoidP_UByte_Long_UByteP_UByte), \ + received_unhandled_entry = cast(None, FnVoid_VoidP_DataP)) + + callback = FnVoid_VoidP_DataP(lambda ctx, p: print("threshold crossed: {epoch: %d, value: %s}" % (p.contents.epoch, parse_value(p)))) + libmetawear.mbl_mw_logger_subscribe(ths_logger, None, callback) + libmetawear.mbl_mw_logging_download(d.board, 0, byref(download_handler)) + e.wait() + +except RuntimeError as err: + print(err) +finally: + e.clear() + print("Resetting device") + + d.on_disconnect = lambda status: e.set() + libmetawear.mbl_mw_debug_reset(d.board) + e.wait() diff --git a/examples/calibrate.py b/examples/calibrate.py new file mode 100644 index 0000000..443b1f3 --- /dev/null +++ b/examples/calibrate.py @@ -0,0 +1,51 @@ +# usage: python led.py [mac] +from mbientlab.metawear import MetaWear, libmetawear, parse_value +from mbientlab.metawear.cbindings import * +from time import sleep +from threading import Event + +import sys + +device = MetaWear(sys.argv[1]) +device.connect() +print("Connected") + +e = Event() + +def calibration_data_handler(ctx, board, pointer): + print("calibration data: %s" % (pointer.contents)) + libmetawear.mbl_mw_sensor_fusion_write_calibration_data(board, pointer) + libmetawear.mbl_mw_memory_free(pointer) + e.set() +fn_wrapper_01 = FnVoid_VoidP_VoidP_CalibrationDataP(calibration_data_handler) + +signal = libmetawear.mbl_mw_sensor_fusion_calibration_state_data_signal(device.board) +def calibration_handler(ctx, pointer): + value = parse_value(pointer) + print("state: %s" % (value)) + + if (value.accelrometer == Const.SENSOR_FUSION_CALIBRATION_ACCURACY_HIGH and \ + value.gyroscope == Const.SENSOR_FUSION_CALIBRATION_ACCURACY_HIGH and \ + value.magnetometer == Const.SENSOR_FUSION_CALIBRATION_ACCURACY_HIGH): + + libmetawear.mbl_mw_sensor_fusion_read_calibration_data(device.board, None, fn_wrapper_01) + else: + sleep(1.0) + libmetawear.mbl_mw_datasignal_read(signal) +fn_wrapper_02 = FnVoid_VoidP_DataP(calibration_handler) + +libmetawear.mbl_mw_sensor_fusion_set_mode(device.board, SensorFusionMode.NDOF) +libmetawear.mbl_mw_sensor_fusion_write_config(device.board) + +libmetawear.mbl_mw_datasignal_subscribe(signal, None, fn_wrapper_02) +libmetawear.mbl_mw_sensor_fusion_start(device.board) +libmetawear.mbl_mw_datasignal_read(signal) +e.wait() + +print("Disconnecting") +e.clear() +device.on_disconnect = lambda s: e.set() +libmetawear.mbl_mw_sensor_fusion_stop(device.board) +libmetawear.mbl_mw_debug_disconnect(device.board) + +e.wait() \ No newline at end of file diff --git a/examples/multi_device.py b/examples/multi_device.py index 33529e8..85b3ab5 100644 --- a/examples/multi_device.py +++ b/examples/multi_device.py @@ -18,7 +18,7 @@ def __init__(self, device): self.callback = FnVoid_VoidP_DataP(self.data_handler) def data_handler(self, ctx, data): - #print("%s -> %s" % (self.device.address, parse_value(data))) + print("%s -> %s" % (self.device.address, parse_value(data))) self.samples+= 1 states = [] @@ -53,7 +53,7 @@ def data_handler(self, ctx, data): libmetawear.mbl_mw_datasignal_unsubscribe(signal) libmetawear.mbl_mw_debug_disconnect(s.device.board) -sleep(1.0) +sleep(30.0) print("Total Samples Received") for s in states: