def main (): parser = argparse.ArgumentParser () parser.add_argument ('--ip-address', type = str, help = 'ip address', required = True) parser.add_argument ('--ip-port', type = int, help = 'ip port', required = True) args = parser.parse_args () BoardShim.enable_dev_board_logger () params = BrainFlowInputParams () params.ip_address = args.ip_address; params.ip_port = args.ip_port; board = BoardShim (BoardIds.GANGLION_WIFI_BOARD.value, params) board.prepare_session () # 5 seconds of resistance data board.config_board ('z') board.start_stream (45000, 'file://raw_data_resistance.csv:w') time.sleep (5) data = board.get_board_data () board.stop_stream () # now get eeg data board.config_board ('Z') board.start_stream (45000, 'file://raw_data_eeg.csv:w') time.sleep (5) data = board.get_board_data () board.stop_stream () board.release_session () print (data)
def main(): BoardShim.enable_dev_board_logger() logging.basicConfig(level=logging.DEBUG) parser = argparse.ArgumentParser() parser.add_argument('--mac-address', type=str, help='mac address', required=False, default='') args = parser.parse_args() params = BrainFlowInputParams() params.mac_address = args.mac_address try: board_shim = BoardShim(BoardIds.ENOPHONE_BOARD, params) board_shim.prepare_session() board_shim.start_stream(450000, '') Graph(board_shim) except BaseException: logging.warning('Exception', exc_info=True) finally: logging.info('End') if board_shim.is_prepared(): logging.info('Releasing session') board_shim.release_session()
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
class BrainbitReader: def __init__(self): # Establish all parameters for Brainflow self.params = BrainFlowInputParams() # Assign the BrainBit as the board self.params.board_id = 7 # set it logging BoardShim.enable_dev_board_logger() print('BrainBit reader ready') def start(self): # instantiate the board reading self.board = BoardShim(self.params.board_id, self.params) self.board.prepare_session() # board.start_stream () # use this for default options self.board.start_stream(2) # removed 48000 print('BrainBit stream started') def read(self): self.data = self.board.get_board_data( ) # get all data and remove it from internal buffer return self.data def terminate(self): self.board.stop_stream() self.board.release_session()
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 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 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)
class Capture(): # boardID = 1 for ganglion # serialPort : https://brainflow.readthedocs.io/en/stable/SupportedBoards.html#ganglion def __init__(self, boardID, serial_port): self.serial_port = serial_port params = BrainFlowInputParams() params.serial_port = serial_port BoardShim.disable_board_logger () self.board = BoardShim (boardID, params) self.board.prepare_session() def startStream(self): self.board.start_stream() # so given this many seconds it will try to get num_samples of data # if seconds is too small, num_samples returned won't be enough def getData(self, num_seconds, num_samples): time.sleep(num_seconds) # data = self.board.get_current_board_data (num_samples) data = self.board.get_board_data()[:190] # gets 0,1,2 channel. ignore 4 b/c noise data return np.array([data[1], data[2], data[3]]) def closeStream(self): self.board.stop_stream() self.board.release_session()
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
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(): app = QApplication([]) app.setStyle(global_config.APP_STYLE) BoardShim.enable_board_logger() BoardShim.enable_dev_board_logger() params = BrainFlowInputParams() params.serial_port = utils.cyton_port() board = BoardShim(global_config.BOARD_ID, params) # Switch to using white background and black foreground pg.setConfigOption('background', 'w') pg.setConfigOption('foreground', 'k') window = MainWindow(app, board=board, screen_width=app.primaryScreen().size().width(), channel_count=6) window.show() board.prepare_session() app.exec() print("Release session") board.release_session()
def main(): BoardShim.enable_dev_board_logger() parser = argparse.ArgumentParser() parser.add_argument('--serial-port', type=str, help='serial port', required=True) args = parser.parse_args() params = BrainFlowInputParams() params.serial_port = args.serial_port board = BoardShim(BoardIds.CYTON_BOARD, params) try: board.prepare_session() resp = board.config_board('?') print(resp) # check that there is a response if streaming is off if not resp: raise ValueError('resp is None') board.start_stream() time.sleep(5) resp = board.config_board('?') print(resp) # check that there is no response if streaming is on if resp: raise ValueError('resp is not None') finally: if board.is_prepared(): board.release_session()
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, 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 main(): BoardShim.enable_dev_board_logger() # use my board for demo params = BrainFlowInputParams() params.serial_port = '/dev/ttyUSB0' board = BoardShim(BoardIds.CYTON_BOARD.value, params) board.prepare_session() # some question 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 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(BoardIds.CYTON_DAISY_BOARD.value) print(data.shape) print(data[0]) print(data[1]) print(type(data[1, 0])) #df = pd.DataFrame(np.transpose(data)) #df = pd.DataFrame(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() np.savetxt("foo3.csv", np.transpose(data), fmt='%10.7f', delimiter=",")
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_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(): BoardShim.enable_dev_board_logger() params = BrainFlowInputParams() board = BoardShim(BoardIds.SYNTHETIC_BOARD.value, params) board.prepare_session() board.start_stream(450000, 'streaming_board://225.1.1.1:6677') run_test(sys.argv[1:]) board.stop_stream() board.release_session()
def run_livestream(params, args): try: board_shim = BoardShim(args.board_id, params) board_shim.prepare_session() board_shim.start_stream(4500000, args.streamer_params) g = Graph(board_shim) except BaseException as e: logging.warning('Exception', exc_info=True) finally: logging.info('End') if board_shim.is_prepared(): logging.info('Releasing session') board_shim.release_session()
class OpenBCIInterface: def __init__(self, serial_port='COM7', board_id=2, 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 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') try: self.board.start_stream(self.ring_buffer_size, self.streamer_params) 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 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') 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 () board.start_stream () print('Session Started') for x in range(2): time.sleep (5) board.config_board ('/2') # enable analog mode only for Cyton Based Boards! time.sleep (5) data = board.get_board_data () board.stop_stream () board.release_session () """ data[BoardShim.get_other_channels(args.board_id)[0]] contains cyton end byte data[BoardShim.get_other_channels(args.board_id)[1....]] contains unprocessed bytes if end byte is 0xC0 there are accel data in data[BoardShim.get_accel_channels(args.board_id)[....]] else there are zeros if end byte is 0xC1 there are analog data in data[BoardShim.get_analog_channels(args.board_id)[....]] else there are zeros """ print (data[BoardShim.get_other_channels(args.board_id)[0]][0:5]) # should be standard end byte 0xC0 print (data[BoardShim.get_other_channels(args.board_id)[0]][-5:]) # should be analog and byte 0xC1 DataFilter.write_file (data, 'cyton_data_new.txt', 'w')
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 ('--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 ('--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.serial_number = args.serial_number params.ip_address = args.ip_address params.ip_protocol = args.ip_protocol params.timeout = args.timeout BoardShim.enable_dev_board_logger () 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 (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 (): 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() params = BrainFlowInputParams() board = BoardShim(BoardIds.MUSE_S_BOARD, params) board.prepare_session() board.config_board('p61') board.start_stream(45000, 'file://data.csv:w') time.sleep(10) data = board.get_board_data() board.stop_stream() board.release_session() print(data)
def recordData(serial_port, board_id=0, samples=500): params = BrainFlowInputParams() params.serial_port = serial_port board = BoardShim(board_id, params) board.prepare_session() board.start_stream(samples + 1) time.sleep(2.5) data = board.get_board_data() board.stop_stream() board.release_session() data = data[:7].T return data
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')
class SensorWrapper: BoardShim.enable_dev_board_logger() params = BrainFlowInputParams() board_id = None board = None channels_idx = None buffer = None sensor_settings: SensorSettings = None rx_sensor_settings_subject_subscription: Disposable = None def __init__(self, rx_sensor_settings_subject: BehaviorSubject): self.sensor_settings = rx_sensor_settings_subject.value self.rx_sensor_settings_subject_subscription = rx_sensor_settings_subject.subscribe(self.set_sensor_settings) if self.sensor_settings.simulation: self.board_id = BoardIds.SYNTHETIC_BOARD.value else: self.board_id = BoardIds.CYTON_BOARD.value self.params.serial_port = self.sensor_settings.sensor_com_port self.board = BoardShim(self.board_id, self.params) self.channels_idx = BoardShim.get_emg_channels(self.board_id) self.buffer = np.empty([0, NUM_CHANNELS]) self.board.prepare_session() self.board.start_stream() def set_sensor_settings(self, sensor_settings: SensorSettings): self.sensor_settings = sensor_settings def disconnect(self): self.board.stop_stream() self.board.release_session() self.rx_sensor_settings_subject_subscription.dispose() def read(self): data = self.board.get_board_data().transpose()[:, self.channels_idx] self.buffer = np.concatenate((self.buffer, data), axis=0) def read_filtered(self): self.read() if self.buffer.shape[0] < MIN_READ_BUFFER_DEPTH: return None read_matrix = np.asmatrix(self.buffer) self.buffer = np.empty([0, NUM_CHANNELS]) if self.sensor_settings.notch_filter: read_matrix = np.apply_along_axis(notch, 0, read_matrix, val=self.sensor_settings.notch_frequency)[0] if self.sensor_settings.bandpass_filter: read_matrix = np.apply_along_axis(bandpass, 0, read_matrix, start=self.sensor_settings.bandpass_low_frequency, stop=self.sensor_settings.bandpass_high_frequency) return read_matrix
def main (): parser = argparse.ArgumentParser () # use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port # https://brainflow.readthedocs.io/en/stable/SupportedBoards.html#supported-boards-label # board_id: 1 # serial_port field of BrainFlowInputParams structure # mac_address field of BrainFlowInputParams structure, if its empty BrainFlow will try to autodiscover Ganglion # optional: timeout field of BrainFlowInputParams structure, default is 15sec 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 = '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 params.timeout = args.timeout if (args.log): BoardShim.enable_dev_board_logger () else: BoardShim.disable_board_logger () board = BoardShim (args.board_id, params) board.prepare_session () # board.start_stream () # use this for default options board.start_stream (45000, args.streamer_params) # time.sleep (1) # 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 () print (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)