Added missing functions to Scheduler.

Author: shajen

CMakeLists.txt

@@ -55,7 +55,18 @@ target_link_libraries(auto_sdr
 )
 
 add_executable(auto_sdr_test ${TEST_SOURCES} "tests/test_main.cpp")
-target_link_libraries(auto_sdr_test auto_sdr_libs gtest)
+target_link_libraries(auto_sdr_test 
+    gtest
+    auto_sdr_libs
+    gnuradio::gnuradio-blocks
+    gnuradio::gnuradio-fft
+    gnuradio::gnuradio-filter
+    gnuradio::gnuradio-soapy
+    nlohmann_json::nlohmann_json
+    spdlog::spdlog
+    PahoMqttCpp::paho-mqttpp3
+    CLI11::CLI11
+)
 
 install(TARGETS auto_sdr DESTINATION)
 install(TARGETS auto_sdr_test DESTINATION)

sources/radio/scheduler.cpp

@@ -8,9 +8,14 @@
 constexpr auto LABEL = "scheduler";
 constexpr auto LOOP_TIMEOUT = std::chrono::milliseconds(100);
 constexpr auto UPDATE_INTERVAL = std::chrono::minutes(60);
+constexpr auto SHIFT_FREQUENCY = Frequency(100000);
 
 using namespace std::placeholders;
 
+ScheduledTransmission::ScheduledTransmission(
+    const std::string& name, const std::chrono::seconds& begin, const std::chrono::seconds& end, const Frequency& frequency, const Frequency& bandwidth, const std::string& modulation)
+    : m_name(name), m_begin(begin), m_end(end), m_frequency(frequency), m_bandwidth(bandwidth), m_modulation(modulation) {}
+
 Scheduler::Scheduler(const Config& config, const Device& device, RemoteController& remoteController)
     : m_config(config), m_device(device), m_remoteController(remoteController), m_lastUpdateTime(0), m_isRunning(true), m_thread([this]() { worker(); }) {}
 
@@ -19,6 +24,43 @@ Scheduler::~Scheduler() {
   m_thread.join();
 }
 
+std::vector<ScheduledTransmission> Scheduler::getTransmissions(const std::chrono::milliseconds& now, std::list<ScheduledTransmission>& scheduledTransmissions) {
+  while (!scheduledTransmissions.empty() && scheduledTransmissions.front().m_end < now) {
+    scheduledTransmissions.pop_front();
+  }
+  std::vector<ScheduledTransmission> transmissions;
+  for (auto it = scheduledTransmissions.begin(); it != scheduledTransmissions.end() && it->m_begin <= now; ++it) {
+    transmissions.push_back(*it);
+  }
+  return transmissions;
+}
+
+std::optional<std::pair<FrequencyRange, std::vector<Recording>>> Scheduler::getRecordings(
+    const std::chrono::milliseconds& now, std::list<ScheduledTransmission>& scheduledTransmissions, Frequency sampleRate, Frequency shift) {
+  const auto transmissions = getTransmissions(now, scheduledTransmissions);
+  if (transmissions.empty()) {
+    return std::nullopt;
+  }
+  const auto center = transmissions.front().m_frequency + shift;
+  const auto left = center - sampleRate / 2;
+  const auto right = center + sampleRate / 2;
+  const FrequencyRange range(left, right);
+  std::vector<Recording> recordings;
+  for (const auto& transmission : transmissions) {
+    const auto transmissionLeft = transmission.m_frequency - transmission.m_bandwidth / 2;
+    const auto transmissionRight = transmission.m_frequency + transmission.m_bandwidth / 2;
+    if (left <= transmissionLeft && transmissionRight <= right) {
+      recordings.emplace_back(transmission.m_frequency - center, true);
+    }
+  }
+  return std::pair<FrequencyRange, std::vector<Recording>>(range, recordings);
+}
+
+std::optional<std::pair<FrequencyRange, std::vector<Recording>>> Scheduler::getRecordings(const std::chrono::milliseconds& now) {
+  std::unique_lock lock(m_mutex);
+  return Scheduler::getRecordings(now, m_scheduledTransmissions, m_device.m_sampleRate, SHIFT_FREQUENCY);
+}
+
 void Scheduler::worker() {
   m_remoteController.satellitesCallback(m_device.getName(), std::bind(&Scheduler::satellitesCallback, this, _1));
   while (m_isRunning) {
@@ -47,4 +89,20 @@ void Scheduler::satellitesQuery() {
   m_remoteController.satellitesQuery(m_device.getName(), json.dump());
 }
 
-void Scheduler::satellitesCallback(const nlohmann::json& json) { Logger::info(LABEL, "received satellites: {}", colored(GREEN, "{}", json.dump())); }
+void Scheduler::satellitesCallback(const nlohmann::json& json) {
+  Logger::info(LABEL, "received satellites: {}", colored(GREEN, "{}", json.dump()));
+
+  std::list<ScheduledTransmission> scheduledTransmissions;
+  for (const auto& item : json) {
+    const auto name = item.at("name").get<std::string>();
+    const auto begin = std::chrono::seconds(item.at("begin").get<uint64_t>());
+    const auto end = std::chrono::seconds(item.at("end").get<uint64_t>());
+    const auto frequency = item.at("frequency").get<Frequency>();
+    const auto bandwidth = item.at("bandwidth").get<Frequency>();
+    const auto modulation = item.at("modulation").get<std::string>();
+    scheduledTransmissions.emplace_back(name, begin, end, frequency, bandwidth, modulation);
+  }
+
+  std::unique_lock lock(m_mutex);
+  m_scheduledTransmissions = scheduledTransmissions;
+}

sources/radio/scheduler.h

@@ -4,20 +4,42 @@
 #include <network/remote_controller.h>
 #include <radio/sdr_device.h>
 
+#include <list>
+#include <mutex>
+#include <optional>
+
+struct ScheduledTransmission {
+  ScheduledTransmission(
+      const std::string& m_name, const std::chrono::seconds& m_begin, const std::chrono::seconds& m_end, const Frequency& m_frequency, const Frequency& m_bandwidth, const std::string& m_modulation);
+
+  std::string m_name;
+  std::chrono::seconds m_begin;
+  std::chrono::seconds m_end;
+  Frequency m_frequency;
+  Frequency m_bandwidth;
+  std::string m_modulation;
+};
+
 class Scheduler {
  public:
   Scheduler(const Config& config, const Device& device, RemoteController& remoteController);
   ~Scheduler();
 
- private:
+  static std::vector<ScheduledTransmission> getTransmissions(const std::chrono::milliseconds& now, std::list<ScheduledTransmission>& scheduledTransmissions);
+  static std::optional<std::pair<FrequencyRange, std::vector<Recording>>> getRecordings(
+      const std::chrono::milliseconds& now, std::list<ScheduledTransmission>& scheduledTransmissions, Frequency sampleRate, Frequency shift);
+  std::optional<std::pair<FrequencyRange, std::vector<Recording>>> getRecordings(const std::chrono::milliseconds& now);
+
   void worker();
   void satellitesQuery();
   void satellitesCallback(const nlohmann::json& json);
 
   const Config& m_config;
   const Device m_device;
   RemoteController& m_remoteController;
+  std::list<ScheduledTransmission> m_scheduledTransmissions;
   std::chrono::milliseconds m_lastUpdateTime;
   std::atomic<bool> m_isRunning;
   std::thread m_thread;
+  std::mutex m_mutex;
 };

tests/test_scheduler.cpp

@@ -0,0 +1,125 @@
+#include <gtest/gtest.h>
+#include <radio/scheduler.h>
+
+#include <chrono>
+
+using namespace std::chrono_literals;
+
+TEST(Scheduler, Transmissions) {
+  std::list<ScheduledTransmission> scheduledTransmissions;
+  const Frequency f1(700);
+  const Frequency f2(800);
+  const Frequency f3(800);
+
+  scheduledTransmissions.emplace_back("", 100s, 200s, f1, 20, "");
+  scheduledTransmissions.emplace_back("", 150s, 200s, f2, 20, "");
+  scheduledTransmissions.emplace_back("", 250s, 300s, f3, 20, "");
+
+  {
+    const auto result = Scheduler::getTransmissions(10s, scheduledTransmissions);
+    EXPECT_EQ(result.size(), 0);
+    EXPECT_EQ(scheduledTransmissions.size(), 3);
+  }
+  {
+    const auto result = Scheduler::getTransmissions(99s, scheduledTransmissions);
+    EXPECT_EQ(result.size(), 0);
+    EXPECT_EQ(scheduledTransmissions.size(), 3);
+  }
+  {
+    const auto result = Scheduler::getTransmissions(100s, scheduledTransmissions);
+    EXPECT_EQ(result.size(), 1);
+    EXPECT_EQ(result[0].m_frequency, f1);
+    EXPECT_EQ(scheduledTransmissions.size(), 3);
+  }
+  {
+    const auto result = Scheduler::getTransmissions(150s, scheduledTransmissions);
+    EXPECT_EQ(result.size(), 2);
+    EXPECT_EQ(result[0].m_frequency, f1);
+    EXPECT_EQ(result[1].m_frequency, f2);
+    EXPECT_EQ(scheduledTransmissions.size(), 3);
+  }
+  {
+    const auto result = Scheduler::getTransmissions(200s, scheduledTransmissions);
+    EXPECT_EQ(result.size(), 2);
+    EXPECT_EQ(result[0].m_frequency, f1);
+    EXPECT_EQ(result[1].m_frequency, f2);
+    EXPECT_EQ(scheduledTransmissions.size(), 3);
+  }
+  {
+    const auto result = Scheduler::getTransmissions(201s, scheduledTransmissions);
+    EXPECT_EQ(result.size(), 0);
+    EXPECT_EQ(scheduledTransmissions.size(), 1);
+  }
+  {
+    const auto result = Scheduler::getTransmissions(250s, scheduledTransmissions);
+    EXPECT_EQ(result.size(), 1);
+    EXPECT_EQ(result[0].m_frequency, f3);
+    EXPECT_EQ(scheduledTransmissions.size(), 1);
+  }
+  {
+    const auto result = Scheduler::getTransmissions(301s, scheduledTransmissions);
+    EXPECT_EQ(result.size(), 0);
+    EXPECT_EQ(scheduledTransmissions.size(), 0);
+  }
+}
+
+TEST(Scheduler, Recordings) {
+  std::list<ScheduledTransmission> scheduledTransmissions;
+  const Frequency f1(7000);
+  const Frequency f2(7500);
+  const Frequency f3(8050);
+  const Frequency sampleRate(2000);
+  const Frequency shift(100);
+
+  scheduledTransmissions.emplace_back("", 100s, 300s, f1, 100, "");
+  scheduledTransmissions.emplace_back("", 150s, 300s, f2, 100, "");
+  scheduledTransmissions.emplace_back("", 200s, 300s, f3, 100, "");
+
+  {
+    const auto result = Scheduler::getRecordings(125s, scheduledTransmissions, sampleRate, shift);
+    EXPECT_EQ(result->first, FrequencyRange(6100, 8100));
+    EXPECT_EQ(result->second.size(), 1);
+    EXPECT_EQ(result->second[0].m_shift, -100);
+  }
+  {
+    const auto result = Scheduler::getRecordings(175s, scheduledTransmissions, sampleRate, shift);
+    EXPECT_EQ(result->first, FrequencyRange(6100, 8100));
+    EXPECT_EQ(result->second.size(), 2);
+    EXPECT_EQ(result->second[0].m_shift, -100);
+    EXPECT_EQ(result->second[1].m_shift, 400);
+  }
+  {
+    const auto result = Scheduler::getRecordings(225s, scheduledTransmissions, sampleRate, shift);
+    EXPECT_EQ(result->first, FrequencyRange(6100, 8100));
+    EXPECT_EQ(result->second.size(), 3);
+    EXPECT_EQ(result->second[0].m_shift, -100);
+    EXPECT_EQ(result->second[1].m_shift, 400);
+    EXPECT_EQ(result->second[2].m_shift, 950);
+  }
+}
+
+TEST(Scheduler, RecordingsEdgeCase) {
+  std::list<ScheduledTransmission> scheduledTransmissions;
+  const Frequency f1(7000);
+  const Frequency f2(6149);
+  const Frequency f3(6150);
+  const Frequency f4(8050);
+  const Frequency f5(8051);
+  const Frequency sampleRate(2000);
+  const Frequency shift(100);
+
+  scheduledTransmissions.emplace_back("", 200s, 300s, f1, 100, "");
+  scheduledTransmissions.emplace_back("", 200s, 300s, f2, 100, "");
+  scheduledTransmissions.emplace_back("", 200s, 300s, f3, 100, "");
+  scheduledTransmissions.emplace_back("", 200s, 300s, f4, 100, "");
+  scheduledTransmissions.emplace_back("", 200s, 300s, f5, 100, "");
+
+  {
+    const auto result = Scheduler::getRecordings(250s, scheduledTransmissions, sampleRate, shift);
+    EXPECT_EQ(result->first, FrequencyRange(6100, 8100));
+    EXPECT_EQ(result->second.size(), 3);
+    EXPECT_EQ(result->second[0].m_shift, -100);
+    EXPECT_EQ(result->second[1].m_shift, -950);
+    EXPECT_EQ(result->second[2].m_shift, 950);
+  }
+}