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():
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 __init__(self, board_shim):
self.board_id = board_shim.get_board_id()
self.board_shim = board_shim
self.exg_channels = BoardShim.get_exg_channels(self.board_id)
self.sampling_rate = BoardShim.get_sampling_rate(self.board_id)
self.update_speed_ms = 50
self.window_size = 8
self.partial_window_size = 4
self.n_pads = 12
self.noise = np.ones(self.partial_window_size * self.sampling_rate)
self.beta = np.ones(self.partial_window_size * self.sampling_rate)/10
self.alpha = np.ones(self.partial_window_size * self.sampling_rate)/10
self.num_points = self.window_size * self.sampling_rate
self.num_points_partial = self.partial_window_size * self.sampling_rate
self.app = QtGui.QApplication([])
self.win = pg.GraphicsWindow(title='BrainFlow Plot',size=(800, 600))
self._init_timeseries()
timer = QtCore.QTimer()
timer.timeout.connect(self.update)
timer.start(self.update_speed_ms)
QtGui.QApplication.instance().exec_()
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)
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 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 __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)
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 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()
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 __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 _run(self):
self._board = BoardShim(self._device_id, self._brain_flow_input_params)
self._board.set_log_level(0)
self._board.prepare_session()
threading.Thread(target=self._stream_loop).start()
while True:
message = self.message_queue.get()
if message is None:
continue
if message.type == MessageType.START:
if self._state == "START":
print(
"Brainflow streaming has already recorded the START triger"
)
else:
print("Brainflow start")
self.__set_trigger(message)
self._experiment_id = message.experiment_id
self._state = "START"
elif message.type == MessageType.STOP:
if self._state == "STOP":
print(
"Brainflow streaming has already recorded the STOP triger"
)
else:
print("Brainflow stop")
if self._saving_mode == SavingModeEnum.SEPARATED_SAVING_MODE:
self._experiment_id = message.experiment_id
file_name = \
"{0}/{1}-{2}-{3}.csv".format(self.output_path,
self.name,
self._experiment_id,
message.stimulus_id)
self._save_to_file(file_name)
self._stream_data = []
else:
self._experiment_id = message.experiment_id
self.__set_trigger(message)
self._state = "STOP"
elif message.type == MessageType.TERMINATE:
self._terminate = True
if self._saving_mode == SavingModeEnum.CONTINIOUS_SAVING_MODE:
file_name = \
"{0}/{1}-{2}.csv".format(self.output_path,
self.name,
self._experiment_id)
self._save_to_file(file_name)
break
self._board.stop_stream()
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 __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 __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():
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
sensor_wrapper = SensorWrapper(BehaviorSubject(SensorSettings()))
sensor_wrapper.connect()
sleep(5)
data = sensor_wrapper.read_filtered()
sensor_wrapper.disconnect()
# demo how to convert it to pandas DF and plot data
df = pd.DataFrame(data)
print('Data From the Board')
print(df.head(10))
def start_stream(self): """" Start the data stream. If there is already some data displayed, it won't get cleaned. """ if self.timer is None: self.boardShim.start_stream() BoardShim.log_message(LogLevels.LEVEL_INFO.value, "The data stream has started!") self.save_to_file = self.save_to_file_checkbox.isChecked() self.file_path = self.file_path_line_edit.text() self.timer = QTimer() self.timer.timeout.connect(self.read_data) self.timer.start(100)
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 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 eeg_signals():
#获取原始数据，根据采样率大小取出1s的数据
eeg_data = board.get_current_board_data(sampling_rate)[0:9]
# 带通滤波处理（0.5-50），中心频率25.25，带宽49.5
eeg_channels = BoardShim.get_eeg_channels(0)
for count, channel in enumerate(eeg_channels):
eeg_data[channel] = eeg_data[channel] - np.average(eeg_data[channel])
DataFilter.perform_bandpass(eeg_data[channel],
BoardShim.get_sampling_rate(2), 25.25,
49.5, 3, FilterTypes.BESSEL.value, 0)
eeg_data = eeg_data[1:9]
eeg_data = np.array([eeg_data])
pca = UnsupervisedSpatialFilter(PCA(8), average=False)
eeg_data = pca.fit_transform(eeg_data)
eeg_data = eeg_data[0]
return eeg_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(self):
self.board.prepare_session()
self.board.start_stream()
try:
nfft = DataFilter.get_nearest_power_of_two(self.sampling_rate)
eeg_channels = BoardShim.get_eeg_channels(self.board_id)
time.sleep(3)
cv2_thread = threading.Thread(target=self.cv2_video_thread)
audio_thread = threading.Thread(target=self.audio_thread)
cv2_thread.start()
audio_thread.start()
self.player_is_playing = True
signal_freq_coeff = 1.1 # auto adjustable coefficient?
high_signal_freq_coeff = 1.5
data_log_file = open(f'log2-{time.time()}.csv', 'a')
print_bands = []
for channel in self.channels.keys():
print_bands.append(','.join(
[b.name for b in self.channels[channel]]))
data_log_file.write(
f'time,metrics_sum,signal,high_signal,{",".join(print_bands)}')
metrics_hist = []
while self.player_is_playing:
time.sleep(.3)
self.on_next(eeg_channels, nfft)
metrics_sum = 0.0
for metric in self.metrics:
metrics_sum += metric.get_metric()
metrics_hist.append(metrics_sum)
if len(metrics_hist) > 50:
metrics_hist.pop(0)
avg_metrics_hist = sum(metrics_hist) / len(metrics_hist)
self.positive_signal = avg_metrics_hist < metrics_sum * signal_freq_coeff
self.is_last_signal_delta_high = False
if self.positive_signal and avg_metrics_hist < metrics_sum * high_signal_freq_coeff:
self.is_last_signal_delta_high = True
print(
f'{self.positive_signal} {avg_metrics_hist} < {metrics_sum*signal_freq_coeff}'
)
print_bands = []
for channel in self.channels.keys():
print_bands.append(','.join([
str(b.band_current_power)
for b in self.channels[channel]
]))
log_line = f'\n{time.asctime(time.gmtime(time.time()))},{metrics_sum},{self.positive_signal},{self.is_last_signal_delta_high},{",".join(print_bands)}'
data_log_file.write(log_line)
data_log_file.close()
audio_thread.join()
cv2_thread.join()
except Exception as e:
print(e)
self.player_is_playing = False
return
def main(self):
self.board.prepare_session()
self.board.start_stream()
try:
nfft = DataFilter.get_nearest_power_of_two(self.sampling_rate)
eeg_channels = BoardShim.get_eeg_channels(self.board_id)
time.sleep(3)
signals = []
cv2_thread = threading.Thread(target=self.cv2_video_read_thread)
audio_thread = threading.Thread(target=self.audio_thread)
cv2_thread.start()
audio_thread.start()
self.player_is_playing = True
while self.player_is_playing:
signals.append(self.on_next(eeg_channels, nfft))
if len(signals) > 3:
signals.pop(0)
avg_signal = sum(signals) / len(signals)
self.positive_signal = avg_signal < signals[-1]
self.last_signal_delta = abs(avg_signal - signals[-1])
if signals[-1] > 9: # min positive signals
self.positive_signal = True
print(
f'up {self.last_signal_delta}' if avg_signal < signals[-1]
else f'down {self.last_signal_delta}') # enable it later
audio_thread.join()
cv2_thread.join()
except Exception as e:
print(e)
return
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 update(self):
# received_data, addr = sock.recvfrom(1024) # buffer size is 1024 bytes
# print("Received message: ", received_data)
data = self.board_shim.get_current_board_data(self.num_points)
if data[0:7, 0:250].shape == (7, 250):
for count, channel in enumerate(self.exg_channels):
# plot timeseries
DataFilter.perform_lowpass(
data[channel], BoardShim.get_sampling_rate(args.board_id),
high, 3, FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_highpass(
data[channel], BoardShim.get_sampling_rate(args.board_id),
low, 3, FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_bandstop(
data[channel], BoardShim.get_sampling_rate(args.board_id),
50, 2, 8, FilterTypes.BUTTERWORTH.value, 0)
self.curves[count + 1].setData(data[channel][-1001:].tolist())
window = data[0:8, -250:] # input window
window = window - window[3, :] # Cz reference
x = np.vstack((window[0:3, :], window[4:, :]))
x = create_data(x, fs, 1, low, high, n_freqs, zeros,
length) # convert to PSD
x = np.reshape(x, (1, n_channels_ref, n_freqs))
x_csp = csp2.transform(x)
window = np.reshape(window, (1, window.shape[0], window.shape[1]))
x_raw_csp = csp1.transform(window)
inference = np.hstack((x_csp, x_raw_csp))
current_time = datetime.now()
current_time = current_time.strftime("%M:%S")
result.append(model.predict(inference)[0])
MESSAGE = str(model.predict(inference)[0])
MESSAGE = bytes(MESSAGE, 'utf-8')
sock.sendto(MESSAGE, (UDP_IP, UDP_PORT))
pygame.time.delay(100)
self.curves[0].setData(result[-1001:])
self.app.processEvents()
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 getEGG_Data(self): self.__board.stop_stream() data = self.__board.get_board_data() eeg_channels = BoardShim.get_eeg_channels(self.__board_ID) eeg_data = data[eeg_channels] return eeg_data
def __init__(self, board_shim):
self.board_id = board_shim.get_board_id()
self.board_shim = board_shim
self.exg_channels = BoardShim.get_exg_channels(self.board_id)
self.sampling_rate = BoardShim.get_sampling_rate(self.board_id)
self.update_speed_ms = 50
self.window_size = 10
self.num_points = self.window_size * self.sampling_rate
self.plot_names = [
'Quality A2', 'Quality A1', 'Quality C4', 'Quality C3'
]
self.mains = None
self.app = QtGui.QApplication([])
self.win = pg.GraphicsWindow(title='Enophone Live Streaming',
size=(800, 600))
self._init_timeseries()
timer = QtCore.QTimer()
timer.timeout.connect(self.update)
timer.start(self.update_speed_ms)
QtGui.QApplication.instance().exec_()
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 _get_source_info(self):
""" Gets board-specific information from the Brainflow library
Returns:
eeg_channels
sfreq
channel_names
"""
if self.board_type == 'synthetic':
eeg_channels = BoardShim.get_eeg_channels(
BoardIds.SYNTHETIC_BOARD.value)
sfreq = BoardShim.get_sampling_rate(BoardIds.SYNTHETIC_BOARD.value)
channel_names = [
'T7', 'CP5', 'FC5', 'C3', 'C4', 'FC6', 'CP6', 'T8'
]
elif self.board_type == 'cyton':
eeg_channels = BoardShim.get_eeg_channels(
BoardIds.CYTON_BOARD.value)
sfreq = BoardShim.get_sampling_rate(BoardIds.CYTON_BOARD.value)
channel_names = OPENBCI_STANDARD[:9]
elif self.board_type == 'daisy':
eeg_channels = BoardShim.get_eeg_channels(
BoardIds.CYTON_DAISY_BOARD.value)
sfreq = BoardShim.get_sampling_rate(
BoardIds.CYTON_DAISY_BOARD.value)
channel_names = OPENBCI_STANDARD
return [eeg_channels, sfreq, channel_names]
