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, 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 start_recording(total_sec, max_samples, params, args): board = BoardShim(args.board_id, params) board.prepare_session() # board.start_stream () # use this for default options board.start_stream(max_samples, args.streamer_params) time.sleep(total_sec) # data = board.get_current_board_data (256) # get latest 256 packages or less, doesnt remove them from internal buffer data = board.get_board_data( ) # get all data and remove it from internal buffer timestamp_channel = board.get_timestamp_channel(board_id=0) board.stop_stream() board.release_session() # demo how to convert it to pandas DF and plot data eeg_channels = BoardShim.get_eeg_channels(args.board_id) print(eeg_channels) df = pd.DataFrame(np.transpose(data)) plt.figure() df[eeg_channels].plot(subplots=True) plt.savefig('data/before_processing.png') # for demo apply different filters to different channels, in production choose one for count, channel in enumerate(eeg_channels): DataFilter.perform_lowpass(data[channel], BoardShim.get_sampling_rate(args.board_id), 30, 3, FilterTypes.BUTTERWORTH.value, 0) DataFilter.perform_highpass(data[channel], BoardShim.get_sampling_rate(args.board_id), 5, 3, FilterTypes.BUTTERWORTH.value, 0) DataFilter.perform_bandstop(data[channel], BoardShim.get_sampling_rate(args.board_id), 50, 2, 8, FilterTypes.BUTTERWORTH.value, 0) df = pd.DataFrame(np.transpose( data[:, 1000:])) # Usable after 1000 given order of filters are 3 plt.figure() df[eeg_channels].plot(subplots=True) plt.savefig('data/after_processing.png') return data, timestamp_channel
def save_data(self): data = self.board.get_current_board_data( self.board.get_board_data_count()) ts_channels = BoardShim.get_timestamp_channel(self.board_id) eeg_data = data[self.eeg_channels, :] eeg_ts = data[ts_channels, :] eeg_data = eeg_data / 1000000 np.save("raw_data.npy", eeg_data) raw = mne.io.RawArray(eeg_data, self.info) raw2 = mne.io.RawArray(np.copy(eeg_data), self.info) # do this if need be ... raw.filter(0.5, 40., fir_design='firwin') raw2.filter(9., 50., fir_design='firwin') data1 = raw.get_data() data2 = raw2.get_data() np.save("./data/eeg_data_{0}_old.npy".format(self.data_idx), np.transpose(data1)) np.save("./data/eeg_fft_data_{0}_old.npy".format(self.data_idx), np.transpose(data2)) np.save("./data/eeg_timestamps_{0}_old.npy".format(self.data_idx), eeg_ts)
def main(i): board_id = BoardIds.SYNTHETIC_BOARD.value eeg_channels = BoardShim.get_eeg_channels(board_id) timestamp = BoardShim.get_timestamp_channel(board_id) style.use('fivethirtyeight') plt.title("Live EEG Datastream from Brainflow", fontsize=15) plt.ylabel("Data in millivolts", fontsize=15) plt.xlabel("\nTime", fontsize=10) data = DataFilter.read_file('data.csv') eegdf = pd.DataFrame(np.transpose(data[eeg_channels, timestamp])) #timedf = pd.DataFrame(np.transpose(data[timestamp])) #to keep it simple, making another dataframe for the timestamps to access later eegdf_col_names = ["ch1","ch2","ch3","ch4","ch5","ch6","ch7","ch8","ch9","ch10","ch11","ch12","ch13","ch14","ch15","ch16"] eegdf.columns = eegdf_col_names print("EEG Dataframe") print(eegdf) #easy way to check what data is being streamed and if program is working #print(eegdf) eeg1 = eegdf.iloc[:, 0].values #I am using OpenBCI Ganglion board, so only have four channels. eeg2 = eegdf.iloc[:, 1].values eeg3 = eegdf.iloc[:, 2].values eeg4 = eegdf.iloc[:, 3].values timex= eegdf.iloc[:, 15].values #timestamps #print(timex) #use this to see what the UNIX timestamps look like print("EEG Channel 1") print(eeg1) #print("Time DF") #print(timedf) print("Timestamp") print(timex) """plt.cla()
def main(): ''' Connect to the Brainstorm ''' # Authentication username = '******' password = '' ## Set Connection Details # brainstorm = brainsatplay.Brainstorm('https://localhost') # Local brainstorm = brainsatplay.Brainstorm() # Deployed Server ## Connect res = brainstorm.connect(username, password) # All optional (defaults to guest) ''' Subscribe to a Particular Game ''' # # Connection Settings # appname = 'brainstorm' # devices = [] # props = ['raw','times','sps','deviceType','format','eegChannelTags'] # sessionid = None # spectating = False # Spectate to view data without sending it # res = brainstorm.getSessions(appname) # if res['msg'] != 'appNotFound': # sessionid = res['sessions'][0]['id'] # else: # res = brainstorm.createSession(appname, devices, props) # sessionid = res['sessionInfo']['id'] # # Handle Data from Subscribed Games # def newData(json): # for user in json['userData']: # name = user['username'] # print('Data for {}'.format(name)) # res = brainstorm.subscribeToSession(sessionid,spectating, newData) ''' Stream your Data ''' # Setup Brainflow params = BrainFlowInputParams() board_id = BoardIds['SYNTHETIC_BOARD'].value board = BoardShim(board_id, params) board.rate = BoardShim.get_sampling_rate(board_id) board.channels = BoardShim.get_eeg_channels(board_id) board.time_channel = BoardShim.get_timestamp_channel(board_id) board.eeg_channels = BoardShim.get_eeg_channels(board_id) board.eeg_names = BoardShim.get_eeg_names(board_id) board.prepare_session() board.start_stream(num_samples=450000) # Handle CTRL-C Exit def onStop(): board.stop_stream() board.release_session() loopCount = 0 # Start Stream Loop def streamLoop(): pass_data = [] rate = DataFilter.get_nearest_power_of_two(board.rate) data = board.get_board_data() t = data[board.time_channel] data = data[board.eeg_channels] for entry in data: pass_data.append((entry).tolist()) data = {} data['raw'] = pass_data data['times'] = t.tolist() # Send Metadata on First Loop if loopCount == 0: data['sps'] = board.rate data['deviceType'] = 'eeg' data['format'] = 'brainflow' tags = [] for i, channel in enumerate(board.eeg_channels): tags.append({ 'ch': channel - 1, 'tag': board.eeg_names[i], 'analyze': True }) data['eegChannelTags'] = tags return data res = brainstorm.startStream(streamLoop, onStop)
def 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()
class OpenBCIInterface: def __init__(self, serial_port='COM5', board_id=0, log='store_true', streamer_params='', ring_buffer_size=45000): # default board_id 2 for Cyton params = BrainFlowInputParams() params.serial_port = serial_port params.ip_port = 0 params.mac_address = '' params.other_info = '' params.serial_number = '' params.ip_address = '' params.ip_protocol = 0 params.timeout = 0 params.file = '' self.streamer_params = streamer_params self.ring_buffer_size = ring_buffer_size self.board_id = board_id self.info_eeg = None self.info_aux = None self.outlet_eeg = None self.outlet_aux = None if (log): BoardShim.enable_dev_board_logger() else: BoardShim.disable_board_logger() self.board = BoardShim(board_id, params) def start_sensor(self): # tell the sensor to start sending frames self.board.prepare_session() print('OpenBCIInterface: connected to sensor') print(self.board.get_board_id()) try: self.board.start_stream(self.ring_buffer_size, self.streamer_params) self.infor_test() except brainflow.board_shim.BrainFlowError: print('OpenBCIInterface: Board is not ready.') def process_frames(self): # return one or more frames of the sensor frames = self.board.get_board_data() return frames def stop_sensor(self): try: self.board.stop_stream() print('OpenBCIInterface: stopped streaming.') self.board.release_session() print('OpenBCIInterface: released session.') except brainflow.board_shim.BrainFlowError as e: print(e) def create_lsl(self, name='OpenBCI_Cyton_8', type='EEG', channel_count=8, nominal_srate=250.0, channel_format='float32', source_id='Cyton_0'): self.info_eeg = StreamInfo(name=name, type=type, channel_count=channel_count, nominal_srate=nominal_srate, channel_format=channel_format, source_id='') chns = self.info_eeg.desc().append_child('channels') self.labels = ['Fp1', 'Fp2', 'C3', 'C4', 'T5', 'T6', 'O1', 'O2'] for label in self.labels: ch = chns.append_child("channel") ch.append_child_value('label', label) ch.append_child_value('unit', 'microvolts') ch.append_child_value('type', 'EEG') self.info_eeg.desc().append_child_value('manufacturer', 'OpenBCI Inc.') self.outlet_eeg = StreamOutlet(self.info_eeg) print("--------------------------------------\n" + \ "LSL Configuration: \n" + \ " Stream 1: \n" + \ " Name: " + name + " \n" + \ " Type: " + type + " \n" + \ " Channel Count: " + str(channel_count) + "\n" + \ " Sampling Rate: " + str(nominal_srate) + "\n" + \ " Channel Format: " + channel_format + " \n" + \ " Source Id: " + source_id + " \n") def push_sample(self, samples): self.outlet_eeg.push_sample(samples) def infor_test(self): print(self.board.get_eeg_names(self.board_id)) print(self.board.get_sampling_rate(self.board_id)) print(self.board.get_board_id()) print(self.board.get_package_num_channel(self.board_id)) print(self.board.get_timestamp_channel(self.board_id)) print(self.board.get_eeg_channels(self.board_id)) print(self.board.get_accel_channels(self.board_id)) print(self.board.get_marker_channel(self.board_id)) print(self.board.get_other_channels(self.board_id)) print(self.board.get_analog_channels(self.board_id)) print(self.board.get_other_channels(self.board_id))
def main(): parser = argparse.ArgumentParser() # use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port parser.add_argument('--ip-port', type=int, help='ip port', required=False, default=0) parser.add_argument('--ip-protocol', type=int, help='ip protocol, check IpProtocolType enum', required=False, default=0) parser.add_argument('--ip-address', type=str, help='ip address', required=False, default='') parser.add_argument('--serial-port', type=str, help='serial port', required=False, default='') parser.add_argument('--mac-address', type=str, help='mac address', required=False, default='') parser.add_argument('--other-info', type=str, help='other info', required=False, default='') parser.add_argument('--streamer-params', type=str, help='other info', required=False, default='') parser.add_argument( '--board-id', type=int, help='board id, check docs to get a list of supported boards', required=True) parser.add_argument('--log', action='store_true') parser.add_argument('--run-time', type=int, help='run time in sec', required=True) args = parser.parse_args() params = BrainFlowInputParams() params.ip_port = args.ip_port params.serial_port = args.serial_port params.mac_address = args.mac_address params.other_info = args.other_info params.ip_address = args.ip_address params.ip_protocol = args.ip_protocol if (args.log): BoardShim.enable_dev_board_logger() else: BoardShim.disable_board_logger() # for streaming board need to use master board id master_board_id = args.board_id if args.board_id == BoardIds.STREAMING_BOARD.value: master_board_id = int(params.other_info) board = BoardShim(args.board_id, params) board.prepare_session() buffer_size = int( BoardShim.get_sampling_rate(master_board_id) * args.run_time * 1.2) # + 20% for safety board.start_stream(buffer_size, args.streamer_params) time.sleep(args.run_time) board.stop_stream() data = board.get_board_data() board.release_session() if master_board_id in (BoardIds.CYTON_BOARD.value, BoardIds.CYTON_WIFI_BOARD.value, BoardIds.GANGLION_WIFI_BOARD.value): bytes_per_package = 33 elif master_board_id in (BoardIds.CYTON_DAISY_BOARD, BoardIds.CYTON_DAISY_WIFI_BOARD.value): bytes_per_package = 66 elif master_board_id == BoardIds.SYNTHETIC_BOARD.value: bytes_per_package = 104 elif master_board_id == BoardIds.NOVAXR_BOARD.value: bytes_per_package = 72 else: raise ValueError('unsupported board') total_bytes_received = bytes_per_package * data.shape[1] packages_per_sec = float(data.shape[1]) / float(args.run_time) timestamp_channel = BoardShim.get_timestamp_channel(master_board_id) timestamp_array = data[timestamp_channel] time_diff_array = list() for i in range(0, timestamp_array.size - 1): time_diff_array.append(timestamp_array[i + 1] - timestamp_array[i]) package_num_channel = BoardShim.get_package_num_channel(master_board_id) package_num_array = data[package_num_channel] lost_packages = 0 expected = 0 cur_id = 0 while cur_id < package_num_array.size: if expected == 256: expected = 0 if package_num_array[cur_id] != expected: BoardShim.log_message( LogLevels.LEVEL_WARN.value, 'package loss detected: position %d package_num value %d expected value %d' % (cur_id, package_num_array[cur_id], expected)) lost_packages = lost_packages + 1 else: cur_id = cur_id + 1 expected = expected + 1 package_loss = (lost_packages / data.shape[1]) * 100 BoardShim.log_message(LogLevels.LEVEL_INFO.value, '\nResults:\n') BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'package loss percent %f' % package_loss) BoardShim.log_message( LogLevels.LEVEL_INFO.value, 'average time delta %f' % statistics.mean(time_diff_array)) BoardShim.log_message( LogLevels.LEVEL_INFO.value, 'std deviation of time delta %f' % statistics.pstdev(time_diff_array)) BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'total packages received %d' % data.shape[1]) BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'packages per sec %f' % packages_per_sec) BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'total bytes received %d' % total_bytes_received) eeg_channels = BoardShim.get_eeg_channels(master_board_id) emg_channels = BoardShim.get_emg_channels(master_board_id) total_channels = eeg_channels # for cyton/ganglion eeg_channels and emg_channels are the same array because we can not split it # for novaxr its 2 different arrays, join them for ch in emg_channels: if ch not in total_channels: total_channels.append(ch) df = pd.DataFrame(np.transpose(data)) df[total_channels].to_csv('eeg_emg_data.csv') df.to_csv('all_data.csv') plt.figure() df[total_channels].plot(subplots=True) plt.show()
class OpenBCILSLInterface: 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 start_sensor(self): # tell the sensor to start sending frames try: self.board.prepare_session() except brainflow.board_shim.BrainFlowError: raise AssertionError('Unable to connect to device: please check the sensor connection or the COM port number in device preset.') print('OpenBCIInterface: connected to sensor') try: self.board.start_stream(self.ring_buffer_size, self.streamer_params) except brainflow.board_shim.BrainFlowError: raise AssertionError('Unable to connect to device: please check the sensor connection or the COM port number in device preset.') print('OpenBCIInterface: connected to sensor') self.create_lsl(name=self.stream_name, type=self.stream_type, nominal_srate=self.board.get_sampling_rate(self.board_id), channel_format='float32', source_id='Cyton_' + str(self.board_id)) def process_frames(self): # return one or more frames of the sensor frames = self.board.get_board_data() for frame in frames.T: self.push_frame(frame) # TODO: fine push chunk error # frames = np.transpose(frames) # tesst = [[rand() for chan_ix in range(24)] # for samp_ix in range(6)] # # frames = frames.astype('float32') # if frames.shape[0] > 0: # self.push_frame(samples=frames) return frames def stop_sensor(self): try: self.board.stop_stream() print('OpenBCIInterface: stopped streaming.') self.board.release_session() print('OpenBCIInterface: released session.') except brainflow.board_shim.BrainFlowError as e: print(e) def create_lsl(self, name='OpenBCI_Cyton_8', type='EEG', nominal_srate=250.0, channel_format='float32', source_id='Cyton_0'): channel_count = self.board.get_num_rows(self.board_id) self.info_eeg = StreamInfo(name=name, type=type, channel_count=channel_count, nominal_srate=nominal_srate, channel_format=channel_format, source_id=source_id) # chns = self.info_eeg.desc().append_child('channels') # # self.labels = ['Fp1', 'Fp2', 'C3', 'C4', 'T5', 'T6', 'O1', 'O2'] # # for label in self.labels: # ch = chns.append_child("channel") # ch.append_child_value('label', label) # ch.append_child_value('unit', 'microvolts') # ch.append_child_value('type', 'EEG') # # self.info_eeg.desc().append_child_value('manufacturer', 'OpenBCI Inc.') self.outlet_eeg = StreamOutlet(self.info_eeg) print("--------------------------------------\n" + \ "LSL Configuration: \n" + \ " Stream 1: \n" + \ " Name: " + name + " \n" + \ " Type: " + type + " \n" + \ " Channel Count: " + str(channel_count) + "\n" + \ " Sampling Rate: " + str(nominal_srate) + "\n" + \ " Channel Format: " + channel_format + " \n" + \ " Source Id: " + source_id + " \n") def push_frame(self, samples): self.outlet_eeg.push_sample(samples) def info_print(self): print("Board Information:") print("Sampling Rate:", self.board.get_sampling_rate(self.board_id)) print("Board Id:", self.board.get_board_id()) print("EEG names:", self.board.get_eeg_names(self.board_id)) print("Package Num Channel: ", self.board.get_package_num_channel(self.board_id)) print("EEG Channels:", self.board.get_eeg_channels(self.board_id)) print("Accel Channels: ", self.board.get_accel_channels(self.board_id)) print("Other Channels:", self.board.get_other_channels(self.board_id)) print("Analog Channels: ", self.board.get_analog_channels(self.board_id)) print("TimeStamp: ", self.board.get_timestamp_channel(self.board_id)) print("Marker Channel: ", self.board.get_marker_channel(self.board_id))
def liveStream(): BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value board = BoardShim(board_id, params) eeg_channels = BoardShim.get_eeg_channels(board_id) sampling_rate = BoardShim.get_sampling_rate(board_id) timestamp = BoardShim.get_timestamp_channel(board_id) board.prepare_session() board.start_stream() while True: #get board data removes data from the buffer while board.get_board_data_count() < 250: time.sleep(0.005) data = board.get_board_data() #datadf = pd.DataFrame(np.transpose(data)) #creating a dataframe of the eeg data to extract eeg values later """for count, channel in enumerate(eeg_channels): # filters work in-place #Check Brainflow docs for more filters if count == 0: DataFilter.perform_bandstop(data[channel], sampling_rate, 60.0, 4.0, 4, FilterTypes.BUTTERWORTH.value, 0) # bandstop 58 - 62 DataFilter.perform_bandpass(data[channel], sampling_rate, 21.0, 20.0, 4, FilterTypes.BESSEL.value, 0) # bandpass 11 - 31 if count == 1: DataFilter.perform_bandstop(data[channel], sampling_rate, 60.0, 4.0, 4, FilterTypes.BUTTERWORTH.value, 0) # bandstop 58 - 62 DataFilter.perform_bandpass(data[channel], sampling_rate, 21.0, 20.0, 4, FilterTypes.BESSEL.value, 0) # bandpass 11 - 31 if count == 2: DataFilter.perform_bandstop(data[channel], sampling_rate, 60.0, 4.0, 4, FilterTypes.BUTTERWORTH.value, 0) # bandstop 58 - 62 DataFilter.perform_bandpass(data[channel], sampling_rate, 21.0, 20.0, 4, FilterTypes.BESSEL.value, 0) # bandpass 11 - 31 if count == 3: DataFilter.perform_bandstop(data[channel], sampling_rate, 60.0, 4.0, 4, FilterTypes.BUTTERWORTH.value, 0) # bandstop 58 - 62 DataFilter.perform_bandpass(data[channel], sampling_rate, 21.0, 20.0, 4, FilterTypes.BESSEL.value, 0) # bandpass 11 - 31""" #Brainflow ML Model 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() DataFilter.write_file(data, 'data.csv', 'w') #writing data to csv file board.stop_stream() board.release_session()
# assuming that there is one directory per session (i.e. morning and night) todays_sessions = os.listdir(todays_sessions_path) curr_sesh_name = f"Session_{len(todays_sessions)+1}" if args.synth: curr_sesh_name += "_SYNTH" current_session_dir = os.path.join(todays_sessions_path, curr_sesh_name) os.mkdir(current_session_dir) raw_data_path = os.path.join(current_session_dir, "raw_data.csv") board_id = BoardIds.SYNTHETIC_BOARD.value if args.synth else BoardIds.CYTON_DAISY_BOARD.value sampling_rate = BoardShim.get_sampling_rate(board_id) eegs = BoardShim.get_eeg_channels(board_id) battery = BoardShim.get_battery_channel(board_id) resistance = BoardShim.get_resistance_channels(board_id) timestamp = BoardShim.get_timestamp_channel(board_id) others = BoardShim.get_accel_channels( board_id) if args.synth else BoardShim.get_other_channels(board_id) columns = ['timestamp'] + [f'ch_{x+1}' for x in range(len(eegs)) ] + [f'aux_{x+1}' for x in range(len(others))] with open(raw_data_path, 'w') as raw: raw.write(','.join(columns) + '\n') if args.debug: BoardShim.enable_dev_board_logger() for c in ['eegs', 'battery', 'resistance', 'others', 'timestamp']: log_debug(f'Channel for {c} is {eval(c)} ') log_debug(f"sampling rate is {sampling_rate} with board ID {board_id}") DataFilter.write_file BUFFER_TIME = args.buffer
def main(i): BoardShim.enable_dev_board_logger() BoardShim.disable_board_logger( ) #optional. take this out for initial setup for your board. # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value board = BoardShim(board_id, params) eeg_channels = BoardShim.get_eeg_channels(board_id) sampling_rate = BoardShim.get_sampling_rate(board_id) timestamp = BoardShim.get_timestamp_channel(board_id) board.prepare_session() board.start_stream() style.use('fivethirtyeight') plt.title("Live EEG stream from Brainflow", fontsize=15) plt.ylabel("Data in millivolts", fontsize=15) plt.xlabel("\nTime", fontsize=10) keep_alive = True eeg1 = [] #lists to store eeg data eeg2 = [] eeg3 = [] eeg4 = [] timex = [] #list to store timestamp while keep_alive == True: while board.get_board_data_count( ) < 250: #ensures that all data shape is the same time.sleep(0.005) data = board.get_current_board_data(250) # creating a dataframe of the eeg data to extract eeg values later eegdf = pd.DataFrame(np.transpose(data[eeg_channels])) eegdf_col_names = [ "ch1", "ch2", "ch3", "ch4", "ch5", "ch6", "ch7", "ch8", "ch9", "ch10", "ch11", "ch12", "ch13", "ch14", "ch15", "ch16" ] eegdf.columns = eegdf_col_names # to keep it simple, making another dataframe for the timestamps to access later timedf = pd.DataFrame(np.transpose(data[timestamp])) print( "EEG Dataframe" ) #easy way to check what data is being streamed and if program is working print(eegdf) #isn't neccesary. for count, channel in enumerate(eeg_channels): # filters work in-place # Check Brainflow docs for more filters if count == 0: DataFilter.perform_bandstop(data[channel], sampling_rate, 60.0, 4.0, 4, FilterTypes.BUTTERWORTH.value, 0) # bandstop 58 - 62 DataFilter.perform_bandpass(data[channel], sampling_rate, 21.0, 20.0, 4, FilterTypes.BESSEL.value, 0) # bandpass 11 - 31 if count == 1: DataFilter.perform_bandstop(data[channel], sampling_rate, 60.0, 4.0, 4, FilterTypes.BUTTERWORTH.value, 0) # bandstop 58 - 62 DataFilter.perform_bandpass(data[channel], sampling_rate, 21.0, 20.0, 4, FilterTypes.BESSEL.value, 0) # bandpass 11 - 31 if count == 2: DataFilter.perform_bandstop(data[channel], sampling_rate, 60.0, 4.0, 4, FilterTypes.BUTTERWORTH.value, 0) # bandstop 58 - 62 DataFilter.perform_bandpass(data[channel], sampling_rate, 21.0, 20.0, 4, FilterTypes.BESSEL.value, 0) # bandpass 11 - 31 if count == 3: DataFilter.perform_bandstop(data[channel], sampling_rate, 60.0, 4.0, 4, FilterTypes.BUTTERWORTH.value, 0) # bandstop 58 - 62 DataFilter.perform_bandpass(data[channel], sampling_rate, 21.0, 20.0, 4, FilterTypes.BESSEL.value, 0) # bandpass 11 - 31 # Brainflow ML Model bands = DataFilter.get_avg_band_powers(data, eeg_channels, sampling_rate, True) feature_vector = np.concatenate((bands[0], bands[1])) # calc concentration concentration_params = BrainFlowModelParams( BrainFlowMetrics.CONCENTRATION.value, BrainFlowClassifiers.KNN.value) concentration = MLModel(concentration_params) concentration.prepare() print('Concentration: %f' % concentration.predict(feature_vector)) concentrated_measure = concentration.predict(feature_vector) concentration.release() # calc relaxation relaxation_params = BrainFlowModelParams( BrainFlowMetrics.RELAXATION.value, BrainFlowClassifiers.KNN.value) relaxation = MLModel(relaxation_params) relaxation.prepare() print('Relaxation: %f' % relaxation.predict(feature_vector)) relaxed_measure = relaxation.predict(feature_vector) relaxation.release() #appending eeg data to lists eeg1.extend( eegdf.iloc[:, 0].values ) # I am using OpenBCI Ganglion board, so I only have four channels. eeg2.extend( eegdf.iloc[:, 1].values ) # If you have a different board, you should be able to copy paste eeg3.extend(eegdf.iloc[:, 2].values) # these commands for more channels. eeg4.extend(eegdf.iloc[:, 3].values) timex.extend(timedf.iloc[:, 0].values) # timestamps plt.cla() #plotting eeg data plt.plot(timex, eeg1, label="Channel 1", color="red") plt.plot(timex, eeg2, label="Channel 2", color="blue") plt.plot(timex, eeg3, label="Channel 3", color="orange") plt.plot(timex, eeg4, label="Channel 4", color="purple") plt.tight_layout() keep_alive = False #resetting stream so that matplotlib can plot data if concentrated_measure >= 0.5: print( "GOOD KEEP CONCENTRATING" ) #a program screaming at you to concentrate should do the trick :) else: print("WHERE IS THE CONCENTRATION??") if relaxed_measure >= 0.5: print("YES RELAX MORE") else: print("NO, START RELAXING") board.stop_stream() board.release_session()