def main(): BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board = BoardShim(BoardIds.SYNTHETIC_BOARD.value, params) board.prepare_session() board.start_stream() BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep(10) data = board.get_current_board_data( 20) # get 20 latest data points dont remove them from internal buffer board.stop_stream() board.release_session() eeg_channels = BoardShim.get_eeg_channels(BoardIds.SYNTHETIC_BOARD.value) # demo for downsampling, it just aggregates data for count, channel in enumerate(eeg_channels): print('Original data for channel %d:' % channel) print(data[channel]) if count == 0: downsampled_data = DataFilter.perform_downsampling( data[channel], 3, AggOperations.MEDIAN.value) elif count == 1: downsampled_data = DataFilter.perform_downsampling( data[channel], 2, AggOperations.MEAN.value) else: downsampled_data = DataFilter.perform_downsampling( data[channel], 2, AggOperations.EACH.value) print('Downsampled data for channel %d:' % channel) print(downsampled_data)
def main (): BoardShim.enable_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 main(): BoardShim.enable_dev_board_logger() # use my board for demo params = BrainFlowInputParams() params.serial_port = '/dev/ttyUSB0' board = BoardShim(BoardIds.CYTON_BOARD.value, params) board.prepare_session() # some question board.start_stream() BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep(10) #data = board.get_current_board_data(20) # get 20 latest data points dont remove them from internal buffer data = board.get_board_data() board.stop_stream() board.release_session() # demo how to convert it to pandas DF and plot data #eeg_channels = BoardShim.get_eeg_channels(BoardIds.CYTON_DAISY_BOARD.value) print(data.shape) print(data[0]) print(data[1]) print(type(data[1, 0])) #df = pd.DataFrame(np.transpose(data)) #df = pd.DataFrame(data) #print('Data From the Board') #print(df.head(10)) # demo for data serialization using brainflow API, we recommend to use it instead pandas.to_csv() np.savetxt("foo3.csv", np.transpose(data), fmt='%10.7f', delimiter=",")
def main(): BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value sampling_rate = BoardShim.get_sampling_rate(board_id) board = BoardShim(board_id, params) board.prepare_session() board.start_stream() BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep(10) data = board.get_current_board_data( DataFilter.get_nearest_power_of_two(sampling_rate)) board.stop_stream() board.release_session() eeg_channels = BoardShim.get_eeg_channels(board_id) for count, channel in enumerate(eeg_channels): # optional: subtract mean or detrend psd = DataFilter.get_psd(data[channel], sampling_rate, WindowFunctions.BLACKMAN_HARRIS.value) band_power_alpha = DataFilter.get_band_power(psd, 7.0, 13.0) band_power_beta = DataFilter.get_band_power(psd, 14.0, 30.0) print("alpha/beta:%f", band_power_alpha / band_power_beta)
def main(): BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value sampling_rate = BoardShim.get_sampling_rate(board_id) board = BoardShim(board_id, params) board.prepare_session() board.start_stream() BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep(10) nfft = DataFilter.get_nearest_power_of_two(sampling_rate) data = board.get_board_data() board.stop_stream() board.release_session() eeg_channels = BoardShim.get_eeg_channels(board_id) # second eeg channel of synthetic board is a sine wave at 10Hz, should see huge alpha eeg_channel = eeg_channels[1] # optional detrend DataFilter.detrend(data[eeg_channel], DetrendOperations.LINEAR.value) psd = DataFilter.get_psd_welch(data[eeg_channel], nfft, nfft // 2, sampling_rate, WindowFunctions.BLACKMAN_HARRIS.value) band_power_alpha = DataFilter.get_band_power(psd, 7.0, 13.0) band_power_beta = DataFilter.get_band_power(psd, 14.0, 30.0) print("alpha/beta:%f", band_power_alpha / band_power_beta) # fail test if ratio is not smth we expect if (band_power_alpha / band_power_beta < 100): raise ValueError('Wrong Ratio')
def main (): BoardShim.enable_dev_board_logger () # use synthetic board for demo params = BrainFlowInputParams () board = BoardShim (BoardIds.SYNTHETIC_BOARD.value, params) board.prepare_session () board.start_stream () BoardShim.log_message (LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep (10) data = board.get_current_board_data (20) # get 20 latest data points dont remove them from internal buffer board.stop_stream () board.release_session () # demo how to convert it to pandas DF and plot data eeg_channels = BoardShim.get_eeg_channels (BoardIds.SYNTHETIC_BOARD.value) df = pd.DataFrame (np.transpose (data)) print ('Data From the Board') print (df.head (10)) # demo for data serialization using brainflow API, we recommend to use it instead pandas.to_csv() DataFilter.write_file (data, 'test.csv', 'w') # use 'a' for append mode restored_data = DataFilter.read_file ('test.csv') restored_df = pd.DataFrame (np.transpose (restored_data)) print ('Data From the File') print (restored_df.head (10))
def main(): BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value board = BoardShim(board_id, params) board.prepare_session() board.start_stream() BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep(10) data = board.get_board_data() board.stop_stream() board.release_session() # demo how to convert it to pandas DF and plot data eeg_channels = BoardShim.get_eeg_channels(board_id) df = pd.DataFrame(np.transpose(data)) plt.figure() df[eeg_channels].plot(subplots=True) plt.savefig('before_processing.png') # for demo apply different filters to different channels, in production choose one for count, channel in enumerate(eeg_channels): # filters work in-place if count == 0: DataFilter.perform_bandpass(data[channel], BoardShim.get_sampling_rate(board_id), 15.0, 6.0, 4, FilterTypes.BESSEL.value, 0) elif count == 1: DataFilter.perform_bandstop(data[channel], BoardShim.get_sampling_rate(board_id), 30.0, 1.0, 3, FilterTypes.BUTTERWORTH.value, 0) elif count == 2: DataFilter.perform_lowpass(data[channel], BoardShim.get_sampling_rate(board_id), 20.0, 5, FilterTypes.CHEBYSHEV_TYPE_1.value, 1) elif count == 3: DataFilter.perform_highpass(data[channel], BoardShim.get_sampling_rate(board_id), 3.0, 4, FilterTypes.BUTTERWORTH.value, 0) elif count == 4: DataFilter.perform_rolling_filter(data[channel], 3, AggOperations.MEAN.value) else: DataFilter.remove_environmental_noise( data[channel], BoardShim.get_sampling_rate(board_id), NoiseTypes.FIFTY.value) df = pd.DataFrame(np.transpose(data)) plt.figure() df[eeg_channels].plot(subplots=True) plt.savefig('after_processing.png')
def 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 start_stream(self): """" Start the data stream. If there is already some data displayed, it won't get cleaned. """ if self.timer is None: self.boardShim.start_stream() BoardShim.log_message(LogLevels.LEVEL_INFO.value, "The data stream has started!") self.save_to_file = self.save_to_file_checkbox.isChecked() self.file_path = self.file_path_line_edit.text() self.timer = QTimer() self.timer.timeout.connect(self.read_data) self.timer.start(100)
def main(): BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value board = BoardShim(board_id, params) board.prepare_session() board.start_stream() BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep(20) data = board.get_board_data() board.stop_stream() board.release_session() # demo how to convert it to pandas DF and plot data eeg_channels = BoardShim.get_eeg_channels(board_id) df = pd.DataFrame(np.transpose(data)) plt.figure() df[eeg_channels].plot(subplots=True) plt.savefig('before_processing.png') # demo for denoising, apply different methods to different channels for demo for count, channel in enumerate(eeg_channels): # first of all you can try simple moving median or moving average with different window size if count == 0: DataFilter.perform_rolling_filter(data[channel], 3, AggOperations.MEAN.value) elif count == 1: DataFilter.perform_rolling_filter(data[channel], 3, AggOperations.MEDIAN.value) # if methods above dont work for your signal you can try wavelet based denoising # feel free to try different functions and decomposition levels elif count == 2: DataFilter.perform_wavelet_denoising(data[channel], 'db6', 3) elif count == 3: DataFilter.perform_wavelet_denoising(data[channel], 'bior3.9', 3) elif count == 4: DataFilter.perform_wavelet_denoising(data[channel], 'sym7', 3) elif count == 5: # with synthetic board this one looks like the best option, but it depends on many circumstances DataFilter.perform_wavelet_denoising(data[channel], 'coif3', 3) df = pd.DataFrame(np.transpose(data)) plt.figure() df[eeg_channels].plot(subplots=True) plt.savefig('after_processing.png')
def main(): BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value sampling_rate = BoardShim.get_sampling_rate(board_id) board = BoardShim(board_id, params) board.prepare_session() board.start_stream() BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep(10) data = board.get_current_board_data( DataFilter.get_nearest_power_of_two(sampling_rate)) board.stop_stream() board.release_session() eeg_channels = BoardShim.get_eeg_channels(board_id) # demo for transforms for count, channel in enumerate(eeg_channels): print('Original data for channel %d:' % channel) print(data[channel]) # demo for wavelet transforms # wavelet_coeffs format is[A(J) D(J) D(J-1) ..... D(1)] where J is decomposition level, A - app coeffs, D - detailed coeffs # lengths array stores lengths for each block wavelet_coeffs, lengths = DataFilter.perform_wavelet_transform( data[channel], 'db5', 3) app_coefs = wavelet_coeffs[0:lengths[0]] detailed_coeffs_first_block = wavelet_coeffs[lengths[0]:lengths[1]] # you can do smth with wavelet coeffs here, for example denoising works via thresholds # for wavelets coefficients restored_data = DataFilter.perform_inverse_wavelet_transform( (wavelet_coeffs, lengths), data[channel].shape[0], 'db5', 3) print('Restored data after wavelet transform for channel %d:' % channel) print(restored_data) # demo for fft, len of data must be a power of 2 fft_data = DataFilter.perform_fft(data[channel], WindowFunctions.NO_WINDOW.value) # len of fft_data is N / 2 + 1 restored_fft_data = DataFilter.perform_ifft(fft_data) print('Restored data after fft for channel %d:' % channel) print(restored_fft_data)
def main(): BoardShim.enable_board_logger() DataFilter.enable_data_logger() MLModel.enable_ml_logger() params = BrainFlowInputParams() board = BoardShim(BoardIds.BRAINBIT_BOARD.value, params) master_board_id = board.get_board_id() sampling_rate = BoardShim.get_sampling_rate(master_board_id) board.prepare_session() board.start_stream(45000, '') eeg_channels = BoardShim.get_eeg_channels(int(master_board_id)) while True: BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep( 5 ) # recommended window size for eeg metric calculation is at least 4 seconds, bigger is better data = board.get_board_data() bands = DataFilter.get_avg_band_powers(data, eeg_channels, sampling_rate, True) feature_vector = np.concatenate((bands[0], bands[1])) print(feature_vector) # calc concentration concentration_params = BrainFlowModelParams( BrainFlowMetrics.CONCENTRATION.value, BrainFlowClassifiers.KNN.value) concentration = MLModel(concentration_params) concentration.prepare() print('Concentration: %f' % concentration.predict(feature_vector)) concentration.release() # calc relaxation relaxation_params = BrainFlowModelParams( BrainFlowMetrics.RELAXATION.value, BrainFlowClassifiers.REGRESSION.value) relaxation = MLModel(relaxation_params) relaxation.prepare() print('Relaxation: %f' % relaxation.predict(feature_vector)) relaxation.release() board.stop_stream() board.release_session()
def main(): BoardShim.enable_dev_board_logger() # use synthetic board for demo params = BrainFlowInputParams() board_id = BoardIds.SYNTHETIC_BOARD.value sampling_rate = BoardShim.get_sampling_rate(board_id) board = BoardShim(board_id, params) board.prepare_session() board.start_stream() BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') time.sleep(10) data = board.get_board_data() board.stop_stream() board.release_session() eeg_channels = BoardShim.get_eeg_channels(board_id) bands = DataFilter.get_avg_band_powers(data, eeg_channels, sampling_rate, True) print("avg band powers : %s" % str(bands[0])) print("stddev band powers : %s" % str(bands[1]))
def main(): show_img = None event_img = None screen_col = None counter = 3 #number of trials trials = 3 event_function = random_prompt() pygame.time.set_timer(pygame.USEREVENT, 1000) run = True print_first = True raise_indicate = False clench_indicate = False BoardShim.enable_dev_board_logger() params = BrainFlowInputParams() # for synthetic board: board_id = BoardIds.SYNTHETIC_BOARD.value # for openbci ganglion board_id: #board_id = BoardIds.GANGLION_BOARD.value #params.serial_port = 'COM3' #params.mac_address = '12345' board = BoardShim(board_id, params) board.prepare_session() board.start_stream() BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') 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": label_extractor(BoardShim.get_emg_channels, board_id, True), "ECG": label_extractor(BoardShim.get_ecg_channels, board_id, True), "Temperature": label_extractor(BoardShim.get_temperature_channels, board_id, True), "Resistance": label_extractor(BoardShim.get_resistance_channels, board_id, True), "EOG": label_extractor(BoardShim.get_eog_channels, board_id, True), "EXG": label_extractor(BoardShim.get_exg_channels, board_id, True), "EDA": label_extractor(BoardShim.get_eda_channels, board_id, True), "PPG": label_extractor(BoardShim.get_ppg_channels, board_id, True), "Accel": label_extractor(BoardShim.get_accel_channels, board_id, True), "Analog": label_extractor(BoardShim.get_analog_channels, board_id, True), "Gyro": label_extractor(BoardShim.get_gyro_channels, board_id, True), "Other": label_extractor(BoardShim.get_other_channels, board_id, True) } for key, value in label_dict.items(): for count, channel in enumerate(value): label_list[channel] = key + " " + str(count) if len( value) > 1 else key with open(output_file, 'w', newline='') as file: writer = csv.writer(file) #writer.writerow(np.arange(BoardShim.get_num_rows(board_id))) writer.writerow([ "Sampling Rate: " + str(BoardShim.get_sampling_rate(board_id)) + " Hz" ]) writer.writerow(["Board: " + BoardShim.get_device_name(board_id)]) writer.writerow(np.append(np.append(label_list, "Raise"), "Clench")) while run: data = board.get_board_data().T with open(output_file, 'a', newline='') as file: writer = csv.writer(file) # if (print_first): # writer.writerow(np.arange(data[0].size)) # print_first = False for i in range(data[:, 0].size): if raise_indicate: raise_event = 1 else: raise_event = 0 if clench_indicate: clench_event = 1 else: clench_event = 0 writer.writerow( np.append(np.append(data[i, :], raise_event), clench_event)) for event in pygame.event.get(): if event.type == pygame.USEREVENT: show_img, screen_col, event_img, raise_indicate, clench_indicate = event_function( counter) counter -= 1 if counter < 0 and trials > 1: trials -= 1 counter = 3 event_function = random_prompt() if event.type == pygame.QUIT: run = False if screen_col: WIN.fill(screen_col) if event_img: WIN.blit(event_img, (100, 100)) if show_img: WIN.blit(show_img, (300, 300)) pygame.display.update() pygame.quit() board.stop_stream() board.release_session()
def start_stream(board=None): board.start_stream(num_samples=450000) start_time = time.time() BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread') return start_time
def log_error(msg: str): BoardShim.log_message(LogLevels.LEVEL_ERROR.value, msg)
def log_debug(msg: str): BoardShim.log_message(LogLevels.LEVEL_DEBUG.value, msg)
"{:.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": label_extractor(BoardShim.get_emg_channels, board_id, True), "ECG": label_extractor(BoardShim.get_ecg_channels, board_id, True), "Temperature": label_extractor(BoardShim.get_temperature_channels, board_id, True), "Resistance":
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 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() # demo how to read data as 2d numpy array 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 (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() # demo how to convert it to pandas DF and plot data eeg_channels = BoardShim.get_eeg_channels(args.board_id) df = pd.DataFrame(np.transpose(data)) print('Data From the Board') print(df.head()) plt.figure() df[eeg_channels].plot(subplots=True) plt.savefig('before_processing.png') # demo for data serialization DataFilter.write_file(data, 'test.csv', 'w') restored_data = DataFilter.read_file('test.csv') restored_df = pd.DataFrame(np.transpose(restored_data)) print('Data From the File') print(restored_df.head()) # demo how to perform signal processing 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) df = pd.DataFrame(np.transpose(data)) print('Data After Processing') print(df.head()) plt.figure() df[eeg_channels].plot(subplots=True) plt.savefig('after_processing.png')
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()
def run(self): current_song_id = None prev_song_id = None is_playing = False is_end = False # handle the case of skipping songs needed_duration = 10 # in seconds time_sleep = 1 counter_for_duration = 0 counter_max = int(needed_duration / time_sleep) current_time = str(time.time()) folder_name = str(self.board.get_board_id()) if not os.path.exists(folder_name): os.makedirs(folder_name) brainflow_output_file = os.path.join( folder_name, 'brainflow' + current_time + '.csv') song_features_output_file = os.path.join( folder_name, 'songs' + current_time + '.csv') while self.keep_alive: time.sleep(time_sleep) track = self.spotify.current_user_playing_track() if track is not None: # despite the check above track obj can become None in case of ads try: if track.get('item', {}).get( 'id' ) != current_song_id and current_song_id is not None: is_end = True if track.get('is_playing', False) and not is_end: try: # despite the check above track object can become None, no idea how current_song_id = track.get('item', {}).get('id') counter_for_duration = counter_for_duration + 1 is_end = False is_playing = True except BaseException: pass elif not track.get('is_playing', True): is_end = True except AttributeError as e: BoardShim.log_message( LogLevels.LEVEL_WARN.value, 'Exception occured, more likely because of ads(its ok): %s' % str(e)) else: is_end = True if is_end: prev_song_id = current_song_id current_song_id = None data = self.board.get_board_data() # store data when a song ends if is_playing and counter_for_duration >= counter_max and prev_song_id is not None and data.shape[ 1] > 1: DataFilter.write_file(data, brainflow_output_file, 'a') features = self.spotify.audio_features(prev_song_id) BoardShim.log_message( LogLevels.LEVEL_DEBUG.value, 'adding info about song: %s' % prev_song_id) features_df = pd.DataFrame.from_dict(features) music_feature = features_df[[ 'danceability', 'energy', 'loudness', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo', 'id' ]] music_features_replicated = pd.concat([music_feature] * (data.shape[1] - 1), ignore_index=True) music_features_replicated.to_csv(song_features_output_file, sep='\t', mode='a') is_playing = False counter_for_duration = 0 is_end = False
def log_info(msg: str): BoardShim.log_message(LogLevels.LEVEL_INFO.value, msg)