def _get_source_info(self): """ Gets board-specific information from the Brainflow library Returns: eeg_channels sfreq channel_names """ if self.board_type == 'synthetic': eeg_channels = BoardShim.get_eeg_channels( BoardIds.SYNTHETIC_BOARD.value) sfreq = BoardShim.get_sampling_rate(BoardIds.SYNTHETIC_BOARD.value) channel_names = [ 'T7', 'CP5', 'FC5', 'C3', 'C4', 'FC6', 'CP6', 'T8' ] elif self.board_type == 'cyton': eeg_channels = BoardShim.get_eeg_channels( BoardIds.CYTON_BOARD.value) sfreq = BoardShim.get_sampling_rate(BoardIds.CYTON_BOARD.value) channel_names = OPENBCI_STANDARD[:9] elif self.board_type == 'daisy': eeg_channels = BoardShim.get_eeg_channels( BoardIds.CYTON_DAISY_BOARD.value) sfreq = BoardShim.get_sampling_rate( BoardIds.CYTON_DAISY_BOARD.value) channel_names = OPENBCI_STANDARD return [eeg_channels, sfreq, channel_names]
def initialize_board(name='SYNTHETIC',port = None): if name == 'SYNTHETIC': BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value board = BoardShim(board_id, params) board.rate = BoardShim.get_sampling_rate(board_id) board.channels = BoardShim.get_eeg_channels(board_id) board.time_channel = BoardShim.get_timestamp_channel(board_id) board.eeg_channels = BoardShim.get_eeg_channels(board_id) board.accel_channels = BoardShim.get_accel_channels(board_id) elif name == 'OPENBCI': board_id = BoardIds.CYTON_DAISY_BOARD.value params = BrainFlowInputParams() params.serial_port = port board_id = BoardIds.CYTON_DAISY_BOARD.value board = BoardShim(board_id, params) board.rate = BoardShim.get_sampling_rate(board_id) board.channels = BoardShim.get_eeg_channels(board_id) board.time_channel = BoardShim.get_timestamp_channel(board_id) board.eeg_channels = BoardShim.get_eeg_channels(board_id) board.accel_channels = BoardShim.get_accel_channels(board_id) print('Must have OpenBCI GUI open to work... (as port is not opened by Brainflow)') board.prepare_session() return board
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 main(): BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value sampling_rate = BoardShim.get_sampling_rate(board_id) 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) nfft = DataFilter.get_nearest_power_of_two(sampling_rate) data = board.get_board_data() board.stop_stream() board.release_session() eeg_channels = BoardShim.get_eeg_channels(board_id) # second eeg channel of synthetic board is a sine wave at 10Hz, should see huge alpha eeg_channel = eeg_channels[1] # optional detrend DataFilter.detrend(data[eeg_channel], DetrendOperations.LINEAR.value) psd = DataFilter.get_psd_welch(data[eeg_channel], nfft, nfft // 2, sampling_rate, WindowFunctions.BLACKMAN_HARRIS.value) band_power_alpha = DataFilter.get_band_power(psd, 7.0, 13.0) band_power_beta = DataFilter.get_band_power(psd, 14.0, 30.0) print("alpha/beta:%f", band_power_alpha / band_power_beta) # fail test if ratio is not smth we expect if (band_power_alpha / band_power_beta < 100): raise ValueError('Wrong Ratio')
def __init__(self, board_shim): self.board_id = board_shim.get_board_id() self.board_shim = board_shim self.exg_channels = BoardShim.get_exg_channels(self.board_id) self.sampling_rate = BoardShim.get_sampling_rate(self.board_id) self.update_speed_ms = 50 self.window_size = 8 self.partial_window_size = 4 self.n_pads = 12 self.noise = np.ones(self.partial_window_size * self.sampling_rate) self.beta = np.ones(self.partial_window_size * self.sampling_rate)/10 self.alpha = np.ones(self.partial_window_size * self.sampling_rate)/10 self.num_points = self.window_size * self.sampling_rate self.num_points_partial = self.partial_window_size * self.sampling_rate self.app = QtGui.QApplication([]) self.win = pg.GraphicsWindow(title='BrainFlow Plot',size=(800, 600)) self._init_timeseries() timer = QtCore.QTimer() timer.timeout.connect(self.update) timer.start(self.update_speed_ms) QtGui.QApplication.instance().exec_()
def main(): BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board = BoardShim(BoardIds.SYNTHETIC_BOARD.value, params) board.prepare_session() board.start_stream() time.sleep(10) data = board.get_board_data() board.stop_stream() board.release_session() eeg_channels = BoardShim.get_eeg_channels(BoardIds.SYNTHETIC_BOARD.value) eeg_data = data[eeg_channels, :] eeg_data = eeg_data / 1000000 # BrainFlow returns uV, convert to V for MNE # Creating MNE objects from brainflow data arrays ch_types = ['eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg'] ch_names = ['T7', 'CP5', 'FC5', 'C3', 'C4', 'FC6', 'CP6', 'T8'] sfreq = BoardShim.get_sampling_rate(BoardIds.SYNTHETIC_BOARD.value) info = mne.create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types) raw = mne.io.RawArray(eeg_data, info) # its time to plot something! raw.plot_psd(average=True) plt.savefig('psd.png')
class CytonBoard(object): def __init__(self, serial_port): self.params = BrainFlowInputParams() self.params.serial_port = serial_port self.board = BoardShim(BoardIds.CYTON_BOARD.value, self.params) def start_stream(self): self.board.prepare_session() self.board.start_stream() def stop_stream(self): self.board.stop_stream() self.board.release_session() def poll(self, sample_num): try: while self.board.get_board_data_count() < sample_num: time.sleep(0.02) except Exception as e: raise (e) board_data = self.board.get_board_data() #df = board_2_df(np.transpose(board_data)) return board_data def sampling_frequency(self): sampling_freq = self.board.get_sampling_rate( BoardIds.CYTON_BOARD.value) return sampling_freq
def load_demo(duration=1) -> mne.io.RawArray: """Loads and returns some demo data""" BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board = BoardShim(BoardIds.SYNTHETIC_BOARD.value, params) board.prepare_session() board.start_stream() print("Waiting for board shim to generate data...") time.sleep(duration) print("Done!") data = board.get_board_data() board.stop_stream() board.release_session() eeg_channels = BoardShim.get_eeg_channels(BoardIds.SYNTHETIC_BOARD.value) # Only pick 8 channels eeg_channels = eeg_channels[:8] eeg_data = data[eeg_channels, :] eeg_data = eeg_data / 1000000 # BrainFlow returns uV, convert to V for MNE # Creating MNE objects from brainflow data arrays ch_types = ["eeg", "eeg", "eeg", "eeg", "eeg", "eeg", "eeg", "eeg"] ch_names = ["T7", "CP5", "FC5", "C3", "C4", "FC6", "CP6", "T8"] sfreq = BoardShim.get_sampling_rate(BoardIds.SYNTHETIC_BOARD.value) info = mne.create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types) raw = mne.io.RawArray(eeg_data, info) return raw
def main(): BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value sampling_rate = BoardShim.get_sampling_rate(board_id) 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_current_board_data( DataFilter.get_nearest_power_of_two(sampling_rate)) board.stop_stream() board.release_session() eeg_channels = BoardShim.get_eeg_channels(board_id) for count, channel in enumerate(eeg_channels): # optional: subtract mean or detrend psd = DataFilter.get_psd(data[channel], sampling_rate, WindowFunctions.BLACKMAN_HARRIS.value) band_power_alpha = DataFilter.get_band_power(psd, 7.0, 13.0) band_power_beta = DataFilter.get_band_power(psd, 14.0, 30.0) print("alpha/beta:%f", band_power_alpha / band_power_beta)
def main (): BoardShim.enable_board_logger () DataFilter.enable_data_logger () MLModel.enable_ml_logger () parser = argparse.ArgumentParser () # use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port parser.add_argument ('--timeout', type = int, help = 'timeout for device discovery or connection', required = False, default = 0) 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 ('--streamer-params', type = str, help = 'streamer params', required = False, default = '') parser.add_argument ('--serial-number', type = str, help = 'serial number', 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 ('--file', type = str, help = 'file', required = False, default = '') 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.serial_number = args.serial_number params.ip_address = args.ip_address params.ip_protocol = args.ip_protocol params.timeout = args.timeout params.file = args.file board = BoardShim (args.board_id, params) master_board_id = board.get_board_id () sampling_rate = BoardShim.get_sampling_rate (master_board_id) board.prepare_session () board.start_stream (45000, args.streamer_params) BoardShim.log_message (LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep (5) # recommended window size for eeg metric calculation is at least 4 seconds, bigger is better data = board.get_board_data () board.stop_stream () board.release_session () eeg_channels = BoardShim.get_eeg_channels (int (master_board_id)) bands = DataFilter.get_avg_band_powers (data, eeg_channels, sampling_rate, True) feature_vector = np.concatenate ((bands[0], bands[1])) print(feature_vector) # calc concentration concentration_params = BrainFlowModelParams (BrainFlowMetrics.CONCENTRATION.value, BrainFlowClassifiers.KNN.value) concentration = MLModel (concentration_params) concentration.prepare () print ('Concentration: %f' % concentration.predict (feature_vector)) concentration.release () # calc relaxation relaxation_params = BrainFlowModelParams (BrainFlowMetrics.RELAXATION.value, BrainFlowClassifiers.REGRESSION.value) relaxation = MLModel (relaxation_params) relaxation.prepare () print ('Relaxation: %f' % relaxation.predict (feature_vector)) relaxation.release ()
class CytonBoard(object): def __init__(self, serial_port): self.params = BrainFlowInputParams() self.params.serial_port = serial_port self.board = BoardShim(BoardIds.CYTON_BOARD.value, self.params) def start_stream(self): self.board.prepare_session() self.board.start_stream() def stop_stream(self): self.board.stop_stream() self.board.release_session() def poll(self, sample_num): try: while self.board.get_board_data_count() < sample_num: time.sleep(0.02) except Exception as e: raise (e) board_data = self.board.get_board_data() DataFilter.write_file(board_data, '.\Data\cyton_data_new.txt', 'a') # 'a' appends; 'w' overwrites # Could add check to see if file already exists, adding a 1, 2, etc. on the end to avoid conflict # Could use date function for generating names based on date-time. df = board_2_df(np.transpose(board_data)) #print('/n') #print(df) return df def sampling_frequency(self): sampling_freq = self.board.get_sampling_rate( BoardIds.CYTON_BOARD.value) return sampling_freq
class CytonBoard(object): def __init__(self, file): self.params = BrainFlowInputParams() #self.params.serial_port = serial_port self.params.file = file self.params.other_info = str(BoardIds.CYTON_BOARD.value) self.board = BoardShim(BoardIds.PLAYBACK_FILE_BOARD.value, self.params) def start_stream(self): self.board.prepare_session() #self.board.config_board ('loopback_true') self.board.config_board('old_timestamps') self.board.start_stream() def stop_stream(self): self.board.stop_stream() self.board.release_session() def poll(self, sample_num): try: while self.board.get_board_data_count() < sample_num: time.sleep(0.02) except Exception as e: raise (e) #print(self.board.get_board_data_count()) board_data = self.board.get_board_data() #df = board_2_df(np.transpose(board_data)) return board_data def sampling_frequency(self): sampling_freq = self.board.get_sampling_rate( BoardIds.CYTON_BOARD.value) return sampling_freq
def __init__(self, data_idx=101, board=None): self.data_idx = data_idx self.board_id = 2 self.eeg_channels = BoardShim.get_eeg_channels(self.board_id) self.ts_channels = BoardShim.get_timestamp_channel(self.board_id) sfreq = BoardShim.get_sampling_rate(self.board_id) self.freq = sfreq ch_types = [ 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg' ] ch_names = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P' ] self.info = mne.create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types) if board is not None: self.board = board else: params = BrainFlowInputParams() params.serial_port = "/dev/cu.usbserial-DM01MTXZ" board = BoardShim(self.board_id, params) self.board.prepare_session() self.board.start_stream()
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 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 __init__(self): BoardShim.enable_dev_board_logger() params = BrainFlowInputParams() params.serial_port = "/dev/ttyUSB0" self.board_id = BoardIds.CYTON_DAISY_BOARD.value self.sampling_rate = BoardShim.get_sampling_rate(self.board_id) self.board = BoardShim(self.board_id, params) self.player_is_playing = False self.positive_signal = True self.last_signal_delta = 0 self.metrics = {} self.channels = {}
def __init__( self, board_name: str, serial_port: str = "", mac_address: str = "", ip_address: str = "", ip_port: int = 0, ip_protocol: int = 0, other_info: str = "", timeout: int = 0, serial_number: str = "", board_file: str = "", ): self.board_name = board_name if not valid_boardname(board_name): raise BoardException( f"Invalid board name in config: {self.board_name}") else: self.board_id = BoardIds[self.board_name].value # Get and set vars with basic info about the board: self.sample_rate = BoardShim.get_sampling_rate(self.board_id) try: self.channel_names = BoardShim.get_eeg_names(self.board_id) except Exception: self.channel_names = [] self.channel_count = len(BoardShim.get_eeg_channels(self.board_id)) # Prepare the board params object: self.params = BrainFlowInputParams() # Load params into the object from init function args: self.params.serial_port = serial_port self.params.mac_address = mac_address self.params.ip_address = ip_address self.params.ip_port = ip_port self.params.ip_protocol = ip_protocol self.params.other_info = other_info self.params.timeout = timeout self.params.serial_number = serial_number self.params.file = board_file # Construct the board object: try: self.board = BoardShim(self.board_id, self.params) except Exception as e: raise BoardException( f"Failed to instantiate board object for {self.board_name}" + str(e)) # Initial values: self.is_ready = False self.is_recording = False # Self-check via our 'ping' function: self.ping()
def filter_data(self): """" Filters the current EEG data. Uses raw data from unfiltered_data array and updates the filtered_data array. """ # Subtract average from data self.filtered_data = self.unfiltered_data - self.eeg_average.compute_average() if self.eeg_average.count > 2 * self.config.window_size(): print("Clearing average...") self.eeg_average.reset() if self.notch_filter_checkbox.isChecked(): # Notch filter DataFilter.perform_bandstop\ (self.filtered_data, BoardShim.get_sampling_rate(global_config.BOARD_ID), self.config.notch_freq, 2, 4, FilterTypes.BUTTERWORTH.value, 0) # Bandpass filter band_width = self.config.bandpass_max_freq - self.config.bandpass_min_freq band_center = self.config.bandpass_min_freq + band_width / 2 DataFilter.perform_bandpass(self.filtered_data, BoardShim.get_sampling_rate(global_config.BOARD_ID), band_center, band_width, 4, FilterTypes.BUTTERWORTH.value, 0)
def __init__(self, video_path): self.windowName = "Neurofeedback" self.video_path = video_path self.audio_start_time_sec = time.time() BoardShim.enable_dev_board_logger() params = BrainFlowInputParams() params.serial_port = "/dev/ttyUSB0" self.board_id = BoardIds.CYTON_DAISY_BOARD.value self.sampling_rate = BoardShim.get_sampling_rate(self.board_id) self.board = BoardShim(self.board_id, params) self.player_is_playing = False self.positive_signal = True self.last_signal_delta = 0 self.signals = []
def eeg_signals(): #获取原始数据,根据采样率大小取出1s的数据 eeg_data = board.get_current_board_data(sampling_rate)[0:9] # 带通滤波处理(0.5-50),中心频率25.25,带宽49.5 eeg_channels = BoardShim.get_eeg_channels(0) for count, channel in enumerate(eeg_channels): eeg_data[channel] = eeg_data[channel] - np.average(eeg_data[channel]) DataFilter.perform_bandpass(eeg_data[channel], BoardShim.get_sampling_rate(2), 25.25, 49.5, 3, FilterTypes.BESSEL.value, 0) eeg_data = eeg_data[1:9] eeg_data = np.array([eeg_data]) pca = UnsupervisedSpatialFilter(PCA(8), average=False) eeg_data = pca.fit_transform(eeg_data) eeg_data = eeg_data[0] return eeg_data
def gen_EEG_wifi_LSL(lslname='eeg1A'): args = { "ip_port": 2190, "serial_port": "", "mac_address": "", "other_info": "", "serial_number": "", "ip_address": "192.168.4.1", #这个ip地址需要查看openbci板子的ip "ip_protocol": 2, "timeout": 0, "file": "", "log": True, "streamer_params": "", "board_id": -1, } args['board_id'] = 5 eegchannelsnums = 8 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.serial_number = args['serial_number'] params.ip_address = args['ip_address'] params.ip_protocol = args['ip_protocol'] params.timeout = args['timeout'] params.file = args['file'] # self.str.set("ss" + self.eegserialport) if (args['log']): BoardShim.enable_dev_board_logger() else: BoardShim.disable_board_logger() eegboard = BoardShim(args['board_id'], params) eegboard.prepare_session() # eegboard.config_board('~6') sample = eegboard.get_sampling_rate(eegboard.get_board_id()) #print('sample:',sample) eegboard.start_stream(45000, "") lslinfo = StreamInfo(lslname, 'EEG', eegchannelsnums, sample, 'float32', 'brain01') lsloutlet = StreamOutlet(lslinfo) sendeegThead = SendData(eegboard, lsloutlet) sendeegThead.start()
def prepare_data(): # use different windows, its kinda data augmentation window_sizes = [4.0, 6.0, 8.0, 10.0] overlaps = [0.5, 0.45, 0.4, 0.35] # percentage of window_size dataset_x = list() dataset_y = list() for data_type in ('relaxed', 'focused'): for file in glob.glob(os.path.join('data', data_type, '*', '*.csv')): print(file) board_id = os.path.basename(os.path.dirname(file)) try: board_id = int(board_id) data = DataFilter.read_file(file) sampling_rate = BoardShim.get_sampling_rate(board_id) eeg_channels = get_eeg_channels(board_id) for num, window_size in enumerate(window_sizes): if data_type == 'focused': cur_pos = sampling_rate * 10 # skip a little more for focus else: cur_pos = sampling_rate * 3 while cur_pos + int( window_size * sampling_rate) < data.shape[1]: data_in_window = data[:, cur_pos:cur_pos + int(window_size * sampling_rate)] bands = DataFilter.get_avg_band_powers( data_in_window, eeg_channels, sampling_rate, True) feature_vector = np.concatenate((bands[0], bands[1])) dataset_x.append(feature_vector) if data_type == 'relaxed': dataset_y.append(0) else: dataset_y.append(1) cur_pos = cur_pos + int( window_size * overlaps[num] * sampling_rate) except Exception as e: print(str(e)) print('Class 1: %d Class 0: %d' % (len([x for x in dataset_y if x == 1]), len([x for x in dataset_y if x == 0]))) with open('dataset_x.pickle', 'wb') as f: pickle.dump(dataset_x, f, protocol=3) with open('dataset_y.pickle', 'wb') as f: pickle.dump(dataset_y, f, protocol=3) return dataset_x, dataset_y
def main(): BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value sampling_rate = BoardShim.get_sampling_rate(board_id) 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_current_board_data( DataFilter.get_nearest_power_of_two(sampling_rate)) board.stop_stream() board.release_session() eeg_channels = BoardShim.get_eeg_channels(board_id) # demo for transforms for count, channel in enumerate(eeg_channels): print('Original data for channel %d:' % channel) print(data[channel]) # demo for wavelet transforms # wavelet_coeffs format is[A(J) D(J) D(J-1) ..... D(1)] where J is decomposition level, A - app coeffs, D - detailed coeffs # lengths array stores lengths for each block wavelet_coeffs, lengths = DataFilter.perform_wavelet_transform( data[channel], 'db5', 3) app_coefs = wavelet_coeffs[0:lengths[0]] detailed_coeffs_first_block = wavelet_coeffs[lengths[0]:lengths[1]] # you can do smth with wavelet coeffs here, for example denoising works via thresholds # for wavelets coefficients restored_data = DataFilter.perform_inverse_wavelet_transform( (wavelet_coeffs, lengths), data[channel].shape[0], 'db5', 3) print('Restored data after wavelet transform for channel %d:' % channel) print(restored_data) # demo for fft, len of data must be a power of 2 fft_data = DataFilter.perform_fft(data[channel], WindowFunctions.NO_WINDOW.value) # len of fft_data is N / 2 + 1 restored_fft_data = DataFilter.perform_ifft(fft_data) print('Restored data after fft for channel %d:' % channel) print(restored_fft_data)
def test(): if request.method == 'GET': # sample的存放地址 # data_path = 'C:\\Users\\zzzal\\Desktop\\' BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board = BoardShim(BoardIds.SYNTHETIC_BOARD.value, params) sampling = board.get_sampling_rate(BoardIds.SYNTHETIC_BOARD.value) board.prepare_session() board.start_stream() time.sleep(10) data = board.get_board_data() board.stop_stream() board.release_session() # eeg_channels = BoardShim.get_eeg_channels (BoardIds.SYNTHETIC_BOARD.value) eeg_channels = [1, 2, 3, 4, 5, 6, 7, 8] eeg_data = data[eeg_channels, :] eeg_data = eeg_data / 1000000 # BrainFlow returns uV, convert to V for MNE # time=data.values[0::,1] xtime = [i / sampling for i in range(eeg_data.shape[1])] xtime = np.array(xtime) xtime.astype(np.float32) i = len(xtime) - 1 while (i > 0): xtime[i] = xtime[i] - xtime[i - 1] i -= 1 i = 1 xtime[0] = 0 while (i < len(xtime)): xtime[i] += xtime[i - 1] i += 1 xtime = xtime.tolist() return render_template("chart.html", time=xtime, one=eeg_data[0].tolist(), two=eeg_data[1].tolist(), three=eeg_data[2].tolist(), four=eeg_data[3].tolist(), five=eeg_data[4].tolist(), six=eeg_data[5].tolist(), seven=eeg_data[6].tolist(), eight=eeg_data[7].tolist())
def main(): BoardShim.enable_board_logger() DataFilter.enable_data_logger() MLModel.enable_ml_logger() params = BrainFlowInputParams() board = BoardShim(BoardIds.BRAINBIT_BOARD.value, params) master_board_id = board.get_board_id() sampling_rate = BoardShim.get_sampling_rate(master_board_id) board.prepare_session() board.start_stream(45000, '') eeg_channels = BoardShim.get_eeg_channels(int(master_board_id)) while True: BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep( 5 ) # recommended window size for eeg metric calculation is at least 4 seconds, bigger is better data = board.get_board_data() bands = DataFilter.get_avg_band_powers(data, eeg_channels, sampling_rate, True) feature_vector = np.concatenate((bands[0], bands[1])) print(feature_vector) # calc concentration concentration_params = BrainFlowModelParams( BrainFlowMetrics.CONCENTRATION.value, BrainFlowClassifiers.KNN.value) concentration = MLModel(concentration_params) concentration.prepare() print('Concentration: %f' % concentration.predict(feature_vector)) concentration.release() # calc relaxation relaxation_params = BrainFlowModelParams( BrainFlowMetrics.RELAXATION.value, BrainFlowClassifiers.REGRESSION.value) relaxation = MLModel(relaxation_params) relaxation.prepare() print('Relaxation: %f' % relaxation.predict(feature_vector)) relaxation.release() board.stop_stream() board.release_session()
def __init__(self, board_shim): self.board_id = board_shim.get_board_id() self.board_shim = board_shim self.exg_channels = BoardShim.get_exg_channels(self.board_id) self.sampling_rate = BoardShim.get_sampling_rate(self.board_id) self.update_speed_ms = 50 self.window_size = 10 self.num_points = self.window_size * self.sampling_rate self.plot_names = [ 'Quality A2', 'Quality A1', 'Quality C4', 'Quality C3' ] self.mains = None self.app = QtGui.QApplication([]) self.win = pg.GraphicsWindow(title='Enophone Live Streaming', size=(800, 600)) self._init_timeseries() timer = QtCore.QTimer() timer.timeout.connect(self.update) timer.start(self.update_speed_ms) QtGui.QApplication.instance().exec_()
def resize_visible_window(self, visible_seconds: int, notify_listener=True): """" Change the size of the visible window """ print("Resizing window, new size = {} sec".format(visible_seconds)) new_window_size = visible_seconds * BoardShim.get_sampling_rate(global_config.BOARD_ID) current_window_size = self.unfiltered_data.shape[0] - self.INTERNAL_BUFFER_EXTRA_SIZE self.config.set_visible_seconds(visible_seconds, notify_owner=False, notify_listener=notify_listener) if new_window_size == current_window_size: return difference = int(abs(new_window_size - current_window_size)) if new_window_size > current_window_size: self.unfiltered_data = np.concatenate((np.zeros(difference), self.unfiltered_data)) else: self.unfiltered_data = self.unfiltered_data[difference:] self.filter_data()
def main(): BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value sampling_rate = BoardShim.get_sampling_rate(board_id) 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() eeg_channels = BoardShim.get_eeg_channels(board_id) bands = DataFilter.get_avg_band_powers(data, eeg_channels, sampling_rate, True) print("avg band powers : %s" % str(bands[0])) print("stddev band powers : %s" % str(bands[1]))
def __init__(self, board_shim): pg.setConfigOption('background', 'w') pg.setConfigOption('foreground', 'k') self.board_id = board_shim.get_board_id() self.board_shim = board_shim self.exg_channels = BoardShim.get_exg_channels(self.board_id) self.sampling_rate = BoardShim.get_sampling_rate(self.board_id) self.update_speed_ms = 50 self.window_size = 4 self.num_points = self.window_size * self.sampling_rate self.app = QtGui.QApplication([]) self.win = pg.GraphicsWindow(title='BrainFlow Plot',size=(800, 600)) self._init_pens() self._init_timeseries() self._init_psd() self._init_band_plot() timer = QtCore.QTimer() timer.timeout.connect(self.update) timer.start(self.update_speed_ms) QtGui.QApplication.instance().exec_()