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_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()
logging.basicConfig(level=logging.DEBUG)
parser = argparse.ArgumentParser()
parser.add_argument('--mac-address',
type=str,
help='mac address',
required=False,
default='')
args = parser.parse_args()
params = BrainFlowInputParams()
params.mac_address = args.mac_address
try:
board_shim = BoardShim(BoardIds.ENOPHONE_BOARD, params)
board_shim.prepare_session()
board_shim.start_stream(450000, '')
Graph(board_shim)
except BaseException:
logging.warning('Exception', exc_info=True)
finally:
logging.info('End')
if board_shim.is_prepared():
logging.info('Releasing session')
board_shim.release_session()
def main ():
BoardShim.enable_dev_board_logger ()
# 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))
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
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()
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
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
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()
parser = argparse.ArgumentParser()
parser.add_argument('--serial-port',
type=str,
help='serial port',
required=True)
args = parser.parse_args()
params = BrainFlowInputParams()
params.serial_port = args.serial_port
board = BoardShim(BoardIds.CYTON_BOARD, params)
try:
board.prepare_session()
resp = board.config_board('?')
print(resp)
# check that there is a response if streaming is off
if not resp:
raise ValueError('resp is None')
board.start_stream()
time.sleep(5)
resp = board.config_board('?')
print(resp)
# check that there is no response if streaming is on
if resp:
raise ValueError('resp is not None')
finally:
if board.is_prepared():
board.release_session()
def main ():
BoardShim.enable_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 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 ():
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)
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():
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
board = BoardShim(BoardIds.SYNTHETIC_BOARD.value, params)
board.prepare_session()
board.start_stream(450000, 'streaming_board://225.1.1.1:6677')
run_test(sys.argv[1:])
board.stop_stream()
board.release_session()
def run_livestream(params, args):
try:
board_shim = BoardShim(args.board_id, params)
board_shim.prepare_session()
board_shim.start_stream(4500000, args.streamer_params)
g = Graph(board_shim)
except BaseException as e:
logging.warning('Exception', exc_info=True)
finally:
logging.info('End')
if board_shim.is_prepared():
logging.info('Releasing session')
board_shim.release_session()
def main ():
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 ('--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 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
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():
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 gen_EEG_wifi_LSL(lslname='eeg1A'):
args = {
"ip_port": 2190,
"serial_port": "",
"mac_address": "",
"other_info": "",
"serial_number": "",
"ip_address": "192.168.4.1", #这个ip地址需要查看openbci板子的ip
"ip_protocol": 2,
"timeout": 0,
"file": "",
"log": True,
"streamer_params": "",
"board_id": -1,
}
args['board_id'] = 5
eegchannelsnums = 8
params = BrainFlowInputParams()
params.ip_port = args['ip_port']
params.serial_port = args['serial_port']
params.mac_address = args['mac_address']
params.other_info = args['other_info']
params.serial_number = args['serial_number']
params.ip_address = args['ip_address']
params.ip_protocol = args['ip_protocol']
params.timeout = args['timeout']
params.file = args['file']
# self.str.set("ss" + self.eegserialport)
if (args['log']):
BoardShim.enable_dev_board_logger()
else:
BoardShim.disable_board_logger()
eegboard = BoardShim(args['board_id'], params)
eegboard.prepare_session()
# eegboard.config_board('~6')
sample = eegboard.get_sampling_rate(eegboard.get_board_id())
#print('sample:',sample)
eegboard.start_stream(45000, "")
lslinfo = StreamInfo(lslname, 'EEG', eegchannelsnums, sample, 'float32',
'brain01')
lsloutlet = StreamOutlet(lslinfo)
sendeegThead = SendData(eegboard, lsloutlet)
sendeegThead.start()
def main ():
parser = argparse.ArgumentParser ()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port
# https://brainflow.readthedocs.io/en/stable/SupportedBoards.html#supported-boards-label
# board_id: 1
# serial_port field of BrainFlowInputParams structure
# mac_address field of BrainFlowInputParams structure, if its empty BrainFlow will try to autodiscover Ganglion
# optional: timeout field of BrainFlowInputParams structure, default is 15sec
parser.add_argument ('--timeout', type = int, help = 'timeout for device discovery or connection', required = False, default = 0)
parser.add_argument ('--ip-port', type = int, help = 'ip port', required = False, default = 0)
parser.add_argument ('--ip-protocol', type = int, help = 'ip protocol, check IpProtocolType enum', required = False, default = 0)
parser.add_argument ('--ip-address', type = str, help = 'ip address', required = False, default = '')
parser.add_argument ('--serial-port', type = str, help = 'serial port', required = False, default = '')
parser.add_argument ('--mac-address', type = str, help = 'mac address', required = False, default = '')
parser.add_argument ('--other-info', type = str, help = 'other info', required = False, default = '')
parser.add_argument ('--streamer-params', type = str, help = 'other info', required = False, default = '')
parser.add_argument ('--board-id', type = int, help = 'board id, check docs to get a list of supported boards', required = True)
parser.add_argument ('--log', action = 'store_true')
args = parser.parse_args ()
params = BrainFlowInputParams ()
params.ip_port = args.ip_port
params.serial_port = args.serial_port
params.mac_address = args.mac_address
params.other_info = args.other_info
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
params.timeout = args.timeout
if (args.log):
BoardShim.enable_dev_board_logger ()
else:
BoardShim.disable_board_logger ()
board = BoardShim (args.board_id, params)
board.prepare_session ()
# board.start_stream () # use this for default options
board.start_stream (45000, args.streamer_params)
# time.sleep (1)
# data = board.get_current_board_data (256) # get latest 256 packages or less, doesnt remove them from internal buffer
data = board.get_board_data () # get all data and remove it from internal buffer
board.stop_stream ()
board.release_session ()
print (data)
def main():
BoardShim.enable_dev_board_logger()
# 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)
