1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
#include "PollingTransceiver.h"
#include <exception>
#include <QObject>
#include <QString>
#include <QTimer>
#include "moc_PollingTransceiver.cpp"
namespace {
unsigned const polls_to_stabilize{3};
}
PollingTransceiver::PollingTransceiver(int poll_interval, QObject *parent)
: TransceiverBase{parent}, interval_{poll_interval * 1000},
poll_timer_{nullptr}, retries_{0} {}
void PollingTransceiver::start_timer() {
if (interval_) {
if (!poll_timer_) {
poll_timer_ = new QTimer{this}; // pass ownership to
// QObject which handles
// destruction for us
connect(poll_timer_, &QTimer::timeout, this,
&PollingTransceiver::handle_timeout);
}
poll_timer_->start(interval_);
} else {
stop_timer();
}
}
void PollingTransceiver::stop_timer() {
if (poll_timer_) {
poll_timer_->stop();
}
}
void PollingTransceiver::do_post_start() {
start_timer();
if (!next_state_.online()) {
// remember that we are expecting to go online
next_state_.online(true);
retries_ = polls_to_stabilize;
}
}
void PollingTransceiver::do_post_stop() {
// not much point waiting for rig to go offline since we are ceasing
// polls
stop_timer();
}
void PollingTransceiver::do_post_frequency(Frequency f, MODE m) {
// take care not to set the expected next mode to unknown since some
// callers use mode == unknown to signify that they do not know the
// mode and don't care
if (next_state_.frequency() != f || (m != UNK && next_state_.mode() != m)) {
// update expected state with new frequency and set poll count
next_state_.frequency(f);
if (m != UNK) {
next_state_.mode(m);
}
retries_ = polls_to_stabilize;
}
}
void PollingTransceiver::do_post_tx_frequency(Frequency f, MODE) {
if (next_state_.tx_frequency() != f) {
// update expected state with new TX frequency and set poll
// count
next_state_.tx_frequency(f);
next_state_.split(f); // setting non-zero TX frequency means split
retries_ = polls_to_stabilize;
}
}
void PollingTransceiver::do_post_mode(MODE m) {
// we don't ever expect mode to goto to unknown
if (m != UNK && next_state_.mode() != m) {
// update expected state with new mode and set poll count
next_state_.mode(m);
retries_ = polls_to_stabilize;
}
}
void PollingTransceiver::do_post_ptt(bool p) {
if (next_state_.ptt() != p) {
// update expected state with new PTT and set poll count
next_state_.ptt(p);
retries_ = polls_to_stabilize;
// retries_ = 0; // fast feedback on PTT
}
}
bool PollingTransceiver::do_pre_update() {
// if we are holding off a change then withhold the signal
if (retries_ && state() != next_state_) {
return false;
}
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;
// 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();
} catch (std::exception const &e) {
message = e.what();
} catch (...) {
message = tr("Unexpected rig error");
}
if (!message.isEmpty()) {
offline(message);
}
}
|
