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_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 __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 __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 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 initialize_board(name='SYNTHETIC',port = None): if name == 'SYNTHETIC': BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value board = BoardShim(board_id, params) board.rate = BoardShim.get_sampling_rate(board_id) board.channels = BoardShim.get_eeg_channels(board_id) board.time_channel = BoardShim.get_timestamp_channel(board_id) board.eeg_channels = BoardShim.get_eeg_channels(board_id) board.accel_channels = BoardShim.get_accel_channels(board_id) elif name == 'OPENBCI': board_id = BoardIds.CYTON_DAISY_BOARD.value params = BrainFlowInputParams() params.serial_port = port board_id = BoardIds.CYTON_DAISY_BOARD.value board = BoardShim(board_id, params) board.rate = BoardShim.get_sampling_rate(board_id) board.channels = BoardShim.get_eeg_channels(board_id) board.time_channel = BoardShim.get_timestamp_channel(board_id) board.eeg_channels = BoardShim.get_eeg_channels(board_id) board.accel_channels = BoardShim.get_accel_channels(board_id) print('Must have OpenBCI GUI open to work... (as port is not opened by Brainflow)') board.prepare_session() return board
def main(): 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 __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 __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 ('--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 ('--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 (): 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 gen_EEG_wifi_LSL(lslname='eeg1A'): args = { "ip_port": 2190, "serial_port": "", "mac_address": "", "other_info": "", "serial_number": "", "ip_address": "192.168.4.1", #这个ip地址需要查看openbci板子的ip "ip_protocol": 2, "timeout": 0, "file": "", "log": True, "streamer_params": "", "board_id": -1, } args['board_id'] = 5 eegchannelsnums = 8 params = BrainFlowInputParams() params.ip_port = args['ip_port'] params.serial_port = args['serial_port'] params.mac_address = args['mac_address'] params.other_info = args['other_info'] params.serial_number = args['serial_number'] params.ip_address = args['ip_address'] params.ip_protocol = args['ip_protocol'] params.timeout = args['timeout'] params.file = args['file'] # self.str.set("ss" + self.eegserialport) if (args['log']): BoardShim.enable_dev_board_logger() else: BoardShim.disable_board_logger() eegboard = BoardShim(args['board_id'], params) eegboard.prepare_session() # eegboard.config_board('~6') sample = eegboard.get_sampling_rate(eegboard.get_board_id()) #print('sample:',sample) eegboard.start_stream(45000, "") lslinfo = StreamInfo(lslname, 'EEG', eegchannelsnums, sample, 'float32', 'brain01') lsloutlet = StreamOutlet(lslinfo) sendeegThead = SendData(eegboard, lsloutlet) sendeegThead.start()
def 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() logging.basicConfig(level=logging.DEBUG) 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=False, default=BoardIds.SYNTHETIC_BOARD) 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 try: board_shim = BoardShim(args.board_id, params) board_shim.prepare_session() board_shim.start_stream(450000, 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()
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) 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) 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 (): 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 synth_params = BrainFlowInputParams () if (args.log): BoardShim.enable_dev_board_logger () else: BoardShim.disable_board_logger () board = BoardShim (args.board_id, params) synth_board = BoardShim (brainflow.board_shim.BoardIds.SYNTHETIC_BOARD.value, synth_params) board.prepare_session () synth_board.prepare_session () board.start_stream () synth_board.start_stream () time.sleep (10) data = board.get_board_data () synth_data = synth_board.get_board_data () board.stop_stream () synth_board.stop_stream () # board.release_session () # test that we handle it correctly synth_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) window = TrialConductor(board) window.show() if not board.is_prepared(): print("Preparing board from trial gui") board.prepare_session() app.exec() board.release_session()
def main(): app = QApplication([]) app.setStyle(global_config.APP_STYLE) BoardShim.enable_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 = ResonanceFrequencyFinder(board) window.show() board.prepare_session() app.exec() board.release_session()
def __init__(self, device_id, header=None, serial_port="/dev/ttyUSB0", saving_mode=SavingModeEnum.CONTINIOUS_SAVING_MODE, **kwargs): super().__init__(**kwargs) self._saving_mode = saving_mode self._stream_data = [] params = BrainFlowInputParams() params.serial_port = serial_port self.header = header self._board = BoardShim(device_id, params) self._board.set_log_level(0) self._board.prepare_session() self._terminate = False self._trigger = None self._experiment_id = None self.output_path = os.path.join(self.output_path, self.name) os.makedirs(self.output_path, exist_ok=True)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--serial-port', type=str, help='serial port', required=True) parser.add_argument('--mac-address', type=str, help='mac address', required=False, default='') args = parser.parse_args() BoardShim.enable_dev_board_logger() params = BrainFlowInputParams() params.serial_port = args.serial_port params.mac_address = args.mac_address board = BoardShim(BoardIds.GANGLION_BOARD.value, params) board.prepare_session() # expected result: 5 seconds of resistance data(unknown sampling rate) after that 5 seconds of exg data board.config_board('z') board.start_stream(45000, 'file://raw_data.csv:w') time.sleep(5) board.config_board('Z') time.sleep(5) data = board.get_board_data() board.stop_stream() board.release_session() print(data) resistance_channels = BoardShim.get_resistance_channels( BoardIds.GANGLION_BOARD.value) print(resistance_channels)
import time from brainflow.board_shim import BoardShim, BrainFlowInputParams BoardShim.enable_dev_board_logger() params = BrainFlowInputParams() params.ip_port = 6677 params.serial_port = "COM5" # params.ip_address = args.ip_address # params.ip_protocol = args.ip_protocol # params.timeout = args.timeout # params.file = args.file board = BoardShim(2, params) board.prepare_session() # board.start_stream () # use this for default options board.start_stream(45000) 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) print()
sum_welch[left_lim:right_lim][value] / cols.size, marker="o", ls="", ms=3) ax3.annotate( "{:.2f}".format(avg_freq[left_lim:right_lim][value]), (avg_freq[left_lim:right_lim][value], sum_welch[left_lim:right_lim][value] / cols.size), verticalalignment="top") plt.tight_layout() BoardShim.enable_dev_board_logger() params = BrainFlowInputParams() params.serial_port = serial_port params.mac_address = mac_address board = BoardShim(board_id, params) board.prepare_session() board.start_stream() BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') if (create_csv): label_list = [None] * BoardShim.get_num_rows(board_id) label_dict = { "Battery": label_extractor(BoardShim.get_battery_channel, board_id, False), "EEG": label_extractor(BoardShim.get_eeg_channels, board_id, True), "EMG":
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()
def get_input(): parser = argparse.ArgumentParser() parser.add_argument('--runtime', type=int, help='max time to sleep in the main thread in seconds', default=1800, required=False) # brainflow args 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=False, default=int(BoardIds.ENOPHONE_BOARD)) parser.add_argument('--file', type=str, help='file', required=False, default='') # spotify args parser.add_argument('--redirect-uri', type=str, default=None) parser.add_argument('--client-id', type=str, default=None) parser.add_argument('--client-secret', type=str, default=None) parser.add_argument('--username', type=str, 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 params.file = args.file token = util.prompt_for_user_token(args.username, scope='user-read-currently-playing', client_id=args.client_id, client_secret=args.client_secret, redirect_uri=args.redirect_uri) return args.board_id, params, token, args.runtime
def initialize_board() -> BoardShim: params = BrainFlowInputParams() params.serial_port = utils.cyton_port() board = BoardShim(global_config.BOARD_ID, params) return board
def main(): policy, parser = init_policy() args = parser.parse_args("") reward_dec = EEGNet() ctrl_dec = EEGNet() value_dec = EEGNet(softmax=False) params = BrainFlowInputParams() params.serial_port = "/dev/cu.usbserial-DM01MTXZ" board = BoardShim(2, params) board.prepare_session() board.start_stream() while True: task = input(PROMPT) if task.isdigit(): task = eval(task) if task == 1: if RETRAIN_META: # assuming balanced datasets # ERP erp_datasets = format_datasets(task="erp") reward_dec.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) reptile(reward_dec, erp_datasets, save_weights=True, task="erp") # CTRL ctrl_datasets = format_datasets(task="ctrl") ctrl_dec.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) reptile(ctrl_dec, ctrl_datasets, save_weights=True, task="ctrl") # Value value_dec.compile(loss='mse', optimizer='adam', metrics=['mse']) for dataset in erp_datasets: dataset["y_train"] = np.abs(dataset["y_train"] - 1) dataset["y_test"] = np.abs(dataset["y_test"] - 1) reptile(value_dec, erp_datasets, save_weights=True, task="vf") else: ctrl_dec = EEGNet() value_dec = EEGNet(softmax=False) reward_dec.load_weights('./models/erp_meta_init.h5') ctrl_dec.load_weights('./models/ctrl_meta_init.h5') value_dec.load_weights('./models/vf_meta_init.h5') print("Loaded meta-learned weights.") elif task == 2: data_idx = 20 print("Collecting data at index {0}.".format(data_idx)) streamer = Streamer(data_idx=data_idx, board=board) cursor_ctrl = CursorCtrl(data_idx=data_idx, streamer=streamer) cursor_ctrl.run_game(30 * 60) cursor_ctrl.close() print("Training ...") reward_dec.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) ctrl_dec.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) value_dec.compile(loss='mse', optimizer='adam', metrics=['mse']) erp_dataset = format_datasets(data_idxs=[data_idx], task="erp")[0] ctrl_dataset = format_datasets(data_idxs=[data_idx], task="ctrl")[0] for dp in range(len(erp_dataset["x_test"])): erp_dataset["x_test"][dp] = denoise(erp_dataset["x_test"][dp]) for dp in range(len(erp_dataset["x_train"])): erp_dataset["x_train"][dp] = denoise( erp_dataset["x_train"][dp]) for dp in range(len(ctrl_dataset["x_test"])): ctrl_dataset["x_test"][dp] = denoise( ctrl_dataset["x_test"][dp]) for dp in range(len(ctrl_dataset["x_train"])): ctrl_dataset["x_train"][dp] = denoise( ctrl_dataset["x_train"][dp]) reward_dec.fit(erp_dataset["x_train"], erp_dataset["y_train"], batch_size=16, epochs=100, verbose=2, validation_data=(erp_dataset["x_test"], erp_dataset["y_test"])) ctrl_dec.fit(ctrl_dataset["x_train"], ctrl_dataset["y_train"], batch_size=16, epochs=100, verbose=2, validation_data=(ctrl_dataset["x_test"], ctrl_dataset["y_test"])) erp_dataset["y_train"] = np.abs(erp_dataset["y_train"] - 1) erp_dataset["y_test"] = np.abs(erp_dataset["y_test"] - 1) value_dec.fit(erp_dataset["x_train"], erp_dataset["y_train"], batch_size=16, epochs=100, verbose=2, validation_data=(erp_dataset["x_test"], erp_dataset["y_test"])) reward_dec.save_weights('./models/erp_d{0}.h5'.format(data_idx)) ctrl_dec.save_weights('./models/ctrl_d{0}.h5'.format(data_idx)) value_dec.save_weights('./models/vf_d{0}.h5'.format(data_idx)) policy.actor.load_weights('./models/ctrl_d{0}.h5'.format(data_idx)) policy.qf1.load_weights('./models/vf_d{0}.h5'.format(data_idx)) policy.qf1_target.load_weights( './models/vf_d{0}.h5'.format(data_idx)) print("Finished training.") elif task == 3: streamer = Streamer(data_idx=102, board=board) cursor_ctrl = CursorCtrl(data_idx=102) env = BCIEnv(is_live=True, streamer=streamer, reward_dec=reward_dec, cursor_ctrl=cursor_ctrl) for ft_epoch in range(3): thread = threading.Thread(target=cursor_ctrl.render_for, args=(300, )) thread.start() print("On Round {0} / 3".format(ft_epoch + 1)) start_time = time.time() epoch_obs = [] epoch_act = [] epoch_rew = [] obs = env.reset() while time.time() - start_time < 300.: obs = denoise(obs) epoch_obs.append(obs) action = policy.get_action(obs) time.sleep(2.5) obs, reward, _, _, = env.step(action) epoch_act.append(action) epoch_rew.append(reward) epoch_obs.append(obs) print("Training ...") parser.set_defaults(max_steps=500) args = parser.parse_args("") rep_buff = { 'act': epoch_act, 'obs': epoch_obs, 'rew': epoch_rew } trainer = BCITrainer(policy, env, args) trainer.rep_buff = rep_buff # pulls data from here instead trainer() print("Finished fine-tuning.") streamer.save_data() streamer.close() cursor_ctrl.close() elif task == 4: name = str(int(time.time())) os.mkdir('./models/{0}'.format(name)) reward_dec.save_weights('./models/{0}/reward_dec.h5'.format(name)) policy.actor.save_weights( './models/{0}/policy_actor.h5'.format(name)) policy.qf1.save_weights('./models/{0}/policy_qf1.h5'.format(name)) policy.qf1_target.save_weights( './models/{0}/policy_qf1_target.h5'.format(name)) policy.qf2.save_weights('./models/{0}/policy_qf2.h5'.format(name)) policy.qf2_target.save_weights( './models/{0}/policy_qf2_target.h5'.format(name)) print('Saved weights with prefix {0}'.format(name)) elif task == 5: duration = 60 print("Starting up CursorCtrl for 1 minute.") streamer = Streamer(data_idx=103, board=board) cursor_ctrl = CursorCtrl(data_idx=103) env = BCIEnv(is_live=True, streamer=streamer, reward_dec=reward_dec, cursor_ctrl=cursor_ctrl) thread = threading.Thread(target=cursor_ctrl.render_for, args=(duration, )) thread.start() start_time = time.time() all_obs = [] obs = env.reset() while time.time() - start_time < duration: obs = denoise(obs) all_obs.append(obs) action = policy.get_action(obs, test=True) time.sleep(2.5) obs, _, _, _, = env.step(action) np.save("all_obs_20.npy", all_obs) elif task == 6: exit() else: print("Sorry, command not understood.")