Updated Recording.

Author: shajen

sources/application.cpp

@@ -24,7 +24,7 @@ Application::Application(nlohmann::json& tmpJson, const ArgConfig& argConfig)
       if (!device.enabled) {
         Logger::info(LABEL, "device disabled, skipping: {}", colored(GREEN, "{}", device.getName()));
       } else {
-        m_scanners.push_back(std::make_unique<Scanner>(m_config, device, m_mqtt, m_remoteController, m_config.recordersCount()));
+        m_scanners.push_back(std::make_unique<Scanner>(m_config, device, m_remoteController, m_config.recordersCount()));
       }
     } catch (const std::exception& exception) {
       Logger::exception(LABEL, exception, SPDLOG_LOC, "open device failed: {}", device.getName());

sources/network/data_controller.cpp

@@ -13,11 +13,32 @@ struct SchedulerQuery {
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(SchedulerQuery, latitude, longitude, altitude, satellites, crontabs)
 
 struct ScheduledTransmission {
+  std::string source;
   std::string name;
   std::chrono::seconds begin;
   std::chrono::seconds end;
   Frequency frequency;
   Frequency bandwidth;
   std::string modulation;
 };
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(ScheduledTransmission, name, begin, end, frequency, bandwidth, modulation)
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(ScheduledTransmission, source, name, begin, end, frequency, bandwidth, modulation)
+
+struct SpectrogramQuery {
+  std::string source;
+  std::chrono::milliseconds time;
+  Frequency frequency;
+  Frequency sample_rate;
+  std::string data;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(SpectrogramQuery, source, time, frequency, sample_rate, data)
+
+struct TransmissionQuery {
+  std::string source;
+  std::string name;
+  std::chrono::milliseconds time;
+  Frequency frequency;
+  Frequency bandwidth;
+  std::string modulation;
+  std::string data;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(TransmissionQuery, source, name, time, frequency, bandwidth, modulation, data)

sources/network/data_controller.h

@@ -13,6 +13,8 @@ constexpr auto SCHEDULER = "scheduler";
 constexpr auto SUCCESS = "success";
 constexpr auto FAILED = "failed";
 constexpr auto LABEL = "remote";
+constexpr auto SPECTROGRAM = "spectrogram";
+constexpr auto TRANSMISSION = "transmission";
 
 using namespace std::placeholders;
 
@@ -34,3 +36,6 @@ void RemoteController::schedulerQuery(const std::string& device, const std::stri
 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::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); }

sources/network/query.h

@@ -25,6 +25,9 @@ class RemoteController {
   void schedulerQuery(const std::string& device, const std::string& query);
   void schedulerCallback(const std::string& 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);
+
  private:
   void listCallback(const std::string& data);
 

sources/network/remote_controller.cpp

@@ -2,20 +2,21 @@
 
 #include <config.h>
 #include <logger.h>
+#include <network/query.h>
 #include <utils/utils.h>
 
 constexpr auto LABEL = "spectogram";
 
 Spectrogram::Container::Container(int size) : m_lastDataSendTime(getTime()) { m_sum.resize(size); }
 
-Spectrogram::Spectrogram(const int itemSize, const Frequency sampleRate, DataController& dataController, std::function<Frequency()> getFrequency)
+Spectrogram::Spectrogram(const int itemSize, const Frequency sampleRate, std::function<Frequency()> getFrequency, std::function<void(const nlohmann::json&)> 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))),
       m_decimatorFactor(m_inputSize / m_outputSize),
       m_sampleRate(sampleRate),
-      m_dataController(dataController),
-      m_getFrequency(getFrequency) {
+      m_getFrequency(getFrequency),
+      m_send(send) {
   const auto step = m_sampleRate / m_outputSize;
   Logger::info(
       LABEL,
@@ -67,7 +68,8 @@ void Spectrogram::send(Container& container) {
     for (int j = 0; j < m_outputSize; ++j) {
       tmp[j] = container.m_sum[j] / container.m_counter;
     }
-    m_dataController.pushSpectrogram(now, frequency, m_sampleRate, tmp.data(), m_outputSize);
+    SpectrogramQuery spectrogram("", now, frequency, m_sampleRate, encode_base64(tmp.data(), m_outputSize));
+    m_send(spectrogram);
     std::memset(container.m_sum.data(), 0, sizeof(float) * container.m_sum.size());
     container.m_counter = 0;
     container.m_lastDataSendTime = now;

sources/network/remote_controller.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <gnuradio/sync_block.h>
-#include <network/data_controller.h>
+#include <radio/help_structures.h>
 
 #include <functional>
 #include <vector>
@@ -16,7 +16,7 @@ class Spectrogram : virtual public gr::sync_block {
   };
 
  public:
-  Spectrogram(const int itemSize, const Frequency sampleRate, DataController& dataController, std::function<Frequency()> getFrequency);
+  Spectrogram(const int itemSize, const Frequency sampleRate, std::function<Frequency()> getFrequency, std::function<void(const nlohmann::json&)> send);
 
   int work(int noutput_items, gr_vector_const_void_star& input_items, gr_vector_void_star& output_items) override;
 
@@ -28,7 +28,7 @@ class Spectrogram : virtual public gr::sync_block {
   const int m_outputSize;
   const int m_decimatorFactor;
   const Frequency m_sampleRate;
-  DataController& m_dataController;
-  std::function<Frequency()> m_getFrequency;
+  const std::function<Frequency()> m_getFrequency;
+  const std::function<void(const nlohmann::json&)> m_send;
   std::map<Frequency, Container> m_containers;
 };

sources/radio/blocks/spectrogram.cpp

@@ -12,6 +12,7 @@ Transmission::Transmission(
     const int itemSize,
     const int groupSize,
     TransmissionNotification& notification,
+    std::function<Frequency()> getFrequency,
     std::function<Frequency(const Index index)> indexToFrequency,
     std::function<Frequency(const Index index)> indexToShift,
     std::function<bool(const int Index)> isIndexInRange)
@@ -22,6 +23,7 @@ Transmission::Transmission(
       m_groupSize(groupSize),
       m_averager(itemSize, GROUPING_Y),
       m_notification(notification),
+      m_getFrequency(getFrequency),
       m_indexToFrequency(indexToFrequency),
       m_indexToShift(indexToShift),
       m_isIndexInRange(isIndexInRange) {
@@ -169,8 +171,9 @@ std::vector<Recording> Transmission::getSortedTransmissions(const std::chrono::m
   std::sort(indexes.begin(), indexes.end(), [this](const Index& i1, const Index& i2) { return m_signals.at(i1).getPower() > m_signals.at(i2).getPower(); });
   std::vector<Recording> transmissions;
   for (const auto& index : indexes) {
-    const auto frequency = getTunedFrequency(m_indexToShift(index), m_config.recordingTuningStep());
-    transmissions.emplace_back(frequency, m_signals.at(index).needFlush(now));
+    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));
   }
   return transmissions;
 }

sources/radio/blocks/spectrogram.h

@@ -20,6 +20,7 @@ class Transmission : virtual public gr::sync_block {
       const int itemSize,
       const int groupSize,
       TransmissionNotification& notification,
+      std::function<Frequency()> getFrequency,
       std::function<Frequency(const int index)> indexToFrequency,
       std::function<Frequency(const int index)> indexToShift,
       std::function<bool(const int Index)> isIndexInRange);
@@ -42,6 +43,7 @@ class Transmission : virtual public gr::sync_block {
   const int m_groupSize;
   Averager m_averager;
   TransmissionNotification& m_notification;
+  const std::function<Frequency()> m_getFrequency;
   const std::function<Frequency(const Index index)> m_indexToFrequency;
   const std::function<Frequency(const Index index)> m_indexToShift;
   const std::function<bool(const Index index)> m_isIndexInRange;