def convert (old_file, new_file):
with open (old_file) as f:
old_lines = f.readlines ()
x_accel = '0.0'
y_accel = '0.0'
z_accel = '0.0'
with open (new_file, 'w') as f:
for i, line in enumerate (old_lines):
if i == 0:
f.write (line)
elif i == 1:
num_channels = find_int_in_string (line)
f.write (line)
elif i == 2:
# sampling rate from double to int
patched_string = line.replace ('.0 Hz', ' Hz')
sampling_rate = find_int_in_string (patched_string)
f.write (patched_string)
board_class, board_id = get_board_class (num_channels, sampling_rate)
board_line = '%%Board = OpenBCI_GUI$%s\n' % board_class
f.write (board_line)
# need to determine number of rows in new file
num_rows = BoardShim.get_num_rows (board_id.value)
accel_channels = BoardShim.get_accel_channels (board_id.value)
stub_string = ['0.0' for i in range (num_rows + 1)]
write_array (f, stub_string)
# skip other lines in old header
elif line.startswith ('%'):
continue
# start parsing data
else:
line = line.strip ('\n')
data_points = line.split (',')
new_data_points = list ()
# first package and eeg are the same place always
for i in range (1 + num_channels):
new_data_points.append (data_points[i])
i = 1 + num_channels
while i != accel_channels[0]:
i = i + 1
new_data_points.append ('0.0')
# always 3 accel channels
if not compare_floats (float(data_points[i]), 0.0):
x_accel = data_points[i]
y_accel = data_points[i + 1]
z_accel = data_points[i + 2]
new_data_points.append (x_accel)
new_data_points.append (y_accel)
new_data_points.append (z_accel)
i = i + 3
while i < num_rows - 1:
i = i + 1
new_data_points.append ('0.0')
# last two columns timestamps but reversed
new_data_points.append (data_points[-1])
new_data_points.append (data_points[-2])
write_array (f, new_data_points)
plt.tight_layout()
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
params.serial_port = serial_port
params.mac_address = mac_address
board = BoardShim(board_id, params)
board.prepare_session()
board.start_stream()
BoardShim.log_message(LogLevels.LEVEL_INFO.value,
'start sleeping in the main thread')
if (create_csv):
label_list = [None] * BoardShim.get_num_rows(board_id)
label_dict = {
"Battery":
label_extractor(BoardShim.get_battery_channel, board_id, False),
"EEG":
label_extractor(BoardShim.get_eeg_channels, board_id, True),
"EMG":
label_extractor(BoardShim.get_emg_channels, board_id, True),
"ECG":
label_extractor(BoardShim.get_ecg_channels, board_id, True),
"Temperature":
label_extractor(BoardShim.get_temperature_channels, board_id, True),
"Resistance":
label_extractor(BoardShim.get_resistance_channels, board_id, True),
"EOG":
label_extractor(BoardShim.get_eog_channels, board_id, True),
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))
def _start():
"""Start the module
This uses the global variables from setup and adds a set of global variables
"""
global parser, args, config, r, response, patch
global monitor, debug, delay, ft_host, ft_port, ft_output, board_id, streamer_params, params, board
# this can be used to show parameters that have changed
monitor = EEGsynth.monitor(name=name,
debug=patch.getint("general", "debug"))
# get the general options from the configuration file
debug = patch.getint("general", "debug")
delay = patch.getfloat("general", "delay")
try:
ft_host = patch.getstring("fieldtrip", "hostname")
ft_port = patch.getint("fieldtrip", "port")
monitor.success("Trying to connect to buffer on %s:%i ..." %
(ft_host, ft_port))
ft_output = FieldTrip.Client()
ft_output.connect(ft_host, ft_port)
monitor.success("Connected to output FieldTrip buffer")
except:
raise RuntimeError("cannot connect to output FieldTrip buffer")
# get the options that are specific for BrainFlow
board_id = patch.getint("brainflow", "board_id", default=-1)
streamer_params = patch.getstring("brainflow",
"streamer_params",
default=None)
params = BrainFlowInputParams()
params.ip_port = patch.getint("brainflow", "ip_port", default=0)
params.serial_port = patch.getstring("brainflow",
"serial_port",
default="/dev/cu.usbmodem11")
params.mac_address = patch.getstring("brainflow",
"mac_address",
default="")
params.other_info = patch.getstring("brainflow", "other_info", default="")
params.serial_number = patch.getstring("brainflow",
"serial_number",
default="")
params.ip_address = patch.getstring("brainflow", "ip_address", default="")
params.ip_protocol = patch.getint("brainflow", "ip_protocol", default=0)
params.timeout = patch.getint("brainflow", "timeout", default=0)
params.file = patch.getstring("brainflow", "file", default="")
monitor.success("Starting BrainFlow ...")
BoardShim.disable_board_logger()
# BoardShim.enable_board_logger()
# BoardShim.enable_dev_board_logger()
board = BoardShim(board_id, params)
board.prepare_session()
board.start_stream(45000, streamer_params)
# get all data and remove it from internal buffer
board.get_board_data()
monitor.success("Connected to " + board.get_device_name(board_id))
monitor.info("fsample =", board.get_sampling_rate(board_id))
monitor.info("nchans =", board.get_num_rows(board_id))
ft_output.putHeader(board.get_num_rows(board_id),
float(board.get_sampling_rate(board_id)),
FieldTrip.DATATYPE_FLOAT32)
# there should not be any local variables in this function, they should all be global
if len(locals()):
print("LOCALS: " + ", ".join(locals().keys()))
def main():
show_img = None
event_img = None
screen_col = None
counter = 3
#number of trials
trials = 3
event_function = random_prompt()
pygame.time.set_timer(pygame.USEREVENT, 1000)
run = True
print_first = True
raise_indicate = False
clench_indicate = False
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
# for synthetic board:
board_id = BoardIds.SYNTHETIC_BOARD.value
# for openbci ganglion board_id:
#board_id = BoardIds.GANGLION_BOARD.value
#params.serial_port = 'COM3'
#params.mac_address = '12345'
board = BoardShim(board_id, params)
board.prepare_session()
board.start_stream()
BoardShim.log_message(LogLevels.LEVEL_INFO.value,
'start sleeping in the main thread')
label_list = [None] * BoardShim.get_num_rows(board_id)
label_dict = {
"Battery":
label_extractor(BoardShim.get_battery_channel, board_id, False),
"EEG":
label_extractor(BoardShim.get_eeg_channels, board_id, True),
"EMG":
label_extractor(BoardShim.get_emg_channels, board_id, True),
"ECG":
label_extractor(BoardShim.get_ecg_channels, board_id, True),
"Temperature":
label_extractor(BoardShim.get_temperature_channels, board_id, True),
"Resistance":
label_extractor(BoardShim.get_resistance_channels, board_id, True),
"EOG":
label_extractor(BoardShim.get_eog_channels, board_id, True),
"EXG":
label_extractor(BoardShim.get_exg_channels, board_id, True),
"EDA":
label_extractor(BoardShim.get_eda_channels, board_id, True),
"PPG":
label_extractor(BoardShim.get_ppg_channels, board_id, True),
"Accel":
label_extractor(BoardShim.get_accel_channels, board_id, True),
"Analog":
label_extractor(BoardShim.get_analog_channels, board_id, True),
"Gyro":
label_extractor(BoardShim.get_gyro_channels, board_id, True),
"Other":
label_extractor(BoardShim.get_other_channels, board_id, True)
}
for key, value in label_dict.items():
for count, channel in enumerate(value):
label_list[channel] = key + " " + str(count) if len(
value) > 1 else key
with open(output_file, 'w', newline='') as file:
writer = csv.writer(file)
#writer.writerow(np.arange(BoardShim.get_num_rows(board_id)))
writer.writerow([
"Sampling Rate: " + str(BoardShim.get_sampling_rate(board_id)) +
" Hz"
])
writer.writerow(["Board: " + BoardShim.get_device_name(board_id)])
writer.writerow(np.append(np.append(label_list, "Raise"), "Clench"))
while run:
data = board.get_board_data().T
with open(output_file, 'a', newline='') as file:
writer = csv.writer(file)
# if (print_first):
# writer.writerow(np.arange(data[0].size))
# print_first = False
for i in range(data[:, 0].size):
if raise_indicate:
raise_event = 1
else:
raise_event = 0
if clench_indicate:
clench_event = 1
else:
clench_event = 0
writer.writerow(
np.append(np.append(data[i, :], raise_event),
clench_event))
for event in pygame.event.get():
if event.type == pygame.USEREVENT:
show_img, screen_col, event_img, raise_indicate, clench_indicate = event_function(
counter)
counter -= 1
if counter < 0 and trials > 1:
trials -= 1
counter = 3
event_function = random_prompt()
if event.type == pygame.QUIT:
run = False
if screen_col:
WIN.fill(screen_col)
if event_img:
WIN.blit(event_img, (100, 100))
if show_img:
WIN.blit(show_img, (300, 300))
pygame.display.update()
pygame.quit()
board.stop_stream()
board.release_session()
