Esempio n. 1
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. 2
0
    def process(self):
        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 execution")
            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
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 display_image(image_file):
    print("hi")
    image = Image.open(image_file)

    # Configuration for the matrix
    options = RGBMatrixOptions()
    options.rows = 32
    options.cols = 64
    options.chain_length = 1
    options.parallel = 1
    options.hardware_mapping = 'adafruit-hat'  # If you have an Adafruit HAT: 'adafruit-hat'
    options.brightness = 30
    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)
Esempio n. 6
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
        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)

        return True
Esempio n. 7
0
 def __init__(self, cols: int, rows: int, **kwargs):
     options = RGBMatrixOptions()
     options.cols = cols
     options.rows = rows
     for k, v in kwargs.items():
         setattr(options, k, v)
     self.matrix = RGBMatrix(options=options)
     self.canvas = self.matrix.CreateFrameCanvas()
Esempio n. 8
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. 9
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. 10
0
    def __init__(self, rows=32, cols=32, chain_length=1):
        options = RGBMatrixOptions()
        options.rows = rows
        options.chain_length = chain_length
        options.parallel = 1
        options.hardware_mapping = 'adafruit-hat'
        options.cols = cols

        self.matrix = RGBMatrix(options=options)
Esempio n. 11
0
def init():
    # Configuration for the matrix
    options = RGBMatrixOptions()
    options.rows = 64
    options.cols = 64
    options.chain_length = 1
    options.parallel = 1
    options.hardware_mapping = 'regular'
    options.brightness = 10
    return RGBMatrix(options=options)
Esempio n. 12
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. 13
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. 14
0
 def __init__(self, *args, **kwargs):
     o = RGBMatrixOptions()
     o.rows = 16
     o.cols = 32
     o.chain_length = 3
     o.parallel = 3
     o.multiplexing = 8
     o.row_address_type = 0
     o.pwm_lsb_nanoseconds = 100
     o.brightness = 25
     self.matrix = RGBMatrix(options=o)
Esempio n. 15
0
def screen_init():
    # Configuration for the matrix
    options = RGBMatrixOptions()
    options.rows = 32
    options.cols = 64
    options.chain_length = 1
    options.parallel = 1
    options.hardware_mapping = 'adafruit-hat'  # If you have an Adafruit HAT: 'adafruit-hat'
    options.brightness = 100
    options.show_refresh_rate = 1
    global matrix
    matrix = RGBMatrix(options=options)
Esempio n. 16
0
    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()
Esempio n. 17
0
def gen_options(cfg):
    options = RGBMatrixOptions()

    options.chain_length = int(cfg['display']['chain'])
    options.rows = int(cfg['display']['rows'])
    options.cols = int(cfg['display']['cols'])
    options.brightness = float(cfg['display']['brightness'])
    options.hardware_mapping = cfg['display']['hardware_mapping']

    options.show_refresh_rate = int(
        cfg['display']['debug']['show_refresh_rate'])

    return options
Esempio n. 18
0
    def __init__(self, clear_screen=True):
        options = RGBMatrixOptions()
        options.rows = Config.get_or_throw('leds.display_height')
        options.cols = Config.get_or_throw('leds.display_width')
        options.chain_length = 1
        options.parallel = 1
        options.hardware_mapping = 'adafruit-hat'
        options.drop_privileges = False

        self.__matrix = RGBMatrix(options=options)
        self.__pixels = self.__matrix.CreateFrameCanvas()
        if clear_screen:
            self.clear_screen()
Esempio n. 19
0
    def start(self):

        options = RGBMatrixOptions()
        options.rows = 16
        options.cols = 32
        #options.show_refresh_rate = 1

        self.matrix = RGBMatrix(options=options)

        try:
            # Start loop
            print("Press CTRL-C to stop sample")

            offscreen_canvas = self.matrix.CreateFrameCanvas()
            font = graphics.Font()
            font.LoadFont("./6x13B.bdf")
            textColor = graphics.Color(0, 0, 0)

            xpos = 1
            ypos = 14
            brightness = 1

            while True:
                # only update at 0 seconds
                time_now = datetime.datetime.now()
                time_pause = int(time_now.strftime("%-S"))

                if time_pause == 0:
                    # different brightness at different times
                    hour_of_day = int(time_now.strftime("%-H"))
                    if hour_of_day < 7:
                        brightness = 1
                    elif hour_of_day > 9:
                        brightness = 1
                    else:
                        brightness = 4
                    # draw a background
                    for y in range(0, self.matrix.height):
                        graphics.DrawLine(self.matrix, 0, y, 31, y,
                                          self.color(y, brightness))
                    # type time
                    time_string = time_now.strftime("%H:%M")
                    graphics.DrawText(self.matrix, font, xpos, ypos, textColor,
                                      time_string)

                time.sleep(1)

        except KeyboardInterrupt:
            print("Exiting\n")
            sys.exit(0)
Esempio n. 20
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")
    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()
Esempio n. 22
0
 def matrix(self):
     # Configuration for the matrix
     options = RGBMatrixOptions()
     options.rows = 32
     options.cols = 64
     options.chain_length = 1
     options.parallel = 1
     options.hardware_mapping = 'adafruit-hat'
     options.panel_type = 'FM6126A'
     #options.show_refresh_rate = 1
     #options.gpio_slowdown = 1
     #options.scan_mode = 1
     #options.limit_refresh_rate_hz = 100
     matrix = RGBMatrix(options=options)
     return matrix
Esempio n. 23
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. 24
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. 25
0
    def run(self):
        print('[Display] Display thread started.')

        # Configure matrix options
        options = RGBMatrixOptions()
        options.hardware_mapping = constants.matrix_hardware_mapping
        options.rows = constants.matrix_rows
        options.cols = constants.matrix_cols
        options.brightness = constants.matrix_brightness
        options.pwm_bits = constants.matrix_pwm_bits
        options.pwm_lsb_nanoseconds = constants.matrix_pwm_lsb_nanoseconds

        # Init matrix and canvas
        matrix = RGBMatrix(options=options)
        canvas = matrix.CreateFrameCanvas()

        # Configure font and colors
        font = graphics.Font()
        font.LoadFont('font.bdf')
        primaryColor = graphics.Color(255, 217, 0)
        secondaryColor = graphics.Color(255, 255, 255)

        # Init loop
        update_time = 0
        count = 0

        # Loop until the stop flag is raised
        while not self.stop_flag.is_set():
            # Animate counting
            if self.count != count:
                update_time = time.time()
                delta = self.count - count
                count = count + \
                  int(math.ceil(abs(delta) * constants.count_speed)) * \
                  (delta < 0 and -1 or 1)

            # Select color
            cooldown = update_time > time.time() - constants.highlight_cooldown
            color = secondaryColor if cooldown else primaryColor

            # Draw digits to canvas
            canvas.Clear()
            graphics.DrawText(canvas, font, 0, 25, color, str(count).zfill(4))
            canvas = matrix.SwapOnVSync(canvas)

            # Wait for next cycle
            time.sleep(0.1)
Esempio n. 26
0
    def __init__(self, *args, **kwargs):
        options = RGBMatrixOptions()

        options.hardware_mapping = "adafruit-hat"
        options.rows = 32
        options.cols = 64

        self.matrix = RGBMatrix(options=options)

        try:
            print("Press CTRL-C to stop sample")
            self.run()
        except KeyboardInterrupt:
            print("Exiting\n")
            sys.exit(0)

        return True
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)
def main():
    # Configuration for the matrix
    options = RGBMatrixOptions()
    options.rows = 64
    options.cols = 128
    options.chain_length = 1
    options.parallel = 3
    options.hardware_mapping = 'regular'  # If you have an Adafruit HAT: 'adafruit-hat'
    options.pwm_lsb_nanoseconds = 60

    matrix = RGBMatrix(options=options)

    shader = emersons_favorites("green_streaks")

    # Make a custom color based on age (0-1)
    #   I have a lot of 'preset' ones as comments in there too that you can try out.
    def gen_color(seed, age):
        global warmness
        global intensity
        c1 = [0.8 - warmness * 0.2, 0.8, 0.8 + warmness * 0.2]
        # co = [c1[i] * (0.8 + abs(age - 0.5) * 0.4) * intensity for i in range(3)]
        co = [
            c1[i] * (0.8 + smooth_osc(age) * 0.2) * intensity for i in range(3)
        ]
        return co

    # Loop to display screen (press q to close it)
    ret_char = None
    last_time = time.time()
    while ret_char != "q":
        # Here you can set global variables
        #   for some shaders to be controlled 'remotely'
        global warmness
        global intensity
        # warmness = abs((time.time() % 5) / 5 * 4 - 2) - 2
        warmness = math.sin(time.time() * 1.3) - 1
        # warmness = 0.5
        intensity = 0.4

        screen = np.full((64 * 3, 64 * 4, 3), 0.1)
        shader.render(screen)
        # screen = np.kron(screen, np.ones((2,2,1)))
        ret_char = print_screen(screen, wait_for_key=False, matrix=matrix)

        print("\r" + str(time.time() - last_time), end="")
        last_time = time.time()
Esempio n. 29
0
def make_matrix() -> RGBMatrix:
    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 = 65
    #  options.pwm_lsb_nanoseconds = 130
    #  options.led_rgb_sequence = 'RGB'
    #  options.pixel_mapper_config = ''
    #  options.gpio_slowdown = 1
    options.drop_privileges = False
    return RGBMatrix(options=options)
Esempio n. 30
0
def main():
    if len(sys.argv) < 2:
        sys.exit("require an image argument")
    else:
        image_file = sys.argv[1]

    image = Image.open(image_file)

    options = RGBMatrixOptions()
    options.rows = 32
    options.cols = 32
    options.chain_length = 4
    options.parallel = 1
    options.hardware_mapping = 'adafruit-hat'

    matrix = RGBMatrix(options=options)

    imgwidth, imgheight = image.size
    height = imgheight / 2
    width = imgwidth / 2
    startnum = 0

    long_img = Image.new('RGB', (width * 4, height))
    x_offset = 0
    for k, piece in enumerate(crop(image, height, width), startnum):
        long_img.paste(piece, (x_offset, 0))
        x_offset += piece.size[0]

        img = Image.new('RGB', (width, height), 255)
        img.paste(piece)

        img.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)

        matrix.SetImage(img.convert('RGB'))
        time.sleep(1)

    long_img.thumbnail((matrix.width, matrix.height), Image.ANTIALIAS)
    matrix.SetImage(long_img.convert('RGB'))

    try:
        print("Press CTRL-C to stop")
        while True:
            time.sleep(100)
    except KeyboardInterrupt:
        sys.exit(0)
Esempio n. 31
0
    def __init__(self, panel_rows, panel_columns, num_horiz_panels,
                 num_vert_panels):

        self.total_rows = panel_rows * num_vert_panels
        self.total_columns = panel_columns * num_horiz_panels

        options = RGBMatrixOptions()
        options.rows = matrix_rows
        options.cols = matrix_columns
        options.chain_length = num_horiz_panels
        options.parallel = num_vert_panels
        options.hardware_mapping = 'regular'
        #options.gpio_slowdown = 2

        self.matrix = RGBMatrix(options=options)
        self.background = None
        self.icons = []
        self.screen = Image.new("RGBA", (self.total_columns, self.total_rows))
Esempio n. 32
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. 33
0
    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()
Esempio n. 34
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
        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
Esempio n. 35
0
    first_run = True
    ledpi = LEDPi()
    while not run_once or first_run:
        first_run = False
        matrix = ledpi.display_clock()
        if matrix:
            send_matrix(driver, matrix)
    time.sleep(3)
    driver.Clear()


if __name__ == '__main__':
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s [%(levelname)s] in %(funcName)s: %(message)s')

    parser = argparse.ArgumentParser()
    parser.add_argument('--run-once', action='store_true')
    args = parser.parse_args()

    options = RGBMatrixOptions()
    options.rows = 32
    options.cols = 32
    options.chain_length = 2
    options.parallel = 1
    options.multiplexing = 0
    options.hardware_mapping = 'adafruit-hat-pwm'
    driver = RGBMatrix(options=options)

    main(driver, args.run_once)