def main():
BoardShim.enable_dev_board_logger()
parser = argparse.ArgumentParser()
parser.add_argument('--serial-port',
type=str,
help='serial port',
required=True)
args = parser.parse_args()
params = BrainFlowInputParams()
params.serial_port = args.serial_port
board = BoardShim(BoardIds.CYTON_BOARD, params)
try:
board.prepare_session()
resp = board.config_board('?')
print(resp)
# check that there is a response if streaming is off
if not resp:
raise ValueError('resp is None')
board.start_stream()
time.sleep(5)
resp = board.config_board('?')
print(resp)
# check that there is no response if streaming is on
if resp:
raise ValueError('resp is not None')
finally:
if board.is_prepared():
board.release_session()
def main():
BoardShim.enable_dev_board_logger()
# use my board for demo
params = BrainFlowInputParams()
params.serial_port = '/dev/ttyUSB0'
board = BoardShim(BoardIds.CYTON_BOARD.value, params)
board.prepare_session() # some question
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
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(BoardIds.CYTON_DAISY_BOARD.value)
print(data.shape)
print(data[0])
print(data[1])
print(type(data[1, 0]))
#df = pd.DataFrame(np.transpose(data))
#df = pd.DataFrame(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()
np.savetxt("foo3.csv", np.transpose(data), fmt='%10.7f', delimiter=",")
def __init__(self, boardID, serial_port):
self.serial_port = serial_port
params = BrainFlowInputParams()
params.serial_port = serial_port
BoardShim.disable_board_logger ()
self.board = BoardShim (boardID, params)
self.board.prepare_session()
def __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 ():
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 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():
app = QApplication([])
app.setStyle(global_config.APP_STYLE)
BoardShim.enable_board_logger()
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
params.serial_port = utils.cyton_port()
board = BoardShim(global_config.BOARD_ID, params)
# Switch to using white background and black foreground
pg.setConfigOption('background', 'w')
pg.setConfigOption('foreground', 'k')
window = MainWindow(app, board=board, screen_width=app.primaryScreen().size().width(), channel_count=6)
window.show()
board.prepare_session()
app.exec()
print("Release session")
board.release_session()
def __init__(self, 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 __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,
channels_order: List[str] = None,
board_type: str = "cyton-daisy",
name: Optional[str] = None,
output_path: str = "output",
serial_port=None):
self.channels = channels_order
if board_type == "cyton-daisy":
device_id = 2
sampling_rate = 125
if self.channels is None:
self.channels = \
["ch1", "ch2", "ch3", "ch4", "ch5", "ch6", "ch7", "ch8", "ch9",
"ch10", "ch11", "ch12", "ch13", "ch14", "ch15", "ch16"]
if len(self.channels) != 16:
raise RuntimeError(
"The number of channels in channels_order should be 16")
elif board_type == "cyton":
device_id = 0
sampling_rate = 250
self.channels = \
["ch1", "ch2", "ch3", "ch4", "ch5", "ch6", "ch7", "ch8"]
if len(self.channels) != 8:
raise RuntimeError(
"The number of channels in channels_order should be 8")
elif board_type == "Ganglion":
device_id = 1
sampling_rate = 200
self.channels = \
["ch1", "ch2", "ch3", "ch4"]
if len(self.channels) != 4:
raise RuntimeError(
"The number of channels in channels_order should be 4")
else:
raise RuntimeError("Use BrainflowStreaming fr other boards")
if serial_port is None:
if platform.system() == "Linux":
serial_port = "/dev/ttyUSB0"
elif platform.system() == "Windows":
serial_port = "Com3"
else:
serial_port = "/dev/cu.*"
params = BrainFlowInputParams()
params.serial_port = serial_port
super().__init__(device_id,
sampling_rate,
brain_flow_input_params=params,
name=name,
output_path=output_path)
def __init__(self, video_path):
self.windowName = "Neurofeedback"
self.video_path = video_path
self.audio_start_time_sec = time.time()
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
params.serial_port = "/dev/ttyUSB0"
self.board_id = BoardIds.CYTON_DAISY_BOARD.value
self.sampling_rate = BoardShim.get_sampling_rate(self.board_id)
self.board = BoardShim(self.board_id, params)
self.player_is_playing = False
self.positive_signal = True
self.last_signal_delta = 0
self.signals = []
def main ():
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')
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 ()
board.start_stream ()
print('Session Started')
for x in range(2):
time.sleep (5)
board.config_board ('/2') # enable analog mode only for Cyton Based Boards!
time.sleep (5)
data = board.get_board_data ()
board.stop_stream ()
board.release_session ()
"""
data[BoardShim.get_other_channels(args.board_id)[0]] contains cyton end byte
data[BoardShim.get_other_channels(args.board_id)[1....]] contains unprocessed bytes
if end byte is 0xC0 there are accel data in data[BoardShim.get_accel_channels(args.board_id)[....]] else there are zeros
if end byte is 0xC1 there are analog data in data[BoardShim.get_analog_channels(args.board_id)[....]] else there are zeros
"""
print (data[BoardShim.get_other_channels(args.board_id)[0]][0:5]) # should be standard end byte 0xC0
print (data[BoardShim.get_other_channels(args.board_id)[0]][-5:]) # should be analog and byte 0xC1
DataFilter.write_file (data, 'cyton_data_new.txt', 'w')
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 ():
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 recordData(serial_port, board_id=0, samples=500):
params = BrainFlowInputParams()
params.serial_port = serial_port
board = BoardShim(board_id, params)
board.prepare_session()
board.start_stream(samples + 1)
time.sleep(2.5)
data = board.get_board_data()
board.stop_stream()
board.release_session()
data = data[:7].T
return 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 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)
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
synth_params = BrainFlowInputParams ()
if (args.log):
BoardShim.enable_dev_board_logger ()
else:
BoardShim.disable_board_logger ()
board = BoardShim (args.board_id, params)
synth_board = BoardShim (brainflow.board_shim.BoardIds.SYNTHETIC_BOARD.value, synth_params)
board.prepare_session ()
synth_board.prepare_session ()
board.start_stream ()
synth_board.start_stream ()
time.sleep (10)
data = board.get_board_data ()
synth_data = synth_board.get_board_data ()
board.stop_stream ()
synth_board.stop_stream ()
# board.release_session () # test that we handle it correctly
synth_board.release_session ()
def main():
app = QApplication([])
app.setStyle(global_config.APP_STYLE)
BoardShim.enable_board_logger()
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
params.serial_port = utils.cyton_port()
board = BoardShim(global_config.BOARD_ID, params)
window = TrialConductor(board)
window.show()
if not board.is_prepared():
print("Preparing board from trial gui")
board.prepare_session()
app.exec()
board.release_session()
def main():
app = QApplication([])
app.setStyle(global_config.APP_STYLE)
BoardShim.enable_board_logger()
params = BrainFlowInputParams()
params.serial_port = utils.cyton_port()
board = BoardShim(global_config.BOARD_ID, params)
# Switch to using white background and black foreground
pg.setConfigOption('background', 'w')
pg.setConfigOption('foreground', 'k')
window = ResonanceFrequencyFinder(board)
window.show()
board.prepare_session()
app.exec()
board.release_session()
def __init__(self,
device_id,
header=None,
serial_port="/dev/ttyUSB0",
saving_mode=SavingModeEnum.CONTINIOUS_SAVING_MODE,
**kwargs):
super().__init__(**kwargs)
self._saving_mode = saving_mode
self._stream_data = []
params = BrainFlowInputParams()
params.serial_port = serial_port
self.header = header
self._board = BoardShim(device_id, params)
self._board.set_log_level(0)
self._board.prepare_session()
self._terminate = False
self._trigger = None
self._experiment_id = None
self.output_path = os.path.join(self.output_path, self.name)
os.makedirs(self.output_path, exist_ok=True)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--serial-port',
type=str,
help='serial port',
required=True)
parser.add_argument('--mac-address',
type=str,
help='mac address',
required=False,
default='')
args = parser.parse_args()
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
params.serial_port = args.serial_port
params.mac_address = args.mac_address
board = BoardShim(BoardIds.GANGLION_BOARD.value, params)
board.prepare_session()
# expected result: 5 seconds of resistance data(unknown sampling rate) after that 5 seconds of exg data
board.config_board('z')
board.start_stream(45000, 'file://raw_data.csv:w')
time.sleep(5)
board.config_board('Z')
time.sleep(5)
data = board.get_board_data()
board.stop_stream()
board.release_session()
print(data)
resistance_channels = BoardShim.get_resistance_channels(
BoardIds.GANGLION_BOARD.value)
print(resistance_channels)
import time from brainflow.board_shim import BoardShim, BrainFlowInputParams BoardShim.enable_dev_board_logger() params = BrainFlowInputParams() params.ip_port = 6677 params.serial_port = "COM5" # params.ip_address = args.ip_address # params.ip_protocol = args.ip_protocol # params.timeout = args.timeout # params.file = args.file board = BoardShim(2, params) board.prepare_session() # board.start_stream () # use this for default options board.start_stream(45000) 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) print()
sum_welch[left_lim:right_lim][value] / cols.size,
marker="o",
ls="",
ms=3)
ax3.annotate(
"{:.2f}".format(avg_freq[left_lim:right_lim][value]),
(avg_freq[left_lim:right_lim][value],
sum_welch[left_lim:right_lim][value] / cols.size),
verticalalignment="top")
plt.tight_layout()
BoardShim.enable_dev_board_logger()
params = BrainFlowInputParams()
params.serial_port = serial_port
params.mac_address = mac_address
board = BoardShim(board_id, params)
board.prepare_session()
board.start_stream()
BoardShim.log_message(LogLevels.LEVEL_INFO.value,
'start sleeping in the main thread')
if (create_csv):
label_list = [None] * BoardShim.get_num_rows(board_id)
label_dict = {
"Battery":
label_extractor(BoardShim.get_battery_channel, board_id, False),
"EEG":
label_extractor(BoardShim.get_eeg_channels, board_id, True),
"EMG":
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 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 initialize_board() -> BoardShim: params = BrainFlowInputParams() params.serial_port = utils.cyton_port() board = BoardShim(global_config.BOARD_ID, params) return board
def main():
policy, parser = init_policy()
args = parser.parse_args("")
reward_dec = EEGNet()
ctrl_dec = EEGNet()
value_dec = EEGNet(softmax=False)
params = BrainFlowInputParams()
params.serial_port = "/dev/cu.usbserial-DM01MTXZ"
board = BoardShim(2, params)
board.prepare_session()
board.start_stream()
while True:
task = input(PROMPT)
if task.isdigit():
task = eval(task)
if task == 1:
if RETRAIN_META: # assuming balanced datasets
# ERP
erp_datasets = format_datasets(task="erp")
reward_dec.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
reptile(reward_dec,
erp_datasets,
save_weights=True,
task="erp")
# CTRL
ctrl_datasets = format_datasets(task="ctrl")
ctrl_dec.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
reptile(ctrl_dec,
ctrl_datasets,
save_weights=True,
task="ctrl")
# Value
value_dec.compile(loss='mse',
optimizer='adam',
metrics=['mse'])
for dataset in erp_datasets:
dataset["y_train"] = np.abs(dataset["y_train"] - 1)
dataset["y_test"] = np.abs(dataset["y_test"] - 1)
reptile(value_dec, erp_datasets, save_weights=True, task="vf")
else:
ctrl_dec = EEGNet()
value_dec = EEGNet(softmax=False)
reward_dec.load_weights('./models/erp_meta_init.h5')
ctrl_dec.load_weights('./models/ctrl_meta_init.h5')
value_dec.load_weights('./models/vf_meta_init.h5')
print("Loaded meta-learned weights.")
elif task == 2:
data_idx = 20
print("Collecting data at index {0}.".format(data_idx))
streamer = Streamer(data_idx=data_idx, board=board)
cursor_ctrl = CursorCtrl(data_idx=data_idx, streamer=streamer)
cursor_ctrl.run_game(30 * 60)
cursor_ctrl.close()
print("Training ...")
reward_dec.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
ctrl_dec.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
value_dec.compile(loss='mse', optimizer='adam', metrics=['mse'])
erp_dataset = format_datasets(data_idxs=[data_idx], task="erp")[0]
ctrl_dataset = format_datasets(data_idxs=[data_idx],
task="ctrl")[0]
for dp in range(len(erp_dataset["x_test"])):
erp_dataset["x_test"][dp] = denoise(erp_dataset["x_test"][dp])
for dp in range(len(erp_dataset["x_train"])):
erp_dataset["x_train"][dp] = denoise(
erp_dataset["x_train"][dp])
for dp in range(len(ctrl_dataset["x_test"])):
ctrl_dataset["x_test"][dp] = denoise(
ctrl_dataset["x_test"][dp])
for dp in range(len(ctrl_dataset["x_train"])):
ctrl_dataset["x_train"][dp] = denoise(
ctrl_dataset["x_train"][dp])
reward_dec.fit(erp_dataset["x_train"],
erp_dataset["y_train"],
batch_size=16,
epochs=100,
verbose=2,
validation_data=(erp_dataset["x_test"],
erp_dataset["y_test"]))
ctrl_dec.fit(ctrl_dataset["x_train"],
ctrl_dataset["y_train"],
batch_size=16,
epochs=100,
verbose=2,
validation_data=(ctrl_dataset["x_test"],
ctrl_dataset["y_test"]))
erp_dataset["y_train"] = np.abs(erp_dataset["y_train"] - 1)
erp_dataset["y_test"] = np.abs(erp_dataset["y_test"] - 1)
value_dec.fit(erp_dataset["x_train"],
erp_dataset["y_train"],
batch_size=16,
epochs=100,
verbose=2,
validation_data=(erp_dataset["x_test"],
erp_dataset["y_test"]))
reward_dec.save_weights('./models/erp_d{0}.h5'.format(data_idx))
ctrl_dec.save_weights('./models/ctrl_d{0}.h5'.format(data_idx))
value_dec.save_weights('./models/vf_d{0}.h5'.format(data_idx))
policy.actor.load_weights('./models/ctrl_d{0}.h5'.format(data_idx))
policy.qf1.load_weights('./models/vf_d{0}.h5'.format(data_idx))
policy.qf1_target.load_weights(
'./models/vf_d{0}.h5'.format(data_idx))
print("Finished training.")
elif task == 3:
streamer = Streamer(data_idx=102, board=board)
cursor_ctrl = CursorCtrl(data_idx=102)
env = BCIEnv(is_live=True,
streamer=streamer,
reward_dec=reward_dec,
cursor_ctrl=cursor_ctrl)
for ft_epoch in range(3):
thread = threading.Thread(target=cursor_ctrl.render_for,
args=(300, ))
thread.start()
print("On Round {0} / 3".format(ft_epoch + 1))
start_time = time.time()
epoch_obs = []
epoch_act = []
epoch_rew = []
obs = env.reset()
while time.time() - start_time < 300.:
obs = denoise(obs)
epoch_obs.append(obs)
action = policy.get_action(obs)
time.sleep(2.5)
obs, reward, _, _, = env.step(action)
epoch_act.append(action)
epoch_rew.append(reward)
epoch_obs.append(obs)
print("Training ...")
parser.set_defaults(max_steps=500)
args = parser.parse_args("")
rep_buff = {
'act': epoch_act,
'obs': epoch_obs,
'rew': epoch_rew
}
trainer = BCITrainer(policy, env, args)
trainer.rep_buff = rep_buff # pulls data from here instead
trainer()
print("Finished fine-tuning.")
streamer.save_data()
streamer.close()
cursor_ctrl.close()
elif task == 4:
name = str(int(time.time()))
os.mkdir('./models/{0}'.format(name))
reward_dec.save_weights('./models/{0}/reward_dec.h5'.format(name))
policy.actor.save_weights(
'./models/{0}/policy_actor.h5'.format(name))
policy.qf1.save_weights('./models/{0}/policy_qf1.h5'.format(name))
policy.qf1_target.save_weights(
'./models/{0}/policy_qf1_target.h5'.format(name))
policy.qf2.save_weights('./models/{0}/policy_qf2.h5'.format(name))
policy.qf2_target.save_weights(
'./models/{0}/policy_qf2_target.h5'.format(name))
print('Saved weights with prefix {0}'.format(name))
elif task == 5:
duration = 60
print("Starting up CursorCtrl for 1 minute.")
streamer = Streamer(data_idx=103, board=board)
cursor_ctrl = CursorCtrl(data_idx=103)
env = BCIEnv(is_live=True,
streamer=streamer,
reward_dec=reward_dec,
cursor_ctrl=cursor_ctrl)
thread = threading.Thread(target=cursor_ctrl.render_for,
args=(duration, ))
thread.start()
start_time = time.time()
all_obs = []
obs = env.reset()
while time.time() - start_time < duration:
obs = denoise(obs)
all_obs.append(obs)
action = policy.get_action(obs, test=True)
time.sleep(2.5)
obs, _, _, _, = env.step(action)
np.save("all_obs_20.npy", all_obs)
elif task == 6:
exit()
else:
print("Sorry, command not understood.")
