условно компилируемый проект после рефактора, еще нет настроек rxtx

2025-06-01 15:49:31 +03:00
parent 3e38e77069
commit c2dd4b13e8
11 changed files with 25182 additions and 1298 deletions
--- a/src/api-driver/structs.cpp
+++ b/src/api-driver/structs.cpp
@@ -1,9 +1,10 @@
 #include "api-driver/structs.h"
 #include "api-driver/proxy.h"
-
+#include "common/nlohmann/json.hpp"
 #include <iomanip>
 #include <sys/sysinfo.h>
 #include <boost/property_tree/ptree.hpp>
+#include "terminal_api_driver.h"


 #define TIME_NOW() std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()).time_since_epoch().count()
@@ -13,6 +14,10 @@ typedef boost::property_tree::ptree::path_type json_path;
 static constexpr const char* DEFAULT_QOS_CLASSES = R"({"rt1":[],"rt2":[],"rt3":[],"cd":[]})";
 // пороговое значение сна

+double translateCoordinates(uint8_t deg, uint8_t min) {
+    return static_cast<double>(deg) + static_cast<double>(min) / 60;
+}
+
 // static int calculateSubnetMask(const std::string& subnet_mask) {
 //     int mask = 0;
 //     std::istringstream iss(subnet_mask);
@@ -93,21 +98,7 @@ std::string makeTimepointFromMillis(int64_t unix_time_ms) {
 }


-bool api_driver::obj::CpUpdatebleObject::checkNeedUpdate(int64_t now) const {
-    if (updatePeriodMs < 0) return false;
-    // тут нет смысла спать меньше чем на 20мс, поэтому можно разрешить чтение на некоторое время раньше
-    return now - lastUpdate >= (updatePeriodMs - 20);
-}
-int64_t api_driver::obj::CpUpdatebleObject::getNextUpdate(int64_t now) const {
-    if (checkNeedUpdate(now)) {
-        return 0;
-    }
-    auto next = now - lastUpdate;
-    return next < 0 ? 0 : next;
-}
-api_driver::obj::CpUpdatebleObject::~CpUpdatebleObject() = default;
-
-#if API_OBJECT_STATISTICS_ENABLE
+#ifdef API_OBJECT_DEBUG_METRICS_ENABLE
 api_driver::obj::StatisticsLogger::StatisticsLogger(): timeStart(TIME_NOW()) {}

 std::string api_driver::obj::StatisticsLogger::getSettings() {
@@ -189,20 +180,12 @@ void api_driver::obj::StatisticsLogger::putItem(const debug_metrics &item) {
 api_driver::obj::StatisticsLogger::~StatisticsLogger() = default;
 #endif

-#if API_OBJECT_NETWORK_SETTINGS_ENABLE
+#ifdef API_OBJECT_NETWORK_SETTINGS_ENABLE
 api_driver::obj::TerminalNetworkSettings::TerminalNetworkSettings() { loadDefaults(); }

 api_driver::obj::TerminalNetworkSettings::TerminalNetworkSettings(const TerminalNetworkSettings &src) = default;

-api_driver::obj::TerminalNetworkSettings & api_driver::obj::TerminalNetworkSettings::operator=(const TerminalNetworkSettings &src) {
-    managementIp = src.managementIp;
-    managementGateway = src.managementGateway;
-    dataIp = src.dataIp;
-    serverName = src.serverName;
-    isL2 = src.isL2;
-    dataMtu = src.dataMtu;
-    return *this;
-}
+api_driver::obj::TerminalNetworkSettings & api_driver::obj::TerminalNetworkSettings::operator=(const TerminalNetworkSettings &src) = default;

 void api_driver::obj::TerminalNetworkSettings::loadDefaults() {
    managementIp = "0.0.0.0";
@@ -268,17 +251,14 @@ std::string api_driver::obj::TerminalNetworkSettings::asJson() {
 api_driver::obj::TerminalNetworkSettings::~TerminalNetworkSettings() = default;
 #endif

-#if API_OBJECT_QOS_SETTINGS_ENABLE
-api_driver::obj::TerminalQosSettings::TerminalQosSettings() {
-}
-
-api_driver::obj::TerminalQosSettings::TerminalQosSettings(const TerminalQosSettings &src) {
-}
-
-api_driver::obj::TerminalQosSettings & api_driver::obj::TerminalQosSettings::operator=(const TerminalQosSettings &src) {
-}
+#ifdef API_OBJECT_QOS_SETTINGS_ENABLE
+api_driver::obj::TerminalQosSettings::TerminalQosSettings() = default;
+api_driver::obj::TerminalQosSettings::TerminalQosSettings(const TerminalQosSettings &src) = default;
+api_driver::obj::TerminalQosSettings & api_driver::obj::TerminalQosSettings::operator=(const TerminalQosSettings &src) = default;

 void api_driver::obj::TerminalQosSettings::loadDefaults() {
+    qosEnabled = false;
+    qosSettingsJson = DEFAULT_QOS_CLASSES;
 }

 void api_driver::obj::TerminalQosSettings::updateCallback(proxy::CpProxy &cp) {
@@ -293,17 +273,15 @@ void api_driver::obj::TerminalQosSettings::store(proxy::CpProxy &cp) {
 std::string api_driver::obj::TerminalQosSettings::asJson() {
 }

-api_driver::obj::TerminalQosSettings::~TerminalQosSettings() {
-}
+api_driver::obj::TerminalQosSettings::~TerminalQosSettings() = default;
 #endif


-
-
-
+api_driver::obj::TerminalState::TerminalState() = default;

 void api_driver::obj::TerminalState::updateCallback(proxy::CpProxy& cp) {
    modulator_state mod{};
+    modulator_settings modSet{};
    demodulator_state demod{};
 #ifdef MODEM_IS_SCPC
    CinC_state cinc{};
@@ -311,13 +289,17 @@ void api_driver::obj::TerminalState::updateCallback(proxy::CpProxy& cp) {
    try {
        cp.getModState(mod);
        cp.getDemodState(demod);
-#ifdef MODEM_IS_SCPC
-        // CinC state прописывается в настройках
-        {
+        cp.getModSettings(modSet);

+        fTxState = modSet.tx_is_on;
+        fIsTest = modSet.tx_is_on && (!modSet.is_carrier || modSet.is_test_data);
+#ifdef MODEM_IS_SCPC
+        fIsCinC = modSet.is_cinc;
+        if (fIsCinC) {
+            cp.getCincState(cinc);
        }
-        cp.getCincState(cinc);
 #endif
+
 #ifdef MODEM_IS_TDMA
        fInitState = cp.getDmaDebug("status_init");
 #endif
@@ -325,165 +307,120 @@ void api_driver::obj::TerminalState::updateCallback(proxy::CpProxy& cp) {
        throw std::runtime_error(std::string("api_driver::obj::TerminalState::updateCallback() error: ") + e.what());
    }

+    fRxState = demod.locks.sym_sync_lock && demod.locks.freq_lock && demod.locks.afc_lock && demod.locks.pkt_sync;
+    fRxSymSyncLock = demod.locks.sym_sync_lock;
+    fRxFreqSearchLock = demod.locks.freq_lock;
+    fRxAfcLock = demod.locks.afc_lock;
+    fRxPktSync = demod.locks.pkt_sync;

+    fRxSnr = demod.snr;
+    fRxRssi = demod.rssi;
+    fRxModcod = demod.modcod;
+    fRxFrameSizeNormal = !demod.is_short;
+    fRxIsPilots = demod.is_pilots;
+
+    fRxSymError = demod.sym_err;
+    fRxFreqErr = demod.crs_freq_err;
+    fRxFreqErrAcc = demod.fine_freq_err;
+    fRxInputSignalLevel = demod.if_overload;
+    fRxPllError = demod.afc_err;
+    fRxSpeedOnRxKbit = static_cast<double>(demod.speed_in_bytes_rx) / 128.0;
+    fRxSpeedOnIifKbit = static_cast<double>(demod.speed_in_bytes_rx_iface) / 128.0;
+    fRxPacketsOk = demod.packet_ok_cnt;
+    fRxPacketsBad = demod.packet_bad_cnt;
+    fRxPacketsDummy = demod.dummy_cnt;
+
+    fTxModcod = mod.modcod;
+    fTxSpeedOnTxKbit = static_cast<double>(mod.speed_in_bytes_tx) / 128.0;
+    fTxSpeedOnIifKbit = static_cast<double>(mod.speed_in_bytes_tx_iface) / 128.0;
 #ifdef MODEM_IS_SCPC
-
-    bool isCinC = getIsCinC();
-    if (isCinC) {
-        logCpApiError("api_driver::TerminalApiDaemon::updateState()->CP_GetCinCState()", CP_GetCinCState(sid, cinc));
-    }
+    fTxSnr = mod.snr_remote;
+    fTxFrameSizeNormal = !mod.is_short;
+    fTxIsPilots = mod.is_pilots;
+    fCincOcc = cinc.ratio_signal_signal;
+    fCincCorrelator = cinc.carrier_lock;
+    fCincCorrelatorFails = cinc.cnt_bad_lock;
+    fCincFreqErr = cinc.freq_error_offset;
+    fCincFreqErrAcc = cinc.freq_fine_estimate;
+    fCincChannelDelay = cinc.delay_dpdi;
 #endif
-
-    {
 #ifdef MODEM_IS_TDMA
-        this->fInitState = tmpDevState;
+    fStatTxCenterFreq = modSet.central_freq_in_kGz;
+    fStatTxSymSpeed = static_cast<double>(modSet.baudrate) / 1000.0;
 #endif
-        this->fTxState = modulator.is_tx_on;
-        this->fTxModcod = modulator.modcod;
-        this->fTxSnr = modulator.snr_remote;
-        this->fTxframeSizeNormal = modulator.snr_remote;
-        this->fTx = modulator.snr_remote;
-        this->fTx = modulator.snr_remote;
-        this->fTx = modulator.snr_remote;
-#ifdef MODEM_IS_SCPC
-        result << ",\"tx.snr\":"; writeDouble(result, modulator.snr_remote);
-
-        if (modulator.is_short) { result << R"(,"tx.frameSizeNormal":false)"; }
-        else { result << R"(,"tx.frameSizeNormal":true)"; }
-
-        if (modulator.is_pilots) { result << R"(,"tx.isPilots":true)"; }
-        else { result << R"(,"tx.isPilots":false)"; }
-#else
-        {
-            modulator_settings modSet{};
-            daemon->getSettings(&modSet, nullptr, nullptr, nullptr);
-            result << ",\"tx.centerFreq\":"; writeDouble(result, modSet.central_freq_in_kGz);
-            result << ",\"tx.symSpeed\":"; writeDouble(result, (static_cast<double>(modSet.baudrate) / 1000.0));
-        }
-#endif
-
-            /*
-
-
-    result << ",\"tx.speedOnTxKbit\":"; writeDouble(result, static_cast<double>(modulator.speed_in_bytes_tx) / 128.0);
-    result << ",\"tx.speedOnIifKbit\":"; writeDouble(result, (static_cast<double>(modulator.speed_in_bytes_tx_iface) / 128.0));
-
-    // формируем структуру для RX
-    result << ",\n\"rx.state\":" << boolAsStr(demodulator.locks.sym_sync_lock && demodulator.locks.freq_lock && demodulator.locks.afc_lock && demodulator.locks.pkt_sync);
-    result << ",\"rx.sym_sync_lock\":" << boolAsStr(demodulator.locks.sym_sync_lock);
-    result << ",\"rx.freq_search_lock\":" << boolAsStr(demodulator.locks.freq_lock);
-    result << ",\"rx.afc_lock\":" << boolAsStr(demodulator.locks.afc_lock);
-    result << ",\"rx.pkt_sync\":" << boolAsStr(demodulator.locks.pkt_sync);
-
-    result << ",\"rx.snr\":"; writeDouble(result, demodulator.snr);
-    result << ",\"rx.rssi\":"; writeDouble(result, demodulator.rssi);
-    result << ",\"rx.modcod\":" << demodulator.modcod;
-
-    if (demodulator.is_short) {
-        result << R"(,"rx.frameSizeNormal":false)";
-    } else {
-        result << R"(,"rx.frameSizeNormal":true)";
-    }
-
-    if (demodulator.is_pilots) {
-        result << R"(,"rx.isPilots":true)";
-    } else {
-        result << R"(,"rx.isPilots":false)";
-    }
-
-    result << ",\n\"rx.symError\":"; writeDouble(result, demodulator.sym_err);
-    result << ",\"rx.freqErr\":"; writeDouble(result, demodulator.crs_freq_err);
-    result << ",\"rx.freqErrAcc\":"; writeDouble(result, demodulator.fine_freq_err);
-    result << ",\"rx.inputSignalLevel\":"; writeDouble(result, demodulator.if_overload);
-    result << ",\"rx.pllError\":"; writeDouble(result, demodulator.afc_err);
-    result << ",\"rx.speedOnRxKbit\":"; writeDouble(result, static_cast<double>(demodulator.speed_in_bytes_rx) / 128.0);
-    result << ",\"rx.speedOnIifKbit\":"; writeDouble(result, static_cast<double>(demodulator.speed_in_bytes_rx_iface) / 128.0);
-    result << ",\"rx.packetsOk\":" << demodulator.packet_ok_cnt;
-    result << ",\"rx.packetsBad\":" << demodulator.packet_bad_cnt;
-    result << ",\"rx.packetsDummy\":" << demodulator.dummy_cnt;
-
-#ifdef MODEM_IS_SCPC
-    // формируем структуру для CinC
-    if (isCinC) {
-        if (modulator.is_tx_on) {
-            if (cinc.carrier_lock) {
-                result << R"(,"cinc.correlator":true)";
-            } else {
-                result << R"(,"cinc.correlator":false)";
-            }
-        } else {
-            result << R"(,"cinc.correlator":null)";
-        }
-
-        result << ",\n\"cinc.occ\":"; writeDouble(result, cinc.ratio_signal_signal, 3);
-        result << ",\"cinc.correlatorFails\":" << cinc.cnt_bad_lock;
-        result << ",\"cinc.freqErr\":" << cinc.freq_error_offset;
-        result << ",\"cinc.freqErrAcc\":" << cinc.freq_fine_estimate;
-        result << ",\"cinc.channelDelay\":" << cinc.delay_dpdi;
-    } else {
-        result << R"(,"cinc.correlator":null)";
-    }
-#endif
-
-    // структура температур девайса
-    result << ",\n\"device.adrv\":"; writeDouble(result, device.adrv_temp, 1);
-    result << ",\"device.fpga\":"; writeDouble(result, device.pl_temp, 1);
-    result << ",\"device.zynq\":"; writeDouble(result, device.zynq_temp, 1);
-#ifdef MODEM_IS_TDMA
-    if (device.cur_image.empty()) {
-        result << R"(,
-"device.upgradeStatus":"Нет обновлений","device.upgradePercent":0,"device.upgradeImage":"")";
-    } else {
-        switch (device.status) {
-            case NORM_RX_OBJECT_NEW_API: result << ",\n" R"("device.upgradeStatus": "Начало загрузки")"; break;
-            case NORM_RX_OBJECT_INFO_API: result << ",\n" R"("device.upgradeStatus": "Получено имя образа")"; break;
-            case NORM_RX_OBJECT_UPDATED_API: result << ",\n" R"("device.upgradeStatus": "Загружается")"; break;
-            case NORM_RX_OBJECT_COMPLETED_API: result << ",\n" R"("device.upgradeStatus": "Загрузка завершена")"; break;
-            case NORM_RX_OBJECT_ABORTED_API: result << ",\n" R"("device.upgradeStatus": "Загрузка прервана")"; break;
-            default: result << ",\n" R"("device.upgradeStatus": "?")";
-
-        }
-        result << ",\"device.upgradePercent\":" << device.dwl_percent;
-        result << ",\"device.upgradeImage\":" << buildEscapedString(device.cur_image);
-    }
-
-#endif
-
-    result << "}";
-     */
-        this->modState = modulator;
-        this->demodState = demodulator;
-
-#ifdef MODEM_IS_SCPC
-        this->cincState = cinc;
-#endif
-    }
 }

+nlohmann::json api_driver::obj::TerminalState::asJson() {
+    nlohmann::json res{};
+
+    res["initState"] = fInitState;
+    res["testState"] = fIsTest;
+    res["fTxState"] = fIsTest;
+#ifdef MODEM_IS_SCPC
+    res["isCinC"] = fIsCinC;
+#endif
+
+    res["rx"]["state"] = fRxState;
+    res["rx"]["sym_sync_lock"] = fRxSymSyncLock;
+    res["rx"]["freq_search_lock"] = fRxFreqSearchLock;
+    res["rx"]["afc_lock"] = fRxAfcLock;
+    res["rx"]["pkt_sync"] = fRxPktSync;
+
+    res["rx"]["snr"] = fRxSnr;
+    res["rx"]["rssi"] = fRxRssi;
+    res["rx"]["modcod"] = fRxModcod;
+    res["rx"]["frameSizeNormal"] = fRxFrameSizeNormal;
+    res["rx"]["isPilots"] = fRxIsPilots;
+
+    res["rx"]["symError"] = fRxSymError;
+    res["rx"]["freqErr"] = fRxFreqErr;
+    res["rx"]["freqErrAcc"] = fRxFreqErrAcc;
+    res["rx"]["inputSignalLevel"] = fRxInputSignalLevel;
+    res["rx"]["pllError"] = fRxPllError;
+    res["rx"]["speedOnRxKbit"] = fRxSpeedOnRxKbit;
+    res["rx"]["speedOnIifKbit"] = fRxSpeedOnIifKbit;
+    res["rx"]["packetsOk"] = fRxPacketsOk;
+    res["rx"]["packetsBad"] = fRxPacketsBad;
+    res["rx"]["packetsDummy"] = fRxPacketsDummy;
+
+    res["tx"]["modcod"] = fTxModcod;
+    res["tx"]["speedOnTxKbit"] = fTxSpeedOnTxKbit;
+    res["tx"]["speedOnIifKbit"] = fTxSpeedOnIifKbit;
+#ifdef MODEM_IS_SCPC
+    res["tx"]["snr"] = fTxSnr;
+    res["tx"]["frameSizeNormal"] = fTxFrameSizeNormal;
+    res["tx"]["isPilots"] = fTxIsPilots;
+
+    if (fIsCinC) {
+        if (fTxState) {
+            res["cinc"]["correlator"] = fCincCorrelator;
+        } else {
+            res["cinc"]["correlator"] = nullptr;
+        }
+
+        res["cinc"]["occ"] = fCincOcc;
+        res["cinc"]["correlatorFails"] = fCincCorrelatorFails;
+        res["cinc"]["freqErr"] = fCincFreqErr;
+        res["cinc"]["freqErrAcc"] = fCincFreqErrAcc;
+        res["cinc"]["channelDelay"] = fCincChannelDelay;
+    } else {
+        res["cinc"]["correlator"] = nullptr;
+    }
+#endif
+#ifdef MODEM_IS_TDMA
+    res["tx"]["centerFreq"] = fTxCenterFreq;
+    res["tx"]["symSpeed"] = fTxSymSpeed;
+#endif
+
+    return res;
+}

 api_driver::obj::TerminalState::~TerminalState() = default;


 api_driver::obj::TerminalDeviceState::TerminalDeviceState() = default;
 api_driver::obj::TerminalDeviceState::TerminalDeviceState(const TerminalDeviceState &src) = default;
-api_driver::obj::TerminalDeviceState & api_driver::obj::TerminalDeviceState::operator=(const TerminalDeviceState &src) {
-    fOsUptime = src.fOsUptime;
-    fOsLoad1 = src.fOsLoad1;
-    fOsLoad5 = src.fOsLoad5;
-    fOsLoad15 = src.fOsLoad15;
-    fOsTotalram = src.fOsTotalram;
-    fOsFreeram = src.fOsFreeram;
-    fOsProcs = src.fOsProcs;
-    fTempAdrv = src.fTempAdrv;
-    fTempZynq = src.fTempZynq;
-    fTempFpga = src.fTempFpga;
-#ifdef MODEM_IS_TDMA
-    fUpgradeStatus = src.fUpgradeStatus;
-    fUpgradePercent = src.fUpgradePercent;
-    fUpgradeImage = src.fUpgradeImage;
-#endif
-    return *this;
-}
+api_driver::obj::TerminalDeviceState & api_driver::obj::TerminalDeviceState::operator=(const TerminalDeviceState &src) = default;

 void api_driver::obj::TerminalDeviceState::updateCallback(proxy::CpProxy &cp) {
    {
@@ -516,39 +453,38 @@ void api_driver::obj::TerminalDeviceState::updateCallback(proxy::CpProxy &cp) {
    fOsProcs = info.procs;
 }

-std::string api_driver::obj::TerminalDeviceState::asJson() const {
-    std::stringstream result;
-    result << "{\"uptime\":" << fOsUptime
-           << ",\"load1min\":" << std::setprecision(2) << fOsLoad1
-           << ",\"load5min\":" << std::setprecision(2) << fOsLoad5
-           << ",\"load15min\":" << std::setprecision(2) << fOsLoad15
-           << ",\"totalram\":" << fOsTotalram
-           << ",\"freeram\":" << fOsFreeram
-           << ",\"procs\":" << fOsProcs
-           << ",\"adrv\":" << std::setprecision(1) << fTempAdrv
-           << ",\"fpga\":" << std::setprecision(1) << fTempFpga
-           << ",\"zynq\":" << std::setprecision(1) << fTempZynq;
+nlohmann::json api_driver::obj::TerminalDeviceState::asJson() const {
+    nlohmann::json res;
+    res["uptime"] = fOsUptime;
+    res["load1min"] = fOsLoad1;
+    res["load5min"] = fOsLoad5;
+    res["load15min"] = fOsLoad15;
+    res["totalram"] = fOsTotalram;
+    res["freeram"] = fOsFreeram;
+    res["procs"] = fOsProcs;
+    res["adrv"] = fTempAdrv;
+    res["fpga"] = fTempFpga;
+    res["zynq"] = fTempZynq;
 #ifdef MODEM_IS_TDMA
    if (fUpgradeImage.empty()) {
-        result << R"(,
-"upgradeStatus":"Нет обновлений","upgradePercent":0,"upgradeImage":"")";
+        res["upgradeStatus"] = "Нет обновлений";
+        res["upgradePercent"] = 0;
+        res["upgradeImage"] = "";
    } else {
        switch (fUpgradeStatus) {
-            case NORM_RX_OBJECT_NEW_API: result << ",\n" R"("upgradeStatus": "Начало загрузки")"; break;
-            case NORM_RX_OBJECT_INFO_API: result << ",\n" R"("upgradeStatus": "Получено имя образа")"; break;
-            case NORM_RX_OBJECT_UPDATED_API: result << ",\n" R"("upgradeStatus": "Загружается")"; break;
-            case NORM_RX_OBJECT_COMPLETED_API: result << ",\n" R"("upgradeStatus": "Загрузка завершена")"; break;
-            case NORM_RX_OBJECT_ABORTED_API: result << ",\n" R"("upgradeStatus": "Загрузка прервана")"; break;
-            default: result << ",\n" R"("upgradeStatus": "?")";
-
+            case NORM_RX_OBJECT_NEW_API: res["upgradeStatus"] = "Начало загрузки"; break;
+            case NORM_RX_OBJECT_INFO_API: res["upgradeStatus"] = "Получено имя образа"; break;
+            case NORM_RX_OBJECT_UPDATED_API: res["upgradeStatus"] = "Загружается"; break;
+            case NORM_RX_OBJECT_COMPLETED_API: res["upgradeStatus"] = "Загрузка завершена"; break;
+            case NORM_RX_OBJECT_ABORTED_API: res["upgradeStatus"] = "Загрузка прервана"; break;
+            default: res["upgradeStatus"] = "?";
        }
-        result << ",\"upgradePercent\":" << fUpgradePercent;
-        result << ",\"upgradeImage\":" << buildEscapedString(fUpgradeImage);
+        res["upgradePercent"] = fUpgradePercent;
+        res["upgradeImage"] = fUpgradeImage;
    }

 #endif
-    result << "}";
-    return result.str();
+    return res;
 }

 api_driver::obj::TerminalDeviceState::~TerminalDeviceState() = default;