def __init__(self, out_queue): Thread.__init__(self) self.out_queue = out_queue self.headset = mindwave.Headset('/dev/tty.MindWave', 'C61A') self.headset.connect() self._stop = False time.sleep(2)
def main(): headset = mindwave.Headset('/dev/rfcomm0') time.sleep(2) headset.connect() while True: # poor_signal, attention, meditation, blink, raw_value, status attention = headset.attention print "Attention: ", attention
def bacadata(): headset = mindwave.Headset('COM4', '1425') time.sleep(1) headset.connect() print "Connecting..." headset.status != 'connected': time.sleep(1) headset.status == 'standby': headset.connect() print "Retrying connect..."
def __init__(self, foldername): self.foldername = foldername time.sleep(2) #pygame.init() self.headset = mindwave.Headset('/dev/ttyUSB0','ee69') #pygame.display.set_mode((100,100)) self.headset.connect() print "Connecting..." while self.headset.status != 'connected': time.sleep(0.5) if self.headset.status == 'standby': self.headset.connect() print "Retrying connect..." print "Connected."
def bacadataloop(): headset = mindwave.Headset('COM4', '1425') time.sleep(1) headset.connect() print "Connecting..." while headset.status != 'connected': time.sleep(1) if headset.status == 'standby': headset.connect() print "Retrying connect..." print "Connected." while True: print headset.raw_value time.sleep(1)
def recordRaw(): headset = mindwave.Headset('/dev/tty.MindWaveMobile-SerialPo', '625f') time.sleep(initial_sleep) dateTimeString = datetime.now().strftime("%m_%d_%Y__%H_%M_%S") headset.connect() signal = [] start_time = time.time() while True: v = headset.raw_value time.sleep(0.001) print(v, headset.poor_signal, headset.blink) signal.append(v) if time.time() > start_time + 30: break f = open('signal' + dateTimeString + '.txt', 'w') f.write(str(signal)) f.write("start time:" + str(start_time)) f.close()
def monitor(self): if self.running: if self.h: self.h.serial_close() self.running = False else: self.running = True self.h = None import serial try: device = self.deviceComboBox.currentText() self.h = mindwave.Headset("{0}".format(device)) except serial.serialutil.SerialException, e: print "{0}".format(e) QtGui.QMessageBox.information(self.MainWindow, 'Couldn\'t find the headset', 'Headset not found. Did you pair and connect to serial device {0}?'.format(device), QtGui.QMessageBox.Ok) if self.h: self.h.raw_wave_handlers.append(self.raw_wave_handler) else: self.running = False
def run(self): print("Connecting") headset = mindwave.Headset('/dev/tty.MindWaveMobile-SerialPo') time.sleep(2) print("Connected!") try: while (headset.poor_signal > 5): print( "Headset signal noisy %d. Adjust the headset and the earclip." % (headset.poor_signal)) time.sleep(0.1) print("Writing output to LSL stream") stime = time.time() prevTime = 0 while True: cycle_start_time = time.time() if headset.poor_signal > 5: print( "Headset signal noisy %d. Adjust the headset and the earclip." % (headset.poor_signal)) self.__eeg_outlet.push_sample(np.array([0, 0, 0, 0])) else: self.__eeg_outlet.push_sample( np.array([ headset.raw_value, headset.attention, headset.meditation, headset.blink ])) timeDiff = int(time.time() - stime) if (timeDiff != prevTime): print("seconds elapsed: " + str(timeDiff)) prevTime = timeDiff time.sleep((1 / (self.__Fs)) - (time.time() - cycle_start_time + 0.0005)) finally: print("Closing!") headset.stop()
def MainThread(): while True: def on_raw(headset, raw): queue.put(raw) #print queue.get() data = [] data.append(raw) path = "relaxy.csv" printraw(data, path) def printraw(data, path): with open(path, 'a') as f: writer = csv.writer(f) for i in data: writer.writerow(data) headset = mindwave.Headset('/dev/ttyUSB0') time.sleep(1) headset.connect() print("Connecting") while headset.status != 'connected': time.sleep(0.5) if headset.status == 'standby': headset.connect() print("Retrying") try: print("connected") headset.raw_value_handlers.append(on_raw) time.sleep(1200) headset.disconnect() except KeyboardInterrupt: headset.disconnect() except: headset.disconnect() print("Unknown Error") raise
def monitor(self): """ start/stop button pressed """ print "monitor" if self.running: self.connected = "Not connected" self.signal_quality = "unknown signal quality" for i, mo in enumerate(self.midiOut): bytemsg = self.notequeue.clear_notes(i) for msg in bytemsg: self.midiOut[i].send_message(msg) if self.h: self.h.serial_close() self.running = False else: self.connected = "Connected" self.signal_quality = "unknown signal quality" self.running = True self.h = None import serial try: device = self.deviceComboBox.currentText() self.h = mindwave.Headset("{0}".format(device)) except serial.serialutil.SerialException, e: print "{0}".format(e) QtGui.QMessageBox.information( self.MainWindow, 'Couldn\'t find the headset', 'Headset not found. Did you pair and connect to serial device {0}?' .format(device), QtGui.QMessageBox.Ok) if self.h: self.h.raw_wave_handlers.append(self.raw_wave_handler) self.h.meditation_handlers.append(self.handle_meditation_event) self.h.attention_handlers.append(self.handle_attention_event) self.h.poor_signal_handlers.append(self.handle_poor_signal) self.h.good_signal_handlers.append(self.handle_good_signal) else: self.running = False
def graphAnalysis(): """This function is used to both receive and depict the data into a graph.""" then = time.time() now = time.time() plt.axis([-2000, 2000, 0, 50]) plt.ion() # Connect the path and the mindwave's serial number neuroSet = mindwave.Headset('COM5', 'CC0E') time.sleep(2) # Connect the mindwave neuroSet.connect() print("Currently Pairing Your Headset.") while mindwave.status != "Paired!": time.sleep(2) if mindwave.status == "Standing by.": mindwave.connect() print("Retrying.") print("Paired!") # Put data into graph format using matplotlib x = True while x == True: # time.sleep(.5) print("Attention: %s" % (neuroSet.attention)) now = time.time() duration = now - then duration_sec = duration % 60 x = str(neuroSet.attention) y = str(duration_sec) plt.plot(x, y) plt.pause(1) while True: plt.pause(1)
def train(mode): if mode == "raw": # Connect headset headset = mindwave.Headset('/dev/rfcomm0') time.sleep(2) headset.connect() else: manus = Manus() X = np.zeros((TRAIN_SAMPLE, HISTORY)) Y = np.zeros(TRAIN_SAMPLE) print "Acquiring True condition..." for i in range(TRAIN_SAMPLE / 2): for k in range(HISTORY): if mode == "raw": X[i, k] = headset.attention else: X[i, k] = manus.simulate() if i % 10 == 0: print i Y[:TRAIN_SAMPLE / 2 - 1] = 1 print "Acquiring False condition..." for i in range(TRAIN_SAMPLE / 2): for k in range(HISTORY): if mode == "raw": X[i + TRAIN_SAMPLE / 2, k] = headset.attention else: X[i + TRAIN_SAMPLE / 2, k] = manus.simulate() if i % 10 == 0: print i Y[TRAIN_SAMPLE / 2:] = 0 print "Start training." lin_clf = LinearSVC() lin_clf.fit(X, Y) print "Training finished." pickle.dump(lin_clf, open(MODEL_FILENAME, 'wb'))
def headsetConnect(self, donglePortName): try: if not self.headset or not self.headset.is_open(): self.headset = mindwave.Headset(donglePortName, config.MINDSET_ID) self.headset.attention_handlers.append(self.getAttentionHandler) logger.info('Connect to the Mindwave headset') if self.headset.status != 'connected': if self.headset.status == 'standby': self.headsetStatus = Statuses.DISCONNECTED if self.headsetStatus != Statuses.CONNECTING: self.headsetStatus = Statuses.CONNECTING self.headset.connect(config.MINDSET_ID) else: logger.info('Mindwave headset connected') self.headsetStatus = Statuses.CONNECTED except Exception as err: logger.error(err) self.headset.disconnect() self.headsetStatus = Statuses.DISCONNECTED pass return
import time import mindwave, time import pyqtgraph as pg import numpy as np import mindwave, time then = time.time() headset = mindwave.Headset('COM10', 'CC0E') time.sleep(2) headset.connect() print "Connecting..." while headset.status != 'connected': time.sleep(0.5) if headset.status == 'standby': headset.connect() print "Retrying connect..." print "Connected." x = np.arange(100) y = np.arange(100) x[0] = 0.0000 y[0] = 0.0000 pg.setConfigOption('background', 'w') pg.setConfigOption('foreground', 'k') pw = pg.plot() while True:
import mindwave, time headset = mindwave.Headset('COM4', '1425') time.sleep(1) headset.connect() print "Connecting..." while headset.status != 'connected': time.sleep(1) if headset.status == 'standby': headset.connect() print "Retrying connect..." print "Connected." while True: print headset.raw_value time.sleep(1)
def on_raw(headset, raw): if headset.poor_signal == 0: if raw > 400 and headset.listener.initial == 0: headset.listener.initial = mindwave.datetime.datetime.now() elif raw < -90 and headset.listener.timer( ) > 20 and headset.listener.timer() < 300: on_blink(headset) headset.listener.initial = 0 elif headset.listener.timer() > 500: headset.listener.initial = 0 if __name__ == '__main__': headset = mindwave.Headset('/dev/ttyUSB0') time.sleep(2) headset.connect() print "Connecting" while headset.status != 'connected': time.sleep(0.5) if headset.status == 'standby': headset.connect() print "Retrying" try: print "connected" headset.blink_handlers.append(on_blink) headset.raw_value_handlers.append(on_raw) headset.raw_value_handlers.append(send_poor)
def main(): num_lights = None if len(sys.argv) != 2: print( "\nDiscovery will go much faster if you provide the number of lights on your LAN:" ) print(" python {} <number of lights on LAN>\n".format(sys.argv[0])) else: num_lights = int(sys.argv[1]) # instantiate LifxLAN client, num_lights may be None (unknown). # In fact, you don't need to provide LifxLAN with the number of bulbs at all. # lifx = LifxLAN() works just as well. Knowing the number of bulbs in advance # simply makes initial bulb discovery faster. lifx = LifxLAN(num_lights) # test power control print("Discovering lights...") original_powers = lifx.get_power_all_lights() original_colors = lifx.get_color_all_lights() half_period_ms = 2500 duration_mins = 20 duration_secs = duration_mins * 60 print("Breathing...") #inititalize lcd display lcd_init() #GPIO.setup(23,GPIO.OUT) #GPIO.setup(12,GPIO.OUT) #GPIO.output(12,GPIO.HIGH) #GPIO.output(23,GPIO.HIGH) GPIO.setup(17, GPIO.OUT) #connect headset to Rpi headset = mindwave.Headset('/dev/ttyUSB0', 'DB00') time.sleep(2) headset.connect() print "Connecting..." while headset.status != 'connected': time.sleep(0.5) if headset.status == 'standby': headset.connect() print "Retrying connect..." print "Connected." time.sleep(1) # dims bulb completely at beginning # brightness in range [0 - 65535] # set_color is [Hue, Saturation, Brightness, Kelvin], duration in ms for bulb in original_colors: color = original_colors[bulb] dim = list(copy(color)) dim[2] = 65000 dim[0] = 62000 #print "changing bulb to %s" % dim[2] bulb.set_color(dim, half_period_ms, rapid=True) lightswitch = False previous = [] #no idea what this is for lol # p = False prevAvg = 0 count = 0 while True: #This is for meditation time.sleep(1) #Take user input for number of readings per output avgSize = 4 while True: question = "Average Size: " + str(avgSize) print question text = raw_input("Average Size = ") if text == "end": break avgSize = int(text) time.sleep(1) while True: if count < avgSize - 1: count += 1 previous.append(headset.meditation) #for x in range(len(previous)): # print previous[x] else: #p = False previous.append(headset.meditation) #for x in range(len(previous)): # print previous[x] k = 0 sum = 0 while k < avgSize: sum += previous[k] k += 1 Avg = sum / len(previous) #print original_colors # max brightness of bulb goes from 0 to 65535 based on reverse of Avg. So closer to max meditation means dimmer bulb. # brightness in range [0 - 65535] # set_color is [Hue, Saturation, Brightness, Kelvin], duration in ms for bulb in original_colors: color = original_colors[bulb] dim = list(copy(color)) #dim[2] = 655*(100-Avg) dim[0] = 62000 - 200 * Avg #bulb.set_color(dim, 0, rapid=True) #print "changing bulb to %s" % dim[2] bulb.set_color(dim, half_period_ms, rapid=True) #time.sleep(half_period_ms/1000.0) previous = [] count = 0 print "Meditation: %s changing bulb to %s" % (Avg, dim[0]) #switch light state if avg is more than 50 and prev is less than 50 if Avg >= 50 and prevAvg < 50: if lightswitch == False: GPIO.output(17, GPIO.HIGH) lightswitch = True else: GPIO.output(17, GPIO.LOW) lightswitch = False prevAvg = Avg time.sleep(1)
import mindwave, time from pprint import pprint headset = mindwave.Headset('/dev/ttyUSB0', '1F5D') time.sleep(2) headset.connect() print "Connecting..." while headset.status != 'connected': time.sleep(0.5) if headset.status == 'standby': headset.connect() print "Retrying connect..." print "Connected." while True: time.sleep(.5) print "Raw value: %s, Attention: %s, Meditation: %s" % ( headset.raw_value, headset.attention, headset.meditation) pprint(headset.waves)
import threading import mindwave import cv2 import time import os LOW_THRESHOLD_OPENCV = 2 # Anything 2 and under is considered not paying attention LOW_THRESHOLD_MINDWAVE = 75 # Anything below 75 is considered not paying attention STRICT_MODE = False # False is basically (LOW_THRESHOLD_OPENCV OR LOW_THRESHOLD_MINDWAVE) and True is (LOW_THRESHOLD_OPENCV AND LOW_THRESHOLD_MINDWAVE) try: headset = mindwave.Headset("/dev/rfcomm0") headset.connect() except: pass eye_detect_list = [] def get_rolling_average(): print eye_detect_list if len(eye_detect_list) < 10: for i in range(10-len(eye_detect_list)): print("Inserting data for rolling average...") eye_detect_list.insert(0,3) return sum(eye_detect_list) / float(len(eye_detect_list)) def get_headset_attention(): try: val = headset.attention except: val = 0
def main(): num_lights = None if len(sys.argv) != 2: print("\nDiscovery will go much faster if you provide the number of lights on your LAN:") print(" python {} <number of lights on LAN>\n".format(sys.argv[0])) else: num_lights = int(sys.argv[1]) # instantiate LifxLAN client, num_lights may be None (unknown). # In fact, you don't need to provide LifxLAN with the number of bulbs at all. # lifx = LifxLAN() works just as well. Knowing the number of bulbs in advance # simply makes initial bulb discovery faster. lifx = LifxLAN(num_lights) # test power control print("Discovering lights...") original_powers = lifx.get_power_all_lights() original_colors = lifx.get_color_all_lights() half_period_ms = 2500 duration_mins = 20 duration_secs = duration_mins*60 print("Breathing...") #inititalize lcd display lcd_init() #GPIO.setup(23,GPIO.OUT) #GPIO.setup(12,GPIO.OUT) #GPIO.output(12,GPIO.HIGH) #GPIO.output(23,GPIO.HIGH) GPIO.setup(17,GPIO.OUT) #connect headset to Rpi headset = mindwave.Headset('/dev/ttyUSB0', 'DB00') time.sleep(2) headset.connect() print "Connecting..." while headset.status != 'connected': time.sleep(0.5) if headset.status == 'standby': headset.connect() print "Retrying connect..." print "Connected." time.sleep(1) # dims bulb completely at beginning # brightness in range [0 - 65535] # set_color is [Hue, Saturation, Brightness, Kelvin], duration in ms for bulb in original_colors: color = original_colors[bulb] dim = list(copy(color)) dim[2] = 65000 dim[0]=62000 #print "changing bulb to %s" % dim[2] bulb.set_color(dim, half_period_ms, rapid=True) previous = 0 #selecting options from menu arr = ['Attention', 'Meditation', 'Blink'] i = 0 j = 1 lcd_byte(LCD_LINE_1, LCD_CMD) lcd_string('Select option',2) lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string('Press any Button' ,2) while GPIO.input(14)==GPIO.LOW and GPIO.input(15)==GPIO.LOW: pass time.sleep(1) lcd_byte(LCD_LINE_1, LCD_CMD) lcd_string("-->" + arr[i],2) lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string(arr[j],2) while True: #print "Attention: %s, Meditation: %s, previous: %s" % (headset.attention, headset.meditation,previous) #scroll through options on the menu if GPIO.input(15)== GPIO.HIGH: print('Scrolling--------') i = (i+1)%3 j = (j+1)%3 lcd_byte(LCD_LINE_1, LCD_CMD) lcd_string("-->" + arr[i],2) lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string(arr[j],2) while GPIO.input(15)== GPIO.HIGH: pass ## lcd.GPIO.cleanup() #select option if GPIO.input(14)== GPIO.HIGH: selected = arr[i] print ("Selected " + selected) lightswitch = False previous = [] p = False prevAvg=0 count = 0 #if attention is selected if i==0: time.sleep(1) lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string("Type end to Cont",2) #Take user input for number of readings per output avgSize =4 while True: lcd_byte(LCD_LINE_1, LCD_CMD) question = "Average Size: "+str(avgSize) lcd_string(question,2) text = raw_input("Average Size = ") if text == "end": break avgSize = int(text) lcd_byte(LCD_LINE_1, LCD_CMD) lcd_string("Sel. Attention ",2) time.sleep(1) while True: if GPIO.input(14)==GPIO.HIGH: break if count < avgSize-1: count+=1 previous.append(headset.attention) #for x in range(len(previous)): # print previous[x] else: #p = False previous.append(headset.attention) #for x in range(len(previous)): # print previous[x] k = 0 sum = 0 while k < avgSize: sum += previous[k] k+=1 Avg = sum/len(previous) previous = [] count = 0 print "Attention: %s" % Avg #switch light state if avg is more than 50 and prev is less than 50 if Avg >= 50 and prevAvg < 50: if lightswitch == False : GPIO.output(17,GPIO.HIGH) lightswitch = True else: GPIO.output(17,GPIO.LOW) lightswitch = False prevAvg = Avg lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string(str(Avg),2) time.sleep(1) #if meditation is selected if i ==1: time.sleep(1) lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string("Type end to Cont",2) #Take user input for number of readings per output avgSize =4 while True: lcd_byte(LCD_LINE_1, LCD_CMD) question = "Average Size: "+str(avgSize) lcd_string(question,2) text = raw_input("Average Size = ") if text == "end": break avgSize = int(text) lcd_byte(LCD_LINE_1, LCD_CMD) lcd_string("Sel. Meditation ",2) time.sleep(1) while True: if GPIO.input(14)==GPIO.HIGH: break if count < avgSize-1: count+=1 previous.append(headset.meditation) #for x in range(len(previous)): # print previous[x] else: #p = False previous.append(headset.meditation) #for x in range(len(previous)): # print previous[x] k = 0 sum = 0 while k < avgSize: sum += previous[k] k+=1 Avg = sum/len(previous) #print original_colors # max brightness of bulb goes from 0 to 65535 based on reverse of Avg. So closer to max meditation means dimmer bulb. # brightness in range [0 - 65535] # set_color is [Hue, Saturation, Brightness, Kelvin], duration in ms for bulb in original_colors: color = original_colors[bulb] dim = list(copy(color)) #dim[2] = 655*(100-Avg) dim[0] = 62000-200*Avg #bulb.set_color(dim, 0, rapid=True) #print "changing bulb to %s" % dim[2] bulb.set_color(dim, half_period_ms, rapid=True) #time.sleep(half_period_ms/1000.0) previous = [] count = 0 print "Meditation: %s changing bulb to %s" % (Avg,dim[0]) #switch light state if avg is more than 50 and prev is less than 50 if Avg >= 50 and prevAvg < 50: if lightswitch == False : GPIO.output(17,GPIO.HIGH) lightswitch = True else: GPIO.output(17,GPIO.LOW) lightswitch = False prevAvg = Avg lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string(str(Avg),2) time.sleep(1) #if blink is selected #blink doesnt work yet if i == 2: print('WORK IN PROGRESS') lcd_byte(LCD_LINE_1, LCD_CMD) lcd_string("-->" + arr[i],2) lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string(arr[j],2) GPIO.output(17,GPIO.LOW) while GPIO.input(14)== GPIO.HIGH: pass
plt.pause(0.0001) self.plcounter = self.plcounter + 1 if self.plcounter > self.rangeval: self.plcounter = 0 self.plotx[:] = [] self.x[:] = [] self.y[:] = [] self.z[:] = [] import mindwave, time # Hardcoded serial number of my Mindwave device. headset = mindwave.Headset() time.sleep(2) plotter = Plotter(500, -500, 500) attention = 0 meditation = 0 eeg = 0 # def on_raw( headset, rawvalue): # time.sleep(.01) # print "Count %d :Raw value: %s, Attention: %s, Meditation: %s" % (headset.count, headset.raw_value, headset.attention, headset.meditation) # (eeg, attention, meditation) = (headset.raw_value, headset.count, headset.meditation) # plotter.plotdata( [eeg, attention, meditation]) #
import mindwave import time import matplotlib.pyplot as plt headset = mindwave.Headset('/dev/tty.MindWaveMobile-SerialPo', '625f') time.sleep(2) headset.connect() signal = [] start_time = time.time() while True: v = headset.raw_value time.sleep(0.001) print(v) signal.append(v) if time.time() > start_time + 30: break plt.plot(signal) plt.show() f = open('signal.txt', 'w') f.write(str(signal)) f.close()
med_array.append(headset.meditation) att_array.append(headset.attention) med = np.mean(med_array) att = np.mean(att_array) mood = (att - med) / 200.0 + 0.50 return mood if __name__ == '__main__': global sp global user_config global med global att global mood global headset headset = mindwave.Headset(port + sys.argv[1], '625f') headset.autoconnect() headset.connect() med = 0 att = 0 mood = 0.5 mood_old = 0 load_config() token = util.prompt_for_user_token( user_config['username'], scope= 'user-follow-read,user-top-read,user-modify-playback-state,user-read-playback-state,streaming,app-remote-control,playlist-modify-private,playlist-modify-public', client_id=user_config['client_id'], client_secret=user_config['client_secret'], redirect_uri=user_config['redirect_uri']) spotify_auth = spotipy.Spotify(auth=token)
import mindwave import time headset = mindwave.Headset('/dev/tty.MindWave','625f') time.sleep(2) headset.autoconnect() #headset.connect() print "Connecting.." while (headset.status) != 'connected': print headset.status time.sleep(0.5) if headset.status == 'standby': headset.autoconnect() print "Retrying connect..." print "Connected." while True: print "Attention: %s, Meditation: %s" % (headset.attention, headset.meditation) time.sleep(2)
import mindwave, time import os port = "/dev/null" mid = "1425" rate = 0.001953125 namafile = "hasilnya.csv" runfile = "run" open(runfile, 'a').close() headset = mindwave.Headset(port, mid) headset.connect() print("Connecting") while headset.status != "connected": time.sleep(0.5) if headset.status == "standby": headset.connect() print("Retrying connect...") print("Connected.") f = open(namafile, 'a+') while True: if os.path.exists(runfile) != True: f.close() break try: while True:
import mindwave, time #headset = mindwave.Headset('/dev/tty.MindWaveMobile-DevA','ef47') headset = mindwave.Headset('COM4') time.sleep(2) while True: time.sleep(.5) print ("Raw value: %s, Attention: %s, Meditation: %s" % (headset.raw_value, headset.attention, headset.meditation))
currentTimestamp = None currentRawValue = None currentAttention = None trial_index = 0 # the first trial in the permutation data = {'timestamp': [], 'raw_value': [], 'attention': []} sampled_data = { 'timestamp': [], 'raw_value': [], 'attention': [], 'label': [] } print("Connecting...") headset = mindwave.Headset( '/dev/tty.MindWaveMobile-SerialPo') # mac version print("Connected!") try: while (headset.poor_signal > 5): print( "Headset signal noisy %d. Adjust the headset and the earclip." % (headset.poor_signal)) time.sleep(0.1) print("Writing %d seconds output to %s" % (secondsToSample, filename)) stime = time.time() trial_stime = time.time() headset.raw_value_handlers.append(on_raw) prevTime = 0 while ((time.time() - stime) < secondsToSample):
def main(): lcd_init() GPIO.setup(17,GPIO.OUT) headset = mindwave.Headset('/dev/ttyUSB0', 'DB00') time.sleep(2) headset.connect() print "Connecting..." while headset.status != 'connected': time.sleep(0.5) if headset.status == 'standby': headset.connect() print "Retrying connect..." print "Connected." time.sleep(1) previous = 0 arr = ['Attention', 'Meditation', 'Blink'] i = 0 j = 1 lcd_byte(LCD_LINE_1, LCD_CMD) lcd_string('Select option',2) lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string('Press any Button' ,2) while GPIO.input(14)==GPIO.LOW and GPIO.input(15)==GPIO.LOW: pass time.sleep(1) lcd_byte(LCD_LINE_1, LCD_CMD) lcd_string("-->" + arr[i],2) lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string(arr[j],2) while True: #print "Attention: %s, Meditation: %s, previous: %s" % (headset.attention, headset.meditation,previous) if GPIO.input(15)== GPIO.HIGH: print('Scrolling--------') i = (i+1)%3 j = (j+1)%3 lcd_byte(LCD_LINE_1, LCD_CMD) lcd_string("-->" + arr[i],2) lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string(arr[j],2) while GPIO.input(15)== GPIO.HIGH: pass ## lcd.GPIO.cleanup() if GPIO.input(14)== GPIO.HIGH: selected = arr[i] print ("Selected " + selected) lightswitch = False previous = 0 p = False prevAvg=0 if i==0: lcd_byte(LCD_LINE_1, LCD_CMD) lcd_string("Sel. Attention ",2) time.sleep(1) while True: if GPIO.input(14)==GPIO.HIGH: break if p == False: p = True previous = headset.attention else: p = False Avg = (headset.attention+previous)/2 print "Attention: %s" % Avg if Avg >= 50 and prevAvg < 50: if lightswitch == False : GPIO.output(17,GPIO.HIGH) lightswitch = True else: GPIO.output(17,GPIO.LOW) lightswitch = False prevAvg = Avg lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string(str(Avg),2) time.sleep(1) if i ==1: lcd_byte(LCD_LINE_1, LCD_CMD) lcd_string("Sel. Meditation",2) time.sleep(1) while True: if GPIO.input(14)==GPIO.HIGH: break if p == False: p = True previous = headset.attention else: p = False Avg = (headset.attention+previous)/2 print "Meditation: %s" % Avg if Avg >= 50 and prevAvg < 50: if lightswitch == False : GPIO.output(17,GPIO.HIGH) lightswitch = True else: GPIO.output(17,GPIO.LOW) lightswitch = False prevAvg = Avg lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string(str(Avg),2) time.sleep(1) if i == 2: print('WORK IN PROGRESS') lcd_byte(LCD_LINE_1, LCD_CMD) lcd_string("-->" + arr[i],2) lcd_byte(LCD_LINE_2, LCD_CMD) lcd_string(arr[j],2) GPIO.output(17,GPIO.LOW) while GPIO.input(14)== GPIO.HIGH: pass
#!/usr/bin/python import mindwave import time import datetime #create a tsv file_name of YMD of today's date time_stamp = time.time() file_name = datetime.datetime.fromtimestamp(time_stamp).strftime( '%Y-%m-%d') + '.tsv' f = open(file_name, 'a') #connect the mindwave headset = mindwave.Headset('/dev/tty.MindWaveMobile-DevA', '771C') headset.disconnect() #clear any previous activity headset.connect() while 1: #getting the data meditation_data = headset.meditation attention_data = headset.attention #printing data to screen print("attention average : {0}".format(meditation_data)) print("meditation average: {0}\r\n".format(attention_data)) #create raw and formatted timestamp time_stamp = time.time() date_stamp = datetime.datetime.fromtimestamp(time_stamp).strftime( '%Y-%m-%d %H:%M:%S') #writing data and timestamp to tab-separated-value file
import mindwave, time headset = mindwave.Headset('/dev/ttyUSB3', '1E5F') time.sleep(2) headset.connect() print "Connecting..." while headset.status != 'connected': time.sleep(0.5) if headset.status == 'standby': headset.connect() print "Retrying connect..." print "Connected." while True: time.sleep(.5) print "Attention: %s, Meditation: %s" % (headset.attention, headset.meditation)