def __init__(self):
self.interval = TimeInterval(None, 0.05)
self.orientation = None
self.pose = myo.Pose.rest
self.emg_enabled = False
self.locked = False
self.emg = None
def __init__(self):
self.interval = TimeInterval(None, 0.1)
self.orientation = None
self.emg_enabled = False
self.emg = None
self.lock = Lock()
self.emg_data_queue = collections.deque(maxlen=1)
self.ori_data_queue = collections.deque(maxlen=1)
def __init__(self):
self.interval = TimeInterval(None, 0.05)
self.orientation = None
self.pose = myo.Pose.rest
self.emg_enabled = True
self.locked = False
self.rssi = None
self.emg = None
#self.output = ""
self.csv = open("out.csv",'a')
self.LABEL = 'j'
def __init__(self): self.interval = TimeInterval(None, 0.05) self.acceleration = None self.gyroscope = None self.orientation = None self.pose = myo.Pose.rest self.emg_enabled = True self.locked = False self.rssi = None self.emg = None self.temp = 0
def __init__(self):
self.interval = TimeInterval(None, 0.01)
self.orientation = None
self.pose = myo.Pose.rest
self.emg_enabled = False
self.locked = False
self.rssi = None
self.emg = None
self.acceleration = None
self.gyroscope = None
self.quat = None
self.yaw = None
self.roll = None
self.pitch = None
self.snap = snap
class Listener(myo.DeviceListener):
def __init__(self):
self.interval = TimeInterval(None, 0.05)
self.orientation = None
self.pose = myo.Pose.rest
self.emg_enabled = False
self.locked = False
self.emg = None
def output(self):
if not self.interval.check_and_reset():
return
parts = []
if self.emg:
for comp in self.emg:
parts.append(str(comp).ljust(5))
print('\r' + ','.join('{}'.format(p) for p in parts), end='')
sys.stdout.flush()
def on_connected(self, event):
event.device.request_rssi()
def on_pose(self, event):
event.device.stream_emg(True)
self.emg_enabled = True
self.emg = None
self.output()
def on_emg(self, event):
self.emg = event.emg
self.output()
def main():
queue_size = 10
# Initialize Myo and create a Hub and our listener.
myo.init()
hub = myo.Hub()
listener = Listener(queue_size)
def update():
emgs = np.array([x[1] for x in listener.get_emg_data()]).T
for x in emgs:
data = x
if len(data) < queue_size:
data = np.concatenate([np.zeros(queue_size - len(data)), data])
word = 'Mean = %d , vector = ' % (data.mean())
print(word + str(data))
try:
threading.Thread(
target=lambda: hub.run_forever(listener.on_event)).start()
time = TimeInterval(None, 0.1)
while True:
if time.check_and_reset():
os.system('cls')
update()
finally:
hub.stop() # Will also stop the thread
def __init__(self): self.interval = TimeInterval(None, 0.05) self.orientation = None self.pose = myo.Pose.rest self.emg_enabled = False self.locked = False self.rssi = None self.emg = None
def __init__(self):
self.interval = TimeInterval(None, 0.02)
self.orientation = None
self.pose = myo.Pose.rest
self.emg_enabled = False
self.locked = False
self.rssi = None
self.emg = None
send_address = '127.0.0.1', 9098
print("Sending Myo data on {}".format(send_address))
print("Ctrl+C to quit")
self.client = OSC.OSCClient()
self.client.connect(send_address)
self.ypr = None
self.orientstring = []
self.t = time.time()
self.delta = 0
class Listener(myo.DeviceListener):
def __init__(self):
self.interval = TimeInterval(None, 0.05)
self.orientation = None
self.pose = myo.Pose.rest
self.emg_enabled = False
self.locked = False
self.rssi = None
self.emg = None
def output(self):
if not self.interval.check_and_reset():
return
parts = []
if self.orientation:
for comp in self.orientation:
parts.append('{}{:.4f}'.format(' ' if comp >= 0 else '', comp))
parts.append(str(self.pose).ljust(15))
parts.append('E' if self.emg_enabled else ' ')
parts.append('L' if self.locked else ' ')
parts.append(self.rssi or 'NORSSI')
if self.emg:
for comp in self.emg:
parts.append(str(comp).ljust(5))
print('\r' + ''.join('[{}]'.format(p) for p in parts), end='')
sys.stdout.flush()
def on_connected(self, event):
event.device.request_rssi()
event.device.stream_emg(True)
self.emg_enabled = True
def on_rssi(self, event):
self.rssi = event.rssi
self.output()
def on_pose(self, event):
self.pose = event.pose
self.output()
def on_orientation(self, event):
self.orientation = event.orientation
self.output()
def on_emg(self, event):
self.emg = event.emg
self.output()
def __init__(self, queue_size=8):
self.lock = Lock()
self.emg_data_queue = collections.deque(maxlen=queue_size)
self.imu_data_queue = collections.deque(maxlen=queue_size)
self.acc_data_queue = collections.deque(maxlen=queue_size)
self.interval = TimeInterval(None, 0.05)
self.orientation = list()
self.acc = list()
self.gyro = list()
self.pose = myo.Pose.rest
self.emg_enabled = False
self.locked = False
self.rssi = None
self.emg = list()
class Listener(myo.DeviceListener):
def __init__(self):
self.interval = TimeInterval(None, 0.1)
self.orientation = None
self.emg_enabled = False
self.emg = None
self.lock = Lock()
self.emg_data_queue = collections.deque(maxlen=1)
self.ori_data_queue = collections.deque(maxlen=1)
global X
def output(self):
if not self.interval.check_and_reset():
return
parts = []
if self.orientation:
for comp in self.orientation:
parts.append(comp)
parts.append(self.emg)
X.append(parts)
#print(parts)
#parts is the orientation data
sys.stdout.flush()
def on_connected(self, event):
event.device.stream_emg(True)
def on_orientation(self, event):
self.orientation = event.orientation
self.output()
def on_emg_data(self, event):
print(str(event.emg))
self.output()
def on_emg(self, event):
self.emg = event.emg
self.output()
class Listener(myo.DeviceListener):
def __init__(self):
self.interval = TimeInterval(None, 0.05)
self.acceleration = None
self.gyroscope = None
self.orientation = None
self.pose = myo.Pose.rest
self.emg_enabled = True
self.locked = False
self.rssi = None
self.emg = None
self.temp = 0
def output(self):
if not self.interval.check_and_reset():
return
def on_connected(self, event):
event.device.request_rssi()
def on_pose(self, event):
self.pose = event.pose
if self.pose == myo.Pose.fist:
#self.locked = not self.locked
print(self.locked)
print("fist")
if self.pose == myo.Pose.rest:
print("rest")
if self.pose == myo.Pose.wave_in and not self.locked:
keyboard.press_and_release("left_arrow")
print("Wave In")
if self.pose == myo.Pose.wave_out and not self.locked:
keyboard.press_and_release("right_arrow")
print("Wave out")
if self.pose == myo.Pose.fingers_spread:
print("Fingers Spread")
class Listener(myo.DeviceListener):
def __init__(self):
self.interval = TimeInterval(None, 0.05)
self.orientation = None
self.pose = myo.Pose.rest
self.emg_enabled = False
self.locked = False
self.rssi = None
self.emg = None
def output(self):
if not self.interval.check_and_reset():
return
parts = []
if self.orientation:
for comp in self.orientation:
parts.append('{}{:.4f}'.format(' ' if comp >= 0 else '', comp))
parts.append(str(self.pose).ljust(10))
parts.append('E' if self.emg_enabled else ' ')
parts.append('L' if self.locked else ' ')
parts.append(self.rssi or 'NORSSI')
if self.emg:
for comp in self.emg:
parts.append(str(comp).ljust(5))
print('\r' + ''.join('[{}]'.format(p) for p in parts), end='')
sys.stdout.flush()
def on_connected(self, event):
event.device.request_rssi()
def on_rssi(self, event):
self.rssi = event.rssi
self.output()
def on_pose(self, event):
self.pose = event.pose
if self.pose == myo.Pose.double_tap:
event.device.stream_emg(True)
self.emg_enabled = True
elif self.pose == myo.Pose.fingers_spread:
event.device.stream_emg(False)
self.emg_enabled = False
self.emg = None
self.output()
def on_orientation(self, event):
self.orientation = event.orientation
self.output()
def on_emg(self, event):
self.emg = event.emg
self.output()
def on_unlocked(self, event):
self.locked = False
self.output()
def on_locked(self, event):
self.locked = True
self.output()
class Listener(myo.DeviceListener):
def __init__(self):
self.interval = TimeInterval(None, 0.05)
self.orientation = None
self.pose = myo.Pose.rest
self.emg_enabled = False
self.locked = False
self.rssi = None
self.emg = None
def output(self):
global centre
global indice, indice2
if not self.interval.check_and_reset():
return
parts = []
aux = list(
quaternion_to_euler(self.orientation[0], self.orientation[1],
self.orientation[2],
self.orientation[3])) #wrist, y, x
for i in range(len(aux)):
aux[i] = aux[i] - centre[i]
if aux[i] > 180:
aux[i] = aux[i] - 360
elif aux[i] < -180:
aux[i] = 360 + aux[i]
aux[2] = -aux[2]
if self.pose == 1 and (aux[0] > 90 or aux[0] < -90):
indice2 = 5
else:
indice2 = int(self.pose) - 1
if aux[2] > 50 and aux[1] < aux[2]:
indice = 3
'''print("XD+\n")
if self.pose == 1:
print("puño arriba")
elif self.pose == 2:
print("wave in")
elif self.pose == 3:
print("wave out")
elif self.pose == 4:
print("hola")
elif aux[0]>50:
print("derrape derecha")
elif aux[0]<-50:
print("derrape izda")'''
elif aux[2] < -50 and aux[1] > aux[2]:
indice = 2
'''print("XD-\n")
if self.pose == 1:
print("puño arriba")
elif self.pose == 2:
print("wave in")
elif self.pose == 3:
print("wave out")
elif self.pose == 4:
print("hola")
elif aux[0]>50:
print("derrape derecha")
elif aux[0]<-50:
print("derrape izda")'''
elif aux[1] > 30 and aux[2] < aux[1]:
indice = 0
'''print("Y:)\n")
if self.pose == 1:
print("puño arriba")
elif self.pose == 2:
print("wave in")
elif self.pose == 3:
print("wave out")
elif self.pose == 4:
print("hola")
elif aux[0]>50:
print("derrape derecha")
elif aux[0]<-50:
print("derrape izda")'''
elif aux[1] < -30 and aux[2] > aux[1]:
indice = 1
'''print("Y:(\n")
if self.pose == 1:
print("puño arriba")
elif self.pose == 2:
print("wave in")
elif self.pose == 3:
print("wave out")
elif self.pose == 4:
print("hola")
elif aux[0]>50:
print("derrape derecha")
elif aux[0]<-50:
print("derrape izda")'''
elif (aux[1] > -30 and aux[1] < 0) or (aux[2] > -50 and aux[2] < 50):
indice = -1
print(indice)
print(indice2)
if indice > -1:
print(predictor.gesto_a_letra(indice, indice2))
print(predictor.palabra_actual)
else:
if self.pose == 2:
predictor.escuchar_palabra(str(predictor.palabra_actual))
#predictor.escuchar_palabra("hola")
#self.engine.say("hola")
self.engine.runAndWait()
predictor.palabra_actual = ""
print("No te escucho\n")
parts.append(aux)
parts.append(str(self.pose).ljust(10))
parts.append('E' if self.emg_enabled else ' ')
print('\r' + ''.join('[{}]'.format(p) for p in parts), end='')
sys.stdout.flush()
def on_connected(self, event):
event.device.request_rssi()
def on_rssi(self, event):
self.rssi = event.rssi
def on_pose(self, event):
global centre, flag
self.pose = event.pose
if self.pose == myo.Pose.fingers_spread:
if flag:
centre = quaternion_to_euler(self.orientation[0],
self.orientation[1],
self.orientation[2],
self.orientation[3])
flag = 0
print("Centrado")
if self.pose != 0 and not flag:
self.locked = True
self.output()
time.sleep(2.5)
self.locked = False
event.device.vibrate(myo.VibrationType.short)
def on_orientation(self, event):
self.orientation = event.orientation
def on_emg(self, event):
self.emg = event.emg
def on_unlocked(self, event):
self.locked = False
def on_locked(self, event):
self.locked = True
class Listener(myo.DeviceListener):
def __init__(self):
self.interval = TimeInterval(None, 0.05)
self.orientation = None
self.pose = myo.Pose.rest
self.emg_enabled = True
self.locked = False
self.rssi = None
self.emg = None
#self.output = ""
self.csv = open("out.csv",'a')
self.LABEL = 'j'
def output(self):
if not self.interval.check_and_reset() or not self.emg or not self.orientation:
return
parts = []
for comp in self.orientation:
parts.append('{:.4f}'.format( comp))
#parts.append(str(self.pose).ljust(10))
#parts.append('E' if self.emg_enabled else ' ')
#parts.append('L' if self.locked else ' ')
#parts.append(self.rssi or 'NORSSI')
for comp in self.emg:
parts.append(str(comp).strip())
line = self.LABEL + ', {:.4f}, '.format(time.time()) + ''.join('{}, '.format(p) for p in parts) + '\n'
self.csv.write(line)
self.csv.flush()
print(line, end='')
sys.stdout.flush()
def on_connected(self, event):
event.device.request_rssi()
#event.device.request_battery_level()
def on_rssi(self, event):
self.rssi = event.rssi
#self.output()
def on_pose(self, event):
self.pose = event.pose
event.device.stream_emg(True)
self.output()
"""
if self.pose == myo.Pose.double_tap:
event.device.stream_emg(True)
self.emg_enabled = True
elif self.pose == myo.Pose.fingers_spread:
event.device.stream_emg(False)
self.emg_enabled = False
self.emg = None
self.output()
"""
def on_orientation(self, event):
self.orientation = event.orientation
self.output()
def on_emg(self, event):
self.emg = event.emg
self.output()
def on_unlocked(self, event):
#self.locked = False
#self.output()
pass
def on_locked(self, event):
#self.locked = True
#self.output()
pass
class Listener(myo.DeviceListener):
def __init__(self):
self.interval = TimeInterval(None, 0.05)
self.orientation = None
self.pose = myo.Pose.rest # unused
self.emg_enabled = True
self.locked = False
self.rssi = None
self.emg = None
def output(self):
if not self.interval.check_and_reset():
return
sample_parameters = collections.deque(maxlen=2)
sample_limit = 50
with open("sample_parameters.txt") as file_sampleParam:
for line in file_sampleParam:
for num in line.split(','):
sample_parameters.append(int(num))
sample_count = sample_parameters[0]
sample_number = sample_parameters[1]
if sample_count == sample_limit:
contVar = int(input("Do you want to continue? "))
if contVar == 1:
sample_number = sample_number + 1
sample_count = 0
else:
pass
else:
quat_w = open("quaternion_w" + "_" + str(sample_number) + ".txt",
"a+")
quat_i = open("quaternion_i" + "_" + str(sample_number) + ".txt",
"a+")
quat_j = open("quaternion_j" + "_" + str(sample_number) + ".txt",
"a+")
quat_k = open("quaternion_k" + "_" + str(sample_number) + ".txt",
"a+")
emgPod_1 = open("emgPod1" + "_" + str(sample_number) + ".txt",
"a+")
emgPod_2 = open("emgPod2" + "_" + str(sample_number) + ".txt",
"a+")
emgPod_3 = open("emgPod3" + "_" + str(sample_number) + ".txt",
"a+")
emgPod_4 = open("emgPod4" + "_" + str(sample_number) + ".txt",
"a+")
emgPod_5 = open("emgPod5" + "_" + str(sample_number) + ".txt",
"a+")
emgPod_6 = open("emgPod6" + "_" + str(sample_number) + ".txt",
"a+")
emgPod_7 = open("emgPod7" + "_" + str(sample_number) + ".txt",
"a+")
emgPod_8 = open("emgPod8" + "_" + str(sample_number) + ".txt",
"a+")
quaternions_read = collections.deque(maxlen=4)
instances_quat = 4
emg_read = collections.deque(maxlen=8)
instances_emg = 8
if self.orientation and self.emg:
for element in self.orientation:
quaternions_read.append(element)
instances_quat = instances_quat - 1
if instances_quat == 0:
quat_w.write(str(quaternions_read[0]) + ' ')
quat_i.write(str(quaternions_read[1]) + ' ')
quat_j.write(str(quaternions_read[2]) + ' ')
quat_k.write(str(quaternions_read[3]) + ' ')
for element in self.emg:
emg_read.append(element)
instances_emg = instances_emg - 1
if instances_emg == 0:
emgPod_1.write(str(emg_read[0]) + ' ')
emgPod_2.write(str(emg_read[1]) + ' ')
emgPod_3.write(str(emg_read[2]) + ' ')
emgPod_4.write(str(emg_read[3]) + ' ')
emgPod_5.write(str(emg_read[4]) + ' ')
emgPod_6.write(str(emg_read[5]) + ' ')
emgPod_7.write(str(emg_read[6]) + ' ')
emgPod_8.write(str(emg_read[7]) + ' ')
sample_count = sample_count + 1
#print(quaternions_read)
#print(emg_read)
quat_w.close()
quat_i.close()
quat_j.close()
quat_k.close()
emgPod_1.close()
emgPod_2.close()
emgPod_3.close()
emgPod_4.close()
emgPod_5.close()
emgPod_6.close()
emgPod_7.close()
emgPod_8.close()
file_sampleParam = open("sample_parameters.txt", "w")
file_sampleParam.write(str(sample_count) + ',' + str(sample_number))
file_sampleParam.close()
def on_connected(self, event):
event.device.request_rssi()
event.device.stream_emg(True)
def on_rssi(self, event):
self.rssi = event.rssi
self.output()
def on_pose(self, event):
self.pose = event.pose
self.output()
def on_orientation(self, event):
self.orientation = event.orientation
self.output()
def on_emg(self, event):
self.emg = event.emg
self.output()
def on_unlocked(self, event):
self.locked = False
self.output()
def on_locked(self, event):
self.locked = True
self.output()
class Listener(myo.DeviceListener):
def __init__(self):
self.interval = TimeInterval(None, 0.01)
self.orientation = None
self.pose = myo.Pose.rest
self.emg_enabled = False
self.locked = False
self.rssi = None
self.emg = None
self.acceleration = None
self.gyroscope = None
self.quat = None
self.yaw = None
self.roll = None
self.pitch = None
self.snap = snap
def output(self):
if not self.interval.check_and_reset():
return
s1 = Snapshot(self.orientation, self.emg, self.gyroscope,
self.acceleration, self.roll, self.pitch, self.yaw)
#print(s1)
if( s1.orientation and s1.emg and s1.gyroscope and
s1.acceleration and s1.roll and s1.pitch and s1.yaw ):
self.snap.append(s1)
def on_connected(self, event):
event.device.request_rssi()
event.device.stream_emg(True)
self.emg_enabled = True
print("connected")
time.sleep(1)
print(3)
time.sleep(1)
print(2)
time.sleep(1)
print(1)
time.sleep(1)
print("shoot")
def on_rssi(self, event):
self.rssi = event.rssi
self.output()
def on_pose(self, event):
self.pose = event.pose
self.output()
def on_orientation(self, event):
temp = []
self.orientation = event.orientation
if(self.orientation):
quaternion = Quaternion(self.orientation[0], self.orientation[1]
,self.orientation[2], self.orientation[3])
self.yaw = quaternion.yaw
self.roll = quaternion.roll
self.pitch = quaternion.pitch
self.acceleration = event.acceleration
self.gyroscope = event.gyroscope
self.output()
def on_emg(self, event):
self.emg = event.emg
self.output()
def on_unlocked(self, event):
self.locked = False
self.output()
def on_locked(self, event):
self.locked = True
self.output()
def post_mov(self, data):
post = FakeDatabase('data.txt')
post.dumpToFile(data)
def read_data(self):
post = FakeDatabase('data.txt')
return post.parseDataFromFile()
class Listener(myo.DeviceListener):
def __init__(self):
self.interval = TimeInterval(None, 0.05)
self.acceleration = None
self.gyroscope = None
self.orientation = None
self.pose = myo.Pose.rest
self.emg_enabled = True
self.locked = False
self.rssi = None
self.emg = None
self.temp = 0
def output(self):
if not self.interval.check_and_reset():
return
self.temp = self.temp + 1
if self.temp == 5:
self.temp = 0
os.system('cls')
parts = []
if self.orientation:
parts.append("Orientation")
for comp in self.orientation:
parts.append('{}{:.4f}'.format(' ' if comp >= 0 else '', comp))
parts.append('\n')
if self.acceleration:
parts.append("Acceleration")
for comp in self.acceleration:
parts.append('{}{:.4f}'.format(' ' if comp >= 0 else '', comp))
parts.append('\n')
if self.gyroscope:
parts.append("Gyroscope")
for comp in self.gyroscope:
parts.append('{}{:.4f}'.format(' ' if comp >= 0 else '', comp))
parts.append('\n')
#parts.append(str(self.pose).ljust(10))
#parts.append('E' if self.emg_enabled else ' ')
#parts.append('L' if self.locked else ' ')
#parts.append(self.rssi or 'NORSSI')
if self.emg:
parts.append("EMG")
for comp in self.emg:
parts.append(str(comp).ljust(5))
os.system('cls')
print('\r' + ''.join('[{}]'.format(p) for p in parts), end='')
def on_connected(self, event):
event.device.request_rssi()
event.device.stream_emg(True)
def on_rssi(self, event):
self.rssi = event.rssi
self.output()
def on_orientation(self, event):
self.orientation = event.orientation
self.acceleration = event.acceleration
self.gyroscope = event.gyroscope
self.output()
def on_emg(self, event):
self.emg = event.emg
self.output()
def on_unlocked(self, event):
self.locked = False
self.output()
def on_locked(self, event):
self.locked = True
self.output()
class Listener(myo.DeviceListener):
def __init__(self):
self.interval = TimeInterval(None, 0.02)
self.orientation = None
self.pose = myo.Pose.rest
self.emg_enabled = False
self.locked = False
self.rssi = None
self.emg = None
send_address = '127.0.0.1', 9098
print("Sending Myo data on {}".format(send_address))
print("Ctrl+C to quit")
self.client = OSC.OSCClient()
self.client.connect(send_address)
self.ypr = None
self.orientstring = []
self.t = time.time()
self.delta = 0
def output(self):
if not self.interval.check_and_reset():
return
self.delta = time.time() - self.t
self.t = time.time()
self.orientstring = []
parms = []
if self.orientation:
for q in self.orientation:
parms.append(q)
self.orientstring.append('{}{:.4f}'.format(
' ' if q >= 0 else '', q))
#mapping quaternions to normalized control values
angles = self.toEulerAngle(parms)
ypr = self.normalizeAndOffset(angles)
self.ypr = ypr
# send to OSC
for i in range(len(ypr)):
msg = OSC.OSCMessage()
msg.setAddress("/Myo/{}".format(i + 1))
msg.append(ypr[i])
self.client.send(msg)
def normalizeAndOffset(self, angles):
# get yaw, pitch, roll of 0.5, 0.5, 0.5 when your arm is pointing straight in front of you
# yaw increase to the right
# pitch increase up
# roll increase clockwise
y, p, r = angles
y = 1 - ((y / (2 * math.pi) + 0.5))
p = 1 - (p / (2 * math.pi) + 0.5) #
r = ((r / (2 * math.pi) + 1.0) % 1.0)
return y, p, r
def toEulerAngle(self, quats):
""" Quaternion to Euler angle conversion borrowed from wikipedia.
https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles """
w, x, y, z = quats
# roll (x-axis rotation)
sinr = +2.0 * (w * x + y * z)
cosr = +1.0 - 2.0 * (x * x + y * y)
roll = math.atan2(sinr, cosr)
# pitch (y-axis rotation)
sinp = +2.0 * (w * y - z * x)
if (math.fabs(sinp) >= 1):
pitch = math.copysign(math.pi / 2,
sinp) # use 90 degrees if out of range
else:
pitch = math.asin(sinp)
# yaw (z-axis rotation)
siny = +2.0 * (w * z + x * y)
cosy = +1.0 - 2.0 * (y * y + z * z)
yaw = math.atan2(siny, cosy)
return roll, pitch, yaw
def on_connected(self, event):
event.device.request_rssi()
def on_rssi(self, event):
self.rssi = event.rssi
self.output()
def on_pose(self, event):
self.pose = event.pose
if self.pose == myo.Pose.double_tap:
event.device.stream_emg(True)
self.emg_enabled = True
elif self.pose == myo.Pose.fingers_spread:
event.device.stream_emg(False)
self.emg_enabled = False
self.emg = None
self.output()
def on_orientation(self, event):
self.orientation = event.orientation
self.output()
def on_emg(self, event):
self.emg = event.emg
self.output()
def on_unlocked(self, event):
self.locked = False
self.output()
def on_locked(self, event):
self.locked = True
self.output()
class Listener(myo.DeviceListener):
def __init__(self):
self.interval = TimeInterval(None, 0.05)
self.orientation = None
self.pose = myo.Pose.rest # unused
self.emg_enabled = True
self.locked = False
self.rssi = None
self.emg = None
def output(self):
if not self.interval.check_and_reset():
return
sample_count = int(np.loadtxt('sample_count.txt'))
sample_limit = 50
# files containing EMG and orientation data.
quat_w = open("quaternion_w" + ".txt", "a+")
quat_i = open("quaternion_i" + ".txt", "a+")
quat_j = open("quaternion_j" + ".txt", "a+")
quat_k = open("quaternion_k" + ".txt", "a+")
emgPod_1 = open("emgPod1" + ".txt", "a+")
emgPod_2 = open("emgPod2" + ".txt", "a+")
emgPod_3 = open("emgPod3" + ".txt", "a+")
emgPod_4 = open("emgPod4" + ".txt", "a+")
emgPod_5 = open("emgPod5" + ".txt", "a+")
emgPod_6 = open("emgPod6" + ".txt", "a+")
emgPod_7 = open("emgPod7" + ".txt", "a+")
emgPod_8 = open("emgPod8" + ".txt", "a+")
# temp variables for EMG and orientation data.
quaternions_read = collections.deque(maxlen=4)
instances_quat = 4
emg_read = collections.deque(maxlen=8)
instances_emg = 8
if sample_count != sample_limit:
if self.orientation and self.emg:
# get orientation data.
for element in self.orientation:
quaternions_read.append(element)
instances_quat = instances_quat - 1
if instances_quat == 0:
quat_w.write(str(quaternions_read[0]) + ' ')
quat_i.write(str(quaternions_read[1]) + ' ')
quat_j.write(str(quaternions_read[2]) + ' ')
quat_k.write(str(quaternions_read[3]) + ' ')
# get EMG data.
for element in self.emg:
emg_read.append(element)
instances_emg = instances_emg - 1
if instances_emg == 0:
emgPod_1.write(str(emg_read[0]) + ' ')
emgPod_2.write(str(emg_read[1]) + ' ')
emgPod_3.write(str(emg_read[2]) + ' ')
emgPod_4.write(str(emg_read[3]) + ' ')
emgPod_5.write(str(emg_read[4]) + ' ')
emgPod_6.write(str(emg_read[5]) + ' ')
emgPod_7.write(str(emg_read[6]) + ' ')
emgPod_8.write(str(emg_read[7]) + ' ')
# updates sample count (max: 50).
sample_count = sample_count + 1
np.savetxt('sample_count.txt', [sample_count])
# close files with orientation data once they will no longer be accessed.
quat_w.close()
quat_i.close()
quat_j.close()
quat_k.close()
# close files with EMG data once they will no longer be accessed.
emgPod_1.close()
emgPod_2.close()
emgPod_3.close()
emgPod_4.close()
emgPod_5.close()
emgPod_6.close()
emgPod_7.close()
emgPod_8.close()
else:
print('\nTranslating gesture...') # flavor text.
# retrieve all data as arrays.
emgPod_1 = np.loadtxt("emgPod1" + ".txt")
emgPod_2 = np.loadtxt("emgPod2" + ".txt")
emgPod_3 = np.loadtxt("emgPod3" + ".txt")
emgPod_4 = np.loadtxt("emgPod4" + ".txt")
emgPod_5 = np.loadtxt("emgPod5" + ".txt")
emgPod_6 = np.loadtxt("emgPod6" + ".txt")
emgPod_7 = np.loadtxt("emgPod7" + ".txt")
emgPod_8 = np.loadtxt("emgPod8" + ".txt")
quat_w = np.loadtxt("quaternion_w" + ".txt")
quat_i = np.loadtxt("quaternion_i" + ".txt")
quat_j = np.loadtxt("quaternion_j" + ".txt")
quat_k = np.loadtxt("quaternion_k" + ".txt")
# stack data element-wise.
input_data = np.dstack(
(emgPod_1, emgPod_2, emgPod_3, emgPod_4, emgPod_5, emgPod_6,
emgPod_7, emgPod_8, quat_i, quat_j, quat_k, quat_w))
# reshape for use in NN.
input_data = np.array(input_data).reshape((1, 50, 12))
# interface with NN.
gesture = create_and_predict_model(input_data)
# print output.
print('\nYou said: "' + str(gesture) + '."')
def on_connected(self, event):
event.device.request_rssi()
event.device.stream_emg(True)
def on_rssi(self, event):
self.rssi = event.rssi
self.output()
def on_pose(self, event):
self.pose = event.pose
self.output()
def on_orientation(self, event):
self.orientation = event.orientation
self.output()
def on_emg(self, event):
self.emg = event.emg
self.output()
def on_unlocked(self, event):
self.locked = False
self.output()
def on_locked(self, event):
self.locked = True
self.output()
class Listener(myo.DeviceListener):
def __init__(self):
self.interval = TimeInterval(None, 0.05)
self.orientation = None
self.pose = myo.Pose.rest # unused
self.emg_enabled = True
self.locked = False
self.rssi = None
self.emg = None
def output(self):
if not self.interval.check_and_reset():
return
sample_count = int(np.loadtxt('sample_count.txt'))
sample_limit = 50
# files containing EMG and orientation data.
quat_w = open("quaternion_w" + ".txt", "a+")
quat_i = open("quaternion_i" + ".txt", "a+")
quat_j = open("quaternion_j" + ".txt", "a+")
quat_k = open("quaternion_k" + ".txt", "a+")
emgPod_1 = open("emgPod1" + ".txt", "a+")
emgPod_2 = open("emgPod2" + ".txt", "a+")
emgPod_3 = open("emgPod3" + ".txt", "a+")
emgPod_4 = open("emgPod4" + ".txt", "a+")
emgPod_5 = open("emgPod5" + ".txt", "a+")
emgPod_6 = open("emgPod6" + ".txt", "a+")
emgPod_7 = open("emgPod7" + ".txt", "a+")
emgPod_8 = open("emgPod8" + ".txt", "a+")
# temp variables for EMG and orientation data.
quaternions_read = collections.deque(maxlen=4)
instances_quat = 4
emg_read = collections.deque(maxlen=8)
instances_emg = 8
if sample_count != sample_limit:
if self.orientation and self.emg:
# get orientation data.
for element in self.orientation:
quaternions_read.append(element)
instances_quat = instances_quat - 1
if instances_quat == 0:
quat_w.write(str(quaternions_read[0]) + ' ')
quat_i.write(str(quaternions_read[1]) + ' ')
quat_j.write(str(quaternions_read[2]) + ' ')
quat_k.write(str(quaternions_read[3]) + ' ')
# get EMG data.
for element in self.emg:
emg_read.append(element)
instances_emg = instances_emg - 1
if instances_emg == 0:
emgPod_1.write(str(emg_read[0]) + ' ')
emgPod_2.write(str(emg_read[1]) + ' ')
emgPod_3.write(str(emg_read[2]) + ' ')
emgPod_4.write(str(emg_read[3]) + ' ')
emgPod_5.write(str(emg_read[4]) + ' ')
emgPod_6.write(str(emg_read[5]) + ' ')
emgPod_7.write(str(emg_read[6]) + ' ')
emgPod_8.write(str(emg_read[7]) + ' ')
# updates sample count.
sample_count = sample_count + 1
np.savetxt('sample_count.txt', [sample_count])
else:
pass
# close files with orientation data once they will no longer be accessed.
quat_w.close()
quat_i.close()
quat_j.close()
quat_k.close()
# close files with EMG data once they will no longer be accessed.
emgPod_1.close()
emgPod_2.close()
emgPod_3.close()
emgPod_4.close()
emgPod_5.close()
emgPod_6.close()
emgPod_7.close()
emgPod_8.close()
def on_connected(self, event):
event.device.request_rssi()
event.device.stream_emg(True)
def on_rssi(self, event):
self.rssi = event.rssi
self.output()
def on_pose(self, event):
self.pose = event.pose
self.output()
def on_orientation(self, event):
self.orientation = event.orientation
self.output()
def on_emg(self, event):
self.emg = event.emg
self.output()
def on_unlocked(self, event):
self.locked = False
self.output()
def on_locked(self, event):
self.locked = True
self.output()
