def evt_main():
global is_running
ring_buf = np.zeros(x.size)
ring_buf2 = np.zeros(x.size)
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(0)
pos = 0
try:
while is_running:
packet = headset.dequeue()
print packet.gyro_x, packet.gyro_y
ring_buf[pos] = packet.sensors["O1"]["value"]
ring_buf2[pos] = packet.sensors["O2"]["value"]
pos = (pos + 1) % ring_buf.size
if pos % 4 == 0:
yield np.concatenate((ring_buf[pos:ring_buf.size:1], ring_buf[0:pos:1])), np.concatenate((ring_buf2[pos:ring_buf.size:1], ring_buf2[0:pos:1]))
gevent.sleep(0)
except KeyboardInterrupt:
headset.close()
finally:
is_running = False
headset.close()
def analizeProccess(self):
headset = Emotiv(display_output = False)
gevent.spawn(headset.setup)
gevent.sleep(0)
packets = {};
bufferLenght = 128*3
sensors = "O1 O2".split(' ')
print "analize"
for name in sensors:
packets[name] = []
pass
while True:
p = headset.dequeue()
if p != None:
for name in sensors:
packets[name].append(p.sensors[name]['value'])
pass
if len(packets[sensors[0]]) >= bufferLenght:
self.signal = self.analize(packets,sensors,bufferLenght,[8,12])
#print self.signal
for name in sensors:
packets[name] = packets[name][5:]
pass
pass
gevent.sleep(0)
pass
def epocBuffer(self):
cont = 0
logging.debug("Iniciando buffer del epoc")
headset = Emotiv(display_output=False)
gevent.spawn(headset.setup)
gevent.sleep(0)
showFillMessage = True
while self.epocBufferState:
packet = headset.dequeue()
key.acquire()
if packet == None:
logging.debug("Error, paquete nulo")
else:
#print packet.gyro_x, packet.gyro_y
self.packages.append(packet)
#print packet.sensors['O2']['value']
if len(self.packages) > self.bufferlength:
if showFillMessage:
logging.debug("Buffer lleno con " +
str(self.bufferlength) + " paquetes")
showFillMessage ^= True
self.packages = self.packages[10:]
gevent.sleep(0)
key.release()
pass
headset.close()
logging.debug("Buffer detenido")
pass
def evt_main():
global is_running
ring_buf = np.zeros(x.size)
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(0)
pos = 0
try:
while is_running:
packet = headset.dequeue()
print packet.gyro_x, packet.gyro_y
ring_buf[pos] = packet.sensors["O1"]["value"]
pos = (pos + 1) % ring_buf.size
if pos % 4 == 0:
yield np.concatenate(
(ring_buf[pos:ring_buf.size:1], ring_buf[0:pos:1]))
gevent.sleep(0)
except KeyboardInterrupt:
headset.close()
finally:
is_running = False
headset.close()
def console_gather() :
os.system('clear')
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(0)
packets = 0
now = datetime.now()
filename = str(now.time()) + "_" + str(now.date())
while True :
dir = str(input("Choose input: \n 1. up\n 2. down\n 3. left\n 4. right\n 0. neutral\n"))
if dir in ['1','2','3','4','0'] : break
filename += "_" + dir
if TEST : filename = "TEST_" + filename
buffers = []
names = 'AF3 F7 F3 FC5 T7 P7 O1 O2 P8 T8 FC6 F4 F8 AF4'.split(' ')
for name in names :
buffers.append(sensor_buffer(name))
print "Training will start in..."; sleep(1); print "3..."; sleep(1); print "2..."; sleep(1); print "1..."; sleep(1); print "Focus!"
qualities = []
timeout = time() + 12
while True:
if time() > timeout :
break
packet = headset.dequeue()
for buffer in buffers :
buffer.update( packet )
packets += 1
gevent.sleep(0)
headset.close()
quality = 0.
f = open("./data/" + filename,'w')
columns = []
for name in names :
columns.append(str(name))
columns.append('Q' + str(name))
f.write(','.join(columns))
f.write('\n')
while packets > 0 :
for buffer in buffers :
f.write( buffer.pop() )
f.write('\n')
packets -= 1
f.close()
print "Finished reading, saved to file %s" % filename
for buffer in buffers :
print "Sensor %s mean quality: %.2f" % (buffer.name, buffer.mean_quality())
def main_process(self):
"""
Get realtime EEG data from Emotiv EPOC, process all data (FFT, feature extraction, and classification), and predict the emotion.
Input: -
Output: Class of emotion between 1 to 5 according to Russel's Circumplex Model.
"""
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(0)
threads = []
eeg_realtime = np.zeros((number_of_channel, number_of_realtime_eeg),
dtype=np.double)
counter = 0
init = True
try:
#Looping to get realtime EEG data from Emotiv EPOC
while True:
packet = headset.dequeue()
#Get initial EEG data for all channels
if init:
for i in range(number_of_channel):
eeg_realtime[i, counter] = packet.sensors[
channel_names[i]]['value']
else:
new_data = [
packet.sensors[channel_names[i]]['value']
for i in range(number_of_channel)
]
eeg_realtime = np.insert(eeg_realtime,
number_of_realtime_eeg,
new_data,
axis=1)
eeg_realtime = np.delete(eeg_realtime, 0, axis=1)
#If EEG data have been recorded in ... seconds, then process data to predict emotion
if counter == (sampling_rate -
1) or counter == (number_of_realtime_eeg - 1):
t = threading.Thread(target=rte.process_all_data,
args=(eeg_realtime, ))
threads.append(t)
t.start()
init = False
counter = 0
gevent.sleep(0)
counter += 1
except KeyboardInterrupt:
headset.close()
finally:
headset.close()
def epoc_publish_frames():
# Setup ROS publisher.
publisher = rospy.Publisher('epoc/frames', EEGFrame)
# Open a connection to the Emotiv EPOC.
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(1)
# Initialize ROS node+publisher.
rospy.init_node('epoc_publish')
# Start the publishing loop.
rospy.loginfo('Starting publishing loop...')
published_count = 0
try:
while not rospy.is_shutdown():
# Get the next packet from the EPOC.
packet = headset.dequeue()
frame_header = Header(published_count, rospy.Time.now(), '/epoc')
frame_accel_x = packet.sensors['X']['value']
frame_accel_y = packet.sensors['Y']['value']
frame_signals = [
packet.sensors[channel]['value']
for channel in channels]
frame_qualities = [
packet.sensors[channel]['quality']
for channel in channels]
frame = EEGFrame(
frame_header,
frame_accel_x,
frame_accel_y,
14,
channels,
frame_signals,
frame_qualities)
# Publish the the EEG channels and accelerometer values.
publisher.publish(frame)
# Update and print information count.
published_count += 1
print('\rPublished: %d' % published_count, end='')
gevent.sleep(0)
except rospy.ROSInterruptException:
headset.close()
def evt_main():
global is_running
ring_buf = np.zeros(x.size)
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(0)
pos = 0
try:
while is_running:
packet = headset.dequeue()
yield packet
gevent.sleep(0)
except KeyboardInterrupt:
headset.close()
finally:
is_running = False
headset.close()
def evt_main():
global is_running
ring_buf = np.zeros(x.size)
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(0)
pos = 0
try:
while is_running:
packet = headset.dequeue()
yield packet
gevent.sleep(0)
except KeyboardInterrupt:
headset.close()
finally:
is_running = False
headset.close()
def main_process(self): """ Get realtime EEG data from Emotiv EPOC, process all data (FFT, feature extraction, and classification), and predict the emotion. Input: - Output: Class of emotion between 1 to 5 according to Russel's Circumplex Model. """ headset = Emotiv() gevent.spawn(headset.setup) gevent.sleep(0) threads = [] eeg_realtime = np.zeros((number_of_channel,number_of_realtime_eeg),dtype=np.double) counter=0 init=True try: #Looping to get realtime EEG data from Emotiv EPOC while True: packet = headset.dequeue() #Get initial EEG data for all channels if init: for i in range(number_of_channel):eeg_realtime[i,counter]=packet.sensors[channel_names[i]]['value'] else: new_data=[packet.sensors[channel_names[i]]['value'] for i in range(number_of_channel)] eeg_realtime=np.insert(eeg_realtime,number_of_realtime_eeg,new_data,axis=1) eeg_realtime=np.delete(eeg_realtime,0,axis=1) #If EEG data have been recorded in ... seconds, then process data to predict emotion if counter == (sampling_rate-1) or counter == (number_of_realtime_eeg-1): t = threading.Thread(target=rte.process_all_data, args=(eeg_realtime,)) threads.append(t) t.start() init=False counter=0 gevent.sleep(0) counter += 1 except KeyboardInterrupt: headset.close() finally: headset.close()
def _thread_reading_online(self):
"""
Helper function for reading online data.
To be used as a thread, putting data to queue.
"""
online_data = dict(
zip(self.channel_list,
[[] for i in range(len(self.channel_list))]))
counter = 0
headset = Emotiv(display_output=False,
serial_number=self.serial_number,
write_values=False)
# epoc_channels = [k[1] for k in enumerate(self.headset.sensors)]
try:
start_time = time.time()
while True:
packet = headset.dequeue()
if packet is not None:
for ch in self.channel_list:
quality = packet.sensors[ch]['quality']
data = packet.sensors[ch]['value']
online_data[ch].append((data * 0.51) / 1000.) # in mV
counter += 1
if counter >= self.buffer_size:
ratio = self.sampling_rate // self.buffer_size
# assert ((time.time() - start_time) % (1./ratio)) < 0.075 # assert sampling rate
# print((time.time() - start_time) % (1./ratio))
# if not ((time.time() - start_time) % 1) < 0.05:
# print("WARNING: sampling rate is low!")
self.online_data_queue.put(
[online_data, headset.battery])
online_data = dict(
zip(self.channel_list,
[[] for i in range(len(self.channel_list))]))
counter = 0
except KeyboardInterrupt:
print("stopping...")
self.stop()
def packets():
global is_running
ring_buf = np.zeros(x.size)
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(0)
pos = 0
try:
while is_running:
packet = headset.dequeue()
data = {key: (value["value"], value["quality"])
for (key, value) in packet.sensors.items()}
yield data
gevent.sleep(0)
except KeyboardInterrupt:
headset.close()
finally:
is_running = False
headset.close()
def epoc_publish_channels():
# Setup ROS publishers.
signal_publishers = {
channel: rospy.Publisher('epoc/signal/%s' % channel, UInt32)
for channel
in channels}
quality_publishers = {
channel: rospy.Publisher('epoc/quality/%s' % channel, UInt32)
for channel
in channels}
# Open a connection to the Emotiv EPOC.
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(1)
# Initialize ROS node+publisher.
rospy.init_node('epoc_publish')
# Start the publishing loop.
rospy.loginfo('Starting publishing loop...')
published_count = 0
try:
while not rospy.is_shutdown():
# Get the next packet from the EPOC.
packet = headset.dequeue()
# Publish the the EEG channels and accelerometer values.
for channel in channels:
signal = UInt32(packet.sensors[channel]['value'])
quality = UInt32(packet.sensors[channel]['quality'])
signal_publishers[channel].publish(signal)
quality_publishers[channel].publish(quality)
# Update and print information count.
published_count += 1
print('\rPublished: %d' % published_count, end='')
gevent.sleep(0)
except rospy.ROSInterruptException:
headset.close()
class ThreadReaderEmotiv(Thread):
def __init__(self, input):
threading.Thread.__init__(self)
self.headset = Emotiv()
self.f3 = input['F3']
self.f4 = input['F4']
self.af3 = input['AF3']
self.af4 = input['AF4']
def run(self):
self.headset = Emotiv()
gevent.spawn(self.headset.setup)
gevent.sleep(0)
print("Serial Number: %s" % self.headset.serial_number)
while True:
packet = self.headset.dequeue()
self.f3.insert(packet.sensors['F3']['value'])
self.f4.insert(packet.sensors['F4']['value'])
self.af3.insert(packet.sensors['AF3']['value'])
self.af4.insert(packet.sensors['AF4']['value'])
gevent.sleep(0)
def evt_main(ring_buf):
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(0)
pos = 0
try:
while True:
packet = headset.dequeue()
print packet.gyro_x, packet.gyro_y
ring_buf[pos] = packet.gyro_x
if pos % 4 == 0:
yield ring_buf
pos = (pos + 1) % 1024
gevent.sleep(0)
except KeyboardInterrupt:
headset.close()
finally:
is_running = False
headset.close()
def evt_main(ring_buf):
global is_running
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(0)
pos = 0
try:
while is_running:
packet = headset.dequeue()
print packet.gyro_x, packet.gyro_y
ring_buf[pos] = packet.sensors["FC5"]["value"]
if pos % 4 == 0:
yield ring_buf
pos = (pos + 1) % ring_buf.size
gevent.sleep(0)
except KeyboardInterrupt:
headset.close()
finally:
is_running = False
headset.close()
def evt_main(ring_buf):
global is_running
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(0)
pos = 0
try:
while is_running:
packet = headset.dequeue()
print packet.gyro_x, packet.gyro_y
ring_buf[pos] = packet.sensors["FC5"]["value"]
if pos % 4 == 0:
yield ring_buf
pos = (pos + 1) % ring_buf.size
gevent.sleep(0)
except KeyboardInterrupt:
headset.close()
finally:
is_running = False
headset.close()
def start(self, sequence=None, time_block=7, filename='data.csv'):
self.time_block = time_block
self.filename = filename
#Se define el objeto EMOTIV, utilizando la libreria EMOKIT
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(0)
print("Serial Number: %s" % headset.serial_number)
if sequence is not None:
self.sequence = sequence
self.num_blocks = len(self.sequence)
i = 0
cont_block = 0
cont_seconds = 0
temp_t = 0
tag = self.sequence[0]
#Se define el escritor de las lecturas en el archivo CSV
writer = csv.writer(open(self.filename, 'w'),
delimiter='\t',
quotechar='"')
try:
t0 = time.time()
while True:
t = int(time.time() - t0)
#t = int(time.time())
if temp_t != t:
cont_seconds += 1
if cont_seconds > self.time_block:
cont_seconds = 0
cont_block += 1
if cont_block == self.num_blocks:
headset.close()
break
else:
tag = self.sequence[cont_block]
# Se obtiene el paquete de datos, utilizando EMOKIT
packet = headset.dequeue()
# Se construye la informacion a guardar
row = [
str(t), "F3:" + str(packet.sensors['F3']['quality']) +
"," + str(packet.sensors['F3']['value']),
"F4:" + str(packet.sensors['F4']['quality']) + "," +
str(packet.sensors['F4']['value']),
"AF3:" + str(packet.sensors['AF3']['quality']) + "," +
str(packet.sensors['AF3']['value']),
"AF4:" + str(packet.sensors['AF4']['quality']) + "," +
str(packet.sensors['AF4']['value']), tag
]
# Se exporta a csv
writer.writerow(row)
print row
temp_t = t
gevent.sleep(0)
except KeyboardInterrupt:
headset.close()
finally:
headset.close()
i += 1
def main():
"""
Creates pygame window and graph drawing workers for each sensor.
"""
global gheight
pygame.init()
screen = pygame.display.set_mode((1280, 800))
graphers = []
recordings = []
recording = False
record_packets = []
updated = False
cursor_x, cursor_y = 400, 300
#for name in 'AF3 F7 F3 FC5 T7 P7 O1 O2 P8 T8 FC6 F4 F8 AF4'.split(' '):
for name in 'AF4 P8 F4 T8 O2'.split(' '):
graphers.append(Grapher(screen, name, len(graphers)))
fullscreen = False
emotiv = Emotiv(display_output=True)
gevent.spawn(emotiv.setup)
gevent.sleep(0)
while emotiv.running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
emotiv.close()
return
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
emotiv.close()
return
elif event.key == pygame.K_f:
if fullscreen:
screen = pygame.display.set_mode((1280, 800))
fullscreen = False
else:
screen = pygame.display.set_mode((1280, 800), FULLSCREEN, 16)
fullscreen = True
elif event.key == pygame.K_r:
if not recording:
record_packets = []
recording = True
else:
recording = False
recordings.append(list(record_packets))
record_packets = None
packets_in_queue = 0
try:
while packets_in_queue < 8:
packet = emotiv.dequeue()
if abs(packet.gyro_x) > 1:
cursor_x = max(0, min(cursor_x, 1280))
cursor_x -= packet.gyro_x
if abs(packet.gyro_y) > 1:
cursor_y += packet.gyro_y
cursor_y = max(0, min(cursor_y, 800))
map(lambda x: x.update(packet), graphers)
if recording:
record_packets.append(packet)
updated = True
packets_in_queue += 1
except Exception, ex:
print ex
if updated:
screen.fill((75, 75, 75))
map(lambda x: x.draw(), graphers)
pygame.draw.rect(screen, (255, 255, 255), (cursor_x - 5, cursor_y - 5, 10, 10), 0)
pygame.display.flip()
updated = False
gevent.sleep(0)
def main():
"""
Creates pygame window and graph drawing workers for each sensor.
"""
global gheight
pygame.init()
screen = pygame.display.set_mode((800, 600))
graphers = []
recordings = []
recording = False
record_packets = []
updated = False
cursor_x, cursor_y = 400, 300
for name in 'AF3 F7 F3 FC5 T7 P7 O1 O2 P8 T8 FC6 F4 F8 AF4'.split(' '):
graphers.append(Grapher(screen, name, len(graphers)))
fullscreen = False
emotiv = Emotiv(display_output=True)
gevent.spawn(emotiv.setup)
gevent.sleep(0)
while emotiv.running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
emotiv.close()
return
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
emotiv.close()
return
elif event.key == pygame.K_f:
if fullscreen:
screen = pygame.display.set_mode((800, 600))
fullscreen = False
else:
screen = pygame.display.set_mode((800, 600),
FULLSCREEN, 16)
fullscreen = True
elif event.key == pygame.K_r:
if not recording:
record_packets = []
recording = True
else:
recording = False
recordings.append(list(record_packets))
record_packets = None
packets_in_queue = 0
try:
while packets_in_queue < 8:
packet = emotiv.dequeue()
if abs(packet.gyro_x) > 1:
cursor_x = max(0, min(cursor_x, 800))
cursor_x -= packet.gyro_x
if abs(packet.gyro_y) > 1:
cursor_y += packet.gyro_y
cursor_y = max(0, min(cursor_y, 600))
map(lambda x: x.update(packet), graphers)
if recording:
record_packets.append(packet)
updated = True
packets_in_queue += 1
except Exception, ex:
print ex
if updated:
screen.fill((75, 75, 75))
map(lambda x: x.draw(), graphers)
pygame.draw.rect(screen, (255, 255, 255),
(cursor_x - 5, cursor_y - 5, 10, 10), 0)
pygame.display.flip()
updated = False
gevent.sleep(0)
mOscMessage = OSCMessage()
headset = Emotiv(serial_number="SN201405232628GM",
vendor_id=8609,
product_id=1)
gevent.spawn(headset.setup)
gevent.sleep(0)
chanHist = [[0 for x in range(0)] for x in range(6)]
N = 128 #We always take 128 chunks so we get to slighly above 60hz
T = 1.0 / (N * 1
) # We know that the emotive delivers 128 samples persecond
count = 0
try:
while True:
packet = headset.dequeue()
cCount = 0
for k, v in packet.sensors.iteritems():
if ((k in SENSOR_LIST) and ('value' in v)
and ('quality' in v)):
chanHist[cCount].append(v['value'])
cCount += 1
mOscMessage.clear("/emokit/" + k + "/")
mOscMessage.append(v['value'])
mOscMessage.append(v['quality'])
mOscClient.send(mOscMessage)
count += 1
if count >= N:
for i in range(0, len(chanHist)):
output = [1 for x in range(8)]
norm = [1 for x in range(8)]
class EmokitController:
def __init__(self,
connect_new_device=True,
cache=True,
cache_length=200,
is_research=True,
**kwargs):
self.current_y = 22
self.previous_y = 22
self.speed_y = 22
self.cache = cache
self.t_last_window = time.time()
self.t = []
if self.cache:
self.cache_data = dict()
self.cache_decoder = np.zeros((emotiv_decoder.OUTPUT_DIM, 1))
for ch in CHANNELS:
self.cache_data[ch] = [0]
self.cache_length = cache_length
if connect_new_device:
self.emotiv = Emotiv(display_output=False, is_research=is_research)
else:
self.emotiv = kwargs['emotiv']
self.load_calibration()
def load_calibration(self):
self.calibrated = False
try:
self.bounds = pickle.load(open('data/CALIBRATION_BOUNDS.pkl',
'rb'))
self.calibrated = True
except:
print('No calibration profile found (data/CALIBRATION_BOUNDS.pkl)')
def establish_connection(self):
while True:
self.stream_data()
key = self.decode()
if key != 1:
time.sleep(0.01)
else:
break
print('Connection established.')
def decode(self):
data = np.array([
self.cache_data[ch][-emotiv_decoder.WINDOW_SIZE:]
for ch in emotiv_decoder.CHANNELS
],
dtype='float')
if (np.size(data, 1) == emotiv_decoder.WINDOW_SIZE):
if self.calibrated:
for i, ch in enumerate(emotiv_decoder.CHANNELS):
data[i, :] = (
data[i, :] -
(self.bounds['max'][ch] + self.bounds['min'][ch]) /
2) / (self.bounds['max'][ch] - self.bounds['min'][ch])
key = emotiv_decoder.decode(data)
#print(self.cache_data)
if (np.size(self.cache_decoder, 1) >= self.cache_length):
self.cache_decoder[:, :-1] = self.cache_decoder[:, 1:]
self.cache_decoder[:, -1] = key
else:
self.cache_decoder = np.hstack(
[self.cache_decoder,
key.reshape(np.size(key), 1)])
return (key)
else:
return (0)
def stream_and_decode(self):
self.stream_data()
if (time.time() - self.t_last_window) >= emotiv_decoder.WINDOW_SHIFT:
key = self.decode()
self.t_last_window = time.time()
def post_pygame_event(self):
self.stream_data()
if (time.time() - self.t_last_window) >= emotiv_decoder.WINDOW_SHIFT:
key = self.decode()
self.t_last_window = time.time()
if (key == 1):
pygame.event.post(
pygame.event.Event(pygame.KEYDOWN, {
'key': K_UP,
'unicode': None
}))
elif (key == 2):
pygame.event.post(
pygame.event.Event(pygame.KEYDOWN, {
'key': K_DOWN,
'unicode': None
}))
elif (key == 3):
pygame.event.post(
pygame.event.Event(pygame.KEYDOWN, {
'key': K_LEFT,
'unicode': None
}))
elif (key == 4):
pygame.event.post(
pygame.event.Event(pygame.KEYDOWN, {
'key': K_RIGHT,
'unicode': None
}))
def get_cache_data(self):
return (self.cache_data)
def get_cache_decoder(self):
return (self.cache_decoder)
def get_cache_decoder_last(self):
return (self.cache_decoder[-1])
def stream_data(self):
record_sensors = dict()
for ch in CHANNELS:
record_sensors[ch] = []
while (self.emotiv.running):
try:
packet = self.emotiv.dequeue()
if packet is not None:
if type(packet) == EmotivPacket:
for ch in CHANNELS:
record_sensors[ch] = packet.sensors[ch].copy()
except Exception as ex:
print("EmotivRender DequeuePlotError ",
sys.exc_info()[0],
sys.exc_info()[1],
sys.exc_info()[2], " : ", ex)
if self.cache:
for ch in CHANNELS:
if (len(self.cache_data[ch]) >= self.cache_length):
self.cache_data[ch].pop(0)
if (record_sensors[ch] != []):
self.cache_data[ch].append(record_sensors[ch]['value'])
else:
# Not correctly controlling for shifting series for lost packet
self.cache_data[ch].append(self.cache_data[ch][-1])
if (len(self.t) > self.cache_length):
self.t.pop(0)
self.t.append(time.time())
return (record_sensors)
def record_session(self, t, name=None):
self.establish_connection()
data = dict()
for ch in CHANNELS:
data[ch] = []
for i in range(t):
data_point = self.stream_data().copy()
for ch in CHANNELS:
if (data_point[ch] != []):
data[ch].append(data_point[ch]['value'])
time.sleep(0.01)
if (name is not None):
import pickle
pickle.dump(data, open(name, 'wb'))
else:
return (data)
# run forever
try:
running = True
while running:
if guifeature:
for event in pygame.event.get():
if event.type == QUIT:
running = False
break
if not running:
break
# get sensor values from headset
packet = emotiv.dequeue()
processPacket(packet)
for i in range(len(sensornames)):
updateQuality(i, packet.sensors[sensornames[i]]['quality'])
if guifeature:
pygame.display.flip()
gevent.sleep(0)
print "Terminating client."
if guifeature:
pygame.quit()
emotiv.close()
closeOSC()
sys.exit()
# cleanly exit the client
except KeyboardInterrupt:
def main(debug=False):
global gheight
pygame.init()
screen = pygame.display.set_mode((1600, 900))
graphers = []
recordings = []
recording = False
record_packets = []
updated = False
curX, curY = 400, 300
for name in 'AF3 F7 F3 FC5 T7 P7 O1 O2 P8 T8 FC6 F4 F8 AF4'.split(' '):
graphers.append(Grapher(screen, name, len(graphers)))
fullscreen = False
emotiv = Emotiv(displayOutput=False)
gevent.spawn(emotiv.setup)
gevent.sleep(1)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
emotiv.close()
return
if (event.type == pygame.KEYDOWN):
if (event.key == pygame.K_ESCAPE):
emotiv.close()
return
elif (event.key == pygame.K_f):
if fullscreen:
screen = pygame.display.set_mode((1600, 900))
fullscreen = False
else:
screen = pygame.display.set_mode((1600, 900),
FULLSCREEN, 16)
fullscreen = True
elif (event.key == pygame.K_r):
if not recording:
record_packets = []
recording = True
else:
recording = False
recordings.append(list(record_packets))
record_packets = None
packetsInQueue = 0
try:
while packetsInQueue < 8:
packet = emotiv.dequeue()
if abs(packet.gyroX) > 1:
curX = max(0, min(curX, 1600))
curX -= packet.gyroX
if abs(packet.gyroY) > 1:
curY += packet.gyroY
curY = max(0, min(curY, 900))
map(lambda x: x.update(packet), graphers)
if recording:
record_packets.append(packet)
updated = True
packetsInQueue += 1
except Exception, e:
print e
if updated:
screen.fill((75, 75, 75))
map(lambda x: x.draw(), graphers)
pygame.draw.rect(screen, (255, 255, 255),
(curX - 5, curY - 5, 10, 10), 0)
pygame.display.flip()
updated = False
gevent.sleep(0)
# This is an example of popping a packet from the Emotiv class's packet queue
# and printing the gyro x and y values to the console.
from emokit.emotiv import Emotiv
import gevent
if __name__ == "__main__":
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(0)
try:
while True:
packet = headset.dequeue()
print packet.gyro_x, packet.gyro_y
gevent.sleep(0)
except KeyboardInterrupt:
headset.close()
finally:
headset.close()
class Record:
def __init__(self, parent=None):
self.headset = Emotiv()
self.electrodePairing = { \
"AF3": {'pair': "AF4", 'order': 1},
"AF4": {'pair': "AF3", 'order': 0},
"F3": {'pair': "F4", 'order': 1},
"F4": {'pair': "F3", 'order': 0},
"F7": {'pair': "F8", 'order': 1},
"F8": {'pair': "F7", 'order': 0},
"FC5": {'pair': "FC6", 'order': 1},
"FC6": {'pair': "FC5", 'order': 0},
"T7": {'pair': "T8", 'order': 1},
"T8": {'pair': "T7", 'order': 0},
"P7": {'pair': "P8", 'order': 1},
"P8": {'pair': "P7", 'order': 0},
"O1": {'pair': "O2", 'order': 1},
"O2": {'pair': "O1", 'order': 0},
}
self.timer = pg.QtCore.QTimer()
self.recording = False
self.parser = PacketParser()
self.header_text = "Timestamp,F3 Value,F3 Quality,FC5 Value,FC5 Quality,F7 Value,F7 Quality,T7 Value,T7 Quality,P7 Value,P7 Quality,O1 Value,O1 Quality,O2 Value,O2 Quality,P8 Value,P8 Quality,T8 Value,T8 Quality,F8 Value,F8 Quality,AF4 Value,AF4 Quality,FC6 Value,FC6 Quality,F4 Value,F4 Quality,AF3 Value,AF3 Quality,X Value,Y Value,Z Value"
def setPlotGraphBySensor(self, sensor):
self.plots.setVisible(False)
self.altPlots.setVisible(True)
if self.electrodePairing[sensor]["order"]:
self.altPlots.restartSensors( [ sensor, self.electrodePairing[sensor]["pair"]] )
else:
self.altPlots.restartSensors([ self.electrodePairing[sensor]["pair"], sensor ])
self.returnToGraphs.setVisible(True)
def update(self):
packet = self.headset.dequeue()
if packet != None:
self.plots.updater(packet)
self.headsetState.updateHeadsetStatus(packet)
if self.recording:
row = self.parser.fromPacketToCSV( packet )
self.output_file.write(row + "\n")
def setRecordTab(self):
self.setLeftSidedBox()
self.setCenterBox()
# Main grid layout
self.gridLayout = QGridLayout()
self.gridLayout.addLayout( self.leftBox, 0, 0)
self.gridLayout.addLayout( self.centerBox, 0, 1)
self.gridLayout.setColumnStretch(0, 1)
self.gridLayout.setColumnStretch(1, 3)
return self.gridLayout
def setLeftSidedBox(self):
# Left sided box for controls
self.leftBox = QFormLayout()
self.recordButton = QPushButton("Record")
self.recordButton.setEnabled(False)
self.recordButton.clicked.connect(self.startRecord)
self.stopButton = QPushButton("Stop")
self.stopButton.setEnabled(False)
self.stopButton.clicked.connect(self.stopRecord)
self.recordButtons = QGridLayout()
self.recordButtons.addWidget( self.recordButton, 0, 0)
self.recordButtons.addWidget( self.stopButton, 0, 1)
self.leftBox.addRow(QLabel("Recording controls"))
self.leftBox.addRow(self.recordButtons)
self.route = QLineEdit()
self.route.setReadOnly(True)
self.examine = QPushButton("Examine")
self.examine.clicked.connect(self.getFilename)
folderButtons = QGridLayout()
folderButtons.addWidget(self.route, 0, 0)
folderButtons.addWidget(self.examine, 0, 1)
self.leftBox.addRow(QLabel("Save folder"))
self.leftBox.addRow(folderButtons)
# Sensors status
self.leftBox.addRow(QLabel("Sensor status"))
self.headsetState = HeadStatusWidget(self.setPlotGraphBySensor)
self.leftBox.addRow(self.headsetState)
self.headsetState.updateHeadsetStatus(None)
def setCenterBox(self):
# Center sided box for signals
self.centerBox = QFormLayout()
self.centerBox.addRow(QLabel("Signal status"))
self.returnToGraphs = QPushButton("Return")
self.returnToGraphs.setVisible(False)
self.returnToGraphs.clicked.connect(self.returnToGraphics)
self.centerBox.addRow(self.returnToGraphs)
self.plots = PlottingWidget()
self.centerBox.addRow(self.plots)
self.altPlots = PlottingWidget([])
self.centerBox.addRow(self.altPlots)
self.altPlots.setVisible(False)
def returnToGraphics(self):
self.altPlots.setVisible(False)
self.returnToGraphs.setVisible(False)
self.plots.setVisible(True)
def getFilename(self):
filename = QFileDialog.getExistingDirectory(self.examine, "Open Directory",
"/home",
QFileDialog.ShowDirsOnly
| QFileDialog.DontResolveSymlinks);
self.fileRoute = filename
self.route.setText(self.fileRoute)
self.recordButton.setEnabled(True)
def startRecord(self):
self.stopButton.setEnabled(True)
self.recordButton.setEnabled(False)
self.recording = True
self.file_name += datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d_%H-%M-%S') + ".csv"
self.output_file = open(self.file_name, 'w')
self.output_file.write(self.header_text + "\n")
def stopRecord(self):
self.output_file.close()
# run forever
try:
running = True
while running:
if guifeature:
for event in pygame.event.get():
if event.type == QUIT:
running = False
break
if not running:
break
# get sensor values from headset
packet = emotiv.dequeue()
processPacket(packet)
for i in range(len(sensornames)):
updateQuality(i, packet.sensors[sensornames[i]]['quality'])
if guifeature:
pygame.display.flip()
gevent.sleep(0)
print "Terminating client."
if guifeature:
pygame.quit()
emotiv.close()
closeOSC()
sys.exit()
# cleanly exit the client
except KeyboardInterrupt:
def main(debug=False):
global gheight
pygame.init()
screen = pygame.display.set_mode((1600, 900))
graphers = []
recordings = []
recording = False
record_packets = []
updated = False
curX, curY = 400, 300
for name in 'AF3 F7 F3 FC5 T7 P7 O1 O2 P8 T8 FC6 F4 F8 AF4'.split(' '):
graphers.append(Grapher(screen, name, len(graphers)))
fullscreen = False
emotiv = Emotiv(displayOutput=False)
gevent.spawn(emotiv.setup)
gevent.sleep(1)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
emotiv.close()
return
if (event.type == pygame.KEYDOWN):
if (event.key == pygame.K_ESCAPE):
emotiv.close()
return
elif (event.key == pygame.K_f):
if fullscreen:
screen = pygame.display.set_mode((1600, 900))
fullscreen = False
else:
screen = pygame.display.set_mode((1600,900), FULLSCREEN, 16)
fullscreen = True
elif (event.key == pygame.K_r):
if not recording:
record_packets = []
recording = True
else:
recording = False
recordings.append(list(record_packets))
record_packets = None
packetsInQueue = 0
try:
while packetsInQueue < 8:
packet = emotiv.dequeue()
print(packet.sensors)
if abs(packet.gyroX) > 1:
curX = max(0, min(curX, 1600))
curX -= packet.gyroX
if abs(packet.gyroY) > 1:
curY += packet.gyroY
curY = max(0, min(curY, 900))
map(lambda x: x.update(packet), graphers)
if recording:
record_packets.append(packet)
updated = True
packetsInQueue += 1
except Exception, e:
print e
if updated:
screen.fill((75, 75, 75))
map(lambda x: x.draw(), graphers)
pygame.draw.rect(screen, (255, 255, 255), (curX - 5, curY - 5, 10, 10), 0)
pygame.display.flip()
updated = False
gevent.sleep(0)
def console_gather():
os.system('clear')
headset = Emotiv()
gevent.spawn(headset.setup)
gevent.sleep(0)
packets = 0
now = datetime.now()
filename = str(now.time()) + "_" + str(now.date())
while True:
dir = str(
input(
"Choose input: \n 1. up\n 2. down\n 3. left\n 4. right\n 0. neutral\n"
))
if dir in ['1', '2', '3', '4', '0']: break
filename += "_" + dir
if TEST: filename = "TEST_" + filename
buffers = []
names = 'AF3 F7 F3 FC5 T7 P7 O1 O2 P8 T8 FC6 F4 F8 AF4'.split(' ')
for name in names:
buffers.append(sensor_buffer(name))
print "Training will start in..."
sleep(1)
print "3..."
sleep(1)
print "2..."
sleep(1)
print "1..."
sleep(1)
print "Focus!"
qualities = []
timeout = time() + 12
while True:
if time() > timeout:
break
packet = headset.dequeue()
for buffer in buffers:
buffer.update(packet)
packets += 1
gevent.sleep(0)
headset.close()
quality = 0.
f = open("./data/" + filename, 'w')
columns = []
for name in names:
columns.append(str(name))
columns.append('Q' + str(name))
f.write(','.join(columns))
f.write('\n')
while packets > 0:
for buffer in buffers:
f.write(buffer.pop())
f.write('\n')
packets -= 1
f.close()
print "Finished reading, saved to file %s" % filename
for buffer in buffers:
print "Sensor %s mean quality: %.2f" % (buffer.name,
buffer.mean_quality())
class EmoGetter(DataGetter):
_values = []
_fs = 20
"""Gets data from Emotiv"""
def __init__(self):
super(EmoGetter, self).__init__()
self.headset = Emotiv()
gevent.spawn(self.headset.setup)
gevent.sleep(0)
self.running = True
def get_all_data(self):
return _values
def get_next_data(self):
packet = self.headset.dequeue()
if packet is None:
self.running = False
return []
sensors = packet.sensors
vect_2 = (packet.gyro_y**2 + packet.gyro_x**2)
is_bad = vect_2 > 2
values = []
#if sum(self.gyro_hist[-self.n_usless:]) / len(self.gyro_hist[-self.n_usless:]) - vect_2 > self.n_change:
# is_bad = True
for data_name in DATA_NAMES:
val = sensors[data_name]['value']
values.append(val)
gevent.sleep(0)
self._values.append(values)
return (values, False)
def getN(self, n):
T = 1 / self._fs
datas = []
for i in range(n):
a = time.time()
v, g = self.get_next_data()
datas.append(v)
b = time.time()
delta = b - a
if delta < T:
time.sleep(T - delta)
return datas
class EEGRenderer():
def __init__(self, channels, gheight):
"""
Creates pygame window and graph drawing workers for each sensor.
"""
pygame.init()
self.screen = pygame.display.set_mode(resolution)
self.graphers = []
self.record_packets = []
self.fullscreen = False
self.recording = False
self.updated = False
self.middle_x, self.middle_y = resolution[0]/2, resolution[1]/2
for i, name in enumerate(channels):
self.graphers.append(Grapher(self.screen, gheight, name, i))
self.emotiv = Emotiv(display_output=False)
gevent.spawn(self.emotiv.setup)
gevent.sleep(0)
def handleEvents(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.emotiv.close()
return
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.emotiv.close()
return
elif event.key == pygame.K_f:
if self.fullscreen:
self.screen = pygame.display.set_mode(resolution)
self.fullscreen = False
else:
self.screen = pygame.display.set_mode(resolution, FULLSCREEN, 16)
self.fullscreen = True
elif event.key == pygame.K_r:
if not self.recording:
self.record_packets = []
self.recording = True
else:
self.recording = False
self.recordings.append(list(self.record_packets))
self.record_packets = None
def update(self, cursor_x, cursor_y):
if self.updated:
self.screen.fill((75, 75, 75))
map(lambda x:x.draw(), self.graphers)
pygame.draw.rect(self.screen, (255, 0, 255), [cursor_x, cursor_y, 5, 5], 5)
pygame.display.flip()
self.updated = False
def main(self):
while self.emotiv.running:
self.handleEvents()
packets_in_queue = 0
try:
cursor_x, cursor_y = self.middle_x, self.middle_y
while packets_in_queue < 8:
packet = self.emotiv.dequeue()
if abs(packet.gyro_x) > 1:
cursor_x += packet.gyro_x-GYRO_DEFAULT
if abs(packet.gyro_y) > 1:
cursor_y += packet.gyro_y-GYRO_DEFAULT
map(lambda x: x.update(packet), self.graphers)
if self.recording:
self.record_packets.append(packet)
self.updated = True
packets_in_queue += 1
cursor_x = self.middle_x + cursor_x / packets_in_queue
cursor_y = self.middle_y + cursor_y / packets_in_queue
except (Exception, KeyboardInterrupt) as e:
raise e
self.update(cursor_x, cursor_y)
gevent.sleep(0)
