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 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()
import brainflow
from brainflow.board_shim import BoardShim, BrainFlowInputParams, BoardIds
from brainflow.data_filter import DataFilter, FilterTypes, AggOperations
import json
import asyncio
import random
import struct
import time
import threading
import websockets
BOARD_ID = BoardIds.CALLIBRI_EMG_BOARD.value
EEG_CHANNELS = BoardShim.get_emg_channels(BOARD_ID)
session_id = "".join(random.choice("abcdefghijklmnopqrstuvwxyz") for _ in range(10))
print("Session ID:", session_id)
markers = []
markers_filename = "data/" + session_id + ".json"
data_filename = "data/" + session_id + ".csv"
alive_sockets = []
all_data = []
loop = None
def ws_server():
global loop
def __init__(self,
debug=False,
display=True,
num_channels=None,
wifi=True):
# make audio stream
self.audio_stream = sd.InputStream(device=None,
channels=1,
samplerate=16000)
# make emg stream
params = BrainFlowInputParams()
if debug:
board_id = -1 # synthetic
sample_rate = 256
elif not wifi:
board_id = BoardIds.CYTON_BOARD.value
params.serial_port = '/dev/ttyUSB0'
sample_rate = 250
else:
board_id = BoardIds.CYTON_WIFI_BOARD.value
params.ip_port = 8001
params.ip_address = '192.168.4.1'
sample_rate = 1000
self.emg_channels = BoardShim.get_emg_channels(board_id)
if num_channels is not None:
self.emg_channels = self.emg_channels[:num_channels]
board = BoardShim(board_id, params)
board.prepare_session()
board.config_board('/3') # configure for digital read
board.start_stream()
self.board = board
# config and make data holders
audio_multiplier = int(16000 / sample_rate)
window = sample_rate * 5
self.audio_data = []
self.emg_data = []
self.button_data = []
self.debug = debug
self.previous_sample_number = -1
# plot setup
self.display = display
if display:
plt.ion()
fig, (audio_ax, emg_ax) = plt.subplots(2)
audio_ax.axis((0, window * audio_multiplier, -1, 1))
emg_ax.axis((0, window, -300, 300))
audio_lines = audio_ax.plot(np.zeros(window * audio_multiplier))
emg_lines = emg_ax.plot(np.zeros((window, len(self.emg_channels))))
for l, c in zip(emg_lines, [
'grey', 'mediumpurple', 'blue', 'green', 'yellow',
'orange', 'red', 'sienna'
]):
l.set_color(c)
text = emg_ax.text(50, -250, 'RMS: 0')
for ax in (audio_ax, emg_ax):
ax.set_yticks([0])
ax.yaxis.grid(True)
ax.tick_params(bottom=False,
top=False,
labelbottom=False,
right=False,
left=False,
labelleft=False)
fig.tight_layout(pad=0)
def update_plot(frame):
""" This is called by matplotlib for each plot update. """
audio_to_plot = get_last_sequence(self.audio_data,
window * audio_multiplier, 1,
False, sample_rate)
audio_to_plot = audio_to_plot.squeeze(1)
audio_lines[0].set_ydata(audio_to_plot)
emg_to_plot = get_last_sequence(self.emg_data, window,
len(self.emg_channels), True,
sample_rate)
for column, line in enumerate(emg_lines):
line.set_ydata(emg_to_plot[:, column])
text.set_text('RMS: ' +
str(emg_to_plot[-sample_rate * 2:-sample_rate //
2].std()))
return audio_lines + emg_lines
self.ani = FuncAnimation(fig, update_plot, interval=30)
