/*
* th_get_freq
* Assumes rig!=NULL, freq!=NULL
*/
int
th_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
char buf[20];
int retval, step;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo)
return kenwood_wrong_vfo(__func__, vfo);
*freq = 0;
retval = kenwood_safe_transaction(rig, "FQ", buf, sizeof(buf), 17);
if (retval != RIG_OK)
return retval;
retval = num_sscanf(buf, "FQ %"SCNfreq",%x", freq, &step);
if (retval != 2) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf);
return -RIG_ERJCTED;
}
return RIG_OK;
}
/* push/pull language is uses for stuff inside 710 driver rather than get/set */
int
tmd710_pull_fo(RIG * rig,vfo_t vfo, tmd710_fo *fo_struct) {
char cmdbuf[50];
char buf[50];
int vfonum = 0;
int retval;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
switch (vfo) {
case (RIG_VFO_CURR):
vfonum = rig->state.current_vfo==RIG_VFO_B;
break;
case (RIG_VFO_A):
vfonum = 0;
break;
case (RIG_VFO_B):
vfonum = 1;
break;
}
// if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo)
//return kenwood_wrong_vfo(__func__, vfo);
snprintf(cmdbuf,49,"FO %d",vfonum);
retval = kenwood_safe_transaction(rig, cmdbuf, buf, sizeof(buf), 49);
if (retval != RIG_OK)
return retval;
retval = num_sscanf(buf, "FO %x,%"SCNfreq",%x,%x,%x,%x,%x,%x,%d,%d,%d,%d,%d",
&fo_struct->vfo, &fo_struct->freq,
&fo_struct->step, &fo_struct->shift,
&fo_struct->reverse, &fo_struct->tone,
&fo_struct->ct, &fo_struct->dsc,
&fo_struct->tone_freq, &fo_struct->ct_freq,
&fo_struct->dsc_val, &fo_struct->offset,
&fo_struct->mode);
if (retval != 13) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf);
return -RIG_ERJCTED;
}
return RIG_OK;
}
static int netrigctl_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq)
{
int ret, len;
char cmd[CMD_MAX];
char buf[BUF_MAX];
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __FUNCTION__);
len = sprintf(cmd, "i\n");
ret = netrigctl_transaction(rig, cmd, len, buf);
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
CHKSCN1ARG(num_sscanf(buf, "%"SCNfreq, tx_freq));
return RIG_OK;
}
/*
* rx340_get_freq
* Assumes rig!=NULL, freq!=NULL
*/
int rx340_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
char buf[BUFSZ];
int buf_len;
int retval;
double f;
#define REPORT_FREQ "TF"EOM
retval = rx340_transaction(rig, REPORT_FREQ, strlen(REPORT_FREQ), buf, &buf_len);
if (retval < 0)
return retval;
if (buf_len < 2 || buf[0] != 'F' || num_sscanf(buf+1, "%lf", &f) != 1)
return -RIG_EPROTO;
*freq = f*1e6;
return RIG_OK;
}
int rs_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
char buf[RESPSZ], *slevel;
int buf_len, retval;
switch (level) {
case RIG_LEVEL_STRENGTH: slevel = BOM "SENS:DATA? \"VOLT:AC\"" EOM; break;
case RIG_LEVEL_ATT: slevel = BOM "INP:ATT:STAT?" EOM; break;
case RIG_LEVEL_AF: slevel = BOM "SYST:AUD:VOL?" EOM; break;
case RIG_LEVEL_SQL:
case RIG_LEVEL_AGC:
case RIG_LEVEL_RF:
return -RIG_ENIMPL;
default:
return -RIG_EINVAL;
}
retval = rs_transaction(rig, slevel, strlen(slevel), buf, &buf_len);
if (retval < 0)
return retval;
switch (level) {
case RIG_LEVEL_STRENGTH:
/* assumes FORMAat:DATA ASCii
* result in dBuV, keep only integer part
*/
sscanf(buf, "%d", &val->i);
val->i -= 34;
break;
case RIG_LEVEL_ATT:
val->i = (!memcmp(buf, "ON", 2) || !memcmp(buf, "1", 1)) ? rig->state.attenuator[0] : 0;
break;
case RIG_LEVEL_AF:
if (num_sscanf(buf, "%f", &val->f) != 1)
return -RIG_EPROTO;
break;
default:
return -RIG_EINVAL;
}
return retval;
}
/*
* rx340_get_mode
* Assumes rig!=NULL, mode!=NULL
*/
int rx340_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
char buf[BUFSZ];
int buf_len;
int retval;
double f;
#define REPORT_MODEFILTER "TDI"EOM
retval = rx340_transaction(rig, REPORT_MODEFILTER,
strlen(REPORT_MODEFILTER), buf, &buf_len);
if (retval < 0)
return retval;
if (buf_len < 4 || buf[0] != 'D' || buf[2] != 'I')
return -RIG_EPROTO;
switch (buf[1]) {
case RX340_USB: *mode = RIG_MODE_USB; break;
case RX340_LSB: *mode = RIG_MODE_LSB; break;
case RX340_CW1:
case RX340_CW: *mode = RIG_MODE_CW; break;
case RX340_FM: *mode = RIG_MODE_FM; break;
case RX340_AM: *mode = RIG_MODE_AM; break;
case RX340_SAM: *mode = RIG_MODE_AMS; break;
case RX340_ISB: *mode = RIG_MODE_DSB; break;
default:
rig_debug(RIG_DEBUG_ERR,
"%s: unknown mode '%c'\n",
__func__, buf[1]);
return -RIG_EPROTO;
}
if (num_sscanf(buf+3, "%lf", &f) != 1)
return -RIG_EPROTO;
*width = f*1e3;
return RIG_OK;
}
int
gp2000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
char buf[RESPSZ], *slevel;
int buf_len, retval, ival;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s\n", __func__, rig_strvfo(vfo));
switch (level)
{
case RIG_LEVEL_AF:
slevel = BOM "SL?" EOM;
break;
case RIG_LEVEL_SQL:
slevel = BOM "SQ?" EOM;
break;
case RIG_LEVEL_STRENGTH:
case RIG_LEVEL_ATT:
case RIG_LEVEL_AGC:
case RIG_LEVEL_RF:
return -RIG_ENIMPL;
default:
return -RIG_EINVAL;
}
retval = gp2000_transaction(rig, slevel, strlen(slevel), buf, &buf_len);
if (retval < 0)
{
return retval;
}
switch (level)
{
case RIG_LEVEL_AF:
if (num_sscanf(buf, "%*cSL%d", &ival) != 1)
{
return -RIG_EPROTO;
}
val->f = ival;
break;
case RIG_LEVEL_SQL:
if (num_sscanf(buf, "%*cSQ%1d", &ival) != 1)
{
return -RIG_EPROTO;
}
val->f = ival;
break;
default:
return -RIG_EINVAL;
}
return retval;
}
/*
* mimics rpcrig_open() from rpcrig/rpcrig_backend.c
*/
static int netrigctl_open(RIG *rig)
{
int ret, len, i;
struct rig_state *rs = &rig->state;
int prot_ver;
char cmd[CMD_MAX];
char buf[BUF_MAX];
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __FUNCTION__);
len = sprintf(cmd, "\\dump_state\n");
ret = netrigctl_transaction(rig, cmd, len, buf);
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
prot_ver = atoi(buf);
#define RIGCTLD_PROT_VER 0
if (prot_ver < RIGCTLD_PROT_VER)
return -RIG_EPROTO;
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
rs->itu_region = atoi(buf);
for (i=0; i<FRQRANGESIZ; i++) {
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
ret = num_sscanf(buf, "%"SCNfreq"%"SCNfreq"%x%d%d%x%x",
&rs->rx_range_list[i].start,
&rs->rx_range_list[i].end,
&rs->rx_range_list[i].modes,
&rs->rx_range_list[i].low_power,
&rs->rx_range_list[i].high_power,
&rs->rx_range_list[i].vfo,
&rs->rx_range_list[i].ant
);
if (ret != 7)
return -RIG_EPROTO;
if (RIG_IS_FRNG_END(rs->rx_range_list[i]))
break;
}
for (i=0; i<FRQRANGESIZ; i++) {
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
ret = num_sscanf(buf, "%"SCNfreq"%"SCNfreq"%x%d%d%x%x",
&rs->tx_range_list[i].start,
&rs->tx_range_list[i].end,
&rs->tx_range_list[i].modes,
&rs->tx_range_list[i].low_power,
&rs->tx_range_list[i].high_power,
&rs->tx_range_list[i].vfo,
&rs->tx_range_list[i].ant
);
if (ret != 7)
return -RIG_EPROTO;
if (RIG_IS_FRNG_END(rs->tx_range_list[i]))
break;
}
for (i=0; i<TSLSTSIZ; i++) {
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
ret = sscanf(buf, "%x%ld",
&rs->tuning_steps[i].modes,
&rs->tuning_steps[i].ts);
if (ret != 2)
return -RIG_EPROTO;
if (RIG_IS_TS_END(rs->tuning_steps[i]))
break;
}
for (i=0; i<FLTLSTSIZ; i++) {
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
ret = sscanf(buf, "%x%ld",
&rs->filters[i].modes,
&rs->filters[i].width);
if (ret != 2)
return -RIG_EPROTO;
if (RIG_IS_FLT_END(rs->filters[i]))
break;
}
#if 0
/* TODO */
chan_t chan_list[CHANLSTSIZ]; /*!< Channel list, zero ended */
#endif
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
rs->max_rit = atol(buf);
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
rs->max_xit = atol(buf);
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
rs->max_ifshift = atol(buf);
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
rs->announces = atoi(buf);
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
ret = sscanf (buf, "%d%d%d%d%d%d%d",
&rs->preamp[0], &rs->preamp[1],
&rs->preamp[2], &rs->preamp[3],
&rs->preamp[4], &rs->preamp[5],
&rs->preamp[6]);
if (ret < 0 || ret >= MAXDBLSTSIZ)
ret = 0;
rs->preamp[ret] = RIG_DBLST_END;
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
ret = sscanf (buf, "%d%d%d%d%d%d%d",
&rs->attenuator[0], &rs->attenuator[1],
&rs->attenuator[2], &rs->attenuator[3],
&rs->attenuator[4], &rs->attenuator[5],
&rs->attenuator[6]);
if (ret < 0 || ret >= MAXDBLSTSIZ)
ret = 0;
rs->attenuator[ret] = RIG_DBLST_END;
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
rs->has_get_func = strtol(buf, NULL, 0);
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
rs->has_set_func = strtol(buf, NULL, 0);
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
rs->has_get_level = strtol(buf, NULL, 0);
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
rs->has_set_level = strtol(buf, NULL, 0);
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
rs->has_get_parm = strtol(buf, NULL, 0);
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", sizeof("\n"));
if (ret <= 0)
return (ret < 0) ? ret : -RIG_EPROTO;
rs->has_set_parm = strtol(buf, NULL, 0);
#if 0
gran_t level_gran[RIG_SETTING_MAX]; /*!< level granularity */
gran_t parm_gran[RIG_SETTING_MAX]; /*!< parm granularity */
#endif
for (i=0; i<FRQRANGESIZ && !RIG_IS_FRNG_END(rs->rx_range_list[i]); i++) {
rs->vfo_list |= rs->rx_range_list[i].vfo;
}
for (i=0; i<FRQRANGESIZ && !RIG_IS_FRNG_END(rs->tx_range_list[i]); i++) {
rs->vfo_list |= rs->tx_range_list[i].vfo;
}
return RIG_OK;
}
/*
* th_decode_event is called by sa_sigio, when some asynchronous
* data has been received from the rig.
*/
int
th_decode_event (RIG *rig)
{
char asyncbuf[128];
int retval;
size_t async_len=128;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
retval = kenwood_transaction(rig, NULL, 0, asyncbuf, &async_len);
if (retval != RIG_OK)
return retval;
rig_debug(RIG_DEBUG_TRACE, "%s: Decoding message\n", __func__);
if (async_len> 3 && asyncbuf[0] == 'B' && asyncbuf[1] == 'U' && asyncbuf[2] == 'F') {
vfo_t vfo;
freq_t freq, offset;
int mode;
int step, shift, rev, tone, ctcss, tonefq, ctcssfq;
retval = num_sscanf(asyncbuf, "BUF %d,%"SCNfreq",%X,%d,%d,%d,%d,,%d,,%d,%"SCNfreq",%d",
&vfo, &freq, &step, &shift, &rev, &tone,
&ctcss, &tonefq, &ctcssfq, &offset, &mode);
if (retval != 11) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BUF message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
/* Calibration and conversions */
vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B;
mode = (mode == 0) ? RIG_MODE_FM : RIG_MODE_AM;
rig_debug(RIG_DEBUG_TRACE, "%s: Buffer (vfo %d, freq %"PRIfreq" Hz, mode %d)\n", __func__, vfo, freq, mode);
/* Callback execution */
if (rig->callbacks.vfo_event) {
rig->callbacks.vfo_event(rig, vfo, rig->callbacks.vfo_arg);
}
if (rig->callbacks.freq_event) {
rig->callbacks.freq_event(rig, vfo, freq, rig->callbacks.freq_arg);
}
if (rig->callbacks.mode_event) {
rig->callbacks.mode_event(rig, vfo, mode, RIG_PASSBAND_NORMAL,
rig->callbacks.mode_arg);
}
} else if (async_len> 2 && asyncbuf[0] == 'S' && asyncbuf[1] == 'M') {
vfo_t vfo;
int lev;
retval = sscanf(asyncbuf, "SM %d,%d", &vfo, &lev);
if (retval != 2) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected SM message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
/* Calibration and conversions */
vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B;
rig_debug(RIG_DEBUG_TRACE, "%s: Signal strength event - signal = %.3f\n", __func__, (float)(lev / 5.0));
/* Callback execution */
#if STILLHAVETOADDCALLBACK
if (rig->callbacks.strength_event)
rig->callbacks.strength_event(rig, vfo,(float)(lev / 5.0),
rig->callbacks.strength_arg);
#endif
} else if (async_len > 2 && asyncbuf[0] == 'B' && asyncbuf[1] == 'Y') {
vfo_t vfo;
int busy;
retval = sscanf(asyncbuf, "BY %d,%d", &vfo, &busy);
if (retval != 2) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BY message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B;
rig_debug(RIG_DEBUG_TRACE, "%s: Busy event - status = '%s'\n",
__func__, (busy == 0) ? "OFF" : "ON" );
return -RIG_ENIMPL;
/* This event does not have a callback. */
} else if (async_len > 2 && asyncbuf[0] == 'B' && asyncbuf[1] == 'C') {
vfo_t vfo;
retval = sscanf(asyncbuf, "BC %d", &vfo);
if (retval != 1) {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BC message '%s'\n", __func__, asyncbuf);
return -RIG_ERJCTED;
}
vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B;
rig_debug(RIG_DEBUG_TRACE, "%s: VFO event - vfo = %d\n", __func__, vfo);
if (rig->callbacks.vfo_event)
rig->callbacks.vfo_event(rig, vfo, rig->callbacks.vfo_arg);
} else {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported transceive cmd '%s'\n", __func__, asyncbuf);
return -RIG_ENIMPL;
}
return RIG_OK;
}
/* --------------------------------------------------------------------- */
int th_get_channel(RIG *rig, channel_t *chan)
{
char membuf[64],ackbuf[ACKBUF_LEN];
int retval;
size_t ack_len;
freq_t freq,offset;
char req[16],scf[128];
int step, shift, rev, tone, ctcss, tonefq, ctcssfq, dcs, dcscode, mode, lockout;
const char *mr_extra;
int channel_num;
vfo_t vfo;
const struct kenwood_priv_caps *priv=(const struct kenwood_priv_caps *)rig->caps->priv;
const chan_t *chan_caps;
if (chan->vfo == RIG_VFO_MEM) {
chan_caps = rig_lookup_mem_caps(rig, chan->channel_num);
if (!chan_caps)
return -RIG_ECONF;
} else {
/* TODO: stuff channel_num (out of current freq) and chan_caps */
return -RIG_ENIMPL;
}
channel_num = chan->channel_num;
vfo = chan->vfo;
memset(chan, 0, sizeof(channel_t));
chan->channel_num = channel_num;
chan->vfo = vfo;
if (rig->caps->rig_model == RIG_MODEL_THF7E ||
rig->caps->rig_model == RIG_MODEL_THF6A)
mr_extra = "";
else
mr_extra = "0, ";
channel_num -= chan_caps->start;
switch (chan_caps->type) {
case RIG_MTYPE_MEM:
if (chan_caps[1].type == RIG_MTYPE_PRIO) {
/* Info */
sprintf(req, "MR %s0,I-%01d",mr_extra,channel_num);
} else
sprintf(req, "MR %s0,%03d",mr_extra,channel_num);
break;
case RIG_MTYPE_EDGE:
if (chan_caps[1].type == RIG_MTYPE_EDGE) {
sprintf(req, "MR %s0,L%01d",mr_extra,channel_num);
sprintf(chan->channel_desc, "L%01d",channel_num);
} else {
sprintf(req, "MR %s0,U%01d",mr_extra,channel_num);
sprintf(chan->channel_desc, "U%01d",channel_num);
}
break;
case RIG_MTYPE_PRIO:
if (chan_caps->start == chan_caps->end) {
sprintf(req, "MR %s0,PR",mr_extra);
sprintf(chan->channel_desc, "Pr");
} else {
sprintf(req, "MR %s0,PR%01d",mr_extra,channel_num+1);
sprintf(chan->channel_desc, "Pr%01d",channel_num+1);
}
break;
case RIG_MTYPE_CALL:
sprintf(req, "CR 0,%01d",channel_num);
if (chan->channel_num==chan_caps->start) sprintf(chan->channel_desc, "Call V");
else if (chan->channel_num==chan_caps->end) sprintf(chan->channel_desc, "Call U");
else sprintf(chan->channel_desc, "Call");
break;
case RIG_MTYPE_BAND:
sprintf(req, "VR %01X",channel_num);
sprintf(chan->channel_desc, "BAND %01X",channel_num);
break;
default:
return -RIG_EINVAL;
}
sprintf(membuf, "%s",req);
ack_len=ACKBUF_LEN;
retval = kenwood_transaction(rig, membuf, strlen(membuf), ackbuf, &ack_len);
if (retval != RIG_OK)
return retval;
/*
* TODO: dcs/mode/lockout are not there on TH-G71
*/
mode = RIG_MODE_NONE;
rev = lockout = dcs = dcscode = 0;
strcpy(scf,req);
if (chan_caps->mem_caps.dcs_sql)
{
/* Step can be hexa
* Lockout is optional on some channels
*/
strcat(scf, ",%"SCNfreq",%x,%d,%d,%d,%d,%d,%d,%d,%d,%"SCNfreq",%d,%d");
retval = num_sscanf(ackbuf, scf,
&freq, &step, &shift, &rev, &tone,
&ctcss, &dcs, &tonefq, &ctcssfq, &dcscode,
&offset, &mode, &lockout);
if (retval < 12) {
rig_debug(RIG_DEBUG_WARN, "%s: sscanf failed %d\n", __func__, retval);
return -RIG_EPROTO;
}
} else {
strcat(scf, ",%"SCNfreq",%x,%d,%d,%d,%d,,%d,,%d,%"SCNfreq);
retval = num_sscanf(ackbuf, scf,
&freq, &step, &shift, &rev, &tone,
&ctcss, &tonefq, &ctcssfq, &offset);
if (retval != 9) {
rig_debug(RIG_DEBUG_WARN, "%s: sscanf failed %d\n", __func__, retval);
}
}
chan->funcs = rev ? RIG_FUNC_REV : 0;
chan->flags = lockout ? RIG_CHFLAG_SKIP : 0;
chan->freq=freq;
chan->vfo=RIG_VFO_MEM;
chan->tuning_step=rig->state.tuning_steps[step].ts;
if (priv->mode_table) {
chan->mode = kenwood2rmode(mode, priv->mode_table);
if (chan->mode == RIG_MODE_NONE) {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode value '%d'\n",
__func__, mode);
return -RIG_EPROTO;
}
} else {
/* No mode info (TH-G71, TMV7,..),
* guess it from current freq
*/
chan->mode = (freq < MHz(136)) ? RIG_MODE_AM : RIG_MODE_FM;
}
chan->width=rig_passband_normal(rig, chan->mode);
switch (shift) {
case 0 :
chan->rptr_shift=RIG_RPT_SHIFT_NONE;
break;
case 1 :
chan->rptr_shift=RIG_RPT_SHIFT_PLUS;
break;
case 2 :
chan->rptr_shift=RIG_RPT_SHIFT_MINUS;
offset = -offset;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: not supported shift %d\n",
__func__, shift);
chan->rptr_shift=RIG_RPT_SHIFT_NONE;
}
chan->rptr_offs=offset;
/* FIXME: ctcss_list for t[fm]*.c */
//chan->ctcss_tone=rig->caps->ctcss_list[tonefq==1?0:tonefq-2];
// chan->ctcss_sql=rig->caps->ctcss_list[ctcssfq==1?0:ctcssfq-2];
if (tone)
chan->ctcss_tone=rig->caps->ctcss_list[tonefq];
else
chan->ctcss_tone=0;
if (ctcss)
chan->ctcss_sql=rig->caps->ctcss_list[ctcssfq];
else
chan->ctcss_sql=0;
if (dcs)
chan->dcs_sql=chan->dcs_code=rig->caps->dcs_list[dcscode];
else
chan->dcs_sql=chan->dcs_code=0;
chan->tx_freq=RIG_FREQ_NONE;
if (shift==RIG_RPT_SHIFT_NONE &&
((chan_caps->type==RIG_MTYPE_MEM && chan_caps->start == 0) ||
chan_caps->type==RIG_MTYPE_CALL)) {
/* split ? */
req[3+strlen(mr_extra)]='1';
sprintf(membuf, "%s",req);
ack_len=ACKBUF_LEN;
retval = kenwood_transaction(rig, membuf, strlen(membuf), ackbuf, &ack_len);
if (retval == RIG_OK) {
strcpy(scf,req);
strcat(scf, ",%"SCNfreq",%x");
retval = num_sscanf(ackbuf, scf, &freq, &step);
chan->tx_freq=freq;
chan->split=RIG_SPLIT_ON;
}
}
/* If not set already by special channels.. */
if (chan->channel_desc[0] == '\0') {
if (chan_caps[1].type == RIG_MTYPE_PRIO)
sprintf(membuf, "MNA %sI-%01d",mr_extra,channel_num);
else
sprintf(membuf, "MNA %s%03d",mr_extra,channel_num);
ack_len=ACKBUF_LEN;
/* Get memory name */
retval = kenwood_transaction(rig, membuf, strlen(membuf), ackbuf, &ack_len);
if (retval != RIG_OK)
return retval;
if (ack_len > rig->caps->chan_desc_sz)
ack_len = rig->caps->chan_desc_sz;
strncpy(chan->channel_desc,ackbuf+strlen(membuf)+1,ack_len);
chan->channel_desc[ack_len] = '\0';
}
return RIG_OK;
}
