from pyOpenBCI import OpenBCICyton import matplotlib.pyplot as plt # ax1 = fig1.add_subplot(111) .show() i = 0 x1,x2,y1,y2 = [], [], [], [] def plot1(x,y): global i x1.append(x) y1.append(y) plt.plot(x1, y1, color='b') fig1.canvas.draw() fig1.set_xlim(left=max(0, i-50), right=i+50) #time.sleep(0.1) def print_raw(sample): global i # print(sample.channels_data[0]) * (4.5)/24/(2**23-1) plot1(i,(sample.channels_data[0] * ((4.5)/24/(2**23-1)*1000000))) #plot2(i,(sample.channels_data[1] * ((4.5)/24/(2**23-1)))) i += 1 board = OpenBCICyton(port='/dev/ttyUSB0', daisy=False) board.start_stream(print_raw)
def start_board():
board = OpenBCICyton(port='COM8', daisy=False)
board.start_stream(save_data)
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)
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.
# 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)
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()
board.start_stream(lsl_streamers)
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)
outlet_aux.push_sample(np.array(sample.aux_data) * SCALE_FACTOR_AUX)
board = OpenBCICyton(port='COM3', daisy=False)
while (True):
try:
board.start_stream(lsl_streamers)
except:
board.stop_stream()
time.sleep(0.5)
board.disconnect()
break
global rawBuffer, filterBuffer
#print(rawBuffer)
filterBuffer[:-window_size] = filterBuffer[window_size:]
filterBuffer[-window_size:] = rawBuffer
last64 = remove_dc_offset()
notch_filter()
bandpass()
#plot(rawBuffer, last64)
#plot2()
#get_spectrum_data()
#makePlot()
plt.pause(0.0001)
ax1.clear()
#time.sleep(1)
plt.ion()
plt.show()
print("AFTER PYQT")
board = OpenBCICyton(port='/dev/ttyUSB0', daisy=False)
while (True):
data = board.start_stream(1)
print(data)
acquire_raw(data[0])
#t1 = threading.Thread(target=board.start_stream, args=(acquire_raw,))
#board.start_stream(acquire_raw)
#t1.start()
np.squeeze(raw_data),
NFFT,
window=mlab.window_hanning,
Fs=fs_Hz,
noverlap=overlap) # returns PSD power per Hz
# convert the units of the spectral data
spec_PSDperBin = spec_PSDperHz * fs_Hz / float(NFFT)
def plot_spectrum_avg_fft():
# print("Generating power spectrum plot")
spectrum_PSDperHz = np.mean(spec_PSDperHz, 1)
plt.figure(figsize=(10, 5))
plt.plot(spec_freqs, 10 * np.log10(spectrum_PSDperHz)) # dB re: 1 uV
plt.xlim((0, 60))
plt.ylim((-30, 50))
# plotname = 'Channel '+str(self.channel)+' Spectrum Average FFT Plot'
plt.xlabel('Frequency (Hz)')
plt.ylabel('PSD per Hz (dB re: 1uV^2/Hz)')
# plt.title(self.plot_title("Power Spectrum"))
# self.plotit(plt, self.plot_filename("Power Spectrum"))
board = OpenBCICyton(port='/dev/ttyUSB2', daisy=False)
board.start_stream(process_raw)
plt.close()
global i
x1.append(x)
y1.append(y)
ax1.plot(x1, y1, color='b')
fig1.canvas.draw()
ax1.set_xlim(left=max(0, i-50), right=i+50)
#time.sleep(0.1)
def plot2(x,y):
global i
x2.append(x)
y2.append(y)
ax2.plot(x2, y2, color='b')
fig2.canvas.draw()
ax2.set_xlim(left=max(0, i-50), right=i+50)
#time.sleep(0.1)
def print_raw(sample):
global i
print(sample.channels_data) #* (4.5)/24/(2**23-1))
plot1(i,(sample.channels_data[0] * ((4.5)/24/(2**23-1))))
plot2(i,(sample.channels_data[1] * ((4.5)/24/(2**23-1))))
i += 1
board = OpenBCICyton(port='/dev/ttyUSB1', daisy=False)
def save_raw
board.start_stream(save_raw)
keep_block = arr2D.shape[1] * (SAMPLES_PER_FRAME - 1)
im_data = np.delete(im_data, np.s_[:-keep_block], 1)
im_data = np.hstack((im_data, arr2D))
im.set_array(im_data)
return im,
#main program
arr2D, freqs, bins = get_specgram(streamedData.channels_data[0] * ((4.5)/24/(2**23-1)))
"""
Setup the plot paramters
"""
extent = (bins[0], bins[-1] * SAMPLES_PER_FRAME, freqs[-1], freqs[0])
im = plt.imshow(arr2D, aspect='auto', extent=extent, interpolation="none",
cmap='jet', norm=LogNorm(vmin=.01, vmax=1))
plt.xlabel('Time (s)')
plt.ylabel('Frequency (Hz)')
plt.title('Real Time Spectogram')
plt.gca().invert_yaxis()
##plt.colorbar() #enable if you want to display a color bar
anim = animation.FuncAnimation(fig, update_fig, blit=False,interval=10)
# interval=mic_read.CHUNK_SIZE / 1000)
plt.show(block=False)
board = OpenBCICyton(port='/dev/ttyUSB0', daisy=False)
#call back fn
board.start_stream(get_data)
Author: zachandfox
Source Materials: https://docs.openbci.com/OpenBCI%20Software/05-OpenBCI_Python#pyopenbci-installation
- Keyboard Interrupt: https://stackoverflow.com/questions/4205317/capture-keyboardinterrupt-in-python-without-try-except
Pull in raw data from Cyton Board using bluetooth arduino
"""
from pyOpenBCI import OpenBCICyton
import time
import numpy as np
output = np.zeros(8)
timer = 1000
SCALE_FACTOR_EEG = (4500000) / 24 / (2**23 - 1) #uV/count
board = OpenBCICyton()
MaxVal = 100000
StepInterval = 1
### start_stream method ###
#def print_raw(sample):
# try:
# #output.append(sample.channels_data)
# print(sample.channels_data)
# for i in range(1, MaxVal, StepInterval):
# print(i)
# except KeyboardInterrupt:
# for i in range(1, MaxVal, StepInterval):
# print('INTERRUPTED! Closing in: ', str(MaxVal-i))
# board.stop_stream()
SCALE_FACTOR_EEG = (4500000)/24/(2**23-1) #uV/count
# Defining stream info:
name = 'OpenBCIEEG'
ID = 'OpenBCItestEEG'
port = argv[1]
channels = 8
sample_rate = 250
datatype = 'float32'
streamType = 'EEG'
print(f"Creating LSL stream for EEG. \nName: {name}\nID: {ID}\n")
info_eeg = StreamInfo(name, streamType, channels, sample_rate, datatype, ID)
outlet_eeg = StreamOutlet(info_eeg)
def lsl_streamer(sample):
"""
Convert the sample data from it's raw format (counts) to uV and push it
to the LSL-stream.
* Input: Raw EEG data from the Cyton board, unit is counts
* Output: EEG-data formatted as a LSL-sample with unit micro-volts (uV).
"""
outlet_eeg.push_sample(np.array(sample.channels_data)*SCALE_FACTOR_EEG)
# Start the stream:
board = OpenBCICyton(port=port, daisy=False)
board.start_stream(lsl_streamer)
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)
class OpenBCI(object):
def __init__(self,
port=None,
daisy=None,
chunk_size=250,
method=1,
path=None,
createSession=True):
'''
Initialize all the variables
'''
self.port = port
self.daisy = daisy
self.chunk_size = chunk_size
self.method = method # Read data continously or in chunks of chunk_size
print("Starting creating streamer....")
self.streamer = BCI(self.port, self.daisy)
self.uVolts_per_count = (4.5) / 24 / (
2**23 - 1
) * 1000000 # scalar factor to convert raw data into real world signal data
#Saving data and naming conventions
self.homeFolder = os.getcwd()
self.sessionFolder = self.homeFolder + "/SessionData"
self.sessionId = time.strftime("SESSION_%Y%m%d_%H%M%S")
if (path == None):
self.currentSession = self.sessionFolder + "/" + self.sessionId
else:
self.currentSession = self.sessionFolder + "/" + path
print("Building Session Folders....")
if (createSession == True):
self.makeSessionFolder()
def makeSessionFolder(self):
if (os.path.isdir(self.sessionFolder) == False):
os.mkdir(self.sessionFolder)
if (os.path.isdir(self.currentSession) == False):
os.mkdir(self.currentSession)
def read_chunk(self,
n_chunks=1,
verbose=False,
data_only=True,
exit_after=False,
save_data=False):
'''
- Each chunk is defined by "chunk_size".
- "n_chunks" defines how many chunks of data you want.
- "data_only" is to say whether you want only the numeric
signal data or you want the entire sample points.
- "exit_after" is for if you want to close the stream after
reading the data.
- "save_data" if you want to save the raw data some where
Create a numpy array if the user is requesting for data only
Use lists if you entire object of the sample.
The output of this function is an array of shape:
(n_chunks,chunk_size,n_channels)
'''
if (data_only == True):
t = 0
data = np.zeros(shape=(1, self.chunk_size, 8))
for i in range(n_chunks):
if verbose:
print("Reading Chunk: %d " % (i + 1))
sample = self.streamer.start_stream_ext(
method=self.method,
chunk_size=self.chunk_size,
data_only=data_only)
sample = np.expand_dims(np.asarray(sample), 0)
data = np.append(data, sample, 0)
data = data[1:]
data = data * self.uVolts_per_count
if (exit_after == True):
self.streamer.stop_stream()
if (save_data == True):
t = time.strftime("%Y%m%d_%H%M%S")
np.save(self.currentSession + "/RawData_" + t, data)
#return (data.transpose(0,2,1),self.currentSession,t)
return data.transpose(0, 2, 1)
else:
data = []
for i in range(n_chunks):
print("Reading Chunk: %d " % (i + 1))
sample = self.streamer.start_stream_ext(
method=self.method,
chunk_size=self.chunk_size,
data_only=data_only)
data.append(sample)
if (exit_after == True):
self.streamer.stop_stream()
if (save_data == True):
t = time.strftime("%Y%m%d_%H%M%D")
with open(self.currentSession + "/RawData_" + t + ".pickle",
'w') as f:
pickle.dump(data, f)
return data
rawBuffer = []
def process_raw():
global rawBuffer, filterBuffer
#print(rawBuffer)
filterBuffer[:-window_size] = filterBuffer[window_size:]
filterBuffer[-window_size:] = rawBuffer
last64 = remove_dc_offset()
notch_filter()
lastBandpass = bandpass()
#plot(rawBuffer, lastBandpass)
#plot2()
#get_spectrum_data()
#makePlot()
plt.pause(0.0001)
ax1.clear()
#time.sleep(1)
plt.ion()
plt.show()
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)
#t1.start()
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)
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)
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
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)
#print(np.array(sample.aux_data)*SCALE_FACTOR_AUX)
board = OpenBCICyton(port='/dev/cu.usbserial-DM00D7TW')
board.write_command('/2') # change the cyton AUX board mode to Analog mode.
board.start_stream(lsl_streamers)
