/*
* rs_set_mode
* Assumes rig!=NULL
*/
int rs_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
char buf[32], *smode;
int len, retval;
switch (mode) {
case RIG_MODE_AM: smode = "AM"; break;
case RIG_MODE_WFM:
case RIG_MODE_FM: smode = "FM"; break;
case RIG_MODE_CW: smode = "CW"; break;
case RIG_MODE_USB: smode = "USB"; break;
case RIG_MODE_LSB: smode = "LSB"; break;
default:
return -RIG_EINVAL;
}
len = sprintf(buf, BOM "DEM %s" EOM, smode);
retval = rs_transaction(rig, buf, len, NULL, NULL);
if (width == RIG_PASSBAND_NORMAL)
width = rig_passband_normal(rig, mode);
if (width > 0) {
len = sprintf(buf, BOM "BAND %d" EOM, (int) width);
retval = rs_transaction(rig, buf, len, NULL, NULL);
}
return retval;
}
/*
* sr2200_set_mode
* Assumes rig!=NULL
*/
int sr2200_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
char mdbuf[BUFSZ];
int mdbuf_len, aormode, retval;
pbwidth_t normal_width;
normal_width = rig_passband_normal(rig, mode);
if (width == RIG_PASSBAND_NORMAL)
width = normal_width;
switch (mode) {
case RIG_MODE_AM:
aormode = width > normal_width ?
SR2200_WAM : SR2200_AM;
break;
case RIG_MODE_FM:
aormode = width >= normal_width ?
SR2200_FM : SR2200_SFM;
break;
case RIG_MODE_WFM:
aormode = SR2200_WFM;
break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode %d\n",
__FUNCTION__,mode);
return -RIG_EINVAL;
}
mdbuf_len = sprintf(mdbuf, "MD%c" EOM, aormode);
retval = sr2200_transaction (rig, mdbuf, mdbuf_len, NULL, NULL);
return retval;
}
/*
* parse8k_aor_mode * don't care about aorwidth,
* because there's no such BW command
*/
int parse8k_aor_mode(RIG *rig, char aormode, char aorwidth, rmode_t *mode, pbwidth_t *width)
{
*width = RIG_PASSBAND_NORMAL;
switch (aormode) {
case AR8K_AM: *mode = RIG_MODE_AM; break;
case AR8K_NAM:
*mode = RIG_MODE_AM;
*width = rig_passband_narrow(rig, *mode);
break;
case AR8K_WAM:
*mode = RIG_MODE_AM;
*width = rig_passband_wide(rig, *mode);
break;
case AR8K_CW: *mode = RIG_MODE_CW; break;
case AR8K_USB: *mode = RIG_MODE_USB; break;
case AR8K_LSB: *mode = RIG_MODE_LSB; break;
case AR8K_WFM: *mode = RIG_MODE_WFM; break;
case AR8K_NFM: *mode = RIG_MODE_FM; break;
case AR8K_SFM:
*mode = RIG_MODE_FM;
*width = rig_passband_narrow(rig, *mode);
break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode '%c'\n",
__FUNCTION__, aormode);
return -RIG_EINVAL;
}
if (*width == RIG_PASSBAND_NORMAL)
*width = rig_passband_normal(rig, *mode);
return RIG_OK;
}
/*
* ar3k_get_mode
* Assumes rig!=NULL, mode!=NULL
*/
int ar3k_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
char *rfp;
int buf_len, retval;
char buf[BUFSZ];
/*
* #--J0WZ-----Y---------Q
* X R,S,T,U,V
*/
retval = ar3k_transaction (rig, "D" EOM, 3, buf, &buf_len);
if (retval != RIG_OK)
return retval;
rfp = strchr(buf, 'Y');
if (!rfp)
return -RIG_EPROTO;
rfp += 11;
switch (*rfp) {
case 'Q': *mode = RIG_MODE_FM; break;
case 'R': *mode = RIG_MODE_WFM; break;
case 'S': *mode = RIG_MODE_AM; break;
case 'T': *mode = RIG_MODE_LSB; break;
case 'U': *mode = RIG_MODE_USB; break;
case 'V': *mode = RIG_MODE_CW; break;
default:
rig_debug(RIG_DEBUG_ERR,"ar3k_get_mode: unsupported mode '%c'\n",
*rfp);
return -RIG_EPROTO;
}
*width = rig_passband_normal(rig, *mode);
return RIG_OK;
}
int icmarine_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
int retval;
char modebuf[BUFSZ];
retval = icmarine_transaction (rig, CMD_MODE, NULL, modebuf);
if (retval != RIG_OK)
return retval;
if (!memcmp(modebuf, MD_LSB, strlen(MD_LSB)))
*mode = RIG_MODE_LSB;
else if (!memcmp(modebuf, MD_USB, strlen(MD_USB)))
*mode = RIG_MODE_USB;
else if (!memcmp(modebuf, MD_CW, strlen(MD_CW)))
*mode = RIG_MODE_CW;
else if (!memcmp(modebuf, MD_AM, strlen(MD_AM)))
*mode = RIG_MODE_AM;
else if (!memcmp(modebuf, MD_FSK, strlen(MD_FSK)))
*mode = RIG_MODE_RTTY;
else
retval = -RIG_EPROTO;
if (retval == RIG_OK)
*width = rig_passband_normal(rig, *mode);
return retval;
}
bool rigControl::setMode(QString mode)
{
QString orgMode;
int i;
int pos=-1;
if(catParams.enableXMLRPC)
{
orgMode=xmlIntfPtr->getMode();
for(i=0;i<xmlModes.count();i++)
{
pos=orgMode.indexOf(xmlModes.at(i),Qt::CaseInsensitive);
if(pos>=0)
{
orgMode.replace(xmlModes.at(i),mode);
break;
}
}
if(pos>=0) xmlIntfPtr->setMode(orgMode);
}
else
{
rmode_t rmode=rig_parse_mode(mode.toLatin1().data());
int retcode;
if(!rigControlEnabled) return false;
retcode = rig_set_mode(my_rig, RIG_VFO_CURR, rmode, rig_passband_normal(my_rig,rmode));
if (retcode != RIG_OK ) {errorMessage(retcode,"setMode"); return false; }
}
return true;
}
/*
* racal_set_mode
* Assumes rig!=NULL
*/
int racal_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
struct racal_priv_data *priv = (struct racal_priv_data*)rig->state.priv;
int ra_mode;
char buf[BUFSZ];
switch (mode) {
case RIG_MODE_CW: ra_mode = (priv->bfo!=0) ? MD_MCW:MD_CW; break;
case RIG_MODE_USB: ra_mode = MD_USB; break;
case RIG_MODE_LSB: ra_mode = MD_LSB; break;
case RIG_MODE_AM: ra_mode = MD_AM; break;
case RIG_MODE_AMS: ra_mode = MD_ISB; break; /* TBC */
case RIG_MODE_FM: ra_mode = MD_FM; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported mode %d\n",
__FUNCTION__, mode);
return -RIG_EINVAL;
}
if (width == RIG_PASSBAND_NORMAL)
width = rig_passband_normal(rig, mode);
sprintf(buf, "D%dI%.0f", ra_mode, (double)(width/kHz(1)));
return racal_transaction (rig, buf, NULL, NULL);
}
int mode2rig(RIG *rig, rmode_t mode, pbwidth_t width)
{
int md;
/*
* translate mode from generic to frg100 specific
*/
switch(mode) {
case RIG_MODE_USB: md = MODE_USB; break;
case RIG_MODE_LSB: md = MODE_LSB; break;
case RIG_MODE_AM:
if (width != RIG_PASSBAND_NORMAL ||
width < rig_passband_normal(rig, mode))
md = MODE_AMN;
else
md = MODE_AMW;
break;
case RIG_MODE_FM:
if (width != RIG_PASSBAND_NORMAL ||
width < rig_passband_normal(rig, mode))
md = MODE_FMN;
else
md = MODE_FMW;
break;
case RIG_MODE_CW:
if (width != RIG_PASSBAND_NORMAL ||
width < rig_passband_normal(rig, mode))
md = MODE_CWN;
else
md = MODE_CWW;
break;
default:
return -RIG_EINVAL; /* sorry, wrong MODE */
}
return md;
}
int parse2700_aor_mode(RIG *rig, char aormode, char aorwidth, rmode_t *mode, pbwidth_t *width)
{
switch (aormode) {
case AR2700_NFM: *mode = RIG_MODE_FM; break;
case AR2700_WFM: *mode = RIG_MODE_WFM; break;
case AR2700_AM: *mode = RIG_MODE_AM; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode '%c'\n",
__FUNCTION__, aormode);
return -RIG_EPROTO;
}
*width = rig_passband_normal(rig, *mode);
return RIG_OK;
}
/*
* prm80_get_channel
* Assumes rig!=NULL
*/
int prm80_get_channel(RIG * rig, channel_t * chan)
{
char statebuf[BUFSZ];
int statebuf_len = BUFSZ;
int ret, chanstate;
if (chan->vfo == RIG_VFO_MEM) {
ret = prm80_set_mem(rig, RIG_VFO_CURR, chan->channel_num);
if (ret != RIG_OK)
return ret;
}
/* [E] = Show system state (Mode-Chan-Chanstate-Sql-Vol-Lock-RX freq-TX freq). */
ret = prm80_transaction (rig, "E", 1, statebuf, &statebuf_len);
if (ret != RIG_OK)
return ret;
if (statebuf_len < 20)
return -RIG_EPROTO;
/* Example: 1240080AFF0033F02D40 */
if (hhtoi(statebuf) != 0x12)
rig_debug(RIG_DEBUG_WARN, "%s: Unknown mode 0x%c%c\n",
__func__, statebuf[0], statebuf[1]);
chan->mode = RIG_MODE_FM;
chan->width = rig_passband_normal(rig, chan->mode);
chan->channel_num = hhtoi(statebuf+2);
chanstate = hhtoi(statebuf+4) & 0x0f;
/* is it rptr_shift or split mode ? */
chan->rptr_shift = (chanstate & 0x01) == 0 ? RIG_RPT_SHIFT_NONE :
chanstate & 0x02 ? RIG_RPT_SHIFT_MINUS :
chanstate & 0x04 ? RIG_RPT_SHIFT_PLUS : RIG_RPT_SHIFT_NONE;
chan->flags = chanstate & 0x08 ? RIG_CHFLAG_SKIP : 0;
chan->levels[LVL_SQL].f = ((float)(hhtoi(statebuf+6)>>4))/15.;
chan->levels[LVL_AF].f = ((float)(hhtoi(statebuf+8)>>4))/15.;
/* same as chanstate bit 1 */
chan->flags = hhtoi(statebuf+10) == 0 ? 0 : RIG_CHFLAG_SKIP;
chan->freq = ((hhtoi(statebuf+12)<<8) + hhtoi(statebuf+14)) * 12500;
chan->tx_freq = ((hhtoi(statebuf+16)<<8) + hhtoi(statebuf+18)) * 12500;
chan->rptr_offs = chan->tx_freq - chan->freq;
return RIG_OK;
}
int frg8800_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0x80};
unsigned char md;
rig_debug(RIG_DEBUG_TRACE,"frg8800: frg8800_set_mode called %x\n", mode);
/*
* translate mode from generic to frg8800 specific
*/
switch(mode) {
case RIG_MODE_AM:
md = MODE_SET_AM;
break;
case RIG_MODE_CW:
md = MODE_SET_CW;
break;
case RIG_MODE_USB:
md = MODE_SET_USB;
break;
case RIG_MODE_LSB:
md = MODE_SET_LSB;
break;
case RIG_MODE_FM:
md = MODE_SET_FM;
break;
case RIG_MODE_WFM:
md = MODE_SET_FMW;
break;
default:
return -RIG_EINVAL; /* sorry, wrong MODE */
}
if (width != RIG_PASSBAND_NOCHANGE
&& width != RIG_PASSBAND_NORMAL
&& width < rig_passband_normal(rig, mode)) {
md |= 0x08;
}
cmd[3] = md;
/* Mode set */
return write_block(&rig->state.rigport, (char *) cmd, YAESU_CMD_LENGTH);
}
/*
* rx340_set_mode
* Assumes rig!=NULL
*/
int rx340_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
struct rig_state *rs = &rig->state;
char dmode;
int mdbuf_len, retval;
char mdbuf[32];
switch (mode) {
case RIG_MODE_USB: dmode = RX340_USB; break;
case RIG_MODE_LSB: dmode = RX340_LSB; break;
case RIG_MODE_CW: dmode = RX340_CW; break;
case RIG_MODE_FM: dmode = RX340_FM; break;
case RIG_MODE_AM: dmode = RX340_AM; break;
case RIG_MODE_AMS: dmode = RX340_SAM; break;
case RIG_MODE_DSB: dmode = RX340_ISB; break;
default:
rig_debug(RIG_DEBUG_ERR,
"%s: unsupported mode %d\n",
__func__, mode);
return -RIG_EINVAL;
}
if (width != RIG_PASSBAND_NOCHANGE) {
if (width == RIG_PASSBAND_NORMAL)
width = rig_passband_normal(rig, mode);
/*
* Set DETECTION MODE and IF FILTER
*/
mdbuf_len = num_sprintf(mdbuf, "D%cI%.02f" EOM,
dmode, (float)width/1e3);
}
else {
/*
* Set DETECTION MODE
*/
mdbuf_len = num_sprintf(mdbuf, "D%c" EOM, dmode);
}
retval = write_block(&rs->rigport, mdbuf, mdbuf_len);
return retval;
}
/*
* ic10_get_mode
* Assumes rig!=NULL, !vfo
*/
int ic10_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
struct kenwood_priv_caps *priv = (struct kenwood_priv_caps *)rig->caps->priv;
char modebuf[50];
unsigned char c;
int retval, iflen;
/* query RX VFO */
retval = get_ic10_if (rig, modebuf);
if (retval != RIG_OK)
return retval;
/* trim extra spaces */
iflen = ic10_cmd_trim(modebuf, priv->if_len);
/* IFggmmmkkkhhh snnnzrx yytdfcp */
/* IFggmmmkkkhhhxxxxxrrrrrssxcctmfcp */
c = modebuf[iflen-4];
switch (c) {
case MD_CW : *mode = RIG_MODE_CW; break;
case MD_USB : *mode = RIG_MODE_USB; break;
case MD_LSB : *mode = RIG_MODE_LSB; break;
case MD_FM : *mode = RIG_MODE_FM; break;
case MD_AM : *mode = RIG_MODE_AM; break;
case MD_FSK : *mode = RIG_MODE_RTTY; break;
case MD_NONE: *mode = RIG_MODE_NONE; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode '%c'\n",
__func__, c);
return -RIG_EINVAL;
}
*width = rig_passband_normal(rig, *mode);
return RIG_OK;
}
int rig2mode(RIG *rig, int md, rmode_t *mode, pbwidth_t *width)
{
/*
* translate mode from frg100 specific to generic
*/
switch(md) {
case MODE_USB: *mode = RIG_MODE_USB; break;
case MODE_LSB: *mode = RIG_MODE_LSB; break;
case MODE_AMW:
case MODE_AMN: *mode = RIG_MODE_AM; break;
case MODE_FMW:
case MODE_FMN: *mode = RIG_MODE_FM; break;
case MODE_CWW:
case MODE_CWN: *mode = RIG_MODE_CW; break;
default:
return -RIG_EINVAL; /* sorry, wrong MODE */
}
if (md == MODE_CWN || md == MODE_AMN || md == MODE_FMN)
*width = rig_passband_narrow(rig, *mode);
else
*width = rig_passband_normal(rig, *mode);
return RIG_OK;
}
int ft100_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) {
unsigned char cmd_index; /* index of sequence to send */
unsigned char p_cmd[YAESU_CMD_LENGTH];
int ret;
rig_debug(RIG_DEBUG_VERBOSE,"ft100: generic mode = %x, width %d\n", mode, width);
switch(mode) {
case RIG_MODE_AM:
cmd_index = FT100_NATIVE_CAT_SET_MODE_AM;
break;
case RIG_MODE_CW:
cmd_index = FT100_NATIVE_CAT_SET_MODE_CW;
break;
case RIG_MODE_CWR:
cmd_index = FT100_NATIVE_CAT_SET_MODE_CWR;
break;
case RIG_MODE_USB:
cmd_index = FT100_NATIVE_CAT_SET_MODE_USB;
break;
case RIG_MODE_LSB:
cmd_index = FT100_NATIVE_CAT_SET_MODE_LSB;
break;
case RIG_MODE_FM:
cmd_index = FT100_NATIVE_CAT_SET_MODE_FM;
break;
case RIG_MODE_RTTY:
cmd_index = FT100_NATIVE_CAT_SET_MODE_DIG;
break;
case RIG_MODE_WFM:
cmd_index = FT100_NATIVE_CAT_SET_MODE_WFM;
break;
default:
return -RIG_EINVAL;
}
ret = ft100_send_priv_cmd(rig,cmd_index);
if (ret != RIG_OK)
return ret;
#if 1
if (mode != RIG_MODE_FM && mode != RIG_MODE_WFM && width <= kHz(6))
{
p_cmd[0] = 0x00;
p_cmd[1] = 0x00;
p_cmd[2] = 0x00;
p_cmd[3] = 0x00; /* to be filled in */
p_cmd[4] = 0x8C; /* Op: filter selection */
if (width == RIG_PASSBAND_NORMAL)
width = rig_passband_normal(rig, mode);
switch(width) {
case 2400:
p_cmd[3] = 0x00;
break;
case 6000:
p_cmd[3] = 0x01;
break;
case 500:
p_cmd[3] = 0x02;
break;
case 300:
p_cmd[3] = 0x03;
break;
default:
return -RIG_EINVAL;
};
ret = write_block(&rig->state.rigport, (char *) p_cmd, YAESU_CMD_LENGTH);
if (ret != RIG_OK)
return ret;
}
#endif
return RIG_OK;
}
/*
* gp2000_set_mode
* Assumes rig!=NULL
*/
int
gp2000_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
char buf[32], *smode;
int len, retval;
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s, mode=%s, width=%d\n", __func__,
rig_strvfo(vfo), rig_strvfo(mode), width);
switch (mode)
{
case RIG_MODE_AM:
smode = "1";
break;
case RIG_MODE_USB:
smode = "2";
break;
case RIG_MODE_LSB:
smode = "3";
break;
case RIG_MODE_CW:
smode = "5";
break;
case RIG_MODE_FM:
smode = "9";
break;
case RIG_MODE_PKTUSB:
smode = "13"; // use the 2700 bandwidth for packet
break;
case RIG_MODE_PKTLSB:
smode = "14"; // use the 2700 bandwidth for packet
break;
default:
return -RIG_EINVAL;
}
len = snprintf(buf, sizeof(buf), BOM "I%s" EOM, smode);
retval = gp2000_transaction(rig, buf, len, NULL, NULL);
if (retval < 0)
{
return retval;
}
if (width == RIG_PASSBAND_NOCHANGE)
{
return retval;
}
if (width == RIG_PASSBAND_NORMAL)
{
width = rig_passband_normal(rig, mode);
}
if (width > 0)
{
len = snprintf(buf, sizeof(buf), BOM "W%d" EOM, (int) width);
retval = gp2000_transaction(rig, buf, len, NULL, NULL);
}
return retval;
}
int ft847_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) {
unsigned char cmd_index; /* index of sequence to send */
struct rig_state *rs = &rig->state;
unsigned char p_cmd[YAESU_CMD_LENGTH]; /* sequence to send */
int ret;
/*
* translate mode from generic to ft847 specific
*/
rig_debug(RIG_DEBUG_VERBOSE,"ft847: generic mode = %x \n", mode);
switch(mode) {
case RIG_MODE_AM:
cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_AM;
break;
case RIG_MODE_CW:
cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_CW;
break;
case RIG_MODE_CWR:
cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_CWR;
break;
case RIG_MODE_USB:
cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_USB;
break;
case RIG_MODE_LSB:
cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_LSB;
break;
case RIG_MODE_FM:
cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_FM;
break;
default:
return -RIG_EINVAL; /* sorry, wrong MODE */
}
/*
* Now set width
*/
if (width != RIG_PASSBAND_NOCHANGE) {
if (width == rig_passband_narrow(rig, mode)) {
switch(mode) {
case RIG_MODE_AM:
cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_AMN;
break;
case RIG_MODE_FM:
cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_FMN;
break;
case RIG_MODE_CW:
cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_CWN;
break;
case RIG_MODE_CWR:
cmd_index = FT_847_NATIVE_CAT_SET_MODE_MAIN_CWRN;
break;
case RIG_MODE_USB:
case RIG_MODE_LSB:
break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode/width: %s/%d, narrow: %d\n",
__FUNCTION__, rig_strrmode(mode), width,
rig_passband_narrow(rig, mode));
return -RIG_EINVAL; /* sorry, wrong MODE/WIDTH combo */
}
} else {
if (width != RIG_PASSBAND_NORMAL &&
width != rig_passband_normal(rig, mode)) {
return -RIG_EINVAL; /* sorry, wrong MODE/WIDTH combo */
}
}
}
/*
* Now send the command
*/
ret = opcode_vfo(rig, p_cmd, cmd_index, vfo);
if (ret != RIG_OK)
return ret;
return write_block(&rs->rigport, (char*)p_cmd, YAESU_CMD_LENGTH);
}
static int get_freq_and_mode(RIG *rig, vfo_t vfo, freq_t *freq, rmode_t *mode,
pbwidth_t *width) {
struct rig_state *rs = &rig->state;
unsigned char p_cmd[YAESU_CMD_LENGTH]; /* sequence to send */
unsigned char cmd_index; /* index of sequence to send */
unsigned char data[8];
int n;
rig_debug(RIG_DEBUG_VERBOSE,"ft847: %s vfo =%s \n",
__func__, rig_strvfo(vfo));
cmd_index = FT_847_NATIVE_CAT_GET_FREQ_MODE_STATUS_MAIN;
memcpy(p_cmd,&ncmd[cmd_index].nseq,YAESU_CMD_LENGTH);
/* change opcode according to vfo */
n = opcode_vfo(rig, p_cmd, cmd_index, vfo);
if (n != RIG_OK)
return n;
n = write_block(&rs->rigport, (char *) p_cmd, YAESU_CMD_LENGTH);
if (n < 0)
return n;
n = read_block(&rs->rigport, (char *) data, YAESU_CMD_LENGTH);
if (n != YAESU_CMD_LENGTH) {
rig_debug(RIG_DEBUG_ERR,"ft847: read_block returned %d\n", n);
return n < 0 ? n : -RIG_EPROTO;
}
/* Remember, this is 10Hz resolution */
*freq = 10*from_bcd_be(data, 8);
*width = RIG_PASSBAND_NORMAL;
switch (data[4]) {
case MD_LSB: *mode = RIG_MODE_LSB; break;
case MD_USB: *mode = RIG_MODE_USB; break;
case MD_CWN:
*width = rig_passband_narrow(rig, RIG_MODE_CW);
case MD_CW:
*mode = RIG_MODE_CW;
break;
case MD_CWNR:
*width = rig_passband_narrow(rig, RIG_MODE_CW);
case MD_CWR:
*mode = RIG_MODE_CWR;
break;
case MD_AMN:
*width = rig_passband_narrow(rig, RIG_MODE_AM);
case MD_AM:
*mode = RIG_MODE_AM;
break;
case MD_FMN:
*width = rig_passband_narrow(rig, RIG_MODE_FM);
case MD_FM:
*mode = RIG_MODE_FM;
break;
default:
*mode = RIG_MODE_NONE;
rig_debug(RIG_DEBUG_VERBOSE,"ft847: Unknown mode %02x\n", data[4]);
}
if (*width == RIG_PASSBAND_NORMAL)
*width = rig_passband_normal(rig, *mode);
return RIG_OK;
}
int k3_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
if (!rig)
return -RIG_EINVAL;
int err;
char cmd_s[16];
switch (mode) {
case RIG_MODE_PKTLSB:
mode = RIG_MODE_RTTYR;
strncpy(cmd_s, "DT0", 5);
break;
case RIG_MODE_PKTUSB:
mode = RIG_MODE_RTTY;
strncpy(cmd_s, "DT0", 5);
break;
case RIG_MODE_RTTY:
case RIG_MODE_RTTYR:
strncpy(cmd_s, "DT1", 5);
break;
default:
break;
}
/* kenwood_set_mode() ignores width value for K2/K3/TS-570 */
err = kenwood_set_mode(rig, vfo, mode, width);
if (err != RIG_OK)
return err;
/* Now set data sub-mode. K3 needs to be in a DATA mode before setting
* the sub-mode.
*/
if (mode == RIG_MODE_PKTLSB || mode == RIG_MODE_PKTUSB
|| mode == RIG_MODE_RTTY || mode == RIG_MODE_RTTYR) {
err = kenwood_simple_cmd(rig, cmd_s);
if (err != RIG_OK)
return err;
}
/* and set the requested bandwidth. On my K3, the bandwidth is rounded
* down to the nearest 50 Hz, i.e. sending BW0239; will cause the bandwidth
* to be set to 2.350 kHz. As the width must be divided by 10, 10 Hz values
* between 0 and 4 round down to the nearest 100 Hz and values between 5
* and 9 round down to the nearest 50 Hz.
*
* width string value must be padded with leading '0' to equal four
* characters.
*/
/* passband widths vary by mode so gather lower and upper limits */
pbwidth_t pb_nar = rig_passband_narrow(rig, mode);
pbwidth_t pb_wid = rig_passband_wide(rig, mode);
if (width < 0)
width = labs(width);
if (width == RIG_PASSBAND_NORMAL)
width = rig_passband_normal(rig, mode);
else if (width < pb_nar)
width = pb_nar;
else if (width > pb_wid)
width = pb_wid;
sprintf(cmd_s, "BW%04ld", width / 10);
err = kenwood_simple_cmd(rig, cmd_s);
if (err != RIG_OK)
return err;
return RIG_OK;
}
int ic10_get_channel(RIG *rig, channel_t *chan)
{
char membuf[16],infobuf[32];
int retval,info_len,len;
len = sprintf(membuf,"MR0 %02d;",chan->channel_num);
info_len = 24;
retval = ic10_transaction(rig, membuf, len, infobuf, &info_len);
if (retval != RIG_OK && info_len > 17)
return retval;
/* MRn rrggmmmkkkhhhdz ; */
switch (infobuf[17]) {
case MD_CW : chan->mode = RIG_MODE_CW; break;
case MD_USB : chan->mode = RIG_MODE_USB; break;
case MD_LSB : chan->mode = RIG_MODE_LSB; break;
case MD_FM : chan->mode = RIG_MODE_FM; break;
case MD_AM : chan->mode = RIG_MODE_AM; break;
case MD_FSK : chan->mode = RIG_MODE_RTTY; break;
case MD_NONE: chan->mode = RIG_MODE_NONE; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode '%c'\n",
__func__,infobuf[17]);
return -RIG_EINVAL;
}
chan->width = rig_passband_normal(rig, chan->mode);
/* infobuf[17] = ' '; */
infobuf[17] = '\0';
sscanf(infobuf+6, "%011"SCNfreq, &chan->freq);
chan->vfo=RIG_VFO_MEM;
/* TX VFO (Split channel only) */
len = sprintf(membuf,"MR1 %02d;",chan->channel_num);
info_len = 24;
retval = ic10_transaction(rig, membuf, len, infobuf, &info_len);
if (retval == RIG_OK && info_len > 17) {
/* MRn rrggmmmkkkhhhdz ; */
switch (infobuf[17]) {
case MD_CW : chan->tx_mode = RIG_MODE_CW; break;
case MD_USB : chan->tx_mode = RIG_MODE_USB; break;
case MD_LSB : chan->tx_mode = RIG_MODE_LSB; break;
case MD_FM : chan->tx_mode = RIG_MODE_FM; break;
case MD_AM : chan->tx_mode = RIG_MODE_AM; break;
case MD_FSK : chan->tx_mode = RIG_MODE_RTTY; break;
case MD_NONE: chan->tx_mode = RIG_MODE_NONE; break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: unsupported mode '%c'\n",
__func__,infobuf[17]);
return -RIG_EINVAL;
}
chan->tx_width = rig_passband_normal(rig, chan->tx_mode);
/* infobuf[17] = ' '; */
infobuf[17] = '\0';
sscanf(infobuf+6, "%011"SCNfreq, &chan->tx_freq);
}
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;
}
/*
* tentec_set_mode
* Assumes rig!=NULL
*/
int tentec_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
struct tentec_priv_data *priv = (struct tentec_priv_data *)rig->state.priv;
struct rig_state *rs = &rig->state;
char ttmode;
rmode_t saved_mode;
pbwidth_t saved_width;
int mdbuf_len, ttfilter, retval;
char mdbuf[32];
switch (mode) {
case RIG_MODE_USB: ttmode = TT_USB; break;
case RIG_MODE_LSB: ttmode = TT_LSB; break;
case RIG_MODE_CW: ttmode = TT_CW; break;
case RIG_MODE_AM: ttmode = TT_AM; break;
case RIG_MODE_FM: ttmode = TT_FM; break;
default:
rig_debug(RIG_DEBUG_ERR,
"tentec_set_mode: unsupported mode %d\n",
mode);
return -RIG_EINVAL;
}
/* backup current values
* in case we fail to write to port
*/
saved_mode = priv->mode;
saved_width = priv->width;
if (width != RIG_PASSBAND_NOCHANGE) {
if (width == RIG_PASSBAND_NORMAL)
width = rig_passband_normal(rig, mode);
for (ttfilter=0; tentec_filters[ttfilter] != 0; ttfilter++) {
if (tentec_filters[ttfilter] == width)
break;
}
if (tentec_filters[ttfilter] != width) {
rig_debug(RIG_DEBUG_ERR,
"tentec_set_mode: unsupported width %d\n",
width);
return -RIG_EINVAL;
}
priv->width = width;
}
priv->mode = mode;
tentec_tuning_factor_calc(rig);
if (width != RIG_PASSBAND_NOCHANGE) {
mdbuf_len = sprintf(mdbuf, "W%c" EOM
"N%c%c%c%c%c%c" EOM
"M%c" EOM,
ttfilter,
priv->ctf >> 8, priv->ctf & 0xff,
priv->ftf >> 8, priv->ftf & 0xff,
priv->btf >> 8, priv->btf & 0xff,
ttmode);
retval = write_block(&rs->rigport, mdbuf, mdbuf_len);
if (retval != RIG_OK) {
priv->mode = saved_mode;
priv->width = saved_width;
return retval;
}
}
int main(int argc, char *argv[])
{
RIG *my_rig; /* handle to rig (nstance) */
freq_t freq; /* frequency */
rmode_t rmode; /* radio mode of operation */
pbwidth_t width;
vfo_t vfo; /* vfo selection */
int strength; /* S-Meter level */
int rit = 0; /* RIT status */
int xit = 0; /* XIT status */
int retcode; /* generic return code from functions */
rig_model_t myrig_model;
printf("testrig: Hello, I am your main() !\n");
/* Turn off backend debugging ouput */
rig_set_debug_level(RIG_DEBUG_NONE);
/*
* allocate memory, setup & open port
*/
if (argc < 2)
{
hamlib_port_t myport;
/* may be overriden by backend probe */
myport.type.rig = RIG_PORT_SERIAL;
myport.parm.serial.rate = 9600;
myport.parm.serial.data_bits = 8;
myport.parm.serial.stop_bits = 1;
myport.parm.serial.parity = RIG_PARITY_NONE;
myport.parm.serial.handshake = RIG_HANDSHAKE_NONE;
strncpy(myport.pathname, SERIAL_PORT, FILPATHLEN - 1);
rig_load_all_backends();
myrig_model = rig_probe(&myport);
}
else
{
myrig_model = atoi(argv[1]);
}
my_rig = rig_init(myrig_model);
if (!my_rig)
{
fprintf(stderr, "Unknown rig num: %d\n", myrig_model);
fprintf(stderr, "Please check riglist.h\n");
exit(1); /* whoops! something went wrong (mem alloc?) */
}
strncpy(my_rig->state.rigport.pathname, SERIAL_PORT, FILPATHLEN - 1);
retcode = rig_open(my_rig);
if (retcode != RIG_OK)
{
printf("rig_open: error = %s\n", rigerror(retcode));
exit(2);
}
printf("Port %s opened ok\n", SERIAL_PORT);
/*
* Below are examples of set/get routines.
* Must add checking of functionality map prior to command execution -- FS
*
*/
/*
* Example of setting rig paameters
* and some error checking on the return code.
*/
retcode = rig_set_vfo(my_rig, RIG_VFO_B);
if (retcode != RIG_OK)
{
printf("rig_set_vfo: error = %s \n", rigerror(retcode));
}
/*
* Lets try some frequencies and modes. Return code is not checked.
* Examples of checking return code are further down.
*
*/
/* 10m FM Narrow */
printf("\nSetting 10m FM Narrow...\n");
retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 29620000); /* 10m */
retcode = rig_set_mode(my_rig, RIG_VFO_CURR, RIG_MODE_FM,
rig_passband_narrow(my_rig, RIG_MODE_FM));
if (retcode != RIG_OK)
{
printf("rig_set_freq: error = %s \n", rigerror(retcode));
}
rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);
printf(" Freq: %.6f MHz, Mode: %s, Passband: %.3f kHz\n\n",
freq / 1000000,
rig_strrmode(rmode),
width / 1000.0);
sleep(1); /* so you can see it -- FS */
/* 15m USB */
printf("Setting 15m USB...\n");
retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 21235175); /* 15m */
retcode = rig_set_mode(my_rig,
RIG_VFO_CURR,
RIG_MODE_USB,
rig_passband_normal(my_rig, RIG_MODE_USB));
if (retcode != RIG_OK)
{
printf("rig_set_freq: error = %s \n", rigerror(retcode));
}
rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);
printf(" Freq: %.6f MHz, Mode: %s, Passband: %.3f kHz\n\n",
freq / 1000000, rig_strrmode(rmode), width / 1000.0);
sleep(1);
/* 40m LSB */
printf("Setting 40m LSB...\n");
retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 7250100); /* 40m */
retcode = rig_set_mode(my_rig,
RIG_VFO_CURR,
RIG_MODE_LSB,
RIG_PASSBAND_NORMAL);
if (retcode != RIG_OK)
{
printf("rig_set_freq: error = %s \n", rigerror(retcode));
}
rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);
printf(" Freq: %.6f MHz, Mode: %s, Passband: %.3f kHz\n\n",
freq / 1000000,
rig_strrmode(rmode),
width / 1000.0);
sleep(1);
/* 80m AM Narrow */
printf("Setting 80m AM Narrow...\n");
retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 3885000); /* 80m */
retcode = rig_set_mode(my_rig,
RIG_VFO_CURR,
RIG_MODE_AM,
rig_passband_narrow(my_rig, RIG_MODE_AM));
if (retcode != RIG_OK)
{
printf("rig_set_freq: error = %s \n", rigerror(retcode));
}
rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);
printf(" Freq: %.6f MHz, Mode: %s, Passband: %.3f kHz\n\n",
freq / 1000000,
rig_strrmode(rmode),
width / 1000.0);
sleep(1);
/* 160m CW Normal */
printf("Setting 160m CW...\n");
retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 1875000); /* 160m */
retcode = rig_set_mode(my_rig,
RIG_VFO_CURR,
RIG_MODE_CW,
RIG_PASSBAND_NORMAL);
if (retcode != RIG_OK)
{
printf("rig_set_freq: error = %s \n", rigerror(retcode));
}
rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);
printf(" Freq: %.3f kHz, Mode: %s, Passband: %li Hz\n\n",
freq / 1000,
rig_strrmode(rmode),
width);
sleep(1);
/* 160m CW Narrow -- The band is noisy tonight -- FS*/
printf("Setting 160m CW Narrow...\n");
retcode = rig_set_mode(my_rig,
RIG_VFO_CURR,
RIG_MODE_CW,
rig_passband_narrow(my_rig, RIG_MODE_CW));
if (retcode != RIG_OK)
{
printf("rig_set_freq: error = %s \n", rigerror(retcode));
}
rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);
printf(" Freq: %.3f kHz, Mode: %s, Passband: %li Hz\n\n",
freq / 1000,
rig_strrmode(rmode),
width);
sleep(1);
/* AM Broadcast band */
printf("Setting Medium Wave AM...\n");
retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 770000); /* KAAM */
retcode = rig_set_mode(my_rig,
RIG_VFO_CURR,
RIG_MODE_AM,
RIG_PASSBAND_NORMAL);
if (retcode != RIG_OK)
{
printf("rig_set_freq: error = %s \n", rigerror(retcode));
}
rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);
printf(" Freq: %.3f kHz, Mode: %s, Passband: %.3f kHz\n\n",
freq / 1000,
rig_strrmode(rmode),
width / 1000.0);
sleep(1);
/* 20m USB on VFO_A */
printf("Setting 20m on VFO A with two functions...\n");
retcode = rig_set_vfo(my_rig, RIG_VFO_A);
retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 14250375); /* cq de vk3fcs */
if (retcode != RIG_OK)
{
printf("rig_set_freq: error = %s \n", rigerror(retcode));
}
rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
rig_get_vfo(my_rig, &vfo);
printf(" Freq: %.6f MHz, VFO: %s\n\n", freq / 1000000, rig_strvfo(vfo));
sleep(1);
/* 20m USB on VFO_A , with only 1 call */
printf("Setting 20m on VFO A with one function...\n");
retcode = rig_set_freq(my_rig, RIG_VFO_A, 14295125); /* cq de vk3fcs */
if (retcode != RIG_OK)
{
printf("rig_set_freq: error = %s \n", rigerror(retcode));
}
rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
rig_get_vfo(my_rig, &vfo);
printf(" Freq: %.6f MHz, VFO: %s\n\n", freq / 1000000, rig_strvfo(vfo));
sleep(1);
#if 0
retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 145100000); /* 2m */
sleep(2);
retcode = rig_set_freq(my_rig, RIG_VFO_CURR, 435125000); /* 70cm */
sleep(2);
#endif
printf("Setting rig Mode to LSB.\n");
retcode = rig_set_mode(my_rig,
RIG_VFO_CURR,
RIG_MODE_LSB,
RIG_PASSBAND_NORMAL);
if (retcode != RIG_OK)
{
printf("rig_set_mode: error = %s \n", rigerror(retcode));
}
sleep(1);
printf("Setting rig PTT ON.\n");
retcode = rig_set_ptt(my_rig, RIG_VFO_A, RIG_PTT_ON); /* stand back ! */
if (retcode != RIG_OK)
{
printf("rig_set_ptt: error = %s \n", rigerror(retcode));
}
sleep(1);
printf("Setting rig PTT OFF.\n");
retcode = rig_set_ptt(my_rig, RIG_VFO_A, RIG_PTT_OFF); /* phew ! */
if (retcode != RIG_OK)
{
printf("rig_set_ptt: error = %s \n", rigerror(retcode));
}
sleep(1);
/*
* Simple examples of getting rig information -- FS
*
*/
printf("\nGet various raw rig values:\n");
retcode = rig_get_vfo(my_rig, &vfo); /* try to get vfo info */
if (retcode == RIG_OK)
{
printf("rig_get_vfo: vfo = %i \n", vfo);
}
else
{
printf("rig_get_vfo: error = %s \n", rigerror(retcode));
}
retcode = rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
if (retcode == RIG_OK)
{
printf("rig_get_freq: freq = %"PRIfreq"\n", freq);
}
else
{
printf("rig_get_freq: error = %s \n", rigerror(retcode));
}
retcode = rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);
if (retcode == RIG_OK)
{
printf("rig_get_mode: mode = %"PRIll"\n", rmode);
}
else
{
printf("rig_get_mode: error = %s \n", rigerror(retcode));
}
retcode = rig_get_strength(my_rig, RIG_VFO_CURR, &strength);
if (retcode == RIG_OK)
{
printf("rig_get_strength: strength = %i \n", strength);
}
else
{
printf("rig_get_strength: error = %s \n", rigerror(retcode));
}
if (rig_has_set_func(my_rig, RIG_FUNC_RIT))
{
retcode = rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_RIT, 1);
printf("rig_set_func: Setting RIT ON\n");
}
if (rig_has_get_func(my_rig, RIG_FUNC_RIT))
{
retcode = rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_RIT, &rit);
printf("rig_get_func: RIT: %d\n", rit);
}
if (rig_has_set_func(my_rig, RIG_FUNC_XIT))
{
retcode = rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_XIT, 1);
printf("rig_set_func: Setting XIT ON\n");
}
if (rig_has_get_func(my_rig, RIG_FUNC_XIT))
{
retcode = rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_XIT, &xit);
printf("rig_get_func: XIT: %d\n", xit);
}
rig_close(my_rig); /* close port */
rig_cleanup(my_rig); /* if you care about memory */
printf("port %s closed ok \n", SERIAL_PORT);
return 0;
}
/*
* drake_set_mode
* Assumes rig!=NULL
*/
int drake_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
unsigned char mdbuf[16], ackbuf[16];
unsigned char mode_sel, width_sel;
int mdbuf_len, ack_len, retval;
switch (mode) {
case RIG_MODE_CW: mode_sel = MD_CW; break;
case RIG_MODE_ECSSUSB:
case RIG_MODE_USB: mode_sel = MD_USB; break;
case RIG_MODE_ECSSLSB:
case RIG_MODE_LSB: mode_sel = MD_LSB; break;
case RIG_MODE_FM: mode_sel = MD_FM; break;
case RIG_MODE_AMS:
case RIG_MODE_AM: mode_sel = MD_AM; break;
case RIG_MODE_RTTY: mode_sel = MD_RTTY; break;
default:
rig_debug(RIG_DEBUG_ERR, "drake_set_mode: "
"unsupported mode %d\n", mode);
return -RIG_EINVAL;
}
mdbuf_len = sprintf((char *) mdbuf, "M%c" EOM, mode_sel);
retval = drake_transaction(rig, (char *) mdbuf, mdbuf_len, (char *) ackbuf, &ack_len);
if (retval != RIG_OK)
return retval;
if (mode != RIG_MODE_FM) {
if (width == RIG_PASSBAND_NORMAL)
width = rig_passband_normal(rig, mode);
switch (width) {
case 500: width_sel = '0'; break;
case 1800: width_sel = '1'; break;
case 2300: width_sel = '2'; break;
case 4000: width_sel = '4'; break;
case 6000: width_sel = '6'; break;
default:
rig_debug(RIG_DEBUG_ERR, "drake_set_mode: "
"unsupported width %d\n", width);
return -RIG_EINVAL;
}
mdbuf_len = sprintf((char *) mdbuf, "W%c" EOM, width_sel);
retval = drake_transaction(rig, (char *) mdbuf, mdbuf_len, (char *) ackbuf, &ack_len);
}
if ((mode == RIG_MODE_AMS) || (mode == RIG_MODE_ECSSUSB) || (mode == RIG_MODE_ECSSLSB) ||
(mode == RIG_MODE_AM) || (mode == RIG_MODE_USB) || (mode == RIG_MODE_LSB)) {
mdbuf_len = sprintf((char *) mdbuf, "S%c" EOM,
((mode == RIG_MODE_AMS) || (mode == RIG_MODE_ECSSUSB) || (mode == RIG_MODE_ECSSLSB))
? 'O' : 'F');
retval = drake_transaction(rig, (char *) mdbuf, mdbuf_len, (char *) ackbuf, &ack_len);
}
return retval;
}
int
pcr_set_mode(RIG * rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
struct pcr_priv_data *priv = (struct pcr_priv_data *) rig->state.priv;
struct pcr_rcvr *rcvr = is_sub_rcvr(rig, vfo) ? &priv->sub_rcvr : &priv->main_rcvr;
unsigned char buf[20];
int buf_len, err;
int pcrmode, pcrfilter;
rig_debug(RIG_DEBUG_VERBOSE, "%s: mode = %d (%s), width = %d\n",
__func__, mode, rig_strrmode(mode), width);
/* XXX? */
if (mode == RIG_MODE_NONE)
mode = RIG_MODE_FM;
/*
* not so sure about modes and filters
* as I write this from manual (no testing) --SF
*/
switch (mode) {
case RIG_MODE_CW:
pcrmode = MD_CW;
break;
case RIG_MODE_USB:
pcrmode = MD_USB;
break;
case RIG_MODE_LSB:
pcrmode = MD_LSB;
break;
case RIG_MODE_AM:
pcrmode = MD_AM;
break;
case RIG_MODE_WFM:
pcrmode = MD_WFM;
break;
case RIG_MODE_FM:
pcrmode = MD_FM;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported mode %d\n",
__func__, mode);
return -RIG_EINVAL;
}
if (width == RIG_PASSBAND_NORMAL)
width = rig_passband_normal(rig, mode);
rig_debug(RIG_DEBUG_VERBOSE, "%s: will set to %d\n",
__func__, width);
switch (width) {
/* nop, pcrfilter already set
* TODO: use rig_passband_normal instead?
*/
case s_kHz(2.8):
pcrfilter = FLT_2_8kHz;
break;
case s_kHz(6):
pcrfilter = FLT_6kHz;
break;
case s_kHz(15):
pcrfilter = FLT_15kHz;
break;
case s_kHz(50):
pcrfilter = FLT_50kHz;
break;
case s_kHz(230):
pcrfilter = FLT_230kHz;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported width %d\n",
__func__, width);
return -RIG_EINVAL;
}
rig_debug(RIG_DEBUG_VERBOSE, "%s: filter set to %d (%c)\n",
__func__, width, pcrfilter);
buf_len = sprintf((char *) buf, "K%c%010" PRIll "0%c0%c00",
is_sub_rcvr(rig, vfo) ? '1':'0',
(int64_t) rcvr->last_freq, pcrmode, pcrfilter);
if (buf_len < 0)
return -RIG_ETRUNC;
err = pcr_transaction(rig, (char *) buf);
if (err != RIG_OK)
return err;
rig_debug(RIG_DEBUG_VERBOSE, "%s: saving values\n",
__func__);
rcvr->last_mode = pcrmode;
rcvr->last_filter = pcrfilter;
return RIG_OK;
}
