diff --git a/dependencies/control_system/CMakeLists.txt b/dependencies/control_system/CMakeLists.txt old mode 100644 new mode 100755 index fc6d7b4..1eafad4 --- a/dependencies/control_system/CMakeLists.txt +++ b/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) diff --git a/dependencies/control_system/client/main.cpp b/dependencies/control_system/client/main.cpp index cdca466..9023f31 100644 --- a/dependencies/control_system/client/main.cpp +++ b/dependencies/control_system/client/main.cpp @@ -1,11 +1,175 @@ #include -#include "terminal_api/ControlProtoCInterface.h" +#include #include "system_client.h" std::shared_mutex mtx; TSID sid_counter { 0 }; std::map> 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(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(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(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(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(state_com); + state.locks = reinterpret_cast(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(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(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(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) diff --git a/dependencies/control_system/client/sock_client.cpp b/dependencies/control_system/client/sock_client.cpp index 724e8cc..049e42c 100644 --- a/dependencies/control_system/client/sock_client.cpp +++ b/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) diff --git a/dependencies/control_system/client/system_client.cpp b/dependencies/control_system/client/system_client.cpp index fed86ad..5eb190b 100644 --- a/dependencies/control_system/client/system_client.cpp +++ b/dependencies/control_system/client/system_client.cpp @@ -315,6 +315,72 @@ void system_client::data_received(const std::vector & 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(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(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(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(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(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(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(data_from_serv); return result; -} \ No newline at end of file +} diff --git a/dependencies/control_system/client/system_client.h b/dependencies/control_system/client/system_client.h index bdd4bc8..66cb9fb 100644 --- a/dependencies/control_system/client/system_client.h +++ b/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); diff --git a/dependencies/control_system/common/protocol_commands.h b/dependencies/control_system/common/protocol_commands.h index cd3fd34..addaf28 100644 --- a/dependencies/control_system/common/protocol_commands.h +++ b/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 + 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 + 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 + 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 + 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 + 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 + 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 { diff --git a/dependencies/control_system/example-get-statistics.cpp b/dependencies/control_system/example-get-statistics.cpp new file mode 100644 index 0000000..4ee4616 --- /dev/null +++ b/dependencies/control_system/example-get-statistics.cpp @@ -0,0 +1,76 @@ +#include "include/terminal_api/ControlProtoCInterface.h" +#include +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: " < #include #include #ifdef __cplusplus -#include #define EXTERNC extern "C" #else -#include #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); diff --git a/src/main.cpp b/src/main.cpp index 1b82354..5cb1473 100644 --- a/src/main.cpp +++ b/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; diff --git a/src/terminal_api_driver.cpp b/src/terminal_api_driver.cpp index 19c4376..23eccad 100644 --- a/src/terminal_api_driver.cpp +++ b/src/terminal_api_driver.cpp @@ -1,4 +1,7 @@ #include "terminal_api_driver.h" + +#include + #include "terminal_api/ControlProtoCInterface.h" #include #include @@ -35,202 +38,124 @@ timer_->timeout().connect([=]{ api_driver::ApiDriver::ApiDriver() { CP_Login("admin", "pass", &sid, &access); -} - -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; + CP_GetDmaDebug(sid, "status_init", &deviceInitState); } 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); - const auto isCinC = DriverCp_GetIsCinC(sid); - result << "\"isCinC\":" << boolAsStr(isCinC); + modulator_state modulator{}; + CP_GetModulatorState(sid, modulator); + + 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(txEnable); + result << ",\"tx.state\":" << boolAsStr(modulator.is_tx_on); + result.precision(2); result << ",\"tx.modcod\":" << modulator.snr_remote; - double tmp = 0; - char tmpStr[32]; - - CP_GetLevelDemod(sid, "snr_acm", &tmp); - sprintf(tmpStr, "%.2f", tmp); - result << ",\"tx.snr\":" << tmpStr; - - CP_GetLevelDemod(sid, "modcod_tx", &tmp); - result << ",\"tx.modcod\":" << (static_cast(tmp) >> 2); - - if (static_cast(tmp) & 0b00000010) { - result << R"(,"tx.frameSize":"short")"; - } else { - result << R"(,"tx.frameSize":"normal")"; - } - - if (static_cast(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_short) { + result << R"(,"tx.frameSize":"short")"; + } else { + result << R"(,"tx.frameSize":"normal")"; } + if (modulator.is_pilots) { + result << R"(,"tx.pilots":"pilots")"; + } else { + result << R"(,"tx.pilots":"no pilots")"; + } + + result.precision(2); result << ",\"tx.speedOnTxKbit\":" << static_cast(modulator.speed_in_bytes_tx) / 128.0; + result.precision(2); result << ",\"tx.speedOnIifKbit\":" << (static_cast(modulator.speed_in_bytes_tx_iface) / 128.0); + // формируем структуру для RX - { - const auto sym_sync_lock = DriverCP_GetLevelDemod(sid, "sym_sync_lock"); // захват символьной - const auto freq_search_lock = DriverCP_GetLevelDemod(sid, "freq_lock"); // Захват поиска по частоте - const auto afc_lock = DriverCP_GetLevelDemod(sid, "afc_lock"); // захват ФАПЧ - const auto pkt_sync = DriverCP_GetLevelDemod(sid, "pkt_sync"); // захват пакетной синхронизации - const auto receive_active = sym_sync_lock && freq_search_lock && afc_lock && pkt_sync; + result << ",\"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.state\":" << boolAsStr(receive_active); - result << ",\"rx.sym_sync_lock\":" << boolAsStr(sym_sync_lock); - result << ",\"rx.freq_search_lock\":" << boolAsStr(freq_search_lock); - result << ",\"rx.afc_lock\":" << boolAsStr(afc_lock); - result << ",\"rx.pkt_sync\":" << boolAsStr(pkt_sync); + result.precision(2); result << ",\"rx.snr\":" << demodulator.snr; + result.precision(2); result << ",\"rx.rssi\":" << demodulator.rssi; + result << ",\"rx.modcod\":" << demodulator.modcod; - double tmpd = 0; uint32_t tmpu32 = 0; - char tmpStr[32]; - - CP_GetLevelDemod(sid, "snr", &tmpd); - 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_short) { + result << R"(,"rx.frameSize":"short")"; + } else { + result << R"(,"rx.frameSize":"normal")"; } + 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(demodulator.speed_in_bytes_rx) / 128.0); + result.precision(2); result << ",\"rx.speedOnIifKbit\":" << (static_cast(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 - { - 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; + result.precision(3); result << ",\"cinc.occ\":" << state_cinc.ratio_signal_signal; - const bool carrierOk = DriverCP_GetLevelDemod(sid, "carrier_lock"); - if (isCinC && txEnable) { - if (carrierOk) { - result << R"(,"cinc.correlator":true)"; - } else { - result << R"(,"cinc.correlator":false)"; - } + if (isCinC && modulator.is_tx_on) { + if (state_cinc.carrier_lock) { + result << R"(,"cinc.correlator":true)"; } else { - result << R"(,"cinc.correlator":null)"; + result << R"(,"cinc.correlator":false)"; } - - uint32_t tmpu32 = 0; - 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(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(std::round(std::atof(tmps.c_str()) * 1000))); + } else { + result << R"(,"cinc.correlator":null)"; } + 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; + // структура температур девайса - { - char tmp[32]; - double tmp_adrv_c = 0; - 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.precision(3); result << ",\"device.adrv\":" << device.adrv_temp; + result.precision(3); result << ",\"device.fpga\":" << device.pl_temp; + result.precision(3); result << ",\"device.zync\":" << device.zynq_temp; 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 "{}"; } diff --git a/src/terminal_api_driver.h b/src/terminal_api_driver.h index 8e4a3cb..7f67b6d 100644 --- a/src/terminal_api_driver.h +++ b/src/terminal_api_driver.h @@ -32,6 +32,7 @@ namespace api_driver { TSID sid{0}; unsigned int access{0}; + std::string deviceInitState; }; } diff --git a/static/main.html b/static/main.html index df3fe24..6077e4d 100644 --- a/static/main.html +++ b/static/main.html @@ -11,9 +11,9 @@