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); }