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

Compare commits

base: VladislavOstapov:541b08a40e1aee52310c6e9eeafcc409f4e82bd8
Branches Tags
VladislavOstapov:master
VladislavOstapov:v1.1-stable
..
compare: VladislavOstapov:b2ed7ab0155a8bffc8c1ded13cfcb81becd4d093
Branches Tags
VladislavOstapov:master
VladislavOstapov:v1.1-stable

No commits in common. "541b08a40e1aee52310c6e9eeafcc409f4e82bd8" and "b2ed7ab0155a8bffc8c1ded13cfcb81becd4d093" have entirely different histories.
541b08a40e ... b2ed7ab015

13 changed files with 218 additions and 930 deletions
Show Stats Expand all files Collapse all files

2
dependencies/control_system/CMakeLists.txt vendored Executable file → Normal file
View File

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

176
dependencies/control_system/client/main.cpp vendored
View File

@ -1,175 +1,11 @@
#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);
@ -449,16 +285,6 @@ 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)

4
dependencies/control_system/client/sock_client.cpp vendored
View File

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

198
dependencies/control_system/client/system_client.cpp vendored
View File

@ -315,72 +315,6 @@ 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)
@ -743,136 +677,6 @@ 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);
@ -948,4 +752,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;
}
}

12
dependencies/control_system/client/system_client.h vendored
View File

@ -48,18 +48,6 @@ 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);

159
dependencies/control_system/common/protocol_commands.h vendored
View File

@ -47,79 +47,6 @@ 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,
@ -365,15 +292,7 @@ enum class cmd_type
get_network = 27,
set_qos_settings = 28,
get_qos_settings = 29,
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
set_lbq_params = 30
};
struct cmd_lbq_params
@ -387,82 +306,6 @@ 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
{

76
dependencies/control_system/example-get-statistics.cpp vendored
View File

@ -1,76 +0,0 @@
#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;
}
}

86
dependencies/control_system/include/terminal_api/ControlProtoCInterface.h vendored
View File

@ -1,13 +1,14 @@
#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
@ -74,89 +75,6 @@ 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);

5
src/main.cpp
View File

@ -253,13 +253,8 @@ 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;

311
src/terminal_api_driver.cpp
View File

@ -1,7 +1,4 @@
#include "terminal_api_driver.h"
#include <algorithm>
#include "terminal_api/ControlProtoCInterface.h"
#include <sstream>
#include <cmath>
@ -38,124 +35,202 @@ 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 << "{\"initState\":" << buildEscapedString(this->deviceInitState);
result << "{";
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);
const auto txEnable = DriverCP_GetTxPower(sid);
const auto isCinC = DriverCp_GetIsCinC(sid);
result << "\"isCinC\":" << boolAsStr(isCinC);
// формируем структуру для TX
result << ",\"tx.state\":" << boolAsStr(modulator.is_tx_on);
result.precision(2); result << ",\"tx.modcod\":" << modulator.snr_remote;
{
result << ",\"tx.state\":" << boolAsStr(txEnable);
if (modulator.is_short) {
result << R"(,"tx.frameSize":"short")";
} else {
result << R"(,"tx.frameSize":"normal")";
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<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);
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);
{
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.precision(2); result << ",\"rx.snr\":" << demodulator.snr;
result.precision(2); result << ",\"rx.rssi\":" << demodulator.rssi;
result << ",\"rx.modcod\":" << demodulator.modcod;
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);
if (demodulator.is_short) {
result << R"(,"rx.frameSize":"short")";
} else {
result << R"(,"rx.frameSize":"normal")";
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_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;
if (isCinC && modulator.is_tx_on) {
if (state_cinc.carrier_lock) {
result << R"(,"cinc.correlator":true)";
const bool carrierOk = DriverCP_GetLevelDemod(sid, "carrier_lock");
if (isCinC && txEnable) {
if (carrierOk) {
result << R"(,"cinc.correlator":true)";
} else {
result << R"(,"cinc.correlator":false)";
}
} else {
result << R"(,"cinc.correlator":false)";
result << R"(,"cinc.correlator":null)";
}
} else {
result << R"(,"cinc.correlator":null)";
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<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;
result.precision(3); result << ",\"device.fpga\":" << device.pl_temp;
result.precision(3); result << ",\"device.zync\":" << device.zynq_temp;
{
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 << "}";
@ -169,52 +244,6 @@ 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 "{}";
}

1
src/terminal_api_driver.h
View File

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

7
static/fields.css
View File

@ -47,9 +47,6 @@
flex-direction: row;
flex-wrap: wrap;
}
.tabs-item-flex-container > * {
flex: 1 1 auto
}
.tabs-item-flex-container > *, .settings-set-container {
padding: 1em;
@ -60,10 +57,6 @@
.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;

111
static/main.html
View File

@ -11,9 +11,9 @@
<div id="app" hidden>
<div>
<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_good: stat_tx.state === true, indicator: true }"></span></span>
<span class="nav-bar-element">Тест: <span :class="{ indicator_bad: testState === false, indicator_good: testState === true, indicator: true }"></span></span>
<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_tx.state === true, indicator_good: stat_tx.state === false, indicator: true }"></span></span>
<span class="nav-bar-element">Тест: <span :class="{ indicator_bad: testState === true, indicator_good: testState === false, indicator: true }"></span></span>
<!-- Последнее обновление: {{ lastUpdateTime }}-->
</div>
<div class="tabs">
@ -24,7 +24,6 @@
<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>
@ -37,8 +36,7 @@
<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 }}</td></tr>
<tr><th>Размер кадра</th><td>{{ stat_rx.frameSize }}</td></tr>
<tr><th>Modcod/размер кадра</th><td>{{ stat_rx.modcod }} / {{ 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>
@ -209,7 +207,16 @@
<label v-show="param.dvbs2.mode === 'ccm'">
<span>Скорость кода</span>
<select v-model="param.dvbs2.ccm_speed">
<option v-for="speed in getAvailableModcods(param.dvbs2.ccm_modulation)" v-bind:value="speed">{{ speed }}</option>
<option value="1/4">1/4</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>
@ -225,7 +232,16 @@
<label v-show="param.dvbs2.mode === 'acm'">
<span>Скорость кода (макс. режим)</span>
<select v-model="param.dvbs2.acm_maxSpeed">
<option v-for="speed in getAvailableModcods(param.dvbs2.acm_maxModulation)" v-bind:value="speed">{{ speed }}</option>
<option value="1/4">1/4</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'">
@ -240,7 +256,16 @@
<label v-show="param.dvbs2.mode === 'acm'">
<span>Скорость кода (мин. режим)</span>
<select v-model="param.dvbs2.acm_minSpeed">
<option v-for="speed in getAvailableModcods(param.dvbs2.acm_minModulation)" v-bind:value="speed">{{ speed }}</option>
<option value="'1/4'">1/4</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>
@ -356,49 +381,8 @@
return defaultTab
}
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]
}
// TODO: взять модкоды из раздела 5.5.2.2 https://www.etsi.org/deliver/etsi_en/302300_302399/302307/01.01.02_60/en_302307v010102p.pdf
// и прикрутить декодинг модкода
const app = new Vue({
el: '#app',
@ -503,29 +487,14 @@
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"]
@ -537,7 +506,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 = modcodToStr(vals["mainState"]["rx.modcod"])
this.stat_rx.modcod = 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"]
@ -553,7 +522,7 @@
this.stat_tx.state = vals["mainState"]["tx.state"]
this.stat_tx.snr = vals["mainState"]["rx.snr"]
this.stat_tx.modcod = modcodToStr(vals["mainState"]["rx.modcod"])
this.stat_tx.modcod = 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"]