Finished RigCTL server

2025-06-26 12:27:51 +02:00 · 2021-07-18 04:30:55 +02:00
parent 2ddb1b93c4
commit 336d69c043
17 changed files with 522 additions and 69 deletions
--- a/rigctl_server/CMakeLists.txt
+++ b/rigctl_server/CMakeLists.txt
@ -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)
--- a/rigctl_server/src/main.cpp
+++ b/rigctl_server/src/main.cpp
@ -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();
 }