VladislavOstapov/terminal-web-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Vladislav Ostapov 2025-06-01 15:49:31 +03:00
parent 3e38e77069
commit c2dd4b13e8
11 changed files with 25182 additions and 1298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@ -23,7 +23,7 @@ elseif ("${MODEM_TYPE}" STREQUAL "TDMA")
message(STATUS "Selected TDMA modem")
elseif ("${MODEM_TYPE}" STREQUAL "SHPS")
add_definitions(-DMODEM_IS_SHPS)
message(STATUS "Selected TDMA modem")
message(STATUS "Selected SHPS modem")
else()
message(FATAL_ERROR "You must set `MODEM_TYPE` \"SCPC\" or \"TDMA\" or \"SHPS\"!")
endif()
@ -63,6 +63,7 @@ add_executable(terminal-web-server
src/api-driver/proxy.cpp
src/api-driver/structs.h
src/api-driver/structs.cpp
src/common/nlohmann/json.hpp
src/server/mime_types.hpp
src/server/mime_types.cpp
src/server/request_parser.hpp

453
src/api-driver/daemon.cpp
View File

@ -1,10 +1,45 @@
//
// Created by vlad on 03.04.2025.
//
#include "daemon.h"
#include <utility>
#include <boost/thread/pthread/thread_data.hpp>
#include "terminal_api_driver.h"
// минимальный порог для сна в цикле событий демона
static constexpr int64_t SLEEP_THRESHOLD = 10;
namespace api_driver {
/**
* Обертка для объектов, доступных для обновления
* NOTE: перед вызовом функций, требующих `TSID`, необходимо захватить мютекс API.
*/
class CpUpdatebleObject {
public:
int64_t lastUpdate = 0;
int64_t updatePeriodMs = -1;
/**
* Функция для обновления (загрузки) объекта из CP API.
*/
std::function<void ()> updateCallback;
explicit CpUpdatebleObject(std::function<void ()> callback, int64_t period = -1): updatePeriodMs(period), updateCallback(std::move(callback)) {}
bool checkNeedUpdate(int64_t now) const {
if (updatePeriodMs < 0) return false;
// тут нет смысла спать меньше чем на 20мс, поэтому можно разрешить чтение на некоторое время раньше
return now - lastUpdate >= (updatePeriodMs - 20);
}
int64_t getNextUpdate(int64_t now) const {
if (checkNeedUpdate(now)) {
return 0;
}
auto next = now - lastUpdate;
return next < 0 ? 0 : next;
}
~CpUpdatebleObject() = default;
};
}
void api_driver::TerminalApiDaemon::connectToApi() {
@ -12,7 +47,7 @@ void api_driver::TerminalApiDaemon::connectToApi() {
std::lock_guard _lock(this->stateMutex);
this->state.fInitState = "Not connected to API";
}
#if defined(MODEM_IS_SCPC) || defined(MODEM_IS_TDMA)
#ifdef API_OBJECT_NETWORK_SETTINGS_ENABLE
{
std::lock_guard _lock(this->settingsMutex);
this->settingsNetwork.loadDefaults();
@ -54,89 +89,92 @@ void api_driver::TerminalApiDaemon::run() {
this->connectToApi();
struct {
obj::CpUpdatebleObject* u;
std::function<void ()> c;
CpUpdatebleObject uo;
std::string updaterName;
} updaters[] = {
#if API_OBJECT_NETWORK_SETTINGS_ENABLE
#ifdef API_OBJECT_NETWORK_SETTINGS_ENABLE
// обновление логов
{.u = &statsLogs, .c = [this]() {
try {
{
std::lock_guard _alock(this->cpApiMutex);
this->statsLogs.updateCallback(cp);
}
BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon->statsLogs.putItem(): success write statistics state to log!";
} catch (std::exception& e) {
BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon->statsLogs.putItem() failed to log: " << e.what();
}
}},
{.uo = CpUpdatebleObject([this]() {
this->statsLogs.updateCallback(cp);
}), .updaterName = "updateDebugMetrics"},
#endif
// обновление статистики
{.u = state, .c = [this]() {
try {
std::lock_guard _alock(this->cpApiMutex);
std::lock_guard _slock(this->stateMutex);
state.updateCallback(cp);
stateDev.updateCallback(cp);
BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon::updateState(): success update!";
} catch (std::exception& e) {
BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::updateState(): " << e.what();
}
}},
{.uo = CpUpdatebleObject([this]() {
std::shared_lock _slock1(this->settingsMutex);
obj::TerminalState tmp(state);
_slock1.release();
tmp.updateCallback(cp);
std::lock_guard _slock2(this->settingsMutex);
state = tmp;
}, CACHE_STATISTICS_UPDATE_MS), .updaterName = "updateStatistics"},
{.uo = CpUpdatebleObject([this]() {
obj::TerminalDeviceState tmp(stateDev);
tmp.updateCallback(cp);
std::lock_guard _slock2(this->settingsMutex);
stateDev = tmp;
}, CACHE_STATISTICS_UPDATE_MS), .updaterName = "updateDeviceState"},
// обновление кеша настроек
{.lastUpdate = 0, .periodMs = CACHE_SETTINGS_UPDATE_MS, .c = [this]() {
try {
this->updateSettings();
BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon::updateSettings(): success update!";
} catch (std::exception& e) {
BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::updateSettings(): " << e.what();
}
}},
// обновление кеша настроек сети (делается отдельно)
{.lastUpdate = 0, .periodMs = CACHE_SETTINGS_UPDATE_MS, .c = [this]() {
try {
this->updateNetworkSettings();
BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon::updateNetworkSettings(): success update!";
} catch (std::exception& e) {
BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::updateNetworkSettings(): " << e.what();
}
}},
{.uo = CpUpdatebleObject([this]() {
obj::TerminalRxTxSettings rxtx;
rxtx.updateCallback(cp);
std::lock_guard _slock2(this->settingsMutex);
settingsRxTx = rxtx;
}, CACHE_SETTINGS_UPDATE_MS), .updaterName = "updateRxTxSettings"},
#ifdef API_OBJECT_NETWORK_SETTINGS_ENABLE
{.uo = CpUpdatebleObject([this]() {
std::shared_lock _slock1(this->settingsMutex);
obj::TerminalNetworkSettings net(settingsNetwork);
_slock1.release();
net.updateCallback(cp);
std::lock_guard _slock2(this->settingsMutex);
settingsNetwork = net;
}, CACHE_SETTINGS_UPDATE_MS), .updaterName = "updateNetworkSettings"},
#endif
#ifdef API_OBJECT_QOS_SETTINGS_ENABLE
// обновление кеша QoS
{.lastUpdate = 0, .periodMs = CACHE_QOS_UPDATE_MS, .c = [this]() {
try {
this->updateQos();
BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon::updateQos(): success update!";
} catch (std::exception& e) {
BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::updateQos(): " << e.what();
}
}}
{.uo = CpUpdatebleObject([this]() {
obj::TerminalQosSettings qos;
qos.updateCallback(cp);
std::lock_guard _slock(this->settingsMutex);
settingsQos = qos;
}, CACHE_SETTINGS_UPDATE_MS), .updaterName = "updateQosSettings"},
#endif
};
while (true) {
if (this->lastCpError == ERROR || this->lastCpError == TIMEOUT) {
BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::run(): close current daemon session caused error " << this->lastCpError;
CP_Logout(this->sid);
if (this->cp.lastCpError == ERROR || this->cp.lastCpError == TIMEOUT) {
BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::run(): close current daemon session caused error " << this->cp.lastCpError;
cp.disconnect();
this->connectToApi();
}
#ifdef MODEM_IS_SCPC
updaters[0].periodMs = this->statsLogs.logEn ? this->statsLogs.logPeriodMs.load() : -1;
#ifdef API_OBJECT_DEBUG_METRICS_ENABLE
updaters[0].uo.updatePeriodMs = this->statsLogs.logEn ? this->statsLogs.logPeriodMs.load() : -1;
#endif
int64_t sleepTime = 60000; // минута по-умолчанию
auto now = TIME_NOW();
auto now = TimeNow();
for (auto& u: updaters) {
if (u.checkNeedUpdate(now)) {
auto targetTime = u.lastUpdate + u.periodMs;
if (u.uo.checkNeedUpdate(now)) {
auto targetTime = u.uo.lastUpdate + u.uo.updatePeriodMs;
if (targetTime + SLEEP_THRESHOLD <= now && targetTime - SLEEP_THRESHOLD >= now) {
u.lastUpdate = targetTime;
u.uo.lastUpdate = targetTime;
} else {
u.lastUpdate = now;
u.uo.lastUpdate = now;
}
u.callback();
now = TIME_NOW();
try {
std::lock_guard _lock(this->cpApiMutex);
u.uo.updateCallback();
BOOST_LOG_TRIVIAL(debug) << "api_driver::TerminalApiDaemon::run()->" << u.updaterName << "(): success update!";
} catch (std::exception& e) {
BOOST_LOG_TRIVIAL(error) << "api_driver::TerminalApiDaemon::run()->" << u.updaterName << "(): error " << e.what();
}
now = TimeNow();
}
if (u.periodMs >= 0) {
sleepTime = std::min(sleepTime, u.getNextUpdate(now));
if (u.uo.updatePeriodMs >= 0) {
sleepTime = std::min(sleepTime, u.uo.getNextUpdate(now));
}
}
@ -149,12 +187,12 @@ void api_driver::TerminalApiDaemon::run() {
api_driver::TerminalApiDaemon::TerminalApiDaemon(): daemon([this]() { this->run(); }) {}
void api_driver::TerminalApiDaemon::getState(obj::TerminalState &dest) {
std::shared_lock _lock(state);
std::shared_lock _lock(stateMutex);
dest = state;
}
void api_driver::TerminalApiDaemon::getDeviceState(obj::TerminalDeviceState &dest) {
std::shared_lock _lock(state);
std::shared_lock _lock(stateMutex);
dest = stateDev;
}
@ -199,274 +237,3 @@ api_driver::TerminalApiDaemon::~TerminalApiDaemon() {
BOOST_LOG_TRIVIAL(error) << "api_driver::~TerminalApiDaemon(): " << e.what();
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Этот демон нужен для того, чтобы получать статистику из API, а так же корректно сохранять настройки
*/
class api_driver::TerminalApiDaemon {
void updateState() {
obj::TerminalDeviceState s;
std::lock_guard lock(this->cpApiMutex);
try {
s.updateCallback(cp);
}
{
std::lock_guard lock2(this->stateMutex);
this->state = s;
#ifdef MODEM_IS_TDMA
this->state.fInitState = tmpDevState;
#endif
}
}
void updateSettings() {
modulator_settings mod{};
// uint32_t modulatorModcod;
// CP_GetModulatorParams(sid, "modcod", &modulatorModcod);
demodulator_settings demod{};
#ifdef MODEM_IS_SCPC
ACM_parameters_serv_ acm{};
#endif
DPDI_parmeters dpdi{};
buc_lnb_settings bucLnb{};
std::lock_guard lock(this->cpApiMutex);
logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetModulatorSettings()", CP_GetModulatorSettings(sid, mod));
logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetDemodulatorSettings()", CP_GetDemodulatorSettings(sid, demod));
#ifdef MODEM_IS_SCPC
logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetAcmParams()", CP_GetAcmParams(sid, &acm));
#endif
logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetDpdiParams()", CP_GetDpdiParams(sid, &dpdi));
logCpApiError("api_driver::TerminalApiDaemon::updateSettings()->CP_GetBUC_LNB_settings()", CP_GetBUC_LNB_settings(sid, bucLnb));
{
std::lock_guard lock2(this->settingsMutex);
this->modSettings = mod;
this->demodSettings = demod;
#ifdef MODEM_IS_SCPC
this->acmSettings = acm;
#endif
this->dpdiSettings = dpdi;
this->bucLnbSettings = bucLnb;
}
}
void updateNetworkSettings() {
obj::TerminalNetworkSettings s;
std::lock_guard lock(this->cpApiMutex);
unsafeLoadNetworkSettings(s);
{
std::lock_guard lock2(this->networkSettingsMutex);
this->networkSettings = s;
}
}
void updateQos() {
bool tmp1; std::string tmp2;
std::scoped_lock lock{this->cpApiMutex};
logCpApiError("api_driver::TerminalApiDaemon::updateQos()->CP_GetQoSSettings()", CP_GetQoSSettings(this->sid, tmp2, tmp1));
{
std::lock_guard lock2(this->qosSettingsMutex);
this->qosEnabled = tmp1;
this->qosClassesJson = tmp2.empty() ? DEFAULT_QOS_CLASSES : tmp2;
}
}
public:
/**
* Получение статистики, копирует текущие значения в структуры, переданные по указателю. Если передан пустой указатель, копирования не произойдет.
*/
TerminalDeviceState getState() {
TerminalDeviceState s;
{
std::shared_lock lock(this->stateMutex);
s = this->state;
}
return s;
}
/**
* Получение настроек, копирует текущие значения в структуры, переданные по указателю. Если передан пустой указатель, копирования не произойдет.
*/
void getSettings(
modulator_settings* mod, demodulator_settings* demod,
#ifdef MODEM_IS_SCPC
ACM_parameters_serv_* acm,
#endif
DPDI_parmeters* dpdi, buc_lnb_settings* bucLnb) {
if (mod || demod ||
#ifdef MODEM_IS_SCPC
acm ||
#endif
dpdi || bucLnb) {
std::shared_lock lock(this->settingsMutex);
if (mod) { *mod = this->modSettings; }
if (demod) { *demod = this->demodSettings; }
#ifdef MODEM_IS_SCPC
if (acm) { *acm = this->acmSettings; }
#endif
if (dpdi) { *dpdi = this->dpdiSettings; }
if (bucLnb) { *bucLnb = this->bucLnbSettings; }
}
}
#ifdef MODEM_IS_SCPC
bool getIsCinC() {
std::shared_lock lock(this->settingsMutex);
return modSettings.is_cinc;
}
#endif
bool isTest() {
std::shared_lock lock(this->settingsMutex);
return modSettings.tx_is_on && (!modSettings.is_carrier
#ifdef MODEM_IS_SCPC
|| this->modSettings.is_test_data
#endif
);
}
void getNetworkSettings(TerminalNetworkSettings& dest) {
std::shared_lock lock(this->networkSettingsMutex);
dest = this->networkSettings;
}
void getQosSettings(bool& isEnabled, std::string& json) {
std::shared_lock lock(this->qosSettingsMutex);
isEnabled = this->qosEnabled;
json = this->qosClassesJson;
}
#ifdef MODEM_IS_SCPC
void setSettingsRxTx(modulator_settings& mod, demodulator_settings& demod, ACM_parameters_serv_& acm, bool readback = true) {
std::lock_guard lock(this->cpApiMutex);
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", ""));
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetModulatorSettings()", CP_SetModulatorSettings(this->sid, mod));
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDemodulatorSettings()", CP_SetDemodulatorSettings(this->sid, demod));
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetAcmParams()", CP_SetAcmParams(this->sid, acm));
if (readback) {
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetModulatorSettings()", CP_GetModulatorSettings(this->sid, mod));
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetDemodulatorSettings()", CP_GetDemodulatorSettings(this->sid, demod));
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetAcmParams()", CP_GetAcmParams(this->sid, &acm));
{
std::lock_guard lock2{this->settingsMutex};
this->modSettings = mod;
this->demodSettings = demod;
this->acmSettings = acm;
}
}
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", ""));
}
#else
void setSettingsRxTx(modulator_settings& mod, demodulator_settings& demod, bool readback = true) {
std::lock_guard lock(this->cpApiMutex);
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", ""));
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetModulatorSettings()", CP_SetModulatorSettings(this->sid, mod));
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDemodulatorSettings()", CP_SetDemodulatorSettings(this->sid, demod));
if (readback) {
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetModulatorSettings()", CP_GetModulatorSettings(this->sid, mod));
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_GetDemodulatorSettings()", CP_GetDemodulatorSettings(this->sid, demod));
{
std::lock_guard lock2{this->settingsMutex};
this->modSettings = mod;
this->demodSettings = demod;
}
}
logCpApiError("api_driver::TerminalApiDaemon::setSettingsRxTx()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", ""));
}
#endif
void setSettingsDpdi(DPDI_parmeters& s, bool readback = true) {
std::lock_guard lock(this->cpApiMutex);
logCpApiError("api_driver::TerminalApiDaemon::setSettingsDpdi()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", ""));
logCpApiError("api_driver::TerminalApiDaemon::setSettingsDpdi()->CP_SetDpdiParams()", CP_SetDpdiParams(sid, s));
if (readback) {
logCpApiError("api_driver::TerminalApiDaemon::setSettingsDpdi()->CP_GetDpdiParams()", CP_GetDpdiParams(this->sid, &s));
{
std::lock_guard lock2{this->settingsMutex};
this->dpdiSettings = s;
}
}
logCpApiError("api_driver::TerminalApiDaemon::setSettingsDpdi()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", ""));
}
void setSettingsBucLnb(buc_lnb_settings& bucLnb, bool readback = true) {
std::lock_guard lock(this->cpApiMutex);
logCpApiError("api_driver::TerminalApiDaemon::setSettingsBucLnb()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", ""));
logCpApiError("api_driver::TerminalApiDaemon::setSettingsBucLnb()->CP_SetBUC_LNB_settings()", CP_SetBUC_LNB_settings(this->sid, bucLnb));
if (readback) {
logCpApiError("api_driver::TerminalApiDaemon::setSettingsBucLnb()->CP_GetBUC_LNB_settings()", CP_GetBUC_LNB_settings(this->sid, bucLnb));
{
std::lock_guard lock2{this->settingsMutex};
this->bucLnbSettings = bucLnb;
}
}
logCpApiError("api_driver::TerminalApiDaemon::setSettingsBucLnb()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", ""));
}
void setQosSettings(bool enabled, const std::string& str, bool readback = true) {
std::lock_guard lock(this->cpApiMutex);
logCpApiError("api_driver::TerminalApiDaemon::setQosSettings()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", ""));
logCpApiError("api_driver::TerminalApiDaemon::setQosSettings()->CP_SetQoSSettings()", CP_SetQoSSettings(this->sid, str, enabled));
if (readback) {
bool tmp1; std::string tmp2;
logCpApiError("api_driver::TerminalApiDaemon::setQosSettings()->CP_GetQoSSettings()", CP_GetQoSSettings(this->sid, tmp2, tmp1));
{
std::lock_guard lock2(this->qosSettingsMutex);
this->qosEnabled = tmp1;
this->qosClassesJson = tmp2.empty() ? DEFAULT_QOS_CLASSES : tmp2;
}
}
logCpApiError("api_driver::TerminalApiDaemon::setQosSettings()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", ""));
}
void setNetworkSettings(TerminalNetworkSettings& s, bool readback = true) {
// const auto mang = splitIpAndMask();
// std::pair<std::string, std::string> data;
// if (!s.isL2) {
// data = splitIpAndMask(s.dataIp);
// }
std::lock_guard lock(this->cpApiMutex);
logCpApiError("api_driver::TerminalApiDaemon::setNetworkSettings()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", ""));
unsafStoreNetworkSettings(s);
if (readback) {
unsafeLoadNetworkSettings(s);
{
std::lock_guard lock2(this->networkSettingsMutex);
this->networkSettings = s;
}
}
logCpApiError("api_driver::TerminalApiDaemon::setNetworkSettings()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", ""));
}
TerminalFirmwareVersion getFirmware() {
std::shared_lock lock(this->firmwareMutex);
return firmware;
}
void resetPacketStatistics() {
std::string tmp;
std::lock_guard lock(this->cpApiMutex);
logCpApiError("api_driver::TerminalApiDaemon::resetPacketStatistics()->CP_GetDmaDebug(reset_cnt_rx)", CP_GetDmaDebug(sid, "reset_cnt_rx", &tmp));
}
void resetDefaultSettings() {
std::lock_guard lock(this->cpApiMutex);
logCpApiError("api_driver::TerminalApiDaemon::resetDefaultSettings()->CP_SetDmaDebug(begin_save_config)", CP_SetDmaDebug(sid, "begin_save_config", ""));
logCpApiError("api_driver::TerminalApiDaemon::resetDefaultSettings()->CP_SetDmaDebug(default_params)", CP_SetDmaDebug(sid, "default_params", ""));
logCpApiError("api_driver::TerminalApiDaemon::resetDefaultSettings()->CP_SetDmaDebug(save_config)", CP_SetDmaDebug(sid, "save_config", ""));
}
};

55
src/api-driver/daemon.h
View File

@ -1,16 +1,15 @@
#ifndef DAEMON_H
#define DAEMON_H
#include <boost/thread/detail/thread.hpp>
#ifndef API_DRIVER_DAEMON_H
#define API_DRIVER_DAEMON_H
#include "proxy.h"
#include "api-driver/structs.h"
#include <boost/thread/thread.hpp>
namespace api_driver {
int64_t TimeNow();
class TerminalApiDaemon {
std::mutex cpApiMutex;
boost::thread daemon;
proxy::CpProxy cp;
void connectToApi();
@ -22,49 +21,51 @@ namespace api_driver {
std::shared_mutex settingsMutex;
obj::TerminalRxTxSettings settingsRxTx;
#if API_OBJECT_NETWORK_SETTINGS_ENABLE
#ifdef API_OBJECT_NETWORK_SETTINGS_ENABLE
obj::TerminalNetworkSettings settingsNetwork;
#endif
#if API_OBJECT_QOS_SETTINGS_ENABLE
#endif
#ifdef API_OBJECT_QOS_SETTINGS_ENABLE
obj::TerminalQosSettings settingsQos;
#endif
#endif
std::shared_mutex firmwareMutex;
obj::TerminalFirmwareVersion firmware;
public:
#if API_OBJECT_STATISTICS_ENABLE
std::mutex cpApiMutex;
proxy::CpProxy cp;
#ifdef API_OBJECT_DEBUG_METRICS_ENABLE
obj::StatisticsLogger statsLogs;
#endif
#endif
explicit TerminalApiDaemon();
std::string getDeviceInitState();
/**
* Получение статистики, копирует текущие значения в структуры, переданные по указателю. Если передан пустой указатель, копирования не произойдет.
*/
void getState(obj::TerminalState& dest);
void getDeviceState(obj::TerminalDeviceState& dest);
* Получение статистики, копирует текущие значения в структуры, переданные по указателю. Если передан пустой указатель, копирования не произойдет.
*/
void getState(obj::TerminalState &dest);
void getDeviceState(obj::TerminalDeviceState &dest);
// /**
// * Получение настроек, копирует текущие значения в структуры, переданные по указателю. Если передан пустой указатель, копирования не произойдет.
// */
void getSettingsRxTx(obj::TerminalRxTxSettings& dest);
void getSettingsRxTx(obj::TerminalRxTxSettings &dest);
void getNetworkSettings(obj::TerminalNetworkSettings& dest);
void getNetworkSettings(obj::TerminalNetworkSettings &dest);
void getQosSettings(bool& isEnabled, std::string& json);
void getQosSettings(bool &isEnabled, std::string &json);
void setSettingsRxTx(obj::TerminalRxTxSettings& s, bool readback = true);
void setSettingsRxTx(obj::TerminalRxTxSettings &s, bool readback = true);
void setSettingsDpdi(DPDI_parmeters& s, bool readback = true);
void setSettingsDpdi(DPDI_parmeters &s, bool readback = true);
void setSettingsBucLnb(buc_lnb_settings& bucLnb, bool readback = true);
void setSettingsBucLnb(buc_lnb_settings &bucLnb, bool readback = true);
void setQosSettings(bool enabled, const std::string& str, bool readback = true);
void setQosSettings(bool enabled, const std::string &str, bool readback = true);
void setNetworkSettings(obj::TerminalNetworkSettings& s, bool readback = true);
void setNetworkSettings(obj::TerminalNetworkSettings &s, bool readback = true);
obj::TerminalFirmwareVersion getFirmware();
@ -77,4 +78,4 @@ namespace api_driver {
}
#endif //DAEMON_H
#endif //API_DRIVER_DAEMON_H

3
src/api-driver/proxy.h
View File

@ -28,6 +28,7 @@ namespace api_driver::proxy {
void disconnect();
std::string getDmaDebug(const std::string& arg);
void setDmaDebug(const std::string& arg, const std::string& value);
std::string getNetwork(const std::string& param);
void setNetwork(const std::string& param, const std::string& value);
@ -46,7 +47,7 @@ namespace api_driver::proxy {
void getCincState(CinC_state& dest);
#endif
#if API_OBJECT_STATISTICS_ENABLE
#ifdef API_OBJECT_DEBUG_METRICS_ENABLE
void getDebugMetrics(debug_metrics& dest);
#endif

24
src/api-driver/stricts-enable.h
View File

@ -1,8 +1,26 @@
#ifndef API_DRIVER_STRICTS_ENABLE_H
#define API_DRIVER_STRICTS_ENABLE_H
#define API_OBJECT_STATISTICS_ENABLE defined(MODEM_IS_SCPC)
#define API_OBJECT_NETWORK_SETTINGS_ENABLE defined(MODEM_IS_SCPC) || defined(MODEM_IS_TDMA)
#define API_OBJECT_QOS_SETTINGS_ENABLE defined(MODEM_IS_SCPC) || defined(MODEM_IS_TDMA)
#if defined(MODEM_IS_SCPC)
#define API_OBJECT_DEBUG_METRICS_ENABLE
#endif
#if defined(MODEM_IS_SCPC) || defined(MODEM_IS_TDMA)
#define API_OBJECT_NETWORK_SETTINGS_ENABLE
#endif
#if defined(MODEM_IS_SCPC) || defined(MODEM_IS_TDMA)
#define API_OBJECT_QOS_SETTINGS_ENABLE
#endif
#if defined(MODEM_IS_SCPC) || defined(MODEM_IS_TDMA)
#define API_OBJECT_DPDI_SETTINGS_ENABLE
#endif
#if defined(MODEM_IS_SCPC) || defined(MODEM_IS_TDMA) || defined(MODEM_IS_SHPS)
#define API_OBJECT_BUCLNB_SETTINGS_ENABLE
#endif
#endif //API_DRIVER_STRICTS_ENABLE_H

366
src/api-driver/structs.cpp
View File

@ -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;

143
src/api-driver/structs.h
View File

@ -10,33 +10,12 @@
#include <boost/log/trivial.hpp>
#include <boost/property_tree/ptree_fwd.hpp>
#include "common/nlohmann/json.hpp"
namespace api_driver::obj {
/**
* Обертка для объектов, доступных для обновления
* NOTE: перед вызовом функций, требующих `TSID`, необходимо захватить мютекс API.
*/
class CpUpdatebleObject {
public:
int64_t lastUpdate = 0;
int64_t updatePeriodMs = -1;
/**
* Функция для обновления (загрузки) объекта из CP API.
*/
virtual void updateCallback(proxy::CpProxy& cp) = 0;
bool checkNeedUpdate(int64_t now) const;
int64_t getNextUpdate(int64_t now) const;
virtual ~CpUpdatebleObject();
};
#if API_OBJECT_STATISTICS_ENABLE
class StatisticsLogger: public CpUpdatebleObject {
#ifdef API_OBJECT_DEBUG_METRICS_ENABLE
class StatisticsLogger {
public:
StatisticsLogger();
@ -55,7 +34,7 @@ namespace api_driver::obj {
std::string getSettings();
void setSettings(boost::property_tree::ptree &pt);
void updateCallback(proxy::CpProxy& cp) override;
void updateCallback(proxy::CpProxy& cp);
/**
* Записать значение в "базу данных". Метку при этом вставлять не нужно, она будет вставлена автоматически.
* @param item
@ -69,7 +48,7 @@ namespace api_driver::obj {
// logs.clear();
// }
~StatisticsLogger() override;
~StatisticsLogger();
private:
// std::pmr::deque<LogItem> logs;
std::fstream logFile{};
@ -87,8 +66,8 @@ namespace api_driver::obj {
#error "Selected modem type not supported!"
#endif
#if API_OBJECT_NETWORK_SETTINGS_ENABLE
class TerminalNetworkSettings: public CpUpdatebleObject {
#ifdef API_OBJECT_NETWORK_SETTINGS_ENABLE
class TerminalNetworkSettings {
public:
std::string managementIp, managementGateway, dataIp, serverName;
bool isL2 = true;
@ -100,17 +79,17 @@ namespace api_driver::obj {
void loadDefaults();
void updateCallback(proxy::CpProxy& cp) override;
void updateCallback(proxy::CpProxy& cp);
void updateFromPt(boost::property_tree::ptree &pt);
void store(proxy::CpProxy& cp);
std::string asJson();
~TerminalNetworkSettings() override;
~TerminalNetworkSettings();
};
#endif
#if API_OBJECT_QOS_SETTINGS_ENABLE
class TerminalQosSettings: public CpUpdatebleObject {
#ifdef API_OBJECT_QOS_SETTINGS_ENABLE
class TerminalQosSettings {
public:
static constexpr const char* DEFAULT_QOS_CLASSES = R"({"rt1":[],"rt2":[],"rt3":[],"cd":[]})";
std::string qosSettingsJson;
@ -122,12 +101,12 @@ namespace api_driver::obj {
void loadDefaults();
void updateCallback(proxy::CpProxy& cp) override;
void updateCallback(proxy::CpProxy& cp);
void updateFromPt(boost::property_tree::ptree &pt);
void store(proxy::CpProxy& cp);
std::string asJson();
~TerminalQosSettings() override;
~TerminalQosSettings();
};
#endif
@ -154,7 +133,7 @@ namespace api_driver::obj {
/**
* Обертка состояния терминала, тут состояние девайса, модулятора/демодулятора, состояние автоматического обновления.
*/
class TerminalState: public CpUpdatebleObject {
class TerminalState {
public:
std::string fInitState{};
bool fIsTest = false; // daemon->isTest()
@ -163,62 +142,60 @@ namespace api_driver::obj {
bool fIsCinC = false;
#endif
bool fStatRxState;
bool fStatRxSymSyncLock;
bool fStatRxFreqSearchLock;
bool fStatRxAfcLock;
bool fStatRxPktSync;
bool fRxState;
bool fRxSymSyncLock;
bool fRxFreqSearchLock;
bool fRxAfcLock;
bool fRxPktSync;
float fStatRxSnr;
float fStatRxRssi;
uint16_t fStatRxModcod;
bool fStatRxFrameSizeNormal;
bool fStatRxIsPilots;
float fRxSnr;
float fRxRssi;
uint16_t fRxModcod;
bool fRxFrameSizeNormal;
bool fRxIsPilots;
double fStatRxSymError;
double fStatRxFreqErr;
double fStatRxFreqErrAcc;
double fStatRxInputSignalLevel;
double fStatRxPllError;
double fStatRxSpeedOnRxKbit;
double fStatRxSpeedOnIifKbit;
uint32_t fStatRxPacketsOk;
uint32_t fStatRxPacketsBad;
uint32_t fStatRxPacketsDummy;
double fRxSymError;
double fRxFreqErr;
double fRxFreqErrAcc;
double fRxInputSignalLevel;
double fRxPllError;
double fRxSpeedOnRxKbit;
double fRxSpeedOnIifKbit;
uint32_t fRxPacketsOk;
uint32_t fRxPacketsBad;
uint32_t fRxPacketsDummy;
bool fStatTxState;
uint16_t fStatTxModcod;
double fStatTxSpeedOnTxKbit;
double fStatTxSpeedOnIifKbit;
uint16_t fTxModcod;
double fTxSpeedOnTxKbit;
double fTxSpeedOnIifKbit;
#ifdef MODEM_IS_SCPC
float fStatTxSnr;
bool fStatTxFrameSizeNormal;
bool fStatTxIsPilots;
double fStatCincOcc;
bool fStatCincCorrelator;
uint32_t fStatCincCorrelatorFails;
int32_t fStatCincFreqErr;
int32_t fStatCincFreqErrAcc;
float fStatCincChannelDelay;
float fTxSnr;
bool fTxFrameSizeNormal;
bool fTxIsPilots;
double fCincOcc;
bool fCincCorrelator;
uint32_t fCincCorrelatorFails;
int32_t fCincFreqErr;
int32_t fCincFreqErrAcc;
float fCincChannelDelay;
#endif
#ifdef MODEM_IS_TDMA
fStatTxCenterFreq;
fStatTxSymSpeed;
TODO fTxCenterFreq;
TODO fTxSymSpeed;
#endif
TerminalState();
/**
* Обновление основной части статистики, то есть RX/TX и sysinfo
*/
void updateCallback(proxy::CpProxy& cp) override;
void updateCallback(proxy::CpProxy& cp);
nlohmann::json asJson();
void updateFromPt(boost::property_tree::ptree &pt);
void store(TSID sid, CP_Result& lastCpError);
std::string asJson();
~TerminalState() override;
~TerminalState();
};
class TerminalDeviceState: public CpUpdatebleObject {
class TerminalDeviceState {
public:
time_t fOsUptime{};
double fOsLoad1{};
@ -241,23 +218,23 @@ namespace api_driver::obj {
TerminalDeviceState(const TerminalDeviceState& src);
TerminalDeviceState& operator= (const TerminalDeviceState& src);
void updateCallback(proxy::CpProxy& cp) override;
std::string asJson() const;
void updateCallback(proxy::CpProxy& cp);
nlohmann::json asJson() const;
~TerminalDeviceState() override;
~TerminalDeviceState();
};
class TerminalRxTxSettings: public CpUpdatebleObject {
class TerminalRxTxSettings {
public:
// TODO описать все параметры для всех терминалов
void updateCallback(proxy::CpProxy& cp) override;
void updateCallback(proxy::CpProxy& cp);
void updateFromPt(boost::property_tree::ptree &pt);
void store(proxy::CpProxy& cp);
std::string asJson();
~TerminalRxTxSettings() override;
~TerminalRxTxSettings();
};
}

24765
src/common/nlohmann/json.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

30
src/main.cpp
View File

@ -21,6 +21,7 @@
#include "auth/resources.h"
#include "auth/jwt.h"
#include "auth/utils.h"
#include "common/nlohmann/json.hpp"
namespace ssl = boost::asio::ssl; // from <boost/asio/ssl.hpp>
@ -76,19 +77,19 @@ class ServerResources {
}
void doTerminalUpgrade() const {
api->executeInApi([](TSID sid) {
CP_SetDmaDebug(sid, "begin_save_config", "");
api->executeInApi([](api_driver::proxy::CpProxy& cp) {
cp.setDmaDebug("begin_save_config", "");
std::string cmd(UPGRADE_COMMAND);
cmd += " ";
cmd += FIRMWARE_LOCATION;
system(cmd.c_str());
CP_SetDmaDebug(sid, "save_config", "");
cp.setDmaDebug("begin_save_config", "");
});
}
#ifdef MODEM_IS_TDMA
void doTerminalUpgradeOta() const {
api->executeInApi([&](TSID sid) {
api->executeInApi([&](proxy::CpProxy&) {
CP_SetDmaDebug(sid, "begin_save_config", "");
std::string cmd(UPGRADE_COMMAND);
cmd += " ";
@ -222,11 +223,7 @@ public:
rep.status = http::server::ok;
rep.headers.push_back({.name = "Content-Type", .value = toString(mime_types::json)});
std::string result = R"({"mainState":)";
result += api->loadTerminalState();
result += R"(,"sysinfo":)";
result += api->loadSysInfo();
result += "}";
const auto result = api->loadTerminalState();
rep.content.insert(rep.content.end(), result.c_str(), result.c_str() + result.size());
}));
@ -494,17 +491,16 @@ public:
if (func == "SetDmaDebug") {
if (req.url->params.find("param") == req.url->params.end()) { http::server::stockReply(http::server::bad_request, rep); return; }
if (req.url->params.find("value") == req.url->params.end()) { http::server::stockReply(http::server::bad_request, rep); return; }
this->api->executeInApi([&](auto sid) {
CP_SetDmaDebug(sid, req.url->params["param"].c_str(), req.url->params["value"]);
this->api->executeInApi([&](auto& cp) {
cp.setDmaDebug(req.url->params["param"], req.url->params["value"]);
});
} else if (func == "GetDmaDebug") {
if (req.url->params.find("param") == req.url->params.end()) { http::server::stockReply(http::server::bad_request, rep); return; }
this->api->executeInApi([&](auto sid) {
std::string tmp{};
CP_GetDmaDebug(sid, req.url->params["param"].c_str(), &tmp);
result = R"({"status":"ok","result":)";
result += api_driver::buildEscapedString(tmp);
result += "}";
this->api->executeInApi([&](auto& cp) {
nlohmann::json tmp;
tmp["status"] = "ok";
tmp["result"] = cp.getDmaDebug(req.url->params["param"]);
result = tmp.dump();
});
} else {
http::server::stockReply(http::server::not_implemented, rep);

619
src/terminal_api_driver.cpp
View File

@ -1,7 +1,6 @@
#include "terminal_api_driver.h"
#include <cmath>
#include "terminal_api/ControlProtoCInterface.h"
#include <sstream>
#include <iomanip>
#include <shared_mutex>
@ -9,215 +8,11 @@
#include <boost/log/trivial.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <sys/sysinfo.h>
#define TIME_NOW() std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()).time_since_epoch().count()
#include "common/nlohmann/json.hpp"
#include "api-driver/daemon.h"
typedef boost::property_tree::ptree::path_type json_path;
// пороговое значение сна
static constexpr int64_t SLEEP_THRESHOLD = 10;
static inline void rtrim(std::string &s) {
s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) {
return !std::isspace(ch);
}).base(), s.end());
}
static inline const char* boolAsStr(bool value) {
return value ? "true" : "false";
}
class TerminalNetworkSettings {
public:
std::string managementIp, managementGateway, dataIp, serverName;
bool isL2 = true;
unsigned int dataMtu = 1500;
#ifdef MODEM_IS_SCPC
static constexpr const char* DEFAULT_SERVER_NAME = "RCSM-101";
#endif
#ifdef MODEM_IS_TDMA
static constexpr const char* DEFAULT_SERVER_NAME = "RCSM-101 TDMA";
#endif
TerminalNetworkSettings() = default;
TerminalNetworkSettings(const TerminalNetworkSettings& src) = default;
~TerminalNetworkSettings() = default;
TerminalNetworkSettings& operator= (const TerminalNetworkSettings& src) = default;
void loadDefaults() {
managementIp = "0.0.0.0";
managementGateway = "";
isL2 = true;
dataIp = "0.0.0.0";
dataMtu = 1500;
serverName = DEFAULT_SERVER_NAME;
}
};
class TerminalDeviceState {
public:
double adrv_temp{}, pl_temp{}, zynq_temp{};
#ifdef MODEM_IS_TDMA
DOWNLOAD_STATUS otaStatus{}; // Downloading Status
unsigned int otaPercent{}; // % downloaded data
std::string otaImage{}; // Name of downloading image file
#endif
modulator_state mod{};
demodulator_state demod{};
#ifdef MODEM_IS_SCPC
debug_metrics debug{};
CinC_state cinc{};
#endif
};
class TerminalFirmwareVersion {
public:
std::string version, modemId, modemSn, macMang, macData;
TerminalFirmwareVersion() = default;
TerminalFirmwareVersion(const TerminalFirmwareVersion& src) = default;
~TerminalFirmwareVersion() = default;
TerminalFirmwareVersion& operator= (const TerminalFirmwareVersion& src) = default;
};
static std::ostream& operator<<(std::ostream& out, CP_Result result) {
switch (result) {
case OK: out << "OK"; break;
case TIMEOUT: out << "TIMEOUT"; break;
case ERROR: out << "ERROR"; break;
case ABORT: out << "ABORT"; break;
case BUSY: out << "BUSY"; break;
default:
out << static_cast<int>(result);
}
return out;
}
std::string makeTimepointFromMillis(int64_t unix_time_ms) {
// Преобразуем миллисекунды в микросекунды для std::chrono
auto time_point = std::chrono::time_point<std::chrono::system_clock,
std::chrono::microseconds>(std::chrono::microseconds(unix_time_ms * 1000));
auto tp = std::chrono::system_clock::to_time_t(time_point);
tm* t = std::localtime(&tp);
std::stringstream ss;
ss << std::put_time(t, "%Y-%m-%d %H:%M:%S");
auto ms = (unix_time_ms % 1000);
ss << '.' << std::setw(3) << std::setfill('0') << ms;
return ss.str();
}
#ifdef MODEM_IS_SCPC
class api_driver::StatisticsLogger {
public:
StatisticsLogger(): timeStart(TIME_NOW()) {}
int64_t timeStart;
bool logEn = false;
std::atomic<int> logPeriodMs = 1000;
std::atomic<int> maxAgeMs = 10000;
/**
*
* @return {"en": bool, "logPeriodMs": int, ""}
*/
std::string getSettings() {
std::lock_guard _lock(mutex);
std::stringstream res;
res << "{\"en\":" << boolAsStr(this->logEn);
res << ",\"logPeriodMs\":" << logPeriodMs;
res << ",\"maxAgeMs\":" << maxAgeMs;
res << '}';
return res.str();
}
void setSettings(boost::property_tree::ptree &pt) {
const bool newEn = pt.get<bool>("en");
const int newInterval = pt.get<int>("logPeriodMs");
const int newMaxAgeMs = pt.get<int>("maxAgeMs");
std::lock_guard _lock(this->mutex);
this->logPeriodMs = newInterval;
this->maxAgeMs = newMaxAgeMs;
if (newEn != this->logEn) {
if (newEn) {
this->logFile.open("/tmp/weblog-statistics.csv", std::ios::out);
if (this->logFile.is_open()) {
const auto* header = "timestamp\tcnt ok\tcnt bad\tfine freq dem\tcrs freq dem\tcrs freq compensator\tcrs time est\tfine time est\tmax level corr\tcurrent delay\tSNR\tcurrent modcod\tfine freq compensator\tind freq grb\tind freq tochn\tind filt adapt\tfilter corr cinc\tcorr cnt\tRSS\tcor erl\tcor lat\tgc gain\tpower pl rx\n";
this->logFile.write(header, static_cast<std::streamsize>(strlen(header)));
this->logEn = true;
this->timeStart = TIME_NOW();
}
} else {
if (this->logFile.is_open()) {
this->logFile.close();
}
this->logEn = false;
}
}
}
/**
* Записать значение в "базу данных". Метку при этом вставлять не нужно, она будет вставлена автоматически.
* @param item
*/
void putItem(const debug_metrics& item) {
std::lock_guard _lock(this->mutex);
if (!logEn) return;
if (this->logFile.is_open()) {
std::stringstream res;
res << makeTimepointFromMillis(TIME_NOW()) << '\t';
res << item.cnt_ok << '\t';
res << item.cnt_bad << '\t';
res << item.fine_freq_dem << '\t';
res << item.crs_freq_dem << '\t';
res << item.crs_freq_compensator << '\t';
res << item.crs_time_est << '\t';
res << item.fine_time_est << '\t';
res << item.max_level_corr << '\t';
res << item.current_delay << '\t';
res << item.SNR << '\t';
res << item.current_modcod << '\t';
res << item.fine_freq_compensator << '\t';
res << item.ind_freq_grb << '\t';
res << item.ind_freq_tochn << '\t';
res << item.ind_filt_adapt << '\t';
res << item.filter_corr_cinc << '\t';
res << item.corr_cnt << '\t';
res << item.RSS << '\t';
res << item.cor_erl << '\t';
res << item.cor_lat << '\t';
res << item.gc_gain << '\t';
res << item.power_pl_rx << '\n';
const auto out = res.str();
this->logFile.write(out.c_str(), static_cast<std::streamsize>(out.length()));
this->logFile.flush();
}
}
// void collectExpiredItems();
// void resetLogs() {
// std::lock_guard _lock(mutex);
// logs.clear();
// }
~StatisticsLogger() = default;
private:
// std::pmr::deque<LogItem> logs;
std::fstream logFile{};
std::shared_mutex mutex;
};
#endif
api_driver::ApiDriver::ApiDriver() = default;
@ -241,18 +36,6 @@ std::string api_driver::buildEscapedString(const std::string& source) {
return "\"" + str.substr(start_pos, end_pos - start_pos + 1) + "\"";
}
static void writeDouble(std::ostream& out, double value, int prec = 2) {
if (std::isnan(value) || std::isinf(value)) {
out << "\"nan\"";
} else {
out << std::fixed << std::setprecision(prec) << value;
}
}
double translateCoordinates(uint8_t deg, uint8_t min) {
return static_cast<double>(deg) + static_cast<double>(min) / 60;
}
std::tuple<uint8_t, uint8_t> translateCoordinates(double abs) {
auto deg = static_cast<uint8_t>(abs);
double min_double = (abs - deg) * 60;
@ -265,126 +48,15 @@ std::string api_driver::ApiDriver::loadTerminalState() const {
if (daemon == nullptr) {
return R"({"error": "api daemon not started!"})";
}
std::stringstream result;
result << "{\n\"initState\":" << buildEscapedString(daemon->getDeviceInitState());
result << ",\n\"testState\":" << boolAsStr(daemon->isTest());
obj::TerminalState state;
daemon->getState(state);
obj::TerminalDeviceState devState;
daemon->getDeviceState(devState);
auto state = daemon->getState();
#ifdef MODEM_IS_SCPC
const bool isCinC = this->daemon->getIsCinC();
#endif
#ifdef MODEM_IS_SCPC
result << ",\"isCinC\":" << boolAsStr(isCinC);
#endif
// формируем структуру для TX
result << ",\n\"tx.state\":" << boolAsStr(state.mod.is_tx_on);
result << ",\"tx.modcod\":" << state.mod.modcod;
#ifdef MODEM_IS_SCPC
result << ",\"tx.snr\":"; writeDouble(result, state.mod.snr_remote);
if (state.mod.is_short) { result << R"(,"tx.frameSizeNormal":false)"; }
else { result << R"(,"tx.frameSizeNormal":true)"; }
if (state.mod.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>(state.mod.speed_in_bytes_tx) / 128.0);
result << ",\"tx.speedOnIifKbit\":"; writeDouble(result, (static_cast<double>(state.mod.speed_in_bytes_tx_iface) / 128.0));
// формируем структуру для RX
result << ",\n\"rx.state\":" << boolAsStr(state.demod.locks.sym_sync_lock && state.demod.locks.freq_lock && state.demod.locks.afc_lock && state.demod.locks.pkt_sync);
result << ",\"rx.sym_sync_lock\":" << boolAsStr(state.demod.locks.sym_sync_lock);
result << ",\"rx.freq_search_lock\":" << boolAsStr(state.demod.locks.freq_lock);
result << ",\"rx.afc_lock\":" << boolAsStr(state.demod.locks.afc_lock);
result << ",\"rx.pkt_sync\":" << boolAsStr(state.demod.locks.pkt_sync);
result << ",\"rx.snr\":"; writeDouble(result, state.demod.snr);
result << ",\"rx.rssi\":"; writeDouble(result, state.demod.rssi);
result << ",\"rx.modcod\":" << state.demod.modcod;
if (state.demod.is_short) {
result << R"(,"rx.frameSizeNormal":false)";
} else {
result << R"(,"rx.frameSizeNormal":true)";
}
if (state.demod.is_pilots) {
result << R"(,"rx.isPilots":true)";
} else {
result << R"(,"rx.isPilots":false)";
}
result << ",\n\"rx.symError\":"; writeDouble(result, state.demod.sym_err);
result << ",\"rx.freqErr\":"; writeDouble(result, state.demod.crs_freq_err);
result << ",\"rx.freqErrAcc\":"; writeDouble(result, state.demod.fine_freq_err);
result << ",\"rx.inputSignalLevel\":"; writeDouble(result, state.demod.if_overload);
result << ",\"rx.pllError\":"; writeDouble(result, state.demod.afc_err);
result << ",\"rx.speedOnRxKbit\":"; writeDouble(result, static_cast<double>(state.demod.speed_in_bytes_rx) / 128.0);
result << ",\"rx.speedOnIifKbit\":"; writeDouble(result, static_cast<double>(state.demod.speed_in_bytes_rx_iface) / 128.0);
result << ",\"rx.packetsOk\":" << state.demod.packet_ok_cnt;
result << ",\"rx.packetsBad\":" << state.demod.packet_bad_cnt;
result << ",\"rx.packetsDummy\":" << state.demod.dummy_cnt;
#ifdef MODEM_IS_SCPC
// формируем структуру для CinC
if (isCinC) {
if (state.mod.is_tx_on) {
if (state.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, state.cinc.ratio_signal_signal, 3);
result << ",\"cinc.correlatorFails\":" << state.cinc.cnt_bad_lock;
result << ",\"cinc.freqErr\":" << state.cinc.freq_error_offset;
result << ",\"cinc.freqErrAcc\":" << state.cinc.freq_fine_estimate;
result << ",\"cinc.channelDelay\":" << state.cinc.delay_dpdi;
} else {
result << R"(,"cinc.correlator":null)";
}
#endif
// структура температур девайса
result << ",\n\"device.adrv\":"; writeDouble(result, state.adrv_temp, 1);
result << ",\"device.fpga\":"; writeDouble(result, state.pl_temp, 1);
result << ",\"device.zynq\":"; writeDouble(result, state.zynq_temp, 1);
#ifdef MODEM_IS_TDMA
if (state.otaImage.empty()) {
result << R"(,
"device.upgradeStatus":"Нет обновлений","device.upgradePercent":0,"device.upgradeImage":"")";
} else {
switch (state.otaStatus) {
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\":" << state.otaPercent;
result << ",\"device.upgradeImage\":" << buildEscapedString(state.otaImage);
}
#endif
result << "}";
return result.str();
auto res = state.asJson();
res["device"] = devState.asJson();
return res.dump();
}
@ -450,118 +122,8 @@ std::string api_driver::ApiDriver::loadSettings() const {
return R"({"error": "api daemon not started!"})";
}
modulator_settings modSettings{};
demodulator_settings demodSettings{};
buc_lnb_settings bucLnb{};
TerminalNetworkSettings network;
DPDI_parmeters dpdiSettings{};
#ifdef MODEM_IS_SCPC
ACM_parameters_serv_ acmSettings{};
daemon->getSettings(&modSettings, &demodSettings, &acmSettings, &dpdiSettings, &bucLnb);
#else
daemon->getSettings(&modSettings, &demodSettings, &dpdiSettings, &bucLnb);
#endif
daemon->getNetworkSettings(network);
std::stringstream result;
result << "{\n\"txAutoStart\":" << boolAsStr(modSettings.is_save_current_state);
result << ",\"txEn\":" << boolAsStr(modSettings.tx_is_on);
#ifdef MODEM_IS_SCPC
result << ",\"txIsTestInput\":" << boolAsStr(modSettings.is_test_data);
#endif
result << ",\"txModulatorIsTest\":" << boolAsStr(!modSettings.is_carrier);
result << ",\"txCentralFreq\":"; writeDouble(result, modSettings.central_freq_in_kGz);
#ifdef MODEM_IS_SCPC
result << ",\"txBaudrate\":" << modSettings.baudrate;
result << ",\"txRolloff\":" << static_cast<int>(modSettings.rollof);
result << ",\"txGoldan\":" << static_cast<int>(modSettings.gold_seq_is_active);
#endif
result << ",\"txAttenuation\":"; writeDouble(result, modSettings.attenuation);
#ifdef MODEM_IS_SCPC
result << ",\n\"isCinC\":" << boolAsStr(modSettings.is_cinc);
result << ",\n\"dvbServicePacketPeriod\":" << acmSettings.period_pack_acm;
result << ",\"dvbIsAcm\":" << boolAsStr(acmSettings.enable_acm);
result << ",\"txFrameSizeNormal\":" << boolAsStr((modSettings.modcod_tx & 2) == 0);
result << ",\"txIsPilots\":" << boolAsStr((modSettings.modcod_tx & 1) != 0);
result << R"(,"dvbCcmModulation":")" << extractModcodModulation(modSettings.modcod_tx) << "\"";
result << R"(,"dvbCcmSpeed":")" << extractModcodSpeed(modSettings.modcod_tx) << "\"";
result << R"(,"dvbAcmMinModulation":")" << extractModcodModulation(acmSettings.min_modcod_acm) << "\"";
result << R"(,"dvbAcmMinSpeed":")" << extractModcodSpeed(acmSettings.min_modcod_acm) << "\"";
result << R"(,"dvbAcmMaxModulation":")" << extractModcodModulation(acmSettings.max_modcod_acm) << "\"";
result << R"(,"dvbAcmMaxSpeed":")" << extractModcodSpeed(acmSettings.max_modcod_acm) << "\"";
result << ",\"dvbSnrReserve\":"; writeDouble(result, acmSettings.snr_threashold_acm);
result << ",\n\"aupcEn\":" << boolAsStr(acmSettings.enable_aupc);
result << ",\"aupcMinAttenuation\":"; writeDouble(result, acmSettings.min_attenuation_aupc);
result << ",\"aupcMaxAttenuation\":"; writeDouble(result, acmSettings.max_attenuation_aupc);
result << ",\"aupcRequiredSnr\":"; writeDouble(result, acmSettings.snr_threashold_aupc);
#endif
result << ",\n\"dpdiIsPositional\":" << boolAsStr(!dpdiSettings.is_delay_window);
#ifdef MODEM_IS_SCPC
result << ",\"dpdiSearchBandwidth\":" << dpdiSettings.freq_offset; // полоса поиска в кГц
#endif
result << ",\"dpdiPositionStationLatitude\":"; writeDouble(result, translateCoordinates(dpdiSettings.latitude_station_grad, dpdiSettings.latitude_station_minute), 6);
result << ",\"dpdiPositionStationLongitude\":"; writeDouble(result, translateCoordinates(dpdiSettings.longitude_station_grad, dpdiSettings.longitude_station_minute), 6);
result << ",\"dpdiPositionSatelliteLongitude\":"; writeDouble(result, translateCoordinates(dpdiSettings.longitude_sattelite_grad, dpdiSettings.longitude_sattelite_minute), 6);
#ifdef MODEM_IS_SCPC
result << ",\"dpdiDelayMin\":" << dpdiSettings.min_delay;
result << ",\"dpdiDelayMax\":" << dpdiSettings.max_delay;
#else
result << ",\"dpdiDelay\":" << dpdiSettings.max_delay;
#endif
result << ",\n\"rxAgcEn\":" << boolAsStr(demodSettings.is_aru_on);
result << ",\"rxSpectrumInversion\":" << boolAsStr(demodSettings.is_rvt_iq);
result << ",\"rxManualGain\":"; writeDouble(result, demodSettings.gain);
result << ",\"rxCentralFreq\":"; writeDouble(result, demodSettings.central_freq_in_kGz);
result << ",\"rxBaudrate\":" << demodSettings.baudrate;
result << ",\"rxRolloff\":" << static_cast<int>(demodSettings.rollof);
#ifdef MODEM_IS_SCPC
result << ",\"rxGoldan\":" << static_cast<int>(demodSettings.gold_seq_is_active);
#endif
// BUC LNB
result << ",\n\"bucRefClk10M\":" << boolAsStr(bucLnb.is_ref_10MHz_buc);
switch (bucLnb.buc) {
case voltage_buc::_24V: result << ",\"bucPowering\":24"; break;
#ifdef MODEM_IS_SCPC
case voltage_buc::_48V: result << ",\"bucPowering\":48"; break;
#endif
case voltage_buc::DISABLE:
default: result << ",\"bucPowering\":0";
}
result << ",\"lnbRefClk10M\":" << boolAsStr(bucLnb.is_ref_10MHz_lnb);
switch (bucLnb.lnb) {
case voltage_lnb::_13V: result << ",\"lnbPowering\":13"; break;
case voltage_lnb::_18V: result << ",\"lnbPowering\":18"; break;
case voltage_lnb::_24V: result << ",\"lnbPowering\":24"; break;
case voltage_lnb::DISABLE:
default: result << ",\"lnbPowering\":0";
}
result << ",\"srvRefClk10M\":" << boolAsStr(bucLnb.is_ref_10MHz_output);
result << ",\"bucLnbAutoStart\":" << boolAsStr(bucLnb.is_save_current_state);
// QoS
bool qosEnabled = false; std::string qosClasses;
daemon->getQosSettings(qosEnabled, qosClasses);
result << ",\n\"qosEnabled\":" << boolAsStr(qosEnabled);
result << ",\"qosProfile\":" << qosClasses;
// сеть
result << "\n,\"netManagementIp\":" << buildEscapedString(network.managementIp);
result << ",\"netIsL2\":" << boolAsStr(network.isL2);
result << ",\"netManagementGateway\":" << buildEscapedString(network.managementGateway);
result << ",\"netDataIp\":" << buildEscapedString(network.dataIp);
result << ",\"netDataMtu\":" << network.dataMtu;
result << ",\"netServerName\":" << buildEscapedString(network.serverName);
result << "}";
return result.str();
// TODO сделать получение настроек
return "{}";
}
std::string api_driver::ApiDriver::loadFirmwareVersion() const {
@ -601,178 +163,33 @@ static uint32_t buildModcodFromPt(const boost::property_tree::ptree& pt, const s
#endif
void api_driver::ApiDriver::setRxTxSettings(boost::property_tree::ptree &pt) {
modulator_settings mod{};
demodulator_settings demod{};
#ifdef MODEM_IS_SCPC
ACM_parameters_serv_ acm{};
daemon->getSettings(&mod, &demod, &acm, nullptr, nullptr);
#else
daemon->getSettings(&mod, &demod, nullptr, nullptr);
#endif
// для модулятора
#ifdef MODEM_IS_SCPC
mod.is_cinc = pt.get<bool>("isCinC");
#endif
mod.tx_is_on = pt.get<bool>("txEn");
#ifdef MODEM_IS_SCPC
mod.is_save_current_state = pt.get<bool>("txAutoStart");
mod.is_test_data = pt.get<bool>("txIsTestInput");
#endif
mod.is_carrier = !pt.get<bool>("txModulatorIsTest");
mod.central_freq_in_kGz = pt.get<double>("txCentralFreq");
#ifdef MODEM_IS_SCPC
mod.baudrate = pt.get<uint32_t>("txBaudrate");
mod.rollof = pt.get<unsigned int>("txRolloff");
mod.gold_seq_is_active = pt.get<unsigned int>("txGoldan");
#endif
mod.attenuation = pt.get<double>("txAttenuation");
#ifdef MODEM_IS_SCPC
const bool acmIsShortFrame = !pt.get<bool>("txFrameSizeNormal");
const bool acmIsPilots = pt.get<bool>("txIsPilots");
mod.modcod_tx = buildModcodFromPt(pt, "dvbCcm", acmIsShortFrame, acmIsPilots);
#endif
// демодулятор
demod.is_aru_on = pt.get<bool>("rxAgcEn");
demod.gain = pt.get<double>("rxManualGain");
demod.is_rvt_iq = pt.get<bool>("rxSpectrumInversion");
demod.central_freq_in_kGz = pt.get<double>("rxCentralFreq");
demod.baudrate = pt.get<uint32_t>("rxBaudrate");
demod.rollof = pt.get<unsigned int>("rxRolloff");
#ifdef MODEM_IS_SCPC
demod.gold_seq_is_active = pt.get<unsigned int>("rxGoldan");
#endif
#ifdef MODEM_IS_SCPC
// ACM
acm.period_pack_acm = pt.get<uint32_t>("dvbServicePacketPeriod");
acm.enable_acm = pt.get<bool>("dvbIsAcm");
#ifdef MODEM_IS_SCPC
acm.min_modcod_acm = buildModcodFromPt(pt, "dvbAcmMin", acmIsShortFrame, acmIsPilots);
acm.max_modcod_acm = buildModcodFromPt(pt, "dvbAcmMax", acmIsShortFrame, acmIsPilots);
#else
acm.min_modcod_acm = buildModcodFromPt(pt, "dvbAcmMin", acmIsShortFrame);
acm.max_modcod_acm = buildModcodFromPt(pt, "dvbAcmMax", acmIsShortFrame);
#endif
acm.snr_threashold_acm = pt.get<double>("dvbSnrReserve"); // запас ОСШ
acm.enable_aupc = pt.get<bool>(json_path("aupcEn", '/'));
acm.min_attenuation_aupc = pt.get<int>("aupcMinAttenuation");
acm.max_attenuation_aupc = pt.get<int>("aupcMaxAttenuation");
acm.snr_threashold_aupc= pt.get<double>("aupcRequiredSnr");
daemon->setSettingsRxTx(mod, demod, acm);
#else
daemon->setSettingsRxTx(mod, demod);
#endif
// TODO
}
void api_driver::ApiDriver::setDpdiSettings(boost::property_tree::ptree &pt) {
DPDI_parmeters s{};
#ifdef MODEM_IS_SCPC
this->daemon->getSettings(nullptr, nullptr, nullptr, &s, nullptr);
#else
this->daemon->getSettings(nullptr, nullptr, &s, nullptr);
#endif
s.is_delay_window = !pt.get<bool>("dpdiIsPositional");
#ifdef MODEM_IS_SCPC
s.freq_offset = pt.get<uint32_t>("dpdiSearchBandwidth");
#endif
auto ctmp = translateCoordinates(pt.get<double>("dpdiPositionStationLatitude"));
s.latitude_station_grad = std::get<0>(ctmp);
s.latitude_station_minute = std::get<1>(ctmp);
ctmp = translateCoordinates(pt.get<double>("dpdiPositionStationLongitude"));
s.longitude_station_grad = std::get<0>(ctmp);
s.longitude_station_minute = std::get<1>(ctmp);
ctmp = translateCoordinates(pt.get<double>("dpdiPositionSatelliteLongitude"));
s.longitude_sattelite_grad = std::get<0>(ctmp);
s.longitude_sattelite_minute = std::get<1>(ctmp);
#ifdef MODEM_IS_SCPC
s.min_delay = pt.get<uint32_t>("dpdiDelayMin");
s.max_delay = pt.get<uint32_t>("dpdiDelayMax");
#else
s.min_delay = 0;
s.max_delay = pt.get<uint32_t>("dpdiDelay");
#endif
this->daemon->setSettingsDpdi(s);
// TODO
}
void api_driver::ApiDriver::setBucLnbSettings(boost::property_tree::ptree &pt) {
buc_lnb_settings s{};
#ifdef MODEM_IS_SCPC
daemon->getSettings(nullptr, nullptr, nullptr, nullptr, &s);
#else
daemon->getSettings(nullptr, nullptr, nullptr, &s);
#endif
auto tmp = pt.get<int>("bucPowering");
switch (tmp) {
case 24: s.buc = voltage_buc::_24V; break;
#ifdef MODEM_IS_SCPC
case 48: s.buc = voltage_buc::_48V; break;
#endif
case 0:
default:
s.buc = voltage_buc::DISABLE;
}
s.is_ref_10MHz_buc = pt.get<bool>("bucRefClk10M");
tmp = pt.get<int>("lnbPowering");
switch (tmp) {
case 13: s.lnb = voltage_lnb::_13V; break;
case 18: s.lnb = voltage_lnb::_18V; break;
case 24: s.lnb = voltage_lnb::_24V; break;
case 0:
default:
s.lnb = voltage_lnb::DISABLE;
}
s.is_ref_10MHz_lnb = pt.get<bool>("lnbRefClk10M");
s.is_ref_10MHz_output = pt.get<bool>("srvRefClk10M");
s.is_save_current_state = pt.get<bool>("bucLnbAutoStart");
this->daemon->setSettingsBucLnb(s);
// TODO
}
void api_driver::ApiDriver::setQosSettings(boost::property_tree::ptree &pt) {
bool enabled = pt.get<bool>("en");
pt.erase("en");
std::ostringstream oss;
write_json(oss, pt);
this->daemon->setQosSettings(enabled, oss.str());
// TODO
}
void api_driver::ApiDriver::setNetworkSettings(boost::property_tree::ptree &pt) {
TerminalNetworkSettings s;
daemon->getNetworkSettings(s);
s.managementIp = pt.get<std::string>("netManagementIp");
// s.managementGateway = pt.get<std::string>(json_path("network.managementGateway", '/'));
s.isL2 = pt.get<bool>("netIsL2");
s.dataIp = pt.get<std::string>("netDataIp");
s.dataMtu = pt.get<unsigned int>("netDataMtu");
s.serverName = pt.get<std::string>("netServerName");
daemon->setNetworkSettings(s);
// TODO
}
void api_driver::ApiDriver::resetDefaultSettings() {
daemon->resetDefaultSettings();
}
void api_driver::ApiDriver::executeInApi(const std::function<void(TSID sid)>& callback) {
void api_driver::ApiDriver::executeInApi(const std::function<void(proxy::CpProxy&)>& callback) {
try {
std::lock_guard lock(this->daemon->cpApiMutex);
callback(this->daemon->sid);
callback(this->daemon->cp);
} catch (std::exception& e) {
BOOST_LOG_TRIVIAL(error) << "ApiDriver::executeInApi(): failed to exec with error: " << e.what();
}

19
src/terminal_api_driver.h
View File

@ -1,10 +1,11 @@
#ifndef TERMINAL_API_DRIVER_H
#define TERMINAL_API_DRIVER_H
#include "api-driver/stricts-enable.h"
#include "api-driver/proxy.h"
#include <memory>
#include <string>
#include <boost/property_tree/ptree.hpp>
#include <terminal_api/ControlProtoCInterface.h>
namespace api_driver {
@ -13,7 +14,6 @@ namespace api_driver {
constexpr int CACHE_SETTINGS_UPDATE_MS = 5000;
constexpr int CACHE_QOS_UPDATE_MS = 5000;
class StatisticsLogger;
class TerminalApiDaemon;
/**
@ -48,30 +48,37 @@ namespace api_driver {
*/
void setRxTxSettings(boost::property_tree::ptree &pt);
#ifdef API_OBJECT_DPDI_SETTINGS_ENABLE
/**
* Установить настройки DPDI, readback можно получить используя loadTerminalState.
* @note Для TDMA и SCPC модемов эти настройки доступны
*/
void setDpdiSettings(boost::property_tree::ptree &pt);
#endif
#ifdef API_OBJECT_BUCLNB_SETTINGS_ENABLE
/**
* Установить настройки BUC и LNB, readback можно получить используя loadTerminalState.
*/
void setBucLnbSettings(boost::property_tree::ptree &pt);
#endif
#ifdef API_OBJECT_QOS_SETTINGS_ENABLE
/**
* Установить настройки QoS, readback можно получить используя loadTerminalState.
*/
void setQosSettings(boost::property_tree::ptree &pt);
#endif
#ifdef API_OBJECT_NETWORK_SETTINGS_ENABLE
void setNetworkSettings(boost::property_tree::ptree &pt);
#endif
void resetDefaultSettings();
void executeInApi(const std::function<void(TSID sid)> &callback);
void executeInApi(const std::function<void(proxy::CpProxy&)> &callback);
#ifdef MODEM_IS_SCPC
#ifdef API_OBJECT_DEBUG_METRICS_ENABLE
std::string getLoggingStatisticsSettings();
void setLoggingStatisticsSettings(boost::property_tree::ptree &pt);
@ -90,8 +97,6 @@ namespace api_driver {
std::string getOtaFileLocation() const;
#endif
static std::string loadSysInfo();
~ApiDriver();
private: