Merge pull request #23 from mbientlab/mw_usb_rebase

usb: add mw usb class for scanning and connecting over usb serial.

Author: lkasso

examples/log_acc_perf.py

@@ -0,0 +1,88 @@
+# usage: python3 log_acc_perf.py [mac]
+from __future__ import print_function
+from mbientlab.metawear import MetaWear, libmetawear, parse_value, create_voidp, create_voidp_int
+from mbientlab.metawear.cbindings import *
+from threading import Event
+
+import sys
+import time
+
+print("Searching for device...")
+d = MetaWear(sys.argv[1])
+d.connect()
+print("Connected to " + d.address)
+
+print("Configuring device")
+
+try:
+    print("Get and log acc signal")
+    signal = libmetawear.mbl_mw_acc_get_acceleration_data_signal(d.board)
+    logger = create_voidp(lambda fn: libmetawear.mbl_mw_datasignal_log(signal, None, fn), resource = "acc_logger")
+    
+    print("Start logging")
+    libmetawear.mbl_mw_logging_start(d.board, 0)
+    
+    print("Start acc")
+    libmetawear.mbl_mw_acc_set_odr(d.board, 400.)
+    libmetawear.mbl_mw_acc_write_acceleration_config(d.board)
+    libmetawear.mbl_mw_acc_enable_acceleration_sampling(d.board)
+    libmetawear.mbl_mw_acc_start(d.board)
+
+    print("Logging data for 10s")
+    time.sleep(10.0)
+
+    print("Setop acc")
+    libmetawear.mbl_mw_acc_stop(d.board)
+    libmetawear.mbl_mw_acc_disable_acceleration_sampling(d.board)
+    
+    print("Stop logging")
+    libmetawear.mbl_mw_logging_stop(d.board)
+
+    print("Flush cache if MMS")
+    libmetawear.mbl_mw_logging_flush_page(d.board)
+    
+    print("Downloading data")
+    libmetawear.mbl_mw_settings_set_connection_parameters(d.board, 7.5, 7.5, 0, 6000)
+    time.sleep(1.0)
+
+    print("Setup Download handler")
+    e = Event()
+    read_count = 0
+    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))
+
+    def data_handler(p):
+        global read_count
+        read_count += 2
+        #print("{epoch: %d, value: %s}" % (p.contents.epoch, parse_value(p)))
+
+    callback = FnVoid_VoidP_DataP(lambda ctx, p: data_handler(p))
+    
+    print("Subscribe to logger")
+    libmetawear.mbl_mw_logger_subscribe(logger, None, callback)
+    
+    print("Download data")
+    dl_time = time.time()
+    libmetawear.mbl_mw_logging_download(d.board, 0, byref(download_handler))
+    e.wait()
+    dl_time = time.time() - dl_time
+    print("Entry Read Count: %d" % (read_count))
+    print("Entry Read Rate: %0.1f entries/s" % (read_count/dl_time))	
+
+except RuntimeError as err:
+    print(err)
+finally:
+    print("Resetting device")
+    
+    e = Event()
+    d.on_disconnect = lambda status: e.set()
+    print("Debug reset")
+    libmetawear.mbl_mw_debug_reset(d.board)
+    e.wait()

examples/log_download.py

@@ -0,0 +1,104 @@
+# usage: python3 log_download.py [mac]
+from __future__ import print_function
+from mbientlab.metawear import MetaWear, libmetawear, parse_value
+from mbientlab.metawear.cbindings import *
+from time import sleep, strftime
+from threading import Event
+
+import platform
+import sys
+
+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.filename = self.identifier.decode() + '-' + strftime("%m-%d-%Y-%H-%M-%S") + '.csv'
+        self.file = None
+        #self.data_handler_fn = FnVoid_VoidP_DataP(lambda ctx, ptr: print({"identifier": self.identifier, "epoch": ptr.contents.epoch, "value": parse_value(ptr)}))
+        self.data_handler_fn = FnVoid_VoidP_DataP(lambda ctx, ptr: self.write(ctx, ptr))
+    def write(self, ctx, ptr):
+        d_struct = parse_value(ptr)
+        if self.file is None:
+            print("Opening %s for write." % (self.filename))
+            self.file = open(self.filename, 'w')
+            self.file.write('epoch,' + ','.join([f[0] for f in d_struct._fields_]) + '\n')
+        data = [str(getattr(d_struct, f[0])) for f in d_struct._fields_]
+        self.file.write(str(ptr.contents.epoch) + ',' + ','.join(data) + '\n')
+    def __del__(self):
+        if self.file is not None:
+            self.file.close()
+
+# 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")
+    e.clear()
+    metawear.on_disconnect = lambda status: e.set()
+    # disconnect
+    libmetawear.mbl_mw_debug_disconnect(metawear.board)
+    e.wait()
+

examples/stream_gyro_packed.py

@@ -70,7 +70,7 @@ def gyro_data_handler(self, ctx, data):
     libmetawear.mbl_mw_gyro_bmi270_stop(s.device.board)
     libmetawear.mbl_mw_gyro_bmi270_disable_rotation_sampling(s.device.board)
 
-    gyro = llibmetawear.mbl_mw_gyro_bmi270_get_packed_rotation_data_signal(s.device.board)
+    gyro = libmetawear.mbl_mw_gyro_bmi270_get_packed_rotation_data_signal(s.device.board)
     libmetawear.mbl_mw_datasignal_unsubscribe(gyro)
 
     libmetawear.mbl_mw_debug_disconnect(s.device.board)

mbientlab/metawear/__init__.py

@@ -15,6 +15,7 @@
 init_libmetawear(libmetawear)
 
 from .metawear import MetaWear
+from .metawear import MetaWearUSB
 
 _value_parsers = {
     DataTypeId.UINT32: lambda p: cast(p.contents.value, POINTER(c_uint)).contents.value,