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