def filter_data_pre_raw(self, data, fcenter, bandwidth, order,
filter_type):
"""Filters the OpenBCI data using the BrainFlow functions before creating an MNE Raw object.
Parameters:
data
fcenter
bandwidth
order
filter_type
Returns:
data
"""
for channel in self.eeg_info[0]:
if filter_type == 'bandpass':
DataFilter.perform_bandpass(data[channel], self.eeg_info[1],
fcenter, bandwidth, order,
FilterTypes.BESSEL.value, 0)
elif filter_type == 'notch':
DataFilter.perform_bandstop(data[channel], self.eeg_info[1],
fcenter, bandwidth, order,
FilterTypes.BUTTERWORTH.value, 0)
elif filter_type == 'highpass':
DataFilter.perform_highpass(data[channel], self.eeg_info[1],
fcenter, order,
FilterTypes.BUTTERWORTH.value, 0)
return data
def update(self):
data = self.board_shim.get_current_board_data(self.num_points)
avg_bands = [0, 0, 0, 0, 0]
for count, channel in enumerate(self.exg_channels):
# plot timeseries
DataFilter.detrend(data[channel], DetrendOperations.CONSTANT.value)
DataFilter.perform_bandpass(data[channel], self.sampling_rate, 30.0, 56.0, 2,
FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_bandstop(data[channel], self.sampling_rate, 50.0, 4.0, 2,
FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_bandstop(data[channel], self.sampling_rate, 60.0, 4.0, 2,
FilterTypes.BUTTERWORTH.value, 0)
self.curves[count].setData(data[channel].tolist())
if data.shape[1] > self.psd_size:
# plot psd
psd_data = DataFilter.get_psd_welch(data[channel], self.psd_size, self.psd_size // 2, self.sampling_rate,
WindowFunctions.BLACKMAN_HARRIS.value)
lim = min(70, len(psd_data[0]))
self.psd_curves[count].setData(psd_data[1][0:lim].tolist(), psd_data[0][0:lim].tolist())
# plot bands
avg_bands[0] = avg_bands[0] + DataFilter.get_band_power(psd_data, 1.0, 4.0)
avg_bands[1] = avg_bands[1] + DataFilter.get_band_power(psd_data, 4.0, 8.0)
avg_bands[2] = avg_bands[2] + DataFilter.get_band_power(psd_data, 8.0, 13.0)
avg_bands[3] = avg_bands[3] + DataFilter.get_band_power(psd_data, 13.0, 30.0)
avg_bands[4] = avg_bands[4] + DataFilter.get_band_power(psd_data, 30.0, 50.0)
avg_bands = [int(x * 100 / len(self.exg_channels)) for x in avg_bands]
self.band_bar.setOpts(height=avg_bands)
self.app.processEvents()
def main():
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board_id = BoardIds.SYNTHETIC_BOARD.value
board = BoardShim(board_id, params)
board.prepare_session()
board.start_stream()
BoardShim.log_message(LogLevels.LEVEL_INFO.value,
'start sleeping in the main thread')
time.sleep(10)
data = board.get_board_data()
board.stop_stream()
board.release_session()
# demo how to convert it to pandas DF and plot data
eeg_channels = BoardShim.get_eeg_channels(board_id)
df = pd.DataFrame(np.transpose(data))
plt.figure()
df[eeg_channels].plot(subplots=True)
plt.savefig('before_processing.png')
# for demo apply different filters to different channels, in production choose one
for count, channel in enumerate(eeg_channels):
# filters work in-place
if count == 0:
DataFilter.perform_bandpass(data[channel],
BoardShim.get_sampling_rate(board_id),
15.0, 6.0, 4, FilterTypes.BESSEL.value,
0)
elif count == 1:
DataFilter.perform_bandstop(data[channel],
BoardShim.get_sampling_rate(board_id),
30.0, 1.0, 3,
FilterTypes.BUTTERWORTH.value, 0)
elif count == 2:
DataFilter.perform_lowpass(data[channel],
BoardShim.get_sampling_rate(board_id),
20.0, 5,
FilterTypes.CHEBYSHEV_TYPE_1.value, 1)
elif count == 3:
DataFilter.perform_highpass(data[channel],
BoardShim.get_sampling_rate(board_id),
3.0, 4, FilterTypes.BUTTERWORTH.value,
0)
elif count == 4:
DataFilter.perform_rolling_filter(data[channel], 3,
AggOperations.MEAN.value)
else:
DataFilter.remove_environmental_noise(
data[channel], BoardShim.get_sampling_rate(board_id),
NoiseTypes.FIFTY.value)
df = pd.DataFrame(np.transpose(data))
plt.figure()
df[eeg_channels].plot(subplots=True)
plt.savefig('after_processing.png')
def main ():
parser = argparse.ArgumentParser ()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port
parser.add_argument ('--ip-port', type = int, help = 'ip port', required = False, default = 0)
parser.add_argument ('--ip-protocol', type = int, help = 'ip protocol, check IpProtocolType enum', required = False, default = 0)
parser.add_argument ('--ip-address', type = str, help = 'ip address', required = False, default = '')
parser.add_argument ('--serial-port', type = str, help = 'serial port', required = False, default = '')
parser.add_argument ('--mac-address', type = str, help = 'mac address', required = False, default = '')
parser.add_argument ('--other-info', type = str, help = 'other info', required = False, default = '')
parser.add_argument ('--board-id', type = int, help = 'board id, check docs to get a list of supported boards', required = True)
parser.add_argument ('--log', action = 'store_true')
args = parser.parse_args ()
params = BrainFlowInputParams ()
params.ip_port = args.ip_port
params.serial_port = args.serial_port
params.mac_address = args.mac_address
params.other_info = args.other_info
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
if (args.log):
BoardShim.enable_dev_board_logger ()
else:
BoardShim.disable_board_logger ()
board = BoardShim (args.board_id, params)
board.prepare_session ()
# disable 2nd channel for cyton use real board to check it, emulator ignores commands
if args.board_id == brainflow.board_shim.BoardIds.CYTON_BOARD.value:
board.config_board ('x2100000X')
board.start_stream ()
time.sleep (10)
data = board.get_board_data ()
board.stop_stream ()
board.release_session ()
eeg_channels = BoardShim.get_eeg_channels (args.board_id)
for count, channel in enumerate (eeg_channels):
if count == 0:
DataFilter.perform_bandpass (data[channel], BoardShim.get_sampling_rate (args.board_id), 15.0, 6.0, 4, FilterTypes.BESSEL.value, 0)
elif count == 1:
DataFilter.perform_bandstop (data[channel], BoardShim.get_sampling_rate (args.board_id), 5.0, 1.0, 3, FilterTypes.BUTTERWORTH.value, 0)
elif count == 2:
DataFilter.perform_lowpass (data[channel], BoardShim.get_sampling_rate (args.board_id), 9.0, 5, FilterTypes.CHEBYSHEV_TYPE_1.value, 1)
elif count == 3:
DataFilter.perform_highpass (data[channel], BoardShim.get_sampling_rate (args.board_id), 3.0, 4, FilterTypes.BUTTERWORTH.value, 0)
def update(self):
# received_data, addr = sock.recvfrom(1024) # buffer size is 1024 bytes
# print("Received message: ", received_data)
data = self.board_shim.get_current_board_data(self.num_points)
if data[0:7, 0:250].shape == (7, 250):
for count, channel in enumerate(self.exg_channels):
# plot timeseries
DataFilter.perform_lowpass(
data[channel], BoardShim.get_sampling_rate(args.board_id),
high, 3, FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_highpass(
data[channel], BoardShim.get_sampling_rate(args.board_id),
low, 3, FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_bandstop(
data[channel], BoardShim.get_sampling_rate(args.board_id),
50, 2, 8, FilterTypes.BUTTERWORTH.value, 0)
self.curves[count + 1].setData(data[channel][-1001:].tolist())
window = data[0:8, -250:] # input window
window = window - window[3, :] # Cz reference
x = np.vstack((window[0:3, :], window[4:, :]))
x = create_data(x, fs, 1, low, high, n_freqs, zeros,
length) # convert to PSD
x = np.reshape(x, (1, n_channels_ref, n_freqs))
x_csp = csp2.transform(x)
window = np.reshape(window, (1, window.shape[0], window.shape[1]))
x_raw_csp = csp1.transform(window)
inference = np.hstack((x_csp, x_raw_csp))
current_time = datetime.now()
current_time = current_time.strftime("%M:%S")
result.append(model.predict(inference)[0])
MESSAGE = str(model.predict(inference)[0])
MESSAGE = bytes(MESSAGE, 'utf-8')
sock.sendto(MESSAGE, (UDP_IP, UDP_PORT))
pygame.time.delay(100)
self.curves[0].setData(result[-1001:])
self.app.processEvents()
def update(self):
data = self.board_shim.get_current_board_data(self.num_points)
if data.shape[1] >= 2000:
for count, channel in enumerate(self.exg_channels):
# plot timeseries
DataFilter.perform_bandpass(data[channel], self.sampling_rate, 25, 25, 2,
FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_bandstop(data[channel], self.sampling_rate, 50.0, 4, 3,
FilterTypes.BUTTERWORTH.value, 0)
front_all_bp = DataFilter.get_avg_band_powers(data[:, -1000:], [0, 1, 2], self.sampling_rate, False)
motor_all_bp_L = DataFilter.get_avg_band_powers(data[:, -1000:], [3], self.sampling_rate, False)
motor_all_bp_R = DataFilter.get_avg_band_powers(data[:, -1000:], [4], self.sampling_rate, False)
# For calculating beta band power from concentrating
weighted_beta = EWA(self.beta[-1], front_all_bp[0][3], beta=0.95, threshold=0.11)
self.beta = np.hstack((self.beta[1:self.num_points_partial], weighted_beta))
self.curves[0].setData(self.beta)
# # Calculate alpha band power from motor imagery
# weighted_alpha = EWA(self.alpha[-1], motor_all_bp_R[0][2]/motor_all_bp_L[0][2], beta=0.99, threshold=1.5)
# self.alpha = np.hstack((self.alpha[1:self.num_points_partial], weighted_alpha))
# self.curves[1].setData(self.alpha)
# print("Weighted Alpha: ", self.alpha[-1], "Weighted Beta: ", self.beta[-1])
# print("Beta: ", front_all_bp[0][2], "Alpha L: ", motor_all_bp_R[0][3]/motor_all_bp_L[0][3])
if weighted_beta > 0.104:
self.alpha = np.hstack((self.alpha[1:self.num_points_partial], 1))
self.curves[1].setData(self.alpha)
MESSAGE = '1'
MESSAGE = bytes(MESSAGE, 'utf-8')
sock.sendto(MESSAGE, (UDP_IP, UDP_PORT))
else:
self.alpha = np.hstack((self.alpha[1:self.num_points_partial], 0))
self.curves[1].setData(self.alpha)
MESSAGE = '0'
MESSAGE = bytes(MESSAGE, 'utf-8')
sock.sendto(MESSAGE, (UDP_IP, UDP_PORT))
print(weighted_beta)
self.app.processEvents()
def start_recording(total_sec, max_samples, params, args):
board = BoardShim(args.board_id, params)
board.prepare_session()
# board.start_stream () # use this for default options
board.start_stream(max_samples, args.streamer_params)
time.sleep(total_sec)
# data = board.get_current_board_data (256) # get latest 256 packages or less, doesnt remove them from internal buffer
data = board.get_board_data(
) # get all data and remove it from internal buffer
timestamp_channel = board.get_timestamp_channel(board_id=0)
board.stop_stream()
board.release_session()
# demo how to convert it to pandas DF and plot data
eeg_channels = BoardShim.get_eeg_channels(args.board_id)
print(eeg_channels)
df = pd.DataFrame(np.transpose(data))
plt.figure()
df[eeg_channels].plot(subplots=True)
plt.savefig('data/before_processing.png')
# for demo apply different filters to different channels, in production choose one
for count, channel in enumerate(eeg_channels):
DataFilter.perform_lowpass(data[channel],
BoardShim.get_sampling_rate(args.board_id),
30, 3, FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_highpass(data[channel],
BoardShim.get_sampling_rate(args.board_id),
5, 3, FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_bandstop(data[channel],
BoardShim.get_sampling_rate(args.board_id),
50, 2, 8, FilterTypes.BUTTERWORTH.value, 0)
df = pd.DataFrame(np.transpose(
data[:, 1000:])) # Usable after 1000 given order of filters are 3
plt.figure()
df[eeg_channels].plot(subplots=True)
plt.savefig('data/after_processing.png')
return data, timestamp_channel
def update(self):
data = self.board_shim.get_current_board_data(self.num_points)
for count, channel in enumerate(self.exg_channels):
# plot timeseries
DataFilter.detrend(data[channel], DetrendOperations.CONSTANT.value)
DataFilter.perform_bandpass(data[channel], self.sampling_rate,
51.0, 100.0, 2,
FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_bandpass(data[channel], self.sampling_rate,
51.0, 100.0, 2,
FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_bandstop(data[channel], self.sampling_rate,
50.0, 4.0, 2,
FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_bandstop(data[channel], self.sampling_rate,
60.0, 4.0, 2,
FilterTypes.BUTTERWORTH.value, 0)
self.curves[count].setData(data[channel].tolist())
self.app.processEvents()
def filter_data(data: np.ndarray,
sampling_rate: int,
bandpass_min: float,
bandpass_max: float,
subtract_average: bool,
notch_filter: bool = True,
notch_freq: float = 50):
if subtract_average:
data = data - np.average(data)
DataFilter.perform_bandpass(data, sampling_rate,
(bandpass_max + bandpass_min) / 2,
bandpass_max - bandpass_min, 4,
FilterTypes.BUTTERWORTH.value, 0)
if notch_filter:
DataFilter.perform_bandstop(data, sampling_rate, notch_freq, 2, 4,
FilterTypes.BUTTERWORTH.value, 0)
return data
def run(self):
# 重写线程执行的run函数
# 触发自定义信号
eegchannel = self.parent.get_eeg_channels(self.parent.get_board_id())
timechannel = self.parent.get_timestamp_channel(
self.parent.get_board_id())
print(timechannel)
get_sample_count = 1000
delaytime = 1.0 * get_sample_count / self.parent.get_sampling_rate(
self.parent.get_board_id())
while (1):
#data = self.parent.get_current_board_data(get_sample_count)
count = self.parent.get_board_data_count() * 1.2
data = self.parent.get_board_data()
delaytime = 1.0 * count / self.parent.get_sampling_rate(
self.parent.get_board_id())
showdata = data[eegchannel[0]:eegchannel[-1] +
1, :] #*scale_fac_uVolts_per_count
print(showdata)
# timedata = data[timechannel:, :]
# iddata = data[:1, :]
# savedata = np.concatenate((showdata, timedata), axis=0)
# savedata = np.concatenate((iddata, savedata), axis=0)
for k in range(len(showdata)):
#print(showdata[k].shape)
DataFilter.perform_bandstop(showdata[k], get_sample_count, 50,
4.0, 2, 0, 0)
DataFilter.perform_bandpass(showdata[k], get_sample_count, 25,
40, 2, 0, 0)
datat = showdata.T
#datat *= -scale_fac_uVolts_per_count
self.lsloutlet.push_chunk(datat.tolist())
def run(self):
# Initialize Acquisition Paramenters
window_size = 3
sleep_time = 0.5
points_per_update = window_size * self.sampling_rate
# Load Decoder
classifier = keras.models.load_model(
'..\jupyter-notebooks\classifier_22_v3')
# Initialize Actuator
# LIF Parameters:
alpha = 0.4
beta = 0.1
v_ref = 0
v_thresh = 1
v_prev = np.zeros(4)
v = np.zeros(4)
# Manipulator Initialization
portHandler = PortHandler(DEVICE_NAME)
# There's also a class type that handles how to send packages across the COM port
packetHandler = PacketHandler(PROTOCOL_VERSION)
# Open the port
if portHandler.openPort():
print('Succeeded to open the port')
else:
print('Failed to open the port')
quit()
enable_motor(MOTOR_ID_Y, packetHandler, portHandler)
enable_motor(3, packetHandler, portHandler)
enable_motor(2, packetHandler, portHandler)
enable_motor(MOTOR_ID_Z, packetHandler, portHandler)
position_my = 1900
position_mz = 1900
move_motor(position_my, MOTOR_ID_Y, packetHandler, portHandler)
move_motor(1900, 3, packetHandler, portHandler)
move_motor(1900, 2, packetHandler, portHandler)
move_motor(position_mz, MOTOR_ID_Z, packetHandler, portHandler)
_ = input()
while self.keep_alive:
start_time = time.time()
time.sleep(sleep_time)
# get current board data doesnt remove data from the buffer
data = self.board.get_current_board_data(int(points_per_update))
# print('Data Shape %s' % (str(data.shape)))
first_channel = True
for channel in self.eeg_channels:
# filters work in-place
DataFilter.perform_highpass(data[channel], self.sampling_rate,
0.5, 4,
FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_bandstop(data[channel], self.sampling_rate,
60.0, 2.0, 4,
FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_bandpass(data[channel], self.sampling_rate,
19.0, 12.0, 4,
FilterTypes.BUTTERWORTH.value, 0)
stft_data = data[channel].copy()
_, _, Zxx = signal.stft(stft_data,
self.sampling_rate,
nperseg=128,
noverlap=127,
nfft=256)
spectro = np.asarray(Zxx[7:32, :])
spectro = np.abs(spectro)
spectro = np.expand_dims(spectro, axis=2)
if first_channel:
tfi = spectro.copy()
first_channel = False
else:
tfi = np.dstack((tfi, spectro))
res_tfi = resize(tfi, (64, 64, 8))
res_tfi = np.reshape(res_tfi, (1, 64, 64, 8))
outputs = classifier.predict(res_tfi)
outputs = np.reshape(outputs, -1)
output = np.argmax(outputs)
exc = np.zeros(4)
if output == 0:
exc[0] = 1
elif output == 2:
exc[1] = 1
elif output == 3:
exc[2] = 1
elif output == 4:
exc[3] = 1
print(v)
dv = np.subtract((alpha * exc), (beta * v_prev))
v = np.add(v_prev, dv)
print(v)
if v[0] > v_thresh:
position_my = move_down(position_my, packetHandler,
portHandler)
v[0] = v_ref
elif v[1] > v_thresh:
position_mz = move_left(position_mz, packetHandler,
portHandler)
v[1] = v_ref
elif v[2] > v_thresh:
position_mz = move_right(position_mz, packetHandler,
portHandler)
v[2] = v_ref
elif v[3] > v_thresh:
position_my = move_up(position_my, packetHandler, portHandler)
v[3] = v_ref
else:
print('do not move')
v_prev = v
print(time.time() - start_time)
disable_motor(MOTOR_ID_Y, packetHandler, portHandler)
disable_motor(3, packetHandler, portHandler)
disable_motor(2, packetHandler, portHandler)
disable_motor(MOTOR_ID_Z, packetHandler, portHandler)
# Close the port
portHandler.closePort()
def main():
parser = argparse.ArgumentParser()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port,
parser.add_argument('--ip-port',
type=int,
help='ip port',
required=False,
default=0)
parser.add_argument('--ip-protocol',
type=int,
help='ip protocol, check IpProtocolType enum',
required=False,
default=0)
parser.add_argument('--ip-address',
type=str,
help='ip address',
required=False,
default='')
parser.add_argument('--serial-port',
type=str,
help='serial port',
required=False,
default='')
parser.add_argument('--mac-address',
type=str,
help='mac address',
required=False,
default='')
parser.add_argument('--other-info',
type=str,
help='other info',
required=False,
default='')
parser.add_argument(
'--board-id',
type=int,
help='board id, check docs to get a list of supported boards',
required=True)
parser.add_argument('--log', action='store_true')
args = parser.parse_args()
params = BrainFlowInputParams()
params.ip_port = args.ip_port
params.serial_port = args.serial_port
params.mac_address = args.mac_address
params.other_info = args.other_info
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
if (args.log):
BoardShim.enable_dev_board_logger()
else:
BoardShim.disable_board_logger()
# demo how to read data as 2d numpy array
board = BoardShim(args.board_id, params)
board.prepare_session()
board.start_stream()
BoardShim.log_message(LogLevels.LEVEL_INFO.value,
'start sleeping in the main thread')
time.sleep(10)
# data = board.get_current_board_data (256) # get latest 256 packages or less, doesnt remove them from internal buffer
data = board.get_board_data(
) # get all data and remove it from internal buffer
board.stop_stream()
board.release_session()
# demo how to convert it to pandas DF and plot data
eeg_channels = BoardShim.get_eeg_channels(args.board_id)
df = pd.DataFrame(np.transpose(data))
print('Data From the Board')
print(df.head())
plt.figure()
df[eeg_channels].plot(subplots=True)
plt.savefig('before_processing.png')
# demo for data serialization
DataFilter.write_file(data, 'test.csv', 'w')
restored_data = DataFilter.read_file('test.csv')
restored_df = pd.DataFrame(np.transpose(restored_data))
print('Data From the File')
print(restored_df.head())
# demo how to perform signal processing
for count, channel in enumerate(eeg_channels):
if count == 0:
DataFilter.perform_bandpass(
data[channel], BoardShim.get_sampling_rate(args.board_id),
15.0, 6.0, 4, FilterTypes.BESSEL.value, 0)
elif count == 1:
DataFilter.perform_bandstop(
data[channel], BoardShim.get_sampling_rate(args.board_id), 5.0,
1.0, 3, FilterTypes.BUTTERWORTH.value, 0)
elif count == 2:
DataFilter.perform_lowpass(
data[channel], BoardShim.get_sampling_rate(args.board_id), 9.0,
5, FilterTypes.CHEBYSHEV_TYPE_1.value, 1)
elif count == 3:
DataFilter.perform_highpass(
data[channel], BoardShim.get_sampling_rate(args.board_id), 3.0,
4, FilterTypes.BUTTERWORTH.value, 0)
df = pd.DataFrame(np.transpose(data))
print('Data After Processing')
print(df.head())
plt.figure()
df[eeg_channels].plot(subplots=True)
plt.savefig('after_processing.png')
def main(i):
BoardShim.enable_dev_board_logger()
BoardShim.disable_board_logger(
) #optional. take this out for initial setup for your board.
# use synthetic board for demo
params = BrainFlowInputParams()
board_id = BoardIds.SYNTHETIC_BOARD.value
board = BoardShim(board_id, params)
eeg_channels = BoardShim.get_eeg_channels(board_id)
sampling_rate = BoardShim.get_sampling_rate(board_id)
timestamp = BoardShim.get_timestamp_channel(board_id)
board.prepare_session()
board.start_stream()
style.use('fivethirtyeight')
plt.title("Live EEG stream from Brainflow", fontsize=15)
plt.ylabel("Data in millivolts", fontsize=15)
plt.xlabel("\nTime", fontsize=10)
keep_alive = True
eeg1 = [] #lists to store eeg data
eeg2 = []
eeg3 = []
eeg4 = []
timex = [] #list to store timestamp
while keep_alive == True:
while board.get_board_data_count(
) < 250: #ensures that all data shape is the same
time.sleep(0.005)
data = board.get_current_board_data(250)
# creating a dataframe of the eeg data to extract eeg values later
eegdf = pd.DataFrame(np.transpose(data[eeg_channels]))
eegdf_col_names = [
"ch1", "ch2", "ch3", "ch4", "ch5", "ch6", "ch7", "ch8", "ch9",
"ch10", "ch11", "ch12", "ch13", "ch14", "ch15", "ch16"
]
eegdf.columns = eegdf_col_names
# to keep it simple, making another dataframe for the timestamps to access later
timedf = pd.DataFrame(np.transpose(data[timestamp]))
print(
"EEG Dataframe"
) #easy way to check what data is being streamed and if program is working
print(eegdf) #isn't neccesary.
for count, channel in enumerate(eeg_channels):
# filters work in-place
# Check Brainflow docs for more filters
if count == 0:
DataFilter.perform_bandstop(data[channel], sampling_rate, 60.0,
4.0, 4,
FilterTypes.BUTTERWORTH.value,
0) # bandstop 58 - 62
DataFilter.perform_bandpass(data[channel], sampling_rate, 21.0,
20.0, 4, FilterTypes.BESSEL.value,
0) # bandpass 11 - 31
if count == 1:
DataFilter.perform_bandstop(data[channel], sampling_rate, 60.0,
4.0, 4,
FilterTypes.BUTTERWORTH.value,
0) # bandstop 58 - 62
DataFilter.perform_bandpass(data[channel], sampling_rate, 21.0,
20.0, 4, FilterTypes.BESSEL.value,
0) # bandpass 11 - 31
if count == 2:
DataFilter.perform_bandstop(data[channel], sampling_rate, 60.0,
4.0, 4,
FilterTypes.BUTTERWORTH.value,
0) # bandstop 58 - 62
DataFilter.perform_bandpass(data[channel], sampling_rate, 21.0,
20.0, 4, FilterTypes.BESSEL.value,
0) # bandpass 11 - 31
if count == 3:
DataFilter.perform_bandstop(data[channel], sampling_rate, 60.0,
4.0, 4,
FilterTypes.BUTTERWORTH.value,
0) # bandstop 58 - 62
DataFilter.perform_bandpass(data[channel], sampling_rate, 21.0,
20.0, 4, FilterTypes.BESSEL.value,
0) # bandpass 11 - 31
# Brainflow ML Model
bands = DataFilter.get_avg_band_powers(data, eeg_channels,
sampling_rate, True)
feature_vector = np.concatenate((bands[0], bands[1]))
# calc concentration
concentration_params = BrainFlowModelParams(
BrainFlowMetrics.CONCENTRATION.value,
BrainFlowClassifiers.KNN.value)
concentration = MLModel(concentration_params)
concentration.prepare()
print('Concentration: %f' % concentration.predict(feature_vector))
concentrated_measure = concentration.predict(feature_vector)
concentration.release()
# calc relaxation
relaxation_params = BrainFlowModelParams(
BrainFlowMetrics.RELAXATION.value, BrainFlowClassifiers.KNN.value)
relaxation = MLModel(relaxation_params)
relaxation.prepare()
print('Relaxation: %f' % relaxation.predict(feature_vector))
relaxed_measure = relaxation.predict(feature_vector)
relaxation.release()
#appending eeg data to lists
eeg1.extend(
eegdf.iloc[:, 0].values
) # I am using OpenBCI Ganglion board, so I only have four channels.
eeg2.extend(
eegdf.iloc[:, 1].values
) # If you have a different board, you should be able to copy paste
eeg3.extend(eegdf.iloc[:,
2].values) # these commands for more channels.
eeg4.extend(eegdf.iloc[:, 3].values)
timex.extend(timedf.iloc[:, 0].values) # timestamps
plt.cla()
#plotting eeg data
plt.plot(timex, eeg1, label="Channel 1", color="red")
plt.plot(timex, eeg2, label="Channel 2", color="blue")
plt.plot(timex, eeg3, label="Channel 3", color="orange")
plt.plot(timex, eeg4, label="Channel 4", color="purple")
plt.tight_layout()
keep_alive = False #resetting stream so that matplotlib can plot data
if concentrated_measure >= 0.5:
print(
"GOOD KEEP CONCENTRATING"
) #a program screaming at you to concentrate should do the trick :)
else:
print("WHERE IS THE CONCENTRATION??")
if relaxed_measure >= 0.5:
print("YES RELAX MORE")
else:
print("NO, START RELAXING")
board.stop_stream()
board.release_session()
