Fixed resampling.

Author: shajen

CMakeLists.txt

@@ -45,6 +45,7 @@ add_library(auto_sdr_libs STATIC ${SOURCES})
 add_executable(auto_sdr "sources/main.cpp")
 target_link_libraries(auto_sdr
     auto_sdr_libs
+    gnuradio::gnuradio-analog
     gnuradio::gnuradio-blocks
     gnuradio::gnuradio-fft
     gnuradio::gnuradio-filter
@@ -60,6 +61,7 @@ add_executable(auto_sdr_test ${TEST_SOURCES} "tests/test_main.cpp")
 target_link_libraries(auto_sdr_test 
     gtest
     auto_sdr_libs
+    gnuradio::gnuradio-analog
     gnuradio::gnuradio-blocks
     gnuradio::gnuradio-fft
     gnuradio::gnuradio-filter

sources/config.h

@@ -13,7 +13,6 @@
 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
-constexpr auto RESAMPLER_THRESHOLD = 125;                                 // max interpolation or decimation factor of RESAMPLER
 constexpr auto TRANSMISSION_MAX_TIME = std::chrono::minutes(10);          // break transmission if longer that
 
 // SCANNING SETTINGS
@@ -33,6 +32,9 @@ 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
 
+// RECORDER SETTINGS
+constexpr auto RECORDER_SAMPLE_RATE_DECIMATOR = 2000000;
+
 // SOURCE AND RECORDING NAMES
 constexpr auto GAIN_TESTER_SOURCE_NAME = "gain tester";
 constexpr auto GAIN_TESTER_RECORDING_NAME = "auto";

sources/radio/recorder.cpp

@@ -1,9 +1,15 @@
 #include "recorder.h"
 
 #include <config.h>
+#include <gnuradio/analog/agc2_cc.h>
 #include <gnuradio/blocks/complex_to_interleaved_char.h>
 #include <gnuradio/blocks/file_sink.h>
 #include <gnuradio/blocks/stream_to_vector.h>
+#include <gnuradio/filter/fir_filter.h>
+#include <gnuradio/filter/fir_filter_blk.h>
+#include <gnuradio/filter/firdes.h>
+#include <gnuradio/filter/freq_xlating_fir_filter.h>
+#include <gnuradio/filter/pfb_arb_resampler_ccf.h>
 #include <gnuradio/filter/rational_resampler.h>
 #include <gnuradio/zeromq/sub_source.h>
 #include <logger.h>
@@ -13,6 +19,35 @@
 
 constexpr auto LABEL = "recorder";
 
+// most blocks based on
+// https://github.com/gqrx-sdr/gqrx/blob/master/src/applications/gqrx/receiver.cpp
+
+Block buildDecimator(Frequency sampleRate, Frequency shift, int decim) {
+  if (1 < decim) {
+    const auto filter = gr::filter::freq_xlating_fir_filter_ccf::make(decim, {1}, 0.0, sampleRate);
+    const auto outRate = sampleRate / decim;
+    const auto lpf_cutoff = 120e3;
+    filter->set_center_freq(shift);
+    filter->set_taps(gr::filter::firdes::low_pass(1.0, sampleRate, lpf_cutoff, outRate - 2 * lpf_cutoff, gr::fft::window::WIN_BLACKMAN_HARRIS));
+    return filter;
+  } else {
+    auto shiftBlock = gr::blocks::rotator_cc::make();
+    shiftBlock->set_phase_inc(2.0l * M_PIl * (static_cast<double>(shift) / static_cast<float>(sampleRate)));
+    return shiftBlock;
+  }
+}
+
+Block buildResampler(Frequency inputRate, Frequency outputRate) {
+  const auto rate = static_cast<double>(outputRate) / inputRate;
+  const auto cutoff = rate > 1.0f ? 0.4 : 0.4 * (double)rate;
+  const auto trans_width = rate > 1.0f ? 0.2 : 0.2 * (double)rate;
+  const auto flt_size = 32;
+  const auto d_taps = gr::filter::firdes::low_pass(flt_size, flt_size, cutoff, trans_width);
+  auto resampler = gr::filter::pfb_arb_resampler_ccf::make(rate, d_taps, flt_size);
+  resampler->set_output_multiple(4096);
+  return resampler;
+}
+
 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(
@@ -26,18 +61,14 @@ Recorder::Recorder(const Config& config, const Device& device, const std::string
 
   auto source = gr::zeromq::sub_source::make(sizeof(gr_complex), 1, const_cast<char*>(zeromq.c_str()));
   std::vector<Block> blocks;
-  m_shiftBlock = gr::blocks::rotator_cc::make();
   blocks.push_back(source);
-  blocks.push_back(m_shiftBlock);
-
-  Block lastResampler;
-  for (const auto& [factor1, factor2] : getResamplersFactors(m_sampleRate, m_recording.bandwidth, RESAMPLER_THRESHOLD)) {
-    Logger::debug(LABEL, "rational resampler factors: {}, {}", colored(GREEN, "{}", factor1), colored(GREEN, "{}", factor2));
-    lastResampler = gr::filter::rational_resampler<gr_complex, gr_complex, gr_complex>::make(factor1, factor2);
-    blocks.push_back(lastResampler);
-  }
+  const auto decim = std::max(1, static_cast<int>(sampleRate / RECORDER_SAMPLE_RATE_DECIMATOR));
+  blocks.push_back(buildDecimator(m_sampleRate, m_recording.shift(), decim));
+  blocks.push_back(buildResampler(sampleRate / decim, m_recording.bandwidth));
+  auto raw = blocks.back();
 
   const auto samplesSize = roundUp(m_recording.bandwidth * RECORDER_FLUSH_INTERVAL.count() / 1000, 4096);
+  blocks.push_back(gr::analog::agc2_cc::make(2e-3, 2e-3, 0.585, 53));
   blocks.push_back(gr::blocks::complex_to_interleaved_char::make(true, 127.0));
   blocks.push_back(gr::blocks::stream_to_vector::make(sizeof(SimpleComplex), samplesSize));
   m_buffer = std::make_shared<Buffer<SimpleComplex>>("RecorderBuffer", samplesSize);
@@ -46,12 +77,11 @@ Recorder::Recorder(const Config& config, const Device& device, const std::string
 
   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()));
+    m_connector.connect<Block>(raw, gr::blocks::file_sink::make(sizeof(gr_complex), fileName.c_str()));
   }
 
   m_firstDataTime = getTime();
   m_lastDataTime = m_firstDataTime;
-  m_shiftBlock->set_phase_inc(2.0l * M_PIl * (static_cast<double>(-m_recording.shift()) / static_cast<float>(m_sampleRate)));
   m_tb->start();
 }
 

sources/radio/recorder.h

@@ -32,7 +32,6 @@ class Recorder {
   const std::function<void(const nlohmann::json&)> m_send;
 
   std::shared_ptr<gr::top_block> m_tb;
-  std::shared_ptr<gr::blocks::rotator_cc> m_shiftBlock;
   std::shared_ptr<Buffer<SimpleComplex>> m_buffer;
   Connector m_connector;
   std::chrono::milliseconds m_firstDataTime;