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 connectDevice(address):
print("Connecting to %s..." % (address))
device = MetaWear(address)
device.connect()
print("Device information: " + str(device.info))
return device
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 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 __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 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 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)
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 = []
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
# usage: python3 led.py [mac]
# This is an example of how to specify a BLE dongle to the python metawear API
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
# Add hci_mac to the setup to specify which dongle to use
device = MetaWear(sys.argv[1], hci_mac="B8:27:EB:F2:61:2E")
device.connect()
print("Connected")
# create led pattern
pattern = LedPattern(repeat_count=Const.LED_REPEAT_INDEFINITELY)
libmetawear.mbl_mw_led_load_preset_pattern(byref(pattern), LedPreset.BLINK)
libmetawear.mbl_mw_led_write_pattern(device.board, byref(pattern),
LedColor.GREEN)
# play the pattern
libmetawear.mbl_mw_led_play(device.board)
# wait 5s
sleep(5.0)
# remove the led pattern and stop playing
libmetawear.mbl_mw_led_stop_and_clear(device.board)
sleep(2.0)
e.wait()
libmetawear.mbl_mw_datasignal_subscribe(self.processor, None,
self.callback)
def start(self):
libmetawear.mbl_mw_gyro_bmi160_enable_rotation_sampling(
self.device.board)
libmetawear.mbl_mw_acc_enable_acceleration_sampling(self.device.board)
libmetawear.mbl_mw_gyro_bmi160_start(self.device.board)
libmetawear.mbl_mw_acc_start(self.device.board)
# Connect to all devices provided as command line args
# for i in range(len(argv) - 1):
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()
sleep(seconds_to_stream)
# while(True):
# pass
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(
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")
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 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)
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
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)
self.device.board, SensorFusionData.LINEAR_ACC)
libmetawear.mbl_mw_datasignal_unsubscribe(AccSignal)
gpioSignal = libmetawear.mbl_mw_gpio_get_pin_monitor_data_signal(
self.device.board, 0)
libmetawear.mbl_mw_datasignal_unsubscribe(gpioSignal)
libmetawear.mbl_mw_gpio_stop_pin_monitoring(self.device.board, 0)
resetSignal = libmetawear.mbl_mw_gpio_get_pin_monitor_data_signal(
self.device.board, 1)
libmetawear.mbl_mw_datasignal_unsubscribe(resetSignal)
libmetawear.mbl_mw_gpio_stop_pin_monitoring(self.device.board, 1)
libmetawear.mbl_mw_debug_disconnect(self.device.board)
sleep(5.0)
self.device.disconnect()
sleep(1.0)
print("DISCONNECTED!")
Mac = 'EC:7A:04:95:D6:B3'
device = MetaWear(Mac)
device.connect()
print("Connected")
d = MyDevice(device)
d.calibrate()
d.setup()
d.start()
while True:
sleep(2)
if is_pressed('e'):
d.stop()
break
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)
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: 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)
# usage: python3 log_download.py [mac]
from __future__ import print_function
from mbientlab.metawear import MetaWear, libmetawear, parse_value
from mbientlab.metawear.cbindings import *
from time import sleep, strftime
from threading import Event
import platform
import sys
if sys.version_info[0] == 2:
range = xrange
# connect
metawear = MetaWear(sys.argv[1])
metawear.connect()
print("Connected")
# setup
e = Event()
result = {}
# handler fxn
def handler(ctx, board, signals, len):
result['length'] = len
result['signals'] = cast(signals, POINTER(
c_void_p * len)) if signals is not None else None
e.set()
# 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)
def __init__(self):
self.device = MetaWear('C7:CF:3D:0E:D9:0E')
self.default_name = '_temp_data.txt'
