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

astyle files preparing for 4.4 release

Hamlib-4.4
Mike Black W9MDB 2021-11-28 12:41:10 -06:00
rodzic 7349a0de73
commit 63a51c36a1
52 zmienionych plików z 1815 dodań i 1251 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

3
amplifiers/elecraft/kpa.c
Wyświetl plik

@ -369,7 +369,8 @@ int kpa_get_level(AMP *amp, setting_t level, value_t *val)
//
do
{
retval = read_string(&rs->ampport, responsebuf, sizeof(responsebuf), ";", 1, 0, 1);
retval = read_string(&rs->ampport, responsebuf, sizeof(responsebuf), ";", 1, 0,
1);
if (retval != RIG_OK) { return retval; }

2
lib/termios.c
Wyświetl plik

@ -1722,6 +1722,7 @@ int win32_serial_read(int fd, void *vb, int size)
return (total);
#if 0
if (size > 0)
{
now = GetTickCount();
@ -1923,6 +1924,7 @@ int win32_serial_read(int fd, void *vb, int size)
total += nBytes;
return (total);
#if 0
if (size > 0)
{
now = GetTickCount();

3
rigs/aor/aor.c
Wyświetl plik

@ -1428,7 +1428,8 @@ int aor_get_chan_all_cb(RIG *rig, vfo_t vfo, chan_cb_t chan_cb, rig_ptr_t arg)
/*
* get next line
*/
retval = read_string(&rig->state.rigport, chanbuf, BUFSZ, EOM, strlen(EOM), 0, 1);
retval = read_string(&rig->state.rigport, chanbuf, BUFSZ, EOM, strlen(EOM), 0,
1);
if (retval < 0)
{

3
rigs/dorji/dra818.c
Wyświetl plik

@ -60,7 +60,8 @@ struct dra818_priv
static int dra818_response(RIG *rig, const char *expected)
{
char response[80];
int r = read_string(&rig->state.rigport, response, sizeof(response), "\n", 1, 0, 1);
int r = read_string(&rig->state.rigport, response, sizeof(response), "\n", 1, 0,
1);
if (r != strlen(expected))
{

8
rigs/dummy/flrig.c
Wyświetl plik

@ -673,7 +673,8 @@ static const char *modeMapGetFLRig(rmode_t modeHamlib)
for (i = 0; modeMap[i].mode_hamlib != 0; ++i)
{
if (modeMap[i].mode_flrig == NULL) continue;
if (modeMap[i].mode_flrig == NULL) { continue; }
rig_debug(RIG_DEBUG_TRACE,
"%s: checking modeMap[%d]=%.0f to modeHamlib=%.0f, mode_flrig='%s'\n", __func__,
i, (double)modeMap[i].mode_hamlib, (double)modeHamlib, modeMap[i].mode_flrig);
@ -797,12 +798,13 @@ static int flrig_open(RIG *rig)
if (retval != RIG_OK)
{
rig_debug(RIG_DEBUG_ERR, "%s: get_version failed: %s\nAssuming version < 1.3.54", __func__,
rig_debug(RIG_DEBUG_ERR,
"%s: get_version failed: %s\nAssuming version < 1.3.54", __func__,
rigerror(retval));
// we fall through and assume old version
}
int v1=0, v2=0, v3=0, v4=0;
int v1 = 0, v2 = 0, v3 = 0, v4 = 0;
sscanf(value, "%d.%d.%d.%d", &v1, &v2, &v3, &v4);
if (v1 >= 1 && v2 >= 3 && v3 >= 54)

19
rigs/dummy/netrigctl.c
Wyświetl plik

@ -122,8 +122,8 @@ static int netrigctl_vfostr(RIG *rig, char *vfostr, int len, vfo_t vfo)
if (vfo == RIG_VFO_NONE) { vfo = RIG_VFO_A; }
}
else if (vfo == RIG_VFO_RX) vfo = priv->rx_vfo;
else if (vfo == RIG_VFO_TX) vfo = priv->tx_vfo;
else if (vfo == RIG_VFO_RX) { vfo = priv->rx_vfo; }
else if (vfo == RIG_VFO_TX) { vfo = priv->tx_vfo; }
rig_debug(RIG_DEBUG_TRACE, "%s: vfo_opt=%d\n", __func__, rig->state.vfo_opt);
@ -628,9 +628,12 @@ static int netrigctl_open(RIG *rig)
rs->mode_list |= rs->tx_range_list[i].modes;
rs->vfo_list |= rs->tx_range_list[i].vfo;
}
if (rs->vfo_list == 0) {
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo_list empty, defaulting to A/B\n", __func__);
rs->vfo_list = RIG_VFO_A|RIG_VFO_B;
if (rs->vfo_list == 0)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo_list empty, defaulting to A/B\n",
__func__);
rs->vfo_list = RIG_VFO_A | RIG_VFO_B;
}
if (prot_ver == 0) { return RIG_OK; }
@ -1596,7 +1599,8 @@ static int netrigctl_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
char buf[BUF_MAX];
char vfostr[16] = "";
rig_debug(RIG_DEBUG_VERBOSE, "%s called vfo=%s, vfotx=%s, split=%d\n", __func__, rig_strvfo(vfo), rig_strvfo(tx_vfo), split);
rig_debug(RIG_DEBUG_VERBOSE, "%s called vfo=%s, vfotx=%s, split=%d\n", __func__,
rig_strvfo(vfo), rig_strvfo(tx_vfo), split);
ret = netrigctl_vfostr(rig, vfostr, sizeof(vfostr), RIG_VFO_A);
@ -2561,7 +2565,8 @@ static int netrigctl_power2mW(RIG *rig, unsigned int *mwpower, float power,
ENTERFUNC;
// we shouldn't need any precision than microwatts
snprintf(cmdbuf, sizeof(cmdbuf), "\\power2mW %.3f %.0f %s\n", power, freq, rig_strrmode(mode));
snprintf(cmdbuf, sizeof(cmdbuf), "\\power2mW %.3f %.0f %s\n", power, freq,
rig_strrmode(mode));
ret = netrigctl_transaction(rig, cmdbuf, strlen(cmdbuf), buf);
if (ret <= 0)

6
rigs/dummy/rot_dummy.c
Wyświetl plik

@ -190,9 +190,11 @@ static int dummy_rot_open(ROT *rot)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
if (rot->caps->rot_model == ROT_MODEL_DUMMY) {
if (rot->caps->rot_model == ROT_MODEL_DUMMY)
{
simulating = 1;
rig_debug(RIG_DEBUG_VERBOSE, "%s: dummy rotator so simulating speed\n", __func__);
rig_debug(RIG_DEBUG_VERBOSE, "%s: dummy rotator so simulating speed\n",
__func__);
}
return RIG_OK;

93
rigs/dummy/tci1x.c
Wyświetl plik

@ -151,8 +151,8 @@ const struct rig_caps tci1x_caps =
.port_type = RIG_PORT_SERIAL,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 5000,
.retry = 2,
.timeout = 1000,
.retry = 1,
.has_get_func = RIG_FUNC_NONE,
.has_set_func = RIG_FUNC_NONE,
@ -281,20 +281,18 @@ static int read_transaction(RIG *rig, char *buf, int buf_len)
ENTERFUNC;
retry = 2;
retry = 0;
do
{
char tmp_buf[MAXBUFLEN]; // plenty big for expected tci1x responses hopefully
if (retry < 2)
{
rig_debug(RIG_DEBUG_WARN, "%s: retry needed? retry=%d\n", __func__, retry);
}
int len = read_string(&rs->rigport, tmp_buf, sizeof(tmp_buf), delims,
int len = read_string(&rs->rigport, buf, buf_len, delims,
strlen(delims), 0, 1);
rig_debug(RIG_DEBUG_TRACE, "%s: string='%s'\n", __func__, tmp_buf);
rig_debug(RIG_DEBUG_TRACE, "%s: string='%s'\n", __func__, buf);
if (len <= 0)
{
@ -303,7 +301,7 @@ static int read_transaction(RIG *rig, char *buf, int buf_len)
}
}
while (retry-- > 0 && strstr(buf, delims) == NULL);
while (retry-- > 0 && strlen(buf) == 0);
if (retry == 0)
{
@ -343,7 +341,7 @@ static int write_transaction(RIG *rig, char *buf, int buf_len)
while (try-- >= 0 && retval != RIG_OK)
{
retval = write_block(&rs->rigport, buf, strlen(buf));
retval = write_block(&rs->rigport, buf, buf_len);
if (retval < 0)
{
@ -357,15 +355,32 @@ static int write_transaction(RIG *rig, char *buf, int buf_len)
static int tci1x_transaction(RIG *rig, char *cmd, char *cmd_arg, char *value,
int value_len)
{
int retry = 5;
int retry = 0;
char frame[1024];
ENTERFUNC;
memset(frame, 0, sizeof(frame));
if (value)
{
value[0] = 0;
}
frame[0] = 0x81;
frame[1] = strlen(cmd);
frame[2] = 0x00;
frame[3] = 0x00;
frame[4] = 0x00;
frame[5] = 0x00;
frame[6] = 0x00;
frame[7] = 0x00;
frame[8] = 0x00;
frame[9] = 0x00;
frame[10] = 0x00;
frame[11] = 0x00;
strcat(&frame[12], cmd);
do
{
int retval;
@ -375,7 +390,7 @@ static int tci1x_transaction(RIG *rig, char *cmd, char *cmd_arg, char *value,
rig_debug(RIG_DEBUG_VERBOSE, "%s: cmd=%s, retry=%d\n", __func__, cmd, retry);
}
retval = write_transaction(rig, cmd, strlen(cmd));
retval = write_transaction(rig, frame, strlen(cmd) + 12);
if (retval != RIG_OK)
{
@ -388,12 +403,12 @@ static int tci1x_transaction(RIG *rig, char *cmd, char *cmd_arg, char *value,
hl_usleep(50 * 1000); // 50ms sleep if error
}
read_transaction(rig, value, value_len);
read_transaction(rig, value, value_len);
rig_debug(RIG_DEBUG_VERBOSE, "%s: value=%s\n", __func__,value);
rig_debug(RIG_DEBUG_VERBOSE, "%s: value=%s\n", __func__, value);
}
while ((value && (strlen(value) == 0) )
while ((value && (strlen(value) == 0))
&& retry--); // we'll do retries if needed
if (value && strlen(value) == 0) { RETURNFUNC(RIG_EPROTO); }
@ -468,7 +483,8 @@ static const char *modeMapGetTCI(rmode_t modeHamlib)
for (i = 0; modeMap[i].mode_hamlib != 0; ++i)
{
if (modeMap[i].mode_tci1x == NULL) continue;
if (modeMap[i].mode_tci1x == NULL) { continue; }
rig_debug(RIG_DEBUG_TRACE,
"%s: checking modeMap[%d]=%.0f to modeHamlib=%.0f, mode_tci1x='%s'\n", __func__,
i, (double)modeMap[i].mode_hamlib, (double)modeHamlib, modeMap[i].mode_tci1x);
@ -578,7 +594,7 @@ static void modeMapAdd(rmode_t *modes, rmode_t mode_hamlib, char *mode_tci1x)
static int tci1x_open(RIG *rig)
{
int retval;
int trx_count=0;
int trx_count = 0;
char value[MAXBUFLEN];
char arg[MAXBUFLEN];
rmode_t modes;
@ -588,37 +604,49 @@ static int tci1x_open(RIG *rig)
ENTERFUNC;
rig_debug(RIG_DEBUG_VERBOSE, "%s: version %s\n", __func__, rig->caps->version);
char *websocket =
"GET / HTTP/1.1\r\nHost: localhost:50001\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: TnwnvtFT6akIBYQC7nh3vA==\r\nSec-WebSocket-Version: 13\r\n\r\n";
retval = tci1x_transaction(rig, "DEVICE;", NULL, value, sizeof(value));
write_transaction(rig, websocket, strlen(websocket));
do
{
retval = read_transaction(rig, value, sizeof(value));
rig_debug(RIG_DEBUG_VERBOSE, "%s: value=%s\n", __func__, value);
}
while (retval == RIG_OK && strlen(value) > 0);
retval = tci1x_transaction(rig, "device;", NULL, value, sizeof(value));
dump_hex((unsigned char *)value, strlen(value));
if (retval != RIG_OK)
{
rig_debug(RIG_DEBUG_ERR, "%s: DEVICE failed: %s\n", __func__,
rigerror(retval));
// we fall through and assume old version
RETURNFUNC(retval);
//RETURNFUNC(retval);
}
sscanf(value,"DEVICE:%s", arg);
sscanf(&value[2], "device:%s", value);
rig_debug(RIG_DEBUG_VERBOSE, "%s: TCI Device is %s\n", __func__, arg);
// Receive only
retval = tci1x_transaction(rig, "RECEIVE_ONLY;", NULL, value, sizeof(value));
retval = tci1x_transaction(rig, "receive_only;", NULL, value, sizeof(value));
if (retval != RIG_OK)
{
rig_debug(RIG_DEBUG_ERR, "%s: RECEIVE_ONLY failed: %s\n", __func__,
rigerror(retval));
// we fall through and assume old version
RETURNFUNC(retval);
//RETURNFUNC(retval);
}
sscanf(value,"RECEIVE_ONLY:%s", arg);
sscanf(&value[2], "receive_only:%s", value);
rig_debug(RIG_DEBUG_VERBOSE, "%s: readonly is %s\n", __func__, arg);
// TRX count
retval = tci1x_transaction(rig, "TRX_COUNT;", NULL, value, sizeof(value));
retval = tci1x_transaction(rig, "trx_count;", NULL, value, sizeof(value));
if (retval != RIG_OK)
{
@ -626,7 +654,7 @@ static int tci1x_open(RIG *rig)
rigerror(retval));
}
sscanf(value, "TRX_COUNT:%d", &trx_count);
sscanf(&value[2], "trx_count:%d", &trx_count);
rig_debug(RIG_DEBUG_VERBOSE, "Trx count=%d\n", trx_count);
freq_t freq;
@ -635,20 +663,22 @@ static int tci1x_open(RIG *rig)
if (retval != RIG_OK)
{
rig_debug(RIG_DEBUG_ERR, "%s: tci1x_get_freq not working!!\n", __func__);
RETURNFUNC(RIG_EPROTO);
//RETURNFUNC(RIG_EPROTO);
}
rig->state.current_vfo = RIG_VFO_A;
rig_debug(RIG_DEBUG_TRACE, "%s: currvfo=%s value=%s\n", __func__,
rig_strvfo(rig->state.current_vfo), value);
//tci1x_get_split_vfo(rig, vfo, &priv->split, &vfo_tx);
RETURNFUNC(RIG_OK);
/* find out available widths and modes */
retval = tci1x_transaction(rig, "MODULATIONS_LIST;", NULL, value, sizeof(value));
retval = tci1x_transaction(rig, "modulations_list;", NULL, value,
sizeof(value));
if (retval != RIG_OK) { RETURNFUNC(retval); }
sscanf(value, "MODULATIONS_LIST:%s", arg);
sscanf(&value[2], "modulations_list:%s", arg);
rig_debug(RIG_DEBUG_VERBOSE, "%s: modes=%s\n", __func__, arg);
modes = 0;
pr = value;
@ -861,7 +891,7 @@ static int tci1x_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
__func__, rig_strvfo(vfo));
}
char *cmd = vfo == RIG_VFO_A ? "VFO:0:0;" : "VFO:0:1:";
char *cmd = vfo == RIG_VFO_A ? "vfo:0:0;" : "vfo:0:1:";
int retval;
int n;
@ -874,8 +904,9 @@ static int tci1x_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
RETURNFUNC(retval);
}
n = sscanf(value,"VFO:%*d,%*d,%lf", freq);
rig_debug(RIG_DEBUG_VERBOSE, "%s: got '%s', scanned %d items\n", __func__, value, n);
n = sscanf(&value[2], "vfo:%*d,%*d,%lf", freq);
rig_debug(RIG_DEBUG_VERBOSE, "%s: got '%s', scanned %d items\n", __func__,
value, n);
if (*freq == 0)
{

131
rigs/icom/icom.c
Wyświetl plik

@ -790,9 +790,11 @@ static vfo_t icom_current_vfo_x25(RIG *rig)
{
// we can't change freqs unless rig is idle and we don't know that
// so we only check vfo once when freqs are equal
rig_debug(RIG_DEBUG_TRACE,"%s: vfo already determined...returning current_vfo", __func__);
rig_debug(RIG_DEBUG_TRACE, "%s: vfo already determined...returning current_vfo",
__func__);
return rig->state.current_vfo;
}
priv->vfo_flag = 1;
fOffset = 100;
@ -883,9 +885,11 @@ static vfo_t icom_current_vfo(RIG *rig)
{
// we can't change freqs unless rig is idle and we don't know that
// so we only check vfo once when freqs are equal
rig_debug(RIG_DEBUG_TRACE,"%s: vfo already determined...returning current_vfo", __func__);
rig_debug(RIG_DEBUG_TRACE, "%s: vfo already determined...returning current_vfo",
__func__);
return rig->state.current_vfo;
}
priv->vfo_flag = 1;
fOffset = 100;
@ -978,13 +982,16 @@ retry_open:
else if (retval != RIG_OK)
{
// didnt' ask for power on so let's retry one more time
rig_debug(RIG_DEBUG_ERR, "%s: rig error getting frequency retry=%d, err=%s\n", __func__,retry_flag,rigerror(retval));
rig_debug(RIG_DEBUG_ERR, "%s: rig error getting frequency retry=%d, err=%s\n",
__func__, retry_flag, rigerror(retval));
if (retry_flag)
{
retry_flag = 0;
hl_usleep(500*1000); // 500ms pause
hl_usleep(500 * 1000); // 500ms pause
goto retry_open;
}
RETURNFUNC(retval);
}
@ -1358,6 +1365,7 @@ int icom_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
case RIG_VFO_NONE: // VFO_NONE will become VFO_CURR
rig->state.current_vfo = RIG_VFO_CURR;
case RIG_VFO_CURR: priv->curr_freq = freq; break;
case RIG_VFO_OTHER: priv->other_freq = freq; break;
@ -1636,6 +1644,7 @@ int icom_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
case RIG_VFO_NONE: // VFO_NONE will become VFO_CURR
rig->state.current_vfo = RIG_VFO_CURR;
case RIG_VFO_CURR: priv->curr_freq = *freq; break;
default:
@ -1760,8 +1769,8 @@ int icom_set_xit_new(RIG *rig, vfo_t vfo, shortfreq_t ts)
and some models like IC910/Omni VI Plus have a different meaning for
this subcommand
*/
int filtericom[] = { 50,100,150,200,250,300,350,400,450,500,600,700,800,900,1000,1100,1200,1300,1400,1500,1600,1700,1800,1900,2000,2100,2200,2300,2400,2500,2600,2700,2800,2900,3000,3100,3200,3300,3400,3500,3600 };
int filtericom[] = { 50, 100, 150, 200, 250, 300, 350, 400, 450, 500, 600, 700, 800, 900, 1000, 1100, 1200, 1300, 1400, 1500, 1600, 1700, 1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500, 2600, 2700, 2800, 2900, 3000, 3100, 3200, 3300, 3400, 3500, 3600 };
pbwidth_t icom_get_dsp_flt(RIG *rig, rmode_t mode)
{
@ -1810,7 +1819,8 @@ pbwidth_t icom_get_dsp_flt(RIG *rig, rmode_t mode)
if (-RIG_ERJCTED == retval)
{
if (priv->no_1a_03_cmd == ENUM_1A_03_UNK) {
if (priv->no_1a_03_cmd == ENUM_1A_03_UNK)
{
priv->no_1a_03_cmd = ENUM_1A_03_NO; /* do not keep asking */
return (RIG_OK);
}
@ -1837,10 +1847,13 @@ pbwidth_t icom_get_dsp_flt(RIG *rig, rmode_t mode)
if (mode & RIG_MODE_AM)
{
if (i > 49) {
rig_debug(RIG_DEBUG_ERR, "%s: Expected max 49, got %d for filter\n", __func__, i);
if (i > 49)
{
rig_debug(RIG_DEBUG_ERR, "%s: Expected max 49, got %d for filter\n", __func__,
i);
RETURNFUNC(-RIG_EPROTO);
}
return ((i + 1) * 200); /* All Icoms that we know of */
}
else if (mode &
@ -1867,9 +1880,10 @@ int icom_set_dsp_flt(RIG *rig, rmode_t mode, pbwidth_t width)
S_MEM_FILT_WDTH;
ENTERFUNC;
rig_debug(RIG_DEBUG_TRACE, "%s: mode=%s, width=%d\n", __func__, rig_strrmode(mode), (int)width);
rig_debug(RIG_DEBUG_TRACE, "%s: mode=%s, width=%d\n", __func__,
rig_strrmode(mode), (int)width);
if (RIG_PASSBAND_NOCHANGE == width)
{
RETURNFUNC(RIG_OK);
@ -1901,7 +1915,8 @@ int icom_set_dsp_flt(RIG *rig, rmode_t mode, pbwidth_t width)
RETURNFUNC(-RIG_EINVAL);
}
}
if (priv->no_1a_03_cmd == ENUM_1A_03_NO) RETURNFUNC(RIG_OK); // don't bother to try since it doesn't work
if (priv->no_1a_03_cmd == ENUM_1A_03_NO) { RETURNFUNC(RIG_OK); } // don't bother to try since it doesn't work
if (mode & RIG_MODE_AM)
{
@ -1920,12 +1935,14 @@ int icom_set_dsp_flt(RIG *rig, rmode_t mode, pbwidth_t width)
}
else
{
rig_debug(RIG_DEBUG_VERBOSE, "%s: unknown mode=%s\n", __func__, rig_strrmode(mode));
rig_debug(RIG_DEBUG_VERBOSE, "%s: unknown mode=%s\n", __func__,
rig_strrmode(mode));
RETURNFUNC(RIG_OK);
}
to_bcd(&flt_ext, flt_idx, 2);
rig_debug(RIG_DEBUG_VERBOSE, "%s: flt_ext=%d, flt_idx=%d\n", __func__, flt_ext, flt_idx);
rig_debug(RIG_DEBUG_VERBOSE, "%s: flt_ext=%d, flt_idx=%d\n", __func__, flt_ext,
flt_idx);
retval = icom_transaction(rig, C_CTL_MEM, fw_sub_cmd, &flt_ext, 1,
ackbuf, &ack_len);
@ -2166,6 +2183,7 @@ int icom_set_mode_with_data(RIG *rig, vfo_t vfo, rmode_t mode,
}
}
}
icom_set_dsp_flt(rig, mode, width);
RETURNFUNC(retval);
@ -2419,7 +2437,10 @@ int icom_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
TRACE;
rig_debug(RIG_DEBUG_VERBOSE, "%s: targetable=%x, targetable_mode=%x, and=%d\n", __func__, rig->caps->targetable_vfo,RIG_TARGETABLE_MODE, rig->caps->targetable_vfo & RIG_TARGETABLE_MODE);
rig_debug(RIG_DEBUG_VERBOSE, "%s: targetable=%x, targetable_mode=%x, and=%d\n",
__func__, rig->caps->targetable_vfo, RIG_TARGETABLE_MODE,
rig->caps->targetable_vfo & RIG_TARGETABLE_MODE);
// IC7800 can set but not read with 0x26
if ((rig->caps->targetable_vfo & RIG_TARGETABLE_MODE)
&& (rig->caps->rig_model != RIG_MODEL_IC7800))
@ -2720,8 +2741,10 @@ int icom_set_vfo(RIG *rig, vfo_t vfo)
case RIG_VFO_MAIN:
icvfo = S_MAIN;
// If not split or satmode then we must want VFOA
if (VFO_HAS_MAIN_SUB_A_B_ONLY && !priv->split_on && !rig->state.cache.satmode) { icvfo = S_VFOA; }
break;
case RIG_VFO_SUB:
@ -2860,40 +2883,50 @@ int icom_set_vfo(RIG *rig, vfo_t vfo)
break;
case RIG_VFO_OTHER:
switch(rig->state.current_vfo)
switch (rig->state.current_vfo)
{
case RIG_VFO_A:
icvfo = vfo = RIG_VFO_B;
break;
case RIG_VFO_B:
icvfo = vfo = RIG_VFO_A;
break;
case RIG_VFO_MAIN:
icvfo = vfo = RIG_VFO_SUB;
break;
case RIG_VFO_SUB:
icvfo = vfo = RIG_VFO_MAIN;
break;
case RIG_VFO_MAIN_A:
icvfo = vfo = RIG_VFO_MAIN_B;
break;
case RIG_VFO_MAIN_B:
icvfo = vfo = RIG_VFO_MAIN_A;
break;
case RIG_VFO_SUB_A:
icvfo = vfo = RIG_VFO_SUB_B;
break;
case RIG_VFO_SUB_B:
icvfo = vfo = RIG_VFO_SUB_A;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unknown vfo '%s'\n", __func__, rig_strvfo(rig->state.current_vfo));
case RIG_VFO_A:
icvfo = vfo = RIG_VFO_B;
break;
case RIG_VFO_B:
icvfo = vfo = RIG_VFO_A;
break;
case RIG_VFO_MAIN:
icvfo = vfo = RIG_VFO_SUB;
break;
case RIG_VFO_SUB:
icvfo = vfo = RIG_VFO_MAIN;
break;
case RIG_VFO_MAIN_A:
icvfo = vfo = RIG_VFO_MAIN_B;
break;
case RIG_VFO_MAIN_B:
icvfo = vfo = RIG_VFO_MAIN_A;
break;
case RIG_VFO_SUB_A:
icvfo = vfo = RIG_VFO_SUB_B;
break;
case RIG_VFO_SUB_B:
icvfo = vfo = RIG_VFO_SUB_A;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unknown vfo '%s'\n", __func__,
rig_strvfo(rig->state.current_vfo));
}
default:
if (!priv->x25cmdfails)
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__,
rig_strvfo(vfo));
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %s\n", __func__,
rig_strvfo(vfo));
RETURNFUNC(-RIG_EINVAL);
}
@ -7714,7 +7747,7 @@ int icom_set_powerstat(RIG *rig, powerstat_t status)
priv->serial_USB_echo_off = 1;
retval =
icom_transaction(rig, C_SET_PWR, pwr_sc, NULL, 0, ackbuf, &ack_len);
hl_usleep(4000*1000); // give some time to wake up
hl_usleep(4000 * 1000); // give some time to wake up
break;
@ -7736,8 +7769,11 @@ int icom_set_powerstat(RIG *rig, powerstat_t status)
// need to see if echo is on or not first
// until such time as rig is awake we don't know
retval = icom_get_usb_echo_off(rig);
if (retval == -RIG_ETIMEOUT) {
rig_debug(RIG_DEBUG_WARN, "%s: get_usb_echo_off timeout...try#%d\n", __func__, i+1);
if (retval == -RIG_ETIMEOUT)
{
rig_debug(RIG_DEBUG_WARN, "%s: get_usb_echo_off timeout...try#%d\n", __func__,
i + 1);
continue;
}
@ -7758,6 +7794,7 @@ int icom_set_powerstat(RIG *rig, powerstat_t status)
__func__, i + 1, retry);
}
}
rs->rigport.retry = retry_save;
if (i == retry)

6
rigs/icom/optoscan.c
Wyświetl plik

@ -245,9 +245,9 @@ int optoscan_recv_dtmf(RIG *rig, vfo_t vfo, char *digits, int *length)
unsigned char dtmfbuf[MAXFRAMELEN], digit;
int len, digitpos;
const unsigned char xlate[] = {'0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'A', 'B', 'C', 'D',
'*', '#'
};
'7', '8', '9', 'A', 'B', 'C', 'D',
'*', '#'
};
digitpos = 0;
do

26
rigs/kenwood/elecraft.c
Wyświetl plik

@ -477,12 +477,12 @@ int elecraft_get_firmware_revision_level(RIG *rig, const char *cmd,
int elecraft_get_vfo_tq(RIG *rig, vfo_t *vfo)
{
int retval;
int fr,ft,tq;
int fr, ft, tq;
char cmdbuf[10];
char splitbuf[12];
memset(splitbuf,0,sizeof(splitbuf));
snprintf(cmdbuf,sizeof(cmdbuf),"FR;");
memset(splitbuf, 0, sizeof(splitbuf));
snprintf(cmdbuf, sizeof(cmdbuf), "FR;");
retval = kenwood_safe_transaction(rig, cmdbuf, splitbuf, 12, 3);
if (retval != RIG_OK)
@ -490,11 +490,12 @@ int elecraft_get_vfo_tq(RIG *rig, vfo_t *vfo)
RETURNFUNC(retval);
}
if(sscanf(splitbuf, "FR%1d", &fr) != 1)
if (sscanf(splitbuf, "FR%1d", &fr) != 1)
{
rig_debug(RIG_DEBUG_ERR, "%s: unable to parse FR '%s'\n", __func__, splitbuf);
}
snprintf(cmdbuf,sizeof(cmdbuf),"FT;");
snprintf(cmdbuf, sizeof(cmdbuf), "FT;");
retval = kenwood_safe_transaction(rig, cmdbuf, splitbuf, 12, 3);
if (retval != RIG_OK)
@ -502,11 +503,12 @@ int elecraft_get_vfo_tq(RIG *rig, vfo_t *vfo)
RETURNFUNC(retval);
}
if(sscanf(splitbuf, "FT%1d", &ft) != 1)
if (sscanf(splitbuf, "FT%1d", &ft) != 1)
{
rig_debug(RIG_DEBUG_ERR, "%s: unable to parse FT '%s'\n", __func__, splitbuf);
}
snprintf(cmdbuf,sizeof(cmdbuf),"TQ;");
snprintf(cmdbuf, sizeof(cmdbuf), "TQ;");
retval = kenwood_safe_transaction(rig, cmdbuf, splitbuf, 12, 3);
if (retval != RIG_OK)
@ -514,13 +516,17 @@ int elecraft_get_vfo_tq(RIG *rig, vfo_t *vfo)
RETURNFUNC(retval);
}
if(sscanf(splitbuf, "TQ%1d", &tq) != 1)
if (sscanf(splitbuf, "TQ%1d", &tq) != 1)
{
rig_debug(RIG_DEBUG_ERR, "%s: unable to parse TQ '%s'\n", __func__, splitbuf);
}
*vfo = RIG_VFO_A;
if (tq && ft == 1) *vfo = RIG_VFO_B;
if (!tq && fr == 1) *vfo = RIG_VFO_B;
if (tq && ft == 1) { *vfo = RIG_VFO_B; }
if (!tq && fr == 1) { *vfo = RIG_VFO_B; }
RETURNFUNC(RIG_OK);
}

1
rigs/kenwood/flex6xxx.c
Wyświetl plik

@ -919,6 +919,7 @@ int powersdr_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
__func__, lvlbuf);
return -RIG_EPROTO;
}
n = val->i;
val->f = (n + 20.0) / (120.0 - -20.0);

42
rigs/kenwood/k3.c
Wyświetl plik

@ -959,6 +959,7 @@ int k3_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
cmd_bw_len = 7;
}
if (!mode || !width)
{
return -RIG_EINVAL;
@ -978,7 +979,8 @@ int k3_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
if (temp_m == RIG_MODE_RTTY)
{
err = kenwood_safe_transaction(rig, cmd_mode, buf, KENWOOD_MAX_BUF_LEN, strlen(cmd_mode)+1);
err = kenwood_safe_transaction(rig, cmd_mode, buf, KENWOOD_MAX_BUF_LEN,
strlen(cmd_mode) + 1);
if (err != RIG_OK)
{
@ -1005,7 +1007,8 @@ int k3_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
}
else if (temp_m == RIG_MODE_RTTYR)
{
err = kenwood_safe_transaction(rig, cmd_mode, buf, KENWOOD_MAX_BUF_LEN, strlen(cmd_mode)+1);
err = kenwood_safe_transaction(rig, cmd_mode, buf, KENWOOD_MAX_BUF_LEN,
strlen(cmd_mode) + 1);
if (err != RIG_OK)
{
@ -1039,7 +1042,8 @@ int k3_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
/* The K3 is not limited to specific filter widths so we can query
* the actual bandwidth using the BW command
*/
err = kenwood_safe_transaction(rig, cmd_bw, buf, KENWOOD_MAX_BUF_LEN, cmd_bw_len);
err = kenwood_safe_transaction(rig, cmd_bw, buf, KENWOOD_MAX_BUF_LEN,
cmd_bw_len);
if (err != RIG_OK)
{
@ -1047,7 +1051,7 @@ int k3_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
return err;
}
*width = atoi(&buf[cmd_bw_len-4]) * 10;
*width = atoi(&buf[cmd_bw_len - 4]) * 10;
return RIG_OK;
}
@ -1086,28 +1090,30 @@ int k3_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
int k3_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
int err,err2;
int err, err2;
char cmd_m[5];
char buf[KENWOOD_MAX_BUF_LEN];
char *dtcmd;
struct kenwood_priv_caps *caps = kenwood_caps(rig);
struct kenwood_priv_data *priv = rig->state.priv;
rig_debug(RIG_DEBUG_VERBOSE, "%s called vfo=%s mode=%s width=%d\n", __func__, rig_strvfo(vfo), rig_strrmode(mode), (int)width);
rig_debug(RIG_DEBUG_VERBOSE, "%s called vfo=%s mode=%s width=%d\n", __func__,
rig_strvfo(vfo), rig_strrmode(mode), (int)width);
if (vfo == RIG_VFO_CURR)
{
vfo = rig->state.current_vfo;
}
rmode_t tmodeA,tmodeB;
rmode_t tmodeA, tmodeB;
pbwidth_t twidth;
err = k3_get_mode(rig, RIG_VFO_A, &tmodeA, &twidth);
err2 = k3_get_mode(rig, RIG_VFO_B, &tmodeB, &twidth);
// we keep both vfos in the same mode -- any reason they should ever be differnet? If so, fix this
// if we change mode on one VFO we'll also change the other
if (err == RIG_OK && err2 == RIG_OK && tmodeA == mode && tmodeB == mode && width == RIG_PASSBAND_NOCHANGE)
if (err == RIG_OK && err2 == RIG_OK && tmodeA == mode && tmodeB == mode
&& width == RIG_PASSBAND_NOCHANGE)
{
rig_debug(RIG_DEBUG_TRACE, "%s(%d): mode/width no change, skipping\n", __FILE__,
__LINE__);
@ -1116,11 +1122,14 @@ int k3_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
else
{
rig_debug(RIG_DEBUG_TRACE,
"%s(%d): changing oldmode=A=%s B=%s, to mode=%s, oldwidth=%ld, to width=%ld\n", __FILE__,
__LINE__, rig_strrmode(tmodeA), rig_strrmode(tmodeB), rig_strrmode(mode), twidth, width);
"%s(%d): changing oldmode=A=%s B=%s, to mode=%s, oldwidth=%ld, to width=%ld\n",
__FILE__,
__LINE__, rig_strrmode(tmodeA), rig_strrmode(tmodeB), rig_strrmode(mode),
twidth, width);
}
dtcmd = "DT";
if ((priv->is_k4 || priv->is_k4d || priv->is_k4hd) && vfo == RIG_VFO_B)
{
dtcmd = "DT$";
@ -2699,7 +2708,9 @@ int k4_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
snprintf(cmd, sizeof(cmd), "RX");
if (ptt) cmd[0] = 'T';
if (ptt) { cmd[0] = 'T'; }
retval = kenwood_transaction(rig, cmd, NULL, 0);
if (retval != RIG_OK)
@ -2709,20 +2720,23 @@ int k4_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
do
{
hl_usleep(10*1000);
hl_usleep(10 * 1000);
retval = kenwood_safe_transaction(rig, "TQ", pttbuf, 6, 3);
if (retval != RIG_OK)
{
return retval;
}
ptt2 = pttbuf[2] == '1'? RIG_PTT_ON : RIG_PTT_OFF;
ptt2 = pttbuf[2] == '1' ? RIG_PTT_ON : RIG_PTT_OFF;
if (ptt2 != ptt)
{
rig_debug(RIG_DEBUG_TRACE, "%s: ptt=%d, expected=%d\n", __func__, ptt2, ptt);
}
} while (ptt != ptt2);
}
while (ptt != ptt2);
return RIG_OK;
}

294
rigs/kenwood/kenwood.c
Wyświetl plik

@ -268,7 +268,8 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, char *data,
if (cache_age_ms < 500) // 500ms cache time
{
rig_debug(RIG_DEBUG_TRACE, "%s(%d): cache hit, age=%dms\n", __func__, __LINE__, cache_age_ms);
rig_debug(RIG_DEBUG_TRACE, "%s(%d): cache hit, age=%dms\n", __func__, __LINE__,
cache_age_ms);
if (data) { strncpy(data, priv->last_if_response, datasize); }
@ -369,7 +370,8 @@ transaction_read:
/* allow room for most any response */
len = min(datasize ? datasize + 1 : strlen(priv->verify_cmd) + 48,
KENWOOD_MAX_BUF_LEN);
retval = read_string(&rs->rigport, buffer, len, cmdtrm_str, strlen(cmdtrm_str), 0, 1);
retval = read_string(&rs->rigport, buffer, len, cmdtrm_str, strlen(cmdtrm_str),
0, 1);
rig_debug(RIG_DEBUG_TRACE, "%s: read_string(len=%d)='%s'\n", __func__,
(int)strlen(buffer), buffer);
@ -466,9 +468,11 @@ transaction_read:
{
rig_debug(RIG_DEBUG_ERR, "%s: Unknown command or rig busy '%s'\n", __func__,
cmdstr);
// sometimes IF; command after TX; will return ? but still return IF response
if (retry_read++ <= 1) {
hl_usleep(100*1000);
if (retry_read++ <= 1)
{
hl_usleep(100 * 1000);
goto transaction_read;
}
}
@ -1065,14 +1069,16 @@ int kenwood_set_vfo(RIG *rig, vfo_t vfo)
* This prevents a 1.8 second delay in PowerSDR when switching VFOs
* We'll do this once if curr_mode has not been set yet
*/
if (priv->is_emulation && priv->curr_mode > 0) {
if (priv->is_emulation && priv->curr_mode > 0)
{
TRACE;
RETURNFUNC(RIG_OK);
}
RETURNFUNC(RIG_OK);
}
if (rig->state.current_vfo == vfo)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo already is %s...skipping\n", __func__, rig_strvfo(vfo));
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo already is %s...skipping\n", __func__,
rig_strvfo(vfo));
RETURNFUNC(RIG_OK);
}
@ -1155,6 +1161,7 @@ int kenwood_set_vfo(RIG *rig, vfo_t vfo)
{
RETURNFUNC(retval);
}
TRACE;
rig->state.current_vfo = vfo;
@ -1166,36 +1173,47 @@ int kenwood_set_vfo(RIG *rig, vfo_t vfo)
}
TRACE;
// some rigs need split turned on after VFOA is set
if (priv->split == RIG_SPLIT_ON)
{ // so let's figure out who the rx_vfo is based on the tx_vfo
{
// so let's figure out who the rx_vfo is based on the tx_vfo
TRACE;
vfo_t rx_vfo = RIG_VFO_A;
switch(priv->tx_vfo)
switch (priv->tx_vfo)
{
case RIG_VFO_A:
rx_vfo = RIG_VFO_B;
break;
case RIG_VFO_MAIN:
rx_vfo = RIG_VFO_SUB;
break;
case RIG_VFO_MAIN_A:
rx_vfo = RIG_VFO_MAIN_B;
break;
case RIG_VFO_B:
rx_vfo = RIG_VFO_A;
break;
case RIG_VFO_SUB:
rx_vfo = RIG_VFO_MAIN;
break;
case RIG_VFO_SUB_B:
rx_vfo = RIG_VFO_MAIN_A;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unhandled VFO=%s, deafaulting to VFOA\n", __func__, rig_strvfo(priv->tx_vfo));
case RIG_VFO_A:
rx_vfo = RIG_VFO_B;
break;
case RIG_VFO_MAIN:
rx_vfo = RIG_VFO_SUB;
break;
case RIG_VFO_MAIN_A:
rx_vfo = RIG_VFO_MAIN_B;
break;
case RIG_VFO_B:
rx_vfo = RIG_VFO_A;
break;
case RIG_VFO_SUB:
rx_vfo = RIG_VFO_MAIN;
break;
case RIG_VFO_SUB_B:
rx_vfo = RIG_VFO_MAIN_A;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unhandled VFO=%s, deafaulting to VFOA\n",
__func__, rig_strvfo(priv->tx_vfo));
}
retval = rig_set_split_vfo(rig, rx_vfo , 1, priv->tx_vfo);
retval = rig_set_split_vfo(rig, rx_vfo, 1, priv->tx_vfo);
}
#if 0
@ -1278,9 +1296,10 @@ int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
char cmdbuf[12];
int retval;
unsigned char vfo_function;
split_t tsplit=0;
split_t tsplit = 0;
rig_debug(RIG_DEBUG_VERBOSE, "%s called %s,%d,%s\n", __func__, rig_strvfo(vfo), split, rig_strvfo(txvfo));
rig_debug(RIG_DEBUG_VERBOSE, "%s called %s,%d,%s\n", __func__, rig_strvfo(vfo),
split, rig_strvfo(txvfo));
if (RIG_IS_TS990S)
{
@ -1296,62 +1315,66 @@ int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
RETURNFUNC(kenwood_transaction(rig, cmdbuf, NULL, 0));
}
if (vfo == RIG_VFO_CURR) vfo = rig->state.current_vfo;
if (vfo == RIG_VFO_CURR) { vfo = rig->state.current_vfo; }
switch (vfo)
switch (vfo)
{
case RIG_VFO_A: vfo_function = '0'; break;
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 %s\n", __func__, rig_strvfo(vfo));
RETURNFUNC(-RIG_EINVAL);
}
rig_get_split(rig, vfo, &tsplit);
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): tsplit=%d, split=%d\n", __func__,
__LINE__, tsplit, split);
if (tsplit == split)
{
rig_debug(RIG_DEBUG_TRACE, "%s: split already set\n", __func__);
RETURNFUNC(RIG_OK);
}
/* set RX VFO */
snprintf(cmdbuf, sizeof(cmdbuf), "FR%c", vfo_function);
// FR can turn off split on some Kenwood rigs
// So we'll turn it back on just in case
TRACE;
if (split)
{
if (vfo_function == '0')
{
case RIG_VFO_A: vfo_function = '0'; break;
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 %s\n", __func__, rig_strvfo(vfo));
RETURNFUNC(-RIG_EINVAL);
}
rig_get_split(rig, vfo, &tsplit);
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): tsplit=%d, split=%d\n", __func__, __LINE__, tsplit, split);
if (tsplit == split)
{
rig_debug(RIG_DEBUG_TRACE, "%s: split already set\n", __func__);
RETURNFUNC(RIG_OK);
}
/* set RX VFO */
snprintf(cmdbuf, sizeof(cmdbuf), "FR%c", vfo_function);
// FR can turn off split on some Kenwood rigs
// So we'll turn it back on just in case
TRACE;
if (split)
{
if (vfo_function == '0')
{
TRACE;
strcat(cmdbuf, ";FT1");
}
else
{
TRACE;
strcat(cmdbuf, ";FT0");
}
TRACE;
strcat(cmdbuf, ";FT1");
}
else
{
TRACE;
strcat(cmdbuf, ";FT0");
}
}
else
{
strcat(cmdbuf, ";FT0");
}
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
rig->state.cache.split = split;
rig->state.cache.split_vfo = txvfo;
elapsed_ms(&rig->state.cache.time_split, HAMLIB_ELAPSED_SET);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
rig->state.cache.split = split;
rig->state.cache.split_vfo = txvfo;
elapsed_ms(&rig->state.cache.time_split, HAMLIB_ELAPSED_SET);
/* Split off means Rx and Tx are the same */
if (split == RIG_SPLIT_OFF)
@ -1369,14 +1392,18 @@ TRACE;
}
}
if (txvfo == RIG_VFO_CURR && vfo == RIG_VFO_A) {
if (vfo == RIG_VFO_A) txvfo = RIG_VFO_B;
else if (vfo == RIG_VFO_B) txvfo = RIG_VFO_A;
else {
rig_debug(RIG_DEBUG_ERR, "%s: unsupported split VFO=%s\n", __func__, rig_strvfo(txvfo));
if (txvfo == RIG_VFO_CURR && vfo == RIG_VFO_A)
{
if (vfo == RIG_VFO_A) { txvfo = RIG_VFO_B; }
else if (vfo == RIG_VFO_B) { txvfo = RIG_VFO_A; }
else
{
rig_debug(RIG_DEBUG_ERR, "%s: unsupported split VFO=%s\n", __func__,
rig_strvfo(txvfo));
RETURNFUNC(-RIG_EINVAL);
}
}
switch (txvfo)
{
case RIG_VFO_VFO:
@ -1400,20 +1427,24 @@ TRACE;
*/
tsplit = RIG_SPLIT_OFF; // default in case rig does not set split status
retval = rig_get_split(rig, vfo, &tsplit);
// and it should be OK to do a SPLIT_OFF at any time so we won's skip that
if (retval == RIG_OK && split == RIG_SPLIT_ON && tsplit == RIG_SPLIT_ON)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s: already set split=%d\n", __func__, tsplit);
RETURNFUNC(RIG_OK);
RETURNFUNC(RIG_OK);
}
rig_debug(RIG_DEBUG_VERBOSE, "%s: split is=%d, split wants=%d\n", __func__, tsplit, split);
rig_debug(RIG_DEBUG_VERBOSE, "%s: split is=%d, split wants=%d\n", __func__,
tsplit, split);
/* set TX VFO */
// if turning on split need to do some VFOB setup on Elecraft rigs to avoid SPLIT N/A and ER59 messages
if (rig->caps->rig_model == RIG_MODEL_K4 // Elecraft needs VFOB to be same band as VFOA
||rig->caps->rig_model == RIG_MODEL_K3
||rig->caps->rig_model == RIG_MODEL_KX2
||rig->caps->rig_model == RIG_MODEL_KX3)
if (rig->caps->rig_model ==
RIG_MODEL_K4 // Elecraft needs VFOB to be same band as VFOA
|| rig->caps->rig_model == RIG_MODEL_K3
|| rig->caps->rig_model == RIG_MODEL_KX2
|| rig->caps->rig_model == RIG_MODEL_KX3)
{
rig_set_freq(rig, RIG_VFO_B, rig->state.cache.freqMainA);
}
@ -1549,7 +1580,8 @@ int kenwood_get_split_vfo_if(RIG *rig, vfo_t rxvfo, split_t *split,
}
else
{
rig_debug(RIG_DEBUG_WARN, "%s(%d): unknown rxVFO=%s\n", __func__, __LINE__, rig_strvfo(rig->state.rx_vfo));
rig_debug(RIG_DEBUG_WARN, "%s(%d): unknown rxVFO=%s\n", __func__, __LINE__,
rig_strvfo(rig->state.rx_vfo));
*txvfo = RIG_VFO_A; // pick a default
}
@ -1568,9 +1600,11 @@ int kenwood_get_split_vfo_if(RIG *rig, vfo_t rxvfo, split_t *split,
}
else
{
rig_debug(RIG_DEBUG_WARN, "%s(%d): unknown rxVFO=%s\n", __func__, __LINE__, rig_strvfo(rig->state.rx_vfo));
rig_debug(RIG_DEBUG_WARN, "%s(%d): unknown rxVFO=%s\n", __func__, __LINE__,
rig_strvfo(rig->state.rx_vfo));
*txvfo = RIG_VFO_A; // pick a default
}
break;
case '2':
@ -1684,6 +1718,7 @@ int kenwood_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
}
rig_get_freq(rig, tvfo, &tfreq);
if (tfreq == freq)
{
rig_debug(RIG_DEBUG_TRACE, "%s: no freq change needed\n", __func__);
@ -2127,19 +2162,22 @@ int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
struct kenwood_priv_data *priv = rig->state.priv;
struct kenwood_priv_caps *caps = kenwood_caps(rig);
rig_debug(RIG_DEBUG_VERBOSE, "%s called, vfo=%s, mode=%s, width=%d, curr_vfo=%s\n", __func__,
rig_strvfo(vfo), rig_strrmode(mode), (int)width, rig_strvfo(rig->state.current_vfo));
rig_debug(RIG_DEBUG_VERBOSE,
"%s called, vfo=%s, mode=%s, width=%d, curr_vfo=%s\n", __func__,
rig_strvfo(vfo), rig_strrmode(mode), (int)width,
rig_strvfo(rig->state.current_vfo));
// we wont' set opposite VFO if the mode is the same as requested
// setting VFOB mode requires split modifications which cause VFO flashing
// this should generally work unless the user changes mode on VFOB
// in which case VFOB won't get mode changed until restart
if (priv->split && (priv->tx_vfo & (RIG_VFO_B|RIG_VFO_SUB|RIG_VFO_SUB_A)))
if (priv->split && (priv->tx_vfo & (RIG_VFO_B | RIG_VFO_SUB | RIG_VFO_SUB_A)))
{
if (priv->modeB == mode)
if (priv->modeB == mode)
{
rig_debug(RIG_DEBUG_TRACE, "%s: VFOB mode already %s so ignoring request\n", __func__, rig_strrmode(mode));
return(RIG_OK);
rig_debug(RIG_DEBUG_TRACE, "%s: VFOB mode already %s so ignoring request\n",
__func__, rig_strrmode(mode));
return (RIG_OK);
}
}
@ -2171,7 +2209,10 @@ int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
/* emulations like PowerSDR and SmartSDR normally hijack the
RTTY modes for SSB-DATA AFSK modes */
rig_debug(RIG_DEBUG_VERBOSE, "%s: emulate=%d, HPSDR=%d, changing PKT mode to RTTY\n", __func__, priv->is_emulation, RIG_IS_HPSDR);
rig_debug(RIG_DEBUG_VERBOSE,
"%s: emulate=%d, HPSDR=%d, changing PKT mode to RTTY\n", __func__,
priv->is_emulation, RIG_IS_HPSDR);
if (RIG_MODE_PKTLSB == mode) { mode = RIG_MODE_RTTY; }
if (RIG_MODE_PKTUSB == mode) { mode = RIG_MODE_RTTYR; }
@ -2252,25 +2293,37 @@ int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
datamode = 1;
}
}
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s, curr_mode=%s, new_mode=%s\n", __func__, rig_strvfo(vfo), rig_strrmode(priv->curr_mode), rig_strrmode(mode));
rig_debug(RIG_DEBUG_VERBOSE, "%s: vfo=%s, curr_mode=%s, new_mode=%s\n",
__func__, rig_strvfo(vfo), rig_strrmode(priv->curr_mode), rig_strrmode(mode));
// only change mode if needed
if (priv->curr_mode != mode)
{
snprintf(buf, sizeof(buf), "MD%c", c);
err = kenwood_transaction(rig, buf, NULL, 0);
}
// determine if we need to set datamode on A or B
needdata = 0;
if (vfo == RIG_VFO_CURR)
if (vfo == RIG_VFO_CURR)
{
TRACE;
vfo = rig->state.current_vfo;
}
if ((vfo & (RIG_VFO_A|RIG_VFO_MAIN)) && ((priv->datamodeA == 0 && datamode) || (priv->datamodeA == 1 && !datamode)))
if ((vfo & (RIG_VFO_A | RIG_VFO_MAIN)) && ((priv->datamodeA == 0 && datamode)
|| (priv->datamodeA == 1 && !datamode)))
{
needdata = 1;
if ((vfo & (RIG_VFO_B|RIG_VFO_SUB)) && ((priv->datamodeB == 0 && datamode) || (priv->datamodeB == 1 && !datamode)))
}
if ((vfo & (RIG_VFO_B | RIG_VFO_SUB)) && ((priv->datamodeB == 0 && datamode)
|| (priv->datamodeB == 1 && !datamode)))
{
needdata = 1;
}
if (needdata)
{
@ -2282,7 +2335,8 @@ int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
}
else if (datamode)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): datamode set on %s not needed\n", __func__, __LINE__, rig_strvfo(vfo));
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): datamode set on %s not needed\n",
__func__, __LINE__, rig_strvfo(vfo));
}
if (RIG_PASSBAND_NOCHANGE == width) { RETURNFUNC(RIG_OK); }
@ -2427,7 +2481,8 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
struct kenwood_priv_data *priv = rig->state.priv;
struct kenwood_priv_caps *caps = kenwood_caps(rig);
rig_debug(RIG_DEBUG_VERBOSE, "%s called, curr_vfo=%s\n", __func__, rig_strvfo(rig->state.current_vfo));
rig_debug(RIG_DEBUG_VERBOSE, "%s called, curr_vfo=%s\n", __func__,
rig_strvfo(rig->state.current_vfo));
if (!mode || !width)
{
@ -2471,7 +2526,8 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
}
else
{
if (vfo == RIG_VFO_B && rig->caps->rig_model == RIG_MODEL_K4) // K4 new MD$ command for VFOB
if (vfo == RIG_VFO_B
&& rig->caps->rig_model == RIG_MODEL_K4) // K4 new MD$ command for VFOB
{
snprintf(cmd, sizeof(cmd), "MD$");
offs = 3;
@ -2505,7 +2561,10 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
/* emulations like PowerSDR and SmartSDR normally hijack the
RTTY modes for SSB-DATA AFSK modes */
rig_debug(RIG_DEBUG_VERBOSE, "%s: emulate=%d, HPSDR=%d, changing RTTY mode to PKT\n", __func__, priv->is_emulation, RIG_IS_HPSDR);
rig_debug(RIG_DEBUG_VERBOSE,
"%s: emulate=%d, HPSDR=%d, changing RTTY mode to PKT\n", __func__,
priv->is_emulation, RIG_IS_HPSDR);
if (RIG_MODE_RTTY == *mode) { *mode = RIG_MODE_PKTLSB; }
if (RIG_MODE_RTTYR == *mode) { *mode = RIG_MODE_PKTUSB; }
@ -2523,8 +2582,9 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
if ('1' == modebuf[2])
{
if (vfo == RIG_VFO_A) priv->datamodeA = 1;
else priv->datamodeB = 1;
if (vfo == RIG_VFO_A) { priv->datamodeA = 1; }
else { priv->datamodeB = 1; }
switch (*mode)
{
case RIG_MODE_USB: *mode = RIG_MODE_PKTUSB; break;
@ -2540,8 +2600,8 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
}
else
{
if (vfo == RIG_VFO_A) priv->datamodeA = 0;
else priv->datamodeB = 0;
if (vfo == RIG_VFO_A) { priv->datamodeA = 0; }
else { priv->datamodeB = 0; }
}
}
@ -2561,9 +2621,9 @@ int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
*width = rig_passband_normal(rig, *mode);
}
if (vfo == RIG_VFO_A) priv->modeA = *mode;
else priv->modeB = *mode;
if (vfo == RIG_VFO_A) { priv->modeA = *mode; }
else { priv->modeB = *mode; }
RETURNFUNC(RIG_OK);
}

1
rigs/kenwood/ts890s.c
Wyświetl plik

@ -224,6 +224,7 @@ int kenwood_ts890_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
default:
return kenwood_get_level(rig, vfo, level, val);
}
return -RIG_EINTERNAL;
}

7
rigs/kit/funcube.c
Wyświetl plik

@ -75,7 +75,8 @@ static int funcubepro_get_level(RIG *rig, vfo_t vfo, setting_t level,
value_t *val);
static const char *funcube_get_info(RIG *rig);
static int funcube_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width);
static int funcube_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode,
pbwidth_t *width);
static const struct confparams funcube_cfg_params[] =
{
@ -943,7 +944,8 @@ int funcubepro_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return RIG_OK;
}
static int funcube_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
static int funcube_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode,
pbwidth_t *width)
{
if (rig->caps->rig_model == RIG_MODEL_FUNCUBEDONGLE)
{
@ -953,6 +955,7 @@ static int funcube_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width
{
*mode = RIG_MODE_IQ;
}
*width = 192000;
return RIG_OK;
}

3
rigs/tentec/omnivii.c
Wyświetl plik

@ -288,7 +288,8 @@ static int tt588_transaction(RIG *rig, const char *cmd, int cmd_len, char *data,
if (data)
{
retval = read_string(&rs->rigport, data, (*data_len) + 1, term, strlen(term), 0, 1);
retval = read_string(&rs->rigport, data, (*data_len) + 1, term, strlen(term), 0,
1);
if (retval != -RIG_ETIMEOUT)
{

1
rigs/tentec/rx331.c
Wyświetl plik

@ -780,6 +780,7 @@ int rx331_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
return -RIG_EPROTO;
}
f = val->i / 120.0;
val->f = 1.0 - f;

3
rigs/tentec/tt550.c
Wyświetl plik

@ -1699,7 +1699,8 @@ tt550_decode_event(RIG *rig)
priv = (struct tt550_priv_data *) rs->priv;
data_len = read_string(&rs->rigport, (char *) buf, MAXFRAMELEN, "\n\r", 2, 0, 1);
data_len = read_string(&rs->rigport, (char *) buf, MAXFRAMELEN, "\n\r", 2, 0,
1);
if (data_len == -RIG_ETIMEOUT)

3
rigs/yaesu/frg100.c
Wyświetl plik

@ -36,7 +36,8 @@
#include "yaesu.h"
#include "frg100.h"
enum frg100_native_cmd_e {
enum frg100_native_cmd_e
{
FRG100_NATIVE_RECALL_MEM = 0, /* 0x02, p1=ch */
FRG100_NATIVE_VFO_TO_MEM, /* 0x03, p1=ch, p2=0 */
FRG100_NATIVE_MEM_HIDE, /* 0x03, p1=ch, p2=1 */

165
rigs/yaesu/ft100.c
Wyświetl plik

@ -41,51 +41,52 @@
#include "misc.h"
#include "bandplan.h"
enum ft100_native_cmd_e {
enum ft100_native_cmd_e
{
FT100_NATIVE_CAT_LOCK_ON = 0,
FT100_NATIVE_CAT_LOCK_OFF,
FT100_NATIVE_CAT_PTT_ON,
FT100_NATIVE_CAT_PTT_OFF,
FT100_NATIVE_CAT_SET_FREQ,
FT100_NATIVE_CAT_SET_MODE_LSB,
FT100_NATIVE_CAT_SET_MODE_USB,
FT100_NATIVE_CAT_SET_MODE_CW,
FT100_NATIVE_CAT_SET_MODE_CWR,
FT100_NATIVE_CAT_SET_MODE_AM,
FT100_NATIVE_CAT_SET_MODE_FM,
FT100_NATIVE_CAT_SET_MODE_DIG,
FT100_NATIVE_CAT_SET_MODE_WFM,
FT100_NATIVE_CAT_CLAR_ON,
FT100_NATIVE_CAT_CLAR_OFF,
FT100_NATIVE_CAT_SET_CLAR_FREQ,
FT100_NATIVE_CAT_SET_VFOAB,
FT100_NATIVE_CAT_SET_VFOA,
FT100_NATIVE_CAT_SET_VFOB,
FT100_NATIVE_CAT_SPLIT_ON,
FT100_NATIVE_CAT_SPLIT_OFF,
FT100_NATIVE_CAT_SET_RPT_SHIFT_MINUS,
FT100_NATIVE_CAT_SET_RPT_SHIFT_PLUS,
FT100_NATIVE_CAT_SET_RPT_SHIFT_SIMPLEX,
FT100_NATIVE_CAT_SET_RPT_OFFSET,
/* fix me */
FT100_NATIVE_CAT_SET_DCS_ON,
FT100_NATIVE_CAT_SET_CTCSS_ENC_ON,
FT100_NATIVE_CAT_SET_CTCSS_ENC_DEC_ON,
FT100_NATIVE_CAT_SET_CTCSS_DCS_OFF,
/* em xif */
FT100_NATIVE_CAT_SET_CTCSS_FREQ,
FT100_NATIVE_CAT_SET_DCS_CODE,
FT100_NATIVE_CAT_GET_RX_STATUS,
FT100_NATIVE_CAT_GET_TX_STATUS,
FT100_NATIVE_CAT_GET_FREQ_MODE_STATUS,
FT100_NATIVE_CAT_PWR_WAKE,
FT100_NATIVE_CAT_PWR_ON,
FT100_NATIVE_CAT_PWR_OFF,
FT100_NATIVE_CAT_READ_STATUS,
FT100_NATIVE_CAT_READ_METERS,
FT100_NATIVE_CAT_READ_FLAGS,
FT100_NATIVE_SIZE /* end marker */
FT100_NATIVE_CAT_LOCK_ON = 0,
FT100_NATIVE_CAT_LOCK_OFF,
FT100_NATIVE_CAT_PTT_ON,
FT100_NATIVE_CAT_PTT_OFF,
FT100_NATIVE_CAT_SET_FREQ,
FT100_NATIVE_CAT_SET_MODE_LSB,
FT100_NATIVE_CAT_SET_MODE_USB,
FT100_NATIVE_CAT_SET_MODE_CW,
FT100_NATIVE_CAT_SET_MODE_CWR,
FT100_NATIVE_CAT_SET_MODE_AM,
FT100_NATIVE_CAT_SET_MODE_FM,
FT100_NATIVE_CAT_SET_MODE_DIG,
FT100_NATIVE_CAT_SET_MODE_WFM,
FT100_NATIVE_CAT_CLAR_ON,
FT100_NATIVE_CAT_CLAR_OFF,
FT100_NATIVE_CAT_SET_CLAR_FREQ,
FT100_NATIVE_CAT_SET_VFOAB,
FT100_NATIVE_CAT_SET_VFOA,
FT100_NATIVE_CAT_SET_VFOB,
FT100_NATIVE_CAT_SPLIT_ON,
FT100_NATIVE_CAT_SPLIT_OFF,
FT100_NATIVE_CAT_SET_RPT_SHIFT_MINUS,
FT100_NATIVE_CAT_SET_RPT_SHIFT_PLUS,
FT100_NATIVE_CAT_SET_RPT_SHIFT_SIMPLEX,
FT100_NATIVE_CAT_SET_RPT_OFFSET,
/* fix me */
FT100_NATIVE_CAT_SET_DCS_ON,
FT100_NATIVE_CAT_SET_CTCSS_ENC_ON,
FT100_NATIVE_CAT_SET_CTCSS_ENC_DEC_ON,
FT100_NATIVE_CAT_SET_CTCSS_DCS_OFF,
/* em xif */
FT100_NATIVE_CAT_SET_CTCSS_FREQ,
FT100_NATIVE_CAT_SET_DCS_CODE,
FT100_NATIVE_CAT_GET_RX_STATUS,
FT100_NATIVE_CAT_GET_TX_STATUS,
FT100_NATIVE_CAT_GET_FREQ_MODE_STATUS,
FT100_NATIVE_CAT_PWR_WAKE,
FT100_NATIVE_CAT_PWR_ON,
FT100_NATIVE_CAT_PWR_OFF,
FT100_NATIVE_CAT_READ_STATUS,
FT100_NATIVE_CAT_READ_METERS,
FT100_NATIVE_CAT_READ_FLAGS,
FT100_NATIVE_SIZE /* end marker */
};
/*
@ -95,41 +96,41 @@ enum ft100_native_cmd_e {
*/
typedef struct
{
unsigned char band_no;
unsigned char freq[4];
unsigned char mode;
unsigned char ctcss;
unsigned char dcs;
unsigned char flag1;
unsigned char flag2;
unsigned char clarifier[2];
unsigned char not_used;
unsigned char step1;
unsigned char step2;
unsigned char filter;
unsigned char band_no;
unsigned char freq[4];
unsigned char mode;
unsigned char ctcss;
unsigned char dcs;
unsigned char flag1;
unsigned char flag2;
unsigned char clarifier[2];
unsigned char not_used;
unsigned char step1;
unsigned char step2;
unsigned char filter;
unsigned char stuffing[16];
unsigned char stuffing[16];
}
FT100_STATUS_INFO;
FT100_STATUS_INFO;
typedef struct
{
unsigned char mic_switch_1;
unsigned char tx_fwd_power;
unsigned char tx_rev_power;
unsigned char s_meter;
unsigned char mic_level;
unsigned char squelch_level;
unsigned char mic_switch_2;
unsigned char final_temp;
unsigned char alc_level;
unsigned char mic_switch_1;
unsigned char tx_fwd_power;
unsigned char tx_rev_power;
unsigned char s_meter;
unsigned char mic_level;
unsigned char squelch_level;
unsigned char mic_switch_2;
unsigned char final_temp;
unsigned char alc_level;
}
FT100_METER_INFO;
FT100_METER_INFO;
typedef struct
{
unsigned char byte[8];
unsigned char byte[8];
}
FT100_FLAG_INFO;
@ -161,8 +162,10 @@ static int ft100_set_parm(RIG *rig, setting_t parm, value_t val);
static int ft100_get_parm(RIG *rig, setting_t parm, value_t *val);
#endif
static int ft100_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
static int ft100_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo);
static int ft100_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
vfo_t tx_vfo);
static int ft100_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo);
static int ft100_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t shift);
static int ft100_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *shift);
@ -525,7 +528,7 @@ static int ft100_send_priv_cmd(RIG *rig, unsigned char cmd_index)
if (!rig) { return -RIG_EINVAL; }
return write_block(&rig->state.rigport, (char *) &ncmd[cmd_index].nseq,
YAESU_CMD_LENGTH);
YAESU_CMD_LENGTH);
}
static int ft100_read_status(RIG *rig)
@ -920,18 +923,24 @@ int ft100_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
{
case RIG_PTT_ON:
cmd_index = FT100_NATIVE_CAT_PTT_ON;
if (split) rig_set_vfo(rig,RIG_VFO_B);
if (split) { rig_set_vfo(rig, RIG_VFO_B); }
break;
case RIG_PTT_OFF:
cmd_index = FT100_NATIVE_CAT_PTT_OFF;
if (split) rig_set_vfo(rig,RIG_VFO_A);
hl_usleep(100*1000); // give ptt some time to do it's thing -- fake it was not reseting freq after tx
if (split) { rig_set_vfo(rig, RIG_VFO_A); }
hl_usleep(100 *
1000); // give ptt some time to do it's thing -- fake it was not reseting freq after tx
break;
default:
return -RIG_EINVAL;
}
return ft100_send_priv_cmd(rig, cmd_index);
}
@ -974,9 +983,11 @@ int ft100_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
rig_debug(RIG_DEBUG_VERBOSE, "%s: %s\n", __func__, rig_strlevel(level));
// if in split have to switch to VFOB to read power and back to VFOA
if (split && ptt) rig_set_vfo(rig, RIG_VFO_B);
if (split && ptt) { rig_set_vfo(rig, RIG_VFO_B); }
ret = ft100_send_priv_cmd(rig, FT100_NATIVE_CAT_READ_METERS);
if (split && ptt) rig_set_vfo(rig, RIG_VFO_A);
if (split && ptt) { rig_set_vfo(rig, RIG_VFO_A); }
if (ret != RIG_OK)
{

196
rigs/yaesu/ft1000d.c
Wyświetl plik

@ -44,73 +44,74 @@
#include "ft1000d.h"
// FT1000D native commands
enum FT1000D_native_cmd_e {
FT1000D_NATIVE_SPLIT_OFF = 0,
FT1000D_NATIVE_SPLIT_ON,
FT1000D_NATIVE_RECALL_MEM,
FT1000D_NATIVE_VFO_TO_MEM,
FT1000D_NATIVE_LOCK_OFF,
FT1000D_NATIVE_LOCK_ON,
FT1000D_NATIVE_VFO_A,
FT1000D_NATIVE_VFO_B,
FT1000D_NATIVE_MEM_TO_VFO,
FT1000D_NATIVE_VFO_STEP_UP,
FT1000D_NATIVE_VFO_STEP_UP_FAST,
FT1000D_NATIVE_VFO_STEP_DOWN,
FT1000D_NATIVE_VFO_STEP_DOWN_FAST,
FT1000D_NATIVE_RX_CLARIFIER_OFF,
FT1000D_NATIVE_RX_CLARIFIER_ON,
FT1000D_NATIVE_TX_CLARIFIER_OFF,
FT1000D_NATIVE_TX_CLARIFIER_ON,
FT1000D_NATIVE_CLEAR_CLARIFIER_OFFSET,
FT1000D_NATIVE_CLARIFIER_OPS,
FT1000D_NATIVE_FREQ_SET,
FT1000D_NATIVE_MODE_SET_LSB,
FT1000D_NATIVE_MODE_SET_USB,
FT1000D_NATIVE_MODE_SET_CW_W,
FT1000D_NATIVE_MODE_SET_CW_N,
FT1000D_NATIVE_MODE_SET_AM_W,
FT1000D_NATIVE_MODE_SET_AM_N,
FT1000D_NATIVE_MODE_SET_FM,
FT1000D_NATIVE_MODE_SET_RTTY_LSB,
FT1000D_NATIVE_MODE_SET_RTTY_USB,
FT1000D_NATIVE_MODE_SET_PKT_LSB,
FT1000D_NATIVE_MODE_SET_PKT_FM,
FT1000D_NATIVE_MODE_SUB_VFOB_SET_LSB, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_USB, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_CW_W, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_CW_N, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_AM_W, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_AM_N, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_FM, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_RTTY_LSB, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_RTTY_USB, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_PKT_LSB, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_PKT_FM, /* Added December 2016 */
FT1000D_NATIVE_PACING,
FT1000D_NATIVE_PTT_OFF,
FT1000D_NATIVE_PTT_ON,
FT1000D_NATIVE_UPDATE_ALL_DATA,
FT1000D_NATIVE_UPDATE_MEM_CHNL,
FT1000D_NATIVE_UPDATE_OP_DATA,
FT1000D_NATIVE_UPDATE_VFO_DATA,
FT1000D_NATIVE_UPDATE_MEM_CHNL_DATA,
FT1000D_NATIVE_TUNER_OFF,
FT1000D_NATIVE_TUNER_ON,
FT1000D_NATIVE_TUNER_START,
FT1000D_NATIVE_RPTR_SHIFT_NONE,
FT1000D_NATIVE_RPTR_SHIFT_MINUS,
FT1000D_NATIVE_RPTR_SHIFT_PLUS,
FT1000D_NATIVE_VFO_TO_VFO,
FT1000D_NATIVE_SET_SUB_VFO_FREQ,
FT1000D_NATIVE_BANDWIDTH,
FT1000D_NATIVE_OP_FREQ_STEP_UP,
FT1000D_NATIVE_OP_FREQ_STEP_DOWN,
FT1000D_NATIVE_READ_METER,
FT1000D_NATIVE_DIM_LEVEL,
FT1000D_NATIVE_RPTR_OFFSET,
FT1000D_NATIVE_READ_FLAGS,
FT1000D_NATIVE_SIZE
enum FT1000D_native_cmd_e
{
FT1000D_NATIVE_SPLIT_OFF = 0,
FT1000D_NATIVE_SPLIT_ON,
FT1000D_NATIVE_RECALL_MEM,
FT1000D_NATIVE_VFO_TO_MEM,
FT1000D_NATIVE_LOCK_OFF,
FT1000D_NATIVE_LOCK_ON,
FT1000D_NATIVE_VFO_A,
FT1000D_NATIVE_VFO_B,
FT1000D_NATIVE_MEM_TO_VFO,
FT1000D_NATIVE_VFO_STEP_UP,
FT1000D_NATIVE_VFO_STEP_UP_FAST,
FT1000D_NATIVE_VFO_STEP_DOWN,
FT1000D_NATIVE_VFO_STEP_DOWN_FAST,
FT1000D_NATIVE_RX_CLARIFIER_OFF,
FT1000D_NATIVE_RX_CLARIFIER_ON,
FT1000D_NATIVE_TX_CLARIFIER_OFF,
FT1000D_NATIVE_TX_CLARIFIER_ON,
FT1000D_NATIVE_CLEAR_CLARIFIER_OFFSET,
FT1000D_NATIVE_CLARIFIER_OPS,
FT1000D_NATIVE_FREQ_SET,
FT1000D_NATIVE_MODE_SET_LSB,
FT1000D_NATIVE_MODE_SET_USB,
FT1000D_NATIVE_MODE_SET_CW_W,
FT1000D_NATIVE_MODE_SET_CW_N,
FT1000D_NATIVE_MODE_SET_AM_W,
FT1000D_NATIVE_MODE_SET_AM_N,
FT1000D_NATIVE_MODE_SET_FM,
FT1000D_NATIVE_MODE_SET_RTTY_LSB,
FT1000D_NATIVE_MODE_SET_RTTY_USB,
FT1000D_NATIVE_MODE_SET_PKT_LSB,
FT1000D_NATIVE_MODE_SET_PKT_FM,
FT1000D_NATIVE_MODE_SUB_VFOB_SET_LSB, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_USB, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_CW_W, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_CW_N, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_AM_W, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_AM_N, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_FM, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_RTTY_LSB, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_RTTY_USB, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_PKT_LSB, /* Added December 2016 */
FT1000D_NATIVE_MODE_SUB_VFOB_SET_PKT_FM, /* Added December 2016 */
FT1000D_NATIVE_PACING,
FT1000D_NATIVE_PTT_OFF,
FT1000D_NATIVE_PTT_ON,
FT1000D_NATIVE_UPDATE_ALL_DATA,
FT1000D_NATIVE_UPDATE_MEM_CHNL,
FT1000D_NATIVE_UPDATE_OP_DATA,
FT1000D_NATIVE_UPDATE_VFO_DATA,
FT1000D_NATIVE_UPDATE_MEM_CHNL_DATA,
FT1000D_NATIVE_TUNER_OFF,
FT1000D_NATIVE_TUNER_ON,
FT1000D_NATIVE_TUNER_START,
FT1000D_NATIVE_RPTR_SHIFT_NONE,
FT1000D_NATIVE_RPTR_SHIFT_MINUS,
FT1000D_NATIVE_RPTR_SHIFT_PLUS,
FT1000D_NATIVE_VFO_TO_VFO,
FT1000D_NATIVE_SET_SUB_VFO_FREQ,
FT1000D_NATIVE_BANDWIDTH,
FT1000D_NATIVE_OP_FREQ_STEP_UP,
FT1000D_NATIVE_OP_FREQ_STEP_DOWN,
FT1000D_NATIVE_READ_METER,
FT1000D_NATIVE_DIM_LEVEL,
FT1000D_NATIVE_RPTR_OFFSET,
FT1000D_NATIVE_READ_FLAGS,
FT1000D_NATIVE_SIZE
};
static int ft1000d_init(RIG *rig);
@ -120,20 +121,28 @@ static int ft1000d_close(RIG *rig);
static int ft1000d_set_freq(RIG *rig, vfo_t vfo, freq_t freq);
static int ft1000d_get_freq(RIG *rig, vfo_t vfo, freq_t *freq);
static int ft1000d_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width);
static int ft1000d_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width);
static int ft1000d_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode,
pbwidth_t *width);
static int ft1000d_set_vfo(RIG *rig, vfo_t vfo);
static int ft1000d_get_vfo(RIG *rig, vfo_t *vfo);
static int ft1000d_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt);
static int ft1000d_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt);
static int ft1000d_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift);
static int ft1000d_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift);
static int ft1000d_get_rptr_shift(RIG *rig, vfo_t vfo,
rptr_shift_t *rptr_shift);
static int ft1000d_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t offs);
static int ft1000d_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq); /* Added December 2016 */
static int ft1000d_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq); /* Added December 2016 */
static int ft1000d_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
static int ft1000d_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo);
static int ft1000d_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width); /* Added December 2016 */
static int ft1000d_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode, pbwidth_t *tx_width); /* Added December 2016 */
static int ft1000d_set_split_freq(RIG *rig, vfo_t vfo,
freq_t tx_freq); /* Added December 2016 */
static int ft1000d_get_split_freq(RIG *rig, vfo_t vfo,
freq_t *tx_freq); /* Added December 2016 */
static int ft1000d_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
vfo_t tx_vfo);
static int ft1000d_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo);
static int ft1000d_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode,
pbwidth_t tx_width); /* Added December 2016 */
static int ft1000d_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode,
pbwidth_t *tx_width); /* Added December 2016 */
static int ft1000d_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit);
static int ft1000d_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit);
static int ft1000d_set_func(RIG *rig, vfo_t vfo, setting_t func, int status);
@ -141,12 +150,14 @@ static int ft1000d_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status);
static int ft1000d_set_parm(RIG *rig, setting_t parm, value_t val);
static int ft1000d_set_xit(RIG *rig, vfo_t vfo, shortfreq_t xit);
static int ft1000d_get_xit(RIG *rig, vfo_t vfo, shortfreq_t *xit);
static int ft1000d_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *value);
static int ft1000d_get_level(RIG *rig, vfo_t vfo, setting_t level,
value_t *value);
static int ft1000d_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op);
static int ft1000d_set_mem(RIG *rig, vfo_t vfo, int ch);
static int ft1000d_get_mem(RIG *rig, vfo_t vfo, int *ch);
static int ft1000d_set_channel (RIG *rig, vfo_t vfo, const channel_t *chan);
static int ft1000d_get_channel (RIG *rig, vfo_t vfo, channel_t *chan, int read_only);
static int ft1000d_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan);
static int ft1000d_get_channel(RIG *rig, vfo_t vfo, channel_t *chan,
int read_only);
@ -1121,7 +1132,8 @@ static int ft1000d_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t offs)
* the correct TX VFO is selected by the rig in split mode.
* An error is returned if vfo and tx_vfo are the same.
*/
static int ft1000d_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
static int ft1000d_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
vfo_t tx_vfo)
{
struct ft1000d_priv_data *priv;
unsigned char ci;
@ -1222,7 +1234,8 @@ static int ft1000d_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vf
* Comments: The passed value for the vfo is ignored in order to
* preserve the current split vfo system settings.
*/
static int ft1000d_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo)
static int ft1000d_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo)
{
struct ft1000d_priv_data *priv;
int err;
@ -2076,7 +2089,8 @@ static int ft1000d_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
* In all other cases the passed vfo is selected if it differs
* from the currently selected VFO.
*/
static int ft1000d_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
static int ft1000d_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode,
pbwidth_t *width)
{
struct ft1000d_priv_data *priv;
unsigned char *p;
@ -2435,7 +2449,8 @@ static int ft1000d_get_vfo(RIG *rig, vfo_t *vfo)
* In all other cases the passed vfo is selected if it differs
* from the currently selected VFO.
*/
static int ft1000d_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *value)
static int ft1000d_get_level(RIG *rig, vfo_t vfo, setting_t level,
value_t *value)
{
struct ft1000d_priv_data *priv;
unsigned char mdata[YAESU_CMD_LENGTH];
@ -2480,7 +2495,8 @@ static int ft1000d_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *valu
return err;
}
err = read_block(&rig->state.rigport, (char *) mdata, FT1000D_READ_METER_LENGTH);
err = read_block(&rig->state.rigport, (char *) mdata,
FT1000D_READ_METER_LENGTH);
if (err < 0)
{
@ -2798,7 +2814,8 @@ static int ft1000d_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
* Status for split operation, active rig functions and tuning steps
* are only relevant for currVFO
*/
static int ft1000d_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
static int ft1000d_get_channel(RIG *rig, vfo_t vfo, channel_t *chan,
int read_only)
{
struct ft1000d_priv_data *priv;
ft1000d_op_data_t *p;
@ -3279,7 +3296,8 @@ static int ft1000d_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_on
* Returns: RIG_OK if all called functions are successful,
* otherwise returns error from called functiion
*/
static int ft1000d_get_update_data(RIG *rig, unsigned char ci, unsigned short ch)
static int ft1000d_get_update_data(RIG *rig, unsigned char ci,
unsigned short ch)
{
struct rig_state *rig_s;
struct ft1000d_priv_data *priv;
@ -3447,8 +3465,8 @@ static int ft1000d_send_static_cmd(RIG *rig, unsigned char ci)
* otherwise returns error from called functiion
*/
static int ft1000d_send_dynamic_cmd(RIG *rig, unsigned char ci,
unsigned char p1, unsigned char p2,
unsigned char p3, unsigned char p4)
unsigned char p1, unsigned char p2,
unsigned char p3, unsigned char p4)
{
struct ft1000d_priv_data *priv;
int err;
@ -3768,7 +3786,7 @@ static int ft1000d_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq)
*/
static int ft1000d_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode,
pbwidth_t tx_width)
pbwidth_t tx_width)
{
int err;
unsigned char bw;
@ -3901,7 +3919,7 @@ static int ft1000d_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode,
*/
static int ft1000d_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode,
pbwidth_t *tx_width)
pbwidth_t *tx_width)
{
struct ft1000d_priv_data *priv;
int err;

38
rigs/yaesu/ft1000mp.c
Wyświetl plik

@ -117,10 +117,13 @@ static int ft1000mp_open(RIG *rig);
static int ft1000mp_set_freq(RIG *rig, vfo_t vfo, freq_t freq);
static int ft1000mp_get_freq(RIG *rig, vfo_t vfo, freq_t *freq);
static int ft1000mp_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq);
static int ft1000mp_set_split_freq_mode(RIG *rig, vfo_t vfo, freq_t freq, rmode_t mode, pbwidth_t width);
static int ft1000mp_set_split_freq_mode(RIG *rig, vfo_t vfo, freq_t freq,
rmode_t mode, pbwidth_t width);
static int ft1000mp_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq);
static int ft1000mp_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
static int ft1000mp_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo);
static int ft1000mp_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
vfo_t tx_vfo);
static int ft1000mp_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo);
static int ft1000mp_set_mode(RIG *rig, vfo_t vfo, rmode_t mode,
pbwidth_t width); /* select mode */
static int ft1000mp_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode,
@ -131,7 +134,8 @@ static int ft1000mp_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit);
static int ft1000mp_set_xit(RIG *rig, vfo_t vfo, shortfreq_t rit);
static int ft1000mp_set_rxit(RIG *rig, vfo_t vfo, shortfreq_t rit);
static int ft1000mp_get_rxit(RIG *rig, vfo_t vfo, shortfreq_t *rit);
static int ft1000mp_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val);
static int ft1000mp_get_level(RIG *rig, vfo_t vfo, setting_t level,
value_t *val);
static int ft1000mp_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt);
static int ft1000mp_set_func(RIG *rig, vfo_t vfo, setting_t func, int status);
static int ft1000mp_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status);
@ -423,7 +427,7 @@ const struct rig_caps ft1000mp_caps =
.set_split_freq = ft1000mp_set_split_freq,
.get_split_freq = ft1000mp_get_split_freq,
.set_split_freq_mode =ft1000mp_set_split_freq_mode,
.set_split_freq_mode = ft1000mp_set_split_freq_mode,
.set_split_vfo = ft1000mp_set_split_vfo,
.get_split_vfo = ft1000mp_get_split_vfo,
@ -558,7 +562,7 @@ const struct rig_caps ft1000mpmkv_caps =
.set_split_freq = ft1000mp_set_split_freq,
.get_split_freq = ft1000mp_get_split_freq,
.set_split_freq_mode =ft1000mp_set_split_freq_mode,
.set_split_freq_mode = ft1000mp_set_split_freq_mode,
.set_split_vfo = ft1000mp_set_split_vfo,
.get_split_vfo = ft1000mp_get_split_vfo,
@ -693,7 +697,7 @@ const struct rig_caps ft1000mpmkvfld_caps =
.set_split_freq = ft1000mp_set_split_freq,
.get_split_freq = ft1000mp_get_split_freq,
.set_split_freq_mode =ft1000mp_set_split_freq_mode,
.set_split_freq_mode = ft1000mp_set_split_freq_mode,
.set_split_vfo = ft1000mp_set_split_vfo,
.get_split_vfo = ft1000mp_get_split_vfo,
@ -815,7 +819,8 @@ static int ft1000mp_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
p = (struct ft1000mp_priv_data *)rig->state.priv;
rig_debug(RIG_DEBUG_TRACE, "%s: requested freq on %s = %"PRIfreq" Hz \n", __func__,
rig_debug(RIG_DEBUG_TRACE, "%s: requested freq on %s = %"PRIfreq" Hz \n",
__func__,
rig_strvfo(vfo), freq);
if (vfo == RIG_VFO_CURR)
@ -1066,7 +1071,8 @@ static int ft1000mp_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
*
*/
static int ft1000mp_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
static int ft1000mp_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode,
pbwidth_t *width)
{
struct ft1000mp_priv_data *priv;
unsigned char mymode; /* ft1000mp mode */
@ -1324,6 +1330,7 @@ static int ft1000mp_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported set_func %s", __func__,
rig_strfunc(func));
}
RETURNFUNC(-RIG_EINVAL);
}
@ -1515,7 +1522,8 @@ static int ft1000mp_get_rxit(RIG *rig, vfo_t vfo, shortfreq_t *rit)
}
static int ft1000mp_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
static int ft1000mp_get_level(RIG *rig, vfo_t vfo, setting_t level,
value_t *val)
{
struct ft1000mp_priv_data *priv;
struct rig_state *rs;
@ -1687,13 +1695,15 @@ static int ft1000mp_send_priv_cmd(RIG *rig, unsigned char ci)
__func__);
RETURNFUNC(-RIG_EINVAL);
}
write_block(&rig->state.rigport, (char *) ncmd[ci].nseq, YAESU_CMD_LENGTH);
RETURNFUNC(RIG_OK);
}
static int ft1000mp_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
static int ft1000mp_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
vfo_t tx_vfo)
{
unsigned char cmd_index = 0; /* index of sequence to send */
@ -1730,7 +1740,8 @@ static int ft1000mp_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_v
*
*/
static int ft1000mp_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo)
static int ft1000mp_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo)
{
struct ft1000mp_priv_data *p;
int retval;
@ -1772,7 +1783,8 @@ static int ft1000mp_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
RETURNFUNC(ft1000mp_set_freq(rig, RIG_VFO_B, tx_freq));
}
static int ft1000mp_set_split_freq_mode(RIG *rig, vfo_t vfo, freq_t freq, rmode_t mode, pbwidth_t width)
static int ft1000mp_set_split_freq_mode(RIG *rig, vfo_t vfo, freq_t freq,
rmode_t mode, pbwidth_t width)
{
// don't believe mode on VFOB can be different than mode on VFOA
return ft1000mp_set_split_freq(rig, vfo, freq);

114
rigs/yaesu/ft600.c
Wyświetl plik

@ -41,47 +41,48 @@
#include "misc.h"
#include "bandplan.h"
enum ft600_native_cmd_e {
enum ft600_native_cmd_e
{
FT600_NATIVE_CAT_LOCK_ON = 0,
FT600_NATIVE_CAT_LOCK_OFF,
FT600_NATIVE_CAT_PTT_ON,
FT600_NATIVE_CAT_PTT_OFF,
FT600_NATIVE_CAT_SET_FREQ,
FT600_NATIVE_CAT_SET_MODE_LSB,
FT600_NATIVE_CAT_SET_MODE_USB,
FT600_NATIVE_CAT_SET_MODE_DIG,
FT600_NATIVE_CAT_SET_MODE_CW,
FT600_NATIVE_CAT_SET_MODE_AM,
FT600_NATIVE_CAT_CLAR_ON,
FT600_NATIVE_CAT_CLAR_OFF,
FT600_NATIVE_CAT_SET_CLAR_FREQ,
FT600_NATIVE_CAT_SET_VFOAB,
FT600_NATIVE_CAT_SET_VFOA,
FT600_NATIVE_CAT_SET_VFOB,
FT600_NATIVE_CAT_SPLIT_ON,
FT600_NATIVE_CAT_SPLIT_OFF,
FT600_NATIVE_CAT_SET_RPT_SHIFT_MINUS,
FT600_NATIVE_CAT_SET_RPT_SHIFT_PLUS,
FT600_NATIVE_CAT_SET_RPT_SHIFT_SIMPLEX,
FT600_NATIVE_CAT_SET_RPT_OFFSET,
/* fix me */
FT600_NATIVE_CAT_SET_DCS_ON,
FT600_NATIVE_CAT_SET_CTCSS_ENC_ON,
FT600_NATIVE_CAT_SET_CTCSS_ENC_DEC_ON,
FT600_NATIVE_CAT_SET_CTCSS_DCS_OFF,
/* em xif */
FT600_NATIVE_CAT_SET_CTCSS_FREQ,
FT600_NATIVE_CAT_SET_DCS_CODE,
FT600_NATIVE_CAT_GET_RX_STATUS,
FT600_NATIVE_CAT_GET_TX_STATUS,
FT600_NATIVE_CAT_GET_FREQ_MODE_STATUS,
FT600_NATIVE_CAT_PWR_WAKE,
FT600_NATIVE_CAT_PWR_ON,
FT600_NATIVE_CAT_PWR_OFF,
FT600_NATIVE_CAT_READ_STATUS,
FT600_NATIVE_CAT_READ_METERS,
FT600_NATIVE_CAT_READ_FLAGS
FT600_NATIVE_CAT_LOCK_ON = 0,
FT600_NATIVE_CAT_LOCK_OFF,
FT600_NATIVE_CAT_PTT_ON,
FT600_NATIVE_CAT_PTT_OFF,
FT600_NATIVE_CAT_SET_FREQ,
FT600_NATIVE_CAT_SET_MODE_LSB,
FT600_NATIVE_CAT_SET_MODE_USB,
FT600_NATIVE_CAT_SET_MODE_DIG,
FT600_NATIVE_CAT_SET_MODE_CW,
FT600_NATIVE_CAT_SET_MODE_AM,
FT600_NATIVE_CAT_CLAR_ON,
FT600_NATIVE_CAT_CLAR_OFF,
FT600_NATIVE_CAT_SET_CLAR_FREQ,
FT600_NATIVE_CAT_SET_VFOAB,
FT600_NATIVE_CAT_SET_VFOA,
FT600_NATIVE_CAT_SET_VFOB,
FT600_NATIVE_CAT_SPLIT_ON,
FT600_NATIVE_CAT_SPLIT_OFF,
FT600_NATIVE_CAT_SET_RPT_SHIFT_MINUS,
FT600_NATIVE_CAT_SET_RPT_SHIFT_PLUS,
FT600_NATIVE_CAT_SET_RPT_SHIFT_SIMPLEX,
FT600_NATIVE_CAT_SET_RPT_OFFSET,
/* fix me */
FT600_NATIVE_CAT_SET_DCS_ON,
FT600_NATIVE_CAT_SET_CTCSS_ENC_ON,
FT600_NATIVE_CAT_SET_CTCSS_ENC_DEC_ON,
FT600_NATIVE_CAT_SET_CTCSS_DCS_OFF,
/* em xif */
FT600_NATIVE_CAT_SET_CTCSS_FREQ,
FT600_NATIVE_CAT_SET_DCS_CODE,
FT600_NATIVE_CAT_GET_RX_STATUS,
FT600_NATIVE_CAT_GET_TX_STATUS,
FT600_NATIVE_CAT_GET_FREQ_MODE_STATUS,
FT600_NATIVE_CAT_PWR_WAKE,
FT600_NATIVE_CAT_PWR_ON,
FT600_NATIVE_CAT_PWR_OFF,
FT600_NATIVE_CAT_READ_STATUS,
FT600_NATIVE_CAT_READ_METERS,
FT600_NATIVE_CAT_READ_FLAGS
};
@ -92,28 +93,28 @@ enum ft600_native_cmd_e {
*/
typedef struct
{
unsigned char band_no;
unsigned char freq[16];
unsigned char mode;
unsigned char ctcss;
unsigned char dcs;
unsigned char flag1;
unsigned char flag2;
unsigned char clarifier[2];
unsigned char not_used;
unsigned char step1;
unsigned char step2;
unsigned char filter;
unsigned char band_no;
unsigned char freq[16];
unsigned char mode;
unsigned char ctcss;
unsigned char dcs;
unsigned char flag1;
unsigned char flag2;
unsigned char clarifier[2];
unsigned char not_used;
unsigned char step1;
unsigned char step2;
unsigned char filter;
// cppcheck-suppress *
unsigned char stuffing[16];
unsigned char stuffing[16];
}
FT600_STATUS_INFO;
FT600_STATUS_INFO;
typedef struct
{
unsigned char byte[8];
unsigned char byte[8];
}
// cppcheck-suppress *
FT600_FLAG_INFO;
@ -396,7 +397,8 @@ static int ft600_send_priv_cmd(RIG *rig, unsigned char cmd_index)
if (!rig) { return -RIG_EINVAL; }
return write_block(&rig->state.rigport, (char *) &ncmd[cmd_index].nseq, YAESU_CMD_LENGTH);
return write_block(&rig->state.rigport, (char *) &ncmd[cmd_index].nseq,
YAESU_CMD_LENGTH);
}
static int ft600_read_status(RIG *rig)

68
rigs/yaesu/ft747.c
Wyświetl plik

@ -52,35 +52,36 @@
*
*/
enum ft747_native_cmd_e {
FT_747_NATIVE_SPLIT_OFF = 0,
FT_747_NATIVE_SPLIT_ON,
FT_747_NATIVE_RECALL_MEM,
FT_747_NATIVE_VFO_TO_MEM,
FT_747_NATIVE_DLOCK_OFF,
FT_747_NATIVE_DLOCK_ON,
FT_747_NATIVE_VFO_A,
FT_747_NATIVE_VFO_B,
FT_747_NATIVE_M_TO_VFO,
FT_747_NATIVE_UP_500K,
FT_747_NATIVE_DOWN_500K,
FT_747_NATIVE_CLARIFY_OFF,
FT_747_NATIVE_CLARIFY_ON,
FT_747_NATIVE_FREQ_SET,
FT_747_NATIVE_MODE_SET_LSB,
FT_747_NATIVE_MODE_SET_USB,
FT_747_NATIVE_MODE_SET_CWW,
FT_747_NATIVE_MODE_SET_CWN,
FT_747_NATIVE_MODE_SET_AMW,
FT_747_NATIVE_MODE_SET_AMN,
FT_747_NATIVE_MODE_SET_FMW,
FT_747_NATIVE_MODE_SET_FMN,
FT_747_NATIVE_PACING,
FT_747_NATIVE_PTT_OFF,
FT_747_NATIVE_PTT_ON,
FT_747_NATIVE_UPDATE,
FT_747_NATIVE_SIZE /* end marker, value indicates number of */
/* native cmd entries */
enum ft747_native_cmd_e
{
FT_747_NATIVE_SPLIT_OFF = 0,
FT_747_NATIVE_SPLIT_ON,
FT_747_NATIVE_RECALL_MEM,
FT_747_NATIVE_VFO_TO_MEM,
FT_747_NATIVE_DLOCK_OFF,
FT_747_NATIVE_DLOCK_ON,
FT_747_NATIVE_VFO_A,
FT_747_NATIVE_VFO_B,
FT_747_NATIVE_M_TO_VFO,
FT_747_NATIVE_UP_500K,
FT_747_NATIVE_DOWN_500K,
FT_747_NATIVE_CLARIFY_OFF,
FT_747_NATIVE_CLARIFY_ON,
FT_747_NATIVE_FREQ_SET,
FT_747_NATIVE_MODE_SET_LSB,
FT_747_NATIVE_MODE_SET_USB,
FT_747_NATIVE_MODE_SET_CWW,
FT_747_NATIVE_MODE_SET_CWN,
FT_747_NATIVE_MODE_SET_AMW,
FT_747_NATIVE_MODE_SET_AMN,
FT_747_NATIVE_MODE_SET_FMW,
FT_747_NATIVE_MODE_SET_FMN,
FT_747_NATIVE_PACING,
FT_747_NATIVE_PTT_OFF,
FT_747_NATIVE_PTT_ON,
FT_747_NATIVE_UPDATE,
FT_747_NATIVE_SIZE /* end marker, value indicates number of */
/* native cmd entries */
};
@ -169,8 +170,10 @@ static int ft747_close(RIG *rig);
static int ft747_set_freq(RIG *rig, vfo_t vfo, freq_t freq);
static int ft747_get_freq(RIG *rig, vfo_t vfo, freq_t *freq);
static int ft747_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width); /* select mode */
static int ft747_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width); /* get mode */
static int ft747_set_mode(RIG *rig, vfo_t vfo, rmode_t mode,
pbwidth_t width); /* select mode */
static int ft747_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode,
pbwidth_t *width); /* get mode */
static int ft747_set_vfo(RIG *rig, vfo_t vfo); /* select vfo */
static int ft747_get_vfo(RIG *rig, vfo_t *vfo); /* get vfo */
@ -1049,7 +1052,8 @@ static int ft747_send_priv_cmd(RIG *rig, unsigned char ci)
return -RIG_EINVAL;
}
return write_block(&rig->state.rigport, (char *) ft747_ncmd[ci].nseq, YAESU_CMD_LENGTH);
return write_block(&rig->state.rigport, (char *) ft747_ncmd[ci].nseq,
YAESU_CMD_LENGTH);
}

6
rigs/yaesu/ft757gx.c
Wyświetl plik

@ -63,8 +63,10 @@ static int ft757_set_freq(RIG *rig, vfo_t vfo, freq_t freq);
static int ft757_get_freq(RIG *rig, vfo_t vfo, freq_t *freq);
static int ft757gx_get_freq(RIG *rig, vfo_t vfo, freq_t *freq);
static int ft757_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width); /* select mode */
static int ft757_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width); /* get mode */
static int ft757_set_mode(RIG *rig, vfo_t vfo, rmode_t mode,
pbwidth_t width); /* select mode */
static int ft757_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode,
pbwidth_t *width); /* get mode */
static int ft757_set_vfo(RIG *rig, vfo_t vfo); /* select vfo */
static int ft757_get_vfo(RIG *rig, vfo_t *vfo); /* get vfo */

187
rigs/yaesu/ft817.c
Wyświetl plik

@ -169,9 +169,9 @@ static int ft817_power2mW(RIG *rig, unsigned int *mwpower, float power,
static int ft817_mW2power(RIG *rig, float *power, unsigned int mwpower,
freq_t freq, rmode_t mode);
static int ft817_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option,
ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx);
ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx);
static int ft818_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option,
ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx);
ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx);
/* Native ft817 cmd set prototypes. These are READ ONLY as each */
/* rig instance will copy from these and modify if required . */
@ -320,8 +320,8 @@ const struct rig_caps ft817_caps =
.has_get_func = RIG_FUNC_NONE,
.has_set_func = RIG_FUNC_LOCK | RIG_FUNC_TONE | RIG_FUNC_TSQL,
.has_get_level =
RIG_LEVEL_STRENGTH | RIG_LEVEL_RAWSTR | RIG_LEVEL_RFPOWER |
RIG_LEVEL_ALC | RIG_LEVEL_SWR,
RIG_LEVEL_STRENGTH | RIG_LEVEL_RAWSTR | RIG_LEVEL_RFPOWER |
RIG_LEVEL_ALC | RIG_LEVEL_SWR,
.has_set_level = RIG_LEVEL_NONE,
.has_get_parm = RIG_PARM_NONE,
.has_set_parm = RIG_PARM_NONE,
@ -466,8 +466,8 @@ const struct rig_caps ft818_caps =
.has_get_func = RIG_FUNC_NONE,
.has_set_func = RIG_FUNC_LOCK | RIG_FUNC_TONE | RIG_FUNC_TSQL,
.has_get_level =
RIG_LEVEL_STRENGTH | RIG_LEVEL_RAWSTR | RIG_LEVEL_RFPOWER |
RIG_LEVEL_ALC | RIG_LEVEL_SWR,
RIG_LEVEL_STRENGTH | RIG_LEVEL_RAWSTR | RIG_LEVEL_RFPOWER |
RIG_LEVEL_ALC | RIG_LEVEL_SWR,
.has_set_level = RIG_LEVEL_NONE,
.has_get_parm = RIG_PARM_NONE,
.has_set_parm = RIG_PARM_NONE,
@ -729,7 +729,7 @@ static int ft817_get_status(RIG *rig, int status)
case FT817_NATIVE_CAT_GET_TX_METERING:
data = result;
len = sizeof(result)/sizeof(result[0]); /* We expect two bytes */
len = sizeof(result) / sizeof(result[0]); /* We expect two bytes */
tv = &p->tx_level_tv;
break;
@ -762,50 +762,51 @@ static int ft817_get_status(RIG *rig, int status)
if (n != len)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s: Length mismatch exp %d got %d!\n",
__func__, len, n);
__func__, len, n);
return -RIG_EIO;
}
switch(status)
switch (status)
{
case FT817_NATIVE_CAT_GET_FREQ_MODE_STATUS:
{
/* Only in digimode we need fetch to extra bits from EEPROM.
* This save communication cycle for all other modes.
* Because mode and frequency are shared this saves also when
* getting the frequency. */
switch (p->fm_status[4] & 0x7f)
{
/* Only in digimode we need fetch to extra bits from EEPROM.
* This save communication cycle for all other modes.
* Because mode and frequency are shared this saves also when
* getting the frequency. */
switch (p->fm_status[4] & 0x7f)
unsigned char dig_mode;
case 0x0a:
if ((n = ft817_read_eeprom(rig, 0x0065, &dig_mode)) < 0)
{
unsigned char dig_mode;
case 0x0a:
if ((n = ft817_read_eeprom(rig, 0x0065, &dig_mode)) < 0)
{
return n;
}
/* Top 3 bit define the digi mode */
p->dig_mode = dig_mode >> 5;
default:
break;
return n;
}
/* Top 3 bit define the digi mode */
p->dig_mode = dig_mode >> 5;
default:
break;
}
break;
}
break;
case FT817_NATIVE_CAT_GET_TX_METERING:
/* FT-817 returns 2 bytes with 4 nibbles.
* Extract raw values here;
* convert to float when they are requested. */
p->swr_level = result[0] & 0xF;
p->pwr_level = result[0] >> 4;
p->alc_level = result[1] & 0xF;
p->mod_level = result[1] >> 4;
rig_debug(RIG_DEBUG_TRACE, "%s: swr: %d, pwr %d, alc %d, mod %d\n",
__func__,
p->swr_level,
p->pwr_level,
p->alc_level,
p->mod_level);
/* FT-817 returns 2 bytes with 4 nibbles.
* Extract raw values here;
* convert to float when they are requested. */
p->swr_level = result[0] & 0xF;
p->pwr_level = result[0] >> 4;
p->alc_level = result[1] & 0xF;
p->mod_level = result[1] >> 4;
rig_debug(RIG_DEBUG_TRACE, "%s: swr: %d, pwr %d, alc %d, mod %d\n",
__func__,
p->swr_level,
p->pwr_level,
p->alc_level,
p->mod_level);
break;
}
@ -837,7 +838,7 @@ static int ft817_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
f1 = f2;
f2 = from_bcd_be(p->fm_status, 8);
dump_hex(p->fm_status, sizeof(p->fm_status)/sizeof(p->fm_status[0]));
dump_hex(p->fm_status, sizeof(p->fm_status) / sizeof(p->fm_status[0]));
}
#if 1 // user must be twiddling the VFO
@ -945,7 +946,8 @@ static int ft817_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
return RIG_OK;
}
static int ft817_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo)
static int ft817_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo)
{
struct ft817_priv_data *p = (struct ft817_priv_data *) rig->state.priv;
ptt_t ptt;
@ -954,6 +956,7 @@ static int ft817_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vf
rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
n = ft817_get_ptt(rig, 0, &ptt);
if (n != RIG_OK)
{
return n;
@ -967,6 +970,7 @@ static int ft817_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vf
/* Get split status from EEPROM */
n = ft817_read_eeprom(rig, 0x7a, &c);
if (n != RIG_OK)
{
return n;
@ -1003,7 +1007,8 @@ static int ft817_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
return RIG_OK;
}
static int ft817_get_tx_level(RIG *rig, value_t *val, unsigned char *tx_level, const cal_table_float_t *cal)
static int ft817_get_tx_level(RIG *rig, value_t *val, unsigned char *tx_level,
const cal_table_float_t *cal)
{
struct ft817_priv_data *p = (struct ft817_priv_data *) rig->state.priv;
@ -1023,6 +1028,7 @@ static int ft817_get_tx_level(RIG *rig, value_t *val, unsigned char *tx_level, c
* perhaps pointless retries + timeouts.
*/
n = ft817_get_ptt(rig, 0, &ptt);
if (n != RIG_OK)
{
return n;
@ -1035,6 +1041,7 @@ static int ft817_get_tx_level(RIG *rig, value_t *val, unsigned char *tx_level, c
}
n = ft817_get_status(rig, FT817_NATIVE_CAT_GET_TX_METERING);
if (n != RIG_OK)
{
return n;
@ -1114,6 +1121,7 @@ static int ft817_get_raw_smeter_level(RIG *rig, value_t *val)
static int ft817_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
struct ft817_priv_data *p = (struct ft817_priv_data *) rig->state.priv;
switch (level)
{
@ -1125,7 +1133,8 @@ static int ft817_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return ft817_get_raw_smeter_level(rig, val);
case RIG_LEVEL_RFPOWER:
return ft817_get_tx_level(rig, val, &p->pwr_level, &rig->caps->rfpower_meter_cal);
return ft817_get_tx_level(rig, val, &p->pwr_level,
&rig->caps->rfpower_meter_cal);
case RIG_LEVEL_ALC:
return ft817_get_tx_level(rig, val, &p->alc_level, &rig->caps->alc_cal);
@ -1179,6 +1188,7 @@ static int ft818_817_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option,
/* Read eeprom for current 'band' for both VFO's */
ret = ft817_read_eeprom(rig, 0x59, &eeprom_band);
if (ret != RIG_OK)
{
return ret;
@ -1188,6 +1198,7 @@ static int ft818_817_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option,
* The FT818/817 stores antenna per band not per VFO!
* So changing antenna will change for both VFO's */
ret = ft817_read_eeprom(rig, 0x7A, &eeprom_ant);
if (ret != RIG_OK)
{
return ret;
@ -1200,18 +1211,20 @@ static int ft818_817_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option,
}
/* band info is 4 bit per VFO, for A lower nibble, B is upper nible */
switch (vfo) {
case RIG_VFO_A:
eeprom_band &= 0xF;
break;
case RIG_VFO_B:
eeprom_band = eeprom_band >> 4;
switch (vfo)
{
case RIG_VFO_A:
eeprom_band &= 0xF;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %0x!\n",
__func__, vfo);
return -RIG_EINTERNAL;
case RIG_VFO_B:
eeprom_band = eeprom_band >> 4;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %0x!\n",
__func__, vfo);
return -RIG_EINTERNAL;
}
/* The 818 and the 817 differ in bands: the 818 has 60m.
@ -1233,43 +1246,44 @@ static int ft818_817_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option,
*/
switch (eeprom_band) {
case 0: /* 160M */
case 1: /* 80M */
case 2: /* 60M, 818 only */
case 3: /* 40M */
case 4: /* 30M */
case 5: /* 20M */
case 6: /* 17M */
case 7: /* 15M */
case 8: /* 12M */
case 9: /* 10M */
/* All HF use the same antenna setting, bit 0 */
eeprom_ant &= 1<<0;
switch (eeprom_band)
{
case 0: /* 160M */
case 1: /* 80M */
case 2: /* 60M, 818 only */
case 3: /* 40M */
case 4: /* 30M */
case 5: /* 20M */
case 6: /* 17M */
case 7: /* 15M */
case 8: /* 12M */
case 9: /* 10M */
/* All HF use the same antenna setting, bit 0 */
eeprom_ant &= 1 << 0;
break;
case 0xA: /* 6m, bit 1 */
eeprom_ant &= 1<<1;
case 0xA: /* 6m, bit 1 */
eeprom_ant &= 1 << 1;
break;
case 0xB: /* FM BCB 76Mhz - 108Mhz, bit 2 */
eeprom_ant &= 1<<2;
case 0xB: /* FM BCB 76Mhz - 108Mhz, bit 2 */
eeprom_ant &= 1 << 2;
break;
case 0xC: /* Airband, bit 3 */
eeprom_ant &= 1<<3;
case 0xC: /* Airband, bit 3 */
eeprom_ant &= 1 << 3;
break;
case 0xD: /* 2M, bit 4 */
eeprom_ant &= 1<<4;
case 0xD: /* 2M, bit 4 */
eeprom_ant &= 1 << 4;
break;
case 0xE: /* 70cm / UHF, bit 5 */
eeprom_ant &= 1<<5;
case 0xE: /* 70cm / UHF, bit 5 */
eeprom_ant &= 1 << 5;
break;
case 0xF: /* Free-tuning?, bit 6 */
eeprom_ant &= 1<<6;
case 0xF: /* Free-tuning?, bit 6 */
eeprom_ant &= 1 << 6;
break;
}
@ -1281,18 +1295,18 @@ static int ft818_817_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option,
}
static int ft817_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option,
ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx)
ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx)
{
return ft818_817_get_ant(rig, vfo, ant, option, ant_curr, ant_tx, ant_rx,
true);
true);
}
static int ft818_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option,
ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx)
ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx)
{
return ft818_817_get_ant(rig, vfo, ant, option, ant_curr, ant_tx, ant_rx,
false);
false);
}
/* ---------------------------------------------------------------------- */
@ -1517,6 +1531,7 @@ static int ft817_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
{
int n;
n = ft817_send_cmd(rig, index);
if (n < 0 && n != -RIG_ERJCTED)
{
rig_debug(RIG_DEBUG_ERR, "%s: send ptt cmd failed\n", __func__);
@ -1526,6 +1541,7 @@ static int ft817_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
/* Read TX status it contains the PTT flag.
* Use TX_STATUS instead of ft817_get_ptt to skip the cache. */
n = ft817_get_status(rig, FT817_NATIVE_CAT_GET_TX_STATUS);
if (n < 0 && n != -RIG_ERJCTED)
{
rig_debug(RIG_DEBUG_ERR, "%s: get ptt cmd failed\n", __func__);
@ -1535,6 +1551,7 @@ static int ft817_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
/* Should be in cache now! But if above command was rejected
* we will still try again here. */
n = ft817_get_ptt(rig, vfo, &ptt_response);
if (n < 0 && n != -RIG_ERJCTED)
{
rig_debug(RIG_DEBUG_ERR, "%s: get ptt cmd failed\n", __func__);
@ -1863,7 +1880,7 @@ static int ft817_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
1 bar = 0.5W
*/
static int ft817_power2mW(RIG *rig, unsigned int *mwpower, float power,
freq_t freq, rmode_t mode)
freq_t freq, rmode_t mode)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
*mwpower = (int)(power * 6000);
@ -1873,7 +1890,7 @@ static int ft817_power2mW(RIG *rig, unsigned int *mwpower, float power,
/* FIXME: currently ignores mode and freq */
static int ft817_mW2power(RIG *rig, float *power, unsigned int mwpower,
freq_t freq, rmode_t mode)
freq_t freq, rmode_t mode)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
*power = mwpower / 6000.0;

51
rigs/yaesu/ft840.c
Wyświetl plik

@ -45,31 +45,32 @@
*
*/
enum ft840_native_cmd_e {
FT840_NATIVE_SPLIT_OFF = 0,
FT840_NATIVE_SPLIT_ON,
FT840_NATIVE_RECALL_MEM,
FT840_NATIVE_VFO_TO_MEM,
FT840_NATIVE_VFO_A,
FT840_NATIVE_VFO_B,
FT840_NATIVE_MEM_TO_VFO,
FT840_NATIVE_CLARIFIER_OPS,
FT840_NATIVE_FREQ_SET,
FT840_NATIVE_MODE_SET,
FT840_NATIVE_PACING,
FT840_NATIVE_PTT_OFF,
FT840_NATIVE_PTT_ON,
FT840_NATIVE_MEM_CHNL,
FT840_NATIVE_OP_DATA,
FT840_NATIVE_VFO_DATA,
FT840_NATIVE_MEM_CHNL_DATA,
FT840_NATIVE_TUNER_OFF,
FT840_NATIVE_TUNER_ON,
FT840_NATIVE_TUNER_START,
FT840_NATIVE_READ_METER,
FT840_NATIVE_READ_FLAGS,
FT840_NATIVE_SIZE /* end marker, value indicates number of */
/* native cmd entries */
enum ft840_native_cmd_e
{
FT840_NATIVE_SPLIT_OFF = 0,
FT840_NATIVE_SPLIT_ON,
FT840_NATIVE_RECALL_MEM,
FT840_NATIVE_VFO_TO_MEM,
FT840_NATIVE_VFO_A,
FT840_NATIVE_VFO_B,
FT840_NATIVE_MEM_TO_VFO,
FT840_NATIVE_CLARIFIER_OPS,
FT840_NATIVE_FREQ_SET,
FT840_NATIVE_MODE_SET,
FT840_NATIVE_PACING,
FT840_NATIVE_PTT_OFF,
FT840_NATIVE_PTT_ON,
FT840_NATIVE_MEM_CHNL,
FT840_NATIVE_OP_DATA,
FT840_NATIVE_VFO_DATA,
FT840_NATIVE_MEM_CHNL_DATA,
FT840_NATIVE_TUNER_OFF,
FT840_NATIVE_TUNER_ON,
FT840_NATIVE_TUNER_START,
FT840_NATIVE_READ_METER,
FT840_NATIVE_READ_FLAGS,
FT840_NATIVE_SIZE /* end marker, value indicates number of */
/* native cmd entries */
};
/*

185
rigs/yaesu/ft847.c
Wyświetl plik

@ -65,96 +65,97 @@
*
*/
enum ft847_native_cmd_e {
enum ft847_native_cmd_e
{
/* Set commands to the rig */
/* Set commands to the rig */
FT_847_NATIVE_CAT_ON = 0,
FT_847_NATIVE_CAT_OFF,
FT_847_NATIVE_CAT_ON = 0,
FT_847_NATIVE_CAT_OFF,
FT_847_NATIVE_CAT_PTT_ON,
FT_847_NATIVE_CAT_PTT_OFF,
FT_847_NATIVE_CAT_PTT_ON,
FT_847_NATIVE_CAT_PTT_OFF,
FT_847_NATIVE_CAT_SAT_MODE_ON,
FT_847_NATIVE_CAT_SAT_MODE_OFF,
FT_847_NATIVE_CAT_SAT_MODE_ON,
FT_847_NATIVE_CAT_SAT_MODE_OFF,
FT_847_NATIVE_CAT_SET_FREQ_MAIN,
FT_847_NATIVE_CAT_SET_FREQ_SAT_RX_VFO,
FT_847_NATIVE_CAT_SET_FREQ_SAT_TX_VFO,
FT_847_NATIVE_CAT_SET_FREQ_MAIN,
FT_847_NATIVE_CAT_SET_FREQ_SAT_RX_VFO,
FT_847_NATIVE_CAT_SET_FREQ_SAT_TX_VFO,
FT_847_NATIVE_CAT_SET_MODE_MAIN_LSB, /* MAIN VFO */
FT_847_NATIVE_CAT_SET_MODE_MAIN_USB,
FT_847_NATIVE_CAT_SET_MODE_MAIN_CW,
FT_847_NATIVE_CAT_SET_MODE_MAIN_CWR,
FT_847_NATIVE_CAT_SET_MODE_MAIN_AM,
FT_847_NATIVE_CAT_SET_MODE_MAIN_FM,
FT_847_NATIVE_CAT_SET_MODE_MAIN_CWN,
FT_847_NATIVE_CAT_SET_MODE_MAIN_CWRN,
FT_847_NATIVE_CAT_SET_MODE_MAIN_AMN,
FT_847_NATIVE_CAT_SET_MODE_MAIN_FMN,
FT_847_NATIVE_CAT_SET_MODE_MAIN_LSB, /* MAIN VFO */
FT_847_NATIVE_CAT_SET_MODE_MAIN_USB,
FT_847_NATIVE_CAT_SET_MODE_MAIN_CW,
FT_847_NATIVE_CAT_SET_MODE_MAIN_CWR,
FT_847_NATIVE_CAT_SET_MODE_MAIN_AM,
FT_847_NATIVE_CAT_SET_MODE_MAIN_FM,
FT_847_NATIVE_CAT_SET_MODE_MAIN_CWN,
FT_847_NATIVE_CAT_SET_MODE_MAIN_CWRN,
FT_847_NATIVE_CAT_SET_MODE_MAIN_AMN,
FT_847_NATIVE_CAT_SET_MODE_MAIN_FMN,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_LSB, /* SAT RX VFO */
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_USB,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_CW,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_CWR,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_AM,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_FM,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_CWN,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_CWRN,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_AMN,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_FMN,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_LSB, /* SAT RX VFO */
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_USB,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_CW,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_CWR,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_AM,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_FM,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_CWN,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_CWRN,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_AMN,
FT_847_NATIVE_CAT_SET_MODE_SAT_RX_FMN,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_LSB, /* SAT TX VFO */
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_USB,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_CW,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_CWR,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_AM,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_FM,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_CWN,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_CWRN,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_AMN,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_FMN,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_LSB, /* SAT TX VFO */
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_USB,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_CW,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_CWR,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_AM,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_FM,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_CWN,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_CWRN,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_AMN,
FT_847_NATIVE_CAT_SET_MODE_SAT_TX_FMN,
FT_847_NATIVE_CAT_SET_DCS_ON_MAIN, /* MAIN CTCSS/DCS */
FT_847_NATIVE_CAT_SET_CTCSS_ENC_DEC_ON_MAIN,
FT_847_NATIVE_CAT_SET_CTCSS_ENC_ON_MAIN,
FT_847_NATIVE_CAT_SET_CTCSS_DCS_OFF_MAIN,
FT_847_NATIVE_CAT_SET_DCS_ON_MAIN, /* MAIN CTCSS/DCS */
FT_847_NATIVE_CAT_SET_CTCSS_ENC_DEC_ON_MAIN,
FT_847_NATIVE_CAT_SET_CTCSS_ENC_ON_MAIN,
FT_847_NATIVE_CAT_SET_CTCSS_DCS_OFF_MAIN,
FT_847_NATIVE_CAT_SET_DCS_ON_SAT_RX, /* SAT RX CTCSS/DCS */
FT_847_NATIVE_CAT_SET_CTCSS_ENC_DEC_ON_SAT_RX,
FT_847_NATIVE_CAT_SET_CTCSS_ENC_ON_SAT_RX,
FT_847_NATIVE_CAT_SET_CTCSS_DCS_OFF_SAT_RX,
FT_847_NATIVE_CAT_SET_DCS_ON_SAT_RX, /* SAT RX CTCSS/DCS */
FT_847_NATIVE_CAT_SET_CTCSS_ENC_DEC_ON_SAT_RX,
FT_847_NATIVE_CAT_SET_CTCSS_ENC_ON_SAT_RX,
FT_847_NATIVE_CAT_SET_CTCSS_DCS_OFF_SAT_RX,
FT_847_NATIVE_CAT_SET_DCS_ON_SAT_TX, /* SAT TX CTCSS/DCS */
FT_847_NATIVE_CAT_SET_CTCSS_ENC_DEC_ON_SAT_TX,
FT_847_NATIVE_CAT_SET_CTCSS_ENC_ON_SAT_TX,
FT_847_NATIVE_CAT_SET_CTCSS_DCS_OFF_SAT_TX,
FT_847_NATIVE_CAT_SET_DCS_ON_SAT_TX, /* SAT TX CTCSS/DCS */
FT_847_NATIVE_CAT_SET_CTCSS_ENC_DEC_ON_SAT_TX,
FT_847_NATIVE_CAT_SET_CTCSS_ENC_ON_SAT_TX,
FT_847_NATIVE_CAT_SET_CTCSS_DCS_OFF_SAT_TX,
FT_847_NATIVE_CAT_SET_CTCSS_FREQ_MAIN, /* CTCSS Freq */
FT_847_NATIVE_CAT_SET_CTCSS_FREQ_SAT_RX,
FT_847_NATIVE_CAT_SET_CTCSS_FREQ_SAT_TX,
FT_847_NATIVE_CAT_SET_CTCSS_FREQ_MAIN, /* CTCSS Freq */
FT_847_NATIVE_CAT_SET_CTCSS_FREQ_SAT_RX,
FT_847_NATIVE_CAT_SET_CTCSS_FREQ_SAT_TX,
FT_847_NATIVE_CAT_SET_DCS_CODE_MAIN, /* DCS code */
FT_847_NATIVE_CAT_SET_DCS_CODE_SAT_RX,
FT_847_NATIVE_CAT_SET_DCS_CODE_SAT_TX,
FT_847_NATIVE_CAT_SET_DCS_CODE_MAIN, /* DCS code */
FT_847_NATIVE_CAT_SET_DCS_CODE_SAT_RX,
FT_847_NATIVE_CAT_SET_DCS_CODE_SAT_TX,
FT_847_NATIVE_CAT_SET_RPT_SHIFT_MINUS, /* RPT SHIFT */
FT_847_NATIVE_CAT_SET_RPT_SHIFT_PLUS,
FT_847_NATIVE_CAT_SET_RPT_SHIFT_SIMPLEX,
FT_847_NATIVE_CAT_SET_RPT_SHIFT_MINUS, /* RPT SHIFT */
FT_847_NATIVE_CAT_SET_RPT_SHIFT_PLUS,
FT_847_NATIVE_CAT_SET_RPT_SHIFT_SIMPLEX,
FT_847_NATIVE_CAT_SET_RPT_OFFSET, /* RPT Offset frequency */
FT_847_NATIVE_CAT_SET_RPT_OFFSET, /* RPT Offset frequency */
/* Get info from the rig */
/* Get info from the rig */
FT_847_NATIVE_CAT_GET_RX_STATUS,
FT_847_NATIVE_CAT_GET_TX_STATUS,
FT_847_NATIVE_CAT_GET_RX_STATUS,
FT_847_NATIVE_CAT_GET_TX_STATUS,
FT_847_NATIVE_CAT_GET_FREQ_MODE_STATUS_MAIN,
FT_847_NATIVE_CAT_GET_FREQ_MODE_STATUS_SAT_RX,
FT_847_NATIVE_CAT_GET_FREQ_MODE_STATUS_SAT_TX,
FT_847_NATIVE_CAT_GET_FREQ_MODE_STATUS_MAIN,
FT_847_NATIVE_CAT_GET_FREQ_MODE_STATUS_SAT_RX,
FT_847_NATIVE_CAT_GET_FREQ_MODE_STATUS_SAT_TX,
FT_847_NATIVE_SIZE /* end marker, value indicates number of */
/* native cmd entries */
FT_847_NATIVE_SIZE /* end marker, value indicates number of */
/* native cmd entries */
};
@ -175,30 +176,36 @@ static int ft847_close(RIG *rig);
static int ft847_set_freq(RIG *rig, vfo_t vfo, freq_t freq);
static int ft847_get_freq(RIG *rig, vfo_t vfo, freq_t *freq);
static int ft847_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width); /* select mode */
static int ft847_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width); /* get mode */
static int ft847_set_mode(RIG *rig, vfo_t vfo, rmode_t mode,
pbwidth_t width); /* select mode */
static int ft847_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode,
pbwidth_t *width); /* get mode */
static int ft847_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
static int ft847_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo);
static int ft847_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
vfo_t tx_vfo);
static int ft847_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo);
static int ft847_set_split_freq(RIG *rig, vfo_t vfo, freq_t freq);
static int ft847_get_split_freq(RIG *rig, vfo_t vfo, freq_t *freq);
static int ft847_set_split_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width);
static int ft847_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width);
static int ft847_set_split_mode(RIG *rig, vfo_t vfo, rmode_t mode,
pbwidth_t width);
static int ft847_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *mode,
pbwidth_t *width);
static int ft847_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt);
static int ft847_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt);
static int ft847_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd);
static int ft847_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t * val);
static int ft847_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val);
static int ft847_set_func(RIG *rig, vfo_t vfo, setting_t func, int status);
static int ft847_set_ctcss_tone (RIG *rig, vfo_t vfo, tone_t tone);
static int ft847_set_ctcss_sql (RIG *rig, vfo_t vfo, tone_t tone);
static int ft847_set_dcs_sql (RIG *rig, vfo_t vfo, tone_t code);
static int ft847_set_rptr_shift (RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift);
static int ft847_set_rptr_offs (RIG *rig, vfo_t vfo, shortfreq_t rptr_offs);
static int ft847_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone);
static int ft847_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone);
static int ft847_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code);
static int ft847_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift);
static int ft847_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs);
/*
* ft847 instance - private data
@ -942,7 +949,8 @@ static int ft847_send_priv_cmd(RIG *rig, int cmd_index)
return -RIG_EINVAL;
}
return write_block(&rig->state.rigport, (char *) ncmd[cmd_index].nseq, YAESU_CMD_LENGTH);
return write_block(&rig->state.rigport, (char *) ncmd[cmd_index].nseq,
YAESU_CMD_LENGTH);
}
@ -1335,7 +1343,8 @@ static int ft847_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
return ret;
}
static int ft847_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo)
static int ft847_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo)
{
struct ft847_priv_data *priv = (struct ft847_priv_data *)rig->state.priv;
@ -1361,12 +1370,14 @@ static int ft847_get_split_freq(RIG *rig, vfo_t vfo, freq_t *freq)
return ft847_get_freq(rig, RIG_VFO_TX, freq);
}
static int ft847_set_split_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
static int ft847_set_split_mode(RIG *rig, vfo_t vfo, rmode_t mode,
pbwidth_t width)
{
return ft847_set_mode(rig, RIG_VFO_TX, mode, width);
}
static int ft847_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
static int ft847_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *mode,
pbwidth_t *width)
{
return ft847_get_mode(rig, RIG_VFO_TX, mode, width);
}

97
rigs/yaesu/ft857.c
Wyświetl plik

@ -75,48 +75,49 @@
#include "tones.h"
#include "bandplan.h"
enum ft857_native_cmd_e {
FT857_NATIVE_CAT_LOCK_ON = 0,
FT857_NATIVE_CAT_LOCK_OFF,
FT857_NATIVE_CAT_PTT_ON,
FT857_NATIVE_CAT_PTT_OFF,
FT857_NATIVE_CAT_SET_FREQ,
FT857_NATIVE_CAT_SET_MODE_LSB,
FT857_NATIVE_CAT_SET_MODE_USB,
FT857_NATIVE_CAT_SET_MODE_CW,
FT857_NATIVE_CAT_SET_MODE_CWR,
FT857_NATIVE_CAT_SET_MODE_AM,
FT857_NATIVE_CAT_SET_MODE_FM,
FT857_NATIVE_CAT_SET_MODE_FM_N,
FT857_NATIVE_CAT_SET_MODE_DIG,
FT857_NATIVE_CAT_SET_MODE_PKT,
FT857_NATIVE_CAT_CLAR_ON,
FT857_NATIVE_CAT_CLAR_OFF,
FT857_NATIVE_CAT_SET_CLAR_FREQ,
FT857_NATIVE_CAT_SET_VFOAB,
FT857_NATIVE_CAT_SPLIT_ON,
FT857_NATIVE_CAT_SPLIT_OFF,
FT857_NATIVE_CAT_SET_RPT_SHIFT_MINUS,
FT857_NATIVE_CAT_SET_RPT_SHIFT_PLUS,
FT857_NATIVE_CAT_SET_RPT_SHIFT_SIMPLEX,
FT857_NATIVE_CAT_SET_RPT_OFFSET,
FT857_NATIVE_CAT_SET_DCS_ON,
FT857_NATIVE_CAT_SET_DCS_DEC_ON,
FT857_NATIVE_CAT_SET_DCS_ENC_ON,
FT857_NATIVE_CAT_SET_CTCSS_ON,
FT857_NATIVE_CAT_SET_CTCSS_DEC_ON,
FT857_NATIVE_CAT_SET_CTCSS_ENC_ON,
FT857_NATIVE_CAT_SET_CTCSS_DCS_OFF,
FT857_NATIVE_CAT_SET_CTCSS_FREQ,
FT857_NATIVE_CAT_SET_DCS_CODE,
FT857_NATIVE_CAT_GET_RX_STATUS,
FT857_NATIVE_CAT_GET_TX_STATUS,
FT857_NATIVE_CAT_GET_FREQ_MODE_STATUS,
FT857_NATIVE_CAT_PWR_WAKE,
FT857_NATIVE_CAT_PWR_ON,
FT857_NATIVE_CAT_PWR_OFF,
FT857_NATIVE_CAT_EEPROM_READ,
FT857_NATIVE_SIZE /* end marker */
enum ft857_native_cmd_e
{
FT857_NATIVE_CAT_LOCK_ON = 0,
FT857_NATIVE_CAT_LOCK_OFF,
FT857_NATIVE_CAT_PTT_ON,
FT857_NATIVE_CAT_PTT_OFF,
FT857_NATIVE_CAT_SET_FREQ,
FT857_NATIVE_CAT_SET_MODE_LSB,
FT857_NATIVE_CAT_SET_MODE_USB,
FT857_NATIVE_CAT_SET_MODE_CW,
FT857_NATIVE_CAT_SET_MODE_CWR,
FT857_NATIVE_CAT_SET_MODE_AM,
FT857_NATIVE_CAT_SET_MODE_FM,
FT857_NATIVE_CAT_SET_MODE_FM_N,
FT857_NATIVE_CAT_SET_MODE_DIG,
FT857_NATIVE_CAT_SET_MODE_PKT,
FT857_NATIVE_CAT_CLAR_ON,
FT857_NATIVE_CAT_CLAR_OFF,
FT857_NATIVE_CAT_SET_CLAR_FREQ,
FT857_NATIVE_CAT_SET_VFOAB,
FT857_NATIVE_CAT_SPLIT_ON,
FT857_NATIVE_CAT_SPLIT_OFF,
FT857_NATIVE_CAT_SET_RPT_SHIFT_MINUS,
FT857_NATIVE_CAT_SET_RPT_SHIFT_PLUS,
FT857_NATIVE_CAT_SET_RPT_SHIFT_SIMPLEX,
FT857_NATIVE_CAT_SET_RPT_OFFSET,
FT857_NATIVE_CAT_SET_DCS_ON,
FT857_NATIVE_CAT_SET_DCS_DEC_ON,
FT857_NATIVE_CAT_SET_DCS_ENC_ON,
FT857_NATIVE_CAT_SET_CTCSS_ON,
FT857_NATIVE_CAT_SET_CTCSS_DEC_ON,
FT857_NATIVE_CAT_SET_CTCSS_ENC_ON,
FT857_NATIVE_CAT_SET_CTCSS_DCS_OFF,
FT857_NATIVE_CAT_SET_CTCSS_FREQ,
FT857_NATIVE_CAT_SET_DCS_CODE,
FT857_NATIVE_CAT_GET_RX_STATUS,
FT857_NATIVE_CAT_GET_TX_STATUS,
FT857_NATIVE_CAT_GET_FREQ_MODE_STATUS,
FT857_NATIVE_CAT_PWR_WAKE,
FT857_NATIVE_CAT_PWR_ON,
FT857_NATIVE_CAT_PWR_OFF,
FT857_NATIVE_CAT_EEPROM_READ,
FT857_NATIVE_SIZE /* end marker */
};
static int ft857_init(RIG *rig);
@ -127,10 +128,14 @@ 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);
static int ft857_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width);
static int ft857_set_split_freq_mode(RIG *rig, vfo_t vfo, freq_t freq, rmode_t mode, pbwidth_t width);
static int ft857_get_split_freq_mode(RIG *rig, vfo_t vfo, freq_t *freq, rmode_t *mode, pbwidth_t *width);
static int ft857_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
static int ft857_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo);
static int ft857_set_split_freq_mode(RIG *rig, vfo_t vfo, freq_t freq,
rmode_t mode, pbwidth_t width);
static int ft857_get_split_freq_mode(RIG *rig, vfo_t vfo, freq_t *freq,
rmode_t *mode, pbwidth_t *width);
static int ft857_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
vfo_t tx_vfo);
static int ft857_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo);
// static int ft857_set_vfo(RIG *rig, vfo_t vfo);
// static int ft857_get_vfo(RIG *rig, vfo_t *vfo);
static int ft857_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt);

57
rigs/yaesu/ft890.c
Wyświetl plik

@ -75,31 +75,32 @@
*
*/
enum ft890_native_cmd_e {
FT890_NATIVE_SPLIT_OFF = 0,
FT890_NATIVE_SPLIT_ON,
FT890_NATIVE_RECALL_MEM,
FT890_NATIVE_VFO_TO_MEM,
FT890_NATIVE_VFO_A,
FT890_NATIVE_VFO_B,
FT890_NATIVE_MEM_TO_VFO,
FT890_NATIVE_CLARIFIER_OPS,
FT890_NATIVE_FREQ_SET,
FT890_NATIVE_MODE_SET,
FT890_NATIVE_PACING,
FT890_NATIVE_PTT_OFF,
FT890_NATIVE_PTT_ON,
FT890_NATIVE_MEM_CHNL,
FT890_NATIVE_OP_DATA,
FT890_NATIVE_VFO_DATA,
FT890_NATIVE_MEM_CHNL_DATA,
FT890_NATIVE_TUNER_OFF,
FT890_NATIVE_TUNER_ON,
FT890_NATIVE_TUNER_START,
FT890_NATIVE_READ_METER,
FT890_NATIVE_READ_FLAGS,
FT890_NATIVE_SIZE /* end marker, value indicates number of */
/* native cmd entries */
enum ft890_native_cmd_e
{
FT890_NATIVE_SPLIT_OFF = 0,
FT890_NATIVE_SPLIT_ON,
FT890_NATIVE_RECALL_MEM,
FT890_NATIVE_VFO_TO_MEM,
FT890_NATIVE_VFO_A,
FT890_NATIVE_VFO_B,
FT890_NATIVE_MEM_TO_VFO,
FT890_NATIVE_CLARIFIER_OPS,
FT890_NATIVE_FREQ_SET,
FT890_NATIVE_MODE_SET,
FT890_NATIVE_PACING,
FT890_NATIVE_PTT_OFF,
FT890_NATIVE_PTT_ON,
FT890_NATIVE_MEM_CHNL,
FT890_NATIVE_OP_DATA,
FT890_NATIVE_VFO_DATA,
FT890_NATIVE_MEM_CHNL_DATA,
FT890_NATIVE_TUNER_OFF,
FT890_NATIVE_TUNER_ON,
FT890_NATIVE_TUNER_START,
FT890_NATIVE_READ_METER,
FT890_NATIVE_READ_FLAGS,
FT890_NATIVE_SIZE /* end marker, value indicates number of */
/* native cmd entries */
};
typedef enum ft890_native_cmd_e ft890_native_cmd_t;
@ -302,8 +303,10 @@ static int ft890_get_vfo(RIG *rig, vfo_t *vfo);
static int ft890_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt);
static int ft890_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt);
static int ft890_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
static int ft890_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo);
static int ft890_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
vfo_t tx_vfo);
static int ft890_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo);
static int ft890_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit);
static int ft890_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit);

19
rigs/yaesu/ft891.c
Wyświetl plik

@ -44,11 +44,15 @@
/* Prototypes */
static int ft891_init(RIG *rig);
static int ft891_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo);
static int ft891_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode, pbwidth_t *tx_width);
static int ft891_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width);
static int ft891_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo);
static int ft891_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode,
pbwidth_t *tx_width);
static int ft891_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode,
pbwidth_t tx_width);
static int ft891_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width);
static int ft891_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
static int ft891_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
vfo_t tx_vfo);
const struct confparams ft891_ext_levels[] =
{
@ -408,7 +412,8 @@ static int ft891_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
*
* Comments: The passed value for the vfo is ignored since can only split one way
*/
static int ft891_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo)
static int ft891_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo)
{
struct newcat_priv_data *priv;
int err;
@ -467,7 +472,7 @@ static int ft891_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vf
*/
static int ft891_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode,
pbwidth_t *tx_width)
pbwidth_t *tx_width)
{
struct newcat_priv_data *priv;
int err;
@ -514,7 +519,7 @@ static int ft891_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode,
*/
static int ft891_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode,
pbwidth_t tx_width)
pbwidth_t tx_width)
{
struct newcat_priv_data *priv;
struct rig_state *state;

85
rigs/yaesu/ft897.c
Wyświetl plik

@ -81,48 +81,49 @@
#include "tones.h"
#include "bandplan.h"
enum ft897_native_cmd_e {
FT897_NATIVE_CAT_LOCK_ON = 0,
FT897_NATIVE_CAT_LOCK_OFF,
FT897_NATIVE_CAT_PTT_ON,
FT897_NATIVE_CAT_PTT_OFF,
FT897_NATIVE_CAT_SET_FREQ,
FT897_NATIVE_CAT_SET_MODE_LSB,
FT897_NATIVE_CAT_SET_MODE_USB,
FT897_NATIVE_CAT_SET_MODE_CW,
FT897_NATIVE_CAT_SET_MODE_CWR,
FT897_NATIVE_CAT_SET_MODE_AM,
FT897_NATIVE_CAT_SET_MODE_FM,
FT897_NATIVE_CAT_SET_MODE_FM_N,
FT897_NATIVE_CAT_SET_MODE_DIG,
FT897_NATIVE_CAT_SET_MODE_PKT,
FT897_NATIVE_CAT_CLAR_ON,
FT897_NATIVE_CAT_CLAR_OFF,
FT897_NATIVE_CAT_SET_CLAR_FREQ,
FT897_NATIVE_CAT_SET_VFOAB,
FT897_NATIVE_CAT_SPLIT_ON,
FT897_NATIVE_CAT_SPLIT_OFF,
FT897_NATIVE_CAT_SET_RPT_SHIFT_MINUS,
FT897_NATIVE_CAT_SET_RPT_SHIFT_PLUS,
FT897_NATIVE_CAT_SET_RPT_SHIFT_SIMPLEX,
FT897_NATIVE_CAT_SET_RPT_OFFSET,
FT897_NATIVE_CAT_SET_DCS_ON,
FT897_NATIVE_CAT_SET_DCS_DEC_ON,
FT897_NATIVE_CAT_SET_DCS_ENC_ON,
FT897_NATIVE_CAT_SET_CTCSS_ON,
FT897_NATIVE_CAT_SET_CTCSS_DEC_ON,
FT897_NATIVE_CAT_SET_CTCSS_ENC_ON,
FT897_NATIVE_CAT_SET_CTCSS_DCS_OFF,
FT897_NATIVE_CAT_SET_CTCSS_FREQ,
FT897_NATIVE_CAT_SET_DCS_CODE,
FT897_NATIVE_CAT_GET_RX_STATUS,
FT897_NATIVE_CAT_GET_TX_STATUS,
FT897_NATIVE_CAT_GET_FREQ_MODE_STATUS,
FT897_NATIVE_CAT_PWR_WAKE,
FT897_NATIVE_CAT_PWR_ON,
FT897_NATIVE_CAT_PWR_OFF,
FT897_NATIVE_CAT_EEPROM_READ,
FT897_NATIVE_SIZE /* end marker */
enum ft897_native_cmd_e
{
FT897_NATIVE_CAT_LOCK_ON = 0,
FT897_NATIVE_CAT_LOCK_OFF,
FT897_NATIVE_CAT_PTT_ON,
FT897_NATIVE_CAT_PTT_OFF,
FT897_NATIVE_CAT_SET_FREQ,
FT897_NATIVE_CAT_SET_MODE_LSB,
FT897_NATIVE_CAT_SET_MODE_USB,
FT897_NATIVE_CAT_SET_MODE_CW,
FT897_NATIVE_CAT_SET_MODE_CWR,
FT897_NATIVE_CAT_SET_MODE_AM,
FT897_NATIVE_CAT_SET_MODE_FM,
FT897_NATIVE_CAT_SET_MODE_FM_N,
FT897_NATIVE_CAT_SET_MODE_DIG,
FT897_NATIVE_CAT_SET_MODE_PKT,
FT897_NATIVE_CAT_CLAR_ON,
FT897_NATIVE_CAT_CLAR_OFF,
FT897_NATIVE_CAT_SET_CLAR_FREQ,
FT897_NATIVE_CAT_SET_VFOAB,
FT897_NATIVE_CAT_SPLIT_ON,
FT897_NATIVE_CAT_SPLIT_OFF,
FT897_NATIVE_CAT_SET_RPT_SHIFT_MINUS,
FT897_NATIVE_CAT_SET_RPT_SHIFT_PLUS,
FT897_NATIVE_CAT_SET_RPT_SHIFT_SIMPLEX,
FT897_NATIVE_CAT_SET_RPT_OFFSET,
FT897_NATIVE_CAT_SET_DCS_ON,
FT897_NATIVE_CAT_SET_DCS_DEC_ON,
FT897_NATIVE_CAT_SET_DCS_ENC_ON,
FT897_NATIVE_CAT_SET_CTCSS_ON,
FT897_NATIVE_CAT_SET_CTCSS_DEC_ON,
FT897_NATIVE_CAT_SET_CTCSS_ENC_ON,
FT897_NATIVE_CAT_SET_CTCSS_DCS_OFF,
FT897_NATIVE_CAT_SET_CTCSS_FREQ,
FT897_NATIVE_CAT_SET_DCS_CODE,
FT897_NATIVE_CAT_GET_RX_STATUS,
FT897_NATIVE_CAT_GET_TX_STATUS,
FT897_NATIVE_CAT_GET_FREQ_MODE_STATUS,
FT897_NATIVE_CAT_PWR_WAKE,
FT897_NATIVE_CAT_PWR_ON,
FT897_NATIVE_CAT_PWR_OFF,
FT897_NATIVE_CAT_EEPROM_READ,
FT897_NATIVE_SIZE /* end marker */
};
struct ft897_priv_data

57
rigs/yaesu/ft900.c
Wyświetl plik

@ -76,31 +76,32 @@
*
*/
enum ft900_native_cmd_e {
FT900_NATIVE_SPLIT_OFF = 0,
FT900_NATIVE_SPLIT_ON,
FT900_NATIVE_RECALL_MEM,
FT900_NATIVE_VFO_TO_MEM,
FT900_NATIVE_VFO_A,
FT900_NATIVE_VFO_B,
FT900_NATIVE_MEM_TO_VFO,
FT900_NATIVE_CLARIFIER_OPS,
FT900_NATIVE_FREQ_SET,
FT900_NATIVE_MODE_SET,
FT900_NATIVE_PACING,
FT900_NATIVE_PTT_OFF,
FT900_NATIVE_PTT_ON,
FT900_NATIVE_MEM_CHNL,
FT900_NATIVE_OP_DATA,
FT900_NATIVE_VFO_DATA,
FT900_NATIVE_MEM_CHNL_DATA,
FT900_NATIVE_TUNER_OFF,
FT900_NATIVE_TUNER_ON,
FT900_NATIVE_TUNER_START,
FT900_NATIVE_READ_METER,
FT900_NATIVE_READ_FLAGS,
FT900_NATIVE_SIZE /* end marker, value indicates number of */
/* native cmd entries */
enum ft900_native_cmd_e
{
FT900_NATIVE_SPLIT_OFF = 0,
FT900_NATIVE_SPLIT_ON,
FT900_NATIVE_RECALL_MEM,
FT900_NATIVE_VFO_TO_MEM,
FT900_NATIVE_VFO_A,
FT900_NATIVE_VFO_B,
FT900_NATIVE_MEM_TO_VFO,
FT900_NATIVE_CLARIFIER_OPS,
FT900_NATIVE_FREQ_SET,
FT900_NATIVE_MODE_SET,
FT900_NATIVE_PACING,
FT900_NATIVE_PTT_OFF,
FT900_NATIVE_PTT_ON,
FT900_NATIVE_MEM_CHNL,
FT900_NATIVE_OP_DATA,
FT900_NATIVE_VFO_DATA,
FT900_NATIVE_MEM_CHNL_DATA,
FT900_NATIVE_TUNER_OFF,
FT900_NATIVE_TUNER_ON,
FT900_NATIVE_TUNER_START,
FT900_NATIVE_READ_METER,
FT900_NATIVE_READ_FLAGS,
FT900_NATIVE_SIZE /* end marker, value indicates number of */
/* native cmd entries */
};
typedef enum ft900_native_cmd_e ft900_native_cmd_t;
@ -322,8 +323,10 @@ static int ft900_get_vfo(RIG *rig, vfo_t *vfo);
static int ft900_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt);
static int ft900_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt);
static int ft900_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
static int ft900_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo);
static int ft900_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
vfo_t tx_vfo);
static int ft900_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo);
static int ft900_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit);
static int ft900_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit);

17
rigs/yaesu/ft920.c
Wyświetl plik

@ -71,7 +71,8 @@
*
*/
enum ft920_native_cmd_e {
enum ft920_native_cmd_e
{
FT920_NATIVE_SPLIT_OFF = 0,
FT920_NATIVE_SPLIT_ON,
FT920_NATIVE_RECALL_MEM,
@ -99,7 +100,7 @@ enum ft920_native_cmd_e {
FT920_NATIVE_VFO_B_PASSBAND_NAR,
FT920_NATIVE_STATUS_FLAGS,
FT920_NATIVE_SIZE /* end marker, value indicates number of */
/* native cmd entries */
/* native cmd entries */
};
/*
@ -302,14 +303,18 @@ static int ft920_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width);
static int ft920_set_vfo(RIG *rig, vfo_t vfo);
static int ft920_get_vfo(RIG *rig, vfo_t *vfo);
static int ft920_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
static int ft920_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo);
static int ft920_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
vfo_t tx_vfo);
static int ft920_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo);
static int ft920_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq);
static int ft920_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq);
static int ft920_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width);
static int ft920_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode, pbwidth_t *tx_width);
static int ft920_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode,
pbwidth_t tx_width);
static int ft920_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode,
pbwidth_t *tx_width);
static int ft920_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit);
static int ft920_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit);

122
rigs/yaesu/ft990.c
Wyświetl plik

@ -48,61 +48,62 @@
#include "ft990.h"
// FT990 native commands
enum ft990_native_cmd_e {
FT990_NATIVE_SPLIT_OFF = 0,
FT990_NATIVE_SPLIT_ON,
FT990_NATIVE_RECALL_MEM,
FT990_NATIVE_VFO_TO_MEM,
FT990_NATIVE_LOCK_OFF,
FT990_NATIVE_LOCK_ON,
FT990_NATIVE_VFO_A,
FT990_NATIVE_VFO_B,
FT990_NATIVE_MEM_TO_VFO,
FT990_NATIVE_VFO_STEP_UP,
FT990_NATIVE_VFO_STEP_UP_FAST,
FT990_NATIVE_VFO_STEP_DOWN,
FT990_NATIVE_VFO_STEP_DOWN_FAST,
FT990_NATIVE_RX_CLARIFIER_OFF,
FT990_NATIVE_RX_CLARIFIER_ON,
FT990_NATIVE_TX_CLARIFIER_OFF,
FT990_NATIVE_TX_CLARIFIER_ON,
FT990_NATIVE_CLEAR_CLARIFIER_OFFSET,
FT990_NATIVE_CLARIFIER_OPS,
FT990_NATIVE_FREQ_SET,
FT990_NATIVE_MODE_SET_LSB,
FT990_NATIVE_MODE_SET_USB,
FT990_NATIVE_MODE_SET_CW_W,
FT990_NATIVE_MODE_SET_CW_N,
FT990_NATIVE_MODE_SET_AM_W,
FT990_NATIVE_MODE_SET_AM_N,
FT990_NATIVE_MODE_SET_FM,
FT990_NATIVE_MODE_SET_RTTY_LSB,
FT990_NATIVE_MODE_SET_RTTY_USB,
FT990_NATIVE_MODE_SET_PKT_LSB,
FT990_NATIVE_MODE_SET_PKT_FM,
FT990_NATIVE_PACING,
FT990_NATIVE_PTT_OFF,
FT990_NATIVE_PTT_ON,
FT990_NATIVE_UPDATE_ALL_DATA,
FT990_NATIVE_UPDATE_MEM_CHNL,
FT990_NATIVE_UPDATE_OP_DATA,
FT990_NATIVE_UPDATE_VFO_DATA,
FT990_NATIVE_UPDATE_MEM_CHNL_DATA,
FT990_NATIVE_TUNER_OFF,
FT990_NATIVE_TUNER_ON,
FT990_NATIVE_TUNER_START,
FT990_NATIVE_RPTR_SHIFT_NONE,
FT990_NATIVE_RPTR_SHIFT_MINUS,
FT990_NATIVE_RPTR_SHIFT_PLUS,
FT990_NATIVE_VFO_TO_VFO,
FT990_NATIVE_BANDWIDTH,
FT990_NATIVE_OP_FREQ_STEP_UP,
FT990_NATIVE_OP_FREQ_STEP_DOWN,
FT990_NATIVE_READ_METER,
FT990_NATIVE_DIM_LEVEL,
FT990_NATIVE_RPTR_OFFSET,
FT990_NATIVE_READ_FLAGS,
FT990_NATIVE_SIZE
enum ft990_native_cmd_e
{
FT990_NATIVE_SPLIT_OFF = 0,
FT990_NATIVE_SPLIT_ON,
FT990_NATIVE_RECALL_MEM,
FT990_NATIVE_VFO_TO_MEM,
FT990_NATIVE_LOCK_OFF,
FT990_NATIVE_LOCK_ON,
FT990_NATIVE_VFO_A,
FT990_NATIVE_VFO_B,
FT990_NATIVE_MEM_TO_VFO,
FT990_NATIVE_VFO_STEP_UP,
FT990_NATIVE_VFO_STEP_UP_FAST,
FT990_NATIVE_VFO_STEP_DOWN,
FT990_NATIVE_VFO_STEP_DOWN_FAST,
FT990_NATIVE_RX_CLARIFIER_OFF,
FT990_NATIVE_RX_CLARIFIER_ON,
FT990_NATIVE_TX_CLARIFIER_OFF,
FT990_NATIVE_TX_CLARIFIER_ON,
FT990_NATIVE_CLEAR_CLARIFIER_OFFSET,
FT990_NATIVE_CLARIFIER_OPS,
FT990_NATIVE_FREQ_SET,
FT990_NATIVE_MODE_SET_LSB,
FT990_NATIVE_MODE_SET_USB,
FT990_NATIVE_MODE_SET_CW_W,
FT990_NATIVE_MODE_SET_CW_N,
FT990_NATIVE_MODE_SET_AM_W,
FT990_NATIVE_MODE_SET_AM_N,
FT990_NATIVE_MODE_SET_FM,
FT990_NATIVE_MODE_SET_RTTY_LSB,
FT990_NATIVE_MODE_SET_RTTY_USB,
FT990_NATIVE_MODE_SET_PKT_LSB,
FT990_NATIVE_MODE_SET_PKT_FM,
FT990_NATIVE_PACING,
FT990_NATIVE_PTT_OFF,
FT990_NATIVE_PTT_ON,
FT990_NATIVE_UPDATE_ALL_DATA,
FT990_NATIVE_UPDATE_MEM_CHNL,
FT990_NATIVE_UPDATE_OP_DATA,
FT990_NATIVE_UPDATE_VFO_DATA,
FT990_NATIVE_UPDATE_MEM_CHNL_DATA,
FT990_NATIVE_TUNER_OFF,
FT990_NATIVE_TUNER_ON,
FT990_NATIVE_TUNER_START,
FT990_NATIVE_RPTR_SHIFT_NONE,
FT990_NATIVE_RPTR_SHIFT_MINUS,
FT990_NATIVE_RPTR_SHIFT_PLUS,
FT990_NATIVE_VFO_TO_VFO,
FT990_NATIVE_BANDWIDTH,
FT990_NATIVE_OP_FREQ_STEP_UP,
FT990_NATIVE_OP_FREQ_STEP_DOWN,
FT990_NATIVE_READ_METER,
FT990_NATIVE_DIM_LEVEL,
FT990_NATIVE_RPTR_OFFSET,
FT990_NATIVE_READ_FLAGS,
FT990_NATIVE_SIZE
};
@ -122,8 +123,10 @@ static int ft990_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt);
static int ft990_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift);
static int ft990_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift);
static int ft990_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t offs);
static int ft990_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
static int ft990_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo);
static int ft990_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
vfo_t tx_vfo);
static int ft990_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
vfo_t *tx_vfo);
static int ft990_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit);
static int ft990_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit);
static int ft990_set_func(RIG *rig, vfo_t vfo, setting_t func, int status);
@ -135,8 +138,9 @@ static int ft990_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val);
static int ft990_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op);
static int ft990_set_mem(RIG *rig, vfo_t vfo, int ch);
static int ft990_get_mem(RIG *rig, vfo_t vfo, int *ch);
static int ft990_set_channel (RIG *rig, vfo_t vfo, const channel_t *chan);
static int ft990_get_channel (RIG *rig, vfo_t vfo, channel_t *chan, int read_only);
static int ft990_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan);
static int ft990_get_channel(RIG *rig, vfo_t vfo, channel_t *chan,
int read_only);

4
rigs/yaesu/ft991.c
Wyświetl plik

@ -452,7 +452,7 @@ ft991_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq)
*/
static int ft991_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode,
pbwidth_t *tx_width)
pbwidth_t *tx_width)
{
struct newcat_priv_data *priv;
int err;
@ -538,7 +538,7 @@ static void debug_ft991info_data(const ft991info *rdata)
*/
static int ft991_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode,
pbwidth_t tx_width)
pbwidth_t tx_width)
{
struct newcat_priv_data *priv;
struct rig_state *state;

418
rigs/yaesu/newcat.c
Wyświetl plik

@ -932,6 +932,7 @@ int newcat_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
&& rig->caps->set_vfo != NULL) // gotta' have get_vfo too
{
TRACE;
if (rig->state.current_vfo != vfo)
{
int vfo1 = 1, vfo2 = 0;
@ -1245,9 +1246,13 @@ int newcat_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
if (vfo == RIG_VFO_B || vfo == RIG_VFO_SUB)
{
rig_get_mode(rig, vfo, &tmode, &twidth);
if (mode == tmode && (twidth == width || twidth == RIG_PASSBAND_NOCHANGE))
{
RETURNFUNC(RIG_OK);
}
}
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "MD0x%c", cat_term);
priv->cmd_str[3] = newcat_modechar(mode);
@ -2312,7 +2317,8 @@ int newcat_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
vfo_t rx_vfo = RIG_VFO_NONE;
//ENTERFUNC;
rig_debug(RIG_DEBUG_TRACE, "%s: entered, rxvfo=%s, txvfo=%s, split=%d\n", __func__, rig_strvfo(vfo), rig_strvfo(tx_vfo), split);
rig_debug(RIG_DEBUG_TRACE, "%s: entered, rxvfo=%s, txvfo=%s, split=%d\n",
__func__, rig_strvfo(vfo), rig_strvfo(tx_vfo), split);
err = newcat_set_vfo_from_alias(rig, &vfo);
@ -3697,6 +3703,7 @@ int newcat_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
RETURNFUNC(-RIG_ENAVAIL);
}
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "KS%03d%c", val.i, cat_term);
break;
@ -4618,6 +4625,7 @@ int newcat_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx9000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "RM06%c", cat_term);
@ -4626,6 +4634,7 @@ int newcat_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "RM3%c", cat_term);
}
break;
case RIG_LEVEL_VD_METER:
@ -4633,6 +4642,7 @@ int newcat_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx9000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "RM11%c", cat_term);
@ -4641,6 +4651,7 @@ int newcat_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "RM8%c", cat_term);
}
break;
case RIG_LEVEL_ID_METER:
@ -4648,6 +4659,7 @@ int newcat_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx9000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "RM10%c", cat_term);
@ -4656,6 +4668,7 @@ int newcat_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "RM7%c", cat_term);
}
break;
case RIG_LEVEL_ANTIVOX:
@ -5067,14 +5080,17 @@ int newcat_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
case RIG_LEVEL_RAWSTR:
case RIG_LEVEL_KEYSPD:
if (rig->caps->rig_model == RIG_MODEL_TS570D || rig->caps->rig_model == RIG_MODEL_TS570S)
{ // TS570 uses 010-~060 scale according to manual
val->i = atoi(retlvl)/2 + 10;
if (rig->caps->rig_model == RIG_MODEL_TS570D
|| rig->caps->rig_model == RIG_MODEL_TS570S)
{
// TS570 uses 010-~060 scale according to manual
val->i = atoi(retlvl) / 2 + 10;
}
else
{
val->i = atoi(retlvl);
}
break;
case RIG_LEVEL_IF:
@ -5594,15 +5610,28 @@ int newcat_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
}
if (is_ftdx101d || is_ftdx101mp) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c2%04d%c", main_sub_vfo, status ? 1 : 0, cat_term);
} else if (is_ftdx10 || is_ft991 || is_ft891) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO02%04d%c", status ? 1 : 0, cat_term);
} else if (is_ftdx5000) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c0%02d%c", main_sub_vfo, status ? 2 : 0, cat_term);
} else if (is_ftdx3000 || is_ftdx1200 || is_ft2000) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO00%02d%c", status ? 2 : 0, cat_term);
} else {
if (is_ftdx101d || is_ftdx101mp)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c2%04d%c", main_sub_vfo,
status ? 1 : 0, cat_term);
}
else if (is_ftdx10 || is_ft991 || is_ft891)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO02%04d%c", status ? 1 : 0,
cat_term);
}
else if (is_ftdx5000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c0%02d%c", main_sub_vfo,
status ? 2 : 0, cat_term);
}
else if (is_ftdx3000 || is_ftdx1200 || is_ft2000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO00%02d%c", status ? 2 : 0,
cat_term);
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -5835,19 +5864,31 @@ int newcat_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx101d || is_ftdx101mp) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c2%c", main_sub_vfo, cat_term);
} else if (is_ftdx10 || is_ft991 || is_ft891) {
if (is_ftdx101d || is_ftdx101mp)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c2%c", main_sub_vfo,
cat_term);
}
else if (is_ftdx10 || is_ft991 || is_ft891)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO02%c", cat_term);
} else if (is_ftdx5000) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c0%c", main_sub_vfo, cat_term);
} else if (is_ftdx3000 || is_ftdx1200 || is_ft2000) {
}
else if (is_ftdx5000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c0%c", main_sub_vfo,
cat_term);
}
else if (is_ftdx3000 || is_ftdx1200 || is_ft2000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO00%c", cat_term);
} else {
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
break;
default:
RETURNFUNC(-RIG_EINVAL);
}
@ -5930,15 +5971,24 @@ int newcat_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
break;
case RIG_FUNC_APF:
if (is_ftdx101d || is_ftdx101mp) {
if (is_ftdx101d || is_ftdx101mp)
{
*status = (retfunc[last_char_index] == '1') ? 1 : 0;
} else if (is_ftdx10 || is_ft991 || is_ft891) {
}
else if (is_ftdx10 || is_ft991 || is_ft891)
{
*status = (retfunc[last_char_index] == '1') ? 1 : 0;
} else if (is_ftdx5000) {
}
else if (is_ftdx5000)
{
*status = (retfunc[last_char_index] == '2') ? 1 : 0;
} else if (is_ftdx3000 || is_ftdx1200 || is_ft2000) {
}
else if (is_ftdx3000 || is_ftdx1200 || is_ft2000)
{
*status = (retfunc[last_char_index] == '2') ? 1 : 0;
} else {
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -5986,7 +6036,7 @@ int newcat_set_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t val)
}
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "KR%d%c", val.i ? 1 : 0,
cat_term);
cat_term);
RETURNFUNC(newcat_set_cmd(rig));
@ -6176,6 +6226,7 @@ int newcat_send_morse(RIG *rig, vfo_t vfo, const char *msg)
int rc;
char *s = strdup(msg);
ENTERFUNC;
if (newcat_is_rig(rig, RIG_MODEL_FT450))
{
// 450 manual says 1/2/3 playback needs P1=6/7/8
@ -6185,6 +6236,7 @@ int newcat_send_morse(RIG *rig, vfo_t vfo, const char *msg)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "KY%c%c", s[0], cat_term);
}
rc = newcat_set_cmd(rig);
free(s);
RETURNFUNC(rc);
@ -10394,10 +10446,12 @@ int newcat_send_voice_mem(RIG *rig, vfo_t vfo, int ch)
{
char *p1 = "0"; // newer rigs have 2 bytes where is fixed at zero e.g. FT991
struct newcat_priv_data *priv = (struct newcat_priv_data *)rig->state.priv;
if (!newcat_valid_command(rig, "PB"))
{
RETURNFUNC(-RIG_ENAVAIL);
}
// we don't do any channel checking -- varies by rig -- could do it but not critical
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "PB%s%d%c", p1, ch, cat_term);
@ -10415,13 +10469,23 @@ static int newcat_set_apf_frequency(RIG *rig, vfo_t vfo, int freq)
}
// Range seems to be -250..250 Hz in 10 Hz steps
if (is_ftdx101d || is_ftdx101mp) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c3%04d%c", main_sub_vfo, (freq + 250) / 10, cat_term);
} else if (is_ftdx10 || is_ft991 || is_ft891) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO03%04d%c", (freq + 250) / 10, cat_term);
} else if (is_ftdx3000 || is_ftdx1200) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO02%02d%c", (freq + 250) / 10, cat_term);
} else {
if (is_ftdx101d || is_ftdx101mp)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c3%04d%c", main_sub_vfo,
(freq + 250) / 10, cat_term);
}
else if (is_ftdx10 || is_ft991 || is_ft891)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO03%04d%c", (freq + 250) / 10,
cat_term);
}
else if (is_ftdx3000 || is_ftdx1200)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO02%02d%c", (freq + 250) / 10,
cat_term);
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -10441,13 +10505,21 @@ static int newcat_get_apf_frequency(RIG *rig, vfo_t vfo, int *freq)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx101d || is_ftdx101mp) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c3%c", main_sub_vfo, cat_term);
} else if (is_ftdx10 || is_ft991 || is_ft891) {
if (is_ftdx101d || is_ftdx101mp)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c3%c", main_sub_vfo,
cat_term);
}
else if (is_ftdx10 || is_ft991 || is_ft891)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO03%c", cat_term);
} else if (is_ftdx3000 || is_ftdx1200) {
}
else if (is_ftdx3000 || is_ftdx1200)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO02%c", cat_term);
} else {
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -10481,17 +10553,29 @@ static int newcat_set_apf_width(RIG *rig, vfo_t vfo, int choice)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx101d || is_ftdx101mp || is_ftdx10) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX030201%d%c", choice, cat_term);
} else if (is_ft991) {
if (is_ftdx101d || is_ftdx101mp || is_ftdx10)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX030201%d%c", choice,
cat_term);
}
else if (is_ft991)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX111%d%c", choice, cat_term);
} else if (is_ft891) {
}
else if (is_ft891)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX1201%d%c", choice, cat_term);
} else if (is_ftdx5000) {
}
else if (is_ftdx5000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX112%d%c", choice, cat_term);
} else if (is_ftdx3000 || is_ftdx1200) {
}
else if (is_ftdx3000 || is_ftdx1200)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX107%d%c", choice, cat_term);
} else {
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -10510,17 +10594,28 @@ static int newcat_get_apf_width(RIG *rig, vfo_t vfo, int *choice)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx101d || is_ftdx101mp || is_ftdx10) {
if (is_ftdx101d || is_ftdx101mp || is_ftdx10)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX030201%c", cat_term);
} else if (is_ft991) {
}
else if (is_ft991)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX111%c", cat_term);
} else if (is_ft891) {
}
else if (is_ft891)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX1201%c", cat_term);
} else if (is_ftdx5000) {
}
else if (is_ftdx5000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX112%c", cat_term);
} else if (is_ftdx3000 || is_ftdx1200) {
}
else if (is_ftdx3000 || is_ftdx1200)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX107%c", cat_term);
} else {
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -10552,15 +10647,28 @@ static int newcat_set_contour(RIG *rig, vfo_t vfo, int status)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx101d || is_ftdx101mp) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c0%04d%c", main_sub_vfo, status ? 1 : 0, cat_term);
} else if (is_ftdx10 || is_ft991 || is_ft891) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO00%04d%c", status ? 1 : 0, cat_term);
} else if (is_ftdx5000) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c0%02d%c", main_sub_vfo, status ? 1 : 0, cat_term);
} else if (is_ftdx3000 || is_ftdx1200 || is_ft2000) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO00%02d%c", status ? 1 : 0, cat_term);
} else {
if (is_ftdx101d || is_ftdx101mp)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c0%04d%c", main_sub_vfo,
status ? 1 : 0, cat_term);
}
else if (is_ftdx10 || is_ft991 || is_ft891)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO00%04d%c", status ? 1 : 0,
cat_term);
}
else if (is_ftdx5000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c0%02d%c", main_sub_vfo,
status ? 1 : 0, cat_term);
}
else if (is_ftdx3000 || is_ftdx1200 || is_ft2000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO00%02d%c", status ? 1 : 0,
cat_term);
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -10581,15 +10689,26 @@ static int newcat_get_contour(RIG *rig, vfo_t vfo, int *status)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx101d || is_ftdx101mp) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c0%c", main_sub_vfo, cat_term);
} else if (is_ftdx10 || is_ft991 || is_ft891) {
if (is_ftdx101d || is_ftdx101mp)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c0%c", main_sub_vfo,
cat_term);
}
else if (is_ftdx10 || is_ft991 || is_ft891)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO00%c", cat_term);
} else if (is_ftdx5000) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c0%c", main_sub_vfo, cat_term);
} else if (is_ftdx3000 || is_ftdx1200 || is_ft2000) {
}
else if (is_ftdx5000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c0%c", main_sub_vfo,
cat_term);
}
else if (is_ftdx3000 || is_ftdx1200 || is_ft2000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO00%c", cat_term);
} else {
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -10623,19 +10742,31 @@ static int newcat_set_contour_frequency(RIG *rig, vfo_t vfo, int freq)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx101d || is_ftdx101mp) {
if (is_ftdx101d || is_ftdx101mp)
{
// Range is 10..3200 Hz
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c1%04d%c", main_sub_vfo, freq, cat_term);
} else if (is_ftdx10 || is_ft991 || is_ft891) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c1%04d%c", main_sub_vfo,
freq, cat_term);
}
else if (is_ftdx10 || is_ft991 || is_ft891)
{
// Range is 10..3200 Hz
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO01%04d%c", freq, cat_term);
} else if (is_ftdx5000) {
}
else if (is_ftdx5000)
{
// Range is 100..4000 Hz in 100 Hz steps
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c1%01d%c", main_sub_vfo, freq / 100, cat_term);
} else if (is_ftdx3000 || is_ftdx1200 || is_ft2000) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c1%01d%c", main_sub_vfo,
freq / 100, cat_term);
}
else if (is_ftdx3000 || is_ftdx1200 || is_ft2000)
{
// Range is 100..4000 Hz in 100 Hz steps
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO01%02d%c", freq / 100, cat_term);
} else {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO01%02d%c", freq / 100,
cat_term);
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -10655,15 +10786,26 @@ static int newcat_get_contour_frequency(RIG *rig, vfo_t vfo, int *freq)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx101d || is_ftdx101mp) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c1%c", main_sub_vfo, cat_term);
} else if (is_ftdx10 || is_ft991 || is_ft891) {
if (is_ftdx101d || is_ftdx101mp)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c1%c", main_sub_vfo,
cat_term);
}
else if (is_ftdx10 || is_ft991 || is_ft891)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO01%c", cat_term);
} else if (is_ftdx5000) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c1%c", main_sub_vfo, cat_term);
} else if (is_ftdx3000 || is_ftdx1200 || is_ft2000) {
}
else if (is_ftdx5000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO%c1%c", main_sub_vfo,
cat_term);
}
else if (is_ftdx3000 || is_ftdx1200 || is_ft2000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "CO01%c", cat_term);
} else {
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -10682,11 +10824,16 @@ static int newcat_get_contour_frequency(RIG *rig, vfo_t vfo, int *freq)
int raw_value = atoi(ret_data);
if (is_ftdx101d || is_ftdx101mp || is_ftdx10 || is_ft991 || is_ft891) {
if (is_ftdx101d || is_ftdx101mp || is_ftdx10 || is_ft991 || is_ft891)
{
*freq = raw_value;
} else if (is_ftdx5000 || is_ftdx3000 || is_ftdx1200 || is_ft2000) {
}
else if (is_ftdx5000 || is_ftdx3000 || is_ftdx1200 || is_ft2000)
{
*freq = raw_value * 100;
} else {
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -10702,17 +10849,30 @@ static int newcat_set_contour_level(RIG *rig, vfo_t vfo, int level)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx101d || is_ftdx101mp || is_ftdx10) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX030202%+03d%c", level, cat_term);
} else if (is_ft991) {
if (is_ftdx101d || is_ftdx101mp || is_ftdx10)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX030202%+03d%c", level,
cat_term);
}
else if (is_ft991)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX112%+03d%c", level, cat_term);
} else if (is_ft891) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX1202%+03d%c", level, cat_term);
} else if (is_ftdx5000) {
}
else if (is_ft891)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX1202%+03d%c", level,
cat_term);
}
else if (is_ftdx5000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX113%+03d%c", level, cat_term);
} else if (is_ftdx3000 || is_ftdx1200) {
}
else if (is_ftdx3000 || is_ftdx1200)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX108%+03d%c", level, cat_term);
} else {
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -10731,17 +10891,28 @@ static int newcat_get_contour_level(RIG *rig, vfo_t vfo, int *level)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx101d || is_ftdx101mp || is_ftdx10) {
if (is_ftdx101d || is_ftdx101mp || is_ftdx10)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX030202%c", cat_term);
} else if (is_ft991) {
}
else if (is_ft991)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX112%c", cat_term);
} else if (is_ft891) {
}
else if (is_ft891)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX1202%c", cat_term);
} else if (is_ftdx5000) {
}
else if (is_ftdx5000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX113%c", cat_term);
} else if (is_ftdx3000 || is_ftdx1200) {
}
else if (is_ftdx3000 || is_ftdx1200)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX108%c", cat_term);
} else {
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -10772,17 +10943,29 @@ static int newcat_set_contour_width(RIG *rig, vfo_t vfo, int width)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx101d || is_ftdx101mp || is_ftdx10) {
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX030203%02d%c", width, cat_term);
} else if (is_ft991) {
if (is_ftdx101d || is_ftdx101mp || is_ftdx10)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX030203%02d%c", width,
cat_term);
}
else if (is_ft991)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX113%02d%c", width, cat_term);
} else if (is_ft891) {
}
else if (is_ft891)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX1203%02d%c", width, cat_term);
} else if (is_ftdx5000) {
}
else if (is_ftdx5000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX114%02d%c", width, cat_term);
} else if (is_ftdx3000 || is_ftdx1200) {
}
else if (is_ftdx3000 || is_ftdx1200)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX109%02d%c", width, cat_term);
} else {
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}
@ -10801,17 +10984,28 @@ static int newcat_get_contour_width(RIG *rig, vfo_t vfo, int *width)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx101d || is_ftdx101mp || is_ftdx10) {
if (is_ftdx101d || is_ftdx101mp || is_ftdx10)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX030203%c", cat_term);
} else if (is_ft991) {
}
else if (is_ft991)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX113%c", cat_term);
} else if (is_ft891) {
}
else if (is_ft891)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX1203%c", cat_term);
} else if (is_ftdx5000) {
}
else if (is_ftdx5000)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX114%c", cat_term);
} else if (is_ftdx3000 || is_ftdx1200) {
}
else if (is_ftdx3000 || is_ftdx1200)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "EX109%c", cat_term);
} else {
}
else
{
RETURNFUNC(-RIG_ENIMPL);
}

148
rigs/yaesu/vx1700.c
Wyświetl plik

@ -46,100 +46,101 @@
#include "vx1700.h"
// VX-1700 native commands
typedef enum vx1700_native_cmd_e {
VX1700_NATIVE_RECALL_MEM = 0, /* 0x02, p1=ch */
VX1700_NATIVE_VFO_TO_MEM, /* 0x03, p1=ch, p2=0 */
VX1700_NATIVE_MEM_HIDE, /* 0x03, p1=ch, p2=1 */
VX1700_NATIVE_VFO_A, /* 0x05 */
VX1700_NATIVE_FREQ_SET, /* 0x0a, p1:4=freq */
VX1700_NATIVE_MODE_SET_LSB, /* 0x0c, p1=0x00 */
VX1700_NATIVE_MODE_SET_USB, /* 0x0c, p1=0x01 */
VX1700_NATIVE_MODE_SET_CW_W, /* 0x0c, p1=0x02 */
VX1700_NATIVE_MODE_SET_CW_N, /* 0x0c, p1=0x03 */
VX1700_NATIVE_MODE_SET_AM, /* 0x0c, p1=0x04 */
VX1700_NATIVE_MODE_SET_RTTY_LSB_W, /* 0x0c, p1=0x08 */
VX1700_NATIVE_MODE_SET_RTTY_USB_W, /* 0x0c, p1=0x09 */
VX1700_NATIVE_MODE_SET_H3E, /* 0x0c, p1=0x0d */
VX1700_NATIVE_MODE_SET_RTTY_LSB_N, /* 0x0c, p1=0x0e */
VX1700_NATIVE_MODE_SET_RTTY_USB_N, /* 0x0c, p1=0x0f */
VX1700_NATIVE_PTT_OFF, /* 0x0f, p1=0 */
VX1700_NATIVE_PTT_ON, /* 0x0f, p1=1 */
VX1700_NATIVE_UPDATE_MEM_CHNL, /* 0x10, p1=1 */
VX1700_NATIVE_UPDATE_OP_DATA, /* 0x10, p1=2 */
VX1700_NATIVE_UPDATE_VFO_DATA, /* 0x10, p1=3 */
VX1700_NATIVE_TX_POWER_LOW, /* 0x18 */
VX1700_NATIVE_TX_POWER_MID, /* 0x28 */
VX1700_NATIVE_TX_POWER_HI, /* 0x48 */
VX1700_NATIVE_CPY_RX_TO_TX, /* 0x85 */
VX1700_NATIVE_TX_FREQ_SET, /* 0x8a, p1:4=freq */
VX1700_NATIVE_OP_FREQ_STEP_UP, /* 0x8e, p1=0 */
VX1700_NATIVE_OP_FREQ_STEP_DOWN, /* 0x8e, p1=1 */
VX1700_NATIVE_READ_METER, /* 0xf7 */
VX1700_NATIVE_READ_FLAGS, /* 0xfa */
typedef enum vx1700_native_cmd_e
{
VX1700_NATIVE_RECALL_MEM = 0, /* 0x02, p1=ch */
VX1700_NATIVE_VFO_TO_MEM, /* 0x03, p1=ch, p2=0 */
VX1700_NATIVE_MEM_HIDE, /* 0x03, p1=ch, p2=1 */
VX1700_NATIVE_VFO_A, /* 0x05 */
VX1700_NATIVE_FREQ_SET, /* 0x0a, p1:4=freq */
VX1700_NATIVE_MODE_SET_LSB, /* 0x0c, p1=0x00 */
VX1700_NATIVE_MODE_SET_USB, /* 0x0c, p1=0x01 */
VX1700_NATIVE_MODE_SET_CW_W, /* 0x0c, p1=0x02 */
VX1700_NATIVE_MODE_SET_CW_N, /* 0x0c, p1=0x03 */
VX1700_NATIVE_MODE_SET_AM, /* 0x0c, p1=0x04 */
VX1700_NATIVE_MODE_SET_RTTY_LSB_W, /* 0x0c, p1=0x08 */
VX1700_NATIVE_MODE_SET_RTTY_USB_W, /* 0x0c, p1=0x09 */
VX1700_NATIVE_MODE_SET_H3E, /* 0x0c, p1=0x0d */
VX1700_NATIVE_MODE_SET_RTTY_LSB_N, /* 0x0c, p1=0x0e */
VX1700_NATIVE_MODE_SET_RTTY_USB_N, /* 0x0c, p1=0x0f */
VX1700_NATIVE_PTT_OFF, /* 0x0f, p1=0 */
VX1700_NATIVE_PTT_ON, /* 0x0f, p1=1 */
VX1700_NATIVE_UPDATE_MEM_CHNL, /* 0x10, p1=1 */
VX1700_NATIVE_UPDATE_OP_DATA, /* 0x10, p1=2 */
VX1700_NATIVE_UPDATE_VFO_DATA, /* 0x10, p1=3 */
VX1700_NATIVE_TX_POWER_LOW, /* 0x18 */
VX1700_NATIVE_TX_POWER_MID, /* 0x28 */
VX1700_NATIVE_TX_POWER_HI, /* 0x48 */
VX1700_NATIVE_CPY_RX_TO_TX, /* 0x85 */
VX1700_NATIVE_TX_FREQ_SET, /* 0x8a, p1:4=freq */
VX1700_NATIVE_OP_FREQ_STEP_UP, /* 0x8e, p1=0 */
VX1700_NATIVE_OP_FREQ_STEP_DOWN, /* 0x8e, p1=1 */
VX1700_NATIVE_READ_METER, /* 0xf7 */
VX1700_NATIVE_READ_FLAGS, /* 0xfa */
VX1700_NATIVE_SIZE
} vx1700_native_cmd_t;
// OpCode Declarations
#define VX1700_CMD_RECALLMEM 0x02
#define VX1700_CMD_VFO2MEM 0x03
#define VX1700_CMD_SEL_VFOA 0x05
#define VX1700_CMD_SET_VFOA 0x0a
#define VX1700_CMD_SEL_OP_MODE 0x0c
#define VX1700_CMD_PTT 0x0f
#define VX1700_CMD_UPDATE 0x10
#define VX1700_CMD_RX2TX 0x85
#define VX1700_CMD_STEP_VFO 0x8e
#define VX1700_CMD_RD_METER 0xf7
#define VX1700_CMD_RD_FLAGS 0xfa
#define VX1700_CMD_RECALLMEM 0x02
#define VX1700_CMD_VFO2MEM 0x03
#define VX1700_CMD_SEL_VFOA 0x05
#define VX1700_CMD_SET_VFOA 0x0a
#define VX1700_CMD_SEL_OP_MODE 0x0c
#define VX1700_CMD_PTT 0x0f
#define VX1700_CMD_UPDATE 0x10
#define VX1700_CMD_RX2TX 0x85
#define VX1700_CMD_STEP_VFO 0x8e
#define VX1700_CMD_RD_METER 0xf7
#define VX1700_CMD_RD_FLAGS 0xfa
// Return codes
#define VX1700_CMD_RETCODE_OK 0x00
#define VX1700_CMD_RETCODE_ERROR 0xF0
#define VX1700_CMD_RETCODE_OK 0x00
#define VX1700_CMD_RETCODE_ERROR 0xF0
// Operating Mode Status
#define VX1700_MODE_LSB 0x00
#define VX1700_MODE_USB 0x01
#define VX1700_MODE_CW_W 0x02
#define VX1700_MODE_CW_N 0x03
#define VX1700_MODE_AM 0x04
#define VX1700_MODE_RTTY 0x05
#define VX1700_MODE_LSB 0x00
#define VX1700_MODE_USB 0x01
#define VX1700_MODE_CW_W 0x02
#define VX1700_MODE_CW_N 0x03
#define VX1700_MODE_AM 0x04
#define VX1700_MODE_RTTY 0x05
// Operation Mode Selection
#define VX1700_OP_MODE_LSB 0x00
#define VX1700_OP_MODE_USB 0x01
#define VX1700_OP_MODE_CW_W 0x02
#define VX1700_OP_MODE_CW_N 0x03
#define VX1700_OP_MODE_AM 0x04
#define VX1700_OP_MODE_RTTY_LSB_W 0x08
#define VX1700_OP_MODE_RTTY_USB_W 0x09
#define VX1700_OP_MODE_H3E 0x0d
#define VX1700_OP_MODE_RTTY_LSB_N 0x0e
#define VX1700_OP_MODE_RTTY_USB_N 0x0f
#define VX1700_OP_MODE_LSB 0x00
#define VX1700_OP_MODE_USB 0x01
#define VX1700_OP_MODE_CW_W 0x02
#define VX1700_OP_MODE_CW_N 0x03
#define VX1700_OP_MODE_AM 0x04
#define VX1700_OP_MODE_RTTY_LSB_W 0x08
#define VX1700_OP_MODE_RTTY_USB_W 0x09
#define VX1700_OP_MODE_H3E 0x0d
#define VX1700_OP_MODE_RTTY_LSB_N 0x0e
#define VX1700_OP_MODE_RTTY_USB_N 0x0f
// Status Flag 1 Masks
#define VX1700_SF_LOCKED 0x01 /* LOCK is activated */
#define VX1700_SF_MEM 0x20 /* Memory Mode */
#define VX1700_SF_VFO 0x80 /* VFO Mode */
#define VX1700_SF_LOCKED 0x01 /* LOCK is activated */
#define VX1700_SF_MEM 0x20 /* Memory Mode */
#define VX1700_SF_VFO 0x80 /* VFO Mode */
// Status Flag 2 Masks
#define VX1700_SF_PTT_BY_CAT 0x01 /* PTT closed by CAT */
#define VX1700_SF_MEM_SCAN_PAUSE 0x02 /* Scanning paused */
#define VX1700_SF_MEM_SCAN 0x04 /* Scanning enabled */
#define VX1700_SF_RTTY_FILTER_NARROW 0x08 /* Narrow RTTY filter selected */
#define VX1700_SF_CW_FILTER_NARROW 0x10 /* Narrow CW filter selected */
#define VX1700_SF_RTTY_USB 0x20 /* USB selected for RTTY */
#define VX1700_SF_PTT_BY_CAT 0x01 /* PTT closed by CAT */
#define VX1700_SF_MEM_SCAN_PAUSE 0x02 /* Scanning paused */
#define VX1700_SF_MEM_SCAN 0x04 /* Scanning enabled */
#define VX1700_SF_RTTY_FILTER_NARROW 0x08 /* Narrow RTTY filter selected */
#define VX1700_SF_CW_FILTER_NARROW 0x10 /* Narrow CW filter selected */
#define VX1700_SF_RTTY_USB 0x20 /* USB selected for RTTY */
// Status Flag 3 Masks
#define VX1700_SF_10W_TX 0x20 /* 10 Watt TX output selected */
#define VX1700_SF_TUNER_ON 0x20 /* Antenna Tuner working */
#define VX1700_SF_TRANSMISSION_ON 0x80 /* Transmission in progress */
#define VX1700_SF_10W_TX 0x20 /* 10 Watt TX output selected */
#define VX1700_SF_TUNER_ON 0x20 /* Antenna Tuner working */
#define VX1700_SF_TRANSMISSION_ON 0x80 /* Transmission in progress */
/* HAMLIB API implementation */
static int vx1700_init(RIG *rig);
static int vx1700_open(RIG *rig);
static int vx1700_cleanup(RIG *rig);
static const char * vx1700_get_info(RIG *rig);
static const char *vx1700_get_info(RIG *rig);
static int vx1700_set_vfo(RIG *rig, vfo_t vfo);
static int vx1700_get_vfo(RIG *rig, vfo_t *vfo);
@ -148,7 +149,8 @@ static int vx1700_get_freq(RIG *rig, vfo_t vfo, freq_t *freq);
static int vx1700_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq);
static int vx1700_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq);
static int vx1700_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width);
static int vx1700_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width);
static int vx1700_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode,
pbwidth_t *width);
static int vx1700_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt);
static int vx1700_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt);
static int vx1700_set_func(RIG *rig, vfo_t vfo, setting_t func, int status);

2
simulators/simicom.c
Wyświetl plik

@ -194,6 +194,7 @@ void frameParse(int fd, unsigned char *frame, int len)
frame[7] = 0xfd;
write(fd, frame, 8);
break;
case 0x07: // satmode
frame[6] = 0;
frame[7] = 0xfd;
@ -237,6 +238,7 @@ void frameParse(int fd, unsigned char *frame, int len)
break;
#else
case 0x25:
frame[4] = 0xfa;
frame[5] = 0xfd;

4
simulators/simkenwood.c
Wyświetl plik

@ -224,12 +224,12 @@ int main(int argc, char *argv[])
{
sscanf(buf, "MD%d", &modeA); // not worried about modeB yet for simulator
}
else if (strncmp(buf,"FL;",3) == 0)
else if (strncmp(buf, "FL;", 3) == 0)
{
sprintf(buf, "FL%03d;", filternum);
write(fd, buf, strlen(buf));
}
else if (strncmp(buf,"FL",2) == 0)
else if (strncmp(buf, "FL", 2) == 0)
{
sscanf(buf, "FL%d", &filternum);
}

26
simulators/simyaesu.c
Wyświetl plik

@ -130,23 +130,23 @@ int main(int argc, char *argv[])
}
else if (strcmp(buf, "FA;") == 0)
{
pbuf=strdup("FA3456789012;");
sprintf(pbuf,"FA%010.0f", freqA);
pbuf = strdup("FA3456789012;");
sprintf(pbuf, "FA%010.0f", freqA);
free(pbuf);
}
else if (strncmp(buf, "FA",2)==0)
else if (strncmp(buf, "FA", 2) == 0)
{
sscanf(buf,"FA%f",&freqA);
sscanf(buf, "FA%f", &freqA);
}
else if (strcmp(buf, "FB;") == 0)
{
pbuf=strdup("FB3456789012;");
sprintf(pbuf,"FB%010.0f", freqB);
pbuf = strdup("FB3456789012;");
sprintf(pbuf, "FB%010.0f", freqB);
free(pbuf);
}
else if (strncmp(buf, "FB",2)==0)
else if (strncmp(buf, "FB", 2) == 0)
{
sscanf(buf,"FB%f",&freqB);
sscanf(buf, "FB%f", &freqB);
}
else if (strcmp(buf, "IF;") == 0)
{
@ -205,20 +205,22 @@ int main(int argc, char *argv[])
if (n < 0) { perror("VS"); }
}
else if (strcmp(buf, "FT;")==0)
else if (strcmp(buf, "FT;") == 0)
{
usleep(50*1000);
usleep(50 * 1000);
pbuf = strdup("FTx;");
pbuf[2] = tx_vfo;
n = write(fd, pbuf, strlen(pbuf));
free(pbuf);
if (n < 0) { perror("FT"); }
}
else if (strncmp(buf, "FT", 2) == 0)
{
tx_vfo = buf[2];
if (tx_vfo == '3') tx_vfo = '1';
else if (tx_vfo == '2') tx_vfo = '0';
if (tx_vfo == '3') { tx_vfo = '1'; }
else if (tx_vfo == '2') { tx_vfo = '0'; }
else { perror("Expected 2 or 3"); }
}
else if (strcmp(buf, "EX032;") == 0)

34
src/iofunc.c
Wyświetl plik

@ -678,7 +678,7 @@ int HAMLIB_API read_string(hamlib_port_t *p,
fd_set rfds, efds;
struct timeval tv, tv_timeout, start_time, end_time, elapsed_time;
int total_count = 0;
int i=0;
int i = 0;
static int minlen = 1; // dynamic minimum length of rig response data
rig_debug(RIG_DEBUG_TRACE, "%s called, rxmax=%d\n", __func__, (int)rxmax);
@ -728,13 +728,15 @@ int HAMLIB_API read_string(hamlib_port_t *p,
timersub(&end_time, &start_time, &elapsed_time);
dump_hex((unsigned char *) rxbuffer, total_count);
if (!flush_flag) {
rig_debug(RIG_DEBUG_WARN,
"%s(): Timed out %d.%03d seconds after %d chars\n",
__func__,
(int)elapsed_time.tv_sec,
(int)elapsed_time.tv_usec / 1000,
total_count);
if (!flush_flag)
{
rig_debug(RIG_DEBUG_WARN,
"%s(): Timed out %d.%03d seconds after %d chars\n",
__func__,
(int)elapsed_time.tv_sec,
(int)elapsed_time.tv_usec / 1000,
total_count);
}
return -RIG_ETIMEOUT;
@ -769,17 +771,19 @@ int HAMLIB_API read_string(hamlib_port_t *p,
* read 1 character from the rig, (check if in stop set)
* The file descriptor must have been set up non blocking.
*/
do
do
{
minlen -= rd_count;
rd_count = port_read(p, &rxbuffer[total_count], expected_len==1?1:minlen);
rd_count = port_read(p, &rxbuffer[total_count], expected_len == 1 ? 1 : minlen);
if (errno == EAGAIN)
{
hl_usleep(5*1000);
hl_usleep(5 * 1000);
rig_debug(RIG_DEBUG_WARN, "%s: port_read is busy?\n", __func__);
}
} while( ++i < 10 && errno == EBUSY); // 50ms should be enough
}
while (++i < 10 && errno == EBUSY); // 50ms should be enough
/* if we get 0 bytes or an error something is wrong */
if (rd_count <= 0)
@ -800,12 +804,14 @@ int HAMLIB_API read_string(hamlib_port_t *p,
if (stopset && memchr(stopset, rxbuffer[total_count - 1], stopset_len))
{
if (minlen == 1) minlen = total_count;
if (minlen < total_count)
if (minlen == 1) { minlen = total_count; }
if (minlen < total_count)
{
minlen = total_count;
rig_debug(RIG_DEBUG_VERBOSE, "%s: minlen now %d\n", __func__, minlen);
}
break;
}
}

52
src/misc.c
Wyświetl plik

@ -607,12 +607,14 @@ vfo_t HAMLIB_API rig_parse_vfo(const char *s)
{
if (!strcmp(s, vfo_str[i].str))
{
rig_debug(RIG_DEBUG_CACHE, "%s: str='%s' vfo='%s'\n", __func__, vfo_str[i].str, rig_strvfo(vfo_str[i].vfo));
rig_debug(RIG_DEBUG_CACHE, "%s: str='%s' vfo='%s'\n", __func__, vfo_str[i].str,
rig_strvfo(vfo_str[i].vfo));
return vfo_str[i].vfo;
}
}
rig_debug(RIG_DEBUG_ERR, "%s: '%s' not found so vfo='%s'\n", __func__, s, rig_strvfo(RIG_VFO_NONE));
rig_debug(RIG_DEBUG_ERR, "%s: '%s' not found so vfo='%s'\n", __func__, s,
rig_strvfo(RIG_VFO_NONE));
return RIG_VFO_NONE;
}
@ -1738,11 +1740,12 @@ static char *funcname = "Unknown";
static int linenum = 0;
#undef vfo_fixup
vfo_t HAMLIB_API vfo_fixup2a(RIG *rig, vfo_t vfo, split_t split, const char *func, int line)
vfo_t HAMLIB_API vfo_fixup2a(RIG *rig, vfo_t vfo, split_t split,
const char *func, int line)
{
funcname = (char*)func;
funcname = (char *)func;
linenum = (int)line;
return vfo_fixup(rig,vfo,split);
return vfo_fixup(rig, vfo, split);
}
// we're mappping our VFO here to work with either VFO A/B rigs or Main/Sub
@ -1750,7 +1753,8 @@ vfo_t HAMLIB_API vfo_fixup2a(RIG *rig, vfo_t vfo, split_t split, const char *fun
// So we map these to Main/Sub as required
vfo_t HAMLIB_API vfo_fixup(RIG *rig, vfo_t vfo, split_t split)
{
rig_debug(RIG_DEBUG_TRACE, "%s:(from %s:%d) vfo=%s, vfo_curr=%s, split=%d\n", __func__, funcname, linenum,
rig_debug(RIG_DEBUG_TRACE, "%s:(from %s:%d) vfo=%s, vfo_curr=%s, split=%d\n",
__func__, funcname, linenum,
rig_strvfo(vfo), rig_strvfo(rig->state.current_vfo), split);
if (vfo == RIG_VFO_CURR)
@ -1758,22 +1762,28 @@ vfo_t HAMLIB_API vfo_fixup(RIG *rig, vfo_t vfo, split_t split)
rig_debug(RIG_DEBUG_TRACE, "%s: Leaving currVFO alone\n", __func__);
return vfo; // don't modify vfo for RIG_VFO_CURR
}
if (vfo == RIG_VFO_OTHER)
{
switch(rig->state.current_vfo)
switch (rig->state.current_vfo)
{
case RIG_VFO_A:
return RIG_VFO_B;
case RIG_VFO_MAIN:
return RIG_VFO_SUB;
case RIG_VFO_B:
return RIG_VFO_A;
case RIG_VFO_SUB:
return RIG_VFO_MAIN;
case RIG_VFO_SUB_A:
return RIG_VFO_SUB_B;
case RIG_VFO_SUB_B:
return RIG_VFO_SUB_A;
case RIG_VFO_A:
return RIG_VFO_B;
case RIG_VFO_MAIN:
return RIG_VFO_SUB;
case RIG_VFO_B:
return RIG_VFO_A;
case RIG_VFO_SUB:
return RIG_VFO_MAIN;
case RIG_VFO_SUB_A:
return RIG_VFO_SUB_B;
case RIG_VFO_SUB_B:
return RIG_VFO_SUB_A;
}
}
@ -1811,7 +1821,9 @@ vfo_t HAMLIB_API vfo_fixup(RIG *rig, vfo_t vfo, split_t split)
int satmode = rig->state.cache.satmode;
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): split=%d, vfo==%s tx_vfo=%s\n", __func__, __LINE__, split, rig_strvfo(vfo), rig_strvfo(rig->state.tx_vfo));
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): split=%d, vfo==%s tx_vfo=%s\n", __func__,
__LINE__, split, rig_strvfo(vfo), rig_strvfo(rig->state.tx_vfo));
if (split && vfo == RIG_VFO_TX) { vfo = rig->state.tx_vfo; }
if (VFO_HAS_MAIN_SUB_ONLY && !split && !satmode && vfo != RIG_VFO_B) { vfo = RIG_VFO_MAIN; }

6
src/network.c
Wyświetl plik

@ -174,6 +174,7 @@ int network_open(hamlib_port_t *rp, int default_port)
status = network_init();
if (status != RIG_OK) { RETURNFUNC(status); }
#endif
if (!rp)
@ -361,9 +362,10 @@ void network_flush(hamlib_port_t *rp)
}
rig_debug(RIG_DEBUG_WARN,
"%s: network data cleared: ret=%d, len_read=%d/0x%x, '%s'\n",
"%s: network data cleared: ret=%d, len_read=%d/0x%x\n",
__func__,
ret, len_read, len_read, buffer);
ret, len_read, len_read);
dump_hex((unsigned char *)buffer, len_read);
}
else
{

186
src/rig.c
Wyświetl plik

@ -1045,9 +1045,12 @@ int HAMLIB_API rig_open(RIG *rig)
{
//int backend_num = RIG_BACKEND_NUM(rig->caps->rig_model);
rs->tx_vfo = RIG_VFO_TX;
// If we haven't gotten the vfo by now we will default to VFO_CURR
if (rs->current_vfo == RIG_VFO_NONE) rs->current_vfo = RIG_VFO_CURR;
rig_debug(RIG_DEBUG_TRACE, "%s: vfo_curr=%s, tx_vfo=%s\n", __func__, rig_strvfo(rs->current_vfo), rig_strvfo(rs->tx_vfo));
if (rs->current_vfo == RIG_VFO_NONE) { rs->current_vfo = RIG_VFO_CURR; }
rig_debug(RIG_DEBUG_TRACE, "%s: vfo_curr=%s, tx_vfo=%s\n", __func__,
rig_strvfo(rs->current_vfo), rig_strvfo(rs->tx_vfo));
#if 0 // done in the back end
@ -1625,7 +1628,7 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq,
rig_debug(RIG_DEBUG_CACHE, "%s: vfo=%s, current_vfo=%s\n", __func__,
rig_strvfo(vfo), rig_strvfo(rig->state.current_vfo));
if (vfo == RIG_VFO_CURR)
if (vfo == RIG_VFO_CURR)
{
vfo = rig->state.current_vfo;
}
@ -1633,32 +1636,40 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq,
{
switch (vfo)
{
case RIG_VFO_OTHER:
vfo = RIG_VFO_OTHER;
break;
case RIG_VFO_A:
vfo = RIG_VFO_B;
break;
case RIG_VFO_MAIN_A:
vfo = RIG_VFO_MAIN_B;
break;
case RIG_VFO_MAIN:
vfo = RIG_VFO_SUB;
break;
case RIG_VFO_B:
vfo = RIG_VFO_A;
break;
case RIG_VFO_MAIN_B:
vfo = RIG_VFO_MAIN_A;
break;
case RIG_VFO_SUB_A:
vfo = RIG_VFO_SUB_B;
break;
case RIG_VFO_SUB_B:
vfo = RIG_VFO_SUB_A;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unknown vfo=%s\n", __func__, rig_strvfo(vfo));
case RIG_VFO_OTHER:
vfo = RIG_VFO_OTHER;
break;
case RIG_VFO_A:
vfo = RIG_VFO_B;
break;
case RIG_VFO_MAIN_A:
vfo = RIG_VFO_MAIN_B;
break;
case RIG_VFO_MAIN:
vfo = RIG_VFO_SUB;
break;
case RIG_VFO_B:
vfo = RIG_VFO_A;
break;
case RIG_VFO_MAIN_B:
vfo = RIG_VFO_MAIN_A;
break;
case RIG_VFO_SUB_A:
vfo = RIG_VFO_SUB_B;
break;
case RIG_VFO_SUB_B:
vfo = RIG_VFO_SUB_A;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unknown vfo=%s\n", __func__, rig_strvfo(vfo));
}
}
@ -1681,6 +1692,7 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq,
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthCurr,
HAMLIB_ELAPSED_GET);
break;
case RIG_VFO_OTHER:
*freq = rig->state.cache.freqOther;
*mode = rig->state.cache.modeOther;
@ -1692,6 +1704,7 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq,
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthOther,
HAMLIB_ELAPSED_GET);
break;
case RIG_VFO_A:
case RIG_VFO_MAIN:
case RIG_VFO_MAIN_A:
@ -1785,7 +1798,8 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq,
RETURNFUNC(-RIG_EINVAL);
}
rig_debug(RIG_DEBUG_CACHE, "%s: vfo=%s, freq=%.0f, mode=%s, width=%d\n", __func__, rig_strvfo(vfo),
rig_debug(RIG_DEBUG_CACHE, "%s: vfo=%s, freq=%.0f, mode=%s, width=%d\n",
__func__, rig_strvfo(vfo),
(double)*freq, rig_strrmode(*mode), (int)*width);
if (rig_need_debug(RIG_DEBUG_CACHE))
@ -1925,7 +1939,8 @@ int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
RIG_OK); // would be better as error but other software won't handle errors
}
rig_debug(RIG_DEBUG_TRACE, "%s: TARGETABLE_FREQ vfo=%s\n", __func__, rig_strvfo(vfo));
rig_debug(RIG_DEBUG_TRACE, "%s: TARGETABLE_FREQ vfo=%s\n", __func__,
rig_strvfo(vfo));
int retry = 3;
freq_t tfreq = 0;
@ -1974,7 +1989,8 @@ int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
}
else
{
rig_debug(RIG_DEBUG_TRACE, "%s: not a TARGETABLE_FREQ vfo=%s\n", __func__, rig_strvfo(vfo));
rig_debug(RIG_DEBUG_TRACE, "%s: not a TARGETABLE_FREQ vfo=%s\n", __func__,
rig_strvfo(vfo));
if (!caps->set_vfo)
{
@ -2183,7 +2199,9 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
RETURNFUNC(-RIG_ENAVAIL);
}
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): vfo_opt=%d, model=%d\n", __func__, __LINE__, rig->state.vfo_opt, rig->caps->rig_model);
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): vfo_opt=%d, model=%d\n", __func__,
__LINE__, rig->state.vfo_opt, rig->caps->rig_model);
// If we're in vfo_mode then rigctld will do any VFO swapping we need
if ((caps->targetable_vfo & RIG_TARGETABLE_FREQ)
|| vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo
@ -2330,8 +2348,10 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
ELAPSED1;
rig_debug(RIG_DEBUG_VERBOSE, "%s called, vfo=%s, mode=%s, width=%dm, curr_vfo=%s\n", __func__,
rig_strvfo(vfo), rig_strrmode(mode), (int)width, rig_strvfo(rig->state.current_vfo));
rig_debug(RIG_DEBUG_VERBOSE,
"%s called, vfo=%s, mode=%s, width=%dm, curr_vfo=%s\n", __func__,
rig_strvfo(vfo), rig_strrmode(mode), (int)width,
rig_strvfo(rig->state.current_vfo));
if (CHECK_RIG_ARG(rig))
{
@ -2371,9 +2391,11 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
// if not a targetable rig we will only set mode on VFOB if it is changing
if (rig->state.cache.modeMainB == mode)
{
rig_debug(RIG_DEBUG_TRACE, "%s: VFOB mode not changing so ignoring\n", __func__);
return(RIG_OK);
rig_debug(RIG_DEBUG_TRACE, "%s: VFOB mode not changing so ignoring\n",
__func__);
return (RIG_OK);
}
rig_debug(RIG_DEBUG_TRACE, "%s: not targetable need vfo swap\n", __func__);
if (!caps->set_vfo)
@ -3933,6 +3955,7 @@ int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
freq_t tfreq = 0;
ELAPSED1;
if (CHECK_RIG_ARG(rig))
{
RETURNFUNC(-RIG_EINVAL);
@ -3954,7 +3977,7 @@ int HAMLIB_API rig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
tx_vfo = vfo;
}
rig_get_freq(rig, tx_vfo, &tfreq);
rig_get_freq(rig, tx_vfo, &tfreq);
if (tfreq == tx_freq)
{
@ -4284,7 +4307,8 @@ int HAMLIB_API rig_set_split_mode(RIG *rig,
curr_vfo = rig->state.current_vfo;
/* Use previously setup TxVFO */
if (vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX || rig->state.tx_vfo != RIG_VFO_NONE)
if (vfo == RIG_VFO_CURR || vfo == RIG_VFO_TX
|| rig->state.tx_vfo != RIG_VFO_NONE)
{
TRACE;
tx_vfo = rig->state.tx_vfo;
@ -4294,9 +4318,12 @@ int HAMLIB_API rig_set_split_mode(RIG *rig,
TRACE;
tx_vfo = vfo;
}
rig_debug(RIG_DEBUG_VERBOSE, "%s: curr_vfo=%s, tx_vfo=%s\n", __func__, rig_strvfo(curr_vfo), rig_strvfo(tx_vfo));
if (caps->set_mode && ((caps->targetable_vfo & RIG_TARGETABLE_MODE) || (rig->caps->rig_model == RIG_MODEL_NETRIGCTL)))
rig_debug(RIG_DEBUG_VERBOSE, "%s: curr_vfo=%s, tx_vfo=%s\n", __func__,
rig_strvfo(curr_vfo), rig_strvfo(tx_vfo));
if (caps->set_mode && ((caps->targetable_vfo & RIG_TARGETABLE_MODE)
|| (rig->caps->rig_model == RIG_MODEL_NETRIGCTL)))
{
TRACE;
retcode = caps->set_mode(rig, tx_vfo, tx_mode, tx_width);
@ -4307,33 +4334,46 @@ int HAMLIB_API rig_set_split_mode(RIG *rig,
// some rigs exhibit undesirable flashing when swapping vfos in split
// so we turn it off, do our thing, and turn split back on
rx_vfo = RIG_VFO_A;
if (vfo == RIG_VFO_CURR && tx_vfo == RIG_VFO_B) rx_vfo = RIG_VFO_A;
else if (vfo == RIG_VFO_CURR && tx_vfo == RIG_VFO_A) rx_vfo = RIG_VFO_B;
else if (vfo == RIG_VFO_CURR && tx_vfo == RIG_VFO_MAIN) rx_vfo = RIG_VFO_SUB;
else if (vfo == RIG_VFO_CURR && tx_vfo == RIG_VFO_SUB) rx_vfo = RIG_VFO_MAIN;
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): rx_vfo=%s, tx_vfo=%s\n", __func__, __LINE__, rig_strvfo(rx_vfo), rig_strvfo(tx_vfo));
if (vfo == RIG_VFO_CURR && tx_vfo == RIG_VFO_B) { rx_vfo = RIG_VFO_A; }
else if (vfo == RIG_VFO_CURR && tx_vfo == RIG_VFO_A) { rx_vfo = RIG_VFO_B; }
else if (vfo == RIG_VFO_CURR && tx_vfo == RIG_VFO_MAIN) { rx_vfo = RIG_VFO_SUB; }
else if (vfo == RIG_VFO_CURR && tx_vfo == RIG_VFO_SUB) { rx_vfo = RIG_VFO_MAIN; }
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): rx_vfo=%s, tx_vfo=%s\n", __func__,
__LINE__, rig_strvfo(rx_vfo), rig_strvfo(tx_vfo));
// we will reuse cached mode instead of trying to set mode again
if ((tx_vfo & (RIG_VFO_A|RIG_VFO_MAIN|RIG_VFO_MAIN_A|RIG_VFO_SUB_A)) && (tx_mode == rig->state.cache.modeMainA))
if ((tx_vfo & (RIG_VFO_A | RIG_VFO_MAIN | RIG_VFO_MAIN_A | RIG_VFO_SUB_A))
&& (tx_mode == rig->state.cache.modeMainA))
{
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): VFOA mode=%s already set...ignoring\n", __func__, __LINE__, rig_strrmode(tx_mode));
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): VFOA mode=%s already set...ignoring\n",
__func__, __LINE__, rig_strrmode(tx_mode));
ELAPSED2;
RETURNFUNC(RIG_OK);
}
else if ((tx_vfo & (RIG_VFO_B|RIG_VFO_SUB|RIG_VFO_MAIN_B|RIG_VFO_SUB_B)) && (tx_mode == rig->state.cache.modeMainB))
else if ((tx_vfo & (RIG_VFO_B | RIG_VFO_SUB | RIG_VFO_MAIN_B | RIG_VFO_SUB_B))
&& (tx_mode == rig->state.cache.modeMainB))
{
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): VFOB mode=%s already set...ignoring\n", __func__, __LINE__, rig_strrmode(tx_mode));
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): VFOB mode=%s already set...ignoring\n",
__func__, __LINE__, rig_strrmode(tx_mode));
ELAPSED2;
RETURNFUNC(RIG_OK);
}
rig_debug(RIG_DEBUG_WARN, "%s(%d): Unhandled TXVFO=%s, tx_mode=%s\n", __func__, __LINE__, rig_strvfo(tx_vfo), rig_strrmode(tx_mode));
rig_debug(RIG_DEBUG_WARN, "%s(%d): Unhandled TXVFO=%s, tx_mode=%s\n", __func__,
__LINE__, rig_strvfo(tx_vfo), rig_strrmode(tx_mode));
// code below here should be dead code now -- but maybe we have VFO situatiuon we need to handle
if (caps->rig_model == RIG_MODEL_NETRIGCTL)
{ // special handlingt for netrigctl to avoid set_vfo
{
// special handlingt for netrigctl to avoid set_vfo
retcode = caps->set_split_mode(rig, vfo, tx_mode, tx_width);
RETURNFUNC(retcode);
}
rig_set_split_vfo(rig,rx_vfo, RIG_SPLIT_OFF, rx_vfo);
rig_set_split_vfo(rig, rx_vfo, RIG_SPLIT_OFF, rx_vfo);
if (caps->set_vfo)
{
TRACE;
@ -4385,7 +4425,8 @@ int HAMLIB_API rig_set_split_mode(RIG *rig,
/* return the first error code */
retcode = rc2;
}
rig_set_split_vfo(rig,rx_vfo, RIG_SPLIT_ON, tx_vfo);
rig_set_split_vfo(rig, rx_vfo, RIG_SPLIT_ON, tx_vfo);
ELAPSED2;
RETURNFUNC(retcode);
@ -4751,13 +4792,13 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig,
{
RETURNFUNC(-RIG_ENAVAIL);
}
if (rig->state.cache.ptt)
{
rig_debug(RIG_DEBUG_WARN, "%s: cannot execute when PTT is on\n", __func__);
ELAPSED2;
return RIG_OK;
}
if (rig->state.cache.ptt)
{
rig_debug(RIG_DEBUG_WARN, "%s: cannot execute when PTT is on\n", __func__);
ELAPSED2;
return RIG_OK;
}
// We fix up vfos for non-satmode rigs only
if (rig->caps->has_get_func & RIG_FUNC_SATMODE)
@ -4766,23 +4807,27 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig,
__func__, rig_strvfo(rx_vfo), rig_strvfo(tx_vfo));
}
else
{
switch(tx_vfo)
{
switch (tx_vfo)
{
case RIG_VFO_A: rx_vfo = split==1?RIG_VFO_B:RIG_VFO_A;break;
case RIG_VFO_B: rx_vfo = split==1?RIG_VFO_A:RIG_VFO_B;break;
case RIG_VFO_A: rx_vfo = split == 1 ? RIG_VFO_B : RIG_VFO_A; break;
case RIG_VFO_B: rx_vfo = split == 1 ? RIG_VFO_A : RIG_VFO_B; break;
}
rx_vfo = vfo_fixup(rig, rx_vfo, split);
tx_vfo = vfo_fixup(rig, tx_vfo, split);
rig->state.rx_vfo = rx_vfo;
rig->state.tx_vfo = tx_vfo;
rig_debug(RIG_DEBUG_VERBOSE, "%s: final rxvfo=%s, txvfo=%s\n", __func__, rig_strvfo(rx_vfo), rig_strvfo(tx_vfo));
rig_debug(RIG_DEBUG_VERBOSE, "%s: final rxvfo=%s, txvfo=%s\n", __func__,
rig_strvfo(rx_vfo), rig_strvfo(tx_vfo));
}
// set rig to the the requested RX VFO
TRACE;
if ((!(caps->targetable_vfo & RIG_TARGETABLE_FREQ)) && (!(rig->caps->rig_model == RIG_MODEL_NETRIGCTL)))
if ((!(caps->targetable_vfo & RIG_TARGETABLE_FREQ))
&& (!(rig->caps->rig_model == RIG_MODEL_NETRIGCTL)))
#if BUILTINFUNC
rig_set_vfo(rig, rx_vfo == RIG_VFO_B ? RIG_VFO_B : RIG_VFO_A,
__builtin_FUNCTION());
@ -4797,9 +4842,11 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig,
// for non-targetable VFOs we will not set split again
if (rig->state.cache.split == split && rig->state.cache.split_vfo == tx_vfo)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): split already set...ignoring\n", __func__, __LINE__);
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d): split already set...ignoring\n", __func__,
__LINE__);
RETURNFUNC(RIG_OK);
}
TRACE;
retcode = caps->set_split_vfo(rig, rx_vfo, split, tx_vfo);
@ -4928,7 +4975,8 @@ int HAMLIB_API rig_get_split_vfo(RIG *rig,
{
*split = rig->state.cache.split;
*tx_vfo = rig->state.cache.split_vfo;
rig_debug(RIG_DEBUG_TRACE, "%s: cache hit age=%dms, split=%d, tx_vfo=%s\n", __func__, cache_ms, *split, rig_strvfo(*tx_vfo));
rig_debug(RIG_DEBUG_TRACE, "%s: cache hit age=%dms, split=%d, tx_vfo=%s\n",
__func__, cache_ms, *split, rig_strvfo(*tx_vfo));
ELAPSED2;
RETURNFUNC(RIG_OK);
}

24
src/serial.c
Wyświetl plik

@ -673,23 +673,29 @@ int HAMLIB_API serial_flush(hamlib_port_t *p)
timeout_save = p->timeout;
p->timeout = 1;
do
{
// we pass an empty stopset so read_string can determine
// the appropriate stopset for async data
char stopset[1];
len = read_string(p, (char*)buf, sizeof(buf)-1, stopset, 0, 1, 1);
if (len > 0)
len = read_string(p, (char *)buf, sizeof(buf) - 1, stopset, 0, 1, 1);
if (len > 0)
{
int i, binary=0;
for(i=0;i<len;++i)
int i, binary = 0;
for (i = 0; i < len; ++i)
{
if (!isprint(buf[i])) binary = 1;
if (!isprint(buf[i])) { binary = 1; }
}
if (binary)
{
char *hbuf = calloc(len*3+1, 1);
for(i=0;i<len;++i) sprintf(&hbuf[i*3], "%02X ", buf[i]);
char *hbuf = calloc(len * 3 + 1, 1);
for (i = 0; i < len; ++i) { sprintf(&hbuf[i * 3], "%02X ", buf[i]); }
rig_debug(RIG_DEBUG_WARN, "%s: flush hex:%s\n", __func__, hbuf);
free(hbuf);
}
@ -698,7 +704,9 @@ int HAMLIB_API serial_flush(hamlib_port_t *p)
rig_debug(RIG_DEBUG_WARN, "%s: flush string:%s\n", __func__, buf);
}
}
} while(len > 0);
}
while (len > 0);
p->timeout = timeout_save;
//rig_debug(RIG_DEBUG_VERBOSE, "tcflush%s\n", "");
//tcflush(p->fd, TCIFLUSH);

4
tests/ampctld.c
Wyświetl plik

@ -568,7 +568,7 @@ int main(int argc, char *argv[])
sizeof(host),
serv,
sizeof(serv),
NI_NUMERICHOST|NI_NUMERICSERV))
NI_NUMERICHOST | NI_NUMERICSERV))
< 0)
{
@ -674,7 +674,7 @@ void *handle_socket(void *arg)
sizeof(host),
serv,
sizeof(serv),
NI_NUMERICHOST|NI_NUMERICSERV))
NI_NUMERICHOST | NI_NUMERICSERV))
< 0)
{

22
tests/rigctl_parse.c
Wyświetl plik

@ -2798,7 +2798,7 @@ declare_proto_rig(set_split_mode)
}
// mode could be RIG_MODE_NONE here
// we treat it as non-fatal
// we treat it as non-fatal
// rig_parse_mode will spit out error msg
mode = rig_parse_mode(arg1);
CHKSCN1ARG(sscanf(arg2, "%d", &width));
@ -3633,7 +3633,8 @@ declare_proto_rig(vfo_op)
if (RIG_OP_NONE == op)
{
rig_debug(RIG_DEBUG_ERR, "%s: rig_parse_vfo failed with '%s'\n", __func__, arg1);
rig_debug(RIG_DEBUG_ERR, "%s: rig_parse_vfo failed with '%s'\n", __func__,
arg1);
RETURNFUNC(-RIG_EINVAL);
}
@ -5098,13 +5099,18 @@ char rig_passwd[256];
declare_proto_rig(password)
{
const char *passwd = arg1;
if (strcmp(passwd,rig_passwd)==0) {
rig_debug(RIG_DEBUG_ERR, "%s: #1 password OK\n", __func__);
return(RIG_EINVAL);
if (strcmp(passwd, rig_passwd) == 0)
{
rig_debug(RIG_DEBUG_ERR, "%s: #1 password OK\n", __func__);
return (RIG_EINVAL);
}
else{
rig_debug(RIG_DEBUG_ERR, "%s: #2 password error, '%s'!='%s'\n", __func__,passwd,rig_passwd);
else
{
rig_debug(RIG_DEBUG_ERR, "%s: #2 password error, '%s'!='%s'\n", __func__,
passwd, rig_passwd);
}
RETURNFUNC(RIG_OK);
}
@ -5112,7 +5118,7 @@ declare_proto_rig(password)
declare_proto_rig(set_password)
{
const char *passwd = arg1;
strncpy(rig_passwd, passwd, sizeof(passwd)-1);
strncpy(rig_passwd, passwd, sizeof(passwd) - 1);
rig_debug(RIG_DEBUG_ERR, "%s: set_password %s\n", __func__, rig_passwd);
fprintf(fout, "set_password %s\n", rig_passwd);
RETURNFUNC(RIG_OK);

4
tests/rigctld.c
Wyświetl plik

@ -963,7 +963,7 @@ int main(int argc, char *argv[])
sizeof(host),
serv,
sizeof(serv),
NI_NUMERICHOST|NI_NUMERICSERV))
NI_NUMERICHOST | NI_NUMERICSERV))
< 0)
{
rig_debug(RIG_DEBUG_WARN,
@ -1201,7 +1201,7 @@ void *handle_socket(void *arg)
sizeof(host),
serv,
sizeof(serv),
NI_NUMERICHOST|NI_NUMERICSERV))
NI_NUMERICHOST | NI_NUMERICSERV))
< 0)
{

4
tests/rotctld.c
Wyświetl plik

@ -598,7 +598,7 @@ int main(int argc, char *argv[])
sizeof(host),
serv,
sizeof(serv),
NI_NUMERICHOST|NI_NUMERICSERV))
NI_NUMERICHOST | NI_NUMERICSERV))
< 0)
{
@ -711,7 +711,7 @@ void *handle_socket(void *arg)
sizeof(host),
serv,
sizeof(serv),
NI_NUMERICHOST|NI_NUMERICSERV))
NI_NUMERICHOST | NI_NUMERICSERV))
< 0)
{

9
tests/testcookie.c
Wyświetl plik

@ -77,6 +77,7 @@ static int test2()
if (retcode == RIG_OK) { printf("Test#2e OK\n"); }
else {printf("Test#2e Failed\n"); return 1;}
return 0;
}
@ -85,21 +86,25 @@ static int test3_invalid_input()
{
int retcode;
char cookie[HAMLIB_COOKIE_SIZE];
/* Make sure any value smaller then HAMLIB_COOKIE_SIZE is rejected */
for(unsigned int i = 0; i < HAMLIB_COOKIE_SIZE; i++)
for (unsigned int i = 0; i < HAMLIB_COOKIE_SIZE; i++)
{
retcode = rig_cookie(NULL, RIG_COOKIE_GET, cookie, i);
if (retcode == -RIG_EINVAL) { printf("Test#3a OK\n"); }
else {printf("Test#3a Failed\n"); return 1;}
}
/* Make sure a NULL cookie is ignored */
retcode = rig_cookie(NULL, RIG_COOKIE_GET, NULL, sizeof(cookie));
if (retcode == -RIG_EINVAL) { printf("Test#3b OK\n"); }
else {printf("Test#3b Failed\n"); return 1;}
/* Make sure an invalid command is dropped with proto error */
retcode = rig_cookie(NULL, RIG_COOKIE_RENEW + 1, cookie, sizeof(cookie));
if (retcode == -RIG_EPROTO) { printf("Test#3c OK\n"); }
else {printf("Test#3c Failed\n"); return 1;}
@ -113,6 +118,7 @@ static int test4_large_cookie_size()
/* Using a larger cookie should also work */
retcode = rig_cookie(NULL, RIG_COOKIE_GET, cookie, sizeof(cookie));
if (retcode == RIG_OK) { printf("Test#4a OK\n"); }
else {printf("Test#4a Failed\n"); return 1;}
@ -122,6 +128,7 @@ static int test4_large_cookie_size()
/* Release the cookie again to clean up */
retcode = rig_cookie(NULL, RIG_COOKIE_RELEASE, cookie, sizeof(cookie));
if (retcode == RIG_OK) { printf("Test#4c OK\n"); }
else {printf("Test#4c Failed\n"); return 1;}