Reset modem if carrier lost (#94)

When carrier is lost the PLL keeps looking for it and starts drifting slowly. This can make it harder to lock on to the carrier when it comes back. One solution is to reset the frequency back to 57 Khz after 10 seconds of loss of block sync being detected. Open question: is the PLL interface being used correctly?
windytan · Aug 27, 2023 · 748356b · 748356b
1 parent 9587d69
commit 748356b
Show file tree

Hide file tree

Showing 10 changed files with 53 additions and 14 deletions.
diff --git a/src/block_sync.cc b/src/block_sync.cc
@@ -208,6 +208,8 @@ void BlockStream::acquireSync(Block block) {
   if (is_in_sync_)
     return;
 
+  num_bits_since_sync_lost_++;
+
   // Try to find a repeating offset sequence
   if (block.offset != Offset::invalid) {
     sync_buffer.push(block.offset, bitcount_);
@@ -216,9 +218,7 @@ void BlockStream::acquireSync(Block block) {
       is_in_sync_ = true;
       expected_offset_ = block.offset;
       current_group_ = Group();
-    } else {
-      previous_syncing_bitcount_= bitcount_;
-      previous_syncing_offset_  = block.offset;
+      num_bits_since_sync_lost_ = 0;
     }
   }
 }
@@ -293,4 +293,8 @@ Group BlockStream::flushCurrentGroup() const {
   return current_group_;
 }
 
+size_t BlockStream::getNumBitsSinceSyncLost() const {
+  return num_bits_since_sync_lost_;
+}
+
 }  // namespace redsea
diff --git a/src/block_sync.h b/src/block_sync.h
@@ -51,8 +51,8 @@ class BlockStream {
   void pushBit(bool bit);
   Group popGroup();
   bool hasGroupReady() const;
-  bool eof() const;
   Group flushCurrentGroup() const;
+  size_t getNumBitsSinceSyncLost() const;
 
  private:
   void acquireSync(Block block);
@@ -61,19 +61,17 @@ class BlockStream {
   void handleNewlyReceivedGroup();
 
   int      bitcount_                  { 0 };
-  int      previous_syncing_bitcount_ { 0 };
   int      num_bits_until_next_block_ { 1 };
   uint32_t input_register_            { 0 };
-  Offset   previous_syncing_offset_   { Offset::invalid };
   Offset   expected_offset_           { Offset::A };
   bool     is_in_sync_                { false };
   RunningSum<int, 50> block_error_sum50_;
   const    Options options_;
-  bool     is_eof_                    { false };
   RunningAverage<float, kNumBlerAverageGroups> bler_average_;
   Group    current_group_;
   Group    ready_group_;
   bool     has_group_ready_           { false };
+  size_t   num_bits_since_sync_lost_  { 0 };
 };
 
 } // namespace redsea

diff --git a/src/channel.cc b/src/channel.cc
@@ -133,4 +133,8 @@ void Channel::flush() {
     processGroup(last_group);
 }
 
+float Channel::getSecondsSinceCarrierLost() const {
+  return block_stream_.getNumBitsSinceSyncLost() / kBitsPerSecond;
+}
+
 }  // namespace redsea
diff --git a/src/channel.h b/src/channel.h
@@ -65,6 +65,7 @@ class Channel {
   void processBits(BitBuffer buffer);
   void processGroup(Group group);
   void flush();
+  float getSecondsSinceCarrierLost() const;
 
  private:
   Options options_;

diff --git a/src/common.h b/src/common.h
@@ -23,12 +23,12 @@
 
 namespace redsea {
 
-constexpr float kTargetSampleRate_Hz  = 171000.0f;
-constexpr int   kNumBlerAverageGroups = 12;
+constexpr float kBitsPerSecond        = 1187.5f;
 constexpr float kMinimumSampleRate_Hz = 128000.0f;
+constexpr int   kNumBlerAverageGroups = 12;
+constexpr float kTargetSampleRate_Hz  = 171000.0f;
 
-class BitBuffer {
- public:
+struct BitBuffer {
   std::chrono::time_point<std::chrono::system_clock> time_received;
   std::vector<bool> bits;
 };

diff --git a/src/liquid_wrappers.cc b/src/liquid_wrappers.cc
@@ -66,14 +66,19 @@ size_t FIRFilter::length() const {
 }
 
 NCO::NCO(liquid_ncotype type, float freq) :
-    object_(nco_crcf_create(type)) {
+    object_(nco_crcf_create(type)), initial_frequency_(freq) {
   nco_crcf_set_frequency(object_, freq);
 }
 
 NCO::~NCO() {
   nco_crcf_destroy(object_);
 }
 
+void NCO::reset() {
+  nco_crcf_reset(object_);
+  nco_crcf_set_frequency(object_, initial_frequency_);
+}
+
 std::complex<float> NCO::mixDown(std::complex<float> s) {
   std::complex<float> result;
   nco_crcf_mix_down(object_, s, &result);
@@ -92,6 +97,10 @@ void NCO::stepPLL(float dphi) {
   nco_crcf_pll_step(object_, dphi);
 }
 
+float NCO::getFrequency() {
+  return nco_crcf_get_frequency(object_);
+}
+
 SymSync::SymSync(liquid_firfilt_type ftype, unsigned k, unsigned m,
                  float beta, unsigned num_filters) :
     object_(symsync_crcf_create_rnyquist(ftype, k, m, beta, num_filters)),
@@ -102,6 +111,10 @@ SymSync::~SymSync() {
   symsync_crcf_destroy(object_);
 }
 
+void SymSync::reset() {
+  symsync_crcf_reset(object_);
+}
+
 void SymSync::setBandwidth(float bw) {
   symsync_crcf_set_lf_bw(object_, bw);
 }

diff --git a/src/liquid_wrappers.h b/src/liquid_wrappers.h
@@ -60,16 +60,19 @@ class FIRFilter {
 
 class NCO {
  public:
-  explicit NCO(liquid_ncotype type, float freq);
+  NCO(liquid_ncotype type, float freq);
   NCO(const NCO&) = delete;
   ~NCO();
   std::complex<float> mixDown(std::complex<float> s);
   void step();
   void setPLLBandwidth(float);
   void stepPLL(float dphi);
+  void reset();
+  float getFrequency();
 
  private:
   nco_crcf object_;
+  float initial_frequency_;
 };
 
 class SymSync {
@@ -78,6 +81,7 @@ class SymSync {
           float beta, unsigned num_filters);
   SymSync(const SymSync&) = delete;
   ~SymSync();
+  void reset();
   void setBandwidth(float);
   void setOutputRate(unsigned);
   Maybe<std::complex<float>> execute(std::complex<float>* in);

diff --git a/src/redsea.cc b/src/redsea.cc
@@ -133,6 +133,10 @@ int processMPXInput(Options options) {
       channels[i].processBits(
         subcarriers[i]->processChunk(mpx.readChunk(int(i)))
       );
+      if (channels[i].getSecondsSinceCarrierLost() > 10.f &&
+          subcarriers[i]->getSecondsSinceLastReset() > 5.f) {
+        subcarriers[i]->reset();
+      }
     }
   }
 

diff --git a/src/subcarrier.cc b/src/subcarrier.cc
@@ -36,7 +36,6 @@ namespace redsea {
 namespace {
 
 constexpr float kCarrierFrequency_Hz  = 57000.0f;
-constexpr float kBitsPerSecond        = 1187.5f;
 constexpr int   kSamplesPerSymbol     = 3;
 constexpr float kAGCBandwidth_Hz      = 500.0f;
 constexpr float kAGCInitialGain       = 0.08f;
@@ -113,6 +112,12 @@ Subcarrier::Subcarrier(const Options& options) :
   oscillator_.setPLLBandwidth(kPLLBandwidth_Hz / kTargetSampleRate_Hz);
 }
 
+void Subcarrier::reset() {
+  symsync_.reset();
+  oscillator_.reset();
+  sample_num_ = 0;
+}
+
 /** MPX to bits
  */
 BitBuffer Subcarrier::processChunk(MPXBuffer<>& chunk) {
@@ -179,6 +184,10 @@ bool Subcarrier::eof() const {
   return is_eof_;
 }
 
+float Subcarrier::getSecondsSinceLastReset() const {
+  return sample_num_ / kTargetSampleRate_Hz;
+}
+
 }  // namespace redsea
 
 #endif  // HAVE_LIQUID
diff --git a/src/subcarrier.h b/src/subcarrier.h
@@ -62,6 +62,8 @@ class Subcarrier {
   ~Subcarrier() = default;
   bool eof() const;
   BitBuffer processChunk(MPXBuffer<>& chunk);
+  void reset();
+  float getSecondsSinceLastReset() const;
 
  private:
   int sample_num_ { 0 };