def __init__(self, sampling_rate=250, connect=True, port='', channels=[],
path='', test_session=True, electrodes=2, time_run=10, mode=1, save=False):
self.CHANNELS = channels
self.PATH = path
self.bci_port = port
self.connect = connect
self.electrodes = electrodes
self.time_run = time_run
self.mode = mode
self.save_to_file = save
self.reference_signals = []
self.__fs = 1./sampling_rate
self.__t = np.arange(0.0, 1.0, self.__fs)
self.test_session = test_session
self.board = bci.OpenBCICyton(port=self.bci_port)
self.board.print_register_settings()
self.sampling_rate = int(self.board.getSampleRate())
print ("================================")
print (" OpenBCI Cyton CCA Application ")
print ("================================")
self.streaming = mp.Event()
self.terminate = mp.Event()
def __init__(self,
port_name=STD_PORT,
daisy_board=True,
save_fn=None,
channel_num=16):
self.board = bci.OpenBCICyton(port=STD_PORT,
baud=BAUD_RATE,
daisy=daisy_board,
filter_data=False,
scaled_output=True,
log=None,
timeout=None)
self.channel_num = 16
self.sample_rate = 256
self.streaming = False
self.recording = False
self.data = []
self.StartMonitor()
print("Monitor Started")
if save_fn is None:
save_fn = 'EEG-Temp.txt'
self.InitSaveFile(save_fn)
print("Save File Initialized")
def connect():
"""
# FUNCTION: connect()
# INPUT: None
# OUTPUT: Call to acquire(connection)
# DESCRIPTION: Creates the connection with OpenBCI Cyton Board,
sets the configuration & calls to acquire function
# AUTHOR: Jayro Martinez Cervero
"""
# CONNECTION PARAMETERS
# Check for OS system
if platform.system() == 'Darwin': # Mac OSX
port = '/dev/tty.usbserial-DM01HL5T'
else: # Raspberry Pi
port = '/dev/ttyUSB0'
baud = 115200
filter_data = False
scaled_output = True
daisy = False
aux = False
impedance = False
log = False
timeout = None
# CONNECTION ESTABLISHMENT
connection = board.OpenBCICyton(port=port,
baud=baud,
filter_data=filter_data,
scaled_output=scaled_output,
daisy=daisy,
aux=aux,
impedance=impedance,
log=log,
timeout=timeout)
# CONFIGURATION
time.sleep(1)
# Turn Off channels [1, 3, 4, 5, 6, 8]
connection.ser.write(b'1')
connection.ser.write(b'3')
connection.ser.write(b'4')
connection.ser.write(b'5')
connection.ser.write(b'6')
connection.ser.write(b'8')
# For channels 2 & 7:
# Power 'On'
# Gain set to 'x8'
# Input type to 'normal'
# 'Remove' channel from bias
# 'disconnect' channel from SRB2
# 'disconnect' all channels from SRB1
time.sleep(1)
connection.ser.write(b'x2040000X')
time.sleep(1)
connection.ser.write(b'x7040000X')
time.sleep(1)
acquire(connection)
def __init__(self, port_name=None, daisy_board=True):
self.board = bci.OpenBCICyton(port='/dev/ttyUSB0',
baud=BAUD_RATE,
daisy=daisy_board,
filter_data=False,
scaled_output=True,
log=None)
self.streaming = False
self.recording = False
self.startMonitor()
def setup(self, params: Parameters, port: str) -> bci.OpenBCICyton:
# timeout to handle case when board will not stream because of SPS > 250 (v3.1.2-freeSD)
board = bci.OpenBCICyton(port=port,
scaled_output=False,
log=True,
timeout=3)
# board = FakeBoard(params.sampling_rate)
time.sleep(0.5)
board.ser_write(sampling_rate_string(params.sampling_rate))
time.sleep(0.5)
board.print_incoming_text()
return board
if args.log:
print("Logging Enabled: " + str(args.log))
logging.basicConfig(filename="OBCI.log",
format='%(asctime)s - %(levelname)s : %(message)s',
level=logging.DEBUG)
logging.getLogger('yapsy').setLevel(logging.DEBUG)
logging.info('---------LOG START-------------')
logging.info(args)
else:
print("user.py: Logging Disabled.")
print("\n-------INSTANTIATING BOARD-------")
if args.board == "cyton":
board = bci.OpenBCICyton(port=args.port,
baud=args.baud,
daisy=args.daisy,
filter_data=args.filtering,
scaled_output=True,
log=args.log)
elif args.board == "ganglion":
board = bci.OpenBCIGanglion(port=args.port,
filter_data=args.filtering,
scaled_output=True,
log=args.log,
aux=args.aux)
# Info about effective number of channels and sampling rate
if board.daisy:
print("Force daisy mode:")
else:
print("No daisy:")
print(board.getNbEEGChannels(), "EEG channels and",
def printData(sample):
# os.system('clear')
print("----------------")
print("%f" % (sample.id))
print(sample.channel_data)
print(sample.aux_data)
print("----------------")
if __name__ == '__main__':
port = '/dev/ttyUSB1'
baud = 115200
logging.basicConfig(filename="test.log",
format='%(message)s',
level=logging.DEBUG)
logging.info('---------LOG START-------------')
board = bci.OpenBCICyton(port=port, scaled_output=False, log=True)
# 32 bit reset
pdb.set_trace()
board.ser.write('v')
time.sleep(0.100)
pdb.set_trace()
# # connect pins to vcc
# board.ser.write('p')
# time.sleep(0.100)
# # board.start_streaming(printData)
# board.print_packets_in()
if DEBUG:
print(" --")
print(" last values: ", last_values)
print(" interpolation: ", interpol_values)
print(" current sample: ", sample.channel_data)
# send to clients interpolated sample
# leftover_duplications = 0
# server.broadcast_values(interpol_values)
nb_samples_out = nb_samples_out + 1
# send to clients current sample
# server.broadcast_values(sample.channel_data)
nb_samples_out = nb_samples_out + 1
# save current values for possible interpolation
last_values = list(sample.channel_data)
if __name__ == '__main__':
# init server
server = StreamerTCPServer(ip=SERVER_IP, port=SERVER_PORT)
# init board
port = '/dev/tty.usbserial-DM00QA1Z'
baud = 115200
monit = Monitor()
# daemonize theard to terminate it altogether with the main when time will come
monit.daemon = True
monit.start()
board = bci.OpenBCICyton(port=port, baud=baud, filter_data=False)
board.start_streaming(streamData)
class UDPServer(object):
def __init__(self, ip, port, json):
self.ip = ip
self.port = port
self.json = json
print("Selecting raw UDP streaming. IP: ", self.ip, ", port: ",
str(self.port))
self.server = socket.socket(
socket.AF_INET, # Internet
socket.SOCK_DGRAM)
def send_data(self, data):
self.server.sendto(data, (self.ip, self.port))
def handle_sample(self, sample):
if self.json:
# Just send channel data.
self.send_data(json.dumps(sample.channel_data))
else:
# Pack up and send the whole OpenBCISample object.
self.send_data(pickle.dumps(sample))
args = parser.parse_args()
obci = open_bci.OpenBCICyton(args.serial, int(args.baud))
if args.filter_data:
obci.filter_data = True
sock_server = UDPServer(args.host, int(args.port), args.json)
obci.start_streaming(sock_server.handle_sample)
