// ----------------------------------------------------------------------------
// Copyright (C) 2014
// David Freese, W1HKJ
//
// This file is part of flrig.
//
// flrig is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// flrig is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// ----------------------------------------------------------------------------
#include "kenwood/TS480HX.h"
#include "support.h"
static const char TS480HXname_[] = "TS-480HX";
static std::vectorTS480HXmodes_;
static const char *vTS480HXmodes_[] =
{ "LSB", "USB", "CW", "FM", "AM", "FSK", "CW-R", "FSK-R"};
static const char TS480HX_mode_chr[] = { '1', '2', '3', '4', '5', '6', '7', '9' };
static const char TS480HX_mode_type[] = { 'L', 'U', 'U', 'U', 'U', 'L', 'L', 'U' };
static std::vectorTS480HX_empty;
static const char *vTS480HX_empty[] =
{ "N/A" };
static int TS480HX_bw_vals[] = {1, WVALS_LIMIT};
// SL command is lo cut when menu 045 OFF
static std::vectorTS480HX_SL;
static const char *vTS480HX_SL[] =
{
"0", "50", "100", "200", "300",
"400", "500", "600", "700", "800",
"900", "1000" };
static const char *TS480HX_SL_tooltip = "lo cut";
static const char *TS480HX_btn_SL_label = "L";
// SH command is hi cut when menu 045 OFF
static std::vectorTS480HX_SH;
static const char *vTS480HX_SH[] =
{
"1000", "1200", "1400", "1600", "1800",
"2000", "2200", "2400", "2600", "2800",
"3000", "3400", "4000", "5000" };
static int TS480HX_HI_bw_vals[] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,WVALS_LIMIT};
static const char *TS480HX_SH_tooltip = "hi cut";
static const char *TS480HX_btn_SH_label = "H";
// SL command is width when menu 045 ON
static std::vectorTS480HX_dataW;
static const char *vTS480HX_dataW[] =
{ "50", "100", "250", "500", "1000", "1500", "2400" };
static int TS480HX_data_bw_vals[] = {1,2,3,4,5,6,7, WVALS_LIMIT};
static const char *TS480HX_dataW_tooltip = "width";
static const char *TS480HX_dataW_label = "W";
// SH command is center when menu 045 ON
static std::vectorTS480HX_dataC;
static const char *vTS480HX_dataC[] =
{ "1000", "1500", "2210" };
static const char *TS480HX_dataC_tooltip = "center";
static const char *TS480HX_dataC_label = "C";
static std::vectorTS480HX_AM_SL;
static const char *vTS480HX_AM_SL[] =
{ "10", "100", "200", "500"};
static std::vectorTS480HX_AM_SH;
static const char *vTS480HX_AM_SH[] =
{ "2500", "3000", "4000", "5000"};
//static int TS480HX_AM_bw_vals[] = {1,2,3,4,WVALS_LIMIT};
static std::vectorTS480HX_CWwidths;
static const char *vTS480HX_CWwidths[] =
{
"50", "80", "100", "150", "200",
"300", "400", "500", "600", "1000",
"2000"};
static int TS480HX_CW_bw_vals[] = {1,2,3,4,5,6,7,8,9,10,11,WVALS_LIMIT};
static std::vectorTS480HX_CWbw;
static const char *vTS480HX_CWbw[] =
{
"FW0050;", "FW0080;", "FW0100;", "FW0150;", "FW0200;",
"FW0300;", "FW0400;", "FW0500;", "FW0600;", "FW1000;",
"FW2000;" };
static std::vectorTS480HX_FSKwidths;
static const char *vTS480HX_FSKwidths[] =
{
"250", "500", "1000", "1500"};
static int TS480HX_FSK_bw_vals[] = { 1,2,3,4,WVALS_LIMIT};
static std::vectorTS480HX_FSKbw;
static const char *vTS480HX_FSKbw[] =
{ "FW0250;", "FW0500;", "FW1000;", "FW1500;" };
static int agcval = 1;
static bool fm_mode = false;
static GUI rig_widgets[]= {
{ (Fl_Widget *)btnVol, 2, 125, 50 }, // 0
{ (Fl_Widget *)sldrVOLUME, 54, 125, 156 }, // 1
{ (Fl_Widget *)sldrRFGAIN, 54, 145, 156 }, // 2
{ (Fl_Widget *)btnIFsh, 214, 105, 50 }, // 3
{ (Fl_Widget *)sldrIFSHIFT, 266, 105, 156 }, // 4
{ (Fl_Widget *)btnDataPort, 214, 125, 50 }, // 5
{ (Fl_Widget *)sldrSQUELCH, 266, 125, 156 }, // 6
{ (Fl_Widget *)sldrMICGAIN, 266, 145, 156 }, // 7
{ (Fl_Widget *)sldrPOWER, 54, 165, 368 }, // 8
{ (Fl_Widget *)NULL, 0, 0, 0 }
};
static std::string menu012 = "EX01200004";
void RIG_TS480HX::initialize()
{
VECTOR (TS480HXmodes_, vTS480HXmodes_);
VECTOR (TS480HX_empty, vTS480HX_empty);
VECTOR (TS480HX_SL, vTS480HX_SL);
VECTOR (TS480HX_SH, vTS480HX_SH);
VECTOR (TS480HX_dataW, vTS480HX_dataW);
VECTOR (TS480HX_dataC, vTS480HX_dataC);
VECTOR (TS480HX_AM_SL, vTS480HX_AM_SL);
VECTOR (TS480HX_AM_SH, vTS480HX_AM_SH);
VECTOR (TS480HX_CWwidths, vTS480HX_CWwidths);
VECTOR (TS480HX_CWbw, vTS480HX_CWbw);
VECTOR (TS480HX_FSKwidths, vTS480HX_FSKwidths);
VECTOR (TS480HX_FSKbw, vTS480HX_FSKbw);
modes_ = TS480HXmodes_;
_mode_type = TS480HX_mode_type;
bandwidths_ = TS480HX_empty;
bw_vals_ = TS480HX_bw_vals;
rig_widgets[0].W = btnVol;
rig_widgets[1].W = sldrVOLUME;
rig_widgets[2].W = sldrRFGAIN;
rig_widgets[3].W = btnIFsh;
rig_widgets[4].W = sldrIFSHIFT;
rig_widgets[5].W = btnDataPort;
rig_widgets[6].W = sldrSQUELCH;
rig_widgets[7].W = sldrMICGAIN;
rig_widgets[8].W = sldrPOWER;
check_menu_45();
menu012.clear();
cmd = "EX0120000;"; // read menu 012 state
//might return something like EX01200004;
if (wait_char(';', 11, 100, "read ex 012", ASC) == 11)
menu012 = replystr;
cmd = "EX01200000;";
sendCommand(cmd);
}
RIG_TS480HX::RIG_TS480HX() {
// base class values
name_ = TS480HXname_;
modes_ = TS480HXmodes_;
_mode_type = TS480HX_mode_type;
bandwidths_ = TS480HX_empty;
bw_vals_ = TS480HX_bw_vals;
dsp_SL = TS480HX_SL;
SL_tooltip = TS480HX_SL_tooltip;
SL_label = TS480HX_btn_SL_label;
dsp_SH = TS480HX_SH;
SH_tooltip = TS480HX_SH_tooltip;
SH_label = TS480HX_btn_SH_label;
widgets = rig_widgets;
serial_baudrate = BR57600;
stopbits = 1;
serial_retries = 2;
// serial_write_delay = 0;
// serial_post_write_delay = 0;
serial_timeout = 50;
serial_rtscts = true;
serial_rtsplus = false;
serial_dtrplus = false;
serial_catptt = true;
serial_rtsptt = false;
serial_dtrptt = false;
B.imode = A.imode = 1;
B.iBW = A.iBW = 0x8A03;
B.freq = A.freq = 14070000ULL;
can_change_alt_vfo = true;
has_extras = true;
has_noise_reduction =
has_noise_reduction_control =
has_auto_notch =
has_noise_control =
has_sql_control =
has_split = true;
has_split_AB = true;
has_data_port = true;
has_micgain_control = true;
has_ifshift_control = true;
has_rf_control = true;
has_agc_control = true;
has_swr_control = true;
has_alc_control = true;
has_power_out = true;
has_dsp_controls = true;
has_smeter = true;
has_attenuator_control = true;
has_preamp_control = true;
has_mode_control = true;
has_bandwidth_control = true;
has_volume_control = true;
has_power_control = true;
has_tune_control = true;
has_ptt_control = true;
precision = 1;
ndigits = 8;
_noise_reduction_level = 0;
_nrval1 = 2;
_nrval2 = 4;
preamp_level = atten_level = 0;
}
static int ret = 0;
const char * RIG_TS480HX::get_bwname_(int n, int md)
{
static char bwname[20];
if (n > 256) {
int hi = (n >> 8) & 0x7F;
int lo = n & 0xFF;
snprintf(bwname, sizeof(bwname), "%s/%s",
(md == 0 || md == 1 || md == 3) ? dsp_SL[lo].c_str() : TS480HX_AM_SL[lo].c_str(),
(md == 0 || md == 1 || md == 3) ? dsp_SH[hi].c_str() : TS480HX_AM_SH[hi].c_str() );
} else {
snprintf(bwname, sizeof(bwname), "%s",
(md == 2 || md == 6) ? TS480HX_CWwidths[n].c_str() : TS480HX_FSKwidths[n].c_str());
}
return bwname;
}
void RIG_TS480HX::check_menu_45()
{
// read current switch 45 setting
menu_45 = false;
cmd = "EX0450000;";
if (wait_char(';', 11, 100, "Check menu item 45", ASC) >= 11) {
size_t p = replystr.rfind("EX045");
if (p != std::string::npos)
menu_45 = (replystr[p+9] == '1');
}
if (menu_45) {
dsp_SL = TS480HX_dataW;
SL_tooltip = TS480HX_dataW_tooltip;
SL_label = TS480HX_dataW_label;
dsp_SH = TS480HX_dataC;
SH_tooltip = TS480HX_dataC_tooltip;
SH_label = TS480HX_dataC_label;
B.iBW = A.iBW = 0x8106;
} else {
dsp_SL = TS480HX_SL;
SL_tooltip = TS480HX_SL_tooltip;
SL_label = TS480HX_btn_SL_label;
dsp_SH = TS480HX_SH;
SH_tooltip = TS480HX_SH_tooltip;
SH_label = TS480HX_btn_SH_label;
B.iBW = A.iBW = 0x8A03;
}
}
void RIG_TS480HX::shutdown()
{
// restore state of xcvr beeps
if (menu012.empty()) return;
cmd = menu012;
sendCommand(cmd);
}
// SM cmd 0 ... 100 (rig values 0 ... 15)
int RIG_TS480HX::get_smeter()
{
int mtr = 0;
cmd = "SM0;";
get_trace(1, "get_smeter");
ret = wait_char(';', 8, 100, "get Smeter", ASC);
gett("");
if (ret < 8) return 0;
size_t p = replystr.rfind("SM");
if (p != std::string::npos)
mtr = 5 * atoi(&replystr[p + 3]);
return mtr;
}
struct pwrpair {int mtr; float pwr;};
static pwrpair pwrtbl[] = {
{0, 0.0},
{2, 5.0},
{4, 10.0},
{7, 25.0},
{11, 50.0},
{16, 100.0},
{20, 200.0} };
int RIG_TS480HX::get_power_out()
{
int mtr = 0;
cmd = "SM0;";
get_trace(1, "get_power_out");
ret = wait_char(';', 8, 100, "get power", ASC);
gett("");
if (ret < 8) return mtr;
size_t p = replystr.rfind("SM");
if (p != std::string::npos) {
mtr = atoi(&replystr[p + 3]);
size_t i = 0;
for (i = 0; i < sizeof(pwrtbl) / sizeof(pwrpair) - 1; i++)
if (mtr >= pwrtbl[i].mtr && mtr < pwrtbl[i+1].mtr)
break;
if (mtr < 0) mtr = 0;
if (mtr > 20) mtr = 20;
mtr = (int)ceil(pwrtbl[i].pwr +
(pwrtbl[i+1].pwr - pwrtbl[i].pwr)*(mtr - pwrtbl[i].mtr)/(pwrtbl[i+1].mtr - pwrtbl[i].mtr));
if (mtr > 200) mtr = 200;
}
return mtr;
}
// RM cmd 0 ... 100 (rig values 0 ... 8)
// User report of RM; command using Send Cmd tab
// RM10000;RM20000;RM30000;
// RM1nnnn; => SWR
// RM2nnnn; => COMP
// RM3nnnn; => ALC
int RIG_TS480HX::get_swr()
{
int mtr = 0;
cmd = "RM;";
get_trace(1, "get_swr");
ret = wait_char(';', 8, 100, "get SWR/ALC", ASC);
gett("");
if (ret < 8) return (int)mtr;
size_t p = replystr.rfind("RM1");
if (p != std::string::npos)
mtr = 66 * atoi(&replystr[p + 3]) / 10;
p = replystr.rfind("RM3");
if (p != std::string::npos)
alc = 66 * atoi(&replystr[p+3]) / 10;
else
alc = 0;
swralc_polled = true;
return mtr;
}
int RIG_TS480HX::get_alc(void)
{
if (!swralc_polled) get_swr();
swralc_polled = false;
return alc;
}
int RIG_TS480HX::set_widths(int val)
{
int bw;
if (val == 0 || val == 1 || val == 3) {
if (menu_45) {
bw = 0x8106; // 1500 Hz 2400 wide
dsp_SL = TS480HX_dataW;
SL_tooltip = TS480HX_dataW_tooltip;
SL_label = TS480HX_dataW_label;
dsp_SH = TS480HX_dataC;
SH_tooltip = TS480HX_dataC_tooltip;
SH_label = TS480HX_dataC_label;
bandwidths_ = TS480HX_dataW;
bw_vals_ = TS480HX_data_bw_vals;
} else {
bw = 0x8A03; // 200 ... 3000 Hz
dsp_SL = TS480HX_SL;
SL_tooltip = TS480HX_SL_tooltip;
SL_label = TS480HX_btn_SL_label;
dsp_SH = TS480HX_SH;
SH_tooltip = TS480HX_SH_tooltip;
SH_label = TS480HX_btn_SH_label;
bandwidths_ = TS480HX_SH;
bw_vals_ = TS480HX_HI_bw_vals;
}
} else if (val == 2 || val == 6) {
bandwidths_ = TS480HX_CWwidths;
bw_vals_ = TS480HX_CW_bw_vals;
dsp_SL = TS480HX_empty;
dsp_SH = TS480HX_empty;
bw = 7;
} else if (val == 5 || val == 7) {
bandwidths_ = TS480HX_FSKwidths;
bw_vals_ = TS480HX_FSK_bw_vals;
dsp_SL = TS480HX_empty;
dsp_SH = TS480HX_empty;
bw = 1;
} else { // val == 4 ==> AM
bandwidths_ = TS480HX_empty;
bw_vals_ = TS480HX_bw_vals;
dsp_SL = TS480HX_AM_SL;
dsp_SH = TS480HX_AM_SH;
bw = 0x8201;
}
return bw;
}
std::vector& RIG_TS480HX::bwtable(int m)
{
if (m == 0 || m == 1 || m == 3)
return TS480HX_empty;
else if (m == 2 || m == 6)
return TS480HX_CWwidths;
else if (m == 5 || m == 7)
return TS480HX_FSKwidths;
//else AM m == 4
return TS480HX_empty;
}
std::vector& RIG_TS480HX::lotable(int m)
{
if (m == 0 || m == 1 || m == 3)
return TS480HX_SL;
else if (m == 2 || m == 6)
return vNOBWS;
else if (m == 5 || m == 7)
return vNOBWS;
return TS480HX_AM_SL;
}
std::vector& RIG_TS480HX::hitable(int m)
{
if (m == 0 || m == 1 || m == 3)
return TS480HX_SH;
else if (m == 2 || m == 6)
return vNOBWS;
else if (m == 5 || m == 7)
return vNOBWS;
return TS480HX_AM_SH;
}
void RIG_TS480HX::set_modeA(int val)
{
if (val == 3) fm_mode = true;
else fm_mode = false;
A.imode = val;
cmd = "MD";
cmd += TS480HX_mode_chr[val];
cmd += ';';
sendCommand(cmd);
showresp(WARN, ASC, "set mode", cmd, "");
A.iBW = set_widths(val);
}
int RIG_TS480HX::get_modeA()
{
cmd = "MD;";
get_trace(1, "get_modeA");
ret = wait_char(';', 4, 100, "get modeA", ASC);
gett("");
if (ret < 4) return A.imode;
size_t p = replystr.rfind("MD");
if (p != std::string::npos && (p + 2 < replystr.length())) {
int md = replystr[p+2];
md = md - '1';
if (md == 8) md = 7;
A.imode = md;
A.iBW = set_widths(A.imode);
}
if (A.imode == 3) fm_mode = true;
else fm_mode = false;
return A.imode;
}
void RIG_TS480HX::set_modeB(int val)
{
if (val == 3) fm_mode = true;
else fm_mode = false;
B.imode = val;
cmd = "MD";
cmd += TS480HX_mode_chr[val];
cmd += ';';
sendCommand(cmd);
showresp(WARN, ASC, "set mode B", cmd, "");
B.iBW = set_widths(val);
}
int RIG_TS480HX::get_modeB()
{
cmd = "MD;";
get_trace(1, "get_modeB");
ret = wait_char(';', 4, 100, "get modeB", ASC);
gett("");
if (ret < 4) return B.imode;
size_t p = replystr.rfind("MD");
if (p != std::string::npos && (p + 2 < replystr.length())) {
int md = replystr[p+2];
md = md - '1';
if (md == 8) md = 7;
B.imode = md;
B.iBW = set_widths(B.imode);
}
if (B.imode == 3) fm_mode = true;
else fm_mode = false;
return B.imode;
}
int RIG_TS480HX::get_modetype(int n)
{
return _mode_type[n];
}
void RIG_TS480HX::set_bwA(int val)
{
if (A.imode == 0 || A.imode == 1 || A.imode == 3 || A.imode == 4) {
if (val < 256) return;
A.iBW = val;
cmd = "SL";
cmd.append(to_decimal(A.iBW & 0xFF, 2)).append(";");
sendCommand(cmd);
showresp(WARN, ASC, SL_tooltip, cmd, "");
cmd = "SH";
cmd.append(to_decimal(((A.iBW >> 8) & 0x7F), 2)).append(";");
sendCommand(cmd);
showresp(WARN, ASC, SH_tooltip, cmd, "");
}
if (val > 256) return;
else if (A.imode == 2 || A.imode == 6) {
A.iBW = val;
cmd = TS480HX_CWbw[A.iBW];
sendCommand(cmd);
showresp(WARN, ASC, "set CW bw", cmd, "");
}else if (A.imode == 5 || A.imode == 7) {
A.iBW = val;
cmd = TS480HX_FSKbw[A.iBW];
sendCommand(cmd);
showresp(WARN, ASC, "set FSK bw", cmd, "");
}
}
int RIG_TS480HX::get_bwA()
{
int i = 0;
size_t p;
bool menu45 = menu_45;
check_menu_45();
if (menu45 != menu_45)
Fl::awake(updateBandwidthControl);
if (A.imode == 0 || A.imode == 1 || A.imode == 3 || A.imode == 4) {
int lo = A.iBW & 0xFF, hi = (A.iBW >> 8) & 0x7F;
cmd = "SL;";
get_trace(1, "get_bwA, SL");
ret = wait_char(';', 5, 100, "get SL", ASC);
gett("");
if (ret == 5) {
p = replystr.rfind("SL");
if (p != std::string::npos)
lo = fm_decimal(replystr.substr(p+2), 2);
}
cmd = "SH;";
if (wait_char(';', 5, 100, "get SH", ASC) == 5) {
p = replystr.rfind("SH");
if (p != std::string::npos)
hi = fm_decimal(replystr.substr(p+2), 2);
A.iBW = ((hi << 8) | (lo & 0xFF)) | 0x8000;
}
} else if (A.imode == 2 || A.imode == 6) {
cmd = "FW;";
get_trace(1, "get_bwA, FW");
ret = wait_char(';', 7, 100, "get FW", ASC);
gett("");
if (ret == 7) {
p = replystr.rfind("FW");
if (p != std::string::npos) {
for (i = 0; i < 11; i++)
if (replystr.find(TS480HX_CWbw[i]) == p)
break;
if (i == 11) i = 10;
A.iBW = i;
}
}
} else if (A.imode == 5 || A.imode == 7) {
cmd = "FW;";
get_trace(1, "get_bwA, FW");
ret = wait_char(';', 7, 100, "get FW", ASC);
gett("");
if (ret == 7) {
p = replystr.rfind("FW");
if (p != std::string::npos) {
for (i = 0; i < 4; i++)
if (replystr.find(TS480HX_FSKbw[i]) == p)
break;
if (i == 4) i = 3;
A.iBW = i;
}
}
}
return A.iBW;
}
void RIG_TS480HX::set_bwB(int val)
{
if (B.imode == 0 || B.imode == 1 || B.imode == 3 || B.imode == 4) {
if (val < 256) return;
B.iBW = val;
cmd = "SL";
cmd.append(to_decimal(B.iBW & 0xFF, 2)).append(";");
sendCommand(cmd);
showresp(WARN, ASC, SL_tooltip, cmd, "");
cmd = "SH";
cmd.append(to_decimal(((B.iBW >> 8) & 0x7F), 2)).append(";");
sendCommand(cmd);
showresp(WARN, ASC, SH_tooltip, cmd, "");
}
if (val > 256) return;
else if (B.imode == 2 || B.imode == 6) { // CW
B.iBW = val;
cmd = TS480HX_CWbw[B.iBW];
sendCommand(cmd);
showresp(WARN, ASC, "set CW bw", cmd, "");
}else if (B.imode == 5 || B.imode == 7) {
B.iBW = val;
cmd = TS480HX_FSKbw[B.iBW];
sendCommand(cmd);
showresp(WARN, ASC, "set FSK bw", cmd, "");
}
}
int RIG_TS480HX::get_bwB()
{
int i = 0;
size_t p;
bool menu45 = menu_45;
check_menu_45();
if (menu45 != menu_45)
Fl::awake(updateBandwidthControl);
if (B.imode == 0 || B.imode == 1 || B.imode == 3 || B.imode == 4) {
int lo = B.iBW & 0xFF, hi = (B.iBW >> 8) & 0x7F;
cmd = "SL;";
get_trace(1, "get SL");
ret = wait_char(';', 5, 100, "get SL", ASC);
gett("");
if (ret == 5) {
p = replystr.rfind("SL");
if (p != std::string::npos)
lo = fm_decimal(replystr.substr(p+2), 2);
}
cmd = "SH;";
get_trace(1, "get SH");
ret = wait_char(';', 5, 100, "get SH", ASC);
gett("");
if (ret == 5) {
p = replystr.rfind("SH");
if (p != std::string::npos)
hi = fm_decimal(replystr.substr(p+2), 2);
B.iBW = ((hi << 8) | (lo & 0xFF)) | 0x8000;
}
} else if (B.imode == 2 || B.imode == 6) {
cmd = "FW;";
get_trace(1, "get FW");
ret = wait_char(';', 7, 100, "get FW", ASC);
gett("");
if (ret == 7) {
p = replystr.rfind("FW");
if (p != std::string::npos) {
for (i = 0; i < 11; i++)
if (replystr.find(TS480HX_CWbw[i]) == p)
break;
if (i == 11) i = 10;
B.iBW = i;
}
}
} else if (B.imode == 5 || B.imode == 7) {
cmd = "FW;";
get_trace(1, "get FW");
ret = wait_char(';', 7, 100, "get FW", ASC);
gett("");
if (ret == 7) {
p = replystr.rfind("FW");
if (p != std::string::npos) {
for (i = 0; i < 4; i++)
if (replystr.find(TS480HX_FSKbw[i]) == p)
break;
if (i == 4) i = 3;
B.iBW = i;
}
}
}
return B.iBW;
}
int RIG_TS480HX::adjust_bandwidth(int val)
{
int bw = 0;
if (val == 0 || val == 1 || val == 3)
bw = 0x8A03;
else if (val == 4)
bw = 0x8201;
else if (val == 2 || val == 6)
bw = 7;
else if (val == 5 || val == 7)
bw = 1;
return bw;
}
int RIG_TS480HX::def_bandwidth(int val)
{
return adjust_bandwidth(val);
}
void RIG_TS480HX::set_power_control(double val)
{
cmd = "PC";
char szval[4];
if (modeA == 4 && val > 50) val = 50; // AM mode limitation
snprintf(szval, sizeof(szval), "%03d", (int)val);
cmd += szval;
cmd += ';';
LOG_WARN("%s", cmd.c_str());
sendCommand(cmd);
}
double RIG_TS480HX::get_power_control()
{
int val = progStatus.power_level;
cmd = "PC;";
get_trace(1, "get_power_control");
ret = wait_char(';', 6, 100, "get Power control", ASC);
gett("");
if (ret < 6) return val;
size_t p = replystr.rfind("PC");
if (p == std::string::npos) return val;
val = atoi(&replystr[p + 2]);
return val;
}
void RIG_TS480HX::set_attenuator(int val)
{
if (val) cmd = "RA01;";
else cmd = "RA00;";
LOG_WARN("%s", cmd.c_str());
set_trace(1, "set attenuator");
sendCommand(cmd);
sett("");
atten_level = val;
}
int RIG_TS480HX::get_attenuator()
{
cmd = "RA;";
get_trace(1, "get_attenuator");
ret = wait_char(';', 7, 100, "get attenuator", ASC);
gett("");
if (ret < 7) return atten_level;
size_t p = replystr.rfind("RA");
if (p != std::string::npos)
atten_level = (replystr[p+3] == '1');
return atten_level;
}
void RIG_TS480HX::set_preamp(int val)
{
if (val) cmd = "PA1;";
else cmd = "PA0;";
LOG_WARN("%s", cmd.c_str());
set_trace(1, "set preamp");
sendCommand(cmd);
sett("");
preamp_level = val;
}
int RIG_TS480HX::get_preamp()
{
cmd = "PA;";
get_trace(1, "get_preamp");
ret = wait_char(';', 5, 100, "get preamp", ASC);
gett("");
if (ret < 5) return preamp_level;
size_t p = replystr.rfind("PA");
if (p != std::string::npos)
preamp_level = (replystr[p+2] == '1');
return preamp_level;
}
const char *RIG_TS480HX::PRE_label()
{
if (preamp_level == 1) return "Pre 1";
return "PRE";
}
const char *RIG_TS480HX::ATT_label()
{
if (atten_level == 1) return "ON";
return "ATT";
}
void RIG_TS480HX::set_if_shift(int val)
{
cmd = "IS+";
if (val < 0) cmd[2] = '-';
cmd.append(to_decimal(abs(val),4)).append(";");
sendCommand(cmd);
showresp(WARN, ASC, "set IF shift", cmd, "");
}
bool RIG_TS480HX::get_if_shift(int &val)
{
cmd = "IS;";
get_trace(1, "get_if_shift");
ret = wait_char(';', 8, 100, "get IF shift", ASC);
gett("");
if (ret == 8) {
size_t p = replystr.rfind("IS");
if (p != std::string::npos) {
val = fm_decimal(replystr.substr(p+3), 4);
if (replystr[p+2] == '-') val *= -1;
return (val != 0);
}
}
val = progStatus.shift_val;
return progStatus.shift;
}
void RIG_TS480HX::get_if_min_max_step(int &min, int &max, int &step)
{
if_shift_min = min = -1100;
if_shift_max = max = 1100;
if_shift_step = step = 10;
if_shift_mid = 0;
}
// Noise Reduction (TS2000.cxx) NR1 only works; no NR2 and don' no why
void RIG_TS480HX::set_noise_reduction(int val)
{
if (val == -1) {
return;
}
_noise_reduction_level = val;
if (_noise_reduction_level == 0) {
nr_label("NR", false);
} else if (_noise_reduction_level == 1) {
nr_label("NR1", true);
} else if (_noise_reduction_level == 2) {
nr_label("NR2", true);
}
cmd.assign("NR");
cmd += '0' + _noise_reduction_level;
cmd += ';';
sendCommand (cmd);
showresp(WARN, ASC, "SET noise reduction", cmd, "");
}
int RIG_TS480HX::get_noise_reduction()
{
cmd = rsp = "NR";
cmd.append(";");
get_trace(1, "get_noise_reduction");
ret = wait_char(';', 4, 100, "GET noise reduction", ASC);
gett("");
if (ret == 4) {
size_t p = replystr.rfind(rsp);
if (p == std::string::npos) return _noise_reduction_level;
_noise_reduction_level = replystr[p+2] - '0';
}
if (_noise_reduction_level == 1) {
nr_label("NR1", true);
} else if (_noise_reduction_level == 2) {
nr_label("NR2", true);
} else {
nr_label("NR", false);
}
return _noise_reduction_level;
}
void RIG_TS480HX::set_noise_reduction_val(int val)
{
if (_noise_reduction_level == 0) return;
if (_noise_reduction_level == 1) _nrval1 = val;
else _nrval2 = val;
cmd.assign("RL").append(to_decimal(val, 2)).append(";");
sendCommand(cmd);
showresp(WARN, ASC, "SET_noise_reduction_val", cmd, "");
}
int RIG_TS480HX::get_noise_reduction_val()
{
int nrval = 0;
if (_noise_reduction_level == 0) return 0;
int val = progStatus.noise_reduction_val;
cmd = rsp = "RL";
cmd.append(";");
get_trace(1, "get_noise_reduction_val");
ret = wait_char(';', 5, 100, "GET noise reduction val", ASC);
gett("");
if (ret == 5) {
size_t p = replystr.rfind(rsp);
if (p == std::string::npos) {
nrval = (_noise_reduction_level == 1 ? _nrval1 : _nrval2);
return nrval;
}
val = atoi(&replystr[p+2]);
}
if (_noise_reduction_level == 1) _nrval1 = val;
else _nrval2 = val;
return val;
}
int RIG_TS480HX::get_agc()
{
cmd = "GT;";
get_trace(1, "get_agc");
ret = wait_char(';', 6, 100, "GET agc val", ASC);
gett("");
size_t p = replystr.rfind("GT");
if (p == std::string::npos) return agcval;
if (replystr[4] == ' ') return 0;
agcval = replystr[4] - '0' + 1; // '0' == off, '1' = fast, '2' = slow
return agcval;
}
int RIG_TS480HX::incr_agc()
{
if (fm_mode) return 0;
agcval++;
if (agcval == 4) agcval = 1;
cmd.assign("GT00");
cmd += (agcval + '0' - 1);
cmd += ";";
sendCommand(cmd);
showresp(WARN, ASC, "SET agc", cmd, replystr);
return agcval;
}
static const char *agcstrs[] = {"FM", "AGC", "FST", "SLO"};
const char *RIG_TS480HX::agc_label()
{
if (fm_mode) return agcstrs[0];
return agcstrs[agcval];
}
int RIG_TS480HX::agc_val()
{
if (fm_mode) return 0;
return agcval;
}
// Auto Notch, beat canceller (TS2000.cxx) BC1 only, not BC2
void RIG_TS480HX::set_auto_notch(int v)
{
cmd = v ? "BC1;" : "BC0;";
sendCommand(cmd);
showresp(WARN, ASC, "set auto notch", cmd, "");
}
int RIG_TS480HX::get_auto_notch()
{
cmd = "BC;";
get_trace(1, "get_auto_notch");
ret = wait_char(';', 4, 100, "get auto notch", ASC);
gett("");
if (ret == 4) {
int anotch = 0;
size_t p = replystr.rfind("BC");
if (p != std::string::npos) {
anotch = (replystr[p+2] == '1');
return anotch;
}
}
return 0;
}
// Noise Blanker (TS2000.cxx)
void RIG_TS480HX::set_noise(bool b)
{
if (b)
cmd = "NB1;";
else
cmd = "NB0;";
sendCommand(cmd);
showresp(WARN, ASC, "set NB", cmd, "");
}
int RIG_TS480HX::get_noise()
{
cmd = "NB;";
get_trace(1, "get_noise");
ret = wait_char(';', 4, 100, "get Noise Blanker", ASC);
gett("");
if (ret == 4) {
size_t p = replystr.rfind("NB");
if (p == std::string::npos) return 0;
if (replystr[p+2] == '0') return 0;
}
return 1;
}
// Tranceiver PTT on/off
void RIG_TS480HX::set_PTT_control(int val)
{
if (val) {
if (progStatus.data_port) cmd = "TX1;"; // DTS transmission using ANI input
else cmd = "TX0;"; // mic input
} else cmd = "RX;";
sendCommand(cmd);
showresp(WARN, ASC, "set PTT", cmd, "");
}
int RIG_TS480HX::get_PTT()
{
// cmd = "IF;";
// get_trace(1, "get_PTT");
// ret = wait_char(';', 38, 100, "get VFO", ASC);
// gett("");
int ret = check_ifstr();
if (ret < 38) return ptt_;
ptt_ = (replystr[28] == '1');
return ptt_;
}
void RIG_TS480HX::set_rf_gain(int val)
{
cmd = "RG";
cmd.append(to_decimal(val,3)).append(";");
sendCommand(cmd);
showresp(WARN, ASC, "set rf gain", cmd, "");
}
int RIG_TS480HX::get_rf_gain()
{
int val = progStatus.rfgain;
cmd = "RG;";
get_trace(1, "get_rf_gain");
ret = wait_char(';', 6, 100, "get rf gain", ASC);
gett("");
if (ret < 6) return val;
size_t p = replystr.rfind("RG");
if (p != std::string::npos)
val = fm_decimal(replystr.substr(p+2), 3);
return val;
}
void RIG_TS480HX::get_rf_min_max_step(int &min, int &max, int &step)
{
min = 0; max = 100; step = 1;
}
void RIG_TS480HX::selectA()
{
cmd = "FR0;FT0;";
sendCommand(cmd);
showresp(WARN, ASC, "Rx on A, Tx on A", cmd, "");
inuse = onA;
}
void RIG_TS480HX::selectB()
{
cmd = "FR1;FT1;";
sendCommand(cmd);
showresp(WARN, ASC, "Rx on B, Tx on B", cmd, "");
inuse = onB;
}
void RIG_TS480HX::set_split(bool val)
{
split = val;
if (inuse == onB) {
if (val) {
cmd = "FR1;FT0;";
sendCommand(cmd);
showresp(WARN, ASC, "Rx on B, Tx on A", cmd, "");
} else {
cmd = "FR1;FT1;";
sendCommand(cmd);
showresp(WARN, ASC, "Rx on B, Tx on B", cmd, "");
}
} else {
if (val) {
cmd = "FR0;FT1;";
sendCommand(cmd);
showresp(WARN, ASC, "Rx on A, Tx on B", cmd, "");
} else {
cmd = "FR0;FT0;";
sendCommand(cmd);
showresp(WARN, ASC, "Rx on A, Tx on A", cmd, "");
}
}
}
bool RIG_TS480HX::can_split()
{
return true;
}
int RIG_TS480HX::get_split()
{
size_t p;
int split = 0;
char rx = 0, tx = 0;
// tx vfo
cmd = rsp = "FT";
cmd.append(";");
if (wait_char(';', 4, 100, "get split tx vfo", ASC) == 4) {
p = replystr.rfind(rsp);
if (p == std::string::npos) return split;
tx = replystr[p+2];
}
// rx vfo
cmd = rsp = "FR";
cmd.append(";");
if (wait_char(';', 4, 100, "get split rx vfo", ASC) == 4) {
p = replystr.rfind(rsp);
if (p == std::string::npos) return split;
rx = replystr[p+2];
}
if (tx == '0' && rx == '0') split = 0;
else if (tx == '1' && rx == '0') split = 1;
else if (tx == '0' && rx == '1') split = 2;
else if (tx == '1' && rx == '1') split = 3;
return split;
}
unsigned long long RIG_TS480HX::get_vfoA ()
{
cmd = "FA;";
if (wait_char(';', 14, 100, "get vfo A", ASC) < 14) return A.freq;
size_t p = replystr.rfind("FA");
if (p != std::string::npos && (p + 12 < replystr.length())) {
unsigned long long f = 0;
for (size_t n = 2; n < 13; n++)
f = f*10 + replystr[p+n] - '0';
A.freq = f;
}
return A.freq;
}
void RIG_TS480HX::set_vfoA (unsigned long long freq)
{
A.freq = freq;
cmd = "FA00000000000;";
for (int i = 12; i > 1; i--) {
cmd[i] += freq % 10;
freq /= 10;
}
sendCommand(cmd);
showresp(WARN, ASC, "set vfo A", cmd, "");
}
unsigned long long RIG_TS480HX::get_vfoB ()
{
cmd = "FB;";
if (wait_char(';', 14, 100, "get vfo B", ASC) < 14) return B.freq;
size_t p = replystr.rfind("FB");
if (p != std::string::npos && (p + 12 < replystr.length())) {
unsigned long long f = 0;
for (size_t n = 2; n < 13; n++)
f = f*10 + replystr[p+n] - '0';
B.freq = f;
}
return B.freq;
}
void RIG_TS480HX::set_vfoB (unsigned long long freq)
{
B.freq = freq;
cmd = "FB00000000000;";
for (int i = 12; i > 1; i--) {
cmd[i] += freq % 10;
freq /= 10;
}
sendCommand(cmd);
showresp(WARN, ASC, "set vfo B", cmd, "");
}
// Squelch (TS990.cxx)
void RIG_TS480HX::set_squelch(int val)
{
cmd = "SQ0";
cmd.append(to_decimal(abs(val),3)).append(";");
sendCommand(cmd);
showresp(INFO, ASC, "set squelch", cmd, "");
}
int RIG_TS480HX::get_squelch()
{
int val = 0;
cmd = "SQ0;";
if (wait_char(';', 7, 20, "get squelch", ASC) >= 7) {
size_t p = replystr.rfind("SQ0");
if (p == std::string::npos) return val;
replystr[p + 6] = 0;
val = atoi(&replystr[p + 3]);
}
return val;
}
void RIG_TS480HX::get_squelch_min_max_step(int &min, int &max, int &step)
{
min = 0; max = 255; step = 1;
}
void RIG_TS480HX::set_mic_gain(int val)
{
cmd = "MG";
cmd.append(to_decimal(val,3)).append(";");
sendCommand(cmd);
showresp(WARN, ASC, "set mic gain", cmd, "");
}
int RIG_TS480HX::get_mic_gain()
{
int val = progStatus.mic_gain;
cmd = "MG;";
if (wait_char(';', 6, 100, "get mic gain", ASC) < 6) return val;
size_t p = replystr.rfind("MG");
if (p != std::string::npos)
val = fm_decimal(replystr.substr(p+2), 3);
return val;
}
void RIG_TS480HX::get_mic_min_max_step(int &min, int &max, int &step)
{
min = 0; max = 100; step = 1;
}
void RIG_TS480HX::set_volume_control(int val)
{
cmd = "AG";
char szval[20];
snprintf(szval, sizeof(szval), "%04d", val * 255 / 100);
cmd += szval;
cmd += ';';
LOG_WARN("%s", cmd.c_str());
sendCommand(cmd);
}
int RIG_TS480HX::get_volume_control()
{
int val = progStatus.volume;
cmd = "AG0;";
if (wait_char(';', 7, 100, "get vol", ASC) < 7) return val;
size_t p = replystr.rfind("AG");
if (p == std::string::npos) return val;
replystr[p + 6] = 0;
val = atoi(&replystr[p + 3]);
val = val * 100 / 255;
return val;
}
void RIG_TS480HX::tune_rig()
{
cmd = "AC111;";
LOG_WARN("%s", cmd.c_str());
sendCommand(cmd);
}