Initial commit
This commit is contained in:
Noah
248
ledmatrix.py
Executable file
248
ledmatrix.py
Executable file
@@ -0,0 +1,248 @@
|
||||
# This file implements high-level routines for using a LED matrix as a display.
|
||||
#
|
||||
# While this code is primarily designed to be running on the host computer,
|
||||
# MCUs running MicroPython will run this code as well to provide automatic
|
||||
# rendering of the current time while the host computer is offline.
|
||||
#
|
||||
# The constructor needs to be called with a HAL (Hardware Abstraction Layer)
|
||||
# driver which provides low-level access to the display. The HAL can be
|
||||
# e.g. a driver that implements a serial protocol running on an MCU.
|
||||
#
|
||||
import time
|
||||
if not hasattr(time, 'ticks_ms'):
|
||||
# Emulate https://docs.pycom.io/firmwareapi/micropython/utime.html
|
||||
time.ticks_ms = lambda: int(time.time()*1000)
|
||||
|
||||
class LedMatrix:
|
||||
rotation = 180
|
||||
# Reduce brightness by scaling down colors
|
||||
brightness_scaler = 32
|
||||
rows = 0
|
||||
columns = 0
|
||||
driver = None
|
||||
fb = []
|
||||
|
||||
def __init__(self, driver, columns = 8, rows = 8, rotation = 0):
|
||||
self.driver = driver
|
||||
self.columns = columns
|
||||
self.rows = rows
|
||||
self.num_pixels = rows * columns
|
||||
self.num_modified_pixels = self.num_pixels # optimization: avoid rendering too many pixels
|
||||
assert rows == 8, "Calculations in xy_to_phys expect 8 rows"
|
||||
self.rotation = (360 + rotation) % 360
|
||||
# This is laid out in physical order
|
||||
self.fb.append(bytearray(self.num_pixels*3))
|
||||
self.fb.append(bytearray(self.num_pixels*3))
|
||||
self.fb_index = 0
|
||||
# Optimize clear
|
||||
self.fb.append(bytearray(self.num_pixels*3))
|
||||
for i in range(len(self.fb[0])):
|
||||
self.fb[0][i] = 1
|
||||
# Initialize display
|
||||
self.driver.init_display(self.num_pixels)
|
||||
|
||||
def xy_to_phys(self, x, y):
|
||||
"""
|
||||
Map x,y to physical LED address after accounting for display rotation
|
||||
"""
|
||||
if self.rotation < 90:
|
||||
pass
|
||||
elif self.rotation < 180:
|
||||
tmp = x
|
||||
x = self.rows-1-y
|
||||
y = tmp
|
||||
elif self.rotation < 270:
|
||||
x = self.columns-1-x
|
||||
y = self.rows-1-y
|
||||
else:
|
||||
tmp = x
|
||||
x = y
|
||||
y = self.columns-1-tmp
|
||||
# The LEDs are laid out in a long string going from north to south,
|
||||
# one step to the east, and then south to north, before the cycle
|
||||
# starts over.
|
||||
#
|
||||
# Here we calculate the physical offset for the desired rotation, with
|
||||
# the assumption that the first LED is at (0,0).
|
||||
# We'll need this adjusting for the north-south-south-north layout
|
||||
cycle = self.rows << 1 # optimization: twice the number of rows
|
||||
# First we determine which "block" (of a complete cyle) the pixel is in
|
||||
nssn_block = x >> 1 # optimization: divide by two
|
||||
phys_addr = nssn_block << 4 # optimization: Multiply by cycle
|
||||
# Second we determine if the column has decreasing or increasing addrs
|
||||
is_decreasing = x & 1
|
||||
if is_decreasing:
|
||||
phys_addr += cycle - 1 - y
|
||||
else:
|
||||
phys_addr += y
|
||||
return phys_addr
|
||||
|
||||
def phys_to_xy(self, phys_addr):
|
||||
"""
|
||||
Map physical LED address to x,y after accounting for display rotation
|
||||
"""
|
||||
x = phys_addr >> 3 # optimization: divide by number of rows
|
||||
cycle = self.rows << 1 # optimization: twice the number of rows
|
||||
y = phys_addr & (cycle-1) # optimization: modulo the cycle
|
||||
if y >= self.rows:
|
||||
y = cycle - 1 - y
|
||||
if self.rotation < 90:
|
||||
pass
|
||||
elif self.rotation < 180:
|
||||
tmp = x
|
||||
x = self.rows-1-y
|
||||
y = tmp
|
||||
elif self.rotation < 270:
|
||||
x = self.columns-1-x
|
||||
y = self.rows-1-y
|
||||
else:
|
||||
tmp = x
|
||||
x = y
|
||||
y = self.columns-1-tmp
|
||||
return [x, y]
|
||||
|
||||
def get_pixel(self, x, y):
|
||||
"""
|
||||
Get pixel from the currently displayed frame buffer
|
||||
"""
|
||||
pixel = self.xy_to_phys(x, y)
|
||||
back_index = (self.fb_index+1)%2
|
||||
offset = pixel*3
|
||||
return [self.fb[back_index][offset+0], self.fb[back_index][offset+1], self.fb[back_index][offset+2]]
|
||||
|
||||
def get_pixel_front(self, x, y):
|
||||
"""
|
||||
Get pixel from the to-be-displayed frame buffer
|
||||
"""
|
||||
pixel = self.xy_to_phys(x, y)
|
||||
back_index = (self.fb_index)%2
|
||||
offset = pixel*3
|
||||
return [self.fb[back_index][offset+0], self.fb[back_index][offset+1], self.fb[back_index][offset+2]]
|
||||
|
||||
def put_pixel(self, x, y, r, g, b):
|
||||
"""
|
||||
Set pixel ni the to-be-displayed frame buffer"
|
||||
"""
|
||||
if x >= self.columns or y >= self.rows:
|
||||
return
|
||||
pixel = self.xy_to_phys(x, y)
|
||||
offset = pixel*3
|
||||
self.fb[self.fb_index][offset+0] = int(r)
|
||||
self.fb[self.fb_index][offset+1] = int(g)
|
||||
self.fb[self.fb_index][offset+2] = int(b)
|
||||
# Optimization: keep track of last updated pixel
|
||||
if pixel >= self.num_modified_pixels:
|
||||
self.num_modified_pixels = pixel+1
|
||||
|
||||
def clear(self):
|
||||
"""
|
||||
Clear the frame buffer by setting all pixels to black
|
||||
"""
|
||||
self.fb_index ^= 1
|
||||
self.fb[self.fb_index][:] = self.fb[2][:]
|
||||
# Optimization: keep track of last updated pixel
|
||||
self.num_modified_pixels = self.num_pixels
|
||||
|
||||
def render(self):
|
||||
"""
|
||||
Render the to-be-displayed frame buffer by making put_pixel() and
|
||||
render() calls down to the HAL driver.
|
||||
"""
|
||||
# This takes 11ms
|
||||
tX = t0 = time.ticks_ms()
|
||||
front = self.fb[self.fb_index]
|
||||
back = self.fb[self.fb_index ^ 1]
|
||||
num_rendered = 0
|
||||
for pixel in range(self.num_modified_pixels):
|
||||
# This crap saves about 4ms
|
||||
i = pixel*3
|
||||
j = i+1
|
||||
k = j+1
|
||||
r = front[i]
|
||||
g = front[j]
|
||||
b = front[k]
|
||||
if r != back[i] or g != back[j] or b != back[k]:
|
||||
self.driver.put_pixel(pixel, r // self.brightness_scaler, g // self.brightness_scaler, b // self.brightness_scaler)
|
||||
num_rendered += 1
|
||||
t0 = time.ticks_ms() - t0
|
||||
|
||||
# This takes 52ms
|
||||
t1 = time.ticks_ms()
|
||||
self.driver.update_display(self.num_modified_pixels)
|
||||
t1 = time.ticks_ms() - t1
|
||||
#time.sleep(0.00004 * self.columns * self.rows)
|
||||
#time.sleep_ms(10)
|
||||
|
||||
# This takes 0ms
|
||||
self.fb_index ^= 1
|
||||
self.fb[self.fb_index][:] = self.fb[self.fb_index^1]
|
||||
print('LedMatrix render: {} pixels updated in {}ms, spent {}ms in driver update call, total {}ms'.format(num_rendered, t0, t1, time.ticks_ms() - tX))
|
||||
|
||||
# Optimization: keep track of last updated pixel
|
||||
self.num_modified_pixels = 0
|
||||
|
||||
def scrollout(self):
|
||||
"""
|
||||
Scene transition effect: scroll away pixels
|
||||
"""
|
||||
for i in range(self.rows):
|
||||
for x in range(self.columns):
|
||||
self.put_pixel(x, i, 0, 0, 0)
|
||||
for y in range(self.rows-1):
|
||||
for x in range(self.columns):
|
||||
colors = self.get_pixel(x, y)
|
||||
self.put_pixel(x, y+1, colors[0], colors[1], colors[2])
|
||||
self.render()
|
||||
#time.sleep(0.05)
|
||||
return False
|
||||
|
||||
def fade(self):
|
||||
"""
|
||||
Scene transition effect: fade out active pixels
|
||||
"""
|
||||
while True:
|
||||
light = 0
|
||||
for i in range(self.num_pixels):
|
||||
colors = self.get_pixel(i % self.columns, i // self.columns)
|
||||
colors[0] = colors[0] >> 2
|
||||
colors[1] = colors[1] >> 2
|
||||
colors[2] = colors[2] >> 2
|
||||
light |= colors[0]+colors[1]+colors[2]
|
||||
self.put_pixel(i % self.columns, i // self.columns, colors[0], colors[1], colors[2])
|
||||
self.render()
|
||||
time.sleep(0.1)
|
||||
if not light:
|
||||
# Everything has faded out
|
||||
return False
|
||||
|
||||
def dissolve(self):
|
||||
"""
|
||||
Scene transition effect: dissolve active pixels with LFSR
|
||||
"""
|
||||
active_pixels = 0
|
||||
for i in range(self.columns*self.rows):
|
||||
colors = self.get_pixel(i % self.columns, i // self.columns)
|
||||
if colors[0] or colors[1] or colors[2]:
|
||||
active_pixels += 1
|
||||
if not active_pixels:
|
||||
# No more pixels to dissolve
|
||||
return False
|
||||
per_pixel_sleep = (0.1-0.00003*self.num_pixels)/active_pixels
|
||||
|
||||
pixel = 1
|
||||
for i in range(256):
|
||||
bit = pixel & 1
|
||||
pixel >>= 1
|
||||
if bit:
|
||||
pixel ^= 0xb4
|
||||
|
||||
if pixel >= self.columns*self.rows:
|
||||
continue
|
||||
colors = self.get_pixel(pixel % self.columns, pixel // self.columns)
|
||||
if not colors[0] and not colors[1] and not colors[2]:
|
||||
continue
|
||||
self.put_pixel(pixel % self.columns, pixel // self.columns, 0, 0, 0)
|
||||
self.render()
|
||||
time.sleep(per_pixel_sleep)
|
||||
# There are still pixels to dissolve
|
||||
return True
|
||||
Reference in New Issue
Block a user