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")
