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 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, 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 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 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 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 __init__(self):
options = RGBMatrixOptions()
# TODO MOVE TO CONFIG FILE
options.hardware_mapping = "adafruit-hat"
options.disable_hardware_pulsing = True
options.rows = 16
options.cols = 32
options.chain_length = 4
options.pixel_mapper_config = "U-mapper"
options.multiplexing = 8 # CORRECT value for 1/4 SCAN PANELS
self.matrix = RGBMatrix(options=options)
self.offscreen_canvas = self.matrix.CreateFrameCanvas()
def __init__(self):
options = RGBMatrixOptions()
# TODO MOVE TO CONFIG FILE
options.hardware_mapping = "adafruit-hat"
options.disable_hardware_pulsing = True
options.rows = 16
options.cols = 32
# set default brightess to 50% to protect against power spike at turn on
options.brightness = 50
options.chain_length = 4
options.pixel_mapper_config = "U-mapper"
options.multiplexing = 8 # CORRECT value for 1/4 SCAN PANELS
self.matrix = RGBMatrix(options=options)
self.offscreen_canvas = self.matrix.CreateFrameCanvas()
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 __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 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 __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 __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 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, sideclass=PiXXLSide):
assert issubclass(sideclass, PiXXLSide)
options = RGBMatrixOptions()
self.settings = default_cube_settings
self.settings["maxlight"] = self.settings.get("maxlight", 1000000)
#cube specific defaults:
options.rows = default_cube_settings["resolution"]
options.cols = default_cube_settings["resolution"]
options.chain_length = default_cube_settings["chain_length"]
options.parallel = default_cube_settings["parallel"]
options.brightness = default_cube_settings["brightness"]
options.gpio_slowdown = default_cube_settings["gpio_slowdown"]
#other led-matrix defaults:
options.row_address_type = 0
options.multiplexing = 0
options.pwm_bits = 11
options.pwm_lsb_nanoseconds = 130
options.led_rgb_sequence = "RGB"
options.pixel_mapper_config = ""
options.drop_privileges = False
self.options = options
self.raw_accel_vector = []
self.sides = []
self.rendering = False
self.time = time.time()
for sidedata in default_cube_settings["sides"]:
sidedata["res"] = default_cube_settings["resolution"]
self.sides.append(sideclass(self, sidedata))
self.gestureHandlers = []
self.image = Image.new("RGB",
(self.options.chain_length * self.options.cols,
self.options.parallel * self.options.rows))
self.framecouter = 0
def get_options():
options = RGBMatrixOptions()
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.pwm_lsb_nanoseconds = 130
options.led_rgb_sequence = "RGB"
options.pixel_mapper_config = ""
options.panel_type = ""
options.drop_privileges = False
# optional
#options.show_refresh_rate = 1
options.gpio_slowdown = 3 # 1-4
#options.disable_hardware_pulsing = False
return options
def rgbmatrix_options_factory(config):
"""Build RGBMatrix options object."""
options = RGBMatrixOptions()
if config["led-gpio-mapping"] is not None:
options.hardware_mapping = config["led-gpio-mapping"]
options.rows = config["led-rows"]
options.cols = config["led-cols"]
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"] is not None:
options.gpio_slowdown = config["led-slowdown-gpio"]
if config["led-no-hardware-pulse"]:
options.disable_hardware_pulsing = True
if config["led-pixel-mapper"]:
options.pixel_mapper_config = config["led-pixel-mapper"]
return options
def InitMatrix():
"""Class for calling all graphical functions for the matrix."""
# OPTIONS
options = RGBMatrixOptions()
options.rows = 16
options.cols = 32
options.chain_length = 1
options.parallel = 1
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.pixel_mapper_config = ""
options.gpio_slowdown = 3
options.drop_privileges = 0
options.daemon = 0
# Test speed
# options.show_refresh_rate = 1 #~530HZ on wiimote version
return RGBMatrix(options=options)
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()
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 = NUM_ROWS
options.cols = NUM_COLS
options.chain_length = CHAIN_LEN
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 = 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.panel_type = self.args.led_panel_type
if self.args.led_show_refresh:
options.show_refresh_rate = 1
options.gpio_slowdown = GPIO_SLOWDOWN
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 process(self):
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']
options.panel_type = self.args['led_panel_type']
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)
try:
print('Press CTRL-C to stops')
self.run()
except KeyboardInterrupt:
print('Exiting\n')
sys.exit(0)
return True
def __init__(self, gamepad):
self.gamepad = gamepad
self.player = SpaceShip()
self.num_rocks = 10
self.rocks = []
for i in range(self.num_rocks):
self.rocks.append(Rock())
options = RGBMatrixOptions()
options.hardware_mapping = "regular"
options.rows = 64
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.pwm_lsb_nanoseconds = 130
#options.led_rgb_sequence = "RGB"
options.pixel_mapper_config = ""
self.matrix = RGBMatrix(options = options)
def rgbmatrix_options():
options = RGBMatrixOptions()
options.multiplexing = 1
options.row_address_type = 0
options.brightness = 60
options.rows = 64
options.cols = 64
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'regular'
options.inverse_colors = False
options.led_rgb_sequence = "GBR"
options.gpio_slowdown = 4
options.pwm_lsb_nanoseconds = 50
options.show_refresh_rate = 1
options.disable_hardware_pulsing = False
options.scan_mode = 1
options.pwm_bits = 11
# options.daemon = 0
# options.drop_privileges = 0
# options.pixel_mapper_config = "U-mapper;Rotate:90"
options.pixel_mapper_config = "Rotate:90"
return RGBMatrix(options=options)
def init_leds():
options = RGBMatrixOptions()
options.hardware_mapping = 'regular'
options.rows = 32
options.cols = 64
options.chain_length = 1
options.parallel = 1
options.row_address_type = 0
options.multiplexing = 0
options.brightness = 85
options.pwm_bits = 8
options.pwm_lsb_nanoseconds = 130
options.led_rgb_sequence = 'RGB'
options.pixel_mapper_config = ''
options.panel_type = ''
options.limit_refresh_rate_hz = 0 # no fps limit decreases the cpu usage
options.show_refresh_rate = 0
options.gpio_slowdown = 4
options.disable_hardware_pulsing = False
options.drop_privileges = False
return RGBMatrix(options=options)
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.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
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
from rgbmatrix import RGBMatrix, RGBMatrixOptions
from PIL import Image
if len(sys.argv) < 2:
sys.exit("Require an image argument")
else:
image_file = sys.argv[1]
image = Image.open(image_file)
# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 32
options.cols = 64
options.chain_length = 2
options.hardware_mapping = 'adafruit-hat-pwm'
options.pixel_mapper_config = 'U-mapper;Rotate:90'
options.show_refresh_rate = 1
matrix = RGBMatrix(options=options)
# Make image fit our screen.
image.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
matrix.SetImage(image.convert('RGB'))
try:
print("Press CTRL-C to stop.")
while True:
time.sleep(100)
except KeyboardInterrupt:
sys.exit(0)
animationSpeed = 0.05 # Higher number = Faster animation (but choppier)
dimBrightness = 0.02
# Configuration of the display
options = RGBMatrixOptions()
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.pwm_lsb_nanoseconds = 50
options.limit_refresh_rate_hz = 500
options.pixel_mapper_config = "Rotate:180" # If display is upside down
# options.pixel_mapper_config = "" # If display is right way up
options.led_rgb_sequence = "RBG"
options.hardware_mapping = 'adafruit-hat-pwm'
options.gpio_slowdown = 4
options.drop_privileges = False
options.disable_hardware_pulsing = False
matrix = RGBMatrix(options=options)
canvas = matrix.CreateFrameCanvas()
canvas.Clear()
# Graphics stuff
font_1 = graphics.Font()
font_1.LoadFont(
"/srv/dev-disk-by-uuid-87bac57a-ccb7-4b8f-bade-6277e3fa0e30/Nextcloud/nextcloud/data/tahainc/files/Documents/Programming/Server/Clock/time.bdf"
print("attempting to load RGBMatrix")
# load the matrix
options = RGBMatrixOptions()
options.hardware_mapping = 'adafruit-hat-pwm'
options.rows = 32
options.cols = 64
options.chain_length = 2
options.parallel = 1
options.row_address_type = 0
options.multiplexing = 0
options.pwm_bits = 11
options.brightness = 10
options.pwm_lsb_nanoseconds = 130
options.led_rgb_sequence = "RBG"
options.pixel_mapper_config = ""
options.gpio_slowdown = 2
matrix = RGBMatrix(options=options)
def getPlaylist():
c.execute('SELECT * FROM playlist ORDER BY id')
all_rows = c.fetchall()
return all_rows
def getScene(sceneName):
c.execute('SELECT * FROM scenes WHERE name = "{tn}" LIMIT 1'.\
format(tn=sceneName))
all_rows = c.fetchall()
return (all_rows)
def setup(self):
""" Returns False on success, True on error """
parser = argparse.ArgumentParser()
# RGB matrix standards
parser.add_argument(
"-r",
"--led-rows",
action="store",
help="Display rows. 32 for 32x32, 64 for 64x64. Default: 64",
default=64,
type=int,
)
parser.add_argument(
"--led-cols",
action="store",
help="Panel columns. Typically 32 or 64. (Default: 64)",
default=64,
type=int,
)
parser.add_argument(
"-c",
"--led-chain",
action="store",
help="Daisy-chained boards. Default: 6.",
default=6,
type=int,
)
parser.add_argument(
"-P",
"--led-parallel",
action="store",
help="For Plus-models or RPi2: parallel chains. 1..3. Default: 1",
default=1,
type=int,
)
parser.add_argument(
"-p",
"--led-pwm-bits",
action="store",
help="Bits used for PWM. Something between 1..11. Default: 11",
default=11,
type=int,
)
parser.add_argument(
"-b",
"--led-brightness",
action="store",
help="Sets brightness level. Default: 100. Range: 1..100",
default=100,
type=int,
)
parser.add_argument(
"-m",
"--led-gpio-mapping",
help="Hardware Mapping: regular, adafruit-hat, adafruit-hat-pwm",
choices=[
"regular", "regular-pi1", "adafruit-hat", "adafruit-hat-pwm"
],
type=str,
)
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,
)
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,
)
parser.add_argument(
"--led-show-refresh",
action="store_true",
help="Shows the current refresh rate of the LED panel",
)
parser.add_argument(
"--led-slowdown-gpio",
action="store",
help="Slow down writing to GPIO. Range: 0..4. Default: 3",
default=4, # For Pi 4 w/6 matrices
type=int,
)
parser.add_argument(
"--led-no-hardware-pulse",
action="store",
help="Don't use hardware pin-pulse generation",
)
parser.add_argument(
"--led-rgb-sequence",
action="store",
help="Switch if your matrix has led colors swapped. Default: RGB",
default="RGB",
type=str,
)
parser.add_argument(
"--led-pixel-mapper",
action="store",
help='Apply pixel mappers. e.g "Rotate:90"',
default="",
type=str,
)
parser.add_argument(
"--led-row-addr-type",
action="store",
help="0 = default; 1=AB-addressed panels; 2=row direct; "
"3=ABC-addressed panels; 4 = ABC Shift + DE direct",
default=0,
type=int,
choices=[0, 1, 2, 3, 4],
)
parser.add_argument(
"--led-multiplexing",
action="store",
help="Multiplexing type: 0=direct; 1=strip; 2=checker; 3=spiral; "
"4=ZStripe; 5=ZnMirrorZStripe; 6=coreman; 7=Kaler2Scan; "
"8=ZStripeUneven... (Default: 0)",
default=0,
type=int,
)
parser.add_argument(
"--led-panel-type",
action="store",
help="Needed to initialize special panels. Supported: 'FM6126A'",
default="",
type=str,
)
parser.add_argument(
"--led-no-drop-privs",
dest="drop_privileges",
help=
"Don't drop privileges from 'root' after initializing the hardware.",
action="store_false",
)
# Extra args unique to this program
parser.add_argument(
"-i",
action="store",
help="Image filename for texture map. Default: maps/earth.jpg",
default="maps/earth.jpg",
type=str,
)
parser.add_argument(
"-v",
dest="pointy",
help="Orient cube with vertices at top & bottom.",
action="store_true",
)
parser.add_argument(
"-s",
action="store",
help="Spin time in seconds/revolution. Default: 10.0",
default=10.0,
type=float,
)
parser.add_argument(
"-a",
action="store",
help="Antialiasing samples/axis. Default: 1",
default=1,
type=int,
)
parser.add_argument(
"-t",
action="store",
help="Run time in seconds. Default: run indefinitely",
default=-1.0,
type=float,
)
parser.add_argument(
"-f",
action="store",
help="Fade in/out time in seconds. Default: 0.0",
default=0.0,
type=float,
)
parser.add_argument(
"-e",
action="store",
help="Edge-to-edge measure of matrix.",
default=1.0,
type=float,
)
parser.add_argument(
"-E",
action="store",
help="Edge-to-edge measure of opposite cube faces.",
default=1.0,
type=float,
)
parser.set_defaults(drop_privileges=True)
parser.set_defaults(pointy=False)
args = parser.parse_args()
if args.led_rows != args.led_cols:
print(
os.path.basename(__file__) +
": error: led rows and columns must match")
return True
if args.led_chain * args.led_parallel != 6:
print(
os.path.basename(__file__) +
": error: total chained * parallel matrices must equal 6")
return True
options = RGBMatrixOptions()
if args.led_gpio_mapping is not 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
options.panel_type = args.led_panel_type
if args.led_show_refresh:
options.show_refresh_rate = 1
if args.led_slowdown_gpio is not None:
options.gpio_slowdown = args.led_slowdown_gpio
if args.led_no_hardware_pulse:
options.disable_hardware_pulsing = True
if not args.drop_privileges:
options.drop_privileges = False
self.matrix = RGBMatrix(options=options)
self.canvas = self.matrix.CreateFrameCanvas()
self.matrix_size = args.led_rows
self.chain_length = args.led_chain
self.max_brightness = args.led_brightness
self.run_time = args.t
self.fade_time = args.f
self.samples_per_pixel = args.a * args.a
matrix_measure = args.e
cube_measure = args.E
self.spin_time = args.s
try:
image = Image.open(args.i)
except FileNotFoundError:
print(
os.path.basename(__file__) + ": error: image file " + args.i +
" not found")
return True
self.map_width = image.size[0]
map_height = image.size[1]
self.map_data = image.tobytes()
# Longitude and latitude tables are 1-dimensional,
# can do that because we iterate every pixel every frame.
pixels = self.matrix.width * self.matrix.height
subpixels = pixels * self.samples_per_pixel
self.longitude = [0.0 for _ in range(subpixels)]
self.latitude = [0 for _ in range(subpixels)]
# imgbuf holds result for one face of cube
self.imgbuf = bytearray(self.matrix_size * self.matrix_size * 3)
coords = POINTY_COORDS if args.pointy else SQUARE_COORDS
# Fill the longitude & latitude tables, one per subpixel.
ll_index = 0 # Index into longitude[] and latitude[] arrays
ratio = matrix_measure / cube_measure # Scale ratio
offset = ((1.0 - ratio) + ratio / (self.matrix_size * args.a)) * 0.5
# Axis offset
for face in range(6):
upper_left = coords[VERTS[face][0]]
upper_right = coords[VERTS[face][1]]
lower_left = coords[VERTS[face][2]]
for ypix in range(self.matrix_size): # For each pixel Y...
for xpix in range(self.matrix_size): # For each pixel X...
for yaa in range(args.a): # " antialiased sample Y...
yfactor = offset + ratio * (ypix * args.a + yaa) / (
self.matrix_size * args.a)
for xaa in range(args.a): # " antialiased sample X...
xfactor = offset + ratio * (
xpix * args.a + xaa) / (self.matrix_size *
args.a)
# Figure out the pixel's 3D position in space...
x3d = (upper_left[0] +
(lower_left[0] - upper_left[0]) * yfactor +
(upper_right[0] - upper_left[0]) * xfactor)
y3d = (upper_left[1] +
(lower_left[1] - upper_left[1]) * yfactor +
(upper_right[1] - upper_left[1]) * xfactor)
z3d = (upper_left[2] +
(lower_left[2] - upper_left[2]) * yfactor +
(upper_right[2] - upper_left[2]) * xfactor)
# Then convert to polar coords on a sphere...
self.longitude[ll_index] = (
(math.pi + math.atan2(-z3d, x3d)) /
(math.pi * 2.0) *
self.map_width) % self.map_width
self.latitude[ll_index] = int(
(math.pi * 0.5 - math.atan2(
y3d, math.sqrt(x3d * x3d + z3d * z3d))) /
math.pi * map_height)
ll_index += 1
return False
if len(sys.argv) < 2:
sys.exit("Require an image argument")
else:
image_file = sys.argv[1]
image = Image.open(image_file)
# Configuration for the matrix
options = RGBMatrixOptions()
#options.rows = 64
#options.chain_length = 4
#options.parallel = 1
#options.hardware_mapping = 'adafruit-hat' # If you have an Adafruit HAT: 'adafruit-hat'
options.pixel_mapper_config = "U-Mapper"
options.chain_length = 4
matrix = RGBMatrix(options=options)
# Make image fit our screen.
image.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
matrix.SetImage(image.convert('RGB'))
try:
print("Press CTRL-C to stop.")
while True:
time.sleep(100)
except KeyboardInterrupt:
sys.exit(0)
