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]
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 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 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 ('--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 ()
# disable 2nd channel for cyton use real board to check it, emulator ignores commands
if args.board_id == brainflow.board_shim.BoardIds.CYTON_BOARD.value:
board.config_board ('x2100000X')
board.start_stream ()
time.sleep (10)
data = board.get_board_data ()
board.stop_stream ()
board.release_session ()
eeg_channels = BoardShim.get_eeg_channels (args.board_id)
for count, channel in enumerate (eeg_channels):
if count == 0:
DataFilter.perform_bandpass (data[channel], BoardShim.get_sampling_rate (args.board_id), 15.0, 6.0, 4, FilterTypes.BESSEL.value, 0)
elif count == 1:
DataFilter.perform_bandstop (data[channel], BoardShim.get_sampling_rate (args.board_id), 5.0, 1.0, 3, FilterTypes.BUTTERWORTH.value, 0)
elif count == 2:
DataFilter.perform_lowpass (data[channel], BoardShim.get_sampling_rate (args.board_id), 9.0, 5, FilterTypes.CHEBYSHEV_TYPE_1.value, 1)
elif count == 3:
DataFilter.perform_highpass (data[channel], BoardShim.get_sampling_rate (args.board_id), 3.0, 4, FilterTypes.BUTTERWORTH.value, 0)
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 __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 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')
class CytonBoard(object):
def __init__(self, serial_port):
self.params = BrainFlowInputParams()
self.params.serial_port = serial_port
self.board = BoardShim(BoardIds.CYTON_BOARD.value, self.params)
def start_stream(self):
self.board.prepare_session()
self.board.start_stream()
def stop_stream(self):
self.board.stop_stream()
self.board.release_session()
def poll(self, sample_num):
try:
while self.board.get_board_data_count() < sample_num:
time.sleep(0.02)
except Exception as e:
raise (e)
board_data = self.board.get_board_data()
#df = board_2_df(np.transpose(board_data))
return board_data
def sampling_frequency(self):
sampling_freq = self.board.get_sampling_rate(
BoardIds.CYTON_BOARD.value)
return sampling_freq
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)
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 main ():
BoardShim.enable_board_logger ()
DataFilter.enable_data_logger ()
MLModel.enable_ml_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)
parser.add_argument ('--file', type = str, help = 'file', required = False, default = '')
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
params.file = args.file
board = BoardShim (args.board_id, params)
master_board_id = board.get_board_id ()
sampling_rate = BoardShim.get_sampling_rate (master_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 (int (master_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.KNN.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 ()
class CytonBoard(object):
def __init__(self, serial_port):
self.params = BrainFlowInputParams()
self.params.serial_port = serial_port
self.board = BoardShim(BoardIds.CYTON_BOARD.value, self.params)
def start_stream(self):
self.board.prepare_session()
self.board.start_stream()
def stop_stream(self):
self.board.stop_stream()
self.board.release_session()
def poll(self, sample_num):
try:
while self.board.get_board_data_count() < sample_num:
time.sleep(0.02)
except Exception as e:
raise (e)
board_data = self.board.get_board_data()
DataFilter.write_file(board_data, '.\Data\cyton_data_new.txt',
'a') # 'a' appends; 'w' overwrites
# Could add check to see if file already exists, adding a 1, 2, etc. on the end to avoid conflict
# Could use date function for generating names based on date-time.
df = board_2_df(np.transpose(board_data))
#print('/n')
#print(df)
return df
def sampling_frequency(self):
sampling_freq = self.board.get_sampling_rate(
BoardIds.CYTON_BOARD.value)
return sampling_freq
class CytonBoard(object):
def __init__(self, file):
self.params = BrainFlowInputParams()
#self.params.serial_port = serial_port
self.params.file = file
self.params.other_info = str(BoardIds.CYTON_BOARD.value)
self.board = BoardShim(BoardIds.PLAYBACK_FILE_BOARD.value, self.params)
def start_stream(self):
self.board.prepare_session()
#self.board.config_board ('loopback_true')
self.board.config_board('old_timestamps')
self.board.start_stream()
def stop_stream(self):
self.board.stop_stream()
self.board.release_session()
def poll(self, sample_num):
try:
while self.board.get_board_data_count() < sample_num:
time.sleep(0.02)
except Exception as e:
raise (e)
#print(self.board.get_board_data_count())
board_data = self.board.get_board_data()
#df = board_2_df(np.transpose(board_data))
return board_data
def sampling_frequency(self):
sampling_freq = self.board.get_sampling_rate(
BoardIds.CYTON_BOARD.value)
return sampling_freq
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 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()
def start_recording(total_sec, max_samples, params, args):
board = BoardShim(args.board_id, params)
board.prepare_session()
# board.start_stream () # use this for default options
board.start_stream(max_samples, args.streamer_params)
time.sleep(total_sec)
# 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
timestamp_channel = board.get_timestamp_channel(board_id=0)
board.stop_stream()
board.release_session()
# demo how to convert it to pandas DF and plot data
eeg_channels = BoardShim.get_eeg_channels(args.board_id)
print(eeg_channels)
df = pd.DataFrame(np.transpose(data))
plt.figure()
df[eeg_channels].plot(subplots=True)
plt.savefig('data/before_processing.png')
# for demo apply different filters to different channels, in production choose one
for count, channel in enumerate(eeg_channels):
DataFilter.perform_lowpass(data[channel],
BoardShim.get_sampling_rate(args.board_id),
30, 3, FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_highpass(data[channel],
BoardShim.get_sampling_rate(args.board_id),
5, 3, FilterTypes.BUTTERWORTH.value, 0)
DataFilter.perform_bandstop(data[channel],
BoardShim.get_sampling_rate(args.board_id),
50, 2, 8, FilterTypes.BUTTERWORTH.value, 0)
df = pd.DataFrame(np.transpose(
data[:, 1000:])) # Usable after 1000 given order of filters are 3
plt.figure()
df[eeg_channels].plot(subplots=True)
plt.savefig('data/after_processing.png')
return data, timestamp_channel
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,
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 filter_data(self):
""""
Filters the current EEG data. Uses raw data from unfiltered_data array and updates the filtered_data array.
"""
# Subtract average from data
self.filtered_data = self.unfiltered_data - self.eeg_average.compute_average()
if self.eeg_average.count > 2 * self.config.window_size():
print("Clearing average...")
self.eeg_average.reset()
if self.notch_filter_checkbox.isChecked():
# Notch filter
DataFilter.perform_bandstop\
(self.filtered_data, BoardShim.get_sampling_rate(global_config.BOARD_ID),
self.config.notch_freq, 2, 4, FilterTypes.BUTTERWORTH.value, 0)
# Bandpass filter
band_width = self.config.bandpass_max_freq - self.config.bandpass_min_freq
band_center = self.config.bandpass_min_freq + band_width / 2
DataFilter.perform_bandpass(self.filtered_data, BoardShim.get_sampling_rate(global_config.BOARD_ID),
band_center, band_width, 4,
FilterTypes.BUTTERWORTH.value, 0)
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 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 gen_EEG_wifi_LSL(lslname='eeg1A'):
args = {
"ip_port": 2190,
"serial_port": "",
"mac_address": "",
"other_info": "",
"serial_number": "",
"ip_address": "192.168.4.1", #这个ip地址需要查看openbci板子的ip
"ip_protocol": 2,
"timeout": 0,
"file": "",
"log": True,
"streamer_params": "",
"board_id": -1,
}
args['board_id'] = 5
eegchannelsnums = 8
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']
params.file = args['file']
# self.str.set("ss" + self.eegserialport)
if (args['log']):
BoardShim.enable_dev_board_logger()
else:
BoardShim.disable_board_logger()
eegboard = BoardShim(args['board_id'], params)
eegboard.prepare_session()
# eegboard.config_board('~6')
sample = eegboard.get_sampling_rate(eegboard.get_board_id())
#print('sample:',sample)
eegboard.start_stream(45000, "")
lslinfo = StreamInfo(lslname, 'EEG', eegchannelsnums, sample, 'float32',
'brain01')
lsloutlet = StreamOutlet(lslinfo)
sendeegThead = SendData(eegboard, lsloutlet)
sendeegThead.start()
def prepare_data():
# use different windows, its kinda data augmentation
window_sizes = [4.0, 6.0, 8.0, 10.0]
overlaps = [0.5, 0.45, 0.4, 0.35] # percentage of window_size
dataset_x = list()
dataset_y = list()
for data_type in ('relaxed', 'focused'):
for file in glob.glob(os.path.join('data', data_type, '*', '*.csv')):
print(file)
board_id = os.path.basename(os.path.dirname(file))
try:
board_id = int(board_id)
data = DataFilter.read_file(file)
sampling_rate = BoardShim.get_sampling_rate(board_id)
eeg_channels = get_eeg_channels(board_id)
for num, window_size in enumerate(window_sizes):
if data_type == 'focused':
cur_pos = sampling_rate * 10 # skip a little more for focus
else:
cur_pos = sampling_rate * 3
while cur_pos + int(
window_size * sampling_rate) < data.shape[1]:
data_in_window = data[:, cur_pos:cur_pos +
int(window_size * sampling_rate)]
bands = DataFilter.get_avg_band_powers(
data_in_window, eeg_channels, sampling_rate, True)
feature_vector = np.concatenate((bands[0], bands[1]))
dataset_x.append(feature_vector)
if data_type == 'relaxed':
dataset_y.append(0)
else:
dataset_y.append(1)
cur_pos = cur_pos + int(
window_size * overlaps[num] * sampling_rate)
except Exception as e:
print(str(e))
print('Class 1: %d Class 0: %d' % (len([x for x in dataset_y if x == 1]),
len([x for x in dataset_y if x == 0])))
with open('dataset_x.pickle', 'wb') as f:
pickle.dump(dataset_x, f, protocol=3)
with open('dataset_y.pickle', 'wb') as f:
pickle.dump(dataset_y, f, protocol=3)
return dataset_x, dataset_y
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)
# demo for transforms
for count, channel in enumerate(eeg_channels):
print('Original data for channel %d:' % channel)
print(data[channel])
# demo for wavelet transforms
# wavelet_coeffs format is[A(J) D(J) D(J-1) ..... D(1)] where J is decomposition level, A - app coeffs, D - detailed coeffs
# lengths array stores lengths for each block
wavelet_coeffs, lengths = DataFilter.perform_wavelet_transform(
data[channel], 'db5', 3)
app_coefs = wavelet_coeffs[0:lengths[0]]
detailed_coeffs_first_block = wavelet_coeffs[lengths[0]:lengths[1]]
# you can do smth with wavelet coeffs here, for example denoising works via thresholds
# for wavelets coefficients
restored_data = DataFilter.perform_inverse_wavelet_transform(
(wavelet_coeffs, lengths), data[channel].shape[0], 'db5', 3)
print('Restored data after wavelet transform for channel %d:' %
channel)
print(restored_data)
# demo for fft, len of data must be a power of 2
fft_data = DataFilter.perform_fft(data[channel],
WindowFunctions.NO_WINDOW.value)
# len of fft_data is N / 2 + 1
restored_fft_data = DataFilter.perform_ifft(fft_data)
print('Restored data after fft for channel %d:' % channel)
print(restored_fft_data)
def test():
if request.method == 'GET':
# sample的存放地址
# data_path = 'C:\\Users\\zzzal\\Desktop\\'
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board = BoardShim(BoardIds.SYNTHETIC_BOARD.value, params)
sampling = board.get_sampling_rate(BoardIds.SYNTHETIC_BOARD.value)
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_channels = [1, 2, 3, 4, 5, 6, 7, 8]
eeg_data = data[eeg_channels, :]
eeg_data = eeg_data / 1000000 # BrainFlow returns uV, convert to V for MNE
# time=data.values[0::,1]
xtime = [i / sampling for i in range(eeg_data.shape[1])]
xtime = np.array(xtime)
xtime.astype(np.float32)
i = len(xtime) - 1
while (i > 0):
xtime[i] = xtime[i] - xtime[i - 1]
i -= 1
i = 1
xtime[0] = 0
while (i < len(xtime)):
xtime[i] += xtime[i - 1]
i += 1
xtime = xtime.tolist()
return render_template("chart.html",
time=xtime,
one=eeg_data[0].tolist(),
two=eeg_data[1].tolist(),
three=eeg_data[2].tolist(),
four=eeg_data[3].tolist(),
five=eeg_data[4].tolist(),
six=eeg_data[5].tolist(),
seven=eeg_data[6].tolist(),
eight=eeg_data[7].tolist())
def main():
BoardShim.enable_board_logger()
DataFilter.enable_data_logger()
MLModel.enable_ml_logger()
params = BrainFlowInputParams()
board = BoardShim(BoardIds.BRAINBIT_BOARD.value, params)
master_board_id = board.get_board_id()
sampling_rate = BoardShim.get_sampling_rate(master_board_id)
board.prepare_session()
board.start_stream(45000, '')
eeg_channels = BoardShim.get_eeg_channels(int(master_board_id))
while True:
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()
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.KNN.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()
board.stop_stream()
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 = 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 resize_visible_window(self, visible_seconds: int, notify_listener=True):
""""
Change the size of the visible window
"""
print("Resizing window, new size = {} sec".format(visible_seconds))
new_window_size = visible_seconds * BoardShim.get_sampling_rate(global_config.BOARD_ID)
current_window_size = self.unfiltered_data.shape[0] - self.INTERNAL_BUFFER_EXTRA_SIZE
self.config.set_visible_seconds(visible_seconds, notify_owner=False, notify_listener=notify_listener)
if new_window_size == current_window_size:
return
difference = int(abs(new_window_size - current_window_size))
if new_window_size > current_window_size:
self.unfiltered_data = np.concatenate((np.zeros(difference), self.unfiltered_data))
else:
self.unfiltered_data = self.unfiltered_data[difference:]
self.filter_data()
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_board_data()
board.stop_stream()
board.release_session()
eeg_channels = BoardShim.get_eeg_channels(board_id)
bands = DataFilter.get_avg_band_powers(data, eeg_channels, sampling_rate,
True)
print("avg band powers : %s" % str(bands[0]))
print("stddev band powers : %s" % str(bands[1]))
def __init__(self, board_shim):
pg.setConfigOption('background', 'w')
pg.setConfigOption('foreground', 'k')
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 = 4
self.num_points = self.window_size * self.sampling_rate
self.app = QtGui.QApplication([])
self.win = pg.GraphicsWindow(title='BrainFlow Plot',size=(800, 600))
self._init_pens()
self._init_timeseries()
self._init_psd()
self._init_band_plot()
timer = QtCore.QTimer()
timer.timeout.connect(self.update)
timer.start(self.update_speed_ms)
QtGui.QApplication.instance().exec_()
