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