def test_on():
"""test event registering with the on method"""
obs = Observable()
def on_test():
pass
obs.on("on_test", on_test)
assert on_test in obs._events["on_test"]
def test_on():
"""test event registering with the on method"""
obs = Observable()
def on_test():
pass
obs.on("on_test", on_test)
assert on_test in obs._events["on_test"]
def test_is_registered():
"""test is_registered() after registering an event"""
obs = Observable()
def some_test():
pass
assert not obs.is_registered("some_event", some_test)
obs.on("some_event", some_test)
assert obs.is_registered("some_event", some_test)
def test_on():
"""test event registering with the on method"""
obs = Observable()
nose.assert_false(obs.events)
def on_test():
pass
obs.on("on_test", on_test)
nose.assert_in(on_test, obs.events["on_test"])
def test_is_registered():
"""test is_registered() after registering an event"""
obs = Observable()
def some_test():
pass
assert not obs.is_registered("some_event", some_test)
obs.on("some_event", some_test)
assert obs.is_registered("some_event", some_test)
def __init__(self, robot: cozmo.robot.Robot, obs: Observable):
global _robot
_robot = robot
_obs = obs
obs.on("drive", Robot.drive)
obs.on("turn", Robot.turn)
obs.on("greet", Robot.greet)
obs.on("command1", Robot.command1)
obs.on("command2", Robot.command2)
def test_on_multiple_handlers():
"""test event registering with the on method and multiple handlers"""
obs = Observable()
results = []
def some_test(*args, **kw):
results.append(1)
def some_test_2(*args, **kw):
results.append(2)
obs.on("some_test", some_test, some_test_2)
assert len(obs._events["some_test"]) == 2
obs.trigger("some_test")
assert results == [1, 2]
def test_on_multiple_handlers():
"""test event registering with the on method and multiple handlers"""
obs = Observable()
results = []
def some_test(*args, **kw):
results.append(1)
def some_test_2(*args, **kw):
results.append(2)
obs.on("some_test", some_test, some_test_2)
assert len(obs._events["some_test"]) == 2
obs.trigger("some_test")
assert results == [1, 2]
def test_get_handlers():
"""test get_handlers() after registering handlers for two events"""
obs = Observable()
def some_test():
pass
def other_test():
pass
assert not obs.get_handlers("some_event")
obs.on("some_event", some_test)
assert some_test in obs.get_handlers("some_event")
obs.on("other_event", other_test)
assert other_test in obs.get_handlers("other_event")
assert other_test not in obs.get_handlers("some_event")
def test_get_handlers():
"""test get_handlers() after registering handlers for two events"""
obs = Observable()
def some_test():
pass
def other_test():
pass
assert not obs.get_handlers("some_event")
obs.on("some_event", some_test)
assert some_test in obs.get_handlers("some_event")
obs.on("other_event", other_test)
assert other_test in obs.get_handlers("other_event")
assert other_test not in obs.get_handlers("some_event")
def test_on_multiple_handlers():
"""test event registering with the on method and multiple handlers"""
obs = Observable()
nose.assert_false(obs.events)
results = []
def some_test(*args, **kw):
results.append(1)
def some_test_2(*args, **kw):
results.append(2)
obs.on('some_test', some_test, some_test_2)
nose.assert_equals(len(obs.events['some_test']), 2)
obs.trigger('some_test')
nose.assert_equals(results, [1,2])
class PopPi:
# Main application for pop machine
# State information
__acceptingFob = False
__acceptingFunds = False
__creditOnlyMode = False
__lastCreditButtonState = 0
__memberFob = None
__memberCredit = None
__deposited = None
__popCost = None
def __init__(self):
self.__obs = Observable()
conf = Configuration()
self.__rfid = RfidReader(conf.rfid.serialPort)
self.__acceptor = CoinAcceptor(conf.coinAcceptor.serialPort, conf.coinAcceptor.inhibitPin, conf.coinMap)
self.__memberService = MemberService(conf.db.username, conf.db.password, conf.db.hostname, conf.db.port, conf.db.database)
self.__popMachine = PopMachine(conf.popMachine.relayPin)
self.__webService = WebService(conf.web.bindAddress, conf.web.port)
self.__acceptor.inhibit(True)
self.__popCost = self.__popMachine.getPopCost()
self.__obs.on("CardSwiped", self.__onCardRead)
self.__obs.on("CoinAccepted", self.__onCoinAccepted)
self.__obs.on("MemberNotFound", self.__onMemberNotFound)
self.__obs.on("PopPaid", self.__onPopPaid)
self.__obs.on("CreditCompleted", self.__onCreditCompleted)
self.__creditOnlyPin = conf.general.creditOnlyPin
GPIO.setup(self.__creditOnlyPin, GPIO.IN)
def start(self):
self.__fobThread = threading.Thread(target=self.__readCardThread)
self.__fobThread.daemon = True
self.__fobThread.start()
self.__coinThread = threading.Thread(target=self.__readCoinThread)
self.__coinThread.daemon = True
self.__coinThread.start()
self.__creditOnlyThread = threading.Thread(target=self.__readCreditOnlyButton)
self.__creditOnlyThread.daemon = True
self.__creditOnlyThread.start()
self.__resetStates()
self.__acceptingFob = True
def stop(self):
if not self.__rfid is None:
self.__rfid.shutdown()
if not self.__acceptor is None:
self.__acceptor.shutdown()
if not self.__memberService is None:
self.__memberService.shutdown()
if not self.__popMachine is None:
self.__popMachine.shutdown()
if not self.__webService is None:
self.__webService.shutdown()
def __onCardRead(self, card):
if not self.__acceptingFob:
print("Fob swiped while not accepting fobs: Ignoring fob " + str(card))
return
self.__acceptingFob = False
self.__webService.onSwipeStart()
print("Fob " + str(card) + " swiped. Finding member...")
self.__memberCredit = self.__memberService.getCredit(card)
if self.__memberCredit is None:
self.__obs.trigger("MemberNotFound", card)
return
self.__memberFob = card
print("Member " + str(card) + " has " + str(self.__memberCredit) + " cents credit")
self.__acceptingFunds = True
self.__deposited = 0
self.__acceptor.inhibit(False)
self.__webService.onSwipe(self.__memberCredit, self.__popCost)
requiredFunds = self.__getRequiredFunds()
print("Member " + str(card) + " needs to supply " + str(requiredFunds) + " cents")
self.__checkRequiredFunds()
def __onCoinAccepted(self, coin):
if not self.__acceptingFunds:
print("Coin accepted while not accepting coins: Ignoring " + str(coin) + " cents")
return
self.__deposited += coin
self.__webService.onDeposit(coin)
print("Member inserted " + str(coin) + " cents")
self.__checkRequiredFunds()
def __onPopPaid(self):
self.__acceptor.inhibit(True)
self.__acceptingFunds = False
newCredit = (self.__memberCredit + self.__deposited) - self.__popCost
self.__memberService.setCredit(self.__memberFob, newCredit)
print("Member's new credit is " + str(newCredit) + " cents")
self.__webService.onPaid(newCredit)
self.__popMachine.awardPop()
print("Pop awarded to member")
self.__resetStates()
def __onCreditCompleted(self):
self.__acceptor.inhibit(True)
self.__acceptingFunds = False
newCredit = self.__memberCredit + self.__deposited
self.__memberService.setCredit(self.__memberFob, newCredit)
print("Member's new credit is " + str(newCredit) + " cents")
self.__webService.onCreditCompleted(newCredit)
self.__resetStates()
def __onMemberNotFound(self, card):
print("Member not found: " + str(card))
self.__resetStates()
self.__webService.onNotFound()
def __resetStates(self):
self.__acceptingFob = True
self.__acceptingFunds = False
self.__creditOnlyMode = False
self.__memberFob = None
self.__memberCredit = None
self.__deposited = None
self.__acceptor.inhibit(True)
print("Waiting for member")
def __checkRequiredFunds(self):
if self.__getRequiredFunds() <= 0 and not self.__creditOnlyMode:
self.__obs.trigger("PopPaid")
def __getRequiredFunds(self):
totalDeposit = self.__memberCredit + self.__deposited
return self.__popCost - totalDeposit
def __readCardThread(self):
while True:
card = self.__rfid.readCard()
self.__obs.trigger("CardSwiped", card)
def __readCoinThread(self):
while True:
coin = self.__acceptor.readCoin()
self.__obs.trigger("CoinAccepted", coin)
def __readCreditOnlyButton(self):
sleepTime = 0.1 # 100ms
while True:
pressed = GPIO.input(self.__creditOnlyPin)
if self.__lastCreditButtonState == pressed:
sleep(sleepTime)
continue # Ignore: Already handled this state
self.__lastCreditButtonState = pressed
if not self.__acceptingFunds:
sleep(sleepTime)
continue # Ignore button: Don't care about this state
if pressed == 1:
if not self.__creditOnlyMode:
self.__creditOnlyMode = True
self.__webService.onCreditOnly()
print("Member requested credit-only mode")
else:
print("Credit-only mode completed")
self.__obs.trigger("CreditCompleted")
sleep(sleepTime)
class Game(object):
"""
Game object that represents a currently running game state. Holds the Scenes that are in the game and handles some
of the global interactions.
:param config A config object that can be used to define information for the entire game state.
"""
def __init__(self, config=None):
if config is None:
config = {'x': 500, 'y': 500}
pygame.init()
self.clock = pygame.time.Clock()
self.running = True
self.screen = pygame.display.set_mode([config['x'], config['y']])
self.scenes = {}
self.current_scene = ''
self.events = Observable()
self.events_callbacks = {pygame.QUIT: lambda: sys.exit()}
self.key_down_callbacks = {}
self.key_up_callbacks = {}
self.key_pressed_callbacks = {}
self.events.on("set_scene", self.set_scene)
self.events.on("add_key_down_callback", self.add_key_down_callback)
self.events.on("add_key_up_callback", self.add_key_up_callback)
self.events.on("add_key_pressed_callback",
self.add_key_pressed_callback)
# Main game loop
def run(self):
while self.running:
for event in pygame.event.get():
if event.type in self.events_callbacks.keys():
self.events_callbacks[event.type]()
if event.type == pygame.KEYDOWN:
if event.key in self.key_down_callbacks.keys():
self.key_down_callbacks[event.key]()
if event.type == pygame.KEYUP:
if event.key in self.key_up_callbacks.keys():
self.key_up_callbacks[event.key]()
keys = pygame.key.get_pressed()
for key in self.key_pressed_callbacks.keys():
if keys[key]:
self.key_pressed_callbacks[key]()
if self.current_scene in self.scenes.keys():
self.scenes[self.current_scene].update()
pygame.display.flip()
self.clock.tick(60)
pygame.quit()
def quit(self):
self.running = False
def set_scene(self, scene_id: str):
if scene_id not in self.scenes.keys():
raise SceneIdNotFoundException()
self.current_scene = scene_id
self.scenes[self.current_scene].update_events()
def add_scene(self, scene_id: str, scene: Scene):
if scene_id in self.scenes.keys():
raise SceneIdAlreadyInGame()
scene.set_screen(self.screen)
scene.set_event_handler(self.events)
self.scenes[scene_id] = scene
def add_key_down_callback(self, key, callback):
if key in self.key_down_callbacks.keys():
raise Exception("Key is already in set.")
self.key_down_callbacks[key] = callback
def add_key_up_callback(self, key, callback):
if key in self.key_up_callbacks.keys():
raise Exception("Key is already in set.")
self.key_up_callbacks[key] = callback
def add_key_pressed_callback(self, key, callback):
if key in self.key_pressed_callbacks.keys():
raise Exception("Key is already in set.")
self.key_pressed_callbacks[key] = callback
