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("")
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 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()
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()
'''
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")
if HAVE_PYGAME:
for ev in pygame.event.get():
if ev.type == QUIT or (ev.type == KEYDOWN
and ev.unicode == 'q'):
raise KeyboardInterrupt()
# elif ev.type == KEYDOWN and ev.unicode == 'd':
# m.disconnect()
# print("Disconnected")
# raise KeyboardInterrupt()
elif ev.type == KEYDOWN:
if K_1 <= ev.key <= K_3:
m.vibrate(ev.key - K_0)
if K_KP1 <= ev.key <= K_KP3:
m.vibrate(ev.key - K_KP0)
except KeyboardInterrupt:
pass
finally:
# m.power_off()
# print("Power off")
m.disconnect()
print("Disconnected")
# command = raw_input("Do you want to (d)isconnect or (p)ower off?\n")
# if command == 'd':
# m.disconnect()
# print("Disconnected")
# elif command == 'p':
# m.power_off()
# print("Power off")
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:
myo.run(1)
except KeyboardInterrupt:
pass
finally:
myo.disconnect()
print('Disconnected')
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
