/* --------------------------------------------------------------------- */ 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 racal_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) { char resbuf[BUFSZ], *p; int retval, len; double f; retval = racal_transaction (rig, "TDI", resbuf, &len); if (retval < RIG_OK) return retval; p = strchr(resbuf, 'I'); if (len < 3 || resbuf[0] != 'D' || !p) return -RIG_EPROTO; switch (resbuf[1]-'0') { case MD_MCW: case MD_CW: *mode = RIG_MODE_CW; break; case MD_LSB: *mode = RIG_MODE_LSB; break; case MD_USB: *mode = RIG_MODE_USB; break; case MD_ISB: *mode = RIG_MODE_AMS; break; /* TBC */ case MD_FM: *mode = RIG_MODE_FM; break; case MD_AM: *mode = RIG_MODE_AM; break; default: rig_debug(RIG_DEBUG_ERR, "%s: unsupported mode %d\n", __FUNCTION__, mode); return -RIG_EPROTO; } sscanf(p+1, "%lf", &f); *width = (pbwidth_t)(f * kHz(1)); return RIG_OK; }
/* * ar3k_set_ts * Assumes rig!=NULL */ int ar3k_set_ts(RIG *rig, vfo_t vfo, shortfreq_t ts) { char freqbuf[BUFSZ]; int freq_len, retval; int lowhz; /* * actually, frequency must be like nnn.nm, * where m must be 0 or 5 (for 50Hz). */ lowhz = ts % 100; ts /= 100; if (lowhz < 25) lowhz = 0; else if (lowhz < 75) lowhz = 50; else lowhz = 100; ts = ts*100 + lowhz; freq_len = sprintf(freqbuf,"%03.2fS" EOM, ((double)ts)/kHz(1)); retval = ar3k_transaction (rig, freqbuf, freq_len, NULL, NULL); if (retval != RIG_OK) return retval; return RIG_OK; }
/* * tentec_init: * Basically, it just sets up *priv */ int tentec_init(RIG *rig) { struct tentec_priv_data *priv; priv = (struct tentec_priv_data*)malloc(sizeof(struct tentec_priv_data)); if (!priv) { /* whoops! memory shortage! */ return -RIG_ENOMEM; } memset(priv, 0, sizeof(struct tentec_priv_data)); /* * set arbitrary initial status */ priv->freq = MHz(10); priv->mode = RIG_MODE_AM; priv->width = kHz(6); priv->pbt = 0; priv->cwbfo = 1000; priv->agc = RIG_AGC_MEDIUM; /* medium */ priv->lnvol = priv->spkvol = 0.0; /* mute */ rig->state.priv = (rig_ptr_t)priv; /* tentec_tuning_factor_calc needs rig->state.priv */ tentec_tuning_factor_calc(rig); return RIG_OK; }
/* * racal_get_level * Assumes rig!=NULL */ int racal_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) { struct racal_priv_data *priv = (struct racal_priv_data*)rig->state.priv; char resbuf[BUFSZ]; int retval, len, att; double f; switch (level) { case RIG_LEVEL_RF: /* Manually set threshold */ retval = racal_transaction (rig, "TA", resbuf, &len); if (retval < RIG_OK) return retval; if (len < 2 || resbuf[0] != 'A') return -RIG_EPROTO; sscanf(resbuf+1, "%d", &att); val->f = priv->threshold = (float)att/120; break; case RIG_LEVEL_IF: retval = racal_transaction (rig, "TB", resbuf, &len); if (retval < RIG_OK) return retval; if (len < 2 || resbuf[0] != 'B') return -RIG_EPROTO; sscanf(resbuf+1, "%lf", &f); val->i = priv->bfo = (shortfreq_t)(f * kHz(1)); break; case RIG_LEVEL_AGC: retval = racal_transaction (rig, "TM", resbuf, &len); if (retval < RIG_OK) return retval; if (len < 2 || resbuf[0] != 'M') return -RIG_EPROTO; switch (resbuf[1]-'0') { case 1: case 5: val->i = RIG_AGC_FAST; break; case 2: case 6: val->i = RIG_AGC_MEDIUM; break; case 3: case 7: val->i = RIG_AGC_SLOW; break; case 4: val->i = RIG_AGC_USER; break; default: return -RIG_EINVAL; } break; default: rig_debug(RIG_DEBUG_ERR,"%s: Unsupported %d\n", __FUNCTION__, level); return -RIG_EINVAL; } return RIG_OK; }
/* * 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); }
/* * racal_set_level * Assumes rig!=NULL */ int racal_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) { struct racal_priv_data *priv = (struct racal_priv_data*)rig->state.priv; char cmdbuf[BUFSZ]; int agc; switch (level) { case RIG_LEVEL_RF: /* Manually set threshold */ sprintf(cmdbuf, "A%d", (int)(val.f*120)); priv->threshold = val.f; break; case RIG_LEVEL_IF: sprintf(cmdbuf, "B%+0g", ((double)val.i)/kHz(1)); priv->bfo = val.i; break; case RIG_LEVEL_AGC: switch (val.i) { case RIG_AGC_FAST: agc = 1; break; case RIG_AGC_MEDIUM: agc = 2; break; case RIG_AGC_SLOW: agc = 3; break; case RIG_AGC_USER: agc = 4; break; default: return -RIG_EINVAL; } if (priv->threshold != 0 && agc != 4) agc += 4; /* with manually set threshold */ sprintf(cmdbuf, "M%d", agc); break; default: rig_debug(RIG_DEBUG_ERR,"%s: unsupported %d\n", __FUNCTION__, level); return -RIG_EINVAL; } return racal_transaction (rig, cmdbuf, NULL, NULL); }
.tx_range_list1 = { RIG_FRNG_END, }, .rx_range_list2 = { {MHz(25),MHz(512),BCD996T_MODES,-1,-1,BCD996T_VFO}, {MHz(764),MHz(776),BCD996T_MODES,-1,-1,BCD996T_VFO}, {MHz(794),MHz(956),BCD996T_MODES,-1,-1,BCD996T_VFO}, {MHz(1240),MHz(1300),BCD996T_MODES,-1,-1,BCD996T_VFO}, /* TBC */ RIG_FRNG_END, }, .tx_range_list2 = { RIG_FRNG_END, }, .tuning_steps = { {BCD996T_MODES,10}, /* FIXME: add other ts */ RIG_TS_END, }, /* mode/filter list, remember: order matters! */ .filters = { {RIG_MODE_AM|RIG_MODE_FM, kHz(8)}, {RIG_MODE_WFM, kHz(230)}, RIG_FLT_END, }, .get_info = uniden_digital_get_info, .set_freq = uniden_digital_set_freq, .get_freq = uniden_digital_get_freq, }; /* * Function definitions below */
.rx_range_list1 = { { MHz(25),MHz(520),OS456_MODES,-1,-1,OS456_VFO_ALL}, { MHz(760),MHz(1300),OS456_MODES,-1,-1,OS456_VFO_ALL}, RIG_FRNG_END, }, .tx_range_list1 = { RIG_FRNG_END, }, /* this is a scanner */ .rx_range_list2 = { { MHz(25),MHz(520),OS456_MODES,-1,-1,OS456_VFO_ALL}, { MHz(760),MHz(823.995),OS456_MODES,-1,-1,OS456_VFO_ALL}, { MHz(849),MHz(868.995),OS456_MODES,-1,-1,OS456_VFO_ALL}, { MHz(894),MHz(1300),OS456_MODES,-1,-1,OS456_VFO_ALL}, RIG_FRNG_END, }, .tx_range_list2 = { RIG_FRNG_END, }, /* this is a scanner */ .tuning_steps = { {OS456_MODES,kHz(5)}, {OS456_MODES,kHz(12.5)}, {OS456_MODES,kHz(50)}, RIG_TS_END, }, /* mode/filter list, remember: order matters! */ .filters = { {RIG_MODE_AM|RIG_MODE_FM|RIG_MODE_WFM, kHz(15)}, /* TBC */ RIG_FLT_END, }, .str_cal = OS456_STR_CAL, .cfgparams = icom_cfg_params, .set_conf = icom_set_conf, .get_conf = icom_get_conf,
.max_ifshift = Hz(0), .targetable_vfo = 0, .vfo_ops = IC737_VFO_OPS, .scan_ops = IC737_SCAN_OPS, .transceive = RIG_TRN_RIG, .bank_qty = 0, .chan_desc_sz = 0, .chan_list = { { 1, 100, RIG_MTYPE_MEM }, { 101, 101, RIG_MTYPE_EDGE }, RIG_CHAN_END, }, .rx_range_list1 = { {kHz(30),MHz(30),IC737_ALL_RX_MODES,-1,-1,IC737_VFO_ALL,IC737_ANTS}, RIG_FRNG_END, }, .tx_range_list1 = { FRQ_RNG_HF(1,IC737_OTHER_TX_MODES, W(10),W(100),IC737_VFO_ALL,IC737_ANTS), FRQ_RNG_HF(1,IC737_AM_TX_MODES, W(10),W(40),IC737_VFO_ALL,IC737_ANTS), /* AM class */ RIG_FRNG_END, }, .rx_range_list2 = { {kHz(30),MHz(30),IC737_ALL_RX_MODES,-1,-1,IC737_VFO_ALL,IC737_ANTS}, RIG_FRNG_END, }, .tx_range_list2 = { FRQ_RNG_HF(2,IC737_OTHER_TX_MODES, W(10),W(100),IC737_VFO_ALL,IC737_ANTS), FRQ_RNG_HF(2,IC737_AM_TX_MODES, W(10),W(40),IC737_VFO_ALL,IC737_ANTS), /* AM class */ RIG_FRNG_END, },
.max_ifshift = Hz(0), /* TODO */ .targetable_vfo = 0, .vfo_ops = IC7000_VFO_OPS, .scan_ops = IC7000_SCAN_OPS, .transceive = RIG_TRN_RIG, .bank_qty = 5, .chan_desc_sz = 0, /* TODO */ .chan_list = { { 1, 99, RIG_MTYPE_MEM, IC7000_MEM_CAP }, { 100, 105, RIG_MTYPE_EDGE, IC7000_MEM_CAP }, /* two by two */ { 106, 107, RIG_MTYPE_CALL, IC7000_MEM_CAP }, RIG_CHAN_END, }, .rx_range_list1 = { {kHz(30),MHz(199.999999),IC7000_ALL_RX_MODES,-1,-1,IC7000_VFOS}, {MHz(400),MHz(470), IC7000_ALL_RX_MODES,-1,-1,IC7000_VFOS}, RIG_FRNG_END, }, .tx_range_list1 = { FRQ_RNG_HF(1,IC7000_OTHER_TX_MODES, W(2),W(100),IC7000_VFOS,RIG_ANT_1), FRQ_RNG_6m(1,IC7000_OTHER_TX_MODES, W(2),W(100),IC7000_VFOS,RIG_ANT_1), FRQ_RNG_2m(1,IC7000_OTHER_TX_MODES, W(2),W(50),IC7000_VFOS,RIG_ANT_2), FRQ_RNG_70cm(1,IC7000_OTHER_TX_MODES, W(2), W(35), IC7000_VFOS, RIG_ANT_2), FRQ_RNG_HF(1,IC7000_AM_TX_MODES, W(1),W(40),IC7000_VFOS,RIG_ANT_1), /* AM class */ FRQ_RNG_6m(1,IC7000_AM_TX_MODES, W(1),W(40),IC7000_VFOS,RIG_ANT_1), /* AM class */ FRQ_RNG_2m(1,IC7000_AM_TX_MODES, W(2),W(20),IC7000_VFOS,RIG_ANT_2), FRQ_RNG_70cm(1,IC7000_OTHER_TX_MODES, W(2), W(14), IC7000_VFOS, RIG_ANT_2), RIG_FRNG_END, }, .rx_range_list2 = { {kHz(30),MHz(199.999999),IC7000_ALL_RX_MODES,-1,-1,IC7000_VFOS},
}, .rx_range_list2 = { {MHz(1240),MHz(1300),IC1275_MODES,-1,-1,IC1275_VFO_ALL}, RIG_FRNG_END, }, .tx_range_list2 = { {MHz(1240),MHz(1300),IC1275_MODES,W(1),W(10),IC1275_VFO_ALL}, RIG_FRNG_END, }, .tuning_steps = { {IC1275_MODES,10}, /* TBC: does this rig supports settin tuning step? */ RIG_TS_END, }, /* mode/filter list, remember: order matters! */ .filters = { {RIG_MODE_SSB|RIG_MODE_CW, kHz(2.3)}, {RIG_MODE_CW, Hz(500)}, /* optional FL-83 CW narrow filter */ {RIG_MODE_FM, kHz(15)}, RIG_FLT_END, }, .cfgparams = icom_cfg_params, .set_conf = icom_set_conf, .get_conf = icom_get_conf, .priv = (void*)&ic1275_priv_caps, .rig_init = icom_init, .rig_cleanup = icom_cleanup, .rig_open = NULL, .rig_close = NULL,
.ctcss_list = common_ctcss_list, .dcs_list = common_dcs_list, /* only 104 supported */ .preamp = { RIG_DBLST_END, }, .attenuator = { RIG_DBLST_END, }, .max_rit = Hz(9990), .max_xit = Hz(0), .max_ifshift = Hz(0), .targetable_vfo = 0, .transceive = RIG_TRN_OFF, .bank_qty = 0, .chan_desc_sz = 0, .chan_list = { RIG_CHAN_END, }, .vfo_ops = RIG_OP_TOGGLE, .rx_range_list1 = { {kHz(100),MHz(56), FT857_ALL_RX_MODES,-1,-1}, {MHz(76), MHz(108),RIG_MODE_WFM, -1,-1}, {MHz(118),MHz(164),FT857_ALL_RX_MODES,-1,-1}, {MHz(420),MHz(470),FT857_ALL_RX_MODES,-1,-1}, RIG_FRNG_END, }, .tx_range_list1 = { FRQ_RNG_HF(1,FT857_OTHER_TX_MODES, W(10),W(100),FT857_VFO_ALL,FT857_ANTS), /* AM class */ FRQ_RNG_HF(1,FT857_AM_TX_MODES, W(2.5),W(25),FT857_VFO_ALL,FT857_ANTS), FRQ_RNG_2m(1,FT857_OTHER_TX_MODES, W(5),W(50),FT857_VFO_ALL,FT857_ANTS), /* AM class */ FRQ_RNG_2m(1,FT857_AM_TX_MODES, W(2.5),W(25),FT857_VFO_ALL,FT857_ANTS), FRQ_RNG_70cm(1,FT857_OTHER_TX_MODES, W(2),W(20),FT857_VFO_ALL,FT857_ANTS), /* AM class */ FRQ_RNG_70cm(1,FT857_AM_TX_MODES, W(0.5),W(5),FT857_VFO_ALL,FT857_ANTS),
.vfo_ops = RIG_OP_FROM_VFO|RIG_OP_TO_VFO|RIG_OP_UP|RIG_OP_DOWN, .preamp = { RIG_DBLST_END, }, .attenuator = { RIG_DBLST_END, }, .max_rit = Hz(0), .max_xit = Hz(0), .max_ifshift = Hz(0), .targetable_vfo = RIG_TARGETABLE_NONE, .transceive = RIG_TRN_OFF, .bank_qty = 0, .chan_desc_sz = 0, .chan_list = { { 1, 0x32, RIG_MTYPE_MEM, FRG100_MEM_CAP }, { 0x33, 0x34, RIG_MTYPE_EDGE }, }, .rx_range_list1 = { {kHz(50), MHz(30), FRG100_MODES, -1, -1, FRG100_VFOS, FRG100_ANTS }, RIG_FRNG_END, }, /* Region 1 rx ranges */ .tx_range_list1 = { RIG_FRNG_END, }, /* region 1 TX ranges */ .rx_range_list2 = { {kHz(50), MHz(30), FRG100_MODES, -1, -1, FRG100_VFOS, FRG100_ANTS }, RIG_FRNG_END, }, /* Region 2 rx ranges */ .tx_range_list2 = { RIG_FRNG_END, }, /* region 2 TX ranges */
.rx_range_list2 = { {MHz(118),MHz(470),TMD710_MODES,-1,-1,RIG_VFO_A}, {MHz(136),MHz(174),RIG_MODE_FM,-1,-1,RIG_VFO_B}, {MHz(300),MHz(524),RIG_MODE_FM,-1,-1,RIG_VFO_B}, {MHz(800),MHz(1300),RIG_MODE_FM,-1,-1,RIG_VFO_B}, /* TODO: cellular blocked */ RIG_FRNG_END, }, /* rx range */ .tx_range_list2 = { {MHz(144),MHz(148),TMD710_MODES_TX,W(5),W(50),RIG_VFO_A}, {MHz(430),MHz(450),TMD710_MODES_TX,W(5),W(35),RIG_VFO_A}, RIG_FRNG_END, }, /* tx range */ .tuning_steps = { {TMD710_MODES,kHz(5)}, {TMD710_MODES,kHz(6.25)}, {TMD710_MODES,kHz(10)}, {TMD710_MODES,kHz(12.5)}, {TMD710_MODES,kHz(15)}, {TMD710_MODES,kHz(20)}, {TMD710_MODES,kHz(25)}, {TMD710_MODES,kHz(30)}, {TMD710_MODES,kHz(50)}, {TMD710_MODES,kHz(100)}, RIG_TS_END, }, /* mode/filter list, remember: order matters! */ .filters = { {RIG_MODE_FM, kHz(12)}, {RIG_MODE_AM, kHz(9)}, /* TBC */
.has_set_parm = RIG_PARM_NONE, // .level_gran = { [LVL_CWPITCH] = { .step = { .i = 10 } } }, // .ctcss_list = common_ctcss_list, // .dcs_list = full_dcs_list, // 2050 does have channels...not implemented yet as no need yet // .chan_list = { // { 0, 18, RIG_MTYPE_MEM, DUMMY_MEM_CAP }, // { 19, 19, RIG_MTYPE_CALL }, // { 20, NB_CHAN-1, RIG_MTYPE_EDGE }, // RIG_CHAN_END, // }, // .scan_ops = DUMMY_SCAN, // .vfo_ops = DUMMY_VFO_OP, .transceive = RIG_TRN_RIG, .rx_range_list1 = {{ .start = kHz(1600), .end = MHz(30), .modes = BARRETT_MODES, .low_power = -1, .high_power = -1, BARRETT_VFOS, RIG_ANT_1 }, RIG_FRNG_END, }, .rx_range_list2 = {RIG_FRNG_END,}, .tx_range_list1 = {RIG_FRNG_END,}, .tx_range_list2 = {RIG_FRNG_END,}, .tuning_steps = { {BARRETT_MODES, 1}, {BARRETT_MODES, RIG_TS_ANY}, RIG_TS_END, }, .filters = { {RIG_MODE_SSB | RIG_MODE_CW | RIG_MODE_RTTY, kHz(2.4)}, {RIG_MODE_CW, Hz(500)}, {RIG_MODE_AM, kHz(8)}, {RIG_MODE_AM, kHz(2.4)}, RIG_FLT_END, },
.max_ifshift = Hz(1000), .vfo_ops = FT1200_VFO_OPS, .targetable_vfo = RIG_TARGETABLE_FREQ|RIG_TARGETABLE_MODE, .transceive = RIG_TRN_OFF, /* May enable later as the 1200 has an Auto Info command */ .bank_qty = 0, .chan_desc_sz = 0, .str_cal = FT1200_STR_CAL, .chan_list = { { 1, 99, RIG_MTYPE_MEM, NEWCAT_MEM_CAP }, { 100, 117, RIG_MTYPE_EDGE, NEWCAT_MEM_CAP }, /* two by two */ RIG_CHAN_END, }, .rx_range_list1 = { /* General coverage + ham, ANT_5 is RX only antenna */ {kHz(30), MHz(56), FT1200_ALL_RX_MODES, -1, -1, FT1200_VFO_ALL, FT1200_TX_ANTS}, RIG_FRNG_END, }, .tx_range_list1 = { FRQ_RNG_HF(1, FT1200_OTHER_TX_MODES, W(5), W(100), FT1200_VFO_ALL, FT1200_TX_ANTS), FRQ_RNG_HF(1, FT1200_AM_TX_MODES, W(2), W(25), FT1200_VFO_ALL, FT1200_TX_ANTS), /* AM class */ FRQ_RNG_6m(1, FT1200_OTHER_TX_MODES, W(5), W(100), FT1200_VFO_ALL, FT1200_TX_ANTS), FRQ_RNG_6m(1, FT1200_AM_TX_MODES, W(2), W(25), FT1200_VFO_ALL, FT1200_TX_ANTS), /* AM class */ RIG_FRNG_END, }, .rx_range_list2 = { {kHz(30), MHz(56), FT1200_ALL_RX_MODES, -1, -1, FT1200_VFO_ALL, FT1200_TX_ANTS}, RIG_FRNG_END,
.timeout = 200, .retry = 10, .has_get_func = TS50_FUNC_ALL, .has_set_func = TS50_FUNC_ALL, .has_get_level = TS50_LEVEL_ALL, .has_set_level = RIG_LEVEL_SET(TS50_LEVEL_ALL), .has_get_parm = RIG_PARM_NONE, .has_set_parm = RIG_PARM_NONE, /* FIXME: parms */ .level_gran = {}, /* FIXME: granularity */ .parm_gran = {}, .ctcss_list = NULL, .dcs_list = NULL, .preamp = { RIG_DBLST_END, }, /* FIXME: preamp list */ .attenuator = { 18, RIG_DBLST_END, }, .max_rit = kHz(1.1), .max_xit = Hz(0), .max_ifshift = Hz(0), .vfo_ops = TS50_VFO_OP, .targetable_vfo = RIG_TARGETABLE_FREQ, .transceive = RIG_TRN_RIG, .bank_qty = 0, .chan_desc_sz = 0, .chan_list = { { 0, 89, RIG_MTYPE_MEM }, { 90, 99, RIG_MTYPE_EDGE }, RIG_CHAN_END, }, .rx_range_list1 = {
.timeout = 200, .retry = 3, .has_get_func = TS870S_FUNC_ALL, .has_set_func = TS870S_FUNC_ALL, .has_get_level = TS870S_LEVEL_GET, .has_set_level = TS870S_LEVEL_SET, .has_get_parm = RIG_PARM_NONE, .has_set_parm = RIG_PARM_NONE, /* FIXME: parms */ .level_gran = {}, /* FIXME: granularity */ .parm_gran = {}, .ctcss_list = kenwood38_ctcss_list, .dcs_list = NULL, .preamp = { RIG_DBLST_END, }, /* FIXME: preamp list */ .attenuator = { 6, 12, 18, RIG_DBLST_END, }, .max_rit = kHz(9.99), .max_xit = kHz(9.99), .max_ifshift = Hz(0), .targetable_vfo = RIG_TARGETABLE_FREQ, .transceive = RIG_TRN_RIG, .bank_qty = 0, .chan_desc_sz = 0, .chan_list = { { 0, 89, RIG_MTYPE_MEM }, /* TBC */ { 90, 99, RIG_MTYPE_EDGE }, RIG_CHAN_END, }, .rx_range_list1 = {
.extparms = kenwood_cfg_params, .preamp = { 14, RIG_DBLST_END, }, .attenuator = { 10, RIG_DBLST_END, }, .max_rit = Hz(9990), .max_xit = Hz(9990), .max_ifshift = Hz(0), .vfo_ops = K3_VFO_OP, .targetable_vfo = RIG_TARGETABLE_FREQ, .transceive = RIG_TRN_RIG, .bank_qty = 0, .chan_desc_sz = 0, .chan_list = { RIG_CHAN_END }, .rx_range_list1 = { {kHz(500), MHz(30), K3_MODES, -1, -1, K3_VFO, K3_ANTS}, { MHz(48), MHz(54), K3_MODES, -1,- 1, K3_VFO, K3_ANTS}, RIG_FRNG_END, }, /* rx range */ .tx_range_list1 = { FRQ_RNG_HF(1, K3_MODES, mW(10), W(10), K3_VFO, K3_ANTS), FRQ_RNG_6m(1, K3_MODES, mW(10), W(10), K3_VFO, K3_ANTS), RIG_FRNG_END, }, /* tx range */ .rx_range_list2 = { {kHz(500), MHz(30), K3_MODES, -1, -1, K3_VFO, K3_ANTS}, { MHz(48), MHz(54), K3_MODES, -1, -1, K3_VFO, K3_ANTS}, RIG_FRNG_END, }, /* rx range */ .tx_range_list2 = {
.dcs_list = NULL, .preamp = { RIG_DBLST_END }, .attenuator = { 20, RIG_DBLST_END }, .max_rit = Hz(0), .max_xit = Hz(0), .max_ifshift = Hz(0), .targetable_vfo = 0, .transceive = RIG_TRN_RIG, .bank_qty = 0, .chan_desc_sz = 0, .chan_list = { RIG_CHAN_END }, .rx_range_list1 = { { kHz(10), GHz(1.3), PCR100_MODES, -1, -1, RIG_VFO_A }, RIG_FRNG_END, }, .tx_range_list1 = { RIG_FRNG_END }, .rx_range_list2 = { { kHz(10), MHz(824) - 10, PCR100_MODES, -1, -1, RIG_VFO_A }, { MHz(849) + 10, MHz(869) - 10, PCR100_MODES, -1, -1, RIG_VFO_A }, { MHz(894) + 10, GHz(1.3), PCR100_MODES, -1, -1, RIG_VFO_A }, RIG_FRNG_END, }, .tx_range_list2 = { RIG_FRNG_END }, /* no TX ranges, this is a receiver */ .tuning_steps = { { PCR100_MODES, Hz(1) }, RIG_TS_END, },
.dcs_list = common_dcs_list, .preamp = { RIG_DBLST_END, }, /* no preamp/att in CAT */ .attenuator = { RIG_DBLST_END, }, .max_rit = Hz(0), .max_xit = Hz(0), .max_ifshift = Hz(0), .targetable_vfo = RIG_TARGETABLE_FREQ|RIG_TARGETABLE_MODE|RIG_TARGETABLE_TONE|RIG_TARGETABLE_FUNC, .transceive = RIG_TRN_OFF, .bank_qty = 0, .chan_desc_sz = 0, .str_cal = FT847_STR_CAL, .chan_list = { RIG_CHAN_END, }, /* FIXME: memory chan list: 78, but only in clonable mode? */ .rx_range_list1 = { {kHz(100),MHz(30),FT847_ALL_RX_MODES,-1,-1}, /* rx range begin */ {MHz(36),MHz(76),FT847_ALL_RX_MODES,-1,-1}, {MHz(108),MHz(174),FT847_ALL_RX_MODES,-1,-1}, {MHz(420),MHz(512),FT847_ALL_RX_MODES,-1,-1}, RIG_FRNG_END, }, /* rx range end */ .tx_range_list1 = { FRQ_RNG_HF(1,FT847_OTHER_TX_MODES, W(5),W(100),FT847_VFOS,FT847_ANTS), FRQ_RNG_HF(1,FT847_AM_TX_MODES, W(1),W(25),FT847_VFOS,FT847_ANTS), FRQ_RNG_6m(2,FT847_OTHER_TX_MODES, W(5),W(100),FT847_VFOS,FT847_ANTS), FRQ_RNG_6m(2,FT847_AM_TX_MODES, W(1),W(25),FT847_VFOS,FT847_ANTS), FRQ_RNG_2m(2,FT847_OTHER_TX_MODES, W(1),W(50),FT847_VFOS,FT847_ANTS), FRQ_RNG_2m(2,FT847_AM_TX_MODES, W(1),W(12.5),FT847_VFOS,FT847_ANTS),
.transceive = RIG_TRN_OFF, /* May enable later as the 950 has an Auto Info command */ .bank_qty = 0, .chan_desc_sz = 0, .str_cal = FT950_STR_CAL, .chan_list = { { 1, 99, RIG_MTYPE_MEM, NEWCAT_MEM_CAP }, { 100, 117, RIG_MTYPE_EDGE, NEWCAT_MEM_CAP }, /* two by two */ { 125, 128, RIG_MTYPE_BAND, NEWCAT_MEM_CAP }, /* 60M Channels U51-U54 or US1-US4, if available */ { 130, 130, RIG_MTYPE_BAND, NEWCAT_MEM_CAP }, /* 60M Channel U55 or US5, if available */ { 131, 131, RIG_MTYPE_BAND, NEWCAT_MEM_CAP }, /* EU5, 5167.5 KHz Alaska Emergency Freq, if available */ RIG_CHAN_END, }, .rx_range_list1 = { {kHz(30), MHz(56), FT950_ALL_RX_MODES, -1, -1, FT950_VFO_ALL, FT950_ANTS}, /* General coverage + ham */ RIG_FRNG_END, }, /* FIXME: Are these the correct Region 1 values? */ .tx_range_list1 = { FRQ_RNG_HF(1, FT950_OTHER_TX_MODES, W(5), W(100), FT950_VFO_ALL, FT950_ANTS), FRQ_RNG_HF(1, FT950_AM_TX_MODES, W(2), W(25), FT950_VFO_ALL, FT950_ANTS), /* AM class */ FRQ_RNG_6m(1, FT950_OTHER_TX_MODES, W(5), W(100), FT950_VFO_ALL, FT950_ANTS), FRQ_RNG_6m(1, FT950_AM_TX_MODES, W(2), W(25), FT950_VFO_ALL, FT950_ANTS), /* AM class */ RIG_FRNG_END, }, .rx_range_list2 = { {kHz(30), MHz(56), FT950_ALL_RX_MODES, -1, -1, FT950_VFO_ALL, FT950_ANTS}, RIG_FRNG_END,
{MHz(144),MHz(146),ID5100_MODES,W(5),W(25),ID5100_VFO_ALL}, {MHz(430),MHz(440),ID5100_MODES,W(5),W(25),ID5100_VFO_ALL}, RIG_FRNG_END, }, .rx_range_list2 = { {MHz(118),MHz(174),ID5100_ALL_RX_MODES,-1,-1,ID5100_VFO_ALL}, {MHz(375),MHz(550),ID5100_ALL_RX_MODES,-1,-1,ID5100_VFO_ALL}, RIG_FRNG_END, }, .tx_range_list2 = { {MHz(144),MHz(148),ID5100_MODES,W(5),W(50),ID5100_VFO_ALL}, {MHz(430),MHz(450),ID5100_MODES,W(5),W(50),ID5100_VFO_ALL}, RIG_FRNG_END, }, .tuning_steps = { // Rem: no support for changing tuning step {ID5100_ALL_RX_MODES,kHz(5)}, {ID5100_ALL_RX_MODES,kHz(6.25)}, // The 8.33 kHz step is not selectable, depending on the operating band or mode. {ID5100_ALL_RX_MODES,kHz(8.33)}, {ID5100_ALL_RX_MODES,kHz(10)}, {ID5100_ALL_RX_MODES,12500}, {ID5100_ALL_RX_MODES,kHz(15)}, {ID5100_ALL_RX_MODES,kHz(20)}, {ID5100_ALL_RX_MODES,kHz(25)}, {ID5100_ALL_RX_MODES,kHz(30)}, {ID5100_ALL_RX_MODES,kHz(50)}, RIG_TS_END, }, /* mode/filter list, remember: order matters! */ .filters = { {RIG_MODE_FM|RIG_MODE_AM, kHz(12)},
.attenuator = { RIG_DBLST_END, }, .max_rit = Hz(9999), .max_xit = Hz(9999), .max_ifshift = Hz(1200), .vfo_ops = RIG_OP_CPY | RIG_OP_FROM_VFO | RIG_OP_TO_VFO | RIG_OP_UP | RIG_OP_DOWN | RIG_OP_TUNE | RIG_OP_TOGGLE, .targetable_vfo = RIG_TARGETABLE_ALL, .transceive = RIG_TRN_OFF, /* Yaesus have to be polled, sigh */ .bank_qty = 0, .chan_desc_sz = 0, .chan_list = { {1, 99, RIG_MTYPE_MEM, FT1000D_MEM_CAP}, RIG_CHAN_END, }, .rx_range_list1 = { {kHz(100), MHz(30), FT1000D_ALL_RX_MODES, -1, -1, FT1000D_VFO_ALL, FT1000D_ANTS}, /* General coverage + ham */ RIG_FRNG_END, }, .tx_range_list1 = { FRQ_RNG_HF(1, FT1000D_OTHER_TX_MODES, W(5), W(100), FT1000D_VFO_ALL, FT1000D_ANTS), FRQ_RNG_HF(1, FT1000D_AM_TX_MODES, W(2), W(25), FT1000D_VFO_ALL, FT1000D_ANTS), /* AM class */ RIG_FRNG_END, }, .rx_range_list2 = { {kHz(100), MHz(30), FT1000D_ALL_RX_MODES, -1, -1, FT1000D_VFO_ALL, FT1000D_ANTS}, RIG_FRNG_END, }, .tx_range_list2 = {
.ctcss_list = ft100_ctcss_list, .dcs_list = ft100_dcs_list, .preamp = { RIG_DBLST_END, }, .attenuator = { RIG_DBLST_END, }, .max_rit = Hz(0), .max_xit = Hz(0), .max_ifshift = Hz(0), .targetable_vfo = RIG_TARGETABLE_NONE, .transceive = RIG_TRN_OFF, .bank_qty = 0, .chan_desc_sz = 0, .chan_list = { RIG_CHAN_END, }, /* FIXME: memory chan .list = 78 */ .rx_range_list1 = { {kHz(100),MHz(56), FT100_ALL_RX_MODES,-1,-1,FT100_VFO_ALL}, {MHz(76), MHz(108),RIG_MODE_WFM, -1,-1,FT100_VFO_ALL}, {MHz(108),MHz(154),FT100_ALL_RX_MODES,-1,-1,FT100_VFO_ALL}, {MHz(420),MHz(470),FT100_ALL_RX_MODES,-1,-1,FT100_VFO_ALL}, RIG_FRNG_END, }, .tx_range_list1 = { FRQ_RNG_HF(1, FT100_OTHER_TX_MODES, W(0.5), W(100), FT100_VFO_ALL, FT100_ANT), FRQ_RNG_HF(1, FT100_AM_TX_MODES, W(0.5), W(25), FT100_VFO_ALL, FT100_ANT), FRQ_RNG_6m(1, FT100_OTHER_TX_MODES, W(0.5), W(100), FT100_VFO_ALL, FT100_ANT), FRQ_RNG_6m(1, FT100_AM_TX_MODES, W(0.5), W(25), FT100_VFO_ALL, FT100_ANT), FRQ_RNG_2m(1, FT100_OTHER_TX_MODES, W(0.5), W(50), FT100_VFO_ALL, FT100_ANT), FRQ_RNG_2m(1, FT100_AM_TX_MODES, W(0.5), W(12.5), FT100_VFO_ALL, FT100_ANT), FRQ_RNG_70cm(1, FT100_OTHER_TX_MODES, W(0.5), W(20), FT100_VFO_ALL, FT100_ANT), FRQ_RNG_70cm(1, FT100_AM_TX_MODES, W(0.5), W(5), FT100_VFO_ALL, FT100_ANT), },
.retry = 3, .has_get_func = IC9100_FUNC_ALL, .has_set_func = IC9100_FUNC_ALL | RIG_FUNC_RESUME, .has_get_level = IC9100_LEVEL_ALL | RIG_LEVEL_RAWSTR| RIG_LEVEL_SWR, .has_set_level = IC9100_LEVEL_ALL, .has_get_parm = IC9100_PARM_ALL, .has_set_parm = IC9100_PARM_ALL, .level_gran = { [LVL_RAWSTR] = { .min = { .i = 0 }, .max = { .i = 255 } }, }, .parm_gran = {}, .ctcss_list = common_ctcss_list, .dcs_list = common_dcs_list, .preamp = {20, RIG_DBLST_END, }, .attenuator = {20, RIG_DBLST_END, }, .max_rit = kHz(9.999), .max_xit = kHz(9.999), .max_ifshift = Hz(0), .targetable_vfo = 0, .vfo_ops = IC9100_VFO_OPS, .scan_ops = IC9100_SCAN_OPS, .transceive = RIG_TRN_RIG, .bank_qty = 0, .chan_desc_sz = 9, /* TODO */ .chan_list = { /* TBC */ { 1, 396, RIG_MTYPE_MEM }, { 397, 400, RIG_MTYPE_CALL }, { 401, 424, RIG_MTYPE_EDGE }, RIG_CHAN_END, },
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; }
.max_xit = Hz(9999), .max_ifshift = Hz(0), .targetable_vfo = 0, .vfo_ops = IC7600_VFO_OPS, .scan_ops = IC7600_SCAN_OPS, .transceive = RIG_TRN_RIG, .bank_qty = 0, .chan_desc_sz = 0, .chan_list = { { 1, 99, RIG_MTYPE_MEM }, { 100, 101, RIG_MTYPE_EDGE }, /* two by two */ RIG_CHAN_END, }, .rx_range_list1 = { {kHz(30),MHz(60),IC7600_ALL_RX_MODES,-1,-1,IC7600_VFOS,IC7600_ANTS}, RIG_FRNG_END, }, .tx_range_list1 = { FRQ_RNG_HF(1,IC7600_OTHER_TX_MODES, W(2),W(100),IC7600_VFOS,IC7600_ANTS), FRQ_RNG_6m(1,IC7600_OTHER_TX_MODES, W(2),W(100),IC7600_VFOS,IC7600_ANTS), FRQ_RNG_HF(1,IC7600_AM_TX_MODES, W(1),W(30),IC7600_VFOS,IC7600_ANTS), /* AM class */ FRQ_RNG_6m(1,IC7600_AM_TX_MODES, W(1),W(30),IC7600_VFOS,IC7600_ANTS), /* AM class */ RIG_FRNG_END, }, .rx_range_list2 = { {kHz(30),MHz(60),IC7600_ALL_RX_MODES,-1,-1,IC7600_VFOS,IC7600_ANTS}, RIG_FRNG_END, }, .tx_range_list2 = { FRQ_RNG_HF(2,IC7600_OTHER_TX_MODES, W(2),W(100),IC7600_VFOS,IC7600_ANTS), FRQ_RNG_6m(2,IC7600_OTHER_TX_MODES, W(2),W(100),IC7600_VFOS,IC7600_ANTS), FRQ_RNG_HF(2,IC7600_AM_TX_MODES, W(1),W(30),IC7600_VFOS,IC7600_ANTS), /* AM class */ FRQ_RNG_6m(2,IC7600_AM_TX_MODES, W(1),W(30),IC7600_VFOS,IC7600_ANTS), /* AM class */
.max_ifshift = Hz(0), .targetable_vfo = RIG_TARGETABLE_FREQ, .transceive = RIG_TRN_RIG, .bank_qty = 0, .chan_desc_sz = 0, .vfo_ops = TS450S_VFO_OPS, .scan_ops = TS450S_SCAN_OPS, .chan_list = { { 0, 89, RIG_MTYPE_MEM, TS450S_CHANNEL_CAPS }, /* TBC */ { 90, 99, RIG_MTYPE_EDGE, TS450S_CHANNEL_CAPS }, RIG_CHAN_END, }, .rx_range_list1 = { { kHz(500), MHz(30), TS450S_ALL_MODES, -1, -1, TS450S_VFO }, RIG_FRNG_END, }, /* rx range */ .tx_range_list1 = { FRQ_RNG_HF(1,TS450S_OTHER_TX_MODES, W(5),W(100),TS450S_VFO,0), FRQ_RNG_HF(1,TS450S_AM_TX_MODES, W(2),W(40),TS450S_VFO,0), /* AM class */ RIG_FRNG_END, }, .rx_range_list2 = { {kHz(500),MHz(30),TS450S_ALL_MODES,-1,-1,TS450S_VFO}, RIG_FRNG_END, }, /* rx range */ .tx_range_list2 = { {kHz(1800),MHz(2)-1,TS450S_OTHER_TX_MODES,5000,100000,TS450S_VFO}, /* 100W class */