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
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
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
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 __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 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")
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
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
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
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
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
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)
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)
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()
#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()
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
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,