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()
is_valid = isinstance(orientation.g_load, Number)
g_load_text = "{0:.1f} Gs".format(
orientation.g_load) if is_valid else orientation.g_load
texture = self.__font__.render(
g_load_text, True, display.WHITE if is_valid else display.RED,
display.BLACK)
text_width, text_height = texture.get_size()
framebuffer.blit(texture,
(self.__rhs__ - text_width, self.__text_y_pos__))
self.task_timer.stop()
if __name__ == '__main__':
import hud_elements
hud_elements.run_ahrs_hud_element(SkidAndGs)
str(int(utils.apply_declination(
orientation.gps_heading))).rjust(3))
rendered_text = self.__font__.render(heading_text, True, display.GREEN,
display.BLACK)
text_width, text_height = rendered_text.get_size()
framebuffer.blit(rendered_text, (self.__center_x__ -
(text_width >> 1), text_height << 1))
pygame.draw.lines(framebuffer, display.GREEN, True,
self.__heading_text_box_lines__, 2)
self.task_timer.stop()
def __render_heading_text__(self, framebuffer, heading, position_x,
position_y):
"""
Renders the text with the results centered on the given
position.
"""
rendered_text, half_size = self.__heading_text__[heading]
framebuffer.blit(
rendered_text,
(position_x - half_size[0], position_y - half_size[1]))
if __name__ == '__main__':
import hud_elements
hud_elements.run_ahrs_hud_element(CompassAndHeadingTopElement)
pitch_offset = self.__pixels_per_degree_y__ * \
(-pitch + reference_angle)
roll_delta = 90 - roll_int
center_x = ahrs_center_x - \
(pitch_offset * COS_RADIANS_BY_DEGREES[roll_delta]) + 0.5
center_y = ahrs_center_y - \
(pitch_offset * SIN_RADIANS_BY_DEGREES[roll_delta]) + 0.5
center_x = int(center_x)
center_y = int(center_y)
x_len = int(length * COS_RADIANS_BY_DEGREES[roll_int] + 0.5)
y_len = int(length * SIN_RADIANS_BY_DEGREES[roll_int] + 0.5)
half_x_len = x_len >> 1
half_y_len = y_len >> 1
start_x = center_x - half_x_len
end_x = center_x + half_x_len
start_y = center_y + half_y_len
end_y = center_y - half_y_len
return [[start_x, start_y],
[end_x, end_y]], (center_x, center_y), reference_angle
if __name__ == '__main__':
run_ahrs_hud_element(ArtificialHorizon)
from ahrs_element import AhrsElement
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()
if __name__ == '__main__':
import hud_elements
hud_elements.run_ahrs_hud_element(Groundspeed, True)
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()
if __name__ == '__main__':
import hud_elements
hud_elements.run_ahrs_hud_element(LevelReference)
heading -= 360
[
self.__render_heading_mark__(framebuffer,
heading_mark_to_render[0],
heading_mark_to_render[1])
for heading_mark_to_render in self.__heading_strip__[heading]
]
# Render the text that is showing our AHRS and GPS headings
heading_text = "{0} | {1}".format(
utils.apply_declination(
orientation.get_onscreen_projection_display_heading()),
utils.apply_declination(orientation.gps_heading))
rendered_text = self.__font__.render(heading_text, True, BLACK, GREEN)
text_width, text_height = rendered_text.get_size()
pygame.draw.polygon(framebuffer, GREEN,
self.__heading_text_box_lines__)
framebuffer.blit(rendered_text,
(self.__center_x__ -
(text_width >> 1), self.compass_text_y))
self.task_timer.stop()
if __name__ == '__main__':
import hud_elements
hud_elements.run_ahrs_hud_element(CompassAndHeadingBottomElement)
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()
if __name__ == '__main__':
import hud_elements
hud_elements.run_ahrs_hud_element(Time, True)
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()
if __name__ == '__main__':
import hud_elements
hud_elements.run_ahrs_hud_element(Altitude)
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()
if __name__ == '__main__':
import hud_elements
hud_elements.run_ahrs_hud_element(TrafficNotAvailable, True)
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()
if __name__ == '__main__':
import hud_elements
hud_elements.run_ahrs_hud_element(Aithre)
if __name__ == '__main__':
import hud_elements
# for temp in range(45, 95, 5):
# color = get_cpu_temp_text_color(temp)
# print("{3} => {0},{1},{2}".format(color[0], color[1], color[2], temp))
hud_elements.run_ahrs_hud_element(SystemInfo, True)
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()
if __name__ == '__main__':
import hud_elements
hud_elements.run_ahrs_hud_element(AhrsNotAvailable)
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()
if __name__ == '__main__':
import hud_elements
hud_elements.run_ahrs_hud_element(TargetCount, True)
display.GREEN,
self.smaller_reference_arc_box,
reference_roll_in_radians - self.roll_indicator_arc_radians,
reference_roll_in_radians + self.roll_indicator_arc_radians,
self.reference_line_size / 2)
# Draw the REALLY important reference angles longer
for roll_angle in [-90, -60, -45, 0, 45, 60, 90]:
reference_roll_in_radians = math.radians(roll_angle + 90.0)
pygame.draw.arc(framebuffer,
display.GREEN,
self.reference_arc_box,
reference_roll_in_radians - self.roll_indicator_arc_radians,
reference_roll_in_radians + self.roll_indicator_arc_radians,
self.reference_line_size)
# Draws the current roll
pygame.draw.arc(framebuffer,
display.YELLOW,
self.arc_box,
self.half_pi - roll_in_radians - self.roll_indicator_arc_radians,
self.half_pi - roll_in_radians + self.roll_indicator_arc_radians,
self.reference_line_size * 2)
self.task_timer.stop()
if __name__ == '__main__':
import hud_elements
hud_elements.run_ahrs_hud_element(RollIndicator, False)
