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)
