diff --git a/config/config.json b/config/config.json
index 360c285..39f76e5 100644
--- a/config/config.json
+++ b/config/config.json
@@ -8,16 +8,8 @@
     "fft_point_number": 2048,
     "fft_period_ms": 50,
     "fft_win_type": "blkmc",
-    "url": "0.0.0.0",
-    "port": 6000,
-    "power_min": -380,
-    "power_max": 120,
-    "power_offset": -166,
     "frame_rate": 60,
-    "debug": false,
-    "demod_mode": "LSB",
-    "audio_gain": 30,
-    "color_gain": 120
+    "debug": false
   },
   "drogon": {
     "app": {
@@ -32,13 +24,11 @@
     "slow_scope_threshold_ms": 1000
   },
   "mlat": {
-    "enable": false,
-    "merge": false,
-    "library_path": "@/mlat_source.dll",
-    "function_name": "adsb_read"
+    "merge": false
   },
   "web_server": {
-    "webapp": "@/../third_party/eacp_webapp/wwwroot"
+    "webapp": "@/../third_party/eacp_webapp/wwwroot",
+    "listen_port": 9081
   },
   "map_resources": {
     "current_imagery_key": "mixed_imagery",
@@ -262,7 +252,7 @@
       "pitch": -54.917211,
       "roll": 359.999884
     },
-    "baseStationFlyToHeightOffsetMeters": 8000.0
+    "base_station_fly_to_height_offset_meters": 8000.0
   },
   "map_models": {
     "aircraft_model": {
@@ -436,30 +426,11 @@
       "roll_offset_degrees": 0.0
     }
   },
-  "device": {
-    "net": [
-      {
-        "key": "device",
-        "ip": "0.0.0.0",
-        "port": 9081,
-        "netmask": "255.255.255.0",
-        "gateway": "192.168.1.1"
-      },
-      {
-        "key": "wifi",
-        "ip": "192.168.10.193",
-        "port": 80,
-        "netmask": "255.255.255.0",
-        "gateway": "192.168.10.1"
-      }
-    ]
-  },
   "mode_acs": {
     "timeout_seconds": 160,
     "max_speed_m_s": 1000.0,
     "air_pos_timeout": 8.0,
     "surface_pos_timeout": 32.0,
-    "read_milliseconds": 100,
     "wait_process_msg": true,
     "time_space_filter": true,
     "speed_filter": true,
@@ -472,13 +443,9 @@
     "aircraft_change_list_adsb_range_filter": true,
     "aircraft_change_list_adsb_range_factor": 1.2,
     "adsb_theoretical_target_altitude_meters": 10000.0,
-    "ignore_df_11": true,
     "monitor_msg_live": false,
     "data_feed": {
-      "empty_wait_milliseconds": 30,
       "packet_byte_size": 0,
-      "tcp_server_default_connect_user_buffer_size": 409600,
-      "tcp_server_default_connect_system_buffer_size": 409600,
       "list": [
         {
           "type": "Data_Feed_TCP_Server",
@@ -673,9 +640,7 @@
   },
   "console": {
     "record_playback": false,
-    "mode_s_console": false,
-    "post_request": false,
-    "mlat_server": true
+    "mode_s_console": false
   },
   "external_database": {
     "ecap_sqlite_path": "@/../data/sqlite/ecap.sqlite",
diff --git a/config/linux/config.json b/config/linux/config.json
index c69a8e6..995ce05 100644
--- a/config/linux/config.json
+++ b/config/linux/config.json
@@ -8,16 +8,8 @@
     "fft_point_number": 2048,
     "fft_period_ms": 50,
     "fft_win_type": "blkmc",
-    "url": "0.0.0.0",
-    "port": 6000,
-    "power_min": -380,
-    "power_max": 120,
-    "power_offset": -166,
     "frame_rate": 60,
-    "debug": false,
-    "demod_mode": "LSB",
-    "audio_gain": 30,
-    "color_gain": 120
+    "debug": false
   },
   "drogon": {
     "app": {
@@ -32,13 +24,11 @@
     "slow_scope_threshold_ms": 1000
   },
   "mlat": {
-    "enable": false,
-    "merge": false,
-    "library_path": "@/mlat_source.dll",
-    "function_name": "adsb_read"
+    "merge": false
   },
   "web_server": {
-    "webapp": "@/wwwroot"
+    "webapp": "@/wwwroot",
+    "listen_port": 9081
   },
   "map_resources": {
     "current_imagery_key": "mixed_imagery",
@@ -262,7 +252,7 @@
       "pitch": -54.917211,
       "roll": 359.999884
     },
-    "baseStationFlyToHeightOffsetMeters": 8000.0
+    "base_station_fly_to_height_offset_meters": 8000.0
   },
   "map_models": {
     "aircraft_model": {
@@ -436,30 +426,11 @@
       "roll_offset_degrees": 0.0
     }
   },
-  "device": {
-    "net": [
-      {
-        "key": "device",
-        "ip": "0.0.0.0",
-        "port": 9081,
-        "netmask": "255.255.255.0",
-        "gateway": "192.168.1.1"
-      },
-      {
-        "key": "wifi",
-        "ip": "192.168.10.193",
-        "port": 80,
-        "netmask": "255.255.255.0",
-        "gateway": "192.168.10.1"
-      }
-    ]
-  },
   "mode_acs": {
     "timeout_seconds": 160,
     "max_speed_m_s": 1000.0,
     "air_pos_timeout": 8.0,
     "surface_pos_timeout": 32.0,
-    "read_milliseconds": 100,
     "wait_process_msg": true,
     "time_space_filter": true,
     "speed_filter": true,
@@ -472,13 +443,9 @@
     "aircraft_change_list_adsb_range_filter": true,
     "aircraft_change_list_adsb_range_factor": 1.2,
     "adsb_theoretical_target_altitude_meters": 10000.0,
-    "ignore_df_11": true,
     "monitor_msg_live": false,
     "data_feed": {
-      "empty_wait_milliseconds": 30,
       "packet_byte_size": 0,
-      "tcp_server_default_connect_user_buffer_size": 409600,
-      "tcp_server_default_connect_system_buffer_size": 409600,
       "list": [
         {
           "type": "Data_Feed_TCP_Server",
@@ -624,9 +591,7 @@
   },
   "console": {
     "record_playback": false,
-    "mode_s_console": false,
-    "post_request": false,
-    "mlat_server": true
+    "mode_s_console": false
   },
   "external_database": {
     "ecap_sqlite_path": "@/../ecap.sqlite",
diff --git a/module/Local_Server/DSP/DSP_Config.h b/module/Local_Server/DSP/DSP_Config.h
index e5207ee..c8b861e 100644
--- a/module/Local_Server/DSP/DSP_Config.h
+++ b/module/Local_Server/DSP/DSP_Config.h
@@ -11,20 +11,11 @@ class Global;
 // #define USE_PROCESS 1
 // #endif
 // #define USE_PROCESS 1
-enum Demod_Mode { LSB, USB, AM, FM };
 extern BaseLogger* dsp_logger;
 class DSP_Config_Data {
 public:
-    std::string url;
-    std::uint16_t port{};
-    std::int64_t power_min;
-    std::int64_t power_max;
-    std::int64_t power_offset;
     std::uint64_t frame_rate;
     bool debug;
-    Demod_Mode demod_mode;
-    std::int64_t audio_gain;
-    std::int64_t color_gain;
     PSC_USE_JSON
 };
 class DSP_Config : public Base_DSP, public DSP_Config_Data {
@@ -32,17 +23,10 @@ public:
     ~DSP_Config();
     void close_dsp_device() const;
     void init_update(const Psc::JSON* that_json) {
-        Get_J(port);
         Get_J(center_freq);
         Get_J(band_width);
         Get_J(sample_rate);
         Get_J(fft_point_number);
-        Get_J(power_min);
-        Get_J(power_max);
-        Get_J(power_offset);
-        Get_J(demod_mode);
-        Get_J(audio_gain);
-        Get_J(color_gain);
     }
     void from_json(const Psc::JSON* that_json, bool not_exist_use_default_value) {
         Base_DSP::from_base_json(that_json, not_exist_use_default_value);
diff --git a/module/Local_Server/Data_Feed/Data_Feed.cpp b/module/Local_Server/Data_Feed/Data_Feed.cpp
index d415b31..94f973e 100644
--- a/module/Local_Server/Data_Feed/Data_Feed.cpp
+++ b/module/Local_Server/Data_Feed/Data_Feed.cpp
@@ -25,14 +25,6 @@ asio::awaitable<void> Data_Feed_UDP_Server::_open() {
     server_logger->c_debug({}, {}, to_string() + "开启！");
     co_return;
 }
-JSON Data_feed_Config::get_feed(std::string_view key) {
-    auto ret = map.get(std::string(key));
-    if (ret.has_value()) {
-        auto r = ret.value().get();
-        return r->to_json();
-    }
-    return {nullptr};
-}
 void Data_feed_Config::server(Global* g) {
     auto& svr = g->svr;
     auto& api = g->api;
diff --git a/module/Local_Server/Data_Feed/Data_Feed.h b/module/Local_Server/Data_Feed/Data_Feed.h
index 564fbb4..08ba6e7 100644
--- a/module/Local_Server/Data_Feed/Data_Feed.h
+++ b/module/Local_Server/Data_Feed/Data_Feed.h
@@ -3,7 +3,7 @@
 #include <string_view>
 #include "Local_Server/server/With_Loop_Coro.h"
 #include "global.h"
-enum class Output_Data_Format { AVR, AVR_MLAT, BIN, SBS, BIN_ID };
+enum class Output_Data_Format { AVR, AVR_MLAT, BIN, SBS };
 enum class Mode_S_Output_Type { DF_11_17_18, NO_POS_Mode_S, ALL_Mode_S };
 struct Output_Format {
     Output_Data_Format type = Output_Data_Format::BIN;
@@ -349,10 +349,7 @@ inline std::shared_ptr<Data_Feed> create_data_feed_from_type(std::string_view t)
 }
 class Data_feed_Config_Data {
 public:
-    std::uint16_t empty_wait_milliseconds{};
     std::uint16_t packet_byte_size{};
-    size_t tcp_server_default_connect_user_buffer_size{};
-    size_t tcp_server_default_connect_system_buffer_size{};
     PSC_USE_JSON
 };
 namespace adminive {
@@ -361,10 +358,7 @@ struct Type_Descriptor<Data_feed_Config_Data> {
     static auto get() {
         using T = Data_feed_Config_Data;
         return object<T>("data_feed_settings", "数据馈送全局配置",
-                         ADMINIVE_FIELD_LABEL(T, empty_wait_milliseconds, "忙等待时间（毫秒）").editable().number_input(),
-                         ADMINIVE_FIELD_LABEL(T, packet_byte_size, "最小批大小（byte）").editable().number_input(),
-                         ADMINIVE_FIELD_LABEL(T, tcp_server_default_connect_user_buffer_size, "TCP 默认用户缓冲区").editable().number_input(),
-                         ADMINIVE_FIELD_LABEL(T, tcp_server_default_connect_system_buffer_size, "TCP 默认系统缓冲区").editable().number_input());
+                         ADMINIVE_FIELD_LABEL(T, packet_byte_size, "最小批大小（byte）").editable().number_input());
     }
 };
 }
@@ -398,6 +392,5 @@ public:
         ret.append({"list", list()});
         return ret;
     }
-    Psc::JSON get_feed(std::string_view key);
     void server(Global* g);
 };
diff --git a/module/Local_Server/Data_Source/Base_Station.cpp b/module/Local_Server/Data_Source/Base_Station.cpp
index d7fb166..aa3989f 100644
--- a/module/Local_Server/Data_Source/Base_Station.cpp
+++ b/module/Local_Server/Data_Source/Base_Station.cpp
@@ -13,10 +13,6 @@ std::optional<SSR::Position_3D> Base_Station::get_pos() {
   }
   return SSR::Position_3D{hulc.get_latitude(), hulc.get_longitude(), static_cast<SSR::CPR::D>(hulc.Alt)};
 }
-double Base_Station::get_height() {
-  std::lock_guard g(mtx);
-  return hulc.Alt;
-}
 bool Base_Station::has_valid_position() {
   std::lock_guard g(mtx);
   return hulc.GPS_has_valid_fix();
diff --git a/module/Local_Server/Data_Source/Base_Station.h b/module/Local_Server/Data_Source/Base_Station.h
index 555e53b..2c379d7 100644
--- a/module/Local_Server/Data_Source/Base_Station.h
+++ b/module/Local_Server/Data_Source/Base_Station.h
@@ -5,7 +5,6 @@ public:
     std::string to_string();
     Psc::JSON to_Json();
     std::optional<SSR::Position_3D> get_pos();
-    double get_height();
     bool has_valid_position();
     void set_msg(const SSR::HULC_Status_Message& msg);
     static double theoretical_detection_range_meters(double base_height_meters, double target_height_meters);
diff --git a/module/Local_Server/Data_Source/Data_Source.cpp b/module/Local_Server/Data_Source/Data_Source.cpp
index 05e4657..0c4bbfe 100644
--- a/module/Local_Server/Data_Source/Data_Source.cpp
+++ b/module/Local_Server/Data_Source/Data_Source.cpp
@@ -3,26 +3,6 @@
 #include <string_view>
 #include "../server/Global.h"
 #include "Database.h"
-Psc::serial::Serial* create_serial(std::string_view serial_name, Baud_Rate_Type baud_rate) {
-    auto serial = new Psc::serial::Serial;
-    serial->set_serial_name(serial_name);
-    serial->set_baud_rate(baud_rate);
-    serial->set_parity(Psc::serial::Parity::NoParity);
-    serial->set_data_bits(Psc::serial::DataBits::Data8);
-    serial->set_stop_bits(Psc::serial::StopBits::OneStop);
-    serial->set_flow_control(Psc::serial::FlowControl::HardwareControl);
-    serial->set_buffer_byte_size(10 * 1024);
-    if (!serial->open()) {
-        std::cerr << "createSerial " + std::string(serial_name) + ":" + std::to_string(baud_rate) + " 打开串口失败！\n";
-        Psc::fail_fast();
-        return nullptr;
-    }
-    else {
-        // std::cerr << "createSerial " + serial_name + ":" +
-        // std::to_string(baud_rate) + " 打开串口成功！\n";
-    }
-    return serial;
-}
 std::shared_ptr<Data_Source> create_from_json(const JSON* that_json, bool not_exist_use_default_value) {
     std::string type = that_json->get_string("type");
     std::shared_ptr<Data_Source> ret = create_data_source_from_type(type);
@@ -62,10 +42,6 @@ Data_Source::Data_Source() {
         });
     };
 }
-std::string Data_Source::thread_key() const {
-    // return "Data_Source_Handle_Thread:[" + key + "]";
-    return key + "_DS_HT";
-}
 void File_Data_Source::before_handle_msg(std::shared_ptr<SSR::Mode_Msg>& msg) {
     auto cur = std::dynamic_pointer_cast<SSR::Mode_Msg>(msg);
     if (cur != nullptr) {
diff --git a/module/Local_Server/Data_Source/Data_Source.h b/module/Local_Server/Data_Source/Data_Source.h
index f6643d8..6bccef1 100644
--- a/module/Local_Server/Data_Source/Data_Source.h
+++ b/module/Local_Server/Data_Source/Data_Source.h
@@ -175,7 +175,6 @@ public:
         co_return;
     }
     Frequency_Limit statistic_fl;
-    std::string thread_key() const;
     Psc::JSON statistic_json() {
         Psc::JSON ret = With_Loop_Coro::to_base_json();
         ret.append({"aircraft_total", get_aircraft_num()});
diff --git a/module/Local_Server/Data_Source/Data_Source_Handler.cpp b/module/Local_Server/Data_Source/Data_Source_Handler.cpp
index 7a85153..2ced602 100644
--- a/module/Local_Server/Data_Source/Data_Source_Handler.cpp
+++ b/module/Local_Server/Data_Source/Data_Source_Handler.cpp
@@ -233,21 +233,7 @@ void Data_Source_Handler::handle_mode_s(std::shared_ptr<SSR::Mode_S_Msg>& mode_s
                     oss << "\t\tds:" << msg->source->get_key();
                     oss << "\ttime:" << msg->mlat_timestamp.to_string() << std::endl;
                 }
-                // if (have_pos) {
-                // std::cout << oss.str() << std::endl;
                 pure_log("@/logs/mlat.log", oss.str());
-                // }
-                // if (t.size() > 3 && have_pos && icao == "78139F") {
-                //     size_t i = 1;
-                //     auto range = hex_mlat_map.equal_range(t.msg_hex());
-                //     // 遍历与key_to_find对应的所有元素
-                //     for (auto it = range.first; it != range.second; ++it) {
-                //         oss << "\t" << i++ << "  " << it->second.msg << std::endl;
-                //     }
-                //     oss << "===================================================\n";
-                //     std::cout << oss.str() << std::endl;
-                //     pure_log("@/logs/icao/" + icao + "_mlat.log", oss.str(), true);
-                // }
             }
         }
     }
@@ -370,13 +356,13 @@ std::optional<std::string> convert_to_send_format(Data_Source_Handler* ds, const
         if (!use_status)
             return std::nullopt;
         auto data = static_cast<SSR::Msg*>(msg.get());
-        if (output_format == Output_Data_Format::BIN || output_format == Output_Data_Format::BIN_ID) {
+        if (output_format == Output_Data_Format::BIN) {
             send_msg = SSR::packet_to_escape_format(data->packet);
         }
     }
     else if (type == SSR::Msg::Radarcape_status) {
         auto data = static_cast<SSR::Msg*>(msg.get());
-        if (output_format == Output_Data_Format::BIN || output_format == Output_Data_Format::BIN_ID) {
+        if (output_format == Output_Data_Format::BIN) {
             send_msg = SSR::packet_to_escape_format(data->packet);
         }
     }
@@ -385,21 +371,10 @@ std::optional<std::string> convert_to_send_format(Data_Source_Handler* ds, const
             return std::nullopt;
         auto data = static_cast<SSR::Mode_AC_Msg*>(msg.get());
         std::string& msg_hex = data->msg_hex;
-        char signal_level = data->signal_level;
         SSR::MLAT_timestamp& mlat_timestamp = data->mlat_timestamp;
         if (output_format == Output_Data_Format::BIN) {
-            // send_msg = create_Binary_Format_memory(msg_hex, signal_level,
-            // &mlat_timestamp);
             send_msg = SSR::packet_to_escape_format(msg->packet);
         }
-        else if (output_format == Output_Data_Format::BIN_ID) {
-            // std::uint32_t id;
-            // {
-            //     id = Global::instance()->mlat_server.id;
-            // }
-            // auto bin_id_packet = mode_s_msg_packet_to_server_packet(id,
-            // data->packet); send_msg = packet_to_escape_format(bin_id_packet);
-        }
         else if (output_format == Output_Data_Format::AVR) {
             send_msg = SSR::create_AVR_format(msg_hex);
         }
@@ -412,7 +387,6 @@ std::optional<std::string> convert_to_send_format(Data_Source_Handler* ds, const
         std::string& icao = s_msg->icao;
         SSR::Downlink_Format& df = s_msg->df;
         std::string& msg_hex = s_msg->msg_hex;
-        auto& signal_level = s_msg->signal_level;
         SSR::MLAT_timestamp& mlat_timestamp = s_msg->mlat_timestamp;
         auto aircraft = ds->get_aircraft(s_msg->icao);
         if (output_format == Output_Data_Format::SBS) {
@@ -462,16 +436,6 @@ std::optional<std::string> convert_to_send_format(Data_Source_Handler* ds, const
         }
         if (output_format == Output_Data_Format::BIN) {
             send_msg = SSR::packet_to_escape_format(s_msg->packet);
-            // send_msg = create_Binary_Format_memory(msg_hex, signal_level,
-            // &mlat_timestamp);
-        }
-        else if (output_format == Output_Data_Format::BIN_ID) {
-            // std::uint32_t id;
-            // {
-            //     id = Global::instance()->mlat_server.id;
-            // }
-            // auto bin_id_packet = mode_s_msg_packet_to_server_packet(id,
-            // data->packet); send_msg = packet_to_escape_format(bin_id_packet);
         }
         else if (output_format == Output_Data_Format::AVR) {
             send_msg = SSR::create_AVR_format(msg_hex);
diff --git a/module/Local_Server/Data_Source/Database.cpp b/module/Local_Server/Data_Source/Database.cpp
index b0c2fb3..624485d 100644
--- a/module/Local_Server/Data_Source/Database.cpp
+++ b/module/Local_Server/Data_Source/Database.cpp
@@ -407,14 +407,6 @@ Psc::JSON DataBase::aircraft_change_item_json(SSR::Aircraft_Info *info) {
   return ret;
 }
 
-JSON DataBase::get_all_aircraft_json() {
-  JSON json = JSON::array();
-  for (auto &it : get_visible_aircraft_snapshot()) {
-    json.children.push_back(aircraft_change_item_json(it.get()));
-  }
-  return json;
-}
-
 Psc::JSON DataBase::get_aircraft_change_update_json(
     std::unordered_map<std::string, std::string> &client_versions) {
   JSON ret = JSON::object();
diff --git a/module/Local_Server/Data_Source/Database.h b/module/Local_Server/Data_Source/Database.h
index 2072adc..d7448c4 100644
--- a/module/Local_Server/Data_Source/Database.h
+++ b/module/Local_Server/Data_Source/Database.h
@@ -159,7 +159,6 @@ public:
         return key;
     }
     std::atomic<size_t> have_pos_aircraft_num{};
-    Psc::JSON get_all_aircraft_json();
     std::vector<std::shared_ptr<SSR::Aircraft_Info>> get_visible_aircraft_snapshot();
     std::uint64_t aircraft_change_version(SSR::Aircraft_Info* info);
     Psc::JSON aircraft_change_item_json(SSR::Aircraft_Info* info);
diff --git a/module/Local_Server/server/Adminive_Config.cpp b/module/Local_Server/server/Adminive_Config.cpp
index 836fc5f..b3b7790 100644
--- a/module/Local_Server/server/Adminive_Config.cpp
+++ b/module/Local_Server/server/Adminive_Config.cpp
@@ -229,10 +229,10 @@ struct Type_View_Descriptor<Mode_ACS_Config_Data> {
     static Form_View edit() {
         using T = Mode_ACS_Config_Data;
         return edit_form<T>(vertical(
-            group("基础时序", grid(2, use<&T::timeout_seconds>(), use<&T::read_milliseconds>(), use<&T::air_pos_timeout>(), use<&T::surface_pos_timeout>())),
+            group("基础时序", grid(2, use<&T::timeout_seconds>(), use<&T::air_pos_timeout>(), use<&T::surface_pos_timeout>())),
             group("过滤参数", grid(2, use<&T::max_speed_m_s>(), use<&T::time_space_filter>(), use<&T::speed_filter>(), use<&T::aircraft_change_list_adsb_range_filter>(), use<&T::aircraft_change_list_adsb_range_factor>(), use<&T::adsb_theoretical_target_altitude_meters>())),
             group("容量与上报", grid(2, use<&T::max_track_point_size>(), use<&T::mode_s_max_num>(), use<&T::mode_other_max_num>(), use<&T::report_data_feed_msg_mum>(), use<&T::default_min_aircraft_list_num>(), use<&T::aircraft_change_list_min_position_points>())),
-            group("运行开关", grid(2, use<&T::wait_process_msg>(), use<&T::ignore_df_11>(), use<&T::monitor_msg_live>())))).submit("保存 Mode ACS 配置");
+            group("运行开关", grid(2, use<&T::wait_process_msg>(), use<&T::monitor_msg_live>())))).submit("保存 Mode ACS 配置");
     }
 };
 template <>
@@ -250,14 +250,14 @@ template <>
 struct Type_View_Descriptor<Data_feed_Config_Data> {
     static Form_View edit() {
         using T = Data_feed_Config_Data;
-        return edit_form<T>(grid(2, use<&T::packet_byte_size>(), use<&T::empty_wait_milliseconds>(), use<&T::tcp_server_default_connect_user_buffer_size>(), use<&T::tcp_server_default_connect_system_buffer_size>())).submit("保存数据馈送全局配置");
+        return edit_form<T>(grid(2, use<&T::packet_byte_size>())).submit("保存数据馈送全局配置");
     }
 };
 template <>
 struct Type_View_Descriptor<MLAT_Config_Data> {
     static Form_View edit() {
         using T = MLAT_Config_Data;
-        return edit_form<T>(grid(2, use<&T::enable>(), use<&T::merge>(), use<&T::library_path>(), use<&T::function_name>())).submit("保存 MLAT 配置");
+        return edit_form<T>(grid(2, use<&T::merge>())).submit("保存 MLAT 配置");
     }
 };
 }
@@ -268,41 +268,38 @@ class Conflict_Error final : public std::runtime_error {
 public:
     using std::runtime_error::runtime_error;
 };
+class Bad_Request_Error final : public std::runtime_error {
+public:
+    using std::runtime_error::runtime_error;
+};
 template <class Model>
 adminive::Resource_Transaction<Model> value_section_transaction(Config_Section section) {
     adminive::Resource_Transaction<Model> transaction;
     transaction.commit = [section](const Model& value, const adminive::Request_Context&) {
         Config::save(section, value.to_base_json());
     };
-    transaction.rollback = [section](const Model& value, const adminive::Request_Context&) {
-        Config::save(section, value.to_base_json());
-    };
+    transaction.rollback = transaction.commit;
     return transaction;
 }
 adminive::Resource_Transaction<Mode_ACS_Config_Data> mode_acs_transaction() {
     adminive::Resource_Transaction<Mode_ACS_Config_Data> transaction;
-    transaction.commit = [](const Mode_ACS_Config_Data& value, const adminive::Request_Context&) {
-        SSR::Monitor_Mode_ACS_Message_Num = value.monitor_msg_live;
-        Config::merge(Config_Section::mode_acs, value.to_base_json());
-    };
-    transaction.rollback = [](const Mode_ACS_Config_Data& value, const adminive::Request_Context&) {
+    const auto persist = [](const Mode_ACS_Config_Data& value, const adminive::Request_Context&) {
         SSR::Monitor_Mode_ACS_Message_Num = value.monitor_msg_live;
         Config::merge(Config_Section::mode_acs, value.to_base_json());
     };
+    transaction.commit = persist;
+    transaction.rollback = persist;
     return transaction;
 }
 adminive::Resource_Transaction<Data_feed_Config_Data> data_feed_settings_transaction() {
     adminive::Resource_Transaction<Data_feed_Config_Data> transaction;
-    transaction.commit = [](const Data_feed_Config_Data& value, const adminive::Request_Context&) {
-        auto patch = Psc::JSON::object();
-        patch.append({"data_feed", value.to_base_json()});
-        Config::merge(Config_Section::mode_acs, patch);
-    };
-    transaction.rollback = [](const Data_feed_Config_Data& value, const adminive::Request_Context&) {
+    const auto persist = [](const Data_feed_Config_Data& value, const adminive::Request_Context&) {
         auto patch = Psc::JSON::object();
         patch.append({"data_feed", value.to_base_json()});
         Config::merge(Config_Section::mode_acs, patch);
     };
+    transaction.commit = persist;
+    transaction.rollback = persist;
     return transaction;
 }
 adminive::Resource_Transaction<Map_View_Config> map_view_transaction(Global* global) {
@@ -321,20 +318,15 @@ adminive::Resource_Transaction<Map_View_Config> map_view_transaction(Global* glo
                 throw adminive::Field_Validation_Error("map3d.current_terrain_key", "地形源不存在");
         });
     };
-    transaction.commit = [global](const Map_View_Config& value, const adminive::Request_Context&) {
-        global->map_resources_config.write([&](auto& resources) {
-            resources.current_imagery_key = value.scene_mode == "2d" ? value.map2d.current_imagery_key : value.map3d.current_imagery_key;
-        });
-        Config::save(Config_Section::map_view, value.to_base_json());
-        Config::save(Config_Section::map_resources);
-    };
-    transaction.rollback = [global](const Map_View_Config& value, const adminive::Request_Context&) {
+    const auto persist = [global](const Map_View_Config& value, const adminive::Request_Context&) {
         global->map_resources_config.write([&](auto& resources) {
             resources.current_imagery_key = value.scene_mode == "2d" ? value.map2d.current_imagery_key : value.map3d.current_imagery_key;
         });
         Config::save(Config_Section::map_view, value.to_base_json());
         Config::save(Config_Section::map_resources);
     };
+    transaction.commit = persist;
+    transaction.rollback = persist;
     return transaction;
 }
 void save_data_sources(Global* global) {
@@ -358,6 +350,8 @@ template <class Function>
 adminive::Http_Response<Json> business_response(Function&& function) noexcept {
     try {
         return std::forward<Function>(function)();
+    } catch(const Bad_Request_Error& error) {
+        return adminive::make_http_error<Json>(400, error.what());
     } catch(const Conflict_Error& error) {
         return adminive::make_http_error<Json>(409, error.what());
     } catch(const std::out_of_range& error) {
@@ -370,6 +364,15 @@ adminive::Http_Response<Json> business_response(Function&& function) noexcept {
         return adminive::make_http_error<Json>(500, "unknown server error");
     }
 }
+Json read_request_body(std::string_view body) {
+    try {
+        auto input = adminive::parse_json<Json>(body);
+        adminive::Json_Adapter<Json>::erase(input, "id");
+        return input;
+    } catch(const std::exception& error) {
+        throw Bad_Request_Error(error.what());
+    }
+}
 template <class Function>
 void complete_business_request(std::function<void(const drogon::HttpResponsePtr&)>& callback, Function&& function) noexcept {
     callback(adminive::make_drogon_response(business_response(std::forward<Function>(function))));
@@ -630,6 +633,29 @@ adminive::Http_Response<Json> item_response(std::string path, std::vector<Row> r
     adminive::Collection_Service<Row, Json> collection(std::move(path), std::move(rows));
     return collection.item_response(id);
 }
+template <class Row, class Descriptor_Factory, class Rows_Factory, class Schema_Factory>
+void bind_collection_read_handlers(drogon::HttpAppFramework& app, std::string path,
+                                   Descriptor_Factory descriptor_factory, Rows_Factory rows_factory,
+                                   Schema_Factory schema_factory, bool bind_item) {
+    const auto get = adminive::make_drogon_constraints(drogon::Get, {});
+    app.registerHandler(path + "/descriptor", [descriptor_factory](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
+        callback(adminive::make_drogon_response(adminive::make_http_success<Json>(descriptor_factory())));
+    }, get);
+    app.registerHandler(path + "/view", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
+        callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_view_json<Json, Row>(adminive::describe_table_view<Row>()))));
+    }, get);
+    app.registerHandler(path + "/amis", [schema_factory](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
+        callback(adminive::make_drogon_response(adminive::make_http_success<Json>(schema_factory())));
+    }, get);
+    app.registerHandler(path, [path, rows_factory](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
+        callback(adminive::make_drogon_response(list_response<Row>(path, rows_factory(), read_collection_query(request))));
+    }, get);
+    if(bind_item) {
+        app.registerHandler(path + "/{1:id}", [path, rows_factory](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback, std::uint64_t id) {
+            callback(adminive::make_drogon_response(item_response<Row>(path, rows_factory(), id)));
+        }, get);
+    }
+}
 std::vector<Data_Source_Row> source_rows(Global* global) {
     std::vector<Data_Source_Row> rows;
     for(const auto& source : global->mode_acs.data_source_config.map.list())
@@ -832,51 +858,23 @@ private:
         }, get);
     }
     void bind_external_resources(drogon::HttpAppFramework& app) {
-        const auto get = adminive::make_drogon_constraints(drogon::Get, {});
-        app.registerHandler(external_resources_path + "/descriptor", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_descriptor_json<Json, External_Resource_Row>())));
-        }, get);
-        app.registerHandler(external_resources_path + "/view", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_view_json<Json, External_Resource_Row>(adminive::describe_table_view<External_Resource_Row>()))));
-        }, get);
-        app.registerHandler(external_resources_path + "/amis", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(adminive::make_http_success<Json>(external_resource_amis_schema())));
-        }, get);
-        app.registerHandler(external_resources_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(list_response<External_Resource_Row>(external_resources_path, external_resource_rows(global_), read_collection_query(request))));
-        }, get);
+        bind_collection_read_handlers<External_Resource_Row>(app, external_resources_path,
+            [] { return adminive::to_descriptor_json<Json, External_Resource_Row>(); },
+            [this] { return external_resource_rows(global_); },
+            [] { return external_resource_amis_schema(); }, false);
     }
     void bind_data_sources(drogon::HttpAppFramework& app) {
-        const auto get = adminive::make_drogon_constraints(drogon::Get, {});
         const auto post = adminive::make_drogon_constraints(drogon::Post, {});
         const auto put = adminive::make_drogon_constraints(drogon::Put, {});
         const auto patch = adminive::make_drogon_constraints(drogon::Patch, {});
         const auto remove = adminive::make_drogon_constraints(drogon::Delete, {});
-        app.registerHandler(data_sources_path + "/descriptor", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(adminive::make_http_success<Json>(data_source_descriptor())));
-        }, get);
-        app.registerHandler(data_sources_path + "/view", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_view_json<Json, Data_Source_Row>(adminive::describe_table_view<Data_Source_Row>()))));
-        }, get);
-        app.registerHandler(data_sources_path + "/amis", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(adminive::make_http_success<Json>(source_amis_schema())));
-        }, get);
-        app.registerHandler(data_sources_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(list_response<Data_Source_Row>(data_sources_path, source_rows(global_), read_collection_query(request))));
-        }, get);
-        app.registerHandler(data_sources_path + "/{1:id}", [this](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback, std::uint64_t id) {
-            callback(adminive::make_drogon_response(item_response<Data_Source_Row>(data_sources_path, source_rows(global_), id)));
-        }, get);
+        bind_collection_read_handlers<Data_Source_Row>(app, data_sources_path,
+            [] { return data_source_descriptor(); }, [this] { return source_rows(global_); },
+            [] { return source_amis_schema(); }, true);
         app.registerHandler(data_sources_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
             complete_business_request(callback, [this, body = std::string(request->getBody())] {
                 std::lock_guard lock(topology_mutex_);
-                Json input;
-                try {
-                    input = adminive::parse_json<Json>(body);
-                } catch(const std::exception& error) {
-                    return adminive::make_http_error<Json>(400, error.what());
-                }
-                adminive::Json_Adapter<Json>::erase(input, "id");
+                auto input = read_request_body(body);
                 Data_Source_Row row;
                 const auto result = adminive::apply_frontend_create<Json>(row, input);
                 if(!result.success)
@@ -897,13 +895,7 @@ private:
                 std::lock_guard lock(topology_mutex_);
                 const auto list = global_->mode_acs.data_source_config.map.list();
                 auto source = item_by_id(list, id);
-                Json input;
-                try {
-                    input = adminive::parse_json<Json>(body);
-                } catch(const std::exception& error) {
-                    return adminive::make_http_error<Json>(400, error.what());
-                }
-                adminive::Json_Adapter<Json>::erase(input, "id");
+                auto input = read_request_body(body);
                 auto row = source_row(source);
                 const auto result = adminive::apply_frontend_patch<Json>(row, input);
                 if(!result.success)
@@ -945,36 +937,17 @@ private:
         }, post);
     }
     void bind_data_feeds(drogon::HttpAppFramework& app) {
-        const auto get = adminive::make_drogon_constraints(drogon::Get, {});
         const auto post = adminive::make_drogon_constraints(drogon::Post, {});
         const auto put = adminive::make_drogon_constraints(drogon::Put, {});
         const auto patch = adminive::make_drogon_constraints(drogon::Patch, {});
         const auto remove = adminive::make_drogon_constraints(drogon::Delete, {});
-        app.registerHandler(data_feeds_path + "/descriptor", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_descriptor_json<Json, Data_Feed_Row>())));
-        }, get);
-        app.registerHandler(data_feeds_path + "/view", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_view_json<Json, Data_Feed_Row>(adminive::describe_table_view<Data_Feed_Row>()))));
-        }, get);
-        app.registerHandler(data_feeds_path + "/amis", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(adminive::make_http_success<Json>(feed_amis_schema())));
-        }, get);
-        app.registerHandler(data_feeds_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(list_response<Data_Feed_Row>(data_feeds_path, feed_rows(global_), read_collection_query(request))));
-        }, get);
-        app.registerHandler(data_feeds_path + "/{1:id}", [this](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback, std::uint64_t id) {
-            callback(adminive::make_drogon_response(item_response<Data_Feed_Row>(data_feeds_path, feed_rows(global_), id)));
-        }, get);
+        bind_collection_read_handlers<Data_Feed_Row>(app, data_feeds_path,
+            [] { return adminive::to_descriptor_json<Json, Data_Feed_Row>(); },
+            [this] { return feed_rows(global_); }, [] { return feed_amis_schema(); }, true);
         app.registerHandler(data_feeds_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
             complete_business_request(callback, [this, body = std::string(request->getBody())] {
                 std::lock_guard lock(topology_mutex_);
-                Json input;
-                try {
-                    input = adminive::parse_json<Json>(body);
-                } catch(const std::exception& error) {
-                    return adminive::make_http_error<Json>(400, error.what());
-                }
-                adminive::Json_Adapter<Json>::erase(input, "id");
+                auto input = read_request_body(body);
                 Data_Feed_Row row;
                 const auto result = adminive::apply_frontend_create<Json>(row, input);
                 if(!result.success)
@@ -995,13 +968,7 @@ private:
                 std::lock_guard lock(topology_mutex_);
                 const auto list = global_->mode_acs.data_feed_config.map.list();
                 auto feed = item_by_id(list, id);
-                Json input;
-                try {
-                    input = adminive::parse_json<Json>(body);
-                } catch(const std::exception& error) {
-                    return adminive::make_http_error<Json>(400, error.what());
-                }
-                adminive::Json_Adapter<Json>::erase(input, "id");
+                auto input = read_request_body(body);
                 auto row = feed_row(feed);
                 const auto result = adminive::apply_frontend_patch<Json>(row, input);
                 if(!result.success)
@@ -1043,36 +1010,17 @@ private:
         }, post);
     }
     void bind_relations(drogon::HttpAppFramework& app) {
-        const auto get = adminive::make_drogon_constraints(drogon::Get, {});
         const auto post = adminive::make_drogon_constraints(drogon::Post, {});
         const auto put = adminive::make_drogon_constraints(drogon::Put, {});
         const auto patch = adminive::make_drogon_constraints(drogon::Patch, {});
         const auto remove = adminive::make_drogon_constraints(drogon::Delete, {});
-        app.registerHandler(relations_path + "/descriptor", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_descriptor_json<Json, Source_Feed_Relation_Row>())));
-        }, get);
-        app.registerHandler(relations_path + "/view", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_view_json<Json, Source_Feed_Relation_Row>(adminive::describe_table_view<Source_Feed_Relation_Row>()))));
-        }, get);
-        app.registerHandler(relations_path + "/amis", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(adminive::make_http_success<Json>(relation_amis_schema())));
-        }, get);
-        app.registerHandler(relations_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-            callback(adminive::make_drogon_response(list_response<Source_Feed_Relation_Row>(relations_path, relation_rows(global_), read_collection_query(request))));
-        }, get);
-        app.registerHandler(relations_path + "/{1:id}", [this](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback, std::uint64_t id) {
-            callback(adminive::make_drogon_response(item_response<Source_Feed_Relation_Row>(relations_path, relation_rows(global_), id)));
-        }, get);
+        bind_collection_read_handlers<Source_Feed_Relation_Row>(app, relations_path,
+            [] { return adminive::to_descriptor_json<Json, Source_Feed_Relation_Row>(); },
+            [this] { return relation_rows(global_); }, [] { return relation_amis_schema(); }, true);
         app.registerHandler(relations_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
             complete_business_request(callback, [this, body = std::string(request->getBody())] {
                 std::lock_guard lock(topology_mutex_);
-                Json input;
-                try {
-                    input = adminive::parse_json<Json>(body);
-                } catch(const std::exception& error) {
-                    return adminive::make_http_error<Json>(400, error.what());
-                }
-                adminive::Json_Adapter<Json>::erase(input, "id");
+                auto input = read_request_body(body);
                 Source_Feed_Relation_Row row;
                 const auto result = adminive::apply_frontend_create<Json>(row, input);
                 if(!result.success)
@@ -1092,13 +1040,7 @@ private:
                 std::lock_guard lock(topology_mutex_);
                 const auto list = global_->mode_acs.source_feed_relation_config.map.list();
                 auto relation = item_by_id(list, id);
-                Json input;
-                try {
-                    input = adminive::parse_json<Json>(body);
-                } catch(const std::exception& error) {
-                    return adminive::make_http_error<Json>(400, error.what());
-                }
-                adminive::Json_Adapter<Json>::erase(input, "id");
+                auto input = read_request_body(body);
                 auto row = relation_row(relation);
                 const auto result = adminive::apply_frontend_patch<Json>(row, input);
                 if(!result.success)
diff --git a/module/Local_Server/server/Config.cpp b/module/Local_Server/server/Config.cpp
index dec60d2..ee5b657 100644
--- a/module/Local_Server/server/Config.cpp
+++ b/module/Local_Server/server/Config.cpp
@@ -1,7 +1,6 @@
 #include "Config.h"
 #include "Config_Default.h"
 #include <algorithm>
-#include <array>
 #include <exception>
 #include <filesystem>
 #include <mutex>
@@ -10,14 +9,8 @@
 #include <utility>
 #include "Global.h"
 #include "Psc_Cpp_Core/Base/Check.h"
-#include "Psc_Cpp_Core/Net_Adapter/Net_Adapter.h"
-#undef interface
 std::string default_config_directory;
 namespace {
-constexpr std::string_view config_section_names[] = {"version", "dsp", "drogon", "http_monitor", "mlat", "web_server", "map_resources", "map_view", "map_models", "device", "mode_acs", "log", "console", "external_database", "cesium_graphics"};
-constexpr std::string_view config_section_name(Config_Section section) {
-    return config_section_names[static_cast<std::size_t>(section)];
-}
 std::filesystem::path config_directory() {
     if (!default_config_directory.empty()) {
         return default_config_directory;
@@ -116,7 +109,6 @@ Psc::JSON config_section_value(Global& global, Config_Section section) {
         return global.map_model_config.read([](const auto& value) {
             return value.to_base_json();
         });
-    case Config_Section::device: return global.device_config.to_base_json();
     case Config_Section::mode_acs: return global.mode_acs.to_base_json();
     case Config_Section::log: return global.log_config.to_base_json();
     case Config_Section::console: return global.console_config.to_base_json();
@@ -127,11 +119,10 @@ Psc::JSON config_section_value(Global& global, Config_Section section) {
     std::terminate();
 }
 }
-std::string get_config_directory() {
-    return config_directory().string();
-}
 Psc::JSON Config::load() {
     std::filesystem::create_directories(config_directory());
+    std::error_code ignored_error;
+    std::filesystem::remove(config_directory() / "device.json", ignored_error);
     const auto defaults = Psc::parse_json(std::string_view(reinterpret_cast<const char*>(ecap_default_config_json), sizeof(ecap_default_config_json)));
     auto result = Psc::JSON::object();
     for (std::size_t index = 0; index < static_cast<std::size_t>(Config_Section::count); ++index) {
@@ -141,20 +132,19 @@ Psc::JSON Config::load() {
     std::cout << get_current_date_string() << " 启动加载配置目录: 【" << config_directory().string() << "】" << std::endl;
     return result;
 }
-static std::vector<std::string> read_string_array(const Psc::JSON* json, std::string_view key) {
-    auto field = json->get(key);
-    if (field == nullptr || field->valueType != Psc::Array) {
-        throw Psc::json_assign_error(std::make_error_code(std::errc::invalid_argument), std::string(key));
+Psc::JSON Web_Server_Config::to_base_json() const {
+    return Psc::JSON::object({{"webapp", webapp}, {"listen_port", listen_port}});
+}
+void Web_Server_Config::from_base_json(const Psc::JSON* that_json, bool not_exist_use_default_value) {
+    std::error_code error;
+    auto result = Psc::assign_field_ec(webapp, that_json, "webapp", error);
+    if(!not_exist_use_default_value)
+        Psc::check_json_assign_field(result, error, that_json, "webapp");
+    if(that_json != nullptr && that_json->get("listen_port") != nullptr) {
+        error.clear();
+        result = Psc::assign_field_ec(listen_port, that_json, "listen_port", error);
+        Psc::check_json_assign_field(result, error, that_json, "listen_port");
     }
-    std::vector<std::string> ret;
-    ret.reserve(field->children.size());
-    for (const auto& child : field->children) {
-        if (child.valueType != Psc::String) {
-            throw Psc::json_assign_error(std::make_error_code(std::errc::invalid_argument), std::string(key));
-        }
-        ret.emplace_back(child.val);
-    }
-    return ret;
 }
 static std::vector<std::string> read_optional_string_array(const Psc::JSON* json, std::string_view key) {
     auto field = json->get(key);
@@ -459,11 +449,8 @@ void Map_View_Config::from_base_json(const Psc::JSON* that_json, bool not_exist_
     map2d.from_base_json(that_json->get("map2d"), not_exist_use_default_value);
     map3d.from_base_json(that_json->get("map3d"), not_exist_use_default_value);
     camera.from_base_json(that_json->get("camera"), not_exist_use_default_value);
-    const auto height_key = that_json->get("base_station_fly_to_height_offset_meters")
-                                ? "base_station_fly_to_height_offset_meters"
-                                : "baseStationFlyToHeightOffsetMeters";
     base_station_fly_to_height_offset_meters =
-    std::max(100.0, read_optional_double_field(that_json, height_key, base_station_fly_to_height_offset_meters));
+        std::max(100.0, read_optional_double_field(that_json, "base_station_fly_to_height_offset_meters", base_station_fly_to_height_offset_meters));
 }
 Psc::JSON Map_View_Config::to_base_json() const {
     auto ret = Psc::JSON::object();
@@ -552,116 +539,6 @@ void Mode_ACS_Config::server(Global* g) {
     data_source_config.server(g);
     data_feed_config.server(g);
 }
-void Device_Config::server(Global* g) {
-    auto& svr = g->svr;
-    auto& api = g->api;
-    svr.Post(api + "get_device_config", [this](HTTP_Param) { res->setBody(warp(to_base_json()).to_json_string()); });
-    svr.Post(api + "get_net_adapter_list", [this](HTTP_Param) {
-        JSON ret = JSON::object();
-        auto arr = JSON::array();
-        for (auto& it : Psc::get_net_adapter_info_map()) {
-            arr.append(it.second.to_Json());
-        }
-        ret.append({"list", arr});
-        res->setBody(warp(ret).to_json_string());
-    });
-    svr.Post(api + "set_device_config", [this](HTTP_Param) {
-        CHECK_JSON_PARAM
-        JSON old_device_config;
-        {
-            old_device_config = to_base_json();
-        }
-        HTTP_REQUIRE_PTR(net, params.get("net"))
-        Net_Config device, wifi;
-        bool has_device = false;
-        bool has_wifi = false;
-        for (const auto& it : net->children) {
-            HTTP_REQUIRE_VALUE(net_key, it.try_get_string("key"))
-            if (net_key == "device") {
-                device.from_base_json(&it, true);
-                has_device = true;
-            }
-            if (net_key == "wifi") {
-                wifi.from_base_json(&it, true);
-                has_wifi = true;
-            }
-        }
-        HTTP_REQUIRE_TRUE(has_device && has_wifi, "net")
-        bool it1 = check_ip_netmask_gateway(device.ip, device.netmask, device.gateway);
-        bool it2 = check_ip_netmask_gateway(wifi.ip, wifi.netmask, wifi.gateway);
-        bool p1 = check_port(device.port);
-        bool p2 = check_port(wifi.port);
-        if (!it1 || !it2 || !p1 || !p2) {
-            server_logger->error("", {}, LOG_POS + "  ip port! " + device.ip + ":" + std::to_string(device.port));
-            res->setBody(warp(old_device_config).to_json_string());
-            return;
-        }
-#if WIN32
-        bool use = false;
-#else
-    bool use = true;
-#endif
-        {
-            auto& w = *this;
-            *w.list.get("device").value() = device;
-            *w.list.get("wifi").value() = wifi;
-        }
-        Global::save(Config_Section::device);
-        if (use) {
-            std::string interface;
-            {
-                std::string path = get_exe_dir() + "/interface";
-                std::ifstream ifs(path);
-                if (!ifs.is_open()) {
-                    server_logger->error("", {}, LOG_POS + "  无法打开文件! " + path);
-                    res->setBody(warp(old_device_config).to_json_string());
-                    return;
-                }
-                std::stringstream buffer;
-                buffer << ifs.rdbuf();
-                interface = buffer.str();
-            }
-            static auto set = [](std::string& interface, std::string_view token, std::string_view value) {
-                std::string var_name = "${" + std::string(token) + "}";
-                auto size = var_name.size();
-                size_t pos = interface.find(var_name);
-                while (pos != std::string::npos) {
-                    interface.replace(pos, size, value);
-                    pos = interface.find(var_name);
-                }
-            };
-            set(interface, "ip", device.ip);
-            set(interface, "gateway", device.gateway);
-            set(interface, "netmask", device.netmask);
-            set(interface, "wifi_ip", wifi.ip);
-            set(interface, "wifi_gateway", wifi.gateway);
-            set(interface, "wifi_netmask", wifi.netmask);
-            std::cout << interface << std::endl;
-            std::string path = "/etc/network/interfaces";
-            std::ofstream outfile(path);
-            if (!outfile.is_open()) {
-                server_logger->error("", {}, LOG_POS + "  无法打开文件!" + path);
-                res->setBody(warp(old_device_config).to_json_string());
-                return;
-            }
-            outfile << interface;
-            outfile.close();
-            std::string bash_path = get_exe_dir() + "/restart_net_service.sh";
-            if (!std::filesystem::exists(bash_path)) {
-                server_logger->error("", {}, LOG_POS + "  !" + bash_path);
-                res->setBody(warp(old_device_config).to_json_string());
-                return;
-            }
-            int result = system(bash_path.c_str());
-            if (result != 0) {
-                server_logger->error("", {}, LOG_POS + "  脚本执行失败!" + bash_path);
-                res->setBody(warp(old_device_config).to_json_string());
-                return;
-            }
-        }
-        res->setBody(warp(params).to_json_string());
-    });
-}
 void Config::save() {
     auto& global = *Global::instance();
     for (std::size_t index = 0; index < static_cast<std::size_t>(Config_Section::count); ++index) {
diff --git a/module/Local_Server/server/Config.h b/module/Local_Server/server/Config.h
index 0c095c7..f41a61a 100644
--- a/module/Local_Server/server/Config.h
+++ b/module/Local_Server/server/Config.h
@@ -1,5 +1,6 @@
 #ifndef CONFIG_H_H
 #define CONFIG_H_H
+#include <array>
 #include <fstream>
 #include <map>
 #include <vector>
@@ -13,25 +14,37 @@
 #include "adminive/managed.hpp"
 inline bool delete_log = false;
 extern std::string default_config_directory;
-std::string get_config_directory();
+#define ECAP_CONFIG_SECTION_LIST(X) \
+    X(version)                        \
+    X(dsp)                            \
+    X(drogon)                         \
+    X(http_monitor)                   \
+    X(mlat)                           \
+    X(web_server)                     \
+    X(map_resources)                  \
+    X(map_view)                       \
+    X(map_models)                     \
+    X(mode_acs)                       \
+    X(log)                            \
+    X(console)                        \
+    X(external_database)              \
+    X(cesium_graphics)
 enum class Config_Section {
-    version,
-    dsp,
-    drogon,
-    http_monitor,
-    mlat,
-    web_server,
-    map_resources,
-    map_view,
-    map_models,
-    device,
-    mode_acs,
-    log,
-    console,
-    external_database,
-    cesium_graphics,
+#define ECAP_CONFIG_SECTION_ENUM(name) name,
+    ECAP_CONFIG_SECTION_LIST(ECAP_CONFIG_SECTION_ENUM)
+#undef ECAP_CONFIG_SECTION_ENUM
     count
 };
+inline constexpr std::array config_section_names = {
+#define ECAP_CONFIG_SECTION_NAME(name) std::string_view{#name},
+    ECAP_CONFIG_SECTION_LIST(ECAP_CONFIG_SECTION_NAME)
+#undef ECAP_CONFIG_SECTION_NAME
+};
+#undef ECAP_CONFIG_SECTION_LIST
+static_assert(config_section_names.size() == static_cast<std::size_t>(Config_Section::count));
+inline constexpr std::string_view config_section_name(Config_Section section) {
+    return config_section_names[static_cast<std::size_t>(section)];
+}
 struct Log_Config {
     ~Log_Config() {
         if (delete_log)
@@ -50,8 +63,6 @@ struct Console_Config {
     }
     bool record_playback;
     bool mode_s_console;
-    bool post_request;
-    bool mlat_server;
     PSC_USE_JSON
 };
 struct Http_Monitor_Config {
@@ -65,7 +76,6 @@ struct Mode_ACS_Config_Data {
     SSR::CPR::D max_speed_m_s{};
     SSR::CPR::D air_pos_timeout = 8;
     SSR::CPR::D surface_pos_timeout = 32;
-    std::size_t read_milliseconds{};
     bool wait_process_msg{};
     bool time_space_filter{};
     bool speed_filter{};
@@ -78,7 +88,6 @@ struct Mode_ACS_Config_Data {
     bool aircraft_change_list_adsb_range_filter = true;
     double aircraft_change_list_adsb_range_factor = 1.2;
     double adsb_theoretical_target_altitude_meters = 10000.0;
-    bool ignore_df_11{};
     bool monitor_msg_live{};
     PSC_USE_JSON
 };
@@ -92,7 +101,6 @@ struct Type_Descriptor<Mode_ACS_Config_Data> {
                          ADMINIVE_FIELD_LABEL(T, max_speed_m_s, "飞机最大速度（m/s）").editable().required().number_input(),
                          ADMINIVE_FIELD_LABEL(T, air_pos_timeout, "空中 CPR 超时（秒）").editable().required().number_input(),
                          ADMINIVE_FIELD_LABEL(T, surface_pos_timeout, "地面 CPR 超时（秒）").editable().required().number_input(),
-                         ADMINIVE_FIELD_LABEL(T, read_milliseconds, "读取数据源延时（毫秒）").editable().required().number_input(),
                          ADMINIVE_FIELD_LABEL(T, wait_process_msg, "等待处理消息").editable().boolean_input(),
                          ADMINIVE_FIELD_LABEL(T, time_space_filter, "时空过滤").editable().boolean_input(),
                          ADMINIVE_FIELD_LABEL(T, speed_filter, "速度过滤").editable().boolean_input(),
@@ -105,7 +113,6 @@ struct Type_Descriptor<Mode_ACS_Config_Data> {
                          ADMINIVE_FIELD_LABEL(T, aircraft_change_list_adsb_range_filter, "基站理论范围过滤").editable().boolean_input(),
                          ADMINIVE_FIELD_LABEL(T, aircraft_change_list_adsb_range_factor, "范围过滤系数").editable().required().number_input(),
                          ADMINIVE_FIELD_LABEL(T, adsb_theoretical_target_altitude_meters, "理论目标高度（米）").editable().required().number_input(),
-                         ADMINIVE_FIELD_LABEL(T, ignore_df_11, "忽略 DF11").editable().boolean_input(),
                          ADMINIVE_FIELD_LABEL(T, monitor_msg_live, "监控 Mode ACS 消息").editable().boolean_input());
     }
 };
@@ -145,8 +152,10 @@ struct Web_Server_Config {
     [[nodiscard]] std::string get_true_webapp() const {
         return Psc::get_abs_path(webapp);
     }
-    PSC_USE_JSON
     std::string webapp;
+    std::uint16_t listen_port = 9081;
+    [[nodiscard]] Psc::JSON to_base_json() const;
+    void from_base_json(const Psc::JSON* that_json, bool not_exist_use_default_value);
 };
 enum class Map_Tile_File_Format { directory, mbtiles, online };
 enum class Map_Tile_Y_Axis { xyz, tms };
@@ -436,58 +445,11 @@ struct Type_Descriptor<Map_Model_Config> {
     }
 };
 }
-struct Net_Config {
-    std::string key{};
-    std::string ip{};
-    std::uint16_t port{};
-    std::string netmask{};
-    std::string gateway{};
-    PSC_USE_JSON
-};
-struct Device_Config {
-    Ordered_Map<std::string, Net_Config*> list;
-    ~Device_Config() {
-        if (delete_log)
-            std::cout << "~Device_Config()" << std::endl;
-        for (auto it : list.list()) {
-            delete it;
-        }
-        list.clear();
-    }
-    Psc::JSON to_base_json() {
-        Psc::JSON ret = Psc::JSON::object();
-        Psc::JSON net = Psc::JSON::array();
-        for (auto& li : list.list()) {
-            net.append(li->to_base_json());
-        }
-        ret.append({"net", net});
-        return ret;
-    }
-    Device_Config() = default;
-    void from_json(const Psc::JSON* that_json, bool not_exist_use_default_value) {
-        for (auto& li : that_json->get("net")->children) {
-            auto cur = new Net_Config();
-            cur->from_base_json(&li, not_exist_use_default_value);
-            list.push_back(cur);
-        }
-    }
-    Psc::JSON to_net_json() {
-        Psc::JSON ret = Psc::JSON::object();
-        Psc::JSON net = Psc::JSON::array();
-        for (auto& li : list.list()) {
-            net.append(li->to_base_json());
-        }
-        ret.append({"net", net});
-        return ret;
-    }
-    void server(Global* g);
-};
 class Config {
 public:
     Config() = default;
     DELETE_COPY(Config)
     MLAT_Config mlat;
-    Device_Config device_config;
     Web_Server_Config web_server_config;
     adminive::Managed_Value<Map_Resources_Config> map_resources_config;
     adminive::Managed_Value<Map_View_Config> map_view_config;
@@ -515,7 +477,6 @@ public:
         map_model_config.write([&](auto& value) {
             value.from_base_json(that_json->get("map_models"), not_exist_use_default_value);
         });
-        device_config.from_json(that_json->get("device"), not_exist_use_default_value);
         mode_acs.from_json(that_json->get("mode_acs"), not_exist_use_default_value);
         console_config.from_base_json(that_json->get("console"), not_exist_use_default_value);
         dsp_config.from_json(that_json->get("dsp"), not_exist_use_default_value);
@@ -534,9 +495,7 @@ public:
         {"map_resources", map_resources_config.read([](const auto& value) { return value.to_base_json(); })},
         {"map_view", map_view_config.read([](const auto& value) { return value.to_base_json(); })},
         {"map_models", map_model_config.read([](const auto& value) { return value.to_base_json(); })},
-        {"device", device_config.to_base_json()},
         {"mode_acs", mode_acs.to_base_json()},
-        //{"ais", ais.to_json()},
         {"log", log_config.to_base_json()},
         {"console", console_config.to_base_json()},
         {"external_database", external_resources_manager.to_base_json()},
diff --git a/module/Local_Server/server/Global.cpp b/module/Local_Server/server/Global.cpp
index f0c08f1..0be45ad 100644
--- a/module/Local_Server/server/Global.cpp
+++ b/module/Local_Server/server/Global.cpp
@@ -1,7 +1,6 @@
 #include "Global.h"
 #include <drogon/HttpAppFramework.h>
 #include <filesystem>
-#include <fstream>
 #include <sstream>
 #include <string>
 #include <string_view>
@@ -65,8 +64,6 @@ Global::Global() {
     serial::serial_logger = new BaseLogger("@/logs/serial", MB * size_MB, piece_num);
     SSR::mode_s_logger = new BaseLogger("@/logs/mode_s", MB * size_MB * 10, piece_num);
     dsp_logger = new BaseLogger("@/logs/dsp", MB * size_MB, piece_num);
-    // libais::libais_logger = new BaseLogger("@/logs/libais", MB * size_MB,
-    // piece_num);
     server_logger = new BaseLogger("@/logs/server", MB * size_MB, piece_num);
     asio_socket::socket_logger->set_redirect([](const BaseLogger::Log_Info& log_info) {
         auto msg = "[" + std::string("func") + "~" + log_info.func_pattern + "] " + log_info.log_type.to_string() +
@@ -124,144 +121,12 @@ Global::Global() {
     auto str = toJson().to_json_string();
     server_logger->debug("启动", {}, str);
     SSR::mode_s_logger->debug("启动", {}, str);
-    // libais::libais_logger->debug("启动", {}, str);
     std::cout << str << std::endl;
-    // libais::log = normal_log;
-    // libais::log = ais_log;
-    // mode_s_log_info = mode_s_log;
     init_web_server();
 }
 Global::~Global() {
     std::cout << "Global::~Global()" << std::endl;
 }
-void replace(std::string& originalStr, std::string_view findStr, std::string_view replaceStr) {
-    size_t pos = originalStr.find(findStr);
-    while (pos != std::string::npos) {
-        originalStr.replace(pos, findStr.length(), replaceStr);
-        pos = originalStr.find(findStr, pos + replaceStr.length());
-    }
-}
-std::string oneLine(std::string_view str) {
-    auto ret = std::string(str);
-    replace(ret, "\n", "[n]");
-    return ret;
-}
-bool isHexadecimal(std::string_view str) {
-    return std::all_of(str.begin(), str.end(), [](unsigned char c) {
-        return std::isdigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
-    });
-}
-void handle_buffer_muti_start(std::string& buffer, std::string_view data, const std::set<std::string>& prefix_list,
-                              const std::function<void(std::string&)>& callback) {
-    if (!data.empty()) {
-        buffer += data;
-        // std::cout << "[data]:" + data + "\n";
-        // std::cout << "[buffer]:" + buffer + "\n";
-        while (!buffer.empty() && buffer.back() == '\n') {
-            buffer.pop_back();
-        }
-        while (true) {
-            std::string c;
-            size_t pos = 0, n = buffer.size();
-            for (; pos < n; pos++) {
-                bool find = false;
-                for (std::string_view prefix : prefix_list) {
-                    if (pos + prefix.size() <= n) {
-                        if (buffer.substr(pos, prefix.size()) == prefix) {
-                            c = prefix;
-                            find = true;
-                            break;
-                        }
-                    }
-                }
-                if (find)
-                    break;
-            }
-            if (pos == n)
-                break;
-            std::string line = c + buffer.substr(0, pos); // 截取从开头到!之前的数据
-            buffer = buffer.substr(pos + 1); // 更新buffer为剩余数据
-            // std::cout << "[line]:" + line + "\n";
-            if (pos != 0)
-                callback(line);
-        }
-    }
-}
-void handle_buffer_head_tail(std::string& buffer, std::string_view data, std::string_view prefix,
-                             std::string_view suffix, const std::function<void(std::string&)>& callback) {
-    // 只在数据可用时进行读取
-    if (!data.empty()) {
-        buffer += data;
-        size_t pos;
-        while ((pos = buffer.find_first_of(suffix)) != std::string::npos) {
-            size_t start = buffer.find_first_of(prefix);
-            if (start == std::string::npos)
-                break;
-            std::string packet = buffer.substr(start + 1, pos - start - 1);
-            buffer.erase(0, pos + 1);
-            // 处理尾部空格
-            while (!buffer.empty() && buffer.back() == '\n') {
-                buffer.pop_back();
-            }
-            if (!packet.empty()) {
-                callback(packet);
-            }
-        }
-    }
-}
-void read_ais_serial_data(std::atomic<bool>& running) {
-    // static int t = config.ais.read_serial_milliseconds;
-    // static bool ais_log = config.console_config.ais_serial;
-    // static bool use_ais_serial = !config.ais_mock.enable ||
-    // config.ais_mock.use_real_serial; static auto lm =
-    // Light_Manager::instance(); serial::Serial* ais_serial{}; if
-    // (use_ais_serial) ais_serial = create_serial(config.ais.port_name,
-    // config.ais.baud_rate); libais::VdmStream stream; std::string ais_buffer;
-    // while (running.load(std::memory_order_acquire) == true)
-    // {
-    //     std::string ais_data = use_ais_serial ? ais_serial->read() :
-    //     mock_ais_serial.read(); if (!ais_data.empty())
-    //     {
-    //         if (ais_log && !ais_data.empty())
-    //         {
-    //             std::cout << "read:[ais_serial]:" << ais_data << std::endl;
-    //         }
-    //         libais::libais_logger->debug("ais_serial_read/ais_serial_read", {},
-    //         ais_data + "\n"); handle_buffer_muti_start(ais_buffer, ais_data,
-    //         {"!", "$"}, [&](std::string& line) {
-    //             lm->light_control(Light_Type::AIS, true);
-    //             stream.AddLine(line);
-    //             while (auto msg = stream.PopOldestMessage())
-    //             {
-    //                 parse_ais(msg.get());
-    //             }
-    //             lm->light_control(Light_Type::AIS, false);
-    //         });
-    //     }
-    //     std::this_thread::sleep_for(std::chrono::milliseconds(t));
-    // }
-    // delete ais_serial;
-}
-bool is_10004(SSR::Mode_S_Msg& msg) {
-    bool DF_11_17_18 = msg.df == SSR::Downlink_Format::All_Call_Reply_11 ||
-    msg.df == SSR::Downlink_Format::Extended_Squitter_17 ||
-    msg.df == SSR::Downlink_Format::Extended_Squitter_Non_Transponder_18;
-    return DF_11_17_18;
-}
-std::string to_file_name(std::string_view str) {
-    auto ret = std::string(str);
-    // 定义允许的合法字符
-    auto is_valid_char = [](char c) {
-        return std::isalnum(c) || c == '_' || c == '-' || c == '.'; // 允许字母、数字、下划线、连字符、点
-    };
-    // 替换非法字符为下划线 '_'
-    std::transform(ret.begin(), ret.end(), ret.begin(), [&](char c) { return is_valid_char(c) ? c : '_'; });
-    // 检查结果字符串是否全是替换字符，防止生成全是下划线的文件名
-    if (ret.find_first_not_of('_') == std::string::npos) {
-        return "default_file_name"; // 返回一个默认文件名
-    }
-    return ret;
-}
 void Debug_Logger_Info_Manager::push_info(std::string_view c) {
     std::lock_guard g(mtx);
     std::string content = std::to_string(cur_serial_number) + ": " + std::string(c);
@@ -361,34 +226,6 @@ Web_Server& Web_Server::Get(std::string_view pattern, Handler handler) {
     {drogon::Get});
     return *this;
 }
-Web_Server& Web_Server::Get_Coro(std::string_view pattern, CoroHandler handler) {
-    drogon::app().registerHandlerViaRegex(
-    std::string(pattern),
-    [handler = std::move(handler)](const drogon::HttpRequestPtr& request,
-                                   std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
-        auto resp = drogon::HttpResponse::newHttpResponse();
-        resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
-        drogon::async_run([handler, request, resp, callback = std::move(callback)]() mutable -> drogon::Task<> {
-            try {
-                co_await handler(request, resp);
-            }
-            catch (const std::exception& error) {
-                resp->setStatusCode(drogon::k500InternalServerError);
-                resp->setBody(Psc::JSON::object({{"error", std::string(error.what())}}).to_json_string());
-                std::terminate();
-            }
-            catch (...) {
-                resp->setStatusCode(drogon::k500InternalServerError);
-                resp->setBody(Psc::JSON::object({{"error", "unknown error"}}).to_json_string());
-                std::terminate();
-            }
-            callback(resp);
-            co_return;
-        });
-    },
-    {drogon::Get});
-    return *this;
-}
 std::string Debug_Logger_Info_Manager::get_info(Serial_Number_Type serial_number) {
     std::lock_guard g(mtx);
     std::string result;
diff --git a/module/Local_Server/server/Global.h b/module/Local_Server/server/Global.h
index 0314486..784f290 100644
--- a/module/Local_Server/server/Global.h
+++ b/module/Local_Server/server/Global.h
@@ -1,22 +1,17 @@
 #pragma once
 #include <drogon/drogon.h>
-#include <filesystem>
 #include <list>
 #include <string_view>
-#include <utility>
-#include "../../Radarcape_Core/cpp-httplib/httplib.h"
 #include "../Data_Source/export.h"
 #include "../State_Report/State_Report.h"
 #include "../global_include.h"
 #include "Config.h"
 #include "Psc_Cpp_Core/Base/ThreadManager.h"
-#include "Psc_Cpp_Core/Net_Adapter/Net_Adapter.h"
 #include "Ucoro_Drogon_Glue.h"
 #include "libarchive.h"
 // 集中 管理日志
 using namespace Psc;
 extern BaseLogger* server_logger;
-std::string to_file_name(std::string_view str);
 std::string inet_address_to_string(const trantor::InetAddress& addr);
 using Serial_Number_Type = unsigned int;
 struct Debug_Logger_Info_Manager {
@@ -68,7 +63,6 @@ public:
     Web_Server& Post(std::string_view pattern, Handler handler);
     Web_Server& Post_Coro(std::string_view pattern, CoroHandler handler);
     Web_Server& Get(std::string_view pattern, Handler handler);
-    Web_Server& Get_Coro(std::string_view pattern, CoroHandler handler);
 };
 // 这个对象不释放
 class Mlat_MSG {
@@ -170,7 +164,3 @@ public:
     std::time_t start_server_time;
     DELETE_COPY(Global)
 };
-void handle_buffer_muti_start(std::string& buffer, std::string_view data, const std::set<std::string>& prefix_list,
-                              const std::function<void(std::string&)>& callback);
-void handle_buffer_head_tail(std::string& buffer, std::string_view data, std::string_view prefix,
-                             std::string_view suffix, const std::function<void(std::string&)>& callback);
diff --git a/module/Local_Server/server/MLAT.cpp b/module/Local_Server/server/MLAT.cpp
deleted file mode 100644
index bd3cec2..0000000
--- a/module/Local_Server/server/MLAT.cpp
+++ /dev/null
@@ -1,176 +0,0 @@
-#include "MLAT.h"
-#include <fstream>
-#include <string_view>
-#include <tuple>
-#include "Global.h"
-time_t datetime_to_timestamp(std::string_view datetime) {
-    std::tm tm = {};
-    std::istringstream ss{std::string(datetime)};
-    ss >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");
-    if (ss.fail()) {
-        throw std::runtime_error("时间格式错误");
-    }
-    // std::mktime按本地时区转换
-    return std::mktime(&tm);
-}
-std::multimap<std::string, Base_MLAT_Data> hex_mlat_map;
-std::vector<MLAT_Data> read_lines() {
-    Base_Logger_Manager::instance()->init();
-    std::multimap<size_t, Base_MLAT_Data> ordered_multimap;
-    std::ifstream fin("C:/wyc/CLionProjects/plantSunCat/mainProjects/Radarcape/"
-                      "data/0701/info.txt");
-    if (!fin) {
-        std::cerr << "无法打开文件！" << std::endl;
-        return {};
-    }
-    std::string line;
-    while (std::getline(fin, line)) {
-        if (line.empty())
-            continue;
-        std::vector<std::string> fields;
-        std::stringstream ss(line);
-        std::string item;
-        while (std::getline(ss, item, ';')) {
-            fields.push_back(item);
-        }
-        // 检查字段数
-        if (fields.size() < 9)
-            continue;
-        // 2025-07-03 10:16:21;VG_MSDW;28069B;2025-06-27
-        // 08:00:14;A800103FFF9CCB27FFFCA89DE0D3;121.691398;37.344925;8000;;0000;2_1_3
-        // 按 1-base 提取
-        std::string icao = fields[2];
-        icao.resize(6, '_');
-        std::string msg = fields[4];
-        std::string lon = fields[5];
-        std::string lat = fields[6];
-        std::string time = fields[3];
-        std::string hex = fields[4];
-        // 输出（或者你可以存到 vector 里）
-        // std::cout << icao << " " << lat << " " << lon << " " << alt << std::endl;
-        Base_MLAT_Data b;
-        // cur.icao = icao;
-        b.mlat_data.lon = stod(lon);
-        b.mlat_data.lat = stod(lat);
-        b.msg = line;
-        b.hex = hex;
-        b.icao = icao;
-        strncpy(b.mlat_data.icao, icao.c_str(), 6);
-        // std::cout << cur.lat << "  " << cur.lon << std::endl;
-        //  if (35 < cur.lat && cur.lat < 37
-        //      &&
-        //      120 < cur.lon && cur.lon < 122
-        //  ) {
-        //
-        //      pure_log("@/logs/mlat_.log", line + "\n");
-        //  }
-        ordered_multimap.insert({datetime_to_timestamp(time), b});
-    }
-    std::vector<MLAT_Data> list;
-    for (auto it : ordered_multimap) {
-        Base_MLAT_Data& b = it.second;
-        list.push_back(b.mlat_data);
-        auto icao = std::string(b.mlat_data.icao, 6);
-        // if (icao == "78139F") {
-        //     pure_log("@/logs/icao/" +  icao + "_mlat_result.log", b.msg + "\n");
-        // }
-        hex_mlat_map.insert({b.hex, b});
-    }
-    return list;
-}
-std::vector<MLAT_Data> all;
-void read(MLAT_Data* buf, std::uint16_t* len) {
-    if (all.empty()) {
-        all = read_lines();
-    }
-    static size_t pos = 0; // 上一次拷贝结束后的位置
-    const size_t BATCH = 100;
-    size_t total = all.size();
-    size_t n = std::min(BATCH, total - pos); // 本次实际要拷贝多少
-    for (size_t i = 0; i < n; ++i) {
-        buf[i] = all[pos + i];
-    }
-    *len = static_cast<std::uint16_t>(n);
-    pos += n;
-    if (pos >= total) {
-        pos = 0; // 如果需要循环一轮后归零，否则你可以不归零
-    }
-}
-MLAT_Config::MLAT_Config() {
-}
-void MLAT_Config::from_json(const Psc::JSON* that_json, bool not_exist_use_default_value) {
-    const auto [enable, library_path, function_name] = settings.write([&](auto& value) {
-        value.from_base_json(that_json, not_exist_use_default_value);
-        return std::tuple{value.enable, value.library_path, value.function_name};
-    });
-    if (enable) {
-        {
-            auto r = Psc::try_load_library(Psc::get_abs_path(library_path));
-            if (!r) {
-                Psc::fail_fast();
-            }
-            lib = r.value();
-        }
-        {
-            auto r = Psc::try_load_function(lib, function_name);
-            if (!r) {
-                Psc::fail_fast();
-            }
-            read_func_ptr = (Func_Type)r.value();
-        }
-        all = read_lines();
-        read_func_ptr = read;
-    }
-}
-void MLAT_Config::refresh() {
-    std::lock_guard guard(mtx);
-    std::uint16_t len{};
-    if (read_func_ptr)
-        read_func_ptr(buf, &len);
-    auto list = Global::instance()->mode_acs.data_source_config.map.list();
-    for (std::uint16_t i = 0; i < len; i++) {
-        MLAT_Data& cur = buf[i];
-        std::string icao = std::string(cur.icao, 6);
-        for (const auto& li : list) {
-            // auto air = li->get_aircraft(icao);
-            auto air = li->get_aircraft(icao);
-            if (air) {
-                // air->mlat = true;
-                // air->air_pos_track_list.push(CPR::Position{cur.lat, cur.lon});
-            }
-        }
-        auto& t = update_map[icao];
-        if (t.d.lat != cur.lat || t.d.lon != cur.lon) {
-            t.d = cur;
-        }
-    }
-}
-void MLAT_Config::server(Global* g) {
-    auto& svr = g->svr;
-    auto& api = g->api;
-    svr.Post(api + "get_mlat_list", [this](HTTP_Param) { res->setBody(warp(get_reset()).to_json_string()); });
-    // svr.Post(api + "get_mlat_server_config", [this](HTTP_Param) {
-    //      res->setBody(warp(to_json()).to_json_string());
-    //  });
-    // svr.Post(api + "/set_mlat_server_config", [this, g](HTTP_Param) {
-    //     CHECK_JSON_PARAM
-    //     MLAT_Server_Config t;
-    //     t.init(&o_params.value());
-    //     bool ok = check_ipv4(t.ip) && check_port(t.port);
-    //     if (!ok)
-    //     {
-    //         server_logger->error("", {}, LOG_POS + "  ip port! " + t.ip + ":" +
-    //         std::to_string(t.port));
-    //         res->setBody(warp(to_json()).to_json_string());
-    //         return;
-    //     }
-    //
-    //     auto& s = g->mlat_server;
-    //     s.id = t.id;
-    //     s.port = t.port;
-    //     s.ip = t.ip;
-    //
-    //     Global::save();
-    //     res->setBody(warp(to_json()).to_json_string());
-    // });
-}
diff --git a/module/Local_Server/server/MLAT.h b/module/Local_Server/server/MLAT.h
index 306741a..1690d93 100644
--- a/module/Local_Server/server/MLAT.h
+++ b/module/Local_Server/server/MLAT.h
@@ -1,89 +1,37 @@
-#ifndef MLAT_H
-#define MLAT_H
-#include <string>
-#include "../global_include.h"
+#pragma once
+
 #include "Psc_Cpp_Core/Base/JSON.h"
-#include "Psc_Cpp_Core/system/export.h"
 #include "adminive/managed.hpp"
-class Global;
-#pragma pack(push, 8)
-extern "C" {
-struct MLAT_Data {
-    char icao[6];
-    double lon;
-    double lat;
-};
-}
-#pragma pack(pop)
-struct MLAT_Store {
-    MLAT_Data d{};
-    [[nodiscard]] Psc::JSON to_json() const {
-        Psc::JSON ret = Psc::JSON::object();
-        ret.append({"icao", std::string(d.icao, 6)});
-        ret.append({"lon", d.lon});
-        ret.append({"lat", d.lat});
-        return ret;
-    }
-    [[nodiscard]] std::string icao() const {
-        return {d.icao, 6};
-    }
-};
-struct Base_MLAT_Data {
-    MLAT_Data mlat_data;
-    std::string msg;
-    std::string hex;
-    std::string icao;
-};
-extern std::multimap<std::string, Base_MLAT_Data> hex_mlat_map;
-class MLAT_Config_Data {
-public:
-    bool enable{};
+
+struct MLAT_Config_Data {
     bool merge{};
-    std::string library_path;
-    std::string function_name;
     PSC_USE_JSON
 };
+
 namespace adminive {
 template <>
 struct Type_Descriptor<MLAT_Config_Data> {
     static auto get() {
         using T = MLAT_Config_Data;
         return object<T>("mlat_config", "MLAT 配置",
-                         ADMINIVE_FIELD_LABEL(T, enable, "启用 MLAT").editable().boolean_input(),
-                         ADMINIVE_FIELD_LABEL(T, merge, "合并 MLAT").editable().boolean_input(),
-                         ADMINIVE_FIELD_LABEL(T, library_path, "库路径").editable().text_input(),
-                         ADMINIVE_FIELD_LABEL(T, function_name, "函数名").editable().text_input());
+                         ADMINIVE_FIELD_LABEL(T, merge, "合并 MLAT").editable().boolean_input());
     }
 };
 }
+
 class MLAT_Config {
 public:
     adminive::Managed_Value<MLAT_Config_Data> settings;
-    ~MLAT_Config() = default;
-    MLAT_Config();
+
     [[nodiscard]] Psc::JSON to_base_json() const {
         return settings.read([](const auto& value) {
             return value.to_base_json();
         });
     }
-    void* lib{};
-    using Func_Type = void (*)(MLAT_Data* buf, std::uint16_t* len);
-    Func_Type read_func_ptr{};
-    void from_json(const Psc::JSON* that_json, bool not_exist_use_default_value);
-    MLAT_Data buf[std::numeric_limits<std::uint16_t>::max()]{};
-    void refresh();
-    Psc::JSON get_reset() {
-        std::lock_guard guard(mtx);
-        Psc::JSON ret = Psc::JSON::array();
-        for (auto& t : update_map) {
-            ret.append(t.second.to_json());
-        }
-        update_map.clear();
-        return ret;
+
+    void from_json(const Psc::JSON* that_json, bool not_exist_use_default_value) {
+        settings.write([&](auto& value) {
+            value.from_base_json(that_json, not_exist_use_default_value);
+        });
     }
-    void server(Global* g);
-protected:
-    std::mutex mtx;
-    std::map<std::string, MLAT_Store> update_map;
 };
-#endif
diff --git a/module/Local_Server/server/WebSocket_Manager.cpp b/module/Local_Server/server/WebSocket_Manager.cpp
index 69acf84..fa49482 100644
--- a/module/Local_Server/server/WebSocket_Manager.cpp
+++ b/module/Local_Server/server/WebSocket_Manager.cpp
@@ -37,14 +37,6 @@ void WebSocket_Manager::add(const drogon::WebSocketConnectionPtr &conn) {
   std::lock_guard<std::mutex> g(mtx);
   connections.insert(conn);
 }
-void WebSocket_Manager::visit(
-    const std::function<void(const drogon::WebSocketConnectionPtr &conn)>
-        &func) {
-  std::lock_guard<std::mutex> g(mtx);
-  for (const auto &coon : connections) {
-    func(coon);
-  }
-}
 void WebSocket_Manager::push_data(const char *buf, uint64_t len) {
   std::lock_guard<std::mutex> g(mtx);
   for (const auto &conn : connections) {
diff --git a/module/Local_Server/server/WebSocket_Manager.h b/module/Local_Server/server/WebSocket_Manager.h
index cbd80de..79fa0c4 100644
--- a/module/Local_Server/server/WebSocket_Manager.h
+++ b/module/Local_Server/server/WebSocket_Manager.h
@@ -17,7 +17,6 @@ public:
   ~WebSocket_Manager() = default;
   void remove(const drogon::WebSocketConnectionPtr &conn);
   void add(const drogon::WebSocketConnectionPtr &conn);
-  void visit(const std::function<void(const drogon::WebSocketConnectionPtr &conn)> &func);
   void push_data(const char *buf, uint64_t len);
   void set_message_handler(Message_Handler handler);
   void set_close_handler(Close_Handler handler);
diff --git a/module/Local_Server/server/io_coro.cpp b/module/Local_Server/server/io_coro.cpp
index ff85e32..b75d2a2 100644
--- a/module/Local_Server/server/io_coro.cpp
+++ b/module/Local_Server/server/io_coro.cpp
@@ -33,15 +33,6 @@ std::vector<std::shared_ptr<With_Loop_Coro>> get_all() {
     }
     return ret;
 }
-bool Coro::has_running_loop_tasks() {
-    auto list = get_all();
-    for (auto& li : list) {
-        if (li->running()) {
-            return true;
-        }
-    }
-    return false;
-}
 bool data_feed_debug = false;
 bool data_source_debug = false;
 // 不开启wait 性能巨差 数据积压
diff --git a/module/Local_Server/server/io_coro.h b/module/Local_Server/server/io_coro.h
index da6a183..fbf0384 100644
--- a/module/Local_Server/server/io_coro.h
+++ b/module/Local_Server/server/io_coro.h
@@ -35,7 +35,6 @@ public:
     // }
 private:
     asio::awaitable<void> coro_thread();
-    bool has_running_loop_tasks();
     std::unique_ptr<asio::executor_work_guard<asio::io_context::executor_type>> io_work;
     std::thread io_thread;
     std::unique_ptr<std::future<void>> loop_task;
diff --git a/module/Local_Server/server/libarchive.cpp b/module/Local_Server/server/libarchive.cpp
index 1fea107..f54a8ed 100644
--- a/module/Local_Server/server/libarchive.cpp
+++ b/module/Local_Server/server/libarchive.cpp
@@ -639,38 +639,6 @@ void unarchive_file(const fs::path &zipPath, const fs::path &outDir) {
   extract_archive(reader.get(), outDir);
 }
 
-void unarchive_from_memory(const char *data, size_t size,
-                           const fs::path &outDir) {
-  if (data == nullptr || size == 0) {
-    throw std::runtime_error("empty archive");
-  }
-
-  auto reader = make_archive_reader();
-  require_archive_ok(reader.get(),
-                     archive_read_open_memory(reader.get(), data, size),
-                     "archive_read_open_memory failed");
-  extract_archive(reader.get(), outDir);
-}
-
-void archive_directory(const fs::path &dirPath, const fs::path &archive_path,
-                       const Archive_Write_Options &options) {
-  auto writer = make_archive_writer(options);
-#ifdef _WIN32
-  require_archive_ok(writer.get(),
-                     archive_write_open_filename_w(
-                         writer.get(), archive_path.wstring().c_str()),
-                     "archive_write_open_filename_w failed");
-#else
-  require_archive_ok(
-      writer.get(),
-      archive_write_open_filename(writer.get(), archive_path.c_str()),
-      "archive_write_open_filename failed");
-#endif
-  write_directory_to_archive(writer.get(), dirPath, {});
-  require_archive_ok(writer.get(), archive_write_close(writer.get()),
-                     "archive_write_close failed");
-}
-
 std::string
 archive_directory_to_memory(const fs::path &dirPath,
                             const std::vector<std::string> &ignorePatterns,
diff --git a/module/Local_Server/server/libarchive.h b/module/Local_Server/server/libarchive.h
index 0d92382..9681195 100644
--- a/module/Local_Server/server/libarchive.h
+++ b/module/Local_Server/server/libarchive.h
@@ -33,13 +33,6 @@ struct Archive_Write_Options {
 Psc::expected<void, std::string> validate_archive_layout_from_memory(const char* data, std::size_t size,
                                                                      const Archive_Layout_Rules& rules);
 void unarchive_file(const std::filesystem::path& zipPath, const std::filesystem::path& outDir);
-void unarchive_from_memory(const char* data, size_t size, const std::filesystem::path& outDir);
-void archive_directory(const std::filesystem::path& dirPath, const std::filesystem::path& archive_path,
-                       const Archive_Write_Options& options = {});
-// std::string zip_directory_to_memory(const std::filesystem::path& dirPath,
-//                                            const
-//                                            std::vector<std::filesystem::path>&
-//                                            ignoreDirs);
 std::string archive_directory_to_memory(const std::filesystem::path& dirPath,
                                         const std::vector<std::string>& ignorePatterns,
                                         const Archive_Write_Options& options = {});
diff --git a/module/Local_Server/server/server.cpp b/module/Local_Server/server/server.cpp
index 42ef1d3..8b01b90 100644
--- a/module/Local_Server/server/server.cpp
+++ b/module/Local_Server/server/server.cpp
@@ -1,5 +1,6 @@
 
 #include "Adminive_Config.h"
+#include "../../Radarcape_Core/cpp-httplib/httplib.h"
 #include <algorithm>
 #include <cctype>
 #include <string_view>
@@ -171,7 +172,6 @@ void Global::init_web_server() {
     add_path(R"(^/settings)");
     add_path(R"(^/map)");
     add_path(R"(^/map3d)");
-    add_path(R"(^/dsp)");
     add_path(R"(^/aircraftlist)");
     drogon::app().registerHandlerViaRegex(
     R"(^/ui(/.*)?$)",
@@ -183,8 +183,8 @@ void Global::init_web_server() {
             rp = "/";
         }
         auto is_spa_path = [](std::string_view value) {
-            return value == "/" || value == "/map" || value == "/map3d" || value == "/settings" || value == "/dsp" ||
-            value == "/aircraftlist";
+            return value == "/" || value == "/map" || value == "/map3d" || value == "/settings" ||
+                   value == "/aircraftlist";
         };
         if (is_spa_path(rp)) {
             path += "/index.html";
@@ -201,10 +201,8 @@ void Global::init_web_server() {
         arr.append(JSON::object({{"remain_size", sp.remain_size()}, {"free_size", sp.free_size()}}));
         res->setBody(arr.to_json_string("", "\n", ""));
     });
-    mlat.server(this);
     database_server(this);
     external_resources_manager.server(this);
-    device_config.server(this);
     mode_acs.server(this);
     dsp_config.server(this);
     // s.w.init();
diff --git a/module/Local_Server/server/tiles.cpp b/module/Local_Server/server/tiles.cpp
index 7b5e943..e7b59d5 100644
--- a/module/Local_Server/server/tiles.cpp
+++ b/module/Local_Server/server/tiles.cpp
@@ -1,5 +1,6 @@
 #include <SQLiteCpp/Database.h>
 #include <SQLiteCpp/Statement.h>
+#include "../../Radarcape_Core/cpp-httplib/httplib.h"
 #include <algorithm>
 #include <asio/co_spawn.hpp>
 #include <asio/thread_pool.hpp>
diff --git a/module/Local_Server_main.cpp b/module/Local_Server_main.cpp
index d9733a7..d501a7f 100644
--- a/module/Local_Server_main.cpp
+++ b/module/Local_Server_main.cpp
@@ -116,27 +116,21 @@ int psc_main(int argc, char* argv[]) {
     Detach_Thread_Manager& manager = g->thread_manager;
     std::cout << "[主线程:" << std::this_thread::get_id() << "]" << " \n" << std::flush;
     manager.test_and_start_thread("web服务器", [g](std::atomic<bool>& running) {
-        auto& c = Global::instance()->device_config;
-        std::string ip = "0.0.0.0";
+        const auto port = g->web_server_config.listen_port;
+        std::string display_ip = "0.0.0.0";
 #ifdef WIN32
-        ip = "127.0.0.1";
+        display_ip = "127.0.0.1";
 #endif
-        Net_Config* device = c.list.get("device").value();
-        std::cout << "http://" + ip + ":" + std::to_string(device->port) + "\n" << std::flush;
-        std::cout << "http://" + device->ip + ":" + std::to_string(device->port) + "\n" << std::flush;
-        if (!g->svr.listen("0.0.0.0", device->port)) {
+        std::cout << "http://" + display_ip + ":" + std::to_string(port) + "\n" << std::flush;
+        if (!g->svr.listen("0.0.0.0", port)) {
             if (running.load(std::memory_order_acquire)) {
-                std::cout << "http://" + ip + ":" + std::to_string(device->port) + "启动失败 退出！\n" << std::flush;
-                std::cout << "http://" + device->ip + ":" + std::to_string(device->port) + "启动失败 退出！\n"
-                          << std::flush;
+                std::cout << "http://" + display_ip + ":" + std::to_string(port) + "启动失败 退出！\n" << std::flush;
                 std::exit(0);
             }
         }
     });
     // manager.test_and_start_thread("io_coro 协程线程", io_coro);
-    static int t = static_cast<int>(Global::instance()->mode_acs.settings.member<&Mode_ACS_Config_Data::read_milliseconds>().snapshot());
     g->dsp_config.init_env();
-    bool enable = g->mlat.settings.member<&MLAT_Config_Data::enable>().snapshot();
     auto coro = Coro::instance();
     coro->start();
     // Catch_Memory cm;
@@ -144,9 +138,6 @@ int psc_main(int argc, char* argv[]) {
         for (auto& ds : g->mode_acs.data_source_config.map.list()) {
             ds->delete_timeout_aircraft();
         }
-        if (enable) {
-            g->mlat.refresh();
-        }
 #ifdef __linux__
         if (g->mode_acs.settings.member<&Mode_ACS_Config_Data::monitor_msg_live>().snapshot())
             malloc_trim(0);