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'] * len (eeg_channels)
ch_names = BoardShim.get_eeg_names (BoardIds.SYNTHETIC_BOARD.value)
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 __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()
def get_eeg_channels(board_id):
eeg_channels = BoardShim.get_eeg_channels(board_id)
# optional: filter some channels we dont want to consider
try:
eeg_names = BoardShim.get_eeg_names(board_id)
selected_channels = list()
# blacklisted_channels = {'O1', 'O2'}
blacklisted_channels = set()
for i, channel in enumerate(eeg_names):
if not channel in blacklisted_channels:
selected_channels.append(eeg_channels[i])
eeg_channels = selected_channels
except Exception as e:
print(str(e))
print('channels to use: %s' % str(eeg_channels))
return eeg_channels
def main():
'''
Connect to the Brainstorm
'''
# Authentication
username = '******'
password = ''
## Set Connection Details
# brainstorm = brainsatplay.Brainstorm('https://localhost') # Local
brainstorm = brainsatplay.Brainstorm() # Deployed Server
## Connect
res = brainstorm.connect(username,
password) # All optional (defaults to guest)
'''
Subscribe to a Particular Game
'''
# # Connection Settings
# appname = 'brainstorm'
# devices = []
# props = ['raw','times','sps','deviceType','format','eegChannelTags']
# sessionid = None
# spectating = False # Spectate to view data without sending it
# res = brainstorm.getSessions(appname)
# if res['msg'] != 'appNotFound':
# sessionid = res['sessions'][0]['id']
# else:
# res = brainstorm.createSession(appname, devices, props)
# sessionid = res['sessionInfo']['id']
# # Handle Data from Subscribed Games
# def newData(json):
# for user in json['userData']:
# name = user['username']
# print('Data for {}'.format(name))
# res = brainstorm.subscribeToSession(sessionid,spectating, newData)
'''
Stream your Data
'''
# Setup Brainflow
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.eeg_names = BoardShim.get_eeg_names(board_id)
board.prepare_session()
board.start_stream(num_samples=450000)
# Handle CTRL-C Exit
def onStop():
board.stop_stream()
board.release_session()
loopCount = 0
# Start Stream Loop
def streamLoop():
pass_data = []
rate = DataFilter.get_nearest_power_of_two(board.rate)
data = board.get_board_data()
t = data[board.time_channel]
data = data[board.eeg_channels]
for entry in data:
pass_data.append((entry).tolist())
data = {}
data['raw'] = pass_data
data['times'] = t.tolist()
# Send Metadata on First Loop
if loopCount == 0:
data['sps'] = board.rate
data['deviceType'] = 'eeg'
data['format'] = 'brainflow'
tags = []
for i, channel in enumerate(board.eeg_channels):
tags.append({
'ch': channel - 1,
'tag': board.eeg_names[i],
'analyze': True
})
data['eegChannelTags'] = tags
return data
res = brainstorm.startStream(streamLoop, onStop)
markers_filename = "data/" + session_id + ".json"
data_filename = "data/" + session_id + ".raw"
all_data = []
with open(data_filename, "rb") as f:
while True:
block = f.read(8 * CNT_CHANNELS)
if not block:
break
all_data.append(struct.unpack("<" + "d" * CNT_CHANNELS, block))
all_data = np.array(list(zip(*all_data)))
all_data /= 1000000 # uV to V
ch_types = ["eeg"] * CNT_CHANNELS
ch_names = BoardShim.get_eeg_names(BoardIds.SYNTHETIC_BOARD)[:CNT_CHANNELS]
sfreq = BoardShim.get_sampling_rate(BoardIds.SYNTHETIC_BOARD)
info = mne.create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types)
raw = mne.io.RawArray(all_data, info)
onset = []
duration = []
description = []
with open(markers_filename) as f:
prev_marker = None
for marker in json.loads(f.read()):
onset.append(marker["start"] / sfreq)
duration.append((marker["end"] - marker["start"]) / sfreq)
description.append(marker["key"])
class OpenBCIInterface:
def __init__(self,
serial_port='COM5',
board_id=0,
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
self.board_id = board_id
self.info_eeg = None
self.info_aux = None
self.outlet_eeg = None
self.outlet_aux = None
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')
print(self.board.get_board_id())
try:
self.board.start_stream(self.ring_buffer_size,
self.streamer_params)
self.infor_test()
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 create_lsl(self,
name='OpenBCI_Cyton_8',
type='EEG',
channel_count=8,
nominal_srate=250.0,
channel_format='float32',
source_id='Cyton_0'):
self.info_eeg = StreamInfo(name=name,
type=type,
channel_count=channel_count,
nominal_srate=nominal_srate,
channel_format=channel_format,
source_id='')
chns = self.info_eeg.desc().append_child('channels')
self.labels = ['Fp1', 'Fp2', 'C3', 'C4', 'T5', 'T6', 'O1', 'O2']
for label in self.labels:
ch = chns.append_child("channel")
ch.append_child_value('label', label)
ch.append_child_value('unit', 'microvolts')
ch.append_child_value('type', 'EEG')
self.info_eeg.desc().append_child_value('manufacturer', 'OpenBCI Inc.')
self.outlet_eeg = StreamOutlet(self.info_eeg)
print("--------------------------------------\n" + \
"LSL Configuration: \n" + \
" Stream 1: \n" + \
" Name: " + name + " \n" + \
" Type: " + type + " \n" + \
" Channel Count: " + str(channel_count) + "\n" + \
" Sampling Rate: " + str(nominal_srate) + "\n" + \
" Channel Format: " + channel_format + " \n" + \
" Source Id: " + source_id + " \n")
def push_sample(self, samples):
self.outlet_eeg.push_sample(samples)
def infor_test(self):
print(self.board.get_eeg_names(self.board_id))
print(self.board.get_sampling_rate(self.board_id))
print(self.board.get_board_id())
print(self.board.get_package_num_channel(self.board_id))
print(self.board.get_timestamp_channel(self.board_id))
print(self.board.get_eeg_channels(self.board_id))
print(self.board.get_accel_channels(self.board_id))
print(self.board.get_marker_channel(self.board_id))
print(self.board.get_other_channels(self.board_id))
print(self.board.get_analog_channels(self.board_id))
print(self.board.get_other_channels(self.board_id))
class OpenBCILSLInterface:
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 start_sensor(self):
# tell the sensor to start sending frames
try:
self.board.prepare_session()
except brainflow.board_shim.BrainFlowError:
raise AssertionError('Unable to connect to device: please check the sensor connection or the COM port number in device preset.')
print('OpenBCIInterface: connected to sensor')
try:
self.board.start_stream(self.ring_buffer_size, self.streamer_params)
except brainflow.board_shim.BrainFlowError:
raise AssertionError('Unable to connect to device: please check the sensor connection or the COM port number in device preset.')
print('OpenBCIInterface: connected to sensor')
self.create_lsl(name=self.stream_name,
type=self.stream_type,
nominal_srate=self.board.get_sampling_rate(self.board_id),
channel_format='float32',
source_id='Cyton_' + str(self.board_id))
def process_frames(self):
# return one or more frames of the sensor
frames = self.board.get_board_data()
for frame in frames.T:
self.push_frame(frame)
# TODO: fine push chunk error
# frames = np.transpose(frames)
# tesst = [[rand() for chan_ix in range(24)]
# for samp_ix in range(6)]
# # frames = frames.astype('float32')
# if frames.shape[0] > 0:
# self.push_frame(samples=frames)
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 create_lsl(self, name='OpenBCI_Cyton_8', type='EEG',
nominal_srate=250.0, channel_format='float32',
source_id='Cyton_0'):
channel_count = self.board.get_num_rows(self.board_id)
self.info_eeg = StreamInfo(name=name, type=type, channel_count=channel_count,
nominal_srate=nominal_srate, channel_format=channel_format,
source_id=source_id)
# chns = self.info_eeg.desc().append_child('channels')
#
# self.labels = ['Fp1', 'Fp2', 'C3', 'C4', 'T5', 'T6', 'O1', 'O2']
#
# for label in self.labels:
# ch = chns.append_child("channel")
# ch.append_child_value('label', label)
# ch.append_child_value('unit', 'microvolts')
# ch.append_child_value('type', 'EEG')
#
# self.info_eeg.desc().append_child_value('manufacturer', 'OpenBCI Inc.')
self.outlet_eeg = StreamOutlet(self.info_eeg)
print("--------------------------------------\n" + \
"LSL Configuration: \n" + \
" Stream 1: \n" + \
" Name: " + name + " \n" + \
" Type: " + type + " \n" + \
" Channel Count: " + str(channel_count) + "\n" + \
" Sampling Rate: " + str(nominal_srate) + "\n" + \
" Channel Format: " + channel_format + " \n" + \
" Source Id: " + source_id + " \n")
def push_frame(self, samples):
self.outlet_eeg.push_sample(samples)
def info_print(self):
print("Board Information:")
print("Sampling Rate:", self.board.get_sampling_rate(self.board_id))
print("Board Id:", self.board.get_board_id())
print("EEG names:", self.board.get_eeg_names(self.board_id))
print("Package Num Channel: ", self.board.get_package_num_channel(self.board_id))
print("EEG Channels:", self.board.get_eeg_channels(self.board_id))
print("Accel Channels: ", self.board.get_accel_channels(self.board_id))
print("Other Channels:", self.board.get_other_channels(self.board_id))
print("Analog Channels: ", self.board.get_analog_channels(self.board_id))
print("TimeStamp: ", self.board.get_timestamp_channel(self.board_id))
print("Marker Channel: ", self.board.get_marker_channel(self.board_id))
