def __init__(self, config):
from rgbmatrix import RGBMatrix, RGBMatrixOptions
options = RGBMatrixOptions()
options.rows = config.getint('rows')
options.cols = config.getint('cols')
options.hardware_mapping = config['led_hardware_mapping']
options.chain_length = config.getint('led_chain')
options.parallel = config.getint('led_parallel')
options.pwm_bits = config.getint('led_pwm_bits')
options.brightness = config.getint('led_brightness')
options.pwm_lsb_nanoseconds = config.getint('led_pwm_lsb_nanoseconds')
options.inverse_colors = config.getboolean('led_inverse')
options.led_rgb_sequence = config['led_rgb_sequence']
options.pixel_mapper_config = config['led_pixel_mapper']
options.row_address_type = config.getint('led_row_addr_type')
options.multiplexing = config.getint('led_multiplexing')
options.scan_mode = config.getint('led_scan_mode')
options.gpio_slowdown = config.getint('led_slowdown_gpio')
options.disable_hardware_pulsing = config.getboolean(
'led_no_hardware_pulse')
options.show_refresh_rate = config.getboolean('led_show_refresh')
options.pwm_dither_bits = config.getint('led_pwm_dither_bits')
#options.panel_type = config['led_panel_type']
self.matrix = RGBMatrix(options=options)
self.offscreen_canvas = self.matrix.CreateFrameCanvas()
def led_matrix_options(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
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."
)
try:
options.pwm_dither_bits = args.led_pwm_dither_bits
except AttributeError:
debug.warning("Your compiled RGB Matrix Library is out of date.")
debug.warning(
"The --led-pwm-dither-bits argument will not work until it is updated."
)
try:
options.limit_refresh_rate_hz = args.led_limit_refresh
except AttributeError:
debug.warning("Your compiled RGB Matrix Library is out of date.")
debug.warning(
"The --led-limit-refresh argument will not work until it is updated."
)
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
return options
def matrix_factory(width):
if not IS_PRODUCTION:
return MockMatrix()
options = RGBMatrixOptions()
# `pwm` requires small hardware mod but greatly improves flicker
options.hardware_mapping = "adafruit-hat-pwm"
options.chain_length = 1
options.rows = width
# these settings work well on a zero wh
options.gpio_slowdown = 0
options.pwm_lsb_nanoseconds = 100
options.pwm_dither_bits = 1
options.brightness = 35
options.pixel_mapper_config = "Rotate:90"
matrix = RGBMatrix(options=options)
return matrix
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 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)
