def set_led_color(self, mw_mac, led_color, position): device = MetaWear(mw_mac) i = 0 connected = False while i < 3 and not connected: try: device.connect() connected = True self.mw_devices.append(device) self.mw_positions[mw_mac] = position print "Connected to %s" % mw_mac except: i = i + 1 print "Connection to %s failed. Retrying..." % mw_mac if not connected: print "Error connecting to %s" % mw_mac return pattern = LedPattern(repeat_count=Const.LED_REPEAT_INDEFINITELY) libmetawear.mbl_mw_led_load_preset_pattern(byref(pattern), LedPreset.SOLID) libmetawear.mbl_mw_led_write_pattern(device.board, byref(pattern), led_color) libmetawear.mbl_mw_led_play(device.board)
def connectDevice(address): print("Connecting to %s..." % (address)) device = MetaWear(address) device.connect() print("Device information: " + str(device.info)) return device
def init_multidevices(self, devices_mac_list): self.device_list = [] for device_mac in devices_mac_list: device = MetaWear(device_mac) try: device.connect() except WarbleException: logger.error(f"connect error: {device_mac}") print("Connected to " + device.address) state_device = State(device, self.strage) self.device_list.append(state_device) self.init_device(state_device) sleep(5.5)
def connect(self): try: if sys.version_info[0] == 2: range = xrange # Start trying to connect to all of the IMU boards # as saved in the MAC addresses list print('Connecting...') for i in range(len(self.addresses)): d = MetaWear(self.addresses[i]) d.connect() print("Connected to " + d.address) self.states.append(State(d)) return True # If all IMUs connect successfully except RuntimeError: return False # If any IMUs fail to connect
class MetaWearDataStream: def __init__(self, mac_address, callback, frequency=12.0): self.device = MetaWear(mac_address) self.callback = cbindings.FnVoid_VoidP_DataP(callback) self.processor = None self.freq = frequency def setup(self): self.device.connect() 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) libmetawear.mbl_mw_acc_set_odr(self.device.board, self.freq) libmetawear.mbl_mw_acc_write_acceleration_config(self.device.board) acc = libmetawear.mbl_mw_acc_get_acceleration_data_signal( self.device.board) libmetawear.mbl_mw_dataprocessor_average_create( acc, 4, None, fn_wrapper) e.wait() libmetawear.mbl_mw_datasignal_subscribe(self.processor, None, self.callback) def start(self): libmetawear.mbl_mw_acc_enable_acceleration_sampling(self.device.board) libmetawear.mbl_mw_acc_start(self.device.board) def __enter__(self): self.setup() self.start() return self def __exit__(self, type, value, traceback): libmetawear.mbl_mw_debug_reset(self.device.board)
def main(): address = "D9:05:CD:93:E5:FC" #select_device() print("start connecting ", address) device = MetaWear(address) device.connect() print("Connected") pattern = LedPattern(repeat_count=Const.LED_REPEAT_INDEFINITELY) libmetawear.mbl_mw_led_load_preset_pattern(byref(pattern), LedPreset.SOLID) libmetawear.mbl_mw_led_write_pattern(device.board, byref(pattern), LedColor.GREEN) libmetawear.mbl_mw_led_play(device.board) sleep(5.0) libmetawear.mbl_mw_led_stop_and_clear(device.board) sleep(1.0) device.disconnect() sleep(1.0)
# usage: python firmware_build.py [mac] from ctypes import * from mbientlab.metawear import MetaWear, libmetawear from mbientlab.metawear.cbindings import * from time import sleep from threading import Event import sys m = MetaWear(sys.argv[1]) m.connect() print("Connected") size = c_uint(0) info = libmetawear.mbl_mw_metawearboard_get_module_info(m.board, byref(size)) i = 15 #print(info[i].name == b'Settings') if (info[i].extra_len >= 2): print(info[i].extra[1]) else: print("Firmware build not available") libmetawear.mbl_mw_memory_free(info)
devices = service.discover(2) i = 0 for address, attr in devices.items(): print("[%d] %s (%s)" % (i, address, attr['name'])) i += 1 msg = "Select your device (-1 to rescan): " selection = int( raw_input(msg) if platform.python_version_tuple()[0] == '2' else input(msg)) address = list(devices)[selection] print("Connecting to %s..." % (address)) metawear = MetaWear(address) metawear.connect() print("Connected") sync_event = Event() result = {} def handler(board, signals, len): result['length'] = len result['signals'] = cast(signals, POINTER( c_void_p * len)) if signals is not None else None sync_event.set() handler_fn = FnVoid_VoidP_VoidP_UInt(handler)
class s1: def __init__(self, filename,sensorAddress): self.device = MetaWear(sensorAddress) self.board = self.device.board self.filename = filename self.device.connect() self.cnt = 0 print("connected to", self.device.address) sleep(2) self.sensordatastr = "" self.EulerAngels= None self.euler_signal = None self.checkLogFiles(self.filename) self.euler_callback = FnVoid_VoidP_DataP(self.data_handler) self.sensorData = {"Name":self.filename,"epoch":0,"heading":0,"pitch":0,"roll":0,"yaw":0,"logs":0} self.checkLogFiles("log1.csv") ######################################################################## def close(self): libmetawear.mbl_mw_sensor_fusion_stop(self.board) libmetawear.mbl_mw_sensor_fusion_clear_enabled_mask(self.board) libmetawear.mbl_mw_datasignal_unsubscribe(self.euler_signal) self.device.disconnect() sleep(1) print("DISCONNETED") ######################################################################## def checkLogFiles(self,filename): path.exists(filename) res = path.exists(filename) if res == False: print("no file found, creating file") f = open(filename,"w+") f.close() print ("file created") with open(filename, mode='w+') as csv_file: fieldnames = ['epoch', 'pitch', 'roll','yaw'] writer = csv.DictWriter(csv_file, fieldnames=fieldnames, delimiter = ',') writer.writeheader() else: print ("File found in the path") ######################################################################## def logData(self,filename,data): f = open(filename,"a+") f.write(data) f.write("\n") f.close() ######################################################################## def data_handler(self,content,data): EulerAngels = parse_value(data) #print (EulerAngels) pi = pointer(EulerAngels) self.sensordatastr = str(data.contents.epoch)+","+ str(("%.4f" %pi.contents.heading)) +","+ str(("%.4f" %pi.contents.pitch))+","+ str(("%.4f" %pi.contents.roll))+","+str(("%.4f" %pi.contents.yaw)) #print (sensordatastr) self.logData(self.filename,self.sensordatastr) #sleep(0.05) self.sensorData["epoch"] = (data.contents.epoch) self.sensorData["heading"] = ("%.4f" %pi.contents.heading) self.sensorData["pitch"] = ("%.4f" %pi.contents.pitch) self.sensorData["roll"] = ("%.4f" %pi.contents.roll) self.sensorData["yaw"] = ("%.4f" %pi.contents.yaw) self.sensorData["logs"] = self.cnt self.cnt = self.cnt +1 print (self.sensorData) sleep(0.02) ######################################################################## def run(self): try: self.euler_signal = libmetawear.mbl_mw_sensor_fusion_get_data_signal(self.board, SensorFusionData.EULER_ANGLE) libmetawear.mbl_mw_datasignal_subscribe(self.euler_signal, None, self.euler_callback) libmetawear.mbl_mw_sensor_fusion_enable_data(self.board, SensorFusionData.EULER_ANGLE) libmetawear.mbl_mw_sensor_fusion_set_mode(self.board, SensorFusionMode.NDOF) libmetawear.mbl_mw_sensor_fusion_write_config(self.board) libmetawear.mbl_mw_sensor_fusion_start(self.board) self.e.wait() input("") except KeyboardInterrupt as e: print (e) self.close() sys.exit()
class MetaWearClient(object): """A MetaWear communication client. This client bridges the gap between the `MetaWear C++ API <https://github.com/mbientlab/Metawear-CppAPI>`_ and a GATT communication package in Python. It provides Pythonic interface to using the MetaWear boards, allowing for rapid development and testing. :param str address: A Bluetooth MAC address to a MetaWear board. :param str device: Specifying which Bluetooth device to use. Defaults to ``hci0`` on Linux. Not available on Windows. :param bool connect: If client should connect automatically, or wait for explicit :py:meth:`~MetaWearClient.connect` call. Default is ``True``. :param bool debug: If printout of all sent and received data should be done. """ def __init__(self, address, device='hci0', connect=True, debug=False): """Constructor.""" self._address = address self._debug = debug if self._debug: add_stream_logger() log.info("Creating MetaWearClient for {0}...".format(address)) self.mw = MetaWear(self._address, hci_mac=device) log.debug("Client started for BLE device {0}...".format(self._address)) self.accelerometer = None #self.gpio = None self.gyroscope = None self.magnetometer = None self.barometer = None self.ambient_light = None self.switch = None self.settings = None self.temperature = None self.haptic = None self.led = None self.sensorfusion = None if connect: self.connect() @property def board(self): return self.mw.board @property def firmware_version(self): return self.mw.info['firmware'] @property def hardware_version(self): return self.mw.info['hardware'] @property def manufacturer(self): return self.mw.info['manufacturer'] @property def serial(self): return self.mw.info['serial'] @property def model(self): return self.mw.info['model'] def __str__(self): return "MetaWearClient, {0}: {1}".format( self._address, self.mw.info) def __repr__(self): return "<MetaWearClient, {0}>".format(self._address) def connect(self): """Connect this client to the MetaWear device.""" self.mw.connect() self._initialize_modules() def disconnect(self): """Disconnects this client from the MetaWear device.""" self.mw.disconnect() def _initialize_modules(self): #self.gpio = modules.GpioModule( # self.board, # libmetawear.mbl_mw_metawearboard_lookup_module( # self.board, modules.Modules.MBL_MW_MODULE_GPIO)) self.accelerometer = modules.AccelerometerModule( self.board, libmetawear.mbl_mw_metawearboard_lookup_module( self.board, modules.Modules.MBL_MW_MODULE_ACCELEROMETER)) self.gyroscope = modules.GyroscopeModule( self.board, libmetawear.mbl_mw_metawearboard_lookup_module( self.board, modules.Modules.MBL_MW_MODULE_GYRO)) self.magnetometer = modules.MagnetometerModule( self.board, libmetawear.mbl_mw_metawearboard_lookup_module( self.board, modules.Modules.MBL_MW_MODULE_MAGNETOMETER)) self.barometer = modules.BarometerModule( self.board, libmetawear.mbl_mw_metawearboard_lookup_module( self.board, modules.Modules.MBL_MW_MODULE_BAROMETER)) self.ambient_light = modules.AmbientLightModule( self.board, libmetawear.mbl_mw_metawearboard_lookup_module( self.board, modules.Modules.MBL_MW_MODULE_AMBIENT_LIGHT)) self.switch = modules.SwitchModule(self.board) self.settings = modules.SettingsModule(self.board) self.temperature = modules.TemperatureModule(self.board) self.haptic = modules.HapticModule(self.board) self.led = modules.LEDModule(self.board) self.sensorfusion = modules.SensorFusionModule( self.board, libmetawear.mbl_mw_metawearboard_lookup_module( self.board, modules.Modules.MBL_MW_MODULE_SENSOR_FUSION))
def __init__(self, mac_adr): # Create publisher self.frame_id = rospy.get_name().split('/')[-1] self.pub_rotation = rospy.Publisher(self.frame_id + '/rotation', QuaternionStamped, queue_size=10) self.pub_accel = rospy.Publisher(self.frame_id + '/accel', Vector3Stamped, queue_size=10) self.pub_gyro = rospy.Publisher(self.frame_id + '/gyro', Vector3Stamped, queue_size=10) self.pub_g = rospy.Publisher(self.frame_id + '/gravity', Vector3Stamped, queue_size=10) self.pub_acc_lin = rospy.Publisher(self.frame_id + '/lin_acc', Vector3Stamped, queue_size=10) d = MetaWear(mac_adr) d.connect() print("Connected to " + d.address) self.device = d self.samples_acc = 0 self.samples_rot = 0 self.samples_gyro = 0 self.cb_gyro_cpp = FnVoid_VoidP_DataP(self.gyro_cb) self.cb_acc_cpp = FnVoid_VoidP_DataP(self.acc_cb) self.cb_rot_cpp = FnVoid_VoidP_DataP(self.rot_cb) self.cb_g_cpp = FnVoid_VoidP_DataP(self.g_cb) self.cb_acc_lin_cpp = FnVoid_VoidP_DataP(self.acc_lin_cb) print("Configuring device") libmetawear.mbl_mw_settings_set_connection_parameters( self.device.board, 10, 20, 0, 6000) print("Sensor Fusion") libmetawear.mbl_mw_sensor_fusion_set_mode(self.device.board, SensorFusionMode.IMU_PLUS) libmetawear.mbl_mw_sensor_fusion_set_acc_range( self.device.board, SensorFusionAccRange._8G) libmetawear.mbl_mw_sensor_fusion_write_config(self.device.board) rospy.sleep(1) #self.gyro_signal = libmetawear.mbl_mw_sensor_fusion_get_data_signal(self.device.board, SensorFusionData.CORRECTED_GYRO) #self.acc_signal = libmetawear.mbl_mw_sensor_fusion_get_data_signal(self.device.board, SensorFusionData.CORRECTED_ACC) self.rot_signal = libmetawear.mbl_mw_sensor_fusion_get_data_signal( self.device.board, SensorFusionData.QUATERNION) #self.g_signal = libmetawear.mbl_mw_sensor_fusion_get_data_signal(self.device.board, SensorFusionData.GRAVITY_VECTOR) #self.acc_lin_signal = libmetawear.mbl_mw_sensor_fusion_get_data_signal(self.device.board, SensorFusionData.LINEAR_ACC) rospy.sleep(1) #libmetawear.mbl_mw_datasignal_subscribe(self.gyro_signal, None, self.cb_gyro_cpp) #libmetawear.mbl_mw_datasignal_subscribe(self.acc_signal, None, self.cb_acc_cpp) libmetawear.mbl_mw_datasignal_subscribe(self.rot_signal, None, self.cb_rot_cpp) #libmetawear.mbl_mw_datasignal_subscribe(self.g_signal, None, self.cb_g_cpp) #libmetawear.mbl_mw_datasignal_subscribe(self.acc_lin_signal, None, self.cb_acc_lin_cpp) rospy.sleep(1) #libmetawear.mbl_mw_sensor_fusion_enable_data(self.device.board, SensorFusionData.CORRECTED_GYRO) #libmetawear.mbl_mw_sensor_fusion_enable_data(self.device.board, SensorFusionData.CORRECTED_ACC) libmetawear.mbl_mw_sensor_fusion_enable_data( self.device.board, SensorFusionData.QUATERNION) #libmetawear.mbl_mw_sensor_fusion_enable_data(self.device.board, SensorFusionData.GRAVITY_VECTOR) #libmetawear.mbl_mw_sensor_fusion_enable_data(self.device.board, SensorFusionData.LINEAR_ACC) rospy.sleep(1) libmetawear.mbl_mw_sensor_fusion_start(self.device.board)
# 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)
class MbientBackend(): def __init__(self, device_addr, log_flags=["ERROR", "WARNING"]): self.device = MetaWear(device_addr) self.samples = 0 self.callback_acc = FnVoid_VoidP_DataP(self.handle_accel_data) self.callback_gyr = FnVoid_VoidP_DataP(self.handle_gyro_data) self.log_flags = log_flags self.target_servers = {} # Attempt to connect self.log("INFO", "Connecting to device...") self.device.connect() self.log("INFO", "Connected.") return def register_mqtt_server(self, addr, port, label=None): if label == None: label = str(addr) + ":" + str(port) # Add it to the target servers list self.target_servers[label] = { 'label': label, 'address': addr, 'port': port, } return def unregister_mqtt_server(self, label): # Remove it from the target servers list if label in self.target_servers.keys(): del self.target_servers[label] return def handle_accel_data(self, ctx, data): return self.handle_data(ctx, data, "ACCEL") def handle_gyro_data(self, ctx, data): return self.handle_data(ctx, data, "GYRO") def handle_data(self, ctx, data, data_type): self.log("DEBUG", "%s -> %s" % (self.device.address, parse_value(data))) parsed_data = parse_value(data) data_dict = { 'ts': time.time(), # Note we can get this from the data contents itself 'type': data_type, 'contents': { 'x': parsed_data.x, 'y': parsed_data.y, 'z': parsed_data.z, } } data_str = json.dumps(data_dict) topics = "DATA" for srv_id in self.target_servers.keys(): target = self.target_servers[srv_id] mqtt_publish.single(topics, payload=data_str, hostname=target['address'], port=target['port']) return def start(self): if self.device == None: self.log("ERROR", "Device not available") return False dev_board = self.device.board self.log("INFO", "Configuring device") lmw.mbl_mw_settings_set_connection_parameters(dev_board, 7.5, 7.5, 0, 6000) time.sleep(1.5) # Subscribe to accelerometer data acc = lmw.mbl_mw_acc_get_acceleration_data_signal(dev_board) lmw.mbl_mw_datasignal_subscribe(acc, None, self.callback_acc) # Subscribe to gyro data gyro = lmw.mbl_mw_gyro_bmi160_get_rotation_data_signal(dev_board) lmw.mbl_mw_datasignal_subscribe(gyro, None, self.callback_gyr) self.log("INFO", "Starting device...") # Enable accelerometer sampling lmw.mbl_mw_acc_enable_acceleration_sampling(dev_board) lmw.mbl_mw_acc_start(dev_board) # Enable gyrp sampling lmw.mbl_mw_gyro_bmi160_enable_rotation_sampling(dev_board) lmw.mbl_mw_gyro_bmi160_start(dev_board) self.log("INFO", "Device started.") return True def stop(self): if self.device == None: self.log("ERROR", "Device not available") return False dev_board = self.device.board self.log("INFO", "Stopping device...") lmw.mbl_mw_acc_stop(dev_board) lmw.mbl_mw_acc_disable_acceleration_sampling(dev_board) lmw.mbl_mw_gyro_bmi160_stop(dev_board) lmw.mbl_mw_gyro_bmi160_disable_rotation_sampling(dev_board) # Unsubscribe from accelerometer data acc = lmw.mbl_mw_acc_get_acceleration_data_signal(dev_board) lmw.mbl_mw_datasignal_unsubscribe(acc) # Unsubscribe from gyro data gyro = lmw.mbl_mw_gyro_bmi160_get_rotation_data_signal(dev_board) lmw.mbl_mw_datasignal_unsubscribe(gyro) self.log("INFO", "Device stopped.") return True def cleanup(self): if self.device == None: self.log("ERROR", "Device not available") return False # Attempt to connect self.log("INFO", "Disconnecting from device...") lmw.mbl_mw_debug_disconnect(self.device.board) self.log("INFO", "Disconnected.") return True def log(self, log_level, message): if log_level in self.log_flags: print("[MbientBackend][{}] {}".format(log_level, message)) # print(f"[MbientBackend] {message}") return
def mobitrack_connect(e): global mobitrack_status global states global sensor_data last_mobitrack_status = False logging.debug('Connecting to Mobitrack...') while (True): # starting session if (last_mobitrack_status == False and mobitrack_status == True): logging.debug('Starting Mobitrack Session...') d = MetaWear("F7:83:98:15:21:07") 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() # during session # while(mobitrack_status): # logging.debug('processStep()') # last_mobitrack_status = True # time.sleep(0.5) # end session if (last_mobitrack_status == True and mobitrack_status == False): logging.debug('endSession()') m.endSession() m.plotData() m.clear() 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() if not os.path.exists(data_folder_name): os.mkdir(data_folder_name) print("Directory ", data_folder_name, " created ") else: print("Directory ", data_folder_name, " already exists") #print(sensor_data) # Log data to file with open(os.path.join(data_folder_name, 'data_' + filename), 'w') as f: print(filename) f.write( 'timestamp, accel_x, accel_y, accel_z, gyro_x, gyro_y, gyro_z\n' ) f.write('\n'.join(sensor_data)) last_mobitrack_status = mobitrack_status time.sleep(0.5)
class MetaWearClient(object): """A MetaWear communication client. This client bridges the gap between the `MetaWear C++ API <https://github.com/mbientlab/Metawear-CppAPI>`_ and a GATT communication package in Python. It provides Pythonic interface to using the MetaWear boards, allowing for rapid development and testing. :param str address: A Bluetooth MAC address to a MetaWear board. :param str device: Specifying which Bluetooth device to use. Defaults to ``hci0``. :param bool connect: If client should connect automatically, or wait for explicit :py:meth:`~MetaWearClient.connect` call. Default is ``True``. :param bool debug: If printout of all sent and received data should be done. """ def __init__(self, address, device='hci0', connect=True, debug=False): """Constructor.""" self._address = address self._debug = debug if self._debug: add_stream_logger() log.info("Creating MetaWearClient for {0}...".format(address)) self.mw = MetaWear(self._address, device=device) log.info("Client started for BLE device {0} on {1}...".format( self._address, device)) self.accelerometer = None #self.gpio = None self.gyroscope = None self.magnetometer = None self.barometer = None self.ambient_light = None self.switch = None self.settings = None self.temperature = None self.haptic = None self.led = None self.sensorfusion = None if connect: self.connect() @property def board(self): return self.mw.board @property def firmware_version(self): return self.mw.info['firmware'] @property def hardware_version(self): return self.mw.info['hardware'] @property def manufacturer(self): return self.mw.info['manufacturer'] @property def serial(self): return self.mw.info['serial'] @property def model(self): return self.mw.info['model'] def __str__(self): return "MetaWearClient, {0}: {1}".format( self._address, self.mw.info) def __repr__(self): return "<MetaWearClient, {0}>".format(self._address) def connect(self): """Connect this client to the MetaWear device.""" self.mw.connect() self._initialize_modules() def disconnect(self): """Disconnects this client from the MetaWear device.""" self.mw.disconnect() def _initialize_modules(self): #self.gpio = modules.GpioModule( # self.board, # libmetawear.mbl_mw_metawearboard_lookup_module( # self.board, modules.Modules.MBL_MW_MODULE_GPIO), # debug=self._debug) self.accelerometer = modules.AccelerometerModule( self.board, libmetawear.mbl_mw_metawearboard_lookup_module( self.board, modules.Modules.MBL_MW_MODULE_ACCELEROMETER), debug=self._debug) self.gyroscope = modules.GyroscopeModule( self.board, libmetawear.mbl_mw_metawearboard_lookup_module( self.board, modules.Modules.MBL_MW_MODULE_GYRO), debug=self._debug) self.magnetometer = modules.MagnetometerModule( self.board, libmetawear.mbl_mw_metawearboard_lookup_module( self.board, modules.Modules.MBL_MW_MODULE_MAGNETOMETER), debug=self._debug) self.barometer = modules.BarometerModule( self.board, libmetawear.mbl_mw_metawearboard_lookup_module( self.board, modules.Modules.MBL_MW_MODULE_BAROMETER), debug=self._debug) self.ambient_light = modules.AmbientLightModule( self.board, libmetawear.mbl_mw_metawearboard_lookup_module( self.board, modules.Modules.MBL_MW_MODULE_AMBIENT_LIGHT), debug=self._debug) self.switch = modules.SwitchModule(self.board, debug=self._debug) self.settings = modules.SettingsModule(self.board, debug=self._debug) self.temperature = modules.TemperatureModule( self.board, debug=self._debug) self.haptic = modules.HapticModule(self.board, debug=self._debug) self.led = modules.LEDModule(self.board, debug=self._debug) self.sensorfusion = modules.SensorFusionModule( self.board, libmetawear.mbl_mw_metawearboard_lookup_module( self.board, modules.Modules.MBL_MW_MODULE_SENSOR_FUSION), debug=self._debug)
class Sensor(): def __init__(self): self.device = MetaWear('C7:CF:3D:0E:D9:0E') self.default_name = '_temp_data.txt' def connect_to_sensor(self): self.device.connect() self.signal = libmetawear.mbl_mw_acc_get_acceleration_data_signal( self.device.board) self.logger = create_voidp( lambda fn: libmetawear.mbl_mw_datasignal_log( self.signal, None, fn), resource="acc_logger") logging.info('metawear device connected') return 1 def gather_data(self, seconds=3): try: libmetawear.mbl_mw_logging_start(self.device.board, 0) libmetawear.mbl_mw_acc_enable_acceleration_sampling( self.device.board) libmetawear.mbl_mw_acc_start(self.device.board) logging.info('data gathering started') time.sleep(int(seconds)) libmetawear.mbl_mw_acc_stop(self.device.board) libmetawear.mbl_mw_acc_disable_acceleration_sampling( self.device.board) libmetawear.mbl_mw_logging_stop(self.device.board) logging.info('data gathering stopped') except RuntimeError as err: print(err) logging.info('runtime error in gather_data() occurred') return 0 return 1 def download_data(self, name='blank'): try: libmetawear.mbl_mw_settings_set_connection_parameters( self.device.board, 7.5, 7.5, 0, 6000) time.sleep(1.0) e = Event() 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)) # print('Opening log file to write') f = open(name + self.default_name, 'a') callback = FnVoid_VoidP_DataP(lambda ctx, p: print( "{epoch: %d, value: %s}" % (p.contents.epoch, parse_value(p)), file=f)) libmetawear.mbl_mw_logger_subscribe(self.logger, None, callback) libmetawear.mbl_mw_logging_download(self.device.board, 0, byref(download_handler)) e.wait() # close the file, process the data into a csv, then delete the original file f.close() self.process_data(name) # os.remove(name + self.default_name) logging.info('data downloaded') return 1 except RuntimeError as err: print(err) logging.info('runtime error in download_data() occurred') return 0 def process_data(self, name): rows = {} for i in open(name + self.default_name, 'r'): epoch = i[8:21] xyz = i[35:-3] xyz = xyz.replace(' ', '') xyz = xyz.replace(':', '') xyz = xyz.replace(',', '') xyz = xyz.replace('y', ' ') xyz = xyz.replace('z', ' ') x, y, z = xyz.split() rows[epoch] = [x, y, z] df = DataFrame(rows.values(), index=rows.keys(), columns=['X', 'Y', 'Z']) logging.info('row count ' + str(len(df))) df.to_csv('{0}/data/{1}_{2}_data.csv'.format(__here__, __now__, name)) # stream data # implement multithreading (or some similar functionality) # stream metawear data to a file # each second during stream, run second thread that processes the file # and converts it to a proper data format in a csv file # might need to implement a queue of this, or increase from 1 second to 2 # also need to figure out mass load into mysql # might be able to do streaming analytics on this data # calculate std dev, mean, median, range for each second's worth of data def reset_device(self): libmetawear.mbl_mw_debug_reset(self.device.board) logging.info('device reset')
def startTracking(self, macAddress, location, patientID, led_on, target_angle): path_MAC = macAddress.replace(":", "-") m = Mobitrack() m.data_folder = os.path.join( Path(os.path.dirname(__file__)).parents[2], "data") m.patientID = patientID m.wearLocation = location minROM_slack = 5 m.minROM = target_angle - minROM_slack m.minROM_raw = target_angle if m.minROM <= 5.: min.ROM = 5. if m.minROM >= 120.: min.ROM = 120. device = MetaWear(macAddress) state = State(device, m) state.led = led_on try: # Create lock file lock_folder = os.path.join( Path(os.path.dirname(__file__)).parents[2], "lock") if not os.path.exists(lock_folder): os.mkdir(lock_folder) lock_file = os.path.join(lock_folder, path_MAC + "_lock.txt") if os.path.isfile(lock_file): raise ValueError('Device %s already in use' % (macAddress)) # Connect to device self.update_state(state='CONNECTING') print("Connecting to " + macAddress) device.connect() print("Configuring %s" % (macAddress)) state.setup() print("Connected to " + macAddress) self.update_state(state='CONNECTED') # Create lock file if not os.path.isfile(lock_file): with open(lock_file, 'x'): os.utime(lock_file, None) print('Starting wearing session for patient %s on device %s' % (patientID, macAddress)) state.start() while (os.path.isfile(lock_file)): pass self.update_state(state='DISCONNECTING') print("Disconnecting device") state.stop() event = Event() state.device.on_disconnect = lambda s: event.set() libmetawear.mbl_mw_debug_reset(state.device.board) event.wait() m.endSession() m.writeData() m.plotDataAccel() m.plotDataGyro() m.plotRawData() m.plotSmoothData() self.update_state(state='DISCONNECTED') print("Disconnected") except (Exception, ArithmeticError) as e: template = "An exception of type {0} occurred. Arguments:\n{1!r}" message = template.format(type(e).__name__, e.args) print(message) print("Exception occured: ") self.update_state(state='DISCONNECTING') state.stop() print("Disconnecting device") event = Event() state.device.on_disconnect = lambda s: event.set() libmetawear.mbl_mw_debug_reset(state.device.board) event.wait() stopTracking(macAddress) self.update_state(state='DISCONNECTED') print("Disconnected") return 1
class sens1: ## INSTANTIATE THE CLASS ## def __init__(self, **kwargs): print("Go Sensor Class!!") ## INITIALISE THE DEVICE CONNECTION ## def DevConnect(self, device): self.device = MetaWear(device) self.board = self.device.board #self.sensordatastr = "" # Don't seem to need this ? ? print("Connected to Sensor") self.euler_signal = None try: self.device.connect() # Attempt connection except: print("FAILED TO CONNECT...") ## Do Nothing Here - For other Class ## def startup(self): print("For Posterity...") ## CONTINUOUS RUN ## def DevRun(self): try: ## Get data and print to console ## self.euler_signal = libmetawear.mbl_mw_sensor_fusion_get_data_signal( self.board, SensorFusionData.EULER_ANGLE) self.euler_callback = FnVoid_VoidP_DataP( lambda context, data: print("epoch: %s, euler %s\n" % ( data.contents.epoch, parse_value(data)))) ## Required for data extraction ## libmetawear.mbl_mw_datasignal_subscribe(self.euler_signal, None, self.euler_callback) libmetawear.mbl_mw_sensor_fusion_enable_data( self.board, SensorFusionData.EULER_ANGLE) libmetawear.mbl_mw_sensor_fusion_set_mode(self.board, SensorFusionMode.NDOF) libmetawear.mbl_mw_sensor_fusion_write_config(self.board) libmetawear.mbl_mw_sensor_fusion_start(self.board) #input('') # Don't seem to need this ? ? except OSError as err: print("OS ERROR {}".format(err)) self.DevClose() print("Device closed properly...") sys.exit() except ValueError: print("Error with variable...") self.DevClose() print("Device closed properly...") sys.exit() except: print("Unexpected Error:", sys.exc_info()[0]) self.DevClose() print("Device closed properly...") sys.exit() ## CLOSE THE CONNECTION PROPERLY ## def DevClose(self): libmetawear.mbl_mw_sensor_fusion_stop(self.board) libmetawear.mbl_mw_sensor_fusion_clear_enabled_mask(self.board) libmetawear.mbl_mw_datasignal_unsubscribe(self.euler_signal) self.device.disconnect() sleep(1)
# usage: python stream_acc.py [mac1] [mac2] ... [mac(n)] 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 import platform import sys device = MetaWear('FB:81:71:31:92:7A') device.connect() # Callback function to process/parse the battery data def data_handler(self, ctx, data): print("%s -> %s" % (self.device.address, parse_value(data))) callback = FnVoid_VoidP_DataP(data_handler) print("Configuring device") libmetawear.mbl_mw_settings_set_connection_parameters(device.board, 7.5, 7.5, 0, 6000) battery_signal = libmetawear.mbl_mw_settings_get_battery_state_data_signal( device.board) libmetawear.mbl_mw_datasignal_subscribe(battery_signal, None, callback) sleep(1.0) libmetawear.mbl_mw_datasignal_read(battery_signal)
class sens1: filename = 'log1.csv' # Log file - remove later ## INSTANTIATE THE CLASS ## def __init__(self, **kwargs): self.cnt = 0 print("Go Sensor Class!!") ## INITIALISE THE DEVICE CONNECTION ## def DevConnect(self, device): self.device = MetaWear(device) self.board = self.device.board #self.sensordatastr = "" # Don't seem to need this ? ? self.euler_signal = None # only needed in 'close()' print("Connected to sensor 1") try: self.device.connect() except: print("FAILED TO CONNECT...") ## SETUP VARIOUS VARIABLES ## def startup(self): try: self.sensordatastr = "" self.EulerAngels = None self.euler_signal = None #self.checkLogFiles(self.filename) # create/check csv backup file ## ERROR HERE - REMOVED ## #self.euler_callback = FnVoid_VoidP_DataP(self.data_handler) ## Create Data Dictionary ## self.sensorData = { "epoch": 0, "heading": 0, "pitch": 0, "roll": 0, "yaw": 0, "logs": 0 } # removed 'filename' except OSError as err: print("OS ERROR {}".format(err)) self.DevClose() print("Device closed properly...") sys.exit() except ValueError: print("Error with variable...") self.DevClose() print("Device closed properly...") sys.exit() except: print("Unexpected Error:", sys.exc_info()[0]) self.DevClose() print("Device closed properly...") sys.exit() ## CONTINUOUS RUN - Threaded? ## def DevRun(self): try: ## Retrieve Sensor Data? ## self.euler_signal = libmetawear.mbl_mw_sensor_fusion_get_data_signal( self.board, SensorFusionData.EULER_ANGLE) ## View Data Directly - Removed ## #self.euler_callback = FnVoid_VoidP_DataP(lambda context,data:print("epoch: %s, euler %s\n" % (data.contents.epoch, parse_value(data)))) ## From initi function ## self.euler_callback = FnVoid_VoidP_DataP(self.data_handler) ## All required for Data Extraction? ## libmetawear.mbl_mw_datasignal_subscribe(self.euler_signal, None, self.euler_callback) libmetawear.mbl_mw_sensor_fusion_enable_data( self.board, SensorFusionData.EULER_ANGLE) libmetawear.mbl_mw_sensor_fusion_set_mode(self.board, SensorFusionMode.NDOF) libmetawear.mbl_mw_sensor_fusion_write_config(self.board) libmetawear.mbl_mw_sensor_fusion_start(self.board) #self.e.wait() # what is this for ? ? - removed #input('') # what is this for ? ? - Does nothing ## Catch ANY errors ## except OSError as err: print("OS ERROR {}".format(err)) self.DevClose() print("Device closed properly...") sys.exit() except ValueError: print("Error with variable...") self.DevClose() print("Device closed properly...") sys.exit() except: print("Unexpected Error:", sys.exc_info()[0]) self.DevClose() print("Device closed properly...") sys.exit() ## CLOSE THE CONNECTION PROPERLY ## def DevClose(self): libmetawear.mbl_mw_sensor_fusion_stop(self.board) libmetawear.mbl_mw_sensor_fusion_clear_enabled_mask(self.board) libmetawear.mbl_mw_datasignal_unsubscribe(self.euler_signal) self.device.disconnect() time.sleep(1) def data_handler(self, content, data): ## Extract data values? ## EulerAngels = parse_value(data) #print (EulerAngels) # REMOVE pi = pointer(EulerAngels) #self.sensordatastr = str(data.contents.epoch)+","+ str(("%.4f" %pi.contents.heading)) +","+ str(("%.4f" %pi.contents.pitch))+","+ str(("%.4f" %pi.contents.roll))+","+str(("%.4f" %pi.contents.yaw)) ## Backup 'data' to csv file ## #print (sensordatastr) # REMOVE #self.logData(self.filename,self.sensordatastr) #sleep(0.05) ## Update Dictionary data fields ## self.sensorData["epoch"] = (data.contents.epoch) self.sensorData["heading"] = ("%.4f" % pi.contents.heading) self.sensorData["pitch"] = ("%.4f" % pi.contents.pitch) self.sensorData["roll"] = ("%.4f" % pi.contents.roll) self.sensorData["yaw"] = ("%.4f" % pi.contents.yaw) self.sensorData["logs"] = self.cnt self.cnt = self.cnt + 1 print(self.sensorData) # View Dictionary #sleep(0.02) # REMOVED ## REMOVE - CHECK/CREATE CSV FILE ## def checkLogFiles(self, filename): ## Does CSV file exist ## res = os.path.exists(filename) ## Create if doesn't exist ## if res == False: print("no file found, creating file") f = open(filename, "w+") f.close() print("file created") with open(filename, mode='w+') as csv_file: fieldnames = ['epoch', 'pitch', 'roll', 'yaw'] writer = csv.DictWriter(csv_file, fieldnames=fieldnames, delimiter=',') writer.writeheader() ## File already existed ## else: print("File found in the path")