Updates to Omni-Rig interface in line with suggestions from Alex, VE3NEA

Includes tidying up some old and obsolete code.

DXLabSuiteCommanderTransceiver.cpp

@@ -127,7 +127,7 @@ int DXLabSuiteCommanderTransceiver::do_start ()
       throw error {tr ("DX Lab Suite Commander didn't respond correctly reading frequency: ") + reply};
     }
 
-  poll ();
+  do_poll ();
   return resolution;
 }
 
@@ -247,7 +247,7 @@ void DXLabSuiteCommanderTransceiver::do_mode (MODE m)
   update_mode (m);
 }
 
-void DXLabSuiteCommanderTransceiver::poll ()
+void DXLabSuiteCommanderTransceiver::do_poll ()
 {
 #if WSJT_TRACE_CAT && WSJT_TRACE_CAT_POLLS
   bool quiet {false};

DXLabSuiteCommanderTransceiver.hpp

@@ -39,7 +39,7 @@ protected:
   void do_mode (MODE) override;
   void do_ptt (bool on) override;
 
-  void poll () override;
+  void do_poll () override;
 
 private:
   MODE get_mode (bool no_debug = false);

HRDTransceiver.cpp

@@ -885,7 +885,7 @@ bool HRDTransceiver::is_button_checked (int button_index, bool no_debug)
   return "1" == reply;
 }
 
-void HRDTransceiver::poll ()
+void HRDTransceiver::do_poll ()
 {
 #if WSJT_TRACE_CAT && WSJT_TRACE_CAT_POLLS
   bool quiet {false};

HRDTransceiver.hpp

@@ -48,7 +48,7 @@ protected:
   void do_ptt (bool on) override;
 
   // Implement the PollingTransceiver interface.
-  void poll () override;
+  void do_poll () override;
 
 private:
   QString send_command (QString const&, bool no_debug = false, bool prepend_context = true, bool recurse = false);

HamlibTransceiver.cpp

@@ -632,7 +632,7 @@ int HamlibTransceiver::do_start ()
       resolution = -1;          // best guess
     }
 
-  poll ();
+  do_poll ();
 
   TRACE_CAT ("HamlibTransceiver", "exit" << state () << "reversed =" << reversed_ << "resolution = " << resolution);
   return resolution;
@@ -898,7 +898,7 @@ void HamlibTransceiver::do_mode (MODE mode)
   update_mode (mode);
 }
 
-void HamlibTransceiver::poll ()
+void HamlibTransceiver::do_poll ()
 {
 #if !WSJT_TRACE_CAT_POLLS
 #if defined (NDEBUG)

HamlibTransceiver.hpp

@@ -40,7 +40,7 @@ class HamlibTransceiver final
   void do_mode (MODE) override;
   void do_ptt (bool) override;
 
-  void poll () override;
+  void do_poll () override;
 
   void error_check (int ret_code, QString const& doing) const;
   void set_conf (char const * item, char const * value);

OmniRigTransceiver.cpp

@@ -4,6 +4,7 @@
 #include <QDebug>
 #include <objbase.h>
 #include <QThread>
+#include <QEventLoop>
 
 #include "qt_helpers.hpP"
 
@@ -109,6 +110,15 @@ OmniRigTransceiver::OmniRigTransceiver (std::unique_ptr<TransceiverBase> wrapped
 {
 }
 
+// returns false on time out
+bool OmniRigTransceiver::await_notification_with_timeout (int timeout)
+{
+  QEventLoop el;
+  connect (this, &OmniRigTransceiver::notified, &el, [&el] () {el.exit (1);});
+  QTimer::singleShot (timeout, Qt::CoarseTimer, &el, [&el] () {el.exit (0);});
+  return 1 == el.exec ();       // wait for notify or timer
+}
+
 int OmniRigTransceiver::do_start ()
 {
   TRACE_CAT ("OmniRigTransceiver", "starting");
@@ -182,101 +192,97 @@ int OmniRigTransceiver::do_start ()
     .arg (readable_params_, 8, 16, QChar ('0'))
     .arg (writable_params_, 8, 16, QChar ('0'))
     .arg (rig_number_).toLocal8Bit ());
-
+  if (OmniRig::ST_ONLINE != rig_->Status ())
-  offline_timer_.reset (new QTimer);
-  offline_timer_->setSingleShot (true);
-  offline_timer_->setInterval (5 * 1000);
-  connect (&*offline_timer_, &QTimer::timeout, this, &OmniRigTransceiver::timeout_check);
-
-  for (unsigned tries {0}; tries < 10; ++tries)
     {
-      QThread::msleep (100);    // wait until OmniRig polls the rig
+      throw_qstring ("OmniRig: " + rig_->StatusStr ());
-      auto f = rig_->GetRxFrequency ();
+    }
-      int resolution {0};
+  await_notification_with_timeout (1000);
-      if (f)
+  update_rx_frequency (rig_->GetRxFrequency ());
+  qDebug () << "Initial state:" << state ();
+  int resolution {0};
+  if (OmniRig::PM_UNKNOWN == rig_->Vfo ()
+      && (writable_params_ & (OmniRig::PM_VFOA | OmniRig::PM_VFOB))
+      == (OmniRig::PM_VFOA | OmniRig::PM_VFOB))
+    {
+      // start with VFO A (probably MAIN) on rigs that we
+      // can't query VFO but can set explicitly
+      rig_->SetVfo (OmniRig::PM_VFOA);
+    }
+  auto f = state ().frequency ();
+  if (f % 10) return resolution; // 1Hz resolution
+  auto test_frequency = f - f % 100 + 55;
+  if (OmniRig::PM_FREQ & writable_params_)
+    {
+      rig_->SetFreq (test_frequency);
+    }
+  else if (reversed_ && (OmniRig::PM_FREQB & writable_params_))
+    {
+      rig_->SetFreqB (test_frequency);
+    }
+  else if (!reversed_ && (OmniRig::PM_FREQA & writable_params_))
+    {
+      rig_->SetFreqA (test_frequency);
+    }
+  else
+    {
+      throw_qstring (tr ("OmniRig: don't know how to set rig frequency"));
+    }
+  if (!await_notification_with_timeout (1000))
+    {
+      TRACE_CAT ("OmniRigTransceiver", "do_start 1: wait timed out");
+      throw_qstring (tr ("OmniRig: timeout waiting for update from rig"));
+    }
+  switch (rig_->GetRxFrequency () - test_frequency)
+    {
+    case -5: resolution = -1; break;  // 10Hz truncated
+    case 5: resolution = 1; break;    // 10Hz rounded
+    case -15: resolution = -2; break; // 20Hz truncated
+    case -55: resolution = -2; break; // 100Hz truncated
+    case 45: resolution = 2; break;   // 100Hz rounded
+    }
+  if (1 == resolution)  // may be 20Hz rounded
+    {
+      test_frequency = f - f % 100 + 51;
+      if (OmniRig::PM_FREQ & writable_params_)
         {
-          if (OmniRig::PM_UNKNOWN == rig_->Vfo ()
+          rig_->SetFreq (test_frequency);
-              && (writable_params_ & (OmniRig::PM_VFOA | OmniRig::PM_VFOB))
+        }
-              == (OmniRig::PM_VFOA | OmniRig::PM_VFOB))
+      else if (reversed_ && (OmniRig::PM_FREQB & writable_params_))
-            {
+        {
-              // start with VFO A (probably MAIN) on rigs that we
+          rig_->SetFreqB (test_frequency);
-              // can't query VFO but can set explicitly
+        }
-              rig_->SetVfo (OmniRig::PM_VFOA);
+      else if (!reversed_ && (OmniRig::PM_FREQA & writable_params_))
-            }
+        {
-          if (f % 10) return resolution; // 1Hz resolution
+          rig_->SetFreqA (test_frequency);
-          auto test_frequency = f - f % 100 + 55;
+        }
-          if (OmniRig::PM_FREQ & writable_params_)
+      if (!await_notification_with_timeout (2000))
-            {
+        {
-              rig_->SetFreq (test_frequency);
+          TRACE_CAT ("OmniRigTransceiver", "do_start 2: wait timed out");
-            }
+          throw_qstring (tr ("OmniRig: timeout waiting for update from rig"));
-          else if (reversed_ && (OmniRig::PM_FREQB & writable_params_))
+        }
-            {
+      if (9 == rig_->GetRxFrequency () - test_frequency)
-              rig_->SetFreqB (test_frequency);
+        {
-            }
+          resolution = 2;   // 20Hz rounded
-          else if (!reversed_ && (OmniRig::PM_FREQA & writable_params_))
-            {
-              rig_->SetFreqA (test_frequency);
-            }
-          else
-            {
-              throw_qstring (tr ("OmniRig: don't know how to set rig frequency"));
-            }
-          switch (rig_->GetRxFrequency () - test_frequency)
-            {
-            case -5: resolution = -1; break;  // 10Hz truncated
-            case 5: resolution = 1; break;    // 10Hz rounded
-            case -15: resolution = -2; break; // 20Hz truncated
-            case -55: resolution = -2; break; // 100Hz truncated
-            case 45: resolution = 2; break;   // 100Hz rounded
-            }
-          if (1 == resolution)  // may be 20Hz rounded
-            {
-              test_frequency = f - f % 100 + 51;
-              if (OmniRig::PM_FREQ & writable_params_)
-                {
-                  rig_->SetFreq (test_frequency);
-                }
-              else if (reversed_ && (OmniRig::PM_FREQB & writable_params_))
-                {
-                  rig_->SetFreqB (test_frequency);
-                }
-              else if (!reversed_ && (OmniRig::PM_FREQA & writable_params_))
-                {
-                  rig_->SetFreqA (test_frequency);
-                }
-              if (9 == rig_->GetRxFrequency () - test_frequency)
-                {
-                  resolution = 2;   // 20Hz rounded
-                }
-            }
-          if (OmniRig::PM_FREQ & writable_params_)
-            {
-              rig_->SetFreq (f);
-            }
-          else if (reversed_ && (OmniRig::PM_FREQB & writable_params_))
-            {
-              rig_->SetFreqB (f);
-            }
-          else if (!reversed_ && (OmniRig::PM_FREQA & writable_params_))
-            {
-              rig_->SetFreqA (f);
-            }
-          update_rx_frequency (f);
-          return resolution;
         }
     }
-  throw_qstring (tr ("OmniRig: Initialization timed out"));
+  if (OmniRig::PM_FREQ & writable_params_)
-  return 0;                     // keep compiler happy
+    {
+      rig_->SetFreq (f);
+    }
+  else if (reversed_ && (OmniRig::PM_FREQB & writable_params_))
+    {
+      rig_->SetFreqB (f);
+    }
+  else if (!reversed_ && (OmniRig::PM_FREQA & writable_params_))
+    {
+      rig_->SetFreqA (f);
+    }
+  update_rx_frequency (f);
+  return resolution;
 }
 
 void OmniRigTransceiver::do_stop ()
 {
-  if (offline_timer_)
-    {
-      offline_timer_->stop ();
-      offline_timer_.reset ();
-    }
-
   QThread::msleep (200);        // leave some time for pending
                                 // commands at the server end
   if (port_)
@@ -300,17 +306,6 @@ void OmniRigTransceiver::do_stop ()
   TRACE_CAT ("OmniRigTransceiver", "stopped");
 }
 
-void OmniRigTransceiver::do_sync (bool force_signal, bool /*no_poll*/)
-{
-  // nothing much we can do here, we just have to let OmniRig do its
-  // stuff and its first poll should send us and update that will
-  // trigger a update signal from us. Any attempt to query OmniRig
-  // leads to a whole mess of trouble since its internal state is
-  // garbage until it has done its first rig poll.
-  send_update_signal_ = force_signal;
-  update_complete ();
-}
-
 void OmniRigTransceiver::handle_COM_exception (int code, QString source, QString desc, QString help)
 {
   TRACE_CAT ("OmniRigTransceiver", QString::number (code) + " at " + source + ": " + desc + " (" + help + ')');
@@ -319,16 +314,20 @@ void OmniRigTransceiver::handle_COM_exception (int code, QString source, QString
 
 void OmniRigTransceiver::handle_visible_change ()
 {
+  if (!omni_rig_ || omni_rig_->isNull ()) return;
   TRACE_CAT ("OmniRigTransceiver", "visibility change: visibility =" << omni_rig_->DialogVisible ());
 }
 
 void OmniRigTransceiver::handle_rig_type_change (int rig_number)
 {
+  if (!omni_rig_ || omni_rig_->isNull ()) return;
+  TRACE_CAT ("OmniRigTransceiver", "rig type change: rig =" << rig_number);
   if (rig_number_ == rig_number)
     {
+      if (!rig_ || rig_->isNull ()) return;
       readable_params_ = rig_->ReadableParams ();
       writable_params_ = rig_->WriteableParams ();
-      TRACE_CAT ("OmniRigTransceiver", QString {"OmniRig rig type change to: %1 readable params = 0x%2 writable params = 0x%3 for rig %4"}
+      TRACE_CAT ("OmniRigTransceiver", QString {"rig type change to: %1 readable params = 0x%2 writable params = 0x%3 for rig %4"}
         .arg (rig_->RigType ())
         .arg (readable_params_, 8, 16, QChar ('0'))
         .arg (writable_params_, 8, 16, QChar ('0'))
@@ -338,48 +337,43 @@ void OmniRigTransceiver::handle_rig_type_change (int rig_number)
 
 void OmniRigTransceiver::handle_status_change (int rig_number)
 {
+  if (!omni_rig_ || omni_rig_->isNull ()) return;
+  TRACE_CAT ("OmniRigTransceiver", QString {"status change for rig %1"}.arg (rig_number).toLocal8Bit ());
   if (rig_number_ == rig_number)
     {
+      if (!rig_ || rig_->isNull ()) return;
       auto const& status = rig_->StatusStr ().toLocal8Bit ();
-      TRACE_CAT ("OmniRigTransceiver", QString {"OmniRig status change: new status for rig %1 = "}.arg (rig_number).toLocal8Bit () << status);
+      TRACE_CAT ("OmniRigTransceiver", "OmniRig status change: new status = " << status);
       if (OmniRig::ST_ONLINE != rig_->Status ())
         {
-          if (!offline_timer_->isActive ())
+          offline ("Rig went offline");
-            {
-              offline_timer_->start (); // give OmniRig time to recover
-            }
-        }
-      else
-        {
-          offline_timer_->stop ();
-          update_rx_frequency (rig_->GetRxFrequency ());
-          update_complete ();
-          TRACE_CAT ("OmniRigTransceiver", "OmniRig frequency:" << state ().frequency ());
         }
+      // else
+      //   {
+      //     update_rx_frequency (rig_->GetRxFrequency ());
+      //     update_complete ();
+      //     TRACE_CAT ("OmniRigTransceiver", "frequency:" << state ().frequency ());
+      //   }
     }
 }
 
-void OmniRigTransceiver::timeout_check ()
-{
-  offline ("Rig went offline");
-}
-
 void OmniRigTransceiver::handle_params_change (int rig_number, int params)
 {
-  if (rig_number_ == rig_number)
+  if (!omni_rig_ || omni_rig_->isNull ()) return;
-    {
+  TRACE_CAT ("OmniRigTransceiver", QString {"params change: params = 0x%1 for rig %2"}
-      TRACE_CAT ("OmniRigTransceiver", QString {"OmniRig params change: params = 0x%1 for rig %2"}
         .arg (params, 8, 16, QChar ('0'))
         .arg (rig_number).toLocal8Bit ()
         << "state before:" << state ());
+  if (rig_number_ == rig_number)
+    {
+      if (!rig_ || rig_->isNull ()) return;
       //      starting_ = false;
       TransceiverState old_state {state ()};
       auto need_frequency = false;
-      // state_.online = true;  // sometimes we don't get an initial
+
-      //        // OmniRig::ST_ONLINE status change
-      //        // event
       if (params & OmniRig::PM_VFOAA)
         {
+          TRACE_CAT ("OmniRigTransceiver", "VFOAA");
           update_split (false);
           reversed_ = false;
           update_rx_frequency (rig_->FreqA ());
@@ -387,6 +381,7 @@ void OmniRigTransceiver::handle_params_change (int rig_number, int params)
         }
       if (params & OmniRig::PM_VFOAB)
         {
+          TRACE_CAT ("OmniRigTransceiver", "VFOAB");
           update_split (true);
           reversed_ = false;
           update_rx_frequency (rig_->FreqA ());
@@ -394,6 +389,7 @@ void OmniRigTransceiver::handle_params_change (int rig_number, int params)
         }
       if (params & OmniRig::PM_VFOBA)
         {
+          TRACE_CAT ("OmniRigTransceiver", "VFOBA");
           update_split (true);
           reversed_ = true;
           update_other_frequency (rig_->FreqA ());
@@ -401,6 +397,7 @@ void OmniRigTransceiver::handle_params_change (int rig_number, int params)
         }
       if (params & OmniRig::PM_VFOBB)
         {
+          TRACE_CAT ("OmniRigTransceiver", "VFOBB");
           update_split (false);
           reversed_ = true;
           update_other_frequency (rig_->FreqA ());
@@ -408,64 +405,75 @@ void OmniRigTransceiver::handle_params_change (int rig_number, int params)
         }
       if (params & OmniRig::PM_VFOA)
         {
+          TRACE_CAT ("OmniRigTransceiver", "VFOA");
           reversed_ = false;
           need_frequency = true;
         }
       if (params & OmniRig::PM_VFOB)
         {
+          TRACE_CAT ("OmniRigTransceiver", "VFOB");
           reversed_ = true;
           need_frequency = true;
         }
 
       if (params & OmniRig::PM_FREQ)
         {
+          TRACE_CAT ("OmniRigTransceiver", "FREQ");
           need_frequency = true;
         }
       if (params & OmniRig::PM_FREQA)
         {
+          auto f = rig_->FreqA ();
+          TRACE_CAT ("OmniRigTransceiver", "FREQA = " << f);
           if (reversed_)
             {
-              update_other_frequency (rig_->FreqA ());
+              update_other_frequency (f);
             }
           else
             {
-              update_rx_frequency (rig_->FreqA ());
+              update_rx_frequency (f);
             }
         }
       if (params & OmniRig::PM_FREQB)
         {
+          auto f = rig_->FreqB ();
+          TRACE_CAT ("OmniRigTransceiver", "FREQB = " << f);
           if (reversed_)
             {
-              update_rx_frequency (rig_->FreqB ());
+              update_rx_frequency (f);
             }
           else
             {
-              update_other_frequency (rig_->FreqB ());
+              update_other_frequency (f);
             }
         }
       if (need_frequency)
         {
           if (readable_params_ & OmniRig::PM_FREQA)
             {
+              auto f = rig_->FreqA ();
+              TRACE_CAT ("OmniRigTransceiver", "FREQA = " << f);
               if (reversed_)
                 {
-                  update_other_frequency (rig_->FreqA ());
+                  update_other_frequency (f);
                 }
               else
                 {
-                  update_rx_frequency (rig_->FreqA ());
+                  update_rx_frequency (f);
                 }
               need_frequency = false;
             }
           if (readable_params_ & OmniRig::PM_FREQB)
             {
+              auto f = rig_->FreqB ();
+              TRACE_CAT ("OmniRigTransceiver", "FREQB = " << f);
               if (reversed_)
                 {
-                  update_rx_frequency (rig_->FreqB ());
+                  update_rx_frequency (f);
                 }
               else
                 {
-                  update_other_frequency (rig_->FreqB ());
+                  update_other_frequency (f);
                 }
               need_frequency = false;
             }
@@ -473,89 +481,113 @@ void OmniRigTransceiver::handle_params_change (int rig_number, int params)
       if (need_frequency && (readable_params_ & OmniRig::PM_FREQ)
           && !state ().ptt ())
         {
-          update_rx_frequency (rig_->Freq ());
+          auto f = rig_->Freq ();
+          TRACE_CAT ("OmniRigTransceiver", "FREQ = " << f);
+          update_rx_frequency (f);
         }
       if (params & OmniRig::PM_PITCH)
         {
+          TRACE_CAT ("OmniRigTransceiver", "PITCH");
         }
       if (params & OmniRig::PM_RITOFFSET)
         {
+          TRACE_CAT ("OmniRigTransceiver", "RITOFFSET");
         }
       if (params & OmniRig::PM_RIT0)
         {
+          TRACE_CAT ("OmniRigTransceiver", "RIT0");
         }
       if (params & OmniRig::PM_VFOEQUAL)
         {
           auto f = readable_params_ & OmniRig::PM_FREQA ? rig_->FreqA () : rig_->Freq ();
+          auto m = map_mode (rig_->Mode ());
+          TRACE_CAT ("OmniRigTransceiver", QString {"VFOEQUAL f=%1 m=%2"}.arg (f).arg (m));
           update_rx_frequency (f);
           update_other_frequency (f);
-          update_mode (map_mode (rig_->Mode ()));
+          update_mode (m);
         }
       if (params & OmniRig::PM_VFOSWAP)
         {
-          auto temp = state ().tx_frequency ();
+          TRACE_CAT ("OmniRigTransceiver", "VFOSWAP");
+          auto f = state ().tx_frequency ();
           update_other_frequency (state ().frequency ());
-          update_rx_frequency (temp);
+          update_rx_frequency (f);
           update_mode (map_mode (rig_->Mode ()));
         }
       if (params & OmniRig::PM_SPLITON)
         {
+          TRACE_CAT ("OmniRigTransceiver", "SPLITON");
           update_split (true);
         }
       if (params & OmniRig::PM_SPLITOFF)
         {
+          TRACE_CAT ("OmniRigTransceiver", "SPLITOFF");
           update_split (false);
         }
       if (params & OmniRig::PM_RITON)
         {
+          TRACE_CAT ("OmniRigTransceiver", "RITON");
         }
       if (params & OmniRig::PM_RITOFF)
         {
+          TRACE_CAT ("OmniRigTransceiver", "RITOFF");
         }
       if (params & OmniRig::PM_XITON)
         {
+          TRACE_CAT ("OmniRigTransceiver", "XITON");
         }
       if (params & OmniRig::PM_XITOFF)
         {
+          TRACE_CAT ("OmniRigTransceiver", "XITOFF");
         }
       if (params & OmniRig::PM_RX)
         {
+          TRACE_CAT ("OmniRigTransceiver", "RX");
           update_PTT (false);
         }
       if (params & OmniRig::PM_TX)
         {
+          TRACE_CAT ("OmniRigTransceiver", "TX");
           update_PTT ();
         }
       if (params & OmniRig::PM_CW_U)
         {
+          TRACE_CAT ("OmniRigTransceiver", "CW-R");
           update_mode (CW_R);
         }
       if (params & OmniRig::PM_CW_L)
         {
+          TRACE_CAT ("OmniRigTransceiver", "CW");
           update_mode (CW);
         }
       if (params & OmniRig::PM_SSB_U)
         {
+          TRACE_CAT ("OmniRigTransceiver", "USB");
           update_mode (USB);
         }
       if (params & OmniRig::PM_SSB_L)
         {
+          TRACE_CAT ("OmniRigTransceiver", "LSB");
           update_mode (LSB);
         }
       if (params & OmniRig::PM_DIG_U)
         {
+          TRACE_CAT ("OmniRigTransceiver", "DATA-U");
           update_mode (DIG_U);
         }
       if (params & OmniRig::PM_DIG_L)
         {
+          TRACE_CAT ("OmniRigTransceiver", "DATA-L");
           update_mode (DIG_L);
         }
       if (params & OmniRig::PM_AM)
         {
+          TRACE_CAT ("OmniRigTransceiver", "AM");
           update_mode (AM);
         }
       if (params & OmniRig::PM_FM)
         {
+          TRACE_CAT ("OmniRigTransceiver", "FM");
           update_mode (FM);
         }
 
@@ -566,6 +598,7 @@ void OmniRigTransceiver::handle_params_change (int rig_number, int params)
         }
       TRACE_CAT ("OmniRigTransceiver", "OmniRig params change: state after:" << state ());
     }
+  Q_EMIT notified ();
 }
 
 void OmniRigTransceiver::handle_custom_reply (int rig_number, QVariant const& command, QVariant const& reply)
@@ -573,8 +606,10 @@ void OmniRigTransceiver::handle_custom_reply (int rig_number, QVariant const& co
   (void)command;
   (void)reply;
 
+  if (!omni_rig_ || omni_rig_->isNull ()) return;
   if (rig_number_ == rig_number)
     {
+      if (!rig_ || rig_->isNull ()) return;
       TRACE_CAT ("OmniRigTransceiver", "custom command" << command.toString ().toLocal8Bit ()
                  << "with reply" << reply.toString ().toLocal8Bit ()
                  << QString ("for rig %1").arg (rig_number).toLocal8Bit ());

OmniRigTransceiver.hpp

@@ -38,10 +38,11 @@ public:
   void do_tx_frequency (Frequency, MODE, bool no_ignore) override;
   void do_mode (MODE) override;
   void do_ptt (bool on) override;
-  void do_sync (bool force_signal, bool no_poll) override;
 
 private:
-  Q_SLOT void timeout_check ();
+  bool await_notification_with_timeout (int timeout);
+  Q_SIGNAL void notified () const;
+  // Q_SLOT void timeout_check ();
   Q_SLOT void handle_COM_exception (int,  QString, QString, QString);
   Q_SLOT void handle_visible_change ();
   Q_SLOT void handle_rig_type_change (int rig_number);
@@ -62,7 +63,7 @@ private:
   QString rig_type_;
   int readable_params_;
   int writable_params_;
-  QScopedPointer<QTimer> offline_timer_;
+  // QScopedPointer<QTimer> offline_timer_;
   bool send_update_signal_;
   bool reversed_;   // some rigs can reverse VFOs
 };

PollingTransceiver.cpp

@@ -129,52 +129,46 @@ bool PollingTransceiver::do_pre_update ()
   return true;
 }
 
-void PollingTransceiver::do_sync (bool force_signal, bool no_poll)
-{
-  if (!no_poll) poll ();        // tell sub-classes to update our state
-
-  // Signal new state if it is directly requested or, what we expected
-  // or, hasn't become what we expected after polls_to_stabilize
-  // polls. Unsolicited changes will be signalled immediately unless
-  // they intervene in a expected sequence where they will be delayed.
-  if (retries_)
-    {
-      --retries_;
-      if (force_signal || state () == next_state_ || !retries_)
-        {
-          // our client wants a signal regardless
-          // or the expected state has arrived
-          // or there are no more retries
-          force_signal = true;
-        }
-    }
-  else if (force_signal || state () != last_signalled_state_)
-    {
-      // here is the normal passive polling path either our client has
-      // requested a state update regardless of change or state has
-      // changed asynchronously
-      force_signal = true;
-    }
-
-  if (force_signal)
-    {
-      // reset everything, record and signal the current state
-      retries_ = 0;
-      next_state_ = state ();
-      last_signalled_state_ = state ();
-      update_complete (true);
-    }
-}
-
 void PollingTransceiver::handle_timeout ()
 {
   QString message;
+  bool force_signal {false};
 
   // we must catch all exceptions here since we are called by Qt and
   // inform our parent of the failure via the offline() message
   try
     {
-      do_sync ();
+      do_poll ();              // tell sub-classes to update our state
+
+      // Signal new state if it what we expected or, hasn't become
+      // what we expected after polls_to_stabilize polls. Unsolicited
+      // changes will be signalled immediately unless they intervene
+      // in a expected sequence where they will be delayed.
+      if (retries_)
+        {
+          --retries_;
+          if (state () == next_state_ || !retries_)
+            {
+              // the expected state has arrived or there are no more
+              // retries
+              force_signal = true;
+            }
+        }
+      else if (state () != last_signalled_state_)
+        {
+          // here is the normal passive polling path where state has
+          // changed asynchronously
+          force_signal = true;
+        }
+
+      if (force_signal)
+        {
+          // reset everything, record and signal the current state
+          retries_ = 0;
+          next_state_ = state ();
+          last_signalled_state_ = state ();
+          update_complete (true);
+        }
     }
   catch (std::exception const& e)
     {

PollingTransceiver.hpp

@@ -39,11 +39,9 @@ protected:
                                QObject * parent);
 
 protected:
-  void do_sync (bool force_signal = false, bool no_poll = false) override final;
-
   // Sub-classes implement this and fetch what they can from the rig
   // in a non-intrusive manner.
-  virtual void poll () = 0;
+  virtual void do_poll () = 0;
 
   void do_post_start () override final;
   void do_post_stop () override final;

TransceiverBase.cpp

@@ -19,10 +19,10 @@ void TransceiverBase::start (unsigned sequence_number) noexcept
   QString message;
   try
     {
+      last_sequence_number_ = sequence_number;
       may_update u {this, true};
       shutdown ();
       startup ();
-      last_sequence_number_ = sequence_number;
     }
   catch (std::exception const& e)
     {
@@ -46,6 +46,7 @@ void TransceiverBase::set (TransceiverState const& s,
   QString message;
   try
     {
+      last_sequence_number_ = sequence_number;
       may_update u {this, true};
       bool was_online {requested_.online ()};
       if (!s.online () && was_online)
@@ -115,7 +116,6 @@ void TransceiverBase::set (TransceiverState const& s,
           // record what actually changed
           requested_.ptt (actual_.ptt ());
         }
-      last_sequence_number_ = sequence_number;
     }
   catch (std::exception const& e)
     {
@@ -133,10 +133,27 @@ void TransceiverBase::set (TransceiverState const& s,
 
 void TransceiverBase::startup ()
 {
-  Q_EMIT resolution (do_start ());
+  QString message;
-  do_post_start ();
+  try
-  actual_.online (true);
+    {
-  requested_.online (true);
+      actual_.online (true);
+      requested_.online (true);
+      auto res = do_start ();
+      do_post_start ();
+      Q_EMIT resolution (res);
+    }
+  catch (std::exception const& e)
+    {
+      message = e.what ();
+    }
+  catch (...)
+    {
+      message = unexpected;
+    }
+  if (!message.isEmpty ())
+    {
+      offline (message);
+    }
 }
 
 void TransceiverBase::shutdown ()
@@ -163,8 +180,8 @@ void TransceiverBase::shutdown ()
     }
   do_stop ();
   do_post_stop ();
-  actual_.online (false);
+  actual_ = TransceiverState {};
-  requested_.online (false);
+  requested_ = TransceiverState {};
 }
 
 void TransceiverBase::stop () noexcept

TransceiverBase.hpp

@@ -112,8 +112,6 @@ protected:
   virtual void do_ptt (bool = true) = 0;
   virtual void do_post_ptt (bool = true) {}
 
-  virtual void do_sync (bool force_signal = false, bool no_poll = false) = 0;
-
   virtual bool do_pre_update () {return true;}
 
   // sub classes report rig state changes with these methods