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 _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 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')
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 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() BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep(10) data = board.get_current_board_data( 20) # get 20 latest data points dont remove them from internal buffer board.stop_stream() board.release_session() eeg_channels = BoardShim.get_eeg_channels(BoardIds.SYNTHETIC_BOARD.value) # demo for downsampling, it just aggregates data for count, channel in enumerate(eeg_channels): print('Original data for channel %d:' % channel) print(data[channel]) if count == 0: downsampled_data = DataFilter.perform_downsampling( data[channel], 3, AggOperations.MEDIAN.value) elif count == 1: downsampled_data = DataFilter.perform_downsampling( data[channel], 2, AggOperations.MEAN.value) else: downsampled_data = DataFilter.perform_downsampling( data[channel], 2, AggOperations.EACH.value) print('Downsampled data for channel %d:' % channel) print(downsampled_data)
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(self): self.board.prepare_session() self.board.start_stream() try: nfft = DataFilter.get_nearest_power_of_two(self.sampling_rate) eeg_channels = BoardShim.get_eeg_channels(self.board_id) time.sleep(3) signals = [] cv2_thread = threading.Thread(target=self.cv2_video_read_thread) audio_thread = threading.Thread(target=self.audio_thread) cv2_thread.start() audio_thread.start() self.player_is_playing = True while self.player_is_playing: signals.append(self.on_next(eeg_channels, nfft)) if len(signals) > 3: signals.pop(0) avg_signal = sum(signals) / len(signals) self.positive_signal = avg_signal < signals[-1] self.last_signal_delta = abs(avg_signal - signals[-1]) if signals[-1] > 9: # min positive signals self.positive_signal = True print( f'up {self.last_signal_delta}' if avg_signal < signals[-1] else f'down {self.last_signal_delta}') # enable it later audio_thread.join() cv2_thread.join() except Exception as e: print(e) return
def main(self): self.board.prepare_session() self.board.start_stream() try: nfft = DataFilter.get_nearest_power_of_two(self.sampling_rate) eeg_channels = BoardShim.get_eeg_channels(self.board_id) time.sleep(3) cv2_thread = threading.Thread(target=self.cv2_video_thread) audio_thread = threading.Thread(target=self.audio_thread) cv2_thread.start() audio_thread.start() self.player_is_playing = True signal_freq_coeff = 1.1 # auto adjustable coefficient? high_signal_freq_coeff = 1.5 data_log_file = open(f'log2-{time.time()}.csv', 'a') print_bands = [] for channel in self.channels.keys(): print_bands.append(','.join( [b.name for b in self.channels[channel]])) data_log_file.write( f'time,metrics_sum,signal,high_signal,{",".join(print_bands)}') metrics_hist = [] while self.player_is_playing: time.sleep(.3) self.on_next(eeg_channels, nfft) metrics_sum = 0.0 for metric in self.metrics: metrics_sum += metric.get_metric() metrics_hist.append(metrics_sum) if len(metrics_hist) > 50: metrics_hist.pop(0) avg_metrics_hist = sum(metrics_hist) / len(metrics_hist) self.positive_signal = avg_metrics_hist < metrics_sum * signal_freq_coeff self.is_last_signal_delta_high = False if self.positive_signal and avg_metrics_hist < metrics_sum * high_signal_freq_coeff: self.is_last_signal_delta_high = True print( f'{self.positive_signal} {avg_metrics_hist} < {metrics_sum*signal_freq_coeff}' ) print_bands = [] for channel in self.channels.keys(): print_bands.append(','.join([ str(b.band_current_power) for b in self.channels[channel] ])) log_line = f'\n{time.asctime(time.gmtime(time.time()))},{metrics_sum},{self.positive_signal},{self.is_last_signal_delta_high},{",".join(print_bands)}' data_log_file.write(log_line) data_log_file.close() audio_thread.join() cv2_thread.join() except Exception as e: print(e) self.player_is_playing = False return
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 ()
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 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 () BoardShim.log_message (LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep (10) data = board.get_current_board_data (20) # get 20 latest data points dont remove them 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 (BoardIds.SYNTHETIC_BOARD.value) df = pd.DataFrame (np.transpose (data)) print ('Data From the Board') print (df.head (10)) # demo for data serialization using brainflow API, we recommend to use it instead pandas.to_csv() DataFilter.write_file (data, 'test.csv', 'w') # use 'a' for append mode restored_data = DataFilter.read_file ('test.csv') restored_df = pd.DataFrame (np.transpose (restored_data)) print ('Data From the File') print (restored_df.head (10))
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 getEGG_Data(self): self.__board.stop_stream() data = self.__board.get_board_data() eeg_channels = BoardShim.get_eeg_channels(self.__board_ID) eeg_data = data[eeg_channels] return eeg_data
def main(self): self.board.prepare_session() self.board.start_stream() try: nfft = DataFilter.get_nearest_power_of_two(self.sampling_rate) eeg_channels = BoardShim.get_eeg_channels(self.board_id) time.sleep(3) cv2_thread = threading.Thread(target=self.cv2_video_thread) audio_thread = threading.Thread(target=self.audio_thread) cv2_thread.start() audio_thread.start() self.player_is_playing = True signal_freq_coeff = .5 # auto adjustable coefficient? high_signal_freq_coeff = .15 data_log_file = open(f'log-{time.time()}.csv', 'a') while self.player_is_playing: time.sleep(.1) bands_signals = self.on_next(eeg_channels, nfft) positive_signals_sum = 0.0 negative_signals_sum = 0.0 for i in bands_signals.keys(): if bands_signals[i] > 0: positive_signals_sum += bands_signals[i] else: negative_signals_sum += bands_signals[i] self.positive_signal = abs( negative_signals_sum ) < positive_signals_sum * signal_freq_coeff self.is_last_signal_delta_high = False if self.positive_signal and positive_signals_sum * high_signal_freq_coeff > abs( negative_signals_sum): self.is_last_signal_delta_high = True print_bands = [] for proto in self.protocol: print_bands.append( f'{eeg_channels[proto.channel_inx]},' + ",".join( [str(b.band_current_power) for b in proto.bands])) log_line = f'\n{time.asctime(time.gmtime(time.time()))},{positive_signals_sum},{negative_signals_sum},{self.positive_signal},{self.is_last_signal_delta_high},{",".join(print_bands)}' data_log_file.write(log_line) data_log_file.close() audio_thread.join() cv2_thread.join() except Exception as e: print(e) self.player_is_playing = False return
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 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 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(20) 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') # demo for denoising, apply different methods to different channels for demo for count, channel in enumerate(eeg_channels): # first of all you can try simple moving median or moving average with different window size if count == 0: DataFilter.perform_rolling_filter(data[channel], 3, AggOperations.MEAN.value) elif count == 1: DataFilter.perform_rolling_filter(data[channel], 3, AggOperations.MEDIAN.value) # if methods above dont work for your signal you can try wavelet based denoising # feel free to try different functions and decomposition levels elif count == 2: DataFilter.perform_wavelet_denoising(data[channel], 'db6', 3) elif count == 3: DataFilter.perform_wavelet_denoising(data[channel], 'bior3.9', 3) elif count == 4: DataFilter.perform_wavelet_denoising(data[channel], 'sym7', 3) elif count == 5: # with synthetic board this one looks like the best option, but it depends on many circumstances DataFilter.perform_wavelet_denoising(data[channel], 'coif3', 3) df = pd.DataFrame(np.transpose(data)) plt.figure() df[eeg_channels].plot(subplots=True) plt.savefig('after_processing.png')
def get_eeg_channels(board_id): eeg_channels = BoardShim.get_eeg_channels(board_id) # optional: filter some channels we dont want to consider try: eeg_names = BoardShim.get_eeg_names(board_id) selected_channels = list() # blacklisted_channels = {'O1', 'O2'} blacklisted_channels = set() for i, channel in enumerate(eeg_names): if not channel in blacklisted_channels: selected_channels.append(eeg_channels[i]) eeg_channels = selected_channels except Exception as e: print(str(e)) print('channels to use: %s' % str(eeg_channels)) return eeg_channels
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 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 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 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 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 main(i): board_id = BoardIds.SYNTHETIC_BOARD.value eeg_channels = BoardShim.get_eeg_channels(board_id) timestamp = BoardShim.get_timestamp_channel(board_id) style.use('fivethirtyeight') plt.title("Live EEG Datastream from Brainflow", fontsize=15) plt.ylabel("Data in millivolts", fontsize=15) plt.xlabel("\nTime", fontsize=10) data = DataFilter.read_file('data.csv') eegdf = pd.DataFrame(np.transpose(data[eeg_channels, timestamp])) #timedf = pd.DataFrame(np.transpose(data[timestamp])) #to keep it simple, making another dataframe for the timestamps to access later eegdf_col_names = ["ch1","ch2","ch3","ch4","ch5","ch6","ch7","ch8","ch9","ch10","ch11","ch12","ch13","ch14","ch15","ch16"] eegdf.columns = eegdf_col_names print("EEG Dataframe") print(eegdf) #easy way to check what data is being streamed and if program is working #print(eegdf) eeg1 = eegdf.iloc[:, 0].values #I am using OpenBCI Ganglion board, so only have four channels. eeg2 = eegdf.iloc[:, 1].values eeg3 = eegdf.iloc[:, 2].values eeg4 = eegdf.iloc[:, 3].values timex= eegdf.iloc[:, 15].values #timestamps #print(timex) #use this to see what the UNIX timestamps look like print("EEG Channel 1") print(eeg1) #print("Time DF") #print(timedf) print("Timestamp") print(timex) """plt.cla()
def main(): ''' Connect to the Brainstorm ''' # Authentication username = '******' password = '' ## Set Connection Details # brainstorm = brainsatplay.Brainstorm('https://localhost') # Local brainstorm = brainsatplay.Brainstorm() # Deployed Server ## Connect res = brainstorm.connect(username, password) # All optional (defaults to guest) ''' Subscribe to a Particular Game ''' # # Connection Settings # appname = 'brainstorm' # devices = [] # props = ['raw','times','sps','deviceType','format','eegChannelTags'] # sessionid = None # spectating = False # Spectate to view data without sending it # res = brainstorm.getSessions(appname) # if res['msg'] != 'appNotFound': # sessionid = res['sessions'][0]['id'] # else: # res = brainstorm.createSession(appname, devices, props) # sessionid = res['sessionInfo']['id'] # # Handle Data from Subscribed Games # def newData(json): # for user in json['userData']: # name = user['username'] # print('Data for {}'.format(name)) # res = brainstorm.subscribeToSession(sessionid,spectating, newData) ''' Stream your Data ''' # Setup Brainflow 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.eeg_names = BoardShim.get_eeg_names(board_id) board.prepare_session() board.start_stream(num_samples=450000) # Handle CTRL-C Exit def onStop(): board.stop_stream() board.release_session() loopCount = 0 # Start Stream Loop def streamLoop(): pass_data = [] rate = DataFilter.get_nearest_power_of_two(board.rate) data = board.get_board_data() t = data[board.time_channel] data = data[board.eeg_channels] for entry in data: pass_data.append((entry).tolist()) data = {} data['raw'] = pass_data data['times'] = t.tolist() # Send Metadata on First Loop if loopCount == 0: data['sps'] = board.rate data['deviceType'] = 'eeg' data['format'] = 'brainflow' tags = [] for i, channel in enumerate(board.eeg_channels): tags.append({ 'ch': channel - 1, 'tag': board.eeg_names[i], 'analyze': True }) data['eegChannelTags'] = tags return data res = brainstorm.startStream(streamLoop, onStop)
def __init__(self, board, board_id): threading.Thread.__init__(self) self.eeg_channels = BoardShim.get_eeg_channels(board_id) self.sampling_rate = BoardShim.get_sampling_rate(board_id) self.keep_alive = True self.board = board
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('--streamer-params', 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') parser.add_argument('--run-time', type=int, help='run time in sec', required=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() # for streaming board need to use master board id master_board_id = args.board_id if args.board_id == BoardIds.STREAMING_BOARD.value: master_board_id = int(params.other_info) board = BoardShim(args.board_id, params) board.prepare_session() buffer_size = int( BoardShim.get_sampling_rate(master_board_id) * args.run_time * 1.2) # + 20% for safety board.start_stream(buffer_size, args.streamer_params) time.sleep(args.run_time) board.stop_stream() data = board.get_board_data() board.release_session() if master_board_id in (BoardIds.CYTON_BOARD.value, BoardIds.CYTON_WIFI_BOARD.value, BoardIds.GANGLION_WIFI_BOARD.value): bytes_per_package = 33 elif master_board_id in (BoardIds.CYTON_DAISY_BOARD, BoardIds.CYTON_DAISY_WIFI_BOARD.value): bytes_per_package = 66 elif master_board_id == BoardIds.SYNTHETIC_BOARD.value: bytes_per_package = 104 elif master_board_id == BoardIds.NOVAXR_BOARD.value: bytes_per_package = 72 else: raise ValueError('unsupported board') total_bytes_received = bytes_per_package * data.shape[1] packages_per_sec = float(data.shape[1]) / float(args.run_time) timestamp_channel = BoardShim.get_timestamp_channel(master_board_id) timestamp_array = data[timestamp_channel] time_diff_array = list() for i in range(0, timestamp_array.size - 1): time_diff_array.append(timestamp_array[i + 1] - timestamp_array[i]) package_num_channel = BoardShim.get_package_num_channel(master_board_id) package_num_array = data[package_num_channel] lost_packages = 0 expected = 0 cur_id = 0 while cur_id < package_num_array.size: if expected == 256: expected = 0 if package_num_array[cur_id] != expected: BoardShim.log_message( LogLevels.LEVEL_WARN.value, 'package loss detected: position %d package_num value %d expected value %d' % (cur_id, package_num_array[cur_id], expected)) lost_packages = lost_packages + 1 else: cur_id = cur_id + 1 expected = expected + 1 package_loss = (lost_packages / data.shape[1]) * 100 BoardShim.log_message(LogLevels.LEVEL_INFO.value, '\nResults:\n') BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'package loss percent %f' % package_loss) BoardShim.log_message( LogLevels.LEVEL_INFO.value, 'average time delta %f' % statistics.mean(time_diff_array)) BoardShim.log_message( LogLevels.LEVEL_INFO.value, 'std deviation of time delta %f' % statistics.pstdev(time_diff_array)) BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'total packages received %d' % data.shape[1]) BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'packages per sec %f' % packages_per_sec) BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'total bytes received %d' % total_bytes_received) eeg_channels = BoardShim.get_eeg_channels(master_board_id) emg_channels = BoardShim.get_emg_channels(master_board_id) total_channels = eeg_channels # for cyton/ganglion eeg_channels and emg_channels are the same array because we can not split it # for novaxr its 2 different arrays, join them for ch in emg_channels: if ch not in total_channels: total_channels.append(ch) df = pd.DataFrame(np.transpose(data)) df[total_channels].to_csv('eeg_emg_data.csv') df.to_csv('all_data.csv') plt.figure() df[total_channels].plot(subplots=True) plt.show()
class OpenBCIInterface: def __init__(self, serial_port='COM5', board_id=0, log='store_true', streamer_params='', ring_buffer_size=45000): # default board_id 2 for Cyton params = BrainFlowInputParams() params.serial_port = serial_port params.ip_port = 0 params.mac_address = '' params.other_info = '' params.serial_number = '' params.ip_address = '' params.ip_protocol = 0 params.timeout = 0 params.file = '' self.streamer_params = streamer_params self.ring_buffer_size = ring_buffer_size self.board_id = board_id self.info_eeg = None self.info_aux = None self.outlet_eeg = None self.outlet_aux = None if (log): BoardShim.enable_dev_board_logger() else: BoardShim.disable_board_logger() self.board = BoardShim(board_id, params) def start_sensor(self): # tell the sensor to start sending frames self.board.prepare_session() print('OpenBCIInterface: connected to sensor') print(self.board.get_board_id()) try: self.board.start_stream(self.ring_buffer_size, self.streamer_params) self.infor_test() except brainflow.board_shim.BrainFlowError: print('OpenBCIInterface: Board is not ready.') def process_frames(self): # return one or more frames of the sensor frames = self.board.get_board_data() return frames def stop_sensor(self): try: self.board.stop_stream() print('OpenBCIInterface: stopped streaming.') self.board.release_session() print('OpenBCIInterface: released session.') except brainflow.board_shim.BrainFlowError as e: print(e) def create_lsl(self, name='OpenBCI_Cyton_8', type='EEG', channel_count=8, nominal_srate=250.0, channel_format='float32', source_id='Cyton_0'): self.info_eeg = StreamInfo(name=name, type=type, channel_count=channel_count, nominal_srate=nominal_srate, channel_format=channel_format, source_id='') chns = self.info_eeg.desc().append_child('channels') self.labels = ['Fp1', 'Fp2', 'C3', 'C4', 'T5', 'T6', 'O1', 'O2'] for label in self.labels: ch = chns.append_child("channel") ch.append_child_value('label', label) ch.append_child_value('unit', 'microvolts') ch.append_child_value('type', 'EEG') self.info_eeg.desc().append_child_value('manufacturer', 'OpenBCI Inc.') self.outlet_eeg = StreamOutlet(self.info_eeg) print("--------------------------------------\n" + \ "LSL Configuration: \n" + \ " Stream 1: \n" + \ " Name: " + name + " \n" + \ " Type: " + type + " \n" + \ " Channel Count: " + str(channel_count) + "\n" + \ " Sampling Rate: " + str(nominal_srate) + "\n" + \ " Channel Format: " + channel_format + " \n" + \ " Source Id: " + source_id + " \n") def push_sample(self, samples): self.outlet_eeg.push_sample(samples) def infor_test(self): print(self.board.get_eeg_names(self.board_id)) print(self.board.get_sampling_rate(self.board_id)) print(self.board.get_board_id()) print(self.board.get_package_num_channel(self.board_id)) print(self.board.get_timestamp_channel(self.board_id)) print(self.board.get_eeg_channels(self.board_id)) print(self.board.get_accel_channels(self.board_id)) print(self.board.get_marker_channel(self.board_id)) print(self.board.get_other_channels(self.board_id)) print(self.board.get_analog_channels(self.board_id)) print(self.board.get_other_channels(self.board_id))
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('--streamer-params', 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') parser.add_argument('--run-time', type=int, help='run time for one iteration in sec', required=True) parser.add_argument('--num-iters', type=int, help='number of iterations', default=1) parser.add_argument( '--channels', type=str, help='channels to plot in format 0,1,2 by default plot all channels', default=None) parser.add_argument('--config-file', type=str, help='file with strings to send to device', default=None) 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() # for streaming board need to use master board id master_board_id = args.board_id if args.board_id == BoardIds.STREAMING_BOARD.value: master_board_id = int(params.other_info) board = BoardShim(args.board_id, params) board.prepare_session() if args.config_file: with open(args.config_file) as file: lines = file.readlines() for line in lines: board.config_board(line) buffer_size = int( BoardShim.get_sampling_rate(master_board_id) * args.run_time * 1.2) # + 20% for safety if master_board_id in (BoardIds.CYTON_BOARD.value, BoardIds.CYTON_WIFI_BOARD.value, BoardIds.GANGLION_WIFI_BOARD.value): bytes_per_package = 33 elif master_board_id in (BoardIds.CYTON_DAISY_BOARD, BoardIds.CYTON_DAISY_WIFI_BOARD.value): bytes_per_package = 66 elif master_board_id == BoardIds.SYNTHETIC_BOARD.value: bytes_per_package = 104 elif master_board_id == BoardIds.NOVAXR_BOARD.value: bytes_per_package = 72 else: raise ValueError('unsupported board') timestamp_channel = BoardShim.get_timestamp_channel(master_board_id) package_num_channel = BoardShim.get_package_num_channel(master_board_id) try: cur_id = 0 for i in range(args.num_iters): # wait for an input input('Press Enter to continue...') BoardShim.log_message( LogLevels.LEVEL_INFO.value, '\nRunning iteration %d/%d\n' % (i, args.num_iters)) # start stream and get data board.start_stream(buffer_size, args.streamer_params) time.sleep(args.run_time) board.stop_stream() data = board.get_board_data() if data.shape[1] == 0: BoardShim.log_message(LogLevels.LEVEL_WARN.value, '\nNo data received!\n') continue # calculate some metrics total_bytes_received = bytes_per_package * data.shape[1] packages_per_sec = float(data.shape[1]) / float(args.run_time) timestamp_array = data[timestamp_channel] time_diff_array = list() for i in range(0, timestamp_array.size - 1): time_diff_array.append(timestamp_array[i + 1] - timestamp_array[i]) package_num_array = data[package_num_channel] lost_packages = 0 expected = package_num_array[0] while cur_id < package_num_array.size: if expected == 256: expected = 0 if package_num_array[cur_id] != expected: BoardShim.log_message( LogLevels.LEVEL_WARN.value, 'package loss detected: position %d package_num value %d expected value %d' % (cur_id, package_num_array[cur_id], expected)) lost_packages = lost_packages + 1 else: cur_id = cur_id + 1 expected = expected + 1 package_loss = (lost_packages / data.shape[1]) * 100 # provide results for iteration BoardShim.log_message(LogLevels.LEVEL_INFO.value, '\nResults:\n') BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'package loss percent %f' % package_loss) BoardShim.log_message( LogLevels.LEVEL_INFO.value, 'average time delta %f' % statistics.mean(time_diff_array)) BoardShim.log_message( LogLevels.LEVEL_INFO.value, 'std deviation of time delta %f' % statistics.pstdev(time_diff_array)) BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'total packages received %d' % data.shape[1]) BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'packages per sec %f' % packages_per_sec) BoardShim.log_message( LogLevels.LEVEL_INFO.value, 'total bytes received %d' % total_bytes_received) # plot data eeg_channels = BoardShim.get_eeg_channels(master_board_id) emg_channels = BoardShim.get_emg_channels(master_board_id) total_channels = list() if args.channels is not None: selected_channels = [int(x) for x in args.channels.split(',')] temp_channels = eeg_channels for ch in emg_channels: if ch not in temp_channels: temp_channels.append(ch) for i in range(len(temp_channels)): if i in selected_channels: total_channels.append(temp_channels[i]) else: # for cyton/ganglion eeg_channels and emg_channels are the same array because we can not split it # for novaxr its 2 different arrays, join them total_channels = eeg_channels for ch in emg_channels: if ch not in total_channels: total_channels.append(ch) total_channels.append(timestamp_channel) columns = list() for i in range(len(total_channels) - 1): columns.append('channel_%d' % (int(total_channels[i]) - 1)) columns.append('timestamp') df = pd.DataFrame(np.transpose(data)) df.to_csv('all_data_%d.csv' % i) df_to_plot = df[total_channels] df_to_plot.columns = columns df_to_plot.to_csv('selected_data_%d.csv' % i) df_to_plot.plot(subplots=True, x='timestamp', style='.-') plt.show() finally: # release session in the end board.release_session()