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