Esempio n. 1
0
    def __init__(self):
        configfile, demo = process_input_arg(sys.argv)
        (mapping, width, height, max_number_of_panels, led_rows, led_cols,
         parallel) = get_config(configfile)
        self.RUNNING = True
        self.mapping = mapping
        self.demo = demo
        self.width = width
        self.height = height
        self.max_number_of_panels = max_number_of_panels
        self.led_rows = led_rows
        self.led_cols = led_cols
        self.parallel = parallel
        self.scratch = pygame.Surface((width, height))
        self.gamepad = None

        #signal handlers to quite gracefully
        signal.signal(signal.SIGINT, self.quit_gracefully)
        signal.signal(signal.SIGTERM, self.quit_gracefully)
        print("""    murapix  Copyright (C) 2019  [email protected]
    This program comes with ABSOLUTELY NO WARRANTY.
    This is free software, and you are welcome to redistribute it
    under certain conditions.""")  #LICENSE

        if not demo:
            #must be a raspberry pi configured for murapix, hence nodename
            #must be "rpi-murapix"
            if os.uname().nodename not in ("rpi-murapix", "raspberrypi"):
                raise EnvironmentError(
                    "Not a murapix, please select demo mode with --demo=X")

            print('Going on the Murapix!')
            print('{0} channel(s) of [{1}*{2}={3} LED] X [{4} LED]'.format(
                parallel, max_number_of_panels // parallel, led_rows,
                max_number_of_panels * led_rows // parallel, led_cols))
            #the screen is just a single line of panels

            options = RGBMatrixOptions()
            options.rows = options.cols = led_rows
            options.parallel = parallel
            options.chain_length = max_number_of_panels // parallel
            options.hardware_mapping = 'regular'
            options.drop_privileges = 0
            self.matrix = RGBMatrix(options=options)

            self.double_buffer = self.matrix.CreateFrameCanvas()
            self._screen = init_pygame_display(
                (max_number_of_panels // parallel) * led_rows,
                led_cols * parallel)
        else:
            print('Going on the standart screen...')
            pygame.init()
            self._screen = pygame.display.set_mode(
                (width * demo, height * demo), 0, 32)

        self.clock = pygame.time.Clock()
        self.fps = 15
Esempio n. 2
0
 def setup(self):
     logger.info("setting up the matrix: %s", getpass.getuser())
     options = RGBMatrixOptions()
     options.rows = 16
     options.chain_length = 1
     options.brightness = BRIGHTNESS
     options.daemon = 0
     options.drop_privileges = 0
     self.matrix = RGBMatrix(options=options)
     logger.info("matrix setup is done: %s", getpass.getuser())
     return
Esempio n. 3
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
Esempio n. 4
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. 5
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. 6
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)
    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. 8
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
Esempio n. 9
0
    def __init__(self, sideclass=PiXXLSide):

        assert issubclass(sideclass, PiXXLSide)
        options = RGBMatrixOptions()

        self.settings = default_cube_settings
        self.settings["maxlight"] = self.settings.get("maxlight", 1000000)
        #cube specific defaults:
        options.rows = default_cube_settings["resolution"]
        options.cols = default_cube_settings["resolution"]
        options.chain_length = default_cube_settings["chain_length"]
        options.parallel = default_cube_settings["parallel"]
        options.brightness = default_cube_settings["brightness"]
        options.gpio_slowdown = default_cube_settings["gpio_slowdown"]

        #other led-matrix defaults:
        options.row_address_type = 0
        options.multiplexing = 0
        options.pwm_bits = 11
        options.pwm_lsb_nanoseconds = 130
        options.led_rgb_sequence = "RGB"
        options.pixel_mapper_config = ""
        options.drop_privileges = False

        self.options = options
        self.raw_accel_vector = []
        self.sides = []

        self.rendering = False
        self.time = time.time()

        for sidedata in default_cube_settings["sides"]:
            sidedata["res"] = default_cube_settings["resolution"]
            self.sides.append(sideclass(self, sidedata))

        self.gestureHandlers = []

        self.image = Image.new("RGB",
                               (self.options.chain_length * self.options.cols,
                                self.options.parallel * self.options.rows))

        self.framecouter = 0
Esempio n. 10
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
        options.panel_type = self.args.led_panel_type

        if self.args.led_show_refresh:
            options.show_refresh_rate = 1

        if self.args.led_slowdown_gpio != None:
            options.gpio_slowdown = self.args.led_slowdown_gpio
        if self.args.led_no_hardware_pulse:
            options.disable_hardware_pulsing = True
        if not self.args.drop_privileges:
            options.drop_privileges = False

        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. 11
0
def rgbmatrix_options():
    options = RGBMatrixOptions()
    options.multiplexing = 0
    options.row_address_type = 0
    options.brightness = 100
    options.rows = led_panel_height
    options.cols = led_panel_width
    options.chain_length = 1
    options.parallel = 1
    options.hardware_mapping = 'regular'
    options.inverse_colors = False
    options.led_rgb_sequence = "RGB"
    options.gpio_slowdown = 3
    options.pwm_lsb_nanoseconds = 150
    options.show_refresh_rate = 0
    options.disable_hardware_pulsing = True
    options.scan_mode = 0
    options.pwm_bits = 11
    options.daemon = 0
    options.drop_privileges = 0
    return options
Esempio n. 12
0
def get_options():
    options = RGBMatrixOptions()
    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.pwm_lsb_nanoseconds = 130
    options.led_rgb_sequence = "RGB"
    options.pixel_mapper_config = ""
    options.panel_type = ""
    options.drop_privileges = False

    # optional
    #options.show_refresh_rate = 1
    options.gpio_slowdown = 3  # 1-4
    #options.disable_hardware_pulsing = False
    return options
def rgbmatrix_options():
    options = RGBMatrixOptions()
    options.multiplexing = 6
    options.row_address_type = 0
    options.brightness = 80
    options.rows = number_of_rows_per_panel
    options.cols = number_of_columns_per_panel
    options.chain_length = number_of_panels
    options.parallel = parallel
    options.hardware_mapping = 'regular'
    options.inverse_colors = False
    options.led_rgb_sequence = "BGR"
    options.gpio_slowdown = 1
    options.pwm_lsb_nanoseconds = 130
    options.show_refresh_rate = 0
    options.disable_hardware_pulsing = False
    options.scan_mode = 0
    options.pwm_bits = 11
    options.daemon = 0
    options.drop_privileges = 0
    return options
Esempio n. 14
0
def InitMatrix():
    """Class for calling all graphical functions for the matrix."""
    # OPTIONS
    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 = 100
    options.pwm_lsb_nanoseconds = 130
    options.led_rgb_sequence = "RGB"
    options.pixel_mapper_config = ""
    options.gpio_slowdown = 3
    options.drop_privileges = 0
    options.daemon = 0
    # Test speed
    # options.show_refresh_rate = 1 #~530HZ on wiimote version

    return RGBMatrix(options=options)
Esempio n. 15
0
def init_leds():
    options = RGBMatrixOptions()

    options.hardware_mapping = 'regular'
    options.rows = 32
    options.cols = 64
    options.chain_length = 1
    options.parallel = 1
    options.row_address_type = 0
    options.multiplexing = 0
    options.brightness = 85
    options.pwm_bits = 8
    options.pwm_lsb_nanoseconds = 130
    options.led_rgb_sequence = 'RGB'
    options.pixel_mapper_config = ''
    options.panel_type = ''
    options.limit_refresh_rate_hz = 0  # no fps limit decreases the cpu usage
    options.show_refresh_rate = 0
    options.gpio_slowdown = 4
    options.disable_hardware_pulsing = False
    options.drop_privileges = False

    return RGBMatrix(options=options)
Esempio n. 16
0
parser.add_option("-n", "--no-flash", action="store_false", dest="flash",
default=True, help="makes the colon in the middle stop flashing")

(options, args) = parser.parse_args()

# True for 24 hour clock
CLK_24_HOUR = options.twentyfour_hr

ENABLE_DIMMING = options.dimming
DISPLAY_SECONDS = options.secs
DISPLAY_DATE = options.date
COLON_FLASH = options.flash

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

matrix = RGBMatrix(options=_options)

SMALL_SIZE = 10
BIG_SIZE = 13

def run():
    colon = True
    while True:
        image, canvas = new_canvas()
        t = time.localtime()
Esempio n. 17
0
#options.pwm_bits = 11    #default 11
options.pwm_lsb_nanoseconds = 200  #200
#options.scan_mode = 0    #default 0
#options.multiplexing = 0   #default 0, <1..17>
#options.row_address_type = 0   #default 0, <0..4>
#options.disable_hardware_pulsing = False   # debugging if nothing on panel - sound setting
options.show_refresh_rate = True
#options.inverse_colors = False
#options.led_rgb_sequence = "RGB"
#options.pixel_mapper_config =
#options.panel_type = "FM6126A"   #Current supported types: FM6126A or FM6127
#options.pwm_dither_bits = 0    #default 0
options.limit_refresh_rate_hz = 200
options.gpio_slowdown = 4
#options.daemon = False    #  if it looks weird, reboot
options.drop_privileges = True

matrix = RGBMatrix(options=options)

#-------------------------------------------------
# PUT SHADER ON MATRIX

while display.loop_running():
    # drawing
    post.start_capture()
    sprite.draw()
    post.end_capture()
    post.draw()

    ## inputs - mouse ##
    MX, MY = mouse.position()
Esempio n. 18
0
    def setup(self):
        """ Returns False on success, True on error """
        parser = argparse.ArgumentParser()

        # RGB matrix standards
        parser.add_argument(
            "-r",
            "--led-rows",
            action="store",
            help="Display rows. 32 for 32x32, 64 for 64x64. Default: 64",
            default=64,
            type=int,
        )
        parser.add_argument(
            "--led-cols",
            action="store",
            help="Panel columns. Typically 32 or 64. (Default: 64)",
            default=64,
            type=int,
        )
        parser.add_argument(
            "-c",
            "--led-chain",
            action="store",
            help="Daisy-chained boards. Default: 6.",
            default=6,
            type=int,
        )
        parser.add_argument(
            "-P",
            "--led-parallel",
            action="store",
            help="For Plus-models or RPi2: parallel chains. 1..3. Default: 1",
            default=1,
            type=int,
        )
        parser.add_argument(
            "-p",
            "--led-pwm-bits",
            action="store",
            help="Bits used for PWM. Something between 1..11. Default: 11",
            default=11,
            type=int,
        )
        parser.add_argument(
            "-b",
            "--led-brightness",
            action="store",
            help="Sets brightness level. Default: 100. Range: 1..100",
            default=100,
            type=int,
        )
        parser.add_argument(
            "-m",
            "--led-gpio-mapping",
            help="Hardware Mapping: regular, adafruit-hat, adafruit-hat-pwm",
            choices=[
                "regular", "regular-pi1", "adafruit-hat", "adafruit-hat-pwm"
            ],
            type=str,
        )
        parser.add_argument(
            "--led-scan-mode",
            action="store",
            help=
            "Progressive or interlaced scan. 0 Progressive, 1 Interlaced (default)",
            default=1,
            choices=range(2),
            type=int,
        )
        parser.add_argument(
            "--led-pwm-lsb-nanoseconds",
            action="store",
            help="Base time-unit for the on-time in the lowest "
            "significant bit in nanoseconds. Default: 130",
            default=130,
            type=int,
        )
        parser.add_argument(
            "--led-show-refresh",
            action="store_true",
            help="Shows the current refresh rate of the LED panel",
        )
        parser.add_argument(
            "--led-slowdown-gpio",
            action="store",
            help="Slow down writing to GPIO. Range: 0..4. Default: 3",
            default=4,  # For Pi 4 w/6 matrices
            type=int,
        )
        parser.add_argument(
            "--led-no-hardware-pulse",
            action="store",
            help="Don't use hardware pin-pulse generation",
        )
        parser.add_argument(
            "--led-rgb-sequence",
            action="store",
            help="Switch if your matrix has led colors swapped. Default: RGB",
            default="RGB",
            type=str,
        )
        parser.add_argument(
            "--led-pixel-mapper",
            action="store",
            help='Apply pixel mappers. e.g "Rotate:90"',
            default="",
            type=str,
        )
        parser.add_argument(
            "--led-row-addr-type",
            action="store",
            help="0 = default; 1=AB-addressed panels; 2=row direct; "
            "3=ABC-addressed panels; 4 = ABC Shift + DE direct",
            default=0,
            type=int,
            choices=[0, 1, 2, 3, 4],
        )
        parser.add_argument(
            "--led-multiplexing",
            action="store",
            help="Multiplexing type: 0=direct; 1=strip; 2=checker; 3=spiral; "
            "4=ZStripe; 5=ZnMirrorZStripe; 6=coreman; 7=Kaler2Scan; "
            "8=ZStripeUneven... (Default: 0)",
            default=0,
            type=int,
        )
        parser.add_argument(
            "--led-panel-type",
            action="store",
            help="Needed to initialize special panels. Supported: 'FM6126A'",
            default="",
            type=str,
        )
        parser.add_argument(
            "--led-no-drop-privs",
            dest="drop_privileges",
            help=
            "Don't drop privileges from 'root' after initializing the hardware.",
            action="store_false",
        )

        # Extra args unique to this program
        parser.add_argument(
            "-i",
            action="store",
            help="Image filename for texture map. Default: maps/earth.jpg",
            default="maps/earth.jpg",
            type=str,
        )
        parser.add_argument(
            "-v",
            dest="pointy",
            help="Orient cube with vertices at top & bottom.",
            action="store_true",
        )
        parser.add_argument(
            "-s",
            action="store",
            help="Spin time in seconds/revolution. Default: 10.0",
            default=10.0,
            type=float,
        )
        parser.add_argument(
            "-a",
            action="store",
            help="Antialiasing samples/axis. Default: 1",
            default=1,
            type=int,
        )
        parser.add_argument(
            "-t",
            action="store",
            help="Run time in seconds. Default: run indefinitely",
            default=-1.0,
            type=float,
        )
        parser.add_argument(
            "-f",
            action="store",
            help="Fade in/out time in seconds. Default: 0.0",
            default=0.0,
            type=float,
        )
        parser.add_argument(
            "-e",
            action="store",
            help="Edge-to-edge measure of matrix.",
            default=1.0,
            type=float,
        )
        parser.add_argument(
            "-E",
            action="store",
            help="Edge-to-edge measure of opposite cube faces.",
            default=1.0,
            type=float,
        )

        parser.set_defaults(drop_privileges=True)
        parser.set_defaults(pointy=False)

        args = parser.parse_args()

        if args.led_rows != args.led_cols:
            print(
                os.path.basename(__file__) +
                ": error: led rows and columns must match")
            return True

        if args.led_chain * args.led_parallel != 6:
            print(
                os.path.basename(__file__) +
                ": error: total chained * parallel matrices must equal 6")
            return True

        options = RGBMatrixOptions()

        if args.led_gpio_mapping is not 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
        options.panel_type = args.led_panel_type

        if args.led_show_refresh:
            options.show_refresh_rate = 1

        if args.led_slowdown_gpio is not None:
            options.gpio_slowdown = args.led_slowdown_gpio
        if args.led_no_hardware_pulse:
            options.disable_hardware_pulsing = True
        if not args.drop_privileges:
            options.drop_privileges = False

        self.matrix = RGBMatrix(options=options)
        self.canvas = self.matrix.CreateFrameCanvas()
        self.matrix_size = args.led_rows
        self.chain_length = args.led_chain
        self.max_brightness = args.led_brightness
        self.run_time = args.t
        self.fade_time = args.f
        self.samples_per_pixel = args.a * args.a
        matrix_measure = args.e
        cube_measure = args.E
        self.spin_time = args.s

        try:
            image = Image.open(args.i)
        except FileNotFoundError:
            print(
                os.path.basename(__file__) + ": error: image file " + args.i +
                " not found")
            return True

        self.map_width = image.size[0]
        map_height = image.size[1]
        self.map_data = image.tobytes()

        # Longitude and latitude tables are 1-dimensional,
        # can do that because we iterate every pixel every frame.
        pixels = self.matrix.width * self.matrix.height
        subpixels = pixels * self.samples_per_pixel
        self.longitude = [0.0 for _ in range(subpixels)]
        self.latitude = [0 for _ in range(subpixels)]
        # imgbuf holds result for one face of cube
        self.imgbuf = bytearray(self.matrix_size * self.matrix_size * 3)

        coords = POINTY_COORDS if args.pointy else SQUARE_COORDS

        # Fill the longitude & latitude tables, one per subpixel.
        ll_index = 0  # Index into longitude[] and latitude[] arrays
        ratio = matrix_measure / cube_measure  # Scale ratio
        offset = ((1.0 - ratio) + ratio / (self.matrix_size * args.a)) * 0.5
        # Axis offset
        for face in range(6):
            upper_left = coords[VERTS[face][0]]
            upper_right = coords[VERTS[face][1]]
            lower_left = coords[VERTS[face][2]]
            for ypix in range(self.matrix_size):  # For each pixel Y...
                for xpix in range(self.matrix_size):  # For each pixel X...
                    for yaa in range(args.a):  # " antialiased sample Y...
                        yfactor = offset + ratio * (ypix * args.a + yaa) / (
                            self.matrix_size * args.a)
                        for xaa in range(args.a):  # " antialiased sample X...
                            xfactor = offset + ratio * (
                                xpix * args.a + xaa) / (self.matrix_size *
                                                        args.a)
                            # Figure out the pixel's 3D position in space...
                            x3d = (upper_left[0] +
                                   (lower_left[0] - upper_left[0]) * yfactor +
                                   (upper_right[0] - upper_left[0]) * xfactor)
                            y3d = (upper_left[1] +
                                   (lower_left[1] - upper_left[1]) * yfactor +
                                   (upper_right[1] - upper_left[1]) * xfactor)
                            z3d = (upper_left[2] +
                                   (lower_left[2] - upper_left[2]) * yfactor +
                                   (upper_right[2] - upper_left[2]) * xfactor)
                            # Then convert to polar coords on a sphere...
                            self.longitude[ll_index] = (
                                (math.pi + math.atan2(-z3d, x3d)) /
                                (math.pi * 2.0) *
                                self.map_width) % self.map_width
                            self.latitude[ll_index] = int(
                                (math.pi * 0.5 - math.atan2(
                                    y3d, math.sqrt(x3d * x3d + z3d * z3d))) /
                                math.pi * map_height)
                            ll_index += 1

        return False
Esempio n. 19
0
import socket
import logging

from infra.run.common import *
from rgbmatrix import RGBMatrixOptions

# LOGOR_LEVEL = logging.DEBUG

HARDWARE_VERSION = 1

RGB_MATRIX_OPTIONS = RGBMatrixOptions()
RGB_MATRIX_OPTIONS.rows = 16
RGB_MATRIX_OPTIONS.cols = 32
RGB_MATRIX_OPTIONS.row_address_type = 0
RGB_MATRIX_OPTIONS.pwm_lsb_nanoseconds = 130
RGB_MATRIX_OPTIONS.drop_privileges = False
RGB_MATRIX_OPTIONS.led_rgb_sequence = 'RGB'
RGB_MATRIX_OPTIONS.hardware_mapping = 'free-i2c'

MPR121_MAP = []


def _update_gamepad_params(panels_width, panels_height, snake):
    GAMEPAD_PANELS_WIDTH, GAMEPAD_PANELS_HEIGHT = GAMEPAD_PANELS_SIZE = (
        panels_width, panels_height)
    RGB_MATRIX_WIDTH, RGB_MATRIX_HEIGHT = RGB_MATRIX_SIZE = (
        GAMEPAD_PANELS_WIDTH * RGB_MATRIX_OPTIONS.cols,
        GAMEPAD_PANELS_HEIGHT * RGB_MATRIX_OPTIONS.rows)
    ELECTRODE_SIZE = 8
    ELECTRODES_WIDTH, ELECTRODES_HEIGHT = ELECTRODES_SIZE = (
        RGB_MATRIX_WIDTH // ELECTRODE_SIZE,