更新cpr统计，以及解码时间间隔，速度检测跳过配置

module/Local_Server/global_include.h

@@ -272,16 +272,61 @@ protected:
     }
     std::map<std::string, Statistic_Data> statistic_map;
 };
+class CPR_Percentage_Statistic_Data {
+public:
+    void add(SSR::CPR_Type cpr_type, SSR::CPR_Ret_Type result_type) {
+        switch (result_type) {
+        case SSR::CPR_Ret_Type::Speed_Error:
+        case SSR::CPR_Ret_Type::Parse_OK:
+        case SSR::CPR_Ret_Type::Inter_Error:
+        case SSR::CPR_Ret_Type::Time_Space_Too_Long:
+            break;
+        case SSR::CPR_Ret_Type::Lack_Other_Msg:
+        case SSR::CPR_Ret_Type::Lack_Old_Pos:
+        case SSR::CPR_Ret_Type::Base:
+            return;
+        }
+        auto& statistic = statistic_map[cpr_type];
+        ++statistic.total_num;
+        ++statistic.result_num[result_type];
+    }
+    Psc::JSON to_json() const {
+        Psc::JSON result = Psc::JSON::object();
+        for (const auto& [cpr_type, statistic] : statistic_map) {
+            Psc::JSON type_result = Psc::JSON::object();
+            type_result.append({"总计数", statistic.total_num});
+            for (auto result_type : statistic_types) {
+                size_t num = 0;
+                auto iter = statistic.result_num.find(result_type);
+                if (iter != statistic.result_num.end()) {
+                    num = iter->second;
+                }
+                double rate = static_cast<double>(num) /
+                static_cast<double>(statistic.total_num) * 100.0;
+                type_result.append({
+                    Psc::to_string(result_type),
+                    std::format("{}  {:.2f}%", num, rate)
+                });
+            }
+            result.append({Psc::to_string(cpr_type), type_result});
+        }
+        return result;
+    }
+protected:
+    struct Statistic_Data {
+        size_t total_num{};
+        std::map<SSR::CPR_Ret_Type, size_t> result_num;
+    };
+    inline static constexpr std::array statistic_types{
+        SSR::CPR_Ret_Type::Speed_Error,
+        SSR::CPR_Ret_Type::Parse_OK,
+        SSR::CPR_Ret_Type::Inter_Error,
+        SSR::CPR_Ret_Type::Time_Space_Too_Long
+    };
+    std::map<SSR::CPR_Type, Statistic_Data> statistic_map;
+};
 class Mode_S_Statistic_Data {
 public:
-    // Psc::Speed_Statistics speed;
-    // Psc::Speed_Statistics total_speed() const {
-    //     Psc::Speed_Statistics total_speed{};
-    //     for (auto& cur : DF_Statistic_Data_map) {
-    //         total_speed += cur.second.speed;
-    //     }
-    //     return total_speed;
-    // }
     Psc::JSON to_json() {
         size_t total_num = get_total_num();
         size_t crc_error_num = get_crc_error_num();
@@ -291,9 +336,11 @@ public:
         Ret_J(total_num);
         std::string t = "null";
         if (total_num != 0) {
-            t = std::to_string(static_cast<double>(crc_error_num) /
-                static_cast<double>(total_num)) +
-            "%";
+            t = std::format(
+                "{}%",
+                static_cast<double>(crc_error_num) /
+                static_cast<double>(total_num)
+            );
         }
         Ret_J(crc_error_num);
         ret.append({"crc_error_rate", t});
@@ -305,32 +352,19 @@ public:
                 cur.second.to_json()
             });
         }
-        Psc::JSON cpr_error_o = Psc::JSON::object();
-        for (auto& cur : cpr_error) {
-            auto num = cur.second;
-            std::string rate_str = std::format("{:.2f}%", static_cast<double>(num) / base * 100.0);
-            auto& type = cur.first;
-            auto key = Psc::to_string(type);
-            auto val = Psc::to_string(static_cast<size_t>(cur.second)) + "  " + rate_str;
-            cpr_error_o.append({key, val});
-        }
         ret.append({"DF子类型", df_sub_type});
-        ret.append({"CPR统计信息", cpr_error_o});
+        ret.append({"CPR统计信息", cpr_statistic_data.to_json()});
         return ret;
     }
     void add_length_error(std::string_view key) {
-        length_error_num++;
+        ++length_error_num;
     }
-    void add_cpr_error(SSR::CPR_Error_Type cet) {
-        if (cet == SSR::CPR_Error_Type::Normal) {
-            base++;
-        }
-        else {
-            ++cpr_error[cet];
-        }
+    void add_cpr_error(SSR::CPR_Type cpr_type, SSR::CPR_Ret_Type result_type) {
+        cpr_statistic_data.add(cpr_type, result_type);
     }
-    DF_Statistic_Data*
-    get_create_df_statistic_data(const SSR::Downlink_Format& key) {
+    DF_Statistic_Data* get_create_df_statistic_data(
+        const SSR::Downlink_Format& key
+    ) {
         DF_Statistic_Data* t;
         auto iter = DF_Statistic_Data_map.find(key);
         if (iter == DF_Statistic_Data_map.end()) {
@@ -364,8 +398,7 @@ public:
 protected:
     std::atomic<size_t> length_error_num{};
     std::map<SSR::Downlink_Format, DF_Statistic_Data> DF_Statistic_Data_map;
-    std::map<SSR::CPR_Error_Type, double> cpr_error;
-    double base = 0;
+    CPR_Percentage_Statistic_Data cpr_statistic_data;
 };
 template <typename T>
 class Immutable : public T {};

module/Local_Server/server/Config.h

@@ -38,17 +38,17 @@ struct Http_Monitor_Config {
     std::size_t slow_scope_threshold_ms = 100;
     PSC_USE_JSON
 };
-
 struct Mode_ACS_Config_Base_Data {
     Psc::Copyable_Atomic<std::size_t> timeout_seconds{};
-    Psc::Copyable_Atomic<std::size_t> max_speed_m_s{};
-    Psc::Copyable_Atomic<std::size_t> air_pos_timeout = 8;
-    Psc::Copyable_Atomic<std::size_t> surface_pos_timeout = 32;
+    SSR::CPR::D max_speed_m_s{};
+    SSR::CPR::D air_pos_timeout = 8;
+    SSR::CPR::D surface_pos_timeout = 32;
     Psc::Copyable_Atomic<std::size_t> read_milliseconds{};
     PSC_USE_JSON
 };
-
 struct Mode_ACS_Config_Data {
+    Psc::Copyable_Atomic<bool> time_space_filter;
+    Psc::Copyable_Atomic<bool> speed_filter;
     Psc::Copyable_Atomic<std::size_t> max_track_point_size{};
     Psc::Copyable_Atomic<std::size_t> mode_s_max_num{};
     Psc::Copyable_Atomic<std::size_t> mode_other_max_num{};
@@ -58,8 +58,6 @@ struct Mode_ACS_Config_Data {
     Psc::Copyable_Atomic<bool> monitor_msg_live{};
     PSC_USE_JSON
 };
-
-
 struct Mode_ACS_Config : Mode_ACS_Config_Base_Data, Mode_ACS_Config_Data {
     DELETE_COPY(Mode_ACS_Config)
     Data_feed_Config data_feed_config;
@@ -99,7 +97,6 @@ struct Mode_ACS_Config : Mode_ACS_Config_Base_Data, Mode_ACS_Config_Data {
     }
     void server(Global* g);
 };
-
 struct Web_Server_Config {
     [[nodiscard]] std::string get_true_webapp() const {
         return Psc::get_abs_path(webapp);

module/Local_Server/server/Global.cpp

@@ -98,12 +98,11 @@ Global::Global() {
         f->add_msg_limit(mode_s_msg);
     };
 #endif
-    SSR::cpr_cb = [](SSR::CPR_Error_Type t, std::string_view log,
-                     SSR::P_S msg) {
+    SSR::cpr_cb = [](SSR::CPR_Type t, SSR::CPR_Ret_Type err_type, std::string_view log, SSR::P_S msg) {
         auto src = std::dynamic_pointer_cast<Data_Source>(msg->source);
         Mode_S_Statistic_Data* ss = &src->mode_s_statistic;
-        ss->add_cpr_error(t);
-        SSR::mode_s_logger->debug("CPR/" + to_string(t), {}, log);
+        ss->add_cpr_error(t, err_type);
+        SSR::mode_s_logger->debug("CPR/" + to_string(t) + "/" + to_string(err_type), {}, log);
     };
     // 处理错误
     SSR::parse_call_back =