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 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
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():
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(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 _init_psd(self):
self.psd_plot = self.win.addPlot(row=0,col=1, rowspan=len(self.exg_channels)//2)
self.psd_plot.showAxis('left', False)
self.psd_plot.setMenuEnabled('left', False)
self.psd_plot.setTitle('PSD Plot')
self.psd_plot.setLogMode(False, True)
self.psd_curves = list()
self.psd_size = DataFilter.get_nearest_power_of_two(self.sampling_rate)
for i in range(len(self.exg_channels)):
psd_curve = self.psd_plot.plot(pen=self.pens[i % len(self.pens)])
psd_curve.setDownsampling(auto=True, method='mean', ds=3)
self.psd_curves.append(psd_curve)
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 = .5 # auto adjustable coefficient?
high_signal_freq_coeff = .15
data_log_file = open(f'log-{time.time()}.csv', 'a')
while self.player_is_playing:
time.sleep(.1)
bands_signals = self.on_next(eeg_channels, nfft)
positive_signals_sum = 0.0
negative_signals_sum = 0.0
for i in bands_signals.keys():
if bands_signals[i] > 0:
positive_signals_sum += bands_signals[i]
else:
negative_signals_sum += bands_signals[i]
self.positive_signal = abs(
negative_signals_sum
) < positive_signals_sum * signal_freq_coeff
self.is_last_signal_delta_high = False
if self.positive_signal and positive_signals_sum * high_signal_freq_coeff > abs(
negative_signals_sum):
self.is_last_signal_delta_high = True
print_bands = []
for proto in self.protocol:
print_bands.append(
f'{eeg_channels[proto.channel_inx]},' + ",".join(
[str(b.band_current_power) for b in proto.bands]))
log_line = f'\n{time.asctime(time.gmtime(time.time()))},{positive_signals_sum},{negative_signals_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():
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)
async def capture(self, stream,url, port=None,plot=False, model=None,categories=None,details=None):
# Authenticate
res = self.session.post(url + '/login')
cookies = ""
cookieDict = res.cookies.get_dict()
for cookie in (cookieDict):
cookies += str(cookie + "=" + cookieDict[cookie] + "; ")
o = urlparse(url)
if (o.scheme == 'http'):
uri = "ws://" + o.netloc
elif (o.scheme == 'https'):
uri = "wss://" + o.netloc
else:
print('not a valid url scheme')
async with websockets.connect(uri,ping_interval=None, extra_headers=[('cookie', cookies)]) as websocket:
print('Initializing board')
self.board = initialize_board(stream,port)
print('Starting stream')
self.board.start_stream(num_samples=450000)
self.start_time = time.time()
signal.signal(signal.SIGINT, self.signal_handler)
# # initialise plot and line
# fig = plt.figure()
# ax = fig.add_subplot(1, 1, 1)
# xs = []
# ys = []
# def animate(i, xs, ys):
# data = self.board.get_current_board_data(num_samples=DataFilter.get_nearest_power_of_two(self.board.rate))#1)
# t = data[self.board.time_channel]
# data = data[self.board.eeg_channels][self.channel]
# if len(t) > 0:
# t = t - self.start_time
# DataFilter.perform_highpass(data, self.board.rate, 3.0, 4, FilterTypes.BUTTERWORTH.value, 0)
# self.socket.emit('bci', {'signal':(data).tolist(),
# 'time': (t*1000).tolist()})
# xs.append(t[-1])
# ys.append(data[-1])
# # Limit x and y lists to 20 items
# xs = xs[-20:]
# ys = ys[-20:]
# # Draw x and y lists
# ax.clear()
# ax.plot(xs, ys)
# # Format plot
# plt.xticks(rotation=45, ha='right')
# plt.subplots_adjust(bottom=0.30)
# plt.title('OpenBCI Live Stream')
# plt.ylabel('Voltage')
# ani = animation.FuncAnimation(fig, animate, fargs=(xs, ys), interval=1)
# plt.show()
while True:
# Get Data
pass_data = []
rate = DataFilter.get_nearest_power_of_two(self.board.rate)
data = self.board.get_current_board_data(num_samples=rate)#1)
t = data[self.board.time_channel]
if self.all_channels:
data = data[self.board.eeg_channels] # SCALED
else:
data = data[self.board.eeg_channels][self.channels] # SCALED
for entry in data:
DataFilter.perform_highpass(entry, self.board.rate, 3.0, 4, FilterTypes.BUTTERWORTH.value, 0)
pass_data.append((entry).tolist())
if len(t) > 0:
t = t - self.start_time
message = {
'destination': 'bci',
'data': {'ts_filtered':pass_data}
}
message = json.dumps(message, separators=(',', ':'))
# (Re)Open Websocket Connection
if not websocket.open:
try:
print('Websocket is NOT connected. Reconnecting...')
websocket = await websockets.connect(uri,ping_interval=None, extra_headers=[('cookie', cookies)])
except:
print('Unable to reconnect, trying again.')
await websocket.send(message)
time.sleep(.01)
