def main():
parser = argparse.ArgumentParser()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port
parser.add_argument('--ip-port',
type=int,
help='ip port',
required=False,
default=0)
parser.add_argument('--ip-protocol',
type=int,
help='ip protocol, check IpProtocolType enum',
required=False,
default=0)
parser.add_argument('--ip-address',
type=str,
help='ip address',
required=False,
default='')
parser.add_argument('--serial-port',
type=str,
help='serial port',
required=False,
default='')
parser.add_argument('--mac-address',
type=str,
help='mac address',
required=False,
default='')
parser.add_argument('--other-info',
type=str,
help='other info',
required=False,
default='')
parser.add_argument('--streamer-params',
type=str,
help='other info',
required=False,
default='')
parser.add_argument(
'--board-id',
type=int,
help='board id, check docs to get a list of supported boards',
required=True)
parser.add_argument('--log', action='store_true')
parser.add_argument('--run-time',
type=int,
help='run time for one iteration in sec',
required=True)
parser.add_argument('--num-iters',
type=int,
help='number of iterations',
default=1)
parser.add_argument(
'--channels',
type=str,
help='channels to plot in format 0,1,2 by default plot all channels',
default=None)
parser.add_argument('--config-file',
type=str,
help='file with strings to send to device',
default=None)
args = parser.parse_args()
params = BrainFlowInputParams()
params.ip_port = args.ip_port
params.serial_port = args.serial_port
params.mac_address = args.mac_address
params.other_info = args.other_info
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
if (args.log):
BoardShim.enable_dev_board_logger()
else:
BoardShim.disable_board_logger()
# for streaming board need to use master board id
master_board_id = args.board_id
if args.board_id == BoardIds.STREAMING_BOARD.value:
master_board_id = int(params.other_info)
board = BoardShim(args.board_id, params)
board.prepare_session()
if args.config_file:
with open(args.config_file) as file:
lines = file.readlines()
for line in lines:
board.config_board(line)
buffer_size = int(
BoardShim.get_sampling_rate(master_board_id) * args.run_time *
1.2) # + 20% for safety
if master_board_id in (BoardIds.CYTON_BOARD.value,
BoardIds.CYTON_WIFI_BOARD.value,
BoardIds.GANGLION_WIFI_BOARD.value):
bytes_per_package = 33
elif master_board_id in (BoardIds.CYTON_DAISY_BOARD,
BoardIds.CYTON_DAISY_WIFI_BOARD.value):
bytes_per_package = 66
elif master_board_id == BoardIds.SYNTHETIC_BOARD.value:
bytes_per_package = 104
elif master_board_id == BoardIds.NOVAXR_BOARD.value:
bytes_per_package = 72
else:
raise ValueError('unsupported board')
timestamp_channel = BoardShim.get_timestamp_channel(master_board_id)
package_num_channel = BoardShim.get_package_num_channel(master_board_id)
try:
cur_id = 0
for i in range(args.num_iters):
# wait for an input
input('Press Enter to continue...')
BoardShim.log_message(
LogLevels.LEVEL_INFO.value,
'\nRunning iteration %d/%d\n' % (i, args.num_iters))
# start stream and get data
board.start_stream(buffer_size, args.streamer_params)
time.sleep(args.run_time)
board.stop_stream()
data = board.get_board_data()
if data.shape[1] == 0:
BoardShim.log_message(LogLevels.LEVEL_WARN.value,
'\nNo data received!\n')
continue
# calculate some metrics
total_bytes_received = bytes_per_package * data.shape[1]
packages_per_sec = float(data.shape[1]) / float(args.run_time)
timestamp_array = data[timestamp_channel]
time_diff_array = list()
for i in range(0, timestamp_array.size - 1):
time_diff_array.append(timestamp_array[i + 1] -
timestamp_array[i])
package_num_array = data[package_num_channel]
lost_packages = 0
expected = package_num_array[0]
while cur_id < package_num_array.size:
if expected == 256:
expected = 0
if package_num_array[cur_id] != expected:
BoardShim.log_message(
LogLevels.LEVEL_WARN.value,
'package loss detected: position %d package_num value %d expected value %d'
% (cur_id, package_num_array[cur_id], expected))
lost_packages = lost_packages + 1
else:
cur_id = cur_id + 1
expected = expected + 1
package_loss = (lost_packages / data.shape[1]) * 100
# provide results for iteration
BoardShim.log_message(LogLevels.LEVEL_INFO.value, '\nResults:\n')
BoardShim.log_message(LogLevels.LEVEL_INFO.value,
'package loss percent %f' % package_loss)
BoardShim.log_message(
LogLevels.LEVEL_INFO.value,
'average time delta %f' % statistics.mean(time_diff_array))
BoardShim.log_message(
LogLevels.LEVEL_INFO.value, 'std deviation of time delta %f' %
statistics.pstdev(time_diff_array))
BoardShim.log_message(LogLevels.LEVEL_INFO.value,
'total packages received %d' % data.shape[1])
BoardShim.log_message(LogLevels.LEVEL_INFO.value,
'packages per sec %f' % packages_per_sec)
BoardShim.log_message(
LogLevels.LEVEL_INFO.value,
'total bytes received %d' % total_bytes_received)
# plot data
eeg_channels = BoardShim.get_eeg_channels(master_board_id)
emg_channels = BoardShim.get_emg_channels(master_board_id)
total_channels = list()
if args.channels is not None:
selected_channels = [int(x) for x in args.channels.split(',')]
temp_channels = eeg_channels
for ch in emg_channels:
if ch not in temp_channels:
temp_channels.append(ch)
for i in range(len(temp_channels)):
if i in selected_channels:
total_channels.append(temp_channels[i])
else:
# for cyton/ganglion eeg_channels and emg_channels are the same array because we can not split it
# for novaxr its 2 different arrays, join them
total_channels = eeg_channels
for ch in emg_channels:
if ch not in total_channels:
total_channels.append(ch)
total_channels.append(timestamp_channel)
columns = list()
for i in range(len(total_channels) - 1):
columns.append('channel_%d' % (int(total_channels[i]) - 1))
columns.append('timestamp')
df = pd.DataFrame(np.transpose(data))
df.to_csv('all_data_%d.csv' % i)
df_to_plot = df[total_channels]
df_to_plot.columns = columns
df_to_plot.to_csv('selected_data_%d.csv' % i)
df_to_plot.plot(subplots=True, x='timestamp', style='.-')
plt.show()
finally:
# release session in the end
board.release_session()
def main():
parser = argparse.ArgumentParser()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port
parser.add_argument('--ip-port',
type=int,
help='ip port',
required=False,
default=0)
parser.add_argument('--ip-protocol',
type=int,
help='ip protocol, check IpProtocolType enum',
required=False,
default=0)
parser.add_argument('--ip-address',
type=str,
help='ip address',
required=False,
default='')
parser.add_argument('--serial-port',
type=str,
help='serial port',
required=False,
default='')
parser.add_argument('--mac-address',
type=str,
help='mac address',
required=False,
default='')
parser.add_argument('--other-info',
type=str,
help='other info',
required=False,
default='')
parser.add_argument('--streamer-params',
type=str,
help='other info',
required=False,
default='')
parser.add_argument(
'--board-id',
type=int,
help='board id, check docs to get a list of supported boards',
required=True)
parser.add_argument('--log', action='store_true')
parser.add_argument('--run-time',
type=int,
help='run time in sec',
required=True)
args = parser.parse_args()
params = BrainFlowInputParams()
params.ip_port = args.ip_port
params.serial_port = args.serial_port
params.mac_address = args.mac_address
params.other_info = args.other_info
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
if (args.log):
BoardShim.enable_dev_board_logger()
else:
BoardShim.disable_board_logger()
# for streaming board need to use master board id
master_board_id = args.board_id
if args.board_id == BoardIds.STREAMING_BOARD.value:
master_board_id = int(params.other_info)
board = BoardShim(args.board_id, params)
board.prepare_session()
buffer_size = int(
BoardShim.get_sampling_rate(master_board_id) * args.run_time *
1.2) # + 20% for safety
board.start_stream(buffer_size, args.streamer_params)
time.sleep(args.run_time)
board.stop_stream()
data = board.get_board_data()
board.release_session()
if master_board_id in (BoardIds.CYTON_BOARD.value,
BoardIds.CYTON_WIFI_BOARD.value,
BoardIds.GANGLION_WIFI_BOARD.value):
bytes_per_package = 33
elif master_board_id in (BoardIds.CYTON_DAISY_BOARD,
BoardIds.CYTON_DAISY_WIFI_BOARD.value):
bytes_per_package = 66
elif master_board_id == BoardIds.SYNTHETIC_BOARD.value:
bytes_per_package = 104
elif master_board_id == BoardIds.NOVAXR_BOARD.value:
bytes_per_package = 72
else:
raise ValueError('unsupported board')
total_bytes_received = bytes_per_package * data.shape[1]
packages_per_sec = float(data.shape[1]) / float(args.run_time)
timestamp_channel = BoardShim.get_timestamp_channel(master_board_id)
timestamp_array = data[timestamp_channel]
time_diff_array = list()
for i in range(0, timestamp_array.size - 1):
time_diff_array.append(timestamp_array[i + 1] - timestamp_array[i])
package_num_channel = BoardShim.get_package_num_channel(master_board_id)
package_num_array = data[package_num_channel]
lost_packages = 0
expected = 0
cur_id = 0
while cur_id < package_num_array.size:
if expected == 256:
expected = 0
if package_num_array[cur_id] != expected:
BoardShim.log_message(
LogLevels.LEVEL_WARN.value,
'package loss detected: position %d package_num value %d expected value %d'
% (cur_id, package_num_array[cur_id], expected))
lost_packages = lost_packages + 1
else:
cur_id = cur_id + 1
expected = expected + 1
package_loss = (lost_packages / data.shape[1]) * 100
BoardShim.log_message(LogLevels.LEVEL_INFO.value, '\nResults:\n')
BoardShim.log_message(LogLevels.LEVEL_INFO.value,
'package loss percent %f' % package_loss)
BoardShim.log_message(
LogLevels.LEVEL_INFO.value,
'average time delta %f' % statistics.mean(time_diff_array))
BoardShim.log_message(
LogLevels.LEVEL_INFO.value,
'std deviation of time delta %f' % statistics.pstdev(time_diff_array))
BoardShim.log_message(LogLevels.LEVEL_INFO.value,
'total packages received %d' % data.shape[1])
BoardShim.log_message(LogLevels.LEVEL_INFO.value,
'packages per sec %f' % packages_per_sec)
BoardShim.log_message(LogLevels.LEVEL_INFO.value,
'total bytes received %d' % total_bytes_received)
eeg_channels = BoardShim.get_eeg_channels(master_board_id)
emg_channels = BoardShim.get_emg_channels(master_board_id)
total_channels = eeg_channels
# for cyton/ganglion eeg_channels and emg_channels are the same array because we can not split it
# for novaxr its 2 different arrays, join them
for ch in emg_channels:
if ch not in total_channels:
total_channels.append(ch)
df = pd.DataFrame(np.transpose(data))
df[total_channels].to_csv('eeg_emg_data.csv')
df.to_csv('all_data.csv')
plt.figure()
df[total_channels].plot(subplots=True)
plt.show()
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))
