def run(self):
log.debug('ContinuousModePuffs.run() START')
ScoreBoard().display('CP')
while self.terminate is False:
# Print a little graphic of the puffers showing which one is active...
log.info("%s idx=%02d id=%08X" %
(self.puff_type, self.idx, self.puffers[self.idx]))
e = FpEvent(self.puffers[self.idx], self.puff_type,
struct.pack('<H', self.puff_duration))
log.info(str(e))
Visualizer().info(e)
FpSerial().write(e.serialize())
# Move the frixel by inc
self.idx += self.inc
# Bounce if necessary
if self.idx == -1:
self.idx = 1
self.inc = 1
elif self.idx == len(self.puffers):
self.idx = len(self.puffers) - 2
self.inc = -1
# Wait a little bit...
time.sleep(self.delay)
log.debug('ContinuousModePuffs.run() END')
def run(self):
log.debug('MusicPlayMode.run() START')
time.sleep(0.5)
try:
self.start_playback()
while not self.terminate:
l, data = self.inp.read()
self.inp.pause(1)
if l:
try:
matrix = self.calculate_levels(data)
puffer_state = (len(self.channels)*2) * [' ']
puffcount = 0
puffmask = 0x00000000
for i in range(0, len(self.channels)):
diff = matrix[i] - self.means[i].mean()
if diff > 0:
self.means[i].set(matrix[i])
if diff > self.threshold:
puffer_idx = i*2
if self.channels[i]:
puffer_idx += 1
self.channels[i] = not(self.channels[i])
puffer_state[puffer_idx] = 'PUFF'
puffmask = puffmask | self.all_puffers[puffer_idx]
puffcount += 1
else:
self.means[i].push(matrix[i])
self.puff_frequency.push(puffcount)
puff_density = self.puff_frequency.mean()
if self.target_density > puff_density and self.threshold > self.min_threshold:
self.threshold -= self.threshold_step
elif self.threshold < self.max_threshold:
self.threshold += self.threshold_step
log.debug('Music t=%5.2f d=%5.3f t=%5.3f' % (
time.time() - self.start,
puff_density,
self.threshold))
if self.manual_mask > 0:
puffmask = puffmask | self.manual_mask
self.manual_mask = 0
if puffmask != 0:
e = FpEvent(puffmask, self.puff_type, pack('<H', self.puff_duration))
log.info('Event: %s' % str(e))
Visualizer().info(e)
FpSerial().write(e.serialize())
self.out.write(data)
except Exception as e:
log.exception("END: %s: %s" % (type(e), e))
break
self.inp.pause(0)
self.stop_playback()
finally:
try:
self.inp.close()
self.out.close()
except Exception as e:
log.error('while closing ALSA devices %s: %s' % (type(e), e))
log.debug('MusicPlayMode.run() END')
def __init__(self, music_file):
log.debug('MusicPlayMode.__init__() START')
Mode.__init__(self)
# Make sure moc is running
subprocess.call(["mocp", "-S"])
self.music_file = music_file
self.large_puffers = config['LargePuffers']['ids']
self.small_puffers = config['PongGame']['puffers']
self.all_puffers = copy.copy(self.large_puffers)
self.all_puffers.extend(self.small_puffers)
log.info('MusicPlayMode.__init__() all_puffers: %s' % str([('%x' % x) for x in self.all_puffers]))
log.info('MusicPlayMode.__init__() large_puffers: %s' % str([('%x' % x) for x in self.large_puffers]))
self.puff_duration = config['MusicMode']['puff_duration']
self.puff_type = 'FP_EVENT_ALTPUFF' if config['PongGame']['use_alt_puff'] else 'FP_EVENT_PUFF'
self.means = []
self.meanlen = 10
self.puff_frequency = None
self.frequencylen = 30
self.threshold = 2
self.threshold_step = 0.004
self.min_threshold = 0.5
self.max_threshold = 10
self.target_density = config['MusicMode']['target_density']
self.channels = []
self.min_wait = 0.5
self.max_wait = 2.5
self.chunk = (len(self.all_puffers)/2)*80
self.sample_rate = 44100
self.start = time.time()
self.inp = None
self.out = None
self.manual_mask = 0
try:
for _ in range(0, len(self.all_puffers)/2):
self.means.append(RunningMean(self.meanlen))
self.means[-1].set(0)
self.channels.append(False)
self.puff_frequency = RunningMean(self.frequencylen)
self.inp = alsa.PCM(alsa.PCM_CAPTURE, alsa.PCM_NORMAL, 'hw:Loopback,1,0')
self.out = alsa.PCM(alsa.PCM_PLAYBACK, alsa.PCM_NORMAL, 'plughw:0,0')
self.inp.setchannels(2)
self.inp.setrate(self.sample_rate)
self.inp.setformat(alsa.PCM_FORMAT_S16_LE)
self.inp.setperiodsize(self.chunk)
self.out.setchannels(2)
self.out.setrate(self.sample_rate)
self.out.setformat(alsa.PCM_FORMAT_S16_LE)
self.out.setperiodsize(self.chunk)
except Exception as e:
log.error('MusicPlayMode.__init__() %s: %s' % (type(e), e))
if self.inp:
self.inp.close()
if self.out:
self.out.close()
log.debug('MusicPlayMode.__init__() END')
def __init__(self):
log.debug('ScoreBoard display id=%08X' % self.get_id())
self.keyboard = None
self.muted = False
try:
self.keyboard = Keyboard()
except Exception as e:
log.info('Could not get Keyboard object (for screen display)')
def __init__(self):
log.debug('ScoreBoard display id=%08X' % self.get_id())
self.keyboard = None
self.muted = False
try:
self.keyboard = Keyboard()
except Exception as e:
log.info('Could not get Keyboard object (for screen display)')
def sequence(self, pufferid):
log.info('Simple on off, with spark 100ms extra at start and end...')
self.spark(pufferid, on=True)
time.sleep(0.100)
self.solenoid(pufferid, on=True)
time.sleep(0.100)
self.solenoid(pufferid, on=False)
time.sleep(0.100)
self.spark(pufferid, on=False)
def sequence(self, pufferid):
log.info('Simple on off, with spark 200ms extra at start and end...')
self.spark(pufferid, on=True)
time.sleep(0.200)
self.solenoid(pufferid, on=True)
time.sleep(0.100)
self.solenoid(pufferid, on=False)
time.sleep(0.200)
self.spark(pufferid, on=False)
def run(self):
log.debug('ContinuousModeWait.run() START')
log.info("Continuous Mode. WAITING. Press START button to continue")
ScoreBoard().display('CW')
while not self.terminate:
time.sleep(0.5)
log.debug('ContinuousModeWait.run() END')
if self.quit:
return False
else:
return True
def display(self, message):
message = str(message)[0:FpEvent.FP_MAX_DATA_LEN]
disp_id = self.get_id()
if disp_id is not None:
e = FpEvent(disp_id, 'FP_EVENT_DISPLAY', message)
log.info('DISPLAY: %s' % message)
Visualizer().update(e)
if self.muted is False:
FpSerial().write(e.serialize())
if self.keyboard is not None:
self.keyboard.display_text(message)
def display(self, message):
message = str(message)[0:FpEvent.FP_MAX_DATA_LEN]
disp_id = self.get_id()
if disp_id is not None:
e = FpEvent(disp_id, 'FP_EVENT_DISPLAY', message)
log.info('DISPLAY: %s' % message)
Visualizer().update(e)
if self.muted is False:
FpSerial().write(e.serialize())
if self.keyboard is not None:
self.keyboard.display_text(message)
def sequence(self, pufferid):
log.info('Current Firmware Sequence with 150ms main puff length...')
self.spark(pufferid, on=True)
time.sleep(0.100)
self.solenoid(pufferid, on=True)
time.sleep(0.013)
self.solenoid(pufferid, on=False)
time.sleep(0.200)
self.solenoid(pufferid, on=True)
time.sleep(0.150)
self.solenoid(pufferid, on=False)
time.sleep(0.100)
self.spark(pufferid, on=False)
def sequence(self, pufferid):
log.info('Current Firmware Sequence with 150ms main puff length...')
self.spark(pufferid, on=True)
time.sleep(0.100)
self.solenoid(pufferid, on=True)
time.sleep(0.013)
self.solenoid(pufferid, on=False)
time.sleep(0.200)
self.solenoid(pufferid, on=True)
time.sleep(0.150)
self.solenoid(pufferid, on=False)
time.sleep(0.100)
self.spark(pufferid, on=False)
def event(self, event):
log.debug('ContinuousModePuffs.event received: %s' % str(event))
if event in [EventButton('start'), EventQuit()]:
self.terminate = True
if type(event) is EventSwipe:
if event.player == '1UP':
self.delay += 0.025
else:
self.delay -= 0.025
if self.delay < 0.08:
self.delay = 0.08
log.info('DELAY set to %s' % self.delay)
def run(self):
log.debug('PongVictory.run() START')
# Wait for a swipe (indicated by setting self.delay to not None)
ScoreBoard().display('P%d Swipe!' % self.player)
log.info('Waiting for player %d swipe...' % self.player)
while self.terminate is False and self.delay is None:
time.sleep(0.1)
if self.terminate:
return False
while self.idx < len(self.puffers):
if self.terminate:
return 'Quit'
log.info("%s idx=%02d id=%08X" %
(self.puff_type, self.idx, self.puffers[self.idx]))
e = FpEvent(self.puffers[self.idx], self.puff_type,
struct.pack('<H', self.puff_duration))
log.info(str(e))
Visualizer().info(e)
FpSerial().write(e.serialize())
time.sleep(self.delay)
self.idx += 1
log.info('LARGE PUFFER id=%08X duration (ms)=%d' %
(self.large_puffer, self.large_puff_duration_ms))
e = FpEvent(self.large_puffer, 'FP_EVENT_PUFF',
struct.pack('<H', self.large_puff_duration_ms))
Visualizer().info(e)
FpSerial().write(e.serialize())
def run(self):
log.debug('MusicMode.run() START')
while not self.terminate:
if self.display:
self.display = False
log.info('MusicMode.run() SELECTED idx=%d, song=%s' % (self.idx, self.music_files[self.idx]))
ScoreBoard().display(os.path.basename(self.music_files[self.idx]))
next
if self.activate:
self.activate = False
log.info('MusicMode.run() PLAY %s' % self.music_files[self.idx])
ModeManager().push_mode(MusicPlayMode(self.music_files[self.idx]))
next
time.sleep(0.2)
log.debug('MusicMode.run() END')
def discover(self):
while self.wm is None:
try:
log.info('Put Wiimote for player %s in discovery mode' % self.name)
ScoreBoard().display('D%s' % self.name[0])
self.wm = cwiid.Wiimote()
self.wm.rpt_mode = cwiid.RPT_BTN | cwiid.RPT_ACC
self.last_swipe = 0
log.debug('Connected to wiimote for %s' % self.name)
except RuntimeError as e:
log.error('%s - run "sudo hciconfig hci0 up"?' % e)
except Exception as e:
log.error('While discovering WiiMote %s / %s' % (type(e), e))
ScoreBoard().display('ER%s' % self.name)
time.sleep(1.5)
def run(self):
log.debug('%s.run() START' % self.__class__.__name__)
while not self.terminate:
if self.activate:
self.activate = False
self.callback(self.ids[self.idx])
if self.display:
log.info(
'%s.run() select puffer idx=%d; id=0x%08X; press START to activate'
% (self.__class__.__name__, self.idx, self.ids[self.idx]))
ScoreBoard().display('%02d' % self.idx)
self.display = False
time.sleep(0.2)
log.debug('%s.run() END' % self.__class__.__name__)
return None
def run(self):
log.debug('ManualMode.run() START')
ScoreBoard().display(
'Yellow=random small puff; Green=Large 1; Blue=Large 2')
while not self.terminate:
if self.puffer_mask != 0:
e = FpEvent(self.puffer_mask, self.puff_type,
pack('<H', self.duration))
log.info('Event: %s' % str(e))
Visualizer().info(e)
FpSerial().write(e.serialize())
self.puffer_mask = 0
time.sleep(0.1)
log.debug('ManualMode.run() END')
def event(self, event):
if event == EventQuit():
self.quit = True
self.terminate = True
if type(event) is EventSwipe:
log.debug('Swipe by %s' % event.player)
if self.idx in self.hit_idx[event.player]:
log.info("Player %s HITS!" % event.player)
if event.player == '1UP':
self.inc = 1
else:
self.inc = -1
self.delay = strength2delay(event.strength)
else:
log.info('Player %s MISS!' % event.player)
def event(self, event):
if event == EventQuit():
self.quit = True
self.terminate = True
if type(event) is EventSwipe:
log.debug('Swipe by %s' % event.player)
if self.idx in self.hit_idx[event.player]:
log.info("Player %s HITS!" % event.player)
if event.player == '1UP':
self.inc = 1
else:
self.inc = -1
self.delay = strength2delay(event.strength)
else:
log.info('Player %s MISS!' % event.player)
def run(self):
log.debug('%s.run() START' % self.__class__.__name__)
while not self.terminate:
if self.activate:
self.activate = False
try:
ModeManager().push_mode(self.modes[self.idx]())
except Exception as e:
log.exception('in mode %s : %s : %s' % (self.modes[self.idx].__name__, type(e), e))
if self.display:
log.info('%s selection: %s; press START to activate' % (self.__class__.__name__, self.modes[self.idx].__name__))
ScoreBoard().display(self.modes[self.idx].displayname())
self.display = False
time.sleep(0.2)
log.debug('%s.run() END' % self.__class__.__name__)
return 'END'
def event(self, event):
log.debug('%s.event(%s) START' % (self.__class__.__name__, str(event)))
if event == EventQuit():
self.terminate = True
if event == EventButton('start'):
log.info('%s.event() activating mode %s' % (self.__class__.__name__, self.modes[self.idx].__name__))
self.display = True
# we can't actually push a mode in an event handler, so we set the flag to do it in the main loop instead
self.activate = True
if type(event) is EventSwipe:
if event.player == '2UP':
self.idx = (self.idx + 1) % len(self.modes)
else:
self.idx = (self.idx - 1) % len(self.modes)
self.display = True
def callback(self, idmask):
log.info("SOLENOID OPEN id=%08X" % idmask)
e = FpEvent(idmask, 'FP_EVENT_SOLENOID', FpEvent.RELAY_ON)
log.info(str(e))
FpSerial().write(e.serialize())
time.sleep(self.duration)
log.info("SOLENOID CLOSE id%08X" % idmask)
e = FpEvent(idmask, 'FP_EVENT_SOLENOID', FpEvent.RELAY_OFF)
log.info(str(e))
FpSerial().write(e.serialize())
def callback(self, idmask):
log.info("SPARK START id=%08X" % idmask)
e = FpEvent(idmask, 'FP_EVENT_SPARK', FpEvent.RELAY_ON)
log.info(str(e))
FpSerial().write(e.serialize())
time.sleep(self.duration)
log.info("SPARK STOP id%08X" % idmask)
e = FpEvent(idmask, 'FP_EVENT_SPARK', FpEvent.RELAY_OFF)
log.info(str(e))
FpSerial().write(e.serialize())
def callback(self, idmask):
log.info("SPARK START id=%08X" % idmask)
e = FpEvent(idmask, 'FP_EVENT_SPARK', FpEvent.RELAY_ON)
log.info(str(e))
FpSerial().write(e.serialize())
time.sleep(self.duration)
log.info("SPARK STOP id%08X" % idmask)
e = FpEvent(idmask, 'FP_EVENT_SPARK', FpEvent.RELAY_OFF)
log.info(str(e))
FpSerial().write(e.serialize())
def callback(self, idmask):
log.info("SOLENOID OPEN id=%08X" % idmask)
e = FpEvent(idmask, 'FP_EVENT_SOLENOID', FpEvent.RELAY_ON)
log.info(str(e))
FpSerial().write(e.serialize())
time.sleep(self.duration)
log.info("SOLENOID CLOSE id%08X" % idmask)
e = FpEvent(idmask, 'FP_EVENT_SOLENOID', FpEvent.RELAY_OFF)
log.info(str(e))
FpSerial().write(e.serialize())
def event(self, event):
log.debug('%s.event(%s) START' % (self.__class__.__name__, str(event)))
if event == EventQuit():
self.terminate = True
if event == EventButton('start'):
log.info('%s.event() activating mode %s' %
(self.__class__.__name__, self.modes[self.idx].__name__))
self.display = True
# we can't actually push a mode in an event handler, so we set the flag to do it in the main loop instead
self.activate = True
if type(event) is EventSwipe:
if event.player == '2UP':
self.idx = (self.idx + 1) % len(self.modes)
else:
self.idx = (self.idx - 1) % len(self.modes)
self.display = True
def run(self):
log.debug('MusicMode.run() START')
while not self.terminate:
if self.display:
self.display = False
log.info('MusicMode.run() SELECTED idx=%d, song=%s' %
(self.idx, self.music_files[self.idx]))
ScoreBoard().display(
os.path.basename(self.music_files[self.idx]))
next
if self.activate:
self.activate = False
log.info('MusicMode.run() PLAY %s' %
self.music_files[self.idx])
ModeManager().push_mode(
MusicPlayMode(self.music_files[self.idx]))
next
time.sleep(0.2)
log.debug('MusicMode.run() END')
def run(self):
log.debug('%s.run() START' % self.__class__.__name__)
while not self.terminate:
if self.activate:
self.activate = False
try:
ModeManager().push_mode(self.modes[self.idx]())
except Exception as e:
log.exception('in mode %s : %s : %s' %
(self.modes[self.idx].__name__, type(e), e))
if self.display:
log.info(
'%s selection: %s; press START to activate' %
(self.__class__.__name__, self.modes[self.idx].__name__))
ScoreBoard().display(self.modes[self.idx].displayname())
self.display = False
time.sleep(0.2)
log.debug('%s.run() END' % self.__class__.__name__)
return 'END'
def event(self, event):
log.info('PongVictory.debug: %s' % event)
strength = None
if event == EventQuit():
self.terminate = True
if event == EventButton('start'):
strength = randint(60, 250)
if type(event) is EventSwipe:
if event.player == '%dUP' % self.player:
strength = event.strength
if strength:
self.delay = strength2delay(strength) / 5.0
self.large_puff_duration_ms = 25.0 / self.delay
log.info(
"Player %s VICTORY SWIPE (str=%s) => delay=%s; bigg puff=%s" %
(self.player, strength, self.delay,
self.large_puff_duration_ms))
def event(self, event):
log.info('PongVictory.debug: %s' % event)
strength = None
if event == EventQuit():
self.terminate = True
if event == EventButton('start'):
strength = randint(60,250)
if type(event) is EventSwipe:
if event.player == '%dUP' % self.player:
strength = event.strength
if strength:
self.delay = strength2delay(strength) / 5.0
self.large_puff_duration_ms = 25.0 / self.delay
log.info("Player %s VICTORY SWIPE (str=%s) => delay=%s; bigg puff=%s" % (
self.player,
strength,
self.delay,
self.large_puff_duration_ms))
def init_display(self):
disp_no = os.getenv("DISPLAY")
if disp_no:
log.info('Using X with DISPLAY: %s' % disp_no)
self.screen = pygame.display.set_mode((800,600))
pygame.init()
pygame.font.init()
pygame.display.set_caption('Fire Pong Keyboard Input')
else:
found = False
drivers = ['fbcon', 'directfb', 'svgalib']
for driver in drivers:
if not os.getenv('SDL_VIDEODRIVER'):
os.putenv('SDL_VIDEODRIVER', driver)
try:
pygame.display.init()
except pygame.error as e:
log.debug('Framebuffer driver %s failed: %s' % (driver, e))
continue
found = True
log.info('Using framebuffer driver: %s' % driver)
break
if not found:
raise Exception('No working video driver found')
size = (pygame.display.Info().current_w, pygame.display.Info().current_h)
log.info('Display size: %d x %d' % (size[0], size[1]))
self.screen = pygame.display.set_mode(size, pygame.FULLSCREEN)
self.screen.fill(Keyboard.COLBG)
pygame.font.init()
self.font = pygame.font.Font(None, Keyboard.FONTSIZE)
pygame.display.update()
def run(self):
''' Return None if Quit was pressed, else return the winner of the game, i.e. 1 or 2 '''
log.debug('PongGame.run()')
while self.win is None:
if self.terminate:
return
if self.idx < 0:
self.win = 2
break
elif self.idx >= len(self.puffers):
self.win = 1
break
elif self.idx >= 0 and self.idx < len(self.puffers):
log.info("%s idx=%02d id=%08X" % (self.puff_type, self.idx, self.puffers[self.idx]))
e = FpEvent(self.puffers[self.idx], self.puff_type, struct.pack('<H', self.puff_duration))
log.info(str(e))
Visualizer().info(e)
FpSerial().write(e.serialize())
time.sleep(self.delay)
self.idx += self.inc
if self.quit:
return None
else:
death_puffer = self.large_puffers[1 if self.win == 1 else 0]
e = FpEvent(death_puffer, 'FP_EVENT_PUFF', struct.pack('<H', self.large_puff_duration))
log.info(str(e))
Visualizer().info(e)
FpSerial().write(e.serialize())
return self.win
def run(self):
''' Return None if Quit was pressed, else return the winner of the game, i.e. 1 or 2 '''
log.debug('PongGame.run()')
while self.win is None:
if self.terminate:
return
if self.idx < 0:
self.win = 2
break
elif self.idx >= len(self.puffers):
self.win = 1
break
elif self.idx >= 0 and self.idx < len(self.puffers):
log.info("%s idx=%02d id=%08X" %
(self.puff_type, self.idx, self.puffers[self.idx]))
e = FpEvent(self.puffers[self.idx], self.puff_type,
struct.pack('<H', self.puff_duration))
log.info(str(e))
Visualizer().info(e)
FpSerial().write(e.serialize())
time.sleep(self.delay)
self.idx += self.inc
if self.quit:
return None
else:
death_puffer = self.large_puffers[1 if self.win == 1 else 0]
e = FpEvent(death_puffer, 'FP_EVENT_PUFF',
struct.pack('<H', self.large_puff_duration))
log.info(str(e))
Visualizer().info(e)
FpSerial().write(e.serialize())
return self.win
def run(self):
log.debug('PongMode.run() START')
while not self.terminate:
self.reset()
while max(self.score) < self.winning_score and not self.terminate:
self.display_score()
if ModeManager().push_mode(PongWaitStart()) is False:
return 'PongMode Quit'
if ModeManager().push_mode(PongCounterMode(start=3, end=1)) is False:
return 'PongMode Quit'
self.display_score()
win = ModeManager().push_mode(PongGame(self.start_player))
if win is None:
self.terminate = True
else:
self.score[win-1] += 1
if self.start_player == 1:
self.start_player = 2
else:
self.start_player = 1
if self.score[0] > self.score[1]:
log.info("Player 1 wins")
ScoreBoard().display("1W")
ModeManager().push_mode(PongVictory(win))
elif self.score[1] > self.score[0]:
log.info("Player 2 wins")
ScoreBoard().display("2W")
ModeManager().push_mode(PongVictory(win))
else:
log.info("It's a DRAW!")
ScoreBoard().display("Dr")
log.debug('PongMode.run() END')
def run(self):
log.debug('PongVictory.run() START')
# Wait for a swipe (indicated by setting self.delay to not None)
ScoreBoard().display('P%d Swipe!' % self.player)
log.info('Waiting for player %d swipe...' % self.player)
while self.terminate is False and self.delay is None:
time.sleep(0.1)
if self.terminate:
return False
while self.idx < len(self.puffers):
if self.terminate:
return 'Quit'
log.info("%s idx=%02d id=%08X" % (self.puff_type, self.idx, self.puffers[self.idx]))
e = FpEvent(self.puffers[self.idx], self.puff_type, struct.pack('<H', self.puff_duration))
log.info(str(e))
Visualizer().info(e)
FpSerial().write(e.serialize())
time.sleep(self.delay)
self.idx += 1
log.info('LARGE PUFFER id=%08X duration (ms)=%d' % (self.large_puffer, self.large_puff_duration_ms))
e = FpEvent(self.large_puffer, 'FP_EVENT_PUFF', struct.pack('<H', self.large_puff_duration_ms))
Visualizer().info(e)
FpSerial().write(e.serialize())
def run(self):
log.debug('PongMode.run() START')
while not self.terminate:
self.reset()
while max(self.score) < self.winning_score and not self.terminate:
self.display_score()
if ModeManager().push_mode(PongWaitStart()) is False:
return 'PongMode Quit'
if ModeManager().push_mode(PongCounterMode(start=3,
end=1)) is False:
return 'PongMode Quit'
self.display_score()
win = ModeManager().push_mode(PongGame(self.start_player))
if win is None:
self.terminate = True
else:
self.score[win - 1] += 1
if self.start_player == 1:
self.start_player = 2
else:
self.start_player = 1
if self.score[0] > self.score[1]:
log.info("Player 1 wins")
ScoreBoard().display("1W")
ModeManager().push_mode(PongVictory(win))
elif self.score[1] > self.score[0]:
log.info("Player 2 wins")
ScoreBoard().display("2W")
ModeManager().push_mode(PongVictory(win))
else:
log.info("It's a DRAW!")
ScoreBoard().display("Dr")
log.debug('PongMode.run() END')
def callback(self, idmask):
log.info("%s id=%08X" % (self.puff_type, idmask))
e = FpEvent(idmask, self.puff_type, struct.pack('<H', self.duration))
log.info(str(e))
Visualizer().info(e)
FpSerial().write(e.serialize())
def wiiswipe(self, player, strength):
log.info('InputManager[%s]: wiiswipe(%s, %s)' % (tid(), player, strength))
self.emit(EventSwipe(player, strength))
def run(self):
log.debug('MusicPlayMode.run() START')
time.sleep(0.5)
try:
self.start_playback()
while not self.terminate:
l, data = self.inp.read()
self.inp.pause(1)
if l:
try:
matrix = self.calculate_levels(data)
puffer_state = (len(self.channels) * 2) * [' ']
puffcount = 0
puffmask = 0x00000000
for i in range(0, len(self.channels)):
diff = matrix[i] - self.means[i].mean()
if diff > 0:
self.means[i].set(matrix[i])
if diff > self.threshold:
puffer_idx = i * 2
if self.channels[i]:
puffer_idx += 1
self.channels[i] = not (self.channels[i])
puffer_state[puffer_idx] = 'PUFF'
puffmask = puffmask | self.all_puffers[
puffer_idx]
puffcount += 1
else:
self.means[i].push(matrix[i])
self.puff_frequency.push(puffcount)
puff_density = self.puff_frequency.mean()
if self.target_density > puff_density and self.threshold > self.min_threshold:
self.threshold -= self.threshold_step
elif self.threshold < self.max_threshold:
self.threshold += self.threshold_step
log.debug('Music t=%5.2f d=%5.3f t=%5.3f' %
(time.time() - self.start, puff_density,
self.threshold))
if self.manual_mask > 0:
puffmask = puffmask | self.manual_mask
self.manual_mask = 0
if puffmask != 0:
e = FpEvent(puffmask, self.puff_type,
pack('<H', self.puff_duration))
log.info('Event: %s' % str(e))
Visualizer().info(e)
FpSerial().write(e.serialize())
self.out.write(data)
except Exception as e:
log.exception("END: %s: %s" % (type(e), e))
break
self.inp.pause(0)
self.stop_playback()
finally:
try:
self.inp.close()
self.out.close()
except Exception as e:
log.error('while closing ALSA devices %s: %s' % (type(e), e))
log.debug('MusicPlayMode.run() END')
def __init__(self, music_file):
log.debug('MusicPlayMode.__init__() START')
Mode.__init__(self)
# Make sure moc is running
subprocess.call(["mocp", "-S"])
self.music_file = music_file
self.large_puffers = config['LargePuffers']['ids']
self.small_puffers = config['PongGame']['puffers']
self.all_puffers = copy.copy(self.large_puffers)
self.all_puffers.extend(self.small_puffers)
log.info('MusicPlayMode.__init__() all_puffers: %s' %
str([('%x' % x) for x in self.all_puffers]))
log.info('MusicPlayMode.__init__() large_puffers: %s' %
str([('%x' % x) for x in self.large_puffers]))
self.puff_duration = config['MusicMode']['puff_duration']
self.puff_type = 'FP_EVENT_ALTPUFF' if config['PongGame'][
'use_alt_puff'] else 'FP_EVENT_PUFF'
self.means = []
self.meanlen = 10
self.puff_frequency = None
self.frequencylen = 30
self.threshold = 2
self.threshold_step = 0.004
self.min_threshold = 0.5
self.max_threshold = 10
self.target_density = config['MusicMode']['target_density']
self.channels = []
self.min_wait = 0.5
self.max_wait = 2.5
self.chunk = (len(self.all_puffers) / 2) * 80
self.sample_rate = 44100
self.start = time.time()
self.inp = None
self.out = None
self.manual_mask = 0
try:
for _ in range(0, len(self.all_puffers) / 2):
self.means.append(RunningMean(self.meanlen))
self.means[-1].set(0)
self.channels.append(False)
self.puff_frequency = RunningMean(self.frequencylen)
self.inp = alsa.PCM(alsa.PCM_CAPTURE, alsa.PCM_NORMAL,
'hw:Loopback,1,0')
self.out = alsa.PCM(alsa.PCM_PLAYBACK, alsa.PCM_NORMAL,
'plughw:0,0')
self.inp.setchannels(2)
self.inp.setrate(self.sample_rate)
self.inp.setformat(alsa.PCM_FORMAT_S16_LE)
self.inp.setperiodsize(self.chunk)
self.out.setchannels(2)
self.out.setrate(self.sample_rate)
self.out.setformat(alsa.PCM_FORMAT_S16_LE)
self.out.setperiodsize(self.chunk)
except Exception as e:
log.error('MusicPlayMode.__init__() %s: %s' % (type(e), e))
if self.inp:
self.inp.close()
if self.out:
self.out.close()
log.debug('MusicPlayMode.__init__() END')
class DebugEventsMode(Mode):
__displayname__ = 'Debug Events'
def __init__(self):
Mode.__init__(self)
def run(self):
print("DebugEventsMode.run()")
while not self.terminate:
time.sleep(2)
def event(self, event):
log.debug('DebugEventsMode: %s' % event)
if __name__ == '__main__':
import threading
from fire_pong.events import *
import logging
log = logging
log.basicConfig(level=logging.DEBUG)
log.info('DebugEventsMode.displayname() = %s' %
DebugEventsMode.displayname())
m = DebugEventsMode()
m.thread.start()
for e in [EventMessage('bananas'), EventSwipe('1UP', 128)]:
time.sleep(0.5)
m.event(e)
m.shutdown()
m.thread.join()
def wiiswipe(self, player, strength):
log.info('InputManager[%s]: wiiswipe(%s, %s)' %
(tid(), player, strength))
self.emit(EventSwipe(player, strength))
import signal
log.basicConfig(format='%(asctime)s %(name)s[%(process)d]'
'%(levelname)s: %(message)s',
level=logging.DEBUG)
fire_pong.swipemote.log = log
signal.signal(signal.SIGTERM, sh)
config = {
'InputManager': {
'tick': 0.02,
'keyboard': {
'tick': 0.02,
'enabled': True,
'quit': 'ESCAPE',
'start': 's',
'emstop': 'h',
'back': 'b',
'swipe1': 'z',
'swipe2': 'COMMA',
'btstart': 'RETURN',
'btemstop': '_gain'
}
}
}
im = InputManager()
im.set_event_handler(eh)
im.thread.start()
im.thread.join()
log.info('all done')
def info(self, event):
for l in self.as_lines(event):
log.info(l)
def reset(self):
log.info('PongMode: NEW MATCH')
self.score = [0,0]
import signal
log.basicConfig(format='%(asctime)s %(name)s[%(process)d]' '%(levelname)s: %(message)s', level=logging.DEBUG)
fire_pong.swipemote.log = log
signal.signal(signal.SIGTERM, sh)
config = {
'InputManager': {
'tick': 0.02,
'keyboard': {
'tick': 0.02,
'enabled': True,
'quit': 'ESCAPE',
'start': 's',
'emstop': 'h',
'back': 'b',
'swipe1': 'z',
'swipe2': 'COMMA',
'btstart': 'RETURN',
'btemstop': '_gain'
}
}
}
im = InputManager()
im.set_event_handler(eh)
im.thread.start()
im.thread.join()
log.info('all done')
def solenoid(self, pufferid, on=False):
e = FpEvent(pufferid, 'FP_EVENT_SOLENOID', FpEvent.RELAY_ON if on else FpEvent.RELAY_OFF)
log.info('%s.solenoid() sending: %s' % (self.__class__.__name__, str(e)))
FpSerial().write(e.serialize())
def callback(self, idmask):
log.info("%s id=%08X" % (self.puff_type, idmask))
e = FpEvent(idmask, self.puff_type, struct.pack('<H', self.duration))
log.info(str(e))
Visualizer().info(e)
FpSerial().write(e.serialize())
def solenoid(self, pufferid, on=False):
e = FpEvent(pufferid, 'FP_EVENT_SOLENOID',
FpEvent.RELAY_ON if on else FpEvent.RELAY_OFF)
log.info('%s.solenoid() sending: %s' %
(self.__class__.__name__, str(e)))
FpSerial().write(e.serialize())
def info(self, event):
for l in self.as_lines(event):
log.info(l)
def reset(self):
log.info('PongMode: NEW MATCH')
self.score = [0, 0]
