Added dump debug parameters.

Author: shajen

sources/arg_config.h

@@ -13,4 +13,6 @@ struct ArgConfig {
   std::string mqttPassword;
   std::string workDir = ".";
   bool enumerateRemote = false;
+  bool dumpSource = false;
+  bool dumpRecording = false;
 };

sources/config.cpp

@@ -59,4 +59,7 @@ std::string Config::latitude() const { return m_fileConfig.position.latitude; }
 std::string Config::longitude() const { return m_fileConfig.position.longitude; }
 int Config::altitude() const { return m_fileConfig.position.altitude; }
 
-std::string Config::workDir() const { return m_argConfig.workDir; }
+std::string Config::workDir() const { return m_argConfig.workDir; }
+
+bool Config::dumpSource() const { return m_argConfig.dumpSource; }
+bool Config::dumpRecording() const { return m_argConfig.dumpRecording; }

sources/config.h

@@ -10,9 +10,6 @@
 #include <string>
 
 // INTERNAL SETTINGS
-constexpr auto DEBUG_SAVE_FULL_RAW_IQ = false;                            // save orgignal sdr data as raw iq
-constexpr auto DEBUG_SAVE_FULL_POWER = false;                             // save orgignal sdr data as raw iq
-constexpr auto DEBUG_SAVE_RECORDING_RAW_IQ = false;                       // save recordings as raw iq
 constexpr auto INITIAL_DELAY = std::chrono::milliseconds(1000);           // delay after first start sdr device to start processing
 constexpr auto PERFORMANCE_LOGGER_INTERVAL = 1000;                        // print stats every n frames
 constexpr auto RECORDER_FLUSH_INTERVAL = std::chrono::milliseconds(100);  // flush recordings to mqtt every 2 * n bytes
@@ -70,6 +67,8 @@ class Config {
   int altitude() const;
 
   std::string workDir() const;
+  bool dumpSource() const;
+  bool dumpRecording() const;
 
  private:
   const std::string m_id;

sources/main.cpp

@@ -31,6 +31,8 @@ int main(int argc, char** argv) {
   app.add_option("--mqtt-password", argConfig.mqttPassword, "mqtt password")->required();
   app.add_option("--work-dir", argConfig.workDir, "work directory");
   app.add_option("--remote", argConfig.enumerateRemote, "enable remote device enumeration");
+  app.add_option("--dump-source", argConfig.dumpSource, "dump source raw IQ");
+  app.add_option("--dump-recording", argConfig.dumpRecording, "dump recording raw IQ");
   CLI11_PARSE(app, argc, argv);
 
   dup2(fileno(fopen("/dev/null", "w")), fileno(stderr));

sources/radio/recorder.cpp

@@ -13,7 +13,7 @@
 
 constexpr auto LABEL = "recorder";
 
-Recorder::Recorder(const Config& config, const std::string& zeromq, Frequency sampleRate, const Recording& recording, std::function<void(const nlohmann::json&)> send)
+Recorder::Recorder(const Config& config, const Device& device, const std::string& zeromq, Frequency sampleRate, const Recording& recording, std::function<void(const nlohmann::json&)> send)
     : m_config(config), m_sampleRate(sampleRate), m_recording(recording), m_send(send), m_tb(gr::make_top_block("recorder")), m_connector(m_tb) {
   Logger::info(
       LABEL,
@@ -44,8 +44,8 @@ Recorder::Recorder(const Config& config, const std::string& zeromq, Frequency sa
   blocks.push_back(m_buffer);
   m_connector.connect(blocks);
 
-  if (DEBUG_SAVE_RECORDING_RAW_IQ) {
-    const auto fileName = getRawFileName("recording", "fc", m_recording.recordingFrequency, m_recording.bandwidth);
+  if (config.dumpRecording()) {
+    const auto fileName = getRawFileName(config.workDir(), device, "recording", "fc", m_recording.recordingFrequency, m_recording.bandwidth);
     m_connector.connect<Block>(lastResampler, gr::blocks::file_sink::make(sizeof(gr_complex), fileName.c_str()));
   }
 

sources/radio/recorder.h

@@ -18,7 +18,7 @@ class Recorder {
   Recorder(const Recorder&) = delete;
   Recorder& operator=(const Recorder&) = delete;
 
-  Recorder(const Config& config, const std::string& zeromq, Frequency sampleRate, const Recording& recording, std::function<void(const nlohmann::json&)> send);
+  Recorder(const Config& config, const Device& device, const std::string& zeromq, Frequency sampleRate, const Recording& recording, std::function<void(const nlohmann::json&)> send);
   ~Recorder();
 
   Recording getRecording() const;

sources/radio/sdr_device.cpp

@@ -3,6 +3,7 @@
 #include <config.h>
 #include <gnuradio/block_detail.h>
 #include <gnuradio/blocks/copy.h>
+#include <gnuradio/blocks/file_sink.h>
 #include <gnuradio/blocks/null_sink.h>
 #include <gnuradio/soapy/source.h>
 #include <gnuradio/zeromq/pub_sink.h>
@@ -46,6 +47,11 @@ SdrDevice::SdrDevice(const Config& config, const Device& device, RemoteControlle
     m_processorIndex[range.center()] = index++;
   }
 
+  if (config.dumpSource()) {
+    const auto fileName = getRawFileName(config.workDir(), device, "source-all", "fc", ranges.front().center(), device.sample_rate);
+    m_connector.connect<Block>(m_source, gr::blocks::file_sink::make(sizeof(gr_complex), fileName.c_str()));
+  }
+
   m_tb->start();
   Logger::info(LABEL, "started");
 }
@@ -110,7 +116,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, std::placeholders::_1)));
+            std::make_unique<Recorder>(m_config, m_device, 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

@@ -52,13 +52,8 @@ SdrProcessor::SdrProcessor(
   const auto spectrogram = std::make_shared<Spectrogram>(fftSize, sampleRate, getFrequency, sendSpectrogram);
   m_connector.connect<Block>(psd, spectrogram);
 
-  if (DEBUG_SAVE_FULL_POWER) {
-    const auto fileName = getRawFileName("full", "power", frequencyRange.center(), device.sample_rate);
-    m_connector.connect<Block>(psd, gr::blocks::file_sink::make(sizeof(float) * fftSize, fileName.c_str()));
-  }
-
-  if (DEBUG_SAVE_FULL_RAW_IQ) {
-    const auto fileName = getRawFileName("full", "fc", frequencyRange.center(), device.sample_rate);
+  if (config.dumpSource()) {
+    const auto fileName = getRawFileName(config.workDir(), device, "source", "fc", frequencyRange.center(), device.sample_rate);
     m_connector.connect<Block>(source, gr::blocks::file_sink::make(sizeof(gr_complex), fileName.c_str()));
   }
 }

sources/utils/radio_utils.cpp

@@ -3,6 +3,7 @@
 #include <logger.h>
 #include <utils/utils.h>
 
+#include <filesystem>
 #include <numeric>
 
 namespace {
@@ -77,12 +78,25 @@ void setNoData(float* data, const int size) {
   }
 }
 
-std::string getRawFileName(const char* label, const char* extension, Frequency frequency, Frequency sampleRate) {
-  char buf[1024];
+std::string getRawFileName(const std::string& dir, const Device& device, const char* label, const char* extension, Frequency frequency, Frequency sampleRate) {
+  const auto path = std::filesystem::canonical(dir.c_str());
   time_t rawtime = time(nullptr);
   struct tm* tm = localtime(&rawtime);
-  snprintf(buf, 1024, "./%s_%04d%02d%02d_%02d%02d%02d_%d_%d_%s.raw", label, tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, frequency, sampleRate, extension);
-  return buf;
+  return fmt::format(
+      "{}/{}-{}-{}_{:04d}{:02d}{:02d}_{:02d}{:02d}{:02d}_{}_{}_{}.raw",
+      path.c_str(),
+      device.driver,
+      device.serial,
+      label,
+      tm->tm_year + 1900,
+      tm->tm_mon + 1,
+      tm->tm_mday,
+      tm->tm_hour,
+      tm->tm_min,
+      tm->tm_sec,
+      frequency,
+      sampleRate,
+      extension);
 }
 
 Frequency getTunedFrequency(Frequency frequency, Frequency step) {

sources/utils/radio_utils.h

@@ -10,7 +10,7 @@ std::string formatPower(const float power, const char* color = nullptr);
 
 void setNoData(float* data, const int size);
 
-std::string getRawFileName(const char* label, const char* extension, Frequency frequency, Frequency sampleRate);
+std::string getRawFileName(const std::string& dir, const Device& device, const char* label, const char* extension, Frequency frequency, Frequency sampleRate);
 
 Frequency getTunedFrequency(Frequency frequency, Frequency step);