def mindWave(duration):
mind = NeuroPy("/dev/tty.MindWaveMobile-DevA", 57600)
mind.start()
cur_time = time()
while time() < cur_time + duration:
cur.execute("INSERT INTO Waves VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", (time(), mind.delta, mind.theta, mind.lowAlpha, mind.highAlpha, mind.lowBeta, mind.highBeta, mind.lowGamma, mind.midGamma, mind.attention, mind.meditation))
sleep(0.5)
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()
class Nsky():
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 attention_callback(self, attention_value):
if (self.neuro_object.attention >= 15
and self.neuro_object.meditation >= 15
and self.neuro_object.poorSignal == 0):
self.counter += 1
for i in range(len(self.data_array) - 1):
self.data_array[i] = self.data_array[i + 1]
self.data_array[1023] = attention_value
if (self.counter == 1024):
if (self.skip_value == 0):
self.skip_value = 1
self.value = input(
"(0 for left and 1 for right and 2 for ntg)")
self.counter = 0
if self.value == 3:
self.neuro_object.stop()
return None
with open('traindata.csv', 'ab') as datafile:
writer = csv.writer(datafile)
writer.writerow([
self.neuro_object.attention,
self.neuro_object.meditation,
self.neuro_object.poorSignal, self.data_array,
self.value
])
self.value = input(
"(0 for left and 1 for right and 2 for ntg)")
self.counter = 0
return None
def caller(self):
#set call back:
self.neuro_object.setCallBack("rawValue", self.attention_callback)
#call start method
self.value = input("(0 for left and 1 for right and 2 for ntg)")
self.neuro_object.start()
while True:
if (
self.neuro_object.meditation > 100
): #another way of accessing data provided by headset (1st being call backs)
print("geda meditationg too much")
def collect(port, user_id):
"""Collect attention and meditation values from NeuroSky headset & store to database"""
print "You have reached the beginning of this function!"
port = str(port)
headset_data = NeuroPy("/dev/cu.MindWaveMobile-DevA-" + port, 57600)
headset_data.start()
current_time = time.time()
start_time = time.time()
elapsed_time = current_time + 30 # Collect data from headset for an elapsed time of a minute.
new_session = Session(utc=datetime.datetime.utcnow(), user_id=user_id)
# TODO: figure out how to get current_user
# current_user.sessions.append(new_session)
# db.session.add(current_user)
# db.session.add(new_session)
# db.session.commit()
print new_session.id
# Add session to database first.
# In the while loop, save attention and meditation data to database.
while current_time < elapsed_time:
attention = headset_data.attention
# print attention
current_time = time.time()
# print current_time, elapsed_time
meditation = headset_data.meditation
new_state = State(utc=datetime.datetime.utcnow(), attention=attention, meditation=meditation, session_id=new_session.id)
# db.session.add(new_state)
# db.session.commit()
new_session.states.append(new_state)
time.sleep(3) # Collect data every 3 seconds.
new_session.generate_high_score()
db.session.add(new_session)
db.session.commit()
# headset_data.stop()
# print attention
return
from NeuroPy import NeuroPy
import serial
try:
neuro = NeuroPy("COM3", 57600)
neuro.start()
print ("Neuropy found on COM5")
except:
print "Not found"
value = 0
while True:
value = neuro.rawValue
print value
'''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'''
#set call back:
#object1.setCallBack("attention",attention_callback)
#call start method
#values = []
#average = 0
object1.start() #initializes the MindWave headset
start_time = 0
i = 0
blinked = False
last_blink_time = 0
double_blink = False
triple_blink = False
quadruple_blink = False
quintuple_blink = False
degrees = False
shouldMove = 1
code_message_sent = False
servos = ['BASE','BOTTOM BARS','MIDDLE BARS','TOP BARS','GRIPPER']
current_servo = 0
code = [] #the binary code that will be determined based on single and double blinks
# Responsável pela conexão com o MindWave
from NeuroPy import NeuroPy
# Responsável pelo controle do Mouse
from mouse import MindMouse
# Responsável pela detecção do Teclado
from pynput import keyboard
# CONFIGURAÇÃO INICIAL #
neuro = NeuroPy("COM6") #Inicializando o MindWave
neuro.start()
'''Exemplos de inicialização:
#windows: object1=NeuroPy("COM6",57600)
#linux: object1=NeuroPy("/dev/rfcomm0",57600)'''
print('Digite uma velocidade de 5 a 15 (5 mais lento e 15 mais rápido):')
velocidade = input() #Definindo a velocidado do mouse
mouseVirtual = MindMouse(int(velocidade)) #Iniciando objeto mouse
# CÓDIGO TEMPORARIO
'''
Objetivo:
Enquanto não estou fazendo uso do equipamento MindWave, para fazer
os testes de manuseio do mouse, estou usando teclas:
u - Cima
j - Baixo
h - Esquerda
k - Direita
l - um mouse click direito
o - um mouse click esquerdo
def attention_level(attention_value):
neuropy.setCallBack("attention",attention_level)
av = attention_value
print "\nAttention level = ", attention_value
if attention_value > 50: #check if attention is above threshold
print "Moving forward"
motor.forward() #forward motion of wheelchair
time.sleep(1)
ultrasonic.ultra() #check for obbstacle distance
else :
print("Stopped Low Attention")
motor.stop()
return
/*
*
* Function Name: main
* Input: -
* Output: -
* Logic: neuropy object used to create multiple threads by neuropy.start()
* Example Call: run.main()
*
*/
if __name__=='__main__':
neuropy.setCallBack("attention",attention_level)
neuropy.start()
def blinkstrength_callback(blinkstrength_value):
print "Value of blinkstrength is", blinkstrength_value
return None
'''
#set recording timer in minutes
nmin = 1
#set call back:
#object1.setCallBack("attention",attention_callback)
#object1.setCallBack("blinkStrength",blinkstrength_callback)
object1.setCallBack("highAlpha", highalpha_callback)
object1.setCallBack("lowAlpha", lowalpha_callback)
#call start method
object1.start()
#define an INET, STREAMing socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#define IP address and match port with EEGServer port
server_address = (SERVER_ADDRESS, 2222)
print >> sys.stderr, 'connecting to %s port %s' % server_address
#socket connect requires IP address and also port number
sock.connect(server_address)
t_end = time.time() + 60 * (nmin)
print('start recording')
while time.time() < t_end:
#keep running until t_end
data = str(object1.highAlpha) + '\r\n'
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()
from NeuroPy import NeuroPy
object1=NeuroPy("/dev/rfcomm0") #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
def blink_callback(blink_value):
"this function will be called everytime NeuroPy has a new value for blink"
print ("Value of blinks is",blink_value)
#do other stuff (fire a rocket), based on the obtained value of attention_value
#do some more stuff
return None
#set call back:
object1.setCallBack("attention",attention_callback)
object1.setCallBack("blink", blink_callback)
#set call back:
object1.setCallBack("meditation",attention_callback)
#call start method
object1.start()
while True:
if(object1.meditation>70): #another way of accessing data provided by headset (1st being call backs)
object1.stop() #if meditation level reaches above 70, stop fetching data from the headset
'''
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)
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))
idx=np.argmax(np.abs(np.array(eegcoll))**2)
freq=freqs[idx]
freqhz=abs(freq*freqeeg)
if freqhz>40 and freqhz<freqeeg:
__dir__ = os.path.dirname(os.path.realpath(__file__))
devices = {
'OS X': '/dev/cu.MindWaveMobile-DevA'
}
headset = NeuroPy('/dev/cu.MindWaveMobile-DevA')
def cb(name):
def a_cb(value):
print(name, value)
return a_cb
#call start method
headset.start()
#set call back:
for attr in ('attention', 'delta', 'highAlpha', 'highBeta', 'lowAlpha', 'lowBeta', 'lowGamma', 'meditation', 'midGamma', 'theta'):
headset.setCallBack(attr, cb(attr))
mp3 = mp3play.load('../6.mp3')
mp3.play()
# while True:
# sleep(5)
# print('Instant meditation:', headset.meditation)
# if headset.meditation > 90:
# headset.stop()
class BrainWindow(QWidget):
def __init__(self,
parent=None,
sensorNUmber=0
): #sensorNUmber - rfcomm port number - 0 for rfcomm0 etc
super(BrainWindow, self).__init__(parent)
self.sensorNUmber = sensorNUmber
self.setWindowTitle(u"Mindwave " + str(self.sensorNUmber + 1))
layout = QGridLayout()
layout.addWidget(QLabel("Value"), 0, 1)
layout.addWidget(QLabel("Min"), 0, 2)
layout.addWidget(QLabel("Max"), 0, 3)
layout.addWidget(QLabel("Relative"), 0, 4)
layout.addWidget(QLabel("Attention:"), 1, 0)
layout.addWidget(QLabel("Poor signal:"), 1, 2)
layout.addWidget(QLabel("Low beta"), 2, 0)
layout.addWidget(QLabel("High beta"), 3, 0)
layout.addWidget(QLabel("Low gamma"), 4, 0)
layout.addWidget(QLabel("Mid gamma"), 5, 0)
layout.addWidget(QLabel("Raw data:"), 6, 0)
self.attentionLabel = QLabel()
layout.addWidget(self.attentionLabel, 1, 1)
self.poorSignalLabel = QLabel()
layout.addWidget(self.poorSignalLabel, 1, 3)
self.lBetaLabel = QLabel()
self.lBetaMinLabel = QLabel()
self.lBetaMaxLabel = QLabel()
self.lBetaRelLabel = QLabel()
layout.addWidget(self.lBetaLabel, 2, 1)
layout.addWidget(self.lBetaMinLabel, 2, 2)
layout.addWidget(self.lBetaMaxLabel, 2, 3)
layout.addWidget(self.lBetaRelLabel, 2, 4)
self.hBetaLabel = QLabel()
self.hBetaMinLabel = QLabel()
self.hBetaMaxLabel = QLabel()
self.hBetaRelLabel = QLabel()
layout.addWidget(self.hBetaLabel, 3, 1)
layout.addWidget(self.hBetaMinLabel, 3, 2)
layout.addWidget(self.hBetaMaxLabel, 3, 3)
layout.addWidget(self.hBetaRelLabel, 3, 4)
self.lGammaLabel = QLabel()
self.lGammaMinLabel = QLabel()
self.lGammaMaxLabel = QLabel()
self.lGammaRelLabel = QLabel()
layout.addWidget(self.lGammaLabel, 4, 1)
layout.addWidget(self.lGammaMinLabel, 4, 2)
layout.addWidget(self.lGammaMaxLabel, 4, 3)
layout.addWidget(self.lGammaRelLabel, 4, 4)
self.mGammaLabel = QLabel()
self.mGammaMinLabel = QLabel()
self.mGammaMaxLabel = QLabel()
self.mGammaRelLabel = QLabel()
layout.addWidget(self.mGammaLabel, 5, 1)
layout.addWidget(self.mGammaMinLabel, 5, 2)
layout.addWidget(self.mGammaMaxLabel, 5, 3)
layout.addWidget(self.mGammaRelLabel, 5, 4)
#stop
stopButton = QPushButton("Stop")
stopButton.clicked.connect(self.stop)
layout.addWidget(stopButton, 7, 0)
self.setLayout(layout)
self.headSet = NeuroPy("/dev/rfcomm" + str(sensorNUmber), 57600)
self.headSet.setCallBack("attention", self.attention_callback)
self.headSet.setCallBack("lowBeta", self.lowBeta_callback)
self.headSet.setCallBack("highBeta", self.highBeta_callback)
self.headSet.setCallBack("lowGamma", self.lowGamma_callback)
self.headSet.setCallBack("midGamma", self.midGamma_callback)
self.headSet.setCallBack("rawValue", self.rawValue_callback)
self.headSet.setCallBack("poorSignal", self.poorSignal_callback)
self.headSet.start()
self.highLimit = 100000 # ignore occasional higher values from EEG data
self.lowLimit = 100
self.lBetamin = 10000
self.lBetamax = 0.1
self.lBetarelative = 0
self.hBetamin = 10000
self.hBetamax = 0.1
self.hBetarelative = 0
self.lGammamin = 10000
self.lGammamax = 0.1
self.lGammarelative = 0
self.mGammamin = 10000
self.mGammamax = 0.1
self.mGammarelative = 0
def __del__(self):
self.stop()
def stop(self):
self.headSet.stop()
#self.perf.Stop()
#self.perf.Join()
#self.cs.Stop()
#TEMPORARY -delete later
def lowBeta_callback(self, value):
#print "Low beta: ", value
if (value > self.highLimit or
value < self.lowLimit): # don't handle occasional high values
return
self.lBetaLabel.setText(str(value))
if (value < self.lBetamin and value != 0):
self.lBetamin = value
self.lBetaMinLabel.setText(str(value))
if (value > self.lBetamax):
self.lBetamax = value
self.lBetaMaxLabel.setText(str(value))
self.lBetarelative = float(value - self.lBetamin) / (self.lBetamax -
self.lBetamin + 1)
self.lBetaRelLabel.setText(str(self.lBetarelative))
sendUdpMessage("sensor,lb" + str(self.sensorNUmber + 1) + "," +
str(self.lBetarelative))
#self.cs.SetChannel("lowBetaRelative",self.lBetarelative)
return None
def highBeta_callback(self, value):
#print "high beta: ", value
if (value > self.highLimit or
value < self.lowLimit): # don't handle occasional high values
return
self.hBetaLabel.setText(str(value))
if (value < self.hBetamin and value != 0):
self.hBetamin = value
self.hBetaMinLabel.setText(str(value))
if (value > self.hBetamax):
self.hBetamax = value
self.hBetaMaxLabel.setText(str(value))
self.hBetarelative = float(value - self.hBetamin) / (self.hBetamax -
self.hBetamin + 1)
self.hBetaRelLabel.setText(str(self.hBetarelative))
sendUdpMessage("sensor,hb" + str(self.sensorNUmber + 1) + "," +
str(self.hBetarelative))
#self.cs.SetChannel("highBetaRelative",self.hBetarelative)
return None
def lowGamma_callback(self, value):
#print "Low gamma: ", value
if (value > self.highLimit or
value < self.lowLimit): # don't handle occasional high values
return
self.lGammaLabel.setText(str(value))
if (value < self.lGammamin and value != 0):
self.lGammamin = value
self.lGammaMinLabel.setText(str(value))
if (value > self.lGammamax):
self.lGammamax = value
self.lGammaMaxLabel.setText(str(value))
self.lGammarelative = float(value - self.lGammamin) / (
self.lGammamax - self.lGammamin + 1)
self.lGammaRelLabel.setText(str(self.lGammarelative))
#self.cs.SetChannel("lowBetaRelative",self.lGammarelative)
return None
def midGamma_callback(self, value):
#print "mid gamma: ", value
if (value > self.highLimit or
value < self.lowLimit): # don't handle occasional high values
return
self.mGammaLabel.setText(str(value))
if (value < self.mGammamin and value != 0):
self.mGammamin = value
self.mGammaMinLabel.setText(str(value))
if (value > self.mGammamax):
self.mGammamax = value
self.mGammaMaxLabel.setText(str(value))
self.mGammarelative = float(value - self.mGammamin) / (
self.mGammamax - self.mGammamin + 1)
self.mGammaRelLabel.setText(str(self.mGammarelative))
#self.cs.SetChannel("midmGammaRelative",self.mGammarelative)
return None
def attention_callback(self, value):
#print "Attention: ",value
self.attentionLabel.setText(str(value))
sendUdpMessage("sensor,attention" + str(self.sensorNUmber + 1) + "," +
str(float(value) / 100))
#self.cs.SetChannel("attention",value)
return None
def rawValue_callback(self, value):
#this is very fast don't print this
#print "rawValue: ", value
#self.cs.SetChannel("rawValue",value)
if (abs(value) < 1000):
sendUdpMessage("sensor,raw" + str(self.sensorNUmber + 1) + "," +
str(value))
return None
def poorSignal_callback(self, value):
print "headset: ", self.sensorNUmber, "poor signal: ", value
self.poorSignalLabel.setText(str(value))
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
high_alpha = mindwave.high_alpha
low_beta = mindwave.low_beta
high_beta = mindwave.high_beta
meditation = mindwave.meditation
if response:
jsonlist.append(response)
if len(jsonlist) == 2:
z = {jsonlist[0]: jsonlist[1]}
jsonlist1.append(z)
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 BrainWindow(QWidget):
def __init__(self, parent=None, sensorNUmber=0): #sensorNUmber - rfcomm port number - 0 for rfcomm0 etc
super(BrainWindow, self).__init__(parent)
self.sensorNUmber = sensorNUmber
self.setWindowTitle(u"Mindwave"+str(self.sensorNUmber))
layout = QGridLayout()
layout.addWidget(QLabel("Value"),0,1)
layout.addWidget(QLabel("Min"),0,2)
layout.addWidget(QLabel("Max"),0,3)
layout.addWidget(QLabel("Relative"),0,4)
layout.addWidget(QLabel("Attention:"),1,0)
layout.addWidget(QLabel("Poor signal:"),1,2)
layout.addWidget(QLabel("Low beta"),2,0)
layout.addWidget(QLabel("High beta"),3,0)
layout.addWidget(QLabel("Low gamma"),4,0)
layout.addWidget(QLabel("Mid gamma"),5,0)
layout.addWidget(QLabel("Raw data:"),6,0)
self.attentionLabel = QLabel()
layout.addWidget(self.attentionLabel,1,1)
self.poorSignalLabel = QLabel()
layout.addWidget(self.poorSignalLabel,1,3)
self.lBetaLabel = QLabel()
self.lBetaMinLabel = QLabel()
self.lBetaMaxLabel = QLabel()
self.lBetaRelLabel = QLabel()
layout.addWidget(self.lBetaLabel,2,1)
layout.addWidget(self.lBetaMinLabel,2,2)
layout.addWidget(self.lBetaMaxLabel,2,3)
layout.addWidget(self.lBetaRelLabel,2,4)
self.hBetaLabel = QLabel()
self.hBetaMinLabel = QLabel()
self.hBetaMaxLabel = QLabel()
self.hBetaRelLabel = QLabel()
layout.addWidget(self.hBetaLabel,3,1)
layout.addWidget(self.hBetaMinLabel,3,2)
layout.addWidget(self.hBetaMaxLabel,3,3)
layout.addWidget(self.hBetaRelLabel,3,4)
self.lGammaLabel = QLabel()
self.lGammaMinLabel = QLabel()
self.lGammaMaxLabel = QLabel()
self.lGammaRelLabel = QLabel()
layout.addWidget(self.lGammaLabel,4,1)
layout.addWidget(self.lGammaMinLabel,4,2)
layout.addWidget(self.lGammaMaxLabel,4,3)
layout.addWidget(self.lGammaRelLabel,4,4)
self.mGammaLabel = QLabel()
self.mGammaMinLabel = QLabel()
self.mGammaMaxLabel = QLabel()
self.mGammaRelLabel = QLabel()
layout.addWidget(self.mGammaLabel,5,1)
layout.addWidget(self.mGammaMinLabel,5,2)
layout.addWidget(self.mGammaMaxLabel,5,3)
layout.addWidget(self.mGammaRelLabel,5,4)
#stop
stopButton = QPushButton("Stop")
stopButton.clicked.connect(self.stop)
layout.addWidget(stopButton,7,0)
self.setLayout(layout)
self.headSet = NeuroPy("/dev/rfcomm"+str(sensorNUmber),57600)
self.headSet.setCallBack("attention",self.attention_callback)
self.headSet.setCallBack("lowBeta",self.lowBeta_callback)
self.headSet.setCallBack("highBeta",self.highBeta_callback)
self.headSet.setCallBack("lowGamma",self.lowGamma_callback)
self.headSet.setCallBack("midGamma",self.midGamma_callback)
self.headSet.setCallBack("rawValue",self.rawValue_callback)
self.headSet.setCallBack("poorSignal",self.poorSignal_callback)
self.headSet.start()
self.highLimit = 100000 # ignore occasional higher values from EEG data
self.lowLimit = 100
self.lBetamin = 10000
self.lBetamax = 0.1
self.lBetarelative = 0
self.hBetamin = 10000
self.hBetamax = 0.1
self.hBetarelative = 0
self.lGammamin = 10000
self.lGammamax = 0.1
self.lGammarelative = 0
self.mGammamin = 10000
self.mGammamax = 0.1
self.mGammarelative = 0
def __del__(self):
self.stop()
def stop(self):
self.headSet.stop()
#self.perf.Stop()
#self.perf.Join()
#self.cs.Stop()
#TEMPORARY -delete later
def lowBeta_callback(self, value):
#print "Low beta: ", value
if (value>self.highLimit or value<self.lowLimit): # don't handle occasional high values
return
self.lBetaLabel.setText(str(value))
if (value<self.lBetamin and value!=0):
self.lBetamin = value
self.lBetaMinLabel.setText(str(value))
if (value>self.lBetamax):
self.lBetamax = value
self.lBetaMaxLabel.setText(str(value))
self.lBetarelative = float(value-self.lBetamin)/(self.lBetamax-self.lBetamin+1)
self.lBetaRelLabel.setText(str(self.lBetarelative))
sendUdpMessage("sensor,lb"+str(self.sensorNUmber+1)+","+str(self.lBetarelative))
#self.cs.SetChannel("lowBetaRelative",self.lBetarelative)
return None
def highBeta_callback(self, value):
#print "high beta: ", value
if (value>self.highLimit or value<self.lowLimit): # don't handle occasional high values
return
self.hBetaLabel.setText(str(value))
if (value<self.hBetamin and value!=0):
self.hBetamin = value
self.hBetaMinLabel.setText(str(value))
if (value>self.hBetamax):
self.hBetamax = value
self.hBetaMaxLabel.setText(str(value))
self.hBetarelative = float(value-self.hBetamin)/(self.hBetamax-self.hBetamin+1)
self.hBetaRelLabel.setText(str(self.hBetarelative))
sendUdpMessage("sensor,hb"+str(self.sensorNUmber+1)+","+str(self.hBetarelative))
#self.cs.SetChannel("highBetaRelative",self.hBetarelative)
return None
def lowGamma_callback(self, value):
#print "Low gamma: ", value
if (value>self.highLimit or value<self.lowLimit): # don't handle occasional high values
return
self.lGammaLabel.setText(str(value))
if (value<self.lGammamin and value!=0):
self.lGammamin = value
self.lGammaMinLabel.setText(str(value))
if (value>self.lGammamax):
self.lGammamax = value
self.lGammaMaxLabel.setText(str(value))
self.lGammarelative = float(value-self.lGammamin)/(self.lGammamax-self.lGammamin+1)
self.lGammaRelLabel.setText(str(self.lGammarelative))
#self.cs.SetChannel("lowBetaRelative",self.lGammarelative)
return None
def midGamma_callback(self, value):
#print "mid gamma: ", value
if (value>self.highLimit or value<self.lowLimit): # don't handle occasional high values
return
self.mGammaLabel.setText(str(value))
if (value<self.mGammamin and value!=0):
self.mGammamin = value
self.mGammaMinLabel.setText(str(value))
if (value>self.mGammamax):
self.mGammamax = value
self.mGammaMaxLabel.setText(str(value))
self.mGammarelative = float(value-self.mGammamin)/(self.mGammamax-self.mGammamin+1)
self.mGammaRelLabel.setText(str(self.mGammarelative))
#self.cs.SetChannel("midmGammaRelative",self.mGammarelative)
return None
def attention_callback(self, value):
#print "Attention: ",value
self.attentionLabel.setText(str(value))
sendUdpMessage("sensor,attention"+str(self.sensorNUmber+1)+","+str(float(value)/100))
#self.cs.SetChannel("attention",value)
return None
def rawValue_callback(self, value):
#this is very fast don't print this
#print "rawValue: ", value
#self.cs.SetChannel("rawValue",value)
if (abs(value)<1000):
sendUdpMessage("sensor,raw"+str(self.sensorNUmber+1)+","+str(value))
return None
def poorSignal_callback(self,value):
print "headset: ",self.sensorNUmber,"poor signal: ",value
self.poorSignalLabel.setText(str(value))
#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 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()
class MindwaveTracker:
com = "COM16"
time_last_notified = time.clock()
MAX_ZERO_VALUES_BEFORE_WARNING = 10
attention_value = 0
meditation_value = 0
poorSignal = 0
blinkStrength = 0
index = 0
aantal_avg = 0
interval = 0
teller_duration_iteration_sec = 0.0
datetime_from = datetime.datetime.today()
teller_zero_values = 0
mindwave_instance = None
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()
def notify(self):
time_now = time.clock()
duration_iteration_sec = time_now - self.time_last_notified
self.time_last_notified = time.clock()
self.teller_duration_iteration_sec += duration_iteration_sec
if self.teller_duration_iteration_sec >= self.interval:
self.teller_duration_iteration_sec = 0.0
self.record_measurement()
def record_measurement(self):
print str(
str('attention: ' + str(self.mindwave_instance.attention)) + '\t' +
str('meditation: ' + str(self.mindwave_instance.meditation)))
if (self.index == self.aantal_avg):
print str('avg attention: ' +
str(float(self.attention_value / self.aantal_avg)))
average_attention = float(
self.attention_value / self.aantal_avg) / 100
average_meditation = float(
self.meditation_value / self.aantal_avg) / 100
average_poorSignal = float(self.poorSignal / self.aantal_avg)
average_blinkStrength = float(self.blinkStrength / self.aantal_avg)
datetime_to = datetime.datetime.today()
DAMindwave_SQLite.insert_row_mindwave(
self.datetime_from, datetime_to, average_attention,
average_meditation, average_poorSignal, average_blinkStrength)
self.attention_value = self.mindwave_instance.attention
self.meditation_value = self.mindwave_instance.meditation
self.poorSignal = self.mindwave_instance.poorSignal
self.blinkStrength = self.mindwave_instance.blinkStrength
self.index = 1
self.datetime_from = datetime.datetime.today()
else:
if self.mindwave_instance.attention != 0 and self.mindwave_instance.meditation != 0:
self.attention_value += self.mindwave_instance.attention
self.meditation_value += self.mindwave_instance.meditation
self.poorSignal += self.mindwave_instance.poorSignal
self.blinkStrength += self.mindwave_instance.blinkStrength
self.index += 1
else:
self.teller_zero_values += 1
if self.teller_zero_values == self.MAX_ZERO_VALUES_BEFORE_WARNING:
tkMessageBox.showinfo(
title="Warning",
message=
"The attention and meditation values are 0 for a long time. Possible problem with the device"
)
self.teller_zero_values = 0
def stop_device(self):
try:
self.mindwave_instance.stop()
except Exception, e:
raise Exception(e)
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)
break
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
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):
print(ob.attention)
class SpaceInvaders(object):
def __init__(self):
# It seems, in Linux buffersize=512 is not enough, use 4096 to prevent:
# ALSA lib pcm.c:7963:(snd_pcm_recover) underrun occurred
mixer.pre_init(44100, -16, 1, 4096)
init()
self.clock = time.Clock()
self.caption = display.set_caption('Space Invaders')
self.screen = SCREEN
self.background = image.load(IMAGE_PATH + 'background.jpg').convert()
self.mainScreen = True
self.mathScreen = False
self.levelScreen = False
self.startGame = False
self.gameOver = False
# Initial values for attention and meditation thresholds
self.attPractice = list()
self.medPractice = list()
self.attThreshold = 0
self.medThreshold = 0
self.attHigh = True
self.medHigh = True
# Counter for enemy starting position (increased each new round)
self.enemyPosition = ENEMY_DEFAULT_POSITION
self.titleText = Text(FONT, 50, 'Space Invaders', WHITE, 164, 155)
self.titleText2 = Text(FONT, 25, 'Press any key to continue', WHITE,
201, 225)
self.gameOverText = Text(FONT, 50, 'Game Over', WHITE, 250, 270)
self.nextRoundText = Text(FONT, 50, 'Next Round', WHITE, 240, 270)
self.enemy1Text = Text(FONT, 25, ' = 10 pts', GREEN, 368, 270)
self.enemy2Text = Text(FONT, 25, ' = 20 pts', BLUE, 368, 320)
self.enemy3Text = Text(FONT, 25, ' = 30 pts', PURPLE, 368, 370)
self.enemy4Text = Text(FONT, 25, ' = ?????', RED, 368, 420)
self.scoreText = Text(FONT, 20, 'Score', WHITE, 5, 5)
self.livesText = Text(FONT, 20, 'Lives ', WHITE, 640, 5)
# For math practice use
self.titleMath = Text(FONT, 40, 'practice before game!', WHITE, 130,
70)
self.titleMath2 = Text(FONT, 25, 'press any key to next question',
WHITE, 160, 120)
self.attMath = Text(FONT, 25, 'Attention :', GREEN, 280, 450)
self.medMath = Text(FONT, 25, 'Meditation:', GREEN, 280, 500)
# For level screen use
self.titleLevel = Text(FONT, 40, 'select game level', WHITE, 170, 70)
self.titleLevel2 = Text(FONT, 20,
'enter number between 1 and 6 and return',
WHITE, 150, 120)
self.attThText = Text(FONT, 25, 'Attention Threshold :', RED, 200, 450)
self.medThText = Text(FONT, 25, 'Meditation Threshold :', RED, 200,
500)
self.intList = [K_1, K_2, K_3, K_4, K_5, K_6]
self.level = 0
self.levelSet = False
# Display attention value on screen
self.attentionText = Text(FONT, 20, 'Attention', WHITE, 180, 5)
self.meditationText = Text(FONT, 20, 'Meditation', WHITE, 395, 5)
# Life symbols
self.life1 = Life(715, 3)
self.life2 = Life(742, 3)
self.life3 = Life(769, 3)
self.livesGroup = sprite.Group(self.life1, self.life2, self.life3)
# Neuropy object to extract brainwave value
self.neuropy = NeuroPy(PORT1, PORT2)
self.neuropy.start()
def main(self):
while True:
# Main title screen
if self.mainScreen:
self.screen.blit(self.background, (0, 0))
self.titleText.draw(self.screen)
self.titleText2.draw(self.screen)
self.enemy1Text.draw(self.screen)
self.enemy2Text.draw(self.screen)
self.enemy3Text.draw(self.screen)
self.enemy4Text.draw(self.screen)
self.create_main_menu()
# Keyboard input handling
for e in event.get():
if self.should_exit(e): #QUIT or escape key to quit
sys.exit()
if e.type == KEYUP:
self.numQuestions = 5
self.make_math_problem()
self.numQuestions -= 1
self.numQueStr = str(
self.numQuestions) + " more question"
self.mathScreen = True
self.mainScreen = False
# Practice Math Screen
elif self.mathScreen:
self.screen.blit(self.background, (0, 0))
self.titleMath.draw(self.screen)
self.titleMath2.draw(self.screen)
self.attMath.draw(self.screen)
self.medMath.draw(self.screen)
self.problemText = Text(FONT, 50, self.problem, WHITE, 230,
280)
self.problemText.draw(self.screen)
self.numQuestionText = Text(FONT, 25, self.numQueStr, RED, 270,
150)
self.numQuestionText.draw(self.screen)
# Neuropy values
self.attMathValue = Text(FONT, 25, str(self.neuropy.attention),
GREEN, 480, 450)
self.medMathValue = Text(FONT, 25,
str(self.neuropy.meditation), GREEN,
480, 500)
self.attMathValue.draw(self.screen)
self.medMathValue.draw(self.screen)
# add non-zero value of attention and meditation
if self.neuropy.attention > 0:
self.attPractice.append(self.neuropy.attention)
if self.neuropy.meditation > 0:
self.medPractice.append(self.neuropy.meditation)
# Keyboard input handling
for e in event.get():
if self.should_exit(e):
sys.exit()
if e.type == KEYUP:
if self.numQuestions > 0:
self.make_math_problem()
self.numQuestions -= 1
if self.numQuestions == 0:
self.numQueStr = "last question"
else:
self.numQueStr = str(
self.numQuestions) + " more question"
else:
self.attThreshold = int(
sum(self.attPractice) / len(self.attPractice))
self.medThreshold = int(
sum(self.medPractice) / len(self.medPractice))
self.attPractice = list()
self.medPractice = list()
self.attThVal = Text(FONT, 25,
str(self.attThreshold), WHITE,
580, 450)
self.medThVal = Text(FONT, 25,
str(self.medThreshold), WHITE,
580, 500)
self.levelScreen = True
self.mathScreen = False
elif self.levelScreen:
self.screen.blit(self.background, (0, 0))
self.titleLevel.draw(self.screen)
self.titleLevel2.draw(self.screen)
self.attThText.draw(self.screen)
self.medThText.draw(self.screen)
self.attThVal.draw(self.screen)
self.medThVal.draw(self.screen)
if self.levelSet:
self.levelText.draw(self.screen)
for e in event.get():
if self.should_exit(e):
sys.exit()
if e.type == KEYUP:
if self.levelSet and e.key == K_RETURN: # Start Game
self.allBlockers = sprite.Group(
self.make_blockers(0), self.make_blockers(1),
self.make_blockers(2), self.make_blockers(3))
self.livesGroup.add(self.life1, self.life2,
self.life3)
self.reset(0)
self.startGame = True
self.levelScreen = False
elif not self.levelSet and e.key in self.intList:
# input number = number of enermy bullets
self.level = e.key - 48 # extract the key number
levelStr = "level " + str(self.level)
self.levelText = Text(FONT, 70, levelStr, GREEN,
240, 250)
self.levelSet = True
elif self.startGame: # Game Plaing screen
# When winning game and going to next round
if not self.enemies and not self.explosionsGroup:
currentTime = time.get_ticks()
if currentTime - self.gameTimer < 3000:
self.screen.blit(self.background, (0, 0))
self.scoreText2 = Text(FONT, 20, str(self.score),
GREEN, 85, 5)
self.scoreText.draw(self.screen)
self.scoreText2.draw(self.screen)
self.nextRoundText.draw(self.screen)
self.livesText.draw(self.screen)
self.livesGroup.update()
self.check_input()
if currentTime - self.gameTimer > 3000:
self.enemyPosition += ENEMY_MOVE_DOWN
self.reset(self.score)
self.gameTimer += 3000
# While playing actual game
else:
currentTime = time.get_ticks()
self.play_main_music(currentTime)
self.screen.blit(self.background, (0, 0))
self.allBlockers.update(self.screen)
self.scoreText2 = Text(FONT, 20, str(self.score), GREEN,
85, 5)
self.scoreText.draw(self.screen)
self.scoreText2.draw(self.screen)
# Check if att and med are above threshold value
self.attHigh = True if self.neuropy.attention >= self.attThreshold else False
self.medHigh = True if self.neuropy.meditation <= self.medThreshold else False
# Draw neuropy text and value
attColor = GREEN
medColor = GREEN
if self.attHigh:
attColor = RED
if self.medHigh:
medColor = RED
self.attentionText2 = Text(FONT, 20,
str(self.neuropy.attention),
attColor, 320, 5)
self.meditationText2 = Text(FONT, 20,
str(self.neuropy.meditation),
medColor, 545, 5)
self.attentionText2.draw(self.screen)
self.meditationText2.draw(self.screen)
self.attentionText.draw(self.screen)
self.meditationText.draw(self.screen)
# Check some conditions
self.livesText.draw(self.screen)
self.check_input()
self.enemies.update(currentTime)
self.allSprites.update(self.keys, currentTime)
self.explosionsGroup.update(currentTime)
self.check_collisions()
self.create_new_ship(self.makeNewShip, currentTime)
self.make_enemies_shoot()
# When losing game
elif self.gameOver:
currentTime = time.get_ticks()
# Reset enemy starting position
self.enemyPosition = ENEMY_DEFAULT_POSITION
self.create_game_over(currentTime)
display.update()
self.clock.tick(60)
def make_math_problem(self):
num1 = str(random.randint(1, 99))
num2 = str(random.randint(1, 99))
symbol = ' + ' if random.randint(0, 1) == 0 else ' - '
self.problem = num1 + symbol + num2 + ' = ???'
def make_enemies_shoot(self):
if (time.get_ticks() - self.timer) > 700 and self.enemies:
if self.medHigh:
for i in range(self.level):
enemy = self.enemies.random_bottom()
self.enemyBullets.add(
Bullet(enemy.rect.x + 14, enemy.rect.y + 20, 1, 5,
'enemylaser', 'center'))
self.allSprites.add(self.enemyBullets)
else:
enemy = self.enemies.random_bottom()
self.enemyBullets.add(
Bullet(enemy.rect.x + 14, enemy.rect.y + 20, 1, 5,
'enemylaser', 'center'))
self.allSprites.add(self.enemyBullets)
self.timer = time.get_ticks()
def check_input(self):
self.keys = key.get_pressed()
for e in event.get():
if self.should_exit(e):
sys.exit()
if e.type == KEYDOWN:
if e.key == K_SPACE:
if len(self.bullets) == 0 and self.shipAlive:
# Special shoot when attention is high
if self.attHigh:
for i in range(5):
speed = 15 - i
bullet = Bullet(self.player.rect.x + 23,
self.player.rect.y + 5, -1,
speed, 'laser', 'center')
self.bullets.add(bullet)
self.allSprites.add(self.bullets)
self.sounds['shoot2'].play()
# Normal shoot
else:
bullet = Bullet(self.player.rect.x + 23,
self.player.rect.y + 5, -1, 15,
'laser', 'center')
self.bullets.add(bullet)
self.allSprites.add(self.bullets)
self.sounds['shoot'].play()
def reset(self, score):
self.player = Ship()
self.playerGroup = sprite.Group(self.player)
self.explosionsGroup = sprite.Group()
self.bullets = sprite.Group()
self.mysteryShip = Mystery()
self.mysteryGroup = sprite.Group(self.mysteryShip)
self.enemyBullets = sprite.Group()
self.make_enemies()
self.allSprites = sprite.Group(self.player, self.enemies,
self.livesGroup, self.mysteryShip)
self.keys = key.get_pressed()
self.timer = time.get_ticks()
self.noteTimer = time.get_ticks()
self.shipTimer = time.get_ticks()
self.score = score
self.create_audio()
self.makeNewShip = False
self.shipAlive = True
def make_blockers(self, number):
blockerGroup = sprite.Group()
for row in range(4):
for column in range(9):
blocker = Blocker(10, GREEN, row, column)
blocker.rect.x = 50 + (200 * number) + (column * blocker.width)
blocker.rect.y = BLOCKERS_POSITION + (row * blocker.height)
blockerGroup.add(blocker)
return blockerGroup
def create_audio(self):
self.sounds = {}
for sound_name in [
'shoot', 'shoot2', 'invaderkilled', 'mysterykilled',
'shipexplosion'
]:
self.sounds[sound_name] = mixer.Sound(SOUND_PATH +
'{}.wav'.format(sound_name))
self.sounds[sound_name].set_volume(0.2)
self.musicNotes = [
mixer.Sound(SOUND_PATH + '{}.wav'.format(i)) for i in range(4)
]
for sound in self.musicNotes:
sound.set_volume(0.5)
self.noteIndex = 0
def play_main_music(self, currentTime):
if currentTime - self.noteTimer > self.enemies.moveTime:
self.note = self.musicNotes[self.noteIndex]
if self.noteIndex < 3:
self.noteIndex += 1
else:
self.noteIndex = 0
self.note.play()
self.noteTimer += self.enemies.moveTime
@staticmethod
def should_exit(evt):
# type: (pygame.event.EventType) -> bool
return evt.type == QUIT or (evt.type == KEYUP and evt.key == K_ESCAPE)
def make_enemies(self):
enemies = EnemiesGroup(10, 5)
for row in range(5):
for column in range(10):
enemy = Enemy(row, column)
enemy.rect.x = 157 + (column * 50)
enemy.rect.y = self.enemyPosition + (row * 45)
enemies.add(enemy)
self.enemies = enemies
def calculate_score(self, row):
scores = {
0: 30,
1: 20,
2: 20,
3: 10,
4: 10,
5: choice([50, 100, 150, 300])
}
score = scores[row]
self.score += score
return score
def create_main_menu(self):
self.enemy1 = IMAGES['enemy3_1']
self.enemy1 = transform.scale(self.enemy1, (40, 40))
self.enemy2 = IMAGES['enemy2_2']
self.enemy2 = transform.scale(self.enemy2, (40, 40))
self.enemy3 = IMAGES['enemy1_2']
self.enemy3 = transform.scale(self.enemy3, (40, 40))
self.enemy4 = IMAGES['mystery']
self.enemy4 = transform.scale(self.enemy4, (80, 40))
self.screen.blit(self.enemy1, (318, 270))
self.screen.blit(self.enemy2, (318, 320))
self.screen.blit(self.enemy3, (318, 370))
self.screen.blit(self.enemy4, (299, 420))
def check_collisions(self):
sprite.groupcollide(self.bullets, self.enemyBullets, True, True)
for enemy in sprite.groupcollide(self.enemies, self.bullets, True,
True).keys():
self.sounds['invaderkilled'].play()
self.calculate_score(enemy.row)
EnemyExplosion(enemy, self.explosionsGroup)
self.gameTimer = time.get_ticks()
for mystery in sprite.groupcollide(self.mysteryGroup, self.bullets,
True, True).keys():
mystery.mysteryEntered.stop()
self.sounds['mysterykilled'].play()
score = self.calculate_score(mystery.row)
MysteryExplosion(mystery, score, self.explosionsGroup)
newShip = Mystery()
self.allSprites.add(newShip)
self.mysteryGroup.add(newShip)
for player in sprite.groupcollide(self.playerGroup, self.enemyBullets,
True, True).keys():
if self.life3.alive():
self.life3.kill()
elif self.life2.alive():
self.life2.kill()
elif self.life1.alive():
self.life1.kill()
else:
self.gameOver = True
self.startGame = False
self.sounds['shipexplosion'].play()
ShipExplosion(player, self.explosionsGroup)
self.makeNewShip = True
self.shipTimer = time.get_ticks()
self.shipAlive = False
if self.enemies.bottom >= 540:
sprite.groupcollide(self.enemies, self.playerGroup, True, True)
if not self.player.alive() or self.enemies.bottom >= 600:
self.gameOver = True
self.startGame = False
sprite.groupcollide(self.bullets, self.allBlockers, True, True)
sprite.groupcollide(self.enemyBullets, self.allBlockers, True, True)
if self.enemies.bottom >= BLOCKERS_POSITION:
sprite.groupcollide(self.enemies, self.allBlockers, False, True)
def create_new_ship(self, createShip, currentTime):
if createShip and (currentTime - self.shipTimer > 900):
self.player = Ship()
self.allSprites.add(self.player)
self.playerGroup.add(self.player)
self.makeNewShip = False
self.shipAlive = True
def create_game_over(self, currentTime):
self.screen.blit(self.background, (0, 0))
passed = currentTime - self.timer
if passed < 750:
self.gameOverText.draw(self.screen)
elif 750 < passed < 1500:
self.screen.blit(self.background, (0, 0))
elif 1500 < passed < 2250:
self.gameOverText.draw(self.screen)
elif 2250 < passed < 2750:
self.screen.blit(self.background, (0, 0))
elif passed > 3000:
self.mainScreen = True
for e in event.get():
if self.should_exit(e):
sys.exit()
