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
feat_vector = BCIw.compute_feature_vector(data_epoch, fs)
feat_buffer, _ = BCIw.update_buffer(feat_buffer,
np.asarray([feat_vector]))
""" 3.3 VISUALIZE THE RAW EEG AND THE FEATURES """
plotter_eeg.update_plot(eeg_buffer)
plotter_feat.update_plot(feat_buffer)
plt.pause(0.00001)
except KeyboardInterrupt:
print('Closing!')
print('Press Ctrl-C in the console to break the while loop.')
try:
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 AND CLASSIFY """
# Get newest samples from the buffer
data_epoch = BCIw.get_last_data(eeg_buffer,
epoch_length * fs)
# Compute features
feat_vector = BCIw.compute_feature_vector(data_epoch, fs)
y_hat = BCIw.test_classifier(classifier,
feat_vector.reshape(1, -1), mu_ft,
std_ft)
print(y_hat)
decision_buffer, _ = BCIw.update_buffer(decision_buffer,
# script with <Ctrl-C>
print('Press Ctrl-C in the console to break the while loop.')
try:
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 AND CLASSIFY """
# Get newest samples from the buffer
data_epoch = BCIw.get_last_data(eeg_buffer, epoch_length * fs)
# Compute features
feat_vector = BCIw.compute_feature_vector(data_epoch, fs)
y_hat = BCIw.test_classifier(classifier,
feat_vector.reshape(1, -1), mu_ft,
std_ft)
print(y_hat)
decision_buffer, _ = BCIw.update_buffer(decision_buffer,
np.reshape(y_hat, (-1, 1)))
""" 3.3 VISUALIZE THE DECISIONS """
plotter_decision.update_plot(decision_buffer)
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
feat_vector = BCIw.compute_feature_vector(data_epoch, fs)
feat_buffer, _ = BCIw.update_buffer(feat_buffer,
np.asarray([feat_vector]))
""" 3.3 VISUALIZE THE RAW EEG AND THE FEATURES """
plotter_eeg.update_plot(eeg_buffer)
plotter_feat.update_plot(feat_buffer)
""" 3.1 ACQUIRE DATA """
# Beep
aud1.stop()
aud1.play()
# 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 = utils.get_last_data(eeg_buffer,
epoch_length * fs)
# Classify Epoch
example = np.expand_dims(data_epoch, axis=0)
example = torch.from_numpy(example)
example = example.type(torch.FloatTensor)
output = nntrace(example)
if output[0,1] > output[0,0]:
label = "Up"
#%% Start pulling data
mules_client.flushdata() # Flush old data from MuLES
# 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 the raw EEG and the features
while True:
""" 1- ACQUIRE DATA """
eeg_data = mules_client.getalldata() # Obtain EEG data from MuLES
eeg_data = eeg_data[:, indexes_channel] # Removes unwanted channels
eeg_buffer = BCIw.update_buffer(eeg_buffer, eeg_data)[0] # Update EEG buffer
# filter here
eeg_buffer_f = lfilter(b, a, eeg_buffer, axis=0)
# Compute PSD for buffer
eeg_buffer_psd = experiment.psd_fft(eeg_buffer_f, fs)[0]
# Select the last win_test_secs seconds to perform task
test_eeg = eeg_buffer_f[(-win_test_secs*fs):,:]
""" 2- COMPUTE FEATURES """
value = CalculaCCA(test_eeg.T)
""" 3- VISUALIZE THE RAW EEG AND THE FEATURES """
plotter_time.update_plot(eeg_buffer) # Plot EEG buffer in time domain