Esempio n. 1
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")
Esempio n. 2
0
    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
Esempio n. 4
0
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
Esempio n. 5
0
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
Esempio n. 6
0
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
Esempio n. 7
0
    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
Esempio n. 8
0
    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
Esempio n. 9
0
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"))
Esempio n. 10
0
    def __init__(self, config):
        from rgbmatrix import RGBMatrix, RGBMatrixOptions
        options = RGBMatrixOptions()

        options.rows = config.getint('rows')
        options.cols = config.getint('cols')
        options.hardware_mapping = config['led_hardware_mapping']

        options.chain_length = config.getint('led_chain')
        options.parallel = config.getint('led_parallel')
        options.pwm_bits = config.getint('led_pwm_bits')
        options.brightness = config.getint('led_brightness')
        options.pwm_lsb_nanoseconds = config.getint('led_pwm_lsb_nanoseconds')
        options.inverse_colors = config.getboolean('led_inverse')
        options.led_rgb_sequence = config['led_rgb_sequence']
        options.pixel_mapper_config = config['led_pixel_mapper']
        options.row_address_type = config.getint('led_row_addr_type')
        options.multiplexing = config.getint('led_multiplexing')
        options.scan_mode = config.getint('led_scan_mode')
        options.gpio_slowdown = config.getint('led_slowdown_gpio')
        options.disable_hardware_pulsing = config.getboolean(
            'led_no_hardware_pulse')
        options.show_refresh_rate = config.getboolean('led_show_refresh')
        options.pwm_dither_bits = config.getint('led_pwm_dither_bits')
        #options.panel_type = config['led_panel_type']

        self.matrix = RGBMatrix(options=options)
        self.offscreen_canvas = self.matrix.CreateFrameCanvas()
Esempio n. 11
0
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)
Esempio n. 12
0
    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
Esempio n. 13
0
    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
Esempio n. 14
0
    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)
Esempio n. 15
0
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)
Esempio n. 16
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)
Esempio n. 17
0
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)
Esempio n. 18
0
 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()
Esempio n. 19
0
    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)
Esempio n. 20
0
    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
Esempio n. 21
0
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()
Esempio n. 22
0
    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()   
Esempio n. 23
0
  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")
Esempio n. 24
0
 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)
Esempio n. 25
0
    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
Esempio n. 26
0
 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()
Esempio n. 27
0
    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)
Esempio n. 28
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
Esempio n. 29
0
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
Esempio n. 30
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 __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")
Esempio n. 32
0
    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