def main ():
parser = argparse.ArgumentParser ()
parser.add_argument ('--ip-address', type = str, help = 'ip address', required = True)
parser.add_argument ('--ip-port', type = int, help = 'ip port', required = True)
args = parser.parse_args ()
BoardShim.enable_dev_board_logger ()
params = BrainFlowInputParams ()
params.ip_address = args.ip_address;
params.ip_port = args.ip_port;
board = BoardShim (BoardIds.GANGLION_WIFI_BOARD.value, params)
board.prepare_session ()
# 5 seconds of resistance data
board.config_board ('z')
board.start_stream (45000, 'file://raw_data_resistance.csv:w')
time.sleep (5)
data = board.get_board_data ()
board.stop_stream ()
# now get eeg data
board.config_board ('Z')
board.start_stream (45000, 'file://raw_data_eeg.csv:w')
time.sleep (5)
data = board.get_board_data ()
board.stop_stream ()
board.release_session ()
print (data)
class Capture():
# boardID = 1 for ganglion
# serialPort : https://brainflow.readthedocs.io/en/stable/SupportedBoards.html#ganglion
def __init__(self, boardID, serial_port):
self.serial_port = serial_port
params = BrainFlowInputParams()
params.serial_port = serial_port
BoardShim.disable_board_logger ()
self.board = BoardShim (boardID, params)
self.board.prepare_session()
def startStream(self):
self.board.start_stream()
# so given this many seconds it will try to get num_samples of data
# if seconds is too small, num_samples returned won't be enough
def getData(self, num_seconds, num_samples):
time.sleep(num_seconds)
# data = self.board.get_current_board_data (num_samples)
data = self.board.get_board_data()[:190]
# gets 0,1,2 channel. ignore 4 b/c noise data
return np.array([data[1], data[2], data[3]])
def closeStream(self):
self.board.stop_stream()
self.board.release_session()
def main():
BoardShim.enable_dev_board_logger()
# use my board for demo
params = BrainFlowInputParams()
params.serial_port = '/dev/ttyUSB0'
board = BoardShim(BoardIds.CYTON_BOARD.value, params)
board.prepare_session() # some question
board.start_stream()
BoardShim.log_message(LogLevels.LEVEL_INFO.value,
'start sleeping in the main thread')
time.sleep(10)
#data = board.get_current_board_data(20) # get 20 latest data points dont remove them from internal buffer
data = board.get_board_data()
board.stop_stream()
board.release_session()
# demo how to convert it to pandas DF and plot data
#eeg_channels = BoardShim.get_eeg_channels(BoardIds.CYTON_DAISY_BOARD.value)
print(data.shape)
print(data[0])
print(data[1])
print(type(data[1, 0]))
#df = pd.DataFrame(np.transpose(data))
#df = pd.DataFrame(data)
#print('Data From the Board')
#print(df.head(10))
# demo for data serialization using brainflow API, we recommend to use it instead pandas.to_csv()
np.savetxt("foo3.csv", np.transpose(data), fmt='%10.7f', delimiter=",")
def load_demo(duration=1) -> mne.io.RawArray:
"""Loads and returns some demo data"""
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board = BoardShim(BoardIds.SYNTHETIC_BOARD.value, params)
board.prepare_session()
board.start_stream()
print("Waiting for board shim to generate data...")
time.sleep(duration)
print("Done!")
data = board.get_board_data()
board.stop_stream()
board.release_session()
eeg_channels = BoardShim.get_eeg_channels(BoardIds.SYNTHETIC_BOARD.value)
# Only pick 8 channels
eeg_channels = eeg_channels[:8]
eeg_data = data[eeg_channels, :]
eeg_data = eeg_data / 1000000 # BrainFlow returns uV, convert to V for MNE
# Creating MNE objects from brainflow data arrays
ch_types = ["eeg", "eeg", "eeg", "eeg", "eeg", "eeg", "eeg", "eeg"]
ch_names = ["T7", "CP5", "FC5", "C3", "C4", "FC6", "CP6", "T8"]
sfreq = BoardShim.get_sampling_rate(BoardIds.SYNTHETIC_BOARD.value)
info = mne.create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types)
raw = mne.io.RawArray(eeg_data, info)
return raw
class CytonBoard(object):
def __init__(self, serial_port):
self.params = BrainFlowInputParams()
self.params.serial_port = serial_port
self.board = BoardShim(BoardIds.CYTON_BOARD.value, self.params)
def start_stream(self):
self.board.prepare_session()
self.board.start_stream()
def stop_stream(self):
self.board.stop_stream()
self.board.release_session()
def poll(self, sample_num):
try:
while self.board.get_board_data_count() < sample_num:
time.sleep(0.02)
except Exception as e:
raise (e)
board_data = self.board.get_board_data()
DataFilter.write_file(board_data, '.\Data\cyton_data_new.txt',
'a') # 'a' appends; 'w' overwrites
# Could add check to see if file already exists, adding a 1, 2, etc. on the end to avoid conflict
# Could use date function for generating names based on date-time.
df = board_2_df(np.transpose(board_data))
#print('/n')
#print(df)
return df
def sampling_frequency(self):
sampling_freq = self.board.get_sampling_rate(
BoardIds.CYTON_BOARD.value)
return sampling_freq
class BrainbitReader:
def __init__(self):
# Establish all parameters for Brainflow
self.params = BrainFlowInputParams()
# Assign the BrainBit as the board
self.params.board_id = 7
# set it logging
BoardShim.enable_dev_board_logger()
print('BrainBit reader ready')
def start(self):
# instantiate the board reading
self.board = BoardShim(self.params.board_id, self.params)
self.board.prepare_session()
# board.start_stream () # use this for default options
self.board.start_stream(2) # removed 48000
print('BrainBit stream started')
def read(self):
self.data = self.board.get_board_data(
) # get all data and remove it from internal buffer
return self.data
def terminate(self):
self.board.stop_stream()
self.board.release_session()
class CytonBoard(object):
def __init__(self, serial_port):
self.params = BrainFlowInputParams()
self.params.serial_port = serial_port
self.board = BoardShim(BoardIds.CYTON_BOARD.value, self.params)
def start_stream(self):
self.board.prepare_session()
self.board.start_stream()
def stop_stream(self):
self.board.stop_stream()
self.board.release_session()
def poll(self, sample_num):
try:
while self.board.get_board_data_count() < sample_num:
time.sleep(0.02)
except Exception as e:
raise (e)
board_data = self.board.get_board_data()
#df = board_2_df(np.transpose(board_data))
return board_data
def sampling_frequency(self):
sampling_freq = self.board.get_sampling_rate(
BoardIds.CYTON_BOARD.value)
return sampling_freq
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_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.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_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 ()
class CytonBoard(object):
def __init__(self, file):
self.params = BrainFlowInputParams()
#self.params.serial_port = serial_port
self.params.file = file
self.params.other_info = str(BoardIds.CYTON_BOARD.value)
self.board = BoardShim(BoardIds.PLAYBACK_FILE_BOARD.value, self.params)
def start_stream(self):
self.board.prepare_session()
#self.board.config_board ('loopback_true')
self.board.config_board('old_timestamps')
self.board.start_stream()
def stop_stream(self):
self.board.stop_stream()
self.board.release_session()
def poll(self, sample_num):
try:
while self.board.get_board_data_count() < sample_num:
time.sleep(0.02)
except Exception as e:
raise (e)
#print(self.board.get_board_data_count())
board_data = self.board.get_board_data()
#df = board_2_df(np.transpose(board_data))
return board_data
def sampling_frequency(self):
sampling_freq = self.board.get_sampling_rate(
BoardIds.CYTON_BOARD.value)
return sampling_freq
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()
time.sleep(10)
data = board.get_board_data()
board.stop_stream()
board.release_session()
eeg_channels = BoardShim.get_eeg_channels(BoardIds.SYNTHETIC_BOARD.value)
eeg_data = data[eeg_channels, :]
eeg_data = eeg_data / 1000000 # BrainFlow returns uV, convert to V for MNE
# Creating MNE objects from brainflow data arrays
ch_types = ['eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg']
ch_names = ['T7', 'CP5', 'FC5', 'C3', 'C4', 'FC6', 'CP6', 'T8']
sfreq = BoardShim.get_sampling_rate(BoardIds.SYNTHETIC_BOARD.value)
info = mne.create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types)
raw = mne.io.RawArray(eeg_data, info)
# its time to plot something!
raw.plot_psd(average=True)
plt.savefig('psd.png')
def main():
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board = 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_board_data(20)
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_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():
print('BoardShim version: ' + BoardShim.get_version())
print('DataFilter version: ' + DataFilter.get_version())
print('MLModel version: ' + MLModel.get_version())
BoardShim.enable_dev_board_logger()
board = BoardShim(BoardIds.SYNTHETIC_BOARD.value, BrainFlowInputParams())
board.prepare_session()
board.start_stream()
time.sleep(10)
board.stop_stream()
data = board.get_board_data()
print(DataFilter.calc_stddev(data[2]))
data = board.get_board_data()
print(data)
data = board.get_current_board_data(10)
print(data)
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
synth_params = BrainFlowInputParams ()
if (args.log):
BoardShim.enable_dev_board_logger ()
else:
BoardShim.disable_board_logger ()
board = BoardShim (args.board_id, params)
synth_board = BoardShim (brainflow.board_shim.BoardIds.SYNTHETIC_BOARD.value, synth_params)
board.prepare_session ()
synth_board.prepare_session ()
board.start_stream ()
synth_board.start_stream ()
time.sleep (10)
data = board.get_board_data ()
synth_data = synth_board.get_board_data ()
board.stop_stream ()
synth_board.stop_stream ()
# board.release_session () # test that we handle it correctly
synth_board.release_session ()
def main ():
parser = argparse.ArgumentParser ()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port
parser.add_argument ('--ip-port', type = int, help = 'ip port', required = False, default = 0)
parser.add_argument ('--ip-protocol', type = int, help = 'ip protocol, check IpProtocolType enum', required = False, default = 0)
parser.add_argument ('--ip-address', type = str, help = 'ip address', required = False, default = '')
parser.add_argument ('--serial-port', type = str, help = 'serial port', required = False, default = '')
parser.add_argument ('--mac-address', type = str, help = 'mac address', required = False, default = '')
parser.add_argument ('--other-info', type = str, help = 'other info', required = False, default = '')
parser.add_argument ('--streamer-params', type = str, help = 'other info', required = False, default = '')
parser.add_argument ('--board-id', type = int, help = 'board id, check docs to get a list of supported boards', required = True)
parser.add_argument ('--log', action = 'store_true')
args = parser.parse_args ()
params = BrainFlowInputParams ()
params.ip_port = args.ip_port
params.serial_port = args.serial_port
params.mac_address = args.mac_address
params.other_info = args.other_info
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
if (args.log):
BoardShim.enable_dev_board_logger ()
else:
BoardShim.disable_board_logger ()
board = BoardShim (args.board_id, params)
board.prepare_session ()
board.start_stream ()
print('Session Started')
for x in range(2):
time.sleep (5)
board.config_board ('/2') # enable analog mode only for Cyton Based Boards!
time.sleep (5)
data = board.get_board_data ()
board.stop_stream ()
board.release_session ()
"""
data[BoardShim.get_other_channels(args.board_id)[0]] contains cyton end byte
data[BoardShim.get_other_channels(args.board_id)[1....]] contains unprocessed bytes
if end byte is 0xC0 there are accel data in data[BoardShim.get_accel_channels(args.board_id)[....]] else there are zeros
if end byte is 0xC1 there are analog data in data[BoardShim.get_analog_channels(args.board_id)[....]] else there are zeros
"""
print (data[BoardShim.get_other_channels(args.board_id)[0]][0:5]) # should be standard end byte 0xC0
print (data[BoardShim.get_other_channels(args.board_id)[0]][-5:]) # should be analog and byte 0xC1
DataFilter.write_file (data, 'cyton_data_new.txt', 'w')
class OpenBCIInterface:
def __init__(self,
serial_port='COM7',
board_id=2,
log='store_true',
streamer_params='',
ring_buffer_size=45000): # default board_id 2 for Cyton
params = BrainFlowInputParams()
params.serial_port = serial_port
params.ip_port = 0
params.mac_address = ''
params.other_info = ''
params.serial_number = ''
params.ip_address = ''
params.ip_protocol = 0
params.timeout = 0
params.file = ''
self.streamer_params = streamer_params
self.ring_buffer_size = ring_buffer_size
if (log):
BoardShim.enable_dev_board_logger()
else:
BoardShim.disable_board_logger()
self.board = BoardShim(board_id, params)
def start_sensor(self):
# tell the sensor to start sending frames
self.board.prepare_session()
print('OpenBCIInterface: connected to sensor')
try:
self.board.start_stream(self.ring_buffer_size,
self.streamer_params)
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 main ():
parser = argparse.ArgumentParser ()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port
parser.add_argument ('--ip-port', type = int, help = 'ip port', required = False, default = 0)
parser.add_argument ('--ip-protocol', type = int, help = 'ip protocol, check IpProtocolType enum', required = False, default = 0)
parser.add_argument ('--ip-address', type = str, help = 'ip address', required = False, default = '')
parser.add_argument ('--serial-port', type = str, help = 'serial port', required = False, default = '')
parser.add_argument ('--mac-address', type = str, help = 'mac address', required = False, default = '')
parser.add_argument ('--other-info', type = str, help = 'other info', required = False, default = '')
parser.add_argument ('--board-id', type = int, help = 'board id, check docs to get a list of supported boards', required = True)
parser.add_argument ('--log', action = 'store_true')
args = parser.parse_args ()
params = BrainFlowInputParams ()
params.ip_port = args.ip_port
params.serial_port = args.serial_port
params.mac_address = args.mac_address
params.other_info = args.other_info
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
if (args.log):
BoardShim.enable_dev_board_logger ()
else:
BoardShim.disable_board_logger ()
board = BoardShim (args.board_id, params)
board.prepare_session ()
# disable 2nd channel for cyton use real board to check it, emulator ignores commands
if args.board_id == brainflow.board_shim.BoardIds.CYTON_BOARD.value:
board.config_board ('x2100000X')
board.start_stream ()
time.sleep (10)
data = board.get_board_data ()
board.stop_stream ()
board.release_session ()
eeg_channels = BoardShim.get_eeg_channels (args.board_id)
for count, channel in enumerate (eeg_channels):
if count == 0:
DataFilter.perform_bandpass (data[channel], BoardShim.get_sampling_rate (args.board_id), 15.0, 6.0, 4, FilterTypes.BESSEL.value, 0)
elif count == 1:
DataFilter.perform_bandstop (data[channel], BoardShim.get_sampling_rate (args.board_id), 5.0, 1.0, 3, FilterTypes.BUTTERWORTH.value, 0)
elif count == 2:
DataFilter.perform_lowpass (data[channel], BoardShim.get_sampling_rate (args.board_id), 9.0, 5, FilterTypes.CHEBYSHEV_TYPE_1.value, 1)
elif count == 3:
DataFilter.perform_highpass (data[channel], BoardShim.get_sampling_rate (args.board_id), 3.0, 4, FilterTypes.BUTTERWORTH.value, 0)
def main():
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
board = BoardShim(BoardIds.MUSE_S_BOARD, params)
board.prepare_session()
board.config_board('p61')
board.start_stream(45000, 'file://data.csv:w')
time.sleep(10)
data = board.get_board_data()
board.stop_stream()
board.release_session()
print(data)
def recordData(serial_port, board_id=0, samples=500):
params = BrainFlowInputParams()
params.serial_port = serial_port
board = BoardShim(board_id, params)
board.prepare_session()
board.start_stream(samples + 1)
time.sleep(2.5)
data = board.get_board_data()
board.stop_stream()
board.release_session()
data = data[:7].T
return data
def main():
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board_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')
class SensorWrapper:
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
board_id = None
board = None
channels_idx = None
buffer = None
sensor_settings: SensorSettings = None
rx_sensor_settings_subject_subscription: Disposable = None
def __init__(self, rx_sensor_settings_subject: BehaviorSubject):
self.sensor_settings = rx_sensor_settings_subject.value
self.rx_sensor_settings_subject_subscription = rx_sensor_settings_subject.subscribe(self.set_sensor_settings)
if self.sensor_settings.simulation:
self.board_id = BoardIds.SYNTHETIC_BOARD.value
else:
self.board_id = BoardIds.CYTON_BOARD.value
self.params.serial_port = self.sensor_settings.sensor_com_port
self.board = BoardShim(self.board_id, self.params)
self.channels_idx = BoardShim.get_emg_channels(self.board_id)
self.buffer = np.empty([0, NUM_CHANNELS])
self.board.prepare_session()
self.board.start_stream()
def set_sensor_settings(self, sensor_settings: SensorSettings):
self.sensor_settings = sensor_settings
def disconnect(self):
self.board.stop_stream()
self.board.release_session()
self.rx_sensor_settings_subject_subscription.dispose()
def read(self):
data = self.board.get_board_data().transpose()[:, self.channels_idx]
self.buffer = np.concatenate((self.buffer, data), axis=0)
def read_filtered(self):
self.read()
if self.buffer.shape[0] < MIN_READ_BUFFER_DEPTH:
return None
read_matrix = np.asmatrix(self.buffer)
self.buffer = np.empty([0, NUM_CHANNELS])
if self.sensor_settings.notch_filter:
read_matrix = np.apply_along_axis(notch, 0, read_matrix, val=self.sensor_settings.notch_frequency)[0]
if self.sensor_settings.bandpass_filter:
read_matrix = np.apply_along_axis(bandpass, 0, read_matrix, start=self.sensor_settings.bandpass_low_frequency,
stop=self.sensor_settings.bandpass_high_frequency)
return read_matrix
def main ():
parser = argparse.ArgumentParser ()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port
# https://brainflow.readthedocs.io/en/stable/SupportedBoards.html#supported-boards-label
# board_id: 1
# serial_port field of BrainFlowInputParams structure
# mac_address field of BrainFlowInputParams structure, if its empty BrainFlow will try to autodiscover Ganglion
# optional: timeout field of BrainFlowInputParams structure, default is 15sec
parser.add_argument ('--timeout', type = int, help = 'timeout for device discovery or connection', required = False, default = 0)
parser.add_argument ('--ip-port', type = int, help = 'ip port', required = False, default = 0)
parser.add_argument ('--ip-protocol', type = int, help = 'ip protocol, check IpProtocolType enum', required = False, default = 0)
parser.add_argument ('--ip-address', type = str, help = 'ip address', required = False, default = '')
parser.add_argument ('--serial-port', type = str, help = 'serial port', required = False, default = '')
parser.add_argument ('--mac-address', type = str, help = 'mac address', required = False, default = '')
parser.add_argument ('--other-info', type = str, help = 'other info', required = False, default = '')
parser.add_argument ('--streamer-params', type = str, help = 'other info', required = False, default = '')
parser.add_argument ('--board-id', type = int, help = 'board id, check docs to get a list of supported boards', required = True)
parser.add_argument ('--log', action = 'store_true')
args = parser.parse_args ()
params = BrainFlowInputParams ()
params.ip_port = args.ip_port
params.serial_port = args.serial_port
params.mac_address = args.mac_address
params.other_info = args.other_info
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
params.timeout = args.timeout
if (args.log):
BoardShim.enable_dev_board_logger ()
else:
BoardShim.disable_board_logger ()
board = BoardShim (args.board_id, params)
board.prepare_session ()
# board.start_stream () # use this for default options
board.start_stream (45000, args.streamer_params)
# time.sleep (1)
# data = board.get_current_board_data (256) # get latest 256 packages or less, doesnt remove them from internal buffer
data = board.get_board_data () # get all data and remove it from internal buffer
board.stop_stream ()
board.release_session ()
print (data)
def test():
if request.method == 'GET':
# sample的存放地址
# data_path = 'C:\\Users\\zzzal\\Desktop\\'
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board = BoardShim(BoardIds.SYNTHETIC_BOARD.value, params)
sampling = board.get_sampling_rate(BoardIds.SYNTHETIC_BOARD.value)
board.prepare_session()
board.start_stream()
time.sleep(10)
data = board.get_board_data()
board.stop_stream()
board.release_session()
# eeg_channels = BoardShim.get_eeg_channels (BoardIds.SYNTHETIC_BOARD.value)
eeg_channels = [1, 2, 3, 4, 5, 6, 7, 8]
eeg_data = data[eeg_channels, :]
eeg_data = eeg_data / 1000000 # BrainFlow returns uV, convert to V for MNE
# time=data.values[0::,1]
xtime = [i / sampling for i in range(eeg_data.shape[1])]
xtime = np.array(xtime)
xtime.astype(np.float32)
i = len(xtime) - 1
while (i > 0):
xtime[i] = xtime[i] - xtime[i - 1]
i -= 1
i = 1
xtime[0] = 0
while (i < len(xtime)):
xtime[i] += xtime[i - 1]
i += 1
xtime = xtime.tolist()
return render_template("chart.html",
time=xtime,
one=eeg_data[0].tolist(),
two=eeg_data[1].tolist(),
three=eeg_data[2].tolist(),
four=eeg_data[3].tolist(),
five=eeg_data[4].tolist(),
six=eeg_data[5].tolist(),
seven=eeg_data[6].tolist(),
eight=eeg_data[7].tolist())
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()
parser = argparse.ArgumentParser()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port
parser.add_argument('--timeout', type=int, help='timeout for device discovery or connection', required=False,
default=0)
parser.add_argument('--ip-port', type=int, help='ip port', required=False, default=0)
parser.add_argument('--ip-protocol', type=int, help='ip protocol, check IpProtocolType enum', required=False,
default=0)
parser.add_argument('--ip-address', type=str, help='ip address', required=False, default='')
parser.add_argument('--serial-port', type=str, help='serial port', required=False, default='')
parser.add_argument('--mac-address', type=str, help='mac address', required=False, default='')
parser.add_argument('--other-info', type=str, help='other info', required=False, default='')
parser.add_argument('--streamer-params', type=str, help='streamer params', required=False, default='')
parser.add_argument('--serial-number', type=str, help='serial number', required=False, default='')
parser.add_argument('--board-id', type=int, help='board id, check docs to get a list of supported boards',
required=True)
parser.add_argument('--file', type=str, help='file', required=False, default='')
args = parser.parse_args()
params = BrainFlowInputParams()
params.ip_port = args.ip_port
params.serial_port = args.serial_port
params.mac_address = args.mac_address
params.other_info = args.other_info
params.serial_number = args.serial_number
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
params.timeout = args.timeout
params.file = args.file
board = BoardShim(args.board_id, params)
board.prepare_session()
# board.start_stream () # use this for default options
board.start_stream(45000, args.streamer_params)
time.sleep(10)
# data = board.get_current_board_data (256) # get latest 256 packages or less, doesnt remove them from internal buffer
data = board.get_board_data() # get all data and remove it from internal buffer
board.stop_stream()
board.release_session()
print(data)
def 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 main():
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
board = BoardShim(BoardIds.BRAINBIT_BOARD.value, params)
board.prepare_session()
board.start_stream(45000, 'file://raw_data.csv:w')
# its a little tricky and unclear, need to call start_stream to create data acquisition thread(it also sends CommandStartSignal)
# after that send CommandStartResist, CommandStopResist and to get EEG data call CommandStartSignal manually
board.config_board('CommandStartResist')
time.sleep(5)
board.config_board('CommandStopResist')
board.config_board('CommandStartSignal')
time.sleep(5)
data = board.get_board_data()
board.stop_stream()
board.release_session()
print(data)
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]))
