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 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
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)
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
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()
def make_matrix(width, height, brightness): options = RGBMatrixOptions() options.gpio_slowdown = 2 options.disable_hardware_pulsing = True options.brightness = brightness options.rows = height options.cols = width return RGBMatrix(options = options)
def __init__(self, dir="./"): self.dir = dir options = RGBMatrixOptions() options.rows = 32 options.cols = 64 options.gpio_slowdown = 2 self.matrix = RGBMatrix(options=options) self.offscreen_canvas = self.matrix.CreateFrameCanvas()
def __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)
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)
def main(): options = RGBMatrixOptions() options.gpio_slowdown = 3 options.brightness = 50 options.rows = 32 options.cols = 64 # matrix = BandsMatrix(options=options) matrix = WindTrail(options=options) matrix.run()
def __init__(self): ''' ''' opts = RGBMatrixOptions() opts.gpio_slowdown = 4 opts.disable_hardware_pulsing = True opts.rows = ROWS opts.cols = COLS opts.chain_length = N_PANELS #number of panels connected opts.hardware_mapping = 'adafruit-hat' # or 'regular' self.matrix = RGBMatrix(options = opts) self.image = Image.new('RGB', (self.WIDTH, self.HEIGHT), "black") self.draw = ImageDraw.Draw(self.image) self.n = 0 self.options = {} self.options['calculate_refresh_rate'] = False self.options['virtual_LED'] = False #option 1) A solid background self.options['solid_background'] = False self.options['bg_color'] = (0, 5, 0) #option 2) A single bar moving around in the background self.options['moving_back_bar'] = False #option 3) A grated background with multiple vertical bars moving in the background self.options['grated_background'] = True #Some settings for options 2 and 3 self.options['bar_width'] = 10 self.options['grating_color'] = (5, 0, 0) self.options['bg_speed'] = 5 #option 4) Two flashing bars at an angle from buridan self.options['flashing_bars'] = False self.options['flashing_bars_positions'] = (60, 315) #The only foreground option for the moment, two buridan facing bars self.options['draw_buridan'] = True self.options['fg_color'] = (200, 0, 0) self.options['buridan_position'] = 25 #these are used to calculate refresh rate self.rt = 0 self._lastpaint = 0 #Create, daemonize, and start thread thread = threading.Thread(target=self.run, args=()) thread.daemon = True thread.start()
def __init__(self, *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)
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)
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 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
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()
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)
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()
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
def __init__(self, brightness: int): options = RGBMatrixOptions() options.brightness = brightness options.rows = 32 options.cols = 64 options.chain_length = 1 options.parallel = 1 options.pwm_bits = 11 options.hardware_mapping = 'regular' options.pwm_lsb_nanoseconds = 130 options.gpio_slowdown = 1 options.led_rgb_sequence = 'RGB' options.pixel_mapper_config = '' options.row_address_type = 0 options.multiplexing = 0 self.matrix = RGBMatrix(options=options)
def __init__(self): super().__init__() self.Away_Team_Logo_X = 0 self.Away_Team_Logo_y = 33 self.Home_Team_Logo_X = 37 self.Home_Team_Logo_y = 33 options = RGBMatrixOptions() options.rows = 32 options.cols = 64 options.chain_length = 2 options.pixel_mapper_config = "U-mapper" options.hardware_mapping = 'adafruit-hat-pwm' options.pwm_lsb_nanoseconds = 130 options.gpio_slowdown = 4 self.matrix = RGBMatrix(options=options) self.buffer = self.matrix.CreateFrameCanvas()
def 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)
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
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()
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)
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)
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))
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, LEDFormat): logging.info('Initialising LEDMatrix') options = RGBMatrixOptions() options.hardware_mapping = LEDFormat['matrixDriver'] options.rows = LEDFormat['matrixRows'] options.cols = LEDFormat['matrixCols'] options.chain_length = LEDFormat['matrixCount'] options.pixel_mapper_config = LEDFormat['matrixMapper'] options.row_address_type = 0 options.multiplexing = 0 options.pwm_bits = 11 options.brightness = 100 options.pwm_lsb_nanoseconds = 130 options.led_rgb_sequence = "RGB" options.show_refresh_rate = 0 self.__MatrixID = RGBMatrix(options = options) self.__MatrixID.Clear() xsize = self.__MatrixID.width ysize = self.__MatrixID.height self.__LEDXSize = xsize self.__LEDYSize = ysize self.__LEDXMax = xsize - 1 self.__LEDYMax = ysize - 1 self.__DrawOnMatrix = True self.__MatrixCanvas = Canvas((self.__LEDXSize, self.__LEDYSize)) self.__FadeMatrixCanvas = Canvas((self.__LEDXSize, self.__LEDYSize)) self.__MatrixBuffer = self.__MatrixID.CreateFrameCanvas()
def process(self): self.args = self.parser.parse_args() options = RGBMatrixOptions() if self.args.led_gpio_mapping != None: options.hardware_mapping = self.args.led_gpio_mapping options.rows = 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
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)