def dataStream():
global delta_waves
global alpha_waves
global beta_waves
global theta_waves
try:
# The following loop acquires data, computes band powers, and calculates neurofeedback metrics based on those band powers
while True:
eeg_data, timestamp = inlet.pull_chunk(timeout=1,
max_samples=int(
SHIFT_LENGTH * fs))
ch_data = np.array(eeg_data)[:, INDEX_CHANNEL]
eeg_buffer, filter_state = utils.update_buffer(
eeg_buffer, ch_data, notch=True, filter_state=filter_state)
data_epoch = utils.get_last_data(eeg_buffer, EPOCH_LENGTH * fs)
band_powers = utils.compute_band_powers(data_epoch, fs)
band_buffer, _ = utils.update_buffer(band_buffer,
np.asarray([band_powers]))
smooth_band_powers = np.mean(band_buffer, axis=0)
delta_waves = band_powers[Band.Delta]
theta_waves = band_powers[Band.Theta]
alpha_waves = band_powers[Band.Alpha]
beta_waves = band_powers[Band.Beta]
except Exception as e:
print(e)
def _get_data_epoch(self, eeg_buffer):
""" Get newest samples from the buffer
:param eeg_buffer:
:return:
"""
data_epoch = utils.get_last_data(eeg_buffer,
utils.EPOCH_LENGTH * self.fs)
return data_epoch
def get_average_blink(eye_index):
eeg_buffer = np.zeros((int(fs * BUFFER_LENGTH), 1))
filter_state = None
eye = "left" if eye_index == INDEX_CHANNEL_LEFT else "right"
print("Please blink your " + eye + " eye. Press enter when done.")
maxMatches = []
stop_flag = []
_thread.start_new_thread(input_thread, (stop_flag, ))
i = 10 # number of times to run after user presses enter
while i > 0:
if stop_flag:
i = i - 1
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)[:, eye_index]
# Update EEG buffer with the new data
eeg_buffer, filter_state = utils.update_buffer(
eeg_buffer, ch_data, notch=True, filter_state=filter_state)
""" 3.2 COMPUTE BAND POWERS """
# Get newest samples from the buffer
data_epoch = utils.get_last_data(eeg_buffer, int(EPOCH_LENGTH * fs))
matchFilt = signal.hilbert(filt)
matches = signal.correlate(matchFilt, data_epoch[:, 0])
matchesAbs = np.abs(matches[:])
maxMatches.append((np.max(matchesAbs) / 1e5).astype(int))
maxMatchesIdx = np.argmax(maxMatches)
idx = maxMatchesIdx
peakValues = []
stop_flag = 1
check_right_side = False
while True:
if idx > 0 and idx < len(maxMatches) - 1:
idx = idx + (1 if stop_flag == 2 else -1)
possPeak = maxMatches[idx]
if maxMatches[maxMatchesIdx] * 0.6 < possPeak:
peakValues.append(possPeak)
elif stop_flag == 2:
break
else:
check_right_side = True
elif stop_flag == 2:
break
else:
check_right_side = True
if check_right_side:
idx = maxMatchesIdx
stop_flag = 2
check_right_side = False
return peakValues
def readData(eeg_buffer, filter_state, n_win_test, band_buffer):
""" ACQUIRE DATA """
eeg_data, timestamp = inlet.pull_chunk(timeout=1, max_samples=int(SHIFT_LENGTH * fs))
ch_data = np.array(eeg_data)[:, INDEX_CHANNEL]
eeg_buffer, filter_state = utils.update_buffer(eeg_buffer, ch_data, notch=True, filter_state=filter_state)
""" COMPUTE BAND POWERS """
data_epoch = utils.get_last_data(eeg_buffer, EPOCH_LENGTH * fs)
band_powers = utils.compute_band_powers(data_epoch, fs)
return band_powers
def get_dada():
""" 3.1 ACQUIRE DATA """
# Obtain EEG data from the LSL stream
global eeg_buffer
global filter_state
global band_buffer
global file
eeg_data, timestamp = inlet.pull_chunk(
timeout=1, max_samples=int(SHIFT_LENGTH * fs))
# Only keep the channel we're interested in
ret = [None]*4
for i in range(4):
ch_data = np.array(eeg_data)[:, i]#he tocat aixo
# Update EEG buffer with the new data
eeg_buffer, filter_state = utils.update_buffer(
eeg_buffer, ch_data, notch=True,
filter_state=filter_state)
""" 3.2 COMPUTE BAND POWERS """
# Get newest samples from the buffer
data_epoch = utils.get_last_data(eeg_buffer,
EPOCH_LENGTH * fs)
# Compute band powers
band_powers = utils.compute_band_powers(data_epoch, fs)
band_buffer, _ = utils.update_buffer(band_buffer,
np.asarray([band_powers]))
# Compute the average band powers for all epochs in buffer
# This helps to smooth out noise
smooth_band_powers = np.mean(band_buffer, axis=0)
# print('Delta: ', band_powers[Band.Delta], ' Theta: ', band_powers[Band.Theta],
# ' Alpha: ', band_powers[Band.Alpha], ' Beta: ', band_powers[Band.Beta])
#file.write("%lf,%lf,%lf,%lf\n" % (band_powers[Band.Alpha],band_powers[Band.Beta],band_powers[Band.Delta],band_powers[Band.Theta]))
""" 3.3 COMPUTE NEUROFEEDBACK METRICS """
# These metrics could also be used to drive brain-computer interfaces
# Alpha Protocol:
# Simple redout of alpha power, divided by delta waves in order to rule out noise
#return (10 + (smooth_band_powers[Band.Alpha] / \
# smooth_band_powers[Band.Delta]))**5
ret[i] = (smooth_band_powers[Band.Alpha] / smooth_band_powers[Band.Delta])
#acum += (smooth_band_powers[Band.Alpha] - smooth_band_powers[Band.Delta])
return ret
def animate(i, eeg_buffer, filter_state, n_win_test, band_buffer):
global t, start_time
""" 3.1 ACQUIRE DATA """
eeg_data, timestamp = inlet.pull_chunk(timeout=1,
max_samples=int(SHIFT_LENGTH * fs))
ch_data = np.array(eeg_data)[:, INDEX_CHANNEL]
eeg_buffer, filter_state = utils.update_buffer(eeg_buffer,
ch_data,
notch=True,
filter_state=filter_state)
""" 3.2 COMPUTE BAND POWERS """
data_epoch = utils.get_last_data(eeg_buffer, EPOCH_LENGTH * fs)
band_powers = utils.compute_band_powers(data_epoch, fs)
# Add x and y to lists
sensor['A'].append(band_powers[0])
sensor['B'].append(band_powers[1])
sensor['G'].append(band_powers[2])
sensor['T'].append(band_powers[3])
t.append(((time.time()) - start_time))
# Limit x and y lists to 20 items
sensor['A'] = sensor['A'][-40:]
sensor['B'] = sensor['B'][-40:]
sensor['G'] = sensor['G'][-40:]
sensor['T'] = sensor['T'][-40:]
t = t[-40:]
# Draw x and y lists
ax.clear()
ax.plot(t, sensor['A'], color="blue")
ax.plot(t, sensor['B'], color="red")
ax.plot(t, sensor['G'], color="green")
ax.plot(t, sensor['T'], color="black")
# Format plot
plt.title('sensor')
plt.ylabel('data')
plt.xlabel('time')
plt.ylim(-2, 4)
startTime).total_seconds()
""" 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 with the new data
eeg_buffer, filter_state = utils.update_buffer(
eeg_buffer, ch_data, notch=True, filter_state=filter_state)
""" 3.2 COMPUTE BAND POWERS """
# Get newest samples from the buffer
data_epoch = utils.get_last_data(eeg_buffer, EPOCH_LENGTH * fs)
# Compute band powers
band_powers = utils.compute_band_powers(data_epoch, fs)
band_buffer, _ = utils.update_buffer(band_buffer,
np.asarray([band_powers]))
# Compute the average band powers for all epochs in buffer
# This helps to smooth out noise
smooth_band_powers = np.mean(band_buffer, axis=0)
print('Delta: ', band_powers[Band.Delta], ' Theta: ',
band_powers[Band.Theta], ' Alpha: ', band_powers[Band.Alpha],
' Beta: ', band_powers[Band.Beta])
""" 3.3 COMPUTE NEUROFEEDBACK METRICS """
# These metrics could also be used to drive brain-computer interfaces
def recordData():
global timeReadings
""" 1. CONNECT TO EEG STREAM """
# Search for active LSL streams
print('Looking for an EEG stream...')
streams = resolve_byprop('type', 'EEG', timeout=2)
if len(streams) == 0:
raise RuntimeError('Can\'t find EEG stream.')
# Set active EEG stream to inlet and apply time correction
print("Start acquiring data")
inlet = StreamInlet(streams[0], max_chunklen=12)
eeg_time_correction = inlet.time_correction()
# Get the stream info and description
info = inlet.info()
description = info.desc()
# Get the sampling frequency
# This is an important value that represents how many EEG data points are
# collected in a second. This influences our frequency band calculation.
# for the Muse 2016, this should always be 256
fs = int(info.nominal_srate())
""" 2. INITIALIZE BUFFERS """
# Initialize raw EEG data buffer
eeg_buffer = np.zeros((int(fs * BUFFER_LENGTH), 1))
filter_state = None # for use with the notch filter
# Compute the number of epochs in "buffer_length"
n_win_test = int(
np.floor((BUFFER_LENGTH - EPOCH_LENGTH) / SHIFT_LENGTH + 1))
# Initialize the band power buffer (for plotting)
# bands will be ordered: [delta, theta, alpha, beta]
band_buffer = np.zeros((n_win_test, 4))
""" 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.')
i = 0
try:
# # The following loop acquires data, computes band powers, and calculates neurofeedback metrics based on those band powers
while temp:
""" 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 with the new data
eeg_buffer, filter_state = utils.update_buffer(
eeg_buffer, ch_data, notch=True, filter_state=filter_state)
""" 3.2 COMPUTE BAND POWERS """
# Get newest samples from the buffer
data_epoch = utils.get_last_data(eeg_buffer, EPOCH_LENGTH * fs)
# Compute band powers
band_powers = utils.compute_band_powers(data_epoch, fs)
band_buffer, _ = utils.update_buffer(band_buffer,
np.asarray([band_powers]))
# Compute the average band powers for all epochs in buffer
# This helps to smooth out noise
smooth_band_powers = np.mean(band_buffer, axis=0)
# print('Delta: ', band_powers[Band.Delta], ' Theta: ', band_powers[Band.Theta],
# ' Alpha: ', band_powers[Band.Alpha], ' Beta: ', band_powers[Band.Beta])
""" 3.3 COMPUTE NEUROFEEDBACK METRICS """
# These metrics could also be used to drive brain-computer interfaces
# Alpha Protocol:
# Simple redout of alpha power, divided by delta waves in order to rule out noise
alpha_metric = smooth_band_powers[Band.Alpha] / \
smooth_band_powers[Band.Delta]
alphaReadings.append(alpha_metric)
# print('Alpha Relaxation: ', alpha_metric)
# Beta Protocol:
# Beta waves have been used as a measure of mental activity and concentration
# This beta over theta ratio is commonly used as neurofeedback for ADHD
beta_metric = smooth_band_powers[Band.Beta] / \
smooth_band_powers[Band.Theta]
betaReadings.append(beta_metric)
# print('Beta Concentration: ', beta_metric)
# Alpha/Theta Protocol:
# This is another popular neurofeedback metric for stress reduction
# Higher theta over alpha is supposedly associated with reduced anxiety
theta_metric = smooth_band_powers[Band.Theta] / \
smooth_band_powers[Band.Alpha]
thetaReadings.append(theta_metric)
dt = datetime.datetime.now().strftime("%x %X")
if dt in timeReadings.keys():
tempDt = timeReadings[dt]
aph = tempDt['alpha']
bth = tempDt['beta']
tth = tempDt['theta']
aph.append(alpha_metric)
bth.append(beta_metric)
tth.append(theta_metric)
else:
timeReadings = {
dt: {
"alpha": [alpha_metric],
"beta": [beta_metric],
"theta": [theta_metric]
}
}
result.append(timeReadings)
i = i + 1
except KeyboardInterrupt:
print('Closing!')
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 with the new data
eeg_buffer, filter_state = utils.update_buffer(
eeg_buffer, ch_data, notch=True, filter_state=filter_state)
""" 3.2 COMPUTE BAND POWERS """
# Get newest samples from the buffer
data_epoch = utils.get_last_data(eeg_buffer, EPOCH_LENGTH * fs)
# Compute band powers
#band_powers = utils.compute_band_powers(data_epoch, fs)
#band_buffer, _ = utils.update_buffer(band_buffer,
#np.asarray([band_powers]))
# Compute the average band powers for all epochs in buffer
# This helps to smooth out noise
#smooth_band_powers = np.mean(band_buffer, axis=0)
# print('Delta: ', band_powers[Band.Delta], ' Theta: ', band_powers[Band.Theta],
# ' Alpha: ', band_powers[Band.Alpha], ' Beta: ', band_powers[Band.Beta])
""" 3.3 COMPUTE NEUROFEEDBACK METRICS """
# These metrics could also be used to drive brain-computer interfaces
# Alpha Protocol:
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_LEFT]
# Update EEG buffer with the new data
eeg_buffer_left, filter_state_left = utils.update_buffer(
eeg_buffer_left,
ch_data,
notch=True,
filter_state=filter_state_left)
""" 3.2 COMPUTE BAND POWERS """
# Get newest samples from the buffer
data_epoch = utils.get_last_data(eeg_buffer_left,
int(EPOCH_LENGTH * fs))
#print(data_epoch.shape)
matchFilt = signal.hilbert(filt)
matches = signal.correlate(matchFilt, data_epoch[:, 0])
matchesAbs = np.abs(matches[:])
maxMatch = np.max(matchesAbs) / 1e5
maxMatchL = maxMatch
if maxMatch > left_thresh:
newTime = datetime.datetime.now()
if (newTime - oldTimeL).total_seconds() * 1000 > left_delay:
print('selector')
