mirror
/
Hamlib
kopia lustrzana https://github.com/Hamlib/Hamlib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Merge pull request #1 from Hamlib/master 

Merge from upstream
pull/110/head
Kārlis Millers 2019-05-14 22:34:36 +03:00 zatwierdzone przez GitHub
rodzic 58a1f18af1 56ee4fd18a
commit c12a6d35d5
Nie znaleziono w bazie danych klucza dla tego podpisu
ID klucza GPG: 4AEE18F83AFDEB23
22 zmienionych plików z 3894 dodań i 2570 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

3
icom/frame.c
Wyświetl plik

@ -335,7 +335,7 @@ int rig2icom_mode(RIG *rig, rmode_t mode, pbwidth_t width,
case RIG_MODE_RTTY: icmode = S_RTTY; break;
case RIG_MODE_RTTYR: icmode = S_RTTYR; break;
case RIG_MODE_FM: icmode = S_FM; break;
case RIG_MODE_FMN: icmode = S_FMN; break;
case RIG_MODE_FMN: icmode = S_FMN; break;
case RIG_MODE_WFM: icmode = S_WFM; break;
case RIG_MODE_P25: icmode = S_P25; break;
case RIG_MODE_DSTAR: icmode = S_DSTAR; break;
@ -343,6 +343,7 @@ int rig2icom_mode(RIG *rig, rmode_t mode, pbwidth_t width,
case RIG_MODE_NXDNVN: icmode = S_NXDNVN; break;
case RIG_MODE_NXDN_N: icmode = S_NXDN_N; break;
case RIG_MODE_DCR: icmode = S_DCR; break;
case RIG_MODE_DD: icmode = S_DD; break;
default:
rig_debug(RIG_DEBUG_ERR,"icom: Unsupported Hamlib mode %d\n",mode);
return -RIG_EINVAL;

185
icom/ic7300.c
Wyświetl plik

@ -80,6 +80,13 @@
#define IC7300_AGC_MID 0x02
#define IC7300_AGC_SLOW 0x03
/*
* IC9700 items that differ from IC7300
*/
#define IC9700_VFO_OPS (RIG_OP_CPY|RIG_OP_XCHG|RIG_OP_FROM_VFO|RIG_OP_TO_VFO|RIG_OP_MCL)
#define IC9700_ALL_TX_MODES (RIG_MODE_FM|RIG_MODE_AM|RIG_MODE_CW|RIG_MODE_CWR|RIG_MODE_SSB|RIG_MODE_RTTY|RIG_MODE_RTTYR|RIG_MODE_DSTAR|RIG_MODE_DD)
#define IC9700_ALL_RX_MODES (RIG_MODE_FM|RIG_MODE_AM|RIG_MODE_CW|RIG_MODE_CWR|RIG_MODE_SSB|RIG_MODE_RTTY|RIG_MODE_RTTYR|RIG_MODE_DSTAR|RIG_MODE_DD)
/*
* IC-7300 rig capabilities.
*
@ -93,6 +100,14 @@ static const struct icom_priv_caps IC7300_priv_caps = {
.civ_version = 1 /* new version of some commands, e.g. ic7200/7300 */
};
static const struct icom_priv_caps IC9700_priv_caps = {
0xA2, /* default address */
0, /* 731 mode */
0, /* no XCHG */
ic7300_ts_sc_list,
.civ_version = 1 /* new version of some commands, e.g. ic7200/7300 */
};
/* Private IC7300 extra levels definitions
*
* Token definitions for .cfgparams in rig_caps
@ -285,6 +300,176 @@ const struct rig_caps ic7300_caps = {
};
const struct rig_caps ic9700_caps = {
.rig_model = RIG_MODEL_IC9700,
.model_name = "IC-9700",
.mfg_name = "Icom",
.version = BACKEND_VER ".1c",
.copyright = "LGPL",
.status = RIG_STATUS_ALPHA,
.rig_type = RIG_TYPE_TRANSCEIVER,
.ptt_type = RIG_PTT_RIG,
.dcd_type = RIG_DCD_RIG,
.port_type = RIG_PORT_SERIAL,
.serial_rate_min = 4800,
.serial_rate_max = 38400,
.serial_data_bits = 8,
.serial_stop_bits = 1,
.serial_parity = RIG_PARITY_NONE,
.serial_handshake = RIG_HANDSHAKE_NONE,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 1000,
.retry = 3,
.has_get_func = IC7300_FUNCS,
.has_set_func = IC7300_FUNCS,
.has_get_level = IC7300_LEVELS,
.has_set_level = RIG_LEVEL_SET(IC7300_LEVELS),
.has_get_parm = IC7300_PARMS,
.has_set_parm = RIG_PARM_SET(IC7300_PARMS),
.level_gran = {
[LVL_RAWSTR] = { .min = { .i = 0 }, .max = { .i = 255 } },
},
.parm_gran = {},
.extlevels = ic7300_ext_levels,
.ctcss_list = full_ctcss_list,
.dcs_list = NULL,
.preamp = { 1, 2, RIG_DBLST_END, },
.attenuator = { 1, RIG_DBLST_END, }, /* value taken from p.45 of manual*/
.max_rit = Hz(9999),
.max_xit = Hz(9999),
.max_ifshift = Hz(0),
.targetable_vfo = RIG_TARGETABLE_FREQ,
.vfo_ops = IC9700_VFO_OPS,
.scan_ops = IC7300_SCAN_OPS,
.transceive = RIG_TRN_RIG,
.bank_qty = 1,
.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(74.8),IC7300_ALL_RX_MODES,-1,-1,IC7300_VFOS}, RIG_FRNG_END, },
.tx_range_list1 = {
FRQ_RNG_2m(1,IC9700_ALL_TX_MODES, W(2),W(100),IC7300_VFOS,RIG_ANT_2),
FRQ_RNG_70cm(1,IC9700_ALL_TX_MODES, W(2),W(75),IC7300_VFOS,RIG_ANT_2),
FRQ_RNG_23cm(1,IC9700_ALL_TX_MODES, W(2),W(23),IC7300_VFOS,RIG_ANT_3),
RIG_FRNG_END, },
.rx_range_list2 = { {kHz(30),MHz(74.8),IC7300_ALL_RX_MODES,-1,-1,IC7300_VFOS}, RIG_FRNG_END, },
.tx_range_list2 = {
FRQ_RNG_2m(1,IC9700_ALL_TX_MODES, W(2),W(100),IC7300_VFOS,RIG_ANT_2),
FRQ_RNG_70cm(1,IC9700_ALL_TX_MODES, W(2),W(75),IC7300_VFOS,RIG_ANT_2),
FRQ_RNG_23cm(1,IC9700_ALL_TX_MODES, W(2),W(23),IC7300_VFOS,RIG_ANT_3),
RIG_FRNG_END, },
.tuning_steps = {
{IC9700_ALL_RX_MODES,Hz(1)},
{IC9700_ALL_RX_MODES,Hz(10)},
{IC9700_ALL_RX_MODES,Hz(100)},
{IC9700_ALL_RX_MODES,Hz(500)},
{IC9700_ALL_RX_MODES,kHz(1)},
{IC9700_ALL_RX_MODES,kHz(5)},
{IC9700_ALL_RX_MODES,kHz(6.25)},
{IC9700_ALL_RX_MODES,kHz(10)},
{IC9700_ALL_RX_MODES,kHz(12.5)},
{IC9700_ALL_RX_MODES,kHz(20)},
{IC9700_ALL_RX_MODES,kHz(25)},
{IC9700_ALL_RX_MODES,kHz(50)},
{IC9700_ALL_RX_MODES,kHz(100)},
RIG_TS_END,
},
/* mode/filter list, remember: order matters! But duplication may speed up search. Put the most commonly used modes first! Remember these are defaults, with dsp rigs you can change them to anything you want except FM and WFM which are fixed */
.filters = {
{RIG_MODE_SSB, kHz(2.4)},
{RIG_MODE_SSB, kHz(1.8)},
{RIG_MODE_SSB, kHz(3)},
{RIG_MODE_CW|RIG_MODE_CWR|RIG_MODE_RTTY|RIG_MODE_RTTYR, Hz(500)},
{RIG_MODE_CW|RIG_MODE_CWR|RIG_MODE_RTTY|RIG_MODE_RTTYR, Hz(250)},
{RIG_MODE_CW|RIG_MODE_CWR, kHz(1.2)},
{RIG_MODE_RTTY|RIG_MODE_RTTYR, kHz(2.4)},
{RIG_MODE_AM|RIG_MODE_PKTAM, kHz(6)},
{RIG_MODE_AM|RIG_MODE_PKTAM, kHz(3)},
{RIG_MODE_AM|RIG_MODE_PKTAM, kHz(9)},
{RIG_MODE_FM|RIG_MODE_PKTFM, kHz(15)},
{RIG_MODE_FM|RIG_MODE_PKTFM, kHz(10)},
{RIG_MODE_FM|RIG_MODE_PKTFM, kHz(7)},
RIG_FLT_END,
},
.str_cal = IC7300_STR_CAL,
.cfgparams = icom_cfg_params,
.set_conf = icom_set_conf,
.get_conf = icom_get_conf,
.priv = (void*)&IC9700_priv_caps,
.rig_init = icom_init,
.rig_cleanup = icom_cleanup,
.rig_open = NULL,
.rig_close = NULL,
.set_freq = icom_set_freq,
.get_freq = icom_get_freq,
.set_mode = icom_set_mode_with_data,
.get_mode = icom_get_mode_with_data,
//.get_vfo = icom_get_vfo,
.set_vfo = icom_set_vfo,
.set_ant = NULL,
.get_ant = NULL,
.set_rit = ic7300_set_rit,
.get_rit = ic7300_get_rit,
// the 7300 has only one register for both RIT and Delta TX
// you can turn one or both on -- but both end up just being in sync
// so we'll just reuse the rit settings
.get_xit = ic7300_get_rit,
.set_xit = ic7300_set_xit,
.decode_event = icom_decode_event,
.set_level = ic7300_set_level,
.get_level = ic7300_get_level,
.set_ext_level = icom_set_ext_level,
.get_ext_level = icom_get_ext_level,
.set_func = ic7300_set_func,
.get_func = ic7300_get_func,
.set_parm = icom_set_parm,
.get_parm = icom_get_parm,
.set_mem = icom_set_mem,
.vfo_op = icom_vfo_op,
.scan = icom_scan,
.set_ptt = icom_set_ptt,
.get_ptt = icom_get_ptt,
.get_dcd = icom_get_dcd,
.set_ts = icom_set_ts,
.get_ts = icom_get_ts,
.set_rptr_shift = NULL,
.get_rptr_shift = NULL,
.set_rptr_offs = NULL,
.get_rptr_offs = NULL,
.set_ctcss_tone = icom_set_ctcss_tone,
.get_ctcss_tone = icom_get_ctcss_tone,
.set_ctcss_sql = icom_set_ctcss_sql,
.get_ctcss_sql = icom_get_ctcss_sql,
.set_split_freq = icom_set_split_freq,
.get_split_freq = icom_get_split_freq,
.set_split_mode = icom_set_split_mode,
.get_split_mode = icom_get_split_mode,
.set_split_vfo = icom_set_split_vfo,
.get_split_vfo = icom_get_split_vfo,
.set_powerstat = icom_set_powerstat,
//.get_vfo = icom_get_vfo,
.set_vfo = icom_set_vfo,
.power2mW = icom_power2mW,
.mW2power = icom_mW2power,
.send_morse = icom_send_morse
};
int ic7300_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *ts)
{
unsigned char tsbuf[MAXFRAMELEN];

6
icom/ic785x.c
Wyświetl plik

@ -88,9 +88,9 @@ const struct rig_caps ic785x_caps = {
.rig_model = RIG_MODEL_IC785x,
.model_name = "IC-785x",
.mfg_name = "Icom",
.version = BACKEND_VER ".1",
.version = BACKEND_VER ".2",
.copyright = "LGPL",
.status = RIG_STATUS_ALPHA,
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TRANSCEIVER,
.ptt_type = RIG_PTT_RIG,
.dcd_type = RIG_DCD_RIG,
@ -232,5 +232,7 @@ const struct rig_caps ic785x_caps = {
.get_split_mode = icom_get_split_mode,
.set_split_vfo = icom_set_split_vfo,
.get_split_vfo = icom_mem_get_split_vfo,
.set_powerstat = icom_set_powerstat,
.get_powerstat = icom_get_powerstat,
};

137
icom/icom.c
Wyświetl plik

@ -351,6 +351,7 @@ static const struct icom_addr icom_addr_list[] = {
{ RIG_MODEL_IC821H, 0x4c },
{ RIG_MODEL_IC910, 0x60 },
{ RIG_MODEL_IC9100, 0x7c },
{ RIG_MODEL_IC9700, 0xa2 },
{ RIG_MODEL_IC970, 0x2e },
{ RIG_MODEL_IC1271, 0x24 },
{ RIG_MODEL_IC1275, 0x18 },
@ -386,7 +387,7 @@ static const struct icom_addr icom_addr_list[] = {
/*
* This is a generic icom_init function.
* You might want to define yours, so you can customize it for your rig
*
*
* Basically, it sets up *priv
* REM: serial port is already open (rig->state.rigport.fd)
*/
@ -464,7 +465,7 @@ int icom_rig_open(RIG *rig)
struct rig_state *rs = &rig->state;
struct icom_priv_data *priv = (struct icom_priv_data*)rs->priv;
struct icom_priv_caps *priv_caps = (struct icom_priv_caps *) rig->caps->priv;
struct icom_priv_caps *priv_caps = (struct icom_priv_caps *) rig->caps->priv;
if (priv_caps->serial_USB_echo_check) {
@ -482,7 +483,7 @@ int icom_rig_open(RIG *rig)
}
}
priv->serial_USB_echo_off = 0;
return retval;
return retval;
}
@ -497,10 +498,39 @@ int icom_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
unsigned char freqbuf[MAXFRAMELEN], ackbuf[MAXFRAMELEN];
int freq_len, ack_len=sizeof(ackbuf), retval;
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
rig_debug(RIG_DEBUG_VERBOSE, "%s called %s=%"PRIll"\n", __func__, rig_strvfo(vfo),(int64_t)freq);
rs = &rig->state;
priv = (struct icom_priv_data*)rs->priv;
// IC-9700 cannot set freq MAIN to same band as SUB
// So we query both and ensure they won't match
// If a potential collision we just swap VFOs
// This covers setting VFOA, VFOB, Main or Sub
#if 0
if (rig->caps->rig_model == RIG_MODEL_IC9700) {
// the 0x07 0xd2 is not working as of IC-9700 firmwave 1.05
// When it does work this can be unblocked
freq_t freqMain,freqSub;
retval = rig_get_freq(rig, RIG_VFO_MAIN, &freqMain);
if (retval != RIG_OK)
return retval;
retval = rig_get_freq(rig, RIG_VFO_SUB, &freqSub);
if (retval != RIG_OK)
return retval;
// Make our 2M = 1, 70cm = 4, and 23cm=12
freqMain = freqMain/1e8;
freqSub = freqMain/1e8;
freq_t freq2 = freq/1e8;
// Check if changing bands on Main and it matches Sub band
int mainCollides = freq2 != freqMain && freq2 == freqSub;
if (mainCollides) {
// we'll just swap Main/Sub
retval = icom_vfo_op(rig, vfo, RIG_OP_XCHG);
if (retval != RIG_OK)
return retval;
}
}
#endif
freq_len = priv->civ_731_mode ? 4:5;
/*
@ -508,8 +538,9 @@ int icom_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
*/
to_bcd(freqbuf, freq, freq_len*2);
retval = icom_transaction (rig, C_SET_FREQ, -1, freqbuf, freq_len,
ackbuf, &ack_len);
int cmd = C_SET_FREQ;
int subcmd = -1;
retval = icom_transaction (rig, cmd, subcmd, freqbuf, freq_len, ackbuf, &ack_len);
if (retval != RIG_OK)
return retval;
@ -524,7 +555,7 @@ int icom_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
/*
* icom_get_freq
* Assumes rig!=NULL, rig->state.priv!=NULL, freq!=NULL
* Assumes rig!=NULL, rig->state.priv!=NULL, freq!=NULL, Main=VFOA, Sub=VFOB
* Note: old rig may return less than 4/5 bytes for get_freq
*/
int icom_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
@ -534,19 +565,47 @@ int icom_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
unsigned char freqbuf[MAXFRAMELEN];
int freq_len, retval;
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
rig_debug(RIG_DEBUG_VERBOSE, "%s called for %s\n", __func__,rig_strvfo(vfo));
rs = &rig->state;
priv = (struct icom_priv_data*)rs->priv;
retval = icom_transaction (rig, C_RD_FREQ, -1, NULL, 0,
freqbuf, &freq_len);
// Newer Icoms can read main/sub frequency
int cmd = C_RD_FREQ;
int subcmd = -1;
unsigned char data;
int datalen = 0;
switch(vfo) {
case RIG_VFO_MAIN:
cmd = C_SET_VFO;
subcmd = S_SUB_SEL;
data = 0 ;
datalen = 1;
break;
case RIG_VFO_SUB:
cmd = C_SET_VFO;
subcmd = S_SUB_SEL;
data = 1;
datalen = 1;
break;
}
retval = icom_transaction (rig, cmd, subcmd, datalen==0?NULL:&data, datalen, freqbuf, &freq_len);
if (retval != RIG_OK)
return retval;
// The command to read Main/Sub freq is 1 byte longer
// So a simple solution here is to just move left 1 byte
if (cmd == C_SEND_SEL_FREQ) {
memmove(freqbuf,freqbuf+1,freq_len-1);
freq_len--; // have to take off one more byte from the response
}
/*
* freqbuf should contain Cn,Data area
*/
freq_len--;
if (priv->civ_version >= 2) {
memmove(freqbuf,freqbuf+1,freq_len);
freq_len--;
}
/*
* is it a blank mem channel ?
@ -557,7 +616,7 @@ int icom_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
return RIG_OK;
}
if (freq_len != 4 && freq_len != 5) {
if (freq_len != 4 && freq_len != 5) {
rig_debug(RIG_DEBUG_ERR,"icom_get_freq: wrong frame len=%d\n",
freq_len);
return -RIG_ERJCTED;
@ -951,7 +1010,35 @@ int icom_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
}
/*
* icom_set_vfo
* icom_get_vfo
* The IC-9700 has introduced the ability to see MAIN/SUB selection
* Maybe we'll see this in future ICOMs or firmware upgrades
* Command 0x07 0XD2 -- but as of version 1.05 it doesn't work
* We will, by default, force Main=VFOA and Sub=VFOB, and may want
* an option to not force that behavior
* Assumes rig!=NULL, rig->state.priv!=NULL
*/
int icom_get_vfo(RIG *rig, vfo_t *vfo)
{
unsigned char ackbuf[MAXFRAMELEN];
int ack_len=sizeof(ackbuf), retval;
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
retval = icom_transaction (rig, C_SET_VFO, S_SUB_SEL, NULL, 0,
ackbuf, &ack_len);
if (retval != RIG_OK)
return retval;
if (ack_len != 3) {
rig_debug(RIG_DEBUG_ERR,"%s wrong frame len=%d\n", ack_len);
return -RIG_ERJCTED;
}
*vfo = ackbuf[2] == 0 ? RIG_VFO_A : RIG_VFO_B;
return RIG_OK;
}
/*
* icom_get_vfo
* Assumes rig!=NULL, rig->state.priv!=NULL
*/
int icom_set_vfo(RIG *rig, vfo_t vfo)
@ -963,6 +1050,7 @@ int icom_set_vfo(RIG *rig, vfo_t vfo)
if (vfo == RIG_VFO_CURR)
return RIG_OK;
switch(vfo) {
case RIG_VFO_A: icvfo = S_VFOA; break;
case RIG_VFO_B: icvfo = S_VFOB; break;
@ -3273,7 +3361,7 @@ int icom_set_powerstat(RIG *rig, powerstat_t status)
unsigned char fe_buf[200]; // for FE's to power up
int fe_len = 0;
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
rig_debug(RIG_DEBUG_VERBOSE, "%s called status=\n", __func__,status);
switch (status) {
case RIG_POWER_ON:
pwr_sc = RIG_POWER_ON;
@ -3289,15 +3377,33 @@ int icom_set_powerstat(RIG *rig, powerstat_t status)
}
// we can ignore this retval
// sending more than enough 0xfe's to take up the rs232
// sending more than enough 0xfe's to wake up the rs232
icom_transaction(rig, 0xfe, 0xfe, fe_buf, fe_len,
ackbuf, &ack_len);
retval = icom_transaction(rig, C_SET_PWR, pwr_sc, NULL, 0,
ackbuf, &ack_len);
rig_debug(RIG_DEBUG_VERBOSE, "%s #2 called retval=%d\n", __func__,retval);
int i=0;
int retry = 3/rig->state.rigport.retry;
if (status==RIG_POWER_ON) { // wait for wakeup only
for(i=0;i<retry;++i) { // up to 10 attempts
sleep(1);
freq_t freq = 0;
// Use get_freq as all rigs should repond to this
retval = rig_get_freq(rig, RIG_VFO_A, &freq);
if (retval == RIG_OK) return retval;
rig_debug(RIG_DEBUG_TRACE,"%s: Wait %d of %d for get_powerstat\n",__func__,i+1,retry);
}
}
if (i==retry) {
rig_debug(RIG_DEBUG_TRACE,"%s: Wait failed for get_powerstat\n",__func__,i+1);
retval = -RIG_ETIMEOUT;
}
if (retval != RIG_OK)
return retval;
if (ack_len != 1 || ackbuf[0] != ACK) {
if (status==RIG_POWER_OFF && (ack_len != 1 || ackbuf[0] != ACK)) {
rig_debug(RIG_DEBUG_ERR,"icom_set_powerstat: ack NG (%#.2x), "
"len=%d\n", ackbuf[0],ack_len);
return -RIG_ERJCTED;
@ -3997,6 +4103,7 @@ DECLARE_INITRIG_BACKEND(icom)
rig_register(&ic910_caps);
rig_register(&ic9100_caps);
rig_register(&ic970_caps);
rig_register(&ic9700_caps);
rig_register(&icrx7_caps);
rig_register(&icr6_caps);

4
icom/icom.h
Wyświetl plik

@ -30,7 +30,7 @@
#include <sys/time.h>
#endif
#define BACKEND_VER "0.8"
#define BACKEND_VER "0.9"
/*
* defines used by comp_cal_str in rig.c
@ -160,6 +160,7 @@ int icom_set_mode_with_data(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width);
int icom_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width);
int icom_get_mode_with_data(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width);
int icom_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width);
int icom_get_vfo(RIG *rig, vfo_t *vfo);
int icom_set_vfo(RIG *rig, vfo_t vfo);
int icom_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift);
int icom_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift);
@ -252,6 +253,7 @@ extern const struct rig_caps ic821h_caps;
extern const struct rig_caps ic910_caps;
extern const struct rig_caps ic9100_caps;
extern const struct rig_caps ic970_caps;
extern const struct rig_caps ic9700_caps;
extern const struct rig_caps icrx7_caps;
extern const struct rig_caps icr10_caps;
extern const struct rig_caps icr20_caps;

3
icom/icom_defs.h
Wyświetl plik

@ -93,6 +93,7 @@
#define C_SET_TONE 0x1b /* Set tone frequency */
#define C_CTL_PTT 0x1c /* Control Transmit On/Off, Sc */
#define C_CTL_DIG 0x20 /* Digital modes settings & status */
#define C_SEND_SEL_FREQ 0x25 /* Send/Recv sel/unsel VFO frequency */
#define C_CTL_MTEXT 0x70 /* Microtelecom Extension */
#define C_CTL_MISC 0x7f /* Miscellaneous control, Sc */
@ -126,6 +127,7 @@
#define S_NXDNVN 0x19 /* Set to NXDN_VN */
#define S_NXDN_N 0x20 /* Set to NXDN-N */
#define S_DCR 0x21 /* Set to DCR */
#define S_DD 0x22 /* Set to DD 1200Mhz only? */
#define S_R7000_SSB 0x05 /* Set to SSB on R-7000 */
@ -151,6 +153,7 @@
#define S_DUAL_ON 0xc1 /* Dual watch on */
#define S_MAIN 0xd0 /* Select MAIN band */
#define S_SUB 0xd1 /* Select SUB band */
#define S_SUB_SEL 0xd2 /* Read/Set Main/Sub selection */
#define S_FRONTWIN 0xe0 /* Select front window */
/*

3
include/bandplan.h
Wyświetl plik

@ -241,6 +241,9 @@
#define FRQ_RNG_70cm(r,m,lp,hp,v,a) \
FRQ_RNG_70cm_REGION##r((m), (lp), (hp), (v), (a)) \
#define FRQ_RNG_23cm(r,m,lp,hp,v,a) \
FRQ_RNG_23cm_REGION##r((m), (lp), (hp), (v), (a)) \
#endif /* _BANDPLAN_H */

2
include/hamlib/rig.h
Wyświetl plik

@ -926,7 +926,7 @@ typedef uint64_t rmode_t;
#define RIG_MODE_PSKR CONSTANT_64BIT_FLAG (31) /*!< \c PSKR - Kenwood PSKR and others */
#ifndef SWIGLUA
/* hide the top 32 bits from the Lua binding as they will not work */
#define RIG_MODE_BIT32 CONSTANT_64BIT_FLAG (32) /* reserved for future expansion */
#define RIG_MODE_DD CONSTANT_64BIT_FLAG (32) /* DD Mode IC-9700 */
#define RIG_MODE_BIT33 CONSTANT_64BIT_FLAG (33) /* reserved for future expansion */
#define RIG_MODE_BIT34 CONSTANT_64BIT_FLAG (34) /* reserved for future expansion */
#define RIG_MODE_BIT35 CONSTANT_64BIT_FLAG (35) /* reserved for future expansion */

3
include/hamlib/riglist.h
Wyświetl plik

@ -236,7 +236,8 @@
#define RIG_MODEL_IC7610 RIG_MAKE_MODEL(RIG_ICOM, 78)
#define RIG_MODEL_ICR8600 RIG_MAKE_MODEL(RIG_ICOM, 79)
#define RIG_MODEL_ICR30 RIG_MAKE_MODEL(RIG_ICOM, 80)
/* next one is 81 */
#define RIG_MODEL_IC9700 RIG_MAKE_MODEL(RIG_ICOM, 81)
/* next one is 82 */
/*

49
kenwood/kenwood.c
Wyświetl plik

@ -756,7 +756,7 @@ int kenwood_set_vfo(RIG *rig, vfo_t vfo)
return RIG_OK;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo));
return -RIG_EINVAL;
}
@ -831,7 +831,7 @@ int kenwood_set_vfo_main_sub(RIG *rig, vfo_t vfo)
return RIG_OK;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo));
return -RIG_EINVAL;
}
@ -896,7 +896,7 @@ int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
case RIG_VFO_B: vfo_function = '1'; break;
case RIG_VFO_MEM: vfo_function = '2'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo));
return -RIG_EINVAL;
}
/* set RX VFO */
@ -922,7 +922,7 @@ int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
case RIG_VFO_B: vfo_function = '1'; break;
case RIG_VFO_MEM: vfo_function = '2'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, txvfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(txvfo));
return -RIG_EINVAL;
}
if (RIG_MODEL_K2 == rig->caps->rig_model
@ -1144,7 +1144,7 @@ int kenwood_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
vfo_letter = 'C';
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo));
return -RIG_EINVAL;
}
snprintf(freqbuf, sizeof (freqbuf), "F%c%011"PRIll, vfo_letter, (int64_t)freq);
@ -1255,7 +1255,7 @@ int kenwood_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
vfo_letter = 'C';
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo));
return -RIG_EINVAL;
}
@ -1609,7 +1609,7 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
case RIG_VFO_MAIN: c = '0'; break;
case RIG_VFO_SUB: c = '1'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo));
return -RIG_EINVAL;
}
snprintf(cmd, sizeof (cmd), "OM%c", c);
@ -2312,7 +2312,7 @@ int kenwood_set_ctcss_tone_tn(RIG *rig, vfo_t vfo, tone_t tone)
case RIG_VFO_MAIN: c = '0'; break;
case RIG_VFO_SUB: c = '1'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo));
return -RIG_EINVAL;
}
snprintf(buf, sizeof (buf), "TN%c%02d", c, i + 1);
@ -2362,7 +2362,7 @@ int kenwood_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone)
case RIG_VFO_MAIN: c = '0'; break;
case RIG_VFO_SUB: c = '1'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo));
return -RIG_EINVAL;
}
snprintf(cmd, sizeof (cmd), "TN%c", c);
@ -2436,7 +2436,7 @@ int kenwood_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
case RIG_VFO_MAIN: c = '0'; break;
case RIG_VFO_SUB: c = '1'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo));
return -RIG_EINVAL;
}
snprintf(buf, sizeof (buf), "CN%c%02d", c, i + 1);
@ -2480,7 +2480,7 @@ int kenwood_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone)
case RIG_VFO_MAIN: c = '0'; break;
case RIG_VFO_SUB: c = '1'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo));
return -RIG_EINVAL;
}
snprintf(cmd, sizeof (cmd), "CN%c", c);
@ -2557,7 +2557,7 @@ int kenwood_set_ant(RIG * rig, vfo_t vfo, ant_t ant)
case RIG_VFO_MAIN: c = '0'; break;
case RIG_VFO_SUB: c = '1'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo));
return -RIG_EINVAL;
}
snprintf (cmd, sizeof (cmd), "AN0%c%c99", c, a);
@ -2791,12 +2791,29 @@ int kenwood_get_trn(RIG *rig, int *trn)
*/
int kenwood_set_powerstat(RIG *rig, powerstat_t status)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
rig_debug(RIG_DEBUG_VERBOSE, "%s called status=%d\n", __func__, status);
if (!rig)
return -RIG_EINVAL;
return kenwood_transaction(rig, (status == RIG_POWER_ON) ? "PS1" : "PS0", NULL, 0);
int retval = kenwood_transaction(rig, (status == RIG_POWER_ON) ? "PS1" : "PS0", NULL, 0);
int i=0;
int retry=3/rig->state.rigport.retry;
if (status==RIG_POWER_ON) { // wait for wakeup only
for(i=0;i<retry;++i) { // up to 10 seconds
sleep(1);
freq_t freq;
retval = rig_get_freq(rig, RIG_VFO_A, &freq);
if (retval == RIG_OK) return retval;
rig_debug(RIG_DEBUG_TRACE,"%s: Wait %d of %d for power up\n",__func__,i+1,retry);
}
}
if (i==retry) {
rig_debug(RIG_DEBUG_TRACE,"%s: timeout waiting for powerup\n",__func__,i+1);
retval = -RIG_ETIMEOUT;
}
return retval;
}
/*
@ -2991,7 +3008,7 @@ int kenwood_set_mem(RIG *rig, vfo_t vfo, int ch)
case RIG_VFO_MAIN: c = '0'; break;
case RIG_VFO_SUB: c = '1'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo));
return -RIG_EINVAL;
}
snprintf (buf, sizeof (buf), "MN%c%03d", c, ch);
@ -3039,7 +3056,7 @@ int kenwood_get_mem(RIG *rig, vfo_t vfo, int *ch)
case RIG_VFO_MAIN: c = '0'; break;
case RIG_VFO_SUB: c = '1'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__, rig_strvfo(vfo));
return -RIG_EINVAL;
}
snprintf (cmd, sizeof (cmd), "MN%c", c);

2
kenwood/kenwood.h
Wyświetl plik

@ -27,7 +27,7 @@
#include <string.h>
#include "token.h"
#define BACKEND_VER "1.1"
#define BACKEND_VER "1.2"
#define EOM_KEN ';'
#define EOM_TH '\r'

3232
kenwood/th.c
Wyświetl plik

Plik diff jest za duży Load Diff

2078
kenwood/thd72.c
Wyświetl plik

Plik diff jest za duży Load Diff

703
kenwood/ts590.c
Wyświetl plik

@ -32,7 +32,8 @@
/* Function declarations */
const char* ts590_get_info(RIG *rig);
const char *ts590_get_info(RIG *rig);
int ts590_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val);
#define TS590_ALL_MODES (RIG_MODE_AM|RIG_MODE_CW|RIG_MODE_CWR|RIG_MODE_SSB|RIG_MODE_FM|RIG_MODE_RTTY|RIG_MODE_RTTYR|RIG_MODE_PKTFM|RIG_MODE_PKTUSB|RIG_MODE_PKTLSB)
#define TS590_OTHER_TX_MODES (RIG_MODE_CW|RIG_MODE_SSB|RIG_MODE_FM|RIG_MODE_RTTY)
@ -73,8 +74,9 @@ const char* ts590_get_info(RIG *rig);
}
static struct kenwood_priv_caps ts590_priv_caps = {
.cmdtrm = EOM_KEN,
static struct kenwood_priv_caps ts590_priv_caps =
{
.cmdtrm = EOM_KEN,
};
@ -83,340 +85,342 @@ static struct kenwood_priv_caps ts590_priv_caps = {
* Notice that some rigs share the same functions.
* Also this struct is READONLY!
*/
const struct rig_caps ts590_caps = {
.rig_model = RIG_MODEL_TS590S,
.model_name = "TS-590S",
.mfg_name = "Kenwood",
.version = BACKEND_VER ".1",
.copyright = "LGPL",
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TRANSCEIVER,
.ptt_type = RIG_PTT_RIG_MICDATA,
.dcd_type = RIG_DCD_RIG,
.port_type = RIG_PORT_SERIAL,
.serial_rate_min = 4800,
.serial_rate_max = 115200,
.serial_data_bits = 8,
.serial_stop_bits = 1,
.serial_parity = RIG_PARITY_NONE,
.serial_handshake = RIG_HANDSHAKE_HARDWARE,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 500,
.retry = 10,
.preamp = {12, RIG_DBLST_END,},
.attenuator = {12, 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,
const struct rig_caps ts590_caps =
{
.rig_model = RIG_MODEL_TS590S,
.model_name = "TS-590S",
.mfg_name = "Kenwood",
.version = BACKEND_VER ".2",
.copyright = "LGPL",
.status = RIG_STATUS_STABLE,
.rig_type = RIG_TYPE_TRANSCEIVER,
.ptt_type = RIG_PTT_RIG_MICDATA,
.dcd_type = RIG_DCD_RIG,
.port_type = RIG_PORT_SERIAL,
.serial_rate_min = 4800,
.serial_rate_max = 115200,
.serial_data_bits = 8,
.serial_stop_bits = 1,
.serial_parity = RIG_PARITY_NONE,
.serial_handshake = RIG_HANDSHAKE_HARDWARE,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 500,
.retry = 10,
.preamp = {12, RIG_DBLST_END,},
.attenuator = {12, 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,
.chan_list = { /* TBC */
{ 0, 89, RIG_MTYPE_MEM, TS590_CHANNEL_CAPS },
{ 90, 99, RIG_MTYPE_EDGE, TS590_CHANNEL_CAPS },
RIG_CHAN_END,
.chan_list = { /* TBC */
{ 0, 89, RIG_MTYPE_MEM, TS590_CHANNEL_CAPS },
{ 90, 99, RIG_MTYPE_EDGE, TS590_CHANNEL_CAPS },
RIG_CHAN_END,
},
.rx_range_list1 = {
{kHz(30), Hz(59999999), TS590_ALL_MODES, -1, -1, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Receive frequency range list for ITU region 1 */
.tx_range_list1 = {
{kHz(1810), kHz(1850), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS}, /* 100W class */
{kHz(1810), kHz(1850), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS}, /* 25W class */
{kHz(3500), kHz(3800), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(3500), kHz(3800), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7200), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7200), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Transmit frequency range list for ITU region 1 */
.rx_range_list2 = {
{kHz(30), Hz(59999999), TS590_ALL_MODES, -1, -1, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Receive frequency range list for ITU region 2 */
.tx_range_list2 = {
{kHz(1800), MHz(2) - 1, TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS}, /* 100W class */
{kHz(1800), MHz(2) - 1, TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS}, /* 25W class */
{kHz(3500), MHz(4) - 1, TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(3500), MHz(4) - 1, TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(5250), kHz(5450), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(5250), kHz(5450), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7300), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7300), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Transmit frequency range list for ITU region 2 */
.tuning_steps = {
{TS590_ALL_MODES,kHz(1)},
{TS590_ALL_MODES,Hz(2500)},
{TS590_ALL_MODES,kHz(5)},
{TS590_ALL_MODES,Hz(6250)},
{TS590_ALL_MODES,kHz(10)},
{TS590_ALL_MODES,Hz(12500)},
{TS590_ALL_MODES,kHz(15)},
{TS590_ALL_MODES,kHz(20)},
{TS590_ALL_MODES,kHz(25)},
{TS590_ALL_MODES,kHz(30)},
{TS590_ALL_MODES,kHz(100)},
{TS590_ALL_MODES,kHz(500)},
{TS590_ALL_MODES,MHz(1)},
{TS590_ALL_MODES,0}, /* any tuning step */
RIG_TS_END,
},
/* mode/filter list, remember: order matters! */
.filters = {
{RIG_MODE_SSB, kHz(2.2)},
{RIG_MODE_CW|RIG_MODE_CWR|RIG_MODE_RTTY|RIG_MODE_RTTYR, Hz(500)},
{RIG_MODE_AM, kHz(6)},
{RIG_MODE_FM, kHz(12)},
RIG_FLT_END,
},
.str_cal = TS590_STR_CAL,
.priv = (void *) &ts590_priv_caps,
.rig_init = kenwood_init,
.rig_cleanup = kenwood_cleanup,
.rig_open = kenwood_open,
.rig_close = kenwood_close,
.set_freq = kenwood_set_freq,
.get_freq = kenwood_get_freq,
.set_rit = kenwood_set_rit, /* FIXME should this switch to rit mode or just set the frequency? */
.get_rit = kenwood_get_rit,
.set_xit = kenwood_set_xit, /* FIXME should this switch to xit mode or just set the frequency? */
.get_xit = kenwood_get_xit,
.set_mode = kenwood_set_mode,
.get_mode = kenwood_get_mode,
.set_vfo = kenwood_set_vfo,
.get_vfo = kenwood_get_vfo_if,
.set_split_vfo = kenwood_set_split_vfo,
.get_split_vfo = kenwood_get_split_vfo_if,
.get_ptt = kenwood_get_ptt,
.set_ptt = kenwood_set_ptt,
.get_dcd = kenwood_get_dcd,
.set_powerstat = kenwood_set_powerstat,
.get_powerstat = kenwood_get_powerstat,
.get_info = ts590_get_info,
.reset = kenwood_reset,
.set_ant = kenwood_set_ant,
.get_ant = kenwood_get_ant,
.scan_ops = TS590_SCAN_OPS,
.scan = kenwood_scan, /* not working, invalid arguments using rigctl; kenwood_scan does only support on/off and not tone and CTCSS scan */
.has_set_level = RIG_LEVEL_SET(TS590_LEVEL_ALL),
.has_get_level = TS590_LEVEL_ALL,
.set_level = kenwood_set_level,
.get_level = kenwood_get_level,
.has_get_func = TS590_FUNC_ALL,
.has_set_func = TS590_FUNC_ALL,
.set_func = kenwood_set_func,
.get_func = kenwood_get_func,
.set_ctcss_tone = kenwood_set_ctcss_tone,
.get_ctcss_tone = kenwood_get_ctcss_tone,
.ctcss_list = kenwood38_ctcss_list,
.set_trn = kenwood_set_trn,
.get_trn = kenwood_get_trn,
.send_morse = kenwood_send_morse,
.set_mem = kenwood_set_mem,
.get_mem = kenwood_get_mem,
.set_channel = kenwood_set_channel,
.get_channel = kenwood_get_channel,
.vfo_ops = TS590_VFO_OPS,
.vfo_op = kenwood_vfo_op,
.rx_range_list1 = {
{kHz(30), Hz(59999999), TS590_ALL_MODES, -1, -1, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Receive frequency range list for ITU region 1 */
.tx_range_list1 = {
{kHz(1810), kHz(1850), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS}, /* 100W class */
{kHz(1810), kHz(1850), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS}, /* 25W class */
{kHz(3500), kHz(3800), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(3500), kHz(3800), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7200), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7200), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Transmit frequency range list for ITU region 1 */
.rx_range_list2 = {
{kHz(30), Hz(59999999), TS590_ALL_MODES, -1, -1, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Receive frequency range list for ITU region 2 */
.tx_range_list2 = {
{kHz(1800), MHz(2) - 1, TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS}, /* 100W class */
{kHz(1800), MHz(2) - 1, TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS}, /* 25W class */
{kHz(3500), MHz(4) - 1, TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(3500), MHz(4) - 1, TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(5250), kHz(5450), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(5250), kHz(5450), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7300), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7300), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Transmit frequency range list for ITU region 2 */
.tuning_steps = {
{TS590_ALL_MODES, kHz(1)},
{TS590_ALL_MODES, Hz(2500)},
{TS590_ALL_MODES, kHz(5)},
{TS590_ALL_MODES, Hz(6250)},
{TS590_ALL_MODES, kHz(10)},
{TS590_ALL_MODES, Hz(12500)},
{TS590_ALL_MODES, kHz(15)},
{TS590_ALL_MODES, kHz(20)},
{TS590_ALL_MODES, kHz(25)},
{TS590_ALL_MODES, kHz(30)},
{TS590_ALL_MODES, kHz(100)},
{TS590_ALL_MODES, kHz(500)},
{TS590_ALL_MODES, MHz(1)},
{TS590_ALL_MODES, 0}, /* any tuning step */
RIG_TS_END,
},
/* mode/filter list, remember: order matters! */
.filters = {
{RIG_MODE_SSB, kHz(2.2)},
{RIG_MODE_CW | RIG_MODE_CWR | RIG_MODE_RTTY | RIG_MODE_RTTYR, Hz(500)},
{RIG_MODE_AM, kHz(6)},
{RIG_MODE_FM, kHz(12)},
RIG_FLT_END,
},
.str_cal = TS590_STR_CAL,
.priv = (void *)& ts590_priv_caps,
.rig_init = kenwood_init,
.rig_cleanup = kenwood_cleanup,
.rig_open = kenwood_open,
.rig_close = kenwood_close,
.set_freq = kenwood_set_freq,
.get_freq = kenwood_get_freq,
.set_rit = kenwood_set_rit, /* FIXME should this switch to rit mode or just set the frequency? */
.get_rit = kenwood_get_rit,
.set_xit = kenwood_set_xit, /* FIXME should this switch to xit mode or just set the frequency? */
.get_xit = kenwood_get_xit,
.set_mode = kenwood_set_mode,
.get_mode = kenwood_get_mode,
.set_vfo = kenwood_set_vfo,
.get_vfo = kenwood_get_vfo_if,
.set_split_vfo = kenwood_set_split_vfo,
.get_split_vfo = kenwood_get_split_vfo_if,
.get_ptt = kenwood_get_ptt,
.set_ptt = kenwood_set_ptt,
.get_dcd = kenwood_get_dcd,
.set_powerstat = kenwood_set_powerstat,
.get_powerstat = kenwood_get_powerstat,
.get_info = ts590_get_info,
.reset = kenwood_reset,
.set_ant = kenwood_set_ant,
.get_ant = kenwood_get_ant,
.scan_ops = TS590_SCAN_OPS,
.scan = kenwood_scan, /* not working, invalid arguments using rigctl; kenwood_scan does only support on/off and not tone and CTCSS scan */
.has_set_level = RIG_LEVEL_SET(TS590_LEVEL_ALL),
.has_get_level = TS590_LEVEL_ALL,
.set_level = kenwood_set_level,
.get_level = ts590_get_level,
.has_get_func = TS590_FUNC_ALL,
.has_set_func = TS590_FUNC_ALL,
.set_func = kenwood_set_func,
.get_func = kenwood_get_func,
.set_ctcss_tone = kenwood_set_ctcss_tone,
.get_ctcss_tone = kenwood_get_ctcss_tone,
.ctcss_list = kenwood38_ctcss_list,
.set_trn = kenwood_set_trn,
.get_trn = kenwood_get_trn,
.send_morse = kenwood_send_morse,
.set_mem = kenwood_set_mem,
.get_mem = kenwood_get_mem,
.set_channel = kenwood_set_channel,
.get_channel = kenwood_get_channel,
.vfo_ops = TS590_VFO_OPS,
.vfo_op = kenwood_vfo_op,
};
const struct rig_caps ts590sg_caps = {
.rig_model = RIG_MODEL_TS590SG,
.model_name = "TS-590SG",
.mfg_name = "Kenwood",
.version = BACKEND_VER ".1",
.copyright = "LGPL",
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TRANSCEIVER,
.ptt_type = RIG_PTT_RIG_MICDATA,
.dcd_type = RIG_DCD_RIG,
.port_type = RIG_PORT_SERIAL,
.serial_rate_min = 4800,
.serial_rate_max = 115200,
.serial_data_bits = 8,
.serial_stop_bits = 1,
.serial_parity = RIG_PARITY_NONE,
.serial_handshake = RIG_HANDSHAKE_HARDWARE,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 500,
.retry = 10,
.preamp = {12, RIG_DBLST_END,},
.attenuator = {12, 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,
const struct rig_caps ts590sg_caps =
{
.rig_model = RIG_MODEL_TS590SG,
.model_name = "TS-590SG",
.mfg_name = "Kenwood",
.version = BACKEND_VER ".1",
.copyright = "LGPL",
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TRANSCEIVER,
.ptt_type = RIG_PTT_RIG_MICDATA,
.dcd_type = RIG_DCD_RIG,
.port_type = RIG_PORT_SERIAL,
.serial_rate_min = 4800,
.serial_rate_max = 115200,
.serial_data_bits = 8,
.serial_stop_bits = 1,
.serial_parity = RIG_PARITY_NONE,
.serial_handshake = RIG_HANDSHAKE_HARDWARE,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 500,
.retry = 10,
.preamp = {12, RIG_DBLST_END,},
.attenuator = {12, 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,
.chan_list = { /* TBC */
{ 0, 89, RIG_MTYPE_MEM, TS590_CHANNEL_CAPS },
{ 90, 99, RIG_MTYPE_EDGE, TS590_CHANNEL_CAPS },
RIG_CHAN_END,
.chan_list = { /* TBC */
{ 0, 89, RIG_MTYPE_MEM, TS590_CHANNEL_CAPS },
{ 90, 99, RIG_MTYPE_EDGE, TS590_CHANNEL_CAPS },
RIG_CHAN_END,
},
.rx_range_list1 = {
{kHz(30), Hz(59999999), TS590_ALL_MODES, -1, -1, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Receive frequency range list for ITU region 1 */
.tx_range_list1 = {
{kHz(1810), kHz(1850), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS}, /* 100W class */
{kHz(1810), kHz(1850), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS}, /* 25W class */
{kHz(3500), kHz(3800), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(3500), kHz(3800), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7200), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7200), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Transmit frequency range list for ITU region 1 */
.rx_range_list2 = {
{kHz(30), Hz(59999999), TS590_ALL_MODES, -1, -1, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Receive frequency range list for ITU region 2 */
.tx_range_list2 = {
{kHz(1800), MHz(2) - 1, TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS}, /* 100W class */
{kHz(1800), MHz(2) - 1, TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS}, /* 25W class */
{kHz(3500), MHz(4) - 1, TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(3500), MHz(4) - 1, TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(5250), kHz(5450), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(5250), kHz(5450), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7300), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7300), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Transmit frequency range list for ITU region 2 */
.tuning_steps = {
{TS590_ALL_MODES,kHz(1)},
{TS590_ALL_MODES,Hz(2500)},
{TS590_ALL_MODES,kHz(5)},
{TS590_ALL_MODES,Hz(6250)},
{TS590_ALL_MODES,kHz(10)},
{TS590_ALL_MODES,Hz(12500)},
{TS590_ALL_MODES,kHz(15)},
{TS590_ALL_MODES,kHz(20)},
{TS590_ALL_MODES,kHz(25)},
{TS590_ALL_MODES,kHz(30)},
{TS590_ALL_MODES,kHz(100)},
{TS590_ALL_MODES,kHz(500)},
{TS590_ALL_MODES,MHz(1)},
{TS590_ALL_MODES,0}, /* any tuning step */
RIG_TS_END,
},
/* mode/filter list, remember: order matters! */
.filters = {
{RIG_MODE_SSB, kHz(2.2)},
{RIG_MODE_CW|RIG_MODE_CWR|RIG_MODE_RTTY|RIG_MODE_RTTYR, Hz(500)},
{RIG_MODE_AM, kHz(6)},
{RIG_MODE_FM, kHz(12)},
RIG_FLT_END,
},
.str_cal = TS590_STR_CAL,
.priv = (void *) &ts590_priv_caps,
.rig_init = kenwood_init,
.rig_cleanup = kenwood_cleanup,
.rig_open = kenwood_open,
.rig_close = kenwood_close,
.set_freq = kenwood_set_freq,
.get_freq = kenwood_get_freq,
.set_rit = kenwood_set_rit, /* FIXME should this switch to rit mode or just set the frequency? */
.get_rit = kenwood_get_rit,
.set_xit = kenwood_set_xit, /* FIXME should this switch to xit mode or just set the frequency? */
.get_xit = kenwood_get_xit,
.set_mode = kenwood_set_mode,
.get_mode = kenwood_get_mode,
.set_vfo = kenwood_set_vfo,
.get_vfo = kenwood_get_vfo_if,
.set_split_vfo = kenwood_set_split_vfo,
.get_split_vfo = kenwood_get_split_vfo_if,
.get_ptt = kenwood_get_ptt,
.set_ptt = kenwood_set_ptt,
.get_dcd = kenwood_get_dcd,
.set_powerstat = kenwood_set_powerstat,
.get_powerstat = kenwood_get_powerstat,
.get_info = kenwood_get_info,
.reset = kenwood_reset,
.set_ant = kenwood_set_ant,
.get_ant = kenwood_get_ant,
.scan_ops = TS590_SCAN_OPS,
.scan = kenwood_scan, /* not working, invalid arguments using rigctl; kenwood_scan does only support on/off and not tone and CTCSS scan */
.has_set_level = RIG_LEVEL_SET(TS590_LEVEL_ALL),
.has_get_level = TS590_LEVEL_ALL,
.set_level = kenwood_set_level,
.get_level = kenwood_get_level,
.has_get_func = TS590_FUNC_ALL,
.has_set_func = TS590_FUNC_ALL,
.set_func = kenwood_set_func,
.get_func = kenwood_get_func,
.set_ctcss_tone = kenwood_set_ctcss_tone,
.get_ctcss_tone = kenwood_get_ctcss_tone,
.ctcss_list = kenwood38_ctcss_list,
.set_trn = kenwood_set_trn,
.get_trn = kenwood_get_trn,
.send_morse = kenwood_send_morse,
.set_mem = kenwood_set_mem,
.get_mem = kenwood_get_mem,
.set_channel = kenwood_set_channel,
.get_channel = kenwood_get_channel,
.vfo_ops = TS590_VFO_OPS,
.vfo_op = kenwood_vfo_op,
.rx_range_list1 = {
{kHz(30), Hz(59999999), TS590_ALL_MODES, -1, -1, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Receive frequency range list for ITU region 1 */
.tx_range_list1 = {
{kHz(1810), kHz(1850), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS}, /* 100W class */
{kHz(1810), kHz(1850), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS}, /* 25W class */
{kHz(3500), kHz(3800), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(3500), kHz(3800), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7200), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7200), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Transmit frequency range list for ITU region 1 */
.rx_range_list2 = {
{kHz(30), Hz(59999999), TS590_ALL_MODES, -1, -1, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Receive frequency range list for ITU region 2 */
.tx_range_list2 = {
{kHz(1800), MHz(2) - 1, TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS}, /* 100W class */
{kHz(1800), MHz(2) - 1, TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS}, /* 25W class */
{kHz(3500), MHz(4) - 1, TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(3500), MHz(4) - 1, TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(5250), kHz(5450), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(5250), kHz(5450), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7300), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(7), kHz(7300), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(10100), kHz(10150), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(14), kHz(14350), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(18068), kHz(18168), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(21), kHz(21450), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{kHz(24890), kHz(24990), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(28), kHz(29700), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_OTHER_TX_MODES, 5000, 100000, TS590_VFO, TS590_ANTS},
{MHz(50), kHz(52000), TS590_AM_TX_MODES, 5000, 25000, TS590_VFO, TS590_ANTS},
RIG_FRNG_END,
}, /*!< Transmit frequency range list for ITU region 2 */
.tuning_steps = {
{TS590_ALL_MODES, kHz(1)},
{TS590_ALL_MODES, Hz(2500)},
{TS590_ALL_MODES, kHz(5)},
{TS590_ALL_MODES, Hz(6250)},
{TS590_ALL_MODES, kHz(10)},
{TS590_ALL_MODES, Hz(12500)},
{TS590_ALL_MODES, kHz(15)},
{TS590_ALL_MODES, kHz(20)},
{TS590_ALL_MODES, kHz(25)},
{TS590_ALL_MODES, kHz(30)},
{TS590_ALL_MODES, kHz(100)},
{TS590_ALL_MODES, kHz(500)},
{TS590_ALL_MODES, MHz(1)},
{TS590_ALL_MODES, 0}, /* any tuning step */
RIG_TS_END,
},
/* mode/filter list, remember: order matters! */
.filters = {
{RIG_MODE_SSB, kHz(2.2)},
{RIG_MODE_CW | RIG_MODE_CWR | RIG_MODE_RTTY | RIG_MODE_RTTYR, Hz(500)},
{RIG_MODE_AM, kHz(6)},
{RIG_MODE_FM, kHz(12)},
RIG_FLT_END,
},
.str_cal = TS590_STR_CAL,
.priv = (void *)& ts590_priv_caps,
.rig_init = kenwood_init,
.rig_cleanup = kenwood_cleanup,
.rig_open = kenwood_open,
.rig_close = kenwood_close,
.set_freq = kenwood_set_freq,
.get_freq = kenwood_get_freq,
.set_rit = kenwood_set_rit, /* FIXME should this switch to rit mode or just set the frequency? */
.get_rit = kenwood_get_rit,
.set_xit = kenwood_set_xit, /* FIXME should this switch to xit mode or just set the frequency? */
.get_xit = kenwood_get_xit,
.set_mode = kenwood_set_mode,
.get_mode = kenwood_get_mode,
.set_vfo = kenwood_set_vfo,
.get_vfo = kenwood_get_vfo_if,
.set_split_vfo = kenwood_set_split_vfo,
.get_split_vfo = kenwood_get_split_vfo_if,
.get_ptt = kenwood_get_ptt,
.set_ptt = kenwood_set_ptt,
.get_dcd = kenwood_get_dcd,
.set_powerstat = kenwood_set_powerstat,
.get_powerstat = kenwood_get_powerstat,
.get_info = kenwood_get_info,
.reset = kenwood_reset,
.set_ant = kenwood_set_ant,
.get_ant = kenwood_get_ant,
.scan_ops = TS590_SCAN_OPS,
.scan = kenwood_scan, /* not working, invalid arguments using rigctl; kenwood_scan does only support on/off and not tone and CTCSS scan */
.has_set_level = RIG_LEVEL_SET(TS590_LEVEL_ALL),
.has_get_level = TS590_LEVEL_ALL,
.set_level = kenwood_set_level,
.get_level = kenwood_get_level,
.has_get_func = TS590_FUNC_ALL,
.has_set_func = TS590_FUNC_ALL,
.set_func = kenwood_set_func,
.get_func = kenwood_get_func,
.set_ctcss_tone = kenwood_set_ctcss_tone,
.get_ctcss_tone = kenwood_get_ctcss_tone,
.ctcss_list = kenwood38_ctcss_list,
.set_trn = kenwood_set_trn,
.get_trn = kenwood_get_trn,
.send_morse = kenwood_send_morse,
.set_mem = kenwood_set_mem,
.get_mem = kenwood_get_mem,
.set_channel = kenwood_set_channel,
.get_channel = kenwood_get_channel,
.vfo_ops = TS590_VFO_OPS,
.vfo_op = kenwood_vfo_op,
};
@ -429,23 +433,46 @@ const struct rig_caps ts590sg_caps = {
* This is not documented in the manual as of 3/11/15 but confirmed from Kenwood
* "TY" produces "TYK 00" for example
*/
const char* ts590_get_info(RIG *rig)
const char *ts590_get_info(RIG *rig)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
if (!rig)
return "*rig == NULL";
if (!rig)
{
return "*rig == NULL";
}
char firmbuf[10];
int retval;
char firmbuf[10];
int retval;
retval = kenwood_safe_transaction(rig, "TY", firmbuf, 10, 6);
if (retval != RIG_OK)
return NULL;
retval = kenwood_safe_transaction(rig, "TY", firmbuf, 10, 6);
switch (firmbuf[2]) {
if (retval != RIG_OK)
{
return NULL;
}
switch (firmbuf[2])
{
case 'K': return "Firmware: USA version";
case 'E': return "Firmware: European version";
default: return "Firmware: unknown";
}
}
}
/*
* ts590_get_level
* only difference from standard Kenwood is AF level which has an argument
*/
int ts590_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
switch (level)
{
case RIG_LEVEL_AF:
return get_kenwood_level(rig, "AG0", &val->f);
default: return rig_get_level(rig, vfo, level, val);
}
}

2
lib/termios.c
Wyświetl plik

@ -3347,7 +3347,7 @@ fail:
report( message );
errno = EBADFD;
LEAVE( "serial_select" );
return( 1 );
return( -1 );
}
#ifdef asdf
int win32_serial_select( int n, fd_set *readfds, fd_set *writefds,

1
src/serial.c
Wyświetl plik

@ -194,6 +194,7 @@ int HAMLIB_API serial_open(hamlib_port_t *rp)
CLOSE(fd);
return err;
}
serial_flush(rp); // ensure nothing is there when we open
return RIG_OK;
}

1
tentec/orion.c
Wyświetl plik

@ -127,6 +127,7 @@ static int tt565_transaction(RIG *rig, const char *cmd, int cmd_len, char *data,
/* Allow transaction re-tries according to capabilities. */
for (itry=0; itry < rig->caps->retry; itry++) {
rs = &rig->state;
serial_flush(&rs->rigport); /* discard pending i/p */
retval = write_block(&rs->rigport, cmd, cmd_len);
if (retval != RIG_OK)
return retval;

14
tentec/orion.h
Wyświetl plik

@ -193,7 +193,7 @@ const struct rig_caps tt565_caps = {
.rig_model = RIG_MODEL_TT565,
.model_name = "TT-565 Orion",
.mfg_name = "Ten-Tec",
.version = "0.5",
.version = "0.6",
.copyright = "LGPL",
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TRANSCEIVER,
@ -207,8 +207,8 @@ const struct rig_caps tt565_caps = {
.serial_parity = RIG_PARITY_NONE,
.serial_handshake = RIG_HANDSHAKE_HARDWARE,
.write_delay = 0, /* no delay between characters written */
.post_write_delay = 10, /* ms delay between writes DEBUGGING HERE */
.timeout = 200, /* ms */
.post_write_delay = 0, /* ms delay between writes DEBUGGING HERE */
.timeout = 2000, /* ms */
.retry = 4,
.has_get_func = TT565_FUNCS,
@ -410,7 +410,7 @@ const struct rig_caps tt599_caps = {
.rig_model = RIG_MODEL_TT599,
.model_name = "TT-599 Eagle",
.mfg_name = "Ten-Tec",
.version = "0.4",
.version = "0.5",
.copyright = "LGPL",
.status = RIG_STATUS_UNTESTED,
.rig_type = RIG_TYPE_TRANSCEIVER,
@ -424,9 +424,9 @@ const struct rig_caps tt599_caps = {
.serial_parity = RIG_PARITY_NONE,
.serial_handshake = RIG_HANDSHAKE_HARDWARE,
.write_delay = 0, /* no delay between characters written */
.post_write_delay = 10, /* ms delay between writes DEBUGGING HERE */
.timeout = 200, /* ms */
.retry = 3,
.post_write_delay = 0, /* ms delay between writes DEBUGGING HERE */
.timeout = 2000, /* ms */
.retry = 4,
.has_get_func = TT599_FUNCS,
.has_set_func = TT599_FUNCS,

1
yaesu/ft817.c
Wyświetl plik

@ -1114,6 +1114,7 @@ int ft817_vfo_op (RIG *rig, vfo_t vfo, vfo_op_t op)
switch (op) {
case RIG_OP_TOGGLE:
rig_force_cache_timeout(&((struct ft817_priv_data *)rig->state.priv)->fm_status_tv);
return ft817_send_cmd(rig, FT817_NATIVE_CAT_SET_VFOAB);
default:

32
yaesu/ft857.c
Wyświetl plik

@ -150,9 +150,9 @@ const struct rig_caps ft857_caps = {
.rig_model = RIG_MODEL_FT857,
.model_name = "FT-857",
.mfg_name = "Yaesu",
.version = "0.5",
.version = "0.6",
.copyright = "LGPL",
.status = RIG_STATUS_BETA,
.status = RIG_STATUS_STABLE,
.rig_type = RIG_TYPE_TRANSCEIVER,
.ptt_type = RIG_PTT_RIG,
.dcd_type = RIG_DCD_RIG,
@ -259,6 +259,8 @@ const struct rig_caps ft857_caps = {
.rig_cleanup = ft857_cleanup,
.rig_open = ft857_open,
.rig_close = ft857_close,
.get_vfo = ft857_get_vfo,
.set_vfo = ft857_set_vfo,
.set_freq = ft857_set_freq,
.get_freq = ft857_get_freq,
.set_mode = ft857_set_mode,
@ -495,6 +497,32 @@ static int ft857_send_icmd(RIG *rig, int index, unsigned char *data)
/* ---------------------------------------------------------------------- */
int ft857_get_vfo(RIG *rig, vfo_t *vfo)
{
unsigned char c;
int n;
*vfo = RIG_VFO_B;
if ((n = ft857_read_eeprom(rig, 0x0068, &c)) < 0) { /* get vfo status */
return -RIG_EPROTO;
}
if ((c&0x1)==0) *vfo = RIG_VFO_A;
return RIG_OK;
}
int ft857_set_vfo(RIG *rig, vfo_t vfo)
{
vfo_t curvfo;
int retval = ft857_get_vfo(rig,&curvfo);
if (retval != RIG_OK) {
rig_debug(RIG_DEBUG_ERR,"%s: error get_vfo '%s'\n",__func__,rigerror(retval));
return retval;
}
if (curvfo == vfo) {
return RIG_OK;
}
return ft857_send_cmd(rig, FT857_NATIVE_CAT_SET_VFOAB);
}
int ft857_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
struct ft857_priv_data *p = (struct ft857_priv_data *) rig->state.priv;

2
yaesu/ft857.h
Wyświetl plik

@ -139,6 +139,8 @@ static int ft857_init(RIG *rig);
static int ft857_open(RIG *rig);
static int ft857_cleanup(RIG *rig);
static int ft857_close(RIG *rig);
static int ft857_set_vfo(RIG *rig, vfo_t vfo);
static int ft857_get_vfo(RIG *rig, vfo_t *vfo);
static int ft857_set_freq(RIG *rig, vfo_t vfo, freq_t freq);
static int ft857_get_freq(RIG *rig, vfo_t vfo, freq_t *freq);
static int ft857_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width);

1
yaesu/ft897.c
Wyświetl plik

@ -847,6 +847,7 @@ int ft897_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
switch (op) {
case RIG_OP_TOGGLE:
rig_force_cache_timeout(&((struct ft897_priv_data *) rig->state.priv)->tx_status_tv);
index = FT897_NATIVE_CAT_SET_VFOAB;
break;
default: