переход на получение статистики устройства новым API библиотеки control_system_client

dependencies/control_system/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.20)
 
-project(terminal-client-api)
+project(terminal)
 
 set(CMAKE_CXX_STANDARD 17)
 

dependencies/control_system/client/main.cpp

@@ -1,11 +1,175 @@
 #include <shared_mutex>
-#include "terminal_api/ControlProtoCInterface.h"
+#include <terminal_api/ControlProtoCInterface.h>
 #include "system_client.h"
 
 std::shared_mutex mtx;
 TSID sid_counter { 0 };
 std::map<TSID, std::unique_ptr<system_client>> clients;
 
+EXTERNC CP_Result CP_SetModulatorSettings(TSID sid, modulator_settings& settings){
+    std::shared_lock lock(mtx);
+    try
+    {
+        if (clients.find(sid) == clients.end())
+                return ERROR;
+        auto settings_ = reinterpret_cast<modulator_settings_com&>(settings);
+        auto resp = clients[sid]->send_set_modulator_settings(settings_);
+        if (resp == response_type::error)
+            return ERROR;
+        return OK;
+    }
+
+    catch(const std::exception& e)
+    {
+        return ERROR;
+    }
+}
+EXTERNC CP_Result CP_SetDemodulatorSettings(TSID sid, demodulator_settings& settings){
+    std::shared_lock lock(mtx);
+    try
+    {
+        if (clients.find(sid) == clients.end())
+                return ERROR;
+        auto settings_ = reinterpret_cast<demodulator_settings_com&>(settings);
+        auto resp = clients[sid]->send_set_demodulator_settings(settings_);
+        if (resp == response_type::error)
+            return ERROR;
+        return OK;
+    }
+
+    catch(const std::exception& e)
+    {
+        return ERROR;
+    }
+}
+EXTERNC CP_Result CP_GetModulatorSettings(TSID sid, modulator_settings& settings){
+    std::shared_lock lock(mtx);
+    try
+    {
+        if (clients.find(sid) == clients.end())
+                return ERROR;
+
+        modulator_settings_com settings_com;
+        auto resp = clients[sid]->send_get_modulator_settings(settings_com);
+        if (resp == response_type::error)
+            return ERROR;
+        settings = reinterpret_cast<modulator_settings&>(settings_com);
+        return OK;
+    }
+
+    catch(const std::exception& e)
+    {
+        return ERROR;
+    }
+}
+EXTERNC CP_Result CP_GetDemodulatorSettings(TSID sid, demodulator_settings& settings){
+    std::shared_lock lock(mtx);
+    try
+    {
+        if (clients.find(sid) == clients.end())
+                return ERROR;
+        demodulator_settings_com settings_com;
+        auto resp = clients[sid]->send_get_demodulator_settings(settings_com);
+        if (resp == response_type::error)
+            return ERROR;
+        std::cout << "settings_com.rollof: " << settings_com.rollof << std::endl;
+        std::cout << "settings_com.gain: " << settings_com.gain << std::endl;
+        settings = reinterpret_cast<demodulator_settings&>(settings_com);
+        return OK;
+    }
+
+    catch(const std::exception& e)
+    {
+        return ERROR;
+    }
+}
+
+EXTERNC CP_Result CP_GetDemodulatorState(TSID sid, demodulator_state &state){
+    std::shared_lock lock(mtx);
+    try
+    {
+        if (clients.find(sid) == clients.end())
+                return ERROR;
+        demodulator_state_com state_com;
+        auto resp = clients[sid]->send_get_demodulator_state(state_com);
+         
+        if (resp == response_type::error)
+        {
+            std::cout << "error" << std::endl;
+            return ERROR;
+        }
+        state = reinterpret_cast<demodulator_state&>(state_com);
+        state.locks = reinterpret_cast<demodulator_locks&>(state_com.locks);
+        return OK;
+    }
+
+    catch(const std::exception& e)
+    {
+        return ERROR;
+    }
+    
+}
+EXTERNC CP_Result CP_GetModulatorState(TSID sid, modulator_state &state){
+    std::shared_lock lock(mtx);
+    try
+    {
+        if (clients.find(sid) == clients.end())
+                return ERROR;
+        modulator_state_com state_com;
+        auto resp = clients[sid]->send_get_modulator_state(state_com);
+        if (resp == response_type::error)
+            return ERROR;
+        state = reinterpret_cast<modulator_state&>(state_com);
+        return OK;
+    }
+
+    catch(const std::exception& e)
+    {
+        return ERROR;
+    }
+}
+
+EXTERNC CP_Result CP_GetCinCState(TSID sid, CinC_state &state){
+    std::shared_lock lock(mtx);
+    try
+    {
+        if (clients.find(sid) == clients.end())
+                return ERROR;
+        CinC_state_com state_com;
+        auto resp = clients[sid]->send_get_cinc_state(state_com);
+        if (resp == response_type::error)
+            return ERROR;
+        state = reinterpret_cast<CinC_state&>(state_com);
+        return OK;
+    }
+
+    catch(const std::exception& e)
+    {
+        return ERROR;
+    }
+}
+
+EXTERNC CP_Result CP_GetDeviceState(TSID sid, device_state &state){
+
+    std::shared_lock lock(mtx);
+    try
+    {
+        if (clients.find(sid) == clients.end())
+                return ERROR;
+        device_state_com state_com;
+        auto resp = clients[sid]->send_get_device_state(state_com);
+        if (resp == response_type::error)
+            return ERROR;
+        state = reinterpret_cast<device_state&>(state_com);
+        return OK;
+    }
+
+    catch(const std::exception& e)
+    {
+        return ERROR;
+    }
+}
+
 EXTERNC CP_Result CP_SetRollofBaudrate(TSID sid, double rollof, double baudrate)
 {
     std::shared_lock lock(mtx);
@@ -285,6 +449,16 @@ EXTERNC CP_Result CP_GetNetwork(TSID sid, const char *param_name, std::string *v
             net_val = network_value::mac_eth1;
         else if(cmd == "name_serv")
             net_val = network_value::name_serv;
+        else if(cmd == "network_debug_send")
+            net_val = network_value::network_debug_send;
+        else if(cmd == "network_port_metric")
+            net_val = network_value::network_port_metric;
+        else if(cmd == "network_port_data")
+            net_val = network_value::network_port_data;
+        else if(cmd == "if_debug_mode")
+            net_val = network_value::if_debug_mode;
+        else if(cmd == "periodic_send_metrics")
+            net_val = network_value::periodic_send_metrics;
 
         auto resp = clients[sid]->send_get_network_settings(net_val, val_from_server);
         if (resp == response_type::error)

dependencies/control_system/client/sock_client.cpp

@@ -29,8 +29,8 @@ void client::start()
     seq_packet::seqpacket_protocol::socket::message_flags in_flags { MSG_WAITALL };
     socket_.async_receive(boost::asio::buffer(data_), in_flags,
                           std::bind(&client::handle_read, this,
-                                    std::placeholders::_1,
+                          std::placeholders::_1,
-                                    std::placeholders::_2));
+                          std::placeholders::_2));
 }
 
 void client::handle_connect(const boost::system::error_code & error)

dependencies/control_system/client/system_client.cpp

@@ -315,6 +315,72 @@ void system_client::data_received(const std::vector<uint8_t> & data)
             break;
         }
 
+        case cmd_type::get_demodulator_state:
+        {
+            if(cmd.rsp == response_type::ok)
+            {
+                cmd_get_demodulator_state value;
+                iarchive(value);
+                data_from_serv = value;
+            }
+            break;
+        }
+
+        case cmd_type::get_modulator_state:
+        {
+            if(cmd.rsp == response_type::ok)
+            {
+                cmd_get_modulator_state value;
+                iarchive(value);
+                data_from_serv = value;
+            }
+            break;
+        }
+
+        case cmd_type::get_demodulator_settings:
+        {
+            if(cmd.rsp == response_type::ok)
+            {
+                cmd_demodulator_settings value;
+                iarchive(value);
+                data_from_serv = value;
+            }
+            break;
+        }
+
+        case cmd_type::get_modulator_settings:
+        {
+            if(cmd.rsp == response_type::ok)
+            {
+                cmd_modulator_settings value;
+                iarchive(value);
+                data_from_serv = value;
+            }
+            break;
+        }
+
+        case cmd_type::get_device_state:
+        {
+            if(cmd.rsp == response_type::ok)
+            {
+                cmd_get_device_state value;
+                iarchive(value);
+                data_from_serv = value;
+            }
+            break;
+        }
+
+        case cmd_type::get_cinc_state:
+        {
+            if(cmd.rsp == response_type::ok)
+            {
+                cmd_get_cinc_state value;
+                iarchive(value);
+                data_from_serv = value;
+            }
+            break;
+        }
+
         case cmd_type::get_dma_debugg:
         {
             if (cmd.rsp == response_type::ok)
@@ -677,6 +743,136 @@ response_type system_client::send_set_lbq_params(const uint32_t & tick_ms, const
     return result;
 }
 
+response_type system_client::send_set_modulator_settings(modulator_settings_com &settings)
+{
+    std::scoped_lock lock(cmd_in_progress_mtx);
+    uint32_t curr_id { ++cmd_id };
+    cmd_header cmd_acm_header{curr_id, cmd_type::set_modulator_settings};
+
+    cmd_modulator_settings settings_;
+    settings_.modulator_settings = settings;
+    send_to_socket(cmd_acm_header, settings_);
+
+    std::any data_to_serv;
+
+    auto result = wait_for_response(curr_id, cmd_type::set_modulator_settings, data_to_serv);
+
+    return result;
+}
+
+response_type system_client::send_set_demodulator_settings(demodulator_settings_com &settings)
+{
+    std::scoped_lock lock(cmd_in_progress_mtx);
+    uint32_t curr_id { ++cmd_id };
+    cmd_header cmd_acm_header{curr_id, cmd_type::set_demodulator_settings};
+
+    cmd_demodulator_settings settings_;
+    settings_.demodulator_settings = settings;
+    send_to_socket(cmd_acm_header, settings_);
+
+    std::any data_to_serv;
+
+    auto result = wait_for_response(curr_id, cmd_type::set_demodulator_settings, data_to_serv);
+
+    return result;
+
+}
+
+response_type system_client::send_get_modulator_settings(modulator_settings_com &settings)
+{
+    std::scoped_lock lock(cmd_in_progress_mtx);
+    uint32_t curr_id { ++cmd_id };
+    cmd_header cmd_dpdi_header{curr_id, cmd_type::get_modulator_settings};
+    cmd_modulator_settings modulator;
+    send_to_socket(cmd_dpdi_header, modulator);
+
+    std::any data_from_serv;
+
+    auto result = wait_for_response(curr_id, cmd_type::get_modulator_settings, data_from_serv);
+    if (data_from_serv.has_value())
+        settings = std::any_cast<cmd_modulator_settings>(data_from_serv).modulator_settings;
+    return result;
+}
+
+response_type system_client::send_get_demodulator_settings(demodulator_settings_com &settings)
+{
+    std::scoped_lock lock(cmd_in_progress_mtx);
+    uint32_t curr_id { ++cmd_id };
+    cmd_header cmd_dpdi_header{curr_id, cmd_type::get_demodulator_settings};
+    cmd_demodulator_settings demodulator;
+    send_to_socket(cmd_dpdi_header, demodulator);
+    std::cout << "END GET_DEMODULATOR SETTINGS SEND TO SOCKET" << std::endl;
+    std::any data_from_serv;
+
+    auto result = wait_for_response(curr_id, cmd_type::get_demodulator_settings, data_from_serv);
+    if (data_from_serv.has_value())
+        settings = std::any_cast<cmd_demodulator_settings>(data_from_serv).demodulator_settings;
+    return result;
+}
+
+response_type system_client::send_get_demodulator_state(demodulator_state_com &demodulator_state){
+    std::scoped_lock lock(cmd_in_progress_mtx);
+    uint32_t curr_id { ++cmd_id };
+    cmd_header cmd_dpdi_header{curr_id, cmd_type::get_demodulator_state};
+    cmd_get_demodulator_state demodulator;
+    send_to_socket(cmd_dpdi_header, demodulator);
+
+    std::any data_from_serv;
+
+    auto result = wait_for_response(curr_id, cmd_type::get_demodulator_state, data_from_serv);
+    if (data_from_serv.has_value())
+        demodulator_state = std::any_cast<cmd_get_demodulator_state>(data_from_serv).demodulator_state;
+    return result;
+}
+
+response_type system_client::send_get_modulator_state(modulator_state_com &modulator_state){
+    std::scoped_lock lock(cmd_in_progress_mtx);
+    uint32_t curr_id { ++cmd_id };
+    cmd_header cmd_dpdi_header{curr_id, cmd_type::get_modulator_state};
+    cmd_get_modulator_state modulator;
+    send_to_socket(cmd_dpdi_header, modulator);
+
+    std::any data_from_serv;
+
+    auto result = wait_for_response(curr_id, cmd_type::get_modulator_state, data_from_serv);
+    if (data_from_serv.has_value())
+        modulator_state = std::any_cast<cmd_get_modulator_state>(data_from_serv).modulator_state;
+
+    return result;
+}
+
+response_type system_client::send_get_device_state(device_state_com &device_state ){
+    std::scoped_lock lock(cmd_in_progress_mtx);
+    uint32_t curr_id { ++cmd_id };
+    cmd_header cmd_dpdi_header{curr_id, cmd_type::get_device_state};
+    cmd_get_device_state device;
+    send_to_socket(cmd_dpdi_header, device);
+
+    std::any data_from_serv;
+
+    auto result = wait_for_response(curr_id, cmd_type::get_device_state, data_from_serv);
+    if (data_from_serv.has_value())
+        device_state = std::any_cast<cmd_get_device_state>(data_from_serv).device_state;
+
+    return result;
+}
+
+response_type system_client::send_get_cinc_state(CinC_state_com &cinc_state){
+    std::scoped_lock lock(cmd_in_progress_mtx);
+    uint32_t curr_id { ++cmd_id };
+    cmd_header cmd_dpdi_header{curr_id, cmd_type::get_cinc_state};
+
+    cmd_get_cinc_state cinc;
+    send_to_socket(cmd_dpdi_header, cinc);
+    std::any data_from_serv;
+
+    auto result = wait_for_response(curr_id, cmd_type::get_cinc_state, data_from_serv);
+    if (data_from_serv.has_value())
+        cinc_state = std::any_cast<cmd_get_cinc_state>(data_from_serv).cinc_state;
+    return result;
+
+}
+
 response_type system_client::send_set_acm_params(const ACM_parameters_serv &acm_params)
 {
     std::scoped_lock lock(cmd_in_progress_mtx);

dependencies/control_system/client/system_client.h

@@ -48,6 +48,18 @@ public:
     response_type send_set_acm_params(const ACM_parameters_serv &acm_params);
     response_type send_get_acm_params(cmd_get_acm_param &acm_params);
 
+    response_type send_get_demodulator_state(demodulator_state_com &demodulator_state);
+    response_type send_get_modulator_state(modulator_state_com &modulator_state);
+
+    response_type send_get_device_state(device_state_com &device_state);
+    response_type send_get_cinc_state(CinC_state_com &cinc_state);
+
+    response_type send_set_modulator_settings(modulator_settings_com &settings);
+    response_type send_set_demodulator_settings(demodulator_settings_com &settings);
+    response_type send_get_modulator_settings(modulator_settings_com &settings);
+    response_type send_get_demodulator_settings(demodulator_settings_com &settings);
+
+
     response_type send_set_dpdi_params(dpdi_parameters &dpdi_params);
     response_type send_get_dpdi_params(dpdi_parameters &dpdi_params);
 

dependencies/control_system/common/protocol_commands.h

@@ -47,6 +47,79 @@ enum class cmd_dma_debugg
     begin_save_config = 17
 };
 
+struct modulator_settings_com{
+    uint32_t baudrate;
+    double central_freq_in_kGz;
+    double rollof;
+    double attenuation;
+    bool is_test_data;
+    bool is_save_current_state;
+    bool is_carrier;
+    bool tx_is_on;
+    bool is_cinc;
+};
+
+struct modulator_state_com{
+    bool is_tx_on;
+    float snr_remote;
+    uint16_t modcod;
+    bool is_short;
+    bool is_pilots;
+    uint32_t speed_in_bytes_tx;
+    uint32_t speed_in_bytes_tx_iface;
+};
+
+struct demodulator_locks_com{
+    bool pkt_sync;
+    bool afc_lock;
+    bool freq_lock;
+    bool sym_sync_lock;
+};
+
+struct demodulator_settings_com
+{
+    uint32_t baudrate;
+    double central_freq_in_kGz;
+    double rollof;
+    bool is_aru_on;
+    bool is_rvt_iq; 
+    double gain;
+};
+
+struct demodulator_state_com{
+    float snr;
+    uint16_t modcod;
+    bool is_short;
+    bool is_pilots;
+    float rssi;
+    double afc_err;
+    double crs_freq_err;
+    double sym_err;
+    double fine_freq_err;
+    double if_overload;
+    uint32_t packet_ok_cnt;
+    uint32_t packet_bad_cnt;;
+    uint32_t dummy_cnt;
+    uint32_t speed_in_bytes_rx;
+    uint32_t speed_in_bytes_rx_iface;
+    demodulator_locks_com locks;
+};
+
+struct CinC_state_com{
+    float ratio_signal_signal;
+    bool carrier_lock;
+    int32_t freq_error_offset;
+    uint32_t delay_dpdi;
+    int32_t freq_fine_estimate;
+    uint32_t cnt_bad_lock;
+};
+
+struct device_state_com{
+    double adrv_temp;
+    double zynq_temp;
+    double pl_temp;    
+};
+
 enum class name_classes_qos
 {
     realtime1 = 0,
@@ -292,7 +365,15 @@ enum class cmd_type
     get_network = 27,
     set_qos_settings = 28,
     get_qos_settings = 29,
-    set_lbq_params = 30
+    set_lbq_params = 30,
+    get_demodulator_state = 31,
+    get_modulator_state = 32,
+    get_cinc_state = 33,
+    get_device_state = 34,
+    set_modulator_settings = 35,
+    set_demodulator_settings = 36,
+    get_modulator_settings = 37,
+    get_demodulator_settings = 38
 };
 
 struct cmd_lbq_params
@@ -306,6 +387,82 @@ struct cmd_lbq_params
     }
 };
 
+struct cmd_get_cinc_state
+{
+    CinC_state_com cinc_state;
+    template<class Archive>
+    void serialize(Archive & archive)
+    {
+        archive(cinc_state.carrier_lock, cinc_state.cnt_bad_lock, 
+                cinc_state.delay_dpdi, cinc_state.freq_error_offset, 
+                cinc_state.freq_fine_estimate,
+                cinc_state.ratio_signal_signal);
+    }
+};
+
+struct cmd_get_device_state
+{
+    device_state_com device_state;
+    template<class Archive>
+    void serialize(Archive & archive)
+    {
+        archive(device_state.adrv_temp, device_state.pl_temp, device_state.zynq_temp);
+    }
+};
+
+struct cmd_demodulator_settings
+{
+    demodulator_settings_com demodulator_settings;
+
+    template<class Archive>
+    void serialize(Archive & archive)
+    {
+        archive(demodulator_settings.baudrate,demodulator_settings.central_freq_in_kGz,
+                demodulator_settings.gain, demodulator_settings.is_aru_on,
+                demodulator_settings.is_rvt_iq, demodulator_settings.rollof);
+    }
+};
+
+struct cmd_get_demodulator_state
+{
+    demodulator_state_com demodulator_state;
+    template<class Archive>
+    void serialize(Archive & archive)
+    {
+        archive(demodulator_state.snr, demodulator_state.modcod, demodulator_state.is_short, demodulator_state.is_pilots, 
+        demodulator_state.rssi, demodulator_state.afc_err, demodulator_state.crs_freq_err,
+        demodulator_state.sym_err, demodulator_state.fine_freq_err, demodulator_state.if_overload, 
+        demodulator_state.packet_ok_cnt, demodulator_state.packet_bad_cnt, demodulator_state.dummy_cnt,
+        demodulator_state.speed_in_bytes_rx, demodulator_state.speed_in_bytes_rx_iface,
+        demodulator_state.locks.afc_lock, demodulator_state.locks.freq_lock, demodulator_state.locks.pkt_sync, demodulator_state.locks.sym_sync_lock );
+    }
+};
+
+struct cmd_modulator_settings
+{
+    modulator_settings_com modulator_settings;
+
+    template<class Archive>
+    void serialize(Archive & archive)
+    {
+        archive(modulator_settings.attenuation,modulator_settings.baudrate, modulator_settings.central_freq_in_kGz,
+                modulator_settings.is_carrier, modulator_settings.is_cinc,
+                modulator_settings.is_save_current_state, modulator_settings.is_test_data,
+                modulator_settings.rollof, modulator_settings.tx_is_on);
+    }
+
+};
+
+struct cmd_get_modulator_state{
+    modulator_state_com modulator_state;
+    template<class Archive>
+    void serialize(Archive & archive)
+    {
+        archive(modulator_state.snr_remote, modulator_state.modcod, modulator_state.is_short, modulator_state.is_pilots, 
+        modulator_state.is_tx_on, modulator_state.speed_in_bytes_tx, modulator_state.speed_in_bytes_tx_iface);
+    }
+};
+
 
 struct cmd_get_network
 {

dependencies/control_system/example-get-statistics.cpp

@@ -0,0 +1,76 @@
+#include "include/terminal_api/ControlProtoCInterface.h"
+#include <iostream>
+int main()
+{
+    TSID sid{0};
+    unsigned int access{0};
+    if(CP_Login("admin","pass",&sid,&access) == OK)
+    {
+       std::cout << "Succsec" << std::endl;
+    }
+    CinC_state state_cinc;
+    state_cinc.carrier_lock = false;
+    CP_GetCinCState(sid,state_cinc);
+    std::cout << state_cinc.carrier_lock << std::endl;
+    std::cout << state_cinc.freq_error_offset << std::endl;
+    std::cout << state_cinc.delay_dpdi << std::endl;
+    std::cout << state_cinc.cnt_bad_lock << std::endl;
+    modulator_state modulator;
+    CP_GetModulatorState(sid, modulator);
+    std::cout << modulator.is_pilots << "\n"
+    <<  modulator.modcod << "\n"
+    <<  modulator.snr_remote << "\n";
+    demodulator_state demodulator;
+    demodulator.dummy_cnt = 11111;
+    CP_GetDemodulatorState(sid, demodulator);
+    std::cout << "end CP_GetDemodulatorState" << std::endl;
+    std::cout << demodulator.is_short << std::endl;
+    std::cout << demodulator.modcod << std::endl;
+    std::cout << "afc_lock: " <<demodulator.locks.afc_lock << std::endl;
+    std::cout << "sym_sync_lock: " <<demodulator.locks.sym_sync_lock << std::endl;
+    std::cout << "freq_lock: " <<demodulator.locks.freq_lock << std::endl;
+    std::cout << "pkt_sync: " << demodulator.locks.pkt_sync << std::endl;
+    modulator_settings setting_modulator;
+    setting_modulator.baudrate = 2000000;
+    setting_modulator.central_freq_in_kGz = 1340000.24;
+    setting_modulator.rollof = 0.25;
+    setting_modulator.tx_is_on = true;
+    setting_modulator.is_test_data = false;
+    setting_modulator.is_save_current_state = true;
+    setting_modulator.is_cinc = false;
+    setting_modulator.is_carrier = true;
+    CP_SetModulatorSettings(sid, setting_modulator);
+    demodulator_settings demodulator_sett;
+    demodulator_sett.baudrate = 1340000;
+    demodulator_sett.central_freq_in_kGz = 2400000.34;
+    demodulator_sett.is_rvt_iq = true;
+    demodulator_sett.is_aru_on = true;
+    demodulator_sett.gain = 13;
+    demodulator_sett.rollof = 0.15;
+    if(CP_SetDemodulatorSettings(sid, demodulator_sett)== OK)
+    {
+        std::cout << "OK SET DEMODULATOR SETTINGS" <<  std::endl;
+    }
+    demodulator_settings demodulator_settings_;
+    if(CP_GetDemodulatorSettings(sid,demodulator_settings_) == OK)
+    {
+        std::cout << "OK GET DEMODULATOR SETTINGS" << std::endl;
+        std::cout << demodulator_settings_.baudrate << std::endl;
+        std::cout << demodulator_settings_.gain<< std::endl;
+        std::cout << demodulator_settings_.rollof << std::endl;
+        std::cout << demodulator_settings_.is_aru_on << std::endl;
+        std::cout << demodulator_settings_.is_rvt_iq << std::endl;
+        std::cout << demodulator_settings_.central_freq_in_kGz << std::endl;
+    }
+    modulator_settings modulator_settings_;
+    if(CP_GetModulatorSettings(sid,modulator_settings_)== OK)
+    {
+        std::cout << "OK GET MODULATOR SETTINGS" << std::endl;
+        std::cout << modulator_settings_.baudrate << std::endl;
+        std::cout << modulator_settings_.attenuation << std::endl;
+        std::cout << modulator_settings_.central_freq_in_kGz << std::endl;
+        std::cout << modulator_settings_.is_carrier << std::endl;
+        std::cout << modulator_settings_.is_cinc << std::endl;
+        std::cout << modulator_settings_.rollof << std::endl;
+    }
+}

dependencies/control_system/include/terminal_api/ControlProtoCInterface.h

@@ -1,14 +1,13 @@
 #ifndef __CONTROL_PROTO_COMMANDS__
 #define __CONTROL_PROTO_COMMANDS__
 
+#include <stdint.h>
 #include <iostream>
 #include <string>
 
 #ifdef __cplusplus
-#include <cstdint>
 #define EXTERNC extern  "C"
 #else
-#include <stdint.h>
 #define EXTERNC extern
 #endif
 
@@ -75,6 +74,89 @@ LO -- lo frequency
 */
 EXTERNC CP_Result CP_ModulatorParams(TSID sid, const char *modulator_param, uint32_t value);
 
+struct modulator_state{
+    bool is_tx_on;
+    float snr_remote;
+    uint16_t modcod;
+    bool is_short;
+    bool is_pilots;
+    uint32_t speed_in_bytes_tx;
+    uint32_t speed_in_bytes_tx_iface;
+};
+EXTERNC CP_Result CP_GetModulatorState(TSID sid, modulator_state &state);
+
+struct demodulator_locks{
+    bool pkt_sync;
+    bool afc_lock;
+    bool freq_lock;
+    bool sym_sync_lock;
+};
+struct demodulator_state{
+    float snr;
+    uint16_t modcod;
+    bool is_short;
+    bool is_pilots;
+    float rssi;
+    double afc_err;
+    double crs_freq_err;
+    double sym_err;
+    double fine_freq_err;
+    double if_overload;
+    uint32_t packet_ok_cnt;
+    uint32_t packet_bad_cnt;
+    uint32_t dummy_cnt;
+    uint32_t speed_in_bytes_rx;
+    uint32_t speed_in_bytes_rx_iface;
+    demodulator_locks locks;
+};
+EXTERNC CP_Result CP_GetDemodulatorState(TSID sid, demodulator_state &state);
+
+struct CinC_state{
+    float ratio_signal_signal;
+    bool carrier_lock;
+    int32_t freq_error_offset;
+    uint32_t delay_dpdi;
+    int32_t freq_fine_estimate;
+    uint32_t cnt_bad_lock;
+};
+EXTERNC CP_Result CP_GetCinCState(TSID sid, CinC_state &state);
+
+struct device_state{
+    double adrv_temp;
+    double zynq_temp;
+    double pl_temp;
+};
+EXTERNC CP_Result CP_GetDeviceState(TSID sid, device_state &state);
+
+struct modulator_settings{
+    uint32_t baudrate;
+    double central_freq_in_kGz;
+    double rollof;
+    double attenuation;
+    bool is_test_data;
+    bool is_save_current_state;
+    bool is_carrier;
+    bool tx_is_on;
+    bool is_cinc;
+};
+
+EXTERNC CP_Result CP_SetModulatorSettings(TSID sid, modulator_settings& settings);
+EXTERNC CP_Result CP_GetModulatorSettings(TSID sid, modulator_settings& settings);
+
+struct demodulator_settings
+{
+    uint32_t baudrate;
+    double central_freq_in_kGz;
+    double rollof;
+    bool is_aru_on;
+    bool is_rvt_iq; 
+    double gain;
+};
+
+EXTERNC CP_Result CP_SetDemodulatorSettings(TSID sid, demodulator_settings& settings);
+EXTERNC CP_Result CP_GetDemodulatorSettings(TSID sid, demodulator_settings& settings);
+
+
 EXTERNC CP_Result CP_GetModulatorParams(TSID sid, const char *modulator_param, uint32_t *value);
 
 EXTERNC CP_Result CP_GetDemodulatorParams(TSID sid, const char *demodulator_param, uint32_t *value);

src/main.cpp

@@ -253,8 +253,13 @@ int main(int argc, char *argv[]) {
         BOOST_LOG_TRIVIAL(info) << "Starting RELEASE build" << argv[0];
 #endif
 
+#ifdef USE_DEBUG
+        http::auth::jwt::secretKey = "^}u'ZKyQ%;+:lnh^GS7!=G~nRK?7[{``";
+        BOOST_LOG_TRIVIAL(info) << "DEBUG build use pre-created key " << http::auth::jwt::secretKey;
+#else
         http::auth::jwt::generateSecretKey();
         BOOST_LOG_TRIVIAL(info) << "Generated new secret key " << http::auth::jwt::secretKey;
+#endif
 
         ServerResources resources;
 

src/terminal_api_driver.cpp

@@ -1,4 +1,7 @@
 #include "terminal_api_driver.h"
+
+#include <algorithm>
+
 #include "terminal_api/ControlProtoCInterface.h"
 #include <sstream>
 #include <cmath>
@@ -35,202 +38,124 @@ timer_->timeout().connect([=]{
 
 api_driver::ApiDriver::ApiDriver() {
     CP_Login("admin", "pass", &sid, &access);
-}
+    CP_GetDmaDebug(sid, "status_init", &deviceInitState);
-
-static bool DriverCP_GetLevelDemod(TSID sid, const char* param) {
-    double variable_dbl = 0;
-    CP_GetLevelDemod(sid, param, &variable_dbl);
-    return variable_dbl == 0;
-}
-
-static bool DriverCP_GetTxPower(TSID sid) {
-    double variable_dbl = 0;
-    CP_GetGain(sid, "TXPWD", &variable_dbl);
-    return variable_dbl != 0;
-}
-
-static bool DriverCp_GetIsCinC(TSID sid) {
-    uint32_t mode_demod = 0;
-    CP_GetDemodulatorParams(sid, "mode_demod", &mode_demod);
-    return mode_demod == 1;
 }
 
 static const char* boolAsStr(bool value) {
     return value ? "true" : "false";
 }
 
+static std::string buildEscapedString(const std::string& source) {
+    std::string str(source);
+    size_t start_pos = 0;
+    while((start_pos = str.find('\"', start_pos)) != std::string::npos) {
+        str.replace(start_pos, 1, "\\\"");
+        start_pos += 2;
+    }
+    return "\"" + str + "\"";
+}
+
+static bool DriverCP_GetCinC(TSID sid) {
+    modulator_settings s{};
+    CP_GetModulatorSettings(sid, s);
+    return s.is_cinc;
+}
+
 std::string api_driver::ApiDriver::loadTerminalState() {
     std::stringstream result;
-    result << "{";
+    result << "{\"initState\":" << buildEscapedString(this->deviceInitState);
 
-    const auto txEnable = DriverCP_GetTxPower(sid);
+    modulator_state modulator{};
-    const auto isCinC = DriverCp_GetIsCinC(sid);
+    CP_GetModulatorState(sid, modulator);
-    result << "\"isCinC\":" << boolAsStr(isCinC);
+
+    demodulator_state demodulator{};
+    CP_GetDemodulatorState(sid, demodulator);
+
+    CinC_state state_cinc{};
+    CP_GetCinCState(sid,state_cinc);
+
+    device_state device{};
+    CP_GetDeviceState(sid, device);
+
+    const bool isCinC = DriverCP_GetCinC(sid);
+
+    result << ",\"isCinC\":" << boolAsStr(isCinC);
 
     // формируем структуру для TX
-    {
+    result << ",\"tx.state\":" << boolAsStr(modulator.is_tx_on);
-        result << ",\"tx.state\":" << boolAsStr(txEnable);
+    result.precision(2); result << ",\"tx.modcod\":" << modulator.snr_remote;
 
-        double tmp = 0;
+    if (modulator.is_short) {
-        char tmpStr[32];
+        result << R"(,"tx.frameSize":"short")";
-
+    } else {
-        CP_GetLevelDemod(sid, "snr_acm", &tmp);
+        result << R"(,"tx.frameSize":"normal")";
-        sprintf(tmpStr, "%.2f", tmp);
-        result << ",\"tx.snr\":" << tmpStr;
-
-        CP_GetLevelDemod(sid, "modcod_tx", &tmp);
-        result << ",\"tx.modcod\":" << (static_cast<uint32_t>(tmp) >> 2);
-
-        if (static_cast<uint8_t>(tmp) & 0b00000010) {
-            result << R"(,"tx.frameSize":"short")";
-        } else {
-            result << R"(,"tx.frameSize":"normal")";
-        }
-
-        if (static_cast<uint8_t>(tmp) & 0b00000001) {
-            result << R"(,"tx.pilots":"pilots")";
-        } else {
-            result << R"(,"tx.pilots":"no pilots")";
-        }
-
-        std::string speed;
-        CP_GetDmaDebug(sid, "speed_tx", &speed);
-        sprintf(tmpStr, "%.3f", std::atof(speed.c_str()) / 128.0);
-        result << ",\"tx.speedOnTxKbit\":" << tmpStr;
-
-        CP_GetDmaDebug(sid, "speed_tx_iface", &speed);
-        sprintf(tmpStr, "%.3f", std::atof(speed.c_str()) / 128.0);
-        result << ",\"tx.speedOnIifKbit\":" << tmpStr;
     }
 
+    if (modulator.is_pilots) {
+        result << R"(,"tx.pilots":"pilots")";
+    } else {
+        result << R"(,"tx.pilots":"no pilots")";
+    }
+
+    result.precision(2); result << ",\"tx.speedOnTxKbit\":" << static_cast<double>(modulator.speed_in_bytes_tx) / 128.0;
+    result.precision(2); result << ",\"tx.speedOnIifKbit\":" << (static_cast<double>(modulator.speed_in_bytes_tx_iface) / 128.0);
+
     // формируем структуру для RX
-    {
+    result << ",\"rx.state\":" << boolAsStr(demodulator.locks.sym_sync_lock && demodulator.locks.freq_lock && demodulator.locks.afc_lock && demodulator.locks.pkt_sync);
-        const auto sym_sync_lock = DriverCP_GetLevelDemod(sid, "sym_sync_lock"); // захват символьной
+    result << ",\"rx.sym_sync_lock\":" << boolAsStr(demodulator.locks.sym_sync_lock);
-        const auto freq_search_lock = DriverCP_GetLevelDemod(sid, "freq_lock"); // Захват поиска по частоте
+    result << ",\"rx.freq_search_lock\":" << boolAsStr(demodulator.locks.freq_lock);
-        const auto afc_lock = DriverCP_GetLevelDemod(sid, "afc_lock"); // захват ФАПЧ
+    result << ",\"rx.afc_lock\":" << boolAsStr(demodulator.locks.afc_lock);
-        const auto pkt_sync = DriverCP_GetLevelDemod(sid, "pkt_sync"); // захват пакетной синхронизации
+    result << ",\"rx.pkt_sync\":" << boolAsStr(demodulator.locks.pkt_sync);
-        const auto receive_active = sym_sync_lock && freq_search_lock && afc_lock && pkt_sync;
 
-        result << ",\"rx.state\":" << boolAsStr(receive_active);
+    result.precision(2); result << ",\"rx.snr\":" << demodulator.snr;
-        result << ",\"rx.sym_sync_lock\":" << boolAsStr(sym_sync_lock);
+    result.precision(2); result << ",\"rx.rssi\":" << demodulator.rssi;
-        result << ",\"rx.freq_search_lock\":" << boolAsStr(freq_search_lock);
+    result << ",\"rx.modcod\":" << demodulator.modcod;
-        result << ",\"rx.afc_lock\":" << boolAsStr(afc_lock);
-        result << ",\"rx.pkt_sync\":" << boolAsStr(pkt_sync);
 
-        double tmpd = 0; uint32_t tmpu32 = 0;
+    if (demodulator.is_short) {
-        char tmpStr[32];
+        result << R"(,"rx.frameSize":"short")";
-
+    } else {
-        CP_GetLevelDemod(sid, "snr", &tmpd);
+        result << R"(,"rx.frameSize":"normal")";
-        sprintf(tmpStr, "%.2f", tmpd);
-        result << ",\"rx.snr\":" << tmpStr;
-
-        CP_GetLevelDemod(sid, "rssi", &tmpd);
-        sprintf(tmpStr, "%.2f", -tmpd);
-        result << ",\"rx.rssi\":" << tmpStr;
-
-        CP_GetDemodulatorParams(sid, "modcod", &tmpu32);
-        result << ",\"rx.modcod\":" << tmpu32;
-
-        CP_GetDemodulatorParams(sid, "type_pack", &tmpu32);
-        if (tmpu32) {
-            result << R"(,"rx.frameSize":"short")";
-        } else {
-            result << R"(,"rx.frameSize":"normal")";
-        }
-
-        CP_GetDemodulatorParams(sid, "is_pilots", &tmpu32);
-        if (tmpu32) {
-            result << R"(,"rx.pilots":"pilots")";
-        } else {
-            result << R"(,"rx.pilots":"no pilots")";
-        }
-
-        CP_GetLevelDemod(sid, "sym_err", &tmpd);
-        sprintf(tmpStr, "%.2f", tmpd);
-        result << ",\"rx.symError\":" << tmpStr;
-
-        CP_GetLevelDemod(sid, "crs_freq_err", &tmpd); // freqErr
-        sprintf(tmpStr, "%.2f", tmpd);
-        result << ",\"rx.freqErr\":" << tmpStr;
-
-        CP_GetLevelDemod(sid, "fine_freq_err", &tmpd); // freqErrAcc
-        sprintf(tmpStr, "%.2f", tmpd);
-        result << ",\"rx.freqErrAcc\":" << tmpStr;
-
-        CP_GetModulatorParams(sid, "if_overload", &tmpu32); // inputSignalLevel
-        result << ",\"rx.inputSignalLevel\":" << tmpStr;
-
-        CP_GetLevelDemod(sid, "afc_err", &tmpd); // PLL
-        sprintf(tmpStr, "%.2f", tmpd);
-        result << ",\"rx.pllError\":" << tmpStr;
-
-        std::string speed;
-        CP_GetDmaDebug(sid, "speed_rx", &speed);
-        sprintf(tmpStr, "%.3f", std::atof(speed.c_str()) / 128.0);
-        result << ",\"rx.speedOnRxKbit\":" << tmpStr;
-
-        speed.clear(); CP_GetDmaDebug(sid, "speed_rx_iface", &speed);
-        sprintf(tmpStr, "%.3f", std::atof(speed.c_str()) / 128.0);
-        result << ",\"rx.speedOnIifKbit\":" << tmpStr;
-
-        speed.clear(); CP_GetDmaDebug(sid, "packet_ok_rx", &speed);
-        result << ",\"rx.packetsOk\":" << std::atoi(speed.c_str());
-
-        speed.clear(); CP_GetDmaDebug(sid, "drop_bad_rx", &speed);
-        result << ",\"rx.packetsBad\":" << std::atoi(speed.c_str());
-
-        CP_GetDemodulatorParams(sid, "dummy_cnt", &tmpu32);
-        result << ",\"rx.packetsDummy\":" << tmpu32;
     }
 
+    if (demodulator.is_pilots) {
+        result << R"(,"rx.pilots":"pilots")";
+    } else {
+        result << R"(,"rx.pilots":"no pilots")";
+    }
+
+    result.precision(2); result << ",\"rx.symError\":" << demodulator.sym_err;
+    result.precision(2); result << ",\"rx.freqErr\":" << demodulator.crs_freq_err;
+    result.precision(2); result << ",\"rx.freqErrAcc\":" << demodulator.fine_freq_err;
+    result.precision(2); result << ",\"rx.inputSignalLevel\":" << demodulator.if_overload;
+    result.precision(2); result << ",\"rx.pllError\":" << demodulator.afc_err;
+    result.precision(2); result << ",\"rx.speedOnRxKbit\":" << (static_cast<double>(demodulator.speed_in_bytes_rx) / 128.0);
+    result.precision(2); result << ",\"rx.speedOnIifKbit\":" << (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;
+
     // формируем структуру для CinC
-    {
+    result.precision(3); result << ",\"cinc.occ\":" << state_cinc.ratio_signal_signal;
-        std::string tmps;
-        char tmpbuff[32];
-        CP_GetDmaDebug(sid, "ratio_signal_signal", &tmps);
-        sprintf(tmpbuff, "%.3f", std::atof(tmps.c_str()));
-        result << ",\"cinc.occ\":" << tmpbuff;
 
-        const bool carrierOk = DriverCP_GetLevelDemod(sid, "carrier_lock");
+    if (isCinC && modulator.is_tx_on) {
-        if (isCinC && txEnable) {
+        if (state_cinc.carrier_lock) {
-            if (carrierOk) {
+            result << R"(,"cinc.correlator":true)";
-                result << R"(,"cinc.correlator":true)";
-            } else {
-                result << R"(,"cinc.correlator":false)";
-            }
         } else {
-            result << R"(,"cinc.correlator":null)";
+            result << R"(,"cinc.correlator":false)";
         }
-
+    } else {
-        uint32_t tmpu32 = 0;
+        result << R"(,"cinc.correlator":null)";
-        CP_GetDemodulatorParams(sid, "cnt_bad_lock_cinc", &tmpu32);
-        result << ",\"cinc.correlatorFails\":" << tmpu32;
-
-        tmps.clear(); CP_GetDmaDebug(sid, "freq_error_offset", &tmps);
-        // тут так сделано из-за приколов со знаками...
-        result << ",\"cinc.freqErr\":" << std::to_string(static_cast<int32_t>(std::atol(tmps.c_str())));
-
-        tmps.clear(); CP_GetDmaDebug(sid, "freq_fine_estimate", &tmps);
-        result << ",\"cinc.freqErrAcc\":" << tmps;
-
-        tmps.clear(); CP_GetDmaDebug(sid, "delay_dpdi", &tmps);
-        result << ",\"cinc.channelDelay\":" << std::to_string(static_cast<uint32_t>(std::round(std::atof(tmps.c_str()) * 1000)));
     }
 
+    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;
+
     // структура температур девайса
-    {
+    result.precision(3); result << ",\"device.adrv\":" << device.adrv_temp;
-        char tmp[32];
+    result.precision(3); result << ",\"device.fpga\":" << device.pl_temp;
-        double tmp_adrv_c = 0;
+    result.precision(3); result << ",\"device.zync\":" << device.zynq_temp;
-        double tmp_ps = 0;
-        double tmp_pl = 0;
-        CP_ZynqParams(sid,"adrv-c_temper_celsius", &tmp_adrv_c);
-        CP_ZynqParams(sid,"pl_temper_celsius", &tmp_pl);
-        CP_ZynqParams(sid,"ps_temper_celsius", &tmp_ps);
-
-        sprintf(tmp, "%.1f", tmp_adrv_c / 1000); result << ",\"device.adrv\":" << tmp;
-        sprintf(tmp, "%.1f", tmp_pl / 1000); result << ",\"device.fpga\":" << tmp;
-        sprintf(tmp, "%.1f", tmp_ps / 1000); result << ",\"device.zync\":" << tmp;
-    }
 
     result << "}";
 
@@ -244,6 +169,52 @@ void api_driver::ApiDriver::resetPacketStatistics() const {
 }
 
 std::string api_driver::ApiDriver::loadSettings() {
+    // modulator_settings modSettings{};
+    // CP_GetModulatorSettings(sid, modSettings);
+    //
+    // modSettings.baudrate = 2000000;
+    // modSettings.central_freq_in_kGz = 1340000.24;
+    // modSettings.rollof = 0.25;
+    // modSettings.tx_is_on = true;
+    // modSettings.is_test_data = false;
+    // modSettings.is_save_current_state = true;
+    // modSettings.is_cinc = false;
+    // modSettings.is_carrier = true;
+    // CP_SetModulatorSettings(sid, modSettings);
+    // demodulator_settings demodulator_sett;
+    // demodulator_sett.baudrate = 1340000;
+    // demodulator_sett.central_freq_in_kGz = 2400000.34;
+    // demodulator_sett.is_rvt_iq = true;
+    // demodulator_sett.is_aru_on = true;
+    // demodulator_sett.gain = 13;
+    // demodulator_sett.rollof = 0.15;
+    // if(CP_SetDemodulatorSettings(sid, demodulator_sett)== OK)
+    // {
+    //     std::cout << "OK SET DEMODULATOR SETTINGS" <<  std::endl;
+    // }
+    // demodulator_settings demodulator_settings_;
+    // if(CP_GetDemodulatorSettings(sid,demodulator_settings_) == OK)
+    // {
+    //     std::cout << "OK GET DEMODULATOR SETTINGS" << std::endl;
+    //     std::cout << demodulator_settings_.baudrate << std::endl;
+    //     std::cout << demodulator_settings_.gain<< std::endl;
+    //     std::cout << demodulator_settings_.rollof << std::endl;
+    //     std::cout << demodulator_settings_.is_aru_on << std::endl;
+    //     std::cout << demodulator_settings_.is_rvt_iq << std::endl;
+    //     std::cout << demodulator_settings_.central_freq_in_kGz << std::endl;
+    // }
+    // modulator_settings modulator_settings_;
+    // if(CP_GetModulatorSettings(sid,modulator_settings_)== OK)
+    // {
+    //     std::cout << "OK GET MODULATOR SETTINGS" << std::endl;
+    //     std::cout << modulator_settings_.baudrate << std::endl;
+    //     std::cout << modulator_settings_.attenuation << std::endl;
+    //     std::cout << modulator_settings_.central_freq_in_kGz << std::endl;
+    //     std::cout << modulator_settings_.is_carrier << std::endl;
+    //     std::cout << modulator_settings_.is_cinc << std::endl;
+    //     std::cout << modulator_settings_.rollof << std::endl;
+    // }
+
     return "{}";
 }
 

src/terminal_api_driver.h

@@ -32,6 +32,7 @@ namespace api_driver {
         TSID sid{0};
         unsigned int access{0};
 
+        std::string deviceInitState;
     };
 }
 

static/fields.css

@@ -47,6 +47,9 @@
     flex-direction: row;
     flex-wrap: wrap;
 }
+.tabs-item-flex-container > * {
+    flex: 1 1 auto
+}
 
 .tabs-item-flex-container > *, .settings-set-container {
     padding: 1em;
@@ -57,6 +60,10 @@
 
 .tabs-item-flex-container th {
     text-align: left;
+    padding-right: 1em;
+}
+.tabs-item-flex-container td {
+    min-width: 10em;
 }
 .tabs-item-flex-container h2 {
     margin-top: 0;

static/main.html

@@ -11,9 +11,9 @@
 
 <div id="app" hidden>
     <div>
-        <span class="nav-bar-element">Прием: <span :class="{ indicator_bad: stat_rx.state === true, indicator_good: stat_rx.state === false, indicator: true }"></span></span>
+        <span class="nav-bar-element">Прием: <span :class="{ indicator_bad: stat_rx.state === false, indicator_good: stat_rx.state === true, indicator: true }"></span></span>
-        <span class="nav-bar-element">Передача: <span :class="{ indicator_bad: stat_tx.state === true, indicator_good: stat_tx.state === false, indicator: true }"></span></span>
+        <span class="nav-bar-element">Передача: <span :class="{ indicator_good: stat_tx.state === true, indicator: true }"></span></span>
-        <span class="nav-bar-element">Тест: <span :class="{ indicator_bad: testState === true, indicator_good: testState === false, indicator: true }"></span></span>
+        <span class="nav-bar-element">Тест: <span :class="{ indicator_bad: testState === false, indicator_good: testState === true, indicator: true }"></span></span>
 <!--        Последнее обновление: {{ lastUpdateTime }}-->
     </div>
     <div class="tabs">
@@ -24,6 +24,7 @@
             <a href="#admin" class="tabs-btn" @click="activeTab = 'admin'" :class="{ active: activeTab === 'admin' }">Администрирование</a>
             <a href="/logout" class="tabs-btn">Выход</a>
         </div>
+        <div :class="{ value_bad: initState !== 'Успешная инициализация системы' }">{{ initState }}</div>
         <div class="tabs-body">
             <div class="tabs-body-item tabs-item-flex-container" v-show="activeTab === 'monitoring'">
                 <div>
@@ -36,7 +37,8 @@
                         <tr><th>Захват поиска по частоте</th><td><span :class="{ indicator_bad: stat_rx.freq_search_lock === true, indicator_good: stat_rx.freq_search_lock === false, indicator: true }"></span></td></tr>
                         <tr><th>Захват пакетной синхр.</th><td><span :class="{ indicator_bad: stat_rx.pkt_sync === true, indicator_good: stat_rx.pkt_sync === false, indicator: true }"></span></td></tr>
                         <tr><th>ОСШ/RSSI</th><td>{{ stat_rx.snr }} / {{ stat_rx.rssi }}</td></tr>
-                        <tr><th>Modcod/размер кадра</th><td>{{ stat_rx.modcod }} / {{ stat_rx.frameSize }}</td></tr>
+                        <tr><th>Modcod</th><td>{{ stat_rx.modcod }}</td></tr>
+                        <tr><th>Размер кадра</th><td>{{ stat_rx.frameSize }}</td></tr>
                         <tr><th>Пилот-символы</th><td>{{ stat_rx.pilots }}</td></tr>
                         <tr><th>Символьная ошибка</th><td>{{ stat_rx.symError }}</td></tr>
                         <tr><th>Грубая/точная част. ошибка, Гц</th><td>{{ stat_rx.freqErr }} / {{ stat_rx.freqErrAcc }}</td></tr>
@@ -207,16 +209,7 @@
                         <label v-show="param.dvbs2.mode === 'ccm'">
                             <span>Скорость кода</span>
                             <select v-model="param.dvbs2.ccm_speed">
-                                <option value="1/4">1/4</option>
+                                <option v-for="speed in getAvailableModcods(param.dvbs2.ccm_modulation)" v-bind:value="speed">{{ speed }}</option>
-                                <option value="1/3">1/3</option>
-                                <option value="2/5">2/5</option>
-                                <option value="1/2">1/2</option>
-                                <option value="2/3">2/3</option>
-                                <option value="3/4">3/4</option>
-                                <option value="4/5">4/5</option>
-                                <option value="5/6">5/6</option>
-                                <option value="8/9">8/9</option>
-                                <option value="9/10">9/10</option>
                             </select>
                         </label>
 
@@ -232,16 +225,7 @@
                         <label v-show="param.dvbs2.mode === 'acm'">
                             <span>Скорость кода (макс. режим)</span>
                             <select v-model="param.dvbs2.acm_maxSpeed">
-                                <option value="1/4">1/4</option>
+                                <option v-for="speed in getAvailableModcods(param.dvbs2.acm_maxModulation)" v-bind:value="speed">{{ speed }}</option>
-                                <option value="1/3">1/3</option>
-                                <option value="2/5">2/5</option>
-                                <option value="1/2">1/2</option>
-                                <option value="2/3">2/3</option>
-                                <option value="3/4">3/4</option>
-                                <option value="4/5">4/5</option>
-                                <option value="5/6">5/6</option>
-                                <option value="8/9">8/9</option>
-                                <option value="9/10">9/10</option>
                             </select>
                         </label>
                         <label v-show="param.dvbs2.mode === 'acm'">
@@ -256,16 +240,7 @@
                         <label v-show="param.dvbs2.mode === 'acm'">
                             <span>Скорость кода (мин. режим)</span>
                             <select v-model="param.dvbs2.acm_minSpeed">
-                                <option value="'1/4'">1/4</option>
+                                <option v-for="speed in getAvailableModcods(param.dvbs2.acm_minModulation)" v-bind:value="speed">{{ speed }}</option>
-                                <option value="'1/3'">1/3</option>
-                                <option value="'2/5'">2/5</option>
-                                <option value="'1/2'">1/2</option>
-                                <option value="'2/3'">2/3</option>
-                                <option value="'3/4'">3/4</option>
-                                <option value="'4/5'">4/5</option>
-                                <option value="'5/6'">5/6</option>
-                                <option value="'8/9'">8/9</option>
-                                <option value="'9/10'">9/10</option>
                             </select>
                         </label>
 
@@ -381,8 +356,49 @@
         return defaultTab
     }
 
-    // TODO: взять модкоды из раздела 5.5.2.2 https://www.etsi.org/deliver/etsi_en/302300_302399/302307/01.01.02_60/en_302307v010102p.pdf
+    function modcodToStr(modcod) {
-    // и прикрутить декодинг модкода
+        // модкоды из раздела 5.5.2.2 https://www.etsi.org/deliver/etsi_en/302300_302399/302307/01.01.02_60/en_302307v010102p.pdf
+
+        // NOTE модкоды со скоростью хода 3/5 не работают
+        const modcods = [
+            "DUMMY",
+            "QPSK 1/4",
+            "QPSK 1/3",
+            "QPSK 2/5",
+            "QPSK 1/2",
+            "QPSK 3/5", // отключено
+            "QPSK 2/3",
+            "QPSK 3/4",
+            "QPSK 4/5",
+            "QPSK 5/6",
+            "QPSK 8/9",
+            "QPSK 9/10",
+
+            "8PSK 3/5", // отключено
+            "8PSK 2/3",
+            "8PSK 3/4",
+            "8PSK 5/6",
+            "8PSK 8/9",
+            "8PSK 9/10",
+
+            "16APSK 2/3",
+            "16APSK 3/4",
+            "16APSK 4/5",
+            "16APSK 5/6",
+            "16APSK 8/9",
+            "16APSK 9/10",
+
+            "32APSK 3/4",
+            "32APSK 4/5",
+            "32APSK 5/6",
+            "32APSK 8/9",
+            "32APSK 9/10",
+        ]
+        if (typeof modcod != "number" || modcod < 0 || modcod >= modcod.length) {
+            return "?";
+        }
+        return modcods[modcod]
+    }
 
     const app = new Vue({
         el: '#app',
@@ -487,14 +503,29 @@
                 serviceSettings: {},
             },
 
-            message: "<err>",
-
             testState: '?',
+            initState: '',
             lastUpdateTime: new Date(),
             activeTab: getCurrentTab(),
             settingFetchComplete: false
         },
         methods: {
+            getAvailableModcods(modulation) {
+                // NOTE модкоды со скоростью хода 3/5 не работают
+                switch (modulation) {
+                    case 'qpsk':
+                        return ['1/4', '1/3', '2/5', '1/2', /* '3/5',*/ '2/3', '3/4', '4/5', '5/6', '8/9', '9/10']
+                    case '8psk':
+                        return [/* '3/5',*/ '2/3', '3/4', '5/6', '8/9', '9/10']
+                    case '16apsk':
+                        return ['2/3', '3/4', '4/5', '5/6', '8/9', '9/10']
+                    case '32apsk':
+                        return ['3/4', '4/5', '5/6', '8/9', '9/10']
+                    default:
+                        return []
+                }
+            },
+
             updateStatistics(vals) {
                 this.lastUpdateTime = new Date();
                 this.isCinC = vals["mainState"]["isCinC"]
@@ -506,7 +537,7 @@
                 this.stat_rx.pkt_sync = vals["mainState"]["rx.pkt_sync"]
                 this.stat_rx.snr = vals["mainState"]["rx.snr"]
                 this.stat_rx.rssi = vals["mainState"]["rx.rssi"]
-                this.stat_rx.modcod = vals["mainState"]["rx.modcod"]
+                this.stat_rx.modcod = modcodToStr(vals["mainState"]["rx.modcod"])
                 this.stat_rx.frameSize = vals["mainState"]["rx.frameSize"]
                 this.stat_rx.pilots = vals["mainState"]["rx.pilots"]
                 this.stat_rx.symError = vals["mainState"]["rx.symError"]
@@ -522,7 +553,7 @@
 
                 this.stat_tx.state = vals["mainState"]["tx.state"]
                 this.stat_tx.snr = vals["mainState"]["rx.snr"]
-                this.stat_tx.modcod = vals["mainState"]["rx.modcod"]
+                this.stat_tx.modcod = modcodToStr(vals["mainState"]["rx.modcod"])
                 this.stat_tx.frameSize = vals["mainState"]["rx.frameSize"]
                 this.stat_tx.pilots = vals["mainState"]["rx.pilots"]
                 this.stat_tx.speedOnTxKbit = vals["mainState"]["tx.speedOnTxKbit"]