Example #1
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
Example #2
0
def setupDisplay():
    options = RGBMatrixOptions()
    options.rows = 16
    options.cols = 32
    options.brightness = 100
    display = RGBMatrix(options=options)
    return display
Example #3
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"))
Example #4
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()
Example #5
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()
Example #6
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 = 100
    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)
Example #7
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)
Example #8
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)
    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()
Example #10
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)
Example #11
0
    def __generateMatrixOptions(self):
        from rgbmatrix import RGBMatrixOptions
        options = RGBMatrixOptions()
        options.rows = 32
        options.chain_length = 1
        options.parallel = 1
        options.hardware_mapping = 'regular'
        options.pwm_lsb_nanoseconds = 160
        options.brightness = 80
        options.drop_privileges = False

        return options
Example #12
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
    def __init__(self, chain=4, bright=50):  #デフォルト設定(引数なしの場合)
        #Options
        self.options = RGBMatrixOptions()
        self.options.rows = 32
        self.options.chain_length = chain
        self.options.parallel = 1
        self.options.hardware_mapping = 'adafruit-hat-pwm'
        self.options.brightness = bright
        self.options.show_refresh_rate = 0
        self.matrix = RGBMatrix(options=self.options)
        self.canvas = self.matrix.CreateFrameCanvas()

        # 時計用フォント読み込み
        self.clcfont = graphics.Font()
        self.clcfont.LoadFont("Resources/Metroclock.bdf")

        #LED長さ
        self._width = self.canvas.width
        self._height = self.canvas.height

        #Colors
        self.orange = graphics.Color(255, 110, 0)
        self.blue = graphics.Color(0, 220, 255)
        self.white = graphics.Color(255, 255, 255)
        self.red = graphics.Color(255, 0, 0)
        self.green = graphics.Color(0, 255, 0)

        #ループ制御用変数
        self.stopper = False
Example #14
0
class Display():

    options = RGBMatrixOptions()
    options.rows = 32
    options.cols = 64
    options.parallel = 1
    options.hardware_mapping = 'adafruit-hat'
    options.brightness = 50
    options.gpio_slowdown = 4    
    matrix = RGBMatrix(options = options)
    
    def __init__(self):
        self.screen_size = const.screen_size
        self.image = Image.new("RGB", self.screen_size)
        self.t = {'first': '00', 'second': '00'}

    def update_screen(self, text):
        self.clear_screen()
        self.generate_text(self.image, text, const.initial_text_location, const.font_size)
        self.matrix.SetImage(self.image.convert('RGB'))

    def clear_screen(self):
        self.image = Image.new("RGB",self.screen_size)

    def update_text(self):
        text = self.t['first'] + ':' + self.t['second']
        return text

    def generate_text(self, im, text, begin_loc, font_size):
        font = ImageFont.truetype('./fonts/digital-7-mono.ttf', size=(font_size))
        draw = ImageDraw.Draw(im)
        draw.text(begin_loc, text, font=font, fill='red')
Example #15
0
    def __init__(self, chain=4, bright=30):  # デフォルト設定(引数なしの場合)
        # Options
        self.options = RGBMatrixOptions()
        self.options.rows = 32
        self.options.chain_length = chain
        self.options.parallel = 1
        self.options.hardware_mapping = 'adafruit-hat-pwm'
        self.options.brightness = bright
        self.options.show_refresh_rate = 0
        self.options.disable_hardware_pulsing = 0

        # ラズパイ判別
        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
            self.options.gpio_slowdown = 2
        else:
            self.__unsafe = True

        self.matrix = RGBMatrix(options=self.options)
        self.canvas = self.matrix.CreateFrameCanvas()

        # テキスト用フォント
        self.gothic = graphics.Font()
        self.gothic.LoadFont("Resources/Gothic-16.bdf")

        # color
        self.white = graphics.Color(255, 255, 255)

        # LED長さ
        self._width = self.canvas.width
        self._height = self.canvas.height
Example #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()
Example #17
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
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
Example #19
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)
Example #20
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("RGB", (self.total_columns, self.total_rows))
        self.draw = ImageDraw.Draw(self.screen)

        # default frequency bin params:  one pixel bins, no averaging, mono-color
        self.num_pixels_per_freq_bin = 3
        self.num_freq_bins = self.total_columns / self.num_pixels_per_freq_bin
        self.freq_display_style = "instant"

        self.set_color_palette()
        self.color = 150
        self.y_spread = 0
Example #21
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):
     self.options = RGBMatrixOptions()
     self.options.rows = 16
     self.options.chain_length = 1
     self.options.parallel = 1
     self.options.hardware_mapping = 'regular'  # If you have an Adafruit HAT: 'adafruit-hat'
     self.font = graphics.Font()
     self.font.LoadFont("rpi-rgb-led-matrix/fonts/5x8.bdf")
     self.textColor = graphics.Color(255, 0, 0)
Example #23
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()   
Example #24
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)
Example #25
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)
Example #26
0
    def __init__(self):
        """
        setup the rgb matrix; these options will be static for the demo
        """
        options = RGBMatrixOptions()

        options.rows = 16
        options.chain_length = 3
        options.parallel = 1
        options.pwm_bits = 11
        options.brightness = 50
        options.pwm_lsb_nanoseconds = 130
        options.led_rgb_sequence = 'RGB'

        self.matrix = RGBMatrix(options=options)
Example #27
0
    def __init__(self, dimmer):
        #def __init__(self, weather, dimmer):
        threading.Thread.__init__(self)
        self.setDaemon(True)

        # Options
        options = RGBMatrixOptions()
        options.pwm_lsb_nanoseconds = 400
        options.rows = 32
        options.cols = 64

        #self._weather = weather
        self._dimmer = dimmer

        # Configure LED matrix driver
        #self._matrix = RGBMatrix(32, 2, 1)
        self._matrix = RGBMatrix(options=options)
        self._matrix.pwmBits = 11
        self._matrix.brightness = 20

        # Load fonts
        self._font_large = graphics.Font()
        self._font_large.LoadFont("rpi-rgb-led-matrix/fonts/10x20.bdf")
        self._font_small = graphics.Font()
        self._font_small.LoadFont("rpi-rgb-led-matrix/fonts/6x10.bdf")
        self._font_tiny = graphics.Font()
        self._font_tiny.LoadFont("rpi-rgb-led-matrix/fonts/4x6.bdf")

        # Define colors
        self._white = graphics.Color(255, 255, 255)
        self._red = graphics.Color(255, 32, 32)
        self._blue = graphics.Color(64, 64, 255)
        rgbtupl = self.random_color()
        #rgbtupl = self.colorsX(3)
        self._randcolorH = graphics.Color(int(rgbtupl[0]), int(rgbtupl[1]),
                                          int(rgbtupl[2]))
        rgbtupl = self.random_color()
        self._randcolorCollon = graphics.Color(int(rgbtupl[0]),
                                               int(rgbtupl[1]),
                                               int(rgbtupl[2]))
        rgbtupl = self.random_color()
        self._randcolorM = graphics.Color(int(rgbtupl[0]), int(rgbtupl[1]),
                                          int(rgbtupl[2]))
Example #28
0
    def __init__(self, rows, cols, refresh_rate=20):
        self.rows = rows
        self.cols = cols
        self.refresh_rate = refresh_rate

        options = RGBMatrixOptions()
        options.rows = rows
        options.cols = cols
        options.hardware_mapping = 'adafruit-hat'

        self.options = options
        self.matrix = RGBMatrix(options=options)
        self.font = create_font()
        self.widths = widths(
            self.font,
            '$!@#%^*()[]0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-=+_. '
        )

        self.frame = self.matrix.CreateFrameCanvas()
Example #29
0
    def __init__(self):
        # Configuration for the matrix
        self.options = RGBMatrixOptions()
        self.options.rows = 64
        self.options.cols = 64
        self.options.chain_length = 2
        self.options.parallel = 2
        self.options.hardware_mapping = 'regular'  # If you have an Adafruit HAT: 'adafruit-hat'

        self.matrix = RGBMatrix(options=self.options)
Example #30
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()
    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
Example #32
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.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")
            signal.signal(signal.SIGTERM, self.exit_process)
            self.run()
        except KeyboardInterrupt:
            print("Exiting\n")
            sys.exit(0)

        return True
Example #33
0
# image is drawn into a separate buffer, which is then copied to the matrix
# using the SetImage() function (see examples below).
# Requires rgbmatrix.so present in the same directory.

# 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))
#!/usr/bin/env python
import time
import sys

from rgbmatrix import RGBMatrix, RGBMatrixOptions
from PIL import Image

if len(sys.argv) < 2:
    sys.exit("Require an image argument")
else:
    image_file = sys.argv[1]

image = Image.open(image_file)

# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 32
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'regular'  # If you have an Adafruit HAT: 'adafruit-hat'

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:
Example #35
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()
Example #36
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
Example #37
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
Example #38
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)