api v0.6.0 commit

Author: scaryghost

MetaWear-SDK-Cpp

@@ -0,0 +1,72 @@
+from ctypes import c_void_p, cast, POINTER
+from mbientlab.metawear import MetaWear, libmetawear, parse_value, cbindings
+from time import sleep
+from threading import Event
+from sys import argv
+
+states = []
+
+class State:
+    def __init__(self, device):
+        self.device = device
+        self.callback = cbindings.FnVoid_VoidP_DataP(self.data_handler)
+        self.processor = None
+
+    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))
+
+    def setup(self):
+        libmetawear.mbl_mw_settings_set_connection_parameters(self.device.board, 7.5, 7.5, 0, 6000)
+        sleep(1.5)
+
+        e = Event()
+
+        def processor_created(context, pointer):
+            self.processor = pointer
+            e.set()
+        fn_wrapper = cbindings.FnVoid_VoidP_VoidP(processor_created)
+        
+        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)
+
+        signals = (c_void_p * 1)()
+        signals[0] = gyro
+        libmetawear.mbl_mw_dataprocessor_fuser_create(acc, signals, 1, None, fn_wrapper)
+        e.wait()
+
+        libmetawear.mbl_mw_datasignal_subscribe(self.processor, None, self.callback)
+
+    def start(self):
+        libmetawear.mbl_mw_gyro_bmi160_enable_rotation_sampling(self.device.board)
+        libmetawear.mbl_mw_acc_enable_acceleration_sampling(self.device.board)
+
+        libmetawear.mbl_mw_gyro_bmi160_start(self.device.board)
+        libmetawear.mbl_mw_acc_start(self.device.board)
+        
+for i in range(len(argv) - 1):
+    d = MetaWear(argv[i + 1])
+    d.connect()
+    print("Connected to " + d.address)
+    states.append(State(d))
+
+for s in states:
+    print("configuring %s" % (s.device.address))
+    s.setup()
+
+for s in states:
+    s.start()
+
+sleep(10.0)
+
+print("resetting devices")
+events = []
+for s in states:
+    e = Event()
+    events.append(e)
+
+    s.device.on_disconnect = lambda s: e.set()
+    libmetawear.mbl_mw_debug_reset(s.device.board)
+
+for e in events:
+    e.wait()

examples/data_fuser.py

@@ -30,21 +30,29 @@
     DataTypeId.LOGGING_TIME: lambda p: cast(p.contents.value, POINTER(LoggingTime)).contents,
     DataTypeId.BTLE_ADDRESS: lambda p: cast(p.contents.value, POINTER(BtleAddress)).contents,
     DataTypeId.BOSCH_ANY_MOTION: lambda p: cast(p.contents.value, POINTER(BoschAnyMotion)).contents,
-    DataTypeId.CALIBRATION_STATE: lambda p: cast(p.contents.value, POINTER(CalibrationState)).contents
+    DataTypeId.CALIBRATION_STATE: lambda p: cast(p.contents.value, POINTER(CalibrationState)).contents,
+    DataTypeId.BOSCH_TAP: lambda p: cast(p.contents.value, POINTER(BoschTap)).contents
 }
-def parse_value(p_data):
+def parse_value(pointer, **kwargs):
     """
     Helper function to extract the value from a Data object.  If you are storing the values to be used at a later time, 
     call copy.deepcopy preserve the value.  You do not need to do this if the underlying type is a native type or a byte array
     @params:
-        p_data      - Required  : Pointer to a Data object
+        pointer     - Required  : Pointer to a Data object
+        n_elem      - Optional  : Nummber of elements in the value array if the type_id attribute is DataTypeId.DATA_ARRAY
     """
-    if (p_data.contents.type_id in _value_parsers):
-        return _value_parsers[p_data.contents.type_id](p_data)
-    elif (p_data.contents.type_id == DataTypeId.SENSOR_ORIENTATION):
-        return _value_parsers[DataTypeId.INT32](p_data)
-    elif (p_data.contents.type_id == DataTypeId.BYTE_ARRAY):
-        array_ptr= cast(p_data.contents.value, POINTER(c_ubyte * p_data.contents.length))
-        return [array_ptr.contents[i] for i in range(0, p_data.contents.length)]
+    if (pointer.contents.type_id in _value_parsers):
+        return _value_parsers[pointer.contents.type_id](pointer)
+    elif (pointer.contents.type_id == DataTypeId.SENSOR_ORIENTATION):
+        return _value_parsers[DataTypeId.INT32](pointer)
+    elif (pointer.contents.type_id == DataTypeId.BYTE_ARRAY):
+        array_ptr= cast(pointer.contents.value, POINTER(c_ubyte * pointer.contents.length))
+        return [array_ptr.contents[i] for i in range(0, pointer.contents.length)]
+    elif (pointer.contents.type_id == DataTypeId.DATA_ARRAY):
+        if 'n_elem' in kwargs:
+            values = cast(pointer.contents.value, POINTER(POINTER(Data) * kwargs['n_elem']))
+            return [parse_value(values.contents[i]) for i in range(0, kwargs['n_elem'])]
+        else:
+            raise RuntimeError("Missing optional parameter 'n_elem' for parsing DataTypeId.DATA_ARRAY value")
     else:
-        raise RuntimeError('Unrecognized data type id: ' + str(p_data.contents.type_id))
+        raise RuntimeError('Unrecognized data type id: ' + str(pointer.contents.type_id))

mbientlab/metawear/__init__.py

@@ -93,14 +93,6 @@ def __init__(self, address, **kwargs):
 
         if 'deserialize' not in kwargs or kwargs['deserialize']:
             self.deserialize()
-            dev_info = libmetawear.mbl_mw_metawearboard_get_device_information(self.board)
-            self.info = {
-                'hardware': dev_info.contents.hardware_revision.decode('utf8'),
-                'manufacturer': dev_info.contents.manufacturer.decode('utf8'),
-                'serial': dev_info.contents.serial_number.decode('utf8'),
-                'firmware': dev_info.contents.firmware_revision.decode('utf8'),
-                'model': dev_info.contents.model_number.decode('utf8')
-            }
 
         try:
             os.makedirs(self.cache)
@@ -125,65 +117,82 @@ def disconnect(self):
         """
         self.warble.disconnect()
 
-    def connect(self, **kwargs):
+    def connect_async(self, handler, **kwargs):
         """
         Connects to the MetaWear board and initializes the SDK.  You must first connect to the board before using 
         any of the SDK functions
         @params:
+            handler     - Required  : `(BaseException) -> void` function to handle the result of the task
             serialize   - Optional  : Serialize and cached C++ SDK state after initializaion, defaults to true
         """
-        e = Event()
-        result = None
+
         def completed(err):
             if (err != None):
-                result = err
-            e.set()
+                handler(err)
+            else:
+                if not self.in_metaboot_mode:
+                    def init_handler(context, device, status):
+                        if status != Const.STATUS_OK:
+                            self.disconnect()
+                            handler(RuntimeError("Error initializing the API (%d)" % (status)))
+                        else:
+                            if 'serialize' not in kwargs or kwargs['serialize']:
+                                self.serialize()
+                            handler(None)
+
+                    self._init_handler = FnVoid_VoidP_VoidP_Int(init_handler)
+                    libmetawear.mbl_mw_metawearboard_initialize(self.board, None, self._init_handler)
+                else:
+                    def read_task():
+                        uuids = self._read_dev_info_state['uuids']
+                        if(len(uuids)):
+                            next = uuids.popleft()
+                            self._read_dev_info_state['next'] = next                         
+                            if (MetaWear._DEV_INFO[next] not in self.info):
+                                gatt_char = self.warble.find_characteristic(next)
+                                if (gatt_char == None):
+                                    handler(RuntimeError("Missing gatt char '%s'" % (next)))
+                                else:
+                                    gatt_char.read_value_async(self._read_dev_info_state['completed'])
+                            else:
+                                read_task()
+                        else:
+                            handler(None)
 
-        self.warble.connect_async(completed)
-        e.wait()
+                    def completed(value, error):
+                        if (error == None): 
+                            self.info[MetaWear._DEV_INFO[self._read_dev_info_state['next']]] = bytearray(value).decode('utf8')
+                            read_task()
+                        else:
+                            handler(error)
 
-        if (result != None):
-            raise result
+                    self._read_dev_info_state = {
+                        'uuids': deque(MetaWear._DEV_INFO.keys()),
+                        'completed': completed,
+                        'read_task': read_task
+                    }
 
-        if not self.in_metaboot_mode:
-            init_event = Event()
-            def init_handler(context, device, status):
-                self._init_status = status
-                init_event.set()
+                    read_task()
 
-            init_handler_fn = FnVoid_VoidP_VoidP_Int(init_handler)
-            libmetawear.mbl_mw_metawearboard_initialize(self.board, None, init_handler_fn)
-            init_event.wait()
+        if 'firmware' in self.info: del self.info['firmware']
+        self.warble.connect_async(completed)
 
-            if self._init_status != Const.STATUS_OK:
-                self.disconnect()
-                raise RuntimeError("Error initializing the API (%d)" % (self._init_status))
+    def connect(self, **kwargs):
+        """
+        Synchronous variant of `connect_async`
+        """
+        e = Event()
+        result = []
 
-            if 'serialize' not in kwargs or kwargs['serialize']:
-                self.serialize()
-        else:
-            uuids = deque(MetaWear._DEV_INFO.keys())
-            while(len(uuids)):
-                next = uuids.popleft()
-                if (MetaWear._DEV_INFO[next] not in self.info):
-                    gatt_char = self.warble.find_characteristic(next)
-                    if (gatt_char == None):
-                        raise RuntimeError("Missing gatt char '%s'" % (next))
-
-                    e.clear()
-                    results = []
-                    def completed(value, error):
-                        results.append(value)
-                        results.append(error)
-                        e.set()
+        def completed(error):
+            result.append(error)
+            e.set()
 
-                    gatt_char.read_value_async(completed)
-                    e.wait()
+        self.connect_async(completed)
+        e.wait()
 
-                    if results[1] == None:
-                        self.info[MetaWear._DEV_INFO[next]] = bytearray(results[0]).decode('utf8')
-                    else:
-                        raise results[1]
+        if (result[0] != None):
+            raise result[0]
 
     def _read_gatt_char(self, context, caller, ptr_gattchar, handler):
         uuid = _gattchar_to_string(ptr_gattchar.contents)

mbientlab/metawear/metawear.py

@@ -66,7 +66,7 @@ def run(self):
 setup(
     name='metawear',
     packages=['mbientlab', 'mbientlab.metawear'],
-    version='0.5.0',
+    version='0.6.0',
     description='Python bindings for the MetaWear C++ SDK by MbientLab',
     long_description=open(os.path.join(os.path.dirname(__file__), "README.rst")).read(),
     package_data={'mbientlab.metawear': so_pkg_data},
@@ -92,4 +92,4 @@ def run(self):
         'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: 3',
     ]
-)
+)