переход на получение статистики устройства новым 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::_2));
+                          std::placeholders::_1,
+                          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);
@@ -752,4 +948,4 @@ response_type system_client::send_get_network_settings(const network_value & cmd
     if (data_from_serv.has_value())
         value = std::any_cast<std::string>(data_from_serv);
     return result;
-}
+}

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