class TrafficNotAvailable(AhrsElement):
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('TrafficNotAvailable')
self.__font__ = font
font_height = font.get_height()
self.__text_y_pos__ = int(font_height * 0.7)
self.__rhs__ = int(0.9 * framebuffer_size[0])
self.__left_x__ = int(framebuffer_size[0] * 0.01)
self.__center_x__ = framebuffer_size[0] >> 1
def render(self, framebuffer, orientation):
self.task_timer.start()
if not HudDataCache.IS_TRAFFIC_AVAILABLE:
(texture, size) = HudDataCache.get_cached_text_texture(
"TRAFFIC UNAVAILABLE",
self.__font__,
text_color=RED,
background_color=BLACK,
use_alpha=True)
width = size[0]
framebuffer.blit(texture, (self.__center_x__ -
(width >> 1), self.__text_y_pos__))
self.task_timer.stop()
class RollIndicatorText(AhrsElement):
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('RollIndicatorText')
self.__roll_elements__ = {}
self.__framebuffer_size__ = framebuffer_size
self.__center__ = (framebuffer_size[0] >> 1, framebuffer_size[1] >> 1)
half_texture_height = int(font.get_height()) >> 1
self.__font__ = font
self.__text_y_pos__ = self.__center__[1] - half_texture_height
for reference_angle in range(-180, 181):
text = font.render(
"{0:3}".format(int(math.fabs(reference_angle))), True, display.WHITE, display.BLACK)
size_x, size_y = text.get_size()
self.__roll_elements__[reference_angle] = (
text, (size_x >> 1, size_y >> 1))
def render(self, framebuffer, orientation):
self.task_timer.start()
roll = int(orientation.roll)
pitch = int(orientation.pitch)
pitch_direction = ''
if pitch > 0:
pitch_direction = '+'
attitude_text = "{0}{1:3} | {2:3}".format(pitch_direction, pitch, roll)
roll_texture = self.__font__.render(
attitude_text, True, display.BLACK, display.WHITE)
texture_size = roll_texture.get_size()
text_half_width, text_half_height = texture_size
text_half_width = int(text_half_width / 2)
framebuffer.blit(
roll_texture, (self.__center__[0] - text_half_width, self.__text_y_pos__))
self.task_timer.stop()
class Groundspeed(AhrsElement):
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('Groundspeed')
self.__font__ = font
center_y = framebuffer_size[1] >> 2
text_half_height = int(font.get_height()) >> 1
self.__text_y_pos__ = (text_half_height << 2) + \
center_y - text_half_height
self.__rhs__ = int(0.9 * framebuffer_size[0])
self.__left_x__ = 0 # WAS int(framebuffer_size[0] * 0.01)
def render(self, framebuffer, orientation):
self.task_timer.start()
speed_units = configuration.CONFIGURATION.__get_config_value__(
configuration.Configuration.DISTANCE_UNITS_KEY, units.STATUTE)
groundspeed_text = units.get_converted_units_string(
speed_units,
orientation.groundspeed * units.feet_to_nm,
unit_type=units.SPEED,
decimal_places=False
) if orientation.groundspeed is not None and isinstance(
orientation.groundspeed, Number) else "INOP"
display_color = display.WHITE if orientation is not None and orientation.groundspeed is not None and orientation.gps_online else display.RED
texture = self.__font__.render(groundspeed_text, True, display_color,
display.BLACK)
framebuffer.blit(texture, (self.__left_x__, self.__text_y_pos__))
self.task_timer.stop()
class Time(AhrsElement):
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('Time')
self.__font__ = font
font_height = font.get_height()
text_half_height = int(font_height) >> 1
self.__text_y_pos__ = framebuffer_size[
1] - text_half_height - font_height
self.__rhs__ = int(0.9 * framebuffer_size[0])
self.__left_x__ = int(framebuffer_size[0] * 0.01)
self.__center_x__ = framebuffer_size[0] >> 1
def render(self, framebuffer, orientation):
self.task_timer.start()
time_text = str(orientation.utc_time).split(
'.'
)[0] + "UTC" if orientation.utc_time is not None else AhrsElement.GPS_UNAVAILABLE_TEXT
texture = self.__font__.render(time_text, True, YELLOW, BLACK)
width = texture.get_size()[0]
framebuffer.blit(texture, (self.__center_x__ -
(width >> 1), self.__text_y_pos__))
self.task_timer.stop()
def __init__(
self,
degrees_of_pitch,
pixels_per_degree_y,
font,
framebuffer_size
):
CompassAndHeadingTopElement.__init__(
self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size)
self.task_timer = TaskTimer('CompassAndHeadingBottomElement')
self.__line_top__ = framebuffer_size[1] - self.line_height
self.__line_bottom__ = framebuffer_size[1]
self.heading_text_y = self.__line_top__ - (font.get_height() * 1.2)
self._heading_box_y_ = framebuffer_size[1] - \
int(font.get_height() * 2.8)
self.compass_text_y = framebuffer_size[1] - \
int(font.get_height())
self.__border_width__ = 4
text_height = font.get_height()
border_vertical_size = (text_height >> 1) + (text_height >> 2)
vertical_alignment_offset = int(
(border_vertical_size / 2.0) + 0.5) + self.__border_width__
half_width = int(self.__heading_text__[360][1][0] * 3.5)
self.__heading_text_box_lines__ = [
[self.__center_x__ - half_width,
self._heading_box_y_ - border_vertical_size + vertical_alignment_offset],
[self.__center_x__ + half_width,
self._heading_box_y_ - border_vertical_size + vertical_alignment_offset],
[self.__center_x__ + half_width,
self._heading_box_y_ + border_vertical_size + vertical_alignment_offset],
[self.__center_x__ - half_width,
self._heading_box_y_ + border_vertical_size + vertical_alignment_offset]]
class AhrsNotAvailable(object):
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('AhrsNotAvailable')
self.__not_available_lines__ = []
width, height = framebuffer_size
self.__not_available_lines__.append([[0, 0], [width, height]])
self.__not_available_lines__.append([[0, height], [width, 0]])
self.__na_color__ = RED
self.__na_line_width__ = 20
def render(self, framebuffer, orientation):
"""
Render an "X" over the screen to indicate the AHRS is not
available.
"""
self.task_timer.start()
pygame.draw.line(framebuffer, self.__na_color__,
self.__not_available_lines__[0][0],
self.__not_available_lines__[0][1],
self.__na_line_width__)
pygame.draw.line(framebuffer, self.__na_color__,
self.__not_available_lines__[1][0],
self.__not_available_lines__[1][1],
self.__na_line_width__)
self.task_timer.stop()
class Altitude(AhrsElement):
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('Altitude')
self.__font__ = font
center_y = framebuffer_size[1] >> 2
text_half_height = int(font.get_height()) >> 1
self.__text_y_pos__ = center_y - text_half_height
self.__rhs__ = int(framebuffer_size[0]) # was 0.9
def render(self, framebuffer, orientation):
self.task_timer.start()
is_altitude_valid = orientation.alt is not None and isinstance(orientation.alt, Number)
altitude_text = str(int(orientation.alt)) + \
"' MSL" if is_altitude_valid else AhrsElement.INOPERATIVE_TEXT
color = display.WHITE if is_altitude_valid else display.RED
alt_texture = self.__font__.render(
altitude_text,
True,
color,
display.BLACK)
text_width, text_height = alt_texture.get_size()
framebuffer.blit(
alt_texture, (self.__rhs__ - text_width, self.__text_y_pos__))
self.task_timer.stop()
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('Altitude')
self.__font__ = font
center_y = framebuffer_size[1] >> 2
text_half_height = int(font.get_height()) >> 1
self.__text_y_pos__ = center_y - text_half_height
self.__rhs__ = int(framebuffer_size[0]) # was 0.9
class LevelReference(AhrsElement):
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('LevelReference')
self.level_reference_lines = []
width = framebuffer_size[0]
center = (framebuffer_size[0] >> 1, framebuffer_size[1] >> 1)
edge_reference_proportion = int(width * 0.05)
artificial_horizon_level = [[int(width * 0.4), center[1]],
[int(width * 0.6), center[1]]]
left_hash = [[0, center[1]], [edge_reference_proportion, center[1]]]
right_hash = [[width - edge_reference_proportion,
center[1]], [width, center[1]]]
self.level_reference_lines.append(artificial_horizon_level)
self.level_reference_lines.append(left_hash)
self.level_reference_lines.append(right_hash)
def render(self, framebuffer, orientation):
"""
Renders a "straight and level" line to the HUD.
"""
self.task_timer.start()
[pygame.draw.lines(framebuffer, WHITE, False, line, 6)
for line in self.level_reference_lines]
self.task_timer.stop()
class Groundspeed(AhrsElement):
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('Groundspeed')
self.__font__ = font
center_y = framebuffer_size[1] >> 2
text_half_height = int(font.get_height()) >> 1
self.__text_y_pos__ = (text_half_height << 2) + \
center_y - text_half_height
self.__rhs__ = int(0.9 * framebuffer_size[0])
self.__left_x__ = 0 # WAS int(framebuffer_size[0] * 0.01)
def render(self, framebuffer, orientation):
self.task_timer.start()
speed_units = configuration.CONFIGURATION.__get_config_value__(
configuration.Configuration.DISTANCE_UNITS_KEY, units.STATUTE)
groundspeed_text = units.get_converted_units_string(
speed_units, orientation.groundspeed * units.feet_to_nm, units.SPEED)
texture = self.__font__.render(
groundspeed_text, True, WHITE, BLACK)
framebuffer.blit(
texture, (self.__left_x__, self.__text_y_pos__))
self.task_timer.stop()
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('Aithre')
self.__font__ = font
center_y = framebuffer_size[1] >> 2
text_half_height = int(font.get_height()) >> 1
self.__text_y_pos__ = center_y + (10 * text_half_height)
self.__lhs__ = 0
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('Groundspeed')
self.__font__ = font
center_y = framebuffer_size[1] >> 2
text_half_height = int(font.get_height()) >> 1
self.__text_y_pos__ = (text_half_height << 2) + \
center_y - text_half_height
self.__rhs__ = int(0.9 * framebuffer_size[0])
self.__left_x__ = 0 # WAS int(framebuffer_size[0] * 0.01)
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('TrafficNotAvailable')
self.__font__ = font
font_height = font.get_height()
self.__text_y_pos__ = int(font_height * 0.7)
self.__rhs__ = int(0.9 * framebuffer_size[0])
self.__left_x__ = int(framebuffer_size[0] * 0.01)
self.__center_x__ = framebuffer_size[0] >> 1
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('Illyrian')
self.__font__ = font
center_y = framebuffer_size[1] >> 2
text_half_height = int(font.get_height()) >> 1
self.__text_y_pos__ = center_y + (6 * text_half_height)
self.__pulse_y_pos__ = center_y + (8 * text_half_height)
self.__lhs__ = 0
self.__has_been_connected__ = False
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
AdsbElement.__init__(
self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size)
self.task_timer = TaskTimer('AdsbTargetBugs')
self.__listing_text_start_y__ = int(self.__font__.get_height() * 4)
self.__listing_text_start_x__ = int(
self.__framebuffer_size__[0] * 0.01)
self.__next_line_distance__ = int(font.get_height() * 1.5)
self.__top_border__ = 0
self.__bottom_border__ = self.__height__ - int(self.__height__ * 0.1)
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('AhrsNotAvailable')
self.__not_available_lines__ = []
width, height = framebuffer_size
self.__not_available_lines__.append([[0, 0], [width, height]])
self.__not_available_lines__.append([[0, height], [width, 0]])
self.__na_color__ = RED
self.__na_line_width__ = 20
class SystemInfo(AhrsElement):
def uses_ahrs(self):
"""
The diagnostics page does not use AHRS.
Returns:
bool -- Always returns False.
"""
return False
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('Time')
self.__font__ = font
self.font_height = font.get_height()
text_half_height = int(self.font_height) >> 1
self.__text_y_pos__ = framebuffer_size[1] - \
text_half_height - self.font_height
self.__rhs__ = int(0.9 * framebuffer_size[0])
self.__left_x__ = int(framebuffer_size[0] * 0.01)
self.__center_x__ = framebuffer_size[0] >> 1
def render(self, framebuffer, orientation):
self.task_timer.start()
# Status lines are pushed in as a stack.
# First line in the array is at the bottom.
# Last line in the array is towards the top.
info_lines = [
["IP : ", get_ip_address()],
["HUD CPU : ", get_cpu_temp()],
["SOCKET : ", get_websocket_uptime()],
["DECLINATION : ", [
str(configuration.CONFIGURATION.get_declination()), BLUE]],
["OWNSHIP : ", [configuration.CONFIGURATION.ownship, BLUE]]
]
render_y = self.__text_y_pos__
for line in info_lines:
# Draw the label in a standard color.
texture_lhs = self.__font__.render(line[0], True, BLUE, BLACK)
framebuffer.blit(texture_lhs, (0, render_y))
size = texture_lhs.get_size()
# Draw the value in the encoded colors.
texture_rhs = self.__font__.render(
line[1][0], True, line[1][1], BLACK)
framebuffer.blit(texture_rhs, (size[0], render_y))
render_y = render_y - (self.font_height * 1.2)
self.task_timer.stop()
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('Time')
self.__font__ = font
self.font_height = font.get_height()
text_half_height = int(self.font_height) >> 1
self.__text_y_pos__ = framebuffer_size[1] - \
text_half_height - self.font_height
self.__rhs__ = int(0.9 * framebuffer_size[0])
self.__left_x__ = int(framebuffer_size[0] * 0.01)
self.__center_x__ = framebuffer_size[0] >> 1
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('CompassAndHeadingTopElement')
self.__framebuffer_size__ = framebuffer_size
self.__center__ = (framebuffer_size[0] >> 1, framebuffer_size[1] >> 1)
self.__long_line_width__ = self.__framebuffer_size__[0] * 0.2
self.__short_line_width__ = self.__framebuffer_size__[0] * 0.1
self.__pixels_per_degree_y__ = pixels_per_degree_y
self.heading_text_y = int(font.get_height())
self.compass_text_y = int(font.get_height())
self.pixels_per_degree_x = framebuffer_size[0] / 360.0
cardinal_direction_line_proportion = 0.2
self.line_height = int(
framebuffer_size[1] * cardinal_direction_line_proportion)
self.__font__ = font
self.__heading_text__ = {}
for heading in range(-1, 361):
texture = self.__font__.render(
str(heading), True, display.BLACK, display.YELLOW).convert()
width, height = texture.get_size()
self.__heading_text__[heading] = texture, (width >> 1, height >> 1)
text_height = font.get_height()
border_vertical_size = (text_height >> 1) + (text_height >> 2)
half_width = int(self.__heading_text__[360][1][0] * 3.5)
self.__center_x__ = self.__center__[0]
self.__heading_text_box_lines__ = [
[self.__center_x__ - half_width,
self.compass_text_y + (1.5 * text_height) - border_vertical_size],
[self.__center_x__ + half_width,
self.compass_text_y + (1.5 * text_height) - border_vertical_size],
[self.__center_x__ + half_width,
self.compass_text_y + (1.5 * text_height) + border_vertical_size],
[self.__center_x__ - half_width,
self.compass_text_y + (1.5 * text_height) + border_vertical_size]]
self.__heading_strip_offset__ = {}
for heading in range(0, 181):
self.__heading_strip_offset__[heading] = int(
self.pixels_per_degree_x * heading)
self.__heading_strip__ = {}
for heading in range(0, 361):
self.__heading_strip__[
heading] = self.__generate_heading_strip__(heading)
self.__render_heading_mark_timer__ = TaskTimer("HeadingRender")
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('RollIndicatorText')
self.__roll_elements__ = {}
self.__framebuffer_size__ = framebuffer_size
self.__center__ = (framebuffer_size[0] >> 1, framebuffer_size[1] >> 1)
half_texture_height = int(font.get_height()) >> 1
self.__font__ = font
self.__text_y_pos__ = self.__center__[1] - half_texture_height
for reference_angle in range(-180, 181):
text = font.render(
"{0:3}".format(int(math.fabs(reference_angle))), True, display.WHITE, display.BLACK)
size_x, size_y = text.get_size()
self.__roll_elements__[reference_angle] = (
text, (size_x >> 1, size_y >> 1))
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('Time')
self.__font__ = font
self.font_height = font.get_height()
self.__text_y_pos__ = framebuffer_size[1] - self.font_height
self.__rhs__ = int(0.9 * framebuffer_size[0])
self.__left_x__ = int(framebuffer_size[0] * 0.01)
self.__center_x__ = framebuffer_size[0] >> 1
self.__update_ip_timer__ = 0
self.__update_temp_timer__ = 0
self.__ip_address__ = get_ip_address()
self.__cpu_temp__ = None
self.__framebuffer_size__ = framebuffer_size
self.__line_spacing__ = 1.01
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('ArtificialHorizon')
self.__pitch_elements__ = {}
self.__framebuffer_size__ = framebuffer_size
self.__center__ = (framebuffer_size[0] >> 1, framebuffer_size[1] >> 1)
self.__long_line_width__ = self.__framebuffer_size__[0] * 0.4
self.__short_line_width__ = self.__framebuffer_size__[0] * 0.2
self.__pixels_per_degree_y__ = pixels_per_degree_y
self.__height__ = framebuffer_size[1]
for reference_angle in range(-degrees_of_pitch, degrees_of_pitch + 1,
10):
text = font.render(str(reference_angle), True, WHITE,
BLACK).convert()
size_x, size_y = text.get_size()
self.__pitch_elements__[reference_angle] = (text, (size_x >> 1,
size_y >> 1))
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('LevelReference')
self.level_reference_lines = []
width = framebuffer_size[0]
center = (framebuffer_size[0] >> 1, framebuffer_size[1] >> 1)
edge_reference_proportion = int(width * 0.05)
artificial_horizon_level = [[int(width * 0.4), center[1]],
[int(width * 0.6), center[1]]]
left_hash = [[0, center[1]], [edge_reference_proportion, center[1]]]
right_hash = [[width - edge_reference_proportion,
center[1]], [width, center[1]]]
self.level_reference_lines.append(artificial_horizon_level)
self.level_reference_lines.append(left_hash)
self.level_reference_lines.append(right_hash)
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('ArtificialHorizon')
self.__framebuffer_size__ = framebuffer_size
self.__center__ = (framebuffer_size[0] >> 1, framebuffer_size[1] >> 1)
self.__long_line_width__ = self.__framebuffer_size__[0] * 0.4
self.__short_line_width__ = self.__framebuffer_size__[0] * 0.2
self.__pixels_per_degree_y__ = int(pixels_per_degree_y)
self.__height__ = framebuffer_size[1]
self.__font__ = font
self.__reference_angles__ = range(-degrees_of_pitch,
degrees_of_pitch + 1, 10)
self.__pitch_elements__ = {
reference_angle:
self.__generate_rotated_reference_angle__(reference_angle)
for reference_angle in self.__reference_angles__
}
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('RollIndicator')
self.__framebuffer_size__ = framebuffer_size
self.__center__ = (framebuffer_size[0] >> 1, framebuffer_size[1] >> 1)
half_texture_height = int(font.get_height()) >> 1
self.__font__ = font
self.__text_y_pos__ = self.__center__[1] - half_texture_height
self.arc_radius = int(framebuffer_size[1] / 3)
self.top_arc_squash = 0.75
self.arc_angle_adjust = math.pi / 8.0
self.roll_indicator_arc_radians = 0.03
self.arc_box = [self.__center__[0] - self.arc_radius, self.__center__[1] - (
self.arc_radius / 2), self.arc_radius * 2, (self.arc_radius * 2) * self.top_arc_squash]
self.reference_line_size = 20
self.reference_arc_box = [self.arc_box[0], self.arc_box[1] - self.reference_line_size,
self.arc_box[2], self.arc_box[3] - self.reference_line_size]
self.smaller_reference_arc_box = [self.arc_box[0], self.arc_box[1] - (
self.reference_line_size/2), self.arc_box[2], self.arc_box[3] - (self.reference_line_size/2)]
self.half_pi = math.pi / 2.0
class SkidAndGs(AhrsElement):
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('SkidAndGs')
self.__font__ = font
center_y = framebuffer_size[1] >> 2
text_half_height = int(font.get_height()) >> 1
self.__text_y_pos__ = (text_half_height << 2) + \
center_y - text_half_height
self.__rhs__ = int(framebuffer_size[0]) # was 0.9
def render(self, framebuffer, orientation):
self.task_timer.start()
g_load_text = "{0:.1f}Gs".format(orientation.g_load)
texture = self.__font__.render(
g_load_text, True, WHITE, BLACK)
text_width, text_height = texture.get_size()
framebuffer.blit(
texture, (self.__rhs__ - text_width, self.__text_y_pos__))
self.task_timer.stop()
class TargetCount(AhrsElement):
def uses_ahrs(self):
"""
Does this element use AHRS data to render?
Returns:
bool -- True if the element uses AHRS data.
"""
return False
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('TargetCount')
self.__font__ = font
center_y = framebuffer_size[1] >> 2
text_half_height = int(font.get_height()) >> 1
self.__text_y_pos__ = center_y - text_half_height
self.__rhs__ = int(0.9 * framebuffer_size[0])
self.__left_x__ = 0 # WAS int(framebuffer_size[0] * 0.01)
def render(self, framebuffer, orientation):
self.task_timer.start()
# Get the traffic, and bail out of we have none
text = "NO TARGETS"
try:
count = len(targets.TARGET_MANAGER.targets)
if count > 0:
text = "{0} TARGETS".format(count)
except Exception as e:
text = "ERROR" + str(e)
texture = self.__font__.render(text, True, WHITE, BLACK)
framebuffer.blit(texture, (self.__left_x__, self.__text_y_pos__))
self.task_timer.stop()
class Aithre(AhrsElement):
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('Aithre')
self.__font__ = font
center_y = framebuffer_size[1] >> 2
text_half_height = int(font.get_height()) >> 1
self.__text_y_pos__ = center_y - text_half_height
self.__lhs__ = 0
self.__has_been_connected__ = False
def render(self, framebuffer, orientation):
self.task_timer.start()
if aithre.sensor is not None and configuration.CONFIGURATION.aithre_enabled:
co_level = aithre.sensor.get_co_level()
if co_level is None or isinstance(co_level, basestring):
if self.__has_been_connected__:
co_color = RED
co_ppm_text = "OFFLINE"
else:
self.task_timer.stop()
return
else:
co_color = get_aithre_co_color(co_level)
co_ppm_text = str(int(co_level)) + " PPM"
self.__has_been_connected__ = True
co_ppm_texture = self.__font__.render(co_ppm_text, True, co_color,
BLACK)
framebuffer.blit(co_ppm_texture,
(self.__lhs__, self.__text_y_pos__))
self.task_timer.stop()
class Illyrian(AhrsElement):
"""
Screen element to support the Illyrian blood/pulse oxymeter from Aithre
"""
def uses_ahrs(self):
"""
Does this element use AHRS data to render?
Returns:
bool -- True if the element uses AHRS data.
"""
return False
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font,
framebuffer_size):
self.task_timer = TaskTimer('Illyrian')
self.__font__ = font
center_y = framebuffer_size[1] >> 2
text_half_height = int(font.get_height()) >> 1
self.__text_y_pos__ = center_y + (6 * text_half_height)
self.__pulse_y_pos__ = center_y + (8 * text_half_height)
self.__lhs__ = 0
self.__has_been_connected__ = False
def render(self, framebuffer, orientation):
self.task_timer.start()
if AithreClient.INSTANCE is not None and configuration.CONFIGURATION.aithre_enabled:
report = AithreClient.INSTANCE.get_spo2_report()
spo2_level = report.spo2
heartbeat = report.heartrate
heartbeat_text = "{}BPM".format(heartbeat)
if spo2_level is None or isinstance(spo2_level, basestring):
if self.__has_been_connected__:
spo2_color = RED
spo2_text = "OFFLINE"
else:
self.task_timer.stop()
return
else:
spo2_color = get_illyrian_spo2_color(spo2_level)
spo2_text = str(int(spo2_level)) + "% SPO"
self.__has_been_connected__ = True
spo2_ppm_texture = self.__font__.render(spo2_text, True,
spo2_color, BLACK)
heartbeat_texture = self.__font__.render(heartbeat_text, True,
GREEN, BLACK)
framebuffer.blit(spo2_ppm_texture,
(self.__lhs__, self.__text_y_pos__))
framebuffer.blit(heartbeat_texture,
(self.__lhs__, self.__pulse_y_pos__))
self.task_timer.stop()
class Groundspeed(AhrsElement):
def __init__(self, degrees_of_pitch, pixels_per_degree_y, font, framebuffer_size):
self.task_timer = TaskTimer('Groundspeed')
self.__font__ = font
center_y = framebuffer_size[1] >> 2
text_half_height = int(font.get_height()) >> 1
self.__text_y_pos__ = (text_half_height << 2) + \
center_y - text_half_height
self.__rhs__ = int(0.9 * framebuffer_size[0])
self.__left_x__ = 0 # WAS int(framebuffer_size[0] * 0.01)
def render(self, framebuffer, orientation):
self.task_timer.start()
# TODO - Pass in the configuration to all elements so they can have access to the unit types.
groundspeed_text = "{0:.1f}".format(orientation.groundspeed).rjust(5) + units.UNIT_LABELS[units.STATUTE][units.SPEED]
texture = self.__font__.render(
groundspeed_text, True, WHITE, BLACK)
framebuffer.blit(
texture, (self.__left_x__, self.__text_y_pos__))
self.task_timer.stop()
