# ----

def __init__( self, seqname ):

self._sequence = []

self.name = seqname

# ----

def addFrame( self, spritesheet, imgname, duration_ms=100 ):

self._sequence.append( (spritesheet, imgname, duration_ms) )

# ----

def __getitem__( self, i ):

return( self._sequence[i] )

# ----

def getFrame( self, i ):

return( self._sequence[i] )

# ----

def getFrameCnt( self ):

return( len(self._sequence) )

# ----

def __str__( self ):

x1 = y1 = 0

x2 = y2 = 0

sizex = sizey = 0

name = ''

def __init__( self, name, x1, y1, sizex=16, sizey=16 ):

self.name = name

self.x1 = x1

self.y1 = y1

self.x2 = x1 + sizex

self.y2 = y1 + sizey

self.sizex = sizex

"SpriteSheet: Class to represent a sprite sheet image file."

filename = ''

offsetx = 0

offsety = 0

stepx = 0

stepy = 0

sizex = 16 # x size of the images within the sheet

sizey = 16 # y size of the images within the sheet

maxx = 0 # max x coord of the whole sheet

maxy = 0 # max y coord of the whole sheet

sprites = {}

# ----

def __init__( self, filename, stepx=16, stepy=16, offsetx=0, offsety=0, maxx=0, maxy=0 ):

self.filename = filename

self.stepx = stepx

self.stepy = stepy

self.offsetx = offsetx

self.offsety = offsety

# ----

def defineSprite( self, sprite_name, x1, y1, sizex=16, sizey=16 ):

if( sprite_name == '' ):

pass # do nothing when called with empty sprite_name

elif( self.sprites.has_key(sprite_name) == 0 ):

s = Sprite( sprite_name, x1, y1, sizex, sizey )

self.sprites[sprite_name] = s

else:

print "Sprite", sprite_name, " was already added with defineSprite()."

raise Exception()

# ----

def getSprite( self, sprite_name ):

if( self.sprites.has_key(sprite_name) ):

return( self.sprites[sprite_name] )

else:

print "Sprite", sprite_name, " does not exist."

raise Exception()

"""Ledgrid class: Provides methods for displaying and animating sprites on

the 16x16 RGB Grid."""

clear_leds_at_end = True

prucode_file = "./pru_code/ledgriddrvr.bin"

# scaling factors to conserve power & correct color

RedBrightnessPct = 0.43

GrnBrightnessPct = 0.68

BluBrightnessPct = 0.73

# ----

def close( self ):

if( self.clear_leds_at_end ):

self.clear()

pypruss.exit()

# ----

def __init__( self ):

pypruss.modprobe() # This only has to be called once per boot

pypruss.init() # Init the PRU

pypruss.open(0) # Open PRU event 0 which is PRU0_ARM_INTERRUPT

pypruss.pruintc_init() # Init the interrupt controller

# ----

def _sendPixels( self, data ):

pypruss.pru_write_memory(0, 0, data) # Load the data in the PRU ram

pypruss.exec_program(0, self.prucode_file ) # Load firmware on PRU 0

pypruss.wait_for_event(0) # Wait for event 0 which is connected to PRU0_ARM_INTERRUPT

sleep( 0.003 ) # Allow pru to complete

pypruss.clear_event(0) # Clear the event

# ----

def clear( self ):

'Clear the ledgrid (write black to all pixels)'

empty_data = [256] + [0]*256 # 1st index is #_of_pixels, then 256 pixel values of 0 follow it

self._sendPixels( empty_data )

# ----

def sendImage( self ):

pass

# ----

def _reversebits( self, val ):

newval = int('{:08b}'.format(val)[::-1], 2)

return( newval )

# ----

def _tuple3_to_hex( self, tup3val ):

# Takes a tuple of 3 color values & formats it as a single 32bit integer with

# GRB (grn red blu) 8 bit intensity values.

red = int( tup3val[0] * self.RedBrightnessPct )

grn = int( tup3val[1] * self.GrnBrightnessPct )

blu = int( tup3val[2] * self.BluBrightnessPct )

red = self._reversebits( red )

grn = self._reversebits( grn )

blu = self._reversebits( blu )

val = (blu << 16) + (red << 8) + (grn)

return( val )

# ----

def _get_img_array( self, image ):

if image.mode != 'RGB':

image = image.convert( 'RGB' ) # change to RGB if you don't care about alpha

pixels = image.load( )

data = []

width, height = image.size

#print "Image size: (%d, %d)." % (width, height)

for idx in xrange( 0, (height * width) + 2 ):

data.append( 0 )

idx = 0

data[idx] = height * width # First index contains Number of Pixels

idx += 1

for h in range( 0, height ):

if( h % 2 == 0 ):

for w in range( 0, width ):

color = pixels[w,h]

data[idx] = self._tuple3_to_hex( color )

idx += 1

else:

for w in range( width-1, -1, -1 ):

color = pixels[w,h]

data[idx] = self._tuple3_to_hex( color )

idx += 1

return( data )

# ----

def showSequence( self, seq, printinfo=True ):

if printinfo:

print "showSequence( %s ):" % (seq)

for i in range( seq.getFrameCnt() ):

(ss, imgname, duration_ms) = seq[i] # ss is the spritesheet object handle

s = ss.sprites[imgname] # s is the sprite object handle

if printinfo:

print "i=%d : ss.filename=%s, " % (i, ss.filename),

print "imgname=%s, duration_ms=%d, x1=%d, y1=%d, x2=%d, y2=%d, sizex=%d, sizey=%d" % (imgname, duration_ms, s.x1, s.y1, s.x2, s.y2, s.sizex, s.sizey)

sheet = Image.open( ss.filename )

#print 'Sheet info: format=%s, size=%s, mode=%s' % (sheet.format, sheet.size, sheet.mode)

box = (s.x1, s.y1, s.x2, s.y2)

region = sheet.crop( box )

ni = Image.new('RGB', (s.sizex, s.sizey) )

ni.paste( region, (0, 0, s.sizex, s.sizey) )

data = self._get_img_array( ni )

self._sendPixels( data )

sleep( 0.001 * duration_ms )

# ----

def showWideImage( self, im, duration_ms, printinfo=False ):

if printinfo:

print "showWideImage():"

sizex, sizey = im.size

if printinfo:

print "Image size: %d, %d" % (sizex, sizey)

for xoffset in range( sizex-16 ):

#print "%d / %d" % (xoffset, sizex-16-1)

crop_box = (xoffset, 0, xoffset+16, 16)

region = im.crop( crop_box )

ni = Image.new( 'RGB', (16, 16) )

ni.paste( region, (0, 0, 16, 16) )

data = self._get_img_array( ni )

self._sendPixels( data )

if( xoffset < sizex-16-1 ):

sleep( 0.001 * duration_ms )

else:

sleep( 0.020 ) # allow longer delay on last _sendPixels (linux seems to kill pru process & leave half drawn screen on the ledgrid otherwise)

# ----

def exploreSheet( self, ss ):

"""exploreSheet: Takes a reference to a SpriteSheet object, displays a 16x16 pixel window of the sheet and

the coordinates of the window. It takes keypresses to allow you to pan the window around to find images

within the sheet and determine the coordinates of each image. Keys:

k, j, h, l : move the window in stepsize increments: up, down, left, right.

x, X : decrease or increase (respectively) the x-axis stepsize

y, Y : decrease or increase (respectively) the y-axis stepsize

q : quit

"""

print "exploreSheet( %s ):" % (ss)

x1 = y1 = 0

sizex = ss.sizex

sizey = ss.sizey

x2 = sizex

y2 = sizey

stepx = ss.stepx

stepy = ss.stepy

maxx = ss.maxx

maxy = ss.maxy

key = ''

while key != 'q':

print "Position = (%d, %d). Stepsize = %d, %d" % (x1, y1, stepx, stepy)

if key == 'k' and (y1 > 0): # up

print "Up"

y1 -= stepy

#elif key == ord( 'j' ) and ((y1 < maxy) or (maxy == 0)): # down

elif key == 'j' and ((y1 < maxy) or (maxy == 0)): # down

print "Down"

y1 += stepy

elif key == 'h' and (x1 > 0): # left

print "Left"

x1 -= stepx

elif key == 'l' and ((x1 < maxx) or (maxx == 0)): # right

print "Right"

x1 += stepx

elif key == 'x':

print "Decrease StepX"

stepx -= 1

elif key == 'X':

print "Increase StepX"

stepx += 1

elif key == 'y':

print "Decrease StepY"

stepy -= 1

elif key == 'Y':

print "Increase StepY"

stepy += 1

x2 = x1 + sizex

y2 = y1 + sizey

box = (x1, y1, x2, y2)

sheet = Image.open( ss.filename )

if( maxx == 0 or maxy == 0 ):

maxx, maxy = sheet.size

#print 'Sheet info: format=%s, size=%s, mode=%s' % (sheet.format, sheet.size, sheet.mode)

region = sheet.crop( box )

ni = Image.new( "RGB", (ss.sizex, ss.sizey) )

ni.paste( region, (0, 0, ss.sizex, ss.sizey) )

data = self._get_img_array( ni )

self._sendPixels( data )

while True:

print "waiting for key"

key = sys.stdin.read(1)

key = key.rstrip()

if key != ord( '\n' ) and key != ord( '\r' ):

print "Pressed key '%s'" % (key)