int barrett_set_split_vfo(RIG *rig, vfo_t rxvfo, split_t split, vfo_t txvfo)
{
struct barrett_priv_data *priv;
priv = rig->state.priv;
rig_debug(RIG_DEBUG_VERBOSE, "%s called rxvfo=%s, txvfo=%s, split=%d\n",
__FUNCTION__, rig_strvfo(rxvfo), rig_strvfo(txvfo), split);
priv->split = split;
return RIG_OK;
}
int barrett_get_split_vfo(RIG *rig, vfo_t rxvfo, split_t *split, vfo_t *txvfo)
{
struct barrett_priv_data *priv;
priv = rig->state.priv;
*split = priv->split;
*txvfo = RIG_VFO_B; // constant
rig_debug(RIG_DEBUG_VERBOSE, "%s called rxvfo=%s, txvfo=%s, split=%d\n",
__FUNCTION__, rig_strvfo(rxvfo), rig_strvfo(*txvfo), *split);
return RIG_OK;
}
int barrett_get_vfo(RIG *rig, vfo_t *vfo)
{
*vfo = RIG_VFO_A;
if (check_vfo(*vfo) == FALSE) {
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __FUNCTION__,
rig_strvfo(*vfo));
return -RIG_EINVAL;
}
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s\n", __FUNCTION__, rig_strvfo(*vfo));
return RIG_OK;
}
int
pcr_set_freq(RIG * rig, vfo_t vfo, freq_t freq)
{
struct pcr_priv_data *priv;
struct pcr_rcvr *rcvr;
unsigned char buf[20];
int freq_len, err;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo = %s, freq = %.0f\n",
__func__, rig_strvfo(vfo), freq);
priv = (struct pcr_priv_data *) rig->state.priv;
rcvr = is_sub_rcvr(rig, vfo) ? &priv->sub_rcvr : &priv->main_rcvr;
freq_len = sprintf((char *) buf, "K%c%010" PRIll "0%c0%c00",
is_sub_rcvr(rig, vfo) ? '1':'0',
(int64_t) freq,
rcvr->last_mode, rcvr->last_filter);
buf[freq_len] = '\0';
err = pcr_transaction(rig, (char *) buf);
if (err != RIG_OK)
return err;
rcvr->last_freq = freq;
return RIG_OK;
}
int ft847_set_freq(RIG *rig, vfo_t vfo, freq_t freq) {
struct rig_state *rig_s;
unsigned char p_cmd[YAESU_CMD_LENGTH]; /* sequence to send */
int ret;
if (!rig)
return -RIG_EINVAL;
rig_s = &rig->state;
rig_debug(RIG_DEBUG_VERBOSE,"ft847: requested freq = %"PRIfreq" Hz, vfo=%s\n",
freq, rig_strvfo(vfo));
ret = opcode_vfo(rig, p_cmd, FT_847_NATIVE_CAT_SET_FREQ_MAIN, vfo);
if (ret != RIG_OK)
return ret;
to_bcd_be(p_cmd,freq/10,8); /* store bcd format in in p_cmd */
rig_debug(RIG_DEBUG_VERBOSE,"%s: requested freq after conversion = %"PRIll" Hz \n", __func__, from_bcd_be(p_cmd,8)* 10 );
if (rig->caps->rig_model == RIG_MODEL_FT847UNI) {
struct ft847_priv_data *priv = (struct ft847_priv_data*)rig->state.priv;
if (vfo == RIG_VFO_MAIN) {
priv->freqA = freq;
rig_debug(RIG_DEBUG_TRACE,"%s: freqA=%"PRIfreq"\n", __func__, priv->freqA);
}
else {
priv->freqB = freq;
rig_debug(RIG_DEBUG_TRACE,"%s: freqB=%"PRIfreq"\n", __func__, priv->freqB);
}
}
return write_block(&rig_s->rigport, (char*)p_cmd, YAESU_CMD_LENGTH);
}
int
gp2000_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
{
char buf[RESPSZ], *sfunc;
int buf_len, retval;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s\n", __func__, rig_strvfo(vfo));
switch (func)
{
case RIG_FUNC_SQL:
sfunc = BOM "SQ00?" EOM;
break;
default:
return -RIG_EINVAL;
}
retval = gp2000_transaction(rig, sfunc, strlen(sfunc), buf, &buf_len);
if (retval < 0)
{
return retval;
}
// we expecte LF+"X" where X is the status
*status = buf[2] == 1 ? 1 : 0;
return retval;
}
int
gp2000_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
char buf[64];
int len, retval;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s\n", __func__, rig_strvfo(vfo));
switch (level)
{
case RIG_LEVEL_AF:
len = snprintf(buf, sizeof(buf), BOM "SR%02d" EOM, (int)val.f);
break;
case RIG_LEVEL_SQL:
len = snprintf(buf, sizeof(buf), BOM "SQ%1d" EOM, (int)val.f);
break;
case RIG_LEVEL_AGC:
case RIG_LEVEL_RF:
return -RIG_ENIMPL;
default:
return -RIG_EINVAL;
}
retval = gp2000_transaction(rig, buf, len, NULL, NULL);
return retval;
}
/*
* barrett_get_freq
* Assumes rig!=NULL, rig->state.priv!=NULL, freq!=NULL
*/
int barrett_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
int retval;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s\n", __FUNCTION__, rig_strvfo(vfo));
*freq = 0;
char *response = NULL;
if (vfo == RIG_VFO_B) { // We treat the TX VFO as VFO_B and RX VFO as VFO_A
retval = barrett_transaction(rig, "IT", 0, &response);
} else {
retval = barrett_transaction(rig, "IR", 0, &response);
}
if (retval != RIG_OK) {
rig_debug(RIG_DEBUG_ERR, "%s: invalid response=\n", __FUNCTION__, response);
return retval;
}
retval = sscanf(response, "%lg", freq);
if (retval != 1) {
rig_debug(RIG_DEBUG_ERR, "Unable to parse response\n");
return -RIG_EPROTO;
}
return RIG_OK;
}
static int thd72_set_vfo(RIG *rig, vfo_t vfo)
{
const char *cmd;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
switch (vfo)
{
case RIG_VFO_A:
case RIG_VFO_VFO:
case RIG_VFO_MAIN:
cmd = "BC 0";
rig->state.current_vfo = RIG_VFO_A;
break;
case RIG_VFO_B:
case RIG_VFO_SUB:
rig->state.current_vfo = RIG_VFO_B;
cmd = "BC 1";
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO: %s\n", __func__,
rig_strvfo(vfo));
return -RIG_ENTARGET;
}
return kenwood_simple_transaction(rig, cmd, 4);
}
/*
* barrett_get_ptt
* Assumes rig!=NULL
*/
int barrett_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
{
int retval;
char *response = NULL;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s\n", __FUNCTION__, rig_strvfo(vfo));
retval = barrett_transaction(rig, "IP", 0, &response);
if (retval != RIG_OK) {
rig_debug(RIG_DEBUG_ERR, "%s: error response?='%s'\n", response);
return retval;
}
char c = response[0];
if (c == '1' || c == '0') {
*ptt = c - '0';
} else {
rig_debug(RIG_DEBUG_ERR, "%s: error response='%s'\n", response);
return -RIG_EPROTO;
}
return RIG_OK;
}
/*
* opcode_vfo() copy into cmd the 5 byte command designated by cmd_index,
* and patch the opcode with VFO targetting (MAIN 0x0-, SAT RX 0x1-, SAT TX 0x2-)
*/
static int opcode_vfo(RIG *rig, unsigned char * cmd, int cmd_index, vfo_t vfo)
{
struct ft847_priv_data *p = (struct ft847_priv_data*)rig->state.priv;
memcpy(cmd, &ncmd[cmd_index].nseq,YAESU_CMD_LENGTH);
/* If the sat_mode is not enabled,
* then leave the OpCode untouched (MAIN VFO) */
if (p->sat_mode == RIG_SPLIT_ON) {
switch(vfo) {
case RIG_VFO_CURR:
case RIG_VFO_MAIN:
cmd[4] &= 0x0f;
cmd[4] |= 0x10; /* MAIN VFO -> SAT RX VFO */
break;
case RIG_VFO_SUB:
case RIG_VFO_TX:
cmd[4] &= 0x0f;
cmd[4] |= 0x20; /* SAT TX VFO */
break;
default:
rig_debug(RIG_DEBUG_WARN,"%s: Unsupported VFO %s\n",
rig_strvfo(vfo));
return -RIG_EINVAL; /* sorry, wrong VFO */
}
}
return RIG_OK;
}
/*
* gp2000_get_mode
* Assumes rig!=NULL
*/
int
gp2000_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
char buf[RESPSZ];
int buf_len, retval;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s\n", __func__, rig_strvfo(vfo));
#define DEM_QUERY BOM "I?" EOM
retval =
gp2000_transaction(rig, DEM_QUERY, strlen(DEM_QUERY), buf, &buf_len);
if (retval < 0)
{
return retval;
}
int nmode;
char *pmode = "UNKNOWN";
int n = sscanf(buf, "%*cI%d", &nmode);
if (n != 1)
{
return -RIG_EPROTO;
}
switch (nmode)
{
case 1: pmode = "AM"; break;
case 2: pmode = "USB"; break;
case 3: pmode = "LSB"; break;
case 5: pmode = "CW"; break;
case 9: pmode = "FM"; break;
case 13: pmode = "PKTUSB"; break;
case 14: pmode = "PKTLSB"; break;
}
*mode = rig_parse_mode(pmode);
#define BAND_QUERY BOM "W?" EOM
retval =
gp2000_transaction(rig, BAND_QUERY, strlen(BAND_QUERY), buf, &buf_len);
if (retval < 0)
{
return retval;
}
*width = atoi(&buf[2]);
return retval;
}
/*
* barrett_get_mode
* Assumes rig!=NULL
* Note that 2050 does not have set or get width
*/
int barrett_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s\n", __FUNCTION__, rig_strvfo(vfo));
char *result = NULL;
int retval = barrett_transaction(rig, "IB", 0, &result);
if (retval != RIG_OK) {
rig_debug(RIG_DEBUG_ERR, "%s: bad response=%s\n", __FUNCTION__, result);
return retval;
}
//dump_hex((unsigned char *)result,strlen(result));
switch (result[1]) {
case 'L':
*mode = RIG_MODE_LSB;
break;
case 'U':
*mode = RIG_MODE_USB;
break;
case 'A':
*mode = RIG_MODE_AM;
break;
case 'F':
*mode = RIG_MODE_RTTY;
break;
case 'C':
*mode = RIG_MODE_CW;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unknown mode='%c%c'\n", __FUNCTION__, result[0],
result[1]);
return -RIG_EPROTO;
}
*width = 3000; // we'll default this to 3000 for now
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s mode=%s width=%d\n", __FUNCTION__,
rig_strvfo(vfo), rig_strrmode(*mode), *width);
return RIG_OK;
}
/*
* 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;
size_t ack_len;
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");
ack_len=16;
retval = kenwood_transaction(rig, vfobuf, strlen(vfobuf), ackbuf, &ack_len);
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_cmd(rig, vfobuf);
if (retval != RIG_OK)
return retval;
if (vfo == RIG_VFO_MEM)
return RIG_OK;
snprintf(vfobuf, 15, "BC %d,%d", vfonum, txvfonum);
retval = kenwood_cmd(rig, vfobuf);
if (retval != RIG_OK)
return retval;
return RIG_OK;
}
static int thd72_vfoc(RIG *rig, vfo_t vfo, char *vfoc)
{
rig_debug(RIG_DEBUG_TRACE, "%s: called VFO=%s\n", __func__, rig_strvfo(vfo));
vfo = (vfo == RIG_VFO_CURR) ? rig->state.current_vfo : vfo;
switch (vfo)
{
case RIG_VFO_A:
case RIG_VFO_MAIN: *vfoc = '0'; break;
case RIG_VFO_B:
case RIG_VFO_SUB: *vfoc = '1'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO: %s\n", __func__,
rig_strvfo(vfo));
return -RIG_ENTARGET;
}
return RIG_OK;
}
int
gp2000_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
{
int retval = 0;
char cmd[32];
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s\n", __func__, rig_strvfo(vfo));
snprintf(cmd, sizeof(cmd), "X%1d", ptt);
retval = gp2000_transaction(rig, cmd, strlen(cmd), NULL, NULL);
return retval;
}
static int thd72_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
int retval, lvl;
char c, lvlc, cmd[10];
rig_debug(RIG_DEBUG_TRACE, "%s: called VFO=%s, level=%s, val=%g\n", __func__,
rig_strvfo(vfo), rig_strlevel(level), val.f);
retval = thd72_vfoc(rig, vfo, &c);
if (retval != RIG_OK)
{
return retval;
}
switch (level)
{
case RIG_LEVEL_RFPOWER:
if (val.f <= 0.01) { lvlc = '2'; }
else if (val.f <= 0.10) { lvlc = '1'; }
else { lvlc = '0'; }
sprintf(cmd, "PC %c,%c", c, lvlc);
return kenwood_simple_transaction(rig, cmd, 6);
case RIG_LEVEL_VOXGAIN:
return thd72_set_menu_item(rig, 8, (int)(val.f * 10.0 - 0.5));
case RIG_LEVEL_VOXDELAY:
if (val.i > 20000) { lvl = 6; }
else if (val.i > 10000) { lvl = val.i / 10000 + 3; }
else { lvl = val.i / 2500; }
return thd72_set_menu_item(rig, 9, lvl);
case RIG_LEVEL_SQL:
lvlc = '0' + (int)(val.f * 5);
sprintf(cmd, "PC %c,%c", c, lvlc);
return kenwood_simple_transaction(rig, cmd, 6);
case RIG_LEVEL_BALANCE:
/* FIXME - is balance 0.0 .. 1.0 or -1.0 .. 1.0? */
lvl = (int)(val.f * 4.0);
return thd72_set_menu_item(rig, 13, lvl);
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Level %d\n", __func__, level);
return -RIG_EINVAL;
}
return retval;
}
int sprintf_vfo(char *str, vfo_t vfo)
{
int i, len = 0;
const char *sv;
*str = '\0';
if (vfo == RIG_VFO_NONE)
{
return 0;
}
sv = rig_strvfo(vfo & RIG_VFO_CURR);
if (sv && sv[0])
{
len += sprintf(str + len, "%s ", sv);
}
sv = rig_strvfo(vfo & RIG_VFO_MEM);
if (sv && sv[0])
{
len += sprintf(str + len, "%s ", sv);
}
sv = rig_strvfo(vfo & RIG_VFO_VFO);
if (sv && sv[0])
{
len += sprintf(str + len, "%s ", sv);
}
sv = rig_strvfo(vfo & RIG_VFO_MAIN);
if (sv && sv[0])
{
len += sprintf(str + len, "%s ", sv);
}
sv = rig_strvfo(vfo & RIG_VFO_SUB);
if (sv && sv[0])
{
len += sprintf(str + len, "%s ", sv);
}
for (i = 0; i < 16; i++)
{
sv = rig_strvfo(vfo & RIG_VFO_N(i));
if (sv && sv[0])
{
len += sprintf(str + len, "%s ", sv);
}
}
return len;
}
int th_set_split_vfo (RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
{
struct kenwood_priv_data *priv = rig->state.priv;
char vfobuf[16];
int vfonum, txvfonum;
int retval;
rig_debug(RIG_DEBUG_TRACE, "%s: called %s\n", __func__, rig_strvfo(vfo));
if (vfo == RIG_VFO_CURR) {
retval = rig_get_vfo(rig, &vfo);
if (retval != RIG_OK)
return retval;
}
switch (vfo) {
case RIG_VFO_A:
case RIG_VFO_VFO:
vfonum = 0;
if (split == RIG_SPLIT_ON && txvfo != RIG_VFO_B)
return -RIG_EINVAL;
txvfonum = split == RIG_SPLIT_ON ? 1 : vfonum;
break;
case RIG_VFO_B:
vfonum = 1;
if (split == RIG_SPLIT_ON && txvfo != RIG_VFO_A)
return -RIG_EINVAL;
txvfonum = split == RIG_SPLIT_ON ? 0 : vfonum;
break;
default:
return -RIG_EINVAL;
}
/* Set VFO mode. To be done for TX vfo also? */
sprintf(vfobuf, "VMC %d,0", vfonum);
retval = kenwood_cmd(rig, vfobuf);
if (retval != RIG_OK)
return retval;
sprintf(vfobuf, "BC %d,%d", vfonum, txvfonum);
retval = kenwood_cmd(rig, vfobuf);
if (retval != RIG_OK)
return retval;
/* Remember whether split is on, for th_set_vfo */
priv->split = split;
return RIG_OK;
}
static int netrigctl_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
{
int ret, len;
char cmd[CMD_MAX];
char buf[BUF_MAX];
rig_debug(RIG_DEBUG_VERBOSE,"%s called\n", __FUNCTION__);
len = sprintf(cmd, "S %s\n", rig_strvfo(tx_vfo));
ret = netrigctl_transaction(rig, cmd, len, buf);
if (ret > 0)
return -RIG_EPROTO;
else
return ret;
}
/*
* barrett_set_mode
* Assumes rig!=NULL
* Note that 2050 does not have set or get width
*/
int barrett_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
char cmd_buf[32], ttmode;
int retval;
//struct tt588_priv_data *priv = (struct tt588_priv_data *) rig->state.priv;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s mode=%d width=%d\n", __FUNCTION__,
rig_strvfo(vfo), mode, width);
switch (mode) {
case RIG_MODE_USB:
ttmode = 'U';
break;
case RIG_MODE_LSB:
ttmode = 'L';
break;
case RIG_MODE_CW:
ttmode = 'C';
break;
case RIG_MODE_AM:
ttmode = 'A';
break;
case RIG_MODE_RTTY:
ttmode = 'F';
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported mode %d\n", __FUNCTION__, mode);
return -RIG_EINVAL;
}
sprintf((char *) cmd_buf, "XB%c" EOM, ttmode);
retval = barrett_transaction(rig, cmd_buf, 0, NULL);
if (retval < 0) {
return retval;
}
return RIG_OK;
}
/*
* barrett_set_freq
* assumes rig!=NULL, rig->state.priv!=NULL
*/
int barrett_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
char cmd_buf[MAXCMDLEN];
int retval;
struct barrett_priv_data *priv = rig->state.priv;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s freq=%.0f\n", __FUNCTION__,
rig_strvfo(vfo), freq);
// If we are not explicity asking for VFO_B then we'll set the receive side also
if (vfo != RIG_VFO_B) {
sprintf((char *) cmd_buf, "TR%08.0f", freq);
char *response = NULL;
retval = barrett_transaction(rig, cmd_buf, 0, &response);
if (retval < 0) {
return retval;
}
//dump_hex((unsigned char *)response, strlen(response));
if (strncmp(response, "OK", 2) != 0) {
rig_debug(RIG_DEBUG_ERR, "%s: Expected OK, got '%s'\n", __FUNCTION__, response);
return -RIG_EINVAL;
}
}
if (priv->split == 0
|| vfo == RIG_VFO_B) { // if we aren't in split mode we have to set the TX VFO too
sprintf((char *) cmd_buf, "TT%08.0f", freq);
char *response = NULL;
retval = barrett_transaction(rig, cmd_buf, 0, &response);
if (retval < 0) {
return retval;
}
if (strncmp(response, "OK", 2) != 0) {
rig_debug(RIG_DEBUG_ERR, "%s: Expected OK, got '%s'\n", __FUNCTION__, response);
return -RIG_EINVAL;
}
}
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;
}
/*
* gp2000_set_freq
* Assumes rig!=NULL
*/
int
gp2000_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
char freqbuf[32];
int freq_len, retval;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s,freq=%.0f\n", __func__,
rig_strvfo(vfo), freq);
freq_len =
snprintf(freqbuf, sizeof(freqbuf), BOM "F%" PRIll ",%" PRIll EOM,
(int64_t) freq,
(int64_t) freq);
retval = gp2000_transaction(rig, freqbuf, freq_len, NULL, NULL);
return retval;
}
/*
* barrett_set_split_freq
*/
int barrett_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
{
// The 2050 only has one RX and one TX VFO -- it's not treated as VFOA/VFOB
char cmd_buf[MAXCMDLEN];
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s freq=%g\n", __FUNCTION__,
rig_strvfo(vfo), tx_freq);
sprintf((char *) cmd_buf, "TT%08.0f" EOM, tx_freq);
int retval = barrett_transaction(rig, cmd_buf, 0, NULL);
if (retval < 0) {
return retval;
}
return RIG_OK;
}
int
gp2000_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
{
int retval = 0;
int len;
char buf[RESPSZ];
char *cmd = BOM "X?" EOM;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s\n", __func__, rig_strvfo(vfo));
retval = gp2000_transaction(rig, cmd, strlen(cmd), buf, &len);
if (retval < 0)
{
return retval;
}
retval = (sscanf(buf, "%*cX%1u", ptt) == 1) ? RIG_OK : -RIG_EPROTO;
return retval;
}
/*
* pcr_set_vfo
*
* Only useful on PCR-2500 which is a double receiver.
* Simply remember what the current VFO is for RIG_VFO_CURR.
*/
int
pcr_set_vfo(RIG * rig, vfo_t vfo)
{
struct pcr_priv_data *priv = (struct pcr_priv_data *) rig->state.priv;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo = %s\n",
__func__, rig_strvfo(vfo));
switch (vfo) {
case RIG_VFO_MAIN:
case RIG_VFO_SUB:
break;
default:
return -RIG_EINVAL;
}
priv->current_vfo = vfo;
return RIG_OK;
}
/*
* gp2000_get_freq
* Assumes rig!=NULL
*/
int
gp2000_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
char buf[RESPSZ];
int len, retval;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s\n", __func__, rig_strvfo(vfo));
#define FREQ_QUERY BOM "F?" EOM
retval =
gp2000_transaction(rig, FREQ_QUERY, strlen(FREQ_QUERY), buf, &len);
if (retval < 0)
{
return retval;
}
retval = (sscanf(buf, "%*cF%" SCNfreq, freq) == 1) ? RIG_OK : -RIG_EPROTO;
return retval;
}
/*
* barrett_get_level
*/
int barrett_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
int retval = 0;
char *response = NULL;
switch (level) {
case RIG_LEVEL_STRENGTH:
retval = barrett_transaction(rig, "IAL", 0, &response);
if (retval < 0) {
rig_debug(RIG_DEBUG_ERR, "%s: invalid response=%s\n", __FUNCTION__,
level);
return retval;
}
int strength;
int n = sscanf(response, "%2d", &strength);
if (n == 1) {
val->i = strength;
} else {
rig_debug(RIG_DEBUG_ERR, "%s: unable to parse STRENGHT from %s\n",
__FUNCTION__, response);
return -RIG_EPROTO;
}
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported level %d\n", __FUNCTION__, level);
return -RIG_EINVAL;
}
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s level=%d val=%d\n", __FUNCTION__,
rig_strvfo(vfo), level, *val);
return RIG_OK;
}
int
gp2000_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
{
char buf[32], *sfunc;
int len, retval;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s\n", __func__, rig_strvfo(vfo));
switch (func)
{
case RIG_FUNC_SQL:
sfunc = "SQ00";
break;
default:
return -RIG_EINVAL;
}
len = snprintf(buf, sizeof(buf), BOM "%s %s" EOM, sfunc, status ? "1" : "0");
retval = gp2000_transaction(rig, buf, len, NULL, NULL);
return retval;
}
