Fixed device_name, source, name in spectrogram and transmission mqtt messages.

Author: shajen

sources/config.h

@@ -36,6 +36,12 @@ constexpr auto SPECTROGRAM_PREFERRED_MAX_STEP = 1000;                        //
 constexpr auto SPECTROGRAM_MAX_FFT = 16384;                                  // spectrogram fft limit
 constexpr auto SPECTROGRAM_SEND_INTERVAL = std::chrono::milliseconds(1000);  // send spectrogram data interval
 
+// SOURCE AND RECORDING NAMES
+constexpr auto GAIN_TESTER_SOURCE_NAME = "gain tester";
+constexpr auto GAIN_TESTER_RECORDING_NAME = "auto";
+constexpr auto SCANNER_SOURCE_NAME = "scanner";
+constexpr auto SCANNER_RECORDING_NAME = "auto";
+
 class Config {
  public:
   Config(const ArgConfig& argConfig, const FileConfig& fileConfig);

sources/network/remote_controller.cpp

@@ -32,10 +32,14 @@ void RemoteController::resetTmpConfigResponse(const bool& success) { m_mqtt.publ
 void RemoteController::setTmpConfigQuery(const Mqtt::JsonCallback& callback) { m_mqtt.setJsonMessageCallback(fmt::format("sdr/{}/{}", TMP_CONFIG, m_config.getId()), callback); }
 void RemoteController::setTmpConfigResponse(const bool& success) { m_mqtt.publish(fmt::format("sdr/{}/{}/{}", TMP_CONFIG, m_config.getId(), success ? SUCCESS : FAILED), "", 2); }
 
-void RemoteController::schedulerQuery(const std::string& device, const std::string& query) { m_mqtt.publish(fmt::format("sdr/{}/{}/{}/get", SCHEDULER, m_config.getId(), device), query, 2); }
-void RemoteController::schedulerCallback(const std::string& device, const Mqtt::JsonCallback& callback) {
-  m_mqtt.setJsonMessageCallback(fmt::format("sdr/{}/{}/{}/set", SCHEDULER, m_config.getId(), device), callback);
+void RemoteController::schedulerQuery(const Device& device, const std::string& query) { m_mqtt.publish(fmt::format("sdr/{}/{}/{}/get", SCHEDULER, m_config.getId(), device.getName()), query, 2); }
+void RemoteController::schedulerCallback(const Device& device, const Mqtt::JsonCallback& callback) {
+  m_mqtt.setJsonMessageCallback(fmt::format("sdr/{}/{}/{}/set", SCHEDULER, m_config.getId(), device.getName()), callback);
 }
 
-void RemoteController::sendSpectrogram(const std::string& device, const nlohmann::json& json) { m_mqtt.publish(fmt::format("sdr/{}/{}/{}", SPECTROGRAM, m_config.getId(), device), json.dump(), 2); }
-void RemoteController::sendTransmission(const std::string& device, const nlohmann::json& json) { m_mqtt.publish(fmt::format("sdr/{}/{}/{}", TRANSMISSION, m_config.getId(), device), json.dump(), 2); }
+void RemoteController::sendSpectrogram(const Device& device, const nlohmann::json& json) {
+  m_mqtt.publish(fmt::format("sdr/{}/{}/{}", SPECTROGRAM, m_config.getId(), device.getAliasName()), json.dump(), 2);
+}
+void RemoteController::sendTransmission(const Device& device, const nlohmann::json& json) {
+  m_mqtt.publish(fmt::format("sdr/{}/{}/{}", TRANSMISSION, m_config.getId(), device.getAliasName()), json.dump(), 2);
+}

sources/network/remote_controller.h

@@ -2,6 +2,7 @@
 
 #include <config.h>
 #include <network/mqtt.h>
+#include <radio/help_structures.h>
 
 #include <functional>
 #include <nlohmann/json.hpp>
@@ -22,11 +23,11 @@ class RemoteController {
   void setTmpConfigQuery(const Mqtt::JsonCallback& callback);
   void setTmpConfigResponse(const bool& success);
 
-  void schedulerQuery(const std::string& device, const std::string& query);
-  void schedulerCallback(const std::string& device, const Mqtt::JsonCallback& callback);
+  void schedulerQuery(const Device& device, const std::string& query);
+  void schedulerCallback(const Device& device, const Mqtt::JsonCallback& callback);
 
-  void sendSpectrogram(const std::string& device, const nlohmann::json& json);
-  void sendTransmission(const std::string& device, const nlohmann::json& json);
+  void sendSpectrogram(const Device& device, const nlohmann::json& json);
+  void sendTransmission(const Device& device, const nlohmann::json& json);
 
  private:
   void listCallback(const std::string& data);

sources/radio/blocks/spectrogram.cpp

@@ -2,14 +2,13 @@
 
 #include <config.h>
 #include <logger.h>
-#include <network/query.h>
 #include <utils/utils.h>
 
 constexpr auto LABEL = "spectogram";
 
 Spectrogram::Container::Container(int size) : m_counter(0), m_lastDataSendTime(getTime()) { m_sum.resize(size); }
 
-Spectrogram::Spectrogram(const int itemSize, const Frequency sampleRate, std::function<Frequency()> getFrequency, std::function<void(const nlohmann::json&)> send)
+Spectrogram::Spectrogram(const int itemSize, const Frequency sampleRate, std::function<Frequency()> getFrequency, SendFunction send)
     : gr::sync_block("Spectrogram", gr::io_signature::make(1, 1, sizeof(float) * itemSize), gr::io_signature::make(0, 0, 0)),
       m_inputSize(itemSize),
       m_outputSize(std::min(SPECTROGRAM_MAX_FFT, getFft(sampleRate, SPECTROGRAM_PREFERRED_MAX_STEP))),
@@ -68,8 +67,7 @@ void Spectrogram::send(Container& container) {
     for (int j = 0; j < m_outputSize; ++j) {
       tmp[j] = container.m_sum[j] / container.m_counter;
     }
-    SpectrogramQuery spectrogram("", now, frequency, m_sampleRate, encode_base64(tmp.data(), m_outputSize));
-    m_send(spectrogram);
+    m_send(now, frequency, tmp);
     std::memset(container.m_sum.data(), 0, sizeof(float) * container.m_sum.size());
     container.m_counter = 0;
     container.m_lastDataSendTime = now;

sources/radio/blocks/spectrogram.h

@@ -15,8 +15,10 @@ class Spectrogram : virtual public gr::sync_block {
     std::chrono::milliseconds m_lastDataSendTime;
   };
 
+  using SendFunction = std::function<void(const std::chrono::milliseconds&, const Frequency&, const std::vector<int8_t>&)>;
+
  public:
-  Spectrogram(const int itemSize, const Frequency sampleRate, std::function<Frequency()> getFrequency, std::function<void(const nlohmann::json&)> send);
+  Spectrogram(const int itemSize, const Frequency sampleRate, std::function<Frequency()> getFrequency, SendFunction send);
 
   int work(int noutput_items, gr_vector_const_void_star& input_items, gr_vector_void_star& output_items) override;
 
@@ -29,6 +31,6 @@ class Spectrogram : virtual public gr::sync_block {
   const int m_decimatorFactor;
   const Frequency m_sampleRate;
   const std::function<Frequency()> m_getFrequency;
-  const std::function<void(const nlohmann::json&)> m_send;
+  const SendFunction m_send;
   std::map<Frequency, Container> m_containers;
 };

sources/radio/blocks/transmission.cpp

@@ -158,7 +158,9 @@ std::vector<Recording> Transmission::getSortedTransmissions(const std::chrono::m
   for (const auto& index : indexes) {
     const auto deviceFrequency = m_getFrequency();
     const auto shiftFrequency = getTunedFrequency(m_indexToShift(index), m_config.recordingTuningStep());
-    transmissions.emplace_back("scanner", "", deviceFrequency, deviceFrequency + shiftFrequency, m_config.recordingBandwidth(), "", m_signals.at(index).needFlush(now));
+    const auto source = m_device.alias.empty() ? SCANNER_SOURCE_NAME : GAIN_TESTER_SOURCE_NAME;
+    const auto name = m_device.alias.empty() ? SCANNER_RECORDING_NAME : GAIN_TESTER_RECORDING_NAME;
+    transmissions.emplace_back(source, name, deviceFrequency, deviceFrequency + shiftFrequency, m_config.recordingBandwidth(), "", m_signals.at(index).needFlush(now));
   }
   return transmissions;
 }

sources/radio/help_structures.h

@@ -84,6 +84,7 @@ struct Device {
   std::vector<Crontab> crontabs;
 
   std::string getName() const { return driver + "_" + serial; }
+  std::string getAliasName() const { return alias.empty() ? getName() : alias; }
 };
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(
     Device, connected, enabled, gains, serial, driver, alias, sample_rate, ranges, start_recording_level, stop_recording_level, satellites, sample_rates, crontabs)

sources/radio/scheduler.cpp

@@ -65,7 +65,7 @@ std::optional<std::pair<FrequencyRange, std::vector<Recording>>> Scheduler::getR
 }
 
 void Scheduler::worker() {
-  m_remoteController.schedulerCallback(m_device.getName(), std::bind(&Scheduler::callback, this, _1));
+  m_remoteController.schedulerCallback(m_device, std::bind(&Scheduler::callback, this, _1));
   while (m_isRunning) {
     const auto now = getTime();
     if (m_isRefreshEnabled && m_lastUpdateTime + UPDATE_INTERVAL <= now) {
@@ -79,7 +79,7 @@ void Scheduler::worker() {
 void Scheduler::query() {
   Logger::info(LABEL, "send query");
   const SchedulerQuery query(m_config.latitude(), m_config.longitude(), m_config.altitude(), m_device.satellites, m_device.crontabs);
-  m_remoteController.schedulerQuery(m_device.getName(), static_cast<nlohmann::json>(query).dump());
+  m_remoteController.schedulerQuery(m_device, static_cast<nlohmann::json>(query).dump());
 }
 
 void Scheduler::callback(const nlohmann::json& json) {

sources/radio/sdr_device.cpp

@@ -110,7 +110,7 @@ void SdrDevice::updateRecordings(const std::vector<Recording> recordings) {
       if (m_recorders.size() < static_cast<size_t>(m_config.recordersCount())) {
         const auto sampleRate = m_device.sample_rate;
         m_recorders.push_back(
-            std::make_unique<Recorder>(m_config, m_zeromq, sampleRate, recording, std::bind(&RemoteController::sendTransmission, m_remoteController, m_device.getName(), std::placeholders::_1)));
+            std::make_unique<Recorder>(m_config, m_zeromq, sampleRate, recording, std::bind(&RemoteController::sendTransmission, m_remoteController, m_device, std::placeholders::_1)));
       } else {
         if (!ignoredTransmissions.count(recording.recordingFrequency)) {
           Logger::info(LABEL, "maximum recorders limit reached, frequency: {}", formatFrequency(recording.recordingFrequency, RED));

sources/radio/sdr_processor.cpp

@@ -5,12 +5,14 @@
 #include <gnuradio/blocks/stream_to_vector.h>
 #include <gnuradio/fft/fft_v.h>
 #include <gnuradio/fft/window.h>
+#include <network/query.h>
 #include <radio/blocks/decimator.h>
 #include <radio/blocks/noise_learner.h>
 #include <radio/blocks/psd.h>
 #include <radio/blocks/spectrogram.h>
 #include <radio/blocks/transmission.h>
 #include <utils/radio_utils.h>
+#include <utils/utils.h>
 
 constexpr auto LABEL = "processor";
 
@@ -25,6 +27,10 @@ SdrProcessor::SdrProcessor(
     : m_connector(connector) {
   const auto getFrequency = [frequencyRange]() { return frequencyRange.center(); };
   const auto sampleRate = device.sample_rate;
+  const auto sendSpectrogram = [&remoteController, device, sampleRate](const std::chrono::milliseconds& time, const Frequency& frequency, const std::vector<int8_t>& data) {
+    SpectrogramQuery spectrogram(device.alias.empty() ? SCANNER_SOURCE_NAME : GAIN_TESTER_SOURCE_NAME, time, frequency, sampleRate, encode_base64(data.data(), data.size()));
+    remoteController.sendSpectrogram(device, spectrogram);
+  };
 
   const auto fftSize = getFft(sampleRate, SIGNAL_DETECTION_MAX_STEP);
   const auto step = static_cast<double>(sampleRate) / fftSize;
@@ -43,7 +49,7 @@ SdrProcessor::SdrProcessor(
   const auto transmission = std::make_shared<Transmission>(config, device, fftSize, indexStep, notification, getFrequency, indexToFrequency, indexToShift, isIndexInRange);
   m_connector.connect<Block>(source, s2c, decimator, fft, psd, noiseLearner, transmission);
 
-  const auto spectrogram = std::make_shared<Spectrogram>(fftSize, sampleRate, getFrequency, std::bind(&RemoteController::sendSpectrogram, remoteController, device.getName(), std::placeholders::_1));
+  const auto spectrogram = std::make_shared<Spectrogram>(fftSize, sampleRate, getFrequency, sendSpectrogram);
   m_connector.connect<Block>(psd, spectrogram);
 
   if (DEBUG_SAVE_FULL_POWER) {