512 lines
16 KiB
C++
512 lines
16 KiB
C++
#pragma once
|
|
|
|
|
|
|
|
#include "Data_Source_Handler.h"
|
|
|
|
namespace Psc {
|
|
class SM_RingBuffer;
|
|
}
|
|
// 统一封装数据输出的模式
|
|
class Data_Source;
|
|
std::shared_ptr<Data_Source> create_from_json(const Psc::JSON *that_json);
|
|
|
|
|
|
class Input_Format {
|
|
public:
|
|
Input_Format() {
|
|
test_v.resize(static_cast<size_t>(SSR::Downlink_Format::Unknown));
|
|
}
|
|
|
|
Psc::JSON to_json() {
|
|
std::lock_guard g(mtx);
|
|
Psc::JSON ret = Psc::JSON::object();
|
|
for (auto e : magic_enum::enum_values<SSR::Downlink_Format>()) {
|
|
std::string_view value_view = magic_enum::enum_name(e);
|
|
std::string value(value_view.begin(), value_view.end());
|
|
if (value == Psc::to_string(SSR::Downlink_Format::Unknown)) continue;
|
|
auto ev = static_cast<std::uint8_t>(e);
|
|
bool it = test_v[ev];
|
|
ret.append({value, it});
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void from_json(const Psc::JSON* json) {
|
|
std::lock_guard g(mtx);
|
|
for (auto e : magic_enum::enum_values<SSR::Downlink_Format>()) {
|
|
std::string_view value_view = magic_enum::enum_name(e);
|
|
std::string value(value_view.begin(), value_view.end());
|
|
if (value == Psc::to_string(SSR::Downlink_Format::Unknown)) continue;
|
|
auto use = json->get_bool(value);
|
|
auto ev = static_cast<std::uint8_t>(e);
|
|
test_v[ev] = use;
|
|
}
|
|
}
|
|
|
|
|
|
bool test(SSR::Downlink_Format df) {
|
|
std::lock_guard g(mtx);
|
|
auto dfv = static_cast<std::uint8_t>(df);
|
|
if (dfv >= static_cast<std::uint8_t>(SSR::Downlink_Format::Unknown)) return false;
|
|
return test_v[dfv];
|
|
}
|
|
|
|
bool test(std::uint8_t dfv) {
|
|
std::lock_guard g(mtx);
|
|
if (dfv >= static_cast<std::uint8_t>(SSR::Downlink_Format::Unknown)) return false;
|
|
return test_v[dfv];
|
|
}
|
|
protected:
|
|
std::mutex mtx;
|
|
std::vector<bool> test_v;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class Data_Source : public std::enable_shared_from_this<Data_Source>, public Data_Source_Handler{
|
|
public:
|
|
~Data_Source() override = default;
|
|
std::shared_ptr<Data_Source> that();
|
|
virtual ucoro::awaitable<std::string> read_coro() = 0;
|
|
|
|
virtual Psc::JSON get_custom_state_json() = 0;
|
|
Psc::JSON get_state();
|
|
std::string last_char; // 用于处理奇数字节的情况
|
|
// std::shared_ptr<Input_Format> parse_format;
|
|
|
|
Data_Source();
|
|
std::shared_ptr<SSR::Mode_Msg> last_prase_msg = nullptr;
|
|
|
|
|
|
|
|
virtual ucoro::awaitable<void> handle_in_loop_coro(){co_return;}
|
|
|
|
virtual ucoro::awaitable<void> source_step_coro();
|
|
void refresh_data_feed_key_list();
|
|
void push_to_feed(const std::shared_ptr<SSR::Msg> &msg);
|
|
std::atomic<bool> enable{};
|
|
std::string type;
|
|
std::atomic<bool> base_station_show{};
|
|
std::atomic<bool> aircraft_show{};
|
|
std::atomic<bool> show_icao = true;
|
|
std::atomic<bool> show_call_sign = false;
|
|
std::atomic<bool> show_fly_status = false;
|
|
std::atomic<bool> keep_mode = true;
|
|
double lat{};
|
|
double lon{};
|
|
double alt{};
|
|
std::atomic<bool> update_form_gps{};
|
|
std::string color = "#1677ff";
|
|
int aircraft_pixel_size{};
|
|
|
|
Frequency_Limit statistic_fl;
|
|
std::string thread_key() const;
|
|
void test_and_attach_thread();
|
|
void test_and_stop_thread() const;
|
|
Psc::JSON statistic_json() {
|
|
Psc::JSON ret = Psc::JSON::object();
|
|
Ret_J(enable);
|
|
Ret_J(type);
|
|
ret.append({"飞机总数", get_aircraft_num()});
|
|
ret.append({"解出位置的数量", have_pos_aircraft_num});
|
|
ret.append({"mode_ac_statistic", mode_ac_statistic.to_json()});
|
|
ret.append({"mode_s_statistic", mode_s_statistic.to_json()});
|
|
ret.append({"all_connect_feed", get_all_connect_feed_status()});
|
|
|
|
|
|
return ret;
|
|
}
|
|
virtual Psc::JSON to_json() {
|
|
Psc::JSON ret = Psc::JSON::object();
|
|
Ret_J(key);
|
|
Ret_J(enable);
|
|
Ret_J(base_station_show);
|
|
Ret_J(aircraft_show);
|
|
Ret_J(color);
|
|
Ret_J(aircraft_pixel_size);
|
|
Ret_J(type);
|
|
Ret_J(lat);
|
|
Ret_J(lon);
|
|
Ret_J(alt);
|
|
Ret_J(update_form_gps);
|
|
Ret_J(show_icao);
|
|
Ret_J(show_call_sign);
|
|
Ret_J(show_fly_status);
|
|
Ret_J(keep_mode);
|
|
// ret.append({"parse_format", parse_format->to_json()});
|
|
return ret;
|
|
}
|
|
virtual void from_json(const Psc::JSON *that_json) {
|
|
Get_J(key);
|
|
Get_J(enable);
|
|
Get_J(base_station_show);
|
|
Get_J(aircraft_show);
|
|
Get_J(color);
|
|
Get_J(aircraft_pixel_size);
|
|
Get_J(type);
|
|
Get_J(lat);
|
|
Get_J(lon);
|
|
Get_J(alt);
|
|
Get_J(update_form_gps);
|
|
Get_J(show_icao);
|
|
Get_J(show_call_sign);
|
|
Get_J(show_fly_status);
|
|
Get_J(keep_mode);
|
|
// parse_format->from_json(that_json->get("parse_format"));
|
|
}
|
|
bool open() {
|
|
if (!_open_) {
|
|
_open_ = _open();
|
|
return _open_;
|
|
}
|
|
return true;
|
|
}
|
|
bool is_open() const { return _open_; }
|
|
void close() {
|
|
if (_open_) {
|
|
_open_ = false;
|
|
_close();
|
|
}
|
|
}
|
|
|
|
struct Cached_Source_Info {
|
|
std::string key;
|
|
Psc::Value_Statistics mode_s_cache_num;
|
|
Psc::Value_Statistics mode_other_cache_num;
|
|
};
|
|
|
|
std::string buffer;
|
|
std::atomic<bool> need_refresh_data_feed_key_list = true;
|
|
Psc::JSON get_all_connect_feed_status();
|
|
Psc::JSON get_all_connect_feed();
|
|
protected:
|
|
std::mutex cdf_mtx;
|
|
std::vector<Cached_Source_Info> cached_data_feed_key_list{};
|
|
bool _open_ = false;
|
|
virtual bool _open() = 0;
|
|
virtual void _close() = 0;
|
|
};
|
|
|
|
|
|
struct TCP_Client_Data_Source : Data_Source {
|
|
ucoro::awaitable<void> handle_in_loop_coro() override {
|
|
co_await cli.tick_coro();
|
|
co_return;
|
|
}
|
|
Psc::JSON get_custom_state_json() override {
|
|
auto& state = cli.state;
|
|
return VAR_JSON_1(state);
|
|
}
|
|
Psc::asio_socket::TCP_Client_Coro cli;
|
|
std::string ip;
|
|
std::uint16_t port{};
|
|
|
|
~TCP_Client_Data_Source() override = default;
|
|
TCP_Client_Data_Source() {
|
|
type = "TCP_Client_Data_Source";
|
|
}
|
|
bool _open() override {
|
|
Psc::asio_socket::Sockaddr_In addr;
|
|
addr.ip = ip;
|
|
addr.port = port;
|
|
|
|
cli.set_dest_address(addr);
|
|
cli.create();
|
|
ucoro::sync_await(cli.connect_coro());
|
|
return true;
|
|
}
|
|
void _close() override { cli.close(); }
|
|
|
|
Psc::JSON to_json() override {
|
|
Psc::JSON ret = Data_Source::to_json();
|
|
Ret_J(ip);
|
|
Ret_J(port);
|
|
return ret;
|
|
}
|
|
void from_json(const Psc::JSON *that_json) override {
|
|
Data_Source::from_json(that_json);
|
|
Get_J(ip);
|
|
Get_J(port);
|
|
}
|
|
|
|
|
|
ucoro::awaitable<std::string> read_coro() override {
|
|
co_return co_await cli.read_coro();
|
|
}
|
|
};
|
|
struct Serial_Data_Source : Data_Source {
|
|
std::string port_name;
|
|
Baud_Rate_Type baud_rate{};
|
|
Psc::JSON get_custom_state_json() override {
|
|
return Psc::JSON::object();
|
|
}
|
|
Serial_Data_Source() { this->type = "Serial_Data_Source"; }
|
|
bool _open() override {
|
|
serial = std::make_unique<Psc::serial::Serial_Coro>();
|
|
serial->set_serial_name(port_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);
|
|
bool ok = serial->open();
|
|
if (!ok) {
|
|
std::cerr << "createSerial " + port_name + ":" + std::to_string(baud_rate) + " 打开串口失败！\n";
|
|
} else {
|
|
// std::cerr << "createSerial " + serial_name + ":" + std::to_string(baud_rate) + " 打开串口成功！\n";
|
|
}
|
|
return ok;
|
|
}
|
|
void _close() override { if (serial) serial->close(); }
|
|
|
|
ucoro::awaitable<void> handle_in_loop_coro() override {
|
|
if (serial) {
|
|
co_await serial->tick_coro();
|
|
}
|
|
co_return;
|
|
}
|
|
ucoro::awaitable<std::string> read_coro() override {
|
|
if (!serial) {
|
|
co_return "";
|
|
}
|
|
co_return co_await serial->read_coro();
|
|
}
|
|
Psc::JSON to_json() override {
|
|
Psc::JSON ret = Data_Source::to_json();
|
|
Ret_J(port_name);
|
|
Ret_J(baud_rate);
|
|
return ret;
|
|
}
|
|
void from_json(const Psc::JSON *that_json) override {
|
|
Data_Source::from_json(that_json);
|
|
Get_J(port_name) Get_J(baud_rate);
|
|
}
|
|
std::unique_ptr<Psc::serial::Serial_Coro> serial{};
|
|
~Serial_Data_Source() override {
|
|
if (serial) {
|
|
serial->close();
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
enum class File_Data_Type {
|
|
SIMPLE_BIN_Blank, // 没有1a转义的
|
|
BIN_Blank_Text,
|
|
AVR,
|
|
BIN_Text,
|
|
BIN_Blank_One_Line_With_Escape,
|
|
BIN_Blank_One_Line_No_Escape,
|
|
BIN,
|
|
Unknown
|
|
// 纯粹的二进制
|
|
};
|
|
enum Play_Mode { one, loop, analysis, time_batch };
|
|
|
|
|
|
struct File_Data_Source : public Data_Source {
|
|
std::string file_path;
|
|
File_Data_Type data_type = File_Data_Type::BIN_Blank_Text;
|
|
Play_Mode play_mode = Play_Mode::one;
|
|
bool have_report_play_back_all_success = false;
|
|
std::string state = "null";
|
|
Psc::JSON get_custom_state_json() override {
|
|
auto cur_virtual_time = player_clock.get_cur_time_point();
|
|
auto playback_speed_rate = player_clock.playback_speed_rate;
|
|
return VAR_JSON_5(cur_virtual_time, playback_speed_rate, state, index, part_infos.size());
|
|
}
|
|
File_Data_Source() { this->type = "File_Data_Source"; }
|
|
~File_Data_Source() override = default;
|
|
void before_handle_msg(std::shared_ptr<SSR::Mode_Msg>& msg) override;
|
|
|
|
struct Cache_Msg {
|
|
explicit Cache_Msg(std::shared_ptr<SSR::Mode_S_Msg> msg) : msg(std::move(msg)) {}
|
|
SSR::Play_Back_Time_Point time() const {
|
|
return SSR::Play_Back_Time_Point{day_num, msg->mlat_timestamp.daysec};
|
|
}
|
|
std::uint64_t day_num = 0;
|
|
std::shared_ptr<SSR::Mode_S_Msg> msg;
|
|
};
|
|
Player_Clock player_clock;
|
|
std::shared_ptr<Cache_Msg> pre_cache = nullptr;
|
|
std::deque<std::shared_ptr<Cache_Msg>> cache_list;
|
|
|
|
|
|
|
|
std::string get_true_file_path() const { return Psc::get_abs_path(file_path); }
|
|
void _close() override;
|
|
bool _open() override;
|
|
std::vector<std::string> readBinaryFileAsString(const std::string& filepath, size_t part_size);
|
|
void from_json(const Psc::JSON *that_json) override {
|
|
Data_Source::from_json(that_json);
|
|
Get_J(file_path);
|
|
Get_J(data_type);
|
|
Get_J(play_mode);
|
|
}
|
|
|
|
Psc::JSON to_json() override {
|
|
Psc::JSON ret = Data_Source::to_json();
|
|
Ret_J(file_path);
|
|
Ret_J(data_type);
|
|
Ret_J(play_mode);
|
|
return ret;
|
|
}
|
|
|
|
ucoro::awaitable<std::string> read_coro() override;
|
|
|
|
void handle_mode_s(std::shared_ptr<SSR::Mode_S_Msg> msg) override;
|
|
|
|
protected:
|
|
std::optional<std::string> get_raw_line(int &ret_index);
|
|
long long index = 0;
|
|
std::vector<std::string> part_infos;
|
|
std::mutex mtx;
|
|
};
|
|
struct Dll_Data_Source : Data_Source {
|
|
Psc::JSON get_custom_state_json() override {
|
|
auto ret = VAR_JSON_1(state);
|
|
ret.append({"read_vaild_len", vs.to_string()});
|
|
return ret;
|
|
}
|
|
Psc::Value_Statistics vs;
|
|
std::string library_path;
|
|
std::string function_name;
|
|
File_Data_Type data_type = File_Data_Type::BIN_Blank_Text;
|
|
Dll_Data_Source() { this->type = "Dll_Data_Source"; }
|
|
~Dll_Data_Source() override = default;
|
|
std::size_t buffer_size{};
|
|
std::vector<std::uint8_t> buffer;
|
|
void from_json(const Psc::JSON *that_json) override {
|
|
Data_Source::from_json(that_json);
|
|
Get_J(library_path);
|
|
Get_J(function_name);
|
|
Get_J(data_type);
|
|
Get_J(buffer_size);
|
|
buffer.resize(buffer_size);
|
|
}
|
|
Psc::JSON to_json() override {
|
|
Psc::JSON ret = Data_Source::to_json();
|
|
Ret_J(library_path);
|
|
Ret_J(function_name);
|
|
Ret_J(data_type);
|
|
Ret_J(buffer_size);
|
|
return ret;
|
|
}
|
|
void *lib{};
|
|
|
|
using Func_Type = size_t (*)(char *buf, std::size_t max_len);
|
|
// using Func_Type = std::uint16_t (*)(char *buf, std::uint16_t max_len);
|
|
Func_Type read_func_ptr{};
|
|
|
|
|
|
using Call_Back = void (*)(char *buf, std::size_t len);
|
|
using set_Call_back = void (*)(Call_Back);
|
|
|
|
std::string state;
|
|
void _close() override { Psc::free_library(lib); }
|
|
bool _open() override {
|
|
{
|
|
auto r = Psc::try_load_library(Psc::get_abs_path(library_path));
|
|
if (!r) {
|
|
state = r.error().message();
|
|
return false;
|
|
}
|
|
lib = r.value();
|
|
}
|
|
{
|
|
auto r = Psc::try_load_function(lib, function_name);
|
|
if (!r) {
|
|
state = r.error().message();
|
|
std::cout << LOG_POS << " [" << function_name << "] 函数指针加载失败!" << std::endl;
|
|
return false;
|
|
}
|
|
read_func_ptr = (Func_Type) r.value();
|
|
}
|
|
state = "加载成功";
|
|
return true;
|
|
}
|
|
|
|
ucoro::awaitable<std::string> read_coro();
|
|
};
|
|
|
|
|
|
struct Shared_Memory_Data_Source : Data_Source {
|
|
Psc::JSON get_custom_state_json() override {
|
|
return Psc::JSON::object();
|
|
}
|
|
void from_json(const Psc::JSON *that_json) override {
|
|
Data_Source::from_json(that_json);
|
|
Get_J(shared_memory_name);
|
|
Get_J(shared_memory_size);
|
|
Get_J(data_type);
|
|
}
|
|
Psc::JSON to_json() override {
|
|
Psc::JSON ret = Data_Source::to_json();
|
|
Ret_J(shared_memory_name);
|
|
Ret_J(shared_memory_size);
|
|
Ret_J(data_type);
|
|
return ret;
|
|
}
|
|
bool _open() override;
|
|
void _close() override;
|
|
|
|
ucoro::awaitable<std::string> read_coro() override;
|
|
protected:
|
|
std::unique_ptr<Psc::SM_RingBuffer> sm;
|
|
std::string shared_memory_name;
|
|
std::uint64_t shared_memory_size{};
|
|
File_Data_Type data_type = File_Data_Type::BIN_Blank_Text;
|
|
};
|
|
|
|
|
|
inline std::shared_ptr<Data_Source> create_data_source_from_type(const std::string &t) {
|
|
std::shared_ptr<Data_Source> ret{};
|
|
if (t == "Serial_Data_Source")
|
|
ret = std::make_shared<Serial_Data_Source>();
|
|
else if (t == "TCP_Client_Data_Source")
|
|
ret = std::make_shared<TCP_Client_Data_Source>();
|
|
else if (t == "File_Data_Source")
|
|
ret = std::make_shared<File_Data_Source>();
|
|
else if (t == "Dll_Data_Source")
|
|
ret = std::make_shared<Dll_Data_Source>();
|
|
else if (t == "Shared_Memory_Data_Source")
|
|
ret = std::make_shared<Shared_Memory_Data_Source>();
|
|
else {
|
|
std::cout << "未知的 Data_Source type类型!" << std::endl;
|
|
throw std::invalid_argument("unknown Data_Source type: " + t);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
struct Data_Source_Config {
|
|
Ordered_Map<std::string, std::shared_ptr<Data_Source>> map;
|
|
Data_Source_Config() = default;
|
|
void init(const Psc::JSON *that_json) {
|
|
auto list = that_json->get("list");
|
|
for (auto &it: list->children) {
|
|
auto ds = create_from_json(&it);
|
|
map.push_back(ds);
|
|
}
|
|
}
|
|
Psc::JSON list() {
|
|
auto connect_json = Psc::JSON::array();
|
|
for (auto &it: map.list()) {
|
|
connect_json.children.emplace_back(it->to_json());
|
|
}
|
|
return connect_json;
|
|
}
|
|
Psc::JSON to_json() {
|
|
Psc::JSON ret = Psc::JSON::object();
|
|
ret.append({"list", list()});
|
|
return ret;
|
|
}
|
|
void server(Global *g);
|
|
};
|
|
|
|
|