[Hamlib-commits] Hamlib -- Ham radio control libraries branch master updated. 3bc39aaec1f09bd461b82
Library to control radio transceivers and receivers
Brought to you by:
n0nb
Menu
▾
▴
[Hamlib-commits] Hamlib -- Ham radio control libraries branch master updated. 3bc39aaec1f09bd461b82a70c4503127f4d1ebca
|
From: Michael B. <mdb...@us...> - 2021-03-15 22:51:53
|
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Hamlib -- Ham radio control libraries".
The branch, master has been updated
via 3bc39aaec1f09bd461b82a70c4503127f4d1ebca (commit)
from 288f82f96387668f0cf531782711e37cc55847f5 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 3bc39aaec1f09bd461b82a70c4503127f4d1ebca
Author: Michael Black W9MDB <mdb...@ya...>
Date: Mon Mar 15 17:51:22 2021 -0500
astyle files is preparation for 4.2 release
diff --git a/rigs/aor/aor.c b/rigs/aor/aor.c
index 6c2dd045..d69fc933 100644
--- a/rigs/aor/aor.c
+++ b/rigs/aor/aor.c
@@ -642,7 +642,8 @@ int aor_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
}
/* should be caught by the front end */
- if ((val.i != 0) && (i >= HAMLIB_MAXDBLSTSIZ || RIG_IS_DBLST_END(rs->attenuator[i])))
+ if ((val.i != 0) && (i >= HAMLIB_MAXDBLSTSIZ
+ || RIG_IS_DBLST_END(rs->attenuator[i])))
{
return -RIG_EINVAL;
}
diff --git a/rigs/aor/sr2200.c b/rigs/aor/sr2200.c
index 954568a0..63033e05 100644
--- a/rigs/aor/sr2200.c
+++ b/rigs/aor/sr2200.c
@@ -648,7 +648,8 @@ int sr2200_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
}
/* should be caught by the front end */
- if ((val.i != 0) && (i >= HAMLIB_MAXDBLSTSIZ || RIG_IS_DBLST_END(rs->attenuator[i])))
+ if ((val.i != 0) && (i >= HAMLIB_MAXDBLSTSIZ
+ || RIG_IS_DBLST_END(rs->attenuator[i])))
{
return -RIG_EINVAL;
}
diff --git a/rigs/dummy/dummy.c b/rigs/dummy/dummy.c
index 1e20ddb6..1bc0a4ce 100644
--- a/rigs/dummy/dummy.c
+++ b/rigs/dummy/dummy.c
@@ -396,15 +396,15 @@ static int dummy_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
rig_debug(RIG_DEBUG_VERBOSE, "%s called: %s %s\n", __func__,
rig_strvfo(vfo), fstr);
- switch(vfo)
+ switch (vfo)
{
- case RIG_VFO_MAIN:
- case RIG_VFO_A: priv->vfo_a.freq = freq;break;
+ case RIG_VFO_MAIN:
+ case RIG_VFO_A: priv->vfo_a.freq = freq; break;
- case RIG_VFO_SUB:
- case RIG_VFO_B: priv->vfo_b.freq = freq;break;
+ case RIG_VFO_SUB:
+ case RIG_VFO_B: priv->vfo_b.freq = freq; break;
- case RIG_VFO_C: priv->vfo_c.freq = freq;break;
+ case RIG_VFO_C: priv->vfo_c.freq = freq; break;
}
if (!priv->split)
@@ -470,11 +470,11 @@ static int dummy_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
switch (vfo)
{
- case RIG_VFO_A: priv->vfo_a.mode = mode; priv->vfo_a.width = width;break;
+ case RIG_VFO_A: priv->vfo_a.mode = mode; priv->vfo_a.width = width; break;
- case RIG_VFO_B: priv->vfo_b.mode = mode; priv->vfo_b.width = width;break;
+ case RIG_VFO_B: priv->vfo_b.mode = mode; priv->vfo_b.width = width; break;
- case RIG_VFO_C: priv->vfo_c.mode = mode; priv->vfo_c.width = width;break;
+ case RIG_VFO_C: priv->vfo_c.mode = mode; priv->vfo_c.width = width; break;
}
if (RIG_PASSBAND_NOCHANGE == width) { RETURNFUNC(RIG_OK); }
@@ -483,6 +483,7 @@ static int dummy_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
width = curr->width = rig_passband_normal(rig, mode);
}
+
switch (vfo)
{
case RIG_VFO_A: priv->vfo_a.width = width; break;
@@ -504,17 +505,17 @@ static int dummy_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
usleep(CMDSLEEP);
rig_debug(RIG_DEBUG_VERBOSE, "%s called: %s\n", __func__, rig_strvfo(vfo));
- if (vfo == RIG_VFO_CURR) vfo = rig->state.current_vfo;
+ if (vfo == RIG_VFO_CURR) { vfo = rig->state.current_vfo; }
- switch(vfo)
+ switch (vfo)
{
- case RIG_VFO_MAIN:
- case RIG_VFO_A: *mode = priv->vfo_a.mode;*width = priv->vfo_a.width; break;
+ case RIG_VFO_MAIN:
+ case RIG_VFO_A: *mode = priv->vfo_a.mode; *width = priv->vfo_a.width; break;
- case RIG_VFO_SUB:
- case RIG_VFO_B: *mode = priv->vfo_b.mode;*width = priv->vfo_b.width; break;
+ case RIG_VFO_SUB:
+ case RIG_VFO_B: *mode = priv->vfo_b.mode; *width = priv->vfo_b.width; break;
- case RIG_VFO_C: *mode = priv->vfo_c.mode;*width = priv->vfo_c.width; break;
+ case RIG_VFO_C: *mode = priv->vfo_c.mode; *width = priv->vfo_c.width; break;
}
RETURNFUNC(RIG_OK);
@@ -530,7 +531,7 @@ static int dummy_set_vfo(RIG *rig, vfo_t vfo)
usleep(CMDSLEEP);
rig_debug(RIG_DEBUG_VERBOSE, "%s called: %s\n", __func__, rig_strvfo(vfo));
- if (vfo == RIG_VFO_CURR) vfo = rig->state.current_vfo;
+ if (vfo == RIG_VFO_CURR) { vfo = rig->state.current_vfo; }
priv->last_vfo = priv->curr_vfo;
priv->curr_vfo = vfo;
@@ -2122,7 +2123,7 @@ struct rig_caps dummy_caps =
.copyright = "LGPL",
.status = RIG_STATUS_STABLE,
.rig_type = RIG_TYPE_OTHER,
- .targetable_vfo = RIG_TARGETABLE_PTT | RIG_TARGETABLE_RITXIT|RIG_TARGETABLE_FREQ|RIG_TARGETABLE_MODE,
+ .targetable_vfo = RIG_TARGETABLE_PTT | RIG_TARGETABLE_RITXIT | RIG_TARGETABLE_FREQ | RIG_TARGETABLE_MODE,
.ptt_type = RIG_PTT_RIG,
.dcd_type = RIG_DCD_RIG,
.port_type = RIG_PORT_NONE,
@@ -2287,7 +2288,7 @@ struct rig_caps dummy_no_vfo_caps =
.copyright = "LGPL",
.status = RIG_STATUS_STABLE,
.rig_type = RIG_TYPE_OTHER,
- .targetable_vfo = RIG_TARGETABLE_PTT | RIG_TARGETABLE_RITXIT|RIG_TARGETABLE_FREQ|RIG_TARGETABLE_MODE,
+ .targetable_vfo = RIG_TARGETABLE_PTT | RIG_TARGETABLE_RITXIT | RIG_TARGETABLE_FREQ | RIG_TARGETABLE_MODE,
.ptt_type = RIG_PTT_RIG,
.dcd_type = RIG_DCD_RIG,
.port_type = RIG_PORT_NONE,
diff --git a/rigs/dummy/flrig.c b/rigs/dummy/flrig.c
index 1082e3b2..5dc5bfd1 100644
--- a/rigs/dummy/flrig.c
+++ b/rigs/dummy/flrig.c
@@ -71,7 +71,7 @@ static int flrig_get_freq(RIG *rig, vfo_t vfo, freq_t *freq);
static int flrig_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt);
static int flrig_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width);
static int flrig_set_split_mode(RIG *rig, vfo_t vfo, rmode_t mode,
- pbwidth_t width);
+ pbwidth_t width);
static int flrig_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width);
static int flrig_get_vfo(RIG *rig, vfo_t *vfo);
static int flrig_set_vfo(RIG *rig, vfo_t vfo);
@@ -80,138 +80,138 @@ static int flrig_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt);
static int flrig_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq);
static int flrig_get_split_freq(RIG *rig, vfo_t vfo, freq_t *tx_freq);
static int flrig_set_split_vfo(RIG *rig, vfo_t vfo, split_t split,
- vfo_t tx_vfo);
+ vfo_t tx_vfo);
static int flrig_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split,
- vfo_t *tx_vfo);
+ vfo_t *tx_vfo);
static int flrig_set_split_freq_mode(RIG *rig, vfo_t vfo, freq_t freq,
- rmode_t mode, pbwidth_t width);
+ rmode_t mode, pbwidth_t width);
static int flrig_get_split_freq_mode(RIG *rig, vfo_t vfo, freq_t *freq,
- rmode_t *mode, pbwidth_t *width);
+ rmode_t *mode, pbwidth_t *width);
static int flrig_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val);
static int flrig_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val);
static const char *flrig_get_info(RIG *rig);
static int flrig_power2mW(RIG *rig, unsigned int *mwpower, float power,
- freq_t freq, rmode_t mode);
+ freq_t freq, rmode_t mode);
static int flrig_mW2power(RIG *rig, float *power, unsigned int mwpower,
- freq_t freq, rmode_t mode);
+ freq_t freq, rmode_t mode);
struct flrig_priv_data
{
- vfo_t curr_vfo;
- char bandwidths[MAXBANDWIDTHLEN]; /* pipe delimited set returned from flrig */
- int nbandwidths;
- char info[8192];
- ptt_t ptt;
- split_t split;
- rmode_t curr_modeA;
- rmode_t curr_modeB;
- freq_t curr_freqA;
- freq_t curr_freqB;
- pbwidth_t curr_widthA;
- pbwidth_t curr_widthB;
- int has_get_modeA; /* True if this function is available */
- int has_get_bwA; /* True if this function is available */
- float powermeter_scale; /* So we can scale power meter to 0-1 */
+ vfo_t curr_vfo;
+ char bandwidths[MAXBANDWIDTHLEN]; /* pipe delimited set returned from flrig */
+ int nbandwidths;
+ char info[8192];
+ ptt_t ptt;
+ split_t split;
+ rmode_t curr_modeA;
+ rmode_t curr_modeB;
+ freq_t curr_freqA;
+ freq_t curr_freqB;
+ pbwidth_t curr_widthA;
+ pbwidth_t curr_widthB;
+ int has_get_modeA; /* True if this function is available */
+ int has_get_bwA; /* True if this function is available */
+ float powermeter_scale; /* So we can scale power meter to 0-1 */
};
const struct rig_caps flrig_caps =
{
- RIG_MODEL(RIG_MODEL_FLRIG),
- .model_name = "FLRig",
- .mfg_name = "FLRig",
- .version = BACKEND_VER ".0",
- .copyright = "LGPL",
- .status = RIG_STATUS_STABLE,
- .rig_type = RIG_TYPE_TRANSCEIVER,
- .targetable_vfo = RIG_TARGETABLE_FREQ | RIG_TARGETABLE_MODE,
- .ptt_type = RIG_PTT_RIG,
- .port_type = RIG_PORT_NETWORK,
- .write_delay = 0,
- .post_write_delay = 0,
- .timeout = 5000,
- .retry = 5,
-
- .has_get_func = RIG_FUNC_NONE,
- .has_set_func = RIG_FUNC_NONE,
- .has_get_level = FLRIG_LEVELS,
- .has_set_level = RIG_LEVEL_SET(FLRIG_LEVELS),
- .has_get_parm = RIG_PARM_NONE,
- .has_set_parm = RIG_PARM_NONE,
- .filters = {
- RIG_FLT_END
- },
-
- .rx_range_list1 = {{
- .startf = kHz(1), .endf = GHz(10), .modes = FLRIG_MODES,
- .low_power = -1, .high_power = -1, FLRIG_VFOS, RIG_ANT_1
- },
- RIG_FRNG_END,
- },
- .tx_range_list1 = {RIG_FRNG_END,},
- .rx_range_list2 = {{
- .startf = kHz(1), .endf = GHz(10), .modes = FLRIG_MODES,
- .low_power = -1, .high_power = -1, FLRIG_VFOS, RIG_ANT_1
- },
- RIG_FRNG_END,
- },
- .tx_range_list2 = {RIG_FRNG_END,},
- .tuning_steps = { {FLRIG_MODES, 1}, {FLRIG_MODES, RIG_TS_ANY}, RIG_TS_END, },
- .priv = NULL, /* priv */
-
- .rig_init = flrig_init,
- .rig_open = flrig_open,
- .rig_close = flrig_close,
- .rig_cleanup = flrig_cleanup,
-
- .set_freq = flrig_set_freq,
- .get_freq = flrig_get_freq,
- .set_mode = flrig_set_mode,
- .get_mode = flrig_get_mode,
- .set_vfo = flrig_set_vfo,
- .get_vfo = flrig_get_vfo,
- .get_info = flrig_get_info,
- .set_ptt = flrig_set_ptt,
- .get_ptt = flrig_get_ptt,
- .set_split_mode = flrig_set_split_mode,
- .set_split_freq = flrig_set_split_freq,
- .get_split_freq = flrig_get_split_freq,
- .set_split_vfo = flrig_set_split_vfo,
- .get_split_vfo = flrig_get_split_vfo,
- .set_split_freq_mode = flrig_set_split_freq_mode,
- .get_split_freq_mode = flrig_get_split_freq_mode,
- .set_level = flrig_set_level,
- .get_level = flrig_get_level,
- .power2mW = flrig_power2mW,
- .mW2power = flrig_mW2power
+ RIG_MODEL(RIG_MODEL_FLRIG),
+ .model_name = "FLRig",
+ .mfg_name = "FLRig",
+ .version = BACKEND_VER ".0",
+ .copyright = "LGPL",
+ .status = RIG_STATUS_STABLE,
+ .rig_type = RIG_TYPE_TRANSCEIVER,
+ .targetable_vfo = RIG_TARGETABLE_FREQ | RIG_TARGETABLE_MODE,
+ .ptt_type = RIG_PTT_RIG,
+ .port_type = RIG_PORT_NETWORK,
+ .write_delay = 0,
+ .post_write_delay = 0,
+ .timeout = 5000,
+ .retry = 5,
+
+ .has_get_func = RIG_FUNC_NONE,
+ .has_set_func = RIG_FUNC_NONE,
+ .has_get_level = FLRIG_LEVELS,
+ .has_set_level = RIG_LEVEL_SET(FLRIG_LEVELS),
+ .has_get_parm = RIG_PARM_NONE,
+ .has_set_parm = RIG_PARM_NONE,
+ .filters = {
+ RIG_FLT_END
+ },
+
+ .rx_range_list1 = {{
+ .startf = kHz(1), .endf = GHz(10), .modes = FLRIG_MODES,
+ .low_power = -1, .high_power = -1, FLRIG_VFOS, RIG_ANT_1
+ },
+ RIG_FRNG_END,
+ },
+ .tx_range_list1 = {RIG_FRNG_END,},
+ .rx_range_list2 = {{
+ .startf = kHz(1), .endf = GHz(10), .modes = FLRIG_MODES,
+ .low_power = -1, .high_power = -1, FLRIG_VFOS, RIG_ANT_1
+ },
+ RIG_FRNG_END,
+ },
+ .tx_range_list2 = {RIG_FRNG_END,},
+ .tuning_steps = { {FLRIG_MODES, 1}, {FLRIG_MODES, RIG_TS_ANY}, RIG_TS_END, },
+ .priv = NULL, /* priv */
+
+ .rig_init = flrig_init,
+ .rig_open = flrig_open,
+ .rig_close = flrig_close,
+ .rig_cleanup = flrig_cleanup,
+
+ .set_freq = flrig_set_freq,
+ .get_freq = flrig_get_freq,
+ .set_mode = flrig_set_mode,
+ .get_mode = flrig_get_mode,
+ .set_vfo = flrig_set_vfo,
+ .get_vfo = flrig_get_vfo,
+ .get_info = flrig_get_info,
+ .set_ptt = flrig_set_ptt,
+ .get_ptt = flrig_get_ptt,
+ .set_split_mode = flrig_set_split_mode,
+ .set_split_freq = flrig_set_split_freq,
+ .get_split_freq = flrig_get_split_freq,
+ .set_split_vfo = flrig_set_split_vfo,
+ .get_split_vfo = flrig_get_split_vfo,
+ .set_split_freq_mode = flrig_set_split_freq_mode,
+ .get_split_freq_mode = flrig_get_split_freq_mode,
+ .set_level = flrig_set_level,
+ .get_level = flrig_get_level,
+ .power2mW = flrig_power2mW,
+ .mW2power = flrig_mW2power
};
//Structure for mapping flrig dynmamic modes to hamlib modes
//flrig displays modes as the rig displays them
struct s_modeMap
{
- rmode_t mode_hamlib;
- char *mode_flrig;
+ rmode_t mode_hamlib;
+ char *mode_flrig;
};
//FLRig will provide us the modes for the selected rig
//We will then put them in this struct
static struct s_modeMap modeMap[] =
{
- {RIG_MODE_USB, NULL},
- {RIG_MODE_LSB, NULL},
- {RIG_MODE_PKTUSB, NULL},
- {RIG_MODE_PKTLSB, NULL},
- {RIG_MODE_AM, NULL},
- {RIG_MODE_FM, NULL},
- {RIG_MODE_FMN, NULL},
- {RIG_MODE_WFM, NULL},
- {RIG_MODE_CW, NULL},
- {RIG_MODE_CWR, NULL},
- {RIG_MODE_RTTY, NULL},
- {RIG_MODE_RTTYR, NULL},
- {RIG_MODE_C4FM, NULL},
- {0, NULL}
+ {RIG_MODE_USB, NULL},
+ {RIG_MODE_LSB, NULL},
+ {RIG_MODE_PKTUSB, NULL},
+ {RIG_MODE_PKTLSB, NULL},
+ {RIG_MODE_AM, NULL},
+ {RIG_MODE_FM, NULL},
+ {RIG_MODE_FMN, NULL},
+ {RIG_MODE_WFM, NULL},
+ {RIG_MODE_CW, NULL},
+ {RIG_MODE_CWR, NULL},
+ {RIG_MODE_RTTY, NULL},
+ {RIG_MODE_RTTYR, NULL},
+ {RIG_MODE_C4FM, NULL},
+ {0, NULL}
};
/*
@@ -220,23 +220,23 @@ static struct s_modeMap modeMap[] =
*/
static int check_vfo(vfo_t vfo)
{
- switch (vfo)
- {
- case RIG_VFO_A:
- break;
+ switch (vfo)
+ {
+ case RIG_VFO_A:
+ break;
- case RIG_VFO_TX:
- case RIG_VFO_B:
- break;
+ case RIG_VFO_TX:
+ case RIG_VFO_B:
+ break;
- case RIG_VFO_CURR:
- break; // will default to A in which_vfo
+ case RIG_VFO_CURR:
+ break; // will default to A in which_vfo
- default:
- RETURNFUNC(FALSE);
- }
+ default:
+ RETURNFUNC(FALSE);
+ }
- RETURNFUNC(TRUE);
+ RETURNFUNC(TRUE);
}
/*Rather than use some huge XML library we only need a few things
@@ -245,52 +245,52 @@ static int check_vfo(vfo_t vfo)
*/
static char *xml_build(char *cmd, char *value, char *xmlbuf, int xmlbuflen)
{
- char xml[4096]; // we shouldn't need more the 4096 bytes for this
- char tmp[32];
- char *header;
- int n;
-
- // We want at least a 4K buf to play with
- if (xmlbuflen < 4096)
- {
- rig_debug(RIG_DEBUG_ERR, "%s: xmllen < 4096\n", __func__);
- return NULL;
- }
-
- header =
- "POST /RPC2 HTTP/1.1\r\n" "User-Agent: XMLRPC++ 0.8\r\n"
- "Host: 127.0.0.1:12345\r\n" "Content-type: text/xml\r\n";
- n = snprintf(xmlbuf, xmlbuflen, "%s", header);
-
- if (n != strlen(header))
- {
- rig_debug(RIG_DEBUG_ERR, "%s: snprintf of header failed, len=%d, got=%d\n",
- __func__, (int)strlen(header), n);
- }
-
- n = snprintf(xml, sizeof(xml), "<?xml version=\"1.0\"?>\r\n");
-
- if (n != strlen(xml))
- {
- rig_debug(RIG_DEBUG_ERR, "%s: snprintf of xml failed, len=%d, got=%d\n",
- __func__, (int)strlen(header), n);
- }
-
- strncat(xml, "<methodCall><methodName>", sizeof(xml) - 1);
- strncat(xml, cmd, sizeof(xml) - strlen(xml) - 1);
- strncat(xml, "</methodName>\r\n", sizeof(xml) - strlen(xml) - 1);
-
- if (value && strlen(value) > 0)
- {
- strncat(xml, value, sizeof(xml) - 1);
- }
-
- strncat(xml, "</methodCall>\r\n", sizeof(xml) - 1);
- strncat(xmlbuf, "Content-length: ", xmlbuflen - 1);
- snprintf(tmp, sizeof(tmp), "%d\r\n\r\n", (int)strlen(xml));
- strncat(xmlbuf, tmp, xmlbuflen - 1);
- strncat(xmlbuf, xml, xmlbuflen - 1);
- return xmlbuf;
+ char xml[4096]; // we shouldn't need more the 4096 bytes for this
+ char tmp[32];
+ char *header;
+ int n;
+
+ // We want at least a 4K buf to play with
+ if (xmlbuflen < 4096)
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: xmllen < 4096\n", __func__);
+ return NULL;
+ }
+
+ header =
+ "POST /RPC2 HTTP/1.1\r\n" "User-Agent: XMLRPC++ 0.8\r\n"
+ "Host: 127.0.0.1:12345\r\n" "Content-type: text/xml\r\n";
+ n = snprintf(xmlbuf, xmlbuflen, "%s", header);
+
+ if (n != strlen(header))
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: snprintf of header failed, len=%d, got=%d\n",
+ __func__, (int)strlen(header), n);
+ }
+
+ n = snprintf(xml, sizeof(xml), "<?xml version=\"1.0\"?>\r\n");
+
+ if (n != strlen(xml))
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: snprintf of xml failed, len=%d, got=%d\n",
+ __func__, (int)strlen(header), n);
+ }
+
+ strncat(xml, "<methodCall><methodName>", sizeof(xml) - 1);
+ strncat(xml, cmd, sizeof(xml) - strlen(xml) - 1);
+ strncat(xml, "</methodName>\r\n", sizeof(xml) - strlen(xml) - 1);
+
+ if (value && strlen(value) > 0)
+ {
+ strncat(xml, value, sizeof(xml) - 1);
+ }
+
+ strncat(xml, "</methodCall>\r\n", sizeof(xml) - 1);
+ strncat(xmlbuf, "Content-length: ", xmlbuflen - 1);
+ snprintf(tmp, sizeof(tmp), "%d\r\n\r\n", (int)strlen(xml));
+ strncat(xmlbuf, tmp, xmlbuflen - 1);
+ strncat(xmlbuf, xml, xmlbuflen - 1);
+ return xmlbuf;
}
/*This is a very crude xml parse specific to what we need from FLRig
@@ -299,59 +299,59 @@ static char *xml_build(char *cmd, char *value, char *xmlbuf, int xmlbuflen)
*/
static char *xml_parse2(char *xml, char *value, int valueLen)
{
- char *delims = "<>\r\n ";
- char *xmltmp = strdup(xml);
- //rig_debug(RIG_DEBUG_TRACE, "%s: xml='%s'\n", __func__,xml);
- char *pr = xml;
- char *p = strtok_r(xmltmp, delims, &pr);
- value[0] = 0;
-
- while (p)
- {
- if (streq(p, "value"))
- {
- p = strtok_r(NULL, delims, &pr);
-
- if (streq(p, "array")) { continue; }
-
- if (streq(p, "/value")) { continue; } // empty value
-
- if (streq(p, "i4") || streq(p, "double"))
- {
- p = strtok_r(NULL, delims, &pr);
- }
- else if (streq(p, "array"))
- {
- strtok_r(NULL, delims, &pr);
- p = strtok_r(NULL, delims, &pr);
- }
-
- if (strlen(value) + strlen(p) + 1 < valueLen)
- {
- if (value[0] != 0) { strcat(value, "|"); }
-
- strcat(value, p);
- }
- else // we'll just stop adding stuff
- {
- rig_debug(RIG_DEBUG_ERR, "%s: max value length exceeded\n", __func__);
- }
- }
- else
- {
- p = strtok_r(NULL, delims, &pr);
- }
- }
-
- rig_debug(RIG_DEBUG_TRACE, "%s: value returned='%s'\n", __func__, value);
-
- if (rig_need_debug(RIG_DEBUG_WARN) && value != NULL && strlen(value) == 0)
- {
- rig_debug(RIG_DEBUG_ERR, "%s: xml='%s'\n", __func__, xml);
- }
-
- free(xmltmp);
- return value;
+ char *delims = "<>\r\n ";
+ char *xmltmp = strdup(xml);
+ //rig_debug(RIG_DEBUG_TRACE, "%s: xml='%s'\n", __func__,xml);
+ char *pr = xml;
+ char *p = strtok_r(xmltmp, delims, &pr);
+ value[0] = 0;
+
+ while (p)
+ {
+ if (streq(p, "value"))
+ {
+ p = strtok_r(NULL, delims, &pr);
+
+ if (streq(p, "array")) { continue; }
+
+ if (streq(p, "/value")) { continue; } // empty value
+
+ if (streq(p, "i4") || streq(p, "double"))
+ {
+ p = strtok_r(NULL, delims, &pr);
+ }
+ else if (streq(p, "array"))
+ {
+ strtok_r(NULL, delims, &pr);
+ p = strtok_r(NULL, delims, &pr);
+ }
+
+ if (strlen(value) + strlen(p) + 1 < valueLen)
+ {
+ if (value[0] != 0) { strcat(value, "|"); }
+
+ strcat(value, p);
+ }
+ else // we'll just stop adding stuff
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: max value length exceeded\n", __func__);
+ }
+ }
+ else
+ {
+ p = strtok_r(NULL, delims, &pr);
+ }
+ }
+
+ rig_debug(RIG_DEBUG_TRACE, "%s: value returned='%s'\n", __func__, value);
+
+ if (rig_need_debug(RIG_DEBUG_WARN) && value != NULL && strlen(value) == 0)
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: xml='%s'\n", __func__, xml);
+ }
+
+ free(xmltmp);
+ return value;
}
/*
@@ -361,39 +361,39 @@ static char *xml_parse2(char *xml, char *value, int valueLen)
*/
static char *xml_parse(char *xml, char *value, int value_len)
{
- char *next;
- char *pxml;
+ char *next;
+ char *pxml;
- /* first off we should have an OK on the 1st line */
- if (strstr(xml, " 200 OK") == NULL)
- {
- return(NULL);
- }
+ /* first off we should have an OK on the 1st line */
+ if (strstr(xml, " 200 OK") == NULL)
+ {
+ return (NULL);
+ }
- rig_debug(RIG_DEBUG_TRACE, "%s XML:\n%s\n", __func__, xml);
+ rig_debug(RIG_DEBUG_TRACE, "%s XML:\n%s\n", __func__, xml);
- // find the xml skipping the other stuff above it
- pxml = strstr(xml, "<?xml");
+ // find the xml skipping the other stuff above it
+ pxml = strstr(xml, "<?xml");
- if (pxml == NULL)
- {
- return(NULL);
- }
+ if (pxml == NULL)
+ {
+ return (NULL);
+ }
- next = strchr(pxml + 1, '<');
+ next = strchr(pxml + 1, '<');
- if (value != NULL)
- {
- xml_parse2(next, value, value_len);
- }
+ if (value != NULL)
+ {
+ xml_parse2(next, value, value_len);
+ }
- if (value && strstr(value, "faultString"))
- {
- rig_debug(RIG_DEBUG_ERR, "%s error:\n%s\n", __func__, value);
- value[0] = 0; /* truncate to give empty response */
- }
+ if (value && strstr(value, "faultString"))
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s error:\n%s\n", __func__, value);
+ value[0] = 0; /* truncate to give empty response */
+ }
- return(value);
+ return (value);
}
/*
@@ -402,81 +402,81 @@ static char *xml_parse(char *xml, char *value, int value_len)
*/
static int read_transaction(RIG *rig, char *xml, int xml_len)
{
- int retval;
- int retry;
- char *delims;
- char *terminator = "</methodResponse>";
- struct rig_state *rs = &rig->state;
-
- ENTERFUNC;
-
- retry = 2;
- delims = "\n";
- xml[0] = 0;
-
- do
- {
- char tmp_buf[MAXXMLLEN]; // plenty big for expected flrig responses hopefully
-
- if (retry < 2)
- {
- rig_debug(RIG_DEBUG_WARN, "%s: retry needed? retry=%d\n", __func__, retry);
- }
-
- int len = read_string(&rs->rigport, tmp_buf, sizeof(tmp_buf), delims,
- strlen(delims));
- rig_debug(RIG_DEBUG_TRACE, "%s: string='%s'\n", __func__, tmp_buf);
-
- // if our first response we should see the HTTP header
- if (strlen(xml) == 0 && strstr(tmp_buf, "HTTP/1.1 200 OK") == NULL)
- {
- rig_debug(RIG_DEBUG_ERR, "%s: Expected 'HTTP/1.1 200 OK', got '%s'\n", __func__,
- tmp_buf);
- RETURNFUNC(-1);
- }
-
- if (len > 0) { retry = 3; }
-
- if (len <= 0)
- {
- rig_debug(RIG_DEBUG_ERR, "%s: read_string error=%d\n", __func__, len);
- continue;
- }
-
- if (strlen(xml) + strlen(tmp_buf) < xml_len - 1)
- {
- strncat(xml, tmp_buf, xml_len - 1);
- }
- else
- {
- rig_debug(RIG_DEBUG_ERR,
- "%s: xml buffer overflow!!\nTrying to add len=%d\nTo len=%d\n", __func__,
- (int)strlen(tmp_buf), (int)strlen(xml));
- RETURNFUNC(-RIG_EPROTO);
- }
- }
- while (retry-- > 0 && strstr(xml, terminator) == NULL);
-
- if (retry == 0)
- {
- rig_debug(RIG_DEBUG_WARN, "%s: retry timeout\n", __func__);
- RETURNFUNC(-RIG_ETIMEOUT);
- }
-
- if (strstr(xml, terminator))
- {
- rig_debug(RIG_DEBUG_TRACE, "%s: got %s\n", __func__, terminator);
- // Slow down just a bit -- not sure this is needed anymore but not a big deal here
- hl_usleep(2 * 1000);
- retval = RIG_OK;
- }
- else
- {
- rig_debug(RIG_DEBUG_VERBOSE, "%s: did not get %s\n", __func__, terminator);
- retval = -(101 + RIG_EPROTO);
- }
-
- RETURNFUNC(retval);
+ int retval;
+ int retry;
+ char *delims;
+ char *terminator = "</methodResponse>";
+ struct rig_state *rs = &rig->state;
+
+ ENTERFUNC;
+
+ retry = 2;
+ delims = "\n";
+ xml[0] = 0;
+
+ do
+ {
+ char tmp_buf[MAXXMLLEN]; // plenty big for expected flrig responses hopefully
+
+ if (retry < 2)
+ {
+ rig_debug(RIG_DEBUG_WARN, "%s: retry needed? retry=%d\n", __func__, retry);
+ }
+
+ int len = read_string(&rs->rigport, tmp_buf, sizeof(tmp_buf), delims,
+ strlen(delims));
+ rig_debug(RIG_DEBUG_TRACE, "%s: string='%s'\n", __func__, tmp_buf);
+
+ // if our first response we should see the HTTP header
+ if (strlen(xml) == 0 && strstr(tmp_buf, "HTTP/1.1 200 OK") == NULL)
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: Expected 'HTTP/1.1 200 OK', got '%s'\n", __func__,
+ tmp_buf);
+ continue; // we'll try again
+ }
+
+ if (len > 0) { retry = 3; }
+
+ if (len <= 0)
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: read_string error=%d\n", __func__, len);
+ continue;
+ }
+
+ if (strlen(xml) + strlen(tmp_buf) < xml_len - 1)
+ {
+ strncat(xml, tmp_buf, xml_len - 1);
+ }
+ else
+ {
+ rig_debug(RIG_DEBUG_ERR,
+ "%s: xml buffer overflow!!\nTrying to add len=%d\nTo len=%d\n", __func__,
+ (int)strlen(tmp_buf), (int)strlen(xml));
+ RETURNFUNC(-RIG_EPROTO);
+ }
+ }
+ while (retry-- > 0 && strstr(xml, terminator) == NULL);
+
+ if (retry == 0)
+ {
+ rig_debug(RIG_DEBUG_WARN, "%s: retry timeout\n", __func__);
+ RETURNFUNC(-RIG_ETIMEOUT);
+ }
+
+ if (strstr(xml, terminator))
+ {
+ rig_debug(RIG_DEBUG_TRACE, "%s: got %s\n", __func__, terminator);
+ // Slow down just a bit -- not sure this is needed anymore but not a big deal here
+ hl_usleep(2 * 1000);
+ retval = RIG_OK;
+ }
+ else
+ {
+ rig_debug(RIG_DEBUG_VERBOSE, "%s: did not get %s\n", __func__, terminator);
+ retval = -(101 + RIG_EPROTO);
+ }
+
+ RETURNFUNC(retval);
}
/*
@@ -486,89 +486,89 @@ static int read_transaction(RIG *rig, char *xml, int xml_len)
static int write_transaction(RIG *rig, char *xml, int xml_len)
{
- int try = rig->caps->retry;
+ int try = rig->caps->retry;
- int retval = -RIG_EPROTO;
+ int retval = -RIG_EPROTO;
- struct rig_state *rs = &rig->state;
+ struct rig_state *rs = &rig->state;
- ENTERFUNC;
+ ENTERFUNC;
- // This shouldn't ever happen...but just in case
- // We need to avoid an empty write as rigctld replies with blank line
- if (xml_len == 0)
- {
- rig_debug(RIG_DEBUG_ERR, "%s: len==0??\n", __func__);
- RETURNFUNC(retval);
- }
+ // This shouldn't ever happen...but just in case
+ // We need to avoid an empty write as rigctld replies with blank line
+ if (xml_len == 0)
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: len==0??\n", __func__);
+ RETURNFUNC(retval);
+ }
- // appears we can lose sync if we don't clear things out
- // shouldn't be anything for us now anyways
- rig_flush(&rig->state.rigport);
+ // appears we can lose sync if we don't clear things out
+ // shouldn't be anything for us now anyways
+ rig_flush(&rig->state.rigport);
- while (try-- >= 0 && retval != RIG_OK)
- {
- retval = write_block(&rs->rigport, xml, strlen(xml));
+ while (try-- >= 0 && retval != RIG_OK)
+ {
+ retval = write_block(&rs->rigport, xml, strlen(xml));
- if (retval < 0)
- {
- RETURNFUNC(-RIG_EIO);
- }
- }
+ if (retval < 0)
+ {
+ RETURNFUNC(-RIG_EIO);
+ }
+ }
- RETURNFUNC(retval);
+ RETURNFUNC(retval);
}
static int flrig_transaction(RIG *rig, char *cmd, char *cmd_arg, char *value,
- int value_len)
+ int value_len)
{
- char xml[MAXXMLLEN];
- int retry = 5;
+ char xml[MAXXMLLEN];
+ int retry = 5;
- ENTERFUNC;
+ ENTERFUNC;
- if (value)
- {
- value[0] = 0;
- }
+ if (value)
+ {
+ value[0] = 0;
+ }
- do
- {
- char *pxml;
- int retval;
+ do
+ {
+ char *pxml;
+ int retval;
- if (retry < 2)
- {
- rig_debug(RIG_DEBUG_VERBOSE, "%s: cmd=%s, retry=%d\n", __func__, cmd, retry);
- }
+ if (retry < 2)
+ {
+ rig_debug(RIG_DEBUG_VERBOSE, "%s: cmd=%s, retry=%d\n", __func__, cmd, retry);
+ }
- pxml = xml_build(cmd, cmd_arg, xml, sizeof(xml));
- retval = write_transaction(rig, pxml, strlen(pxml));
+ pxml = xml_build(cmd, cmd_arg, xml, sizeof(xml));
+ retval = write_transaction(rig, pxml, strlen(pxml));
- if (retval != RIG_OK)
- {
- rig_debug(RIG_DEBUG_ERR, "%s: write_transaction error=%d\n", __func__, retval);
+ if (retval != RIG_OK)
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: write_transaction error=%d\n", __func__, retval);
- // if we get RIG_EIO the socket has probably disappeared
- // so bubble up the error so port can re re-opened
- if (retval == -RIG_EIO) { RETURNFUNC(retval); }
+ // if we get RIG_EIO the socket has probably disappeared
+ // so bubble up the error so port can re re-opened
+ if (retval == -RIG_EIO) { RETURNFUNC(retval); }
- hl_usleep(50 * 1000); // 50ms sleep if error
- }
+ hl_usleep(50 * 1000); // 50ms sleep if error
+ }
- read_transaction(rig, xml, sizeof(xml)); // this might time out -- that's OK
+ read_transaction(rig, xml, sizeof(xml)); // this might time out -- that's OK
- if (value)
- {
- xml_parse(xml, value, value_len);
- }
- }
- while (((value && strlen(value) == 0) || (strlen(xml) == 0))
- && retry--); // we'll do retries if needed
+ if (value)
+ {
+ xml_parse(xml, value, value_len);
+ }
+ }
+ while (((value && strlen(value) == 0) || (strlen(xml) == 0))
+ && retry--); // we'll do retries if needed
- if (value && strlen(value) == 0) { RETURNFUNC(RIG_EPROTO); }
+ if (value && strlen(value) == 0) { RETURNFUNC(RIG_EPROTO); }
- RETURNFUNC(RIG_OK);
+ RETURNFUNC(RIG_OK);
}
/*
@@ -577,43 +577,43 @@ static int flrig_transaction(RIG *rig, char *cmd, char *cmd_arg, char *value,
*/
static int flrig_init(RIG *rig)
{
- struct flrig_priv_data *priv;
+ struct flrig_priv_data *priv;
- ENTERFUNC;
- rig_debug(RIG_DEBUG_TRACE, "%s version %s\n", __func__, BACKEND_VER);
+ ENTERFUNC;
+ rig_debug(RIG_DEBUG_TRACE, "%s version %s\n", __func__, BACKEND_VER);
- rig->state.priv = (struct flrig_priv_data *)malloc(sizeof(
- struct flrig_priv_data));
+ rig->state.priv = (struct flrig_priv_data *)malloc(sizeof(
+ struct flrig_priv_data));
- if (!rig->state.priv)
- {
- RETURNFUNC(-RIG_ENOMEM);
- }
+ if (!rig->state.priv)
+ {
+ RETURNFUNC(-RIG_ENOMEM);
+ }
- priv = rig->state.priv;
+ priv = rig->state.priv;
- memset(priv, 0, sizeof(struct flrig_priv_data));
+ memset(priv, 0, sizeof(struct flrig_priv_data));
- /*
- * set arbitrary initial status
- */
- rig->state.current_vfo = RIG_VFO_A;
- priv->split = 0;
- priv->ptt = 0;
- priv->curr_modeA = -1;
- priv->curr_modeB = -1;
- priv->curr_widthA = -1;
- priv->curr_widthB = -1;
-
- if (!rig->caps)
- {
- RETURNFUNC(-RIG_EINVAL);
- }
-
- strncpy(rig->state.rigport.pathname, DEFAULTPATH,
- sizeof(rig->state.rigport.pathname));
-
- RETURNFUNC(RIG_OK);
+ /*
+ * set arbitrary initial status
+ */
+ rig->state.current_vfo = RIG_VFO_A;
+ priv->split = 0;
+ priv->ptt = 0;
+ priv->curr_modeA = -1;
+ priv->curr_modeB = -1;
+ priv->curr_widthA = -1;
+ priv->curr_widthB = -1;
+
+ if (!rig->caps)
+ {
+ RETURNFUNC(-RIG_EINVAL);
+ }
+
+ strncpy(rig->state.rigport.pathname, DEFAULTPATH,
+ sizeof(rig->state.rigport.pathname));
+
+ RETURNFUNC(RIG_OK);
}
/*
@@ -623,27 +623,27 @@ static int flrig_init(RIG *rig)
*/
static const char *modeMapGetFLRig(rmode_t modeHamlib)
{
- int i;
-
- rig_debug(RIG_DEBUG_TRACE,"%s: called\n", __func__);
-
- for (i = 0; modeMap[i].mode_hamlib != 0; ++i)
- {
- rig_debug(RIG_DEBUG_TRACE,
- "%s: checking modeMap[%d]=%.0f to modeHamlib=%.0f, mode_flrig='%s'\n", __func__,
- i, (double)modeMap[i].mode_hamlib, (double)modeHamlib, modeMap[i].mode_flrig);
-
- if (modeMap[i].mode_hamlib == modeHamlib)
- {
- rig_debug(RIG_DEBUG_TRACE, "%s matched mode=%.0f, returning '%s'\n", __func__,
- (double)modeHamlib, modeMap[i].mode_flrig);
- return(modeMap[i].mode_flrig);
- }
- }
-
- rig_debug(RIG_DEBUG_ERR, "%s: Unknown mode requested: %s\n", __func__,
- rig_strrmode(modeHamlib));
- return("ERROR");
+ int i;
+
+ rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
+
+ for (i = 0; modeMap[i].mode_hamlib != 0; ++i)
+ {
+ rig_debug(RIG_DEBUG_TRACE,
+ "%s: checking modeMap[%d]=%.0f to modeHamlib=%.0f, mode_flrig='%s'\n", __func__,
+ i, (double)modeMap[i].mode_hamlib, (double)modeHamlib, modeMap[i].mode_flrig);
+
+ if (modeMap[i].mode_hamlib == modeHamlib)
+ {
+ rig_debug(RIG_DEBUG_TRACE, "%s matched mode=%.0f, returning '%s'\n", __func__,
+ (double)modeHamlib, modeMap[i].mode_flrig);
+ return (modeMap[i].mode_flrig);
+ }
+ }
+
+ rig_debug(RIG_DEBUG_ERR, "%s: Unknown mode requested: %s\n", __func__,
+ rig_strrmode(modeHamlib));
+ return ("ERROR");
}
/*
@@ -653,28 +653,28 @@ static const char *modeMapGetFLRig(rmode_t modeHamlib)
*/
static rmode_t modeMapGetHamlib(const char *modeFLRig)
{
- int i;
- char modeFLRigCheck[64];
+ int i;
+ char modeFLRigCheck[64];
- ENTERFUNC;
+ ENTERFUNC;
- snprintf(modeFLRigCheck, sizeof(modeFLRigCheck), "|%s|", modeFLRig);
+ snprintf(modeFLRigCheck, sizeof(modeFLRigCheck), "|%s|", modeFLRig);
- for (i = 0; modeMap[i].mode_hamlib != 0; ++i)
- {
- rig_debug(RIG_DEBUG_TRACE, "%s: find '%s' in '%s'\n", __func__,
- modeFLRigCheck, modeMap[i].mode_flrig);
+ for (i = 0; modeMap[i].mode_hamlib != 0; ++i)
+ {
+ rig_debug(RIG_DEBUG_TRACE, "%s: find '%s' in '%s'\n", __func__,
+ modeFLRigCheck, modeMap[i].mode_flrig);
- if (modeMap[i].mode_flrig
- && strcmp(modeMap[i].mode_flrig, modeFLRigCheck) == 0)
- {
- RETURNFUNC(modeMap[i].mode_hamlib);
- }
- }
+ if (modeMap[i].mode_flrig
+ && strcmp(modeMap[i].mode_flrig, modeFLRigCheck) == 0)
+ {
+ RETURNFUNC(modeMap[i].mode_hamlib);
+ }
+ }
- rig_debug(RIG_DEBUG_TRACE, "%s: mode requested: %s, not in modeMap\n", __func__,
- modeFLRig);
- RETURNFUNC(RIG_MODE_NONE);
+ rig_debug(RIG_DEBUG_TRACE, "%s: mode requested: %s, not in modeMap\n", __func__,
+ modeFLRig);
+ RETURNFUNC(RIG_MODE_NONE);
}
@@ -684,51 +684,51 @@ static rmode_t modeMapGetHamlib(const char *modeFLRig)
*/
static void modeMapAdd(rmode_t *modes, rmode_t mode_hamlib, char *mode_flrig)
{
- int i;
- int len1;
-
- rig_debug(RIG_DEBUG_TRACE, "%s:mode_flrig=%s\n", __func__, mode_flrig);
-
- // if we already have it just return
- // We get ERROR if the mode is not known so non-ERROR is OK
- if (modeMapGetHamlib(mode_flrig) != RIG_MODE_NONE) { return; }
-
- len1 = strlen(mode_flrig) + 3; /* bytes needed for allocating */
-
- for (i = 0; modeMap[i].mode_hamlib != 0; ++i)
- {
- if (modeMap[i].mode_hamlib == mode_hamlib)
- {
- int len2;
- *modes |= modeMap[i].mode_hamlib;
-
- /* we will pipe delimit all the entries for easier matching */
- /* all entries will have pipe symbol on both sides */
- if (modeMap[i].mode_flrig == NULL)
- {
- modeMap[i].mode_flrig = calloc(1, len1);
-
- if (modeMap[i].mode_flrig == NULL)
- {
- rig_debug(RIG_DEBUG_ERR, "%s: error allocating memory for modeMap\n",
- __func__);
- return;
- }
- }
-
- len2 = strlen(modeMap[i].mode_flrig); /* current len w/o null */
- modeMap[i].mode_flrig = realloc(modeMap[i].mode_flrig,
- strlen(modeMap[i].mode_flrig) + len1);
-
- if (strlen(modeMap[i].mode_flrig) == 0) { modeMap[i].mode_flrig[0] = '|'; }
-
- strncat(modeMap[i].mode_flrig, mode_flrig, len1 + len2);
- strncat(modeMap[i].mode_flrig, "|", len1 + len2);
- rig_debug(RIG_DEBUG_TRACE, "%s: Adding mode=%s, index=%d, result=%s\n",
- __func__, mode_flrig, i, modeMap[i].mode_flrig);
- return;
- }
- }
+ int i;
+ int len1;
+
+ rig_debug(RIG_DEBUG_TRACE, "%s:mode_flrig=%s\n", __func__, mode_flrig);
+
+ // if we already have it just return
+ // We get ERROR if the mode is not known so non-ERROR is OK
+ if (modeMapGetHamlib(mode_flrig) != RIG_MODE_NONE) { return; }
+
+ len1 = strlen(mode_flrig) + 3; /* bytes needed for allocating */
+
+ for (i = 0; modeMap[i].mode_hamlib != 0; ++i)
+ {
+ if (modeMap[i].mode_hamlib == mode_hamlib)
+ {
+ int len2;
+ *modes |= modeMap[i].mode_hamlib;
+
+ /* we will pipe delimit all the entries for easier matching */
+ /* all entries will have pipe symbol on both sides */
+ if (modeMap[i].mode_flrig == NULL)
+ {
+ modeMap[i].mode_flrig = calloc(1, len1);
+
+ if (modeMap[i].mode_flrig == NULL)
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: error allocating memory for modeMap\n",
+ __func__);
+ return;
+ }
+ }
+
+ len2 = strlen(modeMap[i].mode_flrig); /* current len w/o null */
+ modeMap[i].mode_flrig = realloc(modeMap[i].mode_flrig,
+ strlen(modeMap[i].mode_flrig) + len1);
+
+ if (strlen(modeMap[i].mode_flrig) == 0) { modeMap[i].mode_flrig[0] = '|'; }
+
+ strncat(modeMap[i].mode_flrig, mode_flrig, len1 + len2);
+ strncat(modeMap[i].mode_flrig, "|", len1 + len2);
+ rig_debug(RIG_DEBUG_TRACE, "%s: Adding mode=%s, index=%d, result=%s\n",
+ __func__, mode_flrig, i, modeMap[i].mode_flrig);
+ return;
+ }
+ }
}
/*
@@ -737,251 +737,254 @@ static void modeMapAdd(rmode_t *modes, rmode_t mode_hamlib, char *mode_flrig)
*/
static int flrig_open(RIG *rig)
{
- int retval;
- char value[MAXXMLLEN];
- char arg[MAXXMLLEN];
- rmode_t modes;
- char *p;
- char *pr;
- struct flrig_priv_data *priv = (struct flrig_priv_data *) rig->state.priv;
-
- ENTERFUNC;
- rig_debug(RIG_DEBUG_VERBOSE, "%s version %s\n", __func__, BACKEND_VER);
-
- retval = flrig_transaction(rig, "main.get_version", NULL, value, sizeof(value));
-
- if (retval != RIG_OK)
- {
- rig_debug(RIG_DEBUG_ERR, "%s: get_version failed: %s\n", __func__,
- rigerror(retval));
- RETURNFUNC(retval);
- }
- rig_debug(RIG_DEBUG_VERBOSE, "%s FlRig version %s\n", __func__, value);
-
- retval = flrig_transaction(rig, "rig.get_xcvr", NULL, value, sizeof(value));
-
- if (retval != RIG_OK)
- {
- rig_debug(RIG_DEBUG_ERR, "%s: get_xcvr failed: %s\n", __func__,
- rigerror(retval));
- RETURNFUNC(retval);
- }
- retval = flrig_transaction(rig, "rig.get_xcvr", NULL, value, sizeof(value));
-
- if (retval != RIG_OK)
- {
- rig_debug(RIG_DEBUG_ERR, "%s: get_xcvr failed: %s\n", __func__,
- rigerror(retval));
- RETURNFUNC(retval);
- }
- retval = flrig_transaction(rig, "rig.get_xcvr", NULL, value, sizeof(value));
-
- if (retval != RIG_OK)
- {
- rig_debug(RIG_DEBUG_ERR, "%s: get_xcvr failed: %s\n", __func__,
- rigerror(retval));
- RETURNFUNC(retval);
- }
-
- strncpy(priv->info, value, sizeof(priv->info));
- rig_debug(RIG_DEBUG_VERBOSE, "Transceiver=%s\n", value);
-
- /* see if get_pwrmeter_scale is available */
- retval = flrig_transaction(rig, "rig.get_pwrmeter_scale", NULL, value,
- sizeof(value));
-
- if (retval != RIG_OK) { RETURNFUNC(retval); }
-
- priv->powermeter_scale = 1; // default
-
- if (strlen(value) > 0)
- {
- priv->powermeter_scale = atof(value);
- }
-
- /* see if get_modeA is available */
- retval = flrig_transaction(rig, "rig.get_modeA", NULL, value, sizeof(value));
-
- if (retval != RIG_OK) { RETURNFUNC(retval); }
-
- if (strlen(value) > 0) /* must have it since we got an answer */
- {
- priv->has_get_modeA = 1;
- rig_debug(RIG_DEBUG_VERBOSE, "%s: getmodeA is available=%s\n", __func__,
- value);
- }
- else
- {
- rig_debug(RIG_DEBUG_VERBOSE, "%s: getmodeA is not available\n", __func__);
- }
-
- /* see if get_bwA is available */
- retval = flrig_transaction(rig, "rig.get_bwA", NULL, value, sizeof(value));
-
- if (retval != RIG_OK) { RETURNFUNC(retval); }
-
- if (strlen(value) > 0) /* must have it since we got an answer */
- {
- priv->has_get_bwA = 1;
- rig_debug(RIG_DEBUG_VERBOSE, "%s: get_bwA is available=%s\n", __func__,
- value);
- }
- else
- {
- rig_debug(RIG_DEBUG_VERBOSE, "%s: get_bwA is not available\n", __func__);
- }
-
- strcpy(arg, value);
- retval = flrig_transaction(rig, "rig.get_AB", arg, value, sizeof(value));
-
- if (retval != RIG_OK) { RETURNFUNC(retval); }
-
- if (streq(value, "A"))
- {
- rig->state.current_vfo = RIG_VFO_A;
- }
- else
- {
- rig->state.current_vfo = RIG_VFO_B;
- }
-
- rig_debug(RIG_DEBUG_TRACE, "%s: currvfo=%s value=%s\n", __func__,
- rig_strvfo(rig->state.current_vfo), value);
- //vfo_t vfo=RIG_VFO_A;
- //vfo_t vfo_tx=RIG_VFO_B; // split is always VFOB
- //flrig_get_split_vfo(rig, vfo, &priv->split, &vfo_tx);
-
- /* find out available widths and modes */
- retval = flrig_transaction(rig, "rig.get_modes", NULL, value, sizeof(value));
-
- if (retval != RIG_OK) { RETURNFUNC(retval); }
-
- rig_debug(RIG_DEBUG_VERBOSE, "%s: modes=%s\n", __func__, value);
- modes = 0;
- pr = value;
-
- /* The following modes in FLRig are not implemented yet
- A1A
- AM-2
- AM6.0
- AM-D1 -- doesn't appear to be read/set
- AM-D2 -- doesn't appear to be read/set
- AM-D3 -- doesn't appear to be read/set
- AMW -- don't have mode in rig.h
- CW2.4 -- could be CW
- CW500 -- could be CWN but CWN not in rig.h
- CW-N -- could be CWN but CWN not in rig.h
- CWN -- dcould be CWN but CWN not in rig.h
- CW-NR -- don't have mode in rig.h
- DATA2-LSB
- DV
- DV-R
- F1B
- FM-D1 -- doesn't appear to be read/set
- FM-D2 -- doesn't appear to be read/set
- FM-D3 -- doesn't appear to be read/set
- H3E
- M11
- USB-D -- doesn't appear to be read/set
- USB-D1 -- doesn't appear to be read/set
- USB-D2 -- doesn't appear to be read/set
- USB-D3 -- doesn't appear to be read/set
- USER-L -- doesn't appear to be read/set
- USER-U -- doesn't appear to be read/set
- */
-
- for (p = strtok_r(value, "|", &pr); p != NULL; p = strtok_r(NULL, "|", &pr))
- {
- if (streq(p, "AM-D")) { modeMapAdd(&modes, RIG_MODE_PKTAM, p); }
- else if (streq(p, "AM")) { modeMapAdd(&modes, RIG_MODE_AM, p); }
- else if (streq(p, "AM-N")) { modeMapAdd(&modes, RIG_MODE_AMN, p); }
- else if (streq(p, "AMN")) { modeMapAdd(&modes, RIG_MODE_AMN, p); }
- else if (streq(p, "CW")) { modeMapAdd(&modes, RIG_MODE_CW, p); }
- else if (streq(p, "CW-L")) { modeMapAdd(&modes, RIG_MODE_CWR, p); }
- else if (streq(p, "CW-LSB")) { modeMapAdd(&modes, RIG_MODE_CWR, p); }
- else if (streq(p, "CW-R")) { modeMapAdd(&modes, RIG_MODE_CWR, p); }
- else if (streq(p, "CW-U")) { modeMapAdd(&modes, RIG_MODE_CW, p); }
- else if (streq(p, "CW-USB")) { modeMapAdd(&modes, RIG_MODE_CW, p); }
- else if (streq(p, "CWL")) { modeMapAdd(&modes, RIG_MODE_CWR, p); }
- else if (streq(p, "CWU")) { modeMapAdd(&modes, RIG_MODE_CW, p); }
- else if (streq(p, "D-LSB")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "D-USB")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "DATA")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "DATA-FM")) { modeMapAdd(&modes, RIG_MODE_PKTFM, p); }
- else if (streq(p, "DATA-L")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "DATA-R")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "DATA-LSB")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "DATA-USB")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "DATA-U")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "DIG")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "DIGI")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "DIGL")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "DIGU")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "DSB")) { modeMapAdd(&modes, RIG_MODE_DSB, p); }
- else if (streq(p, "FM")) { modeMapAdd(&modes, RIG_MODE_FM, p); }
- else if (streq(p, "FM-D")) { modeMapAdd(&modes, RIG_MODE_PKTFM, p); }
- else if (streq(p, "FMN")) { modeMapAdd(&modes, RIG_MODE_FMN, p); }
- else if (streq(p, "FM-N")) { modeMapAdd(&modes, RIG_MODE_FMN, p); }
- else if (streq(p, "FMW")) { modeMapAdd(&modes, RIG_MODE_WFM, p); }
- else if (streq(p, "FSK")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "FSK-R")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "LCW")) { modeMapAdd(&modes, RIG_MODE_CWR, p); }
- else if (streq(p, "LSB")) { modeMapAdd(&modes, RIG_MODE_LSB, p); }
- else if (streq(p, "LSB-D")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "LSB-D1")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "LSB-D2")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "LSB-D3")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "NFM")) { modeMapAdd(&modes, RIG_MODE_FMN, p); }
- else if (streq(p, "PKT")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "PKT-FM")) { modeMapAdd(&modes, RIG_MODE_PKTFM, p); }
- else if (streq(p, "PKT-L")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "PKT-U")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "PKT(L)")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "PKT(U)")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "PSK")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "PSK-L")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "PSK-R")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "PSK-U")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "RTTY")) { modeMapAdd(&modes, RIG_MODE_RTTY, p); }
- else if (streq(p, "RTTY-L")) { modeMapAdd(&modes, RIG_MODE_RTTYR, p); }
- else if (streq(p, "RTTY-R")) { modeMapAdd(&modes, RIG_MODE_RTTYR, p); }
- else if (streq(p, "RTTY-U")) { modeMapAdd(&modes, RIG_MODE_RTTY, p); }
- else if (streq(p, "RTTY(U)")) { modeMapAdd(&modes, RIG_MODE_RTTY, p); }
- else if (streq(p, "RTTY(R")) { modeMapAdd(&modes, RIG_MODE_RTTYR, p); }
- else if (streq(p, "SAH")) { modeMapAdd(&modes, RIG_MODE_SAH, p); }
- else if (streq(p, "SAL")) { modeMapAdd(&modes, RIG_MODE_SAL, p); }
- else if (streq(p, "SAM")) { modeMapAdd(&modes, RIG_MODE_SAM, p); }
- else if (streq(p, "USB")) { modeMapAdd(&modes, RIG_MODE_USB, p); }
- else if (streq(p, "USB-D")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "USB-D1")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "USB-D2")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "USB-D3")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "USER-U")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
- else if (streq(p, "USER-L")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
- else if (streq(p, "W-FM")) { modeMapAdd(&modes, RIG_MODE_WFM, p); }
- else if (streq(p, "WFM")) { modeMapAdd(&modes, RIG_MODE_WFM, p); }
- else if (streq(p, "UCW")) { modeMapAdd(&modes, RIG_MODE_CW, p); }
- else if (streq(p, "C4FM")) { modeMapAdd(&modes, RIG_MODE_C4FM, p); }
- else if (streq(p, "SPEC")) { modeMapAdd(&modes, RIG_MODE_SPEC, p); }
- else if (streq(p, "DRM")) // we don't support DRM yet (or maybe ever)
- {
- rig_debug(RIG_DEBUG_VERBOSE, "%s: no mapping for mode %s\n", __func__, p);
- }
- else { rig_debug(RIG_DEBUG_ERR, "%s: Unknown mode (new?) for this rig='%s'\n", __func__, p); }
- }
-
- rig->state.mode_list = modes;
-
- retval = rig_strrmodes(modes, value, sizeof(value));
-
- if (retval != RIG_OK) // we might get TRUNC but we can still print the debug
- {
- rig_debug(RIG_DEBUG_VERBOSE, "%s: %s\n", __func__, rigerror(retval));
- }
-
- rig_debug(RIG_DEBUG_VERBOSE, "%s: hamlib modes=%s\n", __func__, value);
-
- RETURNFUNC(retval);
+ int retval;
+ char value[MAXXMLLEN];
+ char arg[MAXXMLLEN];
+ rmode_t modes;
+ char *p;
+ char *pr;
+ struct flrig_priv_data *priv = (struct flrig_priv_data *) rig->state.priv;
+
+ ENTERFUNC;
+ rig_debug(RIG_DEBUG_VERBOSE, "%s version %s\n", __func__, BACKEND_VER);
+
+ retval = flrig_transaction(rig, "main.get_version", NULL, value, sizeof(value));
+
+ if (retval != RIG_OK)
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: get_version failed: %s\n", __func__,
+ rigerror(retval));
+ RETURNFUNC(retval);
+ }
+
+ rig_debug(RIG_DEBUG_VERBOSE, "%s FlRig version %s\n", __func__, value);
+
+ retval = flrig_transaction(rig, "rig.get_xcvr", NULL, value, sizeof(value));
+
+ if (retval != RIG_OK)
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: get_xcvr failed: %s\n", __func__,
+ rigerror(retval));
+ RETURNFUNC(retval);
+ }
+
+ retval = flrig_transaction(rig, "rig.get_xcvr", NULL, value, sizeof(value));
+
+ if (retval != RIG_OK)
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: get_xcvr failed: %s\n", __func__,
+ rigerror(retval));
+ RETURNFUNC(retval);
+ }
+
+ retval = flrig_transaction(rig, "rig.get_xcvr", NULL, value, sizeof(value));
+
+ if (retval != RIG_OK)
+ {
+ rig_debug(RIG_DEBUG_ERR, "%s: get_xcvr failed: %s\n", __func__,
+ rigerror(retval));
+ RETURNFUNC(retval);
+ }
+
+ strncpy(priv->info, value, sizeof(priv->info));
+ rig_debug(RIG_DEBUG_VERBOSE, "Transceiver=%s\n", value);
+
+ /* see if get_pwrmeter_scale is available */
+ retval = flrig_transaction(rig, "rig.get_pwrmeter_scale", NULL, value,
+ sizeof(value));
+
+ if (retval != RIG_OK) { RETURNFUNC(retval); }
+
+ priv->powermeter_scale = 1; // default
+
+ if (strlen(value) > 0)
+ {
+ priv->powermeter_scale = atof(value);
+ }
+
+ /* see if get_modeA is available */
+ retval = flrig_transaction(rig, "rig.get_modeA", NULL, value, sizeof(value));
+
+ if (retval != RIG_OK) { RETURNFUNC(retval); }
+
+ if (strlen(value) > 0) /* must have it since we got an answer */
+ {
+ priv->has_get_modeA = 1;
+ rig_debug(RIG_DEBUG_VERBOSE, "%s: getmodeA is available=%s\n", __func__,
+ value);
+ }
+ else
+ {
+ rig_debug(RIG_DEBUG_VERBOSE, "%s: getmodeA is not available\n", __func__);
+ }
+
+ /* see if get_bwA is available */
+ retval = flrig_transaction(rig, "rig.get_bwA", NULL, value, sizeof(value));
+
+ if (retval != RIG_OK) { RETURNFUNC(retval); }
+
+ if (strlen(value) > 0) /* must have it since we got an answer */
+ {
+ priv->has_get_bwA = 1;
+ rig_debug(RIG_DEBUG_VERBOSE, "%s: get_bwA is available=%s\n", __func__,
+ value);
+ }
+ else
+ {
+ rig_debug(RIG_DEBUG_VERBOSE, "%s: get_bwA is not available\n", __func__);
+ }
+
+ strcpy(arg, value);
+ retval = flrig_transaction(rig, "rig.get_AB", arg, value, sizeof(value));
+
+ if (retval != RIG_OK) { RETURNFUNC(retval); }
+
+ if (streq(value, "A"))
+ {
+ rig->state.current_vfo = RIG_VFO_A;
+ }
+ else
+ {
+ rig->state.current_vfo = RIG_VFO_B;
+ }
+
+ rig_debug(RIG_DEBUG_TRACE, "%s: currvfo=%s value=%s\n", __func__,
+ rig_strvfo(rig->state.current_vfo), value);
+ //vfo_t vfo=RIG_VFO_A;
+ //vfo_t vfo_tx=RIG_VFO_B; // split is always VFOB
+ //flrig_get_split_vfo(rig, vfo, &priv->split, &vfo_tx);
+
+ /* find out available widths and modes */
+ retval = flrig_transaction(rig, "rig.get_modes", NULL, value, sizeof(value));
+
+ if (retval != RIG_OK) { RETURNFUNC(retval); }
+
+ rig_debug(RIG_DEBUG_VERBOSE, "%s: modes=%s\n", __func__, value);
+ modes = 0;
+ pr = value;
+
+ /* The following modes in FLRig are not implemented yet
+ A1A
+ AM-2
+ AM6.0
+ AM-D1 -- doesn't appear to be read/set
+ AM-D2 -- doesn't appear to be read/set
+ AM-D3 -- doesn't appear to be read/set
+ AMW -- don't have mode in rig.h
+ CW2.4 -- could be CW
+ CW500 -- could be CWN but CWN not in rig.h
+ CW-N -- could be CWN but CWN not in rig.h
+ CWN -- dcould be CWN but CWN not in rig.h
+ CW-NR -- don't have mode in rig.h
+ DATA2-LSB
+ DV
+ DV-R
+ F1B
+ FM-D1 -- doesn't appear to be read/set
+ FM-D2 -- doesn't appear to be read/set
+ FM-D3 -- doesn't appear to be read/set
+ H3E
+ M11
+ USB-D -- doesn't appear to be read/set
+ USB-D1 -- doesn't appear to be read/set
+ USB-D2 -- doesn't appear to be read/set
+ USB-D3 -- doesn't appear to be read/set
+ USER-L -- doesn't appear to be read/set
+ USER-U -- doesn't appear to be read/set
+ */
+
+ for (p = strtok_r(value, "|", &pr); p != NULL; p = strtok_r(NULL, "|", &pr))
+ {
+ if (streq(p, "AM-D")) { modeMapAdd(&modes, RIG_MODE_PKTAM, p); }
+ else if (streq(p, "AM")) { modeMapAdd(&modes, RIG_MODE_AM, p); }
+ else if (streq(p, "AM-N")) { modeMapAdd(&modes, RIG_MODE_AMN, p); }
+ else if (streq(p, "AMN")) { modeMapAdd(&modes, RIG_MODE_AMN, p); }
+ else if (streq(p, "CW")) { modeMapAdd(&modes, RIG_MODE_CW, p); }
+ else if (streq(p, "CW-L")) { modeMapAdd(&modes, RIG_MODE_CWR, p); }
+ else if (streq(p, "CW-LSB")) { modeMapAdd(&modes, RIG_MODE_CWR, p); }
+ else if (streq(p, "CW-R")) { modeMapAdd(&modes, RIG_MODE_CWR, p); }
+ else if (streq(p, "CW-U")) { modeMapAdd(&modes, RIG_MODE_CW, p); }
+ else if (streq(p, "CW-USB")) { modeMapAdd(&modes, RIG_MODE_CW, p); }
+ else if (streq(p, "CWL")) { modeMapAdd(&modes, RIG_MODE_CWR, p); }
+ else if (streq(p, "CWU")) { modeMapAdd(&modes, RIG_MODE_CW, p); }
+ else if (streq(p, "D-LSB")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
+ else if (streq(p, "D-USB")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
+ else if (streq(p, "DATA")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
+ else if (streq(p, "DATA-FM")) { modeMapAdd(&modes, RIG_MODE_PKTFM, p); }
+ else if (streq(p, "DATA-L")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
+ else if (streq(p, "DATA-R")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
+ else if (streq(p, "DATA-LSB")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
+ else if (streq(p, "DATA-USB")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
+ else if (streq(p, "DATA-U")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
+ else if (streq(p, "DIG")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
+ else if (streq(p, "DIGI")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
+ else if (streq(p, "DIGL")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
+ else if (streq(p, "DIGU")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
+ else if (streq(p, "DSB")) { modeMapAdd(&modes, RIG_MODE_DSB, p); }
+ else if (streq(p, "FM")) { modeMapAdd(&modes, RIG_MODE_FM, p); }
+ else if (streq(p, "FM-D")) { modeMapAdd(&modes, RIG_MODE_PKTFM, p); }
+ else if (streq(p, "FMN")) { modeMapAdd(&modes, RIG_MODE_FMN, p); }
+ else if (streq(p, "FM-N")) { modeMapAdd(&modes, RIG_MODE_FMN, p); }
+ else if (streq(p, "FMW")) { modeMapAdd(&modes, RIG_MODE_WFM, p); }
+ else if (streq(p, "FSK")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
+ else if (streq(p, "FSK-R")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
+ else if (streq(p, "LCW")) { modeMapAdd(&modes, RIG_MODE_CWR, p); }
+ else if (streq(p, "LSB")) { modeMapAdd(&modes, RIG_MODE_LSB, p); }
+ else if (streq(p, "LSB-D")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
+ else if (streq(p, "LSB-D1")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
+ else if (streq(p, "LSB-D2")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
+ else if (streq(p, "LSB-D3")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
+ else if (streq(p, "NFM")) { modeMapAdd(&modes, RIG_MODE_FMN, p); }
+ else if (streq(p, "PKT")) { modeMapAdd(&modes, RIG_MODE_PKTUSB, p); }
+ else if (streq(p, "PKT-FM")) { modeMapAdd(&modes, RIG_MODE_PKTFM, p); }
+ else if (streq(p, "PKT-L")) { modeMapAdd(&modes, RIG_MODE_PKTLSB, p); }
+ else if (streq(p...
[truncated message content] |
