def main():
alpha = False
print("Looking for stream")
inlet = StreamInlet(resolve_stream('type', 'EEG')[0])
chunk, timestamp = inlet.pull_chunk(timeout=3, max_samples=chunk_size)
buffer = np.array(chunk).transpose()
print("Filling buffer")
for i in range(window_size - 1):
chunk, timestamp = inlet.pull_chunk(timeout=3, max_samples=chunk_size)
chunk = np.array(chunk).transpose()
buffer = np.hstack((buffer, chunk))
print(i)
print(buffer.shape)
print("Processing")
while True:
chunk, timestamp = inlet.pull_chunk(timeout=3, max_samples=chunk_size)
chunk = np.array(chunk).transpose()
buffer = np.hstack((buffer, chunk))
freqs, psd = welch(buffer, fs=250., nperseg=4*250)
psd = np.average(psd, axis=0)
freq_res = freqs[1] - freqs[0]
total_power = simps(psd, dx=freq_res)
band_power = []
for band in eeg_bands:
idx = np.logical_and(freqs >= eeg_bands[band][0], freqs <= eeg_bands[band][1])
tmp = simps(psd[idx], dx=freq_res)
band_power.append(tmp)
print(band, tmp, tmp/total_power)
print()
if alpha:
if band_power[2] < band_power[1] or band_power[2] < band_power[3]:
alpha = False
else:
print("Meditação")
else:
if band_power[2] / band_power[1] >= 1.3 and band_power[2] / band_power[3] >= 1.3:
alpha = True
buffer = np.delete(buffer, slice(250), axis=1)
class BetaInlet(object):
def __init__(self):
print("looking for an EEG stream...")
streams = resolve_byprop("type", "EEG")
# create a new inlet to read from the stream
proc_flags = proc_clocksync | proc_dejitter | proc_monotonize
self.inlet = StreamInlet(streams[0], processing_flags=proc_flags)
stream_info = self.inlet.info()
stream_xml = stream_info.desc()
chans_xml = stream_xml.child("channels")
self.channel_list = []
ch = chans_xml.child("channel")
while ch.name() == "channel":
self.channel_list.append(ch)
ch = ch.next_sibling("channel")
def update(self):
max_samps = 3276 * 2
data = np.nan * np.ones(
(max_samps, len(self.channel_list)), dtype=np.float32)
_, timestamps = self.inlet.pull_chunk(max_samples=max_samps,
dest_obj=data)
data = data[:len(timestamps), :]
return data, np.asarray(timestamps)
def sampling_rate(self):
return self.inlet.info().nominal_srate()
def product():
streams = resolve_stream('type', 'EEG')
inlet = StreamInlet(streams[0])
while True:
# sample, timestamp = inlet.pull_sample()
sample, timestamp = inlet.pull_chunk(timeout=1.0)
eeg_queue.put(sample)
class BetaInlet(object):
def __init__(self):
print("looking for an EEG stream...")
streams = resolve_byprop("type", "EEG")
# create a new inlet to read from the stream
proc_flags = proc_clocksync | proc_dejitter | proc_monotonize
self.inlet = StreamInlet(streams[0], processing_flags=proc_flags)
# The following is an example of how to read stream info
stream_info = self.inlet.info()
stream_Fs = stream_info.nominal_srate()
stream_xml = stream_info.desc()
chans_xml = stream_xml.child("channels")
chan_xml_list = []
ch = chans_xml.child("channel")
while ch.name() == "channel":
chan_xml_list.append(ch)
ch = ch.next_sibling("channel")
self.channel_names = [ch_xml.child_value("label") for ch_xml in chan_xml_list]
print("Reading from inlet named {} with channels {} sending data at {} Hz".format(stream_info.name(),
self.channel_names, stream_Fs))
def update(self):
max_samps = 3276*2
data = np.nan * np.ones((max_samps, len(self.channel_names)), dtype=np.float32)
_, timestamps = self.inlet.pull_chunk(max_samples=max_samps, dest_obj=data)
data = data[:len(timestamps), :]
print("Beta inlet retrieved {} samples.".format(len(timestamps)))
return data, np.asarray(timestamps)
def recordeeg(duration):
warnings.filterwarnings('ignore')
BUFFER_LENGTH = 5
EPOCH_LENGTH = 1
OVERLAP_LENGTH = 0.8
SHIFT_LENGTH = EPOCH_LENGTH - OVERLAP_LENGTH
streams = resolve_byprop('type', 'EEG', timeout=2)
if len(streams) == 0:
raise RuntimeError('Can\'t find EEG stream.')
inlet = StreamInlet(streams[0], max_chunklen=12)
eeg_time_correction = inlet.time_correction()
info = inlet.info()
description = info.desc()
fs = int(info.nominal_srate())
eeg_buffer = np.zeros((int(fs * BUFFER_LENGTH), 1))
filter_state = None
n_win_test = int(
np.floor((BUFFER_LENGTH - EPOCH_LENGTH) / SHIFT_LENGTH + 1))
band_buffer = np.zeros((n_win_test, 4))
musedata = []
while True:
eeg_data, timestamp = inlet.pull_chunk(timeout=1,
max_samples=int(SHIFT_LENGTH *
fs))
musedata += eeg_data
if len(musedata) > duration * fs:
return musedata
break
class BetaInlet(object):
def __init__(self):
print("looking for an EEG stream...")
streams = resolve_byprop("type", "EEG")
# create a new inlet to read from the stream
proc_flags = proc_clocksync | proc_dejitter | proc_monotonize
self.inlet = StreamInlet(streams[0], processing_flags=proc_flags)
# The following is an example of how to read stream info
stream_info = self.inlet.info()
stream_Fs = stream_info.nominal_srate()
stream_xml = stream_info.desc()
chans_xml = stream_xml.child("channels")
chan_xml_list = []
ch = chans_xml.child("channel")
while ch.name() == "channel":
chan_xml_list.append(ch)
ch = ch.next_sibling("channel")
self.channel_names = [
ch_xml.child_value("label") for ch_xml in chan_xml_list
]
print(
"Reading from inlet named {} with channels {} sending data at {} Hz"
.format(stream_info.name(), self.channel_names, stream_Fs))
def update(self):
max_samps = 3276 * 2
data = np.nan * np.ones(
(max_samps, len(self.channel_names)), dtype=np.float32)
_, timestamps = self.inlet.pull_chunk(max_samples=max_samps,
dest_obj=data)
data = data[:len(timestamps), :]
print("Beta inlet retrieved {} samples.".format(len(timestamps)))
return data, np.asarray(timestamps)
def main():
model = load_model('RNN')
while True:
try:
print("looking for an EEG stream...")
streams = resolve_stream('name', 'NER_2015_BCI_Challenge_Samples')
# create a new inlet to read from the stream
inlet = StreamInlet(streams[0])
# Pred stream
info_pred = StreamInfo('NER_2015_BCI_Challenge_PRED', 'PRED', 1,
IRREGULAR_RATE, 'float32', 'PREDID')
outlet_pred = StreamOutlet(info_pred)
while True:
sample = np.empty((0, 56))
timestamps = []
while len(sample) < 2001:
chunk, ts = inlet.pull_chunk()
if ts:
ts = timestamps + ts
sample = np.concatenate([sample, chunk], axis=0)
pred = model.predict(
np.expand_dims(sample[:2001].transpose(), axis=0))
outlet_pred.push_chunk(pred[0, :, 0].tolist())
print('Pushed inference results')
except LostError:
pass
def pull_lsl_stream_chunk(stream: pylsl.StreamInlet, timeout: float = 0.0):
try:
sample, timestamps = stream.pull_chunk(timeout)
return sample, timestamps, None
except Exception as e:
logger.info(f'LSL connection lost')
return None, None, e
def pull_chunk(stream: StreamInlet, timeout: float):
try:
sample, timestamps = stream.pull_chunk(timeout)
return sample, timestamps, None
except Exception as e:
logger.debug(f'LSL connection lost')
return None, None, e
def record_eeg_filtered(r_length, freq, channel_i, notch = False, filter_state=None):
streams = resolve_byprop('type', 'EEG', timeout=2)
inlet = StreamInlet(streams[0], max_chunklen=12)
""" Records EEG data from headset
Arguments:
r_length -- how many seconds of data to record
freq -- sample rate
channel_i -- channels to keep data from
Returns:
data -- array of recorded data [sample, channel]
"""
data, timestamps = inlet.pull_chunk(
timeout=r_length + 1,
max_samples=int(freq * r_length))
data = np.array(data)[:, channel_i]
if notch:
if filter_state is None:
filter_state = np.tile(lfilter_zi(NOTCH_B, NOTCH_A),
(data.shape[1], 1)).T
data, filter_state = lfilter(NOTCH_B, NOTCH_A, data, axis=0,
zi=filter_state)
class Stream (Thread):
def __init__(self):
Thread.__init__(self)
# Enough for 1 sec at 256 Hz
self.BUFFER = 256
print("looking for an EEG stream...")
self.streams = resolve_byprop('type', 'EEG', timeout=2)
if len(self.streams) == 0:
raise(RuntimeError("Cant find EEG stream"))
print("Start aquiring data")
self.stream = self.streams[0]
self.inlet = StreamInlet(self.stream, max_chunklen=BUFFER)
self.times = []
self.count = 0
self.chunks = 3
self.ave_len = 10
self.ave = [0.0, 0.0]
self.buf = CircularBuffer(self.chunks)
self.state = 'noise'
def run(self):
while True:
# Sample is a 2d array of [ [channel_i]*5 ] * BUFFER
samples, timestamps = self.inlet.pull_chunk(timeout=2.0, max_samples=self.BUFFER)
if timestamps:
data = np.vstack(samples)
data = np.transpose(data)
print(np.shape(data))
self.buf.write(data)
# Check so that the buffer is filled before any filtering
if self.count >= self.chunks:
channels = list([0])
lower_freq = 8
higher_freq = 12
filtered_data = mne.filter.filter_data(self.buf.window, 256, lower_freq, higher_freq, filter_length=256*self.chunks-1, fir_design='firwin')
#for channel in filtered_data:
# print(alpha(channel))
if(self.count < self.chunks+self.ave_len):
self.ave[0] += alpha(filtered_data[1]) * (1./self.ave_len)
self.ave[1] += alpha(filtered_data[2]) * (1./self.ave_len)
elif(alpha(filtered_data[2]) > self.ave[1]*0.90):
if(alpha(filtered_data[1]) > self.ave[0]*1.05):
#print('Noise')
self.state = 'noise'
else:
self.state = 'yes'
else:
self.state = 'no'
self.count += 1
class AIYVoiceInterface:
def __init__(self, lsl_data_type,
num_channels): # default board_id 2 for Cyton
self.lsl_data_type = lsl_data_type
self.lsl_num_channels = num_channels
self.streams = resolve_byprop('name', self.lsl_data_type, timeout=1)
if len(self.streams) < 1:
raise AttributeError(
'Unable to find LSL Stream with given type {0}'.format(
lsl_data_type))
self.inlet = StreamInlet(self.streams[0])
# TO-DO: fix this, we need to re-stream this since sometimes unity doesn't pick up AIY data for some reason
info = StreamInfo('VoiceBox', 'Voice', num_channels, 0.0, 'string',
'voice')
self.outlet = StreamOutlet(info)
pass
def start_sensor(self):
# connect to the sensor
self.streams = resolve_byprop('name', self.lsl_data_type, timeout=1)
if len(self.streams) < 1:
raise AttributeError(
'Unable to find LSL Stream with given type {0}'.format(
self.lsl_data_type))
self.inlet = StreamInlet(self.streams[0])
self.inlet.open_stream()
print(
'LSLInletInterface: resolved, created and opened inlet for lsl stream with type '
+ self.lsl_data_type)
# read the channel names is there's any
# tell the sensor to start sending frames
def process_frames(self):
# return one or more frames of the sensor
try:
frames, timestamps = self.inlet.pull_chunk()
if len(frames) > 0:
self.outlet.push_sample(frames[0]) # TO-DO: see above
except LostError:
frames, timestamps = [], []
pass # TODO handle stream lost
return np.transpose(frames), timestamps
def stop_sensor(self):
if self.inlet:
self.inlet.close_stream()
print('LSLInletInterface: inlet stream closed.')
def info(self):
return self.inlet.info()
def get_num_chan(self):
return self.lsl_num_channels
def get_nominal_srate(self):
return self.streams[0].nominal_srate()
async def listen(inlet: pylsl.StreamInlet):
while True:
samples, timestamps = inlet.pull_chunk()
for sample, timestamp in zip(samples, timestamps):
print('\t'.join(
map(lambda x: str(x).ljust(20),
[inlet.info().type(), timestamp, sample])),
flush=True)
await asyncio.sleep(0.1)
class LSLInlet:
def __init__(self,
name=LSL_STREAM_NAMES[2],
max_chunklen=8,
n_channels=20):
streams = resolve_byprop('name', name, timeout=LSL_RESOLVE_TIMEOUT)
self.inlet = None
self.dtype = 'float64'
if len(streams) > 0:
self.inlet = StreamInlet(streams[0],
max_buflen=1,
max_chunklen=max_chunklen)
# self.dtype = fmt2string[self.inlet.info().channel_format()]
print(self.dtype)
self.n_channels = n_channels if n_channels else self.inlet.info(
).channel_count()
def get_next_chunk(self, mode=0):
# get next chunk
chunk, timestamp = self.inlet.pull_chunk()
# convert to numpy array
chunk = np.array(chunk, dtype=self.dtype)
# return first n_channels channels or None if empty chunk
return chunk[:, :self.n_channels] if chunk.shape[0] > 0 else None
def update_action(self):
pass
def save_info(self, file):
with open(file, 'w', encoding="utf-8") as f:
f.write(self.inlet.info().as_xml())
def get_frequency(self):
return self.inlet.info().nominal_srate()
def get_n_channels(self):
return self.n_channels
def get_channels_labels_bad(self):
time.sleep(0.001)
labels = []
ch = self.inlet.info().desc().child("channels").child("channel")
for k in range(self.get_n_channels()):
labels.append(ch.child_value("label"))
ch = ch.next_sibling()
return
def get_channels_labels(self):
return ch_names[:self.n_channels]
def disconnect(self):
del self.inlet
self.inlet = None
def receive(self):
streams = resolve_byprop('type',
self.settings.type,
timeout=LSL_SCAN_TIMEOUT)
if len(streams) == 0:
print("Can't find %s stream." % self.settings.type)
return
print("Started acquiring data.")
inlet = StreamInlet(streams[0], max_chunklen=self.settings.chunk)
info = inlet.info()
description = info.desc()
n_channels = info.channel_count()
ch = description.child('channels').first_child()
ch_names = [ch.child_value('label')]
for i in range(1, n_channels):
ch = ch.next_sibling()
ch_names.append(ch.child_value('label'))
channel_descriptor = ChannelDescriptor(self.settings.type, ch_names,
info.nominal_srate())
res = []
timestamps = []
t_init = time()
time_correction = inlet.time_correction()
print('Start recording at time t=%.3f' % t_init)
print('Time correction: ', time_correction)
while (time() - t_init) < 5000:
try:
data, timestamp = inlet.pull_chunk(
timeout=1.0, max_samples=self.settings.chunk)
if timestamp:
res.append(data)
self.subscription.notify_all_subscribers(
self.settings.type, data, timestamp,
channel_descriptor)
timestamps.extend(timestamp)
except KeyboardInterrupt:
break
time_correction = inlet.time_correction()
print('Time correction: ', time_correction)
res = np.concatenate(res, axis=0)
timestamps = np.array(timestamps) + time_correction
print('Done .')
def testing():
dummy_streamer = ble2lsl.Dummy(muse2016) #
streams = resolve_byprop(
"type", "EEG", timeout=5
) #type: EEG, minimum return streams = 1, timeout after 5 seconds
streamIn = StreamInlet(
streams[0], max_chunklen=12, recover=True
) #Grab first stream from streams, MUSE chunk 12, drop lost stream
print(streamIn)
print(streamIn.info().channel_count())
streamIn.open_stream(
) #This actually isn't required: pull_sample() and pull_chunk() implicitly open the stream.
#But it's good to be explicit because it makes the code clearer
print("Pull Sample")
print(streamIn.pull_sample()
) #Returns a tuple with the actual values we want.
#The first element is the list of channel values, the second element is a timestamp. This is a snapshot of our stream
#at a certain point in time.
print("Pull Chunk")
ts = time.time()
while (1):
x = streamIn.pull_chunk()
if all(x):
#if not np.shape(x) == (2, 0):
print(np.shape(x))
print(np.shape(x[1]))
t = [t - ts for t in x[1]]
print(t)
print(t[-1] - t[0])
# for y in x:
# for z in y:
# print(z)
#print("\n")
plt.style.use('ggplot')
# data first then time stamps, sick
pprint(streamIn.info().as_xml()) #what
timeC = streamIn.time_correction()
print(timeC)
#Clean up time
streams.clear()
streamIn.close_stream() #calls lsl_close_stream
streamIn.__del__() #Not throwing errors
dummy_streamer.stop()
class LSLInletInterface:
def __init__(self, lsl_data_type):
self.streams = resolve_byprop('name', lsl_data_type, timeout=0.1)
if len(self.streams) < 1:
raise AttributeError(
'Unable to find LSL Stream with given type {0}'.format(
lsl_data_type))
self.inlet = StreamInlet(self.streams[0])
self.lsl_data_type = lsl_data_type
self.lsl_num_channels = self.inlet.channel_count
pass
def start_sensor(self):
# connect to the sensor
self.streams = resolve_byprop('name', self.lsl_data_type, timeout=0.1)
if len(self.streams) < 1:
raise AttributeError(
'Unable to find LSL Stream with given type {0}'.format(
self.lsl_data_type))
if not self.inlet:
self.inlet = StreamInlet(self.streams[0])
self.inlet.open_stream()
print(
'LSLInletInterface: resolved, created and opened inlet for lsl stream with type '
+ self.lsl_data_type)
# read the channel names is there's any
# tell the sensor to start sending frames
def process_frames(self):
# return one or more frames of the sensor
try:
frames, timestamps = self.inlet.pull_chunk()
except LostError:
frames, timestamps = [], []
pass # TODO handle stream lost
return np.transpose(frames), timestamps
def stop_sensor(self):
if self.inlet:
self.inlet.close_stream()
print('LSLInletInterface: inlet stream closed.')
def info(self):
return self.inlet.info()
def get_num_chan(self):
return self.lsl_num_channels
def get_nominal_srate(self):
return self.streams[0].nominal_srate()
def main():
# first resolve an EEG stream on the lab network
print("looking for an EEG stream...")
streams = resolve_stream('type', 'EEG')
# create a new inlet to read from the stream
inlet = StreamInlet(streams[0])
while True:
# get a new sample (you can also omit the timestamp part if you're not
# interested in it)
chunk, timestamps = inlet.pull_chunk()
if timestamps:
print(timestamps, chunk)
class LSLClient(QThread):
"""docstring for LSLClient"""
StoppedState = 0
PausedState = 1
RecordingState = 2
def __init__(self):
super(LSLClient, self).__init__()
self.D = list()
self.T = list()
self.state = self.StoppedState
self.streams = None
self.inlet = None
def setStream(self, tag, value):
self.streams = resolve_stream(tag, value)
self.inlet = StreamInlet(self.streams[0])
self.D.clear()
self.T.clear()
def getData(self):
return self.D
def getState(self):
return self.state
def record(self):
self.state = self.RecordingState
self.start()
def pause(self):
self.state = self.PausedState
def toggle(self):
self.state = self.PausedState if self.state == self.RecordingState else self.RecordingState
def stop(self):
self.state = self.StoppedState
self.quit()
def run(self):
while True:
if self.state == self.RecordingState:
chunk, timestamps = self.inlet.pull_chunk()
self.D.extend(chunk)
elif self.state == self.PausedState:
pass
else:
break
def _muse_get_recent(self, max_samples=100, restart_inlet=False):
if self._muse_recent_inlet and restart_inlet == False:
inlet = self._muse_recent_inlet
else:
# Initiate a new lsl stream
streams = resolve_byprop('type', 'EEG', timeout=mlsl_cnsts.LSL_SCAN_TIMEOUT)
inlet = StreamInlet(streams[0], max_chunklen=mlsl_cnsts.LSL_EEG_CHUNK)
self._muse_recent_inlet = inlet
_ = inlet.pull_chunk() # seems to be necessary to do this first...
time.sleep(1)
samples, timestamps = inlet.pull_chunk(timeout=0.0, max_samples=max_samples)
samples = np.array(samples)
timestamps = np.array(timestamps)
info = inlet.info()
description = info.desc()
sfreq = info.nominal_srate()
#window = 10
#n_samples = int(self.sfreq * window)
n_chans = info.channel_count()
ch = description.child('channels').first_child()
ch_names = [ch.child_value('label')]
for i in range(n_chans):
ch = ch.next_sibling()
lab = ch.child_value('label')
if lab != '':
ch_names.append(lab)
df = pd.DataFrame(samples, index=timestamps, columns=ch_names)
return df
def acquire_eeg(duration,
callback=print_eeg_callback,
eeg_chunck=LSL_EEG_CHUNK):
DATA_SOURCE = "EEG"
print("Looking for a %s stream..." % (DATA_SOURCE))
streams = resolve_byprop('type', DATA_SOURCE, timeout=LSL_SCAN_TIMEOUT)
if len(streams) == 0:
print("Can't find %s stream." % (DATA_SOURCE))
return
print("Started acquiring data.")
inlet = StreamInlet(streams[0], max_chunklen=eeg_chunck)
info = inlet.info()
description = info.desc()
Nchan = info.channel_count()
ch = description.child('channels').first_child()
ch_names = [ch.child_value('label')]
for i in range(1, Nchan):
ch = ch.next_sibling()
ch_names.append(ch.child_value('label'))
timestamps = []
t_init = time()
time_correction = inlet.time_correction()
print('Start acquiring at time t=%.3f' % t_init)
print('Time correction: ', time_correction)
while (time() - t_init) < duration:
try:
chunk, timestamps = inlet.pull_chunk(timeout=1.0,
max_samples=eeg_chunck)
if timestamps:
samples = {
key: [sample[i] for sample in chunk]
for i, key in enumerate(ch_names)
}
callback(timestamps, samples)
except KeyboardInterrupt:
break
print('Acquisition is done')
class LSLInlet:
def __init__(self, name=LSL_STREAM_NAMES[2], max_chunklen=8, n_channels=20):
streams = resolve_byprop('name', name, timeout=LSL_RESOLVE_TIMEOUT)
self.inlet = None
self.dtype = 'float64'
if len(streams) > 0:
self.inlet = StreamInlet(streams[0], max_buflen=1, max_chunklen=max_chunklen)
# self.dtype = fmt2string[self.inlet.info().channel_format()]
print(self.dtype)
self.n_channels = n_channels if n_channels else self.inlet.info().channel_count()
def get_next_chunk(self):
# get next chunk
chunk, timestamp = self.inlet.pull_chunk()
# convert to numpy array
chunk = np.array(chunk, dtype=self.dtype)
# return first n_channels channels or None if empty chunk
return chunk[:, :self.n_channels] if chunk.shape[0] > 0 else None
def update_action(self):
pass
def save_info(self, file):
with open(file, 'w') as f:
f.write(self.inlet.info().as_xml())
def get_frequency(self):
return self.inlet.info().nominal_srate()
def get_n_channels(self):
return self.n_channels
def get_channels_labels_bad(self):
time.sleep(0.001)
labels = []
ch = self.inlet.info().desc().child("channels").child("channel")
for k in range(self.get_n_channels()):
labels.append(ch.child_value("label"))
ch = ch.next_sibling()
return
def get_channels_labels(self):
return ch_names[:self.n_channels]
def disconnect(self):
del self.inlet
self.inlet = None
def stream_from_lsl(self):
"""
Streaming operation which pulls individual samples from LSL
"""
stream = self.find_given_stream()
stream_inlet = StreamInlet(stream)
chunk = np.zeros((32, stream.channel_count()), dtype=np.float32)
while True:
_, timestamp = stream_inlet.pull_chunk(max_samples=32, dest_obj=chunk, timeout=FOREVER)
if not self.timestamp_stored and self.store_first_timestamp_to is not None:
np.save(self.store_first_timestamp_to, np.array([timestamp[0]]))
self.timestamp_stored = True
self.output_data(chunk[:, self.mask])
class BetaInlet(object):
def __init__(self):
print("looking for an EEG stream...")
streams = resolve_byprop("type", "EEG")
# create a new inlet to read from the stream
proc_flags = proc_clocksync | proc_dejitter | proc_monotonize
self.inlet = StreamInlet(streams[0], processing_flags=proc_flags)
def update(self):
max_samps = 3276*2
data = np.nan * np.ones((max_samps, 25), dtype=np.float32)
_, timestamps = self.inlet.pull_chunk(max_samples=max_samps, dest_obj=data)
data = data[:len(timestamps), :]
return data, np.asarray(timestamps)
def sampling_rate(self):
return self.inlet.info().nominal_srate()
def _muse_get_recent(self,
n_samples: int = 256,
restart_inlet: bool = False):
if self._muse_recent_inlet and not restart_inlet:
inlet = self._muse_recent_inlet
else:
# Initiate a new lsl stream
streams = resolve_byprop("type",
"EEG",
timeout=mlsl_cnsts.LSL_SCAN_TIMEOUT)
if not streams:
raise Exception(
"Couldn't find any stream, is your device connected?")
inlet = StreamInlet(streams[0],
max_chunklen=mlsl_cnsts.LSL_EEG_CHUNK)
self._muse_recent_inlet = inlet
info = inlet.info()
sfreq = info.nominal_srate()
description = info.desc()
n_chans = info.channel_count()
self.sfreq = sfreq
self.info = info
self.n_chans = n_chans
timeout = (n_samples / sfreq) + 0.5
samples, timestamps = inlet.pull_chunk(timeout=timeout,
max_samples=n_samples)
samples = np.array(samples)
timestamps = np.array(timestamps)
ch = description.child("channels").first_child()
ch_names = [ch.child_value("label")]
for i in range(n_chans):
ch = ch.next_sibling()
lab = ch.child_value("label")
if lab != "":
ch_names.append(lab)
df = pd.DataFrame(samples, index=timestamps, columns=ch_names)
return df
class MarkerInlet(object):
def __init__(self):
self.task = {'phase': 'precue', 'class': 1, 'target': 1}
print("Looking for stream with type Markers")
streams = resolve_bypred("type='Markers'", minimum=1)
proc_flags = 0 # Marker events are relatively rare. No need to post-process.
self.inlet = StreamInlet(streams[0], processing_flags=proc_flags)
# The following is an example of how to read stream info
stream_info = self.inlet.info()
stream_Fs = stream_info.nominal_srate()
stream_xml = stream_info.desc()
chans_xml = stream_xml.child("channels")
chan_xml_list = []
ch = chans_xml.child("channel")
while ch.name() == "channel":
chan_xml_list.append(ch)
ch = ch.next_sibling("channel")
stream_ch_names = [
ch_xml.child_value("label") for ch_xml in chan_xml_list
]
print("Reading from inlet named {} with channels {}".format(
stream_info.name(), stream_ch_names))
def update(self):
marker_samples, marker_timestamps = self.inlet.pull_chunk(timeout=0.0)
if (marker_timestamps):
[phase_str, class_str,
targ_str] = marker_samples[-1][0].split(', ')
if phase_str in ['TargetCue']:
self.task['phase'] = 'cue'
elif phase_str in ['GoCue']:
self.task['phase'] = 'go'
elif phase_str in ['Miss', 'Hit']:
self.task['phase'] = 'evaluate'
elif phase_str[:8] == 'NewTrial':
self.task['phase'] = 'precue'
else:
print(phase_str)
self.task['class'] = int(class_str.split(' ')[1])
self.task['target'] = int(targ_str.split(' ')[1])
print("Marker inlet updated with task {}".format(self.task))
class MuseHelmet(Helmet):
def __init__(self):
from muselsl import stream, list_muses
from pylsl import StreamInlet, resolve_byprop
muses = list_muses()
# stream module connects with Muse, but doesn't start streaming data
self.muse_ble_connect = multiprocessing.Process(
target=stream, args=(muses[0]["address"], ))
self.muse_ble_connect.start()
time.sleep(10)
self.streams = resolve_byprop("type", "EEG", timeout=2)
self.inlet = StreamInlet(self.streams[0], max_chunklen=1)
Helmet.__init__(self)
self.channels_number = 4
self.sampling_rate = 256
# Muse lsl streams data in chunks with predefined timestamps
# so putting data in queue is in streaming func, passing insert_sample
def streaming(self):
# channels: TP9, AF7, AF8, TP10, Right Aux (not used)
while True:
eeg_data, timestamp = self.inlet.pull_chunk(timeout=0)
# todo put chunk, concat eeg and time arrays
for i in range(len(timestamp)):
self.q.put(eeg_data[i][0:4] + [timestamp[i]] +
[int(timestamp[i])])
time.sleep(0.01)
# todo make unique signature with inlet.pull_sample
def insert_sample_record(self, sample):
pass
def getData(classifier, mu_ft, std_ft):
print('looking for an EEG stream...')
streams = resolve_stream('type', 'EEG')
if len(streams) == 0:
raise (RunTimeError('Cant find EEG stream :('))
window = 1
inlet = StreamInlet(streams[0])
info = inlet.info()
descriptions = info.desc()
sfreq = info.nominal_srate()
n_samples = int(window * sfreq)
n_chan = info.channel_count()
print('Acquiring data...')
data = np.zeros((n_samples, n_chan))
times = np.arange(-window, 0, 1. / sfreq)
timer = time.time()
while True:
samples, timestamps = inlet.pull_chunk(timeout=1.0, max_samples=12)
if timestamps:
timestamps = np.float64(
np.arange(len(timestamps))
) #creates an array of numbers of numbers from 0 to length timestamps
timestamps /= sfreq #divides that array by our sampling freq
timestamps += times[-1] + 1 / sfreq # not sure
times = np.concatenate(
[times,
timestamps]) #adds timestamps to the end of the times array
times = times[-n_samples:] #takes the last n_samples from times
data = np.vstack([data, samples
]) #adds our new samples to the data array
data = data[-n_samples:]
timer = time.time()
n_samples, n_chan = data.shape
epochs, remainder = tools.epoching(data,
n_samples,
samples_overlap=0)
feature_matrix = tools.compute_feature_matrix(epochs, sfreq)
y_hat = tools.classifier_test(classifier, feature_matrix, mu_ft,
std_ft)
print(y_hat)
def imp_check_pauser(imp_limit):
from pylsl import StreamInlet, resolve_stream
# first resolve an EEG stream on the lab network
print('Searching for Impedances Stream...')
streams = resolve_stream('type', 'Impeadance') # type='Impeadance')
# create a new inlet to read from the stream
inlet = StreamInlet(streams[0])
# Keyword Paramters.
imps = []
channels = ['Fz', 'Cz', 'Pz', 'P4', 'P3', 'O1', 'O2']
controller = 0
num_chans = 7
if imp_limit is None:
imp_limit = 15
# Timed Imp Check Controller Operatin/
while controller == 0:
# Grab Impedances Data Chunks.
chunk, timestamps = inlet.pull_chunk(timeout=2, max_samples=500)
if timestamps:
imps = np.asarray(chunk)
imps = imps[:, 0:num_chans]
print(imps.shape)
imps = zero_mean(imps)
for j in range(1):
con_list = np.zeros(num_chans) # , dtype=int
for i in range(num_chans):
# Range value of channel durng pause.
r_val = np.amax(imps[:, i]) - np.amin(imps[:, i])
if r_val > imp_limit:
print(
'----Channel Impedances Awaiting Stabilization: {0} | Range Value: {1}'
.format(channels[i], r_val))
elif r_val < imp_limit:
con_list[i] = 1
print(
'----Channel Impedances Stabilised: {0} | Range Value: {1}'
.format(channels[i], r_val))
if np.sum(con_list) == num_chans:
controller = 1
def startRecording(self):
self.recording = True
try:
while (self.recording == True):
streams = resolve_byprop('type', 'EEG', timeout=2)
inlet = StreamInlet(streams[0], max_chunklen=12)
# Obtain EEG data from the LSL stream
eeg_data, timestamp = inlet.pull_chunk(
timeout=1, max_samples=int(self.SHIFT_LENGTH * self.freq))
ch_data = np.array(eeg_data)[:, self.INDEX_CHANNEL]
# Update EEG data and apply filter
self.eeg_raw, self.filter_state = BCI.update_buffer(
self.eeg_raw,
ch_data,
notch=True,
filter_state=self.filter_state)
except KeyboardInterrupt:
print("Exception")
class BciThread (threading.Thread):
def __init__(self, name):
threading.Thread.__init__(self)
self.__streamsEEG = resolve_byprop('type', 'EEG', timeout=TIMEOUT)
if len(self.__streamsEEG) == 0:
raise RuntimeError("Can't find EEG stream.")
self.__inlet = StreamInlet(self.__streamsEEG[0], max_chunklen=12)
self.__eeg_time_correction = self.__inlet.time_correction()
self.__info = self.__inlet.info()
self.__fs = int(self.__info.nominal_srate())
self.name = name
self.__lock = threading.Lock()
self.__work = False
self.__observers = set()
def attach(self, observer: Observer):
self.__observers.add(observer)
def event(self, info):
for observer in self.__observers:
observer.update_data(info)
def detach(self, observer: Observer):
self.__observers.remove(observer)
def run(self):
self.__work = True
while self.__work:
eeg_data, timestamp = self.__inlet.pull_chunk(timeout=1, max_samples=int(SHIFT_LENGTH * self.__fs))
info = np.column_stack((timestamp, eeg_data))
self.event(info)
def get_fs(self):
return self.__fs
def stop(self):
self.__lock.acquire()
self.__work = False
self.__lock.release()
def dataReaderLSLChunk(streamName, q):
while True:
print("Waiting for LSL stream")
try:
results = resolve_byprop(prop='name', value=streamName)
while len(results) == 0:
time.sleep(0.25)
info = results[0]
inlet = StreamInlet(info, recover=False)
print("Streaming...")
# Read data in forever
try:
while True:
chunk, timestamps = inlet.pull_chunk()
if len(chunk) > 0:
q.put(np.array(chunk[len(chunk) - 1]))
time.sleep(1 / 120)
except Exception as e:
print(e)
pass
except Exception as e:
print(e)
pass
class MarkerInlet(object):
def __init__(self):
self.task = {'phase':'precue', 'class':1, 'target':1}
print("Looking for stream with type Markers")
streams = resolve_bypred("type='Markers'", minimum=1)
proc_flags = 0 # Marker events are relatively rare. No need to post-process.
self.inlet = StreamInlet(streams[0], processing_flags=proc_flags)
# The following is an example of how to read stream info
stream_info = self.inlet.info()
stream_Fs = stream_info.nominal_srate()
stream_xml = stream_info.desc()
chans_xml = stream_xml.child("channels")
chan_xml_list = []
ch = chans_xml.child("channel")
while ch.name() == "channel":
chan_xml_list.append(ch)
ch = ch.next_sibling("channel")
stream_ch_names = [ch_xml.child_value("label") for ch_xml in chan_xml_list]
print("Reading from inlet named {} with channels {}".format(stream_info.name(), stream_ch_names))
def update(self):
marker_samples, marker_timestamps = self.inlet.pull_chunk(timeout=0.0)
if (marker_timestamps):
[phase_str, class_str, targ_str] = marker_samples[-1][0].split(', ')
if phase_str in ['TargetCue']:
self.task['phase'] = 'cue'
elif phase_str in ['GoCue']:
self.task['phase'] = 'go'
elif phase_str in ['Miss', 'Hit']:
self.task['phase'] = 'evaluate'
elif phase_str[:8] == 'NewTrial':
self.task['phase'] = 'precue'
else:
print(phase_str)
self.task['class'] = int(class_str.split(' ')[1])
self.task['target'] = int(targ_str.split(' ')[1])
print("Marker inlet updated with task {}".format(self.task))
# first resolve an EEG stream on the lab network
print("looking for an EEG stream...")
streams = resolve_stream('type', 'Data')
# create a new inlet to read from the stream
inlet = StreamInlet(streams[0])
globalstart = time.time()
while (time.time() - globalstart < exptime):
startwhile = time.time()
chunk, timestamp = inlet.pull_chunk()
np_ar_chunk = np.asarray(chunk)
chunk_size = np_ar_chunk.shape[0]
if chunk_size > 0:
data_chunk_test = np_ar_chunk.T
received_data_buf[:,pos:(pos+chunk_size)] = data_chunk_test
pos = pos + chunk_size + 1
[data_chunk_test,Zlast_pre_high[0,:,:]] = spsig.lfilter(b_pre_high[0], a_pre_high[0], data_chunk_test, 1, Zlast_pre_high[0,:,:])
[data_chunk_test,Zlast_pre_low[0,:,:]] = spsig.lfilter(b_pre_low[0], a_pre_low[0], data_chunk_test, 1, Zlast_pre_low[0,:,:])
data_chunk_test = data_chunk_test[without_emp_mask,:]
#chan_names_test_used = chan_names_test[:,without_emp_mask]
# Name of our channel for plotting purposes
ch_names = [ch_names[i] for i in index_channel]
n_channels = len(index_channel)
# Get names of features
# ex. ['delta - CH1', 'pwr-theta - CH1', 'pwr-alpha - CH1',...]
feature_names = BCIw.get_feature_names(ch_names)
# Number of seconds to collect training data for (one class)
training_length = 20
""" 3. RECORD TRAINING DATA """
# Record data for mental activity 0
BCIw.beep()
eeg_data0, timestamps0 = inlet.pull_chunk(
timeout=training_length+1, max_samples=fs * training_length)
eeg_data0 = np.array(eeg_data0)[:, index_channel]
print('\nClose your eyes!\n')
# Record data for mental activity 1
BCIw.beep() # Beep sound
eeg_data1, timestamps1 = inlet.pull_chunk(
timeout=training_length+1, max_samples=fs * training_length)
eeg_data1 = np.array(eeg_data1)[:, index_channel]
# Divide data into epochs
eeg_epochs0 = BCIw.epoch(eeg_data0, epoch_length * fs,
overlap_length * fs)
eeg_epochs1 = BCIw.epoch(eeg_data1, epoch_length * fs,
overlap_length * fs)
1 / shift_length)
""" 3. GET DATA """
# The try/except structure allows to quit the while loop by aborting the
# script with <Ctrl-C>
print('Press Ctrl-C in the console to break the while loop.')
try:
# The following loop does what we see in the diagram of Exercise 1:
# acquire data, compute features, visualize raw EEG and the features
while True:
""" 3.1 ACQUIRE DATA """
# Obtain EEG data from the LSL stream
eeg_data, timestamp = inlet.pull_chunk(
timeout=1, max_samples=int(shift_length * fs))
# Only keep the channel we're interested in
ch_data = np.array(eeg_data)[:, index_channel]
# Update EEG buffer
eeg_buffer, filter_state = BCIw.update_buffer(
eeg_buffer, ch_data, notch=True,
filter_state=filter_state)
""" 3.2 COMPUTE FEATURES """
# Get newest samples from the buffer
data_epoch = BCIw.get_last_data(eeg_buffer,
epoch_length * fs)
# Compute features
timeout=100)[0]
print('GUI source discovered')
#print(experiment_info, bci_info)
experiment_inlet = StreamInlet(experiment_info)
bci_inlet = StreamInlet(bci_info)
bci_results = [[], []]
experiment_results = [[], []]
print('Recording')
while True:
# get a new sample (you can also omit the timestamp part if you're not
# interested in it)
bci_values, bci_timestamps = bci_inlet.pull_chunk(max_samples=device.sfreq * 60 *6)
bci_results[0].extend(bci_values)
bci_results[1].extend(bci_timestamps)
experiment_values, experiment_timestamps = experiment_inlet.pull_chunk()
experiment_results[0].extend(experiment_values)
experiment_results[1].extend(experiment_timestamps)
if len(experiment_results[0]) > 0 and experiment_results[0][-1][0] < 0:
break
experiment_results = np.hstack([np.array(experiment_results[1])[:, None],
experiment_results[0]])
np.savetxt(filename+'_experiment'+'.csv', experiment_results, delimiter=';')
bci_results = np.hstack([np.array(bci_results[1])[:, None],
