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
options.panel_type = args.led_panel_type
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 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,
*,
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 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
options.pwm_dither_bits = self.args.led_pwm_dither_bits
options.limit_refresh_rate_hz = self.args.led_limit_refresh
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
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 process(self):
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']
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'] is not 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:
print('Press CTRL-C to stops')
self.run()
except KeyboardInterrupt:
print('Exiting\n')
sys.exit(0)
return True
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)
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 random
import mooncatparser as mc
from PIL import Image
from rgbmatrix import RGBMatrix, RGBMatrixOptions
# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = 64
options.cols = 64
options.chain_length = 1
options.parallel = 1
options.hardware_mapping = 'adafruit-hat' # If you have an Adafruit HAT: 'adafruit-hat'
#options.hardware_mapping = 'adafruit-hat-pwm' # If you have an Adafruit HAT soldered 4 to 18 : 'adafruit-hat-pwm'
options.gpio_slowdown = 4
options.panel_type = "FM6126A"
matrix = RGBMatrix(options=options)
# reads index of all rescued cats and returns list
def read_rescued():
data = []
with open('rescued.txt') as f:
line = f.readline()
while line:
line = f.readline()
if line == "":
break
#print(line)
id, line = line.split(";")
