def main():
if len(sys.argv) < 3:
print("Usage: %s <font.dmd> <text>"%(sys.argv[0]))
return
font = dmd.Font(sys.argv[1])
if not font:
print("Error loading font")
return
text = sys.argv[2]
text_layer = dmd.TextLayer(0, 0, font)
text_layer.set_text(text)
proc = pinproc.PinPROC('wpc')
w = 128
h = 32
proc.reset(1)
grouped_layer = dmd.GroupedLayer(w, h, [dmd.FrameLayer(frame=dmd.Frame(w, h)), text_layer])
frame = grouped_layer.next_frame()
if frame == None:
print("No frame?")
return
for x in range(3): # Send it enough times to get it to show
proc.dmd_draw(frame)
def connect(self):
"""Connect to the P-ROC.
Keep trying if it doesn't work the first time.
"""
self.log.info("Connecting to P-ROC")
while not self.proc:
try:
self.proc = pinproc.PinPROC(self.machine_type)
self.proc.reset(1)
except IOError: # pragma: no cover
print("Retrying...")
time.sleep(1)
version_revision = self.proc.read_data(0x00, 0x01)
self.revision = version_revision & 0xFFFF
self.version = (version_revision & 0xFFFF0000) >> 16
dipswitches = self.proc.read_data(0x00, 0x03)
self.hardware_version = (dipswitches & 0xF00) >> 8
self.log.info(
"Successfully connected to P-ROC/P3-ROC. Firmware Version: %s. Firmware Revision: %s. "
"Hardware Board ID: %s", self.version, self.revision,
self.hardware_version)
def connect(self):
"""Connect to the P-ROC.
Keep trying if it doesn't work the first time.
"""
self.log.info("Connecting to P-ROC")
while not self.proc:
try:
self.proc = pinproc.PinPROC(self.machine_type)
self.proc.reset(1)
except IOError: # pragma: no cover
print("Retrying...")
time.sleep(1)
version_revision = self.proc.read_data(0x00, 0x01)
self.revision = version_revision & 0xFFFF
self.version = (version_revision & 0xFFFF0000) >> 16
self.machine.create_machine_var("p_roc_version", self.version, persist=False, silent=True)
'''machine_var: p_roc_version
desc: Holds the version number of the P-ROC or P3-ROC controller that's
attached to MPF.
'''
self.machine.create_machine_var("p_roc_revision", self.revision, persist=False, silent=True)
'''machine_var: p_roc_revision
desc: Holds the revision number of the P-ROC or P3-ROC controller
that's attached to MPF.
'''
self.log.info("Successfully connected to P-ROC/P3-ROC. Revision: %s. Version: %s", self.revision, self.version)
def connect(self):
"""Connect to the P-ROC.
Keep trying if it doesn't work the first time.
"""
self.log.info("Connecting to P-ROC")
while not self.proc:
try:
self.proc = pinproc.PinPROC(self.machine_type)
self.proc.reset(1)
except IOError: # pragma: no cover
print("Retrying...")
time.sleep(1)
version_revision = self.proc.read_data(0x00, 0x01)
self.revision = version_revision & 0xFFFF
self.version = (version_revision & 0xFFFF0000) >> 16
dipswitches = self.proc.read_data(0x00, 0x03)
self.hardware_version = (dipswitches & 0xF00) >> 8
self.dipswitches = ~dipswitches & 0x3F
self.log.info(
"Successfully connected to P-ROC/P3-ROC. Firmware Version: %s. Firmware Revision: %s. "
"Hardware Board ID: %s", self.version, self.revision,
self.hardware_version)
# for unknown reasons we have to postpone this a bit after init
self.machine.delay.add(100, self._configure_pd_led)
def start_pinproc(self, machine_type, loop):
"""Initialise libpinproc."""
self.loop = loop
self.stop_future = asyncio.Future(loop=self.loop)
while not self.proc:
try:
self.proc = pinproc.PinPROC(machine_type)
self.proc.reset(1)
except IOError: # pragma: no cover
print("Retrying...")
time.sleep(1)
def start_proc_process(self, machine_type, loop):
"""Run the pinproc communication."""
self.loop = loop
while not self.proc:
try:
self.proc = pinproc.PinPROC(machine_type)
self.proc.reset(1)
except IOError: # pragma: no cover
print("Retrying...")
time.sleep(1)
self.stop_future = asyncio.Future(loop=self.loop)
loop.run_until_complete(self.stop_future)
loop.close()
def connect(self):
"""Connect to the P-ROC.
Keep trying if it doesn't work the first time.
"""
self.log.info("Connecting to P-ROC")
while not self.proc:
try:
self.proc = pinproc.PinPROC(self.machine_type)
self.proc.reset(1)
except IOError: # pragma: no cover
print("Retrying...")
time.sleep(1)
self.log.info("Successfully connected to P-ROC/P3-ROC")
def main():
pr = pinproc.PinPROC(machine_type)
time.sleep(2) # Give P-ROC a second to get going?
import pygame
try:
pygame.init()
screen = pygame.display.set_mode((128, 32))
pygame.display.set_caption('P-ROC DMD')
background = pygame.Surface(screen.get_size())
background = background.convert()
fontSize = 14
x = 200.0
while 1:
background.fill((0, 0, 0))
if pygame.font:
font = pygame.font.Font(None, fontSize*3)
text = font.render("This is P-ROC", 1, (150, 150, 150))
textpos = text.get_rect(center=(x, background.get_height()/2))#(centerx=background.get_width()/2)
background.blit(text, textpos)
font = pygame.font.Font(None, fontSize)
text = font.render("This is P-ROC", 1, (255, 255, 255))
textpos = text.get_rect(center=(math.cos(time.clock()*5.0)*10.0+background.get_width()/2, math.sin(time.clock()*5.0)*5.0+background.get_height()*0.3))
background.blit(text, textpos)
font = pygame.font.Font(None, fontSize*1.5)
text = font.render("pypinproc", 1, (255, 255, 255))
textpos = text.get_rect(center=(background.get_width()*0.5, background.get_height()*0.75))
background.blit(text, textpos)
screen.blit(background, (0,0))
pygame.display.flip()
surface = pygame.display.get_surface()
buffer = surface.get_buffer()
pr.dmd_draw(buffer.raw)
del buffer
del surface
x -= 1
if x < -200.0:
x = 200.0
time.sleep(1/40)
finally: #except KeyboardInterrupt:
del pr
# This script is intended to be run:
#
# python -i pypinproctest.py
#
import pinproc
import yaml
machine_type = pinproc.MachineTypeWPC
pr = pinproc.PinPROC(machine_type)
pr.reset(1)
def pulse(n, t=20):
"""docstring for pulse"""
pr.driver_pulse(pinproc.decode(machine_type, str(n)), t)
del pr
def __init__(self):
"""Initialize platform."""
self.proc = pinproc.PinPROC(pinproc.normalize_machine_type('pdb'))
self.proc.reset(1)
# reset all drivers to off
for i in range(0, 255):
state = {'driverNum': i,
'outputDriveTime': 0,
'polarity': True,
'state': False,
'waitForFirstTimeSlot': False,
'timeslots': 0,
'patterOnTime': 0,
'patterOffTime': 0,
'patterEnable': False,
'futureEnable': False}
self.proc.driver_update_state(state)
# some magic stuff we don't understand but it has to be this way
for group_ctr in range(0, 4):
self.proc.driver_update_group_config(
group_ctr,
0,
group_ctr,
0,
0,
False,
True,
True,
True)
# enable banks for boards 0-7
for bank_num in range(0, 16):
self.proc.driver_update_group_config(
bank_num + 4,
0,
bank_num,
0,
0,
False,
True,
True,
True)
self.proc.driver_update_global_config(
False,
True, # Polarity
False, # N/A
False, # N/A
1, # N/A
0,
0,
False, # Active low rows? No
False, # N/A
False, # Stern? No
False, # Reset watchdog trigger
True, # Enable watchdog
1000)
self.proc.driver_update_global_config(
True,
True, # Polarity
False, # N/A
False, # N/A
1, # N/A
0,
0,
False, # Active low rows? No
False, # N/A
False, # Stern? No
False, # Reset watchdog trigger
True, # Enable watchdog
1000)
self.callbacks = {} # type: Dict[str:callable]
import pinproc
proc = pinproc.PinPROC(pinproc.normalize_machine_type('pdb'))
for switch, state in enumerate(proc.switch_get_states()):
if not switch % 16:
print('')
print('SW-16 Board Address {0}'.format(switch / 16))
print('Switch {0} State {1}'.format(switch, state))
import time
import pinproc
proc = pinproc.PinPROC(1)
proc.reset(1)
for x in range(255):
proc.switch_update_rule(x, 'closed_nondebounced',
{'notifyHost': True, 'reloadActive': False}, [],
False)
proc.switch_update_rule(x, 'open_nondebounced',
{'notifyHost': True, 'reloadActive': False}, [],
False)
while True:
for event in proc.get_events():
print(event)
event_type = event['type']
event_value = event['value']
if event_type == pinproc.EventTypeSwitchClosedDebounced:
print('+{}'.format(event_value))
elif event_type == pinproc.EventTypeSwitchOpenDebounced:
print('-{}'.format(event_value))
proc.watchdog_tickle()
proc.flush()
time.sleep(.01)
