def setup_myo():
global myo, myo_initialized
print('Setting up myo ...')
myo = MyoRaw(None)
def emg_handler(emg, moving, times=[]):
# store data
global emg_data_latest
emg_data_latest = emg
def imu_handler(quat, acc, gyro):
# store data
global quat_data_latest, acc_data_latest, gyro_data_latest
quat_data_latest = quat
acc_data_latest = acc
gyro_data_latest = gyro
myo.add_emg_handler(emg_handler)
myo.add_imu_handler(imu_handler)
myo.connect()
myo_initialized = True
print('Myo connected')
myo.sleep_mode(1)
_thread.start_new_thread(thread_myo, ())
print('Myo setup.\n')
def __init__(self, callbacks):
# Initialize internals
MyoRaw.__init__(self, None)
self.callbacks = callbacks
# # Initiate the history. Initially, this list has an average of something huge
self.rollingHistory = deque([(1000, 1000)], Myo.HIST_LEN)
self.rollingHistoryModuloCounter = 0
self.recentActivityList = deque([(1000, 1000)],
Myo.FRAMES_FOR_RECENT_ACTIVITY)
# These vars are used later by logic
self.lastRisingEdge = 0
self.signalState = 'standby' # values can be 'standby', 'in_pulse', 'in_long_pulse'
self.IMU_Enabled = False #
self.startingQuaternion = None # Keep this at None when not in use
self.startingRoll = None
self.lastKnownCommunication = time.time(
) # Used as a watchdog to reboot script.
# Set the logic triggers
# EMG
self.add_emg_handler(self.edge_detector)
# For debugging
#self.add_emg_handler(lambda unused1, unused2: print( str( time.time() ) ) )
self.add_imu_handler(self.IMUCallback)
# Make sure that the script does not break
self.watchCommunications()
def __init__(self, storedPath):
self.m = MyoRaw(sys.argv[1] if len(sys.argv) >= 2 else None)
self.storedPath = storedPath
self.hnd = EMGHandler(self.m, self.storedPath)
self.m.add_emg_handler(self.hnd)
self.m.add_emg_handler(proc_emg)
def __init__(self, cls, tty=None):
MyoRaw.__init__(self, tty)
self.cls = cls
self.history = deque([0] * Myo.HIST_LEN, Myo.HIST_LEN)
self.history_cnt = Counter(self.history)
self.add_emg_handler(self.emg_handler)
self.last_pose = None
self.pose_handlers = []
def __init__(self, cls, tty = None):
self.locked = True
self.use_lock = True
self.timed = True
self.lock_time = 1.0
self.time_to_lock = self.lock_time
self.last_pose = -1
self.last_tick = 0
self.current_box = 0
self.last_box = 0
self.box_factor = 0.25
self.current_arm = 0
self.current_xdir = 0
self.current_gyro = None
self.current_accel = None
self.current_roll = 0
self.current_pitch = 0
self.current_yaw = 0
self.center_roll = 0
self.center_pitch = 0
self.center_yaw = 0
self.first_rot = 0
self.current_rot_roll = 0
self.current_rot_pitch = 0
self.current_rot_yaw = 0
self.mov_history = ''
self.gest_history = ''
self.act_history = ''
if pmouse != None:
self.x_dim, self.y_dim = pmouse.screen_size()
self.mx = self.x_dim / 2
self.my = self.y_dim / 2
self.centered = 0
MyoRaw.__init__(self, tty)
self.cls = cls
self.history = deque([0] * Myo.HIST_LEN, Myo.HIST_LEN)
self.history_cnt = Counter(self.history)
self.add_emg_handler(self.emg_handler)
self.add_arm_handler(self.arm_handler)
self.add_imu_handler(self.imu_handler)
self.add_pose_handler(self.pose_handler)
self.onEMG = None
self.onPoseEdge = None
self.onPoseEdgeList = []
self.onLock = None
self.onLockList = []
self.onUnlock = None
self.onUnlockList = []
self.onPeriodic = None
self.onPeriodicList = []
self.onWear = None
self.onWearList = []
self.onUnwear = None
self.onUnwearList = []
self.onBoxChange = None
self.onBoxChangeList = []
def __init__(self, cls, tty=None):
MyoRaw.__init__(self, tty)
self.cls = cls
self.history = deque([0] * Myo.HIST_LEN, Myo.HIST_LEN)
self.history_cnt = Counter(self.history)
self.add_emg_handler(self.emg_handler)
self.last_pose = None
self.pose_handlers = []
def __init__(self, cls, tty=None):
self.locked = True
self.use_lock = True
self.timed = True
self.lock_time = 1.0
self.time_to_lock = self.lock_time
self.last_pose = -1
self.last_tick = 0
self.current_box = 0
self.last_box = 0
self.box_factor = 0.25
self.current_arm = 0
self.current_xdir = 0
self.current_gyro = None
self.current_accel = None
self.current_roll = 0
self.current_pitch = 0
self.current_yaw = 0
self.center_roll = 0
self.center_pitch = 0
self.center_yaw = 0
self.first_rot = 0
self.current_rot_roll = 0
self.current_rot_pitch = 0
self.current_rot_yaw = 0
self.mov_history = ''
self.gest_history = ''
self.act_history = ''
if pmouse != None:
self.x_dim, self.y_dim = pmouse.screen_size()
self.mx = self.x_dim / 2
self.my = self.y_dim / 2
self.centered = 0
MyoRaw.__init__(self, tty)
self.add_emg_handler(self.emg_handler)
self.add_arm_handler(self.arm_handler)
self.add_imu_handler(self.imu_handler)
self.add_pose_handler(self.pose_handler)
self.onEMG = None
self.onPoseEdge = None
self.onPoseEdgeList = []
self.onLock = None
self.onLockList = []
self.onUnlock = None
self.onUnlockList = []
self.onPeriodic = None
self.onPeriodicList = []
self.onWear = None
self.onWearList = []
self.onUnwear = None
self.onUnwearList = []
self.onBoxChange = None
self.onBoxChangeList = []
return
def __init__(self, stream, tty, native, mac):
# Instantiate
self.myo = MyoRaw(tty, native, mac)
self.stream = stream
self.recording = False
self.recording_type = self.init_recording()
# Recording
self.emg_file = None
self.emg_writer = None
# Setup
self.setup()
def __init__(self, fs=200, win_duration=1, num_channels=8):
self._stop = False
myo = MyoRaw(None)
num_samples = win_duration * fs
emg_win = np.zeros((num_samples, num_channels))
i = 0
signals_chan = queue.Queue()
def collect_data(emg, _moving):
nonlocal i
if i == num_samples:
signals_chan.put(np.copy(emg_win))
i = 0
emg_win[i] = emg
i += 1
myo.add_emg_handler(collect_data)
myo.connect()
self.signals_chan = signals_chan
self.myo = myo
def __init__(self):
self.emgDataPath = ''
self.imuDataPath = ''
self.emgDataSize = 100
self.emg_data = []
self.quat_data = []
self.acc_data = []
self.gyr_data = []
self.actionCategry = -1 #动作的类别
self.displayLength = 100 #the length of data to display
self.dataCounter = 0
self.userName = '******' #eg:wangfengyan -> wfy
self.userPosture = 'stand' # stand or sit ..stc
self.userSex = 'male' #male or female
self.device = MyoRaw(sys.argv[1] if len(sys.argv) >= 2 else None)
self.recording = -1
self.setFilePath()
class myMyo(object):
def __init__(self, storedPath):
self.m = MyoRaw(sys.argv[1] if len(sys.argv) >= 2 else None)
self.storedPath = storedPath
self.hnd = EMGHandler(self.m, self.storedPath)
self.m.add_emg_handler(self.hnd)
self.m.add_emg_handler(proc_emg)
# self.m.add_imu_handler(proc_imu)
def start(self):
self.hnd.recording = 1
print('recording flag --> ' + str(self.hnd.recording))
self.m.connect()
def run(self, ActionCategry):
global actionCategry
self.m.run()
actionCategry = ActionCategry
def stop(self):
self.hnd.recording = -1
print('recording flag --> ' + str(self.hnd.recording))
self.m.disconnect()
type=int,
default=EMGMode.RAW,
choices=[m.value for m in EMGMode],
help='Choose the EMG receiving mode ({0} - default: %(default)s)'.format(
modes))
parser.add_argument('-v',
'--verbose',
action='count',
default=0,
help='Increase verbosity')
args = parser.parse_args()
# set logging level to at least logging.INFO
logging.basicConfig(level=max(2 - args.verbose, 0) * 10)
# setup the BLED112 dongle or a native Bluetooth stack with bluepy and connect to a Myo armband
myo = MyoRaw(args.tty, args.native, args.mac)
# add handlers to process EMG, IMU and battery level data
myo.add_handler(DataCategory.EMG, emg_handler)
myo.add_handler(DataCategory.IMU, imu_handler)
myo.add_handler(DataCategory.BATTERY, battery_handler)
# subscribe to all data services
myo.subscribe(args.emg_mode)
# disable sleep to avoid disconnects while retrieving data
myo.set_sleep_mode(1)
# vibrate and change colors (green logo, blue bar) to signalise a successfull setup
myo.vibrate(1)
myo.set_leds([0, 255, 0], [0, 0, 255])
# run until terminated by the user
try:
while True:
def collect_myo_data(detectedMyos):
global dual
if (detectedMyos is not None):
# Closure function to record EMG data
def proc_emg(timestamp, emg, moving, id):
emgs = list([e / 2000. for e in emg])
print(id, '--', timestamp, '--', emgs)
# Set up first myo
m = MyoRaw(detectedMyos[0], '1')
m.add_emg_handler(proc_emg)
m.connect()
m.add_arm_handler(lambda arm, xdir: print('arm', arm, 'xdir', xdir))
m.add_pose_handler(lambda p: print('pose', p))
# Stop Myo from sleeping during data collection
m.set_sleep_mode(1)
m.vibrate(3)
if (len(detectedMyos) == 2):
m2 = MyoRaw(detectedMyos[1], '2')
m2.add_emg_handler(proc_emg)
m2.connect()
# Stop myo from sleeping during data collection
m2.set_sleep_mode(1)
m2.vibrate(3)
m2.add_arm_handler(
lambda arm, xdir: print('arm', arm, 'xdir', xdir))
m2.add_pose_handler(lambda p: print('pose', p))
dual = True
try:
while True:
if (dual == True):
m.run(1)
m2.run(1)
else:
m.run(1)
except KeyboardInterrupt:
pass
finally:
m.disconnect()
m2.disconnect()
print()
def main(argv):
import subprocess
# --- say hello!
#print('Alive and breathing!\n')
global file_handle, save_to_file
global plot_graph
global simulated, verbose
# --- init variables
filename = str(time.strftime("%Y.%m.%d.%Hh%M"))
# --- parse command-line arguments
if verbose:
print('Parsing input arguments ...')
#print ('Number of arguments:', len(sys.argv), 'argument(s)')
#print ('Arguments:', str(sys.argv))
try:
opts, args = getopt.getopt(argv, "hsgxf:v", ["filename="])
except getopt.GetoptError:
usage()
for opt, arg in opts:
if opt == '-h':
usage()
cleanup(1)
sys.exit(0)
elif opt == '-x':
print('Option chosen: Simulated Myo.')
simulated = True
elif opt == '-g':
print('Option chosen: Plotting graphs.')
plot_graph = True
elif opt == '-s':
print('Option chosen: Saving to file.')
save_to_file = True
elif opt in ("-f", "--filename"):
save_to_file = True
filename = filename + '_' + arg
print('Option chosen: Filename set to: ', filename)
elif opt == '-v':
print('Option chosen: Running verbose.')
verbose = True
if verbose:
print('Input arguments parsed.\n')
# --- open file for storing data
if save_to_file:
print('Saving data to file: ', filename)
file_handle = open(filename, 'w')
# --- setup myo
global myo, myo_initialized
print('Setting up myo ...')
if not (simulated):
#myo = MyoRaw(sys.argv[1] if len(sys.argv) >= 2 else None)
myo = MyoRaw(None)
def emg_handler(emg, moving, times=[]):
# store data
global emg_data_latest
emg_data_latest = emg
def imu_handler(quat, acc, gyro):
# store data
global quat_data_latest, acc_data_latest, gyro_data_latest
quat_data_latest = quat
acc_data_latest = acc
gyro_data_latest = gyro
myo.add_emg_handler(emg_handler)
myo.add_imu_handler(imu_handler)
#myo.add_arm_handler(lambda arm, xdir: print('arm', arm, 'xdir', xdir))
#myo.add_pose_handler(lambda p: print('pose', p))
myo.connect()
myo_initialized = True
print('Myo connected')
else:
print('Myo simulated')
_thread.start_new_thread(thread_myo, ())
print('Myo setup.\n')
# --- setup QT
if plot_graph:
# init window
app = QtGui.QApplication([])
print('Starting up plots and QT ...')
win = pg.GraphicsWindow(title="Myo data")
win.closeEvent = cleanup
win.resize(1000, 1000)
win.setWindowTitle('Myo data')
# pg.setConfigOptions(antialias=True) # Enable antialiasing for prettier plots
pg.setConfigOption('background', 'k')
#pg.setConfigOption('background', pg.mkColor(255,255,255) )
pg.setConfigOption('foreground', 'w')
colors = ['r', 'g', 'b', 'c', 'm', 'y', 'w', 'r']
p_emg = [None] * 8
emg = [None] * 8
for i, color in enumerate(colors):
p_emg[i] = win.addPlot(title="EMG " + str(i + 1))
p_emg[i].setXRange(0, BUFFER_SIZE)
p_emg[i].setYRange(-150, 150)
p_emg[i].enableAutoRange('xy', False)
emg[i] = p_emg[i].plot(pen=color, name="emg" + str(i + 1))
win.nextRow()
def update():
global emg_data_buffer
for i in range(8):
emg[i].setData(emg_data_buffer[1:BUFFER_SIZE, i])
timer = QtCore.QTimer()
timer.timeout.connect(update)
timer.start(10)
print('Plots set up.\n')
if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
QtGui.QApplication.instance().exec_()
# no graphs
else:
while (1):
#if verbose:
# print('whiling.. :D')
1 #do nothing (the threads will perform something, e.g. writing the received values on terminal)
def myo_main(self):
atexit.register(set_normal_term)
set_curses_term()
m = MyoRaw(None)
m.add_emg_handler(self.proc_emg)
m.connect()
m.add_arm_handler(lambda arm, xdir: print('arm', arm, 'xdir', xdir))
m.add_pose_handler(lambda p: print('pose', p))
# [EMG0, EMG1, EMG2, EMG3, EMG4, EMG5, EMG6, EMG7, TIME, STATUS]
dim_data = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=float)
data = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=float)
try:
t_start = time.time()
while True:
m.run(1)
#stop vibration ever
m.write_attr(0x19, b'\x03\x01\x00')
emg, self._time = m.plot_emg(t_start)
if kbhit():
key = getch()
if key == 'r':
#print("ROCK")
dim_data[-1:] = 1
elif key == 's':
#print("SCISSOR")
dim_data[-1:] = 2
elif key == 'p':
#print("PAPET")
dim_data[-1:] = 3
print("\r", end='')
else:
print("\r{0}".format(dim_data), end="")
dim_data[-1:] = 0
continue
#グラフは1次元
dim_data[:9] = np.append(emg, self._time)
if self._time > 1.:
if len(dim_data) == 10:
dim2_data = np.expand_dims(dim_data, axis=0)
data = np.append(data, dim2_data, axis=0)
self.count += 1
except KeyboardInterrupt:
pass
finally:
m.disconnect()
if self.save_csv:
self.save_data(self.saving_path + ".csv", data[1:])
if self.byn_np: np.save(self.saving_path, data[1:])
if self.plt_graph: self.data_plot(data)
print("")
# print framerate of received data
times.append(time.time())
if len(times) > 20:
# print((len(times) - 1) / (times[-1] - times[0]))
times.pop(0)
def proc_battery(timestamp, battery_level):
print("Battery level: %d" % battery_level)
if battery_level < 5:
m.set_leds([255, 0, 0], [255, 0, 0])
else:
m.set_leds([128, 128, 255], [128, 128, 255])
m = MyoRaw(sys.argv[1] if len(sys.argv) >= 2 else None)
m.add_handler(DataCategory.EMG, proc_emg)
m.add_handler(DataCategory.BATTERY, proc_battery)
m.subscribe()
m.add_handler(DataCategory.ARM,
lambda arm, xdir: print('arm', arm, 'xdir', xdir))
m.add_handler(DataCategory.POSE, lambda p: print('pose', p))
# m.add_handler(DataCategory.IMU, lambda quat, acc, gyro: print('quaternion', quat))
m.set_sleep_mode(1)
m.set_leds([128, 128, 255], [128, 128, 255]) # purple logo and bar LEDs
m.vibrate(1)
try:
while True:
m.run(1)
outdir = Path(args.outdir)
outdir.mkdir(parents=True, exist_ok=True)
emg_file = outdir.joinpath(now + '_emg.csv').open(mode='w', newline='')
imu_file = outdir.joinpath(now + '_imu.csv').open(mode='w', newline='')
emg_writer = csv.writer(emg_file,
csv.unix_dialect,
quoting=csv.QUOTE_MINIMAL)
emg_writer.writerow(emg_header)
imu_writer = csv.writer(imu_file,
csv.unix_dialect,
quoting=csv.QUOTE_MINIMAL)
imu_writer.writerow(imu_header)
m = MyoRaw(args.tty, args.native, args.mac)
m.add_handler(DataCategory.EMG, lambda *args: write_data(emg_writer, args))
m.add_handler(DataCategory.IMU, lambda *args: write_data(imu_writer, args))
m.subscribe(args.emg_mode)
# Enable never sleep mode.
m.set_sleep_mode(1)
# vibrate to signalise which Myo will start to stream data
m.vibrate(1)
try:
while True:
m.run(1)
except KeyboardInterrupt:
pass
def __init__(self, tty=None, verbose=False):
"""
Initialize the Myo instance.
Args:
tty (str, None): tty (None, str): TTY (on Linux). You can check the list on a terminal by typing
`ls /dev/tty*`. By default, it will be '/dev/ttyACM0'.
verbose (bool): If True, it will print information about the state of the interface. This is let to the
programmer what he / she wishes to print.
"""
self.verbose = verbose
self.locked = True
self.use_lock = True
self.timed = True
self.lock_time = 1.0
self.time_to_lock = self.lock_time
self.last_pose = -1
self.last_tick = 0
self.current_box = 0
self.last_box = 0
self.box_factor = 0.25
self.current_arm = 0
self.current_xdir = 0
self.current_gyro = None
self.current_accel = None
self.current_roll = 0
self.current_pitch = 0
self.current_yaw = 0
self.center_roll = 0
self.center_pitch = 0
self.center_yaw = 0
self.first_rot = 0
self.current_rot_roll = 0
self.current_rot_pitch = 0
self.current_rot_yaw = 0
self.mov_history = ''
self.gest_history = ''
self.act_history = ''
if pmouse is not None:
self.x_dim, self.y_dim = pmouse.screen_size()
self.mx = self.x_dim / 2
self.my = self.y_dim / 2
self.centered = 0
self.current_emg_values = []
self.bitmask_moving = 0
MyoRaw.__init__(self, tty=tty, verbose=verbose)
self.add_emg_handler(self.emg_handler)
self.add_arm_handler(self.arm_handler)
self.add_imu_handler(self.imu_handler)
self.add_pose_handler(self.pose_handler)
self.onEMG = None
self.onPoseEdge = None
self.onPoseEdgeList = []
self.onLock = None
self.onLockList = []
self.onUnlock = None
self.onUnlockList = []
self.onPeriodic = None
self.onPeriodicList = []
self.onWear = None
self.onWearList = []
self.onUnwear = None
self.onUnwearList = []
self.onBoxChange = None
self.onBoxChangeList = []
return
#
# Copyright (c) 2018 Matthias Gazzari
#
# Licensed under the MIT license. See the LICENSE file for details.
#
import argparse
from myo_raw import MyoRaw
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group()
group.add_argument('--tty',
default=None,
help='The Myo dongle device (autodetected if omitted)')
group.add_argument('--native',
default=False,
action='store_true',
help='Use a native Bluetooth stack')
parser.add_argument(
'--mac',
default=None,
help='The Myo MAC address (arbitrarily detected if omitted)')
args = parser.parse_args()
myo = MyoRaw(args.tty, args.native, args.mac)
myo.deep_sleep()
#print(oscmsg)
#print(data)
def imu(quat, acc, gyro):
#print(quat,acc,gyro)
#print ("quat: ", quat, " type: ", type(quat))
send(quat, wek, "/wek/inputs")
def pose(p):
print(p)
def emg(emg, moving):
emgdat = (sum(emg) / float(len(emg)), )
#print ("emgdat: ", emgdat, " type: ", type(emgdat))
send(emgdat, tenta, "/tenta_emg")
if __name__ == '__main__':
m = MyoRaw()
#m.add_imu_handler(print)
m.add_imu_handler(imu)
#m.add_pose_handler(pose)
m.add_emg_handler(emg)
m.connect()
while True:
m.run()
def __init__(self, tty=None): MyoRaw.__init__(self,tty) self.add_emg_handler(self.emg_handler) self.emg = None
# print framerate of received data
times.append(time.time())
if len(times) > 20:
# print((len(times) - 1) / (times[-1] - times[0]))
times.pop(0)
def proc_battery(battery_level):
print("Battery level: %d" % battery_level)
if battery_level < 5:
m.set_leds([255, 0, 0], [255, 0, 0])
else:
m.set_leds([128, 128, 255], [128, 128, 255])
m = MyoRaw(sys.argv[1] if len(sys.argv) >= 2 else None)
m.add_emg_handler(proc_emg)
m.add_battery_handler(proc_battery)
m.connect()
m.add_arm_handler(lambda arm, xdir: print('arm', arm, 'xdir', xdir))
m.add_pose_handler(lambda p: print('pose', p))
# m.add_imu_handler(lambda quat, acc, gyro: print('quaternion', quat))
m.sleep_mode(1)
m.set_leds([128, 128, 255], [128, 128, 255]) # purple logo and bar LEDs
m.vibrate(1)
try:
while True:
m.run(1)
def collect_myo_data(detectedMyos):
global dual
if(detectedMyos is not None):
# Closure function to record EMG data
def proc_emg(timestamp, emg, moving, id):
emgs = list([e / 2000. for e in emg])
print (id, '--', timestamp, '--', emgs)
# Set up first myo
m = MyoRaw(detectedMyos[0], '1')
m.add_emg_handler(proc_emg)
m.connect()
m.add_arm_handler(lambda arm, xdir: print('arm', arm, 'xdir', xdir))
m.add_pose_handler(lambda p: print('pose', p))
# Stop Myo from sleeping during data collection
m.set_sleep_mode(1)
m.vibrate(3)
if(len(detectedMyos) == 2):
m2 = MyoRaw(detectedMyos[1], '2')
m2.add_emg_handler(proc_emg)
m2.connect()
# Stop myo from sleeping during data collection
m2.set_sleep_mode(1)
m2.vibrate(3)
m2.add_arm_handler(lambda arm, xdir: print('arm', arm, 'xdir', xdir))
m2.add_pose_handler(lambda p: print('pose', p))
dual = True
try:
while True:
if(dual == True):
m.run(1)
m2.run(1)
else:
m.run(1)
except KeyboardInterrupt:
pass
finally:
m.disconnect()
m2.disconnect()
print()
outdir = Path(args.outdir)
outdir.mkdir(parents=True, exist_ok=True)
emg_file = outdir.joinpath(now + '_emg.csv').open(mode='w', newline='')
imu_file = outdir.joinpath(now + '_imu.csv').open(mode='w', newline='')
emg_writer = csv.writer(emg_file,
csv.unix_dialect,
quoting=csv.QUOTE_MINIMAL)
emg_writer.writerow(emg_header)
imu_writer = csv.writer(imu_file,
csv.unix_dialect,
quoting=csv.QUOTE_MINIMAL)
imu_writer.writerow(imu_header)
m = MyoRaw(args.tty)
m.add_emg_handler(lambda *args: write_data(emg_writer, args))
m.add_imu_handler(lambda *args: write_data(imu_writer, args))
m.connect()
# Enable never sleep mode.
m.sleep_mode(1)
try:
while True:
m.run(1)
except KeyboardInterrupt:
pass
finally:
m.disconnect()
print("\nemg data saved to: {}".format(emg_file.name))
# print(self.cal_array)
self.start_ch = most_active(self.cal_array)
print('Most active channel is {}'.format(self.start_ch))
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--start_channel',
'-s',
help='(int) Calibrated start channel')
parser.add_argument('--goal_channel',
'-g',
help='(int) Calibrated target channel')
args = parser.parse_args()
m = MyoRaw(None)
model = Network_XL(7)
model_path = 'myo_rec_data/win_JRS_7C_comb7_shifted_XL_cross_tran_final2.pt'
path = 'myo_rec_data/win_JRS_7C_comb7_shifted'
try:
start = int(args.start_channel)
except:
start = 0
model.load_state_dict(torch.load(model_path, map_location='cpu'))
model.eval()
first_activity = most_active(
'myo_rec_data/raw_emg_JRS_7C_1.csv') #should be 3
rt = RealTime(model, m, start, first_activity)
cal = input('Begin calibration recording? ')
if cal == 'y':
dtype = np.int16
def proc_emg(emg, moving):
global emg_data
emg_data.append(emg)
def proc_imu(quat, acc, gyr):
global quat_data, acc_data, gyr_data
quat_data.append(quat)
acc_data.append(acc)
gyr_data.append(gyr)
m = MyoRaw(sys.argv[1] if len(sys.argv) >= 2 else None)
m.add_emg_handler(proc_emg)
m.add_imu_handler(proc_imu)
m.connect()
try:
print "\nSampling... (^C to stop)"
timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
while True:
m.run()
except KeyboardInterrupt:
m.disconnect()
print "\nDone.\n"
pygame.init()
SURFACE = pygame.display.set_mode((600, 700), 0, 32)
pygame.display.set_caption("2048")
myfont = pygame.font.SysFont("monospace", 25)
scorefont = pygame.font.SysFont("monospace", 50)
tileMatrix = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
undoMat = []
rotations = 0
mClassType = 0
placeRandomTile()
placeRandomTile()
printMatrix()
m = MyoRaw(sys.argv[1] if len(sys.argv) >= 2 else None)
listener = PrintPoseListener(m)
m.add_pose_handler(listener.proc_pose)
m.connect()
try:
while True:
m.run()
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if checkIfCanGo() == True:
if event.type == listener.eventId:
if listener.pose == "WAVE_OUT":
'''
Code to run the Duke eNable myoelectric arm. Bluetooth communication with
the myoband is based on the work by dzhu and Fernando Cosentino.
The main edits were to add the custom predictor for the predictions.
'''
from __future__ import print_function
from myo_raw import MyoRaw
if __name__ == '__main__':
myoband = MyoRaw(None, 25)
myoband.connect()
try:
while True:
myoband.run(1)
except KeyboardInterrupt:
pass
finally:
myoband.arduino.port.close()
myoband.disconnect()
print("Done")
class Myo():
def __init__(self, stream, tty, native, mac):
# Instantiate
self.myo = MyoRaw(tty, native, mac)
self.stream = stream
self.recording = False
self.recording_type = self.init_recording()
# Recording
self.emg_file = None
self.emg_writer = None
# Setup
self.setup()
def close(self):
self.myo.disconnect()
self.record(False)
def setup(self):
# Add handles to process EMG and battery level data
self.myo.add_handler(DataCategory.EMG, self.handle_emg)
self.myo.add_handler(DataCategory.BATTERY, self.handle_battery)
# Subscribe to all data services in full RAW mode (200 Hz)
self.myo.subscribe(EMGMode.RAW)
# Disable sleep to a void disconnects while retrieving data
self.myo.set_sleep_mode(1)
# Vibrate to signalise a successful setup
# myo.vibrate(1)
def run(self):
self.myo.run(1)
def disconnect(self):
self.myo.disconnect()
def sleep(self):
self.myo.deep_sleep()
def handle_emg(self, timestamp, emg, moving, characteristic_num):
emg = list(emg)
_, ca_data, _ = self.stream.plot(emg, recording=self.recording)
record_data = ca_data if len(ca_data) > 0 else emg
if self.recording:
csv_data = [timestamp]
csv_data.extend(record_data)
try:
self.emg_writer.writerow(csv_data)
except AttributeError:
print("Error! Unable to write to CSV!")
if VERBOSE:
print(f"[myo] {self.recording_type}: {timestamp}, {record_data}")
def handle_battery(self, timestamp, battery_level):
if battery_level < 5:
self.myo.set_leds([255, 0, 0], [255, 0, 0]) # red logo, red bar
else:
self.myo.set_leds([128, 128, 255],
[128, 128, 255]) # purple logo, purple bar
if VERBOSE:
print(f"[myo] battery level: {timestamp}, {battery_level}")
def init_recording(self):
if self.stream.pca is not None:
return "pca"
elif self.stream.ica is not None:
return "ica"
return "raw"
def record(self, state=False, toggle=False):
if toggle:
recording = not self.recording
else:
recording = state
if recording:
filename = f"recordings/{self.recording_type}/{time.strftime('%Y%m%d-%H%M%S')}.csv"
os.makedirs(os.path.dirname(filename), exist_ok=True)
self.emg_file = open(filename, "w", newline="")
self.emg_writer = csv.writer(self.emg_file,
csv.unix_dialect,
quoting=csv.QUOTE_MINIMAL)
if self.recording_type == "raw":
self.emg_writer.writerow(CSV_HEADER_EMG)
else:
self.emg_writer.writerow(
CSV_HEADER_CA[:self.stream.ca_components + 1])
elif self.emg_file is not None:
self.emg_file.close()
self.emg_file = None
self.emg_writer = None
self.recording = recording
