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() 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__(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 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(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 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__(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() 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 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_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 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 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): ''' ''' 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): 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 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, *, 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 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 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 __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 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 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 getOptions(self): options = RGBMatrixOptions() options.hardware_mapping = "regular" 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 = 50 options.pwm_lsb_nanoseconds = 130 options.led_rgb_sequence = "RGB" options.show_refresh_rate = 0 options.gpio_slowdown = 4 options.disable_hardware_pulsing = False options.scan_mode = 1 return options
def rgbmatrix_options(): options = RGBMatrixOptions() options.multiplexing = 0 options.row_address_type = 0 options.brightness = 100 options.rows = led_panel_height options.cols = led_panel_width options.chain_length = 1 options.parallel = 1 options.hardware_mapping = 'regular' options.inverse_colors = False options.led_rgb_sequence = "RGB" options.gpio_slowdown = 3 options.pwm_lsb_nanoseconds = 150 options.show_refresh_rate = 0 options.disable_hardware_pulsing = True options.scan_mode = 0 options.pwm_bits = 11 options.daemon = 0 options.drop_privileges = 0 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 rgbmatrix_options(): options = RGBMatrixOptions() options.multiplexing = 6 options.row_address_type = 0 options.brightness = 80 options.rows = number_of_rows_per_panel options.cols = number_of_columns_per_panel options.chain_length = number_of_panels options.parallel = parallel options.hardware_mapping = 'regular' options.inverse_colors = False options.led_rgb_sequence = "BGR" options.gpio_slowdown = 1 options.pwm_lsb_nanoseconds = 130 options.show_refresh_rate = 0 options.disable_hardware_pulsing = False options.scan_mode = 0 options.pwm_bits = 11 options.daemon = 0 options.drop_privileges = 0 return options
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 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 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): options = RGBMatrixOptions() options.rows = 32 options.chain_length = 2 options.parallel = 1 options.pwm_bits = 11 options.brightness = 100 options.pwm_lsb_nanoseconds = 130 options.led_rgb_sequence = 'RGB' options.disable_hardware_pulsing = True self.matrix = RGBMatrix(options=options) try: # loop print("Press CTRL-C to stop sample") self.run() except KeyboardInterrupt: print("Exiting\n") sys.exit(0)
# PIL Image module (create or load images) is explained here: # http://effbot.org/imagingbook/image.htm # PIL ImageDraw module (draw shapes to images) explained here: # http://effbot.org/imagingbook/imagedraw.htm from PIL import Image from PIL import ImageDraw import time from rgbmatrix import RGBMatrix, RGBMatrixOptions # Configuration for the matrix options = RGBMatrixOptions() options.rows = 16 options.chain_length = 1 options.parallel = 1 options.disable_hardware_pulsing = True options.hardware_mapping = 'regular' # If you have an Adafruit HAT: 'adafruit-hat' matrix = RGBMatrix(options = options) # RGB example w/graphics prims. # Note, only "RGB" mode is supported currently. image = Image.new("RGB", (16, 32)) # Can be larger than matrix if wanted!! draw = ImageDraw.Draw(image) # Declare Draw instance before prims # Draw some shapes into image (no immediate effect on matrix)... draw.rectangle((0, 0, 31, 31), fill=(0, 0, 0), outline=(0, 0, 255)) draw.line((0, 0, 15, 31), fill=(255, 0, 0)) draw.line((0, 15, 31, 0), fill=(0, 255, 0)) m = 0 # Then scroll image across matrix...