def port(self):
'''
:list_ports: This module will provide a function called comports that
returns an iterable (generator or list) that will enumerate
available com ports. Note that on some systems non-existent ports
may be listed.
:start_stream: Start handling streaming data from the board.
Call a provided callback for every single sample that is processed.
'''
Lista_puertos = list_ports.comports()
print(Lista_puertos)
for serial_device in Lista_puertos:
code_serial = serial_device.serial_number
if code_serial != None:
if code_serial.startswith(serial_openBCI):
board = OpenBCICyton(port=serial_device.device,
daisy=False)
Data = self.lslStreamers
board.start_stream(Data)
else:
print(
'No hay dispositivo OpenBCI, conectar y volver a iniciar el programa'
)
input('Presione enter para finalizar ...')
def start_board(self):
global fila
fila = 0
self.board = OpenBCICyton(port='COM8', daisy=False)
self.stopconexioUltracortex = False
self.stopconexioUltracortexPlot = False
self.Crear_carpetaEEG()
def connectToBoard():
try:
board = OpenBCICyton(daisy=True)
return board
except Exception as e:
print(e)
return None
def printChannel(channelNum):
try:
board = OpenBCICyton(daisy=True)
except Exception as e:
id.makeErrorPopup(str(e))
return
callback = partial(printChannelsCallback, channelNum=channelNum)
board.start_stream(callback)
def runSession(self):
self.__createEEGStream()
# eeg_thread = threading.Thread(target=self.__board.start_stream, args=(self.__lsl_streamers,))
# eeg_thread.start()
try:
self.__board = OpenBCICyton()
self.__board.start_stream(self.__lsl_streamers)
except (KeyboardInterrupt, SystemExit):
self.__board.stop_stream()
sys.exit()
def start_board_Ultracortex():
global board
try:
board = OpenBCICyton("COM3", daisy=True)
board.start_stream(ui.save_data_EEG)
except:
#ui.Errores("DONGLE DESCONECTADO")
print("DONGLE DESCONECTADO")
def start_board_Ultracortex():
global board
try:
#print("cualquier cosa")
board = OpenBCICyton(port='/dev/ttyUSB0', daisy=True)
board.start_stream(ui.save_data_EEG)
except:
#ui.Errores("DONGLE DESCONECTADO")
print("DONGLE DESCONECTADO")
def main():
TIMEOUT = 60
#Set (daisy = True) to stream 16 ch
board = OpenBCICyton(daisy=True)
signal.signal(signal.SIGALRM, signal_handler)
signal.alarm(TIMEOUT)
try:
board.start_stream(print_raw)
except Exception as e:
print("timed out")
board.stop_stream()
sys.exit(0)
def startStream(self) :
print("start streaming called")
if not self.started:
self.started = True
if self.live:
from pyOpenBCI import OpenBCICyton
print("LIVE: started eeg streaming")
self.board = OpenBCICyton()
self.eeg_thread = threading.Thread(target=self.board.start_stream, args=(self.push_data_sample,))
else :
print("FAKE DATA: started")
self.eeg_thread = threading.Thread(target=self.__generate_artificial_data, args=(self.push_data_sample,))
self.eeg_thread.start()
def start(self):
print("start recording called")
if self.live:
from pyOpenBCI import OpenBCICyton
print("LIVE: started eeg recording")
header = ["timestamp"] + self.channels
self.csv_writer = CSVWriter(self.output_filename,
column_headers=header)
self.board = OpenBCICyton()
self.eeg_thread = threading.Thread(
target=self.board.start_stream,
args=(self.record_data_sample, ))
self.eeg_thread.start()
self.started = True
def port(self):
'''
Rec: Samples from the device (Samples)
Func: Evaluate the list of ports in use and set the port to use.
'''
Lista_puertos = list_ports.comports()
print(Lista_puertos)
for serial_device in Lista_puertos:
code_serial = serial_device.serial_number
if code_serial != None:
if code_serial.startswith(serial_openBCI):
board = OpenBCICyton(
port=serial_device.device, daisy=False)
Data = self.lslStreamers
board.start_stream(Data)
else:
print(
'No hay dispositivo OpenBCI, conectar y volver a iniciar el programa')
input('Presione enter para finalizar ...')
def stream():
#print(address)
#print(name)
print(
"Creating LSL stream for EEG. \nName: OpenBCIEEG\nID: OpenBCItestEEG\n"
)
info_eeg = StreamInfo('OpenBCIEEG', 'EEG', 16, 250, 'float32',
'OpenBCItestEEG')
# print("Creating LSL stream for AUX. \nName: OpenBCIAUX\nID: OpenBCItestEEG\n")
# info_aux = StreamInfo('OpenBCIAUX', 'AUX', 3, 250, 'float32', 'OpenBCItestAUX')
info_eeg.desc().append_child_value("manufacturer", "OpenBCI")
eeg_channels = info_eeg.desc().append_child("channels")
for c in [
'Fp1', 'Fp2', 'C3', 'C4', 'P7', 'P8', 'O1', 'O2', 'F7', 'F8', 'F3',
'F4', 'T7', 'T8', 'P3', 'P4'
]:
eeg_channels.append_child("channel") \
.append_child_value("label", c) \
.append_child_value("unit", "microvolts") \
.append_child_value("type", "EEG")
# eeg_outlet = StreamOutlet(eeg_info, LSL_EEG_CHUNK)
outlet_eeg = StreamOutlet(info_eeg)
# outlet_aux = StreamOutlet(info_aux)
def lsl_streamers(sample):
outlet_eeg.push_sample(
np.array(sample.channels_data) * SCALE_FACTOR_EEG)
# outlet_aux.push_sample(np.array(sample.aux_data)*SCALE_FACTOR_AUX)
#board = OpenBCICyton(port='COM3', daisy=True)
board = OpenBCICyton(port='/dev/tty.usbserial-DM01N7JO', daisy=True)
board.start_stream(lsl_streamers)
def setup(self, device):
self.device = device
if self.device == 'sim':
self.streamFunc = self.simulateStream
elif self.device == 'emotiv':
self.streamFunc = self.emotivStream
elif self.device == 'openBCI':
self.streamFunc = self.openBCIStream
self.done = False
if self.device == 'emotiv':
try:
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.s.connect((self.host, self.port))
self.s.send(b"\r\n")
# To read the header msgs about cykit etc...
self.s.recv(168, socket.MSG_WAITALL)
# Local buffer to store parts of the messages
self.buffer = b''
# If when when split by \r, \r was the last character of the message, we know that we have to remove \n from
# the begining of the next message
self.remove_newline = False
except ConnectionRefusedError:
print('uh oh. looks like CyKIT isn\'t setup right. '
'try again by restarting MusEEG')
elif self.device == 'openBCI':
from pyOpenBCI import OpenBCICyton
self.board = OpenBCICyton(port='/dev/tty.usbserial-DM0258BS',
daisy=True)
def start(self):
print("started work session :D ")
self.timestamp = datetime.now()
self.model = torch.load(
"../data_analysis/models/model_t_combined_continuous_filtered_3class.pickle"
)
self.focus_logger = FocusLogger(fs=self.fs)
self.eeg_sampler = EEGSampler(fs=self.fs,
buffer_seconds=self.buffer_seconds,
update_seconds=DEFAULT_UPDATE_SECONDS,
channels=DEFAULT_CHANNELS,
binning=DEFAULT_BINNING,
live=True,
model=self.model,
to_clean=True,
three_class=True,
focus_logger=self.focus_logger)
if LIVE_DATA:
self.board = OpenBCICyton()
self.eeg_thread = threading.Thread(
target=self.board.start_stream,
args=(self.eeg_sampler.push_data_sample, ))
self.eeg_thread.start()
self.started = True
from pyOpenBCI import OpenBCICyton
board = OpenBCICyton(port='/dev/tty.usbserial-DM01N5XP')
uVolts_per_count = (4500000)/24/(2**23-1) #uV/count
accel_G_per_count = 0.002 / (2**4) #G/count
def print_raw(sample):
print(sample.channels_data)
board.start_stream(print_raw)
and variables_usabilidad_Anterior == None):
satisfaccion.append(Medir_Satisfaccion(sample))
elif (variables_usabilidad != variables_usabilidad_Anterior
and variables_usabilidad_Anterior != None):
satisfaccion.append(Medir_Satisfaccion(sample))
if (variables_usabilidad != None):
variables_usabilidad_Comparar = variables_usabilidad_Anterior
variables_usabilidad_Anterior = variables_usabilidad
if (variables_usabilidad_Comparar != None and variables_usabilidad != None
and
variables_usabilidad_Comparar != variables_usabilidad_Anterior):
Guardar_datos(variables_usabilidad_Comparar, satisfaccion)
satisfaccion = []
if ("FinTomaMuestraUsuario" in variables_usabilidad.decode("utf-8")):
print("Entro en FinTomaMuestraUsuario")
variables_usabilidad = None
variables_usabilidad_Anterior = None
variables_usabilidad_Comparar = None
satisfaccion = []
else:
print("Sample:", sample)
print(satisfaccion)
board = OpenBCICyton(daisy=True)
board.start_stream(print_raw)
# First you need to install pyOpenBCI using: pip install pyOpenBCI
from pyOpenBCI import OpenBCICyton
from pylsl import StreamInfo, StreamOutlet
import numpy as np
SCALE_FACTOR_EEG = (4500000) / 24 / (2**23 - 1) #uV/count
SCALE_FACTOR_AUX = 0.002 / (2**4)
info_eeg = StreamInfo('OpenBCIEEG', 'EEG', 16, 125, 'float32',
'OpenBCItestEEG')
print("Creating LSL stream for AUX. \nName: OpenBCIAUX\nID: OpenBCItestEEG\n")
info_aux = StreamInfo('OpenBCIAUX', 'AUX', 3, 125, 'float32', 'OpenBCItestAUX')
outlet_eeg = StreamOutlet(info_eeg)
outlet_aux = StreamOutlet(info_aux)
def lsl_streamers(sample):
outlet_eeg.push_sample(np.array(sample.channels_data) * SCALE_FACTOR_EEG)
outlet_aux.push_sample(np.array(sample.aux_data) * SCALE_FACTOR_AUX)
board = OpenBCICyton(port='COM3', daisy=True)
board.start_stream(lsl_streamers)
def __init__(self, stream_frames, callback): #self.board = Mockboard() self.board = OpenBCICyton(daisy = True) self.frame_counter = 0 self.stream_frames = stream_frames self.callback = callback
from pyOpenBCI import OpenBCICyton
from pylsl import StreamInfo, StreamOutlet
import numpy as np
SCALE_FACTOR_EEG = (4500000)/24/(2**23-1) #uV/count
SCALE_FACTOR_AUX = 0.002 / (2**4)
print("Creating LSL stream for EEG. \nName: OpenBCIEEG\nID: OpenBCItestEEG\n")
info_eeg = StreamInfo('OpenBCIEEG', 'EEG', 8, 250, 'float32', 'OpenBCItestEEG')
outlet_eeg = StreamOutlet(info_eeg)
def lsl_streamers(sample):
outlet_eeg.push_sample(np.array(sample.channels_data)*SCALE_FACTOR_EEG)
board = OpenBCICyton()
board.start_stream(lsl_streamers) #begins the lsl stream
def start_board():
board = OpenBCICyton(port='COM8', daisy=False)
board.start_stream(save_data)
np.array(sample.channels_data[3]) * SCALE_FACTOR_EEG)
data['CP2'].append(
np.array(sample.channels_data[4]) * SCALE_FACTOR_EEG)
data['T8'].append(np.array(sample.channels_data[5]) * SCALE_FACTOR_EEG)
data['O2'].append(np.array(sample.channels_data[6]) * SCALE_FACTOR_EEG)
data['O1'].append(np.array(sample.channels_data[7]) * SCALE_FACTOR_EEG)
if len(data['FT7']) % 125 == 0:
json_data = {
'raw': [
data['FT7'], data['FT8'], data['T7'], data['CP1'],
data['CP2'], data['T8'], data['O2'], data['O1']
]
}
requests.post('http://0.0.0.0:5000/compute_psd', json=json_data)
requests.post('http://0.0.0.0:5000/store_raw', json=json_data)
elif len(data['FT7']) == 1000:
requests.post('http://0.0.0.0:5000/predictml', json=data)
data['FT7'] = []
data['FT8'] = []
data['T7'] = []
data['CP1'] = []
data['CP2'] = []
data['T8'] = []
data['O2'] = []
data['O1'] = []
board = OpenBCICyton(port='/dev/ttyUSB1', daisy=True)
board.start_stream(process_predict)
print("Now done editing!")
LOADED = False # Did user load a recording?
LOADED_PATH = ""
# Main loop
while True:
user_input = str(input("What to do?"))
# quit
if (user_input == "q"): break
# ping bci
if (user_input == "p"):
test = OpenBCICyton(daisy="True")
# record
elif (user_input == "r"):
row_to_modify = int(
input(
"Row to record to? [0 - Left] [1 - Up] [2 - Right] [3 - Down]")
)
frame_input = int(input("Recording how many frames?"))
mystream = StreamHandler(frame_input, collect_data)
mystream.start_stream()
print("Finished recording to", row_to_modify)
# save or save as
elif (user_input == "s" or user_input == "sa"):
if (LOADED and user_input == "s"):
def start_board(): # Hilo configuracion cyton y lectura de datos
board = OpenBCICyton("COM8",
daisy=False) # LLamado de la clase OpenBCYCyton.
board.start_stream(
ui.save_data) # Se llama el metodo de solicitud de datos.
help='Chosse a callback function: print_raw, lsl_stream, or osc_stream.'
)
args = parser.parse_args()
def print_raw(sample):
print(sample.channels_data)
callback = eval(args.fun)
if args.board not in ['Cyton', 'CytonDaisy', 'Ganglion', 'Wifi']:
sys.exit(
'No Board Selected. You should use Cyton, CytonDaisy, Ganglion, or Wifi. Try: python openbci_interface.py --board Cyton'
)
elif args.board == 'Cyton':
board = OpenBCICyton(port=args.port)
elif args.boad == 'CytonDaisy':
board = OpenBCICyton(port=args.port, daisy=True)
elif args.board == 'Ganglion':
if sys.platform.startswith("linux"):
board = OpenBCIGanglion(mac=args.port)
else:
sys.exit(
'Currently the Ganglion Python repo only works with Linux OS.')
else:
board = OpenBCIWiFi()
valid_commands = '012345678!@#$%^&*qwertyuiQWERTYUI[]pdbsvnN;-=xXDzZASFGHJKLajbs?c<>'
while True:
command = input('--> ')
from pyOpenBCI import OpenBCICyton
from pylsl import StreamInfo, StreamOutlet, local_clock
import numpy as np
import time
SCALE_FACTOR_EEG = (4500000) / 24 / (2**23 - 1) #uV/count
SCALE_FACTOR_AUX = 0.002 / (2**4)
print("Creating LSL stream for EEG. \nName: OpenBCIEEG\nID: OpenBCItestEEG\n")
info_eeg = StreamInfo('OpenBCIEEG', 'EEG', 8, 250, 'float32', 'OpenBCItestEEG')
print("Creating LSL stream for AUX. \nName: OpenBCIAUX\nID: OpenBCItestEEG\n")
info_aux = StreamInfo('OpenBCIAUX', 'AUX', 3, 250, 'float32', 'OpenBCItestAUX')
outlet_eeg = StreamOutlet(info_eeg)
outlet_aux = StreamOutlet(info_aux)
def lsl_streamers(sample):
outlet_eeg.push_sample(np.array(sample.channels_data) * SCALE_FACTOR_EEG)
outlet_aux.push_sample(np.array(sample.aux_data) * SCALE_FACTOR_AUX)
board = OpenBCICyton(port='/dev/ttyUSB0')
board.start_stream(lsl_streamers)
def start_board():
board = OpenBCICyton( "COM8",daisy=True)
board.start_stream(save_data)
def process_raw():
EEG.load_data(raw_data)
EEG.load_channel(1)
EEG.remove_dc_offset()
#EEG.notch_mains_interference()
EEG.signalplot()
#EEG.pyqtplot()
# Returns bandpassed data
# (uses scipy.signal butterworth filter)
# start_Hz = 1
## EEG.data = EEG.bandpass(start_Hz,stop_Hz)
# Make Spectrogram
# EEG.spectrogram()
# Line graph of amplitude over time for a given frequency range.
# Arguments are start frequency, end frequency, and label
# EEG.plot_band_power(8,12,"Alpha")
# Power spectrum plot
# EEG.plot_spectrum_avg_fft()
t1 = []
print("AFTER PYQT")
board = OpenBCICyton(port='/dev/ttyUSB1', daisy=False)
board.start_stream(acquire_raw)
#t1 = threading.Thread(target=board.start_stream, args=(acquire_raw,))
#board.start_stream(acquire_raw)
board.write_command('5')
board.write_command('6')
board.write_command('7')
board.write_command('8')
board.write_command('!')
# board.write_command('?')
print("Creating LSL stream for EEG. \nName: OpenBCIEEG\nID: OpenBCItestEEG\n")
info_eeg = StreamInfo('OpenBCIEEG', 'EEG', 8, 250, 'float32', 'OpenBCItestEEG')
outlet_eeg = StreamOutlet(info_eeg)
print("now sending data...")
def lsl_streamers(sample):
print(np.array(sample.channels_data) * SCALE_FACTOR_EEG)
outlet_eeg.push_sample(np.array(sample.channels_data) * SCALE_FACTOR_EEG)
# print(np.array(sample.channels_data) * SCALE_FACTOR_EEG)
try:
board = OpenBCICyton(port='/dev/ttyUSB0', daisy=False)
except:
board = OpenBCICyton(port='COM4', daisy=False)
init(board)
print("start lsl steamers")
board.start_stream(lsl_streamers)
# print(sample.start_time, sample.board_type)
"""
Source: https://github.com/OpenBCI/pyOpenBCI/blob/master/Examples/print_raw_example.py
"""
from pyOpenBCI import OpenBCICyton
def print_raw(sample):
print(sample.channels_data)
#Set (daisy = True) to stream 16 ch
board = OpenBCICyton(daisy = False)
board.start_stream(print_raw)
Testing sampling frequency when streaming directly with lsl and python
"""
from pyOpenBCI import OpenBCICyton
from pylsl import StreamInfo, StreamOutlet
import numpy as np
SCALE_FACTOR_EEG = (4500000) / 24 / (2**23 - 1) #uV/count
SCALE_FACTOR_AUX = 0.002 / (2**4)
print("Creating LSL stream for EEG. \nName: OpenBCIEEG\nID: OpenBCItestEEG\n")
info_eeg = StreamInfo('OpenBCIEEG', 'EEG', 8, 250, 'float32', 'OpenBCItestEEG')
print("Creating LSL stream for AUX. \nName: OpenBCIAUX\nID: OpenBCItestEEG\n")
info_aux = StreamInfo('OpenBCIAUX', 'AUX', 3, 250, 'float32', 'OpenBCItestAUX')
outlet_eeg = StreamOutlet(info_eeg)
outlet_aux = StreamOutlet(info_aux)
def lsl_streamers(sample):
outlet_eeg.push_sample(np.array(sample.channels_data) * SCALE_FACTOR_EEG)
outlet_aux.push_sample(np.array(sample.aux_data) * SCALE_FACTOR_AUX)
board = OpenBCICyton(port='COM11', daisy=False)
board.start_stream(lsl_streamers)
