/* * 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; }