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 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 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 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 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 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__(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 bootstrap(self): self.args = self.parser.parse_args() options = RGBMatrixOptions() if self.args.gpio_mapping != None: options.hardware_mapping = self.args.gpio_mapping options.rows = self.args.rows options.cols = self.args.cols options.chain_length = self.args.chain options.parallel = self.args.parallel options.brightness = self.args.brightness options.led_rgb_sequence = self.args.sequence if self.args.slow_write != None: options.gpio_slowdown = self.args.slow_write self.matrix = RGBMatrix(options = options) try: # run loop print("CTRL-C to stop") 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 __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 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 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 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_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 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 make_matrix(width, height, brightness): options = RGBMatrixOptions() options.gpio_slowdown = 2 options.disable_hardware_pulsing = True options.brightness = brightness options.rows = height options.cols = width return RGBMatrix(options = 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 __init__(self, dir="./"): self.dir = dir options = RGBMatrixOptions() options.rows = 32 options.cols = 64 options.gpio_slowdown = 2 self.matrix = RGBMatrix(options=options) self.offscreen_canvas = self.matrix.CreateFrameCanvas()
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 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 main(): options = RGBMatrixOptions() options.gpio_slowdown = 3 options.brightness = 50 options.rows = 32 options.cols = 64 # matrix = BandsMatrix(options=options) matrix = WindTrail(options=options) matrix.run()
def __init__(self): ''' ''' opts = RGBMatrixOptions() opts.gpio_slowdown = 4 opts.disable_hardware_pulsing = True opts.rows = ROWS opts.cols = COLS opts.chain_length = N_PANELS #number of panels connected opts.hardware_mapping = 'adafruit-hat' # or 'regular' self.matrix = RGBMatrix(options = opts) self.image = Image.new('RGB', (self.WIDTH, self.HEIGHT), "black") self.draw = ImageDraw.Draw(self.image) self.n = 0 self.options = {} self.options['calculate_refresh_rate'] = False self.options['virtual_LED'] = False #option 1) A solid background self.options['solid_background'] = False self.options['bg_color'] = (0, 5, 0) #option 2) A single bar moving around in the background self.options['moving_back_bar'] = False #option 3) A grated background with multiple vertical bars moving in the background self.options['grated_background'] = True #Some settings for options 2 and 3 self.options['bar_width'] = 10 self.options['grating_color'] = (5, 0, 0) self.options['bg_speed'] = 5 #option 4) Two flashing bars at an angle from buridan self.options['flashing_bars'] = False self.options['flashing_bars_positions'] = (60, 315) #The only foreground option for the moment, two buridan facing bars self.options['draw_buridan'] = True self.options['fg_color'] = (200, 0, 0) self.options['buridan_position'] = 25 #these are used to calculate refresh rate self.rt = 0 self._lastpaint = 0 #Create, daemonize, and start thread thread = threading.Thread(target=self.run, args=()) thread.daemon = True thread.start()
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, 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 process(self): options = RGBMatrixOptions() options.gpio_slowdown = 4 options.disable_hardware_pulsing = True options.hardware_mapping = "classic-pi1" 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__(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, *, 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): options = RGBMatrixOptions() options.rows = 32 options.chain_length = 4 options.gpio_slowdown = 2 options.parallel = 1 options.hardware_mapping = 'regular' self.matrix = RGBMatrix(options=options) self.offscreen_canvas = self.matrix.CreateFrameCanvas() self.home_score = 0 self.away_score = 0 self.ordinal = "" self.time_remaining = "" self.configure_text() self.image_directory = 'resources/tsn_pixelated_logos' self.filename_template = '%s.ppm' pass
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 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