static int thd72_get_channel(RIG *rig, channel_t *chan)
{
int retval, len;
char cmd[8], buf[72];
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
if (chan->vfo == RIG_VFO_MEM) { /* memory channel */
sprintf(cmd, "ME %03d", chan->channel_num);
retval = kenwood_transaction(rig, cmd, buf, sizeof (buf));
if (retval != RIG_OK)
return retval;
retval = thd72_parse_channel(1, buf, chan);
if (retval != RIG_OK)
return retval;
cmd[1] = 'N'; /* change ME to MN */
retval = kenwood_transaction(rig, cmd, buf, sizeof (buf));
if (retval != RIG_OK)
return retval;
len = strlen(buf);
memcpy(chan->channel_desc, buf+7, len-7);
} else { /* current channel */
retval = thd72_get_freq_info(rig, chan->vfo, buf);
if (retval != RIG_OK)
return retval;
return thd72_parse_channel(0, buf, chan);
}
return RIG_OK;
}
/*
* extends kenwood_set_func
* Assumes rig!=NULL, val!=NULL
*/
int ts570_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
{
char fctbuf[6];
/* Filter unimplemented RIG_FUNC_TUNER and allow settings 0..2 for
* RIG_FUNC_NR.
* Send all other requests to kenwood_set_func()
*/
switch (func) {
case RIG_FUNC_NR:
if ((status < 0) || (status >2))
return -RIG_EINVAL;
sprintf(fctbuf,"NR%01d", status);
return kenwood_transaction(rig, fctbuf, NULL, 0);
case RIG_FUNC_TUNER:
sprintf(fctbuf,"AC %c0", (0==status)?'0':'1');
return kenwood_transaction(rig, fctbuf, NULL, 0);
default:
return kenwood_set_func(rig, vfo, func, status);
}
return RIG_OK;
}
/*
* ts570_get_split_vfo
*/
int ts570_get_split_vfo(RIG * rig, vfo_t vfo, split_t * split, vfo_t * tx_vfo)
{
char ack[10];
char ack2[10];
int retval;
retval = kenwood_transaction(rig, "FR", ack, sizeof (ack));
if (retval != RIG_OK)
return retval;
retval = kenwood_transaction(rig, "FT", ack2, sizeof (ack2));
if (retval != RIG_OK)
return retval;
if (ack[2] != ack2[2]) {
*split = RIG_SPLIT_ON;
switch (ack2[2]) {
case '0': *tx_vfo = RIG_VFO_A; break;
case '1': *tx_vfo = RIG_VFO_B; break;
case '2': *tx_vfo = RIG_VFO_MEM; break;
default: rig_debug(RIG_DEBUG_ERR, "ts570_get_split_vfo: unknown tx vfo: %d\n", ack2[2]);
return -RIG_EINVAL;
}
} else {
*split = RIG_SPLIT_OFF;
*tx_vfo = RIG_VFO_CURR;
}
return RIG_OK;
}
static int ts870s_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
char buf[16];
int kmode, retval;
pbwidth_t mode_default_hpf;
switch (mode)
{
case RIG_MODE_CW: kmode = MD_CW; break;
case RIG_MODE_CWR: kmode = MD_CWR; break;
case RIG_MODE_USB: kmode = MD_USB; break;
case RIG_MODE_LSB: kmode = MD_LSB; break;
case RIG_MODE_FM: kmode = MD_FM; break;
case RIG_MODE_AM: kmode = MD_AM; break;
case RIG_MODE_RTTY: kmode = MD_FSK; break;
case RIG_MODE_RTTYR: kmode = MD_FSKR; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode %d\n",
__func__,mode);
return -RIG_EINVAL;
}
sprintf(buf, "MD%c", kmode);
retval = kenwood_transaction(rig, buf, NULL, 0);
if (retval != RIG_OK) return retval;
if (RIG_PASSBAND_NORMAL != width) /* leave well alone if default passband requested */
{
if (RIG_MODE_USB == mode || RIG_MODE_LSB == mode || RIG_MODE_AM == mode)
{
/* we assume the HPF is set to default and set the LPF to
give the best approximaation of the requested width */
if (RIG_MODE_AM == mode)
{
mode_default_hpf = 300;
}
else
{
mode_default_hpf = 100;
}
sprintf(buf, "IS %04d", (int)(width + mode_default_hpf));
retval = kenwood_transaction(rig, buf, NULL, 0);
}
else
{
/*
* This rig will simply use an IF bandpass which is closest to width,
* so we don't need to check the value...
*/
sprintf(buf, "FW%04d", (int)width/10);
retval = kenwood_transaction(rig, buf, NULL, 0);
}
}
return retval;
}
/*
* tm_set_vfo_bc2
* Apply to split-capable models (with BC command taking 2 args): TM-V7, TM-D700
*
* Assumes rig!=NULL
*/
int tmd710_set_vfo (RIG *rig, vfo_t vfo)
{
struct kenwood_priv_data *priv = rig->state.priv;
char vfobuf[16], ackbuf[16];
int vfonum, txvfonum, vfomode=0;
int retval;
rig_debug(RIG_DEBUG_TRACE, "%s: called %s\n", __func__, rig_strvfo(vfo));
switch (vfo) {
case RIG_VFO_A:
case RIG_VFO_VFO:
vfonum = 0;
/* put back split mode when toggling */
txvfonum = (priv->split == RIG_SPLIT_ON &&
rig->state.tx_vfo == RIG_VFO_B) ? 1 : vfonum;
break;
case RIG_VFO_B:
vfonum = 1;
/* put back split mode when toggling */
txvfonum = (priv->split == RIG_SPLIT_ON &&
rig->state.tx_vfo == RIG_VFO_A) ? 0 : vfonum;
break;
case RIG_VFO_MEM:
/* get current band */
snprintf(vfobuf, 10, "BC");
retval = kenwood_transaction(rig, vfobuf, ackbuf, sizeof (ackbuf));
if (retval != RIG_OK)
return retval;
txvfonum = vfonum = ackbuf[3]-'0';
vfomode = 2;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
snprintf(vfobuf,9, "VM %d,%d", vfonum, vfomode);
retval = kenwood_transaction(rig, vfobuf, NULL, 0);
if (retval != RIG_OK)
return retval;
if (vfo == RIG_VFO_MEM)
return RIG_OK;
snprintf(vfobuf, 15, "BC %d,%d", vfonum, txvfonum);
retval = kenwood_transaction(rig, vfobuf, NULL, 0);
if (retval != RIG_OK)
return retval;
return RIG_OK;
}
/*
* th_get_dcs_sql
* Assumes rig!=NULL, rig->caps!=NULL
*/
int
th_get_dcs_sql(RIG *rig, vfo_t vfo, tone_t *code)
{
struct rig_caps *caps;
char buf[ACKBUF_LEN];
int retval;
size_t ack_len=ACKBUF_LEN;
unsigned int code_idx;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
caps = rig->caps;
retval = kenwood_transaction(rig, "DCS", 3, buf, &ack_len);
if (retval != RIG_OK)
return retval;
retval = sscanf(buf, "DCSN %u", (int*)&code_idx);
if (retval != 1) {
rig_debug(RIG_DEBUG_ERR,
"%s: Unexpected reply '%s'\n", __func__, buf);
return -RIG_EPROTO;
}
if (code_idx == 0) {
*code = 0; /* disabled */
return RIG_OK;
}
ack_len=ACKBUF_LEN;
retval = kenwood_transaction(rig, "DCSN", 4, buf, &ack_len);
if (retval != RIG_OK)
return retval;
retval = sscanf(buf, "DCSN %u", (int*)&code_idx);
if (retval != 1) {
rig_debug(RIG_DEBUG_ERR,
"%s: Unexpected reply '%s'\n", __func__, buf);
return -RIG_EPROTO;
}
/* verify code index for TM-D700 rig */
if (code_idx <= 10 || code_idx > 1040) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected DCS no (%04u)\n",
__func__, code_idx);
return -RIG_EPROTO;
}
code_idx = (code_idx/10)-1;
*code = caps->dcs_list[code_idx];
return RIG_OK;
}
int ts570_set_channel (RIG * rig, const channel_t * chan)
{
char cmdbuf[30];
int retval, cmd_len;
int num,freq,tx_freq,tone;
char mode,tx_mode,tones;
num=chan->channel_num;
freq=(int)chan->freq;
mode=mode_to_char(chan->mode);
if(chan->split==RIG_SPLIT_ON) {
tx_freq=(int)chan->tx_freq;
tx_mode=mode_to_char(chan->tx_mode);
} else {
tx_freq=0;
tx_mode='\0';
}
for (tone = 1; rig->caps->ctcss_list[tone-1] != 0 && tone<39; tone++) {
if (rig->caps->ctcss_list[tone-1] == chan->ctcss_tone)
break;
}
if(chan->ctcss_tone!=0) {
tones='1';
} else {
tones='0';
tone=0;
}
cmd_len = sprintf(cmdbuf, "MW0 %02d%011d%c0%c%02d ",
num,freq,mode,tones,tone);
if (cmd_len < 0)
return -RIG_ETRUNC;
retval = kenwood_transaction (rig, cmdbuf, NULL, 0);
if (retval != RIG_OK)
return retval;
cmd_len = sprintf(cmdbuf, "MW1 %02d%011d%c0%c%02d ",
num,tx_freq,tx_mode,tones,tone);
if (cmd_len < 0)
return -RIG_ETRUNC;
retval = kenwood_transaction (rig, cmdbuf, NULL, 0);
if (retval != RIG_OK)
return retval;
return RIG_OK;
}
static int thd72_get_parm(RIG *rig, setting_t parm, value_t *val)
{
int retval, l, hh, mm, ss;
char buf[48];
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
switch (parm) {
case RIG_PARM_APO:
retval = thd72_get_menu_item(rig, 3, 3, &l);
if (retval != RIG_OK)
return retval;
val->i = thd72apo[l];
break;
case RIG_PARM_TIME:
retval = kenwood_transaction(rig, "RT", buf, sizeof (buf));
if (retval != RIG_OK)
return retval;
sscanf(buf+11, "%2d%2d%2d", &hh, &mm, &ss);
val->i = ss + 60*(mm + 60*hh);
break;
default:
return -RIG_EINVAL;
}
return RIG_OK;
}
/* only the ts870s and ts2000 support get_vfo with the 'FR;' command
NOTE: using byte 31 in 'IF' will also work. TODO: check other rigs */
static int ts870s_get_vfo(RIG *rig, vfo_t *vfo)
{
char vfobuf[50];
size_t vfo_len;
int retval;
/* query RX VFO */
retval = kenwood_transaction (rig, "FR", vfobuf, sizeof (vfobuf));
if (retval != RIG_OK)
return retval;
vfo_len = strlen (vfobuf);
if (vfo_len != 3 || vfobuf[1] != 'R') {
rig_debug(RIG_DEBUG_ERR,"%s: unexpected answer %s, "
"len=%d\n",__func__,vfobuf, vfo_len);
return -RIG_ERJCTED;
}
/* TODO: replace 0,1,2,.. constants by defines */
switch (vfobuf[2]) {
case '0': *vfo = RIG_VFO_A; break;
case '1': *vfo = RIG_VFO_B; break;
case '2': *vfo = RIG_VFO_MEM; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported VFO %c\n",
__func__,vfobuf[2]);
return -RIG_EPROTO;
}
return RIG_OK;
}
static int thd72_get_vfo(RIG *rig, vfo_t *vfo)
{
int retval;
char c, buf[10];
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
retval = kenwood_transaction(rig, "BC", buf, sizeof (buf));
if (retval != RIG_OK)
return retval;
size_t length = strlen (buf);
if (length == 4) {
c = buf[3];
} else {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected answer length '%c'\n", __func__, length);
return -RIG_EPROTO;
}
switch (c) {
case '0': *vfo = RIG_VFO_A; break;
case '1': *vfo = RIG_VFO_B; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO: %d\n", __func__, vfo);
return -RIG_EVFO;
}
return RIG_OK;
}
static int thd72_get_mem(RIG *rig, vfo_t vfo, int *ch)
{
int retval;
char c, cmd[10], buf[10];
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
retval = thd72_vfoc(rig, vfo, &c);
if (retval != RIG_OK)
{
return retval;
}
sprintf(cmd, "MR %c", c);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK)
{
return retval;
}
sscanf(buf + 5, "%d", ch);
return RIG_OK;
}
/* --------------------------------------------------------------------- */
int thg71_set_vfo (RIG *rig, vfo_t vfo)
{
char vfobuf[16];
int retval;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
switch (vfo) {
case RIG_VFO_A:
case RIG_VFO_VFO:
sprintf(vfobuf, "VMC 0,0");
break;
case RIG_VFO_MEM:
sprintf(vfobuf, "VMC 0,2");
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
retval = kenwood_transaction(rig, vfobuf, NULL, 0);
if (retval != RIG_OK)
return retval;
return RIG_OK;
}
/*
* thd7_get_ctcss_sql
* Assumes rig!=NULL, rig->caps!=NULL
*/
int
th_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone)
{
struct rig_caps *caps;
char buf[ACKBUF_LEN];
int retval;
size_t ack_len=ACKBUF_LEN;
unsigned int tone_idx;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
caps = rig->caps;
retval = kenwood_transaction(rig, "CTN", 4, buf, &ack_len);
if (retval != RIG_OK)
return retval;
retval = sscanf(buf, "CTN %d", (int*)&tone_idx);
if (retval != 1) {
rig_debug(RIG_DEBUG_ERR,
"%s: Unexpected reply '%s'\n", __func__, buf);
return -RIG_EPROTO;
}
/* verify tone index for TH-7DA rig */
if (tone_idx <= 0 || tone_idx == 2 || tone_idx > 39) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected CTCSS no (%04d)\n",
__func__, tone_idx);
return -RIG_EPROTO;
}
tone_idx -= (tone_idx == 1) ? 1 : 2; /* Correct for TH-7DA index anomaly */
*tone = caps->ctcss_list[tone_idx];
return RIG_OK;
}
/*
* th_set_ctcss_sql
* Assumes rig!=NULL, rig->caps->ctcss_list != NULL
*/
int
th_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
{
const struct rig_caps *caps;
char tonebuf[16],ackbuf[ACKBUF_LEN];
int i, retval;
size_t ack_len;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
caps = rig->caps;
for (i = 0; caps->ctcss_list[i] != 0 && i < RIG_TONEMAX; i++) {
if (caps->ctcss_list[i] == tone)
break;
}
if (caps->ctcss_list[i] != tone)
return -RIG_EINVAL;
i += (i == 0) ? 1 : 2; /* Correct for TH-D7A index anomally */
sprintf(tonebuf, "CTN %02d", i);
ack_len = ACKBUF_LEN;
retval = kenwood_transaction(rig, tonebuf, strlen(tonebuf), ackbuf, &ack_len);
if (retval != RIG_OK)
return retval;
return RIG_OK;
}
/* --------------------------------------------------------------------- */
int thg71_get_mode (RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
char ackbuf[ACKBUF_LEN];
int retval;
int step;
freq_t freq;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
switch (vfo) {
case RIG_VFO_CURR: break;
case RIG_VFO_A: break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
/* try to guess from frequency */
retval = kenwood_transaction(rig, "FQ", ackbuf, sizeof (ackbuf));
if (retval != RIG_OK)
return retval;
sscanf(ackbuf,"FQ %"SCNfreq",%d",&freq,&step);
if(freq <MHz(136) ) {
*mode=RIG_MODE_AM;
*width=kHz(9);
} else {
*mode=RIG_MODE_FM;
*width=kHz(12);
}
return RIG_OK;
}
/* --------------------------------------------------------------------- */
int thg71_get_vfo (RIG *rig, vfo_t *vfo)
{
char ackbuf[ACKBUF_LEN];
int retval;
int vch;
retval = kenwood_transaction(rig, "VMC 0" , ackbuf, sizeof (ackbuf));
if (retval != RIG_OK)
return retval;
sscanf(ackbuf,"VMC 0,%d",&vch);
switch(vch) {
case 0:
*vfo=RIG_VFO_A;
break;
case 1:
case 2:
*vfo=RIG_VFO_MEM;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo);
return -RIG_EVFO;
}
return RIG_OK;
}
/*
* extends kenwood_get_func
* Assumes rig!=NULL, val!=NULL
*/
int ts570_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
{
char fctbuf[50];
size_t fct_len;
int retval;
fct_len = 50;
/* filter unimplemented RIG_FUNC_TUNER
* and send all other requests to kenwood_get_func()
*/
switch (func) {
case RIG_FUNC_NR:
retval = kenwood_transaction (rig, "NR", fctbuf, sizeof (fctbuf));
if (retval != RIG_OK)
return retval;
fct_len = strlen (fctbuf);
if (fct_len != 3) {
rig_debug(RIG_DEBUG_ERR,"kenwood_get_func: "
"wrong answer len=%d\n", fct_len);
return -RIG_ERJCTED;
}
*status = atoi(&fctbuf[2]);
break;
case RIG_FUNC_TUNER:
retval = kenwood_transaction (rig, "AC", fctbuf, sizeof (fctbuf));
if (retval != RIG_OK)
return retval;
fct_len = strlen (fctbuf);
if (fct_len != 5) {
rig_debug(RIG_DEBUG_ERR,"kenwood_get_func: "
"wrong answer len=%d\n", fct_len);
return -RIG_ERJCTED;
}
*status = fctbuf[3] == '0' ? 0 : 1;
break;
default:
return kenwood_get_func(rig, vfo, func, status);
}
return RIG_OK;
}
/*
* ts570_set_level
* Assumes rig!=NULL
*
* set levels of most functions
*/
int
ts570_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val)
{
char levelbuf[16];
int kenwood_val;
int i;
switch (level)
{
case RIG_LEVEL_PREAMP:
kenwood_val = val.i;
/* set the preamplifier if a correct value is entered */
if (kenwood_val == 0)
sprintf(levelbuf, "PA0");
else
for (i=0; i<MAXDBLSTSIZ; i++)
if (kenwood_val == rig->state.preamp[i])
{
sprintf(levelbuf, "PA%01d", i+1);
break; /* found - stop searching */
}
else
return -RIG_EINVAL;
return kenwood_transaction(rig, levelbuf, NULL, 0);
case RIG_LEVEL_RFPOWER:
/* level for TS570D is from 0.. 100W in SSB and CW */
kenwood_val = val.f * 100;
sprintf (levelbuf, "PC%03d", kenwood_val);
return kenwood_transaction(rig, levelbuf, NULL, 0);
case RIG_LEVEL_MICGAIN:
/* level is from 0..100 */
kenwood_val = val.f * 100;
sprintf (levelbuf, "MG%03d", kenwood_val);
return kenwood_transaction(rig, levelbuf, NULL, 0);
default:
return kenwood_set_level (rig, vfo, level, val);
}
return RIG_OK; /* never reached */
}
int thd72_open(RIG *rig)
{
int ret;
struct kenwood_priv_data *priv = rig->state.priv;
strcpy(priv->verify_cmd, "ID\r");
ret = kenwood_transaction(rig, "", NULL, 0);
return ret;
}
int
tmd710_get_vfo_char(RIG *rig, vfo_t *vfo, char *vfoch)
{
char cmdbuf[10], buf[10], vfoc;
size_t buf_size=10;
int retval;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
/* Get VFO band */
retval = kenwood_transaction(rig, "BC", 2, buf, &buf_size);
if (retval != RIG_OK)
return retval;
switch (buf_size) {
case 7: /*intended for D700 BC 0,0*/
if ((buf[0]=='B') &&(buf[1]=='C') && (buf[2]==' ') && (buf[4]=',')){
vfoc = buf[3];
} else {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected answer format '%s'\n", __func__, buf);
return -RIG_EPROTO;
}
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected answer length '%c'\n", __func__, buf_size);
return -RIG_EPROTO;
break;
}
switch (vfoc) {
case '0': *vfo = RIG_VFO_A; break;
case '1': *vfo = RIG_VFO_B; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VFO value '%c'\n", __func__, buf[3]);
return -RIG_EVFO;
}
rig->state.current_vfo = *vfo;
/* Get mode of the VFO band */
snprintf(cmdbuf, 9, "VM %c", vfoc);
retval = kenwood_safe_transaction(rig, cmdbuf, buf, 10, 7);
if (retval != RIG_OK)
return retval;
*vfoch = buf[5];
return RIG_OK;
}
static int thd72_get_freq_info(RIG *rig, vfo_t vfo, char *buf)
{
int retval;
char c, cmd[8];
retval = thd72_vfoc(rig, vfo, &c);
if (retval != RIG_OK)
return retval;
sprintf(cmd, "FO %c", c);
retval = kenwood_transaction(rig, cmd, buf, 53);
return RIG_OK;
}
static int thd72_get_menu_info(RIG *rig, char *buf)
{
int retval;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
retval = kenwood_transaction(rig, "MU", buf, 41);
if (retval != RIG_OK)
return retval;
if (strlen(buf) != 40)
return -RIG_ERJCTED;
return RIG_OK;
}
int ts570_set_xit(RIG * rig, vfo_t vfo, shortfreq_t rit)
{
char buf[50];
unsigned char c;
int retval, len, i;
if (rit == 0) {
retval = kenwood_transaction(rig, "XT0", NULL, 0);
if (retval != RIG_OK)
return retval;
else
return RIG_OK;
} else {
retval = kenwood_transaction(rig, "XT1", NULL, 0);
if (retval != RIG_OK)
return retval;
}
if (rit > 0)
c = 'U';
else
c = 'D';
len = sprintf(buf, "R%c", c);
if (len < 0)
return -RIG_ETRUNC;
retval = kenwood_transaction(rig, "RC", NULL, 0);
if (retval != RIG_OK)
return retval;
for (i = 0; i < abs(rint(rit/10)); i++)
{
retval = kenwood_transaction(rig, buf, NULL, 0);
if (retval != RIG_OK)
return retval;
}
return RIG_OK;
}
/* --------------------------------------------------------------------- */
int thg71_open(RIG *rig)
{
char ackbuf[ACKBUF_LEN],*strl,*stru;
int retval,i;
const freq_range_t frend=RIG_FRNG_END;
/* this will check the model id */
retval = kenwood_open(rig);
if (retval != RIG_OK)
return retval;
/* fill state.rx/tx range_list */
retval = kenwood_transaction(rig, "FL", ackbuf, sizeof (ackbuf));
if (retval != RIG_OK)
return retval;
strl=strtok(ackbuf," ");
for(i=0;i<FRQRANGESIZ;i++) {
freq_range_t frng;
strl=strtok(NULL,",");
stru=strtok(NULL,",");
if(strl==NULL && stru==NULL)
break;
frng.start=MHz(atoi(strl));
frng.end=MHz(atoi(stru));
frng.vfo=RIG_VFO_A;
frng.ant=0;
if(frng.end<=MHz(135))
frng.modes=RIG_MODE_AM;
else
frng.modes=RIG_MODE_FM;
frng.high_power=-1;
frng.low_power=-1;
rig->state.rx_range_list[i]=frng;
if(frng.start> MHz(200))
frng.high_power=5.5;
else
frng.high_power=6;
frng.low_power=mW(50);
rig->state.tx_range_list[i]=frng;
}
rig->state.rx_range_list[i]= frend;
rig->state.tx_range_list[i]= frend;
rig->state.vfo_list=RIG_VFO_A | RIG_VFO_MEM ;
return RIG_OK;
}
static int ts570_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
char buf[16];
int kmode, retval;
if ((kmode = mode_to_char(mode)) == RIG_MODE_NONE)
return -RIG_EINVAL;
sprintf(buf, "MD%c", kmode);
retval = kenwood_transaction(rig, buf, NULL, 0);
if (retval != RIG_OK) return retval;
switch (mode)
{
case RIG_MODE_CW:
case RIG_MODE_CWR:
case RIG_MODE_RTTY:
case RIG_MODE_RTTYR:
sprintf(buf, "FW%04d", (int)width);
retval = kenwood_transaction(rig, buf, NULL, 0);
if (retval != RIG_OK) return retval;
break;
case RIG_MODE_USB:
case RIG_MODE_LSB:
case RIG_MODE_FM:
case RIG_MODE_AM:
sprintf(buf, "SL%02d", (int)width/50);
retval = kenwood_transaction(rig, buf, NULL, 0);
if (retval != RIG_OK) return retval;
break;
default:
return -RIG_EINVAL;
}
return RIG_OK;
}
int ts870s_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
char levelbuf[16];
int intval;
switch (level) {
case RIG_LEVEL_RFPOWER:
intval = val.f * 100;
sprintf(levelbuf, "PC%03d", intval);
return kenwood_transaction(rig, levelbuf, NULL, 0);
break;
default:
return kenwood_set_level (rig, vfo, level, val);
}
return RIG_OK;
}
static int thd72_get_freq_info(RIG *rig, vfo_t vfo, char *buf)
{
int retval;
char c, cmd[8];
rig_debug(RIG_DEBUG_TRACE, "%s: called VFO=%s\n", __func__, rig_strvfo(vfo));
retval = thd72_vfoc(rig, vfo, &c);
if (retval != RIG_OK)
{
return retval;
}
sprintf(cmd, "FO %c", c);
retval = kenwood_transaction(rig, cmd, buf, 53);
return RIG_OK;
}
/* --------------------------------------------------------------------- */
int thg71_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
{
int retval;
if(func != RIG_FUNC_TBURST)
return -RIG_EINVAL;
if(status==1) {
retval = kenwood_transaction(rig, "TT", NULL, 0);
if (retval != RIG_OK)
return retval;
return RIG_OK;
}
if(status==0) {
return rig_set_ptt(rig,vfo,RIG_PTT_OFF);
}
return -RIG_EINVAL;
}
/* Note: The 140/680/711/811 need this to set the VFO on the radio */
static int
ts711_set_vfo(RIG *rig, vfo_t vfo)
{
char cmdbuf[16];
char vfo_function;
switch (vfo) {
case RIG_VFO_VFO:
case RIG_VFO_A: vfo_function = VFO_A; break;
case RIG_VFO_B: vfo_function = VFO_B; break;
case RIG_VFO_MEM: vfo_function = VFO_MEM; break;
case RIG_VFO_CURR: return RIG_OK;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported VFO %d\n",
__func__, vfo);
return -RIG_EINVAL;
}
sprintf(cmdbuf, "FN%c", vfo_function);
return kenwood_transaction(rig, cmdbuf, NULL, 0);
}
static int ts680_set_vfo(RIG *rig, vfo_t vfo)
{
char cmdbuf[16];
char vfo_function;
switch (vfo) {
case RIG_VFO_VFO:
case RIG_VFO_A: vfo_function = VFO_A; break;
case RIG_VFO_B: vfo_function = VFO_B; break;
case RIG_VFO_MEM: vfo_function = VFO_MEM; break;
case RIG_VFO_CURR: return RIG_OK;
default:
rig_debug(RIG_DEBUG_ERR,"ts680_set_vfo: unsupported VFO %d\n",
vfo);
return -RIG_EINVAL;
}
sprintf(cmdbuf, "FN%c", vfo_function); /* The 680 and 140 need this to set the VFO on the radio */
return kenwood_transaction(rig, cmdbuf, NULL, 0);
}
