def __init__(self, data_idx=101, board=None):
self.data_idx = data_idx
self.board_id = 2
self.eeg_channels = BoardShim.get_eeg_channels(self.board_id)
self.ts_channels = BoardShim.get_timestamp_channel(self.board_id)
sfreq = BoardShim.get_sampling_rate(self.board_id)
self.freq = sfreq
ch_types = [
'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg',
'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg', 'eeg'
]
ch_names = [
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P'
]
self.info = mne.create_info(ch_names=ch_names,
sfreq=sfreq,
ch_types=ch_types)
if board is not None:
self.board = board
else:
params = BrainFlowInputParams()
params.serial_port = "/dev/cu.usbserial-DM01MTXZ"
board = BoardShim(self.board_id, params)
self.board.prepare_session()
self.board.start_stream()
def 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 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()
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():
app = QApplication([])
app.setStyle(global_config.APP_STYLE)
BoardShim.enable_board_logger()
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
params.serial_port = utils.cyton_port()
board = BoardShim(global_config.BOARD_ID, params)
# Switch to using white background and black foreground
pg.setConfigOption('background', 'w')
pg.setConfigOption('foreground', 'k')
window = MainWindow(app, board=board, screen_width=app.primaryScreen().size().width(), channel_count=6)
window.show()
board.prepare_session()
app.exec()
print("Release session")
board.release_session()
def initialize_board(name='SYNTHETIC',port = None):
if name == 'SYNTHETIC':
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board_id = BoardIds.SYNTHETIC_BOARD.value
board = BoardShim(board_id, params)
board.rate = BoardShim.get_sampling_rate(board_id)
board.channels = BoardShim.get_eeg_channels(board_id)
board.time_channel = BoardShim.get_timestamp_channel(board_id)
board.eeg_channels = BoardShim.get_eeg_channels(board_id)
board.accel_channels = BoardShim.get_accel_channels(board_id)
elif name == 'OPENBCI':
board_id = BoardIds.CYTON_DAISY_BOARD.value
params = BrainFlowInputParams()
params.serial_port = port
board_id = BoardIds.CYTON_DAISY_BOARD.value
board = BoardShim(board_id, params)
board.rate = BoardShim.get_sampling_rate(board_id)
board.channels = BoardShim.get_eeg_channels(board_id)
board.time_channel = BoardShim.get_timestamp_channel(board_id)
board.eeg_channels = BoardShim.get_eeg_channels(board_id)
board.accel_channels = BoardShim.get_accel_channels(board_id)
print('Must have OpenBCI GUI open to work... (as port is not opened by Brainflow)')
board.prepare_session()
return board
def __init__(self, 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 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 ()
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)
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
board = BoardShim (args.board_id, params)
sampling_rate = BoardShim.get_sampling_rate (args.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 (args.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.REGRESSION.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 __init__(self):
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
params.serial_port = "/dev/ttyUSB0"
self.board_id = BoardIds.CYTON_DAISY_BOARD.value
self.sampling_rate = BoardShim.get_sampling_rate(self.board_id)
self.board = BoardShim(self.board_id, params)
self.player_is_playing = False
self.positive_signal = True
self.last_signal_delta = 0
self.metrics = {}
self.channels = {}
def __init__(self,
channels_order: List[str] = None,
board_type: str = "cyton-daisy",
name: Optional[str] = None,
output_path: str = "output",
serial_port=None):
self.channels = channels_order
if board_type == "cyton-daisy":
device_id = 2
sampling_rate = 125
if self.channels is None:
self.channels = \
["ch1", "ch2", "ch3", "ch4", "ch5", "ch6", "ch7", "ch8", "ch9",
"ch10", "ch11", "ch12", "ch13", "ch14", "ch15", "ch16"]
if len(self.channels) != 16:
raise RuntimeError(
"The number of channels in channels_order should be 16")
elif board_type == "cyton":
device_id = 0
sampling_rate = 250
self.channels = \
["ch1", "ch2", "ch3", "ch4", "ch5", "ch6", "ch7", "ch8"]
if len(self.channels) != 8:
raise RuntimeError(
"The number of channels in channels_order should be 8")
elif board_type == "Ganglion":
device_id = 1
sampling_rate = 200
self.channels = \
["ch1", "ch2", "ch3", "ch4"]
if len(self.channels) != 4:
raise RuntimeError(
"The number of channels in channels_order should be 4")
else:
raise RuntimeError("Use BrainflowStreaming fr other boards")
if serial_port is None:
if platform.system() == "Linux":
serial_port = "/dev/ttyUSB0"
elif platform.system() == "Windows":
serial_port = "Com3"
else:
serial_port = "/dev/cu.*"
params = BrainFlowInputParams()
params.serial_port = serial_port
super().__init__(device_id,
sampling_rate,
brain_flow_input_params=params,
name=name,
output_path=output_path)
def __init__(self, video_path):
self.windowName = "Neurofeedback"
self.video_path = video_path
self.audio_start_time_sec = time.time()
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
params.serial_port = "/dev/ttyUSB0"
self.board_id = BoardIds.CYTON_DAISY_BOARD.value
self.sampling_rate = BoardShim.get_sampling_rate(self.board_id)
self.board = BoardShim(self.board_id, params)
self.player_is_playing = False
self.positive_signal = True
self.last_signal_delta = 0
self.signals = []
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 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 = 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 connect_board(self):
self.params = BrainFlowInputParams()
self.params.ip_port = 0
self.params.ip_protocol = 0
self.params.timeout = 0
self.params.serial_port = self.serial_port
self.board = BoardShim(self.board_id, self.params)
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 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)
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_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 __init__(self, stream_name='OpenBCI_Cyton_8', stream_type='EEG', serial_port='COM5', board_id="0",
log='store_true', streamer_params='',
ring_buffer_size=45000): # default board_id 2 for Cyton
self.params = BrainFlowInputParams()
self.params.serial_port = serial_port
self.params.ip_port = 0
self.params.mac_address = ''
self.params.other_info = ''
self.params.serial_number = ''
self.params.ip_address = ''
self.params.ip_protocol = 0
self.params.timeout = 0
self.params.file = ''
self.stream_name = stream_name
self.stream_type = stream_type
self.board_id = int(board_id)
self.streamer_params = streamer_params
self.ring_buffer_size = ring_buffer_size
if (log):
BoardShim.enable_dev_board_logger()
else:
BoardShim.disable_board_logger()
try:
self.board = BoardShim(self.board_id, self.params)
self.info_print()
except brainflow.board_shim.BrainFlowError:
print('Cannot connect to board')
def 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_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 __init__(self, serial_port):
self.params = BrainFlowInputParams()
if serial_port:
self.params.serial_port = serial_port
self.board = BoardShim(BoardIds.CYTON_BOARD.value, self.params)
else:
self.board = BoardShim(BoardIds.PLAYBACK_FILE_BOARD.value, self.params)
self.params.file = ''
self.params.other_info=BoardShim(BoardIds.CYTON_BOARD.value, self.params)
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
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 (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 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 __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 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')
def main():
BoardShim.enable_dev_board_logger()
params1 = BrainFlowInputParams()
params1.other_info = 'board1'
board_id = BoardIds.SYNTHETIC_BOARD.value
params2 = BrainFlowInputParams()
params2.other_info = 'board2'
board1 = BoardShim(board_id, params1)
board1.prepare_session()
board2 = BoardShim(board_id, params2)
board2.prepare_session()
BoardShim.release_all_sessions()
ml_params1 = BrainFlowModelParams(BrainFlowMetrics.CONCENTRATION.value,
BrainFlowClassifiers.KNN.value)
model1 = MLModel(ml_params1)
model1.prepare()
ml_params2 = BrainFlowModelParams(BrainFlowMetrics.RELAXATION.value,
BrainFlowClassifiers.KNN.value)
model2 = MLModel(ml_params2)
model2.prepare()
MLModel.release_all()
def __init__(
self,
board_name: str,
serial_port: str = "",
mac_address: str = "",
ip_address: str = "",
ip_port: int = 0,
ip_protocol: int = 0,
other_info: str = "",
timeout: int = 0,
serial_number: str = "",
board_file: str = "",
):
self.board_name = board_name
if not valid_boardname(board_name):
raise BoardException(
f"Invalid board name in config: {self.board_name}")
else:
self.board_id = BoardIds[self.board_name].value
# Get and set vars with basic info about the board:
self.sample_rate = BoardShim.get_sampling_rate(self.board_id)
try:
self.channel_names = BoardShim.get_eeg_names(self.board_id)
except Exception:
self.channel_names = []
self.channel_count = len(BoardShim.get_eeg_channels(self.board_id))
# Prepare the board params object:
self.params = BrainFlowInputParams()
# Load params into the object from init function args:
self.params.serial_port = serial_port
self.params.mac_address = mac_address
self.params.ip_address = ip_address
self.params.ip_port = ip_port
self.params.ip_protocol = ip_protocol
self.params.other_info = other_info
self.params.timeout = timeout
self.params.serial_number = serial_number
self.params.file = board_file
# Construct the board object:
try:
self.board = BoardShim(self.board_id, self.params)
except Exception as e:
raise BoardException(
f"Failed to instantiate board object for {self.board_name}" +
str(e))
# Initial values:
self.is_ready = False
self.is_recording = False
# Self-check via our 'ping' function:
self.ping()
