ham-ref/flrig
1
0
Fork 0
mirror of https://git.code.sf.net/p/fldigi/flrig synced 2026-08-13 17:28:24 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Sliders/Auto-on-off

Browse source 
* bug fix - disallow UI slider changes when volume muted
  * bug fix - do not transfer data to xcvr on event FL_LEAVE
  * correct slider behavior using mouse wheel
  * add auto ON/OFF for Icom transceivers
    - IC7100
    - IC7300
    - IC7610
    - IC7851
    - IC9700
This commit is contained in:
David Freese 2020-02-23 10:05:12 -06:00
parent aaaf2252b4
commit e1f13d52ba
23 changed files with 508 additions and 462 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/UI/ui_small.cxx
View file

@ -113,7 +113,7 @@ Fl_Group *small_main_group(int X, int Y, int W, int H)
sldrVOLUME->textsize(12);
sldrVOLUME->callback((Fl_Callback*)cb_sldrVOLUME);
sldrVOLUME->align(Fl_Align(FL_ALIGN_CENTER|FL_ALIGN_INSIDE));
sldrVOLUME->when(FL_WHEN_CHANGED | FL_LEAVE);
sldrVOLUME->when(FL_WHEN_CHANGED | FL_MOUSEWHEEL | FL_LEAVE);
sldrVOLUME->reverse(true);
btnAGC = new Fl_Light_Button(2, 145, 50, 18, _("AGC"));

2
src/UI/ui_touch.cxx
View file

@ -449,7 +449,7 @@ Fl_Group *touch_main_group(int X, int Y, int W, int H)
sldrVOLUME->textsize(14);
sldrVOLUME->callback((Fl_Callback*)cb_sldrVOLUME);
sldrVOLUME->align(Fl_Align(FL_ALIGN_CENTER|FL_ALIGN_INSIDE));
sldrVOLUME->when(FL_WHEN_CHANGED | FL_LEAVE);
sldrVOLUME->when(FL_WHEN_CHANGED | FL_MOUSEWHEEL | FL_LEAVE);
Fl_Group::current()->resizable(sldrVOLUME);
sldrVOLUME->reverse(true);

4
src/UI/ui_wide.cxx
View file

@ -756,7 +756,7 @@ Fl_Group *wide_main_group(int X, int Y, int W, int H)
sldrVOLUME->textsize(12);
sldrVOLUME->callback((Fl_Callback*)cb_sldrVOLUME);
sldrVOLUME->align(Fl_Align(FL_ALIGN_CENTER|FL_ALIGN_INSIDE));
sldrVOLUME->when(FL_WHEN_CHANGED | FL_LEAVE);
sldrVOLUME->when(FL_WHEN_CHANGED | FL_MOUSEWHEEL | FL_LEAVE);
Fl_Group::current()->resizable(sldrVOLUME);
sldrVOLUME->reverse(true);
@ -784,7 +784,7 @@ Fl_Group *wide_main_group(int X, int Y, int W, int H)
sldrVOLUME->textsize(12);
sldrVOLUME->callback((Fl_Callback*)cb_sldrVOLUME);
sldrVOLUME->align(Fl_Align(FL_ALIGN_CENTER|FL_ALIGN_INSIDE));
sldrVOLUME->when(FL_WHEN_CHANGED | FL_LEAVE);
sldrVOLUME->when(FL_WHEN_CHANGED | FL_MOUSEWHEEL | FL_LEAVE);
Fl_Group::current()->resizable(sldrVOLUME);
sldrVOLUME->reverse(true);
#endif

4
src/UI/xcvr_setup.cxx
View file

@ -515,7 +515,7 @@ static void cb_poll_noise(Fl_Value_Input* o, void*) {
}
static void cb_poll_nr(Fl_Value_Input* o, void*) {
progStatus.poll_noise = o->value();
progStatus.poll_nr = o->value();
}
static void cb_poll_compression(Fl_Value_Input* o, void *) {
@ -1467,7 +1467,7 @@ Fl_Group *createPOLLING(int X, int Y, int W, int H, const char *label)
poll_nr->step(1);
poll_nr->callback((Fl_Callback*)cb_poll_nr);
poll_nr->align(Fl_Align(FL_ALIGN_RIGHT));
poll_nr->value(progStatus.poll_noise);
poll_nr->value(progStatus.poll_nr);
poll_compression = new Fl_Value_Input(X + 190, Y + 190, 30, 20, _("Comp'"));
poll_compression->tooltip(_("Compression"));

3
src/include/IC7100.h
View file

@ -169,6 +169,9 @@ public:
void set_BANDWIDTHS(std::string s);
std::string get_BANDWIDTHS();
void set_xcvr_auto_on();
void set_xcvr_auto_off();
};
#endif

2
src/include/IC7300.h
View file

@ -184,6 +184,8 @@ public:
void set_band_selection(int v);
void get_band_selection(int v);
void set_xcvr_auto_on();
void set_xcvr_auto_off();
};
#endif

2
src/include/IC7610.h
View file

@ -192,6 +192,8 @@ public:
void set_band_selection(int v);
void get_band_selection(int v);
void set_xcvr_auto_on();
void set_xcvr_auto_off();
};
#endif

2
src/include/IC7851.h
View file

@ -115,6 +115,8 @@ public:
void set_band_selection(int v);
void get_band_selection(int v);
void set_xcvr_auto_on();
void set_xcvr_auto_off();
};
#endif

2
src/include/IC9700.h
View file

@ -164,6 +164,8 @@ public:
void set_band_selection(int v);
void get_band_selection(int v);
void set_xcvr_auto_on();
void set_xcvr_auto_off();
};
#endif

4
src/include/ICbase.h
View file

@ -43,8 +43,8 @@ public:
void checkresponse();
bool sendICcommand(string str, int nbr);
void delayCommand(string cmd, int wait);
bool waitFB(const char *sz);
bool waitFOR(size_t n, const char *sz);
bool waitFB(const char *sz, int timeout = 0);
bool waitFOR(size_t n, const char *sz, int timeout = 0);
void adjustCIV(uchar adr);
virtual void swapAB();

2
src/rigs/AOR5K.cxx
View file

@ -171,7 +171,6 @@ int RIG_AOR5K::def_bandwidth(int m)
#define AOR5K_WAIT_TIME 800
extern int report_level;
void RIG_AOR5K::initialize()
{
@ -187,7 +186,6 @@ void RIG_AOR5K::initialize()
// aor5k_widgets[5].W = sldrNOTCH;
// aor5k_widgets[6].W = sldrPOWER;
report_level = INFO;
// cmd = "AI0;"; // disable auto-info
// sendCommand(cmd);
// showresp(INFO, ASC, "disable auto-info", cmd, replystr);

234
src/rigs/IC7100.cxx
View file

@ -22,7 +22,6 @@
#include <iostream>
#include <sstream>
#define IC7100_DEBUG
//=============================================================================
// IC-7100
@ -168,6 +167,7 @@ void RIG_IC7100::initialize()
choice_rTONE->activate();
choice_tTONE->activate();
}
RIG_IC7100::RIG_IC7100() {
@ -244,6 +244,8 @@ RIG_IC7100::RIG_IC7100() {
restore_mbw = true;
has_xcvr_auto_on_off = true;
precision = 1;
ndigits = 9;
A.filter = B.filter = 1;
@ -263,6 +265,47 @@ RIG_IC7100::RIG_IC7100() {
// IC7100 unique commands
//======================================================================
void RIG_IC7100::set_xcvr_auto_on()
{
cmd.clear();
int nr = progStatus.comm_baudrate == 6 ? 25 :
progStatus.comm_baudrate == 5 ? 13 :
progStatus.comm_baudrate == 4 ? 7 :
progStatus.comm_baudrate == 3 ? 3 : 2;
cmd.append( nr, '\xFE');
cmd.append(pre_to);
cmd += '\x18'; cmd += '\x01';
cmd.append(post);
waitFB("Power ON", 2000);
cmd = pre_to;
cmd += '\x19'; cmd += '\x00';
cmd.append(post);
waitFOR(8, "get ID", 10000);
}
void RIG_IC7100::set_xcvr_auto_off()
{
cmd.clear();
cmd.append(pre_to);
cmd += '\x18'; cmd += '\x00';
cmd.append(post);
waitFB("Power OFF", 200);
}
bool RIG_IC7100::check ()
{
bool ok = false;
string resp = pre_fm;
resp += '\x03';
cmd = pre_to;
cmd += '\x03';
cmd.append( post );
ok = waitFOR(11, "check vfo");
get_trace(2, "check()", str2hex(replystr.c_str(), replystr.length()));
return ok;
}
static bool IC7100onA = true;
void RIG_IC7100::selectA()
@ -287,18 +330,6 @@ void RIG_IC7100::selectB()
IC7100onA = false;
}
bool RIG_IC7100::check ()
{
string resp = pre_fm;
resp += '\x03';
cmd = pre_to;
cmd += '\x03';
cmd.append( post );
bool ok = waitFOR(11, "check vfo");
get_trace(2, "check()", str2hex(replystr.c_str(), replystr.length()));
return ok;
}
long RIG_IC7100::get_vfoA ()
{
if (useB) return A.freq;
@ -425,22 +456,21 @@ void RIG_IC7100::set_modeA(int val)
cmd = pre_to;
cmd += '\x06';
cmd += IC7100_mode_nbr[val];
cmd += A.filter;
if (val < LSBD7100)
cmd += A.filter;
cmd.append( post );
waitFB("set mode A");
set_trace(4, "set mode A[", IC7100modes_[A.imode], "] ", str2hex(replystr.c_str(), replystr.length()));
cmd = pre_to;
cmd += '\x1A'; cmd += '\x06';
if (val >= LSBD7100) {
cmd = pre_to;
cmd += '\x1A'; cmd += '\x06';
cmd += '\x01';
} else {
cmd += '\x00';
cmd += A.filter;
cmd.append( post);
set_trace(2, "set_data_modeA()", str2hex(replystr.c_str(), replystr.length()));
waitFB("set data mode A");
}
cmd += mode_filterA[A.imode];
cmd.append( post);
waitFB("set data mode A");
set_trace(2, "set_data_modeA()", str2hex(replystr.c_str(), replystr.length()));
}
int RIG_IC7100::get_modeA()
@ -505,22 +535,21 @@ void RIG_IC7100::set_modeB(int val)
cmd = pre_to;
cmd += '\x06';
cmd += IC7100_mode_nbr[val];
cmd += B.filter;
if (val < LSBD7100)
cmd += B.filter;
cmd.append( post );
waitFB("set mode B");
set_trace(4, "set mode B[", IC7100modes_[B.imode], "] ", str2hex(replystr.c_str(), replystr.length()));
cmd = pre_to;
cmd += '\x1A'; cmd += '\x06';
if (val >= LSBD7100) {
cmd = pre_to;
cmd += '\x1A'; cmd += '\x06';
cmd += '\x01';
} else {
cmd += '\x00';
cmd += B.filter;
cmd.append( post);
set_trace(2, "set_data_modeB()", str2hex(replystr.c_str(), replystr.length()));
waitFB("set data mode B");
}
cmd += mode_filterB[B.imode];
cmd.append( post);
set_trace(2, "set_data_modeB()", str2hex(replystr.c_str(), replystr.length()));
waitFB("set data mode B");
}
int RIG_IC7100::get_modeB()
@ -591,11 +620,6 @@ int RIG_IC7100::get_bwA()
cmd.append(post);
string resp = pre_fm;
resp.append("\x1a\x03");
#ifdef IC7100_DEBUG
stringstream ss;
ss << "get_bwA() " << str2hex(replystr.c_str(), replystr.length());
LOG_INFO("%s", ss.str().c_str());
#endif
if (waitFOR(8, "get bw A")) {
size_t p = replystr.rfind(resp);
A.iBW = fm_bcd(replystr.substr(p+6), 2);
@ -615,15 +639,6 @@ void RIG_IC7100::set_bwA(int val)
cmd.append("\x1a\x03");
cmd.append(to_bcd(A.iBW, 2));
cmd.append(post);
#ifdef IC7100_DEBUG
stringstream ss;
const char *bwstr = IC7100_ssb_bws[val];
if ((A.imode == AM7100) || (A.imode == AMD7100)) bwstr = IC7100_am_bws[val];
if ((A.imode == RTTY7100) || (A.imode == RTTYR7100)) bwstr = IC7100_rtty_bws[val];
ss << " (" << val << ") [" << bwstr << "] " <<
str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
waitFB("set bw A");
}
@ -638,11 +653,6 @@ int RIG_IC7100::get_bwB()
cmd.append(post);
string resp = pre_fm;
resp.append("\x1a\x03");
#ifdef IC7100_DEBUG
stringstream ss;
ss << "get_bwB() " << str2hex(replystr.c_str(), replystr.length());
LOG_INFO("%s", ss.str().c_str());
#endif
if (waitFOR(8, "get bw B")) {
size_t p = replystr.rfind(resp);
B.iBW = fm_bcd(replystr.substr(p+6), 2);
@ -662,15 +672,6 @@ void RIG_IC7100::set_bwB(int val)
cmd.append("\x1a\x03");
cmd.append(to_bcd(B.iBW, 2));
cmd.append(post);
#ifdef IC7100_DEBUG
stringstream ss;
const char *bwstr = IC7100_ssb_bws[val];
if ((A.imode == AM7100) || (A.imode == AMD7100)) bwstr = IC7100_am_bws[val];
if ((A.imode == RTTY7100) || (A.imode == RTTYR7100)) bwstr = IC7100_rtty_bws[val];
ss << " (" << val << ") [" << bwstr << "] " <<
str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
waitFB("set bw B");
}
@ -937,12 +938,6 @@ void RIG_IC7100::set_compression(int on, int val)
cmd.append(post);
waitFB("set Comp OFF");
}
#ifdef IC7100_DEBUG
stringstream ss;
ss << " (" << on << ", " << val << ") " <<
str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
}
void RIG_IC7100::set_vox_onoff()
@ -950,21 +945,11 @@ void RIG_IC7100::set_vox_onoff()
if (progStatus.vox_onoff) {
cmd.assign(pre_to).append("\x16\x46\x01");
cmd.append( post );
#ifdef IC7100_DEBUG
stringstream ss;
ss << " () " << str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
waitFB("set vox ON");
} else {
cmd.assign(pre_to).append("\x16\x46");
cmd += '\x00';
cmd.append( post );
#ifdef IC7100_DEBUG
stringstream ss;
ss << " () " << str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
waitFB("set vox OFF");
}
}
@ -976,12 +961,6 @@ void RIG_IC7100::set_vox_gain()
cmd +='\x63';
cmd.append(to_bcd((int)(progStatus.vox_gain * 2.55), 3));
cmd.append( post );
#ifdef IC7100_DEBUG
stringstream ss;
ss << " [" << progStatus.vox_gain << "] " <<
str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
waitFB("SET vox gain");
}
@ -992,12 +971,6 @@ void RIG_IC7100::set_vox_anti()
cmd +='\x64';
cmd.append(to_bcd((int)(progStatus.vox_anti * 2.55), 3));
cmd.append( post );
#ifdef IC7100_DEBUG
stringstream ss;
ss << " [" << progStatus.vox_anti << "] " <<
str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
waitFB("SET anti-vox");
}
@ -1008,12 +981,6 @@ void RIG_IC7100::set_vox_hang()
cmd +='\x65';
cmd.append(to_bcd((int)(progStatus.vox_hang / 10 ), 2));
cmd.append( post );
#ifdef IC7100_DEBUG
stringstream ss;
ss << " [" << progStatus.vox_hang << "] " <<
str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
waitFB("SET vox hang");
}
@ -1024,12 +991,6 @@ void RIG_IC7100::set_cw_wpm()
cmd.assign(pre_to).append("\x14\x0C"); // values 0-255 = 6 to 48 WPM
cmd.append(to_bcd(round((progStatus.cw_wpm - 6) * 255 / (48 - 6)), 3));
cmd.append( post );
#ifdef IC7100_DEBUG
stringstream ss;
ss << " [" << progStatus.cw_wpm << "] " <<
str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
waitFB("SET cw wpm");
}
@ -1039,12 +1000,6 @@ void RIG_IC7100::set_cw_qsk()
cmd.assign(pre_to).append("\x14\x0F");
cmd.append(to_bcd(n, 3));
cmd.append(post);
#ifdef IC7100_DEBUG
stringstream ss;
ss << " [" << progStatus.cw_qsk << "] " <<
str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
waitFB("Set cw qsk delay");
}
@ -1056,12 +1011,6 @@ void RIG_IC7100::set_cw_spot_tone()
if (n < 0) n = 0;
cmd.append(to_bcd(n, 3));
cmd.append( post );
#ifdef IC7100_DEBUG
stringstream ss;
ss << " [" << progStatus.cw_spot_tone << "] " <<
str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
waitFB("SET cw spot tone");
}
@ -1349,13 +1298,6 @@ void RIG_IC7100::set_notch(bool on, int val)
cmd.append(to_bcd(notch,3));
cmd.append(post);
waitFB("set notch val");
#ifdef IC7100_DEBUG
stringstream ss;
ss << " (" << on << ", " << val << ")" << str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
}
bool RIG_IC7100::get_notch(int &val)
@ -1402,11 +1344,6 @@ void RIG_IC7100::set_auto_notch(int val)
cmd += '\x41';
cmd += val ? 0x01 : 0x00;
cmd.append( post );
#ifdef IC7100_DEBUG
stringstream ss;
ss << " (" << val << ")" << str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
waitFB("set AN");
}
@ -1448,22 +1385,12 @@ void RIG_IC7100::set_if_shift(int val)
cmd.append("\x14\x07");
cmd.append(to_bcd(shift, 3));
cmd.append(post);
#ifdef IC7100_DEBUG
stringstream ss;
ss << " inner(" << val << ")" << str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss.str().c_str());
#endif
waitFB("set IF inner");
cmd = pre_to;
cmd.append("\x14\x08");
cmd.append(to_bcd(shift, 3));
cmd.append(post);
#ifdef IC7100_DEBUG
stringstream ss2;
ss2 << " outer(" << val << ")" << str2hex(cmd.data(), cmd.length());
LOG_INFO("%s", ss2.str().c_str());
#endif
waitFB("set IF outer");
}
@ -1566,10 +1493,10 @@ int RIG_IC7100::get_noise()
cmd.append(post);
if (waitFOR(8, "get noise")) {
size_t p = replystr.rfind(resp);
get_trace(2, "get_noise()", str2hex(replystr.c_str(), replystr.length()));
if (p != string::npos)
return (replystr[p+6] ? 1 : 0);
}
get_trace(2, "get_noise()", str2hex(replystr.c_str(), replystr.length()));
return progStatus.noise;
}
@ -1622,10 +1549,10 @@ int RIG_IC7100::get_noise_reduction()
cmd.append(post);
if (waitFOR(8, "get NR")) {
size_t p = replystr.rfind(resp);
get_trace(2, "get_noise_reduction()", str2hex(replystr.c_str(), replystr.length()));
if (p != string::npos)
return (replystr[p+6] ? 1 : 0);
}
get_trace(2, "get_noise_reduction()", str2hex(replystr.c_str(), replystr.length()));
return progStatus.noise_reduction;
}
@ -1658,9 +1585,8 @@ int RIG_IC7100::get_noise_reduction_val()
val /= 16;
}
}
progStatus.noise_reduction_val = val;
get_trace(2, "get_nr_val()", str2hex(replystr.c_str(), replystr.length()));
return progStatus.noise_reduction_val;
return val;
}
// Read/Write band stack registers
@ -1802,22 +1728,21 @@ void RIG_IC7100::set_FILT(int filter)
cmd = pre_to;
cmd += '\x06';
cmd += mdval[B.imode];
cmd += filter;
if (B.imode < LSBD7100)
cmd += filter;
cmd.append( post );
waitFB("set mode/filter B");
set_trace(2, "set mode/filter B", str2hex(replystr.c_str(), replystr.length()));
cmd = pre_to;
cmd += '\x1A'; cmd += '\x06';
if (B.imode >= LSBD7100) {
cmd = pre_to;
cmd += '\x1A'; cmd += '\x06';
cmd += '\x01';
} else {
cmd += '\x00';
cmd += filter;
cmd.append( post);
waitFB("set data mode B");
set_trace(2, "set data mode B", str2hex(replystr.c_str(), replystr.length()));
}
cmd += mode_filterB[B.imode];
cmd.append( post);
waitFB("set data mode/filter B");
set_trace(2, "set data mode/filter B", str2hex(replystr.c_str(), replystr.length()));
} else {
A.filter = filter;
mode_filterA[A.imode] = filter;
@ -1825,22 +1750,21 @@ void RIG_IC7100::set_FILT(int filter)
cmd = pre_to;
cmd += '\x06';
cmd += mdval[A.imode];
cmd += filter;
if (A.imode < LSBD7100)
cmd += filter;
cmd.append( post );
waitFB("set filter A ");
set_trace(2, "set filter A", str2hex(replystr.c_str(), replystr.length()));
cmd = pre_to;
cmd += '\x1A'; cmd += '\x06';
if (A.imode >= LSBD7100) {
cmd = pre_to;
cmd += '\x1A'; cmd += '\x06';
cmd += '\x01';
} else {
cmd += '\x00';
cmd += filter;
cmd.append( post);
waitFB("set data mode A");
set_trace(2, "set data mode A", str2hex(replystr.c_str(), replystr.length()));
}
cmd += mode_filterA[A.imode];
cmd.append( post);
waitFB("set data mode/filter A");
set_trace(2, "set data mode/filter A", str2hex(replystr.c_str(), replystr.length()));
}
}

29
src/rigs/IC7300.cxx
View file

@ -242,6 +242,8 @@ RIG_IC7300::RIG_IC7300() {
has_band_selection = true;
has_xcvr_auto_on_off = true;
precision = 1;
ndigits = 8;
@ -292,6 +294,33 @@ void RIG_IC7300::swapAB()
get_modeB();
}
void RIG_IC7300::set_xcvr_auto_on()
{
cmd.clear();
int fes[] = { 2, 2, 2, 3, 7, 13, 25, 50, 75, 150, 150, 150 };
if (progStatus.comm_baudrate >= 0 && progStatus.comm_baudrate <= 11) {
cmd.append( fes[progStatus.comm_baudrate], '\xFE');
}
cmd.append(pre_to);
cmd += '\x18'; cmd += '\x01';
cmd.append(post);
waitFB("Power ON", 200);
cmd = pre_to;
cmd += '\x19'; cmd += '\x00';
cmd.append(post);
waitFOR(8, "get ID", 10000);
}
void RIG_IC7300::set_xcvr_auto_off()
{
cmd.clear();
cmd.append(pre_to);
cmd += '\x18'; cmd += '\x00';
cmd.append(post);
waitFB("Power OFF", 200);
}
bool RIG_IC7300::check ()
{
string resp = pre_fm;

29
src/rigs/IC7610.cxx
View file

@ -265,6 +265,8 @@ RIG_IC7610::RIG_IC7610() {
has_vfo_adj = true;
has_xcvr_auto_on_off = true;
has_band_selection = true;
can_change_alt_vfo = true;
@ -312,6 +314,33 @@ void RIG_IC7610::swapAB()
get_modeB();
}
void RIG_IC7610::set_xcvr_auto_on()
{
cmd.clear();
int fes[] = { 2, 2, 2, 3, 7, 13, 25, 50, 75, 150, 150, 150 };
if (progStatus.comm_baudrate >= 0 && progStatus.comm_baudrate <= 11) {
cmd.append( fes[progStatus.comm_baudrate], '\xFE');
}
cmd.append(pre_to);
cmd += '\x18'; cmd += '\x01';
cmd.append(post);
waitFB("Power ON", 200);
cmd = pre_to;
cmd += '\x19'; cmd += '\x00';
cmd.append(post);
waitFOR(8, "get ID", 10000);
}
void RIG_IC7610::set_xcvr_auto_off()
{
cmd.clear();
cmd.append(pre_to);
cmd += '\x18'; cmd += '\x00';
cmd.append(post);
waitFB("Power OFF", 200);
}
bool RIG_IC7610::check ()
{
string resp = pre_fm;

29
src/rigs/IC7851.cxx
View file

@ -184,6 +184,8 @@ RIG_IC7851::RIG_IC7851() {
has_band_selection = true;
has_xcvr_auto_on_off = true;
precision = 1;
ndigits = 8;
@ -212,6 +214,33 @@ void RIG_IC7851::selectB()
waitFB("Select B");
}
void RIG_IC7851::set_xcvr_auto_on()
{
cmd.clear();
int fes[] = { 2, 2, 2, 3, 7, 13, 25, 50, 75, 150, 150, 150 };
if (progStatus.comm_baudrate >= 0 && progStatus.comm_baudrate <= 11) {
cmd.append( fes[progStatus.comm_baudrate], '\xFE');
}
cmd.append(pre_to);
cmd += '\x18'; cmd += '\x01';
cmd.append(post);
waitFB("Power ON", 200);
cmd = pre_to;
cmd += '\x19'; cmd += '\x00';
cmd.append(post);
waitFOR(8, "get ID", 10000);
}
void RIG_IC7851::set_xcvr_auto_off()
{
cmd.clear();
cmd.append(pre_to);
cmd += '\x18'; cmd += '\x00';
cmd.append(post);
waitFB("Power OFF", 200);
}
bool RIG_IC7851::check ()
{
string resp = pre_fm;

28
src/rigs/IC9700.cxx
View file

@ -262,6 +262,34 @@ void RIG_IC9700::selectB()
set_trace(2, "selectB()", str2hex(replystr.c_str(), replystr.length()));
}
void RIG_IC9700::set_xcvr_auto_on()
{
cmd.clear();
cmd.append(
(progStatus.comm_baudrate == 6 ? 25 :
progStatus.comm_baudrate == 5 ? 13 :
progStatus.comm_baudrate == 4 ? 7 :
progStatus.comm_baudrate == 3 ? 3 : 2), '\xFE');
cmd.append(pre_to);
cmd += '\x18'; cmd += '\x01';
cmd.append(post);
waitFB("Power ON", 200);
cmd = pre_to;
cmd += '\x19'; cmd += '\x00';
cmd.append(post);
waitFOR(8, "get ID", 10000);
}
void RIG_IC9700::set_xcvr_auto_off()
{
cmd.clear();
cmd.append(pre_to);
cmd += '\x18'; cmd += '\x00';
cmd.append(post);
waitFB("Power OFF", 200);
}
bool RIG_IC9700::check ()
{
string resp = pre_fm;

122
src/rigs/ICbase.cxx
View file

@ -101,7 +101,7 @@ void RIG_ICOM::ICtrace(string cmd, string hexstr)
rig_trace(2, cmd.c_str(), s1.c_str());
}
bool RIG_ICOM::waitFB(const char *sz)
bool RIG_ICOM::waitFB(const char *sz, int timeout)
{
guard_lock cmd_lock(&command_mutex);
@ -110,55 +110,60 @@ bool RIG_ICOM::waitFB(const char *sz)
char sztemp[100];
string returned = "";
string tosend = cmd;
unsigned long tod_start = zmsec();
unsigned long msec_start = 0;
int diff;
if (!progStatus.use_tcpip && !RigSerial->IsOpen()) {
replystr = cmd;//returned;
return false;
}
int cnt = 0, repeat = 0, num = cmd.length() + ok.length();
int num = cmd.length() + ok.length();
int wait_msec = (int)(num*11000.0/RigSerial->Baud() +
progStatus.use_tcpip ? progStatus.tcpip_ping_delay : 50) / 10;
int wait_msec = progStatus.use_tcpip ? progStatus.tcpip_ping_delay : 0;
wait_msec += 100;
wait_msec += num * 11000.0 / RigSerial->Baud();
for (repeat = 0; repeat < progStatus.comm_retries; repeat++) {
msec_start = zmsec();
sendCommand(cmd, 0);
returned = "";
for ( cnt = 0; cnt < wait_msec; cnt++) {
if (readResponse())
returned.append(respstr);
if (returned.find(ok) != string::npos) {
replystr = returned;
unsigned long int waited = zmsec() - msec_start;
snprintf(sztemp, sizeof(sztemp), "%s ans in %ld ms, OK", sz, waited);
if (repeat)
showresp(WARN, HEX, sztemp, tosend, returned);
else
showresp(DEBUG, HEX, sztemp, tosend, returned);
return true;
}
if (returned.find(bad) != string::npos) {
replystr = returned;
unsigned long int waited = zmsec() - msec_start;
snprintf(sztemp, sizeof(sztemp), "%s ans in %ld ms, FAIL", sz, waited);
showresp(ERR, HEX, sztemp, tosend, returned);
return false;
}
MilliSleep(10);
Fl::awake();
timeout += wait_msec;
unsigned long int loop_start;
msec_start = zmsec();
respstr.clear();
sendCommand(cmd, 0);
returned.clear();
loop_start = zmsec();
diff = zmsec() - loop_start;
while ( diff < timeout) { //wait_msec + 10 ) {
returned.append(respstr);
if (returned.find(ok) != string::npos) {
replystr = returned;
unsigned long int waited = zmsec() - msec_start;
snprintf(sztemp, sizeof(sztemp), "%s ans in %ld ms, OK", sz, waited);
showresp(DEBUG, HEX, sztemp, tosend, returned);
return true;
}
if (returned.find(bad) != string::npos) {
replystr = returned;
unsigned long int waited = zmsec() - msec_start;
snprintf(sztemp, sizeof(sztemp), "%s ans in %ld ms, FAILED", sz, waited);
showresp(ERR, HEX, sztemp, tosend, returned);
return false;
}
readResponse();
diff = zmsec() - loop_start;
}
diff = zmsec() - msec_start;
replystr = returned;
unsigned long int waited = zmsec() - tod_start;
snprintf(sztemp, sizeof(sztemp), "%s TIMED OUT in %ld ms", sz, waited);
showresp(ERR, HEX, sztemp, tosend, replystr);
snprintf(sztemp, sizeof(sztemp), "%s TIMED OUT : %d ms", sz, diff);
showresp(ERR, HEX, sztemp, tosend, returned);
return false;
}
bool RIG_ICOM::waitFOR(size_t n, const char *sz)
bool RIG_ICOM::waitFOR(size_t n, const char *sz, int timeout)
{
guard_lock cmd_lock(&command_mutex);
@ -167,42 +172,53 @@ bool RIG_ICOM::waitFOR(size_t n, const char *sz)
char sztemp[100];
string returned = "";
string tosend = cmd;
int cnt = 0, repeat = 0;
size_t num = n;
int diff = 0;
if (progStatus.comm_echo) num += cmd.length();
unsigned long int tod_start = zmsec();
unsigned long int msec_start = 0;
unsigned long int msec_start;
unsigned long int repeat_start;
unsigned long int loop_start;
int delay = (int)(num * 11000.0 / RigSerial->Baud() +
progStatus.use_tcpip ? progStatus.tcpip_ping_delay : 50) / 10;
int delay = progStatus.use_tcpip ? progStatus.tcpip_ping_delay : 0;
delay += 100;
delay += num * 11000.0 / RigSerial->Baud();
if (!progStatus.use_tcpip && !RigSerial->IsOpen()) {
replystr = cmd;//returned;
replystr = cmd;
return false;
}
for (repeat = 0; repeat < progStatus.comm_retries; repeat++) {
msec_start = zmsec();
if (timeout == 0) timeout = progStatus.comm_retries * delay;
msec_start = zmsec();
repeat_start = zmsec();
respstr.clear();
while (int(zmsec() - repeat_start) < timeout) {
sendCommand(tosend, 0);
returned = "";
for ( cnt = 0; cnt < delay; cnt++) {
if (readResponse())
returned.append(respstr);
returned = respstr;//""; // sendCommand captures xcvr response in respstr
loop_start = zmsec();
diff = zmsec() - loop_start;
while ( diff < delay + 10 ) {
if (returned.find(bad) != string::npos) {
snprintf(sztemp, sizeof(sztemp), "%s : %d ms", sz, int(zmsec() - msec_start));
showresp(ERR, HEX, sztemp, tosend, returned);
return false;
}
if (returned.length() >= num) {
replystr = returned;
unsigned long int waited = zmsec() - msec_start;
snprintf(sztemp, sizeof(sztemp), "%s ans in %ld ms, OK ", sz, waited);
snprintf(sztemp, sizeof(sztemp), "%s : %d ms", sz, int(zmsec() - msec_start));
showresp(DEBUG, HEX, sztemp, tosend, returned);
return true;
}
MilliSleep(10);
Fl::awake();
if (readResponse())
returned.append(respstr);
diff = zmsec() - loop_start;
}
}
diff = zmsec() - msec_start;
replystr = returned;
unsigned long int waited = zmsec() - tod_start;
snprintf(sztemp, sizeof(sztemp), "%s TIMED OUT in %ld ms", sz, waited);
snprintf(sztemp, sizeof(sztemp), "%s TIMED OUT : %d ms", sz, diff);
showresp(ERR, HEX, sztemp, tosend, returned);
return false;

3
src/rigs/K3.cxx
View file

@ -124,8 +124,6 @@ int RIG_K3::def_bandwidth(int m)
#define K3_WAIT_TIME 800
extern int report_level;
void RIG_K3::initialize()
{
debug::level = debug::INFO_LEVEL;
@ -139,7 +137,6 @@ void RIG_K3::initialize()
k3_widgets[5].W = sldrMICGAIN;
k3_widgets[6].W = sldrPOWER;
report_level = INFO;
cmd = "AI0;"; // disable auto-info
sendCommand(cmd);
showresp(INFO, ASC, "disable auto-info", cmd, replystr);

3
src/rigs/KX3.cxx
View file

@ -123,8 +123,6 @@ int RIG_KX3::def_bandwidth(int m)
return def_mode_width[m];
}
extern int report_level;
void RIG_KX3::initialize()
{
debug::level = debug::INFO_LEVEL;
@ -138,7 +136,6 @@ void RIG_KX3::initialize()
k3_widgets[5].W = sldrMICGAIN;
k3_widgets[6].W = sldrPOWER;
report_level = INFO;
cmd = "AI0;"; // disable auto-info
sendCommand(cmd);
showresp(INFO, ASC, "disable auto-info", cmd, replystr);

6
src/rigs/rigbase.cxx
View file

@ -398,8 +398,6 @@ int rigbase::waitN(size_t n, int timeout, const char *sz, int pr)
return 0;
}
int report_level = INFO;
int rigbase::wait_char(int ch, size_t n, int timeout, const char *sz, int pr)
{
guard_lock reply_lock(&mutex_replystr);
@ -419,7 +417,7 @@ int rigbase::wait_char(int ch, size_t n, int timeout, const char *sz, int pr)
if(!progStatus.use_tcpip && !RigSerial->IsOpen()) {
snprintf(sztemp, sizeof(sztemp), "TEST %s", sz);
showresp(report_level, pr, sztemp, tosend, replystr);
showresp(DEBUG, pr, sztemp, tosend, replystr);
return 0;
}
@ -434,7 +432,7 @@ int rigbase::wait_char(int ch, size_t n, int timeout, const char *sz, int pr)
replystr = returned;
waited = cnt * 10 + delay;
snprintf(sztemp, sizeof(sztemp), "%s OK %d ms", sz, waited);
showresp(report_level, pr, sztemp, cmd, returned);
showresp(DEBUG, pr, sztemp, cmd, returned);
return replystr.length();
}
MilliSleep(10);

1
src/support/rig_io.cxx
View file

@ -166,7 +166,6 @@ void assignReplyStr(string val)
}
char replybuff[RXBUFFSIZE+1];
//string replystr;
string respstr;
int readResponse()

455
src/support/support.cxx
View file

@ -126,85 +126,6 @@ enum {NOTCH, SHIFT, INNER, OUTER, LOCK, VOLUME, MIC, POWER, SQUELCH, RFGAIN, NB_
int val;
};
queue<SLIDER> sliders;
pthread_mutex_t mutex_sliders = PTHREAD_MUTEX_INITIALIZER;
void process_sliders()
{
SLIDER slider;
int val;
while (!sliders.empty()) {
{
guard_lock slock(&mutex_sliders);
slider = sliders.front();
sliders.pop();
while (!sliders.empty() && (slider.fnc == sliders.front().fnc)) {
slider = sliders.front();
sliders.pop();
}
}
val = slider.val;
if (inhibit_pbt == 1) inhibit_pbt = 0;
switch (slider.fnc) {
case SLIDER::NOTCH :
selrig->set_notch(progStatus.notch, val);
if (inhibit_notch == 1) inhibit_notch = 0;
break;
case SLIDER::SHIFT :
selrig->set_if_shift(val);
if (inhibit_shift == 1) inhibit_shift = 0;
break;
case SLIDER::INNER :
selrig->set_pbt_inner(val);
break;
case SLIDER::OUTER :
selrig->set_pbt_outer(val);
break;
case SLIDER::LOCK :
selrig->set_pbt_inner(val);
selrig->set_pbt_outer(val);
break;
case SLIDER::VOLUME :
selrig->set_volume_control(val);
if (inhibit_volume == 1) inhibit_volume = 0;
break;
case SLIDER::MIC :
selrig->set_mic_gain(val);
if (inhibit_mic == 1) inhibit_mic = 0;
break;
case SLIDER::POWER :
selrig->set_power_control(val);
if (inhibit_power) {
stringstream str;
str << "SLIDER::POWER inhibit_power=" << inhibit_power;
trace(1, str.str().c_str());
}
if (inhibit_power == 1) inhibit_power = 0;
break;
case SLIDER::SQUELCH :
selrig->set_squelch(val);
if (inhibit_squelch == 1) inhibit_squelch = 0;
break;
case SLIDER::RFGAIN :
selrig->set_rf_gain(val);
if (inhibit_rfgain == 1) inhibit_rfgain = 0;
break;
case SLIDER::NB_LEVEL :
selrig->set_nb_level(val);
if (inhibit_nb_level == 1) inhibit_nb_level = 0;
break;
case SLIDER::NR :
selrig->set_noise_reduction(val);
break;
case SLIDER::NR_VAL :
selrig->set_noise_reduction_val(val);
if (inhibit_nr == 1) inhibit_nr = 0;
break;
default: break;
}
}
}
//======================================================================
// loop for serial i/o thread
// runs continuously until program is closed
@ -581,6 +502,8 @@ void update_UI_TUNER(void *)
void read_tuner()
{
if (!selrig->has_tune_control) return;
tunerval = selrig->get_tune();
if (tunerval != btn_tune_on_off->value()) {
stringstream s;
@ -656,13 +579,18 @@ void read_auto_notch()
void update_noise(void *d)
{
btnNOISE->value(progStatus.noise);
btnNOISE->redraw();
sldr_nb_level->value(progStatus.nb_level);
sldr_nb_level->redraw();
}
void read_noise()
{
int on = 0, val = 0;
if (inhibit_nb_level) return;
if (inhibit_nb_level > 0) {
inhibit_nb_level--;
return;
}
{
trace(1,"read_noise()");
on = selrig->get_noise();
@ -708,6 +636,7 @@ void update_preamp(void *d)
void update_attenuator(void *d)
{
btnAttenuator->value(progStatus.attenuator);
btnAttenuator->redraw();
}
void read_preamp_att()
@ -787,13 +716,21 @@ void read_split()
void update_volume(void *d)
{
long *nr = (long *)d;
if (spnrVOLUME) spnrVOLUME->value(progStatus.volume);
if (spnrVOLUME) spnrVOLUME->activate();
sldrVOLUME->value(progStatus.volume); // Set slider to last known value
sldrVOLUME->activate(); // activate it
if (spnrVOLUME) {
spnrVOLUME->value(progStatus.volume);
spnrVOLUME->activate();
spnrVOLUME->redraw();
}
if (sldrVOLUME) {
sldrVOLUME->value(progStatus.volume); // Set slider to last known value
sldrVOLUME->activate(); // activate it
sldrVOLUME->redraw();
}
if (*nr) btnVol->value(1); // Button Lit
else btnVol->value(0); // Button Dark.
btnVol->redraw();
}
long nlzero = 0L;
@ -801,7 +738,10 @@ long nlone = 1L;
void read_volume()
{
if (inhibit_volume) return;
if (inhibit_volume > 0) {
inhibit_volume--;
return;
}
if (!selrig->has_volume_control) return;
int vol;
{
@ -822,20 +762,33 @@ void read_volume()
void update_ifshift(void *d)
{
btnIFsh->value(progStatus.shift);
if (sldrIFSHIFT) sldrIFSHIFT->value(progStatus.shift_val);
if (spnrIFSHIFT) spnrIFSHIFT->value(progStatus.shift_val);
btnIFsh->redraw();
if (sldrIFSHIFT) {
sldrIFSHIFT->value(progStatus.shift_val);
sldrIFSHIFT->redraw();
}
if (spnrIFSHIFT) {
spnrIFSHIFT->value(progStatus.shift_val);
spnrIFSHIFT->redraw();
}
}
void update_pbt(void *)
{
if (sldrINNER) sldrINNER->value(progStatus.pbt_inner);
if (sldrOUTER) sldrOUTER->value(progStatus.pbt_outer);
if (sldrINNER) {
sldrINNER->value(progStatus.pbt_inner);
sldrINNER->redraw();
}
if (sldrOUTER) {
sldrOUTER->value(progStatus.pbt_outer);
sldrOUTER->redraw();
}
}
void read_pbt()
{
if (inhibit_pbt) {
inhibit_pbt = 0;
if (inhibit_pbt > 0) {
inhibit_pbt--;
return;
}
progStatus.pbt_inner = selrig->get_pbt_inner();
@ -850,7 +803,10 @@ void read_ifshift()
if (selrig->has_pbt_controls)
return read_pbt();
if (inhibit_shift) return;
if (inhibit_shift > 0) {
inhibit_shift--;
return;
}
if (!selrig->has_ifshift_control) return;
{
trace(1,"read_if_shift()");
@ -867,15 +823,25 @@ void read_ifshift()
void update_nr(void *d)
{
btnNR->value(progStatus.noise_reduction);
if (sldrNR) sldrNR->value(progStatus.noise_reduction_val);
if (spnrNR) spnrNR->value(progStatus.noise_reduction_val);
btnNR->redraw();
if (sldrNR) {
sldrNR->value(progStatus.noise_reduction_val);
sldrNR->redraw();
}
if (spnrNR) {
spnrNR->value(progStatus.noise_reduction_val);
spnrNR->redraw();
}
}
void read_nr()
{
int on = 0;
int val = 0;
if (inhibit_nr) return;
if (inhibit_nr > 0) {
inhibit_nr--;
return;
}
if (!selrig->has_noise_reduction) return;
{
trace(1,"read_nr()");
@ -893,15 +859,25 @@ void read_nr()
void update_notch(void *d)
{
btnNotch->value(progStatus.notch);
if (sldrNOTCH) sldrNOTCH->value(progStatus.notch_val);
if (spnrNOTCH) spnrNOTCH->value(progStatus.notch_val);
btnNotch->redraw();
if (sldrNOTCH) {
sldrNOTCH->value(progStatus.notch_val);
sldrNOTCH->redraw();
}
if (spnrNOTCH) {
spnrNOTCH->value(progStatus.notch_val);
spnrNOTCH->redraw();
}
}
void read_notch()
{
int on = progStatus.notch;
int val = progStatus.notch_val;
if (inhibit_notch) return;
if (inhibit_notch > 0) {
inhibit_notch--;
return;
}
if (!selrig->has_notch_control) return;
{
trace(1,"read_notch()");
@ -918,8 +894,14 @@ void read_notch()
void update_power_control(void *d)
{
set_power_controlImage(progStatus.power_level);
if (sldrPOWER) sldrPOWER->value(progStatus.power_level);
if (spnrPOWER) spnrPOWER->value(progStatus.power_level);
if (sldrPOWER) {
sldrPOWER->value(progStatus.power_level);
sldrPOWER->redraw();
}
if (spnrPOWER) {
spnrPOWER->value(progStatus.power_level);
spnrPOWER->redraw();
}
if (xcvr_name == rig_K2.name_) {
double min, max, step;
selrig->get_pc_min_max_step(min, max, step);
@ -937,7 +919,10 @@ void update_power_control(void *d)
void read_power_control()
{
int val;
if (inhibit_power) return;
if (inhibit_power > 0) {
inhibit_power--;
return;
}
if (!selrig->has_power_control) return;
{
trace(1,"read_power_control()");
@ -962,14 +947,23 @@ void read_power_control()
// mic gain
void update_mic_gain(void *d)
{
if (sldrMICGAIN) sldrMICGAIN->value(progStatus.mic_gain);
if (spnrMICGAIN) spnrMICGAIN->value(progStatus.mic_gain);
if (sldrMICGAIN) {
sldrMICGAIN->value(progStatus.mic_gain);
sldrMICGAIN->redraw();
}
if (spnrMICGAIN) {
spnrMICGAIN->value(progStatus.mic_gain);
spnrMICGAIN->redraw();
}
}
void read_mic_gain()
{
int val;
if (inhibit_mic) return;
if (inhibit_mic > 0) {
inhibit_mic--;
return;
}
if (!selrig->has_micgain_control) return;
{
trace(1,"read_mic_gain()");
@ -996,14 +990,23 @@ void read_agc()
// rf gain
void update_rfgain(void *d)
{
if (sldrRFGAIN) sldrRFGAIN->value(progStatus.rfgain);
if (spnrRFGAIN) spnrRFGAIN->value(progStatus.rfgain);
if (sldrRFGAIN) {
sldrRFGAIN->value(progStatus.rfgain);
sldrRFGAIN->redraw();
}
if (spnrRFGAIN) {
spnrRFGAIN->value(progStatus.rfgain);
spnrRFGAIN->redraw();
}
}
void read_rfgain()
{
int val;
if (inhibit_rfgain) return;
if (inhibit_rfgain > 0) {
inhibit_rfgain--;
return;
}
if (selrig->has_rf_control) {
trace(1,"read_rfgain");
val = selrig->get_rf_gain();
@ -1018,14 +1021,23 @@ void read_rfgain()
// squelch
void update_squelch(void *d)
{
if (sldrSQUELCH) sldrSQUELCH->value(progStatus.squelch);
if (spnrSQUELCH) spnrSQUELCH->value(progStatus.squelch);
if (sldrSQUELCH) {
sldrSQUELCH->value(progStatus.squelch);
sldrSQUELCH->redraw();
}
if (spnrSQUELCH) {
spnrSQUELCH->value(progStatus.squelch);
spnrSQUELCH->redraw();
}
}
void read_squelch()
{
int val;
if (inhibit_squelch) return;
if (inhibit_squelch > 0) {
inhibit_squelch--;
return;
}
if (!selrig->has_sql_control) return;
{
trace(1,"read_squelch()");
@ -1427,8 +1439,6 @@ void * serial_thread_loop(void *d)
//send any freq/mode/bw changes in the queu
process_sliders();
if (!srvc_reqs.empty())
serviceQUE();
@ -1799,7 +1809,19 @@ void buildlist() {
readTagFile();
return;
}
// else clear the list
// else only read original file to make new MAT file
orgFN = RigHomeDir;
orgFN.append(selrig->name_);
orgFN.append(".arv");
fh = fopen(orgFN.c_str(), "r");
if (fh != NULL) {
fclose (fh);
tmpFN = defFileName;
defFileName = orgFN;
readFile();
defFileName = tmpFN;
return;
}
clearList();
}
@ -2230,10 +2252,11 @@ void setNotch()
trace(1, "setNotch()");
int ev = Fl::event();
if (ev == FL_DRAG || ev == FL_PUSH || ev == FL_MOUSEWHEEL)
inhibit_notch = 2;
else if (ev == FL_RELEASE || ev == FL_LEAVE)
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_notch = 1;
return;
}
int set = 0;
if (sldrNOTCH) {
@ -2241,12 +2264,10 @@ void setNotch()
} else {
set = spnrNOTCH->value();
}
progStatus.notch_val = set;
guard_lock lcksldr(&mutex_sliders);
SLIDER slider;
slider.fnc = SLIDER::NOTCH;
slider.val = set;
sliders.push(slider);
guard_lock lock( &mutex_serial);
selrig->set_notch(progStatus.notch, progStatus.notch_val);
}
// called from xml_io thread
@ -2308,10 +2329,11 @@ void setIFshift()
trace(1, "setIFshift()");
int ev = Fl::event();
if (ev == FL_DRAG || ev == FL_PUSH || ev == FL_MOUSEWHEEL)
inhibit_shift = 2;
else if (ev == FL_RELEASE || ev == FL_LEAVE)
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_shift = 1;
return;
}
int btn = 0, set = 0;
@ -2325,18 +2347,15 @@ void setIFshift()
}
progStatus.shift_val = set;
guard_lock lock(&mutex_serial);
if (xcvr_name == rig_TS990.name_) {
guard_lock lckser(&mutex_serial);
if (progStatus.shift)
selrig->set_monitor(1);
else
selrig->set_monitor(0);
}
guard_lock lcksldr(&mutex_sliders);
SLIDER slider;
slider.fnc = SLIDER::SHIFT;
slider.val = set;
sliders.push(slider);
selrig->set_if_shift(progStatus.shift_val);
}
void cbIFsh()
@ -2385,19 +2404,15 @@ void setINNER()
}
int ev = Fl::event();
if (ev == FL_DRAG || ev == FL_PUSH || ev == FL_MOUSEWHEEL)
inhibit_pbt = 2;
else if (ev == FL_RELEASE || ev == FL_LEAVE)
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_pbt = 1;
return;
}
progStatus.pbt_inner = sldrINNER->value();
guard_lock lcksldr(&mutex_sliders);
SLIDER slider;
slider.fnc = SLIDER::INNER;
if (progStatus.pbt_lock) slider.fnc = SLIDER::LOCK;
slider.val = progStatus.pbt_inner;
sliders.push(slider);
guard_lock lock(&mutex_serial);
selrig->set_pbt_inner(progStatus.pbt_inner);
selrig->set_pbt_outer(progStatus.pbt_outer);
}
void setOUTER()
@ -2408,10 +2423,11 @@ void setOUTER()
}
int ev = Fl::event();
if (ev == FL_DRAG || ev == FL_PUSH || ev == FL_MOUSEWHEEL)
inhibit_pbt = 2;
else if (ev == FL_RELEASE || ev == FL_LEAVE)
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_pbt = 1;
return;
}
progStatus.pbt_outer = sldrOUTER->value();
if (progStatus.pbt_lock) {
@ -2419,14 +2435,9 @@ void setOUTER()
sldrINNER->value(progStatus.pbt_outer);
sldrINNER->redraw();
}
guard_lock lcksldr(&mutex_sliders);
SLIDER slider;
slider.fnc = SLIDER::OUTER;
if (progStatus.pbt_lock) slider.fnc = SLIDER::LOCK;
slider.val = progStatus.pbt_outer;
sliders.push(slider);
guard_lock lock(&mutex_serial);
selrig->set_pbt_outer(progStatus.pbt_outer);
selrig->set_pbt_inner(progStatus.pbt_inner);
}
void setCLRPBT()
@ -2439,13 +2450,9 @@ void setCLRPBT()
sldrINNER->value(0);
sldrINNER->redraw();
guard_lock lcksldr(&mutex_sliders);
SLIDER slider;
slider.fnc = SLIDER::INNER;
slider.val = 0;
sliders.push(slider);
slider.fnc = SLIDER::OUTER;
sliders.push(slider);
guard_lock lock(&mutex_serial);
selrig->set_pbt_outer(progStatus.pbt_outer);
selrig->set_pbt_inner(progStatus.pbt_inner);
}
//----------------------------------------------------------------------
@ -2498,33 +2505,33 @@ void cbEventLog()
debug::show();
}
void setVolume()
void setVolume() // UI call
{
trace(1, "setVolume()");
int ev = Fl::event();
if (ev == FL_DRAG || ev == FL_PUSH || ev == FL_MOUSEWHEEL)
inhibit_volume = 2;
else if (ev == FL_RELEASE || ev == FL_LEAVE)
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_volume = 1;
return;
}
int set;
if (spnrVOLUME) set = spnrVOLUME->value();
else set = sldrVOLUME->value();
progStatus.volume = set;
SLIDER sldr;
sldr.fnc = SLIDER::VOLUME;
sldr.val = set;
guard_lock lcksldr(&mutex_sliders);
sliders.push(sldr);
if (btnVol->value() == 0) return;
guard_lock serial_lock(&mutex_serial);
selrig->set_volume_control(progStatus.volume);
}
void setVolumeControl(void* d)
void setVolumeControl(void* d) // called by xml_server
{
guard_lock serial_lock(&mutex_serial);
trace(1, "setMicGainControl()");
trace(1, "setVolumeControl()");
if (sldrVOLUME) sldrVOLUME->value(progStatus.volume);
if (spnrVOLUME) spnrVOLUME->value(progStatus.volume);
selrig->set_volume_control(progStatus.volume);
}
void cbMute()
@ -2559,14 +2566,14 @@ void cbMute()
void setMicGain()
{
Fl_Event evt = (Fl_Event)Fl::event();;
if (evt == FL_DRAG)
inhibit_mic = 2;
else
int ev = Fl::event();
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_mic = 1;
return;
}
stringstream str;
str << "setMicGain(), evt=" << evt << ", inhibit_mic=" << inhibit_mic;
str << "setMicGain(), ev=" << ev << ", inhibit_mic=" << inhibit_mic;
trace(1, str.str().c_str());
@ -2576,11 +2583,9 @@ void setMicGain()
if (spnrMICGAIN) set = spnrMICGAIN->value();
progStatus.mic_gain = set;
guard_lock lcksldr(&mutex_sliders);
SLIDER slider;
slider.fnc = SLIDER::MIC;
slider.val = set;
sliders.push(slider);
guard_lock lock(&mutex_serial);
selrig->set_mic_gain(set);
}
void setMicGainControl(void* d)
@ -2645,14 +2650,14 @@ void set_power_controlImage(double pwr)
void setPower()
{
Fl_Event evt = (Fl_Event)Fl::event();;
if (evt == FL_DRAG) {
inhibit_power = 2;
} else {
int ev = Fl::event();
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_power = 1;
return;
}
stringstream str;
str << "setPower(), evt=" << evt << ", inhibit_power=" << inhibit_power;
str << "setPower(), ev=" << ev << ", inhibit_power=" << inhibit_power;
trace(1, str.str().c_str());
int set = 0;
@ -2675,11 +2680,8 @@ void setPower()
if (sldrPOWER) sldrPOWER->redraw();
}
guard_lock lcksldr(&mutex_sliders);
SLIDER slider;
slider.fnc = SLIDER::POWER;
slider.val = set;
sliders.push(slider);
guard_lock lock(&mutex_serial);
selrig->set_power_control(set);
}
void cbTune()
@ -2707,21 +2709,18 @@ void setSQUELCH()
trace(1, "setSQUELCH()");
int ev = Fl::event();
if (ev == FL_DRAG || ev == FL_PUSH || ev == FL_MOUSEWHEEL)
inhibit_squelch = 2;
else if (ev == FL_RELEASE || ev == FL_LEAVE)
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_squelch = 1;
return;
}
int set = 0;
if (sldrSQUELCH) set = sldrSQUELCH->value();
if (spnrSQUELCH) set = spnrSQUELCH->value();
progStatus.squelch = set;
guard_lock lcksldr(&mutex_sliders);
SLIDER slider;
slider.fnc = SLIDER::SQUELCH;
slider.val = set;
sliders.push(slider);
guard_lock lock(&mutex_serial);
selrig->set_squelch(set);
}
int agcwas = 0;
@ -2778,10 +2777,11 @@ void setRFGAIN()
trace(1, "setRFGAIN()");
int ev = Fl::event();
if (ev == FL_DRAG || ev == FL_PUSH || ev == FL_MOUSEWHEEL)
inhibit_rfgain = 2;
else if (ev == FL_RELEASE || ev == FL_LEAVE)
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_rfgain = 1;
return;
}
int set = 0;
@ -2790,11 +2790,8 @@ void setRFGAIN()
progStatus.rfgain = set;
guard_lock lcksldr(&mutex_sliders);
SLIDER slider;
slider.fnc = SLIDER::RFGAIN;
slider.val = set;
sliders.push(slider);
guard_lock lock(&mutex_serial);
selrig->set_rf_gain(set);
}
void setRFGAINControl(void* d)
@ -5526,6 +5523,9 @@ void initRig()
if (selrig->has_xcvr_auto_on_off && progStatus.xcvr_auto_on)
selrig->set_xcvr_auto_on();
bool check_ok = false;
if (progStatus.xcvr_serial_port != "NONE") check_ok = selrig->check();
init_special_controls();
init_external_tuner();
init_rit();
@ -5552,7 +5552,7 @@ void initRig()
selrig->initialize();
if (progStatus.xcvr_serial_port != "NONE") {
if (!selrig->check()) goto failed;
if (!check_ok) goto failed;
if (flrig_abort) goto failed;
}
@ -6043,18 +6043,14 @@ void cb_nb_level()
trace(1, "cb_nb_level()");
int ev = Fl::event();
if (ev == FL_DRAG || ev == FL_PUSH || ev == FL_MOUSEWHEEL)
inhibit_nb_level = 2;
else if (ev == FL_RELEASE || ev == FL_LEAVE)
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_nb_level = 1;
return;
}
set = sldr_nb_level->value();
guard_lock lcksldr(&mutex_sliders);
SLIDER slider;
slider.fnc = SLIDER::NB_LEVEL;
slider.val = set;
sliders.push(slider);
guard_lock lock(&mutex_serial);
selrig->set_nb_level(set);
}
void cbNR()
@ -6128,10 +6124,11 @@ void setNR()
int btn = 0, set = 0;
int ev = Fl::event();
if (ev == FL_DRAG || ev == FL_PUSH || ev == FL_MOUSEWHEEL)
inhibit_nr = 2;
else if (ev == FL_RELEASE || ev == FL_LEAVE)
if (ev == FL_LEAVE || ev == FL_ENTER) return;
if (ev == FL_DRAG || ev == FL_PUSH) {
inhibit_nr = 1;
return;
}
if (xcvr_name == rig_TS2000.name_ ||
xcvr_name == rig_TS590S.name_ ||
@ -6157,15 +6154,9 @@ void setNR()
}
}
guard_lock lcksldr(&mutex_sliders);
SLIDER slider;
slider.fnc = SLIDER::NR;
slider.val = btn;
sliders.push(slider);
slider.fnc = SLIDER::NR_VAL;
slider.val = set;
sliders.push(slider);
guard_lock lock(&mutex_serial);
selrig->set_noise_reduction_val(set);
selrig->set_noise_reduction(btn);
}

2
src/support/tod_clock.cxx
View file

@ -64,7 +64,7 @@ void ztimer()
t_temp=(time_t)tv.tv_sec;
gmtime_r(&t_temp, &tm);
_zmsec = (tv.tv_usec/1000) % 1000;
_zmsec = (tv.tv_usec/1000) % 1000 + tv.tv_sec * 1000;
_zsec = tm.tm_sec;
_zmin = tm.tm_min;
_zhr = tm.tm_hour;