update examples for mms

Author: lkasso

examples/acc_threshold_detector.py

@@ -1,4 +1,4 @@
-# usage: python acc_threshold_detector.py [mac]
+# usage: python3 acc_threshold_detector.py [mac]
 from __future__ import print_function
 from mbientlab.metawear import MetaWear, libmetawear, parse_value, create_voidp_int, create_voidp
 from mbientlab.metawear.cbindings import *
@@ -54,31 +54,42 @@
     print("Logging data for 10s")
     sleep(10.0)
 
+    # stop acc
     libmetawear.mbl_mw_acc_stop(d.board)
     libmetawear.mbl_mw_acc_disable_acceleration_sampling(d.board)
+    # stop logging
     libmetawear.mbl_mw_logging_stop(d.board)
-
+    # flush for mms
+    libmetawear.mbl_mw_logging_flush_page(d.board)
+    
+    # download handler fxn
     def progress_update_handler(context, entries_left, total_entries):
         if (entries_left == 0):
             e.set()
-
+    # download handler fxn ptr
     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))))
+    
+    # subscribe to logger
     libmetawear.mbl_mw_logger_subscribe(ths_logger, None, callback)
+    
+    # download
     libmetawear.mbl_mw_logging_download(d.board, 0, byref(download_handler))
+    
+    # wait until done
     e.wait()
 
 except RuntimeError as err:
     print(err)
 finally:
     e.clear()
     print("Resetting device")
-    
+    sleep(1.0)
     d.on_disconnect = lambda status: e.set()
+    # reset
     libmetawear.mbl_mw_debug_reset(d.board)
     e.wait()

examples/anonymous_datasignals.py

@@ -1,4 +1,4 @@
-# usage: python anonymous_datasignals.py [mac]
+# usage: python3 anonymous_datasignals.py [mac]
 from __future__ import print_function
 from mbientlab.metawear import MetaWear, libmetawear, parse_value
 from mbientlab.metawear.cbindings import *
@@ -11,66 +11,85 @@
 if sys.version_info[0] == 2:
     range = xrange
 
+# connect
 metawear = MetaWear(sys.argv[1])
 metawear.connect()
 print("Connected")
 
+# setup
 e = Event()
 result = {}
+
+# handler fxn
 def handler(ctx, board, signals, len):
     result['length'] = len
     result['signals'] = cast(signals, POINTER(c_void_p * len)) if signals is not None else None
     e.set()
+# handler fxn ptr
 handler_fn = FnVoid_VoidP_VoidP_VoidP_UInt(handler)
 
+# datahandler class
 class DataHandler:
     def __init__(self, signal):
         self.identifier = libmetawear.mbl_mw_anonymous_datasignal_get_identifier(signal)
         self.data_handler_fn = FnVoid_VoidP_DataP(lambda ctx, ptr: print({"identifier": self.identifier, "epoch": ptr.contents.epoch, "value": parse_value(ptr)}))
 
-print("Creating anonymous signals")
+# setup ble
 libmetawear.mbl_mw_settings_set_connection_parameters(metawear.board, 7.5, 7.5, 0, 6000)
 sleep(1.0)
+
+# create anonymous signal
+print("Creating anonymous signals")
 libmetawear.mbl_mw_metawearboard_create_anonymous_datasignals(metawear.board, None, handler_fn)
 e.wait()
 
+# make sense of logging signals found
 if (result['signals'] == None):
     if (result['length'] != 0):
         print("Error creating anonymous signals, status = " + str(result['length']))
     else:
         print("No active loggers detected")
 else:
     e.clear()
+    # stop logging
     libmetawear.mbl_mw_logging_stop(metawear.board)
-
+    # print results
     print(str(result['length']) + " active loggers discovered")
     handlers = []
+    # analyze results
     for x in range(0, result['length']):
         wrapper = DataHandler(result['signals'].contents[x])
+        # subscribe to download if good signal
         libmetawear.mbl_mw_anonymous_datasignal_subscribe(result['signals'].contents[x], None, wrapper.data_handler_fn)
         handlers.append(wrapper)
-
+    # progress handler fxn
     def progress_update_handler(ctx, left, total):
         if (left == 0):
             e.set()
-
+    # unknown entry handler fxn
     def unknown_entry_handler(ctx, id, epoch, data, length):
         print("unknown entry = " + str(id))
-
+    # download handlers
     print("Downloading log")
     progress_update_fn = FnVoid_VoidP_UInt_UInt(progress_update_handler)
     unknown_entry_fn = FnVoid_VoidP_UByte_Long_UByteP_UByte(unknown_entry_handler)
     download_handler= LogDownloadHandler(context = None, received_progress_update = progress_update_fn, 
             received_unknown_entry = unknown_entry_fn, received_unhandled_entry = cast(None, FnVoid_VoidP_DataP))
+    # download
     libmetawear.mbl_mw_logging_download(metawear.board, 10, byref(download_handler))
+    # wait until done
     e.wait()
-
+    # wait 1s
+    sleep(1.0)
     print("Download completed")
+    # erase macros
     libmetawear.mbl_mw_macro_erase_all(metawear.board)
+    sleep(1.0)
+    # reset board
     libmetawear.mbl_mw_debug_reset_after_gc(metawear.board)
-
+    sleep(1.0)
     e.clear()
     metawear.on_disconnect = lambda status: e.set()
-    
+    # disconnect
     libmetawear.mbl_mw_debug_disconnect(metawear.board)
     e.wait()

examples/calibrate.py

@@ -1,51 +1,71 @@
-# usage: python calibrate.py [mac]
+# usage: python3 calibrate.py [mac]
+# This example is showing how to calibrate the sensor fusion on the metawear
 from mbientlab.metawear import MetaWear, libmetawear, parse_value
 from mbientlab.metawear.cbindings import *
 from time import sleep
 from threading import Event
 
 import sys
 
+# connect
 device = MetaWear(sys.argv[1])
 device.connect()
 print("Connected")
 
+# event
 e = Event()
 
+# calibration data fxn
 def calibration_data_handler(ctx, board, pointer):
     print("calibration data: %s" % (pointer.contents))
+    # write the calib data to the metawear
     libmetawear.mbl_mw_sensor_fusion_write_calibration_data(board, pointer)
     libmetawear.mbl_mw_memory_free(pointer)
     e.set()
+# calibration data fxn ptr
 fn_wrapper_01 = FnVoid_VoidP_VoidP_CalibrationDataP(calibration_data_handler)
 
+# get calibration state signal
 signal = libmetawear.mbl_mw_sensor_fusion_calibration_state_data_signal(device.board)
+
+# calibration handler fxn
 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):
-        
+        # read
         libmetawear.mbl_mw_sensor_fusion_read_calibration_data(device.board, None, fn_wrapper_01)
     else:
         sleep(1.0)
         libmetawear.mbl_mw_datasignal_read(signal)
+# calbration handle fxn ptr
 fn_wrapper_02 = FnVoid_VoidP_DataP(calibration_handler)
 
+# setup sensor fusion config
 libmetawear.mbl_mw_sensor_fusion_set_mode(device.board, SensorFusionMode.NDOF)
 libmetawear.mbl_mw_sensor_fusion_write_config(device.board)
 
+# subscribe to the calibration sensor fusion signal
 libmetawear.mbl_mw_datasignal_subscribe(signal, None, fn_wrapper_02)
+
+# start
 libmetawear.mbl_mw_sensor_fusion_start(device.board)
+
+# read
 libmetawear.mbl_mw_datasignal_read(signal)
+
+# wait for event
 e.wait()
 
 print("Disconnecting")
 e.clear()
 device.on_disconnect = lambda s: e.set()
+# stop
 libmetawear.mbl_mw_sensor_fusion_stop(device.board)
+sleep(2.0)
+# disconnect
 libmetawear.mbl_mw_debug_disconnect(device.board)
-
-e.wait()
+# wait until done
+e.wait()

examples/data_fuser.py

@@ -9,59 +9,78 @@
 states = []
 
 class State:
+    # init
     def __init__(self, device):
         self.device = device
         self.callback = cbindings.FnVoid_VoidP_DataP(self.data_handler)
         self.processor = None
-
+    # download data callback fxn
     def data_handler(self, ctx, data):
         values = parse_value(data, n_elem = 2)
         print("acc: (%.4f,%.4f,%.4f), gyro; (%.4f,%.4f,%.4f)" % (values[0].x, values[0].y, values[0].z, values[1].x, values[1].y, values[1].z))
-
+    # setup
     def setup(self):
+        # ble settings
         libmetawear.mbl_mw_settings_set_connection_parameters(self.device.board, 7.5, 7.5, 0, 6000)
         sleep(1.5)
-
+        # events
         e = Event()
-
+        # processor callback fxn
         def processor_created(context, pointer):
             self.processor = pointer
             e.set()
+        # processor fxn ptr
         fn_wrapper = cbindings.FnVoid_VoidP_VoidP(processor_created)
-        
+        # get acc signal
         acc = libmetawear.mbl_mw_acc_get_acceleration_data_signal(self.device.board)
-        gyro = libmetawear.mbl_mw_gyro_bmi160_get_rotation_data_signal(self.device.board)
-
+        # get gyro signal - MMRl, MMR, MMc ONLY
+        #gyro = libmetawear.mbl_mw_gyro_bmi160_get_rotation_data_signal(self.device.board)
+        # get gyro signal - MMRS ONLY
+        gyro = libmetawear.mbl_mw_gyro_bmi270_get_rotation_data_signal(self.device.board)
+        # create signals variable
         signals = (c_void_p * 1)()
         signals[0] = gyro
+        # create acc + gyro signal fuser
         libmetawear.mbl_mw_dataprocessor_fuser_create(acc, signals, 1, None, fn_wrapper)
+        # wait for fuser to be created
         e.wait()
-
+        # subscribe to the fused signal
         libmetawear.mbl_mw_datasignal_subscribe(self.processor, None, self.callback)
-
+    # start
     def start(self):
-    
-        libmetawear.mbl_mw_gyro_bmi160_enable_rotation_sampling(self.device.board)
+        # start gyro sampling - MMRL, MMC, MMR only
+        #libmetawear.mbl_mw_gyro_bmi160_enable_rotation_sampling(self.device.board)
+        # start gyro sampling - MMS ONLY
+        libmetawear.mbl_mw_gyro_bmi270_enable_rotation_sampling(self.device.board)
+        # start acc sampling
         libmetawear.mbl_mw_acc_enable_acceleration_sampling(self.device.board)
-
-        libmetawear.mbl_mw_gyro_bmi160_start(self.device.board)
+        # start gyro - MMRL, MMC, MMR only
+        #libmetawear.mbl_mw_gyro_bmi160_start(self.device.board)
+        # start gyro sampling - MMS ONLY
+        libmetawear.mbl_mw_gyro_bmi270_start(self.device.board)
+        # start acc
         libmetawear.mbl_mw_acc_start(self.device.board)
 
+# connect
 for i in range(len(argv) - 1):
     d = MetaWear(argv[i + 1])
     d.connect()
     print("Connected to " + d.address)
     states.append(State(d))
 
+# configure
 for s in states:
     print("Configuring %s" % (s.device.address))
     s.setup()
 
+# start
 for s in states:
     s.start()
 
+# wait 10 s
 sleep(10.0)
 
+# reset
 print("Resetting devices")
 events = []
 for s in states:
@@ -72,4 +91,4 @@ def start(self):
     libmetawear.mbl_mw_debug_reset(s.device.board)
 
 for e in events:
-    e.wait()
+    e.wait()