analyzers: add an error-flags analyzer

This should only be used if the error flags aren't handled in a better
way, like they are for battery.

Author: peterbarker

LA_MsgHandler.cpp

@@ -263,6 +263,8 @@ LA_MsgHandler_ERR::LA_MsgHandler_ERR(std::string name, const struct log_Format &
     _analyze->add_data_source("BATTERY_FAILSAFE", "ERR.ECode");
     _analyze->add_data_source("CRASH", "ERR.Subsys");
     _analyze->add_data_source("CRASH", "ERR.ECode");
+    _analyze->add_data_source("ERRORFLAGS", "ERR.Subsys");
+    _analyze->add_data_source("ERRORFLAGS", "ERR.ECode");
 }
 
 void LA_MsgHandler_ERR::xprocess(const uint8_t *msg) {
@@ -275,6 +277,9 @@ void LA_MsgHandler_ERR::xprocess(const uint8_t *msg) {
     case ERROR_SUBSYSTEM_CRASH:
         _vehicle->set_crashed(ecode);
         break;
+    default:
+        _vehicle->set_subsys_error_code(subsys, ecode);
+        break;
     }
 }
 

Makefile

@@ -54,6 +54,7 @@ SRCS_CPP += analyzer/analyzer_autopilot.cpp
 SRCS_CPP += analyzer/analyzer_battery.cpp
 SRCS_CPP += analyzer/analyzer_compass_offsets.cpp
 SRCS_CPP += analyzer/analyzer_compass_vector_length.cpp
+SRCS_CPP += analyzer/analyzer_subsys_errors.cpp
 SRCS_CPP += analyzer/analyzer_ever_armed.cpp
 SRCS_CPP += analyzer/analyzer_ever_flew.cpp
 SRCS_CPP += analyzer/analyzer_good_kf.cpp

analyze.cpp

@@ -22,6 +22,7 @@
 #include "analyzer/analyzer_parameters.h"
 #include "analyzer/analyzer_position_estimate_divergence.h"
 #include "analyzer/analyzer_sensor_health.h"
+#include "analyzer/analyzer_subsys_errors.h"
 #include "analyzer/analyzer_motorbalance.h"
 #include "analyzer/analyzer_vehicle_definition.h"
 #include "analyzer/analyzer_velocity_estimate_divergence.h"
@@ -211,6 +212,13 @@ void Analyze::instantiate_analyzers(INIReader *config)
         la_log(LOG_INFO, "Failed to create analyzer_sensor_health");
     }
 
+    Analyzer_Subsys_Errors *analyzer_subsys_errors = new Analyzer_Subsys_Errors(vehicle,_data_sources);
+    if (analyzer_subsys_errors != NULL) {
+        configure_analyzer(config, analyzer_subsys_errors);
+    } else {
+        la_log(LOG_INFO, "Failed to create analyzer_subsys_errors");
+    }
+
     Analyzer_Vehicle_Definition *analyzer_vehicle_definition = new Analyzer_Vehicle_Definition(vehicle,_data_sources);
     if (analyzer_vehicle_definition != NULL) {
         configure_analyzer(config, analyzer_vehicle_definition);

analyzer/analyzer_subsys_errors.cpp

@@ -0,0 +1,184 @@
+#include "analyzer_subsys_errors.h"
+
+#include "util.h"
+#include "analyzer_util.h"
+
+void Analyzer_Subsys_Errors_Result::to_json(Json::Value &root) const
+{
+    Analyzer_Result_Period::to_json(root);
+    root["subsystem"] = _subsys;
+    root["subsystem-string"] = _subsys_string;
+    root["ecode"] = _ecode;
+    root["ecode-string"] = _ecode_string;
+}
+
+bool Analyzer_Subsys_Errors::configure(INIReader *config) {
+    if (!Analyzer::configure(config)) {
+	return false;
+    }
+    return true;
+}
+
+void Analyzer_Subsys_Errors::end_of_log(uint32_t packet_count UNUSED)
+{
+    auto subsys_errors = _vehicle->subsys_errors();
+
+    for (auto it = subsys_errors.begin(); it != subsys_errors.end(); ++it) {
+        // ::fprintf(stderr, "would evaluate (%s)\n", (*it).first.c_str());
+        uint32_t subsys = (*it).first;
+        if (_results[subsys] != NULL) {
+            close_result(subsys);
+        }
+    }
+
+    // if (!have) {
+    //     Analyzer_Result_Summary *summary = new Analyzer_Result_Summary();
+    //     summary->set_status(analyzer_status_warn);
+    //     summary->set_reason("Sensor health never updated");
+    //     summary->add_source(_data_sources.get("SENSORS_HEALTH"));
+    //     add_result(summary);
+    // }
+
+}
+
+void Analyzer_Subsys_Errors::close_result(const uint32_t subsys)
+{
+    Analyzer_Subsys_Errors_Result *result = _results[subsys];
+
+    result->set_T_stop(_vehicle->T());
+    add_result(result);
+    _results[subsys] = NULL;
+}
+
+const std::map<const uint32_t, const std::string> _subsys_name = {
+    { ERROR_SUBSYSTEM_MAIN, "MAIN" },
+    { ERROR_SUBSYSTEM_RADIO, "RADIO" },
+    { ERROR_SUBSYSTEM_COMPASS, "COMPASS" },
+    { ERROR_SUBSYSTEM_OPTFLOW, "OPTFLOW" },
+    { ERROR_SUBSYSTEM_FAILSAFE_RADIO, "FAILSAFE_RADIO" },
+    { ERROR_SUBSYSTEM_FAILSAFE_BATT, "FAILSAFE_BATT" },
+    { ERROR_SUBSYSTEM_FAILSAFE_GPS, "FAILSAFE_GPS" },   // not used
+    { ERROR_SUBSYSTEM_FAILSAFE_GCS, "FAILSAFE_GCS" },
+    { ERROR_SUBSYSTEM_FAILSAFE_FENCE, "FAILSAFE_FENCE" },
+    { ERROR_SUBSYSTEM_FLIGHT_MODE, "FLIGHT_MODE" },
+    { ERROR_SUBSYSTEM_GPS, "GPS" },
+    { ERROR_SUBSYSTEM_CRASH_CHECK, "CRASH_CHECK" },
+    { ERROR_SUBSYSTEM_FLIP, "FLIP" },
+    { ERROR_SUBSYSTEM_AUTOTUNE, "AUTOTUNE" },
+    { ERROR_SUBSYSTEM_PARACHUTE, "PARACHUTE" },
+    { ERROR_SUBSYSTEM_EKFCHECK, "EKFCHECK" },
+    { ERROR_SUBSYSTEM_FAILSAFE_EKFINAV, "FAILSAFE_EKFINAV" },
+    { ERROR_SUBSYSTEM_BARO, "BARO" },
+    { ERROR_SUBSYSTEM_CPU, "CPU" },
+    { ERROR_SUBSYSTEM_FAILSAFE_ADSB, "FAILSAFE_ADSB" },
+    { ERROR_SUBSYSTEM_TERRAIN, "TERRAIN" },
+    { ERROR_SUBSYSTEM_NAVIGATION, "NAVIGATION" },
+    { ERROR_SUBSYSTEM_FAILSAFE_TERRAIN, "FAILSAFE_TERRAIN" },
+    { ERROR_SUBSYSTEM_EKF_PRIMARY, "EKF_PRIMARY" },
+};
+
+/// @brief Map from subsystem id to error code values
+/// @note Correct only for ArduCopter ATM
+/// @note taken from ArduCopter/defines.h
+const std::map<const uint32_t, std::map<const uint32_t, const std::string>> _subsys_errors_strings = {
+    { ERROR_SUBSYSTEM_RADIO, {
+            { ERROR_CODE_RADIO_LATE_FRAME, "Late Frame" },
+        }
+    },
+    { ERROR_SUBSYSTEM_FAILSAFE_RADIO, {
+            { ERROR_CODE_FAILSAFE_OCCURRED, "Occured" },
+            { ERROR_CODE_FAILSAFE_RESOLVED, "Resolved" },
+        }
+    },
+    { ERROR_SUBSYSTEM_FAILSAFE_BATT, {
+            { ERROR_CODE_FAILSAFE_OCCURRED, "Occured" },
+            { ERROR_CODE_FAILSAFE_RESOLVED, "Resolved" },
+        }
+    },
+    { ERROR_SUBSYSTEM_FAILSAFE_GPS, {
+            { ERROR_CODE_FAILSAFE_OCCURRED, "Occured" },
+            { ERROR_CODE_FAILSAFE_RESOLVED, "Resolved" },
+        }
+    },
+    { ERROR_SUBSYSTEM_FAILSAFE_GCS, {
+            { ERROR_CODE_FAILSAFE_OCCURRED, "Occured" },
+            { ERROR_CODE_FAILSAFE_RESOLVED, "Resolved" },
+        }
+    },
+    { ERROR_SUBSYSTEM_FAILSAFE_FENCE, {
+            { ERROR_CODE_FAILSAFE_OCCURRED, "Occured" },
+            { ERROR_CODE_FAILSAFE_RESOLVED, "Resolved" },
+        }
+    },
+    { ERROR_SUBSYSTEM_EKFCHECK, {
+            { ERROR_CODE_EKFCHECK_BAD_VARIANCE, "Bad Variance" },
+        }
+    },
+    { ERROR_SUBSYSTEM_BARO, {
+            { ERROR_CODE_BARO_GLITCH, "Baro Glitch" },
+        }
+    },
+    { ERROR_SUBSYSTEM_GPS, {
+            { ERROR_CODE_GPS_GLITCH, "GPS Glitch" },
+        }
+    },
+};
+
+const std::string Analyzer_Subsys_Errors::subsys_string(const uint32_t subsys) const
+{
+    return _subsys_name.at(subsys);
+}
+
+const std::string Analyzer_Subsys_Errors::ecode_string(uint32_t subsys,
+                                                       uint32_t ecode) const
+{
+    try {
+        std::map<const uint32_t, const std::string> bob = _subsys_errors_strings.at(subsys);
+        return bob.at(ecode);
+    } catch (std::out_of_range) {
+    }
+    switch(ecode) {
+    case ERROR_CODE_ERROR_RESOLVED:
+        return "Resolved";
+    case ERROR_CODE_FAILED_TO_INITIALISE:
+        return "Failed to initialise";
+    case ERROR_CODE_UNHEALTHY:
+        return "Unhealthy";
+    default:
+        return "Unknown";
+    }
+}
+
+void Analyzer_Subsys_Errors::open_result(const uint32_t subsys, const uint32_t ecode)
+{
+    _results[subsys] = new Analyzer_Subsys_Errors_Result(subsys,
+                                                         subsys_string(subsys),
+                                                         ecode,
+                                                         ecode_string(subsys, ecode));
+    _results[subsys]->set_reason("A subsystem failure has occured");
+    _results[subsys]->set_T_start(_vehicle->T());
+    _results[subsys]->set_status(analyzer_status_fail);
+    _results[subsys]->add_source(_data_sources.get("SUBSYS_ERRORS"));
+    _results[subsys]->increase_severity_score(10);
+}
+
+
+void Analyzer_Subsys_Errors::evaluate()
+{
+    auto subsys_errors = _vehicle->subsys_errors();
+
+    for (auto it = subsys_errors.begin(); it != subsys_errors.end(); ++it) {
+        uint32_t subsys = (*it).first;
+        uint32_t new_ecode = (*it).second;
+        // ::fprintf(stderr, "would evaluate (%s)\n", name.c_str());
+        if (_results[subsys] != NULL) {
+            if (_results[subsys]->ecode() != new_ecode) {
+                close_result(subsys);
+            }
+        }
+        if (_results[subsys] == NULL && new_ecode) {
+            open_result(subsys, new_ecode);
+        }
+    }
+}
+

analyzer/analyzer_subsys_errors.h

@@ -0,0 +1,73 @@
+#ifndef ANALYZER_SUBSYS_ERRORS_H
+#define ANALYZER_SUBSYS_ERRORS_H
+
+/*
+ * analyzer_subsys_errors
+ *
+ */
+
+#include "analyzer.h"
+#include "data_sources.h"
+
+
+class Analyzer_Subsys_Errors_Result : public Analyzer_Result_Period {
+public:
+    Analyzer_Subsys_Errors_Result(uint32_t subsys,
+                                  const std::string subsys_string,
+                                  uint32_t ecode,
+                                  const std::string ecode_string) :
+        _subsys(subsys),
+        _subsys_string(subsys_string),
+        _ecode(ecode),
+        _ecode_string(ecode_string)
+        { }
+    void to_json(Json::Value &root) const;
+    uint32_t ecode() const { return _ecode; }
+
+    std::string ecode_string() const { return _ecode_string; }
+    std::string subsys_string() const { return _subsys_string; }
+
+private:
+    const uint32_t _subsys;
+    const std::string _subsys_string;
+    const uint32_t _ecode;
+    const std::string _ecode_string;
+
+};
+
+class Analyzer_Subsys_Errors : public Analyzer {
+
+public:
+    Analyzer_Subsys_Errors(AnalyzerVehicle::Base *&vehicle,
+                         Data_Sources &data_sources) :
+    Analyzer(vehicle, data_sources)
+    { }
+
+
+    const std::string name() const override { return "Error Flags"; }
+    const std::string description() const override {
+        return "A UAV can have ongoing errors which it is managing.  This test will fail if such errors occur";
+    }
+
+    bool configure(INIReader *config) override;
+
+private:
+
+    std::map<uint32_t, uint32_t> _subsys_errors = { };
+    std::map<uint32_t, Analyzer_Subsys_Errors_Result*> _results = { };
+
+    void evaluate() override;
+
+    void close_result(const uint32_t code);
+    void open_result(const uint32_t code, const uint32_t ecode);
+
+    void end_of_log(uint32_t packet_count) override;
+
+    const std::string subsys_string(const uint32_t subsys) const;
+    const std::string ecode_string(const uint32_t subsys,
+                                   const uint32_t ecode) const;
+};
+
+#endif
+
+