/*
* Get/Set level abilities
*/
int print_caps_level(const struct rig_caps *caps, void *data)
{
setting_t level;
int i;
if (!data)
{
return 0;
}
level = (*(int *)data) ? caps->has_set_level : caps->has_get_level;
printf("<A NAME=\"%slevel%d\"><TR><TD>%s</TD>",
(*(int *)data) ? "set" : "get",
caps->rig_model,
caps->model_name);
/*
* bitmap_level: only those who have a label
*/
for (i = 0; i < 32; i++)
{
if (rig_idx2setting(i) & bitmap_level)
{
print_yn(level & rig_idx2setting(i));
}
}
printf("</TR></A>\n");
return 1;
}
/*
* Get/Set func abilities
*/
int print_caps_func(const struct rig_caps *caps, void *data)
{
setting_t func;
int i;
if (!data)
{
return 0;
}
func = (*(int *)data) ? caps->has_set_func : caps->has_get_func;
printf("<A NAME=\"%sfunc%d\"><TR><TD>%s</TD>",
(*(int *)data) ? "set" : "get",
caps->rig_model,
caps->model_name);
/*
* bitmap_func: only those who have a label
*/
for (i = 0; i < RIG_SETTING_MAX; i++)
{
if (rig_idx2setting(i) & bitmap_func)
{
print_yn(func & rig_idx2setting(i));
}
}
printf("</TR></A>\n");
return 1;
}
int sprintf_parm_gran(char *str, setting_t parm, const gran_t gran[])
{
int i, len = 0;
*str = '\0';
if (parm == RIG_PARM_NONE)
{
return 0;
}
for (i = 0; i < RIG_SETTING_MAX; i++)
{
const char *ms;
if (!(parm & rig_idx2setting(i)))
{
continue;
}
ms = rig_strparm(parm & rig_idx2setting(i));
if (!ms || !ms[0])
{
if (parm != DUMMY_ALL && parm != RIG_PARM_SET(DUMMY_ALL))
{
rig_debug(RIG_DEBUG_BUG, "unknown parm idx %d\n", i);
}
continue;
}
if (RIG_PARM_IS_FLOAT(rig_idx2setting(i)))
{
len += sprintf(str + len,
"%s(%g..%g/%g) ",
ms,
gran[i].min.f,
gran[i].max.f,
gran[i].step.f);
}
else
{
len += sprintf(str + len,
"%s(%d..%d/%d) ",
ms,
gran[i].min.i,
gran[i].max.i,
gran[i].step.i);
}
}
return len;
}
int sprintf_parm(char *str, setting_t parm)
{
int i, len = 0;
*str = '\0';
if (parm == RIG_PARM_NONE)
{
return 0;
}
for (i = 0; i < RIG_SETTING_MAX; i++)
{
const char *ms = rig_strparm(parm & rig_idx2setting(i));
if (!ms || !ms[0])
{
continue; /* unknown, FIXME! */
}
strcat(str, ms);
strcat(str, " ");
len += strlen(ms) + 1;
}
return len;
}
int sprintf_level(char *str, setting_t level)
{
int i, len = 0;
*str = '\0';
if (level == RIG_LEVEL_NONE)
{
return 0;
}
for (i = 0; i < RIG_SETTING_MAX; i++)
{
const char *ms = rig_strlevel(level & rig_idx2setting(i));
if (!ms || !ms[0])
{
continue; /* unknown, FIXME! */
}
strcat(str, ms);
strcat(str, " ");
len += strlen(ms) + 1;
}
return len;
}
int sprintf_func(char *str, setting_t func)
{
int i, len = 0;
*str = '\0';
if (func == RIG_FUNC_NONE)
{
return 0;
}
for (i = 0; i < RIG_SETTING_MAX; i++)
{
const char *ms = rig_strfunc(func & rig_idx2setting(i));
if (!ms || !ms[0])
{
continue; /* unknown, FIXME! */
}
strcat(str, ms);
strcat(str, " ");
len += strlen(ms) + 1;
}
return len;
}
/*
* Restores chan into current VFO state by emulating rig_set_channel
*/
static int generic_restore_channel(RIG *rig, const channel_t *chan)
{
int i;
struct ext_list *p;
setting_t setting;
const channel_cap_t *mem_cap = NULL;
if (chan->vfo == RIG_VFO_MEM)
{
const chan_t *chan_cap;
chan_cap = rig_lookup_mem_caps(rig, chan->channel_num);
if (chan_cap) mem_cap = &chan_cap->mem_caps;
}
/* If vfo!=RIG_VFO_MEM or incomplete backend, try all properties */
if (mem_cap == NULL || rig_mem_caps_empty(mem_cap))
{
mem_cap = &mem_cap_all;
}
rig_set_vfo(rig, chan->vfo);
if (mem_cap->freq)
rig_set_freq(rig, RIG_VFO_CURR, chan->freq);
if (mem_cap->mode || mem_cap->width)
rig_set_mode(rig, RIG_VFO_CURR, chan->mode, chan->width);
rig_set_split_vfo(rig, RIG_VFO_CURR, chan->split, chan->tx_vfo);
if (chan->split != RIG_SPLIT_OFF) {
if (mem_cap->tx_freq)
rig_set_split_freq(rig, RIG_VFO_CURR, chan->tx_freq);
if (mem_cap->tx_mode || mem_cap->tx_width)
rig_set_split_mode(rig, RIG_VFO_CURR, chan->tx_mode, chan->tx_width);
}
if (mem_cap->rptr_shift)
rig_set_rptr_shift(rig, RIG_VFO_CURR, chan->rptr_shift);
if (mem_cap->rptr_offs)
rig_set_rptr_offs(rig, RIG_VFO_CURR, chan->rptr_offs);
for (i=0; i<RIG_SETTING_MAX; i++) {
setting = rig_idx2setting(i);
if (setting & mem_cap->levels)
rig_set_level(rig, RIG_VFO_CURR, setting, chan->levels[i]);
}
if (mem_cap->ant)
rig_set_ant(rig, RIG_VFO_CURR, chan->ant);
if (mem_cap->tuning_step)
rig_set_ts(rig, RIG_VFO_CURR, chan->tuning_step);
if (mem_cap->rit)
rig_set_rit(rig, RIG_VFO_CURR, chan->rit);
if (mem_cap->xit)
rig_set_xit(rig, RIG_VFO_CURR, chan->xit);
for (i=0; i<RIG_SETTING_MAX; i++) {
setting = rig_idx2setting(i);
if (setting & mem_cap->funcs)
rig_set_func(rig, RIG_VFO_CURR, setting,
chan->funcs & rig_idx2setting(i));
}
if (mem_cap->ctcss_tone)
rig_set_ctcss_tone(rig, RIG_VFO_CURR, chan->ctcss_tone);
if (mem_cap->ctcss_sql)
rig_set_ctcss_sql(rig, RIG_VFO_CURR, chan->ctcss_sql);
if (mem_cap->dcs_code)
rig_set_dcs_code(rig, RIG_VFO_CURR, chan->dcs_code);
if (mem_cap->dcs_sql)
rig_set_dcs_sql(rig, RIG_VFO_CURR, chan->dcs_sql);
/*
* TODO: (missing calls)
* - channel_desc
* - bank_num
* - scan_group
* - flags
*/
for (p = chan->ext_levels; p && !RIG_IS_EXT_END(*p); p++)
rig_set_ext_level(rig, RIG_VFO_CURR, p->token, p->val);
return RIG_OK;
}
/*
* stores current VFO state into chan by emulating rig_get_channel
*/
static int generic_save_channel(RIG *rig, channel_t *chan)
{
int i, retval;
int chan_num;
vfo_t vfo;
setting_t setting;
const channel_cap_t *mem_cap = NULL;
chan_num = chan->channel_num;
vfo = chan->vfo;
memset(chan, 0, sizeof(channel_t));
chan->channel_num = chan_num;
chan->vfo = vfo;
if (vfo == RIG_VFO_MEM)
{
const chan_t *chan_cap;
chan_cap = rig_lookup_mem_caps(rig, chan_num);
if (chan_cap) mem_cap = &chan_cap->mem_caps;
}
/* If vfo!=RIG_VFO_MEM or incomplete backend, try all properties */
if (mem_cap == NULL || rig_mem_caps_empty(mem_cap))
{
mem_cap = &mem_cap_all;
}
if (mem_cap->freq) {
retval = rig_get_freq(rig, RIG_VFO_CURR, &chan->freq);
/* empty channel ? */
if (retval == -RIG_ENAVAIL || chan->freq == RIG_FREQ_NONE)
return -RIG_ENAVAIL;
}
if (mem_cap->vfo)
rig_get_vfo(rig, &chan->vfo);
if (mem_cap->mode || mem_cap->width)
rig_get_mode(rig, RIG_VFO_CURR, &chan->mode, &chan->width);
chan->split = RIG_SPLIT_OFF;
if (mem_cap->split)
rig_get_split_vfo(rig, RIG_VFO_CURR, &chan->split, &chan->tx_vfo);
if (chan->split != RIG_SPLIT_OFF) {
if (mem_cap->tx_freq)
rig_get_split_freq(rig, RIG_VFO_CURR, &chan->tx_freq);
if (mem_cap->tx_mode || mem_cap->tx_width)
rig_get_split_mode(rig, RIG_VFO_CURR, &chan->tx_mode, &chan->tx_width);
} else {
chan->tx_freq = chan->freq;
chan->tx_mode = chan->mode;
chan->tx_width = chan->width;
}
if (mem_cap->rptr_shift)
rig_get_rptr_shift(rig, RIG_VFO_CURR, &chan->rptr_shift);
if (mem_cap->rptr_offs)
rig_get_rptr_offs(rig, RIG_VFO_CURR, &chan->rptr_offs);
if (mem_cap->ant)
rig_get_ant(rig, RIG_VFO_CURR, &chan->ant);
if (mem_cap->tuning_step)
rig_get_ts(rig, RIG_VFO_CURR, &chan->tuning_step);
if (mem_cap->rit)
rig_get_rit(rig, RIG_VFO_CURR, &chan->rit);
if (mem_cap->xit)
rig_get_xit(rig, RIG_VFO_CURR, &chan->xit);
for (i=0; i<RIG_SETTING_MAX; i++) {
setting = rig_idx2setting(i);
if ((setting & mem_cap->levels) && RIG_LEVEL_SET(setting))
rig_get_level(rig, RIG_VFO_CURR, setting, &chan->levels[i]);
}
for (i=0; i<RIG_SETTING_MAX; i++) {
int fstatus;
setting = rig_idx2setting(i);
if ((setting & mem_cap->funcs) &&
(rig_get_func(rig, RIG_VFO_CURR, setting, &fstatus) == RIG_OK))
chan->funcs |= fstatus ? setting : 0;
}
if (mem_cap->ctcss_tone)
rig_get_ctcss_tone(rig, RIG_VFO_CURR, &chan->ctcss_tone);
if (mem_cap->ctcss_sql)
rig_get_ctcss_sql(rig, RIG_VFO_CURR, &chan->ctcss_sql);
if (mem_cap->dcs_code)
rig_get_dcs_code(rig, RIG_VFO_CURR, &chan->dcs_code);
if (mem_cap->dcs_sql)
rig_get_dcs_sql(rig, RIG_VFO_CURR, &chan->dcs_sql);
/*
* TODO: (missing calls)
* - channel_desc
* - bank_num
* - scan_group
* - flags
*/
rig_ext_level_foreach(rig, generic_retr_extl, (rig_ptr_t)chan);
return RIG_OK;
}
int main(int argc, char *argv[])
{
time_t gentime;
int set_or_get;
int i;
char *pbuf, prntbuf[512];
rig_load_all_backends();
printf("<TABLE BORDER=1>");
printf("<TR><TD>Model</TD><TD>Mfg</TD><TD>Vers.</TD><TD>Status</TD>"
"<TD>Type</TD><TD>Freq. range</TD><TD>Parameters</TD>"
"<TD>Capabilities</TD>"
"<TD>Get func</TD>"
"<TD>Set func</TD>"
"<TD>Get level</TD>"
"<TD>Set level</TD>"
"<TD>Get parm</TD>"
"<TD>Set parm</TD>"
"</TR>\n");
rig_list_foreach(print_caps_sum, NULL);
printf("</TABLE>\n");
printf("<P>");
printf("<TABLE BORDER=1>\n");
printf("<TR><TD>Model</TD><TD>PTT</TD><TD>DCD</TD><TD>Port</TD>"
"<TD>Speed min</TD><TD>Speed max</TD>"
"<TD>Parm.</TD><TD>Handshake</TD><TD>Write delay</TD>"
"<TD>Post delay</TD><TD>Timeout</TD><TD>Retry</TD></TR>\n");
rig_list_foreach(print_caps_parameters, NULL);
printf("</TABLE>\n");
printf("<P>");
printf("<TABLE BORDER=1>\n");
printf("<TR><TD>Model</TD><TD>Freq. range</TD></TR>\n");
rig_list_foreach(print_caps_range, NULL);
printf("</TABLE>\n");
printf("<P>");
printf("<TABLE BORDER=1>\n");
printf("<TR><TD>Model</TD><TD>Target VFO</TD>"
"<TD>Set freq</TD><TD>Get freq</TD>"
"<TD>Set mode</TD><TD>Get mode</TD>"
"<TD>Set VFO</TD><TD>Get VFO</TD>"
"<TD>Set PTT</TD><TD>Get PTT</TD><TD>Get DCD</TD>"
"<TD>Set rptr shift</TD><TD>Get rptr shift</TD>"
"<TD>Set rptr offs</TD><TD>Get rptr offs</TD>"
"<TD>Set split frq</TD><TD>Get split frq</TD>"
"<TD>Set split</TD><TD>Get split</TD>"
"<TD>Set ts</TD><TD>Get ts</TD>"
"<TD>Set CTCSS</TD><TD>Get CTCSS</TD>"
"<TD>Set DCS</TD><TD>Get DCS</TD>"
"<TD>Set Power Stat</TD><TD>Get Power Stat</TD>"
"<TD>Set trn</TD><TD>Get trn</TD>"
"<TD>Decode</TD><TD>Get info</TD>"
"</TR>\n");
rig_list_foreach(print_caps_caps, NULL);
printf("</TABLE>\n");
printf("<P>");
bitmap_func = 0;
prntbuf[0] = '\0';
pbuf = prntbuf;
for (i = 0; i < RIG_SETTING_MAX; i++)
{
setting_t func = rig_idx2setting(i);
const char *s = rig_strfunc(func);
if (!s)
{
continue;
}
bitmap_func |= func;
pbuf += sprintf(pbuf, "<TD>%s</TD>", s);
}
printf("Has set func");
printf("<TABLE BORDER=1>\n");
printf("<TR><TD>Model</TD>%s</TR>\n", prntbuf);
set_or_get = 1;
rig_list_foreach(print_caps_func, &set_or_get);
printf("</TABLE>\n");
printf("<P>");
printf("Has get func");
printf("<TABLE BORDER=1>\n");
printf("<TR><TD>Model</TD>%s</TR>\n", prntbuf);
set_or_get = 0;
rig_list_foreach(print_caps_func, &set_or_get);
printf("</TABLE>\n");
printf("<P>");
bitmap_level = 0;
prntbuf[0] = '\0';
pbuf = prntbuf;
for (i = 0; i < RIG_SETTING_MAX; i++)
{
setting_t level = rig_idx2setting(i);
const char *s = rig_strlevel(level);
if (!s)
{
continue;
}
bitmap_level |= level;
pbuf += sprintf(pbuf, "<TD>%s</TD>", s);
}
printf("Set level");
printf("<TABLE BORDER=1>\n");
printf("<TR><TD>Model</TD>%s</TR>\n", prntbuf);
set_or_get = 1;
rig_list_foreach(print_caps_level, &set_or_get);
printf("</TABLE>\n");
printf("<P>");
printf("Get level");
printf("<TABLE BORDER=1>\n");
printf("<TR><TD>Model</TD>%s</TR>\n", prntbuf);
set_or_get = 0;
rig_list_foreach(print_caps_level, &set_or_get);
printf("</TABLE>\n");
printf("<P>");
bitmap_parm = 0;
prntbuf[0] = '\0';
pbuf = prntbuf;
for (i = 0; i < RIG_SETTING_MAX; i++)
{
setting_t parm = rig_idx2setting(i);
const char *s = rig_strparm(parm);
if (!s)
{
continue;
}
bitmap_parm |= parm;
pbuf += sprintf(pbuf, "<TD>%s</TD>", s);
}
printf("Set parm");
printf("<TABLE BORDER=1>\n");
printf("<TR><TD>Model</TD>%s</TR>\n", prntbuf);
set_or_get = 1;
rig_list_foreach(print_caps_parm, &set_or_get);
printf("</TABLE>\n");
printf("<P>");
printf("Get parm");
printf("<TABLE BORDER=1>\n");
printf("<TR><TD>Model</TD>%s</TR>\n", prntbuf);
set_or_get = 0;
rig_list_foreach(print_caps_parm, &set_or_get);
printf("</TABLE>\n");
printf("<P>");
time(&gentime);
printf("Rigmatrix generated %s by %s\n", ctime(&gentime), getenv("USER"));
printf("</body></html>\n");
return 0;
}
int csv_parm_save(RIG *rig, const char *outfilename)
{
int i, ret;
FILE *f;
setting_t parm, get_parm = all ? 0x7fffffff : rig->state.has_get_parm;
f = fopen(outfilename, "w");
if (!f)
{
return -1;
}
for (i = 0; i < RIG_SETTING_MAX; i++)
{
const char *ms = rig_strparm(get_parm & rig_idx2setting(i));
if (!ms || !ms[0])
{
continue;
}
fprintf(f, "%s%c", ms, csv_sep);
}
rig_ext_parm_foreach(rig, print_parm_name, f);
fprintf(f, "\n");
for (i = 0; i < RIG_SETTING_MAX; i++)
{
const char *ms;
value_t val;
parm = get_parm & rig_idx2setting(i);
ms = rig_strparm(parm);
if (!ms || !ms[0])
{
continue;
}
ret = rig_get_parm(rig, parm, &val);
if (ret != RIG_OK)
{
return ret;
}
if (RIG_PARM_IS_FLOAT(parm))
{
fprintf(f, "%f%c", val.f, csv_sep);
}
else
{
fprintf(f, "%d%c", val.i, csv_sep);
}
}
rig_ext_parm_foreach(rig, print_parm_val, f);
fprintf(f, "\n");
fclose(f);
return 0;
}
