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 ()
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 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 ('--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 ('--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.serial_number = args.serial_number
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
params.timeout = args.timeout
BoardShim.enable_dev_board_logger ()
board = BoardShim (args.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 (20) # get 20 latest data points dont remove them from internal buffer
board.stop_stream ()
board.release_session ()
# demo how to convert it to pandas DF and plot data
# eeg_channels = BoardShim.get_eeg_channels (BoardIds.SYNTHETIC_BOARD.value)
df = pd.DataFrame (np.transpose (data))
print ('Data From the Board')
print (df.head (10))
# demo for data serialization using brainflow API, we recommend to use it instead pandas.to_csv()
DataFilter.write_file (data, 'test.csv', 'w') # use 'a' for append mode
restored_data = DataFilter.read_file ('test.csv')
restored_df = pd.DataFrame (np.transpose (restored_data))
print ('Data From the File')
print (restored_df.head (10))
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 main ():
parser = argparse.ArgumentParser ()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port
# https://brainflow.readthedocs.io/en/stable/SupportedBoards.html#supported-boards-label
# board_id: 1
# serial_port field of BrainFlowInputParams structure
# mac_address field of BrainFlowInputParams structure, if its empty BrainFlow will try to autodiscover Ganglion
# optional: timeout field of BrainFlowInputParams structure, default is 15sec
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 = '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
params.timeout = args.timeout
if (args.log):
BoardShim.enable_dev_board_logger ()
else:
BoardShim.disable_board_logger ()
board = BoardShim (args.board_id, params)
board.prepare_session ()
# board.start_stream () # use this for default options
board.start_stream (45000, args.streamer_params)
# time.sleep (1)
# 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
board.stop_stream ()
board.release_session ()
print (data)
def main():
BoardShim.enable_dev_board_logger()
logging.basicConfig(level=logging.DEBUG)
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=False, default=BoardIds.SYNTHETIC_BOARD)
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
try:
board_shim = BoardShim(args.board_id, params)
board_shim.prepare_session()
board_shim.start_stream(450000, 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 main():
BoardShim.enable_dev_board_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)
board.prepare_session()
# board.start_stream () # use this for default options
board.start_stream(45000, args.streamer_params)
time.sleep(10)
# 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
board.stop_stream()
board.release_session()
print(data)
import brainflow
from brainflow.board_shim import BoardShim, BrainFlowInputParams, BoardIds
from brainflow.data_filter import DataFilter, FilterTypes, AggOperations
import time
import math
import threading
BOARD_ID = 10
CHANNEL = 1
params = BrainFlowInputParams()
params.timeout = 15
BoardShim.enable_dev_board_logger()
board = BoardShim(BOARD_ID, params)
board.prepare_session()
board.start_stream()
history_data = []
def get_data_raw():
data = board.get_current_board_data(5)
while len(data[CHANNEL]) == 0:
time.sleep(0.1)
return data[CHANNEL]
def get_data():
import brainflow
from brainflow.board_shim import BoardShim, BrainFlowInputParams, BoardIds
from brainflow.data_filter import DataFilter, FilterTypes, AggOperations
import time
import math
BOARD_ID = 10 # BoardIds.SYNTHETIC_BOARD # BRAINBIT_BOARD
CHANNEL = 1
params = BrainFlowInputParams()
params.timeout = 15 # discovery timeout (seconds)
BoardShim.enable_dev_board_logger()
board = BoardShim(BOARD_ID, params)
board.prepare_session()
board.start_stream()
def get_data_row():
data = board.get_current_board_data(5)
#data = board.get_board_data()
while len(data[CHANNEL]) == 0:
time.sleep(0.1)
# return 2 ** max(min(11, math.floor(math.log2(max(map(abs, data[CHANNEL]))))), 40);
mi=min(data[CHANNEL])
ma=max(data[CHANNEL])
res=ma
if(abs(mi)>abs(ma)):
res=mi
return res
def get_data_3():
def get_input():
parser = argparse.ArgumentParser()
parser.add_argument('--runtime',
type=int,
help='max time to sleep in the main thread in seconds',
default=1800,
required=False)
# brainflow args
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=False,
default=int(BoardIds.ENOPHONE_BOARD))
parser.add_argument('--file',
type=str,
help='file',
required=False,
default='')
# spotify args
parser.add_argument('--redirect-uri', type=str, default=None)
parser.add_argument('--client-id', type=str, default=None)
parser.add_argument('--client-secret', type=str, default=None)
parser.add_argument('--username', type=str, 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.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
token = util.prompt_for_user_token(args.username,
scope='user-read-currently-playing',
client_id=args.client_id,
client_secret=args.client_secret,
redirect_uri=args.redirect_uri)
return args.board_id, params, token, args.runtime
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():
"""Main method to start the app and responsible to receive and process args"""
BoardShim.enable_dev_board_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=True,
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
global board
global input
board = BoardShim(args.board_id, params)
input = args.streamer_params
start_test()
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('--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='')
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.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
if (args.log):
BoardShim.enable_dev_board_logger()
else:
BoardShim.disable_board_logger()
board = BoardShim(args.board_id, params)
board.prepare_session()
# board.start_stream () # use this for default options
board.start_stream(45000, args.streamer_params)
data = np.empty(shape=(31, 0))
print('Started streaming')
start_time = time.time()
while True:
try:
# data = board.get_current_board_data (256) # get latest 256 packages or less, doesnt remove them from internal buffer
new_data = board.get_board_data()
print('new data shape is ' + str(new_data.shape))
data = np.concatenate(
(data, new_data),
axis=-1) # get all data and remove it from internal buffer
except KeyboardInterrupt:
f_sample = data.shape[-1] / (time.time() - start_time)
print('Stopped streaming, sampling rate = ' + str(f_sample))
break
board.stop_stream()
board.release_session()
print(data)
return data
def main():
# =========================================== Boiler Plate Code
BoardShim.enable_dev_board_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
# =========================================== Experiment Setup
# Change the resolution based on your machine: (height x width x channels)
window_size = (960, 1920, 3)
# Define the points that form the polygons of the arrow
up_body_pts = [(870, 350), (870, 900), (1050, 900), (1050, 350)]
up_head_pts = [(960, 50), (745, 350), (1175, 350)]
# (x,y) coordinates of the center of the screen
center = (960, 480)
# Make an image of an arrow pointing up
up_arrow = np.zeros(window_size, np.uint8)
body = np.array(up_body_pts, np.int32)
head = np.array(up_head_pts, np.int32)
make_arrow(up_arrow, head, body)
# Make an image of an arrow pointing down
down_arrow = np.zeros(window_size, np.uint8)
body = np.array(rotate(up_body_pts, center, 180), np.int32)
head = np.array(rotate(up_head_pts, center, 180), np.int32)
make_arrow(down_arrow, head, body)
# Make an image of an arrow pointing left
left_arrow = np.zeros(window_size, np.uint8)
body = np.array(rotate(up_body_pts, center, 270), np.int32)
head = np.array(rotate(up_head_pts, center, 270), np.int32)
make_arrow(left_arrow, head, body)
# Make an image of an arrow pointing right
right_arrow = np.zeros(window_size, np.uint8)
body = np.array(rotate(up_body_pts, center, 90), np.int32)
head = np.array(rotate(up_head_pts, center, 90), np.int32)
make_arrow(right_arrow, head, body)
# Make a blank screen with black background
blank_screen = np.zeros(window_size, np.uint8)
# Make an image of a fixation cross on a black background
blank_cross = np.copy(blank_screen)
make_cross(blank_cross, 10)
# Organize all images in a list
visual_cues = [blank_screen, up_arrow, down_arrow, left_arrow, right_arrow]
# Generate a random sequence of 48 visual cues ensuring that the cues are uniformly distributed:
rand_seq = [1, 2, 3, 4]
rand_seq = np.repeat(rand_seq, 4)
rand_seq = np.random.permutation(rand_seq)
# Show a blank screen and immediately move the window to the upper left corner so that it occupies the entire screen
cv.imshow('window', blank_screen)
cv.moveWindow('window', 0, 0)
cv.waitKey(1)
# Make a board object and let the API initialize the board
board = BoardShim(args.board_id, params)
board.prepare_session()
# 50 trials/session * 8 sec/trial * 250 samples/sec = 100 000 * SF = 1.25 = 125000 samples in buffer
board.start_stream(125000, args.streamer_params)
# =========================================== Running the Experiment
for code in rand_seq:
# Display blank screen for 2 seconds
board.insert_marker(6)
cv.imshow('window', blank_screen)
cv.waitKey(2000)
# Display blank screen with fixation cross for 2 seconds
board.insert_marker(5)
cv.imshow('window', blank_cross)
cv.waitKey(2000)
# Display visual cue with fixation cross for 1.25 seconds followed by fixation cross for 2.75 seconds
board.insert_marker(code)
cv.imshow('window', visual_cues[code])
cv.waitKey(1250)
cv.imshow('window', blank_cross)
cv.waitKey(2750)
cv.destroyAllWindows()
# Get all the data stored in the buffer and terminate all background processes
data = board.get_board_data()
board.stop_stream()
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 ('--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 ('--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.serial_number = args.serial_number
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
params.timeout = args.timeout
if (args.log):
BoardShim.enable_dev_board_logger ()
else:
BoardShim.disable_board_logger ()
board = BoardShim (args.board_id, params)
board.prepare_session ()
board.start_stream (45000, args.streamer_params)
model = P300ClassifierLDA()
model.load("test-model")
figlet = Figlet(font='slant')
stopped = True
raw = None
time.sleep(3)
while stopped:
try:
with mne.utils.use_log_level('error'):
# time.sleep(MICROSECONDS_BEFORE_STIMULUS / 1000)
# show_stimulus()
# time.sleep(MICROSECONDS_AFTER_STIMULUS / 1000)
data = board.get_current_board_data(SAMPLES_TOTAL) # TODO constant from model
raw = create_raw(data, model)
prediction = prepare_raw(raw, model)
print_prediction(figlet, prediction)
except KeyboardInterrupt:
print("Got keyboard interrupt, stopping...")
break
board.stop_stream ()
board.release_session ()
def initialise_brainflow():
BoardShim.enable_dev_board_logger()
parser = 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
params.board_id = args.board_id
return params, args
