def process(self):
self.args = self.parser.parse_args()
options = RGBMatrixOptions()
options.hardware_mapping = "adafruit-hat"
options.rows = self.args.led_rows
options.cols = self.args.led_cols
options.chain_length = self.args.led_chain
options.parallel = self.args.led_parallel
options.row_address_type = self.args.led_row_addr_type
options.multiplexing = self.args.led_multiplexing
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
options.pixel_mapper_config = self.args.led_pixel_mapper
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
options.disable_hardware_pulsing = True
self.matrix = RGBMatrix(options=options)
try:
# Start loop
print("Press CTRL-C to stop sample")
self.run()
except KeyboardInterrupt:
print("Exiting\n")
sys.exit(0)
return True
def init_matrix():
global _state
options = RGBMatrixOptions()
options.hardware_mapping = const.scr_led_gpio_mapping
options.rows = const.scr_led_rows
options.cols = const.scr_led_cols
options.chain_length = const.scr_led_chain
options.parallel = const.scr_led_parallel
options.row_address_type = const.scr_row_address_type
options.multiplexing = const.scr_led_multiplexing
options.pwm_bits = const.scr_led_pwm_bits
options.brightness = _state.currentBrightness
options.pwm_lsb_nanoseconds = const.scr_led_pwm_lsb_nanoseconds
options.led_rgb_sequence = const.scr_led_rgb_sequence
if const.scr_led_show_refresh:
options.show_refresh_rate = 1
if const.scr_led_slowdown_gpio is not None:
options.gpio_slowdown = const.scr_led_slowdown_gpio
if const.scr_led_no_hardware_pulse:
options.disable_hardware_pulsing = True
options.pixel_mapper_config = const.scr_pixel_mapper_config
# https://github.com/hzeller/rpi-rgb-led-matrix/issues/679#issuecomment-423268899
_state.matrix = RGBMatrix(options=options)
for fontFilename in ["10x20", "6x9", "5x8"]:
font = graphics.Font()
font.LoadFont("{}/{}.bdf".format(const.scr_fonts_dir, fontFilename))
_state.fonts.append(font)
logger.debug("matrix canvas initialized")
def led_matrix_options(args):
options = RGBMatrixOptions()
if args.led_gpio_mapping != None:
options.hardware_mapping = args.led_gpio_mapping
options.rows = args.led_rows
options.cols = args.led_cols
options.chain_length = args.led_chain
options.parallel = args.led_parallel
options.row_address_type = args.led_row_addr_type
options.multiplexing = args.led_multiplexing
options.pwm_bits = args.led_pwm_bits
options.brightness = args.led_brightness
options.pwm_lsb_nanoseconds = args.led_pwm_lsb_nanoseconds
options.led_rgb_sequence = args.led_rgb_sequence
try:
options.pixel_mapper_config = args.led_pixel_mapper
except AttributeError:
debug.warning("Your compiled RGB Matrix Library is out of date.")
debug.warning("The --led-pixel-mapper argument will not work until it is updated.")
if args.led_show_refresh:
options.show_refresh_rate = 1
if args.led_slowdown_gpio != None:
options.gpio_slowdown = args.led_slowdown_gpio
if args.led_no_hardware_pulse:
options.disable_hardware_pulsing = True
return options
def __init__(self, options, font=defaultFont):
self._logger = LogManager.get_logger(__name__)
self._logger.debug("Initializing display with '{0}'".format(options))
matrix_options = RGBMatrixOptions()
matrix_options.hardware_mapping = options.led_gpio_mapping
matrix_options.rows = options.led_rows
matrix_options.cols = options.led_cols
matrix_options.chain_length = options.led_chain
matrix_options.parallel = options.led_parallel
matrix_options.row_address_type = options.led_row_addr_type
matrix_options.multiplexing = options.led_multiplexing
matrix_options.pwm_bits = options.led_pwm_bits
matrix_options.brightness = options.led_brightness
matrix_options.pwm_lsb_nanoseconds = options.led_pwm_lsb_nanoseconds
matrix_options.led_rgb_sequence = options.led_rgb_sequence
matrix_options.show_refresh_rate = options.led_show_refresh
matrix_options.gpio_slowdown = options.led_slowdown_gpio
matrix_options.disable_hardware_pulsing = options.led_no_hardware_pulse
self._matrix = RGBMatrix(options = matrix_options)
self._offscreen_canvas = self._matrix.CreateFrameCanvas()
self._font = font
def process(self):
self.args = self.parser.parse_args()
options = RGBMatrixOptions()
if self.args.led_gpio_mapping is not None:
options.hardware_mapping = self.args.led_gpio_mapping
options.rows = self.args.led_rows
options.cols = self.args.led_cols
options.chain_length = self.args.led_chain
options.parallel = self.args.led_parallel
options.row_address_type = self.args.led_row_addr_type
options.multiplexing = self.args.led_multiplexing
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
options.pixel_mapper_config = self.args.led_pixel_mapper
if self.args.led_show_refresh:
options.show_refresh_rate = 1
if self.args.led_slowdown_gpio is not 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)
return True
def process(self):
self.args = self.parser.parse_args()
options = RGBMatrixOptions()
if self.args.led_gpio_mapping != None:
options.hardware_mapping = self.args.led_gpio_mapping
if self.args.led_slowdown_gpio != None:
options.gpio_slowdown = self.args.led_slowdown_gpio
options.pwm_lsb_nanoseconds = self.args.led_pwm_lsb_nanoseconds
options.pwm_bits = self.args.led_pwm_bits
options.rows = self.args.led_rows
options.cols = self.args.led_cols
options.brightness = self.args.led_brightness
if self.args.led_show_refresh:
options.show_refresh_rate = 1
if self.args.led_no_hardware_pulse:
options.disable_hardware_pulsing = True
self.matrix = RGBMatrix(options=options)
try:
# Start loop
print("Press CTRL-C to stop sample")
self.run()
except KeyboardInterrupt:
print("Exiting\n")
sys.exit(0)
return True
def cli(ctx, verbose, home, rows, chain_length, parallel, brightness, gpio_slowdown, pwm_lsb_nanoseconds, scan_mode, hardware_mapping):
"""Blinky Matrix Display Driver"""
ctx.verbose = verbose
if home is not None:
ctx.home = home
# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = rows
ctx.vlog(click.style(f"rows = {options.rows}", fg="yellow"))
options.chain_length = chain_length
ctx.vlog(click.style(f"chain_length = {options.chain_length}", fg="yellow"))
options.parallel = parallel
ctx.vlog(click.style(f"parallel = {options.parallel}", fg="yellow"))
options.brightness = brightness
ctx.vlog(click.style(f"brightness = {options.brightness}", fg="yellow"))
options.gpio_slowdown = gpio_slowdown
ctx.vlog(click.style(f"gpio_slowdown = {options.gpio_slowdown}", fg="yellow"))
options.pwm_lsb_nanoseconds = pwm_lsb_nanoseconds
ctx.vlog(click.style(f"pwm_lsb_nanoseconds = {options.pwm_lsb_nanoseconds}", fg="yellow"))
options.scan_mode = scan_mode
ctx.vlog(click.style(f"scan_mode = {options.scan_mode}", fg="yellow"))
options.hardware_mapping = hardware_mapping
ctx.vlog(click.style(f"hardware_mapping = {options.hardware_mapping}", fg="yellow"))
ctx.matrix = RGBMatrix(options = options)
ctx.vlog(click.style(f"home = {ctx.home}", fg="yellow"))
def process(self):
self.args = self.parser.parse_args()
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
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)
try:
# Start loop
print("Press CTRL-C to stop sample")
self.run()
except KeyboardInterrupt:
print("Exiting\n")
sys.exit(0)
return True
def led_matrix_options(args):
options = RGBMatrixOptions()
if args.led_gpio_mapping != None:
options.hardware_mapping = args.led_gpio_mapping
options.rows = args.led_rows
options.cols = args.led_cols
options.chain_length = args.led_chain
options.parallel = args.led_parallel
options.row_address_type = args.led_row_addr_type
options.multiplexing = args.led_multiplexing
options.pwm_bits = args.led_pwm_bits
options.brightness = args.led_brightness
options.pwm_lsb_nanoseconds = args.led_pwm_lsb_nanoseconds
options.led_rgb_sequence = args.led_rgb_sequence
if args.led_show_refresh:
options.show_refresh_rate = 1
if args.led_slowdown_gpio != None:
options.gpio_slowdown = args.led_slowdown_gpio
if args.led_no_hardware_pulse:
options.disable_hardware_pulsing = True
return options
def init_matrix(self):
args = self.parser.parse_args()
options = RGBMatrixOptions()
if args.led_gpio_mapping != None:
options.hardware_mapping = args.led_gpio_mapping
options.rows = args.led_rows
options.cols = args.led_cols
options.chain_length = args.led_chain
options.parallel = args.led_parallel
options.row_address_type = args.led_row_addr_type
options.multiplexing = args.led_multiplexing
options.pwm_bits = args.led_pwm_bits
options.brightness = args.led_brightness
options.pwm_lsb_nanoseconds = args.led_pwm_lsb_nanoseconds
options.led_rgb_sequence = args.led_rgb_sequence
options.pixel_mapper_config = args.led_pixel_mapper
# Gave error that no options named panel_type existed
#options.panel_type = args.led_panel_type
if args.led_show_refresh:
options.show_refresh_rate = 1
if args.led_slowdown_gpio != None:
options.gpio_slowdown = args.led_slowdown_gpio
if args.led_no_hardware_pulse:
options.disable_hardware_pulsing = True
return RGBMatrix(options=options)
def matrix_options():
'''
Params:
options - Display Board connection options
matrix - Sets the options
Returns:
matrix, offscreen_canvas
'''
options = RGBMatrixOptions()
options.rows = 16
options.cols = 32
options.gpio_slowdown = 4
options.brightness = 100
options.chain_length = 1
options.parallel = 1
options.row_address_type = 0
options.pwm_bits = 11
options.pwm_lsb_nanoseconds = 130
options.led_rgb_sequence = 'RGB'
options.pixel_mapper_config = ''
#options.panel_type = '' # -> supported: str('FM6126A')
options.show_refresh_rate = 0
#options.hardware_mapping = 'regular'
matrix = RGBMatrix(options = options)
offscreen_canvas = matrix.CreateFrameCanvas()
return (matrix, offscreen_canvas)
def initialize():
global options, matrix, canvas, store
global default_font, light_font
options = RGBMatrixOptions()
options.rows = led_rows
options.cols = led_cols
options.chain_length = led_chain
options.parallel = led_parallel
options.brightness = led_brightness
options.hardware_mapping = led_hardware_mapping
options.disable_hardware_pulsing = True
options.pwm_lsb_nanoseconds = 130
# if you're not using raspberry pi 3 comment line below
options.gpio_slowdown = 2
matrix = RGBMatrix(options=options)
canvas = matrix.CreateFrameCanvas()
default_font = graphics.Font()
default_font.LoadFont(default_font_path)
light_font = graphics.Font()
light_font.LoadFont(light_font_path)
store = redis.StrictRedis(host='localhost', port=6379, db=0)
def __init__(self, config):
from rgbmatrix import RGBMatrix, RGBMatrixOptions
options = RGBMatrixOptions()
options.rows = config.getint('rows')
options.cols = config.getint('cols')
options.hardware_mapping = config['led_hardware_mapping']
options.chain_length = config.getint('led_chain')
options.parallel = config.getint('led_parallel')
options.pwm_bits = config.getint('led_pwm_bits')
options.brightness = config.getint('led_brightness')
options.pwm_lsb_nanoseconds = config.getint('led_pwm_lsb_nanoseconds')
options.inverse_colors = config.getboolean('led_inverse')
options.led_rgb_sequence = config['led_rgb_sequence']
options.pixel_mapper_config = config['led_pixel_mapper']
options.row_address_type = config.getint('led_row_addr_type')
options.multiplexing = config.getint('led_multiplexing')
options.scan_mode = config.getint('led_scan_mode')
options.gpio_slowdown = config.getint('led_slowdown_gpio')
options.disable_hardware_pulsing = config.getboolean(
'led_no_hardware_pulse')
options.show_refresh_rate = config.getboolean('led_show_refresh')
options.pwm_dither_bits = config.getint('led_pwm_dither_bits')
#options.panel_type = config['led_panel_type']
self.matrix = RGBMatrix(options=options)
self.offscreen_canvas = self.matrix.CreateFrameCanvas()
def led_matrix_options(args):
options = RGBMatrixOptions()
if args.led_gpio_mapping != None:
options.hardware_mapping = args.led_gpio_mapping
options.rows = args.led_rows
options.cols = args.led_cols
options.chain_length = args.led_chain
options.parallel = args.led_parallel
options.row_address_type = args.led_row_addr_type
options.multiplexing = args.led_multiplexing
options.pwm_bits = args.led_pwm_bits
options.brightness = args.led_brightness
options.pwm_lsb_nanoseconds = args.led_pwm_lsb_nanoseconds
options.led_rgb_sequence = args.led_rgb_sequence
try:
options.pixel_mapper_config = args.led_pixel_mapper
except AttributeError:
debug.warning("Your compiled RGB Matrix Library is out of date.")
debug.warning("The --led-pixel-mapper argument will not work until it is updated.")
if args.led_show_refresh:
options.show_refresh_rate = 1
if args.led_slowdown_gpio != None:
options.gpio_slowdown = args.led_slowdown_gpio
if args.led_no_hardware_pulse:
options.disable_hardware_pulsing = True
return options
def init_matrix():
options = RGBMatrixOptions()
options.rows = 32
options.chain_length = 4
options.pwm_bits = 3
options.pwm_lsb_nanoseconds = 300
options.gpio_slowdown = 2
return RGBMatrix(options=options)
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 __init__(self, *args, **kwargs):
o = RGBMatrixOptions()
o.rows = 16
o.cols = 32
o.chain_length = 3
o.parallel = 3
o.multiplexing = 8
o.row_address_type = 0
o.pwm_lsb_nanoseconds = 100
o.brightness = 25
self.matrix = RGBMatrix(options=o)
def __generateMatrixOptions(self):
from rgbmatrix import RGBMatrixOptions
options = RGBMatrixOptions()
options.rows = 32
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'regular'
options.pwm_lsb_nanoseconds = 160
options.brightness = 80
options.drop_privileges = False
return options
def __init__(self):
# Configuration for the matrix
options = RGBMatrixOptions()
options.cols = self.cols
options.rows = self.width
options.chain_length = 1
options.parallel = 1
options.gpio_slowdown = 2
options.hardware_mapping = 'adafruit-hat'
options.pwm_lsb_nanoseconds = 250
self.matrix = RGBMatrix(options = options)
self.offscreen_canvas = self.matrix.CreateFrameCanvas()
print("init done")
def __init__(self):
"""
setup the rgb matrix; these options will be static for the demo
"""
options = RGBMatrixOptions()
options.rows = 16
options.chain_length = 3
options.parallel = 1
options.pwm_bits = 11
options.brightness = 50
options.pwm_lsb_nanoseconds = 130
options.led_rgb_sequence = 'RGB'
self.matrix = RGBMatrix(options=options)
def __init__(self, brightness: int):
options = RGBMatrixOptions()
options.brightness = brightness
options.rows = 32
options.cols = 64
options.chain_length = 1
options.parallel = 1
options.pwm_bits = 11
options.hardware_mapping = 'regular'
options.pwm_lsb_nanoseconds = 130
options.gpio_slowdown = 1
options.led_rgb_sequence = 'RGB'
options.pixel_mapper_config = ''
options.row_address_type = 0
options.multiplexing = 0
self.matrix = RGBMatrix(options=options)
def __init__(self):
super().__init__()
self.Away_Team_Logo_X = 0
self.Away_Team_Logo_y = 33
self.Home_Team_Logo_X = 37
self.Home_Team_Logo_y = 33
options = RGBMatrixOptions()
options.rows = 32
options.cols = 64
options.chain_length = 2
options.pixel_mapper_config = "U-mapper"
options.hardware_mapping = 'adafruit-hat-pwm'
options.pwm_lsb_nanoseconds = 130
options.gpio_slowdown = 4
self.matrix = RGBMatrix(options=options)
self.buffer = self.matrix.CreateFrameCanvas()
def run(self):
print('[Display] Display thread started.')
# Configure matrix options
options = RGBMatrixOptions()
options.hardware_mapping = constants.matrix_hardware_mapping
options.rows = constants.matrix_rows
options.cols = constants.matrix_cols
options.brightness = constants.matrix_brightness
options.pwm_bits = constants.matrix_pwm_bits
options.pwm_lsb_nanoseconds = constants.matrix_pwm_lsb_nanoseconds
# Init matrix and canvas
matrix = RGBMatrix(options=options)
canvas = matrix.CreateFrameCanvas()
# Configure font and colors
font = graphics.Font()
font.LoadFont('font.bdf')
primaryColor = graphics.Color(255, 217, 0)
secondaryColor = graphics.Color(255, 255, 255)
# Init loop
update_time = 0
count = 0
# Loop until the stop flag is raised
while not self.stop_flag.is_set():
# Animate counting
if self.count != count:
update_time = time.time()
delta = self.count - count
count = count + \
int(math.ceil(abs(delta) * constants.count_speed)) * \
(delta < 0 and -1 or 1)
# Select color
cooldown = update_time > time.time() - constants.highlight_cooldown
color = secondaryColor if cooldown else primaryColor
# Draw digits to canvas
canvas.Clear()
graphics.DrawText(canvas, font, 0, 25, color, str(count).zfill(4))
canvas = matrix.SwapOnVSync(canvas)
# Wait for next cycle
time.sleep(0.1)
def __init__(self,
*,
rows=32,
columns=64,
chain=1,
brightness=80,
gpio_mapping="adafruit-hat-pwm",
parallel=1,
pwm_bits=11,
panel_type="",
rgb_sequence="rgb",
show_refresh=False,
slowdown_gpio=None,
no_hardware_pulse=False,
pwm_lsb_nanoseconds=130,
row_addr_type=0,
multiplexing=0,
pixel_mapper=""):
options = RGBMatrixOptions()
options.drop_privileges = 0
options.daemon = 0
options.hardware_mapping = gpio_mapping
options.rows = rows
options.cols = columns
options.chain_length = chain
options.parallel = parallel
options.pwm_bits = pwm_bits
options.brightness = brightness
options.panel_type = panel_type
options.led_rgb_sequence = rgb_sequence
options.pwm_lsb_nanoseconds = pwm_lsb_nanoseconds
options.row_address_type = row_addr_type
options.multiplexing = multiplexing
options.pixel_mapper_config = pixel_mapper
if show_refresh:
options.show_refresh_rate = 1
if slowdown_gpio is not None:
options.gpio_slowdown = slowdown_gpio
if no_hardware_pulse:
options.disable_hardware_pulsing = True
self._matrix = RGBMatrix(options=options)
self._buffer = self._matrix.CreateFrameCanvas()
self._background = (0, 0, 0)
self._position = (0, 0)
def main():
# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 64
options.cols = 128
options.chain_length = 1
options.parallel = 3
options.hardware_mapping = 'regular' # If you have an Adafruit HAT: 'adafruit-hat'
options.pwm_lsb_nanoseconds = 60
matrix = RGBMatrix(options=options)
shader = emersons_favorites("green_streaks")
# Make a custom color based on age (0-1)
# I have a lot of 'preset' ones as comments in there too that you can try out.
def gen_color(seed, age):
global warmness
global intensity
c1 = [0.8 - warmness * 0.2, 0.8, 0.8 + warmness * 0.2]
# co = [c1[i] * (0.8 + abs(age - 0.5) * 0.4) * intensity for i in range(3)]
co = [
c1[i] * (0.8 + smooth_osc(age) * 0.2) * intensity for i in range(3)
]
return co
# Loop to display screen (press q to close it)
ret_char = None
last_time = time.time()
while ret_char != "q":
# Here you can set global variables
# for some shaders to be controlled 'remotely'
global warmness
global intensity
# warmness = abs((time.time() % 5) / 5 * 4 - 2) - 2
warmness = math.sin(time.time() * 1.3) - 1
# warmness = 0.5
intensity = 0.4
screen = np.full((64 * 3, 64 * 4, 3), 0.1)
shader.render(screen)
# screen = np.kron(screen, np.ones((2,2,1)))
ret_char = print_screen(screen, wait_for_key=False, matrix=matrix)
print("\r" + str(time.time() - last_time), end="")
last_time = time.time()
def matrix_factory(width):
if not IS_PRODUCTION:
return MockMatrix()
options = RGBMatrixOptions()
# `pwm` requires small hardware mod but greatly improves flicker
options.hardware_mapping = "adafruit-hat-pwm"
options.chain_length = 1
options.rows = width
# these settings work well on a zero wh
options.gpio_slowdown = 0
options.pwm_lsb_nanoseconds = 100
options.pwm_dither_bits = 1
options.brightness = 35
options.pixel_mapper_config = "Rotate:90"
matrix = RGBMatrix(options=options)
return matrix
def rgbmatrix_options_factory(config):
"""Build RGBMatrix options object."""
options = RGBMatrixOptions()
if config['led-gpio-mapping'] != None:
options.hardware_mapping = config['led-gpio-mapping']
options.rows = config['led-rows']
options.chain_length = config['led-chain']
options.parallel = config['led-parallel']
options.pwm_bits = config['led-pwm-bits']
options.brightness = config['led-brightness']
options.pwm_lsb_nanoseconds = config['led-pwm-lsb-nanoseconds']
if config['led-show-refresh']:
options.show_refresh_rate = 1
if config['led-slowdown-gpio'] != None:
options.gpio_slowdown = config['led-slowdown-gpio']
if config['led-no-hardware-pulse']:
options.disable_hardware_pulsing = True
return options
def __init__(self):
print("__init__")
options = RGBMatrixOptions()
options.hardware_mapping = "adafruit-hat-pwm"
options.rows = 32
options.cols = 64
options.chain_length = 1
options.parallel = 1
options.row_address_type = 0
options.multiplexing = 0
options.pwm_bits = 11
options.brightness = 100
options.disable_hardware_pulsing = 0
#options.pwm_lsb_nanoseconds = 130
options.pwm_lsb_nanoseconds = 500 # 400=Good
options.led_rgb_sequence = "RGB"
options.pixel_mapper_config = ""
options.show_refresh_rate = 0
options.gpio_slowdown = 0
options.daemon = 0
options.drop_privileges = False
self.matrix = RGBMatrix(options=options)
self.offscreen_canvas = self.matrix.CreateFrameCanvas()
self.font = graphics.Font()
self.fontSmall = graphics.Font()
# Setup Fonts
# Get fonts from here: https://github.com/dk/ibm-vio-os2-fonts
#self.font.LoadFont("../../../fonts/10x20.bdf")
#self.font.LoadFont("ibm-vio-12x20-r-iso10646-1-20.bdf")
self.fontSmall.LoadFont(
"fonts/ibm-vio-6x10-r-iso10646-1-10-modified.bdf")
self.font.LoadFont("fonts/ibm-vio-12x30-r-iso10646-1-30-modified.bdf")
#self.font.LoadFont("fonts/ibm-vio-10x21-r-iso10646-1-21.bdf")
#self.font.LoadFont("fonts/ibm-vio-12x22-r-iso10646-1-22-modified.bdf")
#self.font.LoadFont("../../../fonts/helvR12.bdf")
self.matrix.brightness = 100
#self.textColor = graphics.Color(255, 0, 0)
logger.info("display adafruit hat init complete")
def setup(self):
self.args = self.parser.parse_args()
options = RGBMatrixOptions()
if self.args.led_gpio_mapping != None:
options.hardware_mapping = self.args.led_gpio_mapping
options.rows = self.args.led_rows
options.cols = self.args.led_cols
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
options.pixel_mapper_config = self.args.led_pixel_mapper
options.row_address_type = 0
options.multiplexing = 0
options.show_refresh_rate = 0
options.disable_hardware_pulsing = 0
if self.args.led_show_refresh:
options.show_refresh_rate = 1
# ラズパイ判別
model = subprocess.run(["cat", "/proc/device-tree/model"],
encoding='utf-8',
stdout=subprocess.PIPE)
# Pi4の場合, SetImageのunsafeを有効, gpio速度低下
if "Raspberry Pi 4" in model.stdout:
self.unsafe = False
if self.args.led_slowdown_gpio < 2:
options.gpio_slowdown = 3
else:
options.gpio_slowdown = self.args.led_slowdown_gpio
else:
self.unsafe = True
options.gpio_slowdown = self.args.led_slowdown_gpio
self.matrix = RGBMatrix(options=options)
def canvas_init(self, arg):
options = RGBMatrixOptions()
options.rows = arg.led_rows
fontsize_book = int(arg.font_main[0]) if arg.font_main else 16
fontsize_bold = int(arg.font_bold[0]) if arg.font_bold else 16
self.FELD_LOOP = [
"man", "design", "branding", "advertising", "typography",
"photography", "illustration", "editorial", "video", "print", "web"
]
self.ANIMATION_TIME = arg.animation_time[
0] if arg.animation_time else 10
self.YSHIFT = arg.yshift[0] if arg.yshift else 5
self.PREFIX = arg.prefx[0] if arg.prefx else "Feld"
self.SUFFIX = arg.suffx[0] if arg.suffx else ""
self.MAIN_COLOR = graphics.Color(255, 255, 255)
self.MARGIN_LEFT = arg.margin_left[0] if arg.margin_left else 0
self.MARGIN_TOP = arg.margin_top[0] if arg.margin_top else (
options.rows + fontsize_bold) / 2
self.FONT_MAIN = graphics.Font()
self.FONT_MAIN.LoadFont("libs/myfont/weights/font_" +
str(fontsize_book) + "_book.bdf")
self.FONT_BOLD = graphics.Font()
self.FONT_BOLD.LoadFont("libs/myfont/weights/font_" +
str(fontsize_bold) + "_bold.bdf")
self.SPACE_AFTER_PREFIX = arg.space_after_prefix[
0] if arg.space_after_prefix else 0
self.SPACE_BEFORE_SUFFIX = arg.space_before_suffix[
0] if arg.space_before_suffix else 0
if arg.led_gpio_mapping != None:
options.hardware_mapping = arg.led_gpio_mapping
options.chain_length = arg.led_chain
options.parallel = arg.led_parallel
options.pwm_bits = arg.led_pwm_bits
options.brightness = arg.led_brightness
options.pwm_lsb_nanoseconds = arg.led_pwm_lsb_nanoseconds
options.led_rgb_sequence = arg.led_rgb_sequence
if arg.led_show_refresh:
options.show_refresh_rate = 1
if arg.led_slowdown_gpio != None:
options.gpio_slowdown = arg.led_slowdown_gpio
if arg.led_no_hardware_pulse:
options.disable_hardware_pulsing = True
return RGBMatrix(options=options)
def __init__(self, dimmer):
#def __init__(self, weather, dimmer):
threading.Thread.__init__(self)
self.setDaemon(True)
# Options
options = RGBMatrixOptions()
options.pwm_lsb_nanoseconds = 400
options.rows = 32
options.cols = 64
#self._weather = weather
self._dimmer = dimmer
# Configure LED matrix driver
#self._matrix = RGBMatrix(32, 2, 1)
self._matrix = RGBMatrix(options=options)
self._matrix.pwmBits = 11
self._matrix.brightness = 20
# Load fonts
self._font_large = graphics.Font()
self._font_large.LoadFont("rpi-rgb-led-matrix/fonts/10x20.bdf")
self._font_small = graphics.Font()
self._font_small.LoadFont("rpi-rgb-led-matrix/fonts/6x10.bdf")
self._font_tiny = graphics.Font()
self._font_tiny.LoadFont("rpi-rgb-led-matrix/fonts/4x6.bdf")
# Define colors
self._white = graphics.Color(255, 255, 255)
self._red = graphics.Color(255, 32, 32)
self._blue = graphics.Color(64, 64, 255)
rgbtupl = self.random_color()
#rgbtupl = self.colorsX(3)
self._randcolorH = graphics.Color(int(rgbtupl[0]), int(rgbtupl[1]),
int(rgbtupl[2]))
rgbtupl = self.random_color()
self._randcolorCollon = graphics.Color(int(rgbtupl[0]),
int(rgbtupl[1]),
int(rgbtupl[2]))
rgbtupl = self.random_color()
self._randcolorM = graphics.Color(int(rgbtupl[0]), int(rgbtupl[1]),
int(rgbtupl[2]))
def process(self):
"""Process command-line input and initiate the RGB matrix with
those options before calling the subclass code."""
self.args = self.parser.parse_args()
options = RGBMatrixOptions()
if self.args.led_gpio_mapping is not None:
options.hardware_mapping = self.args.led_gpio_mapping
options.rows = self.args.led_rows
options.cols = self.args.led_cols
options.chain_length = self.args.led_chain
options.parallel = self.args.led_parallel
options.row_address_type = self.args.led_row_addr_type
options.multiplexing = self.args.led_multiplexing
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
options.pixel_mapper_config = self.args.led_pixel_mapper
if self.args.led_show_refresh:
options.show_refresh_rate = 1
if self.args.led_slowdown_gpio is not None:
options.gpio_slowdown = self.args.led_slowdown_gpio
if self.args.led_no_hardware_pulse:
options.disable_hardware_pulsing = True
# Don't drop root status; lets us maintain I2C access, etc.
# For some reason this isn't working from command line.
options.drop_privileges = False
signal.signal(signal.SIGTERM, self.signal_handler)
signal.signal(signal.SIGINT, self.signal_handler)
self.matrix = RGBMatrix(options=options)
try:
self.run()
except KeyboardInterrupt:
sys.exit(0)
return True
def __init__(self, LEDFormat):
logging.info('Initialising LEDMatrix')
options = RGBMatrixOptions()
options.hardware_mapping = LEDFormat['matrixDriver']
options.rows = LEDFormat['matrixRows']
options.cols = LEDFormat['matrixCols']
options.chain_length = LEDFormat['matrixCount']
options.pixel_mapper_config = LEDFormat['matrixMapper']
options.row_address_type = 0
options.multiplexing = 0
options.pwm_bits = 11
options.brightness = 100
options.pwm_lsb_nanoseconds = 130
options.led_rgb_sequence = "RGB"
options.show_refresh_rate = 0
self.__MatrixID = RGBMatrix(options = options)
self.__MatrixID.Clear()
xsize = self.__MatrixID.width
ysize = self.__MatrixID.height
self.__LEDXSize = xsize
self.__LEDYSize = ysize
self.__LEDXMax = xsize - 1
self.__LEDYMax = ysize - 1
self.__DrawOnMatrix = True
self.__MatrixCanvas = Canvas((self.__LEDXSize, self.__LEDYSize))
self.__FadeMatrixCanvas = Canvas((self.__LEDXSize, self.__LEDYSize))
self.__MatrixBuffer = self.__MatrixID.CreateFrameCanvas()
