def run(self): global player global running global laser_list global green pfio.init() tick = 0 while running: try: x = pfio.read_input() if x >= 8 : x=0 if tick + 0.8 < time.time(): #FIRE!!!!!! if x - 4 >= 0: x = x-4 newlaser = laser_sprite(4,10,1, green) newlaser.rect.x = 28 + player.rect.x # laser is 4 wide player is 60; 60 /2 + 4 /2 = 28 newlaser.rect.y = player.rect.y laser_list.add(newlaser) tick = time.time() # go right if x - 2 >= 0: x = x-2 player.rect.x += 2 #go left if x - 1 >= 0: player.rect.x -= 2 except: pass pfio.deinit()
def run(self):
while self.mos.loop(0) == 0:
inputpins = pfio.read_input() # get input pin state
if self.inputpins != inputpins: # check to see if they are different
change = self.inputpins ^ inputpins #get the differences
for i in range(8):
pinid = 1<<i
if change & pinid == pinid:
self.mos.publish( self.topicheader + '/input/pin' + str(i), str((inputpins&pinid)>>i), 0 )
self.inputpins = inputpins
def ajax(request):
data = request.GET.dict()
return_values = dict()
if 'init' in data:
try:
pfio.init()
except pfio.InitError as error:
return_values.update({'status': 'init failed'})
return_values.update({'error': str(error)})
return HttpResponseBadRequest(simplejson.dumps(return_values))
if 'read_input' in data:
try:
input_bitp = pfio.read_input()
except Exception as e:
return_values.update({'status': 'read_input failed'})
return_values.update({'error': str(e)})
return HttpResponseBadRequest(simplejson.dumps(return_values))
else:
return_values.update({'input_bitp': input_bitp})
if 'read_output' in data:
try:
output_bitp = pfio.read_output()
except Exception as e:
return_values.update({'status': 'read_output failed'})
return_values.update({'error': str(e)})
return HttpResponseBadRequest(simplejson.dumps(return_values))
else:
return_values.update({'output_bitp': output_bitp})
if 'write_output' in data:
try:
output_bitp = int(data['write_output'])
except ValueError:
return_values.update({'status': 'write_output failed'})
return_values.update(
{'error': "write_output needs an integer bit pattern."})
return HttpResponseBadRequest(simplejson.dumps(return_values))
try:
pfio.write_output(output_bitp)
except Exception as e:
return_values.update({'status': "write_output failed"})
return_values.update({'error': str(e)})
return HttpResponseBadRequest(simplejson.dumps(return_values))
return_values.update({'status': 'success'})
return HttpResponse(simplejson.dumps(return_values))
def ajax(request):
data = request.GET.dict()
return_values = dict()
if 'init' in data:
try:
pfio.init()
except pfio.InitError as error:
return_values.update({'status' : 'init failed'})
return_values.update({'error' : str(error)})
return HttpResponseBadRequest(simplejson.dumps(return_values))
if 'read_input' in data:
try:
input_bitp = pfio.read_input()
except Exception as e:
return_values.update({'status' : 'read_input failed'})
return_values.update({'error' : str(e)})
return HttpResponseBadRequest(simplejson.dumps(return_values))
else:
return_values.update({'input_bitp' : input_bitp})
if 'read_output' in data:
try:
output_bitp = pfio.read_output()
except Exception as e:
return_values.update({'status' : 'read_output failed'})
return_values.update({'error' : str(e)})
return HttpResponseBadRequest(simplejson.dumps(return_values))
else:
return_values.update({'output_bitp' : output_bitp})
if 'write_output' in data:
try:
output_bitp = int(data['write_output'])
except ValueError:
return_values.update({'status' : 'write_output failed'})
return_values.update({'error' : "write_output needs an integer bit pattern."})
return HttpResponseBadRequest(simplejson.dumps(return_values))
try:
pfio.write_output(output_bitp)
except Exception as e:
return_values.update({'status' : "write_output failed"})
return_values.update({'error' : str(e)})
return HttpResponseBadRequest(simplejson.dumps(return_values))
return_values.update({'status' : 'success'})
return HttpResponse(simplejson.dumps(return_values))
def __init__(self, ident, topicheader, uri = 'localhost', port = 1883):
self.uri = uri
self.port = port
self.ident = ident
self.topicheader = topicheader+ '/' + self.ident
self.outputRegex = re.compile(self.topicheader + "/output/pin/(\d*)", re.IGNORECASE)
self.mos = mosquitto.Mosquitto(self.ident)
self.mos.on_message = self.on_message # register for callback
self.connect()
pfio.init()
self.inputpins = pfio.read_input()
def timeout_loop(self):
# read PiFace input/output state
global last_data
r_input = '{0:08b}'.format(pfio.read_input())
r_output = '{0:08b}'.format(pfio.read_output())
data = {"in": [], "out": []}
for i in range(8):
data['in'].append(r_input[7-i])
data['out'].append(r_output[7-i])
if data != last_data:
self.write_message(json.dumps(data))
last_data = data
# here come the magic part .. loop
if self.connected:
tornado.ioloop.IOLoop.instance().add_timeout(datetime.timedelta(seconds=.5), self.timeout_loop)
sleep(0.5) # wait to keep the colour showing
pfio.digital_write(i + 2, 0) # turn the colour off
sleep(0.2) # small break between colours
sleep(0.4)
pfio.write_output(
0xFF) # signify it is their turn by turning all the LEDs on then off
sleep(0.3)
pfio.write_output(0x0)
if screen_output:
print "\nYour turn!"
for i in array: # for each colour in current sequence (check against inputted sequence)
event = pfio.read_input() # read the button port state
while event != 0: # wait till no buttons pressed
event = pfio.read_input(
) # so a single button press is not read as 2
sleep(0.001) # delay
while event == 0: # wait for any input
event = pfio.read_input()
sleep(0.001) # delay
pin_number = pfio.get_pin_number(event) # calculate the input pin
if screen_output:
print colours[pin_number -
1] # print the colour in sequence to the screen
set_time = 2000 # time allowed to hit each light (starts off large and reduced after each hit) time_left = set_time # countdown timer for hitting the light hit = 0 # the input value score = 0 # keep track of the player's score misses = 0 # keep track of how many the player misses colours = ["Red","Green","Blue","Yellow","White"] # colour list for printing to screen previous_pressed = 255 print "Time left is: %s" %time_left # notify the player how long they have to hit each flash while True: in_bit_pattern = pfio.read_input() # see if any buttons have been hit if in_bit_pattern != previous_pressed: # check this is a new button press previous_pressed = in_bit_pattern # record button press for next time's check if in_bit_pattern > 0: if in_bit_pattern == pfio.get_pin_bit_mask(current): # check that only the correct button was hit pfio.digital_write(current+2, 0) # turn off hit light previous = current current = next_colour() # get next colour while current == previous: # ensure differnt colour each time current = next_colour() # get next colour
def ask_questions(self):
for question in self.questions:
# ask a question
correct_answer_index = int(2 * random.random())
wrong_answer_index = correct_answer_index ^ 1
answers = ["", ""]
answers[correct_answer_index] = question.correct_answer
answers[wrong_answer_index] = question.wrong_answer
values = [question.text]
values.extend(answers)
self.gui.update_question("%s\nA: %s\nB: %s" % tuple(values))
# wait for a button press
pin_bit_pattern = pfio.read_input()
while pin_bit_pattern == 0 and not self.stopped():
pin_bit_pattern = pfio.read_input()
# since we can't have multi-leveled break statements...
if self.stopped():
break
# find out which button was pressed
pin_number = pfio.get_pin_number(pin_bit_pattern)
#print "pin number: %d" % pin_number
#print self.player1.buttons[correct_answer_index].switch.pin_number
if pin_number == self.player1.buttons[correct_answer_index].switch.pin_number:
self.player1.buttons[correct_answer_index].light.turn_on()
print "Player 1 got the correct answer!"
#print "The answer was: {}".format(question.correct_answer)
self.gui.update_question("%s\n\nThe correct answer was: %s\n\nPlayer 1 has 3 seconds to race!" % (question.text, question.correct_answer))
self.player1.car.drive(3)
self.player1.buttons[correct_answer_index].light.turn_off()
elif pin_number == self.player1.buttons[wrong_answer_index].switch.pin_number:
self.player1.buttons[wrong_answer_index].light.turn_on()
print "Player 1 got the WRONG answer!"
#print "The answer was: {}".format(question.correct_answer)
self.gui.update_question("%s\n\nThe correct answer was: %s\n\nPlayer 2 has 3 seconds to race!" % (question.text, question.correct_answer))
self.player2.car.drive(3)
self.player1.buttons[wrong_answer_index].light.turn_off()
elif pin_number == self.player2.buttons[correct_answer_index].switch.pin_number:
self.player2.buttons[correct_answer_index].light.turn_on()
print "Player 2 got the correct answer!"
#print "The answer was: {}".format(question.correct_answer)
self.gui.update_question("%s\n\nThe correct answer was: %s\n\nPlayer 2 has 3 seconds to race!" % (question.text, question.correct_answer))
self.player2.car.drive(3)
self.player2.buttons[correct_answer_index].light.turn_off()
elif pin_number == self.player2.buttons[wrong_answer_index].switch.pin_number:
self.player2.buttons[wrong_answer_index].light.turn_on()
print "Player 2 got the WRONG answer!"
#print "The answer was: {}".format(question.correct_answer)
self.gui.update_question("%s\n\nThe correct answer was: %s\n\nPlayer 1 has 3 seconds to race!" % (question.text, question.correct_answer))
self.player1.car.drive(3)
self.player2.buttons[wrong_answer_index].light.turn_off()
elif pin_number == self.buttons[4].switch.pin_number:
self.buttons[4].light.turn_on()
print "PASS"
#print "The answer was: {}".format(question.correct_answer)
time.sleep(1)
self.buttons[4].light.turn_off()
else:
raise UnknownButtonError("detected change on pin: %d" % pin_number)
# wait until nothing is pressed
pin_bit_pattern = pfio.read_input()
while pin_bit_pattern != 0:
pin_bit_pattern = pfio.read_input()
# should we keep playing?
if self.stopped():
break
def arcade_buttons(): while(True): pfio.write_output(pfio.read_input())
def ask_questions(self):
for question in self.questions:
# ask a question
correct_answer_index = int(2 * random.random())
wrong_answer_index = correct_answer_index ^ 1
answers = ["", ""]
answers[correct_answer_index] = question.correct_answer
answers[wrong_answer_index] = question.wrong_answer
values = [question.text]
values.extend(answers)
self.gui.update_question("%s\nA: %s\nB: %s" % tuple(values))
# wait for a button press
pin_bit_pattern = pfio.read_input()
while pin_bit_pattern == 0 and not self.stopped():
pin_bit_pattern = pfio.read_input()
# since we can't have multi-leveled break statements...
if self.stopped():
break
# find out which button was pressed
pin_number = pfio.get_pin_number(pin_bit_pattern)
#print "pin number: %d" % pin_number
#print self.player1.buttons[correct_answer_index].switch.pin_number
if pin_number == self.player1.buttons[
correct_answer_index].switch.pin_number:
self.player1.buttons[correct_answer_index].light.turn_on()
print "Player 1 got the correct answer!"
#print "The answer was: {}".format(question.correct_answer)
self.gui.update_question(
"%s\n\nThe correct answer was: %s\n\nPlayer 1 has 3 seconds to race!"
% (question.text, question.correct_answer))
self.player1.car.drive(3)
self.player1.buttons[correct_answer_index].light.turn_off()
elif pin_number == self.player1.buttons[
wrong_answer_index].switch.pin_number:
self.player1.buttons[wrong_answer_index].light.turn_on()
print "Player 1 got the WRONG answer!"
#print "The answer was: {}".format(question.correct_answer)
self.gui.update_question(
"%s\n\nThe correct answer was: %s\n\nPlayer 2 has 3 seconds to race!"
% (question.text, question.correct_answer))
self.player2.car.drive(3)
self.player1.buttons[wrong_answer_index].light.turn_off()
elif pin_number == self.player2.buttons[
correct_answer_index].switch.pin_number:
self.player2.buttons[correct_answer_index].light.turn_on()
print "Player 2 got the correct answer!"
#print "The answer was: {}".format(question.correct_answer)
self.gui.update_question(
"%s\n\nThe correct answer was: %s\n\nPlayer 2 has 3 seconds to race!"
% (question.text, question.correct_answer))
self.player2.car.drive(3)
self.player2.buttons[correct_answer_index].light.turn_off()
elif pin_number == self.player2.buttons[
wrong_answer_index].switch.pin_number:
self.player2.buttons[wrong_answer_index].light.turn_on()
print "Player 2 got the WRONG answer!"
#print "The answer was: {}".format(question.correct_answer)
self.gui.update_question(
"%s\n\nThe correct answer was: %s\n\nPlayer 1 has 3 seconds to race!"
% (question.text, question.correct_answer))
self.player1.car.drive(3)
self.player2.buttons[wrong_answer_index].light.turn_off()
elif pin_number == self.buttons[4].switch.pin_number:
self.buttons[4].light.turn_on()
print "PASS"
#print "The answer was: {}".format(question.correct_answer)
time.sleep(1)
self.buttons[4].light.turn_off()
else:
raise UnknownButtonError("detected change on pin: %d" %
pin_number)
# wait until nothing is pressed
pin_bit_pattern = pfio.read_input()
while pin_bit_pattern != 0:
pin_bit_pattern = pfio.read_input()
# should we keep playing?
if self.stopped():
break
def runGame(isFirstGame):
if isFirstGame:
# Let the computer go first on the first game, so the player
# can see how the tokens are dragged from the token piles.
turn = COMPUTER
showHelp = True
else:
# Randomly choose who goes first.
if random.randint(0, 1) == 0:
turn = COMPUTER
else:
turn = HUMAN
showHelp = False
# Set up a blank board data structure.
mainBoard = getNewBoard()
while True: # main game loop
if turn == HUMAN:
# Human player's turn.
#getHumanMove(mainBoard, showHelp)
column = 0
column = pfio.read_input()
while column == 0:
column = pfio.read_input()
column_position = 0
serialport.write("Human player's turn")
if column == 1:
column_position = 0
elif column == 2:
column_position = 1
elif column == 4:
column_position = 2
elif column == 8:
column_position = 3
elif column == 16:
column_position = 4
elif column == 32:
column_position = 5
elif column == 64:
column_position = 6
#board[column][getLowestEmptySpace(mainBoard, column)] = RED
#animateDroppingToken(board, column, RED)
animatePlayerMoving(mainBoard,column_position)
makeMove(mainBoard, RED, column_position)
if showHelp:
# turn off help arrow after the first move
showHelp = False
moves_sound.play()
if isWinner(mainBoard, RED):
winnerImg = HUMANWINNERIMG
break
turn = COMPUTER # switch to other player's turn
else:
# Computer player's turn.
column = getComputerMove(mainBoard)
animateComputerMoving(mainBoard, column)
makeMove(mainBoard, BLACK, column)
if isWinner(mainBoard, BLACK):
winnerImg = COMPUTERWINNERIMG
break
moves_sound.play()
turn = HUMAN # switch to other player's turn
if isBoardFull(mainBoard):
# A completely filled board means it's a tie.
winnerImg = TIEWINNERIMG
break
while True:
# Keep looping until player clicks the mouse or quits.
drawBoard(mainBoard)
DISPLAYSURF.blit(winnerImg, WINNERRECT)
pygame.display.update()
FPSCLOCK.tick()
column = 0
while column == 0:
column = pfio.read_input()
if winnerImg == HUMANWINNERIMG:
serialport.write("The winner is the Human Player")
elif winnerImg == COMPUTERWINNERIMG:
serialport.write("The winner is the Computer")
if column == 1:
menu_sound.play(-1)
DISPLAYSURF.fill(BGCOLOR)
state = 0
return
elif column == 2:
pygame.quit()
sys.exit()
#
# Python script to wait until certain button is pressed
# returns button pressed and turns on a light to indicate it (for testing)
# @Pierre
#
import piface.pfio as pfio
pfio.init()
button = pfio.read_input()
while button == 0:
button = pfio.read_input()
pin_number = pfio.get_pin_number(button)
pfio.digital_write(0,1)
print pin_number
def AnyButtonPressed():
button = pfio.read_input()
while button == 0:
button = pfio.read_input()
pin_number = pfio.get_pin_number(button)
return pin_number
set_time = 2000 # time allowed to hit each light (starts off large and reduced after each hit)
time_left = set_time # countdown timer for hitting the light
hit = 0 # the input value
score = 0 # keep track of the player's score
misses = 0 # keep track of how many the player misses
colours = ["Red", "Green", "Blue", "Yellow", "White"] # colour list for printing to screen
previous_pressed = 255
print "Time left is: %s" % time_left # notify the player how long they have to hit each flash
while True:
in_bit_pattern = pfio.read_input() # see if any buttons have been hit
if in_bit_pattern != previous_pressed: # check this is a new button press
previous_pressed = in_bit_pattern # record button press for next time's check
if in_bit_pattern > 0:
if in_bit_pattern == pfio.get_pin_bit_mask(current): # check that only the correct button was hit
pfio.digital_write(current + 2, 0) # turn off hit light
previous = current
current = next_colour() # get next colour
while current == previous: # ensure differnt colour each time
current = next_colour() # get next colour
def send_message(): def listener(player_number): global addr if player_number: global data1 while True: data1, addr = players[0].recvfrom(1024) print "Lines received from player 1 %s" %data else: while True: global data2 data2, addr = players[1].recvfrom(1024) print "Lines received from player 2 %s" %data players = list() if len(sys.argv) != 1: YOUR_IP =socket.gethostbyname(socket.gethostname()) YOUR_PORT = 5005 if sys.argv[1] == "1": PLAYER1_IP="192.168.1.2" # default IP address for quick play else: PLAYER1_IP = sys.argv[1] PLAYER1_PORT = 4052 sock1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock1.bind((PLAYER1_IP,PLAYER1_PORT)) players.append(sock1) if len(sys.argv) == 3: if sys.argv[2] == "1": PLAYER2_IP="192.168.0.1" # default IP address for quick play else: PLAYER2_IP = sys.argv[2] PLAYER2_PORT = 4053 sock2 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock2.bind((PLAYER2_IP,PLAYER2_PORT)) players.append(sock2) if len(players): listener_thread_1 = threading.Thread(target=listener, args=(True,)) listener_thread_1.daemon = True listener_thread_1.start() if len(players) >1: listener_thread_2 = threading.Thread(target=listener, args=(False,)) listener_thread_2.daemon = True listener_thread_2.start() while in_play: while yourTurn: new = pfio.read_input() if previous != new: previous = new send_message(new) break while not yourTurn: if received: for player in players:
def piface_listener(): global pressed_button while(True): pressed_button = pfio.read_input()
sleep(0.5) # wait to keep the colour showing pfio.digital_write(i+2,0) # turn the colour off sleep(0.2) # small break between colours sleep(0.4) pfio.write_output(0xFF) # signify it is their turn by turning all the LEDs on then off sleep(0.3) pfio.write_output(0x0) if screen_output: print "\nYour turn!" for i in array: # for each colour in current sequence (check against inputted sequence) event = pfio.read_input() # read the button port state while event != 0: # wait till no buttons pressed event = pfio.read_input() # so a single button press is not read as 2 sleep(0.001) # delay while event == 0: # wait for any input event = pfio.read_input() sleep(0.001) # delay pin_number = pfio.get_pin_number(event) # calculate the input pin if screen_output: print colours[pin_number -1] # print the colour in sequence to the screen pfio.digital_write(pin_number+2,1) # light up the buttons pressed
menu.set_center(True,True)
menu.set_alignment('center','center')
if prev_state != state:
pygame.event.post(pygame.event.Event(EVENT_CHANGE_STATE, key = 0))
prev_state = state
e = pygame.event.wait()
if e.type == pygame.KEYDOWN or e.type == EVENT_CHANGE_STATE:
if state == 0:
rect_list,state = menu.update(e,state)
column = 0
while column == 0:
column = pfio.read_input()
serialport.write("Welcome to Connect Four Game")
pygame.display.update()
if column == 1:
state = 1
elif column == 2:
state = 2
if state == 1:
menu_sound.stop()
runGame(isFirstGame)
isFirstGame = False
state = 0
prev_state = 1
elif state == 2 :
print 'Exit'
