def imageDraw():
# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 32
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'regular' # If you have an Adafruit HAT: 'adafruit-hat'
matrix = RGBMatrix(options = options)
# RGB example w/graphics prims.
# Note, only "RGB" mode is supported currently.
image = Image.new("RGB", (32, 32)) # Can be larger than matrix if wanted!!
draw = ImageDraw.Draw(image) # Declare Draw instance before prims
# Draw some shapes into image (no immediate effect on matrix)...
draw.rectangle((0, 0, 31, 31), fill=(0, 0, 0), outline=(0, 0, 255))
draw.line((0, 0, 31, 31), fill=(255, 0, 0))
draw.line((0, 31, 31, 0), fill=(0, 255, 0))
# Then scroll image across matrix...
for n in range(-32, 33): # Start off top-left, move off bottom-right
matrix.Clear()
matrix.SetImage(image, n, n)
time.sleep(0.05)
matrix.Clear()
def display(image, timeLeft):
# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 32
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'adafruit-hat' # If you have an Adafruit HAT: 'adafruit-hat'
matrix = RGBMatrix(options=options)
# Make image fit our screen.
image.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
for n in range(-32, 0): # Start off top-left, move off bottom-right
matrix.SetImage(image.convert('RGB'), n, 0)
time.sleep(0.10)
matrix.Clear()
matrix.SetImage(image.convert('RGB'))
time.sleep(10)
for n in range(0, 33): # Start off top-left, move off bottom-right
matrix.SetImage(image.convert('RGB'), n, 0)
time.sleep(0.15)
matrix.Clear()
class guerillaDisplay(object):
def __init__(self):
self.options = RGBMatrixOptions()
self.options.rows = 16
self.options.pwm_bits = 6
self.options.pwm_lsb_nanoseconds = 300
self.options.chain_length = 1
self.options.parallel = 1
self.options.hardware_mapping = 'regular' # If you have an Adafruit HAT: 'adafruit-hat'
self.font = graphics.Font()
self.font.LoadFont("rpi-rgb-led-matrix/fonts/5x8.bdf")
self.textColor = graphics.Color(255, 0, 0)
def initiate(self):
self.matrix = RGBMatrix(options=self.options)
self.offscreen_canvas = self.matrix.CreateFrameCanvas()
def set(self, m):
self.msg = m
def cellOn(self, x, y, r, g, b):
self.r = int(r)
self.g = int(g)
self.b = int(b)
self.matrix.SetPixel(x, y, self.r, self.g, self.b)
def cellOff(self, x, y):
self.matrix.SetPixel(x, y, 0, 0, 0)
def clear(self):
self.matrix.Clear()
def image_show_API(image_file,stop):
image = Image.open(image_file)
# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 32
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'adafruit-hat' # If you have an Adafruit HAT: 'adafruit-hat'
matrix = RGBMatrix(options = options)
matrix.Clear()
# Make image fit our screen.
image.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
matrix.SetImage(image.convert('RGB'))
try:
while True:
pass
if stop():
break
except KeyboardInterrupt:
sys.exit(0)
class MatrixBase:
def __init__(self, rows, cols, refresh_rate=20):
self.rows = rows
self.cols = cols
self.refresh_rate = refresh_rate
options = RGBMatrixOptions()
options.rows = rows
options.cols = cols
options.hardware_mapping = 'adafruit-hat'
self.options = options
self.matrix = RGBMatrix(options=options)
self.font = create_font()
self.widths = widths(
self.font,
'$!@#%^*()[]0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-=+_. '
)
self.frame = self.matrix.CreateFrameCanvas()
def flush(self):
self.frame = self.matrix.SwapOnVSync(self.frame)
def clear(self):
self.frame.Clear()
def stop(self):
self.matrix.Clear()
class RpiRgbDmdDevice(DmdPlatformInterface):
"""A RpiRgbDmd device."""
def __init__(self, config):
"""Initialise RpiRgbDmd device."""
self.config = config
xs = config["cols"]
ys = config["rows"]
self.img = Image.frombytes("RGB", (xs, ys), b'\x11' * xs * ys * 3)
self.rgbOpts = RGBMatrixOptions()
self.rgbOpts.drop_privileges = 1
# Rudeboy way of setting the RGBMatrixOptions
for k, v in config.items():
try:
setattr(self.rgbOpts, k, v)
except Exception:
print("RpiRgbDmdDevice: couldn't set", k, v)
self.matrix = RGBMatrix(options=self.rgbOpts)
self.matrix.SetImage(self.img)
def update(self, data):
"""Update DMD data."""
self.img.frombytes(data)
self.matrix.SetImage(self.img)
def set_brightness(self, brightness: float):
""" brightness [0.0 ... 1.0] """
self.matrix.brightness = brightness * 100
def stop(self):
self.matrix.Clear()
class RpiRgbDmdDevice(DmdPlatformInterface):
"""A RpiRgbDmd device."""
def __init__(self, config):
"""Initialise RpiRgbDmd device."""
self.config = config
xs = config["cols"]
ys = config["rows"]
self.img = Image.frombytes("RGB", (xs, ys), b'\x11' * xs * ys * 3)
self.rgb_opts = RGBMatrixOptions()
# Rudeboy way of setting the RGBMatrixOptions
for k, v in config.items():
try:
setattr(self.rgb_opts, k, v)
except Exception: # pylint: disable-msg=broad-except
raise AssertionError("RpiRgbDmdDevice: couldn't set", k, v)
self.matrix = RGBMatrix(options=self.rgb_opts)
self.matrix.SetImage(self.img)
def update(self, data):
"""Update DMD data."""
self.img.frombytes(data)
self.matrix.SetImage(self.img)
def set_brightness(self, brightness: float):
"""Set brightness.
Range is [0.0 ... 1.0].
"""
self.matrix.brightness = brightness * 100
def stop(self):
"""Stop device."""
self.matrix.Clear()
class EzMatrix(object):
"""Responsible for handling communication with matrix"""
def __init__(self, rows=32, cols=32, chain_length=1):
options = RGBMatrixOptions()
options.rows = rows
options.chain_length = chain_length
options.parallel = 1
options.hardware_mapping = 'adafruit-hat'
options.cols = cols
self.matrix = RGBMatrix(options=options)
def draw_canvas(self, canvas):
for y in range(len(canvas)):
for x in range(len(canvas[y])):
pixel = canvas[y][x]
self.matrix.SetPixel(x, y, pixel.r, pixel.g, pixel.b)
def run_anim(self, anim):
sleep = 0.07
for canvas in anim:
self.draw_canvas(canvas)
time.sleep(sleep)
self.matrix.Clear()
class controller(threading.Thread):
"""A Class to show a image to a LED matrix.
Attributes:
img: An image to show in the LED matrix.
stop_event: A flag to terminate the control loop.
update_event: A flag to update an image to show.
"""
def setRGBData(self, rgb_im):
"""Set Imge data to the LED matrix.
Args:
rgb_im: a PIL RGB image
"""
self.matrix.SetImage(rgb_im)
def __init__(self, rows, chain_length, brightness):
"""Initialize a LED matrix.
Args:
rows: The numberof matrix rows (usually 32 or 64).
chain_length: The number of daisy-chained panels.
brightness: LED brightness (0-100).
"""
# LED control options
options = RGBMatrixOptions()
options.rows = rows
options.chain_length = chain_length
options.parallel = 1
options.hardware_mapping = 'adafruit-hat'
options.brightness = brightness
self.matrix = RGBMatrix(options=options)
self.img = Image.new('RGB', (rows * chain_length, rows), (0, 0, 0))
self.stop_event = threading.Event()
self.update_event = threading.Event()
threading.Thread.__init__(self)
def run(self):
"""Run a control loop."""
while not self.stop_event.is_set():
self.update_event.wait(3)
if (self.update_event.is_set()):
self.update_event.clear()
self.setRGBData(self.img)
self.matrix.Clear()
class LedServiceMode:
MODE_NAME = None
BACKGROUND_POLL_TIME = None
def __init__(self):
self.matrix = None
self.setup()
self.last_bg_poll = None
def setup(self):
pass
def handle_command(self, cmd):
return True
def iterate(self):
pass
def activate(self):
'''Called when this mode is foregrounded.'''
self.matrix = RGBMatrix(options=options.matrix_options())
self.do_activate()
def deactivate(self):
'''Called when this mode is removed from the foreground.'''
self.do_deactivate()
self.matrix.Clear()
self.matrix = None
def do_activate(self):
pass
def do_deactivate(self):
pass
def background_poll(self):
if self.BACKGROUND_POLL_TIME is None:
return
now = time.time()
if (not self.last_bg_poll
or now - self.last_bg_poll >= self.BACKGROUND_POLL_TIME):
self.last_bg_poll = now
self.background_job()
def background_job(self):
pass
class DriverRgbMatrix(DriverBase):
def __init__(self, clear_screen=True):
options = RGBMatrixOptions()
options.rows = Config.get_or_throw('leds.display_height')
options.cols = Config.get_or_throw('leds.display_width')
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'adafruit-hat'
options.drop_privileges = False
self.__matrix = RGBMatrix(options=options)
self.__pixels = self.__matrix.CreateFrameCanvas()
if clear_screen:
self.clear_screen()
def display_frame(self, frame):
img = Image.fromarray(frame, mode='RGB')
self.__pixels.SetImage(img)
self.__pixels = self.__matrix.SwapOnVSync(self.__pixels)
def clear_screen(self):
self.__pixels.Clear()
self.__matrix.Clear()
# For some drivers, only one instance of the driver can exist at a time because all of them
# would send competing signals to the LEDs. The screensaver, video playback, etc processes
# that the Queue launches might have their own instance of the driver as well as the
# Queue process itself, which could cause problems.
#
# Thus, for some drivers (like the RGB Matrix driver), when the Queue needs to perform
# operations like clearing the screen, it creates a short lived instance to avoid the
# problems with multiple long lived driver instances. This approach does not work for other
# drivers (like the APA102 driver).
#
# See: https://github.com/hzeller/rpi-rgb-led-matrix/issues/640
# https://github.com/dasl-/pifi/pull/32
# https://github.com/dasl-/pifi/issues/33
def can_multiple_driver_instances_coexist(self):
return False
class LedMatrixRGB(object):
""" Gives interface for the 3D.
"""
def __init__(self, nx=None, ny=None, color=None, power=0):
self.matrix_opts = RGBMatrixOptions()
self.set_power(0)
self.nx = nx
self.ny = ny
self.set_options()
def set_options(self):
self.matrix_opts.rows = 32
self.matrix_opts.chain_length = 1
# self.matrix_opts.parallel = 1
self.matrix_opts.pwm_bits = 4
self.matrix_opts.pwm_lsb_nanoseconds = 900
self.matrix_opts.drop_privileges = True
self.matrix_opts.hardware_mapping = 'regular'
# self.matrix_opts.gpio_slowdown=1
self.matrix = RGBMatrix(options=self.matrix_opts)
def set_power(self, power):
""" Adjusts power manually between 0-255.
"""
print('doit')
def set_pixel(self, x, y, power, color):
self.matrix.Clear()
nx, ny, power = int(x), int(y), int(power)
if color == 'R':
self.matrix.SetPixel(nx, ny, power, 0, 0)
if color == 'G':
self.matrix.SetPixel(nx, ny, 0, power, 0)
if color == 'B':
self.matrix.SetPixel(nx, ny, 0, 0, power)
def __del__(self):
print('Goodbye')
draw_beat()
beat_count += 1
if beat_queue.full(
): # if history is full, then replace last element from queue, and perform beat detection
beat_ave = pop_freq(beat_ave, beat_queue)
beat_ave = push_freq(beat_ave, beat, beat_queue)
# compute variance of beat vs average
variance = 0.0
for elem in list(beat_queue.queue):
variance += abs(elem - beat_ave)
variance = variance / 43
c = 1.6 - (variance * 0.000003) # sensitivity factor
if beat >= beat_ave * c and beat_ave > beat_threshold:
# beat detected
draw_beat()
beat_count = 0
else:
beat_ave = push_freq(beat_ave, beat, beat_queue)
matrix.Clear() # erase the image currently on matrix
matrix.SetImage(image, 0, 0) # add new image to matrix
except KeyboardInterrupt:
matrix.Clear()
print('Program Exiting')
# close the stream gracefully
stream.stop_stream()
stream.close()
p.terminate()
def to_matrix(_minutes):
# matrix options set here
options = RGBMatrixOptions()
options.rows = 32
options.chain_length = 2
options.hardware_mapping = 'adafruit-hat'
options.parallel = 1
# orient_image arguments here
mat_x = options.chain_length * options.rows
mat_y = options.rows
char_w = 8
char_h = 13
num_chars = 8
lines= 1
O = orient_image(mat_x, mat_y, char_w ,char_h, num_chars,lines)
matrix = RGBMatrix(options = options)
image = Image.new("RGB", (64, 32))
draw = ImageDraw.Draw(image)
matrix.Clear()
# image files found in respective directories
png = PNG_8x13
# create the countdown timer here
# First for loop takes the initial list of lists and starts itering through
#print(T)
#timer_flag = True
while True:
T = test_timer(_minutes)
for i in T:
#print('here')
# Second for loop takes each individual list itme and iters through, printing to the matrix
#print(i)
# this updates later according to the offset
x_matrix_pos = O[0]
# with a single row of chars this wont change
y_matrix_pos = O[1]
# this is how far away the next char will print from the previous
x_matrix_offset = O[2]
#print(i)
minutes = (i[0],i[1])
seconds = (i[2],i[3])
hundreths = (i[4],i[5])
for i in minutes:
#sleep(.01)
#x_matrix_pos = x_matrix_offset
image = Image.open("%s" % png[int(minutes[0])])
image.load()
matrix.SetImage(image.convert('RGB'),x_matrix_pos, y_matrix_pos)
x_matrix_pos += x_matrix_offset
#print x_matrix_pos
image = Image.open("%s" % png[int(minutes[1])])
image.load()
matrix.SetImage(image.convert('RGB'),x_matrix_pos, y_matrix_pos)
#colon
x_matrix_pos += x_matrix_offset
image = Image.open("%s" % png[10])
image.load()
matrix.SetImage(image.convert('RGB'),x_matrix_pos, y_matrix_pos)
#for secs in seconds:
x_matrix_pos += x_matrix_offset
image = Image.open("%s" % png[int(seconds[0])])
image.load()
matrix.SetImage(image.convert('RGB'),x_matrix_pos, y_matrix_pos)
x_matrix_pos += x_matrix_offset
#image = Image.open("%s" % png[int(seconds[1])])
image = Image.open("%s" % png[int(seconds[1])])
image.load()
matrix.SetImage(image.convert('RGB'),x_matrix_pos, y_matrix_pos)
#period
x_matrix_pos += x_matrix_offset
image = Image.open("./8x13/period.png")
image.load()
matrix.SetImage(image.convert('RGB'),x_matrix_pos, y_matrix_pos)
#for hunds in hundreths:
x_matrix_pos += x_matrix_offset
image = Image.open("%s" % png[int(hundreths[0])])
image.load()
matrix.SetImage(image.convert('RGB'),x_matrix_pos, y_matrix_pos)
x_matrix_pos += x_matrix_offset
image = Image.open("%s" % png[int(hundreths[1])])
image.load()
matrix.SetImage(image.convert('RGB'),x_matrix_pos, y_matrix_pos)
#print(minutes[0],minutes[1],seconds[0],seconds[1],hundreths[0],hundreths[1])
sleep(.0001693405867)
#timer_flag == False
print(datetime.now())
while 1:
# last list item in timer
zero_status = T[-1]
x_matrix_pos = O[0]
y_matrix_pos = O[1]
x_matrix_offset = O[2]
for i in zero_status:
image = Image.open("%s" % png[i])
image.load()
matrix.SetImage(image.convert('RGB'),x_matrix_pos, y_matrix_pos)
x_matrix_pos += x_matrix_offset
def main(win):
# 32 Rows, 2 panel, 1 chain
MyMatrix = RGBMatrix(32, 2, 1)
# Bits used for PWM. Something between 1..11. Default: 11
MyMatrix.pwmBits = 11
# Sets brightness level. Default: 100. Range: 1..100"
MyMatrix.brightness = 100
# Buffer canvas.
MyOffsetCanvas = MyMatrix.CreateFrameCanvas()
# setup colours for border, paddles and ball
red = graphics.Color(255, 0, 0)
green = graphics.Color(0, 255, 0)
blue = graphics.Color(0, 0, 255)
white = graphics.Color(255, 255, 255)
black = graphics.Color(0, 0, 0)
grey = graphics.Color(128, 128, 128)
# set player1 paddle start
p1x = 2
p1y = 12
# set player2 paddle start
p2x = 61
p2y = 12
# set the ball start
ballx = 32
bally = 16
# Set the ball movement
xballmovement = +1
yballmovement = -1
# start the main loop
going = True
win.nodelay(True) # make getkey() not wait
while going:
try:
key = win.getkey()
except: # in no delay mode getkey raise and exeption if no key is press
key = None
#endtry
if key == "x":
going = False
break
#endif
# player1 paddle down
if key == "q":
p1y = p1y - 1
#endif
# player1 paddle down
if key == "a":
p1y = p1y + 1
#endif
# player2 paddle up
if key == "p":
p2y = p2y - 1
#endif
# player2 paddle down
if key == "l":
p2y = p2y + 1
#endif
ballx = ballx + xballmovement
bally = bally + yballmovement
p1y = bally - 4
p2y = bally - 4
MyMatrix.Clear()
# draw the border
graphics.DrawLine(MyOffsetCanvas, 0, 0, 63, 0, white)
graphics.DrawLine(MyOffsetCanvas, 0, 0, 0, 31, white)
graphics.DrawLine(MyOffsetCanvas, 63, 0, 63, 31, white)
graphics.DrawLine(MyOffsetCanvas, 0, 31, 63, 31, white)
# draw player1 paddle
graphics.DrawLine(MyOffsetCanvas, p1x, p1y, p1x, p1y + 8, red)
# draw player2 paddle
graphics.DrawLine(MyOffsetCanvas, p2x, p2y, p2x, p2y + 8, green)
# draw the ball
graphics.DrawCircle(MyOffsetCanvas, ballx, bally, 1, blue)
# Collision Detect
collision_type = fnDetectCollision(p1x, p1y, p2x, p2y, ballx, bally)
if collision_type == PADDLE1:
xballmovement = +1
#endif
if collision_type == PADDLE2:
xballmovement = -1
#endif
if collision_type == TOP:
yballmovement = +1
#endif
if collision_type == BOTTOM:
yballmovement = -1
#endif
if collision_type == LEFT_EDGE:
xballmovement = +1
#endif
if collision_type == RIGHT_EDGE:
xballmovement = -1
#endif
# flip on vsync
MyOffsetCanvas = MyMatrix.SwapOnVSync(MyOffsetCanvas)
# Wait a bit
time.sleep(0.005)
#endwhile
return
# get the interface name from the command line (will throw an exception if one is not given)
myifname = sys.argv[1]
# init the RGB matrix as 32 Rows, 2 panels (represents 32 x 64 panel), 1 chain
MyMatrix = RGBMatrix(32, 2, 1)
# Bits used for PWM. Something between 1..11. Default: 11
MyMatrix.pwmBits = 11
# Sets brightness level. Default: 100. Range: 1..100"
MyMatrix.brightness = 100
# Flood fill with white as a POST
MyMatrix.Fill(255, 255, 255)
time.sleep(2)
MyMatrix.Clear()
# Setup colours for text display
ColorRED = graphics.Color(255, 0, 0)
ColorGRN = graphics.Color(0, 255, 0)
ColorBLU = graphics.Color(0, 0, 255)
ColorWHI = graphics.Color(255, 255, 255)
# Create the buffer canvas
MyOffsetCanvas = MyMatrix.CreateFrameCanvas()
# Load up the font (use absolute paths so script can be invoked from /etc/rc.local correctly)
font = graphics.Font()
font.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/5x8.bdf")
# get the IP address of the interface specified on the command line (e.g. wlan0)
class AlarmClock(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
# Setup GPIO buttons
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(SENSOR, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(UP, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(DOWN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(SOUND, GPIO.IN, pull_up_down=GPIO.PUD_UP)
self.font_day = graphics.Font()
self.font_day.LoadFont(BASE_DIR + "fonts/4x6.bdf")
self.font_time = graphics.Font()
self.font_time.LoadFont(BASE_DIR + "fonts/5x8.bdf")
self.color_day = graphics.Color(255, 179, 0)
self.color_time = graphics.Color(154, 240, 0)
self.color_pixel = graphics.Color(0, 149, 67)
self.font_alarm = graphics.Font()
self.font_alarm.LoadFont(BASE_DIR + "fonts/7x13.bdf")
self.color_alarm = graphics.Color(234, 0, 52)
self.color_alarm_colon = graphics.Color(255, 130, 42)
self.player = Player()
self.alarm = Alarm(7, 30, self.player)
self.done = False
return
def set_pixel(self, x, y, color):
self.matrix.SetPixel(x, y, color[0], color[1], color[2])
return
def shutdown(self):
logger.info("AlarmClock is shutting down")
self.done = True
time.sleep(2)
pass
def setup(self):
logger.info("setting up the matrix: %s", getpass.getuser())
options = RGBMatrixOptions()
options.rows = 16
options.chain_length = 1
options.brightness = BRIGHTNESS
options.daemon = 0
options.drop_privileges = 0
self.matrix = RGBMatrix(options=options)
logger.info("matrix setup is done: %s", getpass.getuser())
return
def run(self):
self.setup()
logger.info("AlarmClock is running")
self.color_black = graphics.Color(0, 0, 0)
while not self.done:
# handle sound play
if GPIO.input(SOUND) == 0:
self.player.play(SOUND_FILE)
elif GPIO.input(SOUND) == 1:
self.player.stop()
pass
# handle buttons
self.matrix.Clear()
if GPIO.input(SENSOR) == 0:
if GPIO.input(UP) == 0:
self.alarm.change_up()
pass
if GPIO.input(DOWN) == 0:
self.alarm.change_down()
pass
alarm_hour = "%2d" % (self.alarm.hour)
alarm_minute = "%02d" % (self.alarm.minute)
self.alarm_dot(0, 12, alarm_hour, alarm_minute)
else:
local_time = time.localtime()
local_hour = "%2d" % (local_time.tm_hour)
local_minute = "%02d" % (local_time.tm_min)
local_sec = "%02d" % (local_time.tm_sec)
self.time_dot(0, 15, local_hour, local_minute, local_sec)
local_day = time.strftime("%a%d%b%y", local_time)
self.day_text(0, 6, local_day)
pass
time.sleep(1)
pass
GPIO.cleanup()
logger.info("GPIO cleanup is done")
self.player.shutdown()
return
def pixel(self, x, y, color):
self.matrix.SetPixel(x, y - 1, color.red, color.green, color.blue)
self.matrix.SetPixel(x - 1, y - 1, color.red, color.green, color.blue)
self.matrix.SetPixel(x, y - 2, color.red, color.green, color.blue)
self.matrix.SetPixel(x - 1, y - 2, color.red, color.green, color.blue)
return 1
def colon(self, x, y, color):
self.pixel(x, y, color)
self.pixel(x, y - 4, color)
return 1
def alarm_colon(self, x, y, color):
self.pixel(x, y - 1, color)
self.pixel(x, y - 6, color)
return 1
def time_dot(self, x, y, hour, minute, sec):
cx = x
l = graphics.DrawText(self.matrix, self.font_time, cx, y,
self.color_time, hour)
cx = cx + l
self.colon(cx, y, self.color_pixel)
cx = cx + 1
l = graphics.DrawText(self.matrix, self.font_time, cx, y,
self.color_time, minute)
cx = cx + l
self.pixel(cx, y, self.color_pixel)
cx = cx + 1
l = graphics.DrawText(self.matrix, self.font_time, cx, y,
self.color_time, sec)
return
def time_text(self, x, y, text):
graphics.DrawText(self.matrix, self.font_time, x, y, self.color_time,
text)
return
def day_text(self, x, y, text):
graphics.DrawText(self.matrix, self.font_day, x, y, self.color_day,
text)
return
def alarm_dot(self, x, y, hour, minute):
cx = x
l = graphics.DrawText(self.matrix, self.font_alarm, cx, y,
self.color_alarm, hour)
cx = cx + l
self.alarm_colon(cx, y, self.color_alarm_colon)
cx = cx + 1
#cx = cx + l - 2
#l = graphics.DrawText(self.matrix, self.font_alarm, cx, y-1, self.color_alarm_pixel, ":")
#cx = cx + l - 1
l = graphics.DrawText(self.matrix, self.font_alarm, cx, y,
self.color_alarm, minute)
return
class Game:
SWITCHES = None
BLOCK_SIZE = 16
COLUMNS = None
ROWS = None
SHAPES_NEXT_COUNT = None
FPS = None
COLORS = [
# 0 - Black
(0, 0, 0),
# 1 - Purple
(128, 0, 128),
# 2 - Green
(0, 255, 0),
# 3 - Red
(255, 0, 0),
# 4 - Blue
(0, 0, 255),
# 5 - Orange
(255, 165, 0),
# 6 - Cyan
(0, 255, 255),
# 7 - Yellow
(255, 255, 0),
# 8 - Dark Grey
(35, 35, 35),
# 9 - White
(255, 255, 255)
]
SHAPES = [
# T
[
[1, 1, 1],
[0, 1, 0],
],
# S
[
[0, 2, 2],
[2, 2, 0]
],
# Z
[
[3, 3, 0],
[0, 3, 3]
],
# J
[
[4, 0, 0],
[4, 4, 4]
],
# L
[
[0, 0, 5],
[5, 5, 5],
],
# I
[
[6, 6, 6, 6],
],
# O
[
[7, 7],
[7, 7],
]
]
WIDTH = None
HEIGHT = None
COUNTDOWN = None
SCORE_INCREMENTS = None
LINES = 0
SCORE = 0
LEVEL = 1
LEVEL_INCREMENT = None
INTERVAL = None
INTERVAL_INCREMENT = None
PAUSED = False
GAMEOVER = False
BACKGROUND_GRID = None
BACKGROUND_BOX = None
RGB_MATRIX_HARDWARE = None
RGB_MATRIX_ROWS = None
RGB_MATRIX_CHAIN_LENGTH = None
RGB_MATRIX_PARALLEL = None
RGB_MATRIX_PWM_BITS = None
RGB_MATRIX_BRIGHTNESS = None
RGB_MATRIX_LSB_NANOSECONDS = None
RGB_MATRIX_GPIO_SLOWDOWN = None
pygame = None
pygame_font = None
pygame_screen = None
pygame_clock = None
rgbmatrix = None
rgbmatrix_options = None
rgbmatrix_font = None
gpio = None
db = None
board = None
shape = None
shapes_next = None
def __init__(self, switches, columns, rows, shapes_next_count, fps, countdown, interval, score_increments, level_increment, interval_increment, rgb_matrix_hardware, rgb_matrix_rows, rgb_matrix_chain_length, rgb_matrix_parallel, rgb_matrix_pwm_bits, rgb_matrix_brightness, rgb_matrix_lsb_nanoseconds, rgb_matrix_gpio_slowdown, rgb_matrix_disable_hardware_pulsing, rgb_matrix_rgb_sequence, pygame_instance=None):
self.SWITCHES = switches
self.COLUMNS = columns
self.ROWS = rows
self.SHAPES_NEXT_COUNT = shapes_next_count
self.FPS = fps
self.COUNTDOWN = countdown
self.INTERVAL = interval
self.SCORE_INCREMENTS = score_increments
self.LEVEL_INCREMENT = level_increment
self.INTERVAL_INCREMENT = interval_increment
self.RGB_MATRIX_HARDWARE = rgb_matrix_hardware
self.RGB_MATRIX_ROWS = rgb_matrix_rows
self.RGB_MATRIX_CHAIN_LENGTH = rgb_matrix_chain_length
self.RGB_MATRIX_PARALLEL = rgb_matrix_parallel
self.RGB_MATRIX_PWM_BITS = rgb_matrix_pwm_bits
self.RGB_MATRIX_BRIGHTNESS = rgb_matrix_brightness
self.RGB_MATRIX_LSB_NANOSECONDS = rgb_matrix_lsb_nanoseconds
self.RGB_MATRIX_GPIO_SLOWDOWN = rgb_matrix_gpio_slowdown
self.RGB_MATRIX_DISABLE_HARDWARE_PULSING = rgb_matrix_disable_hardware_pulsing
self.RGB_MATRIX_RGB_SEQUENCE = rgb_matrix_rgb_sequence
self.gpio = Gpio
self.rgbmatrix_options = RgbMatrixOptions()
self.rgbmatrix_options.hardware_mapping = self.RGB_MATRIX_HARDWARE
self.rgbmatrix_options.rows = self.RGB_MATRIX_ROWS
self.rgbmatrix_options.chain_length = self.RGB_MATRIX_CHAIN_LENGTH
self.rgbmatrix_options.parallel = self.RGB_MATRIX_PARALLEL
self.rgbmatrix_options.pwm_bits = self.RGB_MATRIX_PWM_BITS
self.rgbmatrix_options.brightness = self.RGB_MATRIX_BRIGHTNESS
self.rgbmatrix_options.pwm_lsb_nanoseconds = self.RGB_MATRIX_LSB_NANOSECONDS
self.rgbmatrix_options.gpio_slowdown = self.RGB_MATRIX_GPIO_SLOWDOWN
self.rgbmatrix_options.disable_hardware_pulsing = self.RGB_MATRIX_DISABLE_HARDWARE_PULSING
self.rgbmatrix_options.led_rgb_sequence = self.RGB_MATRIX_RGB_SEQUENCE
if pygame_instance is None:
self.pygame = pygame
else:
self.pygame = pygame_instance
self.db = TinyDB('data/database.json')
try:
self.gpio.setmode(self.gpio.BCM)
for switch in self.SWITCHES.keys():
self.gpio.setup(switch, self.gpio.IN)
self.WIDTH = self.BLOCK_SIZE * (self.COLUMNS + 12)
self.HEIGHT = self.BLOCK_SIZE * (self.ROWS + 24)
self.BACKGROUND_GRID = [
[8 if x % 2 == y % 2 else 0 for x in xrange(self.COLUMNS)]
for y in xrange(self.ROWS)
]
self.BACKGROUND_BOX = [
[9 if (x == 0 or x == self.COLUMNS + 1 or y == 0 or y == self.ROWS + 1) else 0 for x in xrange(self.COLUMNS + 2)]
for y in xrange(self.ROWS + 2)
]
self.pygame.init()
self.pygame.key.set_repeat(150, 50)
self.pygame_font = self.pygame.font.Font(self.pygame.font.get_default_font(), 12)
self.pygame_screen = self.pygame.display.set_mode((self.WIDTH, self.HEIGHT), 0, 24)
self.pygame.display.set_caption('RGB Matrix Tetris')
self.pygame.event.set_blocked(self.pygame.MOUSEMOTION)
self.pygame.mouse.set_visible(0)
self.pygame_clock = self.pygame.time.Clock()
self.rgbmatrix = RgbMatrix(options=self.rgbmatrix_options)
self.rgbmatrix_graphics = Graphics
self.rgbmatrix_font = self.rgbmatrix_graphics.Font()
self.rgbmatrix_font.LoadFont('./rgbmatrixtetris/fonts/4x6.bdf')
self.board = Board(self.COLUMNS, self.ROWS)
self.__generate_shapes()
except AttributeError:
print("[Game][error] An error occurred initialising game")
def start(self, run_once=False):
print("[Game][info] Starting game")
try:
self.rgbmatrix.Clear()
self.pygame_screen.fill((0, 0, 0))
self.__display_message("Press\n\nenter\n\nto\n\nstart")
self.pygame.display.update()
pygame_wait = True
while pygame_wait:
try:
for event in self.pygame.event.get():
if event.type == self.pygame.KEYDOWN:
if event.key == self.pygame.K_RETURN:
pygame_wait = False
elif event.key == self.pygame.K_ESCAPE:
self.quit()
elif event.type == self.pygame.QUIT:
self.quit()
except KeyboardInterrupt:
self.quit()
except AttributeError:
print("[Game][error] An error occurred starting game")
self.__countdown()
self.__loop()
self.finish()
if run_once is not True:
self.start()
def __countdown(self):
print("[Game][info] Starting game countdown")
try:
start_ticks = self.pygame.time.get_ticks()
while True:
seconds = (self.pygame.time.get_ticks() - start_ticks) / 1000
self.rgbmatrix.Clear()
self.pygame_screen.fill((0, 0, 0))
remaining = (self.COUNTDOWN - seconds)
if seconds > self.COUNTDOWN:
break
if seconds == self.COUNTDOWN:
self.__display_message("Go!")
elif seconds == 0:
self.__display_message("Starting\n\nin %d!" % remaining)
else:
self.__display_message("%d!" % remaining)
self.pygame.display.update()
self.pygame.time.wait(1000)
except AttributeError:
print("[Game][error] An error occurred starting game countdown")
def __loop(self):
print("[Game][info] Starting game loop")
try:
self.pygame.time.set_timer(pygame.USEREVENT + 1, self.INTERVAL)
key_actions = {
'ESCAPE': lambda: self.quit(),
'LEFT': lambda: self.__move(-1),
'RIGHT': lambda: self.__move(+1),
'DOWN': lambda: self.__drop(True),
'UP': lambda: self.__rotate_shape(),
'p': lambda: self.toggle_pause(),
'RETURN': lambda: self.__instant_drop()
}
start_ticks = self.pygame.time.get_ticks()
while not self.GAMEOVER:
self.pygame_clock.tick(self.FPS)
rgbmatrix_canvas = self.rgbmatrix.CreateFrameCanvas()
self.pygame_screen.fill((0, 0, 0))
if self.PAUSED:
self.__display_message("Paused", None, self.COLORS[9], self.COLORS[0], None)
else:
self.__display_message("Next:", ((self.COLUMNS + 3), 1), self.COLORS[9], self.COLORS[0], None, False)
self.__display_message("Time: \n\n\n\n\nScore: \n\n\n\n\nLines: \n\n\n\n\nLevel:", (1, (self.ROWS + 3)), self.COLORS[9], self.COLORS[0], None, False)
self.__display_message("%s" % (str(datetime.timedelta(seconds=((self.pygame.time.get_ticks() - start_ticks) / 1000)))), (1, (self.ROWS + 8)), self.COLORS[3], self.COLORS[0], (60, './rgbmatrixtetris/fonts/4x6.bdf'), rgbmatrix_canvas)
self.__display_message("%d" % (self.SCORE), (1, (self.ROWS + 14)), self.COLORS[2], self.COLORS[0], (60, './rgbmatrixtetris/fonts/4x6.bdf'), rgbmatrix_canvas)
self.__display_message("%d" % (self.LINES), (1, (self.ROWS + 20)), self.COLORS[5], self.COLORS[0], (60, './rgbmatrixtetris/fonts/4x6.bdf'), rgbmatrix_canvas)
self.__display_message("%d" % (self.LEVEL), (1, (self.ROWS + 26)), self.COLORS[6], self.COLORS[0], (60, './rgbmatrixtetris/fonts/4x6.bdf'), rgbmatrix_canvas)
self.__draw_matrix(self.BACKGROUND_GRID, (1, 1), None, False)
self.__draw_matrix(self.board.coordinates(), (1, 1), None, rgbmatrix_canvas)
self.__draw_matrix(self.shape.coordinates(), self.shape.position((1, 1)), None, rgbmatrix_canvas)
self.__draw_matrix(self.BACKGROUND_BOX, (0, 0), None, rgbmatrix_canvas)
for i in range(0, (self.SHAPES_NEXT_COUNT - 1)):
self.__draw_matrix(self.shapes_next[i].coordinates(), ((self.COLUMNS + 3), (((i + 1) * 5) - 2)), None, rgbmatrix_canvas)
rgbmatrix_canvas = self.rgbmatrix.SwapOnVSync(rgbmatrix_canvas)
self.pygame.display.update()
try:
for event in self.pygame.event.get():
if event.type == self.pygame.USEREVENT + 1 and not self.PAUSED:
self.__drop(False)
elif event.type == self.pygame.QUIT:
self.quit()
elif event.type == self.pygame.KEYDOWN:
for key in key_actions:
if event.key == eval("self.pygame.K_" + key):
key_actions[key]()
except KeyboardInterrupt:
self.quit()
except AttributeError:
print("[Game][error] An error occurred during game loop")
def __button_press(self, channel):
print("[Game][info] Button pressed: %d" % channel)
event = self.pygame.event.Event(self.pygame.KEYDOWN, key=eval("self.pygame.K_" + self.SWITCHES[channel]), trigger='gpio')
self.pygame.event.post(event)
def __generate_shapes(self):
print("[Game][info] Generating next shapes")
self.shapes_next = [Shape(self.SHAPES[rand(len(self.SHAPES))]) for x in xrange(self.SHAPES_NEXT_COUNT)]
self.__next_shape()
def __next_shape(self):
print("[Game][info] Getting next shape")
self.shape = self.shapes_next.pop(0)
self.shapes_next.append(Shape(self.SHAPES[rand(len(self.SHAPES))]))
self.shape.set_x(int(self.COLUMNS / 2 - len(self.shape.coordinates()[0]) / 2))
self.shape.set_y(0)
if self.board.check_collision(self.shape, self.shape.position()):
self.GAMEOVER = True
def __display_message(self, message, coordinates=None, color=COLORS[9], background_color=COLORS[0], message_size=None, rgbmatrix=None):
print("[Game][info] Displaying message")
for i, line in enumerate(message.splitlines()):
pygame_message_font = self.pygame_font
rgbmatrix_message_font = self.rgbmatrix_font
if message_size is not None:
pygame_message_size, rgbmatrix_message_size = message_size
pygame_message_font = self.pygame.font.Font(self.pygame.font.get_default_font(), pygame_message_size)
rgbmatrix_message_font = self.rgbmatrix_graphics.Font()
rgbmatrix_message_font.LoadFont(rgbmatrix_message_size)
pygame_message_image = pygame_message_font.render(line, False, color, background_color)
if coordinates is not None:
pygame_position_x, pygame_position_y = coordinates
pygame_position_x = (pygame_position_x * self.BLOCK_SIZE)
pygame_position_y = (pygame_position_y * self.BLOCK_SIZE)
rgbmatrix_position_x, rgbmatrix_position_y = coordinates
else:
pygame_message_image_center_x, pygame_message_image_center_y = pygame_message_image.get_size()
pygame_message_image_center_x //= 2
pygame_message_image_center_y //= 2
pygame_position_x = (self.WIDTH // 2 - pygame_message_image_center_x)
pygame_position_y = (self.HEIGHT // 2 - pygame_message_image_center_y + i)
rgbmatrix_position_x = (self.WIDTH / self.BLOCK_SIZE - (4 * len(line))) // 2
rgbmatrix_position_y = (((self.HEIGHT / self.BLOCK_SIZE - rgbmatrix_message_font.height) // 2) + (i * 3))
if rgbmatrix is not False:
if rgbmatrix is None:
rgbmatrix = self.rgbmatrix
r, g, b = color
self.rgbmatrix_graphics.DrawText(rgbmatrix, rgbmatrix_message_font, rgbmatrix_position_x, rgbmatrix_position_y, self.rgbmatrix_graphics.Color(r, g, b), line)
self.pygame_screen.blit(
pygame_message_image,
(pygame_position_x, pygame_position_y)
)
def __draw_line(self, start_position, end_position, color=COLORS[9], rgbmatrix=True):
print("[Game][info] Drawing line")
if rgbmatrix:
r, g, b = color
start_x, start_y = start_position
end_x, end_y = end_position
self.rgbmatrix_graphics.DrawLine(self.rgbmatrix, start_x, start_y, end_x, end_y, self.rgbmatrix_graphics.Color(r, g, b))
self.pygame.draw.line(self.pygame_screen, color, start_position, end_position)
def __draw_matrix(self, matrix, offset, color=None, rgbmatrix=None):
print("[Game][info] Drawing matrix")
off_x, off_y = offset
for y, row in enumerate(matrix):
for x, val in enumerate(row):
if val:
if color is None:
shape_color = self.COLORS[val]
else:
shape_color = color
if rgbmatrix is not False:
if rgbmatrix is None:
rgbmatrix = self.rgbmatrix
r, g, b = shape_color
rgbmatrix.SetPixel((off_x + x), (off_y + y), r, g, b)
self.pygame.draw.rect(
self.pygame_screen,
shape_color,
self.pygame.Rect((off_x + x) * self.BLOCK_SIZE, (off_y + y) * self.BLOCK_SIZE, self.BLOCK_SIZE, self.BLOCK_SIZE),
0
)
def __count_clear_rows(self, rows):
print("[Game][info] Counting cleared rows")
self.LINES += rows
self.SCORE += self.SCORE_INCREMENTS[rows] * self.LEVEL
if self.LINES >= self.LEVEL * self.LEVEL_INCREMENT:
self.LEVEL += 1
delay = self.INTERVAL - self.INTERVAL_INCREMENT * (self.LEVEL - 1)
delay = 100 if delay < 100 else delay
self.pygame.time.set_timer(self.pygame.USEREVENT + 1, delay)
def __move(self, delta_x):
print("[Game][info] Moving shape")
if not self.GAMEOVER and not self.PAUSED:
new_x = self.shape.x() + delta_x
if new_x < 0:
new_x = 0
if new_x > self.COLUMNS - len(self.shape.coordinates()[0]):
new_x = self.COLUMNS - len(self.shape.coordinates()[0])
if not self.board.check_collision(self.shape, (new_x, self.shape.y())):
self.shape.set_x(new_x)
def __drop(self, manual):
print("[Game][info] Drop shape")
if not self.GAMEOVER and not self.PAUSED:
self.SCORE += 1 if manual else 0
self.shape.set_y(self.shape.y() + 1)
if self.board.check_collision(self.shape, self.shape.position()):
self.board.join_matrixes(self.shape, self.shape.position())
self.__next_shape()
cleared_rows = 0
while True:
for i, row in enumerate(self.board.coordinates()[:-1]):
if 0 not in row:
self.board.clear_row(i)
cleared_rows += 1
break
else:
break
self.__count_clear_rows(cleared_rows)
return True
return False
def __instant_drop(self):
print("[Game][info] Instant drop shape")
if not self.GAMEOVER and not self.PAUSED:
while not self.__drop(True):
pass
def __rotate_shape(self, direction='clockwise'):
print("[Game][info] Rotating shape %s" % (direction))
if not self.GAMEOVER and not self.PAUSED:
new_coordinates = (0, 0)
if direction == 'clockwise':
new_coordinates = self.shape.rotate_clockwise()
elif direction == 'anti-clockwise':
new_coordinates = self.shape.rotate_anti_clockwise()
if not self.board.check_collision(Shape(new_coordinates), self.shape.position()):
self.shape.set_coordinates(new_coordinates)
def toggle_pause(self):
print("[Game][info] Toggling paused state")
self.PAUSED = not self.PAUSED
def get_score(self):
print("[Game][info] Calculating score")
return self.SCORE
def print_score(self):
print("[Game][info] Printing score")
score = self.get_score()
try:
self.__display_message("Game\n\nOver!\n\nYour\n\nscore:\n\n%d" % score)
self.pygame.display.update()
self.pygame.time.wait(3000)
except AttributeError:
print("[Game][error] An error occurred printing score")
def print_high_score(self):
print("[Game][info] Printing high score: %d" % self.get_score())
try:
self.__display_message("Game\n\nOver!\n\nHigh\n\nscore:\n\n%d!" % self.get_score())
self.pygame.display.update()
self.pygame.time.wait(3000)
except AttributeError:
print("[Game][error] An error occurred printing high score")
def finish(self):
print("[Game][info] Finishing game")
score = self.get_score()
self.rgbmatrix.Clear()
self.pygame_screen.fill((0, 0, 0))
if self.db.contains(Query().score >= score):
self.print_score()
else:
self.print_high_score()
self.db.insert({'score': score})
self.reset()
def quit(self):
print("[Game][info] Quitting game")
self.rgbmatrix.Clear()
self.pygame_screen.fill((0, 0, 0))
self.__display_message("Quit...")
self.pygame.display.update()
self.pygame.quit()
sys.exit()
def reset(self):
print("[Game][info] Resetting game")
self.PAUSED = False
self.GAMEOVER = False
self.SCORE = 0
self.LINES = 0
self.LEVEL = 1
self.board = Board(self.COLUMNS, self.ROWS)
self.shape = None
self.shapes_next = None
self.__generate_shapes()
self.pygame.time.set_timer(pygame.USEREVENT + 1, 0)
self.pygame.display.update()
def cleanup(self):
print("[Game][info] Game clean up")
try:
self.rgbmatrix.Clear()
except AttributeError:
print("[Game][error] An error occurred cleaning up")
def __exit__(self):
print("[Game][info] Game exit")
self.cleanup()
#!/usr/bin/env python3
import datetime
import time
from rgbmatrix import RGBMatrix, RGBMatrixOptions, graphics
import init
options = init.get_options()
canvas = RGBMatrix(options=options)
clockFont = graphics.Font()
clockFont.LoadFont("fonts/tom-thumb.bdf")
msgFont = graphics.Font()
msgFont.LoadFont("fonts/clR6x12.bdf")
blue = graphics.Color(0, 0, 255)
red = graphics.Color(255, 0, 0)
while True:
graphics.DrawText(canvas, clockFont, 4, 5, blue,
str(datetime.datetime.now().strftime("%H:%M:%S")))
graphics.DrawText(canvas, msgFont, 4, 20, red, "Line 2")
time.sleep(0.1)
canvas.Clear()
def main(myifname):
# init the RGB matrix as 32 Rows, 2 panels (represents 32 x 64 panel), 1 chain
MyMatrix = RGBMatrix(32, 2, 1)
# Bits used for PWM. Something between 1..11. Default: 11
MyMatrix.pwmBits = 11
# Sets brightness level. Default: 100. Range: 1..100"
MyMatrix.brightness = 100
# Flood fill with white as a POST
MyMatrix.Fill(255, 255, 255)
time.sleep(2)
MyMatrix.Clear()
# Setup colours for text display
ColorRED = graphics.Color(255, 0, 0)
ColorGRN = graphics.Color(0, 255, 0)
ColorBLU = graphics.Color(0, 0, 255)
ColorWHI = graphics.Color(255, 255, 255)
# Create the buffer canvas
MyOffsetCanvas = MyMatrix.CreateFrameCanvas()
# Load up the font (use absolute paths so script can be invoked from /etc/rc.local correctly)
font = graphics.Font()
font.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/5x8.bdf")
# get the IP address of the interface specified on the command line (e.g. wlan0)
ni.ifaddresses(myifname)
myip = ni.ifaddresses(myifname)[2][0]['addr']
# Show the interface, IP address and current time on the RGB led matrix for roughly 30 seconds (loop runs for 60 cycles with a 500ms delays, so roughly 30 seconds)
for i in range(60):
# grab current time and format
thetime = time.strftime("%H:%M:%S")
# run the "iwconfig" command passing in the ifname and capturing the output
cmd = subprocess.Popen('iwconfig %s' % myifname, shell=True, stdout=subprocess.PIPE)
# example output from "iwconfig wlp2s0" from Asus Eee PC R101 running lubuntu 16.04
#
# wlp2s0 IEEE 802.11bg ESSID:"wapifoh"
# Mode:Managed Frequency:2.437 GHz Access Point: E8:FC:AF:2B:09:60
# Bit Rate=54 Mb/s Tx-Power=20 dBm
# Retry short limit:7 RTS thr:off Fragment thr:off
# Power Management:off
# Link Quality=30/70 Signal level=-80 dBm
# Rx invalid nwid:0 Rx invalid crypt:0 Rx invalid frag:0
# Tx excessive retries:0 Invalid misc:2280 Missed beacon:0
#
# scan the output looking for key tokens of "Link Quality" "Level" and "ESSID"
for line in cmd.stdout:
if 'Link Quality' in line:
pos = line.find('Quality=')
quality = str_mid(line, pos+8, 5)
pos = line.find('level=')
level = str_mid(line, pos+6, 7)
#endif
if 'ESSID' in line:
pos = line.find('ESSID:')
essid = str_mid(line, pos+7, len(line)-pos-11)
#endif
#endfor
# format the interface attributes into four lines
line1 = str("%s %s" % (myifname, essid))
line2 = str("%s %s" % (quality, level))
line3 = str("%s" % myip)
line4 = str("%s %s" % (thetime, str(i)))
# clear matrix and print the four lines
MyOffsetCanvas.Clear()
graphics.DrawText(MyOffsetCanvas, font, 0, 7, ColorRED, line1)
graphics.DrawText(MyOffsetCanvas, font, 0, 15, ColorGRN, line2)
graphics.DrawText(MyOffsetCanvas, font, 0, 23, ColorBLU, line3)
graphics.DrawText(MyOffsetCanvas, font, 0, 31, ColorWHI, line4)
# debug print
print("line1=%s; line2=%s; line3=%s; line4=%s" % (line1,line2,line3,line4))
time.sleep(0.5)
MyOffsetCanvas = MyMatrix.SwapOnVSync(MyOffsetCanvas)
#endwhile
# tidy up and exit
MyOffsetCanvas.Clear()
# invoking autoexec.py
graphics.DrawText(MyOffsetCanvas, font, 0, 7, ColorWHI, "invoking:")
graphics.DrawText(MyOffsetCanvas, font, 0, 15, ColorWHI, "autoexec.py")
MyOffsetCanvas = MyMatrix.SwapOnVSync(MyOffsetCanvas)
time.sleep(1.0)
# invoke the autoeec.py python project in /projects with root permissions
# Other python projects to run should replace autoexec.py with there own functionality
# invoking with root allows these projects to do anything!
cmd = subprocess.Popen('sudo python /home/pi/projects/autoexec.py', shell=True, stdout=subprocess.PIPE)
class scoreboard(object):
def __init__(self):
super(scoreboard, self).__init__()
def sleep(self, sleep_period):
""" Function to sleep if not in season or no game.
Inputs sleep period depending if it's off season or no game."""
# Get current time
now = datetime.datetime.now()
# Set sleep time for no game today
if "day" in sleep_period:
delta = datetime.timedelta(hours=12)
# Set sleep time for not in season
elif "season" in sleep_period:
# If in August, 31 days else 30
if now.month is 8:
delta = datetime.timedelta(days=31)
else:
delta = datetime.timedelta(days=30)
next_day = datetime.datetime.today() + delta
next_day = next_day.replace(hour=12, minute=10)
sleep = next_day - now
sleep = sleep.total_seconds()
time.sleep(sleep)
def setup_nhl(self):
"""Function to setup the nhl_goal_light.py with team,
team_id and delay"""
"""Try to find a settings.txt file in the folder to automaticly setup
the goal light with pre-desired team and delay.
settings.txt file should as such : Enter team_id and delay,
each on a separate line in this order. LEAVE EMPTY if you want to
manually input every time. If program can't find settings.txt file or if
file is empty, it will ask for user input.
"""
lines = ""
team = ""
team_id = ""
settings_file = '/home/pi/nhlscoreboard/settings.txt'
if os.path.exists(settings_file):
# get settings from file
f = open(settings_file, 'r')
lines = f.readlines()
# find team_id
try:
team_id = lines[1].strip('\n')
except IndexError:
team_id = ""
if team_id == "":
team = input(
"Enter team you want to setup (without city) (Default: Canadiens) \n"
)
if team == "":
team = "Canadiens"
else:
team = team.title()
# query the api to get the ID
team_id = nhl.get_team_id(team)
# find delay
try:
delay = lines[2].strip('\n')
except IndexError:
delay = ""
if delay is "":
delay = input("Enter delay required to sync : \n")
if delay is "":
delay = 0
delay = float(delay)
delay = 0.0
return (team_id, delay)
def run(self):
options = RGBMatrixOptions()
options.rows = 32
options.cols = 64
options.chain_length = 4
options.parallel = 1
options.hardware_mapping = "adafruit-hat-pwm"
options.pixel_mapper_config = "U-mapper"
options.row_address_type = 0
options.multiplexing = 0
options.pwm_bits = 6
options.brightness = 100
options.pwm_lsb_nanoseconds = 130
options.limit_refresh_rate_hz = 200
options.led_rgb_sequence = "RBG"
options.show_refresh_rate = 0
options.gpio_slowdown = 1
self.matrix = RGBMatrix(options=options)
white = graphics.Color(255, 255, 255)
gray = graphics.Color(127, 127, 127)
green = graphics.Color(0, 150, 0)
yellow = graphics.Color(127, 127, 0)
red = graphics.Color(150, 0, 0)
blue = graphics.Color(0, 0, 150)
magenta = graphics.Color(127, 0, 127)
cyan = graphics.Color(0, 127, 127)
dim = graphics.Color(10, 10, 10)
offscreen_canvas = self.matrix.CreateFrameCanvas()
font = graphics.Font()
#main_dir = os.getcwd()
main_dir = "/home/pi/nhlscoreboard"
width = 128
height = 64
font_medium = graphics.Font()
font_medium.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/7x13.bdf")
font_small = graphics.Font()
font_small.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/6x10.bdf")
font_big = graphics.Font()
font_big.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/9x15.bdf")
fontYoffset = 8
fontYoffset2 = 8
x_offset = -64
gameday = False
season = False
home_roster = {}
away_roster = {}
home_score = 0
home_score_old = 0
away_score = 0
away_score_old = 0
home_team = ""
away_team = ""
live_stats_link = ""
x = 0
y = 10
home_score_color = ""
away_score_color = ""
do_once = 1
ignore_first_score_change = 1
random.seed()
choice = 1
teams = {
1: "NJD",
2: "NYI",
3: "NYR",
4: "PHI",
5: "PIT",
6: "BOS",
7: "BUF",
8: "MTL",
9: "OTT",
10: "TOR",
12: "CAR",
13: "FLA",
14: "TBL",
15: "WSH",
16: "CHI",
17: "DET",
18: "NSH",
19: "STL",
20: "CGY",
21: "COL",
22: "EDM",
23: "VAN",
24: "ANA",
25: "DAL",
26: "LAK",
28: "SJS",
29: "CBJ",
30: "MIN",
52: "WPG",
53: "ARI",
54: "VGK"
}
team_id, delay = self.setup_nhl()
#image = Image.open("/home/pi/nhlscoreboard/images/goal.png")
#self.matrix.SetImage(image.convert('RGB'))
#time.sleep(5)
try:
while (True):
time.sleep(2)
# check if in season
season = nhl.check_season()
season = 1
if season:
# check game
gameday = nhl.check_if_game(team_id)
if gameday:
# check end of game
game_end = nhl.check_game_end(team_id)
if not game_end:
try:
# get score, teams, and live stats link
home_score, home_team, away_score, away_team, live_stats_link = nhl.fetch_game(
team_id)
except TypeError:
continue
# get stats from the game
current_period, home_sog, away_sog, home_powerplay, away_powerplay, time_remaining = nhl.fetch_live_stats(
live_stats_link)
if current_period > 0:
# get the rosters just once at the start
if do_once:
while ((len(home_roster) < 5)
or (len(away_roster) < 5)):
home_roster, away_roster = nhl.fetch_rosters(
live_stats_link)
do_once = 0
# get the players on ice
home_on_ice, away_on_ice = nhl.players_on_ice(
live_stats_link)
# build a list like so for each team
# jersey_number lastname
home_ice_list = []
away_ice_list = []
home_goalie_id, away_goalie_id = nhl.fetch_goalies(
live_stats_link)
for the_id in home_on_ice:
try:
jersey_number = (
home_roster['ID' + str(the_id)]
['jerseyNumber']).encode("ascii")
except:
jersey_number = "0"
if int(jersey_number) < 10:
try:
jersey_number = jersey_number.decode(
"utf-8") + ' '
except:
jersey_number = '00'
else:
try:
jersey_number = jersey_number.decode(
"utf-8")
except:
jersey_number = '00'
try:
last_name = ((
(home_roster['ID' + str(the_id)]
['person']['fullName']).split(
' ', 1))[1]
).encode('utf-8').strip()
except UnicodeEncodeError:
last_name = ' '
try:
temp_thing = jersey_number + ' ' + (
last_name[0:7].upper()
).decode("utf-8")
except TypeError:
temp_thing = ' '
home_ice_list.append(temp_thing)
for the_id in away_on_ice:
try:
jersey_number = (
away_roster['ID' + str(the_id)]
['jerseyNumber']).encode("ascii")
except:
jersey_number = '00'
if int(jersey_number) < 10:
try:
jersey_number = jersey_number.decode(
"ascii") + ' '
except TypeError:
jersey_number = 0
else:
jersey_number = jersey_number.decode(
"utf-8")
try:
last_name = ((
(away_roster['ID' + str(the_id)]
['person']['fullName']).split(
' ', 1))[1]
).encode('utf-8').strip()
except TypeError:
last_name = ' '
try:
temp_thing = jersey_number + ' ' + (
last_name[0:7].upper()
).decode("utf-8")
except TypeError:
temp_thing = ' '
away_ice_list.append(temp_thing)
# determine score colors
if home_score > away_score:
home_score_color = red
away_score_color = green
elif away_score > home_score:
home_score_color = green
away_score_color = red
else:
home_score_color = green
away_score_color = green
# determine team colors
if home_powerplay == 1:
home_team_color = yellow
else:
home_team_color = gray
if away_powerplay == 1:
away_team_color = yellow
else:
away_team_color = gray
# reset x and y
x = 0
y = 0
# clear the offscreen canvas
offscreen_canvas.Clear()
# teams
# away on left
# home on right
# 3-letter team, score, sog
graphics.DrawText(offscreen_canvas, font_small,
0, y + fontYoffset,
away_team_color,
teams[away_team])
graphics.DrawText(offscreen_canvas, font_small,
28, y + fontYoffset,
away_score_color,
str(away_score))
graphics.DrawText(offscreen_canvas, font_small,
49, y + fontYoffset, yellow,
str(away_sog))
y += 8
# players on ice
for line in away_ice_list:
graphics.DrawText(offscreen_canvas,
font_small, 0,
y + fontYoffset, gray,
line)
y += 8
# away on left
y = 0
# 3-letter team, score, sog
graphics.DrawText(offscreen_canvas, font_small,
64, y + fontYoffset,
home_team_color,
teams[home_team])
graphics.DrawText(offscreen_canvas, font_small,
92, y + fontYoffset,
home_score_color,
str(home_score))
graphics.DrawText(offscreen_canvas, font_small,
113, y + fontYoffset, yellow,
str(home_sog))
y += 8
# players on ice
for line in home_ice_list:
graphics.DrawText(offscreen_canvas,
font_small, 64,
y + fontYoffset, gray,
line)
y += 8
y = 64
status, time_remaining = nhl.intermission_status(
live_stats_link)
if status == False:
graphics.DrawText(
offscreen_canvas, font_small, 35, y,
cyan, "PERIOD " + str(current_period))
else:
m, s = divmod(time_remaining, 60)
graphics.DrawText(
offscreen_canvas, font_small, 0, y,
cyan, "INTERMISSION " +
'{:02d}:{:02d}'.format(m, s))
# blit it to the screen
offscreen_canvas = self.matrix.SwapOnVSync(
offscreen_canvas)
# If score change...
if home_score > home_score_old:
home_score_old = home_score
choice = random.randint(1, 3)
if ignore_first_score_change == 0:
if home_team == int(team_id):
time.sleep(delay)
image = Image.open(
"/home/pi/nhlscoreboard/images/goal.png"
)
self.matrix.SetImage(
image.convert('RGB'))
time.sleep(5)
else:
time.sleep(delay)
image = Image.open(
"/home/pi/nhlscoreboard/images/sad-rod.gif"
)
self.matrix.SetImage(
image.convert('RGB'))
time.sleep(5)
else:
ignore_first_score_change = 0
else:
home_score_old = home_score
# If score change...
if away_score > away_score_old:
away_score_old = away_score
choice = random.randint(1, 3)
if ignore_first_score_change == 0:
if away_team == int(team_id):
time.sleep(delay)
image = Image.open(
"/home/pi/nhlscoreboard/images/goal.png"
)
self.matrix.SetImage(
image.convert('RGB'))
time.sleep(5)
else:
time.sleep(delay)
image = Image.open(
"/home/pi/nhlscoreboard/images/sad-rod.gif"
)
self.matrix.SetImage(
image.convert('RGB'))
time.sleep(5)
else:
ignore_first_score_change = 0
else:
away_score_old = away_score
ignore_first_score_change = 0
if current_period == 0:
offscreen_canvas.Clear()
y = 7
x_offset = x_offset + 1
if x_offset > 128:
x_offset = -128
graphics.DrawText(offscreen_canvas, font_small,
x + x_offset, y, blue,
"GAME TODAY!")
y += fontYoffset2
graphics.DrawText(offscreen_canvas, font_small,
x + 10 + x_offset, y, green,
"GAME TODAY!")
y += fontYoffset2
graphics.DrawText(offscreen_canvas, font_small,
x + 20 + x_offset, y, red,
"GAME TODAY!")
y += fontYoffset2
graphics.DrawText(offscreen_canvas, font_small,
x + 30 + x_offset, y, yellow,
"GAME TODAY!")
y += fontYoffset2
graphics.DrawText(offscreen_canvas, font_small,
x + 40 + x_offset, y,
magenta, "GAME TODAY!")
y += fontYoffset2
graphics.DrawText(offscreen_canvas, font_small,
x + 50 + x_offset, y, cyan,
"GAME TODAY!")
y += fontYoffset2
temptime = datetime.datetime.now()
graphics.DrawText(
offscreen_canvas, font_small, 0, y, gray,
temptime.strftime("%m/%d/%y %H:%M"))
y += fontYoffset2
game_start_time = nhl.fetch_game_start_time(
live_stats_link)
graphics.DrawText(
offscreen_canvas, font_small, 0, y, gray,
"GAMETIME: " + game_start_time)
offscreen_canvas = self.matrix.SwapOnVSync(
offscreen_canvas)
else:
home_roster.clear()
away_roster.clear()
old_score = 0 # Reset for new game
current_period = 0
self.matrix.Clear()
offscreen_canvas.Clear()
do_once = 1
self.sleep("day") # sleep till tomorrow
else:
print("No Game Today!")
self.sleep("day") # sleep till tomorrow
else:
print("OFF SEASON!")
self.sleep("season") # sleep till next season
except KeyboardInterrupt:
print("\nCtrl-C pressed")
class LedMatrixRGB(object):
""" Gives interface for the 3D.
"""
def __init__(self, nx=None, ny=None, color=None, power=0):
self.matrix_opts = RGBMatrixOptions()
self.set_power(0)
self.nx = nx
self.ny = ny
self.set_options()
def set_options(self):
self.matrix_opts.rows = 32
self.matrix_opts.chain_length = 1
# self.matrix_opts.parallel = 1
self.matrix_opts.pwm_bits = 1
self.matrix_opts.pwm_lsb_nanoseconds = 200
self.matrix_opts.drop_privileges = True
self.matrix_opts.hardware_mapping = 'regular'
# self.matrix_opts.gpio_slowdown=1
self.matrix = RGBMatrix(options=self.matrix_opts)
def set_power(self, power):
""" Adjusts power manually between 0-255.
"""
print('doit')
def set_pixel(self, x, y, power, color):
self.matrix.Clear()
nx, ny, power = int(x), int(y), int(power)
if color == 'R':
self.matrix.SetPixel(nx, ny, power, 0, 0)
if color == 'G':
self.matrix.SetPixel(nx, ny, 0, power, 0)
if color == 'B':
self.matrix.SetPixel(nx, ny, 0, 0, power)
def set_pattern(self, pattern, power, color):
self.matrix.Clear()
matrix = fpmm.hex_decode(pattern)
offset_canvas = self.matrix.CreateFrameCanvas()
xx , yy = np.where(matrix==1)
for x, y in (zip(xx, yy)):
nx = int(x)
ny = int(y)
power = int(power)
if color == 'R':
offset_canvas.SetPixel(nx, ny, power, 0, 0)
if color == 'G':
offset_canvas.SetPixel(nx, ny, 0, power, 0)
if color == 'B':
offset_canvas.SetPixel(nx, ny, 0, 0, power)
# offset_canvas.SetPixel(nx, ny, power, color)
offset_canvas = self.matrix.SwapOnVSync(offset_canvas)
# nx, ny, power = int(x), int(y), int(power)
# if color == 'R':
# self.matrix.SetPixel(nx, ny, power, 0, 0)
# if color == 'G':
# self.matrix.SetPixel(nx, ny, 0, power, 0)
# if color == 'B':
# self.matrix.SetPixel(nx, ny, 0, 0, power)
def __del__(self):
print('Goodbye')
class LedDisplay:
def __init__(self):
# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 32
options.cols = 32
options.chain_length = 1
options.parallel = 1
options.gpio_slowdown = 5
options.hardware_mapping = 'adafruit-hat'
# Enter in the hardware configurations
self.matrix = RGBMatrix(options=options)
# Specifications for Font style of text
self.font = graphics.Font()
self.font.LoadFont("rpi-rgb-led-matrix/fonts/4x6.bdf")
self.textColor = graphics.Color(100, 100, 100)
self.fontWidth = 4
self.fontHeight = 6
self.canvas = self.matrix.CreateFrameCanvas()
def clear(self):
self.matrix.Clear()
self.canvas.Clear()
def show(self, info):
# first attempt at code that will print multiple lines, could be rerwitten to be easier
if type(info) == tuple:
self.fontHeight = 6 # random constant depending on which font is chosen
index = self.fontHeight # First line in which text can be placed on matrix
for elem in info:
graphics.DrawText(self.canvas, self.font, 0, index,
self.textColor, elem)
index += self.fontHeight # move to next line on matrix
self.canvas = self.matrix.SwapOnVSync(self.canvas)
elif type(info) == str:
if len(info) > 8:
pos = self.canvas.width
while True:
self.canvas.Clear()
length = graphics.DrawText(self.canvas, self.font, pos, 10,
self.textColor, info)
pos -= 1
if (pos + length < 0):
pos = self.canvas.width
time.sleep(0.05)
self.canvas = self.matrix.SwapOnVSync(self.canvas)
else:
graphics.DrawText(self.canvas, self.font, 0, 10,
self.textColor, info)
self.canvas = self.matrix.SwapOnVSync(self.canvas)
elif type(info) == list:
for r in range(self.matrix.height):
for c in range(self.matrix.width):
R, G, B = info[r][c]
self.canvas.SetPixel(r, c, R, G, B)
self.canvas = self.matrix.SwapOnVSync(self.canvas)
else:
print("Invalid input: must be a tuple or a list")
raise ValueError
def getTextDimensions(self):
return int(self.matrix.height / self.fontHeight), int(
self.matrix.width / self.fontWidth)
class MatrixDisplay(object):
matrix_w = 64
matrix_h = 64
options = RGBMatrixOptions()
options.rows = matrix_h
options.cols = matrix_w
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'adafruit-hat'
chipSize = (6, 6) # 6px by 6px chip
def __init__(self,
player1Color=(200, 200, 0),
player2Color=(200, 0, 0),
boardColor=(0, 0, 210),
gridSize=(6, 8),
rotation=0):
self.gridSize = gridSize # rows x cols
self.rotation = rotation
self.matrix = RGBMatrix(options=MatrixDisplay.options)
self.matrix.Clear()
self.absoluteWidth = 64
self.absoluteHeight = 64
self.setRotation(rotation)
self.width = MatrixDisplay.matrix_w
self.height = MatrixDisplay.matrix_h
self.colors = {
"player1": player1Color,
"player2": player2Color,
"board": boardColor
}
# * draw the board upon each call. Output the board along with a possible selection if wanted
def update(self, grid, hoveredCol=None, currentPlayer=None):
#self.matrix.Clear()
#self.drawBoard()
for row in range(self.gridSize[0]):
for col in range(self.gridSize[1]):
gridVal = grid[row][col]
chipColor = (0, 0, 0)
if gridVal == 0:
chipColor = self.colors["player1"]
elif gridVal == 1:
chipColor = self.colors["player2"]
self.drawChip(5 - row, col, chipColor)
if hoveredCol != None:
chipColor = self.colors[
"player1"] if currentPlayer == 0 else self.colors["player2"]
self.drawHoverChip(hoveredCol, chipColor)
def drawChip(self, y, x, color):
# display a chip at (x,y) location with given color
chipColor = color
#print("Drawing chip at {}, {}".format(x, y))
self.drawRect((x * 8) + 1, 18 + (y * 8), (x * 8) + 6, 23 + (y * 8),
chipColor)
def drawBoard(self):
#print("Drawing board")
# draw the virtual grid to screen
boardColor = self.colors["board"]
self.drawRect(0, 16, 0, 63, boardColor)
self.drawRect(63, 16, 63, 63, boardColor)
# draw vertical lines
for x in range(7):
self.drawRect((x * 8) + 7, 16, (x * 8) + 8, 63, boardColor)
# draw horizontal lines
for y in range(6):
self.drawRect(0, (y * 8) + 16, 63, (y * 8) + 17, boardColor)
def drawHoverChip(self, col, color):
# draw a chip over a column when user is making a choice
chipColor = color
self.drawRect(0, 0, 63, 16, (0, 0, 0))
self.drawRect((col * 8) + 1, 4, (col * 8) + 6, 9, chipColor)
def drawWinScreen(self, winningPlayer):
self.matrix.Clear()
# display the winning player or tie if there is one (winningPlayer = 2)
font = graphics.Font()
font.LoadFont("./fonts/6x12.bdf")
if winningPlayer == 2:
graphics.DrawText(self.matrix, font, 5, 25,
graphics.Color(200, 200, 200), "It's a tie!")
else:
graphics.DrawText(self.matrix, font, 5, 15,
graphics.Color(200, 200, 200), "Congrats")
graphics.DrawText(self.matrix, font, 5, 30,
graphics.Color(200, 200, 200),
"player {},".format(winningPlayer + 1))
graphics.DrawText(self.matrix, font, 5, 45,
graphics.Color(200, 200, 200), "nice job!")
def drawStartScreen(self, startingPlayer):
self.matrix.Clear()
# show the start screen along with who is going first
font = graphics.Font()
font.LoadFont("./fonts/6x12.bdf")
graphics.DrawText(self.matrix, font, 5, 25,
graphics.Color(200, 200, 200),
"Player {}".format(startingPlayer))
graphics.DrawText(self.matrix, font, 5, 60,
graphics.Color(200, 200, 200), "starts")
def playAgainAsk(self):
font = graphics.Font()
font.LoadFont("./fonts/6x12.bdf")
graphics.DrawText(self.matrix, font, 2, 10,
graphics.Color(200, 200, 200), "Play again?")
def drawPlayAgainScreen(self, choice):
#self.matrix.Clear()
# * choice is an int for the choice being hovered
# show the play again selection screen
font = graphics.Font()
font.LoadFont("./fonts/6x12.bdf")
graphics.DrawText(
self.matrix, font, 2, 30,
graphics.Color(0, 200, 0) if choice == 0 else graphics.Color(
200, 200, 200), "Yes")
graphics.DrawText(
self.matrix, font, 48, 30,
graphics.Color(0, 200, 0) if choice == 1 else graphics.Color(
200, 200, 200), "No")
def colorTupleToColor(self, color):
return graphics.Color(color[0], color[1], color[2])
def drawRect(self, x1, y1, x2, y2, color):
for x in range(x1, x2 + 1):
for y in range(y1, y2 + 1):
newX, newY = self.mapPixelToRotation(x, y)
#print(newX, newY, sep=',')
self.matrix.SetPixel(newX, newY, color[0], color[1], color[2])
def mapPixelToRotation(self, x, y):
if (x < 0) or (y < 0) or (x >= self.width) or (y >= self.height):
#print("x was {} and y was {}".format(x,y))
return None, None
t = 0
if self.rotation == 1:
t = x
x = self.absoluteWidth - 1 - y
y = t
elif self.rotation == 2:
x = self.absoluteWidth - 1 - x
y = self.absoluteHeight - 1 - y
elif self.rotation == 3:
t = x
x = y
y = self.absoluteHeight - 1 - t
return x, y
def setRotation(self, r):
self.rotation = (r & 3)
if self.rotation == 0:
pass
elif self.rotation == 2:
self.width = self.absoluteWidth
self.height = self.absoluteHeight
elif self.rotation == 1:
pass
elif self.rotation == 3:
self.width = self.absoluteHeight
self.height = self.absoluteWidth
class PulseLedView(object):
def __init__(self, *args, **kwargs):
self.parser = argparse.ArgumentParser()
self.parser.add_argument("-r", "--led-rows", action="store", help="Display rows. 16 for 16x32, 32 for 32x32. Default: 32", default=32, type=int)
self.parser.add_argument("-c", "--led-chain", action="store", help="Daisy-chained boards. Default: 2.", default=2, type=int)
self.parser.add_argument("-P", "--led-parallel", action="store", help="For Plus-models or RPi2: parallel chains. 1..3. Default: 1", default=1, type=int)
self.parser.add_argument("-p", "--led-pwm-bits", action="store", help="Bits used for PWM. Something between 1..11. Default: 11", default=11, type=int)
self.parser.add_argument("-b", "--led-brightness", action="store", help="Sets brightness level. Default: 100. Range: 1..100", default=100, type=int)
self.parser.add_argument("-m", "--led-gpio-mapping", help="Hardware Mapping: regular, adafruit-hat, adafruit-hat-pwm Default: adafruit-hat" , choices=['regular', 'adafruit-hat', 'adafruit-hat-pwm'], default="adafruit-hat", type=str)
self.parser.add_argument("--led-scan-mode", action="store", help="Progressive or interlaced scan. 0 Progressive, 1 Interlaced (default)", default=1, choices=range(2), type=int)
self.parser.add_argument("--led-pwm-lsb-nanoseconds", action="store", help="Base time-unit for the on-time in the lowest significant bit in nanoseconds. Default: 130", default=130, type=int)
self.parser.add_argument("--led-show-refresh", action="store_true", help="Shows the current refresh rate of the LED panel")
self.parser.add_argument("--led-slowdown-gpio", action="store", help="Slow down writing to GPIO. Range: 1..100. Default: 1", choices=range(3), type=int)
self.parser.add_argument("--led-no-hardware-pulse", action="store", help="Don't use hardware pin-pulse generation")
self.parser.add_argument("--led-rgb-sequence", action="store", help="Switch if your matrix has led colors swapped. Default: RGB", default="RGB", type=str)
self.parser.add_argument("--cache-location", action="store", help="Location of the cache folder Default: ./pulse-cache", default="./pulse-cache", type=str)
self.parser.add_argument("--log-level", action="store", help="Log level Default: DEBUG", default="DEBUG", type=str)
def initialize_and_run(self):
self.args = self.parser.parse_args()
logging_level = logging.getLevelName(self.args.log_level)
self.logging = logging.basicConfig(level=logging_level, format='%(asctime)-15s [%(levelname)s] (%(threadName)-10s) %(message)s', )
logging.info("Initializing LED matrix...")
options = RGBMatrixOptions()
if self.args.led_gpio_mapping != None:
options.hardware_mapping = self.args.led_gpio_mapping
options.rows = self.args.led_rows
options.chain_length = self.args.led_chain
options.parallel = self.args.led_parallel
options.pwm_bits = self.args.led_pwm_bits
options.brightness = self.args.led_brightness
options.pwm_lsb_nanoseconds = self.args.led_pwm_lsb_nanoseconds
options.led_rgb_sequence = self.args.led_rgb_sequence
if self.args.led_show_refresh:
options.show_refresh_rate = 1
if self.args.led_slowdown_gpio != None:
options.gpio_slowdown = self.args.led_slowdown_gpio
if self.args.led_no_hardware_pulse:
options.disable_hardware_pulsing = True
self.matrix = RGBMatrix(options = options)
#self.led_pulse_cache = FanoutCache(self.args.cache_location, shards=20, timeout=1)
self.columns = self.args.led_rows * self.args.led_chain
self.rows = 32
# TODO: configure me
self.pulse_events_url = "http://192.168.1.7:9201/events"
# TODO: configure me
self.target_fps = 24.
self.time_per_frame_ms = (1 / self.target_fps) * 1000.
self.draw_state = DrawState()
self.stop_event = threading.Event()
try:
# Start loop
print("Press CTRL-C to stop sample")
self.run()
except KeyboardInterrupt:
print("Exiting\n")
self.stop_event.set()
sys.exit(0)
return True
def draw_text(self, matrix, x, y, text, size = 20):
font = ImageFont.truetype('fonts/FiraCode-Regular.ttf', size)
image = Image.new("RGB", (self.columns, self.rows))
draw = ImageDraw.Draw(image)
text_width, text_height = font.getsize(text)
draw.text((x - text_width/2 ,y - text_height/2), text, font=font, fill=(41,161,228,0))
self.matrix.SetImage(image.convert('RGB'))
def draw_logo(self):
logging.info("Display TS logo...")
logo_image = Image.open("images/tradeshift.jpg")
logo_image.thumbnail((self.columns, self.rows), Image.ANTIALIAS)
logo_image_width, logo_image_height = logo_image.size
x = (self.columns - logo_image_width) / 2
y = (self.rows - logo_image_height) / 2
self.matrix.SetImage(logo_image.convert('RGB'), x, y)
def countdown(self):
for value in reversed(range(0, 10)):
self.draw_text(self.matrix, (self.columns / 2), (self.rows / 2), str(value), 20)
sleep(0.125)
self.matrix.Clear()
def run(self):
self.draw_logo()
sleep(2)
self.countdown()
pulse_data_producer = PulseDataProducer(self.draw_state,
self.stop_event,
self.pulse_events_url,
self.target_fps,
self.columns,
self.rows
)
pulse_led_panel_output = PulseLedPanelOutput( self.draw_state,
self.stop_event,
self.matrix,
self.target_fps,
self.columns,
self.rows
)
producer_thread = threading.Thread(name='data-producer-thread',
target=pulse_data_producer.run)
producer_thread.setDaemon(True)
producer_thread.start()
draw_thread = threading.Thread(name='data-draw-thread',
target=pulse_led_panel_output.run,)
draw_thread.setDaemon(True)
draw_thread.start()
producer_thread.join()
draw_thread.join()
def to_matrix(minutes):
# How fast for testing
sleep_i = 1
# matrix options set here
options = RGBMatrixOptions()
options.rows = 32
options.chain_length = 2
options.hardware_mapping = 'adafruit-hat'
options.parallel = 1
# orient_image arguments here
mat_x = options.chain_length * options.rows
mat_y = options.rows
char_w = 8
char_h = 13
num_chars = 8
lines= 1
O = orient_image(mat_x, mat_y, char_w ,char_h, num_chars,lines)
matrix = RGBMatrix(options = options)
image = Image.new("RGB", (64, 32))
draw = ImageDraw.Draw(image)
matrix.Clear()
# image files found in respective directories
png = PNG_8x13
# create the countdown timer here
T = timer(minutes)
try:
# First for loop takes the initial list of lists and starts itering through
print 'countdown timer started'
while 1:
for i in T:
# Second for loop takes each individual list itme and iters through, printing to the matrix
# this updates later according to the offset
x_matrix_pos = O[0]
# with a single row of chars this wont change
y_matrix_pos = O[1]
# this is how far away the next char will print from the previous
x_matrix_offset = O[2]
print i
for j in i:
#print "i ", i,"\nj ", j
image = Image.open("%s" % png[j])
image.load()
matrix.SetImage(image.convert('RGB'),x_matrix_pos, y_matrix_pos)
x_matrix_pos += x_matrix_offset
sleep(sleep_i)
# display zero status at the end of the timer
print "countdown timer finished"
while 1:
# last list item in timer
zero_status = T[-1]
x_matrix_pos = O[0]
y_matrix_pos = O[1]
x_matrix_offset = O[2]
for i in zero_status:
image = Image.open("%s" % png[i])
image.load()
matrix.SetImage(image.convert('RGB'),x_matrix_pos, y_matrix_pos)
x_matrix_pos += x_matrix_offset
except Exception as e:
matrix.Clear()
print e
except KeyboardInterrupt:
matrix.Clear()
print 'sorry to see you go'
client = MQTTClient(ADAFRUIT_IO_USERNAME, ADAFRUIT_IO_KEY) #initialize MQTT
client.on_connect = connected #setup connect action
client.on_disconnect = disconnected #setup disconnect action
client.on_message = message #setup message action
client.connect() #connect to MQTT
client.loop_background() #continue a loop in background
while True: #forever loop
mean = mn * 4 #set variable mean to the actual mean times 4
if mn > 7: #if actual mean is greater than seven, set colour to green
r = 0
g = 255
b = 0
else: #if not greater than seven, set colour to red
r = 255
g = 0
b = 0
image = Image.new("RGB", (64, 64)) #create new RGB image
draw = ImageDraw.Draw(image) #draw on image
draw.text((0, 50), "Average:" + str(mn),
(0, 0, 255)) #create text showing average
draw.rectangle(
(0, 0, mean, mean),
fill=(r, g, b)) #create rectangle from 0,0 to mean,mean (mn*4,mn*4)
matrix.Clear() #clear the matrix if value has decreased
matrix.SetImage(image, 0,
0) #set the image on the matrix to the one just drawn
time.sleep(60) #wait a minute
matrix.SetImage(downscaled, 0, 0)
time.sleep(1)
time_is += step
def testMoonColors():
img = Image.new('RGB', (dimen, dimen), 'black')
draw = ImageDraw.Draw(img)
for i in range(0, len(moonColors)):
fullColor = moonColors[i]
draw.pieslice((start, start, diameter + start, diameter + start),
-180,
180,
fill=fullColor)
downscaled = getDownscaledImg(img)
matrix.Clear()
matrix.SetImage(downscaled, 0, 0)
time.sleep(2)
#testMoonColors()
runStart()
matrix.Clear()
runMoonClockQuick()
#runMoonClock()
matrix.Clear()
def main(args):
device_lat = args.device_lat
device_long = args.device_long
feeder_url = args.fr24_feeder_host
fonts_home = args.fonts_home
# Configuration for the LED matrix
options = RGBMatrixOptions()
options.cols = 64
options.rows = 32
options.chain_length = 1
options.brightness = 40
options.pwm_dither_bits = 1
options.pwm_lsb_nanoseconds = 50
options.parallel = 1
options.gpio_slowdown = 2 # reduces flicker
#options.hardware_mapping = 'regular' # If you have an Adafruit HAT: 'adafruit-hat'
matrix = RGBMatrix(options=options)
font = graphics.Font()
font.LoadFont(f'{fonts_home}/5x7.bdf')
font2 = graphics.Font()
font2.LoadFont(f'{fonts_home}/6x10.bdf')
green = graphics.Color(0, 255, 0)
graphics.DrawText(matrix, font, 0, 7, green, 'No aircraft')
graphics.DrawText(matrix, font, 0, 14, green, 'found')
try:
print('Press CTRL-C to stop.')
while True:
t = threading.Thread(target=get_aircraft(feeder_url))
t.run()
if aircraft_change:
logger.info('Refreshing aircraft list')
matrix.Clear()
index = 1
if len(aircraft_map.keys()) > 0:
for aircraft in aircraft_map.keys():
matrix.Clear()
aircraft_mode_s_transponder = aircraft_map.get(aircraft)[0]
aircraft_lat = aircraft_map.get(aircraft)[1]
aircraft_long = aircraft_map.get(aircraft)[2]
aircraft_ground_speed = aircraft_map.get(aircraft)[5]
aircraft_squawk = aircraft_map.get(aircraft)[6]
aircraft_callsign = aircraft_map.get(aircraft)[-1]
# Draw ADS-B Mode S transponder code
graphics.DrawText(matrix, font, 0, index * 7, green, f'ModeS: {aircraft_mode_s_transponder}')
# Draw aircraft callsign
if aircraft_callsign:
graphics.DrawText(matrix, font, 0, (index + 1) * 7, green, f'Sign: {aircraft_callsign}')
else:
graphics.DrawText(matrix, font, 0, (index + 1) * 7, green, f'Sign: unknown')
if aircraft_lat and aircraft_long:
geodesic_dict = Geodesic.WGS84.Inverse(float(device_lat), float(device_long), aircraft_lat,
aircraft_long)
azimuth = geodesic_dict['azi1']
distance_meters = geodesic_dict['s12']
distance_miles = 0.000621371 * distance_meters
heading = float(azimuth)
logger.info(f'heading: {heading:.3f}')
# Correct for negative headings
if heading < 0:
heading = heading + 360
logger.info(f'corrected heading: {heading:.3f}')
cardinal_direction = get_direction_from_heading(heading)
logger.info(f'cardinal direction: {cardinal_direction}')
# adjust heading from display orientation
display_heading = 240.0
adjusted_heading = 360 - display_heading + heading
logger.info(f'adjusted heading: {adjusted_heading:.3f}°')
# correct for heading over 360°
if adjusted_heading > 360:
adjusted_heading = adjusted_heading - 360
logger.info(f'adjusted heading (corrected): {adjusted_heading:.3f}°')
arrow_direction = get_direction_from_heading(adjusted_heading)
# Draw cardinal direction and arrow
graphics.DrawText(matrix, font2, 0, ((index + 2) * 7) + 1, green, cardinal_direction)
graphics.DrawText(matrix, font2, 0, ((index + 3) * 7) + 2, green, cardinal_arrows_map[
arrow_direction])
graphics.DrawText(matrix, font2, 22, ((index + 3) * 7) + 2, green, f'{distance_miles:.2f} mi')
else:
graphics.DrawText(matrix, font2, 0, ((index + 2) * 7) + 1, green, '?')
graphics.DrawText(matrix, font2, 0, ((index + 3) * 7) + 2, green, '?')
if aircraft_ground_speed:
graphics.DrawText(matrix, font2, 22, ((index + 2) * 7) + 1, green, f'{aircraft_ground_speed} kts')
time.sleep(10)
else:
graphics.DrawText(matrix, font, 0, 7, green, "No aircraft")
graphics.DrawText(matrix, font, 0, 14, green, "found")
time.sleep(60)
except KeyboardInterrupt:
sys.exit(0)
