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

astyle files

pull/691/head
Mike Black W9MDB 2021-04-29 17:23:37 -05:00
rodzic 604516ed8f
commit 81e3e2e5d2
9 zmienionych plików z 462 dodań i 294 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

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

@ -203,37 +203,46 @@ int parse_array_int(const char *s, const char *delim, int *array, int array_len)
char *p;
char *dup = strdup(s);
char *rest = dup;
int n=0;
int n = 0;
ENTERFUNC;
while((p = strtok_r(rest, delim, &rest)))
while ((p = strtok_r(rest, delim, &rest)))
{
if (n == array_len) { // too many items
if (n == array_len) // too many items
{
return n;
}
array[n] = atoi(p);
//printf("%d\n", array[n]);
++n;
}
free(dup);
return n;
}
int parse_array_double(const char *s, const char *delim, double *array, int array_len)
int parse_array_double(const char *s, const char *delim, double *array,
int array_len)
{
char *p;
char *dup = strdup(s);
char *rest = dup;
int n=0;
int n = 0;
ENTERFUNC;
while((p = strtok_r(rest, delim, &rest)))
while ((p = strtok_r(rest, delim, &rest)))
{
if (n == array_len) { // too many items
if (n == array_len) // too many items
{
return n;
}
array[n] = atof(p);
//printf("%f\n", array[n]);
++n;
}
free(dup);
return n;
}
@ -555,6 +564,7 @@ static int netrigctl_open(RIG *rig)
rig->caps->has_get_level = rs->has_get_level = strtoll(buf, NULL, 0);
#if 0 // don't think we need this anymore
if (rs->has_get_level & RIG_LEVEL_RAWSTR)
{
/* include STRENGTH because the remote rig may be able to
@ -563,6 +573,7 @@ static int netrigctl_open(RIG *rig)
rs->has_get_level |= RIG_LEVEL_STRENGTH;
rig->caps->has_get_level |= RIG_LEVEL_STRENGTH;
}
#endif
ret = read_string(&rig->state.rigport, buf, BUF_MAX, "\n", 1);
@ -701,6 +712,7 @@ static int netrigctl_open(RIG *rig)
if (!has) { rig->caps->get_conf = NULL; }
}
#if 0 // for the future
else if (strcmp(setting, "has_set_trn") == 0)
{
@ -714,6 +726,7 @@ static int netrigctl_open(RIG *rig)
if (!has) { rig->caps->get_trn = NULL; }
}
#endif
else if (strcmp(setting, "has_power2mW") == 0)
{
@ -741,18 +754,22 @@ static int netrigctl_open(RIG *rig)
double ctcss[CTCSS_LIST_SIZE];
rig->caps->ctcss_list = calloc(CTCSS_LIST_SIZE, sizeof(tone_t));
n = parse_array_double(value, " \n\r", ctcss, CTCSS_LIST_SIZE);
for(i=0;i<CTCSS_LIST_SIZE && ctcss[i] != 0;++i) rig->caps->ctcss_list[i] = ctcss[i]*10;
if (n < CTCSS_LIST_SIZE) rig->caps->ctcss_list[n] = 0;
for (i = 0; i < CTCSS_LIST_SIZE && ctcss[i] != 0; ++i) { rig->caps->ctcss_list[i] = ctcss[i] * 10; }
if (n < CTCSS_LIST_SIZE) { rig->caps->ctcss_list[n] = 0; }
}
else if (strcmp(setting,"dcs_list") == 0)
else if (strcmp(setting, "dcs_list") == 0)
{
int i;
int n;
int dcs[DCS_LIST_SIZE+1];
int dcs[DCS_LIST_SIZE + 1];
rig->caps->dcs_list = calloc(DCS_LIST_SIZE, sizeof(tone_t));
n = parse_array_int(value, " \n\r", dcs, DCS_LIST_SIZE);
for(i=0;i<DCS_LIST_SIZE && dcs[i] != 0; i++) rig->caps->dcs_list[i] = dcs[i];
if (n < DCS_LIST_SIZE) rig->caps->dcs_list[n] = 0;
for (i = 0; i < DCS_LIST_SIZE && dcs[i] != 0; i++) { rig->caps->dcs_list[i] = dcs[i]; }
if (n < DCS_LIST_SIZE) { rig->caps->dcs_list[n] = 0; }
}
else
{
@ -2454,12 +2471,14 @@ static int netrigctl_get_trn(RIG *rig, int *trn)
{
return -RIG_EPROTO;
}
if (strstr(buf,"OFF")) *trn = RIG_TRN_OFF;
else if (strstr(buf,"RIG")) *trn = RIG_TRN_RIG;
else if (strstr(buf,"POLL")) *trn = RIG_TRN_POLL;
else {
rig_debug(RIG_DEBUG_ERR, "%s: Expected OFF, RIG, or POLL, got '%s'\n", __func__, buf);
if (strstr(buf, "OFF")) { *trn = RIG_TRN_OFF; }
else if (strstr(buf, "RIG")) { *trn = RIG_TRN_RIG; }
else if (strstr(buf, "POLL")) { *trn = RIG_TRN_POLL; }
else
{
rig_debug(RIG_DEBUG_ERR, "%s: Expected OFF, RIG, or POLL, got '%s'\n", __func__,
buf);
ret = -RIG_EINVAL;
}
@ -2468,7 +2487,7 @@ static int netrigctl_get_trn(RIG *rig, int *trn)
#endif
static int netrigctl_mW2power(RIG *rig, float *power, unsigned int mwpower,
freq_t freq, rmode_t mode)
freq_t freq, rmode_t mode)
{
char cmdbuf[32];
char buf[BUF_MAX];
@ -2491,7 +2510,7 @@ static int netrigctl_mW2power(RIG *rig, float *power, unsigned int mwpower,
static int netrigctl_power2mW(RIG *rig, unsigned int *mwpower, float power,
freq_t freq, rmode_t mode)
freq_t freq, rmode_t mode)
{
char cmdbuf[32];
char buf[BUF_MAX];

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

@ -4499,6 +4499,7 @@ int icom_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq)
&ack_len);
rs->rigport.retry = retry_save;
if (retval == RIG_OK) // then we're done!!
{
*tx_freq = from_bcd(ackbuf + 2, (priv->civ_731_mode ? 4 : 5) * 2);

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

@ -337,7 +337,9 @@ transaction_write:
int skip = strncmp(cmdstr, "RX", 2) == 0;
skip |= strncmp(cmdstr, "RU", 2) == 0;
skip |= strncmp(cmdstr, "RD", 2) == 0;
if (skip) {
if (skip)
{
goto transaction_quit;
}
}
@ -1784,11 +1786,13 @@ int kenwood_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
// by getting current rit we can determine how to handle change
// we just use curr_rit - rit to determine how far we need to move
// No need to zero out rit
retval = kenwood_get_rit(rig,RIG_VFO_CURR,&curr_rit);
retval = kenwood_get_rit(rig, RIG_VFO_CURR, &curr_rit);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
#if 0 // no longer needed if diff can be done
retval = kenwood_transaction(rig, "RC", NULL, 0);
@ -1796,6 +1800,7 @@ int kenwood_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
{
RETURNFUNC(retval);
}
#endif
if (rit == 0 && curr_rit == 0)
@ -1806,15 +1811,18 @@ int kenwood_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
if (priv->has_rit2)
{
diff = rit - curr_rit;
rig_debug(RIG_DEBUG_TRACE, "%s: rit=%ld, curr_rit=%ld, diff=%d\n", __func__, rit, curr_rit, diff);
rig_debug(RIG_DEBUG_TRACE, "%s: rit=%ld, curr_rit=%ld, diff=%d\n", __func__,
rit, curr_rit, diff);
snprintf(buf, sizeof(buf), "R%c%05d", (diff > 0) ? 'U' : 'D', abs((int) diff));
retval = kenwood_transaction(rig, buf, NULL, 0);
}
else
{
snprintf(buf, sizeof(buf), "R%c", (rit > 0) ? 'U' : 'D');
diff = labs(((curr_rit - rit) + (curr_rit - rit) >= 0 ? 5 : -5) / 10); // round to nearest 10Hz
rig_debug(RIG_DEBUG_TRACE, "%s: rit=%ld, curr_rit=%ld, diff=%d\n", __func__, rit, curr_rit, diff);
diff = labs(((curr_rit - rit) + (curr_rit - rit) >= 0 ? 5 : -5) /
10); // round to nearest 10Hz
rig_debug(RIG_DEBUG_TRACE, "%s: rit=%ld, curr_rit=%ld, diff=%d\n", __func__,
rit, curr_rit, diff);
rig_debug(RIG_DEBUG_TRACE, "%s: rit change loop=%d\n", __func__, diff);
for (i = 0; i < diff; i++)

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

@ -1236,6 +1236,7 @@ static int tmd710_find_dcs_index(tone_t code, uint32_t *dcs_index)
// we only allow exact matches here
tone_t *dcs_list = common_dcs_list;
while (code != dcs_list[i])
{
if (dcs_list[i] == 0)

581
rigs/kenwood/ts480.c
Wyświetl plik

@ -86,7 +86,8 @@
#define TOK_LEVEL_DIGITAL_NOISE_LIMITER TOKEN_BACKEND(111)
#define TOK_FUNC_CW_IF_FOR_SSB_RX TOKEN_BACKEND(112)
int ts480_ext_tokens[] = {
int ts480_ext_tokens[] =
{
TOK_FUNC_NOISE_REDUCTION_2, TOK_FUNC_FILTER_WIDTH_DATA, TOK_FUNC_TX_AUDIO_FROM_DATA_INPUT,
TOK_LEVEL_DSP_RX_EQUALIZER, TOK_LEVEL_DSP_TX_EQUALIZER, TOK_LEVEL_DSP_TX_BANDWIDTH,
TOK_LEVEL_BEEP_VOLUME, TOK_LEVEL_TX_SIDETONE_VOLUME,
@ -219,7 +220,9 @@ static int ts480_get_ex_menu(RIG *rig, int number, int value_len, int *value)
snprintf(buf, 20, "EX%03d0000", number);
retval = kenwood_safe_transaction(rig, buf, ackbuf, sizeof(ackbuf), 9 + value_len);
retval = kenwood_safe_transaction(rig, buf, ackbuf, sizeof(ackbuf),
9 + value_len);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
@ -238,14 +241,17 @@ static int ts480_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
switch (func)
{
case RIG_FUNC_MON:
snprintf(buf, sizeof(buf), "ML00%c", (status == 0) ? '0' : '1');
RETURNFUNC(kenwood_transaction(rig, buf, NULL, 0));
case RIG_FUNC_LOCK:
snprintf(buf, sizeof(buf), "LK%c%c", (status == 0) ? '0' : '1', (status == 0) ? '0' : '1');
RETURNFUNC(kenwood_transaction(rig, buf, NULL, 0));
default:
return kenwood_set_func(rig, vfo, func, status);
case RIG_FUNC_MON:
snprintf(buf, sizeof(buf), "ML00%c", (status == 0) ? '0' : '1');
RETURNFUNC(kenwood_transaction(rig, buf, NULL, 0));
case RIG_FUNC_LOCK:
snprintf(buf, sizeof(buf), "LK%c%c", (status == 0) ? '0' : '1',
(status == 0) ? '0' : '1');
RETURNFUNC(kenwood_transaction(rig, buf, NULL, 0));
default:
return kenwood_set_func(rig, vfo, func, status);
}
}
@ -258,29 +264,35 @@ static int ts480_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
switch (func)
{
case RIG_FUNC_MON: {
int raw_value;
retval = kenwood_safe_transaction(rig, "ML", buf, sizeof(buf), 5);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
sscanf(buf, "ML%d", &raw_value);
case RIG_FUNC_MON:
{
int raw_value;
retval = kenwood_safe_transaction(rig, "ML", buf, sizeof(buf), 5);
*status = (raw_value > 0);
break;
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
case RIG_FUNC_LOCK:
retval = kenwood_safe_transaction(rig, "LK", buf, sizeof(buf), 4);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
*status = buf[2] != '0' || buf[3] != '0';
break;
default:
return kenwood_get_func(rig, vfo, func, status);
sscanf(buf, "ML%d", &raw_value);
*status = (raw_value > 0);
break;
}
case RIG_FUNC_LOCK:
retval = kenwood_safe_transaction(rig, "LK", buf, sizeof(buf), 4);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
*status = buf[2] != '0' || buf[3] != '0';
break;
default:
return kenwood_get_func(rig, vfo, func, status);
}
RETURNFUNC(RIG_OK);
@ -355,34 +367,42 @@ int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
break;
case RIG_LEVEL_PREAMP:
if (val.i != 12 && val.i != 0) {
if (val.i != 12 && val.i != 0)
{
RETURNFUNC(-RIG_EINVAL);
}
sprintf(levelbuf, "PA%c", (val.i == 12) ? '1' : '0');
break;
case RIG_LEVEL_ATT:
if (val.i != 12 && val.i != 0) {
if (val.i != 12 && val.i != 0)
{
RETURNFUNC(-RIG_EINVAL);
}
sprintf(levelbuf, "RA%02d", (val.i == 12) ? 1 : 0);
break;
case RIG_LEVEL_METER:
switch (val.i)
{
case RIG_METER_SWR:
kenwood_val = 1;
break;
case RIG_METER_COMP:
kenwood_val = 2;
break;
case RIG_METER_ALC:
kenwood_val = 3;
break;
default:
RETURNFUNC(-RIG_EINVAL);
case RIG_METER_SWR:
kenwood_val = 1;
break;
case RIG_METER_COMP:
kenwood_val = 2;
break;
case RIG_METER_ALC:
kenwood_val = 3;
break;
default:
RETURNFUNC(-RIG_EINVAL);
}
sprintf(levelbuf, "RM%d", kenwood_val);
break;
@ -434,14 +454,18 @@ static int ts480_read_meters(RIG *rig, int *swr, int *comp, int *alc)
if (retval != expected_len)
{
rig_debug(RIG_DEBUG_ERR, "%s: expected %d bytes, got %d in '%s'\n", __func__, expected_len, retval, ackbuf);
rig_debug(RIG_DEBUG_ERR, "%s: expected %d bytes, got %d in '%s'\n", __func__,
expected_len, retval, ackbuf);
RETURNFUNC(-RIG_EPROTO);
}
retval = sscanf(ackbuf, "RM1%d;RM2%d;RM3%d;", swr, comp, alc);
if (retval != 3)
{
rig_debug(RIG_DEBUG_ERR, "%s: expected 3 meter values to parse, got %d in '%s'\n", __func__, retval, ackbuf);
rig_debug(RIG_DEBUG_ERR,
"%s: expected 3 meter values to parse, got %d in '%s'\n", __func__, retval,
ackbuf);
RETURNFUNC(-RIG_EPROTO);
}
@ -548,6 +572,7 @@ kenwood_ts480_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
default:
return -RIG_EPROTO;
}
return RIG_OK;
case RIG_LEVEL_STRENGTH:
@ -559,39 +584,48 @@ kenwood_ts480_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return kenwood_get_level(rig, vfo, level, val);
case RIG_LEVEL_MONITOR_GAIN: {
case RIG_LEVEL_MONITOR_GAIN:
{
int raw_value;
retval = kenwood_safe_transaction(rig, "ML", ackbuf, sizeof(ackbuf), 5);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
sscanf(ackbuf, "ML%d", &raw_value);
val->f = (float) raw_value / 9.0f;
break;
}
case RIG_LEVEL_NB: {
case RIG_LEVEL_NB:
{
int raw_value;
retval = kenwood_safe_transaction(rig, "NL", ackbuf, sizeof(ackbuf), 5);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
sscanf(ackbuf, "NL%d", &raw_value);
val->f = (float) raw_value / 10.0f;
break;
}
case RIG_LEVEL_NR: {
case RIG_LEVEL_NR:
{
int raw_value;
retval = kenwood_safe_transaction(rig, "RL", ackbuf, sizeof(ackbuf), 4);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
sscanf(ackbuf, "RL%d", &raw_value);
val->f = (float) raw_value / 9.0f;
@ -600,59 +634,72 @@ kenwood_ts480_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
case RIG_LEVEL_PREAMP:
retval = kenwood_safe_transaction(rig, "PA", ackbuf, sizeof(ackbuf), 4);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
val->i = ackbuf[2] == '1' ? 12 : 0;
break;
case RIG_LEVEL_ATT:
retval = kenwood_safe_transaction(rig, "RA", ackbuf, sizeof(ackbuf), 6);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
val->i = ackbuf[3] == '1' ? 12 : 0;
break;
case RIG_LEVEL_METER: {
case RIG_LEVEL_METER:
{
int raw_value;
// TODO: Read all meters at the same time: RM10000;RM20000;RM30000;
retval = kenwood_safe_transaction(rig, "RM", ackbuf, sizeof(ackbuf), 7);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
sscanf(ackbuf, "RM%1d", &raw_value);
switch (raw_value)
{
case 1:
val->i = RIG_METER_SWR;
break;
case 2:
val->i = RIG_METER_COMP;
break;
case 3:
val->i = RIG_METER_ALC;
break;
default:
val->i = RIG_METER_NONE;
case 1:
val->i = RIG_METER_SWR;
break;
case 2:
val->i = RIG_METER_COMP;
break;
case 3:
val->i = RIG_METER_ALC;
break;
default:
val->i = RIG_METER_NONE;
}
break;
}
case RIG_LEVEL_SWR:
case RIG_LEVEL_COMP_METER:
case RIG_LEVEL_ALC: {
case RIG_LEVEL_ALC:
{
int swr;
int comp;
int alc;
retval = ts480_read_meters(rig, &swr, &comp, &alc);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
@ -660,30 +707,36 @@ kenwood_ts480_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
switch (level)
{
case RIG_LEVEL_SWR:
if (rig->caps->swr_cal.size)
{
val->f = rig_raw2val_float(swr, &rig->caps->swr_cal);
}
else
{
val->f = (float) swr / 2.0f;
}
break;
case RIG_LEVEL_COMP_METER:
val->f = (float) comp; // Maximum value is 20dB
break;
case RIG_LEVEL_ALC:
// Maximum value is 20, so have the max at 5 just to be on the range where other rigs report ALC
val->f = (float) alc / 4.0f;
break;
default:
return -RIG_ENAVAIL;
case RIG_LEVEL_SWR:
if (rig->caps->swr_cal.size)
{
val->f = rig_raw2val_float(swr, &rig->caps->swr_cal);
}
else
{
val->f = (float) swr / 2.0f;
}
break;
case RIG_LEVEL_COMP_METER:
val->f = (float) comp; // Maximum value is 20dB
break;
case RIG_LEVEL_ALC:
// Maximum value is 20, so have the max at 5 just to be on the range where other rigs report ALC
val->f = (float) alc / 4.0f;
break;
default:
return -RIG_ENAVAIL;
}
break;
}
case RIG_LEVEL_RFPOWER_METER: {
case RIG_LEVEL_RFPOWER_METER:
{
int raw_value;
if (rig->state.cache.ptt == RIG_PTT_OFF)
@ -693,6 +746,7 @@ kenwood_ts480_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
}
retval = kenwood_safe_transaction(rig, "SM0", ackbuf, sizeof(ackbuf), 7);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
@ -704,9 +758,11 @@ kenwood_ts480_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break;
}
case RIG_LEVEL_CWPITCH: {
case RIG_LEVEL_CWPITCH:
{
int raw_value;
retval = ts480_get_ex_menu(rig, 34, 2, &raw_value);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
@ -740,13 +796,16 @@ static int ts480_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
// RC clear command cannot be executed if RIT/XIT is not enabled
retval = kenwood_get_func(rig, vfo, RIG_FUNC_RIT, &rit_enabled);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
if (!rit_enabled)
{
retval = kenwood_get_func(rig, vfo, RIG_FUNC_XIT, &xit_enabled);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
@ -756,6 +815,7 @@ static int ts480_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
if (!rit_enabled && !xit_enabled)
{
retval = kenwood_set_func(rig, vfo, RIG_FUNC_RIT, 1);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
@ -763,6 +823,7 @@ static int ts480_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
}
retval = kenwood_transaction(rig, "RC", NULL, 0);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
@ -771,6 +832,7 @@ static int ts480_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
if (!rit_enabled && !xit_enabled)
{
retval = kenwood_set_func(rig, vfo, RIG_FUNC_RIT, 0);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
@ -825,37 +887,45 @@ static int ts480_set_ext_func(RIG *rig, vfo_t vfo, token_t token, int status)
switch (token)
{
case TOK_FUNC_NOISE_REDUCTION_2:
if (status < 0 || status > 1)
{
RETURNFUNC(-RIG_EINVAL);
}
snprintf(cmdbuf, sizeof(cmdbuf), "NR%d", status ? 2 : 0);
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
break;
case TOK_FUNC_CW_IF_FOR_SSB_RX:
if (status < 0 || status > 1)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 17, 1, status);
break;
case TOK_FUNC_FILTER_WIDTH_DATA:
if (status < 0 || status > 1)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 45, 1, status);
break;
case TOK_FUNC_TX_AUDIO_FROM_DATA_INPUT:
if (status < 0 || status > 1)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 60, 1, status);
break;
default:
case TOK_FUNC_NOISE_REDUCTION_2:
if (status < 0 || status > 1)
{
RETURNFUNC(-RIG_EINVAL);
}
snprintf(cmdbuf, sizeof(cmdbuf), "NR%d", status ? 2 : 0);
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
break;
case TOK_FUNC_CW_IF_FOR_SSB_RX:
if (status < 0 || status > 1)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 17, 1, status);
break;
case TOK_FUNC_FILTER_WIDTH_DATA:
if (status < 0 || status > 1)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 45, 1, status);
break;
case TOK_FUNC_TX_AUDIO_FROM_DATA_INPUT:
if (status < 0 || status > 1)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 60, 1, status);
break;
default:
RETURNFUNC(-RIG_EINVAL);
}
RETURNFUNC(retval);
@ -870,31 +940,37 @@ static int ts480_get_ext_func(RIG *rig, vfo_t vfo, token_t token, int *status)
switch (token)
{
case TOK_FUNC_NOISE_REDUCTION_2: {
int value;
case TOK_FUNC_NOISE_REDUCTION_2:
{
int value;
retval = kenwood_safe_transaction(rig, "NR", ackbuf, sizeof(ackbuf), 3);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
retval = kenwood_safe_transaction(rig, "NR", ackbuf, sizeof(ackbuf), 3);
sscanf(ackbuf, "NR%d", &value);
*status = (value == 2) ? 1 : 0;
break;
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
case TOK_FUNC_CW_IF_FOR_SSB_RX:
retval = ts480_get_ex_menu(rig, 17, 1, status);
break;
case TOK_FUNC_FILTER_WIDTH_DATA:
retval = ts480_get_ex_menu(rig, 45, 1, status);
break;
case TOK_FUNC_TX_AUDIO_FROM_DATA_INPUT:
retval = ts480_get_ex_menu(rig, 60, 1, status);
break;
default:
RETURNFUNC(-RIG_EINVAL);
sscanf(ackbuf, "NR%d", &value);
*status = (value == 2) ? 1 : 0;
break;
}
case TOK_FUNC_CW_IF_FOR_SSB_RX:
retval = ts480_get_ex_menu(rig, 17, 1, status);
break;
case TOK_FUNC_FILTER_WIDTH_DATA:
retval = ts480_get_ex_menu(rig, 45, 1, status);
break;
case TOK_FUNC_TX_AUDIO_FROM_DATA_INPUT:
retval = ts480_get_ex_menu(rig, 60, 1, status);
break;
default:
RETURNFUNC(-RIG_EINVAL);
}
RETURNFUNC(retval);
@ -909,65 +985,82 @@ static int ts480_set_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t val)
switch (token)
{
case TOK_LEVEL_DIGITAL_NOISE_LIMITER:
if (val.i < 0 || val.i > 3)
{
RETURNFUNC(-RIG_EINVAL);
}
snprintf(cmdbuf, sizeof(cmdbuf), "DL%d%02d", val.i != 0 ? 1 : 0, val.i > 0 ? val.i - 1 : 0);
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
break;
case TOK_LEVEL_DSP_RX_EQUALIZER:
if (val.i < 0 || val.i > 7)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 18, 1, val.i);
break;
case TOK_LEVEL_DSP_TX_EQUALIZER:
if (val.i < 0 || val.i > 7)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 19, 1, val.i);
break;
case TOK_LEVEL_DSP_TX_BANDWIDTH:
if (val.i < 0 || val.i > 1)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 20, 1, val.i);
break;
case TOK_LEVEL_BEEP_VOLUME:
if (val.f < 0 || val.f > 9)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 12, 1, (int) val.f);
break;
case TOK_LEVEL_TX_SIDETONE_VOLUME:
if (val.f < 0 || val.f > 9)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 13, 1, (int) val.f);
break;
case TOK_LEVEL_AF_INPUT_LEVEL:
if (val.f < 0 || val.f > 9)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 46, 1, (int) val.f);
break;
case TOK_LEVEL_AF_OUTPUT_LEVEL:
if (val.f < 0 || val.f > 9)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 47, 1, (int) val.f);
break;
default:
case TOK_LEVEL_DIGITAL_NOISE_LIMITER:
if (val.i < 0 || val.i > 3)
{
RETURNFUNC(-RIG_EINVAL);
}
snprintf(cmdbuf, sizeof(cmdbuf), "DL%d%02d", val.i != 0 ? 1 : 0,
val.i > 0 ? val.i - 1 : 0);
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
break;
case TOK_LEVEL_DSP_RX_EQUALIZER:
if (val.i < 0 || val.i > 7)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 18, 1, val.i);
break;
case TOK_LEVEL_DSP_TX_EQUALIZER:
if (val.i < 0 || val.i > 7)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 19, 1, val.i);
break;
case TOK_LEVEL_DSP_TX_BANDWIDTH:
if (val.i < 0 || val.i > 1)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 20, 1, val.i);
break;
case TOK_LEVEL_BEEP_VOLUME:
if (val.f < 0 || val.f > 9)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 12, 1, (int) val.f);
break;
case TOK_LEVEL_TX_SIDETONE_VOLUME:
if (val.f < 0 || val.f > 9)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 13, 1, (int) val.f);
break;
case TOK_LEVEL_AF_INPUT_LEVEL:
if (val.f < 0 || val.f > 9)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 46, 1, (int) val.f);
break;
case TOK_LEVEL_AF_OUTPUT_LEVEL:
if (val.f < 0 || val.f > 9)
{
RETURNFUNC(-RIG_EINVAL);
}
retval = ts480_set_ex_menu(rig, 47, 1, (int) val.f);
break;
default:
RETURNFUNC(-RIG_EINVAL);
}
RETURNFUNC(retval);
@ -983,57 +1076,68 @@ static int ts480_get_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t *val)
switch (token)
{
case TOK_LEVEL_DIGITAL_NOISE_LIMITER: {
int enabled;
int level;
case TOK_LEVEL_DIGITAL_NOISE_LIMITER:
{
int enabled;
int level;
retval = kenwood_safe_transaction(rig, "DL", ackbuf, sizeof(ackbuf), 5);
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
retval = kenwood_safe_transaction(rig, "DL", ackbuf, sizeof(ackbuf), 5);
sscanf(ackbuf, "DL%1d%2d", &enabled, &level);
val->i = enabled ? level + 1 : 0;
break;
if (retval != RIG_OK)
{
RETURNFUNC(retval);
}
case TOK_LEVEL_DSP_RX_EQUALIZER:
retval = ts480_get_ex_menu(rig, 18, 1, &value);
val->i = value;
break;
case TOK_LEVEL_DSP_TX_EQUALIZER:
retval = ts480_get_ex_menu(rig, 19, 1, &value);
val->i = value;
break;
case TOK_LEVEL_DSP_TX_BANDWIDTH:
retval = ts480_get_ex_menu(rig, 20, 1, &value);
val->i = value;
break;
case TOK_LEVEL_BEEP_VOLUME:
retval = ts480_get_ex_menu(rig, 12, 1, &value);
val->f = value;
break;
case TOK_LEVEL_TX_SIDETONE_VOLUME:
retval = ts480_get_ex_menu(rig, 13, 1, &value);
val->f = value;
break;
case TOK_LEVEL_AF_INPUT_LEVEL:
retval = ts480_get_ex_menu(rig, 46, 1, &value);
val->f = value;
break;
case TOK_LEVEL_AF_OUTPUT_LEVEL:
retval = ts480_get_ex_menu(rig, 47, 1, &value);
val->f = value;
break;
default:
RETURNFUNC(-RIG_EINVAL);
sscanf(ackbuf, "DL%1d%2d", &enabled, &level);
val->i = enabled ? level + 1 : 0;
break;
}
case TOK_LEVEL_DSP_RX_EQUALIZER:
retval = ts480_get_ex_menu(rig, 18, 1, &value);
val->i = value;
break;
case TOK_LEVEL_DSP_TX_EQUALIZER:
retval = ts480_get_ex_menu(rig, 19, 1, &value);
val->i = value;
break;
case TOK_LEVEL_DSP_TX_BANDWIDTH:
retval = ts480_get_ex_menu(rig, 20, 1, &value);
val->i = value;
break;
case TOK_LEVEL_BEEP_VOLUME:
retval = ts480_get_ex_menu(rig, 12, 1, &value);
val->f = value;
break;
case TOK_LEVEL_TX_SIDETONE_VOLUME:
retval = ts480_get_ex_menu(rig, 13, 1, &value);
val->f = value;
break;
case TOK_LEVEL_AF_INPUT_LEVEL:
retval = ts480_get_ex_menu(rig, 46, 1, &value);
val->f = value;
break;
case TOK_LEVEL_AF_OUTPUT_LEVEL:
retval = ts480_get_ex_menu(rig, 47, 1, &value);
val->f = value;
break;
default:
RETURNFUNC(-RIG_EINVAL);
}
RETURNFUNC(retval);
}
static struct kenwood_filter_width ts480_filter_width[] = {
static struct kenwood_filter_width ts480_filter_width[] =
{
{ RIG_MODE_CW | RIG_MODE_CWR, 50, 50 },
{ RIG_MODE_CW | RIG_MODE_CWR, 80, 80 },
{ RIG_MODE_CW | RIG_MODE_CWR, 100, 100 },
@ -1058,7 +1162,8 @@ static struct kenwood_filter_width ts480_filter_width[] = {
{ RIG_MODE_NONE, -1, -1 },
};
static struct kenwood_slope_filter ts480_slope_filter_high[] = {
static struct kenwood_slope_filter ts480_slope_filter_high[] =
{
{ RIG_MODE_SSB | RIG_MODE_FM | RIG_MODE_RTTY | RIG_MODE_RTTYR, 0, 0, 1000 },
{ RIG_MODE_SSB | RIG_MODE_FM | RIG_MODE_RTTY | RIG_MODE_RTTYR, 0, 1, 1200 },
{ RIG_MODE_SSB | RIG_MODE_FM | RIG_MODE_RTTY | RIG_MODE_RTTYR, 0, 2, 1400 },
@ -1083,7 +1188,8 @@ static struct kenwood_slope_filter ts480_slope_filter_high[] = {
{ RIG_MODE_NONE, 0, -1, -1 },
};
static struct kenwood_slope_filter ts480_slope_filter_low[] = {
static struct kenwood_slope_filter ts480_slope_filter_low[] =
{
{ RIG_MODE_SSB | RIG_MODE_FM | RIG_MODE_RTTY | RIG_MODE_RTTYR, 0, 0, 0 },
{ RIG_MODE_SSB | RIG_MODE_FM | RIG_MODE_RTTY | RIG_MODE_RTTYR, 0, 1, 50 },
{ RIG_MODE_SSB | RIG_MODE_FM | RIG_MODE_RTTY | RIG_MODE_RTTYR, 0, 2, 100 },
@ -1126,6 +1232,7 @@ int ts480_init(RIG *rig)
rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__);
retval = kenwood_init(rig);
if (retval != RIG_OK)
{
return retval;

2
src/iofunc.c
Wyświetl plik

@ -481,7 +481,7 @@ int HAMLIB_API write_block(hamlib_port_t *p, const char *txbuffer, size_t count)
return -RIG_EIO;
}
if (p->write_delay > 0) hl_usleep(p->write_delay * 1000);
if (p->write_delay > 0) { hl_usleep(p->write_delay * 1000); }
}
}
else

64
src/rig.c
Wyświetl plik

@ -1005,6 +1005,7 @@ int HAMLIB_API rig_open(RIG *rig)
* trigger state->current_vfo first retrieval
*/
TRACE;
if (rig_get_vfo(rig, &rs->current_vfo) == RIG_OK)
{
rs->tx_vfo = rs->current_vfo;
@ -1744,10 +1745,13 @@ int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
rig_debug(RIG_DEBUG_TRACE, "%s: Ignoring set_freq due to VFO twiddling\n",
__func__);
if (vfo != vfo_save && vfo != RIG_VFO_CURR) {
if (vfo != vfo_save && vfo != RIG_VFO_CURR)
{
TRACE;
rig_set_vfo(rig, vfo_save);
}
RETURNFUNC(
RIG_OK); // would be better as error but other software won't handle errors
}
@ -1814,10 +1818,13 @@ int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
rig_debug(RIG_DEBUG_TRACE, "%s: Ignoring set_freq due to VFO twiddling\n",
__func__);
if (vfo != vfo_save && vfo != RIG_VFO_CURR) {
if (vfo != vfo_save && vfo != RIG_VFO_CURR)
{
TRACE;
rig_set_vfo(rig, vfo_save);
}
RETURNFUNC(
RIG_OK); // would be better as error but other software won't handle errors
}
@ -1862,7 +1869,8 @@ int HAMLIB_API rig_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
set_cache_freq(rig, vfo, freq_new);
if (vfo != vfo_save && vfo != RIG_VFO_CURR) {
if (vfo != vfo_save && vfo != RIG_VFO_CURR)
{
TRACE;
rig_set_vfo(rig, vfo_save);
}
@ -1914,7 +1922,7 @@ int HAMLIB_API rig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
vfo = vfo_fixup(rig, vfo);
if (vfo == RIG_VFO_CURR) vfo = curr_vfo;
if (vfo == RIG_VFO_CURR) { vfo = curr_vfo; }
// we ignore get_freq for the uplink VFO for gpredict to behave better
if ((rig->state.uplink == 1 && vfo == RIG_VFO_SUB)
@ -3950,7 +3958,9 @@ int HAMLIB_API rig_set_split_mode(RIG *rig,
}
else
{
rig_debug(RIG_DEBUG_WARN, "%s: rig does not have set_vfo or vfo_op. Assuming mode already set\n", __func__);
rig_debug(RIG_DEBUG_WARN,
"%s: rig does not have set_vfo or vfo_op. Assuming mode already set\n",
__func__);
RETURNFUNC(RIG_OK);
}
@ -6209,11 +6219,11 @@ const char *HAMLIB_API rig_get_info(RIG *rig)
*/
int HAMLIB_API rig_get_rig_info(RIG *rig, char *response, int max_response_len)
{
vfo_t vfoA,vfoB;
freq_t freqA,freqB;
rmode_t modeA,modeB;
vfo_t vfoA, vfoB;
freq_t freqA, freqB;
rmode_t modeA, modeB;
char *modeAstr, *modeBstr;
pbwidth_t widthA,widthB;
pbwidth_t widthA, widthB;
split_t split;
int satmode;
int ret;
@ -6222,30 +6232,42 @@ int HAMLIB_API rig_get_rig_info(RIG *rig, char *response, int max_response_len)
vfoA = vfo_fixup(rig, RIG_VFO_A);
vfoB = vfo_fixup(rig, RIG_VFO_B);
ret = rig_get_vfo_info(rig, vfoA, &freqA, &modeA, &widthA, &split, &satmode);
if (ret != RIG_OK) RETURNFUNC(ret);
ret = rig_get_vfo_info(rig, vfoA, &freqA, &modeA, &widthA, &split, &satmode);
if (ret != RIG_OK) { RETURNFUNC(ret); }
// we need both vfo and mode targtable to avoid vfo swapping
if ((rig->caps->targetable_vfo & RIG_TARGETABLE_FREQ) && (rig->caps->targetable_vfo & RIG_TARGETABLE_MODE))
if ((rig->caps->targetable_vfo & RIG_TARGETABLE_FREQ)
&& (rig->caps->targetable_vfo & RIG_TARGETABLE_MODE))
{
ret = rig_get_vfo_info(rig, vfoB, &freqB, &modeB, &widthB, &split, &satmode);
if (ret != RIG_OK) RETURNFUNC(ret);
ret = rig_get_vfo_info(rig, vfoB, &freqB, &modeB, &widthB, &split, &satmode);
if (ret != RIG_OK) { RETURNFUNC(ret); }
}
else
{
// we'll use cached info instead of doing the vfo swapping
int cache_ms_freq, cache_ms_mode, cache_ms_width;
rig_get_cache(rig, vfoB, &freqB, &cache_ms_freq, &modeB, &cache_ms_mode, &widthB,
rig_get_cache(rig, vfoB, &freqB, &cache_ms_freq, &modeB, &cache_ms_mode,
&widthB,
&cache_ms_width);
}
modeAstr = (char*)rig_strrmode(modeA);
modeBstr = (char*)rig_strrmode(modeB);
if (modeAstr[0]==0) modeAstr="None";
if (modeBstr[0]==0) modeBstr="None";
modeAstr = (char *)rig_strrmode(modeA);
modeBstr = (char *)rig_strrmode(modeB);
if (modeAstr[0] == 0) { modeAstr = "None"; }
if (modeBstr[0] == 0) { modeBstr = "None"; }
rxa = 1;
txa = split == 0;
rxb = !rxa;
txb = split == 1;
snprintf(response,max_response_len,"VFO=%s Freq=%.0f Mode=%s Width=%d RX=%d TX=%d\nVFO=%s Freq=%.0f Mode=%s Width=%d RX=%d TX=%d\nSplit=%d SatMode=%d", rig_strvfo(vfoA), freqA, modeAstr, (int)widthA, rxa, txa, rig_strvfo(vfoB), freqB, modeBstr, (int)widthB, rxb, txb, split, satmode);
snprintf(response, max_response_len,
"VFO=%s Freq=%.0f Mode=%s Width=%d RX=%d TX=%d\nVFO=%s Freq=%.0f Mode=%s Width=%d RX=%d TX=%d\nSplit=%d SatMode=%d",
rig_strvfo(vfoA), freqA, modeAstr, (int)widthA, rxa, txa, rig_strvfo(vfoB),
freqB, modeBstr, (int)widthB, rxb, txb, split, satmode);
RETURNFUNC(RIG_OK);
}
@ -6281,7 +6303,7 @@ 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; }
vfo = vfo_fixup(rig,vfo);
vfo = vfo_fixup(rig, vfo);
// we can't use the cached values as some clients may only call this function
// like Log4OM which mostly does polling
TRACE;

10
tests/rigctl.c
Wyświetl plik

@ -524,17 +524,21 @@ int main(int argc, char *argv[])
{
// if rigctld then we need to open to get the rig caps
if (my_model == RIG_MODEL_NETRIGCTL) {
if (my_model == RIG_MODEL_NETRIGCTL)
{
int ret;
rig_set_debug(verbose);
my_rig = rig_init(my_model);
if((ret=rig_open(my_rig)) != RIG_OK)
if ((ret = rig_open(my_rig)) != RIG_OK)
{
fprintf(stderr,"Unable to open rigctld: %s\n", rigerror(ret));
fprintf(stderr, "Unable to open rigctld: %s\n", rigerror(ret));
exit(1);
}
rig_close(my_rig);
}
dumpcaps(my_rig, stdout);
rig_cleanup(my_rig); /* if you care about memory */
exit(0);

18
tests/rigctl_parse.c
Wyświetl plik

@ -2221,8 +2221,10 @@ declare_proto_rig(get_rig_info)
int ret;
ENTERFUNC;
ret = rig_get_rig_info(rig, buf, sizeof(buf));
if (ret != RIG_OK) RETURNFUNC(ret);
fprintf(fout,"%s\n", buf);
if (ret != RIG_OK) { RETURNFUNC(ret); }
fprintf(fout, "%s\n", buf);
RETURNFUNC(RIG_OK);
}
@ -4354,20 +4356,24 @@ declare_proto_rig(dump_state)
fprintf(fout, "has_mW2power=%d\n", rig->caps->mW2power != NULL);
fprintf(fout, "timeout=%d\n", rig->caps->timeout);
fprintf(fout, "ctcss_list=");
for (i = 0; i < CTCSS_LIST_SIZE && rig->caps->ctcss_list[i] != 0; i++)
{
fprintf(fout,
" %u.%1u",
rig->caps->ctcss_list[i] / 10, rig->caps->ctcss_list[i] % 10);
" %u.%1u",
rig->caps->ctcss_list[i] / 10, rig->caps->ctcss_list[i] % 10);
}
fprintf(fout, "\n");
fprintf(fout, "dcs_list=");
for (i = 0; i < DCS_LIST_SIZE && rig->caps->dcs_list[i] != 0; i++)
{
fprintf(fout,
" %u",
rig->caps->dcs_list[i]);
" %u",
rig->caps->dcs_list[i]);
}
fprintf(fout, "\n");
fprintf(fout, "done\n");