def led_matrix_options(args):
options = RGBMatrixOptions()
if args.led_gpio_mapping != None:
options.hardware_mapping = args.led_gpio_mapping
options.rows = args.led_rows
options.cols = args.led_cols
options.chain_length = args.led_chain
options.parallel = args.led_parallel
options.row_address_type = args.led_row_addr_type
options.multiplexing = args.led_multiplexing
options.pwm_bits = args.led_pwm_bits
options.brightness = args.led_brightness
options.pwm_lsb_nanoseconds = args.led_pwm_lsb_nanoseconds
options.led_rgb_sequence = args.led_rgb_sequence
try:
options.pixel_mapper_config = args.led_pixel_mapper
except AttributeError:
debug.warning("Your compiled RGB Matrix Library is out of date.")
debug.warning("The --led-pixel-mapper argument will not work until it is updated.")
if args.led_show_refresh:
options.show_refresh_rate = 1
if args.led_slowdown_gpio != None:
options.gpio_slowdown = args.led_slowdown_gpio
if args.led_no_hardware_pulse:
options.disable_hardware_pulsing = True
return options
def led_matrix_options(args):
options = RGBMatrixOptions()
if args.led_gpio_mapping != None:
options.hardware_mapping = args.led_gpio_mapping
options.rows = args.led_rows
options.cols = args.led_cols
options.chain_length = args.led_chain
options.parallel = args.led_parallel
options.row_address_type = args.led_row_addr_type
options.multiplexing = args.led_multiplexing
options.pwm_bits = args.led_pwm_bits
options.brightness = args.led_brightness
options.pwm_lsb_nanoseconds = args.led_pwm_lsb_nanoseconds
options.led_rgb_sequence = args.led_rgb_sequence
if args.led_show_refresh:
options.show_refresh_rate = 1
if args.led_slowdown_gpio != None:
options.gpio_slowdown = args.led_slowdown_gpio
if args.led_no_hardware_pulse:
options.disable_hardware_pulsing = True
return options
def process(self):
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")
self.run()
except KeyboardInterrupt:
print("Exiting\n")
sys.exit(0)
return True
def __init__(self, LEDFormat):
logging.info('Initialising LEDMatrix')
options = RGBMatrixOptions()
options.hardware_mapping = LEDFormat['matrixDriver']
options.rows = LEDFormat['matrixRows']
options.cols = LEDFormat['matrixCols']
options.chain_length = LEDFormat['matrixCount']
options.pixel_mapper_config = LEDFormat['matrixMapper']
options.row_address_type = 0
options.multiplexing = 0
options.pwm_bits = 11
options.brightness = 100
options.pwm_lsb_nanoseconds = 130
options.led_rgb_sequence = "RGB"
options.show_refresh_rate = 0
self.__MatrixID = RGBMatrix(options = options)
self.__MatrixID.Clear()
xsize = self.__MatrixID.width
ysize = self.__MatrixID.height
self.__LEDXSize = xsize
self.__LEDYSize = ysize
self.__LEDXMax = xsize - 1
self.__LEDYMax = ysize - 1
self.__DrawOnMatrix = True
self.__MatrixCanvas = Canvas((self.__LEDXSize, self.__LEDYSize))
self.__FadeMatrixCanvas = Canvas((self.__LEDXSize, self.__LEDYSize))
self.__MatrixBuffer = self.__MatrixID.CreateFrameCanvas()
def setup(self):
config = configparser.ConfigParser()
config.read("weatherPanel.cfg")
#
# LED section
#
options = RGBMatrixOptions()
if "LED" in config:
ledOptions = config["LED"]
options.cols = int(ledOptions.get("cols", 64))
options.rows = int(ledOptions.get("rows", 32))
options.chain_length = int(ledOptions.get("chain_length", 4))
options.parallel = int(ledOptions.get("parallel", 1))
options.hardware_mapping = ledOptions.get(
"hardware_mapping", "adafruit-hat"
)
options.pixel_mapper_config = ledOptions.get(
"pixel_mapper_config", "U-mapper"
)
self.matrix = RGBMatrix(options=options)
else:
self.handleOptionsError("LED", "")
#
# WEATHER section
#
if "WEATHER" in config:
weatherOptions = config["WEATHER"]
if "lat" in weatherOptions:
lat = weatherOptions.get("lat")
else:
self.handleOptionsError("WEATHER", "lat")
if "lon" in weatherOptions:
lon = weatherOptions.get("lon")
else:
self.handleOptionsError("WEATHER", "lon")
if "units" in weatherOptions:
units = weatherOptions.get("units", "imperial")
if "appid" in weatherOptions:
appid = weatherOptions["appid"]
else:
self.handleOptionsError("WEATHER", "appid")
else:
self.handleOptionsError("WEATHER", "")
self.weatherUri = "https://api.openweathermap.org/data/2.5/onecall"
self.params = (
"lat=" + lat + "&lon=" + lon + "&appid=" + appid + "&units=" + units
)
#
# RSS section
#
self.feedArray = []
if "RSS" in config:
rssOptions = config["RSS"]
if "feed" in rssOptions:
self.feedArray = rssOptions.get("feed", "").split("\n")
self.rssApp.url = self.feedArray[0]
#
# MISC section
#
if "MISC" in config:
miscOptions = config["MISC"]
self.weatherTimeOut = int(miscOptions.get("weatherTimeOut", 8 * 60 * 10))
self.rssTimeOut = int(miscOptions.get("rssTimeOut", 8 * 60 * 30))
self.rssApp.verbose = self.verbose = miscOptions.get("verbose", False)
else:
self.weatherTimeOut = 8 * 60 * 10
self.rssTimeOut = 8 * 60 * 30
self.rssApp.verbose = self.verbose = False
self.offscreen_canvas = self.matrix.CreateFrameCanvas()
self.font = graphics.Font()
self.font.LoadFont("./fonts/7x13.bdf")
self.fontB = graphics.Font()
self.fontB.LoadFont("./fonts/7x13B.bdf")
self.fontMed = graphics.Font()
self.fontMed.LoadFont("./fonts/6x9.bdf")
self.fontSmall = graphics.Font()
self.fontSmall.LoadFont("./fonts/5x8.bdf")
self.textColor = graphics.Color(0, 0, 128)
self.xpos = 0
self.lineSpacing = 1
self.degreeSign = "\u00B0"
self.alertArray = []
self.weatherIcon = None
self.feedNo = 0
def __init__(self):
p = psutil.Process()
p.cpu_affinity([3])
with open('../config-clock.json') as f:
s = f.read()
self.config = json.loads(s)
self.map = collections.OrderedDict()
if self.config['mqtt']['enabled']:
self.mqcl = mqtt.Client("led-clock")
self.mqcl.enable_logger()
self.mqcl.on_connect = self.mqtt_connect
self.mqcl.on_message = self.mqtt_message
self.mqcl.connect(self.config['mqtt']['host'],
self.config['mqtt']['port'], 60)
self.icons = {}
self.ledW = 64
self.ledH = 32
self.delay = 0.05
self.clockPos = [0, 14]
self.tempPos = [46, 7]
self.co2Pos = [1, 31]
self.humPos = [1, 23]
self.windSpPos = [25, 23]
self.forecastPos = [41, 23]
self.fontReg = graphics.Font()
self.fontReg.LoadFont("./fonts/10x20.bdf")
self.fontRegW = 8
self.fontRegH = 14
self.fontSm = graphics.Font()
self.fontSm.LoadFont("./fonts/5x8.bdf")
self.fontSmW = 5
self.fontSmH = 7
self.fontSmm = graphics.Font()
self.fontSmm.LoadFont("./fonts/4x6.bdf")
self.fontSmmW = 4
self.imgW = 8
self.imgH = 7
self.userBrightness = None
self.bri = 1
self.prevBri = None
self.initColors()
self.snow = []
self.snowTimer = time.time()
options = RGBMatrixOptions()
options.rows = self.ledH
options.cols = self.ledW
options.chain_length = 1
options.parallel = 1
options.multiplexing = 0
options.pwm_bits = 11
options.pwm_lsb_nanoseconds = 130
options.gpio_slowdown = 2
options.disable_hardware_pulsing = False
options.hardware_mapping = 'regular'
options.row_address_type = 0
options.brightness = 100
options.show_refresh_rate = False
self.matrix = RGBMatrix(options=options)
self.canvas = self.matrix.CreateFrameCanvas()
self.metricsUpdated = 0
self.metrics = None
# this is the size of ONE of our matrixes.
matrix_rows = 32
matrix_columns = 32
# how many matrixes stacked horizontally and vertically
matrix_horizontal = 5
matrix_vertical = 3
total_rows = matrix_rows * matrix_vertical
total_columns = matrix_columns * matrix_horizontal
options = RGBMatrixOptions()
options.rows = matrix_rows
options.cols = matrix_columns
options.chain_length = matrix_horizontal
options.parallel = matrix_vertical
options.hardware_mapping = 'regular'
options.gpio_slowdown = 2
matrix = RGBMatrix(options=options)
def display_jpg():
global matrix
image = Image.open("temp.jpg").convert('RGB')
image = image.resize((total_columns, total_rows))
image = image.transpose(Image.FLIP_LEFT_RIGHT)
matrix.SetImage(image, 0, 0)
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: 1..100. Default: 1", choices=range(3), 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", default=0, type=int, choices=[0, 1, 2])
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)
args = parser.parse_args()
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
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
options.daemon = args.daemon
""" Do not modify this section """ from random import randint from rgbmatrix import RGBMatrix, RGBMatrixOptions # Configuration for the matrix options = RGBMatrixOptions() options.rows = 64 options.chain_length = 4 options.parallel = 1 options.hardware_mapping = 'adafruit-hat' options.led_rgb_sequence = "RBG" matrix = RGBMatrix(options=options)
import time
import sys
import os
import socket
from rgbmatrix import RGBMatrix, RGBMatrixOptions
from rgbmatrix import graphics
options = RGBMatrixOptions()
# This chain is mapped as a 64*2 x 32 grid.
options.rows = 32 # 32 rows per display
options.cols = 64 # 64 rows per display (64x32)
options.chain_length = 2 # 2 displays per chain (128x32)
options.parallel = 1 # 3 (128x96)
matrix = RGBMatrix(options=options)
def draw_graphic(x, y, data, color, canvas):
data = data.replace(' ', '').replace('\n', '')
pos = 0
for j in range(12):
for i in range(12):
if data[pos] == '*':
canvas.SetPixel(x + i, y + j, 100, 255, 255)
pos += 1
def main():
"""
from samplebase.py
"""
sys.path.append(os.path.abspath(os.path.dirname(__file__) + '/..'))
parser = argparse.ArgumentParser()
parser.add_argument(
"-r",
"--led-rows",
action="store",
help="Display rows. 16 for 16x32, 32 for 32x32. Default: 32",
default=32,
type=int)
parser.add_argument(
"--led-cols",
action="store",
help="Panel columns. Typically 32 or 64. (Default: 32)",
default=32,
type=int)
parser.add_argument("-c",
"--led-chain",
action="store",
help="Daisy-chained boards. Default: 1.",
default=1,
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', '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: 1..100. Default: 1",
choices=range(3),
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",
default=0,
type=int,
choices=[0, 1, 2])
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)
args = parser.parse_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.pixel_mapper_config = args.led_pixel_mapper
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
matrix = RGBMatrix(options=options)
try:
# Start loop
print('(C) 2020-2021 MSRoth')
print(
'LED clock on 64x32 LED matrix with weather, market, and news updates.'
)
print('See config.py for details. Press CTRL-C to stop clock.')
print('Loading data...\n\n')
run(matrix)
except KeyboardInterrupt:
print("Exiting\n")
tl.stop()
sys.exit(0)
toMatrixBuffer = Image.new("RGB", (128, 16), "black")
dataFile = open("/home/pi/kristallradarlite/started.txt", "r")
countStart = int(dataFile.readline())
dataFile.close()
countStart += 1
dataFile = open("/home/pi/kristallradarlite/started.txt", "w")
dataFile.write(str(countStart))
dataFile.close()
matrix_options = RGBMatrixOptions()
matrix_options.rows = 16
matrix_options.cols = 32
matrix_options.chain_length = 4
matrix_options.parallel = 1
matrix_options.multiplexing = 4
matrix_options.hardware_mapping = 'adafruit-hat'
matrix_options.gpio_slowdown = 2
matrix_options.pwm_bits = 1
#matrix_options.pwm_dither_bits = 1
matrix_options.brightness = 100
matrix_options.pwm_lsb_nanoseconds = 350
matrix = RGBMatrix(options=matrix_options)
matrix.SetImage(buffer, 0, 0)
while 1:
for i in range(200):
speedValue = i
time.sleep(1)
def main():
if len(sys.argv) < 2:
sys.exit("require a command argument")
else:
image_set = sys.argv[1]
random = False
if image_set is "random":
random = True
sets = {
"broccoli_test": ["broccoli.png", "broccoli_black.png"],
"snorunt":
8,
"fireworks":
23,
"uc_broccoli": [
"uc.png", "uc.png", "uc.png", "broccoli.png", "broccoli.png",
"broccoli.png"
],
"schwifty":
22,
"engineer":
16,
"ea": ["ea.png", "ea.png"],
"meche": ["meche.png", "meche2.png"]
}
random_keys = ["snorunt", "fireworks", "uc_broccoli", "ea", "meche"]
image_path = "images/"
if random:
image_set = random.choice(random_keys)
if isinstance(sets[image_set], (int, long)):
slides = []
for i in range(sets[image_set]):
slides.append(str(i) + ".gif")
else:
slides = sets[image_set]
options = RGBMatrixOptions()
options.rows = 32
options.cols = 32
options.chain_length = 4
options.parallel = 1
options.hardware_mapping = 'adafruit-hat'
matrix = RGBMatrix(options=options)
try:
print("Press CTRL-C to stop")
index = 0
start_time = time.time()
while True:
if random:
if time.time() > (start_time + 30):
start_time = time.time()
index = 0
image_set = random.choice(random_keys)
if isinstance(sets[image_set], (int, long)):
slides = []
for i in range(sets[image_set]):
slides.append(str(i) + ".gif")
else:
slides = sets[image_set]
if index == len(slides):
index = 0
print index
image_file = image_path + image_set + '/' + slides[index]
image = Image.open(image_file)
display_image_to_matrix(image, matrix)
index = index + 1
time.sleep(0.1)
except KeyboardInterrupt:
sys.exit(0)
os.environ.get("LOGFILE", "/var/log/matrix.log"))
formatter = logging.Formatter(logging.BASIC_FORMAT)
handler.setFormatter(formatter)
root = logging.getLogger()
root.setLevel(os.environ.get("LOGLEVEL", "INFO"))
root.addHandler(handler)
config = configparser.ConfigParser()
config.read('config.ini')
####
# Configuration for the matrix
####
options = RGBMatrixOptions()
options.rows = int(config['MATRIX']['ROWS'])
options.cols = int(config['MATRIX']['COLS'])
options.chain_length = int(config['MATRIX']['CHAIN_LENGTH'])
options.hardware_mapping = config['MATRIX']['HARDWARE_MAPPING']
options.brightness = int(config['MATRIX']['BRIGHTNESS'])
####
# Configuration for Gmaps
####
gmaps = googlemaps.Client(key=config['LOCATION']['GOOGLE_API'])
####
# Variables
####
my_zip = config['LOCATION']['ZIP'] # US Zip Code used in the weather module
origin = config['LOCATION']['HOME']
destination = config['LOCATION']['WORK']
ua = 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.93 Safari/537.36'
bustime_api_key = config['MUNI']['API_KEY']
def main():
parser = argparse.ArgumentParser()
# arguments from the RGBMatrix library
parser.add_argument(
"-r",
"--led-rows",
action="store",
help="Display rows. 16 for 16x32, 32 for 32x32. Default: 32",
default=32,
type=int,
)
parser.add_argument(
"--led-cols",
action="store",
help="Panel columns. Typically 32 or 64. (Default: 32)",
default=32,
type=int,
)
parser.add_argument(
"-c",
"--led-chain",
action="store",
help="Daisy-chained boards. Default: 1.",
default=1,
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", "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: 1",
default=1,
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",
default=0,
type=int,
choices=[0, 1, 2],
)
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,
)
args = parser.parse_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.pixel_mapper_config = args.led_pixel_mapper
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
try:
print("Press CTRL-C to stop the clock")
run(options)
except KeyboardInterrupt:
print("Exiting\n")
sys.exit(0)
def run(self):
options = RGBMatrixOptions()
options.rows = 32
options.cols = 64
options.chain_length = 4
options.parallel = 1
options.hardware_mapping = "adafruit-hat-pwm"
options.pixel_mapper_config = "U-mapper"
options.row_address_type = 0
options.multiplexing = 0
options.pwm_bits = 6
options.brightness = 100
options.pwm_lsb_nanoseconds = 130
options.limit_refresh_rate_hz = 200
options.led_rgb_sequence = "RBG"
options.show_refresh_rate = 0
options.gpio_slowdown = 1
self.matrix = RGBMatrix(options=options)
white = graphics.Color(255, 255, 255)
gray = graphics.Color(127, 127, 127)
green = graphics.Color(0, 150, 0)
yellow = graphics.Color(127, 127, 0)
red = graphics.Color(150, 0, 0)
blue = graphics.Color(0, 0, 150)
magenta = graphics.Color(127, 0, 127)
cyan = graphics.Color(0, 127, 127)
dim = graphics.Color(10, 10, 10)
offscreen_canvas = self.matrix.CreateFrameCanvas()
font = graphics.Font()
#main_dir = os.getcwd()
main_dir = "/home/pi/nhlscoreboard"
width = 128
height = 64
font_medium = graphics.Font()
font_medium.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/7x13.bdf")
font_small = graphics.Font()
font_small.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/6x10.bdf")
font_big = graphics.Font()
font_big.LoadFont("/home/pi/rpi-rgb-led-matrix/fonts/9x15.bdf")
fontYoffset = 8
fontYoffset2 = 8
x_offset = -64
gameday = False
season = False
home_roster = {}
away_roster = {}
home_score = 0
home_score_old = 0
away_score = 0
away_score_old = 0
home_team = ""
away_team = ""
live_stats_link = ""
x = 0
y = 10
home_score_color = ""
away_score_color = ""
do_once = 1
ignore_first_score_change = 1
random.seed()
choice = 1
teams = {
1: "NJD",
2: "NYI",
3: "NYR",
4: "PHI",
5: "PIT",
6: "BOS",
7: "BUF",
8: "MTL",
9: "OTT",
10: "TOR",
12: "CAR",
13: "FLA",
14: "TBL",
15: "WSH",
16: "CHI",
17: "DET",
18: "NSH",
19: "STL",
20: "CGY",
21: "COL",
22: "EDM",
23: "VAN",
24: "ANA",
25: "DAL",
26: "LAK",
28: "SJS",
29: "CBJ",
30: "MIN",
52: "WPG",
53: "ARI",
54: "VGK"
}
team_id, delay = self.setup_nhl()
#image = Image.open("/home/pi/nhlscoreboard/images/goal.png")
#self.matrix.SetImage(image.convert('RGB'))
#time.sleep(5)
try:
while (True):
time.sleep(2)
# check if in season
season = nhl.check_season()
season = 1
if season:
# check game
gameday = nhl.check_if_game(team_id)
if gameday:
# check end of game
game_end = nhl.check_game_end(team_id)
if not game_end:
try:
# get score, teams, and live stats link
home_score, home_team, away_score, away_team, live_stats_link = nhl.fetch_game(
team_id)
except TypeError:
continue
# get stats from the game
current_period, home_sog, away_sog, home_powerplay, away_powerplay, time_remaining = nhl.fetch_live_stats(
live_stats_link)
if current_period > 0:
# get the rosters just once at the start
if do_once:
while ((len(home_roster) < 5)
or (len(away_roster) < 5)):
home_roster, away_roster = nhl.fetch_rosters(
live_stats_link)
do_once = 0
# get the players on ice
home_on_ice, away_on_ice = nhl.players_on_ice(
live_stats_link)
# build a list like so for each team
# jersey_number lastname
home_ice_list = []
away_ice_list = []
home_goalie_id, away_goalie_id = nhl.fetch_goalies(
live_stats_link)
for the_id in home_on_ice:
try:
jersey_number = (
home_roster['ID' + str(the_id)]
['jerseyNumber']).encode("ascii")
except:
jersey_number = "0"
if int(jersey_number) < 10:
try:
jersey_number = jersey_number.decode(
"utf-8") + ' '
except:
jersey_number = '00'
else:
try:
jersey_number = jersey_number.decode(
"utf-8")
except:
jersey_number = '00'
try:
last_name = ((
(home_roster['ID' + str(the_id)]
['person']['fullName']).split(
' ', 1))[1]
).encode('utf-8').strip()
except UnicodeEncodeError:
last_name = ' '
try:
temp_thing = jersey_number + ' ' + (
last_name[0:7].upper()
).decode("utf-8")
except TypeError:
temp_thing = ' '
home_ice_list.append(temp_thing)
for the_id in away_on_ice:
try:
jersey_number = (
away_roster['ID' + str(the_id)]
['jerseyNumber']).encode("ascii")
except:
jersey_number = '00'
if int(jersey_number) < 10:
try:
jersey_number = jersey_number.decode(
"ascii") + ' '
except TypeError:
jersey_number = 0
else:
jersey_number = jersey_number.decode(
"utf-8")
try:
last_name = ((
(away_roster['ID' + str(the_id)]
['person']['fullName']).split(
' ', 1))[1]
).encode('utf-8').strip()
except TypeError:
last_name = ' '
try:
temp_thing = jersey_number + ' ' + (
last_name[0:7].upper()
).decode("utf-8")
except TypeError:
temp_thing = ' '
away_ice_list.append(temp_thing)
# determine score colors
if home_score > away_score:
home_score_color = red
away_score_color = green
elif away_score > home_score:
home_score_color = green
away_score_color = red
else:
home_score_color = green
away_score_color = green
# determine team colors
if home_powerplay == 1:
home_team_color = yellow
else:
home_team_color = gray
if away_powerplay == 1:
away_team_color = yellow
else:
away_team_color = gray
# reset x and y
x = 0
y = 0
# clear the offscreen canvas
offscreen_canvas.Clear()
# teams
# away on left
# home on right
# 3-letter team, score, sog
graphics.DrawText(offscreen_canvas, font_small,
0, y + fontYoffset,
away_team_color,
teams[away_team])
graphics.DrawText(offscreen_canvas, font_small,
28, y + fontYoffset,
away_score_color,
str(away_score))
graphics.DrawText(offscreen_canvas, font_small,
49, y + fontYoffset, yellow,
str(away_sog))
y += 8
# players on ice
for line in away_ice_list:
graphics.DrawText(offscreen_canvas,
font_small, 0,
y + fontYoffset, gray,
line)
y += 8
# away on left
y = 0
# 3-letter team, score, sog
graphics.DrawText(offscreen_canvas, font_small,
64, y + fontYoffset,
home_team_color,
teams[home_team])
graphics.DrawText(offscreen_canvas, font_small,
92, y + fontYoffset,
home_score_color,
str(home_score))
graphics.DrawText(offscreen_canvas, font_small,
113, y + fontYoffset, yellow,
str(home_sog))
y += 8
# players on ice
for line in home_ice_list:
graphics.DrawText(offscreen_canvas,
font_small, 64,
y + fontYoffset, gray,
line)
y += 8
y = 64
status, time_remaining = nhl.intermission_status(
live_stats_link)
if status == False:
graphics.DrawText(
offscreen_canvas, font_small, 35, y,
cyan, "PERIOD " + str(current_period))
else:
m, s = divmod(time_remaining, 60)
graphics.DrawText(
offscreen_canvas, font_small, 0, y,
cyan, "INTERMISSION " +
'{:02d}:{:02d}'.format(m, s))
# blit it to the screen
offscreen_canvas = self.matrix.SwapOnVSync(
offscreen_canvas)
# If score change...
if home_score > home_score_old:
home_score_old = home_score
choice = random.randint(1, 3)
if ignore_first_score_change == 0:
if home_team == int(team_id):
time.sleep(delay)
image = Image.open(
"/home/pi/nhlscoreboard/images/goal.png"
)
self.matrix.SetImage(
image.convert('RGB'))
time.sleep(5)
else:
time.sleep(delay)
image = Image.open(
"/home/pi/nhlscoreboard/images/sad-rod.gif"
)
self.matrix.SetImage(
image.convert('RGB'))
time.sleep(5)
else:
ignore_first_score_change = 0
else:
home_score_old = home_score
# If score change...
if away_score > away_score_old:
away_score_old = away_score
choice = random.randint(1, 3)
if ignore_first_score_change == 0:
if away_team == int(team_id):
time.sleep(delay)
image = Image.open(
"/home/pi/nhlscoreboard/images/goal.png"
)
self.matrix.SetImage(
image.convert('RGB'))
time.sleep(5)
else:
time.sleep(delay)
image = Image.open(
"/home/pi/nhlscoreboard/images/sad-rod.gif"
)
self.matrix.SetImage(
image.convert('RGB'))
time.sleep(5)
else:
ignore_first_score_change = 0
else:
away_score_old = away_score
ignore_first_score_change = 0
if current_period == 0:
offscreen_canvas.Clear()
y = 7
x_offset = x_offset + 1
if x_offset > 128:
x_offset = -128
graphics.DrawText(offscreen_canvas, font_small,
x + x_offset, y, blue,
"GAME TODAY!")
y += fontYoffset2
graphics.DrawText(offscreen_canvas, font_small,
x + 10 + x_offset, y, green,
"GAME TODAY!")
y += fontYoffset2
graphics.DrawText(offscreen_canvas, font_small,
x + 20 + x_offset, y, red,
"GAME TODAY!")
y += fontYoffset2
graphics.DrawText(offscreen_canvas, font_small,
x + 30 + x_offset, y, yellow,
"GAME TODAY!")
y += fontYoffset2
graphics.DrawText(offscreen_canvas, font_small,
x + 40 + x_offset, y,
magenta, "GAME TODAY!")
y += fontYoffset2
graphics.DrawText(offscreen_canvas, font_small,
x + 50 + x_offset, y, cyan,
"GAME TODAY!")
y += fontYoffset2
temptime = datetime.datetime.now()
graphics.DrawText(
offscreen_canvas, font_small, 0, y, gray,
temptime.strftime("%m/%d/%y %H:%M"))
y += fontYoffset2
game_start_time = nhl.fetch_game_start_time(
live_stats_link)
graphics.DrawText(
offscreen_canvas, font_small, 0, y, gray,
"GAMETIME: " + game_start_time)
offscreen_canvas = self.matrix.SwapOnVSync(
offscreen_canvas)
else:
home_roster.clear()
away_roster.clear()
old_score = 0 # Reset for new game
current_period = 0
self.matrix.Clear()
offscreen_canvas.Clear()
do_once = 1
self.sleep("day") # sleep till tomorrow
else:
print("No Game Today!")
self.sleep("day") # sleep till tomorrow
else:
print("OFF SEASON!")
self.sleep("season") # sleep till next season
except KeyboardInterrupt:
print("\nCtrl-C pressed")
def draw_board():
"""Draw components of LaLiga game.
Firstly, creates a canvas for the LED matrix using various configurations.
Requests games for the day for La Liga and draws various components of the game such as team logos, scores, period, and time.
Also, draws "SCORE!!!" animation for the game if there is an update in the score.
If button is pressed during the execution, it will load the next game. If the game is the last one for the day in La Liga, then it will
go to the next league.
Returns:
int: Return -1 if no favorite game.
"""
# Configuration for the matrix
options = RGBMatrixOptions()
options.rows = ROWS
options.cols = COLS
options.chain_length = 1
options.parallel = 1
options.brightness = BRIGHTNESS
options.hardware_mapping = 'adafruit-hat'
image_size = ROWS if ROWS < COLS else COLS
matrix = RGBMatrix(options=options)
canvas = matrix.CreateFrameCanvas()
font = graphics.Font()
font.LoadFont("./fonts/tom-thumb.bdf")
anifont = graphics.Font()
anifont.LoadFont("./fonts/cherry-10-b.bdf")
textColor = graphics.Color(225, 225, 0)
height_first_row = 9
height_second_row = 18
height_third_row = 27
# Control button
button = Button(GPIO_CONTROL)
it = 0
wait = 0
# Loading La Liga
canvas.Clear()
graphics.DrawText(canvas, font,
10,
height_second_row, textColor, 'Loading LaL')
canvas = matrix.SwapOnVSync(canvas)
games = Scores.get_scores()
if len(games) == 0:
# Print no games scheduled
canvas.Clear()
graphics.DrawText(canvas, font,
4,
height_second_row, textColor, 'LaL - no games')
canvas = matrix.SwapOnVSync(canvas)
# Handle control button and wait
button.wait_for_press(15)
return -1
while it < len(games):
canvas.Clear()
score_len = 20
if 'score' in games[it]:
# Chagne score len if 2 digit score
score_len = 28 if games[it]['score'][3] == '-' else 20
# Get x coords for logos
image_space = (COLS - score_len - 4) / 2
x_away = -ROWS + image_space - 2
x_home = image_space + score_len + 2
# Get logos as thumbnails; home is flipped for right
image_away = Image.open(f"logos/LaLiga/{games[it]['away']}_logo.png")
image_away.thumbnail((image_size, image_size), Image.ANTIALIAS)
image_home = Image.open(f"logos/LaLiga/{games[it]['home']}_logo.png")
image_home.thumbnail((image_size, image_size), Image.ANTIALIAS)
# Print logos
canvas.SetImage(image_away.convert('RGB'), x_away, 0)
canvas.SetImage(image_home.convert('RGB'), x_home, 0)
# Print score final or live
score_len = len(games[it]['score'])*4
if games[it]['stage'] == 'Scheduled':
# If planned game, print @ and time
clock_len = len(games[it]['clock'])*4
graphics.DrawText(canvas, font,
int((COLS - 8) / 2),
height_first_row, textColor, "AT")
graphics.DrawText(canvas, font,
int((COLS - clock_len) / 2),
height_second_row, textColor, games[it]['clock'])
graphics.DrawText(canvas, font,
int((COLS - 12) / 2),
height_third_row, textColor, 'GMT')
elif games[it]['stage'] == 'Full Time':
# Else print 'fin' to indicate final score
graphics.DrawText(canvas, font,
int((COLS - 12) / 2),
height_first_row, textColor, "FIN")
graphics.DrawText(canvas, font,
int((COLS - score_len) / 2),
height_second_row, textColor, games[it]['score'])
else:
# If game is in progress, print period
# and time left in the period
period_len = len(games[it]['period'])*4
clock_len = len(games[it]['clock'])*4
graphics.DrawText(canvas, font,
int((COLS - period_len) / 2),
height_first_row, textColor,
games[it]['period'])
graphics.DrawText(canvas, font,
int((COLS - score_len) / 2),
height_second_row, textColor, games[it]['score'])
graphics.DrawText(canvas, font,
int((COLS - clock_len) / 2),
height_third_row, textColor, games[it]['clock'])
# Handle control button and wait
is_button_pressed = button.wait_for_press(5)
# Increment iterator if button was pressed
if is_button_pressed:
it += 1
time.sleep(1)
# Mention to the user that they should wait after pressing the button
# for about 5-10 seconds as it takes a while to fetch score
wait += 1
if wait > 12 and it < len(games):
wait = 0
tmp = Scores.get_scores()
# Check if new fixes
if games[it]['away'] != games[it]['away'] and \
tmp[it]['home'] != tmp[it]['home']:
it = 0
elif (games[it]['stage'] != 'Scheduled' and games[it]['stage'] == 'Full Time') \
and games[it]['score'] != tmp[it]['score']:
# check for score update
pos = ROWS
rounds = 0
while True:
canvas.Clear()
l = graphics.DrawText(
canvas, anifont, pos, height_second_row, textColor, 'GOAL!!!')
pos -= 1
if (pos + l < 0):
pos = ROWS
rounds += 1
if rounds > 3:
break
time.sleep(0.05)
canvas = matrix.SwapOnVSync(canvas)
games = tmp
canvas = matrix.SwapOnVSync(canvas)
filename='spotipy.log',
level=logging.INFO)
logger = logging.getLogger('spotipy_logger')
# automatically deletes logs more than 2000 bytes
handler = RotatingFileHandler('spotipy.log', maxBytes=2000, backupCount=3)
logger.addHandler(handler)
# Configuration for the matrix
config = configparser.ConfigParser()
config.read(filename)
options = RGBMatrixOptions()
options.rows = int(config['DEFAULT']['rows'])
options.cols = int(config['DEFAULT']['columns'])
options.chain_length = int(config['DEFAULT']['chain_length'])
options.parallel = int(config['DEFAULT']['parallel'])
options.hardware_mapping = config['DEFAULT']['hardware_mapping']
options.gpio_slowdown = int(config['DEFAULT']['gpio_slowdown'])
options.brightness = int(config['DEFAULT']['brightness'])
default_image = os.path.join(dir, config['DEFAULT']['default_image'])
print(default_image)
matrix = RGBMatrix(options=options)
try:
while True:
try:
imageURL = getSongInfo(username, token_path)[1]
response = requests.get(imageURL)
image = Image.open(BytesIO(response.content))
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:
time.sleep(100)
except KeyboardInterrupt:
def main(args):
device_lat = args.device_lat
device_long = args.device_long
feeder_url = args.fr24_feeder_host
fonts_home = args.fonts_home
# Configuration for the LED matrix
options = RGBMatrixOptions()
options.cols = 64
options.rows = 32
options.chain_length = 1
options.brightness = 40
options.pwm_dither_bits = 1
options.pwm_lsb_nanoseconds = 50
options.parallel = 1
options.gpio_slowdown = 2 # reduces flicker
#options.hardware_mapping = 'regular' # If you have an Adafruit HAT: 'adafruit-hat'
matrix = RGBMatrix(options=options)
font = graphics.Font()
font.LoadFont(f'{fonts_home}/5x7.bdf')
font2 = graphics.Font()
font2.LoadFont(f'{fonts_home}/6x10.bdf')
green = graphics.Color(0, 255, 0)
graphics.DrawText(matrix, font, 0, 7, green, 'No aircraft')
graphics.DrawText(matrix, font, 0, 14, green, 'found')
try:
print('Press CTRL-C to stop.')
while True:
t = threading.Thread(target=get_aircraft(feeder_url))
t.run()
if aircraft_change:
logger.info('Refreshing aircraft list')
matrix.Clear()
index = 1
if len(aircraft_map.keys()) > 0:
for aircraft in aircraft_map.keys():
matrix.Clear()
aircraft_mode_s_transponder = aircraft_map.get(aircraft)[0]
aircraft_lat = aircraft_map.get(aircraft)[1]
aircraft_long = aircraft_map.get(aircraft)[2]
aircraft_ground_speed = aircraft_map.get(aircraft)[5]
aircraft_squawk = aircraft_map.get(aircraft)[6]
aircraft_callsign = aircraft_map.get(aircraft)[-1]
# Draw ADS-B Mode S transponder code
graphics.DrawText(matrix, font, 0, index * 7, green, f'ModeS: {aircraft_mode_s_transponder}')
# Draw aircraft callsign
if aircraft_callsign:
graphics.DrawText(matrix, font, 0, (index + 1) * 7, green, f'Sign: {aircraft_callsign}')
else:
graphics.DrawText(matrix, font, 0, (index + 1) * 7, green, f'Sign: unknown')
if aircraft_lat and aircraft_long:
geodesic_dict = Geodesic.WGS84.Inverse(float(device_lat), float(device_long), aircraft_lat,
aircraft_long)
azimuth = geodesic_dict['azi1']
distance_meters = geodesic_dict['s12']
distance_miles = 0.000621371 * distance_meters
heading = float(azimuth)
logger.info(f'heading: {heading:.3f}')
# Correct for negative headings
if heading < 0:
heading = heading + 360
logger.info(f'corrected heading: {heading:.3f}')
cardinal_direction = get_direction_from_heading(heading)
logger.info(f'cardinal direction: {cardinal_direction}')
# adjust heading from display orientation
display_heading = 240.0
adjusted_heading = 360 - display_heading + heading
logger.info(f'adjusted heading: {adjusted_heading:.3f}°')
# correct for heading over 360°
if adjusted_heading > 360:
adjusted_heading = adjusted_heading - 360
logger.info(f'adjusted heading (corrected): {adjusted_heading:.3f}°')
arrow_direction = get_direction_from_heading(adjusted_heading)
# Draw cardinal direction and arrow
graphics.DrawText(matrix, font2, 0, ((index + 2) * 7) + 1, green, cardinal_direction)
graphics.DrawText(matrix, font2, 0, ((index + 3) * 7) + 2, green, cardinal_arrows_map[
arrow_direction])
graphics.DrawText(matrix, font2, 22, ((index + 3) * 7) + 2, green, f'{distance_miles:.2f} mi')
else:
graphics.DrawText(matrix, font2, 0, ((index + 2) * 7) + 1, green, '?')
graphics.DrawText(matrix, font2, 0, ((index + 3) * 7) + 2, green, '?')
if aircraft_ground_speed:
graphics.DrawText(matrix, font2, 22, ((index + 2) * 7) + 1, green, f'{aircraft_ground_speed} kts')
time.sleep(10)
else:
graphics.DrawText(matrix, font, 0, 7, green, "No aircraft")
graphics.DrawText(matrix, font, 0, 14, green, "found")
time.sleep(60)
except KeyboardInterrupt:
sys.exit(0)