def start_data_collection(serial_port, num_seconds=-1): headset_obj = NP.NeuroPy(serial_port, 9600, log=False) headset_obj.setCallBack("attention", generic_callback) headset_obj.setCallBack("meditation", generic_callback) headset_obj.setCallBack("rawValue", generic_callback) headset_obj.setCallBack("delta", generic_callback) headset_obj.setCallBack("theta", generic_callback) headset_obj.setCallBack("lowAlpha", generic_callback) headset_obj.setCallBack("highAlpha", generic_callback) headset_obj.setCallBack("lowBeta", generic_callback) headset_obj.setCallBack("highBeta", generic_callback) headset_obj.setCallBack("lowGamma", generic_callback) headset_obj.setCallBack("midGamma", generic_callback) headset_obj.setCallBack("poorSignal", generic_callback) headset_obj.setCallBack("blinkStrength", generic_callback) headset_obj.start() if num_seconds != -1: time.sleep(num_seconds) headset_obj.stop() if num_seconds != -1: time.sleep(num_seconds) headset_obj.stop()
def __init__(self): self.value = 0 self.counter = 0 self.skip_value = 0 self.data_array = [0.000] * 1024 self.neuro_object = NeuroPy("COM15") self.caller()
def startBCI(): object1=NeuroPy("COM6") #set call back: object1.setCallBack("attention",attention_callback) #start method object1.start() return None
def main(): neuropy = NeuroPy("/dev/rfcomm0") #instantiate NeuroPy class neuropy.start() #start thread start_time = 0 blinked = False #if blink is detected last_blink_time = 0 double_blink = False triple_blink = False i = 100 j = 100 try: while i < 20000: i = i + 1 value = neuropy.rawValue #gets the raw brain activity level print value, " ", i if value > 100: #if the raw level gets above 200, which indicates a spike, start the clock start_time = time.clock() #print value if start_time: if value < -100: #if the spike in brain activity is over total_time = time.clock() - start_time #how long the spike was start_time = 0 if 0.01 < total_time < 0.050: #if the spike was a certain length if last_blink_time and time.clock() - last_blink_time < .6: #if the blink occured right after the previous blink if double_blink: triple_blink = True else : double_blink = True last_blink_time = time.clock() #reset the clock i+=1 blinked = True if blinked and time.clock()-last_blink_time > .61: #if a certain amount of time has passed since the last blink if triple_blink: print "Triple blink detected .......... turning left" motor.forward_left() time.sleep(3) motor.forward() break elif double_blink: print "Double blink detected ........... turning right" motor.forward_right() time.sleep(3) motor.forward() break double_blink = blinked = triple_blink = False time.sleep(2) return finally: neuropy.stop()
def main(): print("hallo hallo") object1 = NeuroPy("/dev/rfcomm0") object1.setCallBack("attention", attention_callback) object1.start() while True: if (object1.meditation > 70): object1.stop()
from NeuroPy import NeuroPy import threading def stoppa(a): a.stop() a.save() #Rilassamento 438 secs a 1min #Musica metal 200 secs da 25sec #Logica 200 da 0 #Memoria 200 da 0 person_name = input('Nome dell\'utente: ') task_name = input('Nome del task: ') task_duration = input('Durata del task(sec):') record = NeuroPy("COM3", person_name=person_name, task_name=task_name, task_duration=task_duration) threading.Timer(int(task_duration), stoppa, [record]).start() record.start()
# -*- coding: utf-8 -*- from NeuroPy import NeuroPy from time import sleep import threading from api_service import * neuropy = NeuroPy("COM4") # type: NeuroPy #neuropy = NeuroPy("/dev/rfcomm0",57600) # type: NeuroPy def attention_callback(attention_value): """this function will be called everytime NeuroPy has a new value for attention""" print("Value of attention is: ", attention_value) return 0 def meditation_callback(meditation_value): """this function will be called everytime NeuroPy has a new value for attention""" print("Value of meditation is: ", meditation_value) return 1 def rawValue_callback(rawValue_value): """this function will be called everytime NeuroPy has a new value for attention""" # print ("Value of rawValue is: ", rawValue_value) return 2 def delta_callback(delta_value): """this function will be called everytime NeuroPy has a new value for attention""" print("Value of delta is: ", delta_value)
from NeuroPy import NeuroPy import time import matplotlib.pyplot as plt import matplotlib.animation as animation neuropy = NeuroPy("COM3") # Specify COM Port neuropy.start() fig = plt.figure() t = 0 meditation = [] x_time = [] print("=============================") def animate(i): global t global meditation if t == 300: # preset: 300(sec) con = input("Continue (Y/N)? ") if con == 'N': with open('BrainWave/BrainWave.csv', 'w') as w: meditation = str(meditation) meditation = meditation.split() for i in range(len(meditation)):
''' attention, meditation, rawValue, delta, theta, lowAlpha, highAlpha, lowBeta, highBeta, lowGamma, midGamma, poorSignal, blinkStrength $ pip install pyserial $ pip install NeuroPy $ pip install pyosc ''' from NeuroPy import NeuroPy import OSC import time neuroPy = NeuroPy("/dev/rfcomm0", 57600) neuroPy.start() oscClient = OSC.OSCClient() oscClient.connect(('127.0.0.1', 57120)) while True: attention = neuroPy.attention meditation = neuroPy.meditation oscMsg = OSC.OSCMessage() oscMsg.setAddress("/neuro") oscMsg.append([attention, meditation]) oscClient.send(oscMsg) print "attention: " + str(attention) + " - " + "meditation: " + str( meditation)
rowdata.append(hset.rawValue) rowdata.append(hset.attention) rowdata.append(hset.meditation) rowdata.append(hset.delta) rowdata.append(hset.theta) rowdata.append(hset.lowAlpha) rowdata.append(hset.highAlpha) rowdata.append(hset.lowBeta) rowdata.append(hset.highBeta) rowdata.append(hset.lowGamma) rowdata.append(hset.midGamma) queue.append(rowdata) # NeuroSky Setup hset = NeuroPy('COM4') hset.start() time.sleep(8) print('Ready...') results = [] queue = [] while True: # Terminating data collection if keyboard.is_pressed('q'): print('Quitting - Results outputted to output.csv') #storing into csv with open("output.csv", "wb") as f: writer = csv.writer(f) writer.writerows(results)
from NeuroPy import NeuroPy import time import socket import sys eyesOption = ['eyes_open', 'eyes_closed'] alphaOption = ['lowAlpha', 'highAlpha'] object1 = NeuroPy("COM3") #If port not given 57600 is automatically assumed #object1=NeuroPy("/dev/rfcomm0") for linux ''' def attention_callback(attention_value): "this function will be called everytime NeuroPy has a new value for attention" print "Value of attention is",attention_value #do other stuff (fire a rocket), based on the obtained value of attention_value #do some more stuff return None ''' #for each callback, store value into textfile def highalpha_callback(highAlpha_value): print "Value of highAlpha is ", highAlpha_value file_name = str(eyesOption[0]) + '-' + str(alphaOption[1]) with open(file_name, 'a') as f: f.write(str(highAlpha_value) + '\n') def lowalpha_callback(lowAlpha_value): print "Value of lowAlpha is ", lowAlpha_value
from NeuroPy import NeuroPy from time import sleep import csv from subprocess import call import sys poorcnter = 0 val = 0 cnter = 0 qwe = 0 arr = [0.000] * 2048 object1 = NeuroPy("COM28") # with open('dataset5.csv', 'wb') as f: # writer = csv.writer(f) def attention_callback(attention_value): global poorcnter if (poorcnter == 0): if (object1.poorSignal != 0): poorcnter = 1 print("started taking data") else: if (object1.attention >= 15 and object1.meditation >= 15 and object1.poorSignal == 0 and attention_value < 30000): global cnter cnter += 1 for i in range(len(arr) - 1): arr[i] = arr[i + 1] arr[2047] = attention_value if (cnter == 2048): global qwe
from NeuroPy import NeuroPy from time import sleep from time import time import csv neuropy = NeuroPy("/dev/rfcomm1") neuropy.start() sleep(3) with open('_jamanna blink.csv', 'w') as csvfile: fieldnames = ['attention', 'delta', 'meditation', 'rawValue', 'theta', 'lowAlpha', 'highAlpha', 'lowBeta', 'highBeta', 'lowGamma', 'midGamma', 'poorSignal', 'blinkStrength' ,'label'] writer = csv.DictWriter(csvfile, fieldnames=fieldnames) writer.writeheader() i = time() j = time() print "Action 1 = truth" while(j-i<140): writer.writerow({'attention': neuropy.attention, 'delta': neuropy.delta, 'meditation': neuropy.meditation, 'rawValue': neuropy.rawValue, 'theta': neuropy.theta, 'lowAlpha': neuropy.lowAlpha, 'highAlpha': neuropy.highAlpha, 'lowBeta': neuropy.lowBeta, 'highBeta': neuropy.highBeta, 'lowGamma' : neuropy.lowGamma, 'midGamma' : neuropy.midGamma, 'poorSignal' : neuropy.poorSignal, 'blinkStrength': neuropy.blinkStrength, 'label': '1'}) sleep(0.1) j = time() csvfile.close() neuropy.stop()
import serial import time from NeuroPy import NeuroPy ser = serial.Serial(port='COM5', baudrate=9600) #set the Arduino port connection object1 = NeuroPy("COM4", 57600) #set the MindWave headset portconnection #change ports if needed object1.start() #start reading from the MindWave headset #t_end = time.time() + 60 * 1 to define time for the while-loop if needed print 'Are you ready to break a spoon bitch !!!' a = input('Shall we continue sucker ?') #request a keyboard input, which is '' to continue with the script #this is done to allow time for the servo to go to the initial position try: while True: if object1.attention > 40: #this statement tells the arduino to start moving the motor if #attention level is over 40 (attention level varies 0-100) ser.write('5') time.sleep(0.5) #0.5s time delay to make consistent and smooth movement of the motor print object1.attention else: #this statement tells the arduino to stop moving the motor if # attention level is bellow the threshold time.sleep(0.5) # another time delay for consistency
import csv from subprocess import call import sys import time ts = time.strftime("%I%M%S") val = 0 val2 = 0 val3 = 0 cnter = 0 cnter2 = 0 cnter3 = 0 qwe = 0 arr = [0.000] * 512 arr2 = [0.000] * 1024 arr3 = [0.000] * 2048 object1 = NeuroPy("COM5") # with open('dataset5.csv', 'wb') as f: # writer = csv.writer(f) def attention_callback(attention_value): if (object1.attention >= 10 and object1.meditation >= 10 and object1.poorSignal == 0 and attention_value < 30000): global cnter global cnter2 global cnter3 cnter += 1 cnter2 += 1 cnter3 += 1 for i in range(len(arr) - 1): arr[i] = arr[i + 1]
def __init__(self, aantal_avg, interval, com_port_mindwave): self.aantal_avg = aantal_avg self.interval = interval self.com = com_port_mindwave self.mindwave_instance = NeuroPy(self.com) self.mindwave_instance.start()
# Connect to Mindwave to computer first # Call neuropy.start() to get data. # Neuropy.stop() to stop from NeuroPy import NeuroPy import numpy as np import matplotlib.pyplot as plt import mindwave, time neuropy = NeuroPy() neuropy.start() then = time.time() now = time.time() plt.axis([-2000, 2000, 0, 50]) plt.ion() #connects the path(usb) and the specific serial number of your mindwave headset = mindwave.Headset('COM5', 'CC0E') time.sleep(2) #connecting the mindwave headset.connect() print("Pairing...") while mindwave.status != "Paired!": time.sleep(2) if mindwave.status == "Standing by...": mindwave.connect() print("Retrying...") print("Paired!")
def predict(model, scl, inpt): inpt = inpt.reshape(1, -1) inpt = scl.transform(inpt) inpt = torch.FloatTensor(inpt) out = model(inpt) y_test_pred = torch.sigmoid(out) y_pred_tag = torch.round(y_test_pred) return y_pred_tag.item() model, scaler = load_model('model_no_jump_hist40.pth', 'scaler_no_jump_hist40.scl') neuropy = mp.NeuroPy(port='COM4') results = Attrdict() def set_callback(neuropy, name, print_result=False, function=None): def default_function(value): results[name] = value if print_result: print(name, value) results[name] = 0 selected_function = function if function else default_function neuropy.setCallBack(name, selected_function) is_pressed_manually = False
#code to obtain data from NeuroPy import NeuroPy import time datafile = open("testdata.txt", "w+") object = NeuroPy("COM11", 57600) #Start communication object.start() f = 200 #set sampling frequency t = 2 #set sampling time N = f * 2 #no of sample points datafile.write('%d\n' % f) datafile.write('%d\n' % N) i = 0 while i < N: datafile.write('%d\n' % object.rawValue) time.sleep(1 / f) i = i + 1 datafile.close()
from NeuroPy import NeuroPy #import winsound import numpy as np import matplotlib.pyplot as plt import matplotlib.animation as animation from pyo import * s = Server().boot() npo = NeuroPy('/dev/rfcomm0', 57600) npo.start() def npacb(sigval): print sigval return None #npo.setCallBack("rawValue",npacb) npo.setCallBack("attention", npacb) freqeeg = 512 def crtfrearray(feeg): eegcoll = [] cnteeg = 0 while cnteeg < feeg: eegcoll.append(npo.rawValue) cnteeg += 1 freqs = np.fft.fftfreq(len(eegcoll))
class MyWin(QtWidgets.QMainWindow): started = False ncolors = 256 colors_by_att = False MindWave_obj = NeuroPy("COM3") cam = cv2.VideoCapture() pwidth, pheight = 0, 0 pil_img = Image.init() pixmap = QtGui.QPixmap def __init__(self, parent=None): QtWidgets.QWidget.__init__(self, parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.setWindowTitle("Color levels | PyQt | OpenCV | NeuroSky MindWave") self.setGeometry(400, 100, 1241, 820) self.ui.pushButton_3.clicked.connect(self.Ext) self.ui.pushButton_4.clicked.connect(self.loadImage) self.ui.pushButton_5.clicked.connect(self.saveImage) self.ui.horizontalSlider.setValue(self.ncolors) self.ui.horizontalSlider.valueChanged.connect(self.colorsChanged) self.ui.checkBox.stateChanged.connect(self.colorsModeChanged) self.ui.checkBox_2.stateChanged.connect(self.cameraModeChanged) self.pwidth = self.ui.label.width() self.pheight = self.ui.label.height() self.pil_img = Image.open("eye.jpg") self.pixmap = QtGui.QPixmap.fromImage( self.pilImgToQImg_resized(self.pil_img)) self.ui.label.setPixmap(self.pixmap) if not self.MindWave_obj.threadRun: try: self.MindWave_obj.start() self.statusBar().showMessage(" === MindWave connected! === ") except: self.statusBar().showMessage( " === Connection to MindWave failed! === ") def pilImgToQImg_resized(self, pilimg): """ convert Pillow Image to QImage and resize choosen image to window area """ ocvimg = cv2.cvtColor(np.array(pilimg), cv2.COLOR_RGB2BGR) dim = (self.pwidth, self.pheight) resized = cv2.resize(ocvimg, dim, interpolation=cv2.INTER_AREA) self.pil_img = Image.fromarray(cv2.cvtColor(resized, cv2.COLOR_BGR2RGB)) return QtGui.QImage(resized, resized.shape[1], resized.shape[0], resized.shape[1] * 3, QtGui.QImage.Format_RGB888).rgbSwapped() def saveImage(self): """ save current transformation of image to file """ fileName, _ = QFileDialog.getSaveFileName( self, "QFileDialog.getSaveeFileName()", "", "Image Files (*.jpg *.png *.bmp)") if fileName: self.pixmap.save(fileName) def loadImage(self): """ load image from file """ fileName, _ = QFileDialog.getOpenFileName( self, "QFileDialog.getOpenFileName()", "", "Image Files (*.jpg *.png *.bmp)") if fileName: self.pil_img = Image.open(fileName) self.pixmap = QtGui.QPixmap.fromImage( self.pilImgToQImg_resized(self.pil_img)) self.ui.label.setPixmap(self.pixmap) def cameraModeChanged(self): """ turn on / off camera input """ if not self.cam.isOpened(): self.cam.open(0) self.started = True else: self.started = False self.cam.release() def colorsModeChanged(self): """ turn on / off color levels dependency on attention level (obtained from EEG device) """ self.colors_by_att = not self.colors_by_att def colorsChanged(self): """ processing change of color levels """ self.ncolors = self.ui.horizontalSlider.value() self.ui.progressBar.setValue(self.MindWave_obj.attention) self.ui.label_3.setText("COLOR LEVELS: " + str(self.ncolors)) if not self.started: t_pil_img = self.pil_img.convert( 'P', palette=Image.ADAPTIVE, colors=self.ncolors).convert('RGB') im = t_pil_img.convert("RGBA") data = im.tobytes("raw", "RGBA") qim = QtGui.QImage(data, im.size[0], im.size[1], QtGui.QImage.Format_RGBA8888) self.pixmap = QtGui.QPixmap.fromImage(qim) self.ui.label.setPixmap(self.pixmap) def update_flow(self): """ update attention value and processing camera input for transformation """ self.ui.progressBar.setValue(self.MindWave_obj.attention) if self.started: ret, frame = self.cam.read() frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) t_pil_img = Image.fromarray(frame) t_pil_img = t_pil_img.convert('P', palette=Image.ADAPTIVE, colors=self.ncolors).convert('RGB') im = t_pil_img.convert("RGBA") data = im.tobytes("raw", "RGBA") qim = QtGui.QImage(data, im.size[0], im.size[1], QtGui.QImage.Format_RGBA8888) self.pixmap = QtGui.QPixmap.fromImage(qim).scaled( self.pwidth, self.pheight, QtCore.Qt.IgnoreAspectRatio) self.ui.label.setPixmap(self.pixmap) if self.MindWave_obj.attention > 0: if self.colors_by_att: self.ncolors = self.MindWave_obj.attention self.ui.horizontalSlider.setValue(self.ncolors) def Ext(self): """ exit the application """ sys.exit()
from NeuroPy import NeuroPy from time import sleep import serial neuropy = NeuroPy(port='/dev/tty.MindWaveMobile-SerialPo') def attention_callback(attention_value): """this function will be called everytime NeuroPy has a new value for attention""" print "Value of attention is: ", attention_value return None neuropy.setCallBack("attention", attention_callback) # neuropy.__srl = serial.Serial( # '/dev/tty.MindWaveMobile-SerialPo', 57600) #neuropy.__srl.flushInput() neuropy.start() print('Sleeping for 10 seconds') sleep(10) try: while True: sleep(1) finally: neuropy.stop()
class neural(): data2 = pd.read_csv('dataset4.csv', names=['att', 'med', 'poo', 'rawValue', 'label']) X_test = data2.rawValue.tolist() # plot 4 images as gray scale tsts2 = [] for i in range(len(X_test)): temp = literal_eval(X_test[i]) temp2 = np.array(temp) tsts2.append(temp2) X_test = np.array(tsts2) X_test = X_test.reshape(len(X_test), 1, 8) json_file = open('model.json', 'r') loaded_model_json = json_file.read() json_file.close() loaded_model = model_from_json(loaded_model_json) # load weights into new model loaded_model.load_weights("model.h5") print("Loaded model from disk") # evaluate loaded model on test data loaded_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) sleep(1) print("taking input started") object1 = NeuroPy("COM11") def attention_callback(attention_value): win = GraphWin('Face', 200, 150) # give title and dimensions win.yUp() # make right side up coordinates! head = Circle(Point(40, 100), 25) # set center and radius head.setFill("yellow") head.draw(win) if (object1.attention >= 5 and object1.meditation >= 5): print(object1.poorSignal) temp = [ object1.delta, object1.theta, object1.lowAlpha, object1.highAlpha, object1.lowBeta, object1.highBeta, object1.lowGamma, object1.midGamma ] #with open('dataset3.csv', 'ab') as f: #writer = csv.writer(f) #writer.writerow([object1.attention, object1.meditation, object1.poorSignal, temp, 0]) temp2 = [temp] temp2 = np.array(temp2) temp2 = temp2.reshape(len(temp2), 1, 8) ynew = loaded_model.predict_proba(temp2) print("X=%s, Predicted=%s" % (temp2, ynew)) if (ynew[0][0] > 0.69): print("left") eye1 = Circle(Point(30, 105), 5) eye1.setFill('blue') eye1.draw(win) if (ynew[0][1] > 0.69): print("right") eye2 = Line(Point(45, 105), Point(55, 105)) # set endpoints eye2.setWidth(3) eye2.draw(win) return None #set call back: object1.setCallBack("delta", attention_callback) #call start method object1.start() while True: if ( object1.meditation > 100 ): #another way of accessing data provided by headset (1st being call backs) print("geda meditationg too much") #object1.stop() #if meditation level reaches above 70, stop fetching data from the headset
from NeuroPy import NeuroPy from time import sleep neuropy = NeuroPy("COM4") neuropy.start() while True: if neuropy.meditation > 70: # Access data through object neuropy.stop() sleep(0.2) # Don't eat the CPU cycles
json_file = open('model4.json', 'r') loaded_model_json = json_file.read() json_file.close() loaded_model = model_from_json(loaded_model_json) # load weights into new model loaded_model.load_weights("model4.h5") print("Loaded model from disk") # evaluate loaded model on test data loaded_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) sleep(1) print("taking input started") object1=NeuroPy("COM15") count=0 count0=0 count1=0 val=0 cnter=0 qwe=0 arrdelta=[0.000]*8 arrtheta=[0.000]*8 arrloalpha=[0.000]*8 arrhialpha=[0.000]*8 arrlobeta=[0.000]*8 arrhibeta=[0.000]*8 arrlogamma=[0.000]*8 arrmidgamma=[0.000]*8 def attention_callback(attention_value):
from NeuroPy import NeuroPy from time import sleep from threading import Timer def end_reading(): file_at.close() # file_me.close() # file_bl.close() neuropy.stop() neuropy = NeuroPy('COM4') neuropy.start() t = Timer(10.0, end_reading) file_at = open('data-bl.txt', 'w') t.start() while True: file_at.write(str(neuropy.blink)) file_at.write('\n') sleep(0.2)
__author__ = "Shivam Shekhar, edited by COGS 189 Group!" import os import sys import pygame import random from pygame import * from time import sleep from NeuroPy import NeuroPy neuropy = NeuroPy("COM3") data = [] pygame.init() scr_size = (width, height) = (600, 150) FPS = 60 gravity = 0.6 black = (0, 0, 0) white = (255, 255, 255) background_col = (235, 235, 235) high_score = 0 screen = pygame.display.set_mode(scr_size) clock = pygame.time.Clock() pygame.display.set_caption("T-Rex Rush") jump_sound = pygame.mixer.Sound('sprites/jump.wav') die_sound = pygame.mixer.Sound('sprites/die.wav')
from NeuroPy import NeuroPy from time import sleep import csv from subprocess import call import sys val = 0 cnter = 0 qwe = 0 arr = [0.000] * 2048 object1 = NeuroPy("COM22") # with open('dataset5.csv', 'wb') as f: # writer = csv.writer(f) def attention_callback(attention_value): if (object1.attention >= 15 and object1.meditation >= 15 and object1.poorSignal == 0 and attention_value < 30000): global cnter cnter += 1 for i in range(len(arr) - 1): arr[i] = arr[i + 1] arr[2047] = attention_value if (cnter == 2048): global qwe global val # if(qwe==0): # qwe=1 # val=input("(0 for red 1 for green 2 for black and 3 for yellow)") # cnter=0 # return None
import pyautogui as pi from win32api import GetSystemMetrics import pytweening import time import win32gui def map(x, oFrom, oTo, nFrom, nTo): return x * ((nTo - nFrom) / (oTo - oFrom)) pass print("Width =", GetSystemMetrics(0)) print("Height =", GetSystemMetrics(1)) ob = NeuroPy("COM6") ob.start() count = 0 flag = 1 lastAttention = 0 while (True): # print(ob.attention, "blink",ob.blinkStrength) # pi.moveTo(map(ob.attention+1, 1, 100, 1, GetSystemMetrics(0)), # map(ob.meditation+1, 1, 100, 1, GetSystemMetrics(1)), pytweening.easeInQuad(0.75)) # pi.moveTo(map(ob.highBeta+1, 1, 100, 1, GetSystemMetrics(0)), # 100, pytweening.easeInQuad(0.75)) # print(ob.blinkStrength) # time.sleep(0.1) # print("alpha ",ob.highAlpha," ",ob.lowAlpha," Beta ",ob.highBeta," ",ob.lowBeta) flags, hcursor, (x, y) = win32gui.GetCursorInfo() if (ob.attention == 0):
def PostRequest(request_body): # 构造服务接口地址 url = 'http://localhost:{0}/'.format(6000) r0 = requests.post(url=url, json=request_body) # print(r0.json()) pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True) r = redis.Redis(connection_pool=pool) serport = FindSerialDevice("Select the Serial port: ") ser = serial.Serial(serport, 9600, timeout=1) mindwaveport = FindSerialDevice("Select the Mindwave port: ") bluetooth_baund_rate = input( 'bluetooth baund rate (default: 57600) >') or 57600 mindwave = NeuroPy(mindwaveport, bluetooth_baund_rate) jsonlist = [] jsonlist1 = [] list = [] if ser.is_open: ser.flushOutput() ser.flushInput() try: mindwave.start() while 1: ser.flushOutput() now_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') response = ser.readline().decode().strip() low_alpha = mindwave.low_alpha