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() 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 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() 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(): 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 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 __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 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 () 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) 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 board = BoardShim (args.board_id, params) sampling_rate = BoardShim.get_sampling_rate (args.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 (args.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.REGRESSION.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): 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, channels_order: List[str] = None, board_type: str = "cyton-daisy", name: Optional[str] = None, output_path: str = "output", serial_port=None): self.channels = channels_order if board_type == "cyton-daisy": device_id = 2 sampling_rate = 125 if self.channels is None: self.channels = \ ["ch1", "ch2", "ch3", "ch4", "ch5", "ch6", "ch7", "ch8", "ch9", "ch10", "ch11", "ch12", "ch13", "ch14", "ch15", "ch16"] if len(self.channels) != 16: raise RuntimeError( "The number of channels in channels_order should be 16") elif board_type == "cyton": device_id = 0 sampling_rate = 250 self.channels = \ ["ch1", "ch2", "ch3", "ch4", "ch5", "ch6", "ch7", "ch8"] if len(self.channels) != 8: raise RuntimeError( "The number of channels in channels_order should be 8") elif board_type == "Ganglion": device_id = 1 sampling_rate = 200 self.channels = \ ["ch1", "ch2", "ch3", "ch4"] if len(self.channels) != 4: raise RuntimeError( "The number of channels in channels_order should be 4") else: raise RuntimeError("Use BrainflowStreaming fr other boards") if serial_port is None: if platform.system() == "Linux": serial_port = "/dev/ttyUSB0" elif platform.system() == "Windows": serial_port = "Com3" else: serial_port = "/dev/cu.*" params = BrainFlowInputParams() params.serial_port = serial_port super().__init__(device_id, sampling_rate, brain_flow_input_params=params, name=name, output_path=output_path)
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 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 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 = 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 connect_board(self): self.params = BrainFlowInputParams() self.params.ip_port = 0 self.params.ip_protocol = 0 self.params.timeout = 0 self.params.serial_port = self.serial_port self.board = BoardShim(self.board_id, self.params)
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 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) 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 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 __init__(self, stream_name='OpenBCI_Cyton_8', stream_type='EEG', serial_port='COM5', board_id="0", log='store_true', streamer_params='', ring_buffer_size=45000): # default board_id 2 for Cyton self.params = BrainFlowInputParams() self.params.serial_port = serial_port self.params.ip_port = 0 self.params.mac_address = '' self.params.other_info = '' self.params.serial_number = '' self.params.ip_address = '' self.params.ip_protocol = 0 self.params.timeout = 0 self.params.file = '' self.stream_name = stream_name self.stream_type = stream_type self.board_id = int(board_id) self.streamer_params = streamer_params self.ring_buffer_size = ring_buffer_size if (log): BoardShim.enable_dev_board_logger() else: BoardShim.disable_board_logger() try: self.board = BoardShim(self.board_id, self.params) self.info_print() except brainflow.board_shim.BrainFlowError: print('Cannot connect to board')
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 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 __init__(self, serial_port): self.params = BrainFlowInputParams() if serial_port: self.params.serial_port = serial_port self.board = BoardShim(BoardIds.CYTON_BOARD.value, self.params) else: self.board = BoardShim(BoardIds.PLAYBACK_FILE_BOARD.value, self.params) self.params.file = '' self.params.other_info=BoardShim(BoardIds.CYTON_BOARD.value, self.params)
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 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 (10) # data = board.get_current_board_data (256) # get latest 256 packages or less, doesnt remove them from internal buffer data = board.get_board_data () # get all data and remove it from internal buffer board.stop_stream () board.release_session () print (data)
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 __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 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(): BoardShim.enable_dev_board_logger() params1 = BrainFlowInputParams() params1.other_info = 'board1' board_id = BoardIds.SYNTHETIC_BOARD.value params2 = BrainFlowInputParams() params2.other_info = 'board2' board1 = BoardShim(board_id, params1) board1.prepare_session() board2 = BoardShim(board_id, params2) board2.prepare_session() BoardShim.release_all_sessions() ml_params1 = BrainFlowModelParams(BrainFlowMetrics.CONCENTRATION.value, BrainFlowClassifiers.KNN.value) model1 = MLModel(ml_params1) model1.prepare() ml_params2 = BrainFlowModelParams(BrainFlowMetrics.RELAXATION.value, BrainFlowClassifiers.KNN.value) model2 = MLModel(ml_params2) model2.prepare() MLModel.release_all()
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()