def _GetSingleValue(self, arg_idx, *args):
"""Obtain a single value for one servo, invoked within _GetAvailableValues.
Args:
arg_idx: The index referring to the n-th servo.
*args: The list of attributes to the indicator. The attributes vary
in different modes. For FULL_COMMS_MODE, it is the list
of ServoStatus messages for each servo, so args[arg_idx] refers to
the servo's message struct. For SPARSE_COMMS_MODE, it is
[TetherDown.servo_statuses, valid, timestamp_sec], so
args[0][`EnumValue(A2)`] refers to the state of servo A2.
Returns:
The servo status of the n-th servo.
"""
if self._mode == common.FULL_COMMS_MODE:
if struct_tree.IsValidElement(args[arg_idx]):
return args[arg_idx].flags.status
else:
return None
elif self._mode == common.SPARSE_COMMS_MODE:
return self._GetTetherValue(args[0], self._node_labels[arg_idx],
'state')
else:
assert False
def _IsTetherDownActuatorUpdated(
status, aio_label, node_label_helper, max_no_update_count):
node_id = node_label_helper.Value(aio_label)
if not struct_tree.IsValidElement(status):
return False
no_update_count = status[node_id].no_update_count
return no_update_count <= max_no_update_count
def _Filter(self, down_status, up_status):
if struct_tree.IsValidElement(down_status):
text, down_stoplight = self._HandleStatus(
down_status.connected, down_status.rssi)
else:
text, down_stoplight = '--', stoplights.STOPLIGHT_WARNING
result = '%s dBm down, ' % text
if struct_tree.IsValidElement(up_status):
is_connected = (up_status.links_up &
pack_avionics_messages.kTetherCommsLinkJoystick)
text, up_stoplight = self._HandleStatus(
is_connected, up_status.received_signal_strength)
else:
text, up_stoplight = '--', stoplights.STOPLIGHT_WARNING
result += '%s dBm up' % text
stoplight = stoplights.MostSevereStoplight(down_stoplight, up_stoplight)
return result, stoplight
def _GetValuePerNode(self, arg_idx, *args):
if self._mode == common.FULL_COMMS_MODE:
return (numpy.rad2deg(args[arg_idx].angle_estimate)
if struct_tree.IsValidElement(args[arg_idx]) else None)
elif self._mode == common.SPARSE_COMMS_MODE:
rad = self._GetTetherValue(args[0], self._node_labels[arg_idx],
'angle')
return numpy.rad2deg(rad) if rad is not None else None
else:
assert False
def _GetSingleValue(self, arg_idx, *args):
if self._mode == common.FULL_COMMS_MODE:
if struct_tree.IsValidElement(args[arg_idx]):
return [args[arg_idx].flags, args[arg_idx].servo_mon.flags]
else:
return None
elif self._mode == common.SPARSE_COMMS_MODE:
return self._GetTetherValue(args[0], self._node_labels[arg_idx],
'state')
else:
assert False
def _GetSingleValue(self, arg_idx, *args):
if self._mode == common.FULL_COMMS_MODE:
if struct_tree.IsValidElement(args[arg_idx]):
return args[arg_idx].r22.temperature
else:
return None
elif self._mode == common.SPARSE_COMMS_MODE:
return self._GetTetherValue(args[0], self._node_labels[arg_idx],
'r22_temp')
else:
assert False
def _Filter(self, message):
if not struct_tree.IsValidElement(message):
text = ' --'
stoplight = stoplights.STOPLIGHT_UNAVAILABLE
else:
value_ranges = self._GetLimits(self._limits)
value = self._GetCTypeFieldByString(message, self._field)
text = self._text_format % value
stoplight = stoplights.SetByRanges(
value, value_ranges['normal'],
value_ranges['warning'])
return text, stoplight
def _Filter(self, short_stack_status):
if struct_tree.IsValidElement(short_stack_status):
status_readout = []
for status_name in SHORT_STACK_STATUS_HELPER.Names():
status_val = (1 if (short_stack_status.short_stack_mon.flags.status &
SHORT_STACK_STATUS_HELPER.Value(status_name))
else 0)
status_readout.append(SHORT_STACK_STATUS_HELPER.ShortName(status_name)
+ ': ' + str(status_val))
return ('\n'.join(status_readout), stoplights.STOPLIGHT_NORMAL)
else:
return '--', stoplights.STOPLIGHT_UNAVAILABLE
def _Filter(self, short_stack_status):
if struct_tree.IsValidElement(short_stack_status):
gpio_readout = []
for gpio_pin in SHORT_STACK_GPIO_HELPER.Names():
pin_value = (1 if (short_stack_status.short_stack_mon.gpio_inputs
& (1 << SHORT_STACK_GPIO_HELPER.Value(gpio_pin)))
else 0)
gpio_readout.append(SHORT_STACK_GPIO_HELPER.ShortName(gpio_pin)
+ ': ' + str(pin_value))
return ('\n'.join(gpio_readout), stoplights.STOPLIGHT_NORMAL)
else:
return '--', stoplights.STOPLIGHT_UNAVAILABLE
def _Filter(self, batt_a, batt_b, slow_status_a, slow_status_b):
aio_nodes = []
batts = []
slow_statuses = []
if (struct_tree.IsValidElement(batt_a)
and struct_tree.IsValidElement(slow_status_a)):
aio_nodes.append('BattA')
batts.append(batt_a)
slow_statuses.append(slow_status_a)
if (struct_tree.IsValidElement(batt_b)
and struct_tree.IsValidElement(slow_status_b)):
aio_nodes.append('BattB')
batts.append(batt_b)
slow_statuses.append(slow_status_b)
if not aio_nodes:
return (common.FillLines(['Unavailable'], self._num_lines),
stoplights.STOPLIGHT_ERROR
if self._enable_error else stoplights.STOPLIGHT_WARNING)
status = BatteryStatus(batts, aio_nodes, verbose_charging=True)
(warning, error, warning_msg, error_msg, status_msg,
batts_discharge) = status.CheckAll(slow_statuses,
self._discharge_watchers)
if batts_discharge: status_msg += ['Batts powering bus.']
if error:
return (common.FillLines(error_msg, self._num_lines),
stoplights.STOPLIGHT_ERROR
if self._enable_error else stoplights.STOPLIGHT_WARNING)
elif warning:
return (common.FillLines(warning_msg + status_msg,
self._num_lines),
stoplights.STOPLIGHT_WARNING)
else:
return (common.FillLines(['Normal'] + status_msg, self._num_lines),
stoplights.STOPLIGHT_NORMAL)
def _Filter(self, tether_down):
if not struct_tree.IsValidElement(tether_down):
return 'Link down', stoplights.STOPLIGHT_ERROR
down_signal_strength = tether_down.received_signal_strength
up_signal_strength = tether_down.comms_status.received_signal_strength
text = '% 4d dBm down, % 4d dBm up' % (
down_signal_strength, up_signal_strength)
if (down_signal_strength < _XLR_RSSI_WARNING_THRESHOLD or
up_signal_strength < _XLR_RSSI_WARNING_THRESHOLD):
stoplight = stoplights.STOPLIGHT_WARNING
else:
stoplight = stoplights.STOPLIGHT_NORMAL
return text, stoplight
def _IsActuatorMessageAnyValid(mode, node_labels, node_label_helper,
max_no_update_count, *attributes):
"""Check if any actuator message is available."""
if mode == common.SPARSE_COMMS_MODE:
# Check the `valid` variable for TetherDown.
if attributes[1]:
for label in node_labels:
idx = node_label_helper.Value(label)
if attributes[0][idx].no_update_count <= max_no_update_count:
return True
return False
elif mode == common.FULL_COMMS_MODE:
for attribute in attributes:
if struct_tree.IsValidElement(attribute):
return True
return False
else:
assert False
def Filter(self, messages):
"""Obtain the attribute from the messages and compute the data to show.
Args:
messages: The StructTree object as a snapshot of all messages received.
Returns:
The data to show and the stoplight value, as arguments to the
scalar indicator.
"""
if not messages:
return self._default, stoplights.STOPLIGHT_UNAVAILABLE
attribute = self._GetAllAttributes(messages)[0]
if not struct_tree.IsValidElement(attribute):
return self._default, stoplights.STOPLIGHT_UNAVAILABLE
return self._Filter(attribute)
def _Filter(self, mvlv_status):
if not struct_tree.IsValidElement(mvlv_status):
return (common.FillLines(['Unavailable'], self._num_lines),
stoplights.STOPLIGHT_ERROR
if self._enable_error else stoplights.STOPLIGHT_WARNING)
mvlv = MvlvStatus(mvlv_status)
warning, error, warning_msg, error_msg = mvlv.CheckAll()
if error:
return (common.FillLines(error_msg, self._num_lines),
stoplights.STOPLIGHT_ERROR
if self._enable_error else stoplights.STOPLIGHT_WARNING)
elif warning:
return (common.FillLines(warning_msg, self._num_lines),
stoplights.STOPLIGHT_WARNING)
else:
return (common.FillLines(['Normal'], self._num_lines),
stoplights.STOPLIGHT_NORMAL)
def _Filter(self, mvlv_status, batt_a, batt_b, slow_status_a, slow_status_b,
control_telemetry):
# TODO: Enable TetherDown message as well.
mvlv_error = False
mvlv_warning = False
batt_error = False
batt_warning = False
mvlv_present = False
flight_mode_perched = False
batts_discharge = False
error_msg = []
warning_msg = []
status_msg = []
# TODO: Also allow indicator to use TetherDown.
if struct_tree.IsValidElement(control_telemetry):
if control_telemetry.flight_mode == FLIGHT_MODE_HELPER.Value('Perched'):
flight_mode_perched = True
if not struct_tree.IsValidElement(mvlv_status):
mvlv_error = True
error_msg.append('MvLv unavailable')
else:
mvlv_present = True
mvlv_warning, mvlv_error, mvlv_warning_msg, mvlv_error_msg = MvlvStatus(
mvlv_status).CheckAll()
warning_msg += ['MvLv ' + m for m in mvlv_warning_msg]
error_msg += ['MvLv ' + m for m in mvlv_error_msg]
aio_nodes = []
batts = []
slow_statuses = []
if (struct_tree.IsValidElement(batt_a) and
struct_tree.IsValidElement(slow_status_a)):
aio_nodes.append('BattA')
batts.append(batt_a)
slow_statuses.append(slow_status_a)
if (struct_tree.IsValidElement(batt_b) and
struct_tree.IsValidElement(slow_status_b)):
aio_nodes.append('BattB')
batts.append(batt_b)
slow_statuses.append(slow_status_b)
if not aio_nodes:
batt_error = True
error_msg.append('Batteries unavailable')
else:
batt_status = batt.BatteryStatus(batts, aio_nodes)
(batt_warning, batt_error,
batt_warning_msg, batt_error_msg, batt_status_msg,
batts_discharge) = batt_status.CheckAll(slow_statuses,
self._discharge_watchers)
warning_msg += batt_warning_msg
error_msg += batt_error_msg
status_msg += batt_status_msg
# If running off batteries, add a message either as warning or just
# status based on wing configuration and flight mode.
discharge_msg = 'LV bus running off batts.'
if batts_discharge:
if mvlv_present or flight_mode_perched:
warning_msg.append(discharge_msg)
batt_warning = True
else:
# No MVLV (batteries only), so discharge during flight is expected.
status_msg.append(discharge_msg)
# Show red as long as battery has error, for the sake of glide landing.
if batt_error:
return (common.FillLines(error_msg + status_msg, self._num_lines),
stoplights.STOPLIGHT_ERROR)
elif not (mvlv_error or batt_warning or mvlv_warning):
return (common.FillLines(['Normal'] + status_msg, self._num_lines),
stoplights.STOPLIGHT_NORMAL)
else:
messages = error_msg + warning_msg + status_msg
return (common.FillLines(messages, self._num_lines),
stoplights.STOPLIGHT_WARNING)
def _IsValidInput(self, *attributes):
"""Whether the input is valid (Required for @ReturnIfInputInvalid)."""
for attribute in attributes:
if struct_tree.IsValidElement(attribute):
return True
return False