mirror/SDRPlusPlus
0
0
Fork 0
mirror of https://github.com/AlexandreRouma/SDRPlusPlus.git synced 2024-11-10 04:37:37 +01:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Finished RigCTL server

Browse Source
This commit is contained in:
Ryzerth 2021-07-18 04:30:55 +02:00
parent 2ddb1b93c4
commit 336d69c043
17 changed files with 522 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
core/src/core.cpp
View File

@ -187,6 +187,7 @@ int sdrpp_main(int argc, char *argv[]) {
defConfig["moduleInstances"]["Frequency Manager"] = "frequency_manager";
defConfig["moduleInstances"]["Recorder"] = "recorder";
defConfig["moduleInstances"]["Rigctl Server"] = "rigctl_server";
// Themes

1
core/src/credits.cpp
View File

@ -2,7 +2,6 @@
namespace sdrpp_credits {
const char* contributors[] = {
"Alexandre Rouma (Author)",
"Aang23",
"Alexsey Shestacov",
"Aosync",

123
core/src/dsp/convertion.h
View File

@ -219,4 +219,127 @@ namespace dsp {
stream<int16_t>* _in;
};
class ComplexToInt16C : public generic_block<ComplexToInt16C> {
public:
ComplexToInt16C() {}
ComplexToInt16C(stream<complex_t>* in) { init(in); }
void init(stream<complex_t>* in) {
_in = in;
generic_block<ComplexToInt16C>::registerInput(_in);
generic_block<ComplexToInt16C>::registerOutput(&out);
generic_block<ComplexToInt16C>::_block_init = true;
}
void setInput(stream<complex_t>* in) {
assert(generic_block<ComplexToInt16C>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<ComplexToInt16C>::ctrlMtx);
generic_block<ComplexToInt16C>::tempStop();
generic_block<ComplexToInt16C>::unregisterInput(_in);
_in = in;
generic_block<ComplexToInt16C>::registerInput(_in);
generic_block<ComplexToInt16C>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_32f_s32f_convert_16i(out.writeBuf, (float*)_in->readBuf, 32768.0f, count * 2);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<int16_t> out;
private:
stream<complex_t>* _in;
};
class Int16ToFloat : public generic_block<Int16ToFloat> {
public:
Int16ToFloat() {}
Int16ToFloat(stream<int16_t>* in) { init(in); }
void init(stream<int16_t>* in) {
_in = in;
generic_block<Int16ToFloat>::registerInput(_in);
generic_block<Int16ToFloat>::registerOutput(&out);
generic_block<Int16ToFloat>::_block_init = true;
}
void setInput(stream<int16_t>* in) {
assert(generic_block<Int16ToFloat>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<Int16ToFloat>::ctrlMtx);
generic_block<Int16ToFloat>::tempStop();
generic_block<Int16ToFloat>::unregisterInput(_in);
_in = in;
generic_block<Int16ToFloat>::registerInput(_in);
generic_block<Int16ToFloat>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_16i_s32f_convert_32f(out.writeBuf, _in->readBuf, 32768.0f, count);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<float> out;
private:
stream<int16_t>* _in;
};
class FloatToInt16 : public generic_block<FloatToInt16> {
public:
FloatToInt16() {}
FloatToInt16(stream<float>* in) { init(in); }
void init(stream<float>* in) {
_in = in;
generic_block<FloatToInt16>::registerInput(_in);
generic_block<FloatToInt16>::registerOutput(&out);
generic_block<FloatToInt16>::_block_init = true;
}
void setInput(stream<float>* in) {
assert(generic_block<FloatToInt16>::_block_init);
std::lock_guard<std::mutex> lck(generic_block<FloatToInt16>::ctrlMtx);
generic_block<FloatToInt16>::tempStop();
generic_block<FloatToInt16>::unregisterInput(_in);
_in = in;
generic_block<FloatToInt16>::registerInput(_in);
generic_block<FloatToInt16>::tempStart();
}
int run() {
int count = _in->read();
if (count < 0) { return -1; }
volk_32f_s32f_convert_16i(out.writeBuf, _in->readBuf, 32768.0f, count);
_in->flush();
if (!out.swap(count)) { return -1; }
return count;
}
stream<int16_t> out;
private:
stream<float>* _in;
};
}

4
core/src/gui/dialogs/credits.cpp
View File

@ -27,7 +27,7 @@ namespace credits {
ImGui::Spacing();
ImGui::Spacing();
ImGui::Text("This software is brought to you by\n\n");
ImGui::Text("This software is brought to you by Alexandre Rouma with the help of\n\n");
ImGui::Columns(3, "CreditColumns", true);
@ -53,7 +53,7 @@ namespace credits {
ImGui::Spacing();
ImGui::Spacing();
ImGui::Spacing();
ImGui::Text("SDR++ v" VERSION_STR);
ImGui::Text("SDR++ v" VERSION_STR " (Built at " __TIME__ ", " __DATE__ ")");
ImVec2 dispSize = ImGui::GetIO().DisplaySize;
ImVec2 winSize = ImGui::GetWindowSize();

4
core/src/gui/main_window.cpp
View File

@ -87,7 +87,7 @@ void MainWindow::init() {
vfoCreatedHandler.handler = vfoAddedHandler;
vfoCreatedHandler.ctx = this;
sigpath::vfoManager.vfoCreatedEvent.bindHandler(&vfoCreatedHandler);
sigpath::vfoManager.onVfoCreated.bindHandler(&vfoCreatedHandler);
spdlog::info("Loading modules");
@ -211,6 +211,8 @@ void MainWindow::init() {
}
initComplete = true;
onInitComplete.emit(true);
}
void MainWindow::fftHandler(dsp::complex_t* samples, int count, void* ctx) {

1
core/src/gui/main_window.h
View File

@ -34,6 +34,7 @@ public:
bool lockWaterfallControls = false;
Event<bool> onPlayStateChange;
Event<bool> onInitComplete;
private:
void generateFFTWindow(int win, int size);

2
core/src/gui/menus/vfo_color.cpp
View File

@ -72,7 +72,7 @@ namespace vfo_color_menu {
}
vfoAddHndl.handler = vfoAddHandler;
sigpath::vfoManager.vfoCreatedEvent.bindHandler(&vfoAddHndl);
sigpath::vfoManager.onVfoCreated.bindHandler(&vfoAddHndl);
core::configManager.release(modified);
}

6
core/src/gui/tuner.cpp
View File

@ -5,7 +5,10 @@
namespace tuner {
void centerTuning(std::string vfoName, double freq) {
if (vfoName != "") { sigpath::vfoManager.setOffset(vfoName, 0); }
if (vfoName != "") {
if (gui::waterfall.vfos.find(vfoName) == gui::waterfall.vfos.end()) { return; }
sigpath::vfoManager.setOffset(vfoName, 0);
}
double BW = gui::waterfall.getBandwidth();
double viewBW = gui::waterfall.getViewBandwidth();
gui::waterfall.setViewOffset((BW / 2.0) - (viewBW / 2.0));
@ -20,6 +23,7 @@ namespace tuner {
centerTuning(vfoName, freq);
return;
}
if (gui::waterfall.vfos.find(vfoName) == gui::waterfall.vfos.end()) { return; }
double viewBW = gui::waterfall.getViewBandwidth();
double BW = gui::waterfall.getBandwidth();

11
core/src/module.cpp
View File

@ -97,6 +97,7 @@ void ModuleManager::createInstance(std::string name, std::string module) {
inst.module = modules[module];
inst.instance = inst.module.createInstance(name);
instances[name] = inst;
onInstanceCreated.emit(name);
}
void ModuleManager::deleteInstance(std::string name) {
@ -104,9 +105,11 @@ void ModuleManager::deleteInstance(std::string name) {
spdlog::error("Tried to remove non-existant instance '{0}'", name);
return;
}
onInstanceDelete.emit(name);
Instance_t inst = instances[name];
inst.module.deleteInstance(inst.instance);
instances.erase(name);
onInstanceDeleted.emit(name);
}
void ModuleManager::deleteInstance(ModuleManager::Instance* instance) {
@ -137,6 +140,14 @@ bool ModuleManager::instanceEnabled(std::string name) {
return instances[name].instance->isEnabled();
}
std::string ModuleManager::getInstanceModuleName(std::string name) {
if (instances.find(name) == instances.end()) {
spdlog::error("Cannot get module name of'{0}', instance doesn't exist", name);
return false;
}
return std::string(instances[name].module.info->name);
}
int ModuleManager::countModuleInstances(std::string module) {
if (modules.find(module) == modules.end()) {
spdlog::error("Cannot count instances of '{0}', Module doesn't exist", module);

6
core/src/module.h
View File

@ -2,6 +2,7 @@
#include <string>
#include <map>
#include <json.hpp>
#include <utils/event.h>
#ifdef _WIN32
#ifdef SDRPP_IS_CORE
@ -83,9 +84,14 @@ public:
void enableInstance(std::string name);
void disableInstance(std::string name);
bool instanceEnabled(std::string name);
std::string getInstanceModuleName(std::string name);
int countModuleInstances(std::string module);
Event<std::string> onInstanceCreated;
Event<std::string> onInstanceDelete;
Event<std::string> onInstanceDeleted;
std::map<std::string, ModuleManager::Module_t> modules;
std::map<std::string, ModuleManager::Instance_t> instances;

5
core/src/signal_path/vfo_manager.cpp
View File

@ -92,7 +92,7 @@ VFOManager::VFO* VFOManager::createVFO(std::string name, int reference, double o
}
VFOManager::VFO* vfo = new VFO(name, reference, offset, bandwidth, sampleRate, minBandwidth, maxBandwidth, bandwidthLocked);
vfos[name] = vfo;
vfoCreatedEvent.emit(vfo);
onVfoCreated.emit(vfo);
return vfo;
}
@ -107,9 +107,10 @@ void VFOManager::deleteVFO(VFOManager::VFO* vfo) {
if (name == "") {
return;
}
vfoDeletedEvent.emit(vfo);
onVfoDelete.emit(vfo);
vfos.erase(name);
delete vfo;
onVfoDeleted.emit(name);
}
void VFOManager::setOffset(std::string name, double offset) {

5
core/src/signal_path/vfo_manager.h
View File

@ -54,8 +54,9 @@ public:
void updateFromWaterfall(ImGui::WaterFall* wtf);
Event<VFOManager::VFO*> vfoCreatedEvent;
Event<VFOManager::VFO*> vfoDeletedEvent;
Event<VFOManager::VFO*> onVfoCreated;
Event<VFOManager::VFO*> onVfoDelete;
Event<std::string> onVfoDeleted;
private:
std::map<std::string, VFO*> vfos;

51
meteor_demodulator/src/main.cpp
View File

@ -15,7 +15,7 @@
#include <dsp/processing.h>
#include <dsp/routing.h>
#include <dsp/sink.h>
#include <meteor_demodulator_interface.h>
#include <gui/widgets/folder_select.h>
#include <gui/widgets/constellation_diagram.h>
@ -76,6 +76,7 @@ public:
sink.start();
gui::menu.registerEntry(name, menuHandler, this, this);
core::modComManager.registerInterface("meteor_demodulator", name, moduleInterfaceHandler, this);
}
~MeteorDemodulatorModule() {
@ -146,26 +147,13 @@ private:
if (_this->recording) {
if (ImGui::Button(CONCAT("Stop##_recorder_rec_", _this->name), ImVec2(menuWidth, 0))) {
std::lock_guard<std::mutex> lck(_this->recMtx);
_this->recording = false;
_this->recFile.close();
_this->dataWritten = 0;
_this->stopRecording();
}
ImGui::TextColored(ImVec4(1.0f, 0.0f, 0.0f, 1.0f), "Recording %.2fMB", (float)_this->dataWritten / 1000000.0f);
}
else {
if (ImGui::Button(CONCAT("Record##_recorder_rec_", _this->name), ImVec2(menuWidth, 0))) {
std::lock_guard<std::mutex> lck(_this->recMtx);
_this->dataWritten = 0;
std::string filename = genFileName(_this->folderSelect.expandString(_this->folderSelect.path) + "/meteor", ".s");
_this->recFile = std::ofstream(filename, std::ios::binary);
if (_this->recFile.is_open()) {
spdlog::info("Recording to '{0}'", filename);
_this->recording = true;
}
else {
spdlog::error("Could not open file for recording!");
}
_this->startRecording();
}
ImGui::Text("Idle --.--MB");
}
@ -195,6 +183,37 @@ private:
_this->dataWritten += count * 2;
}
void startRecording() {
std::lock_guard<std::mutex> lck(recMtx);
dataWritten = 0;
std::string filename = genFileName(folderSelect.expandString(folderSelect.path) + "/meteor", ".s");
recFile = std::ofstream(filename, std::ios::binary);
if (recFile.is_open()) {
spdlog::info("Recording to '{0}'", filename);
recording = true;
}
else {
spdlog::error("Could not open file for recording!");
}
}
void stopRecording() {
std::lock_guard<std::mutex> lck(recMtx);
recording = false;
recFile.close();
dataWritten = 0;
}
static void moduleInterfaceHandler(int code, void* in, void* out, void* ctx) {
MeteorDemodulatorModule* _this = (MeteorDemodulatorModule*)ctx;
if (code == METEOR_DEMODULATOR_IFACE_CMD_START) {
if (!_this->recording) { _this->startRecording(); }
}
else if (code == METEOR_DEMODULATOR_IFACE_CMD_STOP) {
if (_this->recording) { _this->stopRecording(); }
}
}
std::string name;
bool enabled = true;

6
meteor_demodulator/src/meteor_demodulator_interface.h Normal file
View File

@ -0,0 +1,6 @@
#pragma once
enum {
METEOR_DEMODULATOR_IFACE_CMD_START,
METEOR_DEMODULATOR_IFACE_CMD_STOP
};

2
recorder/src/main.cpp
View File

@ -39,7 +39,7 @@ std::string genFileName(std::string prefix, bool isVfo, std::string name = "") {
tm *ltm = localtime(&now);
char buf[1024];
double freq = gui::waterfall.getCenterFrequency();;
if (isVfo) {
if (isVfo && gui::waterfall.vfos.find(name) != gui::waterfall.vfos.end()) {
freq += gui::waterfall.vfos[name]->generalOffset;
}
sprintf(buf, "%.0lfHz_%02d-%02d-%02d_%02d-%02d-%02d.wav", freq, ltm->tm_hour, ltm->tm_min, ltm->tm_sec, ltm->tm_mday, ltm->tm_mon + 1, ltm->tm_year + 1900);

1
rigctl_server/CMakeLists.txt
View File

@ -13,6 +13,7 @@ file(GLOB SRC "src/*.cpp")
include_directories("src/")
include_directories("../recorder/src")
include_directories("../meteor_demodulator/src")
add_library(rigctl_server SHARED ${SRC})
target_link_libraries(rigctl_server PRIVATE sdrpp_core)

362
rigctl_server/src/main.cpp
View File

@ -6,7 +6,12 @@
#include <signal_path/signal_path.h>
#include <core.h>
#include <recorder_interface.h>
#include <meteor_demodulator_interface.h>
#include <config.h>
#include <options.h>
#define CONCAT(a, b) ((std::string(a) + b).c_str())
#define MAX_COMMAND_LENGTH 8192
SDRPP_MOD_INFO {
/* Name: */ "rigctl_server",
@ -16,18 +21,48 @@ SDRPP_MOD_INFO {
/* Max instances */ -1
};
enum {
RECORDER_TYPE_RECORDER,
RECORDER_TYPE_METEOR_DEMODULATOR
};
ConfigManager config;
class SigctlServerModule : public ModuleManager::Instance {
public:
SigctlServerModule(std::string name) {
this->name = name;
strcpy(hostname, "localhost");
config.acquire();
if (!config.conf.contains(name)) {
config.conf[name]["host"] = "localhost";
config.conf[name]["port"] = 4532;
config.conf[name]["tuning"] = true;
config.conf[name]["recording"] = false;
config.conf[name]["autoStart"] = false;
config.conf[name]["vfo"] = "";
config.conf[name]["recorder"] = "";
}
std::string host = config.conf[name]["host"];
strcpy(hostname, host.c_str());
port = config.conf[name]["port"];
tuningEnabled = config.conf[name]["tuning"];
recordingEnabled = config.conf[name]["recording"];
autoStart = config.conf[name]["autoStart"];
selectedVfo = config.conf[name]["vfo"];
selectedRecorder = config.conf[name]["recorder"];
config.release(true);
initHandler.handler = _initHandler;
initHandler.ctx = this;
gui::mainWindow.onInitComplete.bindHandler(&initHandler);
gui::menu.registerEntry(name, menuHandler, this, NULL);
}
~SigctlServerModule() {
gui::menu.removeEntry(name);
// TODO: Use several handler instead of one for the recorders and remove event bindings
}
void enable() {
@ -50,36 +85,77 @@ private:
bool listening = (_this->listener && _this->listener->isListening());
if (listening) { style::beginDisabled(); }
ImGui::InputText("##testestssss", _this->hostname, 1023);
if (ImGui::InputText(CONCAT("##_rigctl_srv_host_", _this->name), _this->hostname, 1023)) {
config.acquire();
config.conf[_this->name]["host"] = std::string(_this->hostname);
config.release(true);
}
ImGui::SameLine();
ImGui::SetNextItemWidth(menuWidth - ImGui::GetCursorPosX());
ImGui::InputInt("##anothertest", &_this->port, 0, 0);
if (ImGui::InputInt(CONCAT("##_rigctl_srv_port_", _this->name), &_this->port, 0, 0)) {
config.acquire();
config.conf[_this->name]["port"] = _this->port;
config.release(true);
}
if (listening) { style::endDisabled(); }
int test = 0;
ImGui::Text("Controlled VFO");
ImGui::SameLine();
ImGui::SetNextItemWidth(menuWidth - ImGui::GetCursorPosX());
ImGui::Combo("##anotesssss", &test, "Radio\0");
{
std::lock_guard lck(_this->vfoMtx);
if (ImGui::Combo(CONCAT("##_rigctl_srv_vfo_", _this->name), &_this->vfoId, _this->vfoNamesTxt.c_str())) {
_this->selectVfoByName(_this->vfoNames[_this->vfoId], false);
}
if (!_this->selectedVfo.empty()) {
config.acquire();
config.conf[_this->name]["vfo"] = _this->selectedVfo;
config.release(true);
}
}
ImGui::Text("Controlled Recorder");
ImGui::SameLine();
ImGui::SetNextItemWidth(menuWidth - ImGui::GetCursorPosX());
ImGui::Combo("##anotesssss2", &test, "Recorder\0");
if (listening && ImGui::Button("Stop##lasttestamirite", ImVec2(menuWidth, 0))) {
if (_this->client) { _this->client->close(); }
_this->listener->close();
{
std::lock_guard lck(_this->vfoMtx);
if (ImGui::Combo(CONCAT("##_rigctl_srv_rec_", _this->name), &_this->recorderId, _this->recorderNamesTxt.c_str())) {
_this->selectRecorderByName(_this->recorderNames[_this->recorderId], false);
}
if (!_this->selectedRecorder.empty()) {
config.acquire();
config.conf[_this->name]["recorder"] = _this->selectedRecorder;
config.release(true);
}
}
else if (!listening && ImGui::Button("Start##lasttestamirite", ImVec2(menuWidth, 0))) {
try {
_this->listener = net::listen(net::PROTO_TCP, _this->hostname, _this->port);
_this->listener->acceptAsync(clientHandler, _this);
}
catch (std::exception e) {
spdlog::error("Could not start rigctl server: {0}", e.what());
}
ImGui::BeginTable(CONCAT("Stop##_rigctl_srv_tbl_", _this->name), 2);
ImGui::TableNextRow();
ImGui::TableSetColumnIndex(0);
if (ImGui::Checkbox(CONCAT("Tuning##_rigctl_srv_tune_ena_", _this->name), &_this->tuningEnabled)) {
config.acquire();
config.conf[_this->name]["tuning"] = _this->tuningEnabled;
config.release(true);
}
ImGui::TableSetColumnIndex(1);
if (ImGui::Checkbox(CONCAT("Recording##_rigctl_srv_tune_ena_", _this->name), &_this->recordingEnabled)) {
config.acquire();
config.conf[_this->name]["recording"] = _this->recordingEnabled;
config.release(true);
}
ImGui::EndTable();
if (ImGui::Checkbox(CONCAT("Listen on startup##_rigctl_srv_auto_lst_", _this->name), &_this->autoStart)) {
config.acquire();
config.conf[_this->name]["autoStart"] = _this->autoStart;
config.release(true);
}
if (listening && ImGui::Button(CONCAT("Stop##_rigctl_srv_stop_", _this->name), ImVec2(menuWidth, 0))) {
_this->stopServer();
}
else if (!listening && ImGui::Button(CONCAT("Start##_rigctl_srv_stop_", _this->name), ImVec2(menuWidth, 0))) {
_this->startServer();
}
ImGui::Text("Status:");
@ -95,16 +171,151 @@ private:
}
}
void startServer() {
try {
listener = net::listen(net::PROTO_TCP, hostname, port);
listener->acceptAsync(clientHandler, this);
}
catch (std::exception e) {
spdlog::error("Could not start rigctl server: {0}", e.what());
}
}
void stopServer() {
if (client) { client->close(); }
listener->close();
}
void refreshModules() {
vfoNames.clear();
vfoNamesTxt.clear();
recorderNames.clear();
recorderNamesTxt.clear();
// List recording capable modules
for (auto const& [_name, inst] : core::moduleManager.instances) {
std::string mod = core::moduleManager.getInstanceModuleName(_name);
if (mod != "recorder" && mod != "meteor_demodulator") { continue; }
recorderNames.push_back(_name);
recorderNamesTxt += _name;
recorderNamesTxt += '\0';
}
// List VFOs
for (auto const& [_name, vfo] : gui::waterfall.vfos) {
vfoNames.push_back(_name);
vfoNamesTxt += _name;
vfoNamesTxt += '\0';
}
}
void selectVfoByName(std::string _name, bool lock = true) {
if (vfoNames.empty()) {
if (lock) { std::lock_guard lck(vfoMtx); }
selectedVfo.clear();
return;
}
// Find the ID of the VFO, if not found, select first VFO in the list
auto vfoIt = std::find(vfoNames.begin(), vfoNames.end(), _name);
if (vfoIt == vfoNames.end()) {
selectVfoByName(vfoNames[0]);
return;
}
// Select the VFO
{
if (lock) { std::lock_guard lck(vfoMtx); }
vfoId = std::distance(vfoNames.begin(), vfoIt);
selectedVfo = _name;
}
}
void selectRecorderByName(std::string _name, bool lock = true) {
if (recorderNames.empty()) {
if (lock) { std::lock_guard lck(recorderMtx); }
selectedRecorder.clear();
return;
}
// Find the ID of the VFO, if not found, select first VFO in the list
auto recIt = std::find(recorderNames.begin(), recorderNames.end(), _name);
if (recIt == recorderNames.end()) {
selectRecorderByName(recorderNames[0]);
return;
}
std::string type = core::modComManager.getModuleName(_name);
// Select the VFO
{
if (lock) { std::lock_guard lck(recorderMtx); }
recorderId = std::distance(recorderNames.begin(), recIt);
selectedRecorder = _name;
if (type == "meteor_demodulator") {
recorderType = RECORDER_TYPE_METEOR_DEMODULATOR;
}
else {
recorderType = RECORDER_TYPE_RECORDER;
}
}
}
static void _initHandler(bool dummy, void* ctx) {
SigctlServerModule* _this = (SigctlServerModule*)ctx;
// Refresh modules
_this->refreshModules();
// Select VFO and recorder from config
_this->selectVfoByName(_this->selectedVfo);
_this->selectRecorderByName(_this->selectedRecorder);
// Bind handlers
_this->vfoCreatedHandler.handler = _vfoCreatedHandler;
_this->vfoCreatedHandler.ctx = _this;
_this->vfoDeletedHandler.handler = _vfoDeletedHandler;
_this->vfoDeletedHandler.ctx = _this;
_this->modChangedHandler.handler = _modChangeHandler;
_this->modChangedHandler.ctx = _this;
sigpath::vfoManager.onVfoCreated.bindHandler(&_this->vfoCreatedHandler);
sigpath::vfoManager.onVfoDeleted.bindHandler(&_this->vfoDeletedHandler);
core::moduleManager.onInstanceCreated.bindHandler(&_this->modChangedHandler);
core::moduleManager.onInstanceDeleted.bindHandler(&_this->modChangedHandler);
// If autostart is enabled, start the server
if (_this->autoStart) { _this->startServer(); }
}
static void _vfoCreatedHandler(VFOManager::VFO* vfo, void* ctx) {
SigctlServerModule* _this = (SigctlServerModule*)ctx;
_this->refreshModules();
_this->selectVfoByName(_this->selectedVfo);
}
static void _vfoDeletedHandler(std::string _name, void* ctx) {
SigctlServerModule* _this = (SigctlServerModule*)ctx;
_this->refreshModules();
_this->selectVfoByName(_this->selectedVfo);
}
static void _modChangeHandler(std::string _name, void* ctx) {
SigctlServerModule* _this = (SigctlServerModule*)ctx;
_this->refreshModules();
_this->selectRecorderByName(_this->selectedRecorder);
}
static void clientHandler(net::Conn _client, void* ctx) {
SigctlServerModule* _this = (SigctlServerModule*)ctx;
spdlog::info("New client!");
//spdlog::info("New client!");
_this->client = std::move(_client);
_this->client->readAsync(1024, _this->dataBuf, dataHandler, _this);
_this->client->waitForEnd();
_this->client->close();
spdlog::info("Client disconnected!");
//spdlog::info("Client disconnected!");
_this->listener->acceptAsync(clientHandler, _this);
}
@ -118,7 +329,7 @@ private:
_this->command.clear();
continue;
}
_this->command += (char)data[i];
if (_this->command.size() < MAX_COMMAND_LENGTH) { _this->command += (char)data[i]; }
}
_this->client->readAsync(1024, _this->dataBuf, dataHandler, _this);
@ -152,6 +363,8 @@ private:
// Execute commands
if (parts.size() == 0) { return; }
else if (parts[0] == "F") {
std::lock_guard lck(vfoMtx);
// if number of arguments isn't correct, return error
if (parts.size() != 2) {
resp = "RPRT 1\n";
@ -159,33 +372,74 @@ private:
return;
}
// Parse frequency and assign it to the VFO
long long freq = std::stoll(parts[1]);
resp = "RPRT 0\n";
client->write(resp.size(), (uint8_t*)resp.c_str());
tuner::tune(tuner::TUNER_MODE_NORMAL, gui::waterfall.selectedVFO, freq);
}
else if (parts[0] == "f") {
double freq = gui::waterfall.getCenterFrequency();
// Get frequency of VFO if it exists
if (sigpath::vfoManager.vfoExists(gui::waterfall.selectedVFO)) {
freq += sigpath::vfoManager.getOffset(gui::waterfall.selectedVFO);
// If not controlling the VFO, return
if (!tuningEnabled) {
resp = "RPRT 0\n";
client->write(resp.size(), (uint8_t*)resp.c_str());
return;
}
// Parse frequency and assign it to the VFO
long long freq = std::stoll(parts[1]);
tuner::tune(tuner::TUNER_MODE_NORMAL, selectedVfo, freq);
resp = "RPRT 0\n";
client->write(resp.size(), (uint8_t*)resp.c_str());
}
else if (parts[0] == "f") {
std::lock_guard lck(vfoMtx);
// Get center frequency of the SDR
double freq = gui::waterfall.getCenterFrequency();
// Add the offset of the VFO if it exists
if (sigpath::vfoManager.vfoExists(selectedVfo)) {
freq += sigpath::vfoManager.getOffset(selectedVfo);
}
// Respond with the frequency
char buf[128];
sprintf(buf, "%" PRIu64 "\n", (uint64_t)freq);
client->write(strlen(buf), (uint8_t*)buf);
}
else if (parts[0] == "AOS") {
// TODO: Start Recorder
core::modComManager.callInterface("Recorder", RECORDER_IFACE_CMD_START, NULL, NULL);
std::lock_guard lck(recorderMtx);
// If not controlling the recorder, return
if (!recordingEnabled) {
resp = "RPRT 0\n";
client->write(resp.size(), (uint8_t*)resp.c_str());
return;
}
// Send the command to the selected recorder
if (recorderType == RECORDER_TYPE_METEOR_DEMODULATOR) {
core::modComManager.callInterface(selectedRecorder, METEOR_DEMODULATOR_IFACE_CMD_START, NULL, NULL);
}
else {
core::modComManager.callInterface(selectedRecorder, RECORDER_IFACE_CMD_START, NULL, NULL);
}
// Respond with a sucess
resp = "RPRT 0\n";
client->write(resp.size(), (uint8_t*)resp.c_str());
}
else if (parts[0] == "LOS") {
// TODO: Stop Recorder
core::modComManager.callInterface("Recorder", RECORDER_IFACE_CMD_STOP, NULL, NULL);
std::lock_guard lck(recorderMtx);
// If not controlling the recorder, return
if (!recordingEnabled) {
resp = "RPRT 0\n";
client->write(resp.size(), (uint8_t*)resp.c_str());
return;
}
// Send the command to the selected recorder
if (recorderType == RECORDER_TYPE_METEOR_DEMODULATOR) {
core::modComManager.callInterface(selectedRecorder, METEOR_DEMODULATOR_IFACE_CMD_STOP, NULL, NULL);
}
else {
core::modComManager.callInterface(selectedRecorder, RECORDER_IFACE_CMD_STOP, NULL, NULL);
}
// Respond with a sucess
resp = "RPRT 0\n";
client->write(resp.size(), (uint8_t*)resp.c_str());
}
@ -211,10 +465,33 @@ private:
std::string command = "";
EventHandler<bool> initHandler;
EventHandler<std::string> modChangedHandler;
EventHandler<VFOManager::VFO*> vfoCreatedHandler;
EventHandler<std::string> vfoDeletedHandler;
std::vector<std::string> vfoNames;
std::string vfoNamesTxt;
std::vector<std::string> recorderNames;
std::string recorderNamesTxt;
std::mutex vfoMtx;
std::mutex recorderMtx;
std::string selectedVfo = "";
std::string selectedRecorder = "";
int vfoId = 0;
int recorderId = 0;
int recorderType = RECORDER_TYPE_RECORDER;
bool tuningEnabled = true;
bool recordingEnabled = false;
bool autoStart = false;
};
MOD_EXPORT void _INIT_() {
// Nothing here
config.setPath(options::opts.root + "/rigctl_server_config.json");
config.load(json::object());
config.enableAutoSave();
}
MOD_EXPORT ModuleManager::Instance* _CREATE_INSTANCE_(std::string name) {
@ -226,5 +503,6 @@ MOD_EXPORT void _DELETE_INSTANCE_(void* instance) {
}
MOD_EXPORT void _END_() {
// Nothing here
config.disableAutoSave();
config.save();
}