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

astyle files is preparation for 4.2 release

pull/614/head
Michael Black W9MDB 2021-03-15 17:51:22 -05:00
rodzic 288f82f963
commit 3bc39aaec1
21 zmienionych plików z 1707 dodań i 1591 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

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

@ -642,7 +642,8 @@ int aor_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
}
/* should be caught by the front end */
if ((val.i != 0) && (i >= HAMLIB_MAXDBLSTSIZ || RIG_IS_DBLST_END(rs->attenuator[i])))
if ((val.i != 0) && (i >= HAMLIB_MAXDBLSTSIZ
|| RIG_IS_DBLST_END(rs->attenuator[i])))
{
return -RIG_EINVAL;
}

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

@ -648,7 +648,8 @@ int sr2200_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
}
/* should be caught by the front end */
if ((val.i != 0) && (i >= HAMLIB_MAXDBLSTSIZ || RIG_IS_DBLST_END(rs->attenuator[i])))
if ((val.i != 0) && (i >= HAMLIB_MAXDBLSTSIZ
|| RIG_IS_DBLST_END(rs->attenuator[i])))
{
return -RIG_EINVAL;
}

39
rigs/dummy/dummy.c
Wyświetl plik

@ -396,15 +396,15 @@ static int dummy_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
rig_debug(RIG_DEBUG_VERBOSE, "%s called: %s %s\n", __func__,
rig_strvfo(vfo), fstr);
switch(vfo)
switch (vfo)
{
case RIG_VFO_MAIN:
case RIG_VFO_A: priv->vfo_a.freq = freq;break;
case RIG_VFO_MAIN:
case RIG_VFO_A: priv->vfo_a.freq = freq; break;
case RIG_VFO_SUB:
case RIG_VFO_B: priv->vfo_b.freq = freq;break;
case RIG_VFO_SUB:
case RIG_VFO_B: priv->vfo_b.freq = freq; break;
case RIG_VFO_C: priv->vfo_c.freq = freq;break;
case RIG_VFO_C: priv->vfo_c.freq = freq; break;
}
if (!priv->split)
@ -470,11 +470,11 @@ static int dummy_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
switch (vfo)
{
case RIG_VFO_A: priv->vfo_a.mode = mode; priv->vfo_a.width = width;break;
case RIG_VFO_A: priv->vfo_a.mode = mode; priv->vfo_a.width = width; break;
case RIG_VFO_B: priv->vfo_b.mode = mode; priv->vfo_b.width = width;break;
case RIG_VFO_B: priv->vfo_b.mode = mode; priv->vfo_b.width = width; break;
case RIG_VFO_C: priv->vfo_c.mode = mode; priv->vfo_c.width = width;break;
case RIG_VFO_C: priv->vfo_c.mode = mode; priv->vfo_c.width = width; break;
}
if (RIG_PASSBAND_NOCHANGE == width) { RETURNFUNC(RIG_OK); }
@ -483,6 +483,7 @@ static int dummy_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
width = curr->width = rig_passband_normal(rig, mode);
}
switch (vfo)
{
case RIG_VFO_A: priv->vfo_a.width = width; break;
@ -504,17 +505,17 @@ static int dummy_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
usleep(CMDSLEEP);
rig_debug(RIG_DEBUG_VERBOSE, "%s called: %s\n", __func__, rig_strvfo(vfo));
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_MAIN:
case RIG_VFO_A: *mode = priv->vfo_a.mode;*width = priv->vfo_a.width; break;
case RIG_VFO_MAIN:
case RIG_VFO_A: *mode = priv->vfo_a.mode; *width = priv->vfo_a.width; break;
case RIG_VFO_SUB:
case RIG_VFO_B: *mode = priv->vfo_b.mode;*width = priv->vfo_b.width; break;
case RIG_VFO_SUB:
case RIG_VFO_B: *mode = priv->vfo_b.mode; *width = priv->vfo_b.width; break;
case RIG_VFO_C: *mode = priv->vfo_c.mode;*width = priv->vfo_c.width; break;
case RIG_VFO_C: *mode = priv->vfo_c.mode; *width = priv->vfo_c.width; break;
}
RETURNFUNC(RIG_OK);
@ -530,7 +531,7 @@ static int dummy_set_vfo(RIG *rig, vfo_t vfo)
usleep(CMDSLEEP);
rig_debug(RIG_DEBUG_VERBOSE, "%s called: %s\n", __func__, rig_strvfo(vfo));
if (vfo == RIG_VFO_CURR) vfo = rig->state.current_vfo;
if (vfo == RIG_VFO_CURR) { vfo = rig->state.current_vfo; }
priv->last_vfo = priv->curr_vfo;
priv->curr_vfo = vfo;
@ -2122,7 +2123,7 @@ struct rig_caps dummy_caps =
.copyright = "LGPL",
.status = RIG_STATUS_STABLE,
.rig_type = RIG_TYPE_OTHER,
.targetable_vfo = RIG_TARGETABLE_PTT | RIG_TARGETABLE_RITXIT|RIG_TARGETABLE_FREQ|RIG_TARGETABLE_MODE,
.targetable_vfo = RIG_TARGETABLE_PTT | RIG_TARGETABLE_RITXIT | RIG_TARGETABLE_FREQ | RIG_TARGETABLE_MODE,
.ptt_type = RIG_PTT_RIG,
.dcd_type = RIG_DCD_RIG,
.port_type = RIG_PORT_NONE,
@ -2287,7 +2288,7 @@ struct rig_caps dummy_no_vfo_caps =
.copyright = "LGPL",
.status = RIG_STATUS_STABLE,
.rig_type = RIG_TYPE_OTHER,
.targetable_vfo = RIG_TARGETABLE_PTT | RIG_TARGETABLE_RITXIT|RIG_TARGETABLE_FREQ|RIG_TARGETABLE_MODE,
.targetable_vfo = RIG_TARGETABLE_PTT | RIG_TARGETABLE_RITXIT | RIG_TARGETABLE_FREQ | RIG_TARGETABLE_MODE,
.ptt_type = RIG_PTT_RIG,
.dcd_type = RIG_DCD_RIG,
.port_type = RIG_PORT_NONE,

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

Plik diff jest za duży Load Diff

2
rigs/dummy/flrig.h
Wyświetl plik

@ -28,7 +28,7 @@
#include <sys/time.h>
#endif
#define BACKEND_VER "20210312"
#define BACKEND_VER "20210315"
#define EOM "\r"
#define TRUE 1

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

@ -526,13 +526,15 @@ static int netrigctl_open(RIG *rig)
gran_t parm_gran[RIG_SETTING_MAX]; /*!< parm granularity */
#endif
for (i = 0; i < HAMLIB_FRQRANGESIZ && !RIG_IS_FRNG_END(rs->rx_range_list[i]); i++)
for (i = 0; i < HAMLIB_FRQRANGESIZ
&& !RIG_IS_FRNG_END(rs->rx_range_list[i]); i++)
{
rs->mode_list |= rs->rx_range_list[i].modes;
rs->vfo_list |= rs->rx_range_list[i].vfo;
}
for (i = 0; i < HAMLIB_FRQRANGESIZ && !RIG_IS_FRNG_END(rs->tx_range_list[i]); i++)
for (i = 0; i < HAMLIB_FRQRANGESIZ
&& !RIG_IS_FRNG_END(rs->tx_range_list[i]); i++)
{
rs->mode_list |= rs->tx_range_list[i].modes;
rs->vfo_list |= rs->tx_range_list[i].vfo;

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

@ -279,17 +279,21 @@ int icom_one_transaction(RIG *rig, int cmd, int subcmd,
}
if (frm_len < ACKFRMLEN) { RETURNFUNC(-RIG_EPROTO); }
// if we send a bad command we will get back a NAK packet
// e.g. fe fe e0 50 fa fd
if (frm_len == 6 && NAK == buf[frm_len - 2]) { RETURNFUNC(-RIG_ERJCTED); }
rig_debug(RIG_DEBUG_TRACE, "%s: frm_len=%d, frm_len-1=%02x, frm_len-2=%02x\n", __func__, frm_len, buf[frm_len-1], buf[frm_len-2]);
rig_debug(RIG_DEBUG_TRACE, "%s: frm_len=%d, frm_len-1=%02x, frm_len-2=%02x\n",
__func__, frm_len, buf[frm_len - 1], buf[frm_len - 2]);
// has to be one of these two now or frame is corrupt
if (FI != buf[frm_len - 1] && ACK != buf[frm_len - 1]) { RETURNFUNC(-RIG_BUSBUSY); }
*data_len = frm_len - (ACKFRMLEN - 1);
if (*data_len <= 0) { RETURNFUNC(-RIG_EPROTO); }
memcpy(data, buf + 4, *data_len);
/*

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

@ -1024,7 +1024,7 @@ int icom_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
subcmd = -1;
retval = icom_transaction(rig, cmd, subcmd, freqbuf, freq_len, ackbuf,
&ack_len);
hl_usleep(50*1000); // pause for transceive message and we'll flush it
hl_usleep(50 * 1000); // pause for transceive message and we'll flush it
if (retval != RIG_OK)
{
@ -1663,8 +1663,8 @@ int icom_set_mode_with_data(RIG *rig, vfo_t vfo, rmode_t mode,
rig_debug(RIG_DEBUG_VERBOSE, "%s mode=%d, width=%d\n", __func__, (int)icom_mode,
(int)width);
retval = icom_set_mode(rig, vfo, icom_mode, width);
hl_usleep(50*1000); // pause for possible transceive message which we'll flush
hl_usleep(50 * 1000); // pause for possible transceive message which we'll flush
if (RIG_OK == retval)
{
@ -3204,13 +3204,16 @@ int icom_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
val->f =
rig_raw2val_float(icom_val, &icom_default_rfpower_meter_cal);
rig_debug(RIG_DEBUG_TRACE, "%s: using rig table to convert %d to %.01f\n", __func__, icom_val, val->f);
rig_debug(RIG_DEBUG_TRACE, "%s: using rig table to convert %d to %.01f\n",
__func__, icom_val, val->f);
}
else
{
val->f =
rig_raw2val_float(icom_val, &rig->caps->rfpower_meter_cal);
rig_debug(RIG_DEBUG_TRACE, "%s: using default icom table to convert %d to %.01f\n", __func__, icom_val, val->f);
rig_debug(RIG_DEBUG_TRACE,
"%s: using default icom table to convert %d to %.01f\n", __func__, icom_val,
val->f);
}
break;

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

@ -877,6 +877,7 @@ int powersdr_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
case RIG_LEVEL_AF:
n = sscanf(lvlbuf, "ZZAG%f", &val->f);
if (n != 1)
{
rig_debug(RIG_DEBUG_ERR, "%s: Error parsing value from lvlbuf='%s'\n",
@ -884,6 +885,7 @@ int powersdr_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
val->f = 0;
return -RIG_EPROTO;
}
val->f /= 100.0;
break;

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

@ -1101,7 +1101,7 @@ int k3_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
switch (mode)
{
case RIG_MODE_PKTLSB:
case RIG_MODE_PKTLSB:
mode = RIG_MODE_RTTY; // in "DT0" Subband RIG_MODE_RTTYR = USB and RIG_MODE_RTTY = LSB
snprintf(cmd_m, sizeof(cmd_m),
"DT0"); /* DATA A mode - DATA (REV) on LSB optimized for HF Packet, VFO dial is suppressed carrier QRG */
@ -1485,7 +1485,7 @@ int k3_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width)
"DT2"); /* FSK D mode - direct FSK on USB optimized for RTTY, VFO dial is MARK */
break;
case RIG_MODE_PSK:
case RIG_MODE_PSK:
tx_mode = RIG_MODE_PSK;
snprintf(cmd_m, sizeof(cmd_m),
"DT3"); /* PSK D Mode - direct PSK keying, USB is "normal", VFO dial is MARK */

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

@ -1001,8 +1001,8 @@ static int kenwood_get_if(RIG *rig)
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
return(kenwood_safe_transaction(rig, "IF", priv->info,
KENWOOD_MAX_BUF_LEN, caps->if_len));
return (kenwood_safe_transaction(rig, "IF", priv->info,
KENWOOD_MAX_BUF_LEN, caps->if_len));
}
@ -3752,6 +3752,7 @@ int kenwood_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
default: RETURNFUNC(-RIG_EINVAL);
}
int retval = kenwood_transaction(rig, ptt_cmd, NULL, 0);
RETURNFUNC(retval);
@ -4573,25 +4574,25 @@ const char *kenwood_get_info(RIG *rig)
if (!rig)
{
return("*rig == NULL");
return ("*rig == NULL");
}
retval = kenwood_safe_transaction(rig, "TY", firmbuf, 10, 5);
if (retval != RIG_OK)
{
return(NULL);
return (NULL);
}
switch (firmbuf[4])
{
case '0': return("Firmware: Overseas type");
case '0': return ("Firmware: Overseas type");
case '1': return("Firmware: Japanese 100W type");
case '1': return ("Firmware: Japanese 100W type");
case '2': return("Firmware: Japanese 20W type");
case '2': return ("Firmware: Japanese 20W type");
default: return("Firmware: unknown");
default: return ("Firmware: unknown");
}
}

3
rigs/kit/hiqsdr.c
Wyświetl plik

@ -307,7 +307,8 @@ int hiqsdr_init(RIG *rig)
priv->split = RIG_SPLIT_OFF;
priv->ref_clock = REFCLOCK;
priv->sample_rate = DEFAULT_SAMPLE_RATE;
strncpy(rig->state.rigport.pathname, "192.168.2.196:48248", HAMLIB_FILPATHLEN - 1);
strncpy(rig->state.rigport.pathname, "192.168.2.196:48248",
HAMLIB_FILPATHLEN - 1);
return RIG_OK;
}

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

@ -46,7 +46,8 @@
int wr_rig_init(RIG *rig)
{
rig->state.rigport.type.rig = RIG_PORT_DEVICE;
strncpy(rig->state.rigport.pathname, DEFAULT_WINRADIO_PATH, HAMLIB_FILPATHLEN - 1);
strncpy(rig->state.rigport.pathname, DEFAULT_WINRADIO_PATH,
HAMLIB_FILPATHLEN - 1);
return RIG_OK;
}

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

@ -1167,7 +1167,9 @@ int ft1000mp_get_vfo(RIG *rig, vfo_t *vfo)
else // we are emulating vfo status
{
*vfo = rig->state.current_vfo;
if (*vfo == RIG_VFO_CURR) {
if (*vfo == RIG_VFO_CURR)
{
rig_debug(RIG_DEBUG_TRACE, "%s: no get_vfo, defaulting to VFOA\n", __func__);
*vfo = RIG_VFO_A;
}

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

@ -510,7 +510,8 @@ int newcat_open(RIG *rig)
ENTERFUNC;
rig_debug(RIG_DEBUG_TRACE, "%s: Rig=%s, version=%s\n", __func__, rig->caps->model_name, rig->caps->version);
rig_debug(RIG_DEBUG_TRACE, "%s: Rig=%s, version=%s\n", __func__,
rig->caps->model_name, rig->caps->version);
rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
__func__, rig_s->rigport.write_delay);
@ -597,6 +598,7 @@ int newcat_close(RIG *rig)
case it's not
supported */
}
if (priv->poweron != 0 && rig_s->auto_power_off)
{
rig_set_powerstat(rig, 0);
@ -3182,7 +3184,8 @@ int newcat_set_powerstat(RIG *rig, powerstat_t status)
rig_debug(RIG_DEBUG_TRACE, "%s: Wait #%d for power up\n", __func__, i + 1);
retval = write_block(&state->rigport, priv->cmd_str, strlen(priv->cmd_str));
if (retval != RIG_OK) RETURNFUNC(retval);
if (retval != RIG_OK) { RETURNFUNC(retval); }
}
}
@ -3471,7 +3474,8 @@ int newcat_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
fpf = newcat_scale_float(scale, val.f);
if (is_ft950 || is_ft891 || is_ft991 || is_ftdx3000 || is_ftdx101d || is_ftdx101mp || is_ftdx10)
if (is_ft950 || is_ft891 || is_ft991 || is_ftdx3000 || is_ftdx101d
|| is_ftdx101mp || is_ftdx10)
{
// Minimum is 5 watts on these rigs
if (fpf < 5)
@ -3661,7 +3665,8 @@ int newcat_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
if (val.f > 1.0) { RETURNFUNC(-RIG_EINVAL); }
if (is_ftdx1200 || is_ftdx3000 || is_ft891 || is_ft991 || is_ftdx101d || is_ftdx101mp
if (is_ftdx1200 || is_ftdx3000 || is_ft891 || is_ft991 || is_ftdx101d
|| is_ftdx101mp
|| is_ftdx10)
{
fpf = newcat_scale_float(100, val.f);
@ -3691,7 +3696,8 @@ int newcat_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx101d || is_ftdx101mp) // new format for the command with VFO selection
if (is_ftdx101d
|| is_ftdx101mp) // new format for the command with VFO selection
{
format = "MS0%d;";
@ -4216,7 +4222,8 @@ int newcat_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
if (val.f > 1.0) { RETURNFUNC(-RIG_EINVAL); }
if (is_ftdx1200 || is_ftdx3000 || is_ft891 || is_ft991 || is_ftdx101d || is_ftdx101mp
if (is_ftdx1200 || is_ftdx3000 || is_ft891 || is_ft991 || is_ftdx101d
|| is_ftdx101mp
|| is_ftdx10)
{
fpf = newcat_scale_float(100, val.f);
@ -4859,7 +4866,8 @@ int newcat_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break;
case RIG_LEVEL_MICGAIN:
if (is_ftdx1200 || is_ftdx3000 || is_ft891 || is_ft991 || is_ftdx101d || is_ftdx101mp
if (is_ftdx1200 || is_ftdx3000 || is_ft891 || is_ft991 || is_ftdx101d
|| is_ftdx101mp
|| is_ftdx10)
{
scale = 100.;
@ -5171,7 +5179,8 @@ int newcat_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break;
case RIG_LEVEL_MONITOR_GAIN:
if (is_ftdx1200 || is_ftdx3000 || is_ft891 || is_ft991 || is_ftdx101d || is_ftdx101mp)
if (is_ftdx1200 || is_ftdx3000 || is_ft891 || is_ft991 || is_ftdx101d
|| is_ftdx101mp)
{
scale = 100.;
}
@ -5422,7 +5431,8 @@ int newcat_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
newcat_get_mode(rig, vfo, &mode, &width);
}
if (is_ft891 || is_ft991 || is_ftdx1200 || is_ftdx3000 || is_ftdx101d || is_ftdx101mp)
if (is_ft891 || is_ft991 || is_ftdx1200 || is_ftdx3000 || is_ftdx101d
|| is_ftdx101mp)
{
// There seems to be an error in the manuals for some of these rigs stating that values should be 1 = OFF and 2 = ON, but they are 0 = OFF and 1 = ON instead
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "PR0%d%c", status ? 1 : 0,
@ -5662,7 +5672,8 @@ int newcat_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
RETURNFUNC(-RIG_ENAVAIL);
}
if (is_ftdx1200 || is_ftdx3000 || is_ft891 || is_ft991 || is_ftdx101d || is_ftdx101mp)
if (is_ftdx1200 || is_ftdx3000 || is_ft891 || is_ft991 || is_ftdx101d
|| is_ftdx101mp)
{
snprintf(priv->cmd_str, sizeof(priv->cmd_str), "PR0%c", cat_term);
}
@ -6567,13 +6578,13 @@ const char *newcat_get_info(RIG *rig)
/* Get Identification Channel */
if (RIG_OK != newcat_get_cmd(rig))
{
return(NULL);
return (NULL);
}
priv->ret_data[6] = '\0';
snprintf(idbuf, sizeof(idbuf), "%s", priv->ret_data);
return(idbuf);
return (idbuf);
}
@ -6623,7 +6634,8 @@ ncboolean newcat_valid_command(RIG *rig, char const *const command)
is_ftdx10 = newcat_is_rig(rig, RIG_MODEL_FTDX10);
if (!is_ft450 && !is_ft950 && !is_ft891 && !is_ft991 && !is_ft2000
&& !is_ftdx5000 && !is_ftdx9000 && !is_ftdx1200 && !is_ftdx3000 && !is_ftdx101d && !is_ftdx101mp && !is_ftdx10)
&& !is_ftdx5000 && !is_ftdx9000 && !is_ftdx1200 && !is_ftdx3000 && !is_ftdx101d
&& !is_ftdx101mp && !is_ftdx10)
{
rig_debug(RIG_DEBUG_ERR, "%s: '%s' is unknown\n", __func__, caps->model_name);
RETURNFUNC(FALSE);
@ -9689,7 +9701,7 @@ int newcat_set_cmd_validate(RIG *rig)
// For FA and FB rig.c now tries to verify the set_freq actually works
// For example the FT-2000 can't do a FA set followed by an immediate read
// We were using "ID" to verify the command but rig.c now does
// We were using "ID" to verify the command but rig.c now does
// a verifcation of frequency and retries if it doesn't match
if ((strncmp(priv->cmd_str, "FA", 2) == 0) && (strlen(priv->cmd_str) > 3))
{

241
src/rig.c
Wyświetl plik

@ -311,8 +311,9 @@ const char *HAMLIB_API rigerror(int errnum)
if (*p == '\n') { *p = 0; }
snprintf(msg, sizeof(msg), "%.80s\n%.15000s%.15000s%.15000s", rigerror_table[errnum],
debugmsgsave3,debugmsgsave2, debugmsgsave);
snprintf(msg, sizeof(msg), "%.80s\n%.15000s%.15000s%.15000s",
rigerror_table[errnum],
debugmsgsave3, debugmsgsave2, debugmsgsave);
return msg;
}
@ -375,7 +376,7 @@ RIG *HAMLIB_API rig_init(rig_model_t rig_model)
if (!caps)
{
return(NULL);
return (NULL);
}
/*
@ -390,7 +391,7 @@ RIG *HAMLIB_API rig_init(rig_model_t rig_model)
* FIXME: how can the caller know it's a memory shortage,
* and not "rig not found" ?
*/
return(NULL);
return (NULL);
}
/* caps is const, so we need to tell compiler
@ -518,25 +519,29 @@ RIG *HAMLIB_API rig_init(rig_model_t rig_model)
rs->vfo_list = 0;
rs->mode_list = 0;
for (i = 0; i < HAMLIB_FRQRANGESIZ && !RIG_IS_FRNG_END(caps->rx_range_list1[i]); i++)
for (i = 0; i < HAMLIB_FRQRANGESIZ
&& !RIG_IS_FRNG_END(caps->rx_range_list1[i]); i++)
{
rs->vfo_list |= caps->rx_range_list1[i].vfo;
rs->mode_list |= caps->rx_range_list1[i].modes;
}
for (i = 0; i < HAMLIB_FRQRANGESIZ && !RIG_IS_FRNG_END(caps->tx_range_list1[i]); i++)
for (i = 0; i < HAMLIB_FRQRANGESIZ
&& !RIG_IS_FRNG_END(caps->tx_range_list1[i]); i++)
{
rs->vfo_list |= caps->tx_range_list1[i].vfo;
rs->mode_list |= caps->tx_range_list1[i].modes;
}
for (i = 0; i < HAMLIB_FRQRANGESIZ && !RIG_IS_FRNG_END(caps->rx_range_list2[i]); i++)
for (i = 0; i < HAMLIB_FRQRANGESIZ
&& !RIG_IS_FRNG_END(caps->rx_range_list2[i]); i++)
{
rs->vfo_list |= caps->rx_range_list2[i].vfo;
rs->mode_list |= caps->rx_range_list2[i].modes;
}
for (i = 0; i < HAMLIB_FRQRANGESIZ && !RIG_IS_FRNG_END(caps->tx_range_list2[i]); i++)
for (i = 0; i < HAMLIB_FRQRANGESIZ
&& !RIG_IS_FRNG_END(caps->tx_range_list2[i]); i++)
{
rs->vfo_list |= caps->tx_range_list2[i].vfo;
rs->mode_list |= caps->tx_range_list2[i].modes;
@ -613,11 +618,11 @@ RIG *HAMLIB_API rig_init(rig_model_t rig_model)
__func__);
/* cleanup and exit */
free(rig);
return(NULL);
return (NULL);
}
}
return(rig);
return (rig);
}
@ -1324,13 +1329,16 @@ int HAMLIB_API rig_get_twiddle(RIG *rig, int *seconds)
static int set_cache_mode(RIG *rig, vfo_t vfo, mode_t mode, pbwidth_t width)
{
ENTERFUNC;
if (vfo == RIG_VFO_CURR)
{
// if CURR then update this before we figure out the real VFO
vfo = rig->state.current_vfo;
}
// pick a sane default
if (vfo == RIG_VFO_NONE || vfo == RIG_VFO_CURR) vfo = RIG_VFO_A;
if (vfo == RIG_VFO_NONE || vfo == RIG_VFO_CURR) { vfo = RIG_VFO_A; }
switch (vfo)
{
case RIG_VFO_ALL: // we'll use NONE to reset all VFO caches
@ -1341,29 +1349,39 @@ static int set_cache_mode(RIG *rig, vfo_t vfo, mode_t mode, pbwidth_t width)
elapsed_ms(&rig->state.cache.time_widthMainB, HAMLIB_ELAPSED_INVALIDATE);
elapsed_ms(&rig->state.cache.time_widthMainC, HAMLIB_ELAPSED_INVALIDATE);
break;
case RIG_VFO_A:
case RIG_VFO_MAIN:
case RIG_VFO_MAIN_A:
rig->state.cache.modeMainA = mode;
if (width > 0) rig->state.cache.widthMainA = width;
if (width > 0) { rig->state.cache.widthMainA = width; }
elapsed_ms(&rig->state.cache.time_modeMainA, HAMLIB_ELAPSED_SET);
elapsed_ms(&rig->state.cache.time_widthMainA, HAMLIB_ELAPSED_SET);
break;
case RIG_VFO_B:
case RIG_VFO_SUB:
case RIG_VFO_MAIN_B:
rig->state.cache.modeMainB = mode;
if (width > 0) rig->state.cache.widthMainB = width;
if (width > 0) { rig->state.cache.widthMainB = width; }
elapsed_ms(&rig->state.cache.time_modeMainB, HAMLIB_ELAPSED_SET);
elapsed_ms(&rig->state.cache.time_widthMainB, HAMLIB_ELAPSED_SET);
break;
case RIG_VFO_C:
case RIG_VFO_MAIN_C:
rig->state.cache.modeMainC = mode;
if (width > 0) rig->state.cache.widthMainC = width;
if (width > 0) { rig->state.cache.widthMainC = width; }
elapsed_ms(&rig->state.cache.time_modeMainC, HAMLIB_ELAPSED_SET);
elapsed_ms(&rig->state.cache.time_widthMainC, HAMLIB_ELAPSED_SET);
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unknown vfo=%s\n", __func__, rig_strvfo(vfo));
RETURNFUNC(-RIG_EINTERNAL);
@ -1383,8 +1401,9 @@ static int set_cache_freq(RIG *rig, vfo_t vfo, freq_t freq)
// if CURR then update this before we figure out the real VFO
vfo = rig->state.current_vfo;
}
// pick a sane default
if (vfo == RIG_VFO_NONE || vfo == RIG_VFO_CURR) vfo = RIG_VFO_A;
if (vfo == RIG_VFO_NONE || vfo == RIG_VFO_CURR) { vfo = RIG_VFO_A; }
rig_debug(RIG_DEBUG_TRACE, "%s: set vfo=%s to freq=%.0f\n", __func__,
rig_strvfo(vfo), freq);
@ -1459,13 +1478,15 @@ static int set_cache_freq(RIG *rig, vfo_t vfo, freq_t freq)
RETURNFUNC(RIG_OK);
}
int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq, rmode_t *mode, int *cache_ms_mode, pbwidth_t *width, int *cache_ms_width)
int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq,
rmode_t *mode, int *cache_ms_mode, pbwidth_t *width, int *cache_ms_width)
{
ENTERFUNC;
rig_debug(RIG_DEBUG_TRACE, "%s: vfo=%s, current_vfo=%s\n", __func__,
rig_strvfo(vfo), rig_strvfo(rig->state.current_vfo));
if (vfo == RIG_VFO_CURR) { vfo = rig->state.current_vfo; }
// pick a sane default
if (vfo == RIG_VFO_CURR || vfo == RIG_VFO_NONE) { vfo = RIG_VFO_A; }
@ -1478,9 +1499,12 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq, rmode_t
*freq = rig->state.cache.freqMainA;
*mode = rig->state.cache.modeMainA;
*width = rig->state.cache.widthMainA;
*cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqMainA, HAMLIB_ELAPSED_GET);
*cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeMainA, HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthMainA, HAMLIB_ELAPSED_GET);
*cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqMainA,
HAMLIB_ELAPSED_GET);
*cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeMainA,
HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthMainA,
HAMLIB_ELAPSED_GET);
break;
case RIG_VFO_B:
@ -1488,27 +1512,36 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq, rmode_t
*freq = rig->state.cache.freqMainB;
*mode = rig->state.cache.modeMainB;
*width = rig->state.cache.widthMainB;
*cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqMainB, HAMLIB_ELAPSED_GET);
*cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeMainB, HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthMainB, HAMLIB_ELAPSED_GET);
*cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqMainB,
HAMLIB_ELAPSED_GET);
*cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeMainB,
HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthMainB,
HAMLIB_ELAPSED_GET);
break;
case RIG_VFO_SUB_A:
*freq = rig->state.cache.freqSubA;
*mode = rig->state.cache.modeSubA;
*width = rig->state.cache.widthSubA;
*cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqSubA, HAMLIB_ELAPSED_GET);
*cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeSubA, HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthSubA, HAMLIB_ELAPSED_GET);
*cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqSubA,
HAMLIB_ELAPSED_GET);
*cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeSubA,
HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthSubA,
HAMLIB_ELAPSED_GET);
break;
case RIG_VFO_SUB_B:
*freq = rig->state.cache.freqSubB;
*mode = rig->state.cache.modeSubB;
*width = rig->state.cache.widthSubB;
*cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqSubB, HAMLIB_ELAPSED_GET);
*cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeSubB, HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthSubB, HAMLIB_ELAPSED_GET);
*cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqSubB,
HAMLIB_ELAPSED_GET);
*cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeSubB,
HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthSubB,
HAMLIB_ELAPSED_GET);
break;
case RIG_VFO_C:
@ -1516,18 +1549,24 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq, rmode_t
*freq = rig->state.cache.freqMainC;
*mode = rig->state.cache.modeMainC;
*width = rig->state.cache.widthMainC;
*cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqMainC, HAMLIB_ELAPSED_GET);
*cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeMainC, HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthMainC, HAMLIB_ELAPSED_GET);
*cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqMainC,
HAMLIB_ELAPSED_GET);
*cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeMainC,
HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthMainC,
HAMLIB_ELAPSED_GET);
break;
case RIG_VFO_SUB_C:
*freq = rig->state.cache.freqSubC;
*mode = rig->state.cache.modeSubC;
*width = rig->state.cache.widthSubC;
*cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqSubC, HAMLIB_ELAPSED_GET);
*cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeSubC, HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthSubC, HAMLIB_ELAPSED_GET);
*cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqSubC,
HAMLIB_ELAPSED_GET);
*cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeSubC,
HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthSubC,
HAMLIB_ELAPSED_GET);
break;
case RIG_VFO_MEM:
@ -1536,7 +1575,8 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq, rmode_t
*width = rig->state.cache.widthMem;
*cache_ms_freq = elapsed_ms(&rig->state.cache.time_freqMem, HAMLIB_ELAPSED_GET);
*cache_ms_mode = elapsed_ms(&rig->state.cache.time_modeMem, HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthMem, HAMLIB_ELAPSED_GET);
*cache_ms_width = elapsed_ms(&rig->state.cache.time_widthMem,
HAMLIB_ELAPSED_GET);
break;
default:
@ -1694,7 +1734,9 @@ int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
if (retry == 0 && tfreq != freq)
{
rig_debug(RIG_DEBUG_ERR, "%s: unable to set frequency!!, asked for %.0f, got %.0f\n", __func__, freq, tfreq);
rig_debug(RIG_DEBUG_ERR,
"%s: unable to set frequency!!, asked for %.0f, got %.0f\n", __func__, freq,
tfreq);
}
}
else
@ -1774,6 +1816,7 @@ int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
// update our current freq too
if (vfo == RIG_VFO_CURR || vfo == rig->state.current_vfo) { rig->state.current_freq = freq_new; }
set_cache_freq(rig, vfo, freq_new);
RETURNFUNC(retcode);
@ -1831,7 +1874,8 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
rig_strvfo(rig->state.tx_vfo));
// always return the cached freq for this clause
int cache_ms_freq, cache_ms_mode, cache_ms_width;
rig_get_cache(rig, vfo, freq, &cache_ms_freq, &mode, &cache_ms_mode, &width, &cache_ms_width);
rig_get_cache(rig, vfo, freq, &cache_ms_freq, &mode, &cache_ms_mode, &width,
&cache_ms_width);
RETURNFUNC(RIG_OK);
}
@ -1862,8 +1906,10 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
}
int cache_ms_freq, cache_ms_mode, cache_ms_width;
rig_get_cache(rig, vfo, freq, &cache_ms_freq, &mode, &cache_ms_mode, &width, &cache_ms_width);
rig_debug(RIG_DEBUG_TRACE, "%s: cache check1 age=%dms\n", __func__, cache_ms_freq);
rig_get_cache(rig, vfo, freq, &cache_ms_freq, &mode, &cache_ms_mode, &width,
&cache_ms_width);
rig_debug(RIG_DEBUG_TRACE, "%s: cache check1 age=%dms\n", __func__,
cache_ms_freq);
if (freq != 0 && cache_ms_freq < rig->state.cache.timeout_ms)
{
@ -1874,7 +1920,8 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
else
{
rig_debug(RIG_DEBUG_TRACE,
"%s: cache miss age=%dms, cached_vfo=%s, asked_vfo=%s\n", __func__, cache_ms_freq,
"%s: cache miss age=%dms, cached_vfo=%s, asked_vfo=%s\n", __func__,
cache_ms_freq,
rig_strvfo(vfo), rig_strvfo(vfo));
}
@ -1900,13 +1947,14 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
retcode = caps->get_freq(rig, vfo, freq);
// sometimes a network rig like FLRig will return freq=0
// sometimes a network rig like FLRig will return freq=0
// so we'll just reuse the cache for that condition
if (*freq == 0) {
if (*freq == 0)
{
rmode_t mode;
pbwidth_t width;
int freq_ms,mode_ms,width_ms;
rig_get_cache(rig,vfo,freq,&freq_ms,&mode,&mode_ms,&width,&width_ms);
int freq_ms, mode_ms, width_ms;
rig_get_cache(rig, vfo, freq, &freq_ms, &mode, &mode_ms, &width, &width_ms);
}
if (retcode == RIG_OK)
@ -2033,7 +2081,8 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
|| vfo == rig->state.current_vfo)
{
retcode = caps->set_mode(rig, vfo, mode, width);
rig_debug(RIG_DEBUG_TRACE, "%s: targetable retcode after set_mode=%d\n", __func__,
rig_debug(RIG_DEBUG_TRACE, "%s: targetable retcode after set_mode=%d\n",
__func__,
retcode);
}
else
@ -2042,6 +2091,7 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
vfo_t curr_vfo;
rig_debug(RIG_DEBUG_TRACE, "%s: not targetable need vfo swap\n", __func__);
if (!caps->set_vfo)
{
RETURNFUNC(-RIG_ENAVAIL);
@ -2066,10 +2116,10 @@ int HAMLIB_API rig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
}
}
if (retcode != RIG_OK) RETURNFUNC(retcode);
if (retcode != RIG_OK) { RETURNFUNC(retcode); }
set_cache_mode(rig, vfo, mode, width);
set_cache_mode(rig,vfo,mode,width);
RETURNFUNC(retcode);
}
@ -2117,19 +2167,23 @@ int HAMLIB_API rig_get_mode(RIG *rig,
}
int cache_ms_freq, cache_ms_mode, cache_ms_width;
rig_get_cache(rig, vfo, &freq, &cache_ms_freq, mode, &cache_ms_mode, width, &cache_ms_width);
rig_get_cache(rig, vfo, &freq, &cache_ms_freq, mode, &cache_ms_mode, width,
&cache_ms_width);
rig_debug(RIG_DEBUG_TRACE, "%s: %s cache check age=%dms\n", __func__,
rig_strvfo(vfo), cache_ms_freq);
if (cache_ms_mode < rig->state.cache.timeout_ms || cache_ms_width < rig->state.cache.timeout_ms)
if (cache_ms_mode < rig->state.cache.timeout_ms
|| cache_ms_width < rig->state.cache.timeout_ms)
{
rig_debug(RIG_DEBUG_TRACE, "%s: cache hit age mode=%dms, width=%dms\n", __func__, cache_ms_mode, cache_ms_width);
rig_debug(RIG_DEBUG_TRACE, "%s: cache hit age mode=%dms, width=%dms\n",
__func__, cache_ms_mode, cache_ms_width);
RETURNFUNC(RIG_OK);
}
else
{
rig_debug(RIG_DEBUG_TRACE, "%s: cache miss age mode=%dms, width=%dms\n", __func__, cache_ms_mode, cache_ms_width);
rig_debug(RIG_DEBUG_TRACE, "%s: cache miss age mode=%dms, width=%dms\n",
__func__, cache_ms_mode, cache_ms_width);
}
if ((caps->targetable_vfo & RIG_TARGETABLE_MODE)
@ -2184,7 +2238,7 @@ int HAMLIB_API rig_get_mode(RIG *rig,
*width = rig_passband_normal(rig, *mode);
}
set_cache_mode(rig,vfo,*mode,*width);
set_cache_mode(rig, vfo, *mode, *width);
RETURNFUNC(retcode);
}
@ -2425,8 +2479,9 @@ int HAMLIB_API rig_set_vfo(RIG *rig, vfo_t vfo)
rigerror(retcode));
}
else
{ // if no get_freq clear all cache to be sure we refresh whatever we can
set_cache_freq(rig, RIG_VFO_ALL, (freq_t)0);
{
// if no get_freq clear all cache to be sure we refresh whatever we can
set_cache_freq(rig, RIG_VFO_ALL, (freq_t)0);
}
// expire several cached items when we switch VFOs
@ -2576,7 +2631,7 @@ int HAMLIB_API rig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
if (retcode != RIG_OK) { RETURNFUNC(retcode); }
hl_usleep(50*1000); // give PTT a chance to do it's thing
hl_usleep(50 * 1000); // give PTT a chance to do it's thing
// don't use the cached value and check to see if it worked
elapsed_ms(&rig->state.cache.time_ptt, HAMLIB_ELAPSED_INVALIDATE);
@ -3037,7 +3092,7 @@ int HAMLIB_API rig_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->get_dcd(rig, vfo, dcd));
}
@ -3138,7 +3193,7 @@ int HAMLIB_API rig_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->set_rptr_shift(rig, vfo, rptr_shift));
}
@ -3205,7 +3260,7 @@ int HAMLIB_API rig_get_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->get_rptr_shift(rig, vfo, rptr_shift));
}
@ -3272,7 +3327,7 @@ int HAMLIB_API rig_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->set_rptr_offs(rig, vfo, rptr_offs));
}
@ -3339,7 +3394,7 @@ int HAMLIB_API rig_get_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->get_rptr_offs(rig, vfo, rptr_offs));
}
@ -3900,10 +3955,13 @@ int HAMLIB_API rig_set_split_freq_mode(RIG *rig,
{
retcode = caps->set_split_freq_mode(rig, vfo, tx_freq, tx_mode, tx_width);
retcode2 = rig_get_split_freq(rig, vfo, &tfreq);
if (tfreq != tx_freq)
{
rig_debug(RIG_DEBUG_ERR, "%s: txfreq!=tfreq %.0f!=%.0f, retry=%d, rc1=%d, rc2=%d\n", __func__, tx_freq, tfreq, retry, retcode, retcode2);
hl_usleep(50*1000); // 50ms sleep may help here
rig_debug(RIG_DEBUG_ERR,
"%s: txfreq!=tfreq %.0f!=%.0f, retry=%d, rc1=%d, rc2=%d\n", __func__, tx_freq,
tfreq, retry, retcode, retcode2);
hl_usleep(50 * 1000); // 50ms sleep may help here
}
}
while (tfreq != tx_freq && retry-- > 0 && retcode == RIG_OK
@ -4027,7 +4085,7 @@ int HAMLIB_API rig_set_split_vfo(RIG *rig,
vfo = vfo_fixup(rig, vfo);
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
retcode = caps->set_split_vfo(rig, vfo, split, tx_vfo);
@ -4142,7 +4200,7 @@ int HAMLIB_API rig_get_split_vfo(RIG *rig,
*tx_vfo = rig->state.tx_vfo;
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
retcode = caps->get_split_vfo(rig, vfo, split, tx_vfo);
rig->state.cache.split = *split;
@ -4498,7 +4556,7 @@ int HAMLIB_API rig_set_ts(RIG *rig, vfo_t vfo, shortfreq_t ts)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->set_ts(rig, vfo, ts));
}
@ -4565,7 +4623,7 @@ int HAMLIB_API rig_get_ts(RIG *rig, vfo_t vfo, shortfreq_t *ts)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->get_ts(rig, vfo, ts));
}
@ -4831,12 +4889,12 @@ int HAMLIB_API rig_mW2power(RIG *rig,
if (!rig || !rig->caps || !power || mwpower == 0)
{
return(-RIG_EINVAL);
return (-RIG_EINVAL);
}
if (rig->caps->mW2power != NULL)
{
return(rig->caps->mW2power(rig, power, mwpower, freq, mode));
return (rig->caps->mW2power(rig, power, mwpower, freq, mode));
}
txrange = rig_get_range(rig->state.tx_range_list, freq, mode);
@ -4846,13 +4904,13 @@ int HAMLIB_API rig_mW2power(RIG *rig,
/*
* freq is not on the tx range!
*/
return(-RIG_ECONF); /* could be RIG_EINVAL ? */
return (-RIG_ECONF); /* could be RIG_EINVAL ? */
}
if (txrange->high_power == 0)
{
*power = 0.0;
return(RIG_OK);
return (RIG_OK);
}
*power = (float)mwpower / txrange->high_power;
@ -4862,7 +4920,7 @@ int HAMLIB_API rig_mW2power(RIG *rig,
*power = 1.0;
}
return(mwpower > txrange->high_power ? RIG_OK : -RIG_ETRUNC);
return (mwpower > txrange->high_power ? RIG_OK : -RIG_ETRUNC);
}
@ -5134,7 +5192,7 @@ int HAMLIB_API rig_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->vfo_op(rig, vfo, op));
}
@ -5233,7 +5291,7 @@ int HAMLIB_API rig_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->scan(rig, vfo, scan, ch));
}
@ -5300,7 +5358,7 @@ int HAMLIB_API rig_send_dtmf(RIG *rig, vfo_t vfo, const char *digits)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->send_dtmf(rig, vfo, digits));
}
@ -5368,7 +5426,7 @@ int HAMLIB_API rig_recv_dtmf(RIG *rig, vfo_t vfo, char *digits, int *length)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->recv_dtmf(rig, vfo, digits, length));
}
@ -5435,7 +5493,7 @@ int HAMLIB_API rig_send_morse(RIG *rig, vfo_t vfo, const char *msg)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->send_morse(rig, vfo, msg));
}
@ -5493,7 +5551,7 @@ int HAMLIB_API rig_stop_morse(RIG *rig, vfo_t vfo)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->stop_morse(rig, vfo));
}
@ -5583,7 +5641,7 @@ int HAMLIB_API rig_wait_morse(RIG *rig, vfo_t vfo)
caps = rig->caps;
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(wait_morse_ptt(rig, vfo));
}
@ -5650,7 +5708,7 @@ int HAMLIB_API rig_send_voice_mem(RIG *rig, vfo_t vfo, int ch)
}
if (vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rig->state.current_vfo)
{
RETURNFUNC(caps->send_voice_mem(rig, vfo, ch));
}
@ -5705,18 +5763,18 @@ const freq_range_t *HAMLIB_API rig_get_range(const freq_range_t *range_list,
{
if (range_list[i].startf == 0 && range_list[i].endf == 0)
{
return(NULL);
return (NULL);
}
if (freq >= range_list[i].startf && freq <= range_list[i].endf &&
(range_list[i].modes & mode))
{
const freq_range_t *f = &range_list[i];
return(f);
return (f);
}
}
return(NULL);
return (NULL);
}
/**
@ -5753,15 +5811,15 @@ const char *HAMLIB_API rig_get_info(RIG *rig)
{
if (CHECK_RIG_ARG(rig))
{
return(NULL);
return (NULL);
}
if (rig->caps->get_info == NULL)
{
return(NULL);
return (NULL);
}
return(rig->caps->get_info(rig));
return (rig->caps->get_info(rig));
}
/**
@ -5796,16 +5854,19 @@ int HAMLIB_API rig_get_vfo_info(RIG *rig, vfo_t vfo, freq_t *freq,
if (vfo == RIG_VFO_CURR) { vfo = rig->state.current_vfo; }
// we can't use the cached values as some clients may only call this function
// we can't use the cached values as some clients may only call this function
// like Log4OM which mostly does polling
retval = rig_get_freq(rig, vfo, freq);
if (retval != RIG_OK) RETURNFUNC(retval);
if (retval != RIG_OK) { RETURNFUNC(retval); }
retval = rig_get_mode(rig, vfo, mode, width);
if (retval != RIG_OK) RETURNFUNC(retval);
if (retval != RIG_OK) { RETURNFUNC(retval); }
retval = rig_get_split(rig, vfo, split);
if (retval != RIG_OK) RETURNFUNC(retval);
if (retval != RIG_OK) { RETURNFUNC(retval); }
RETURNFUNC(RIG_OK);
}

30
src/serial.c
Wyświetl plik

@ -887,13 +887,13 @@ int HAMLIB_API ser_get_rts(hamlib_port_t *p, int *state)
// cannot do this for microHam ports
if (p->fd == uh_ptt_fd || p->fd == uh_radio_fd)
{
return(-RIG_ENIMPL);
return (-RIG_ENIMPL);
}
retcode = IOCTL(p->fd, TIOCMGET, &y);
*state = (y & TIOCM_RTS) == TIOCM_RTS;
return(retcode < 0 ? -RIG_EIO : RIG_OK);
return (retcode < 0 ? -RIG_EIO : RIG_OK);
}
@ -973,18 +973,18 @@ int HAMLIB_API ser_get_dtr(hamlib_port_t *p, int *state)
if (p->fd == uh_ptt_fd)
{
*state = uh_get_ptt();
return(RIG_OK);
return (RIG_OK);
}
if (p->fd == uh_radio_fd)
{
return(-RIG_ENIMPL);
return (-RIG_ENIMPL);
}
retcode = IOCTL(p->fd, TIOCMGET, &y);
*state = (y & TIOCM_DTR) == TIOCM_DTR;
return(retcode < 0 ? -RIG_EIO : RIG_OK);
return (retcode < 0 ? -RIG_EIO : RIG_OK);
}
@ -999,14 +999,14 @@ int HAMLIB_API ser_set_brk(hamlib_port_t *p, int state)
// ignore this for microHam ports
if (p->fd == uh_ptt_fd || p->fd == uh_radio_fd)
{
return(RIG_OK);
return (RIG_OK);
}
#if defined(TIOCSBRK) && defined(TIOCCBRK)
return(IOCTL(p->fd, state ? TIOCSBRK : TIOCCBRK, 0) < 0 ?
-RIG_EIO : RIG_OK);
return (IOCTL(p->fd, state ? TIOCSBRK : TIOCCBRK, 0) < 0 ?
-RIG_EIO : RIG_OK);
#else
return(-RIG_ENIMPL);
return (-RIG_ENIMPL);
#endif
}
@ -1024,13 +1024,13 @@ int HAMLIB_API ser_get_car(hamlib_port_t *p, int *state)
// cannot do this for microHam ports
if (p->fd == uh_ptt_fd || p->fd == uh_radio_fd)
{
return(-RIG_ENIMPL);
return (-RIG_ENIMPL);
}
retcode = IOCTL(p->fd, TIOCMGET, &y);
*state = (y & TIOCM_CAR) == TIOCM_CAR;
return(retcode < 0 ? -RIG_EIO : RIG_OK);
return (retcode < 0 ? -RIG_EIO : RIG_OK);
}
@ -1047,13 +1047,13 @@ int HAMLIB_API ser_get_cts(hamlib_port_t *p, int *state)
// cannot do this for microHam ports
if (p->fd == uh_ptt_fd || p->fd == uh_radio_fd)
{
return(-RIG_ENIMPL);
return (-RIG_ENIMPL);
}
retcode = IOCTL(p->fd, TIOCMGET, &y);
*state = (y & TIOCM_CTS) == TIOCM_CTS;
return(retcode < 0 ? -RIG_EIO : RIG_OK);
return (retcode < 0 ? -RIG_EIO : RIG_OK);
}
@ -1070,13 +1070,13 @@ int HAMLIB_API ser_get_dsr(hamlib_port_t *p, int *state)
// cannot do this for microHam ports
if (p->fd == uh_ptt_fd || p->fd == uh_radio_fd)
{
return(-RIG_ENIMPL);
return (-RIG_ENIMPL);
}
retcode = IOCTL(p->fd, TIOCMGET, &y);
*state = (y & TIOCM_DSR) == TIOCM_DSR;
return(retcode < 0 ? -RIG_EIO : RIG_OK);
return (retcode < 0 ? -RIG_EIO : RIG_OK);
}
/** @} */

12
tests/dumpcaps.c
Wyświetl plik

@ -340,7 +340,8 @@ int dumpcaps(RIG *rig, FILE *fout)
fprintf(fout, "Extra functions:\n");
rig_ext_func_foreach(rig, print_ext, fout);
rig_sprintf_level_gran(prntbuf, sizeof(prntbuf), caps->has_get_level, caps->level_gran);
rig_sprintf_level_gran(prntbuf, sizeof(prntbuf), caps->has_get_level,
caps->level_gran);
fprintf(fout, "Get level: %s\n", prntbuf);
if ((caps->has_get_level & RIG_LEVEL_SQLSTAT))
@ -359,7 +360,8 @@ int dumpcaps(RIG *rig, FILE *fout)
backend_warnings++;
}
rig_sprintf_level_gran(prntbuf, sizeof(prntbuf), caps->has_set_level, caps->level_gran);
rig_sprintf_level_gran(prntbuf, sizeof(prntbuf), caps->has_set_level,
caps->level_gran);
fprintf(fout, "Set level: %s\n", prntbuf);
if (caps->has_set_level & RIG_LEVEL_READONLY_LIST)
@ -371,10 +373,12 @@ int dumpcaps(RIG *rig, FILE *fout)
fprintf(fout, "Extra levels:\n");
rig_ext_level_foreach(rig, print_ext, fout);
rig_sprintf_parm_gran(prntbuf, sizeof(prntbuf), caps->has_get_parm, caps->parm_gran);
rig_sprintf_parm_gran(prntbuf, sizeof(prntbuf), caps->has_get_parm,
caps->parm_gran);
fprintf(fout, "Get parameters: %s\n", prntbuf);
rig_sprintf_parm_gran(prntbuf, sizeof(prntbuf), caps->has_set_parm, caps->parm_gran);
rig_sprintf_parm_gran(prntbuf, sizeof(prntbuf), caps->has_set_parm,
caps->parm_gran);
fprintf(fout, "Set parameters: %s\n", prntbuf);
if (caps->has_set_parm & RIG_PARM_READONLY_LIST)

12
tests/dumpcaps_rot.c
Wyświetl plik

@ -166,7 +166,8 @@ int dumpcaps_rot(ROT *rot, FILE *fout)
fprintf(fout, "Extra functions:\n");
rot_ext_func_foreach(rot, print_ext, fout);
rot_sprintf_level_gran(prntbuf, sizeof(prntbuf), caps->has_get_level, caps->level_gran);
rot_sprintf_level_gran(prntbuf, sizeof(prntbuf), caps->has_get_level,
caps->level_gran);
fprintf(fout, "Get level: %s\n", prntbuf);
if ((caps->has_get_level & RIG_LEVEL_SQLSTAT))
@ -175,7 +176,8 @@ int dumpcaps_rot(ROT *rot, FILE *fout)
backend_warnings++;
}
rot_sprintf_level_gran(prntbuf, sizeof(prntbuf), caps->has_set_level, caps->level_gran);
rot_sprintf_level_gran(prntbuf, sizeof(prntbuf), caps->has_set_level,
caps->level_gran);
fprintf(fout, "Set level: %s\n", prntbuf);
if (caps->has_set_level & ROT_LEVEL_READONLY_LIST)
@ -187,10 +189,12 @@ int dumpcaps_rot(ROT *rot, FILE *fout)
fprintf(fout, "Extra levels:\n");
rot_ext_level_foreach(rot, print_ext, fout);
rot_sprintf_parm_gran(prntbuf, sizeof(prntbuf), caps->has_get_parm, caps->parm_gran);
rot_sprintf_parm_gran(prntbuf, sizeof(prntbuf), caps->has_get_parm,
caps->parm_gran);
fprintf(fout, "Get parameters: %s\n", prntbuf);
rot_sprintf_parm_gran(prntbuf, sizeof(prntbuf), caps->has_set_parm, caps->parm_gran);
rot_sprintf_parm_gran(prntbuf, sizeof(prntbuf), caps->has_set_parm,
caps->parm_gran);
fprintf(fout, "Set parameters: %s\n", prntbuf);
if (caps->has_set_parm & ROT_PARM_READONLY_LIST)

10
tests/rigctl_parse.c
Wyświetl plik

@ -4223,7 +4223,8 @@ declare_proto_rig(dump_state)
fprintf(fout, "%d\n", 0);
#endif
for (i = 0; i < HAMLIB_FRQRANGESIZ && !RIG_IS_FRNG_END(rs->rx_range_list[i]); i++)
for (i = 0; i < HAMLIB_FRQRANGESIZ
&& !RIG_IS_FRNG_END(rs->rx_range_list[i]); i++)
{
fprintf(fout,
"%"FREQFMT" %"FREQFMT" 0x%"PRXll" %d %d 0x%x 0x%x\n",
@ -4238,7 +4239,8 @@ declare_proto_rig(dump_state)
fprintf(fout, "0 0 0 0 0 0 0\n");
for (i = 0; i < HAMLIB_FRQRANGESIZ && !RIG_IS_FRNG_END(rs->tx_range_list[i]); i++)
for (i = 0; i < HAMLIB_FRQRANGESIZ
&& !RIG_IS_FRNG_END(rs->tx_range_list[i]); i++)
{
fprintf(fout,
"%"FREQFMT" %"FREQFMT" 0x%"PRXll" %d %d 0x%x 0x%x\n",
@ -4387,7 +4389,7 @@ declare_proto_rig(get_ant)
fprintf(fout, "%s: ", cmd->arg1);
}
rig_sprintf_ant(antbuf, sizeof(antbuf), ant_curr);
rig_sprintf_ant(antbuf, sizeof(antbuf), ant_curr);
fprintf(fout, "%s%c", antbuf, resp_sep);
//fprintf(fout, "%d%c", rig_setting2idx(ant_curr)+1, resp_sep);
@ -4469,7 +4471,7 @@ declare_proto_rig(send_voice_mem)
}
declare_proto_rig(send_dtmf)
{
{
ENTERFUNC;
RETURNFUNC(rig_send_dtmf(rig, vfo, arg1));

33
tests/testcache.c
Wyświetl plik

@ -129,31 +129,40 @@ int main(int argc, char *argv[])
if (widthC != 3000) { printf("widthC = %d\n", (int)widthC); exit(1); }
printf("PTT ON\n");
rig_set_ptt(my_rig,RIG_VFO_CURR,RIG_PTT_ON);
rig_set_ptt(my_rig, RIG_VFO_CURR, RIG_PTT_ON);
ptt_t ptt;
printf("PTT get ptt ON\n");
rig_get_ptt(my_rig,RIG_VFO_CURR,&ptt);
rig_get_ptt(my_rig, RIG_VFO_CURR, &ptt);
if (ptt != RIG_PTT_ON) { printf("ptt != ON\n"); exit(1); }
hl_usleep(1000*1000);
rig_get_ptt(my_rig,RIG_VFO_CURR,&ptt);
hl_usleep(1000 * 1000);
rig_get_ptt(my_rig, RIG_VFO_CURR, &ptt);
printf("PTT get ptt ON\n");
if (ptt != RIG_PTT_ON) { printf("ptt != ON\n"); exit(1); }
printf("PTT ptt OFF\n");
rig_set_ptt(my_rig,RIG_VFO_CURR,RIG_PTT_OFF);
rig_set_ptt(my_rig, RIG_VFO_CURR, RIG_PTT_OFF);
if (ptt != RIG_PTT_ON) { printf("ptt != ON\n"); exit(1); }
rig_get_ptt(my_rig,RIG_VFO_CURR,&ptt);
rig_get_ptt(my_rig, RIG_VFO_CURR, &ptt);
printf("PTT get ptt OFF\n");
vfo_t tx_vfo;
split_t split;
rig_get_split_vfo(my_rig,RIG_VFO_A,&split, &tx_vfo);
rig_get_split_vfo(my_rig, RIG_VFO_A, &split, &tx_vfo);
printf("split=%d, tx_vfo=%s\n", split, rig_strvfo(tx_vfo));
if (split !=0 || tx_vfo != RIG_VFO_A) { printf("split#1 failed\n"); exit(1); }
rig_set_split_vfo(my_rig,RIG_VFO_A,RIG_SPLIT_ON,RIG_VFO_B);
hl_usleep(1000*1000);
rig_get_split_vfo(my_rig,RIG_VFO_A,&split,&tx_vfo);
if (split != 0 || tx_vfo != RIG_VFO_A) { printf("split#1 failed\n"); exit(1); }
rig_set_split_vfo(my_rig, RIG_VFO_A, RIG_SPLIT_ON, RIG_VFO_B);
hl_usleep(1000 * 1000);
rig_get_split_vfo(my_rig, RIG_VFO_A, &split, &tx_vfo);
printf("split=%d, tx_vfo=%s\n", split, rig_strvfo(tx_vfo));
if (split != RIG_SPLIT_ON || tx_vfo != RIG_VFO_B) { printf("split#2 failed\n"); exit(1); }
if (split != RIG_SPLIT_ON || tx_vfo != RIG_VFO_B) { printf("split#2 failed\n"); exit(1); }
printf("All OK\n");
rig_close(my_rig);