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()