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

Change sprintf to SNPRINTF for kenwood files

pull/928/head
Mike Black W9MDB 2022-01-10 23:03:54 -06:00
rodzic b0ae08f7b7
commit 18f69356c9
22 zmienionych plików z 242 dodań i 285 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

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

@ -441,7 +441,7 @@ static int flex6k_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
return -RIG_EINVAL;
}
sprintf(buf, "MD%c", '0' + kmode);
SNPRINTF(buf, sizeof(buf), "MD%c", '0' + kmode);
err = kenwood_transaction(rig, buf, NULL, 0);
if (err != RIG_OK)
@ -471,11 +471,11 @@ static int flex6k_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
switch (vfo)
{
case RIG_VFO_A:
sprintf(buf, "ZZFI%02d;", idx);
SNPRINTF(buf, sizeof(buf), "ZZFI%02d;", idx);
break;
case RIG_VFO_B:
sprintf(buf, "ZZFJ%02d;", idx);
SNPRINTF(buf, sizeof(buf), "ZZFJ%02d;", idx);
break;
default:
@ -513,7 +513,7 @@ static int powersdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
return -RIG_EINVAL;
}
sprintf(buf, "ZZMD%02d", kmode);
SNPRINTF(buf, sizeof(buf), "ZZMD%02d", kmode);
err = kenwood_transaction(rig, buf, NULL, 0);
if (err != RIG_OK)
@ -548,11 +548,11 @@ static int powersdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
// 150Hz on the low end should be enough
// Set high to the width requested
sprintf(buf, "ZZFL00150;ZZFH%05d;", (int)width);
SNPRINTF(buf, sizeof(buf), "ZZFL00150;ZZFH%05d;", (int)width);
}
else
{
sprintf(buf, "ZZFI%02d;", idx);
SNPRINTF(buf, sizeof(buf), "ZZFI%02d;", idx);
}
break;

98
rigs/kenwood/ic10.c
Wyświetl plik

@ -186,7 +186,7 @@ static int get_ic10_if(RIG *rig, char *data)
int ic10_set_vfo(RIG *rig, vfo_t vfo)
{
char cmdbuf[6];
int cmd_len, retval;
int retval;
char vfo_function;
switch (vfo)
@ -208,9 +208,9 @@ int ic10_set_vfo(RIG *rig, vfo_t vfo)
return -RIG_EINVAL;
}
cmd_len = sprintf(cmdbuf, "FN%c;", vfo_function);
SNPRINTF(cmdbuf, sizeof(cmdbuf), "FN%c;", vfo_function);
retval = ic10_transaction(rig, cmdbuf, cmd_len, NULL, 0);
retval = ic10_transaction(rig, cmdbuf, strlen(cmdbuf), NULL, 0);
return retval;
}
@ -373,7 +373,7 @@ int ic10_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
int ic10_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
char modebuf[6];
int mode_len, retval;
int retval;
char mode_letter;
switch (mode)
@ -396,8 +396,8 @@ int ic10_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
return -RIG_EINVAL;
}
mode_len = sprintf(modebuf, "MD%c;", mode_letter);
retval = ic10_transaction(rig, modebuf, mode_len, NULL, 0);
SNPRINTF(modebuf, sizeof(modebuf), "MD%c;", mode_letter);
retval = ic10_transaction(rig, modebuf, strlen(modebuf), NULL, 0);
return retval;
}
@ -442,7 +442,7 @@ int ic10_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
int ic10_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
char freqbuf[64];
int freq_len, retval;
int retval;
unsigned char vfo_letter;
vfo_t tvfo;
@ -470,8 +470,8 @@ int ic10_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
}
// cppcheck-suppress *
freq_len = sprintf(freqbuf, "F%c%011"PRIll";", vfo_letter, (int64_t)freq);
retval = ic10_transaction(rig, freqbuf, freq_len, NULL, 0);
SNPRINTF(freqbuf, sizeof(freqbuf), "F%c%011"PRIll";", vfo_letter, (int64_t)freq);
retval = ic10_transaction(rig, freqbuf, strlen(freqbuf), NULL, 0);
return retval;
}
@ -484,11 +484,11 @@ int ic10_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
int ic10_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option)
{
char buf[6], ackbuf[64];
int len, ack_len, retval;
int ack_len, retval;
len = sprintf(buf, "AN%c;", ant == RIG_ANT_1 ? '1' : '2');
SNPRINTF(buf, sizeof(buf), "AN%c;", ant == RIG_ANT_1 ? '1' : '2');
retval = ic10_transaction(rig, buf, len, ackbuf, &ack_len);
retval = ic10_transaction(rig, buf, strlen(buf), ackbuf, &ack_len);
return retval;
}
@ -562,7 +562,7 @@ int ic10_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
int ic10_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
{
char pttbuf[4];
int ptt_len, retval;
int retval;
unsigned char ptt_letter;
rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
@ -579,8 +579,8 @@ int ic10_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
return -RIG_EINVAL;
}
ptt_len = sprintf(pttbuf, "%cX;", ptt_letter);
retval = ic10_transaction(rig, pttbuf, ptt_len, NULL, 0);
SNPRINTF(pttbuf, sizeof(pttbuf), "%cX;", ptt_letter);
retval = ic10_transaction(rig, pttbuf, strlen(pttbuf), NULL, 0);
return retval;
}
@ -622,11 +622,11 @@ int ic10_get_mem(RIG *rig, vfo_t vfo, int *ch)
int ic10_set_mem(RIG *rig, vfo_t vfo, int ch)
{
char membuf[8], ackbuf[64];
int mem_len, ack_len, retval;
int ack_len, retval;
mem_len = sprintf(membuf, "MC%02d;", ch);
SNPRINTF(membuf, sizeof(membuf), "MC%02d;", ch);
retval = ic10_transaction(rig, membuf, mem_len, ackbuf, &ack_len);
retval = ic10_transaction(rig, membuf, strlen(membuf), ackbuf, &ack_len);
return retval;
}
@ -635,11 +635,11 @@ int ic10_set_mem(RIG *rig, vfo_t vfo, int ch)
int ic10_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
{
char membuf[16], infobuf[32];
int retval, info_len, len;
int retval, info_len;
len = sprintf(membuf, "MR00%02d;", chan->channel_num);
SNPRINTF(membuf, sizeof(membuf), "MR00%02d;", chan->channel_num);
info_len = 24;
retval = ic10_transaction(rig, membuf, len, infobuf, &info_len);
retval = ic10_transaction(rig, membuf, strlen(membuf), infobuf, &info_len);
if (retval != RIG_OK)
{
@ -679,9 +679,9 @@ int ic10_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
{
chan->split = 1;
/* TX VFO (Split channel only) */
len = sprintf(membuf, "MR10%02d;", chan->channel_num);
SNPRINTF(membuf, sizeof(membuf), "MR10%02d;", chan->channel_num);
info_len = 24;
retval = ic10_transaction(rig, membuf, len, infobuf, &info_len);
retval = ic10_transaction(rig, membuf, strlen(membuf), infobuf, &info_len);
if (retval == RIG_OK && info_len > 17)
{
@ -732,7 +732,7 @@ int ic10_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
int ic10_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
{
char membuf[64];
int retval, len, md;
int retval, md;
int64_t freq;
freq = (int64_t) chan->freq;
@ -767,12 +767,12 @@ int ic10_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
}
/* MWnxrrggmmmkkkhhhdzxxxx; */
len = sprintf(membuf, "MW0 %02d%011"PRIll"%c0 ;",
SNPRINTF(membuf, sizeof(membuf), "MW0 %02d%011"PRIll"%c0 ;",
chan->channel_num,
freq,
md
);
retval = ic10_transaction(rig, membuf, len, NULL, 0);
retval = ic10_transaction(rig, membuf, strlen(membuf), NULL, 0);
if (retval != RIG_OK)
{
@ -807,12 +807,12 @@ int ic10_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
if (chan->channel_num >= 90)
{
/* MWnxrrggmmmkkkhhhdzxxxx; */
len = sprintf(membuf, "MW1 %02d%011"PRIll"%c0 ;",
SNPRINTF(membuf, sizeof(membuf), "MW1 %02d%011"PRIll"%c0 ;",
chan->channel_num,
freq,
md
);
retval = ic10_transaction(rig, membuf, len, NULL, 0);
retval = ic10_transaction(rig, membuf, strlen(membuf), NULL, 0);
// I assume we need to check the retval here -- W9MDB
// This was found from cppcheck
@ -835,13 +835,13 @@ int ic10_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
int ic10_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
{
char cmdbuf[6], fctbuf[50];
int cmdlen, fct_len, retval;
int fct_len, retval;
fct_len = 4;
switch (func)
{
case RIG_FUNC_LOCK: cmdlen = sprintf(cmdbuf, "LK;"); break;
case RIG_FUNC_LOCK: SNPRINTF(cmdbuf, sizeof(cmdbuf), "LK;"); break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported get_func %s",
@ -849,7 +849,7 @@ int ic10_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
return -RIG_EINVAL;
}
retval = ic10_transaction(rig, cmdbuf, cmdlen, fctbuf, &fct_len);
retval = ic10_transaction(rig, cmdbuf, strlen(cmdbuf), fctbuf, &fct_len);
if (retval != RIG_OK)
{
@ -876,18 +876,12 @@ int ic10_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
int ic10_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
{
char cmdbuf[4], fctbuf[16], ackbuf[64];
int cmdlen, fct_len, ack_len;
int ack_len;
switch (func)
{
case RIG_FUNC_LOCK:
cmdlen = sprintf(cmdbuf, "LK");
if (cmdlen < 0)
{
return -RIG_ETRUNC;
}
SNPRINTF(cmdbuf, sizeof(cmdbuf), "LK");
break;
default:
@ -896,14 +890,9 @@ int ic10_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
return -RIG_EINVAL;
}
fct_len = sprintf(fctbuf, "%s%c;", cmdbuf, status == 0 ? '0' : '1');
SNPRINTF(fctbuf, sizeof(fctbuf), "%s%c;", cmdbuf, status == 0 ? '0' : '1');
if (fct_len < 0)
{
return -RIG_ETRUNC;
}
return ic10_transaction(rig, fctbuf, fct_len, ackbuf, &ack_len);
return ic10_transaction(rig, fctbuf, strlen(fctbuf), ackbuf, &ack_len);
}
@ -914,7 +903,6 @@ int ic10_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
int ic10_set_parm(RIG *rig, setting_t parm, value_t val)
{
char cmdbuf[50];
int cmd_len;
int hours;
int minutes;
int seconds;
@ -926,8 +914,8 @@ int ic10_set_parm(RIG *rig, setting_t parm, value_t val)
hours = minutes / 60;
seconds = val.i - (minutes * 60);
minutes = minutes % 60;
cmd_len = sprintf(cmdbuf, "CK1%02d%02d%02d;", hours, minutes, seconds);
return ic10_transaction(rig, cmdbuf, cmd_len, NULL, NULL);
SNPRINTF(cmdbuf, sizeof(cmdbuf), "CK1%02d%02d%02d;", hours, minutes, seconds);
return ic10_transaction(rig, cmdbuf, strlen(cmdbuf), NULL, NULL);
break;
default:
@ -996,11 +984,11 @@ int ic10_get_parm(RIG *rig, setting_t parm, value_t *val)
int ic10_set_powerstat(RIG *rig, powerstat_t status)
{
char pwrbuf[16], ackbuf[64];
int pwr_len, ack_len;
int ack_len;
pwr_len = sprintf(pwrbuf, "PS%c;", status == RIG_POWER_ON ? '1' : '0');
SNPRINTF(pwrbuf, sizeof(pwrbuf), "PS%c;", status == RIG_POWER_ON ? '1' : '0');
return ic10_transaction(rig, pwrbuf, pwr_len, ackbuf, &ack_len);
return ic10_transaction(rig, pwrbuf, strlen(pwrbuf), ackbuf, &ack_len);
}
@ -1041,11 +1029,11 @@ int ic10_get_powerstat(RIG *rig, powerstat_t *status)
int ic10_set_trn(RIG *rig, int trn)
{
char trnbuf[16], ackbuf[64];
int trn_len, ack_len;
int ack_len;
trn_len = sprintf(trnbuf, "AI%c;", trn == RIG_TRN_RIG ? '1' : '0');
SNPRINTF(trnbuf, sizeof(trnbuf), "AI%c;", trn == RIG_TRN_RIG ? '1' : '0');
return ic10_transaction(rig, trnbuf, trn_len, ackbuf, &ack_len);
return ic10_transaction(rig, trnbuf, strlen(trnbuf), ackbuf, &ack_len);
}

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

@ -1609,7 +1609,7 @@ int k3_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width)
return -RIG_EINVAL;
}
sprintf(buf, "MD$%c", '0' + kmode);
snprintf(buf, sizeof(buf), "MD$%c", '0' + kmode);
err = kenwood_transaction(rig, buf, NULL, 0);
if (err != RIG_OK)

30
rigs/kenwood/pihpsdr.c
Wyświetl plik

@ -361,7 +361,7 @@ int pihspdr_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
}
/* put channel num in the command string */
sprintf(cmd, "MR0%03d;", chan->channel_num);
SNPRINTF(cmd, sizeof(cmd), "MR0%03d;", chan->channel_num);
err = kenwood_transaction(rig, cmd, buf, sizeof(buf));
@ -735,7 +735,7 @@ int pihspdr_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
}
/* P-number 2-3 4 5 6 7 8 9 101112 13 141516 */
sprintf(buf, "MW0%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;",
SNPRINTF(buf, sizeof(buf), "MW0%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;",
chan->channel_num,
(unsigned) chan->freq, /* 4 - frequency */
'0' + mode, /* 5 - mode */
@ -807,20 +807,20 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
case RIG_LEVEL_RFPOWER:
/* level is float between 0.0 and 1.0, maps to 0 ... 100 */
kenwood_val = val.f * 100;
sprintf(levelbuf, "PC%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "PC%03d", kenwood_val);
break;
case RIG_LEVEL_AF:
sprintf(levelbuf, "AG%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "AG%03d", kenwood_val);
break;
case RIG_LEVEL_RF:
/* XXX check level range */
sprintf(levelbuf, "RG%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "RG%03d", kenwood_val);
break;
case RIG_LEVEL_SQL:
sprintf(levelbuf, "SQ%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "SQ%03d", kenwood_val);
break;
case RIG_LEVEL_AGC:
@ -830,7 +830,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
else if (kenwood_val == RIG_AGC_MEDIUM) { kenwood_val = 15; }
else if (kenwood_val == RIG_AGC_SLOW) { kenwood_val = 20; }
sprintf(levelbuf, "GT%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "GT%03d", kenwood_val);
break;
case RIG_LEVEL_ATT:
@ -838,7 +838,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
/* set the attenuator if a correct value is entered */
if (val.i == 0)
{
sprintf(levelbuf, "RA00");
SNPRINTF(levelbuf, sizeof(levelbuf), "RA00");
}
else
{
@ -848,7 +848,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
if (val.i == rig->state.attenuator[i])
{
sprintf(levelbuf, "RA%02d", i + 1);
SNPRINTF(levelbuf, sizeof(levelbuf), "RA%02d", i + 1);
foundit = 1;
break;
}
@ -867,7 +867,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
/* set the preamp if a correct value is entered */
if (val.i == 0)
{
sprintf(levelbuf, "PA0");
SNPRINTF(levelbuf, sizeof(levelbuf), "PA0");
}
else
{
@ -877,7 +877,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
if (val.i == rig->state.preamp[i])
{
sprintf(levelbuf, "PA%01d", i + 1);
SNPRINTF(levelbuf, sizeof(levelbuf), "PA%01d", i + 1);
foundit = 1;
break;
}
@ -897,7 +897,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return -RIG_EINVAL;
}
sprintf(levelbuf, "SH%02d", (val.i));
SNPRINTF(levelbuf, sizeof(levelbuf), "SH%02d", (val.i));
break;
case RIG_LEVEL_SLOPE_LOW:
@ -906,7 +906,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return -RIG_EINVAL;
}
sprintf(levelbuf, "SL%02d", (val.i));
SNPRINTF(levelbuf, sizeof(levelbuf), "SL%02d", (val.i));
break;
case RIG_LEVEL_CWPITCH:
@ -915,7 +915,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return -RIG_EINVAL;
}
sprintf(levelbuf, "PT%02d", (val.i / 50) - 8);
SNPRINTF(levelbuf, sizeof(levelbuf), "PT%02d", (val.i / 50) - 8);
break;
case RIG_LEVEL_KEYSPD:
@ -924,7 +924,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return -RIG_EINVAL;
}
sprintf(levelbuf, "KS%03d", val.i);
SNPRINTF(levelbuf, sizeof(levelbuf), "KS%03d", val.i);
break;
default:

84
rigs/kenwood/th.c
Wyświetl plik

@ -243,7 +243,7 @@ th_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
freq_sent = freq_sent >= MHz(470) ? (round(freq_sent / 10000) * 10000) :
freq_sent;
// cppcheck-suppress *
sprintf(buf, "FQ %011"PRIll",%X", (int64_t) freq_sent, step);
SNPRINTF(buf, sizeof(buf), "FQ %011"PRIll",%X", (int64_t) freq_sent, step);
return kenwood_transaction(rig, buf, buf, sizeof buf);
}
@ -335,7 +335,7 @@ th_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
}
}
sprintf(mdbuf, "MD %c", kmode);
SNPRINTF(mdbuf, sizeof(mdbuf), "MD %c", kmode);
return kenwood_transaction(rig, mdbuf, mdbuf, sizeof mdbuf);
}
@ -570,7 +570,7 @@ th_get_vfo_char(RIG *rig, vfo_t *vfo, char *vfoch)
/* Get mode of the VFO band */
sprintf(cmdbuf, "VMC %c", vfoc);
SNPRINTF(cmdbuf, sizeof(cmdbuf), "VMC %c", vfoc);
retval = kenwood_safe_transaction(rig, cmdbuf, buf, 10, 7);
@ -1154,7 +1154,7 @@ th_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
switch (level)
{
case RIG_LEVEL_RAWSTR:
sprintf(buf, "SM %c", vch);
SNPRINTF(buf, sizeof(buf), "SM %c", vch);
// XXX use kenwood_safe_transaction
retval = kenwood_transaction(rig, buf, ackbuf, sizeof(ackbuf));
@ -1177,7 +1177,7 @@ th_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break;
case RIG_LEVEL_SQL:
sprintf(buf, "SQ %c", vch);
SNPRINTF(buf, sizeof(buf), "SQ %c", vch);
retval = kenwood_safe_transaction(rig, buf, ackbuf, 10, 7);
if (retval != RIG_OK)
@ -1201,7 +1201,7 @@ th_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break;
case RIG_LEVEL_AF:
sprintf(buf, "AG %c", vch);
SNPRINTF(buf, sizeof(buf), "AG %c", vch);
retval = kenwood_transaction(rig, buf, ackbuf, sizeof(ackbuf));
if (retval != RIG_OK)
@ -1225,7 +1225,7 @@ th_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break;
case RIG_LEVEL_RFPOWER:
sprintf(buf, "PC %c", vch);
SNPRINTF(buf, sizeof(buf), "PC %c", vch);
retval = kenwood_transaction(rig, buf, ackbuf, sizeof(ackbuf));
if (retval != RIG_OK)
@ -1345,7 +1345,7 @@ int th_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
case RIG_LEVEL_RFPOWER :
sprintf(buf, "PC %c,%01d", vch,
SNPRINTF(buf, sizeof(buf), "PC %c,%01d", vch,
(int)(val.f * (rig->caps->level_gran[LVL_RFPOWER].max.i -
rig->caps->level_gran[LVL_RFPOWER].min.i))
+ rig->caps->level_gran[LVL_RFPOWER].min.i);
@ -1353,26 +1353,26 @@ int th_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return kenwood_transaction(rig, buf, NULL, 0);
case RIG_LEVEL_SQL :
sprintf(buf, "SQ %c,%02x", vch,
SNPRINTF(buf, sizeof(buf), "SQ %c,%02x", vch,
(int)(val.f * (rig->caps->level_gran[LVL_SQL].max.i -
rig->caps->level_gran[LVL_SQL].min.i))
+ rig->caps->level_gran[LVL_SQL].min.i);
return kenwood_transaction(rig, buf, NULL, 0);
case RIG_LEVEL_AF :
sprintf(buf, "AG %c,%02x", vch, (int)(val.f * 32.0));
SNPRINTF(buf, sizeof(buf), "AG %c,%02x", vch, (int)(val.f * 32.0));
return kenwood_transaction(rig, buf, NULL, 0);
case RIG_LEVEL_ATT :
sprintf(buf, "ATT %c", val.i ? '1' : '0');
SNPRINTF(buf, sizeof(buf), "ATT %c", val.i ? '1' : '0');
return kenwood_transaction(rig, buf, NULL, 0);
case RIG_LEVEL_BALANCE :
sprintf(buf, "BAL %c", '4' - (int)(val.f * ('4' - '0')));
SNPRINTF(buf, sizeof(buf), "BAL %c", '4' - (int)(val.f * ('4' - '0')));
return kenwood_transaction(rig, buf, NULL, 0);
case RIG_LEVEL_VOXGAIN:
sprintf(buf, "VXG %d", (int)(val.f * 9));
SNPRINTF(buf, sizeof(buf), "VXG %d", (int)(val.f * 9));
return kenwood_transaction(rig, buf, NULL, 0);
case RIG_LEVEL_VOXDELAY: /* "VXD" */
@ -1949,11 +1949,11 @@ int th_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
if (chan_caps[1].type == RIG_MTYPE_PRIO)
{
/* Info */
sprintf(req, "MR %s0,I-%01d", mr_extra, channel_num);
SNPRINTF(req, sizeof(req), "MR %s0,I-%01d", mr_extra, channel_num);
}
else
{
sprintf(req, "MR %s0,%03d", mr_extra, channel_num);
SNPRINTF(req, sizeof(req), "MR %s0,%03d", mr_extra, channel_num);
}
break;
@ -1962,12 +1962,12 @@ int th_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
if (chan_caps[1].type == RIG_MTYPE_EDGE)
{
snprintf(req, sizeof(req), "MR %s0,L%01d", mr_extra, channel_num);
sprintf(chan->channel_desc, "L%01d", channel_num);
SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "L%01d", channel_num);
}
else
{
snprintf(req, sizeof(req), "MR %s0,U%01d", mr_extra, channel_num);
sprintf(chan->channel_desc, "U%01d", channel_num);
SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "U%01d", channel_num);
}
break;
@ -1976,35 +1976,35 @@ int th_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
if (chan_caps->startc == chan_caps->endc)
{
snprintf(req, sizeof(req), "MR %s0,PR", mr_extra);
sprintf(chan->channel_desc, "Pr");
SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Pr");
}
else
{
snprintf(req, sizeof(req), "MR %s0,PR%01d", mr_extra, channel_num + 1);
sprintf(chan->channel_desc, "Pr%01d", channel_num + 1);
SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Pr%01d", channel_num + 1);
}
break;
case RIG_MTYPE_CALL:
sprintf(req, "CR 0,%01d", channel_num);
SNPRINTF(req, sizeof(req), "CR 0,%01d", channel_num);
if (chan->channel_num == chan_caps->startc) { sprintf(chan->channel_desc, "Call V"); }
else if (chan->channel_num == chan_caps->endc) { sprintf(chan->channel_desc, "Call U"); }
else { sprintf(chan->channel_desc, "Call"); }
if (chan->channel_num == chan_caps->startc) { SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Call V"); }
else if (chan->channel_num == chan_caps->endc) { SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Call U"); }
else { SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Call"); }
break;
case RIG_MTYPE_BAND:
sprintf(req, "VR %01X", channel_num);
sprintf(chan->channel_desc, "BAND %01X", channel_num);
SNPRINTF(req, sizeof(req), "VR %01X", channel_num);
SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "BAND %01X", channel_num);
break;
default:
return -RIG_EINVAL;
}
sprintf(membuf, "%s", req);
SNPRINTF(membuf, sizeof(membuf), "%s", req);
retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf));
@ -2140,7 +2140,7 @@ int th_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
{
/* split ? */
req[3 + strlen(mr_extra)] = '1';
sprintf(membuf, "%s", req);
SNPRINTF(membuf, sizeof(membuf), "%s", req);
retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf));
if (retval == RIG_OK)
@ -2160,11 +2160,11 @@ int th_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
if (chan_caps[1].type == RIG_MTYPE_PRIO)
{
sprintf(membuf, "MNA %sI-%01d", mr_extra, channel_num);
SNPRINTF(membuf, sizeof(membuf), "MNA %sI-%01d", mr_extra, channel_num);
}
else
{
sprintf(membuf, "MNA %s%03d", mr_extra, channel_num);
SNPRINTF(membuf, sizeof(membuf), "MNA %s%03d", mr_extra, channel_num);
}
/* Get memory name */
@ -2343,13 +2343,13 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
if (chan_caps[1].type == RIG_MTYPE_PRIO)
{
/* Info */
sprintf(req, "MW %s0,I-%01d", mr_extra, channel_num);
SNPRINTF(req, sizeof(req), "MW %s0,I-%01d", mr_extra, channel_num);
channel_desc = chan->channel_desc;
}
else
{
/* Regular */
sprintf(req, "MW %s0,%03d", mr_extra, channel_num);
SNPRINTF(req, sizeof(req), "MW %s0,%03d", mr_extra, channel_num);
channel_desc = chan->channel_desc;
}
@ -2358,11 +2358,11 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
case RIG_MTYPE_EDGE:
if (chan_caps[1].type == RIG_MTYPE_EDGE)
{
sprintf(req, "MW %s0,L%01d", mr_extra, channel_num);
SNPRINTF(req, sizeof(req), "MW %s0,L%01d", mr_extra, channel_num);
}
else
{
sprintf(req, "MW %s0,U%01d", mr_extra, channel_num);
SNPRINTF(req, sizeof(req), "MW %s0,U%01d", mr_extra, channel_num);
}
break;
@ -2370,21 +2370,21 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
case RIG_MTYPE_PRIO:
if (chan_caps->startc == chan_caps->endc)
{
sprintf(req, "MW %s0,PR", mr_extra);
SNPRINTF(req, sizeof(req), "MW %s0,PR", mr_extra);
}
else
{
sprintf(req, "MW %s0,PR%01d", mr_extra, channel_num + 1);
SNPRINTF(req, sizeof(req), "MW %s0,PR%01d", mr_extra, channel_num + 1);
}
break;
case RIG_MTYPE_CALL:
sprintf(req, "CW 0,%01d", channel_num);
SNPRINTF(req, sizeof(req), "CW 0,%01d", channel_num);
break;
case RIG_MTYPE_BAND:
sprintf(req, "VW %01X", channel_num);
SNPRINTF(req, sizeof(req), "VW %01X", channel_num);
break;
default:
@ -2396,7 +2396,7 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
if (chan_caps->mem_caps.flags)
{
sprintf(lockoutstr, ",%d", lockout);
SNPRINTF(lockoutstr, sizeof(lockoutstr), ",%d", lockout);
}
else
{
@ -2435,7 +2435,7 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
{
/* Without DCS,mode */
sprintf(membuf, "%s,%011"PRIll",%X,%d,%d,%d,%d,,%02d,,%02d,%09"PRIll"%s",
SNPRINTF(membuf, sizeof(membuf), "%s,%011"PRIll",%X,%d,%d,%d,%d,,%02d,,%02d,%09"PRIll"%s",
req, (int64_t)chan->freq, step, shift, rev, tone,
ctcss, tonefq, ctcssfq,
(int64_t)labs((long)(chan->rptr_offs)), lockoutstr
@ -2457,7 +2457,7 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
req[3 + strlen(mr_extra)] = '1';
sprintf(membuf, "%s,%011"PRIll",%X", req, (int64_t)chan->tx_freq, step);
SNPRINTF(membuf, sizeof(membuf), "%s,%011"PRIll",%X", req, (int64_t)chan->tx_freq, step);
retval = kenwood_transaction(rig, membuf, membuf, sizeof membuf);
if (retval != RIG_OK)
@ -2472,11 +2472,11 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
/* TODO: check strlen(channel_desc) < rig->caps->chan_desc_sz */
if (chan_caps[1].type == RIG_MTYPE_PRIO)
{
sprintf(membuf, "MNA %sI-%01d,%s", mr_extra, channel_num, channel_desc);
SNPRINTF(membuf, sizeof(membuf), "MNA %sI-%01d,%s", mr_extra, channel_num, channel_desc);
}
else
{
sprintf(membuf, "MNA %s%03d,%s", mr_extra, channel_num, channel_desc);
SNPRINTF(membuf, sizeof(membuf), "MNA %s%03d,%s", mr_extra, channel_num, channel_desc);
}
retval = kenwood_transaction(rig, membuf, membuf, sizeof membuf);

34
rigs/kenwood/thd72.c
Wyświetl plik

@ -208,7 +208,7 @@ static int thd72_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
vfonum = '1';
}
sprintf(vfobuf, "BC %c", vfonum);
SNPRINTF(vfobuf, sizeof(vfobuf), "BC %c", vfonum);
retval = kenwood_transaction(rig, vfobuf, NULL, 0);
if (retval != RIG_OK)
@ -275,7 +275,7 @@ static int thd72_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
}
/* Set VFO mode */
sprintf(vfobuf, "VMC 0,0");
SNPRINTF(vfobuf, sizeof(vfobuf), "VMC 0,0");
retval = kenwood_transaction(rig, vfobuf, NULL, 0);
if (retval != RIG_OK)
@ -283,7 +283,7 @@ static int thd72_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
return retval;
}
sprintf(vfobuf, "VMC 1,0");
SNPRINTF(vfobuf, sizeof(vfobuf), "VMC 1,0");
retval = kenwood_transaction(rig, vfobuf, NULL, 0);
if (retval != RIG_OK)
@ -291,7 +291,7 @@ static int thd72_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
return retval;
}
sprintf(vfobuf, "BC 1"); // leave VFOB as selected VFO
SNPRINTF(vfobuf, sizeof(vfobuf), "BC 1"); // leave VFOB as selected VFO
retval = kenwood_transaction(rig, vfobuf, NULL, 0);
if (retval != RIG_OK)
@ -378,7 +378,7 @@ static int thd72_get_freq_info(RIG *rig, vfo_t vfo, char *buf)
return retval;
}
sprintf(cmd, "FO %c", c);
SNPRINTF(cmd, sizeof(cmd), "FO %c", c);
retval = kenwood_transaction(rig, cmd, buf, 53);
return retval;
}
@ -457,7 +457,7 @@ static int thd72_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
(int)ts);
freq = roundl(freq / ts) * ts;
// cppcheck-suppress *
sprintf(fbuf, "%010"PRIll, (int64_t)freq);
SNPRINTF(fbuf, sizeof(fbuf), "%010"PRIll, (int64_t)freq);
memcpy(buf + 5, fbuf, 10);
retval = kenwood_simple_transaction(rig, buf, 52);
return retval;
@ -580,7 +580,7 @@ static int thd72_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t offs)
return retval;
}
sprintf(boff, "%08ld", offs);
SNPRINTF(boff, sizeof(boff), "%08ld", offs);
memcpy(buf + 42, boff, 8);
retval = kenwood_simple_transaction(rig, buf, 52);
return retval;
@ -672,7 +672,7 @@ static int thd72_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
}
buf[22] = (tone == 0) ? '0' : '1';
sprintf(tmp, "%02d", tinx);
SNPRINTF(tmp, sizeof(tmp), "%02d", tinx);
memcpy(buf + 30, tmp, 2);
return kenwood_simple_transaction(rig, buf, 52);
}
@ -745,7 +745,7 @@ static int thd72_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code)
}
buf[26] = (code == 0) ? '0' : '1';
sprintf(tmp, "%03d", cinx);
SNPRINTF(tmp, sizeof(tmp), "%03d", cinx);
memcpy(buf + 36, tmp, 3);
return kenwood_simple_transaction(rig, buf, 52);
}
@ -810,7 +810,7 @@ static int thd72_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
}
buf[24] = (tone == 0) ? '0' : '1';
sprintf(tmp, "%02d", tinx);
SNPRINTF(tmp, sizeof(tmp), "%02d", tinx);
memcpy(buf + 33, tmp, 2);
return kenwood_simple_transaction(rig, buf, 52);
}
@ -943,7 +943,7 @@ static int thd72_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
else if (val.f <= 0.10) { lvlc = '1'; }
else { lvlc = '0'; }
sprintf(cmd, "PC %c,%c", c, lvlc);
SNPRINTF(cmd, sizeof(cmd), "PC %c,%c", c, lvlc);
return kenwood_simple_transaction(rig, cmd, 6);
case RIG_LEVEL_VOXGAIN:
@ -958,7 +958,7 @@ static int thd72_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
case RIG_LEVEL_SQL:
lvlc = '0' + (int)(val.f * 5);
sprintf(cmd, "PC %c,%c", c, lvlc);
SNPRINTF(cmd, sizeof(cmd), "PC %c,%c", c, lvlc);
return kenwood_simple_transaction(rig, cmd, 6);
case RIG_LEVEL_BALANCE:
@ -992,7 +992,7 @@ static int thd72_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
switch (level)
{
case RIG_LEVEL_RFPOWER:
sprintf(cmd, "PC %c", c);
SNPRINTF(cmd, sizeof(cmd), "PC %c", c);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK)
@ -1044,7 +1044,7 @@ static int thd72_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break;
case RIG_LEVEL_SQL:
sprintf(cmd, "SQ %c", c);
SNPRINTF(cmd, sizeof(cmd), "SQ %c", c);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK)
@ -1241,7 +1241,7 @@ static int thd72_set_mem(RIG *rig, vfo_t vfo, int ch)
return retval;
}
sprintf(cmd, "MR %c,%03d", c, ch);
SNPRINTF(cmd, sizeof(cmd), "MR %c,%03d", c, ch);
return kenwood_simple_transaction(rig, cmd, 10);
}
@ -1259,7 +1259,7 @@ static int thd72_get_mem(RIG *rig, vfo_t vfo, int *ch)
return retval;
}
sprintf(cmd, "MR %c", c);
SNPRINTF(cmd, sizeof(cmd), "MR %c", c);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK)
@ -1370,7 +1370,7 @@ static int thd72_get_channel(RIG *rig, vfo_t vfo, channel_t *chan,
{
int len;
char cmd[16];
sprintf(cmd, "ME %03d", chan->channel_num);
SNPRINTF(cmd, sizeof(cmd), "ME %03d", chan->channel_num);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK)

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

@ -275,7 +275,7 @@ static int thd74_get_freq_info(RIG *rig, vfo_t vfo, char *buf)
return retval;
}
sprintf(cmd, "FO %c", c);
SNPRINTF(cmd, sizeof(cmd), "FO %c", c);
retval = kenwood_transaction(rig, cmd, buf, 73);
return retval;
}
@ -420,7 +420,7 @@ static int thd74_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
}
freq = thd74_round_freq(rig, vfo, freq);
sprintf(fbuf, "%010"PRIll, (int64_t)freq);
SNPRINTF(fbuf, sizeof(fbuf), "%010"PRIll, (int64_t)freq);
memcpy(buf + 5, fbuf, 10);
retval = kenwood_simple_transaction(rig, buf, 72);
return retval;
@ -511,7 +511,7 @@ int thd74_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
}
}
sprintf(mdbuf, "MD %c,%c", v, kmode);
SNPRINTF(mdbuf, sizeof(mdbuf), "MD %c,%c", v, kmode);
rig_debug(RIG_DEBUG_ERR, "%s: mdbuf: %s\n", __func__, mdbuf);
retval = kenwood_transaction(rig, mdbuf, replybuf, 7);
@ -608,7 +608,7 @@ static int thd74_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t offs)
return retval;
}
sprintf(boff, "%010ld", offs);
SNPRINTF(boff, sizeof(boff), "%010ld", offs);
memcpy(buf + 16, boff, 10);
retval = kenwood_simple_transaction(rig, buf, 72);
return retval;
@ -683,7 +683,7 @@ static int thd74_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
}
buf[22] = (tone == 0) ? '0' : '1';
sprintf(tmp, "%02d", tinx);
SNPRINTF(tmp, sizeof(tmp), "%02d", tinx);
memcpy(buf + 30, tmp, 2);
return kenwood_simple_transaction(rig, buf, 52);
}
@ -756,7 +756,7 @@ static int thd74_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code)
}
buf[26] = (code == 0) ? '0' : '1';
sprintf(tmp, "%03d", cinx);
SNPRINTF(tmp, sizeof(tmp), "%03d", cinx);
memcpy(buf + 36, tmp, 3);
return kenwood_simple_transaction(rig, buf, 52);
}
@ -821,7 +821,7 @@ static int thd74_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
}
buf[24] = (tone == 0) ? '0' : '1';
sprintf(tmp, "%02d", tinx);
SNPRINTF(tmp, sizeof(tmp), "%02d", tinx);
memcpy(buf + 33, tmp, 2);
return kenwood_simple_transaction(rig, buf, 52);
}
@ -908,11 +908,11 @@ static int thd74_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
else if (val.f <= 0.4) { lvlc = '1'; }
else { lvlc = '0'; }
sprintf(cmd, "PC %c,%c", c, lvlc);
SNPRINTF(cmd, sizeof(cmd), "PC %c,%c", c, lvlc);
return kenwood_simple_transaction(rig, cmd, 6);
case RIG_LEVEL_VOXGAIN:
sprintf(cmd, "VG %d", (int)(val.f * 10.0 - 0.5));
SNPRINTF(cmd, sizeof(cmd), "VG %d", (int)(val.f * 10.0 - 0.5));
return kenwood_simple_transaction(rig, cmd, 4);
case RIG_LEVEL_VOXDELAY:
@ -920,15 +920,15 @@ static int thd74_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
else if (val.i > 10000) { lvl = val.i / 10000 + 3; }
else { lvl = val.i / 2500; }
sprintf(cmd, "VD %d", lvl);
SNPRINTF(cmd, sizeof(cmd), "VD %d", lvl);
return kenwood_simple_transaction(rig, cmd, 4);
case RIG_LEVEL_SQL:
sprintf(cmd, "SQ %c,%d", c, (int)val.f);
SNPRINTF(cmd, sizeof(cmd), "SQ %c,%d", c, (int)val.f);
return kenwood_simple_transaction(rig, cmd, 6);
case RIG_LEVEL_ATT: // no value provided to distinguish between on/off??
sprintf(cmd, "RA %c,%d", c, (int)val.f);
SNPRINTF(cmd, sizeof(cmd), "RA %c,%d", c, (int)val.f);
return kenwood_simple_transaction(rig, cmd, 6);
default:
@ -957,7 +957,7 @@ static int thd74_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
switch (level)
{
case RIG_LEVEL_RFPOWER:
sprintf(cmd, "PC %c", c);
SNPRINTF(cmd, sizeof(cmd), "PC %c", c);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK)
@ -987,7 +987,7 @@ static int thd74_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break;
case RIG_LEVEL_VOXGAIN:
sprintf(cmd, "VG");
SNPRINTF(cmd, sizeof(cmd), "VG");
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK)
@ -1001,7 +1001,7 @@ static int thd74_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break;
case RIG_LEVEL_VOXDELAY:
sprintf(cmd, "VD");
SNPRINTF(cmd, sizeof(cmd), "VD");
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK)
@ -1015,7 +1015,7 @@ static int thd74_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break;
case RIG_LEVEL_SQL:
sprintf(cmd, "SQ %c", c);
SNPRINTF(cmd, sizeof(cmd), "SQ %c", c);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK)
@ -1035,7 +1035,7 @@ static int thd74_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break;
case RIG_LEVEL_ATT:
sprintf(cmd, "RA %c", c);
SNPRINTF(cmd, sizeof(cmd), "RA %c", c);
retval = kenwood_transaction(rig, cmd, buf, 7);
if (retval != RIG_OK)
@ -1159,7 +1159,7 @@ static int thd74_set_mem(RIG *rig, vfo_t vfo, int ch)
return retval;
}
sprintf(cmd, "MR %c,%03d", c, ch);
SNPRINTF(cmd, sizeof(cmd), "MR %c,%03d", c, ch);
return kenwood_simple_transaction(rig, cmd, 8);
}
@ -1177,7 +1177,7 @@ static int thd74_get_mem(RIG *rig, vfo_t vfo, int *ch)
return retval;
}
sprintf(cmd, "MR %c", c);
SNPRINTF(cmd, sizeof(cmd), "MR %c", c);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK)
@ -1288,7 +1288,7 @@ static int thd74_get_channel(RIG *rig, vfo_t vfo, channel_t *chan,
{
int len;
char cmd[16];
sprintf(cmd, "ME %03d", chan->channel_num);
SNPRINTF(cmd, sizeof(cmd), "ME %03d", chan->channel_num);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK)
@ -1426,7 +1426,7 @@ int thd74_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
}
tx_freq = thd74_round_freq(rig, RIG_VFO_A, tx_freq);
sprintf(fbuf, "%010"PRIll, (int64_t)tx_freq);
SNPRINTF(fbuf, sizeof(fbuf), "%010"PRIll, (int64_t)tx_freq);
memcpy(buf + 5, fbuf, 10);
return kenwood_simple_transaction(rig, buf, 72);
}

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

@ -412,11 +412,11 @@ int thg71_set_vfo(RIG *rig, vfo_t vfo)
{
case RIG_VFO_A:
case RIG_VFO_VFO:
sprintf(vfobuf, "VMC 0,0");
SNPRINTF(vfobuf, sizeof(vfobuf), "VMC 0,0");
break;
case RIG_VFO_MEM:
sprintf(vfobuf, "VMC 0,2");
SNPRINTF(vfobuf, sizeof(vfobuf), "VMC 0,2");
break;
default:

60
rigs/kenwood/tmv7.c
Wyświetl plik

@ -382,20 +382,20 @@ int tmv7_set_vfo(RIG *rig, vfo_t vfo)
{
case RIG_VFO_A:
case RIG_VFO_VFO:
sprintf(vfobuf, "VMC 0,0");
SNPRINTF(vfobuf, sizeof(vfobuf), "VMC 0,0");
break;
case RIG_VFO_B:
sprintf(vfobuf, "VMC 1,0");
SNPRINTF(vfobuf, sizeof(vfobuf), "VMC 1,0");
break;
case RIG_VFO_MEM:
sprintf(vfobuf, "BC");
SNPRINTF(vfobuf, sizeof(vfobuf), "BC");
retval = kenwood_transaction(rig, vfobuf, ackbuf, sizeof(ackbuf));
if (retval != RIG_OK) { return retval; }
sprintf(vfobuf, "VMC %c,2", ackbuf[3]);
SNPRINTF(vfobuf, sizeof(vfobuf), "VMC %c,2", ackbuf[3]);
break;
default:
@ -418,11 +418,11 @@ int tmv7_set_vfo(RIG *rig, vfo_t vfo)
{
case RIG_VFO_A:
case RIG_VFO_VFO:
sprintf(vfobuf, "BC 0,0");
SNPRINTF(vfobuf, sizeof(vfobuf), "BC 0,0");
break;
case RIG_VFO_B:
sprintf(vfobuf, "BC 1,1");
SNPRINTF(vfobuf, sizeof(vfobuf),"BC 1,1");
break;
case RIG_VFO_MEM:
@ -517,35 +517,35 @@ int tmv7_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
else if (chan->channel_num < 204)
{
snprintf(req, sizeof(req), "MR 0,0,L%01d", chan->channel_num - 200);
sprintf(chan->channel_desc, "L%01d/V", chan->channel_num - 200);
SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "L%01d/V", chan->channel_num - 200);
}
else if (chan->channel_num < 211)
{
snprintf(req, sizeof(req), "MR 1,0,L%01d", chan->channel_num - 203);
sprintf(chan->channel_desc, "L%01d/U", chan->channel_num - 203);
SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "L%01d/U", chan->channel_num - 203);
}
else if (chan->channel_num < 214)
{
snprintf(req, sizeof(req), "MR 0,0,U%01d", chan->channel_num - 210);
sprintf(chan->channel_desc, "U%01d/V", chan->channel_num - 210);
SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "U%01d/V", chan->channel_num - 210);
}
else if (chan->channel_num < 220)
{
snprintf(req, sizeof(req), "MR 1,0,U%01d", chan->channel_num - 213);
sprintf(chan->channel_desc, "U%01d/U", chan->channel_num - 213);
SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "U%01d/U", chan->channel_num - 213);
}
else if (chan->channel_num < 223)
{
if (chan->channel_num == 221)
{
snprintf(req, sizeof(req), "CR 0,0");
sprintf(chan->channel_desc, "Call V");
SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Call V");
}
if (chan->channel_num == 222)
{
snprintf(req, sizeof(req), "CR 1,0");
sprintf(chan->channel_desc, "Call U");
SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Call U");
}
}
else
@ -618,7 +618,7 @@ int tmv7_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
if (chan->channel_num < 223 && shift == 0)
{
req[5] = '1';
sprintf(membuf, "%s", req);
SNPRINTF(membuf, sizeof(membuf), "%s", req);
retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf));
if (retval == RIG_OK)
@ -634,11 +634,11 @@ int tmv7_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
{
if (chan->channel_num < 100)
{
sprintf(membuf, "MNA 0,%03d", chan->channel_num);
SNPRINTF(membuf, sizeof(membuf), "MNA 0,%03d", chan->channel_num);
}
else
{
sprintf(membuf, "MNA 1,%03d", chan->channel_num - 100);
SNPRINTF(membuf, sizeof(membuf), "MNA 1,%03d", chan->channel_num - 100);
}
retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf));
@ -736,38 +736,38 @@ int tmv7_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
if (chan->channel_num < 100)
{
sprintf(req, "MW 0,0,%03d", chan->channel_num);
SNPRINTF(req, sizeof(req), "MW 0,0,%03d", chan->channel_num);
}
else if (chan->channel_num < 200)
{
sprintf(req, "MW 1,0,%03d", chan->channel_num - 100);
SNPRINTF(req, sizeof(req), "MW 1,0,%03d", chan->channel_num - 100);
}
else if (chan->channel_num < 204)
{
sprintf(req, "MW 0,0,L%01d", chan->channel_num - 200);
SNPRINTF(req, sizeof(req), "MW 0,0,L%01d", chan->channel_num - 200);
}
else if (chan->channel_num < 211)
{
sprintf(req, "MW 1,0,L%01d", chan->channel_num - 203);
SNPRINTF(req, sizeof(req), "MW 1,0,L%01d", chan->channel_num - 203);
}
else if (chan->channel_num < 214)
{
sprintf(req, "MW 0,0,U%01d", chan->channel_num - 210);
SNPRINTF(req, sizeof(req), "MW 0,0,U%01d", chan->channel_num - 210);
}
else if (chan->channel_num < 220)
{
sprintf(req, "MW 1,0,U%01d", chan->channel_num - 213);
SNPRINTF(req, sizeof(req), "MW 1,0,U%01d", chan->channel_num - 213);
}
else if (chan->channel_num < 223)
{
if (chan->channel_num == 221)
{
sprintf(req, "CW 0,0");
SNPRINTF(req, sizeof(req), "CW 0,0");
}
if (chan->channel_num == 222)
{
sprintf(req, "CW 1,0");
SNPRINTF(req, sizeof(req), "CW 1,0");
}
}
else
@ -776,13 +776,17 @@ int tmv7_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
}
if (chan->channel_num < 221)
sprintf(membuf, "%s,%011ld,%01d,%01d,0,%01d,%01d,0,%02d,000,%02d,0,0",
{
SNPRINTF(membuf, sizeof(membuf), "%s,%011ld,%01d,%01d,0,%01d,%01d,0,%02d,000,%02d,0,0",
req, (long)freq, step, shift, tone,
ctcss, tonefq, ctcssfq);
}
else
sprintf(membuf, "%s,%011ld,%01d,%01d,0,%01d,%01d,0,%02d,000,%02d,",
{
SNPRINTF(membuf, sizeof(membuf), "%s,%011ld,%01d,%01d,0,%01d,%01d,0,%02d,000,%02d,",
req, (long)freq, step, shift, tone,
ctcss, tonefq, ctcssfq);
}
retval = kenwood_transaction(rig, membuf, NULL, 0);
@ -795,7 +799,7 @@ int tmv7_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
{
req[5] = '1';
// cppcheck-suppress *
sprintf(membuf, "%s,%011"PRIll",%01d", req, (int64_t)chan->tx_freq, step);
SNPRINTF(membuf, sizeof(membuf), "%s,%011"PRIll",%01d", req, (int64_t)chan->tx_freq, step);
retval = kenwood_transaction(rig, membuf, NULL, 0);
if (retval != RIG_OK)
@ -808,11 +812,11 @@ int tmv7_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
{
if (chan->channel_num < 100)
{
sprintf(membuf, "MNA 0,%03d,%s", chan->channel_num, chan->channel_desc);
SNPRINTF(membuf, sizeof(membuf), "MNA 0,%03d,%s", chan->channel_num, chan->channel_desc);
}
else
{
sprintf(membuf, "MNA 1,%03d,%s", chan->channel_num - 100, chan->channel_desc);
SNPRINTF(membuf, sizeof(membuf), "MNA 1,%03d,%s", chan->channel_num - 100, chan->channel_desc);
}
retval = kenwood_transaction(rig, membuf, NULL, 0);

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

@ -71,7 +71,7 @@ static int ts140_set_vfo(RIG *rig, vfo_t vfo)
return -RIG_EINVAL;
}
sprintf(cmdbuf, "FN%c",
SNPRINTF(cmdbuf, sizeof(cmdbuf), "FN%c",
vfo_function); /* The 680 and 140 need this to set the VFO on the radio */
return kenwood_transaction(rig, cmdbuf, NULL, 0);
}

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

@ -388,7 +388,7 @@ int ts2000_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
}
/* put channel num in the command string */
sprintf(cmd, "MR0%03d;", chan->channel_num);
SNPRINTF(cmd, sizeof(cmd), "MR0%03d;", chan->channel_num);
err = kenwood_transaction(rig, cmd, buf, sizeof(buf));
@ -789,7 +789,7 @@ int ts2000_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
if (chan->split == RIG_SPLIT_ON)
{
sprintf(buf, "MW1%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;\n",
SNPRINTF(buf, sizeof(buf), "MW1%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;\n",
chan->channel_num,
(unsigned) chan->tx_freq, /* 4 - frequency */
'0' + tx_mode, /* 5 - mode */

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

@ -313,7 +313,7 @@ int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
case RIG_LEVEL_RF:
kenwood_val = val.f * 100;
sprintf(levelbuf, "RG%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "RG%03d", kenwood_val);
break;
case RIG_LEVEL_AF:
@ -321,7 +321,7 @@ int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
case RIG_LEVEL_SQL:
kenwood_val = val.f * 255;
sprintf(levelbuf, "SQ0%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "SQ0%03d", kenwood_val);
break;
case RIG_LEVEL_AGC:
@ -348,22 +348,22 @@ int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return -RIG_EINVAL;
}
sprintf(levelbuf, "GT%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "GT%03d", kenwood_val);
break;
case RIG_LEVEL_MONITOR_GAIN:
kenwood_val = val.f * 9.0;
sprintf(levelbuf, "ML%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "ML%03d", kenwood_val);
break;
case RIG_LEVEL_NB:
kenwood_val = val.f * 10.0;
sprintf(levelbuf, "NL%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "NL%03d", kenwood_val);
break;
case RIG_LEVEL_NR:
kenwood_val = val.f * 9.0;
sprintf(levelbuf, "RL%02d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "RL%02d", kenwood_val);
break;
case RIG_LEVEL_PREAMP:
@ -372,7 +372,7 @@ int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
RETURNFUNC(-RIG_EINVAL);
}
sprintf(levelbuf, "PA%c", (val.i == 12) ? '1' : '0');
SNPRINTF(levelbuf, sizeof(levelbuf), "PA%c", (val.i == 12) ? '1' : '0');
break;
case RIG_LEVEL_ATT:
@ -381,7 +381,7 @@ int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
RETURNFUNC(-RIG_EINVAL);
}
sprintf(levelbuf, "RA%02d", (val.i == 12) ? 1 : 0);
SNPRINTF(levelbuf, sizeof(levelbuf), "RA%02d", (val.i == 12) ? 1 : 0);
break;
case RIG_LEVEL_METER:
@ -403,7 +403,7 @@ int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
RETURNFUNC(-RIG_EINVAL);
}
sprintf(levelbuf, "RM%d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "RM%d", kenwood_val);
break;
case RIG_LEVEL_CWPITCH:

75
rigs/kenwood/ts570.c
Wyświetl plik

@ -190,7 +190,7 @@ static int ts570_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
return -RIG_EINVAL;
}
sprintf(buf, "MD%c", kmode);
SNPRINTF(buf, sizeof(buf), "MD%c", kmode);
retval = kenwood_transaction(rig, buf, NULL, 0);
if (retval != RIG_OK) { return retval; }
@ -203,7 +203,7 @@ static int ts570_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
case RIG_MODE_CWR:
case RIG_MODE_RTTY:
case RIG_MODE_RTTYR:
sprintf(buf, "FW%04d", (int)width);
SNPRINTF(buf, sizeof(buf), "FW%04d", (int)width);
retval = kenwood_transaction(rig, buf, NULL, 0);
if (retval != RIG_OK) { return retval; }
@ -214,7 +214,7 @@ static int ts570_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
case RIG_MODE_LSB:
case RIG_MODE_FM:
case RIG_MODE_AM:
sprintf(buf, "SL%02d", (int)width / 50);
SNPRINTF(buf, sizeof(buf), "SL%02d", (int)width / 50);
retval = kenwood_transaction(rig, buf, NULL, 0);
if (retval != RIG_OK) { return retval; }
@ -249,11 +249,11 @@ int ts570_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
return -RIG_EINVAL;
}
sprintf(fctbuf, "NR%01d", status);
SNPRINTF(fctbuf, sizeof(fctbuf), "NR%01d", status);
return kenwood_transaction(rig, fctbuf, NULL, 0);
case RIG_FUNC_TUNER:
sprintf(fctbuf, "AC %c0", (0 == status) ? '0' : '1');
SNPRINTF(fctbuf, sizeof(fctbuf), "AC %c0", (0 == status) ? '0' : '1');
return kenwood_transaction(rig, fctbuf, NULL, 0);
default:
@ -346,7 +346,7 @@ ts570_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
/* set the preamplifier if a correct value is entered */
if (kenwood_val == 0)
{
sprintf(levelbuf, "PA0");
SNPRINTF(levelbuf, sizeof(levelbuf), "PA0");
}
else
{
@ -355,7 +355,7 @@ ts570_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
for (i = 0; i < HAMLIB_MAXDBLSTSIZ; i++)
if (kenwood_val == rig->state.preamp[i])
{
sprintf(levelbuf, "PA%01d", i + 1);
SNPRINTF(levelbuf, sizeof(levelbuf), "PA%01d", i + 1);
break; /* found - stop searching */
}
else
@ -369,13 +369,13 @@ ts570_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
case RIG_LEVEL_RFPOWER:
/* level for TS570D is from 0.. 100W in SSB and CW */
kenwood_val = val.f * 100;
sprintf(levelbuf, "PC%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "PC%03d", kenwood_val);
return kenwood_transaction(rig, levelbuf, NULL, 0);
case RIG_LEVEL_MICGAIN:
/* level is from 0..100 */
kenwood_val = val.f * 100;
sprintf(levelbuf, "MG%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "MG%03d", kenwood_val);
return kenwood_transaction(rig, levelbuf, NULL, 0);
default:
@ -561,7 +561,7 @@ int ts570_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo)
int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
{
char cmdbuf[16], ackbuf[20];
int cmd_len, retval;
int retval;
unsigned char vfo_function;
if (vfo != RIG_VFO_CURR)
@ -582,12 +582,7 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
}
/* set RX VFO */
cmd_len = sprintf(cmdbuf, "FR%c%c", vfo_function, cmd_trm(rig));
if (cmd_len < 0)
{
return -RIG_ETRUNC;
}
SNPRINTF(cmdbuf, sizeof(cmdbuf), "FR%c%c", vfo_function, cmd_trm(rig));
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
@ -629,12 +624,7 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
}
/* set TX VFO */
cmd_len = sprintf(cmdbuf, "FT%c%c", vfo_function, cmd_trm(rig));
if (cmd_len < 0)
{
return -RIG_ETRUNC;
}
SNPRINTF(cmdbuf, sizeof(cmdbuf), "FT%c%c", vfo_function, cmd_trm(rig));
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
@ -658,12 +648,7 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
/* and then set it to both vfo's */
vfo_function = ackbuf[2];
cmd_len = sprintf(cmdbuf, "FT%c%c", vfo_function, cmd_trm(rig));
if (cmd_len < 0)
{
return -RIG_ETRUNC;
}
SNPRINTF(cmdbuf, sizeof(cmdbuf), "FT%c%c", vfo_function, cmd_trm(rig));
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
@ -691,7 +676,7 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
int ts570_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
{
char cmdbuf[30];
int retval, cmd_len;
int retval;
int num, freq, tx_freq, tone;
char mode, tx_mode, tones;
@ -728,14 +713,9 @@ int ts570_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
tone = 0;
}
cmd_len = sprintf(cmdbuf, "MW0 %02d%011d%c0%c%02d ",
SNPRINTF(cmdbuf, sizeof(cmdbuf), "MW0 %02d%011d%c0%c%02d ",
num, freq, mode, tones, tone);
if (cmd_len < 0)
{
return -RIG_ETRUNC;
}
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
if (retval != RIG_OK)
@ -743,14 +723,9 @@ int ts570_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
return retval;
}
cmd_len = sprintf(cmdbuf, "MW1 %02d%011d%c0%c%02d ",
SNPRINTF(cmdbuf, sizeof(cmdbuf), "MW1 %02d%011d%c0%c%02d ",
num, tx_freq, tx_mode, tones, tone);
if (cmd_len < 0)
{
return -RIG_ETRUNC;
}
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
if (retval != RIG_OK)
@ -799,7 +774,7 @@ int ts570_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
{
char buf[50];
unsigned char c;
int retval, len, i;
int retval, i;
if (rit == 0)
{
@ -833,12 +808,7 @@ int ts570_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
c = 'D';
}
len = sprintf(buf, "R%c", c);
if (len < 0)
{
return -RIG_ETRUNC;
}
SNPRINTF(buf, sizeof(buf), "R%c", c);
retval = kenwood_transaction(rig, "RC", NULL, 0);
@ -864,7 +834,7 @@ int ts570_set_xit(RIG *rig, vfo_t vfo, shortfreq_t rit)
{
char buf[50];
unsigned char c;
int retval, len, i;
int retval, i;
if (rit == 0)
{
@ -898,12 +868,7 @@ int ts570_set_xit(RIG *rig, vfo_t vfo, shortfreq_t rit)
c = 'D';
}
len = sprintf(buf, "R%c", c);
if (len < 0)
{
return -RIG_ETRUNC;
}
SNPRINTF(buf, sizeof(buf), "R%c", c);
retval = kenwood_transaction(rig, "RC", NULL, 0);

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

@ -71,7 +71,7 @@ static int ts680_set_vfo(RIG *rig, vfo_t vfo)
return -RIG_EINVAL;
}
sprintf(cmdbuf, "FN%c",
SNPRINTF(cmdbuf, sizeof(cmdbuf), "FN%c",
vfo_function); /* The 680 and 140 need this to set the VFO on the radio */
return kenwood_transaction(rig, cmdbuf, NULL, 0);
}

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

@ -90,7 +90,7 @@ ts711_set_vfo(RIG *rig, vfo_t vfo)
return -RIG_EINVAL;
}
sprintf(cmdbuf, "FN%c", vfo_function);
SNPRINTF(cmdbuf, sizeof(cmdbuf), "FN%c", vfo_function);
return kenwood_transaction(rig, cmdbuf, NULL, 0);
}

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

@ -76,7 +76,7 @@ ts811_set_vfo(RIG *rig, vfo_t vfo)
return -RIG_EINVAL;
}
sprintf(cmdbuf, "FN%c", vfo_function);
SNPRINTF(cmdbuf, sizeof(cmdbuf), "FN%c", vfo_function);
return kenwood_transaction(rig, cmdbuf, NULL, 0);
}

8
rigs/kenwood/ts850.c
Wyświetl plik

@ -287,7 +287,7 @@ int ts850_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
c = 'D';
}
sprintf(buf, "R%c", c);
SNPRINTF(buf, sizeof(buf), "R%c", c);
retval = kenwood_transaction(rig, "RC", NULL, 0);
@ -350,7 +350,7 @@ int ts850_set_xit(RIG *rig, vfo_t vfo, shortfreq_t xit)
c = 'D';
}
sprintf(buf, "R%c", c);
SNPRINTF(buf, sizeof(buf), "R%c", c);
for (i = 0; i < labs(lrint(xit / 20)); i++)
{
@ -553,7 +553,7 @@ int ts850_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
tone = 0;
}
sprintf(cmdbuf, "MW0 %02d%011d%c0%c%02d ",
SNPRINTF(cmdbuf, sizeof(cmdbuf), "MW0 %02d%011d%c0%c%02d ",
num, freq, mode, tones, tone);
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
@ -562,7 +562,7 @@ int ts850_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
return retval;
}
sprintf(cmdbuf, "MW1 %02d%011d%c0%c%02d ",
SNPRINTF(cmdbuf, sizeof(cmdbuf), "MW1 %02d%011d%c0%c%02d ",
num, tx_freq, tx_mode, tones, tone);
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);

8
rigs/kenwood/ts870s.c
Wyświetl plik

@ -223,7 +223,7 @@ static int ts870s_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
return -RIG_EINVAL;
}
sprintf(buf, "MD%c", kmode);
SNPRINTF(buf, sizeof(buf), "MD%c", kmode);
retval = kenwood_transaction(rig, buf, NULL, 0);
if (retval != RIG_OK) { return retval; }
@ -248,7 +248,7 @@ static int ts870s_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
mode_default_hpf = 100;
}
sprintf(buf, "IS %04d", (int)(width + mode_default_hpf));
SNPRINTF(buf, sizeof(buf), "IS %04d", (int)(width + mode_default_hpf));
retval = kenwood_transaction(rig, buf, NULL, 0);
}
else
@ -257,7 +257,7 @@ static int ts870s_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
* This rig will simply use an IF bandpass which is closest to width,
* so we don't need to check the value...
*/
sprintf(buf, "FW%04d", (int)width / 10);
SNPRINTF(buf, sizeof(buf), "FW%04d", (int)width / 10);
retval = kenwood_transaction(rig, buf, NULL, 0);
}
}
@ -275,7 +275,7 @@ int ts870s_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
case RIG_LEVEL_RFPOWER:
intval = val.f * 100;
sprintf(levelbuf, "PC%03d", intval);
SNPRINTF(levelbuf, sizeof(levelbuf), "PC%03d", intval);
return kenwood_transaction(rig, levelbuf, NULL, 0);
break;

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

@ -54,12 +54,12 @@ int kenwood_ts890_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
case RIG_LEVEL_RF:
kenwood_val = val.f * 255;
sprintf(levelbuf, "RG%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "RG%03d", kenwood_val);
break;
case RIG_LEVEL_SQL:
kenwood_val = val.f * 255;
sprintf(levelbuf, "SQ%03d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "SQ%03d", kenwood_val);
break;
case RIG_LEVEL_AGC:
@ -94,7 +94,7 @@ int kenwood_ts890_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return -RIG_EINVAL;
}
sprintf(levelbuf, "GC%d", kenwood_val);
SNPRINTF(levelbuf, sizeof(levelbuf), "GC%d", kenwood_val);
break;
default:

12
rigs/kenwood/ts990s.c
Wyświetl plik

@ -418,7 +418,7 @@ int ts990s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return -RIG_EINVAL;
}
sprintf(cmd, "RA%c", v);
SNPRINTF(cmd, sizeof(cmd), "RA%c", v);
retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 4);
if (retval != RIG_OK)
@ -465,7 +465,7 @@ int ts990s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return -RIG_EINVAL;
}
sprintf(cmd, "AG%c", v);
SNPRINTF(cmd, sizeof(cmd), "AG%c", v);
retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 6);
if (retval != RIG_OK)
@ -494,7 +494,7 @@ int ts990s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return -RIG_EINVAL;
}
sprintf(cmd, "RG%c", v);
SNPRINTF(cmd, sizeof(cmd), "RG%c", v);
retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 6);
if (retval != RIG_OK)
@ -523,7 +523,7 @@ int ts990s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return -RIG_EINVAL;
}
sprintf(cmd, "SQ%c", v);
SNPRINTF(cmd, sizeof(cmd), "SQ%c", v);
retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 6);
if (retval != RIG_OK)
@ -605,7 +605,7 @@ int ts990s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return -RIG_EINVAL;
}
sprintf(cmd, "GC%c", v);
SNPRINTF(cmd, sizeof(cmd), "GC%c", v);
if (RIG_OK != (retval = kenwood_safe_transaction(rig, cmd, lvlbuf,
sizeof(lvlbuf), 4)))
@ -701,7 +701,7 @@ int ts990s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return -RIG_EINVAL;
}
sprintf(cmd, "SM%c", v);
SNPRINTF(cmd, sizeof(cmd), "SM%c", v);
retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 7);
if (retval != RIG_OK)

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

@ -387,7 +387,7 @@ int ts2000_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
}
/* put channel num in the command string */
sprintf(cmd, "MR0%03d;", chan->channel_num);
SNPRINTF(cmd, sizeof(cmd), "MR0%03d;", chan->channel_num);
err = kenwood_transaction(rig, cmd, buf, sizeof(buf));
@ -788,7 +788,7 @@ int ts2000_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
if (chan->split == RIG_SPLIT_ON)
{
sprintf(buf, "MW1%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;\n",
SNPRINTF(buf, sizeof(buf), "MW1%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;\n",
chan->channel_num,
(unsigned) chan->tx_freq, /* 4 - frequency */
'0' + tx_mode, /* 5 - mode */

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

@ -248,7 +248,7 @@ int xg3_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
}
/* XXX check level range */
sprintf(levelbuf, "L,%02d", (int)val.f);
SNPRINTF(levelbuf, sizeof(levelbuf), "L,%02d", (int)val.f);
break;
default:
@ -275,7 +275,7 @@ int xg3_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
switch (level)
{
case RIG_LEVEL_RFPOWER:
sprintf(cmdbuf, "L;");
SNPRINTF(cmdbuf, sizeof(cmdbuf), "L;");
retval = write_block(&rs->rigport, (unsigned char *) cmdbuf, strlen(cmdbuf));
if (retval != RIG_OK)
@ -395,11 +395,11 @@ int xg3_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
int ch;
xg3_get_mem(rig, vfo, &ch);
sprintf(cmdbuf, "M,%02d,%011ld", ch, (long)freq);
SNPRINTF(cmdbuf, sizeof(cmdbuf), "M,%02d,%011ld", ch, (long)freq);
}
else
{
sprintf(cmdbuf, "F,%011ld", (long)freq);
SNPRINTF(cmdbuf, sizeof(cmdbuf), "F,%011ld", (long)freq);
}
err = kenwood_transaction(rig, cmdbuf, NULL, 0);
@ -448,11 +448,11 @@ int xg3_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
int ch;
xg3_get_mem(rig, vfo, &ch);
sprintf(cmdbuf, "M,%02d;", ch);
SNPRINTF(cmdbuf, sizeof(cmdbuf), "M,%02d;", ch);
}
else
{
sprintf(cmdbuf, "F;");
SNPRINTF(cmdbuf, sizeof(cmdbuf), "F;");
}
retval = write_block(&rs->rigport, (unsigned char *) cmdbuf, strlen(cmdbuf));
@ -548,7 +548,7 @@ int xg3_set_mem(RIG *rig, vfo_t vfo, int ch)
return -RIG_EINVAL;
}
sprintf(cmdbuf, "C,%02d;", ch);
SNPRINTF(cmdbuf, sizeof(cmdbuf), "C,%02d;", ch);
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
if (retval != RIG_OK)
@ -573,7 +573,7 @@ int xg3_get_mem(RIG *rig, vfo_t vfo, int *ch)
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
sprintf(cmdbuf, "C;");
SNPRINTF(cmdbuf, sizeof(cmdbuf), "C;");
retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
if (retval != RIG_OK)
@ -660,7 +660,7 @@ int xg3_set_parm(RIG *rig, setting_t parm, value_t val)
case RIG_PARM_BACKLIGHT:
ival = 3 - (int)(val.f * 3); // gives us 0-3 bright-to-dim
rig_debug(RIG_DEBUG_ERR, "%s: BACKLIGHT %d\n", __func__, ival);
sprintf(cmdbuf, "G,%02d", ival);
SNPRINTF(cmdbuf, sizeof(cmdbuf), "G,%02d", ival);
retval = kenwood_simple_transaction(rig, cmdbuf, 0);
break;