mirror of
https://github.com/saitohirga/WSJT-X.git
synced 2024-11-22 04:11:16 -05:00
2cfbb15b4f
The concept of a nominal receive and transmit frequency has been introduced. This is used as a base frequency for Doppler correction, frequency setting and reporting. The start up frequency is now zero which is updated by the first rig control status report. This needs more work to accommodate calling frequency plus working frequency operation as is used for random MS operation etc.. The main window frequency display now shows the transmit dial frequency while transmitting. The mode changing logic sequence has been changed such that the rig is correctly put into and taken out of split mode as required by the target mode. This also avoids the "other" VFO having its frequency changed when entering a mode that does not use split operating like WSPR. The main window band combo box edit may now be used to input an kHz offset from the current MHz dial frequency. This is intended for setting a sked or working frequency on the VHF and up bands. For example the working frequency for 23cms might be set to 1296MHz and a working frequency of 1296.3MHz would be selected by selecting the 23cms band with the combo box drop down list and then entering 300k into the band combo box edit widget. When using JT4 modes a CTRL+Click on the waterfall adjusts the nominal frequency such that the frequency clicked on becomes the Tx and Rx frequency using the fixed 1000Hz DF that JT4 modes use. This will probably be extended to all QSO modes when used in VHF & up mode. This assumes that 1000Hz is an optimal DF for both Tx and Rx and therefore one can "net" to an off frequency, but visible on the waterfall, caller with one click. Improvements to OmniRig rig control including use of the serial port control lines RTS or DTR, on the CAT serial port used by OmniRig, for PTT control. Incrementing transaction sequence numbers added to messages to and from the rig control thread. This enables round trip status to be tracked and associated with a request. For example a command that might cause several asynchronous status updates can now be tracked in the originating thread such that it is clear which updates are caused by executing the request. This in turn allows updates to be held until the request is complete i.e. the state is consistent with the results of the request. Messages to the rig control thread are now posted as a new state (Transceiver::TransceiverState) object. The rig control thread tracks requests and actions any differences between the prior requests and the new state. The rig control thread is now stored on the heap so that it can be closed down and released as needed. Along with this the rig control close down semantics are better defined avoiding some potential deadlock situations. If the rig is placed into split mode it will be reverted to simplex mode when the rig connection is closed. When using direct rig control via Hamlib, rigs that have A/B VFO arrangements and no method to query the current VFO like many Icoms and the Yaesu FT-817/857/897(D) series now have smarted frequency updating requiring no VFO changes when changing the frequency. This is particularly important when doing Tx Doppler correction to avoid glitches. The implementation of emulated split operating mode ("Fake It") is simplified and improved. A dummy Hamlib transceiver for PTT control on a separate port is no long instantiated if CAT or VOX PTT control is selected. The resolution and any rounding of the rig CAT frequency set and get commands is determined automatically upon opening the rig connection. This is needed to determine the rate of frequency updates for Doppler tracking. It also allows the rig to be more accurately controlled. Frequency calibration is calculated separately for the receive and transmit frequencies. Whether the rig modulation mode should be controlled is now a constructor argument rather than being passed with individual rig control requests. Doppler shift correction is considerably enhanced with simpler controls and much better rig control. A new mode of tracking called "receive only" is introduced for those with rigs that cannot be QSY:ed via CAT when transmitting. Such rigs have a Doppler correction calculated for the middle of the next transmit period just before transmission starts. While using Doppler tracking it is now possible to adjust the sked frequency either using the new kHz offset feature of the main window band combo box or by directly tuning the rig VFO knob while holding down the CTRL key. The astronomical data window that includes Doppler tracking control is now opened and closed using a checkable menu item to avoid it being accidentally closed. Debug configuration rig control diagnostic messages now have a facility argument for clearer and more standardized trace messages. git-svn-id: svn+ssh://svn.code.sf.net/p/wsjt/wsjt/branches/wsjtx@6590 ab8295b8-cf94-4d9e-aec4-7959e3be5d79
174 lines
5.5 KiB
C++
174 lines
5.5 KiB
C++
#ifndef TRANSCEIVER_HPP__
|
|
#define TRANSCEIVER_HPP__
|
|
|
|
#include <QObject>
|
|
|
|
#include "qt_helpers.hpp"
|
|
#include "Radio.hpp"
|
|
|
|
class QString;
|
|
|
|
//
|
|
// Abstract Transceiver Interface
|
|
//
|
|
// This is the minimal generic interface to a rig as required by
|
|
// wsjtx.
|
|
//
|
|
// Responsibilities
|
|
//
|
|
// Provides a Qt slot to set the frequency, mode and PTT of some
|
|
// transceiver. This is a Qt slot so that it may be invoked across a
|
|
// thread boundary.
|
|
//
|
|
// Provides a synchronisation Qt slot which should be implemented in
|
|
// sub-classes in such a way that normal operation of the rig is not
|
|
// disturbed. This is intended to be use to poll rig state
|
|
// periodically and changing VFO to read the other VFO frequency or
|
|
// mode for example should not be done since the operator may be
|
|
// tuning the VFO at the time and would be surprised by an unprompted
|
|
// VFO change.
|
|
//
|
|
// Provides a control interface using Qt slots to start and stop the
|
|
// rig control and PTT connections.
|
|
//
|
|
// These are Qt slots rather than the constructor and destructor
|
|
// because it is expected that the concrete Transceiver
|
|
// implementations will run in a separate thread from where they are
|
|
// constructed.
|
|
//
|
|
// Qt signals are defined to notify clients of asynchronous rig state
|
|
// changes and failures. These can and are expected to cross thread
|
|
// boundaries.
|
|
//
|
|
// A signal finished() is defined that concrete Transceiver
|
|
// implementations must emit when they are ripe for destruction. This
|
|
// is intended to be used by clients that move the Transceiver
|
|
// instance to a thread and need to use QObject::deleteLater() to
|
|
// safely dispose of the Transceiver instance. Implementations should
|
|
// expect Qt slot calls after emitting finished, it is up to the
|
|
// implementation whether these slot invocations are ignored.
|
|
//
|
|
class Transceiver
|
|
: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_ENUMS (MODE)
|
|
|
|
public:
|
|
using Frequency = Radio::Frequency;
|
|
|
|
protected:
|
|
Transceiver (QObject * parent) : QObject {parent} {}
|
|
|
|
public:
|
|
virtual ~Transceiver () {}
|
|
|
|
enum MODE {UNK, CW, CW_R, USB, LSB, FSK, FSK_R, DIG_U, DIG_L, AM, FM, DIG_FM};
|
|
Q_ENUM (MODE)
|
|
|
|
//
|
|
// Aggregation of all of the rig and PTT state accessible via this
|
|
// interface.
|
|
//
|
|
class TransceiverState
|
|
{
|
|
public:
|
|
TransceiverState ()
|
|
: online_ {false}
|
|
, rx_frequency_ {0}
|
|
, tx_frequency_ {0}
|
|
, mode_ {UNK}
|
|
, split_ {Split::unknown}
|
|
, ptt_ {false}
|
|
{
|
|
}
|
|
|
|
bool online () const {return online_;}
|
|
Frequency frequency () const {return rx_frequency_;}
|
|
Frequency tx_frequency () const {return tx_frequency_;}
|
|
bool split () const {return Split::on == split_;}
|
|
MODE mode () const {return mode_;}
|
|
bool ptt () const {return ptt_;}
|
|
|
|
void online (bool state) {online_ = state;}
|
|
void frequency (Frequency f) {rx_frequency_ = f;}
|
|
void tx_frequency (Frequency f) {tx_frequency_ = f;}
|
|
void split (bool state) {split_ = state ? Split::on : Split::off;}
|
|
void mode (MODE m) {mode_ = m;}
|
|
void ptt (bool state) {ptt_ = state;}
|
|
|
|
private:
|
|
bool online_;
|
|
Frequency rx_frequency_;
|
|
Frequency tx_frequency_; // 0 means use Rx
|
|
MODE mode_;
|
|
enum class Split {unknown, off, on} split_;
|
|
bool ptt_;
|
|
// Don't forget to update the debug print and != operator if you
|
|
// add more members here
|
|
|
|
friend QDebug operator << (QDebug, TransceiverState const&);
|
|
friend bool operator != (TransceiverState const&, TransceiverState const&);
|
|
};
|
|
|
|
//
|
|
// The following slots and signals are expected to all run in the
|
|
// same thread which is not necessarily the main GUI thread. It is
|
|
// up to the client of the Transceiver class to organise the
|
|
// allocation to a thread and the lifetime of the object instances.
|
|
//
|
|
|
|
// Apply state changes to the rig. The sequence_number parameter
|
|
// will be included in any status updates generated after this
|
|
// transaction is processed. The sequence number may be used to
|
|
// ignore any status updates until the results of this transaction
|
|
// have been processed thus avoiding any unwanted "ping-pong" due to
|
|
// signals crossing in transit.
|
|
Q_SLOT virtual void set (Transceiver::TransceiverState const&,
|
|
unsigned sequence_number) noexcept = 0;
|
|
|
|
// Connect and disconnect.
|
|
Q_SLOT virtual void start (unsigned sequence_number) noexcept = 0;
|
|
Q_SLOT virtual void stop () noexcept = 0;
|
|
|
|
//
|
|
// asynchronous status updates
|
|
//
|
|
|
|
// 0 - 1Hz
|
|
// 1 - 10Hz rounded
|
|
// -1 - 10Hz truncated
|
|
// 2 - 100Hz rounded
|
|
// -2 - 100Hz truncated
|
|
Q_SIGNAL void resolution (int);
|
|
|
|
// rig state changed
|
|
Q_SIGNAL void update (Transceiver::TransceiverState const&,
|
|
unsigned sequence_number) const;
|
|
|
|
// something went wrong - not recoverable, start new instance
|
|
Q_SIGNAL void failure (QString const& reason) const;
|
|
|
|
// Ready to be destroyed.
|
|
Q_SIGNAL void finished () const;
|
|
};
|
|
|
|
Q_DECLARE_METATYPE (Transceiver::TransceiverState);
|
|
#if QT_VERSION < 0x050500
|
|
Q_DECLARE_METATYPE (Transceiver::MODE);
|
|
#endif
|
|
|
|
#if !defined (QT_NO_DEBUG_STREAM)
|
|
ENUM_QDEBUG_OPS_DECL (Transceiver, MODE);
|
|
|
|
QDebug operator << (QDebug, Transceiver::TransceiverState const&);
|
|
#endif
|
|
|
|
ENUM_QDATASTREAM_OPS_DECL (Transceiver, MODE);
|
|
ENUM_CONVERSION_OPS_DECL (Transceiver, MODE);
|
|
|
|
bool operator != (Transceiver::TransceiverState const&, Transceiver::TransceiverState const&);
|
|
bool operator == (Transceiver::TransceiverState const&, Transceiver::TransceiverState const&);
|
|
|
|
#endif
|