time = data.contents.epoch
values = parse_value(data, n_elem = 2) #mV
GPIO_output.append("%i, %i" %(time, values))
def switch_handler(ctx, data):
time = data.contents.epoch
value = parse_value(data, n_elem = 2) #no units
switch_output.append("%i, %i" %(time, value))
GPIO_callback = cbindings.FnVoid_VoidP_DataP(GPIO_handler)
switch_callback = cbindings.FnVoid_VoidP_DataP(switch_handler)
#Connecting the MetaWear Device
address = "C5:41:50:B9:17:6F" #Device 2: 'CF:77:B8:03:8A:B4'
print("Connecting to %s..." % (address))
d = MetaWear(address)
d.connect()
print("Connected")
print("Setting up Device")
libmetawear.mbl_mw_settings_set_connection_parameters(d.board, 7.5, 7.5, 0, 6000)
Long = LedPattern(pulse_duration_ms=1000, high_time_ms=500, high_intensity=16, low_intensity=16, repeat_count=Const.LED_REPEAT_INDEFINITELY)
sleep(1.0)
# Collecting GPIO and Switch Data
switch = libmetawear.mbl_mw_switch_get_state_data_signal(d.board)
GPIO = libmetawear.mbl_mw_gpio_get_analog_input_data_signal(d.board, 1, 0)
GPIO_logger = create_voidp(lambda fn: libmetawear.mbl_mw_datasignal_log(GPIO, None, fn), resource = "logger")
libmetawear.mbl_mw_datasignal_subscribe(switch, None, switch_callback)
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()
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 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...")
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...")
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 __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 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
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()
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")
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)
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
# usage: python led.py [mac]
from __future__ import print_function
from mbientlab.metawear import MetaWear, libmetawear
from mbientlab.metawear.cbindings import *
from time import sleep
from threading import Event
#import sys
#sys.argv[1]
#device = MetaWear("FB:81:71:31:92:7A")
device = MetaWear("C2:9B:59:07:56:C9")
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 update_firmware.py [mac] [version](optional)
from mbientlab.metawear import MetaWear, libmetawear
from threading import Event
import sys
device = MetaWear(sys.argv[1])
device.connect()
print("Connected")
args = {
'progress_handler': lambda p: print("upload: %d%%" % (p)),
}
if (len(sys.argv) >= 3):
args['version'] = sys.argv[2]
e = Event()
result = []
def dfu_handler(err):
result.append(err)
e.set()
device.update_firmware_async(dfu_handler, **args)
e.wait()
if (result[0] != None):
raise result[0]
libmetawear.mbl_mw_datasignal_read(signal1)
sleep(0.004)
libmetawear.mbl_mw_datasignal_read(signal2)
sleep(0.004) #bad but polling too quick causes stability issues
a += 1
if (not(s1) or not(s2)):
correct = False
clear_outputs()
print("%r reaction to trick" % (correct))
data.append(["all", correct, -1])
#set up metatracker
device = MetaWear(sys.argv[1])
device.connect()
print("\nConnected")
libmetawear.mbl_mw_gpio_set_pull_mode(device.board, 0, 1) #0 = pull up
libmetawear.mbl_mw_gpio_set_pull_mode(device.board, 1, 1) #1 = pull down
libmetawear.mbl_mw_gpio_set_pull_mode(device.board, 2, 1) #2 = float
libmetawear.mbl_mw_gpio_set_pull_mode(device.board, 3, 1)
libmetawear.mbl_mw_gpio_set_pull_mode(device.board, 4, 0)
libmetawear.mbl_mw_gpio_set_pull_mode(device.board, 5, 0)
clear_outputs() #cleans ungraceful shutdown
print("configured pins")
#subscribe to gpio inputs
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)
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 = []
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 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))
match for idx, match in enumerate(matches)
if idx not in match_idx
]
# if new match is found, print to screen
if len(matches) > len_matches_previous:
total_steps += len(matches) - len_matches_previous
print(pyfiglet.figlet_format(f'{total_steps} steps'))
len_matches_previous = len(matches)
states = []
# connect to device
d = MetaWear("FC:A3:80:92:67:06")
d.connect()
print("Connected to " + d.address)
states.append(State(d))
print("Configuring device")
libmetawear.mbl_mw_settings_set_connection_parameters(states[0].device.board,
7.5, 7.5, 0, 6000)
sleep(1.5)
# start reading in acc data
libmetawear.mbl_mw_acc_set_odr(states[0].device.board, 100.0)
libmetawear.mbl_mw_acc_set_range(states[0].device.board, 16.0)
libmetawear.mbl_mw_acc_write_acceleration_config(states[0].device.board)
signal = libmetawear.mbl_mw_acc_get_acceleration_data_signal(
else:
print("Warning!!!!")
class gState:
def __init__(self, device):
self.device = device
self.callback = FnVoid_DataP(self.data_handler)
def data_handler(self, data):
#print("GYO -> %s" % (parse_value(data)))
gfile.write("%s\n" % (parse_value(data)))
print("Connecting.....")
d = MetaWear(maclist[0])
d.connect()
print("Connected to ACC device at MAC:" + d.address)
a=aState(d)
sleep(0.5)
d = MetaWear(maclist[1])
d.connect()
print("Connected to GYO device at MAC:" + d.address)
g=gState(d)
sleep(0.5)
print("configuring device..........")
libmetawear.mbl_mw_settings_set_connection_parameters(a.device.board, 7.5, 7.5, 0, 6000)
libmetawear.mbl_mw_acc_set_odr(a.device.board, 25.0);
# usage: python led.py [mac]
from __future__ import print_function
from mbientlab.metawear import MetaWear, libmetawear
from mbientlab.metawear.cbindings import *
from time import sleep
from threading import Event
import sys
mac = 'cd:ab:4d:bd:aa:b7'
device = MetaWear(mac)
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)
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()
devices[result.mac] = result.name
BleScanner.set_handler(handler)
BleScanner.start()
sleep(10.0)
BleScanner.stop()
i = 0
for address, name in six.iteritems(devices):
print("[%d] %s (%s)" % (i, address, 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))
device = MetaWear(address)
device.connect()
print("Connected")
print("Device information: " + str(device.info))
sleep(5.0)
device.disconnect()
sleep(1.0)
print("Disconnected")
def data_handler(self, ctx, data):
print("%s -> %s" % (self.device.address, parse_value(data)))
self.samples += 1
temp_data = parse_value(data)
temp = json.dumps({
'x': temp_data.x,
'y': temp_data.y,
'z': temp_data.z
})
print(temp)
conn.sendall(temp)
states = []
for i in range(len(sys.argv) - 1):
d = MetaWear(sys.argv[i + 1])
d.connect()
print("Connected to " + d.address)
states.append(State(d))
for s in states:
print("Configuring device")
libmetawear.mbl_mw_settings_set_connection_parameters(
s.device.board, 1.5, 1.5, 0, 6000)
libmetawear.mbl_mw_gyro_bmi160_set_odr(s.device.board, AccBmi160Odr._50Hz)
libmetawear.mbl_mw_gyro_bmi160_set_range(s.device.board,
AccBoschRange._125dps)
libmetawear.mbl_mw_gyro_bmi160_write_config(s.device.board)
signal = libmetawear.mbl_mw_gyro_bmi160_get_rotation_data_signal(
s.device.board)
service = DiscoveryService("hci0")
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)
# 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 State:
def __init__(self, device):
self.device = device
self.samples = 0
self.callback = FnVoid_DataP(self.data_handler)
def data_handler(self, data):
print("%s -> %s" % (self.device.address, parse_value(data)))
self.samples+= 1
states = []
print(len(maclist))
for z in range(0,1):
print(maclist[z])
d = MetaWear(maclist[z])
d.connect()
print("Connected to " + d.address)
states.append(State(d))
sleep(3.0)
print(len(states))
for s in states:
print("configuring device")
libmetawear.mbl_mw_settings_set_connection_parameters(s.device.board, 7.5, 7.5, 0, 6000)
libmetawear.mbl_mw_acc_set_odr(s.device.board, 25.0);
libmetawear.mbl_mw_acc_set_range(s.device.board, 16.0);
libmetawear.mbl_mw_acc_write_acceleration_config(s.device.board);
signal = libmetawear.mbl_mw_acc_get_acceleration_data_signal(s.device.board)
# 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)
# 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)
