diff --git a/kenwood/th.c b/kenwood/th.c index 5e93e3465..414bf412f 100644 --- a/kenwood/th.c +++ b/kenwood/th.c @@ -48,122 +48,161 @@ * data has been received from the rig. */ int -th_decode_event (RIG *rig) +th_decode_event(RIG *rig) { - char asyncbuf[128]; - int retval; + char asyncbuf[128]; + int retval; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = kenwood_transaction(rig, NULL, asyncbuf, sizeof (asyncbuf)); - if (retval != RIG_OK) - return retval; + retval = kenwood_transaction(rig, NULL, asyncbuf, sizeof(asyncbuf)); - rig_debug(RIG_DEBUG_TRACE, "%s: Decoding message\n", __func__); + if (retval != RIG_OK) + { + return retval; + } - size_t async_len = strlen (asyncbuf); - if (async_len> 3 && asyncbuf[0] == 'B' && asyncbuf[1] == 'U' && asyncbuf[2] == 'F') { + rig_debug(RIG_DEBUG_TRACE, "%s: Decoding message\n", __func__); - vfo_t vfo; - freq_t freq, offset; - int mode; - int step, shift, rev, tone, ctcss, tonefq, ctcssfq; + size_t async_len = strlen(asyncbuf); - retval = num_sscanf(asyncbuf, "BUF %d,%"SCNfreq",%X,%d,%d,%d,%d,,%d,,%d,%"SCNfreq",%d", - &vfo, &freq, &step, &shift, &rev, &tone, - &ctcss, &tonefq, &ctcssfq, &offset, &mode); + if (async_len > 3 && asyncbuf[0] == 'B' && asyncbuf[1] == 'U' + && asyncbuf[2] == 'F') + { - if (retval != 11) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BUF message '%s'\n", __func__, asyncbuf); - return -RIG_ERJCTED; - } + vfo_t vfo; + freq_t freq, offset; + int mode; + int step, shift, rev, tone, ctcss, tonefq, ctcssfq; - /* Calibration and conversions */ - vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B; - mode = (mode == 0) ? RIG_MODE_FM : RIG_MODE_AM; + retval = num_sscanf(asyncbuf, + "BUF %d,%"SCNfreq",%X,%d,%d,%d,%d,,%d,,%d,%"SCNfreq",%d", + &vfo, &freq, &step, &shift, &rev, &tone, + &ctcss, &tonefq, &ctcssfq, &offset, &mode); - rig_debug(RIG_DEBUG_TRACE, "%s: Buffer (vfo %d, freq %"PRIfreq" Hz, mode %d)\n", __func__, vfo, freq, mode); + if (retval != 11) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BUF message '%s'\n", __func__, + asyncbuf); + return -RIG_ERJCTED; + } - /* Callback execution */ - if (rig->callbacks.vfo_event) { - rig->callbacks.vfo_event(rig, vfo, rig->callbacks.vfo_arg); - } + /* Calibration and conversions */ + vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B; + mode = (mode == 0) ? RIG_MODE_FM : RIG_MODE_AM; - if (rig->callbacks.freq_event) { - rig->callbacks.freq_event(rig, vfo, freq, rig->callbacks.freq_arg); - } + rig_debug(RIG_DEBUG_TRACE, "%s: Buffer (vfo %d, freq %"PRIfreq" Hz, mode %d)\n", + __func__, vfo, freq, mode); - if (rig->callbacks.mode_event) { - rig->callbacks.mode_event(rig, vfo, mode, RIG_PASSBAND_NORMAL, - rig->callbacks.mode_arg); - } + /* Callback execution */ + if (rig->callbacks.vfo_event) + { + rig->callbacks.vfo_event(rig, vfo, rig->callbacks.vfo_arg); + } - } else if (async_len> 2 && asyncbuf[0] == 'S' && asyncbuf[1] == 'M') { + if (rig->callbacks.freq_event) + { + rig->callbacks.freq_event(rig, vfo, freq, rig->callbacks.freq_arg); + } - vfo_t vfo; - int lev; - retval = sscanf(asyncbuf, "SM %d,%d", &vfo, &lev); - if (retval != 2) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected SM message '%s'\n", __func__, asyncbuf); - return -RIG_ERJCTED; - } + if (rig->callbacks.mode_event) + { + rig->callbacks.mode_event(rig, vfo, mode, RIG_PASSBAND_NORMAL, + rig->callbacks.mode_arg); + } - /* Calibration and conversions */ - vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B; + } + else if (async_len > 2 && asyncbuf[0] == 'S' && asyncbuf[1] == 'M') + { - rig_debug(RIG_DEBUG_TRACE, "%s: Signal strength event - signal = %.3f\n", __func__, (float)(lev / 5.0)); + vfo_t vfo; + int lev; + retval = sscanf(asyncbuf, "SM %d,%d", &vfo, &lev); - /* Callback execution */ + if (retval != 2) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected SM message '%s'\n", __func__, + asyncbuf); + return -RIG_ERJCTED; + } + + /* Calibration and conversions */ + vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B; + + rig_debug(RIG_DEBUG_TRACE, "%s: Signal strength event - signal = %.3f\n", + __func__, (float)(lev / 5.0)); + + /* Callback execution */ #if STILLHAVETOADDCALLBACK - if (rig->callbacks.strength_event) - rig->callbacks.strength_event(rig, vfo,(float)(lev / 5.0), - rig->callbacks.strength_arg); + + if (rig->callbacks.strength_event) + rig->callbacks.strength_event(rig, vfo, (float)(lev / 5.0), + rig->callbacks.strength_arg); + #endif - } else if (async_len > 2 && asyncbuf[0] == 'B' && asyncbuf[1] == 'Y') { + } + else if (async_len > 2 && asyncbuf[0] == 'B' && asyncbuf[1] == 'Y') + { - vfo_t vfo; - int busy; + vfo_t vfo; + int busy; - retval = sscanf(asyncbuf, "BY %d,%d", &vfo, &busy); - if (retval != 2) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BY message '%s'\n", __func__, asyncbuf); - return -RIG_ERJCTED; - } - vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B; - rig_debug(RIG_DEBUG_TRACE, "%s: Busy event - status = '%s'\n", - __func__, (busy == 0) ? "OFF" : "ON" ); - return -RIG_ENIMPL; - /* This event does not have a callback. */ + retval = sscanf(asyncbuf, "BY %d,%d", &vfo, &busy); - } else if (async_len > 2 && asyncbuf[0] == 'B' && asyncbuf[1] == 'C') { + if (retval != 2) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BY message '%s'\n", __func__, + asyncbuf); + return -RIG_ERJCTED; + } - vfo_t vfo; - retval = sscanf(asyncbuf, "BC %d", &vfo); - if (retval != 1) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BC message '%s'\n", __func__, asyncbuf); - return -RIG_ERJCTED; - } - vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B; + vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B; + rig_debug(RIG_DEBUG_TRACE, "%s: Busy event - status = '%s'\n", + __func__, (busy == 0) ? "OFF" : "ON"); + return -RIG_ENIMPL; + /* This event does not have a callback. */ - rig_debug(RIG_DEBUG_TRACE, "%s: VFO event - vfo = %d\n", __func__, vfo); - if (rig->callbacks.vfo_event) - rig->callbacks.vfo_event(rig, vfo, rig->callbacks.vfo_arg); + } + else if (async_len > 2 && asyncbuf[0] == 'B' && asyncbuf[1] == 'C') + { - } else { + vfo_t vfo; + retval = sscanf(asyncbuf, "BC %d", &vfo); - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported transceive cmd '%s'\n", __func__, asyncbuf); - return -RIG_ENIMPL; - } + if (retval != 1) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected BC message '%s'\n", __func__, + asyncbuf); + return -RIG_ERJCTED; + } - return RIG_OK; + vfo = (vfo == 0) ? RIG_VFO_A : RIG_VFO_B; + + rig_debug(RIG_DEBUG_TRACE, "%s: VFO event - vfo = %d\n", __func__, vfo); + + if (rig->callbacks.vfo_event) + { + rig->callbacks.vfo_event(rig, vfo, rig->callbacks.vfo_arg); + } + + } + else + { + + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported transceive cmd '%s'\n", __func__, + asyncbuf); + return -RIG_ENIMPL; + } + + return RIG_OK; } static int kenwood_wrong_vfo(const char *func, vfo_t vfo) { - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO: %s\n", func, rig_strvfo(vfo)); - return -RIG_ENTARGET; + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO: %s\n", func, rig_strvfo(vfo)); + return -RIG_ENTARGET; } /* @@ -173,31 +212,38 @@ kenwood_wrong_vfo(const char *func, vfo_t vfo) int th_set_freq(RIG *rig, vfo_t vfo, freq_t freq) { - char buf[20]; - int step; - freq_t freq5,freq625,freq_sent; + char buf[20]; + int step; + freq_t freq5, freq625, freq_sent; - rig_debug(RIG_DEBUG_TRACE, "%s: called %s\n", __func__, rig_strvfo(vfo)); + rig_debug(RIG_DEBUG_TRACE, "%s: called %s\n", __func__, rig_strvfo(vfo)); - if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo) - return kenwood_wrong_vfo(__func__, vfo); + if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo) + { + return kenwood_wrong_vfo(__func__, vfo); + } - freq5=round(freq/5000)*5000; - freq625=round(freq/6250)*6250; - if (fabs(freq5-freq)= MHz(470) ? 4 : step; - freq_sent = freq_sent >= MHz(470) ? (round(freq_sent/10000)*10000) : freq_sent; - sprintf(buf, "FQ %011"PRIll",%X", (int64_t) freq_sent, step); + freq5 = round(freq / 5000) * 5000; + freq625 = round(freq / 6250) * 6250; - return kenwood_transaction(rig, buf, NULL, 0); + if (fabs(freq5 - freq) < fabs(freq625 - freq)) + { + step = 0; + freq_sent = freq5; + } + else + { + step = 1; + freq_sent = freq625; + } + + /* Step needs to be at least 10kHz on higher band, otherwise 5 kHz */ + step = freq_sent >= MHz(470) ? 4 : step; + freq_sent = freq_sent >= MHz(470) ? (round(freq_sent / 10000) * 10000) : + freq_sent; + sprintf(buf, "FQ %011"PRIll",%X", (int64_t) freq_sent, step); + + return kenwood_transaction(rig, buf, NULL, 0); } /* @@ -207,27 +253,34 @@ th_set_freq(RIG *rig, vfo_t vfo, freq_t freq) int th_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) { - char buf[20]; - int retval, step; + char buf[20]; + int retval, step; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo) - return kenwood_wrong_vfo(__func__, vfo); + if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo) + { + return kenwood_wrong_vfo(__func__, vfo); + } - *freq = 0; + *freq = 0; - retval = kenwood_safe_transaction(rig, "FQ", buf, sizeof(buf), 16); - if (retval != RIG_OK) - return retval; + retval = kenwood_safe_transaction(rig, "FQ", buf, sizeof(buf), 16); - retval = num_sscanf(buf, "FQ %"SCNfreq",%x", freq, &step); - if (retval != 2) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf); - return -RIG_ERJCTED; - } + if (retval != RIG_OK) + { + return retval; + } - return RIG_OK; + retval = num_sscanf(buf, "FQ %"SCNfreq",%x", freq, &step); + + if (retval != 2) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf); + return -RIG_ERJCTED; + } + + return RIG_OK; } /* @@ -237,44 +290,59 @@ th_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) int th_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { - char kmode, mdbuf[8]; - int retval; - const struct kenwood_priv_caps *priv=(const struct kenwood_priv_caps *)rig->caps->priv; + char kmode, mdbuf[8]; + int retval; + const struct kenwood_priv_caps *priv = (const struct kenwood_priv_caps *) + rig->caps->priv; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo) - return kenwood_wrong_vfo(__func__, vfo); + if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo) + { + return kenwood_wrong_vfo(__func__, vfo); + } - if (priv->mode_table) { + if (priv->mode_table) + { - kmode = rmode2kenwood(mode, priv->mode_table); - if (kmode == -1) { - rig_debug(RIG_DEBUG_WARN, "%s: Unsupported Mode value '%s'\n", - __func__, rig_strrmode(mode)); - return -RIG_EINVAL; - } - kmode += '0'; + kmode = rmode2kenwood(mode, priv->mode_table); - } else { + if (kmode == -1) + { + rig_debug(RIG_DEBUG_WARN, "%s: Unsupported Mode value '%s'\n", + __func__, rig_strrmode(mode)); + return -RIG_EINVAL; + } - switch (mode) { - case RIG_MODE_FM: kmode = '0'; break; /* TH-D7A(G) modes */ - case RIG_MODE_AM: kmode = '1'; break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode %d\n", __func__, mode); - return -RIG_EINVAL; - } - } + kmode += '0'; - sprintf(mdbuf, "MD %c", kmode); + } + else + { - retval = kenwood_transaction(rig, mdbuf, NULL, 0); - if (retval != RIG_OK) - return retval; + switch (mode) + { + case RIG_MODE_FM: kmode = '0'; break; /* TH-D7A(G) modes */ - return RIG_OK; + case RIG_MODE_AM: kmode = '1'; break; + + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode %d\n", __func__, mode); + return -RIG_EINVAL; + } + } + + sprintf(mdbuf, "MD %c", kmode); + + retval = kenwood_transaction(rig, mdbuf, NULL, 0); + + if (retval != RIG_OK) + { + return retval; + } + + return RIG_OK; } /* @@ -284,48 +352,62 @@ th_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) int th_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) { - char buf[ACKBUF_LEN]; - int retval; - const struct kenwood_priv_caps *priv=(const struct kenwood_priv_caps *)rig->caps->priv; + char buf[ACKBUF_LEN]; + int retval; + const struct kenwood_priv_caps *priv = (const struct kenwood_priv_caps *) + rig->caps->priv; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo) - return kenwood_wrong_vfo(__func__, vfo); + if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo) + { + return kenwood_wrong_vfo(__func__, vfo); + } - retval = kenwood_safe_transaction(rig, "MD", buf, sizeof(buf), 4); - if (retval != RIG_OK) - return retval; + retval = kenwood_safe_transaction(rig, "MD", buf, sizeof(buf), 4); - if (buf[3] < '0' || buf[3] > '9') { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf); - return -RIG_ERJCTED; - } + if (retval != RIG_OK) + { + return retval; + } - if (priv->mode_table) - { - *mode = kenwood2rmode(buf[3]-'0', priv->mode_table); - if (*mode == RIG_MODE_NONE) { - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode (table)value '%c'\n", - __func__, buf[3]); - return -RIG_EINVAL; - } - } - else - { - switch (buf[3]) { - case '0': *mode = RIG_MODE_FM; break; /* TH-D7A(G) modes */ - case '1': *mode = RIG_MODE_AM; break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode value '%c'\n", __func__, buf[3]); - return -RIG_EINVAL; - } - } + if (buf[3] < '0' || buf[3] > '9') + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf); + return -RIG_ERJCTED; + } - if (width) - *width = RIG_PASSBAND_NORMAL; + if (priv->mode_table) + { + *mode = kenwood2rmode(buf[3] - '0', priv->mode_table); - return RIG_OK; + if (*mode == RIG_MODE_NONE) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode (table)value '%c'\n", + __func__, buf[3]); + return -RIG_EINVAL; + } + } + else + { + switch (buf[3]) + { + case '0': *mode = RIG_MODE_FM; break; /* TH-D7A(G) modes */ + + case '1': *mode = RIG_MODE_AM; break; + + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode value '%c'\n", __func__, buf[3]); + return -RIG_EINVAL; + } + } + + if (width) + { + *width = RIG_PASSBAND_NORMAL; + } + + return RIG_OK; } /* @@ -337,136 +419,171 @@ th_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) int th_set_vfo(RIG *rig, vfo_t vfo) { - const char *cmd; - int retval; + const char *cmd; + int retval; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - /* from thf7.c - * The band must be active before selecting VFO or MEM. - * The dilemma is whether MEM should be applied to Band A or Band B. - * Remember, not all bands have the same capability - * TODO: if (RIG_VFO_MEM) query current band with BC, then do appropriate VMC - */ + /* from thf7.c + * The band must be active before selecting VFO or MEM. + * The dilemma is whether MEM should be applied to Band A or Band B. + * Remember, not all bands have the same capability + * TODO: if (RIG_VFO_MEM) query current band with BC, then do appropriate VMC + */ - /* set band */ - if (vfo != RIG_VFO_MEM) { + /* set band */ + if (vfo != RIG_VFO_MEM) + { - switch (vfo) { - case RIG_VFO_A: - case RIG_VFO_VFO: - case RIG_VFO_MAIN: - cmd = "BC 0"; - break; + switch (vfo) + { + case RIG_VFO_A: + case RIG_VFO_VFO: + case RIG_VFO_MAIN: + cmd = "BC 0"; + break; - case RIG_VFO_B: - case RIG_VFO_SUB: - cmd = "BC 1"; - break; + case RIG_VFO_B: + case RIG_VFO_SUB: + cmd = "BC 1"; + break; - default: - return kenwood_wrong_vfo(__func__, vfo); - } + default: + return kenwood_wrong_vfo(__func__, vfo); + } - retval = kenwood_simple_transaction(rig, cmd, 5); - if (retval != RIG_OK) - return retval; - } + retval = kenwood_simple_transaction(rig, cmd, 5); - /* No "VMC" cmd on THD72A/THD74 */ - if (rig->caps->rig_model == RIG_MODEL_THD72A || rig->caps->rig_model == RIG_MODEL_THD74) - return RIG_OK; + if (retval != RIG_OK) + { + return retval; + } + } - /* set vfo */ - switch (vfo) { - case RIG_VFO_A: - case RIG_VFO_VFO: - case RIG_VFO_MAIN: - cmd = "VMC 0,0"; - break; + /* No "VMC" cmd on THD72A/THD74 */ + if (rig->caps->rig_model == RIG_MODEL_THD72A + || rig->caps->rig_model == RIG_MODEL_THD74) + { + return RIG_OK; + } - case RIG_VFO_B: - case RIG_VFO_SUB: - cmd = "VMC 1,0"; - break; + /* set vfo */ + switch (vfo) + { + case RIG_VFO_A: + case RIG_VFO_VFO: + case RIG_VFO_MAIN: + cmd = "VMC 0,0"; + break; - case RIG_VFO_MEM: - if (rig->caps->rig_model == RIG_MODEL_THF7E || - rig->caps->rig_model == RIG_MODEL_THF6A) - cmd = "VMC 0,1"; - else - cmd = "VMC 0,2"; - break; + case RIG_VFO_B: + case RIG_VFO_SUB: + cmd = "VMC 1,0"; + break; - default: - return kenwood_wrong_vfo(__func__, vfo); - } + case RIG_VFO_MEM: + if (rig->caps->rig_model == RIG_MODEL_THF7E || + rig->caps->rig_model == RIG_MODEL_THF6A) + { + cmd = "VMC 0,1"; + } + else + { + cmd = "VMC 0,2"; + } - return kenwood_transaction(rig, cmd, NULL, 0); + break; + + default: + return kenwood_wrong_vfo(__func__, vfo); + } + + return kenwood_transaction(rig, cmd, NULL, 0); } int th_get_vfo_char(RIG *rig, vfo_t *vfo, char *vfoch) { - char cmdbuf[10], buf[10], vfoc; - int retval; + char cmdbuf[10], buf[10], vfoc; + int retval; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - /* Get VFO band */ + /* Get VFO band */ - retval = kenwood_transaction(rig, "BC", buf, sizeof (buf)); - if (retval != RIG_OK) - return retval; - size_t length = strlen (buf); - switch (length) { - case 4: /*original case BC 0*/ - vfoc = buf[3]; - break; - case 6: /*intended for D700 BC 0,0*/ - if ((buf[0]=='B') &&(buf[1]=='C') && (buf[2]==' ') && (buf[4]=',')){ - vfoc = buf[3]; - } else { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected answer format '%s'\n", __func__, buf); - return -RIG_EPROTO; - } - break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected answer length '%c'\n", __func__, length); - return -RIG_EPROTO; - break; - } + retval = kenwood_transaction(rig, "BC", buf, sizeof(buf)); + if (retval != RIG_OK) + { + return retval; + } - switch (vfoc) { + size_t length = strlen(buf); - case '0': *vfo = RIG_VFO_A; break; - case '1': *vfo = RIG_VFO_B; break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VFO value '%c'\n", __func__, buf[3]); - return -RIG_EVFO; + switch (length) + { + case 4: /*original case BC 0*/ + vfoc = buf[3]; + break; - } - - /* No "VMC" on THD72A/THD74 */ - if (rig->caps->rig_model == RIG_MODEL_THD72A || rig->caps->rig_model == RIG_MODEL_THD74) { - *vfoch = '0'; /* FIXME: fake */ - - return RIG_OK; + case 6: /*intended for D700 BC 0,0*/ + if ((buf[0] == 'B') && (buf[1] == 'C') && (buf[2] == ' ') && (buf[4] = ',')) + { + vfoc = buf[3]; + } + else + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected answer format '%s'\n", __func__, buf); + return -RIG_EPROTO; } - /* Get mode of the VFO band */ + break; - sprintf(cmdbuf, "VMC %c", vfoc); + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected answer length '%c'\n", __func__, + length); + return -RIG_EPROTO; + break; + } - retval = kenwood_safe_transaction(rig, cmdbuf, buf, 10, 7); - if (retval != RIG_OK) - return retval; - *vfoch = buf[6]; + switch (vfoc) + { - return RIG_OK; + case '0': *vfo = RIG_VFO_A; break; + + case '1': *vfo = RIG_VFO_B; break; + + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VFO value '%c'\n", __func__, buf[3]); + return -RIG_EVFO; + + } + + /* No "VMC" on THD72A/THD74 */ + if (rig->caps->rig_model == RIG_MODEL_THD72A + || rig->caps->rig_model == RIG_MODEL_THD74) + { + *vfoch = '0'; /* FIXME: fake */ + + return RIG_OK; + } + + /* Get mode of the VFO band */ + + sprintf(cmdbuf, "VMC %c", vfoc); + + retval = kenwood_safe_transaction(rig, cmdbuf, buf, 10, 7); + + if (retval != RIG_OK) + { + return retval; + } + + *vfoch = buf[6]; + + return RIG_OK; } /* @@ -476,28 +593,34 @@ th_get_vfo_char(RIG *rig, vfo_t *vfo, char *vfoch) int th_get_vfo(RIG *rig, vfo_t *vfo) { - char vfoch; - int retval; + char vfoch; + int retval; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = th_get_vfo_char(rig, vfo, &vfoch); - if (retval != RIG_OK) - return retval; + retval = th_get_vfo_char(rig, vfo, &vfoch); - switch (vfoch) { - case '0' : - case '1' : - break; - case '2' : - *vfo = RIG_VFO_MEM; - break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VFO value '%c'\n", __func__, vfoch); - return -RIG_EVFO; - } + if (retval != RIG_OK) + { + return retval; + } - return RIG_OK; + switch (vfoch) + { + case '0' : + case '1' : + break; + + case '2' : + *vfo = RIG_VFO_MEM; + break; + + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected VFO value '%c'\n", __func__, vfoch); + return -RIG_EVFO; + } + + return RIG_OK; } /* @@ -506,139 +629,181 @@ th_get_vfo(RIG *rig, vfo_t *vfo) * * Assumes rig!=NULL */ -int tm_set_vfo_bc2 (RIG *rig, vfo_t vfo) +int tm_set_vfo_bc2(RIG *rig, vfo_t vfo) { - struct kenwood_priv_data *priv = rig->state.priv; - char vfobuf[16], ackbuf[16]; - int vfonum, txvfonum, vfomode=0; - int retval; + struct kenwood_priv_data *priv = rig->state.priv; + char vfobuf[16], ackbuf[16]; + int vfonum, txvfonum, vfomode = 0; + int retval; - rig_debug(RIG_DEBUG_TRACE, "%s: called %s\n", __func__, rig_strvfo(vfo)); + rig_debug(RIG_DEBUG_TRACE, "%s: called %s\n", __func__, rig_strvfo(vfo)); - switch (vfo) { - case RIG_VFO_A: - case RIG_VFO_VFO: - vfonum = 0; - /* put back split mode when toggling */ - txvfonum = (priv->split == RIG_SPLIT_ON && + switch (vfo) + { + case RIG_VFO_A: + case RIG_VFO_VFO: + vfonum = 0; + /* put back split mode when toggling */ + txvfonum = (priv->split == RIG_SPLIT_ON && rig->state.tx_vfo == RIG_VFO_B) ? 1 : vfonum; - break; - case RIG_VFO_B: - vfonum = 1; - /* put back split mode when toggling */ - txvfonum = (priv->split == RIG_SPLIT_ON && + break; + + case RIG_VFO_B: + vfonum = 1; + /* put back split mode when toggling */ + txvfonum = (priv->split == RIG_SPLIT_ON && rig->state.tx_vfo == RIG_VFO_A) ? 0 : vfonum; - break; - case RIG_VFO_MEM: - /* get current band */ - sprintf(vfobuf, "BC"); - retval = kenwood_transaction(rig, vfobuf, ackbuf, sizeof (ackbuf)); - if (retval != RIG_OK) - return retval; - txvfonum = vfonum = ackbuf[3]-'0'; - vfomode = 2; - break; + break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo); - return -RIG_EVFO; - } + case RIG_VFO_MEM: + /* get current band */ + sprintf(vfobuf, "BC"); + retval = kenwood_transaction(rig, vfobuf, ackbuf, sizeof(ackbuf)); - sprintf(vfobuf, "VMC %d,%d", vfonum, vfomode); - retval = kenwood_transaction(rig, vfobuf, NULL, 0); - if (retval != RIG_OK) - return retval; + if (retval != RIG_OK) + { + return retval; + } - if (vfo == RIG_VFO_MEM) - return RIG_OK; + txvfonum = vfonum = ackbuf[3] - '0'; + vfomode = 2; + break; - sprintf(vfobuf, "BC %d,%d", vfonum, txvfonum); - retval = kenwood_transaction(rig, vfobuf, NULL, 0); - if (retval != RIG_OK) - return retval; + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO %d\n", __func__, vfo); + return -RIG_EVFO; + } + sprintf(vfobuf, "VMC %d,%d", vfonum, vfomode); + retval = kenwood_transaction(rig, vfobuf, NULL, 0); + + if (retval != RIG_OK) + { + return retval; + } + + if (vfo == RIG_VFO_MEM) + { return RIG_OK; + } + + sprintf(vfobuf, "BC %d,%d", vfonum, txvfonum); + retval = kenwood_transaction(rig, vfobuf, NULL, 0); + + if (retval != RIG_OK) + { + return retval; + } + + return RIG_OK; } -int th_set_split_vfo (RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo) +int th_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo) { - struct kenwood_priv_data *priv = rig->state.priv; - char vfobuf[16]; - int vfonum, txvfonum; - int retval; + struct kenwood_priv_data *priv = rig->state.priv; + char vfobuf[16]; + int vfonum, txvfonum; + int retval; - rig_debug(RIG_DEBUG_TRACE, "%s: called %s\n", __func__, rig_strvfo(vfo)); + rig_debug(RIG_DEBUG_TRACE, "%s: called %s\n", __func__, rig_strvfo(vfo)); - if (vfo == RIG_VFO_CURR) { - retval = rig_get_vfo(rig, &vfo); - if (retval != RIG_OK) - return retval; + if (vfo == RIG_VFO_CURR) + { + retval = rig_get_vfo(rig, &vfo); + + if (retval != RIG_OK) + { + return retval; + } + } + + switch (vfo) + { + case RIG_VFO_A: + case RIG_VFO_VFO: + vfonum = 0; + + if (split == RIG_SPLIT_ON && txvfo != RIG_VFO_B) + { + return -RIG_EINVAL; } - switch (vfo) { - case RIG_VFO_A: - case RIG_VFO_VFO: - vfonum = 0; - if (split == RIG_SPLIT_ON && txvfo != RIG_VFO_B) - return -RIG_EINVAL; - txvfonum = split == RIG_SPLIT_ON ? 1 : vfonum; - break; - case RIG_VFO_B: - vfonum = 1; - if (split == RIG_SPLIT_ON && txvfo != RIG_VFO_A) - return -RIG_EINVAL; - txvfonum = split == RIG_SPLIT_ON ? 0 : vfonum; - break; - default: - return -RIG_EINVAL; + txvfonum = split == RIG_SPLIT_ON ? 1 : vfonum; + break; + + case RIG_VFO_B: + vfonum = 1; + + if (split == RIG_SPLIT_ON && txvfo != RIG_VFO_A) + { + return -RIG_EINVAL; } - /* Set VFO mode. To be done for TX vfo also? */ - sprintf(vfobuf, "VMC %d,0", vfonum); - retval = kenwood_transaction(rig, vfobuf, NULL, 0); - if (retval != RIG_OK) - return retval; + txvfonum = split == RIG_SPLIT_ON ? 0 : vfonum; + break; - sprintf(vfobuf, "BC %d,%d", vfonum, txvfonum); - retval = kenwood_transaction(rig, vfobuf, NULL, 0); - if (retval != RIG_OK) - return retval; + default: + return -RIG_EINVAL; + } - /* Remember whether split is on, for th_set_vfo */ - priv->split = split; + /* Set VFO mode. To be done for TX vfo also? */ + sprintf(vfobuf, "VMC %d,0", vfonum); + retval = kenwood_transaction(rig, vfobuf, NULL, 0); - return RIG_OK; + if (retval != RIG_OK) + { + return retval; + } + + sprintf(vfobuf, "BC %d,%d", vfonum, txvfonum); + retval = kenwood_transaction(rig, vfobuf, NULL, 0); + + if (retval != RIG_OK) + { + return retval; + } + + /* Remember whether split is on, for th_set_vfo */ + priv->split = split; + + return RIG_OK; } -int th_get_split_vfo (RIG *rig, vfo_t vfo, split_t *split, vfo_t *txvfo) +int th_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *txvfo) { - struct kenwood_priv_data *priv = rig->state.priv; - char buf[10]; - int retval; + struct kenwood_priv_data *priv = rig->state.priv; + char buf[10]; + int retval; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - /* Get VFO band */ + /* Get VFO band */ - retval = kenwood_safe_transaction(rig, "BC", buf, 10, 4); - if (retval != RIG_OK) - return retval; + retval = kenwood_safe_transaction(rig, "BC", buf, 10, 4); - switch (buf[5]) { - case '0': *txvfo = RIG_VFO_A; break; - case '1': *txvfo = RIG_VFO_B; break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected txVFO value '%c'\n", __func__, buf[5]); - return -RIG_EPROTO; - } + if (retval != RIG_OK) + { + return retval; + } - *split = (buf[3] == buf[5]) ? RIG_SPLIT_OFF : RIG_SPLIT_ON; + switch (buf[5]) + { + case '0': *txvfo = RIG_VFO_A; break; - /* Remember whether split is on, for th_set_vfo */ - priv->split = *split; + case '1': *txvfo = RIG_VFO_B; break; - return RIG_OK; + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected txVFO value '%c'\n", __func__, buf[5]); + return -RIG_EPROTO; + } + + *split = (buf[3] == buf[5]) ? RIG_SPLIT_OFF : RIG_SPLIT_ON; + + /* Remember whether split is on, for th_set_vfo */ + priv->split = *split; + + return RIG_OK; } @@ -649,7 +814,8 @@ int th_get_split_vfo (RIG *rig, vfo_t vfo, split_t *split, vfo_t *txvfo) int th_set_trn(RIG *rig, int trn) { - return kenwood_transaction(rig, (trn == RIG_TRN_RIG) ? "AI 1" : "AI 0", NULL, 0); + return kenwood_transaction(rig, (trn == RIG_TRN_RIG) ? "AI 1" : "AI 0", NULL, + 0); } /* @@ -659,23 +825,27 @@ th_set_trn(RIG *rig, int trn) int th_get_trn(RIG *rig, int *trn) { - char buf[ACKBUF_LEN]; - int retval; + char buf[ACKBUF_LEN]; + int retval; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = kenwood_transaction(rig, "AI", buf, sizeof (buf)); - if (retval != RIG_OK) - return retval; + retval = kenwood_transaction(rig, "AI", buf, sizeof(buf)); - if (strlen (buf) != 3 ) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf); - return -RIG_ERJCTED; - } + if (retval != RIG_OK) + { + return retval; + } - *trn = (buf[2] != '0') ? RIG_TRN_RIG : RIG_TRN_OFF; + if (strlen(buf) != 3) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf); + return -RIG_ERJCTED; + } - return RIG_OK; + *trn = (buf[2] != '0') ? RIG_TRN_RIG : RIG_TRN_OFF; + + return RIG_OK; } @@ -686,22 +856,27 @@ th_get_trn(RIG *rig, int *trn) static int th_get_kenwood_func(RIG *rig, const char *cmd, int *status) { - char buf[8]; - int retval, len, expected; + char buf[8]; + int retval, len, expected; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - len = strlen(cmd); - expected = len + 2; + len = strlen(cmd); + expected = len + 2; - retval = kenwood_safe_transaction(rig, cmd, buf, sizeof(buf), expected); - if (retval != RIG_OK) - return retval; + retval = kenwood_safe_transaction(rig, cmd, buf, sizeof(buf), expected); - if (status) - *status = (buf[len+1] == '0') ? 0 : 1; + if (retval != RIG_OK) + { + return retval; + } - return RIG_OK; + if (status) + { + *status = (buf[len + 1] == '0') ? 0 : 1; + } + + return RIG_OK; }; /* @@ -713,37 +888,47 @@ th_get_kenwood_func(RIG *rig, const char *cmd, int *status) int th_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) { - rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __func__, func); + rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __func__, func); - switch (func) { - case RIG_FUNC_MUTE: - return th_get_kenwood_func(rig, "MUTE", status); - case RIG_FUNC_MON: - return th_get_kenwood_func(rig, "MON", status); - case RIG_FUNC_TONE: - return th_get_kenwood_func(rig, "TO", status); - case RIG_FUNC_TSQL: - return th_get_kenwood_func(rig, "CT", status); - case RIG_FUNC_REV: - return th_get_kenwood_func(rig, "REV", status); - case RIG_FUNC_ARO: - return th_get_kenwood_func(rig, "ARO", status); - case RIG_FUNC_AIP: - return th_get_kenwood_func(rig, "AIP", status); - case RIG_FUNC_LOCK: - return th_get_kenwood_func(rig, "LK", status); - case RIG_FUNC_BC: - return th_get_kenwood_func(rig, "BC", status); - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported function %#x\n", - __func__, func); - return -RIG_EINVAL; - } + switch (func) + { + case RIG_FUNC_MUTE: + return th_get_kenwood_func(rig, "MUTE", status); + + case RIG_FUNC_MON: + return th_get_kenwood_func(rig, "MON", status); + + case RIG_FUNC_TONE: + return th_get_kenwood_func(rig, "TO", status); + + case RIG_FUNC_TSQL: + return th_get_kenwood_func(rig, "CT", status); + + case RIG_FUNC_REV: + return th_get_kenwood_func(rig, "REV", status); + + case RIG_FUNC_ARO: + return th_get_kenwood_func(rig, "ARO", status); + + case RIG_FUNC_AIP: + return th_get_kenwood_func(rig, "AIP", status); + + case RIG_FUNC_LOCK: + return th_get_kenwood_func(rig, "LK", status); + + case RIG_FUNC_BC: + return th_get_kenwood_func(rig, "BC", status); + + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported function %#x\n", + __func__, func); + return -RIG_EINVAL; + } } static int th_tburst(RIG *rig, vfo_t vfo, int status) { - return kenwood_transaction(rig, (status == 1) ? "TT" : "RX", NULL, 0); + return kenwood_transaction(rig, (status == 1) ? "TT" : "RX", NULL, 0); } /* @@ -753,16 +938,16 @@ static int th_tburst(RIG *rig, vfo_t vfo, int status) static int th_set_kenwood_func(RIG *rig, const char *cmd, int status) { #define BUFSZ 16 - char buf[BUFSZ]; + char buf[BUFSZ]; - rig_debug(RIG_DEBUG_TRACE, "%s: cmd = %s, status = %d\n", - __func__, cmd, status); + rig_debug(RIG_DEBUG_TRACE, "%s: cmd = %s, status = %d\n", + __func__, cmd, status); - strncpy(buf, cmd, BUFSZ-2); - buf[BUFSZ-1] = '\0'; - strncat(buf, status ? " 1" : " 0", BUFSZ-1); + strncpy(buf, cmd, BUFSZ - 2); + buf[BUFSZ - 1] = '\0'; + strncat(buf, status ? " 1" : " 0", BUFSZ - 1); - return kenwood_transaction(rig, buf, NULL, 0); + return kenwood_transaction(rig, buf, NULL, 0); } @@ -775,53 +960,54 @@ static int th_set_kenwood_func(RIG *rig, const char *cmd, int status) int th_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) { - rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __func__, func); + rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __func__, func); - switch (func) { - case RIG_FUNC_MUTE: - return th_set_kenwood_func(rig, "MUTE", status); + switch (func) + { + case RIG_FUNC_MUTE: + return th_set_kenwood_func(rig, "MUTE", status); - case RIG_FUNC_MON: - return th_set_kenwood_func(rig, "MON", status); + case RIG_FUNC_MON: + return th_set_kenwood_func(rig, "MON", status); - case RIG_FUNC_TONE: - return th_set_kenwood_func(rig, "TO", status); + case RIG_FUNC_TONE: + return th_set_kenwood_func(rig, "TO", status); - case RIG_FUNC_TSQL: - return th_set_kenwood_func(rig, "CT", status); + case RIG_FUNC_TSQL: + return th_set_kenwood_func(rig, "CT", status); - case RIG_FUNC_REV: - return th_set_kenwood_func(rig, "REV", status); + case RIG_FUNC_REV: + return th_set_kenwood_func(rig, "REV", status); - case RIG_FUNC_ARO: - return th_set_kenwood_func(rig, "ARO", status); + case RIG_FUNC_ARO: + return th_set_kenwood_func(rig, "ARO", status); - case RIG_FUNC_AIP: - return th_set_kenwood_func(rig, "AIP", status); + case RIG_FUNC_AIP: + return th_set_kenwood_func(rig, "AIP", status); - case RIG_FUNC_LOCK: - return th_set_kenwood_func(rig, "LK", status); + case RIG_FUNC_LOCK: + return th_set_kenwood_func(rig, "LK", status); - case RIG_FUNC_BC: - return th_set_kenwood_func(rig, "NSFT", status); + case RIG_FUNC_BC: + return th_set_kenwood_func(rig, "NSFT", status); - case RIG_FUNC_TBURST: - return th_tburst(rig, vfo, status); + case RIG_FUNC_TBURST: + return th_tburst(rig, vfo, status); - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported function %#x\n", __func__, func); - return -RIG_EINVAL; - } + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported function %#x\n", __func__, func); + return -RIG_EINVAL; + } - return RIG_OK; + return RIG_OK; } int th_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch) { - rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __func__, scan); + rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __func__, scan); - return th_set_kenwood_func(rig, "SC", scan == RIG_SCAN_STOP ? 0 : 1); + return th_set_kenwood_func(rig, "SC", scan == RIG_SCAN_STOP ? 0 : 1); } @@ -832,83 +1018,110 @@ th_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch) int th_get_parm(RIG *rig, setting_t parm, value_t *val) { - char buf[16]; - int ret, status; + char buf[16]; + int ret, status; - rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __func__, parm); + rig_debug(RIG_DEBUG_TRACE, "%s: called (0x%04x)\n", __func__, parm); - switch (parm) { - case RIG_PARM_BEEP: - ret = th_get_kenwood_func(rig, "BEP", &status); - if (ret != RIG_OK) - return ret; + switch (parm) + { + case RIG_PARM_BEEP: + ret = th_get_kenwood_func(rig, "BEP", &status); - val->i = status ? 1 : 0; - return RIG_OK; + if (ret != RIG_OK) + { + return ret; + } - case RIG_PARM_APO: - ret = kenwood_safe_transaction(rig, "APO", buf, sizeof(buf), 5); - if (ret != RIG_OK) - return ret; + val->i = status ? 1 : 0; + return RIG_OK; - val->i = (buf[4]-'0')*30; - return RIG_OK; + case RIG_PARM_APO: + ret = kenwood_safe_transaction(rig, "APO", buf, sizeof(buf), 5); - case RIG_PARM_BACKLIGHT: - if (rig->caps->rig_model == RIG_MODEL_TMD700) { + if (ret != RIG_OK) + { + return ret; + } - ret = kenwood_safe_transaction(rig, "DIM", buf, sizeof(buf), 4); - if (ret != RIG_OK) - return ret; + val->i = (buf[4] - '0') * 30; + return RIG_OK; - val->f = buf[4] == '0' ? 0 : (float)(5-(buf[4]-'0'))/4.; - } else { - ret = th_get_kenwood_func(rig, "LMP", &status); - if (ret != RIG_OK) - return ret; + case RIG_PARM_BACKLIGHT: + if (rig->caps->rig_model == RIG_MODEL_TMD700) + { - val->f = status ? 1.0 : 0; - } - return RIG_OK; + ret = kenwood_safe_transaction(rig, "DIM", buf, sizeof(buf), 4); - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported parm %#x\n", __func__, parm); - return -RIG_EINVAL; - } + if (ret != RIG_OK) + { + return ret; + } - return RIG_OK; + val->f = buf[4] == '0' ? 0 : (float)(5 - (buf[4] - '0')) / 4.; + } + else + { + ret = th_get_kenwood_func(rig, "LMP", &status); + + if (ret != RIG_OK) + { + return ret; + } + + val->f = status ? 1.0 : 0; + } + + return RIG_OK; + + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported parm %#x\n", __func__, parm); + return -RIG_EINVAL; + } + + return RIG_OK; } int th_set_parm(RIG *rig, setting_t parm, value_t val) { - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - switch (parm) { - case RIG_PARM_BACKLIGHT: - if (rig->caps->rig_model == RIG_MODEL_TMD700) { - return th_set_kenwood_func(rig, "DIM", (val.f > 0) ? 1 : 0); /* FIXME */ - } else { - return th_set_kenwood_func(rig, "LMP", (val.f > 0) ? 1 : 0); - } + switch (parm) + { + case RIG_PARM_BACKLIGHT: + if (rig->caps->rig_model == RIG_MODEL_TMD700) + { + return th_set_kenwood_func(rig, "DIM", (val.f > 0) ? 1 : 0); /* FIXME */ + } + else + { + return th_set_kenwood_func(rig, "LMP", (val.f > 0) ? 1 : 0); + } - case RIG_PARM_BEEP: - return th_set_kenwood_func(rig, "BEP", val.i); + case RIG_PARM_BEEP: + return th_set_kenwood_func(rig, "BEP", val.i); - case RIG_PARM_APO: - if (val.i > 30) - return kenwood_transaction(rig, "APO 2", NULL, 0); - else if (val.i > 0) - return kenwood_transaction(rig, "APO 1", NULL, 0); - else - return kenwood_transaction(rig, "APO 0", NULL, 0); - - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported parm %#x\n", __func__, parm); - return -RIG_EINVAL; - } + case RIG_PARM_APO: + if (val.i > 30) + { + return kenwood_transaction(rig, "APO 2", NULL, 0); + } + else if (val.i > 0) + { + return kenwood_transaction(rig, "APO 1", NULL, 0); + } + else + { + return kenwood_transaction(rig, "APO 0", NULL, 0); + } - return RIG_OK; + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported parm %#x\n", __func__, parm); + return -RIG_EINVAL; + } + + return RIG_OK; } @@ -919,207 +1132,264 @@ th_set_parm(RIG *rig, setting_t parm, value_t val) int th_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) { - char vch, buf[10], ackbuf[20]; - int retval, v, l; + char vch, buf[10], ackbuf[20]; + int retval, v, l; - vfo_t tvfo; + vfo_t tvfo; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - tvfo = (vfo == RIG_VFO_CURR) ? rig->state.current_vfo : vfo; + tvfo = (vfo == RIG_VFO_CURR) ? rig->state.current_vfo : vfo; - switch (tvfo) { - case RIG_VFO_A: - case RIG_VFO_VFO: - case RIG_VFO_MEM: - vch = '0'; break; - case RIG_VFO_B: - vch = '1'; break; - default: - return kenwood_wrong_vfo(__func__, vfo); - } + switch (tvfo) + { + case RIG_VFO_A: + case RIG_VFO_VFO: + case RIG_VFO_MEM: + vch = '0'; break; - switch (level) { - case RIG_LEVEL_RAWSTR: - sprintf(buf, "SM %c", vch); + case RIG_VFO_B: + vch = '1'; break; - // XXX use kenwood_safe_transaction - retval = kenwood_transaction(rig, buf, ackbuf, sizeof (ackbuf)); - if (retval != RIG_OK) - return retval; + default: + return kenwood_wrong_vfo(__func__, vfo); + } - retval = sscanf(ackbuf, "SM %d,%d", &v, &l); - if (retval != 2 || l < rig->caps->level_gran[LVL_RAWSTR].min.i || l > rig->caps->level_gran[LVL_RAWSTR].max.i) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf); - return -RIG_ERJCTED; - } + switch (level) + { + case RIG_LEVEL_RAWSTR: + sprintf(buf, "SM %c", vch); - val->i = l; - break; + // XXX use kenwood_safe_transaction + retval = kenwood_transaction(rig, buf, ackbuf, sizeof(ackbuf)); - case RIG_LEVEL_SQL: - sprintf(buf, "SQ %c", vch); - retval = kenwood_safe_transaction(rig, buf, ackbuf, 10, 7); - if (retval != RIG_OK) - return retval; + if (retval != RIG_OK) + { + return retval; + } - retval = sscanf(ackbuf, "SQ %d,%x", &v, &l); - if (retval != 2 || l < rig->caps->level_gran[LVL_SQL].min.i || l > rig->caps->level_gran[LVL_SQL].max.i) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf); - return -RIG_ERJCTED; - } + retval = sscanf(ackbuf, "SM %d,%d", &v, &l); - /* range [0.0 ... 1.0] */ - val->f = (float)(l-rig->caps->level_gran[LVL_SQL].min.i) / - (float)(rig->caps->level_gran[LVL_SQL].max.i-rig->caps->level_gran[LVL_SQL].min.i); - break; + if (retval != 2 || l < rig->caps->level_gran[LVL_RAWSTR].min.i + || l > rig->caps->level_gran[LVL_RAWSTR].max.i) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf); + return -RIG_ERJCTED; + } - case RIG_LEVEL_AF: - sprintf(buf, "AG %c", vch); - retval = kenwood_transaction(rig, buf, ackbuf, sizeof (ackbuf)); - if (retval != RIG_OK) - return retval; + val->i = l; + break; - retval = sscanf(ackbuf, "AG %d,%x", &v, &l); - if (retval != 2 || l < rig->caps->level_gran[LVL_AF].min.i || l > rig->caps->level_gran[LVL_AF].max.i) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf); - return -RIG_ERJCTED; - } + case RIG_LEVEL_SQL: + sprintf(buf, "SQ %c", vch); + retval = kenwood_safe_transaction(rig, buf, ackbuf, 10, 7); - /* range [0.0 ... 1.0] */ - val->f = (float)(l-rig->caps->level_gran[LVL_AF].min.i) / - (float)(rig->caps->level_gran[LVL_AF].max.i-rig->caps->level_gran[LVL_AF].min.i); - break; + if (retval != RIG_OK) + { + return retval; + } - case RIG_LEVEL_RFPOWER: - sprintf(buf, "PC %c",vch); - retval = kenwood_transaction(rig, buf, ackbuf, sizeof (ackbuf)); - if (retval != RIG_OK) - return retval; + retval = sscanf(ackbuf, "SQ %d,%x", &v, &l); - retval = sscanf(ackbuf, "PC %d,%d", &v, &l); - if (retval != 2 || l < 0 || l > 3) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf); - return -RIG_ERJCTED; - } + if (retval != 2 || l < rig->caps->level_gran[LVL_SQL].min.i + || l > rig->caps->level_gran[LVL_SQL].max.i) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf); + return -RIG_ERJCTED; + } - /* range [0.0 ... 1.0] */ - val->f = (float)(l-rig->caps->level_gran[LVL_RFPOWER].min.i) / - (float)(rig->caps->level_gran[LVL_RFPOWER].max.i-rig->caps->level_gran[LVL_RFPOWER].min.i); - break; + /* range [0.0 ... 1.0] */ + val->f = (float)(l - rig->caps->level_gran[LVL_SQL].min.i) / + (float)(rig->caps->level_gran[LVL_SQL].max.i - + rig->caps->level_gran[LVL_SQL].min.i); + break; - case RIG_LEVEL_BALANCE: - retval = kenwood_safe_transaction(rig, "BAL", ackbuf, 10, 5); - if (retval != RIG_OK) - return retval; + case RIG_LEVEL_AF: + sprintf(buf, "AG %c", vch); + retval = kenwood_transaction(rig, buf, ackbuf, sizeof(ackbuf)); - if (ackbuf[4] < '0' || ackbuf[4] > '9') - return -RIG_EPROTO; + if (retval != RIG_OK) + { + return retval; + } - val->f = (float)('4'-ackbuf[4])/('4'-'0'); - break; + retval = sscanf(ackbuf, "AG %d,%x", &v, &l); - case RIG_LEVEL_ATT: - retval = kenwood_safe_transaction(rig, "ATT", ackbuf, 10, 5); - if (retval != RIG_OK) - return retval; + if (retval != 2 || l < rig->caps->level_gran[LVL_AF].min.i + || l > rig->caps->level_gran[LVL_AF].max.i) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf); + return -RIG_ERJCTED; + } - if (ackbuf[4] < '0' || ackbuf[4] > '9') - return -RIG_EPROTO; + /* range [0.0 ... 1.0] */ + val->f = (float)(l - rig->caps->level_gran[LVL_AF].min.i) / + (float)(rig->caps->level_gran[LVL_AF].max.i - + rig->caps->level_gran[LVL_AF].min.i); + break; - if (ackbuf[4] == '0') - val->i = 0; - else - val->i = rig->state.attenuator[ackbuf[4]-'1']; - break; + case RIG_LEVEL_RFPOWER: + sprintf(buf, "PC %c", vch); + retval = kenwood_transaction(rig, buf, ackbuf, sizeof(ackbuf)); - case RIG_LEVEL_VOXGAIN: - retval = kenwood_safe_transaction(rig, "VXG", ackbuf, 10, 5); - if (retval != RIG_OK) - return retval; + if (retval != RIG_OK) + { + return retval; + } - if (ackbuf[4] < '0' || ackbuf[4] > '9') - return -RIG_EPROTO; + retval = sscanf(ackbuf, "PC %d,%d", &v, &l); - val->f = (ackbuf[4] == '0') / 9; - break; + if (retval != 2 || l < 0 || l > 3) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, ackbuf); + return -RIG_ERJCTED; + } - case RIG_LEVEL_VOXDELAY: /* "VXD" */ - return -RIG_ENIMPL; + /* range [0.0 ... 1.0] */ + val->f = (float)(l - rig->caps->level_gran[LVL_RFPOWER].min.i) / + (float)(rig->caps->level_gran[LVL_RFPOWER].max.i - + rig->caps->level_gran[LVL_RFPOWER].min.i); + break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Level %d\n", __func__, level); - return -RIG_EINVAL; - } - return RIG_OK; + case RIG_LEVEL_BALANCE: + retval = kenwood_safe_transaction(rig, "BAL", ackbuf, 10, 5); + + if (retval != RIG_OK) + { + return retval; + } + + if (ackbuf[4] < '0' || ackbuf[4] > '9') + { + return -RIG_EPROTO; + } + + val->f = (float)('4' - ackbuf[4]) / ('4' - '0'); + break; + + case RIG_LEVEL_ATT: + retval = kenwood_safe_transaction(rig, "ATT", ackbuf, 10, 5); + + if (retval != RIG_OK) + { + return retval; + } + + if (ackbuf[4] < '0' || ackbuf[4] > '9') + { + return -RIG_EPROTO; + } + + if (ackbuf[4] == '0') + { + val->i = 0; + } + else + { + val->i = rig->state.attenuator[ackbuf[4] - '1']; + } + + break; + + case RIG_LEVEL_VOXGAIN: + retval = kenwood_safe_transaction(rig, "VXG", ackbuf, 10, 5); + + if (retval != RIG_OK) + { + return retval; + } + + if (ackbuf[4] < '0' || ackbuf[4] > '9') + { + return -RIG_EPROTO; + } + + val->f = (ackbuf[4] == '0') / 9; + break; + + case RIG_LEVEL_VOXDELAY: /* "VXD" */ + return -RIG_ENIMPL; + + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Level %d\n", __func__, level); + return -RIG_EINVAL; + } + + return RIG_OK; } -int th_set_level (RIG *rig, vfo_t vfo, setting_t level, value_t val) +int th_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) { - char vch, buf[12]; - vfo_t tvfo; + char vch, buf[12]; + vfo_t tvfo; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - tvfo = (vfo == RIG_VFO_CURR) ? rig->state.current_vfo : vfo; + tvfo = (vfo == RIG_VFO_CURR) ? rig->state.current_vfo : vfo; - switch (tvfo) { - case RIG_VFO_A: - case RIG_VFO_VFO: - case RIG_VFO_MEM: - vch = '0'; - break; - case RIG_VFO_B: - vch = '1'; - break; - default: - return kenwood_wrong_vfo(__func__, vfo); - } + switch (tvfo) + { + case RIG_VFO_A: + case RIG_VFO_VFO: + case RIG_VFO_MEM: + vch = '0'; + break; - switch (level) { + case RIG_VFO_B: + vch = '1'; + break; - case RIG_LEVEL_RFPOWER : - sprintf(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); + default: + return kenwood_wrong_vfo(__func__, vfo); + } - return kenwood_transaction(rig, buf, NULL, 0); + switch (level) + { - case RIG_LEVEL_SQL : - sprintf(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_RFPOWER : + sprintf(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); - case RIG_LEVEL_AF : - sprintf(buf, "AG %c,%02x", vch, (int)(val.f * 32.0)); - return kenwood_transaction(rig, buf, NULL, 0); + return kenwood_transaction(rig, buf, NULL, 0); - case RIG_LEVEL_ATT : - sprintf(buf, "ATT %c", val.i ? '1' : '0'); - return kenwood_transaction(rig, buf, NULL, 0); + case RIG_LEVEL_SQL : + sprintf(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_BALANCE : - sprintf(buf, "BAL %c", '4' - (int) (val.f * ('4'-'0'))); - return kenwood_transaction(rig, buf, NULL, 0); + case RIG_LEVEL_AF : + sprintf(buf, "AG %c,%02x", vch, (int)(val.f * 32.0)); + return kenwood_transaction(rig, buf, NULL, 0); - case RIG_LEVEL_VOXGAIN: - sprintf(buf, "VXG %d", (int) (val.f * 9)); - return kenwood_transaction(rig, buf, NULL, 0); + case RIG_LEVEL_ATT : + sprintf(buf, "ATT %c", val.i ? '1' : '0'); + return kenwood_transaction(rig, buf, NULL, 0); - case RIG_LEVEL_VOXDELAY: /* "VXD" */ - return -RIG_ENIMPL; + case RIG_LEVEL_BALANCE : + sprintf(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)); + return kenwood_transaction(rig, buf, NULL, 0); + + case RIG_LEVEL_VOXDELAY: /* "VXD" */ + return -RIG_ENIMPL; - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Level %d\n", __func__, level); - return -RIG_EINVAL; - } + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Level %d\n", __func__, level); + return -RIG_EINVAL; + } } #ifndef RIG_TONEMAX -#define RIG_TONEMAX 38 +#define RIG_TONEMAX 38 #endif /* @@ -1129,29 +1399,37 @@ int th_set_level (RIG *rig, vfo_t vfo, setting_t level, value_t val) int th_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone) { - const struct rig_caps *caps; - char tonebuf[16]; - int i, retval; + const struct rig_caps *caps; + char tonebuf[16]; + int i, retval; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - caps = rig->caps; + caps = rig->caps; - for (i = 0; caps->ctcss_list[i] != 0 && i < RIG_TONEMAX; i++) { - if (caps->ctcss_list[i] == tone) - break; - } + for (i = 0; caps->ctcss_list[i] != 0 && i < RIG_TONEMAX; i++) + { + if (caps->ctcss_list[i] == tone) + { + break; + } + } - if (caps->ctcss_list[i] != tone) - return -RIG_EINVAL; + if (caps->ctcss_list[i] != tone) + { + return -RIG_EINVAL; + } - i += (i == 0) ? 1 : 2; /* Correct for TH-D7A index anomally */ - sprintf(tonebuf, "TN %02d", i); - retval = kenwood_transaction(rig, tonebuf, NULL, 0); - if (retval != RIG_OK) - return retval; + i += (i == 0) ? 1 : 2; /* Correct for TH-D7A index anomally */ + sprintf(tonebuf, "TN %02d", i); + retval = kenwood_transaction(rig, tonebuf, NULL, 0); - return RIG_OK; + if (retval != RIG_OK) + { + return retval; + } + + return RIG_OK; } /* @@ -1161,36 +1439,42 @@ th_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone) int th_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) { - struct rig_caps *caps; - char buf[ACKBUF_LEN]; - int retval; - unsigned int tone_idx; + struct rig_caps *caps; + char buf[ACKBUF_LEN]; + int retval; + unsigned int tone_idx; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - caps = rig->caps; + caps = rig->caps; - retval = kenwood_transaction(rig, "TN", buf, sizeof (buf)); - if (retval != RIG_OK) - return retval; + retval = kenwood_transaction(rig, "TN", buf, sizeof(buf)); - retval = sscanf(buf, "TN %d", (int*)&tone_idx); - if (retval != 1) { - rig_debug(RIG_DEBUG_ERR, - "%s: Unexpected reply '%s'\n", __func__, buf); - return -RIG_EPROTO; - } + if (retval != RIG_OK) + { + return retval; + } - /* verify tone index for TH-7DA rig */ - if (tone_idx <= 0 || tone_idx == 2 || tone_idx > 39) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected CTCSS tone no (%04d)\n", - __func__, tone_idx); - return -RIG_EPROTO; - } + retval = sscanf(buf, "TN %d", (int *)&tone_idx); - tone_idx -= (tone_idx == 1) ? 1 : 2; /* Correct for TH-D7A index anomaly */ - *tone = caps->ctcss_list[tone_idx]; - return RIG_OK; + if (retval != 1) + { + rig_debug(RIG_DEBUG_ERR, + "%s: Unexpected reply '%s'\n", __func__, buf); + return -RIG_EPROTO; + } + + /* verify tone index for TH-7DA rig */ + if (tone_idx <= 0 || tone_idx == 2 || tone_idx > 39) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected CTCSS tone no (%04d)\n", + __func__, tone_idx); + return -RIG_EPROTO; + } + + tone_idx -= (tone_idx == 1) ? 1 : 2; /* Correct for TH-D7A index anomaly */ + *tone = caps->ctcss_list[tone_idx]; + return RIG_OK; } /* @@ -1200,29 +1484,37 @@ th_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) int th_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) { - const struct rig_caps *caps; - char tonebuf[16]; - int i, retval; + const struct rig_caps *caps; + char tonebuf[16]; + int i, retval; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - caps = rig->caps; + caps = rig->caps; - for (i = 0; caps->ctcss_list[i] != 0 && i < RIG_TONEMAX; i++) { - if (caps->ctcss_list[i] == tone) - break; - } + for (i = 0; caps->ctcss_list[i] != 0 && i < RIG_TONEMAX; i++) + { + if (caps->ctcss_list[i] == tone) + { + break; + } + } - if (caps->ctcss_list[i] != tone) - return -RIG_EINVAL; + if (caps->ctcss_list[i] != tone) + { + return -RIG_EINVAL; + } - i += (i == 0) ? 1 : 2; /* Correct for TH-D7A index anomally */ - sprintf(tonebuf, "CTN %02d", i); - retval = kenwood_transaction(rig, tonebuf, NULL, 0); - if (retval != RIG_OK) - return retval; + i += (i == 0) ? 1 : 2; /* Correct for TH-D7A index anomally */ + sprintf(tonebuf, "CTN %02d", i); + retval = kenwood_transaction(rig, tonebuf, NULL, 0); - return RIG_OK; + if (retval != RIG_OK) + { + return retval; + } + + return RIG_OK; } /* @@ -1232,36 +1524,42 @@ th_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) int th_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) { - struct rig_caps *caps; - char buf[ACKBUF_LEN]; - int retval; - unsigned int tone_idx; + struct rig_caps *caps; + char buf[ACKBUF_LEN]; + int retval; + unsigned int tone_idx; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - caps = rig->caps; + caps = rig->caps; - retval = kenwood_transaction(rig, "CTN", buf, sizeof (buf)); - if (retval != RIG_OK) - return retval; + retval = kenwood_transaction(rig, "CTN", buf, sizeof(buf)); - retval = sscanf(buf, "CTN %d", (int*)&tone_idx); - if (retval != 1) { - rig_debug(RIG_DEBUG_ERR, - "%s: Unexpected reply '%s'\n", __func__, buf); - return -RIG_EPROTO; - } + if (retval != RIG_OK) + { + return retval; + } - /* verify tone index for TH-7DA rig */ - if (tone_idx <= 0 || tone_idx == 2 || tone_idx > 39) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected CTCSS no (%04d)\n", - __func__, tone_idx); - return -RIG_EPROTO; - } + retval = sscanf(buf, "CTN %d", (int *)&tone_idx); - tone_idx -= (tone_idx == 1) ? 1 : 2; /* Correct for TH-7DA index anomaly */ - *tone = caps->ctcss_list[tone_idx]; - return RIG_OK; + if (retval != 1) + { + rig_debug(RIG_DEBUG_ERR, + "%s: Unexpected reply '%s'\n", __func__, buf); + return -RIG_EPROTO; + } + + /* verify tone index for TH-7DA rig */ + if (tone_idx <= 0 || tone_idx == 2 || tone_idx > 39) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected CTCSS no (%04d)\n", + __func__, tone_idx); + return -RIG_EPROTO; + } + + tone_idx -= (tone_idx == 1) ? 1 : 2; /* Correct for TH-7DA index anomaly */ + *tone = caps->ctcss_list[tone_idx]; + return RIG_OK; } #ifndef RIG_CODEMAX @@ -1275,36 +1573,48 @@ th_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) int th_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code) { - const struct rig_caps *caps; - char codebuf[16]; - int i, retval; + const struct rig_caps *caps; + char codebuf[16]; + int i, retval; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - caps = rig->caps; + caps = rig->caps; - if (code == 0) { - return kenwood_transaction(rig, "DCS 0", NULL, 0); - } + if (code == 0) + { + return kenwood_transaction(rig, "DCS 0", NULL, 0); + } - for (i = 0; caps->dcs_list[i] != 0 && i < RIG_CODEMAX; i++) { - if (caps->dcs_list[i] == code) - break; - } + for (i = 0; caps->dcs_list[i] != 0 && i < RIG_CODEMAX; i++) + { + if (caps->dcs_list[i] == code) + { + break; + } + } - if (caps->dcs_list[i] != code) - return -RIG_EINVAL; + if (caps->dcs_list[i] != code) + { + return -RIG_EINVAL; + } - retval = kenwood_transaction(rig, "DCS 1", NULL, 0); - if (retval != RIG_OK) - return retval; + retval = kenwood_transaction(rig, "DCS 1", NULL, 0); - sprintf(codebuf, "DCSN %04d", (i+1)*10); - retval = kenwood_transaction(rig, codebuf, NULL, 0); - if (retval != RIG_OK) - return retval; + if (retval != RIG_OK) + { + return retval; + } - return RIG_OK; + sprintf(codebuf, "DCSN %04d", (i + 1) * 10); + retval = kenwood_transaction(rig, codebuf, NULL, 0); + + if (retval != RIG_OK) + { + return retval; + } + + return RIG_OK; } /* @@ -1314,74 +1624,91 @@ th_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code) int th_get_dcs_sql(RIG *rig, vfo_t vfo, tone_t *code) { - struct rig_caps *caps; - char buf[ACKBUF_LEN]; - int retval; - unsigned int code_idx; + struct rig_caps *caps; + char buf[ACKBUF_LEN]; + int retval; + unsigned int code_idx; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - caps = rig->caps; + caps = rig->caps; - retval = kenwood_transaction(rig, "DCS", buf, sizeof (buf)); - if (retval != RIG_OK) - return retval; + retval = kenwood_transaction(rig, "DCS", buf, sizeof(buf)); - retval = sscanf(buf, "DCSN %u", (int*)&code_idx); - if (retval != 1) { - rig_debug(RIG_DEBUG_ERR, - "%s: Unexpected reply '%s'\n", __func__, buf); - return -RIG_EPROTO; - } + if (retval != RIG_OK) + { + return retval; + } - if (code_idx == 0) { - *code = 0; /* disabled */ - return RIG_OK; - } + retval = sscanf(buf, "DCSN %u", (int *)&code_idx); - retval = kenwood_transaction(rig, "DCSN", buf, sizeof (buf)); - if (retval != RIG_OK) - return retval; + if (retval != 1) + { + rig_debug(RIG_DEBUG_ERR, + "%s: Unexpected reply '%s'\n", __func__, buf); + return -RIG_EPROTO; + } - retval = sscanf(buf, "DCSN %u", (int*)&code_idx); - if (retval != 1) { - rig_debug(RIG_DEBUG_ERR, - "%s: Unexpected reply '%s'\n", __func__, buf); - return -RIG_EPROTO; - } + if (code_idx == 0) + { + *code = 0; /* disabled */ + return RIG_OK; + } - /* verify code index for TM-D700 rig */ - if (code_idx <= 10 || code_idx > 1040) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected DCS no (%04u)\n", - __func__, code_idx); - return -RIG_EPROTO; - } + retval = kenwood_transaction(rig, "DCSN", buf, sizeof(buf)); - code_idx = (code_idx/10)-1; - *code = caps->dcs_list[code_idx]; - return RIG_OK; + if (retval != RIG_OK) + { + return retval; + } + + retval = sscanf(buf, "DCSN %u", (int *)&code_idx); + + if (retval != 1) + { + rig_debug(RIG_DEBUG_ERR, + "%s: Unexpected reply '%s'\n", __func__, buf); + return -RIG_EPROTO; + } + + /* verify code index for TM-D700 rig */ + if (code_idx <= 10 || code_idx > 1040) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected DCS no (%04u)\n", + __func__, code_idx); + return -RIG_EPROTO; + } + + code_idx = (code_idx / 10) - 1; + *code = caps->dcs_list[code_idx]; + return RIG_OK; } const char * th_get_info(RIG *rig) { - static char firmbuf[50]; - int retval; + static char firmbuf[50]; + int retval; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = kenwood_transaction(rig, "ID", firmbuf, sizeof (firmbuf)); - if (retval != RIG_OK) - return NULL; + retval = kenwood_transaction(rig, "ID", firmbuf, sizeof(firmbuf)); - size_t firm_len = strlen (firmbuf); - if (firm_len < 3) { - rig_debug(RIG_DEBUG_ERR, "%s: unexpected reply '%s', len=%d\n", - __func__, firmbuf, firm_len); - return NULL; - } + if (retval != RIG_OK) + { + return NULL; + } - return &firmbuf[2]; + size_t firm_len = strlen(firmbuf); + + if (firm_len < 3) + { + rig_debug(RIG_DEBUG_ERR, "%s: unexpected reply '%s', len=%d\n", + __func__, firmbuf, firm_len); + return NULL; + } + + return &firmbuf[2]; } /* @@ -1391,39 +1718,48 @@ th_get_info(RIG *rig) int th_set_mem(RIG *rig, vfo_t vfo, int ch) { - unsigned char vsel; - char membuf[10], ackbuf[10]; - int retval; - vfo_t tvfo; + unsigned char vsel; + char membuf[10], ackbuf[10]; + int retval; + vfo_t tvfo; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - tvfo = (vfo == RIG_VFO_CURR) ? rig->state.current_vfo : vfo; + tvfo = (vfo == RIG_VFO_CURR) ? rig->state.current_vfo : vfo; - switch (tvfo) { - case RIG_VFO_VFO: - case RIG_VFO_MEM: - case RIG_VFO_A: - vsel = '0'; - break; - case RIG_VFO_B: - vsel = '1'; - break; - default: - return kenwood_wrong_vfo(__func__, vfo); - } + switch (tvfo) + { + case RIG_VFO_VFO: + case RIG_VFO_MEM: + case RIG_VFO_A: + vsel = '0'; + break; - retval = rig_set_vfo(rig, RIG_VFO_MEM); - if (retval != RIG_OK) - return retval; + case RIG_VFO_B: + vsel = '1'; + break; - sprintf(membuf, "MC %c,%03i", vsel, ch); + default: + return kenwood_wrong_vfo(__func__, vfo); + } - retval = kenwood_safe_transaction(rig, membuf, ackbuf, 10, 8); - if (retval != RIG_OK) - return retval; + retval = rig_set_vfo(rig, RIG_VFO_MEM); - return RIG_OK; + if (retval != RIG_OK) + { + return retval; + } + + sprintf(membuf, "MC %c,%03i", vsel, ch); + + retval = kenwood_safe_transaction(rig, membuf, ackbuf, 10, 8); + + if (retval != RIG_OK) + { + return retval; + } + + return RIG_OK; } /* Get mem works only when the display is @@ -1433,627 +1769,819 @@ th_set_mem(RIG *rig, vfo_t vfo, int ch) int th_get_mem(RIG *rig, vfo_t vfo, int *ch) { - char *membuf, buf[10]; - int retval; - vfo_t tvfo,cvfo; + char *membuf, buf[10]; + int retval; + vfo_t tvfo, cvfo; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - /* store current VFO */ - cvfo = rig->state.current_vfo; + /* store current VFO */ + cvfo = rig->state.current_vfo; - /* check if we should switch VFO */ - if (cvfo != RIG_VFO_MEM) { - retval = rig_set_vfo(rig, RIG_VFO_MEM); - if (retval != RIG_OK) - return retval; - } + /* check if we should switch VFO */ + if (cvfo != RIG_VFO_MEM) + { + retval = rig_set_vfo(rig, RIG_VFO_MEM); - tvfo = (vfo == RIG_VFO_CURR) ? cvfo : vfo; + if (retval != RIG_OK) + { + return retval; + } + } - switch (tvfo) { - case RIG_VFO_VFO: - case RIG_VFO_MEM: - case RIG_VFO_A: - membuf = "MC 0"; - break; - case RIG_VFO_B: - membuf = "MC 1"; - break; - default: - return kenwood_wrong_vfo(__func__, vfo); - } + tvfo = (vfo == RIG_VFO_CURR) ? cvfo : vfo; - retval = kenwood_safe_transaction(rig, membuf, buf, 10, 8); - if (retval != RIG_OK) - return retval; + switch (tvfo) + { + case RIG_VFO_VFO: + case RIG_VFO_MEM: + case RIG_VFO_A: + membuf = "MC 0"; + break; - *ch = atoi(&buf[5]); + case RIG_VFO_B: + membuf = "MC 1"; + break; - /* switch back if appropriate */ - if (cvfo != RIG_VFO_MEM) { - retval = rig_set_vfo(rig, cvfo); - if (retval != RIG_OK) - return retval; - } + default: + return kenwood_wrong_vfo(__func__, vfo); + } - return RIG_OK; + retval = kenwood_safe_transaction(rig, membuf, buf, 10, 8); + + if (retval != RIG_OK) + { + return retval; + } + + *ch = atoi(&buf[5]); + + /* switch back if appropriate */ + if (cvfo != RIG_VFO_MEM) + { + retval = rig_set_vfo(rig, cvfo); + + if (retval != RIG_OK) + { + return retval; + } + } + + return RIG_OK; } int th_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) { - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - return kenwood_transaction(rig, (ptt == RIG_PTT_ON) ? "TX" : "RX", NULL, 0); + return kenwood_transaction(rig, (ptt == RIG_PTT_ON) ? "TX" : "RX", NULL, 0); } int th_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd) { - char *cmd, buf[8]; - int retval; + char *cmd, buf[8]; + int retval; - if (vfo == RIG_VFO_CURR) { - retval = th_get_vfo(rig, &vfo); - if (retval != RIG_OK) - return retval; - } + if (vfo == RIG_VFO_CURR) + { + retval = th_get_vfo(rig, &vfo); - switch (vfo) { - case RIG_VFO_VFO: - case RIG_VFO_A: - case RIG_VFO_MAIN: - cmd = "BY 0"; - break; - case RIG_VFO_B: - case RIG_VFO_SUB: - cmd = "BY 1"; - break; - default: - return kenwood_wrong_vfo(__func__, vfo); - } + if (retval != RIG_OK) + { + return retval; + } + } - retval = kenwood_safe_transaction(rig, cmd, buf, sizeof(buf), 6); - if (retval != RIG_OK) - return retval; + switch (vfo) + { + case RIG_VFO_VFO: + case RIG_VFO_A: + case RIG_VFO_MAIN: + cmd = "BY 0"; + break; - switch (buf[5]) { - case '0' : - *dcd = RIG_DCD_OFF; - return RIG_OK; - case '1' : - *dcd = RIG_DCD_ON; - return RIG_OK; - default : - rig_debug(RIG_DEBUG_ERR, "%s: unexpected reply '%s', len=%d\n", - __func__, buf); - } + case RIG_VFO_B: + case RIG_VFO_SUB: + cmd = "BY 1"; + break; - return -RIG_ERJCTED; + default: + return kenwood_wrong_vfo(__func__, vfo); + } + + retval = kenwood_safe_transaction(rig, cmd, buf, sizeof(buf), 6); + + if (retval != RIG_OK) + { + return retval; + } + + switch (buf[5]) + { + case '0' : + *dcd = RIG_DCD_OFF; + return RIG_OK; + + case '1' : + *dcd = RIG_DCD_ON; + return RIG_OK; + + default : + rig_debug(RIG_DEBUG_ERR, "%s: unexpected reply '%s', len=%d\n", + __func__, buf); + } + + return -RIG_ERJCTED; } int th_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) { - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo) - return kenwood_wrong_vfo(__func__, vfo); + if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo) + { + return kenwood_wrong_vfo(__func__, vfo); + } - switch (op) { - case RIG_OP_UP: - return kenwood_transaction(rig, "UP", NULL, 0); + switch (op) + { + case RIG_OP_UP: + return kenwood_transaction(rig, "UP", NULL, 0); - case RIG_OP_DOWN: - return kenwood_transaction(rig, "DW", NULL, 0); + case RIG_OP_DOWN: + return kenwood_transaction(rig, "DW", NULL, 0); - case RIG_OP_TO_VFO: - return kenwood_transaction(rig, "MSH", NULL, 0); + case RIG_OP_TO_VFO: + return kenwood_transaction(rig, "MSH", NULL, 0); - default: - return -RIG_EINVAL; - } + default: + return -RIG_EINVAL; + } } -/* get and set channel tested on thg71&thf7e */ -/* must work on other th and tm kenwood rigs */ +/* get and set channel tested on thg71&thf7e */ +/* must work on other th and tm kenwood rigs */ /* --------------------------------------------------------------------- */ int th_get_channel(RIG *rig, channel_t *chan) { - char membuf[64],ackbuf[ACKBUF_LEN]; - int retval; - freq_t freq,offset; - char req[32],scf[128]; - int step, shift, rev, tone, ctcss, tonefq, ctcssfq, dcs, dcscode, mode, lockout; - const char *mr_extra; - int channel_num; - vfo_t vfo; - const struct kenwood_priv_caps *priv=(const struct kenwood_priv_caps *)rig->caps->priv; - const chan_t *chan_caps; + char membuf[64], ackbuf[ACKBUF_LEN]; + int retval; + freq_t freq, offset; + char req[32], scf[128]; + int step, shift, rev, tone, ctcss, tonefq, ctcssfq, dcs, dcscode, mode, lockout; + const char *mr_extra; + int channel_num; + vfo_t vfo; + const struct kenwood_priv_caps *priv = (const struct kenwood_priv_caps *) + rig->caps->priv; + const chan_t *chan_caps; - if (chan->vfo == RIG_VFO_MEM) { + if (chan->vfo == RIG_VFO_MEM) + { - chan_caps = rig_lookup_mem_caps(rig, chan->channel_num); - if (!chan_caps) - return -RIG_ECONF; - } else { - /* TODO: stuff channel_num (out of current freq) and chan_caps */ - return -RIG_ENIMPL; + chan_caps = rig_lookup_mem_caps(rig, chan->channel_num); + + if (!chan_caps) + { + return -RIG_ECONF; + } + } + else + { + /* TODO: stuff channel_num (out of current freq) and chan_caps */ + return -RIG_ENIMPL; + } + + channel_num = chan->channel_num; + vfo = chan->vfo; + memset(chan, 0, sizeof(channel_t)); + chan->channel_num = channel_num; + chan->vfo = vfo; + + if (rig->caps->rig_model == RIG_MODEL_THF7E || + rig->caps->rig_model == RIG_MODEL_THF6A) + { + mr_extra = ""; + } + else + { + mr_extra = "0, "; + } + + channel_num -= chan_caps->start; + + switch (chan_caps->type) + { + case RIG_MTYPE_MEM: + if (chan_caps[1].type == RIG_MTYPE_PRIO) + { + /* Info */ + sprintf(req, "MR %s0,I-%01d", mr_extra, channel_num); + } + else + { + sprintf(req, "MR %s0,%03d", mr_extra, channel_num); } - channel_num = chan->channel_num; - vfo = chan->vfo; - memset(chan, 0, sizeof(channel_t)); - chan->channel_num = channel_num; - chan->vfo = vfo; + break; - if (rig->caps->rig_model == RIG_MODEL_THF7E || - rig->caps->rig_model == RIG_MODEL_THF6A) - mr_extra = ""; - else - mr_extra = "0, "; + case RIG_MTYPE_EDGE: + 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); + } + else + { + snprintf(req, sizeof(req), "MR %s0,U%01d", mr_extra, channel_num); + sprintf(chan->channel_desc, "U%01d", channel_num); + } - channel_num -= chan_caps->start; + break; - switch (chan_caps->type) { - case RIG_MTYPE_MEM: - if (chan_caps[1].type == RIG_MTYPE_PRIO) { - /* Info */ - sprintf(req, "MR %s0,I-%01d",mr_extra,channel_num); - } else - sprintf(req, "MR %s0,%03d",mr_extra,channel_num); - break; + case RIG_MTYPE_PRIO: + if (chan_caps->start == chan_caps->end) + { + snprintf(req, sizeof(req), "MR %s0,PR", mr_extra); + sprintf(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); + } - case RIG_MTYPE_EDGE: - 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); - } else { - snprintf(req, sizeof(req), "MR %s0,U%01d",mr_extra,channel_num); - sprintf(chan->channel_desc, "U%01d",channel_num); - } - break; + break; - case RIG_MTYPE_PRIO: - if (chan_caps->start == chan_caps->end) { - snprintf(req, sizeof(req), "MR %s0,PR",mr_extra); - sprintf(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); - } - break; + case RIG_MTYPE_CALL: + sprintf(req, "CR 0,%01d", channel_num); - case RIG_MTYPE_CALL: - sprintf(req, "CR 0,%01d",channel_num); - if (chan->channel_num==chan_caps->start) sprintf(chan->channel_desc, "Call V"); - else if (chan->channel_num==chan_caps->end) sprintf(chan->channel_desc, "Call U"); - else sprintf(chan->channel_desc, "Call"); - break; + if (chan->channel_num == chan_caps->start) { sprintf(chan->channel_desc, "Call V"); } + else if (chan->channel_num == chan_caps->end) { sprintf(chan->channel_desc, "Call U"); } + else { sprintf(chan->channel_desc, "Call"); } - case RIG_MTYPE_BAND: - sprintf(req, "VR %01X",channel_num); - sprintf(chan->channel_desc, "BAND %01X",channel_num); - break; + break; - default: - return -RIG_EINVAL; - } + case RIG_MTYPE_BAND: + sprintf(req, "VR %01X", channel_num); + sprintf(chan->channel_desc, "BAND %01X", channel_num); + break; - sprintf(membuf, "%s",req); + default: + return -RIG_EINVAL; + } - retval = kenwood_transaction(rig, membuf, ackbuf, sizeof (ackbuf)); - if (retval != RIG_OK) - return retval; + sprintf(membuf, "%s", req); - /* - * TODO: dcs/mode/lockout are not there on TH-G71 - */ - mode = RIG_MODE_NONE; - rev = lockout = dcs = dcscode = 0; + retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf)); - strcpy(scf,req); - if (chan_caps->mem_caps.dcs_sql) - { - /* Step can be hexa - * Lockout is optional on some channels - */ - strcat(scf, ",%"SCNfreq",%x,%d,%d,%d,%d,%d,%d,%d,%d,%"SCNfreq",%d,%d"); + if (retval != RIG_OK) + { + return retval; + } - retval = num_sscanf(ackbuf, scf, - &freq, &step, &shift, &rev, &tone, - &ctcss, &dcs, &tonefq, &ctcssfq, &dcscode, - &offset, &mode, &lockout); - if (retval < 12) { - rig_debug(RIG_DEBUG_WARN, "%s: sscanf failed %d\n", __func__, retval); - return -RIG_EPROTO; - } - } else { - strcat(scf, ",%"SCNfreq",%x,%d,%d,%d,%d,,%d,,%d,%"SCNfreq); - retval = num_sscanf(ackbuf, scf, - &freq, &step, &shift, &rev, &tone, - &ctcss, &tonefq, &ctcssfq, &offset); - if (retval != 9) { - rig_debug(RIG_DEBUG_WARN, "%s: sscanf failed %d\n", __func__, retval); - } - } + /* + * TODO: dcs/mode/lockout are not there on TH-G71 + */ + mode = RIG_MODE_NONE; + rev = lockout = dcs = dcscode = 0; - chan->funcs = rev ? RIG_FUNC_REV : 0; - chan->flags = lockout ? RIG_CHFLAG_SKIP : 0; - chan->freq=freq; - chan->vfo=RIG_VFO_MEM; - chan->tuning_step=rig->state.tuning_steps[step].ts; + strcpy(scf, req); - if (priv->mode_table) { - chan->mode = kenwood2rmode(mode, priv->mode_table); - if (chan->mode == RIG_MODE_NONE) { - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode value '%d'\n", - __func__, mode); - return -RIG_EPROTO; - } - } else { - /* No mode info (TH-G71, TMV7,..), - * guess it from current freq - */ - chan->mode = (freq < MHz(136)) ? RIG_MODE_AM : RIG_MODE_FM; - } + if (chan_caps->mem_caps.dcs_sql) + { + /* Step can be hexa + * Lockout is optional on some channels + */ + strcat(scf, ",%"SCNfreq",%x,%d,%d,%d,%d,%d,%d,%d,%d,%"SCNfreq",%d,%d"); - chan->width=rig_passband_normal(rig, chan->mode); + retval = num_sscanf(ackbuf, scf, + &freq, &step, &shift, &rev, &tone, + &ctcss, &dcs, &tonefq, &ctcssfq, &dcscode, + &offset, &mode, &lockout); - switch (shift) { - case 0 : - chan->rptr_shift=RIG_RPT_SHIFT_NONE; - break; - case 1 : - chan->rptr_shift=RIG_RPT_SHIFT_PLUS; - break; - case 2 : - chan->rptr_shift=RIG_RPT_SHIFT_MINUS; - offset = -offset; - break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: not supported shift %d\n", - __func__, shift); - chan->rptr_shift=RIG_RPT_SHIFT_NONE; - } + if (retval < 12) + { + rig_debug(RIG_DEBUG_WARN, "%s: sscanf failed %d\n", __func__, retval); + return -RIG_EPROTO; + } + } + else + { + strcat(scf, ",%"SCNfreq",%x,%d,%d,%d,%d,,%d,,%d,%"SCNfreq); + retval = num_sscanf(ackbuf, scf, + &freq, &step, &shift, &rev, &tone, + &ctcss, &tonefq, &ctcssfq, &offset); - chan->rptr_offs=offset; + if (retval != 9) + { + rig_debug(RIG_DEBUG_WARN, "%s: sscanf failed %d\n", __func__, retval); + } + } - /* FIXME: ctcss_list for t[fm]*.c */ - //chan->ctcss_tone=rig->caps->ctcss_list[tonefq==1?0:tonefq-2]; - // chan->ctcss_sql=rig->caps->ctcss_list[ctcssfq==1?0:ctcssfq-2]; - if (tone) - chan->ctcss_tone=rig->caps->ctcss_list[tonefq]; - else - chan->ctcss_tone=0; + chan->funcs = rev ? RIG_FUNC_REV : 0; + chan->flags = lockout ? RIG_CHFLAG_SKIP : 0; + chan->freq = freq; + chan->vfo = RIG_VFO_MEM; + chan->tuning_step = rig->state.tuning_steps[step].ts; - if (ctcss) - chan->ctcss_sql=rig->caps->ctcss_list[ctcssfq]; - else - chan->ctcss_sql=0; + if (priv->mode_table) + { + chan->mode = kenwood2rmode(mode, priv->mode_table); - if (dcs) - chan->dcs_sql=chan->dcs_code=rig->caps->dcs_list[dcscode]; - else - chan->dcs_sql=chan->dcs_code=0; + if (chan->mode == RIG_MODE_NONE) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode value '%d'\n", + __func__, mode); + return -RIG_EPROTO; + } + } + else + { + /* No mode info (TH-G71, TMV7,..), + * guess it from current freq + */ + chan->mode = (freq < MHz(136)) ? RIG_MODE_AM : RIG_MODE_FM; + } - chan->tx_freq=RIG_FREQ_NONE; - if (shift==RIG_RPT_SHIFT_NONE && - ((chan_caps->type==RIG_MTYPE_MEM && chan_caps->start == 0) || - chan_caps->type==RIG_MTYPE_CALL)) { - /* split ? */ - req[3+strlen(mr_extra)]='1'; - sprintf(membuf, "%s",req); - retval = kenwood_transaction(rig, membuf, ackbuf, sizeof (ackbuf)); - if (retval == RIG_OK) { - strcpy(scf,req); - strcat(scf, ",%"SCNfreq",%x"); - retval = num_sscanf(ackbuf, scf, &freq, &step); - chan->tx_freq=freq; - chan->split=RIG_SPLIT_ON; - } - } + chan->width = rig_passband_normal(rig, chan->mode); - /* If not set already by special channels.. */ - if (chan->channel_desc[0] == '\0') { - if (chan_caps[1].type == RIG_MTYPE_PRIO) - sprintf(membuf, "MNA %sI-%01d",mr_extra,channel_num); - else - sprintf(membuf, "MNA %s%03d",mr_extra,channel_num); + switch (shift) + { + case 0 : + chan->rptr_shift = RIG_RPT_SHIFT_NONE; + break; - /* Get memory name */ - retval = kenwood_transaction(rig, membuf, ackbuf, sizeof (ackbuf)); - if (retval != RIG_OK) - return retval; + case 1 : + chan->rptr_shift = RIG_RPT_SHIFT_PLUS; + break; - size_t ack_len = strlen (ackbuf); - if (ack_len > rig->caps->chan_desc_sz) - ack_len = rig->caps->chan_desc_sz; + case 2 : + chan->rptr_shift = RIG_RPT_SHIFT_MINUS; + offset = -offset; + break; - strncpy(chan->channel_desc,ackbuf+strlen(membuf)+1,ack_len); - chan->channel_desc[ack_len] = '\0'; - } + default: + rig_debug(RIG_DEBUG_ERR, "%s: not supported shift %d\n", + __func__, shift); + chan->rptr_shift = RIG_RPT_SHIFT_NONE; + } - return RIG_OK; + chan->rptr_offs = offset; + + /* FIXME: ctcss_list for t[fm]*.c */ + //chan->ctcss_tone=rig->caps->ctcss_list[tonefq==1?0:tonefq-2]; + // chan->ctcss_sql=rig->caps->ctcss_list[ctcssfq==1?0:ctcssfq-2]; + if (tone) + { + chan->ctcss_tone = rig->caps->ctcss_list[tonefq]; + } + else + { + chan->ctcss_tone = 0; + } + + if (ctcss) + { + chan->ctcss_sql = rig->caps->ctcss_list[ctcssfq]; + } + else + { + chan->ctcss_sql = 0; + } + + if (dcs) + { + chan->dcs_sql = chan->dcs_code = rig->caps->dcs_list[dcscode]; + } + else + { + chan->dcs_sql = chan->dcs_code = 0; + } + + chan->tx_freq = RIG_FREQ_NONE; + + if (shift == RIG_RPT_SHIFT_NONE && + ((chan_caps->type == RIG_MTYPE_MEM && chan_caps->start == 0) || + chan_caps->type == RIG_MTYPE_CALL)) + { + /* split ? */ + req[3 + strlen(mr_extra)] = '1'; + sprintf(membuf, "%s", req); + retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf)); + + if (retval == RIG_OK) + { + strcpy(scf, req); + strcat(scf, ",%"SCNfreq",%x"); + retval = num_sscanf(ackbuf, scf, &freq, &step); + chan->tx_freq = freq; + chan->split = RIG_SPLIT_ON; + } + } + + /* If not set already by special channels.. */ + if (chan->channel_desc[0] == '\0') + { + if (chan_caps[1].type == RIG_MTYPE_PRIO) + { + sprintf(membuf, "MNA %sI-%01d", mr_extra, channel_num); + } + else + { + sprintf(membuf, "MNA %s%03d", mr_extra, channel_num); + } + + /* Get memory name */ + retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf)); + + if (retval != RIG_OK) + { + return retval; + } + + size_t ack_len = strlen(ackbuf); + + if (ack_len > rig->caps->chan_desc_sz) + { + ack_len = rig->caps->chan_desc_sz; + } + + strncpy(chan->channel_desc, ackbuf + strlen(membuf) + 1, ack_len); + chan->channel_desc[ack_len] = '\0'; + } + + return RIG_OK; } static int find_tone_index(const tone_t *tone_list, tone_t tone) { - int i; + int i; - for (i = 0; tone_list[i] != 0 && i < RIG_TONEMAX; i++) { - if (tone_list[i] == tone) - return i; - } + for (i = 0; tone_list[i] != 0 && i < RIG_TONEMAX; i++) + { + if (tone_list[i] == tone) + { + return i; + } + } - return -1; + return -1; } /* --------------------------------------------------------------------- */ int th_set_channel(RIG *rig, const channel_t *chan) { - char membuf[150]; - int retval; - char req[64]; - char lockoutstr[8]; - int channel_num, step, shift, rev, tone, ctcss, tonefq, ctcssfq, dcs, dcscode, mode, lockout; - const char *mr_extra; - const struct kenwood_priv_caps *priv=(const struct kenwood_priv_caps *)rig->caps->priv; - const chan_t *chan_caps; - const char *channel_desc; + char membuf[150]; + int retval; + char req[64]; + char lockoutstr[8]; + int channel_num, step, shift, rev, tone, ctcss, tonefq, ctcssfq, dcs, dcscode, + mode, lockout; + const char *mr_extra; + const struct kenwood_priv_caps *priv = (const struct kenwood_priv_caps *) + rig->caps->priv; + const chan_t *chan_caps; + const char *channel_desc; - channel_num = chan->channel_num; + channel_num = chan->channel_num; - for (step=0; rig->state.tuning_steps[step].ts!=0;step++) - if (chan->tuning_step<=rig->state.tuning_steps[step].ts) - break; + for (step = 0; rig->state.tuning_steps[step].ts != 0; step++) + if (chan->tuning_step <= rig->state.tuning_steps[step].ts) + { + break; + } - switch (chan->rptr_shift) { - case RIG_RPT_SHIFT_NONE : - shift=0; - break; - case RIG_RPT_SHIFT_PLUS: - shift=1; - break; - case RIG_RPT_SHIFT_MINUS: - shift=2; - break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: not supported shift %d\n", - __func__, chan->rptr_shift); - return -RIG_EINVAL; - } + switch (chan->rptr_shift) + { + case RIG_RPT_SHIFT_NONE : + shift = 0; + break; - if (chan->ctcss_tone==0) { - tone=0; - tonefq=8; - } else { - tone=1; - tonefq = find_tone_index(rig->caps->ctcss_list, chan->ctcss_tone); - if (tonefq == -1) - return -RIG_EINVAL; - tonefq++; - } + case RIG_RPT_SHIFT_PLUS: + shift = 1; + break; - if (chan->ctcss_sql==0) { - ctcss=0; - ctcssfq=8; - } else { - ctcss=1; - ctcssfq = find_tone_index(rig->caps->ctcss_list, chan->ctcss_sql); - if (tonefq == -1) - return -RIG_EINVAL; - ctcssfq++; - } + case RIG_RPT_SHIFT_MINUS: + shift = 2; + break; - if (chan->dcs_code==0 && chan->dcs_sql==0) { - dcs=0; - dcscode=0; - } else { - dcs=1; - dcscode = find_tone_index(rig->caps->dcs_list, chan->dcs_sql); - if (dcscode == -1) - return -RIG_EINVAL; - } + default: + rig_debug(RIG_DEBUG_ERR, "%s: not supported shift %d\n", + __func__, chan->rptr_shift); + return -RIG_EINVAL; + } - if (chan->vfo == RIG_VFO_MEM) - { - chan_caps = rig_lookup_mem_caps(rig, chan->channel_num); - if (!chan_caps) - return -RIG_ECONF; - channel_num -= chan_caps->start; - } - else - return -RIG_ENIMPL; + if (chan->ctcss_tone == 0) + { + tone = 0; + tonefq = 8; + } + else + { + tone = 1; + tonefq = find_tone_index(rig->caps->ctcss_list, chan->ctcss_tone); - if (rig->caps->rig_model == RIG_MODEL_THF7E || - rig->caps->rig_model == RIG_MODEL_THF6A) - mr_extra = ""; - else - mr_extra = "0, "; + if (tonefq == -1) + { + return -RIG_EINVAL; + } - channel_desc = NULL; - switch (chan_caps->type) { - case RIG_MTYPE_MEM: - if (chan_caps[1].type == RIG_MTYPE_PRIO) { - /* Info */ - sprintf(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); - channel_desc = chan->channel_desc; - } - break; + tonefq++; + } - case RIG_MTYPE_EDGE: - if (chan_caps[1].type == RIG_MTYPE_EDGE) { - sprintf(req, "MW %s0,L%01d",mr_extra,channel_num); - } else { - sprintf(req, "MW %s0,U%01d",mr_extra,channel_num); - } - break; + if (chan->ctcss_sql == 0) + { + ctcss = 0; + ctcssfq = 8; + } + else + { + ctcss = 1; + ctcssfq = find_tone_index(rig->caps->ctcss_list, chan->ctcss_sql); - case RIG_MTYPE_PRIO: - if (chan_caps->start == chan_caps->end) { - sprintf(req, "MW %s0,PR",mr_extra); - } else { - sprintf(req, "MW %s0,PR%01d",mr_extra,channel_num+1); - } - break; + if (tonefq == -1) + { + return -RIG_EINVAL; + } - case RIG_MTYPE_CALL: - sprintf(req, "CW 0,%01d",channel_num); - break; + ctcssfq++; + } - case RIG_MTYPE_BAND: - sprintf(req, "VW %01X",channel_num); - break; + if (chan->dcs_code == 0 && chan->dcs_sql == 0) + { + dcs = 0; + dcscode = 0; + } + else + { + dcs = 1; + dcscode = find_tone_index(rig->caps->dcs_list, chan->dcs_sql); - default: - return -RIG_EINVAL; - } + if (dcscode == -1) + { + return -RIG_EINVAL; + } + } - rev = chan->funcs & RIG_FUNC_REV ? 1 : 0; - lockout = chan->flags & RIG_CHFLAG_SKIP ? 1 : 0; + if (chan->vfo == RIG_VFO_MEM) + { + chan_caps = rig_lookup_mem_caps(rig, chan->channel_num); - if (chan_caps->mem_caps.flags) - sprintf(lockoutstr, ",%d", lockout); - else - strcpy(lockoutstr, ""); + if (!chan_caps) + { + return -RIG_ECONF; + } - if (chan_caps->mem_caps.flags && chan_caps->mem_caps.dcs_sql) { + channel_num -= chan_caps->start; + } + else + { + return -RIG_ENIMPL; + } - if (!priv->mode_table) { - rig_debug(RIG_DEBUG_ERR, "%s: Buggy backend, no mode_table '%d'\n", - __func__, chan->mode); - return -RIG_ENIMPL; - } + if (rig->caps->rig_model == RIG_MODEL_THF7E || + rig->caps->rig_model == RIG_MODEL_THF6A) + { + mr_extra = ""; + } + else + { + mr_extra = "0, "; + } - mode = rmode2kenwood(chan->mode, priv->mode_table); - if (mode == -1) { - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode value '%d'\n", - __func__, chan->mode); - return -RIG_EINVAL; - } + channel_desc = NULL; - /* Step can be hexa */ - retval = snprintf(membuf, sizeof(membuf), "%s,%011"PRIll",%X,%d,%d,%d,%d,%d,%02d,%02d,%03d,%09"PRIll",%d%s", - req, (int64_t)chan->freq, step, shift, rev, tone, - ctcss, dcs, tonefq, ctcssfq, dcscode, - (int64_t)labs((long)(chan->rptr_offs)), mode, lockoutstr - ); - } else { + switch (chan_caps->type) + { + case RIG_MTYPE_MEM: + if (chan_caps[1].type == RIG_MTYPE_PRIO) + { + /* Info */ + sprintf(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); + channel_desc = chan->channel_desc; + } - /* Without DCS,mode */ - retval = sprintf(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 - ); - } + break; - retval = kenwood_transaction(rig, membuf, NULL, 0); - if (retval != RIG_OK) - return retval; + case RIG_MTYPE_EDGE: + if (chan_caps[1].type == RIG_MTYPE_EDGE) + { + sprintf(req, "MW %s0,L%01d", mr_extra, channel_num); + } + else + { + sprintf(req, "MW %s0,U%01d", mr_extra, channel_num); + } - /* split ? */ - if (chan->tx_freq!=RIG_FREQ_NONE && - ((chan_caps->type==RIG_MTYPE_MEM && chan_caps->start == 0) || - chan_caps->type==RIG_MTYPE_CALL)) { + break; - req[3+strlen(mr_extra)]='1'; + case RIG_MTYPE_PRIO: + if (chan_caps->start == chan_caps->end) + { + sprintf(req, "MW %s0,PR", mr_extra); + } + else + { + sprintf(req, "MW %s0,PR%01d", mr_extra, channel_num + 1); + } - sprintf(membuf, "%s,%011"PRIll",%X", req,(int64_t)chan->tx_freq, step); - retval = kenwood_transaction(rig, membuf, NULL, 0); - if (retval != RIG_OK) - return retval; - } + break; - if (channel_desc) { - /* Memory name */ - /* 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); - else - sprintf(membuf, "MNA %s%03d,%s",mr_extra,channel_num,channel_desc); + case RIG_MTYPE_CALL: + sprintf(req, "CW 0,%01d", channel_num); + break; - retval = kenwood_transaction(rig, membuf, NULL, 0); - if (retval != RIG_OK) - return retval; - } + case RIG_MTYPE_BAND: + sprintf(req, "VW %01X", channel_num); + break; - return RIG_OK; + default: + return -RIG_EINVAL; + } + + rev = chan->funcs & RIG_FUNC_REV ? 1 : 0; + lockout = chan->flags & RIG_CHFLAG_SKIP ? 1 : 0; + + if (chan_caps->mem_caps.flags) + { + sprintf(lockoutstr, ",%d", lockout); + } + else + { + strcpy(lockoutstr, ""); + } + + if (chan_caps->mem_caps.flags && chan_caps->mem_caps.dcs_sql) + { + + if (!priv->mode_table) + { + rig_debug(RIG_DEBUG_ERR, "%s: Buggy backend, no mode_table '%d'\n", + __func__, chan->mode); + return -RIG_ENIMPL; + } + + mode = rmode2kenwood(chan->mode, priv->mode_table); + + if (mode == -1) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode value '%d'\n", + __func__, chan->mode); + return -RIG_EINVAL; + } + + /* Step can be hexa */ + retval = snprintf(membuf, sizeof(membuf), + "%s,%011"PRIll",%X,%d,%d,%d,%d,%d,%02d,%02d,%03d,%09"PRIll",%d%s", + req, (int64_t)chan->freq, step, shift, rev, tone, + ctcss, dcs, tonefq, ctcssfq, dcscode, + (int64_t)labs((long)(chan->rptr_offs)), mode, lockoutstr + ); + } + else + { + + /* Without DCS,mode */ + retval = sprintf(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 + ); + } + + retval = kenwood_transaction(rig, membuf, NULL, 0); + + if (retval != RIG_OK) + { + return retval; + } + + /* split ? */ + if (chan->tx_freq != RIG_FREQ_NONE && + ((chan_caps->type == RIG_MTYPE_MEM && chan_caps->start == 0) || + chan_caps->type == RIG_MTYPE_CALL)) + { + + req[3 + strlen(mr_extra)] = '1'; + + sprintf(membuf, "%s,%011"PRIll",%X", req, (int64_t)chan->tx_freq, step); + retval = kenwood_transaction(rig, membuf, NULL, 0); + + if (retval != RIG_OK) + { + return retval; + } + } + + if (channel_desc) + { + /* Memory name */ + /* 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); + } + else + { + sprintf(membuf, "MNA %s%03d,%s", mr_extra, channel_num, channel_desc); + } + + retval = kenwood_transaction(rig, membuf, NULL, 0); + + if (retval != RIG_OK) + { + return retval; + } + } + + return RIG_OK; } /* * set the aerial/antenna to use */ -int th_set_ant(RIG * rig, vfo_t vfo, ant_t ant) +int th_set_ant(RIG *rig, vfo_t vfo, ant_t ant) { - const char *cmd; + const char *cmd; - rig_debug(RIG_DEBUG_TRACE, "%s: ant = %d\n", __func__, ant); + rig_debug(RIG_DEBUG_TRACE, "%s: ant = %d\n", __func__, ant); - switch (ant) { - case RIG_ANT_1: - cmd = "ANT 0"; - break; + switch (ant) + { + case RIG_ANT_1: + cmd = "ANT 0"; + break; - case RIG_ANT_2: - cmd = "ANT 1"; - break; + case RIG_ANT_2: + cmd = "ANT 1"; + break; - case RIG_ANT_3: - cmd = "ANT 2"; - break; + case RIG_ANT_3: + cmd = "ANT 2"; + break; - default: - return -RIG_EINVAL; - } + default: + return -RIG_EINVAL; + } - return kenwood_transaction(rig, cmd, NULL, 0); + return kenwood_transaction(rig, cmd, NULL, 0); } /* * get the aerial/antenna in use */ -int th_get_ant(RIG * rig, vfo_t vfo, ant_t * ant) +int th_get_ant(RIG *rig, vfo_t vfo, ant_t *ant) { - char buf[8]; - int retval; + char buf[8]; + int retval; - rig_debug(RIG_DEBUG_TRACE, "%s\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s\n", __func__); - retval = kenwood_safe_transaction(rig, "ANT", buf, sizeof(buf), 5); - if (retval != RIG_OK) - return retval; + retval = kenwood_safe_transaction(rig, "ANT", buf, sizeof(buf), 5); - if (buf[4] < '0' || buf[4] > '9') - return -RIG_EPROTO; + if (retval != RIG_OK) + { + return retval; + } - *ant = RIG_ANT_N(buf[4] - '0'); + if (buf[4] < '0' || buf[4] > '9') + { + return -RIG_EPROTO; + } - rig_debug(RIG_DEBUG_TRACE, "%s: ant = %d\n", __func__, *ant); + *ant = RIG_ANT_N(buf[4] - '0'); - return RIG_OK; + rig_debug(RIG_DEBUG_TRACE, "%s: ant = %d\n", __func__, *ant); + + return RIG_OK; } /* TH-F7: 1 VFO, 2 Menu, 3 Full */ /* TM-D700: 1 Master! */ int th_reset(RIG *rig, reset_t reset) { - switch(reset) { - case RIG_RESET_VFO: - return kenwood_transaction(rig, "SR 1", NULL, 0); + switch (reset) + { + case RIG_RESET_VFO: + return kenwood_transaction(rig, "SR 1", NULL, 0); - case RIG_RESET_MASTER: - return kenwood_transaction(rig, "SR 3", NULL, 0); + case RIG_RESET_MASTER: + return kenwood_transaction(rig, "SR 3", NULL, 0); - default: - rig_debug(RIG_DEBUG_ERR, "%s: unsupported reset %d\n", - __func__, reset); - return -RIG_EINVAL; - } + default: + rig_debug(RIG_DEBUG_ERR, "%s: unsupported reset %d\n", + __func__, reset); + return -RIG_EINVAL; + } } diff --git a/kenwood/thd72.c b/kenwood/thd72.c index 6ea279188..7b7793b0a 100644 --- a/kenwood/thd72.c +++ b/kenwood/thd72.c @@ -35,8 +35,8 @@ #include "misc.h" -#define THD72_MODES (RIG_MODE_FM|RIG_MODE_FMN|RIG_MODE_AM) -#define THD72_MODES_TX (RIG_MODE_FM|RIG_MODE_FMN) +#define THD72_MODES (RIG_MODE_FM|RIG_MODE_FMN|RIG_MODE_AM) +#define THD72_MODES_TX (RIG_MODE_FM|RIG_MODE_FMN) #define THD72_FUNC_ALL (RIG_FUNC_TSQL| \ RIG_FUNC_AIP| \ @@ -44,1142 +44,1549 @@ RIG_FUNC_ARO) #define THD72_LEVEL_ALL (RIG_LEVEL_RFPOWER| \ - RIG_LEVEL_SQL| \ - RIG_LEVEL_BALANCE| \ - RIG_LEVEL_VOXGAIN| \ + RIG_LEVEL_SQL| \ + RIG_LEVEL_BALANCE| \ + RIG_LEVEL_VOXGAIN| \ RIG_LEVEL_VOXDELAY) -#define THD72_PARMS (RIG_PARM_APO| \ - RIG_PARM_TIME) +#define THD72_PARMS (RIG_PARM_APO| \ + RIG_PARM_TIME) #define THD72_VFO_OP (RIG_OP_NONE) #define THD72_VFO (RIG_VFO_A|RIG_VFO_B) -static rmode_t thd72_mode_table[3] = { - [0] = RIG_MODE_FM, /* normal, but narrow compared to broadcast */ - [1] = RIG_MODE_FMN, /* what kenwood calls narrow */ - [2] = RIG_MODE_AM, +static rmode_t thd72_mode_table[3] = +{ + [0] = RIG_MODE_FM, /* normal, but narrow compared to broadcast */ + [1] = RIG_MODE_FMN, /* what kenwood calls narrow */ + [2] = RIG_MODE_AM, }; -static pbwidth_t thd72_width_table[3] = { - [0] = 10000, // +-5KHz - [1] = 5000, // +-2.5KHz - [2] = 10000, // what should this be? +static pbwidth_t thd72_width_table[3] = +{ + [0] = 10000, // +-5KHz + [1] = 5000, // +-2.5KHz + [2] = 10000, // what should this be? }; -static rptr_shift_t thd72_rshf_table[3] = { - [0] = RIG_RPT_SHIFT_NONE, - [1] = RIG_RPT_SHIFT_PLUS, - [2] = RIG_RPT_SHIFT_MINUS, +static rptr_shift_t thd72_rshf_table[3] = +{ + [0] = RIG_RPT_SHIFT_NONE, + [1] = RIG_RPT_SHIFT_PLUS, + [2] = RIG_RPT_SHIFT_MINUS, }; -static int thd72tuningstep[10] = { - [0] = 5000, - [1] = 6250, - [2] = 8330, - [3] = 10000, - [4] = 12500, - [5] = 15000, - [6] = 20000, - [7] = 25000, - [8] = 30000, - [9] = 50000, /* or 100 kHz? */ +static int thd72tuningstep[10] = +{ + [0] = 5000, + [1] = 6250, + [2] = 8330, + [3] = 10000, + [4] = 12500, + [5] = 15000, + [6] = 20000, + [7] = 25000, + [8] = 30000, + [9] = 50000, /* or 100 kHz? */ }; -static int thd72voxdelay[7] = { - [0] = 2500, - [1] = 5000, - [2] = 7500, - [3] = 10000, - [4] = 15000, - [5] = 20000, - [6] = 30000 +static int thd72voxdelay[7] = +{ + [0] = 2500, + [1] = 5000, + [2] = 7500, + [3] = 10000, + [4] = 15000, + [5] = 20000, + [6] = 30000 }; -static float thd72sqlevel[6] = { - [0] = 0.0, /* open */ - [1] = 0.2, - [2] = 0.4, - [3] = 0.6, - [4] = 0.8, - [5] = 1.0 +static float thd72sqlevel[6] = +{ + [0] = 0.0, /* open */ + [1] = 0.2, + [2] = 0.4, + [3] = 0.6, + [4] = 0.8, + [5] = 1.0 }; -static int thd72apo[4] = { - [0] = 0, - [1] = 15, - [2] = 30, - [3] = 60 +static int thd72apo[4] = +{ + [0] = 0, + [1] = 15, + [2] = 30, + [3] = 60 }; -static tone_t thd72dcs_list[105] = { - 23, 25, 26, 31, 32, 36, 43, 47, - 51, 53, 54, 65, 71, 72, 73, 74, - 114, 115, 116, 122, 125, 131, 132, 134, - 143, 145, 152, 155, 156, 162, 165, 172, - 174, 205, 212, 223, 225, 226, 243, 244, - 245, 246, 251, 252, 255, 261, 263, 265, - 266, 271, 274, 306, 311, 315, 325, 331, - 332, 343, 346, 351, 356, 364, 365, 371, - 411, 412, 413, 423, 431, 432, 445, 446, - 452, 454, 455, 462, 464, 465, 466, 503, - 506, 516, 523, 526, 532, 546, 565, 606, - 612, 624, 627, 631, 632, 654, 662, 664, - 703, 712, 723, 731, 732, 734, 743, 754, - 0 +static tone_t thd72dcs_list[105] = +{ + 23, 25, 26, 31, 32, 36, 43, 47, + 51, 53, 54, 65, 71, 72, 73, 74, + 114, 115, 116, 122, 125, 131, 132, 134, + 143, 145, 152, 155, 156, 162, 165, 172, + 174, 205, 212, 223, 225, 226, 243, 244, + 245, 246, 251, 252, 255, 261, 263, 265, + 266, 271, 274, 306, 311, 315, 325, 331, + 332, 343, 346, 351, 356, 364, 365, 371, + 411, 412, 413, 423, 431, 432, 445, 446, + 452, 454, 455, 462, 464, 465, 466, 503, + 506, 516, 523, 526, 532, 546, 565, 606, + 612, 624, 627, 631, 632, 654, 662, 664, + 703, 712, 723, 731, 732, 734, 743, 754, + 0 }; -static struct kenwood_priv_caps thd72_priv_caps = { - .cmdtrm = EOM_TH, /* Command termination character */ - .mode_table = thd72_mode_table, +static struct kenwood_priv_caps thd72_priv_caps = +{ + .cmdtrm = EOM_TH, /* Command termination character */ + .mode_table = thd72_mode_table, }; int thd72_open(RIG *rig) { - int ret; - struct kenwood_priv_data *priv = rig->state.priv; - strcpy (priv->verify_cmd, "ID\r"); + int ret; + struct kenwood_priv_data *priv = rig->state.priv; + strcpy(priv->verify_cmd, "ID\r"); - ret = kenwood_transaction(rig, "", NULL, 0); + ret = kenwood_transaction(rig, "", NULL, 0); - return ret; + return ret; } static int thd72_set_vfo(RIG *rig, vfo_t vfo) { - const char *cmd; + const char *cmd; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - switch (vfo) { - case RIG_VFO_A: - case RIG_VFO_VFO: - case RIG_VFO_MAIN: - cmd = "BC 0"; - rig->state.current_vfo = RIG_VFO_A; - break; + switch (vfo) + { + case RIG_VFO_A: + case RIG_VFO_VFO: + case RIG_VFO_MAIN: + cmd = "BC 0"; + rig->state.current_vfo = RIG_VFO_A; + break; - case RIG_VFO_B: - case RIG_VFO_SUB: - rig->state.current_vfo = RIG_VFO_B; - cmd = "BC 1"; - break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO: %s\n", __func__, rig_strvfo(vfo)); - return -RIG_ENTARGET; - } - return kenwood_simple_transaction(rig, cmd, 4); + case RIG_VFO_B: + case RIG_VFO_SUB: + rig->state.current_vfo = RIG_VFO_B; + cmd = "BC 1"; + break; + + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO: %s\n", __func__, + rig_strvfo(vfo)); + return -RIG_ENTARGET; + } + + return kenwood_simple_transaction(rig, cmd, 4); } static int thd72_get_vfo(RIG *rig, vfo_t *vfo) { - int retval; - char c, buf[10]; + int retval; + char c, buf[10]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = kenwood_transaction(rig, "BC", buf, sizeof (buf)); - if (retval != RIG_OK) - return retval; - size_t length = strlen (buf); - if (length == 4) { - c = buf[3]; - } else { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected answer length '%c'\n", __func__, length); - return -RIG_EPROTO; - } - switch (c) { - case '0': *vfo = RIG_VFO_A; break; - case '1': *vfo = RIG_VFO_B; break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO: %c\n", __func__, c); - return -RIG_EVFO; - } - return RIG_OK; + retval = kenwood_transaction(rig, "BC", buf, sizeof(buf)); + + if (retval != RIG_OK) + { + return retval; + } + + size_t length = strlen(buf); + + if (length == 4) + { + c = buf[3]; + } + else + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected answer length '%c'\n", __func__, + length); + return -RIG_EPROTO; + } + + switch (c) + { + case '0': *vfo = RIG_VFO_A; break; + + case '1': *vfo = RIG_VFO_B; break; + + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO: %c\n", __func__, c); + return -RIG_EVFO; + } + + return RIG_OK; } static int thd72_vfoc(RIG *rig, vfo_t vfo, char *vfoc) { - rig_debug(RIG_DEBUG_TRACE, "%s: called VFO=%s\n", __func__, rig_strvfo(vfo)); - vfo = (vfo == RIG_VFO_CURR) ? rig->state.current_vfo : vfo; - switch (vfo) { - case RIG_VFO_A: + rig_debug(RIG_DEBUG_TRACE, "%s: called VFO=%s\n", __func__, rig_strvfo(vfo)); + vfo = (vfo == RIG_VFO_CURR) ? rig->state.current_vfo : vfo; + + switch (vfo) + { + case RIG_VFO_A: case RIG_VFO_MAIN: *vfoc = '0'; break; - case RIG_VFO_B: + + case RIG_VFO_B: case RIG_VFO_SUB: *vfoc = '1'; break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO: %s\n", __func__, rig_strvfo(vfo)); - return -RIG_ENTARGET; - } - return RIG_OK; + + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported VFO: %s\n", __func__, + rig_strvfo(vfo)); + return -RIG_ENTARGET; + } + + return RIG_OK; } static int thd72_get_freq_info(RIG *rig, vfo_t vfo, char *buf) { - int retval; - char c, cmd[8]; + int retval; + char c, cmd[8]; - rig_debug(RIG_DEBUG_TRACE, "%s: called VFO=%s\n", __func__, rig_strvfo(vfo)); - retval = thd72_vfoc(rig, vfo, &c); - if (retval != RIG_OK) - return retval; - sprintf(cmd, "FO %c", c); - retval = kenwood_transaction(rig, cmd, buf, 53); - return RIG_OK; + rig_debug(RIG_DEBUG_TRACE, "%s: called VFO=%s\n", __func__, rig_strvfo(vfo)); + retval = thd72_vfoc(rig, vfo, &c); + + if (retval != RIG_OK) + { + return retval; + } + + sprintf(cmd, "FO %c", c); + retval = kenwood_transaction(rig, cmd, buf, 53); + return RIG_OK; } /* item is an offset into reply buf that is a single char */ static int thd72_get_freq_item(RIG *rig, vfo_t vfo, int item, int hi, int *val) { - int retval, lval; - char c, buf[64]; + int retval, lval; + char c, buf[64]; - retval = thd72_get_freq_info(rig, vfo, buf); - if (retval != RIG_OK) - return retval; - c = buf[item]; - if (c < '0' || c > '9') - return -RIG_EPROTO; - lval = c - '0'; - if (lval > hi) - return -RIG_EPROTO; - *val = lval; - return RIG_OK; + retval = thd72_get_freq_info(rig, vfo, buf); + + if (retval != RIG_OK) + { + return retval; + } + + c = buf[item]; + + if (c < '0' || c > '9') + { + return -RIG_EPROTO; + } + + lval = c - '0'; + + if (lval > hi) + { + return -RIG_EPROTO; + } + + *val = lval; + return RIG_OK; } static int thd72_set_freq_item(RIG *rig, vfo_t vfo, int item, int val) { - int retval; - char buf[64]; + int retval; + char buf[64]; - retval = thd72_get_freq_info(rig, vfo, buf); - if (retval != RIG_OK) - return retval; - buf[item] = val + '0'; - return kenwood_simple_transaction(rig, buf, 52); + retval = thd72_get_freq_info(rig, vfo, buf); + + if (retval != RIG_OK) + { + return retval; + } + + buf[item] = val + '0'; + return kenwood_simple_transaction(rig, buf, 52); } static int thd72_set_freq(RIG *rig, vfo_t vfo, freq_t freq) { - int retval; - char buf[64], fbuf[11]; + int retval; + char buf[64], fbuf[11]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = thd72_get_freq_info(rig, vfo, buf); - if (retval != RIG_OK) - return retval; - sprintf(fbuf, "%010"PRIll, (int64_t)freq); - memcpy(buf+5, fbuf, 10); - retval = kenwood_simple_transaction(rig, buf, 52); + retval = thd72_get_freq_info(rig, vfo, buf); + + if (retval != RIG_OK) + { return retval; + } + + sprintf(fbuf, "%010"PRIll, (int64_t)freq); + memcpy(buf + 5, fbuf, 10); + retval = kenwood_simple_transaction(rig, buf, 52); + return retval; } static int thd72_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) { - int retval; - char buf[64]; + int retval; + char buf[64]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = thd72_get_freq_info(rig, vfo, buf); - if (retval != RIG_OK) - return retval; - sscanf(buf+5, "%"SCNfreq, freq); - return RIG_OK; + retval = thd72_get_freq_info(rig, vfo, buf); + + if (retval != RIG_OK) + { + return retval; + } + + sscanf(buf + 5, "%"SCNfreq, freq); + return RIG_OK; } static int thd72_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { - int val; + int val; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - switch (mode) { - case RIG_MODE_FM: val = 0; break; - case RIG_MODE_FMN: val = 1; break; - case RIG_MODE_AM: val = 2; break; - default: - return -RIG_EINVAL; - } - return thd72_set_freq_item(rig, vfo, 51, val); + switch (mode) + { + case RIG_MODE_FM: val = 0; break; + + case RIG_MODE_FMN: val = 1; break; + + case RIG_MODE_AM: val = 2; break; + + default: + return -RIG_EINVAL; + } + + return thd72_set_freq_item(rig, vfo, 51, val); } static int thd72_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) { - int retval, modeinx; + int retval, modeinx; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = thd72_get_freq_item(rig, vfo, 51, 2, &modeinx); - if (retval != RIG_OK) - return retval; - *mode = thd72_mode_table[modeinx]; - *width = thd72_width_table[modeinx]; - return RIG_OK; + retval = thd72_get_freq_item(rig, vfo, 51, 2, &modeinx); + + if (retval != RIG_OK) + { + return retval; + } + + *mode = thd72_mode_table[modeinx]; + *width = thd72_width_table[modeinx]; + return RIG_OK; } static int thd72_set_rptr_shft(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift) { - int rsinx; + int rsinx; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - switch (rptr_shift) { - case RIG_RPT_SHIFT_NONE: rsinx = 0; break; - case RIG_RPT_SHIFT_PLUS: rsinx = 1; break; - case RIG_RPT_SHIFT_MINUS: rsinx = 2; break; - default: - return -RIG_EINVAL; - } - return thd72_set_freq_item(rig, vfo, 18, rsinx); + switch (rptr_shift) + { + case RIG_RPT_SHIFT_NONE: rsinx = 0; break; + + case RIG_RPT_SHIFT_PLUS: rsinx = 1; break; + + case RIG_RPT_SHIFT_MINUS: rsinx = 2; break; + + default: + return -RIG_EINVAL; + } + + return thd72_set_freq_item(rig, vfo, 18, rsinx); } static int thd72_get_rptr_shft(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift) { - int retval, rsinx; + int retval, rsinx; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = thd72_get_freq_item(rig, vfo, 18, 3, &rsinx); - if (retval != RIG_OK) - return retval; - /* rsinx == 3 indicates split mode? */ - *rptr_shift = (rsinx == 3)? RIG_RPT_SHIFT_NONE: thd72_rshf_table[rsinx]; - return RIG_OK; + retval = thd72_get_freq_item(rig, vfo, 18, 3, &rsinx); + + if (retval != RIG_OK) + { + return retval; + } + + /* rsinx == 3 indicates split mode? */ + *rptr_shift = (rsinx == 3) ? RIG_RPT_SHIFT_NONE : thd72_rshf_table[rsinx]; + return RIG_OK; } static int thd72_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t offs) { - int retval; - char boff[9], buf[64]; + int retval; + char boff[9], buf[64]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = thd72_get_freq_info(rig, vfo, buf); - if (retval != RIG_OK) - return retval; - sprintf(boff, "%08ld", offs); - memcpy(buf+42, boff, 8); - retval = kenwood_simple_transaction(rig, buf, 52); + retval = thd72_get_freq_info(rig, vfo, buf); + + if (retval != RIG_OK) + { return retval; + } + + sprintf(boff, "%08ld", offs); + memcpy(buf + 42, boff, 8); + retval = kenwood_simple_transaction(rig, buf, 52); + return retval; } static int thd72_get_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t *offs) { - int retval; - char buf[64]; + int retval; + char buf[64]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = thd72_get_freq_info(rig, vfo, buf); - if (retval != RIG_OK) - return retval; - sscanf(buf+42, "%ld", offs); - return RIG_OK; + retval = thd72_get_freq_info(rig, vfo, buf); + + if (retval != RIG_OK) + { + return retval; + } + + sscanf(buf + 42, "%ld", offs); + return RIG_OK; } static int thd72_set_ts(RIG *rig, vfo_t vfo, shortfreq_t ts) { - int tsinx; + int tsinx; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - for (tsinx = 0; tsinx < 10; tsinx++) { - if (thd72tuningstep[tsinx] >= ts) { - thd72_set_freq_item(rig, vfo, 16, tsinx); - return RIG_OK; - } + for (tsinx = 0; tsinx < 10; tsinx++) + { + if (thd72tuningstep[tsinx] >= ts) + { + thd72_set_freq_item(rig, vfo, 16, tsinx); + return RIG_OK; } - return -RIG_EINVAL; + } + + return -RIG_EINVAL; } static int thd72_get_ts(RIG *rig, vfo_t vfo, shortfreq_t *ts) { - int retval, tsinx; + int retval, tsinx; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = thd72_get_freq_item(rig, vfo, 16, 9, &tsinx); - if (retval != RIG_OK) - return retval; - *ts = thd72tuningstep[tsinx]; - return RIG_OK; + retval = thd72_get_freq_item(rig, vfo, 16, 9, &tsinx); + + if (retval != RIG_OK) + { + return retval; + } + + *ts = thd72tuningstep[tsinx]; + return RIG_OK; } static int thd72_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone) { - int retval, tinx; - char buf[64], tmp[4]; + int retval, tinx; + char buf[64], tmp[4]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - tinx = 0; /* default */ - if (tone != 0) { - for (tinx = 0; tinx < 42; tinx++) { - if (tone == kenwood42_ctcss_list[tinx]) - break; - } - if (tinx >= 42) - return -RIG_EINVAL; + tinx = 0; /* default */ + + if (tone != 0) + { + for (tinx = 0; tinx < 42; tinx++) + { + if (tone == kenwood42_ctcss_list[tinx]) + { + break; + } } - retval = thd72_get_freq_info(rig, vfo, buf); - if (retval != RIG_OK) - return retval; - buf[22] = (tone == 0) ? '0' : '1'; - sprintf(tmp, "%02d", tinx); - memcpy(buf+30, tmp, 2); - return kenwood_simple_transaction(rig, buf, 52); + + if (tinx >= 42) + { + return -RIG_EINVAL; + } + } + + retval = thd72_get_freq_info(rig, vfo, buf); + + if (retval != RIG_OK) + { + return retval; + } + + buf[22] = (tone == 0) ? '0' : '1'; + sprintf(tmp, "%02d", tinx); + memcpy(buf + 30, tmp, 2); + return kenwood_simple_transaction(rig, buf, 52); } static int thd72_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone) { - int retval, tinx; - char buf[64]; + int retval, tinx; + char buf[64]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = thd72_get_freq_info(rig, vfo, buf); - if (retval != RIG_OK) - return retval; - if (buf[22] == '0') /* no tone */ - *tone = 0; - else { - sscanf(buf+30, "%d", &tinx); - if (tinx >= 0 && tinx <= 41) - *tone = kenwood42_ctcss_list[tinx]; - else - return -RIG_EINVAL; + retval = thd72_get_freq_info(rig, vfo, buf); + + if (retval != RIG_OK) + { + return retval; + } + + if (buf[22] == '0') /* no tone */ + { + *tone = 0; + } + else + { + sscanf(buf + 30, "%d", &tinx); + + if (tinx >= 0 && tinx <= 41) + { + *tone = kenwood42_ctcss_list[tinx]; } - return RIG_OK; + else + { + return -RIG_EINVAL; + } + } + + return RIG_OK; } static int thd72_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code) { - int retval, cinx; - char buf[64], tmp[4]; + int retval, cinx; + char buf[64], tmp[4]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - cinx = 0; /* default */ - if (code != 0) { - for (cinx = 0; cinx < 104; cinx++) { - if (code == thd72dcs_list[cinx]) - break; - } - if (cinx >= 104) - return -RIG_EINVAL; + cinx = 0; /* default */ + + if (code != 0) + { + for (cinx = 0; cinx < 104; cinx++) + { + if (code == thd72dcs_list[cinx]) + { + break; + } } - retval = thd72_get_freq_info(rig, vfo, buf); - if (retval != RIG_OK) - return retval; - buf[26] = (code == 0) ? '0' : '1'; - sprintf(tmp, "%03d", cinx); - memcpy(buf+36, tmp, 3); - return kenwood_simple_transaction(rig, buf, 52); + + if (cinx >= 104) + { + return -RIG_EINVAL; + } + } + + retval = thd72_get_freq_info(rig, vfo, buf); + + if (retval != RIG_OK) + { + return retval; + } + + buf[26] = (code == 0) ? '0' : '1'; + sprintf(tmp, "%03d", cinx); + memcpy(buf + 36, tmp, 3); + return kenwood_simple_transaction(rig, buf, 52); } static int thd72_get_dcs_code(RIG *rig, vfo_t vfo, tone_t *code) { - int retval, cinx; - char buf[64]; + int retval, cinx; + char buf[64]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = thd72_get_freq_info(rig, vfo, buf); - if (retval != RIG_OK) - return retval; - if (buf[26] == '0') /* no tone */ - *code = 0; - else { - sscanf(buf+36, "%d", &cinx); - *code = thd72dcs_list[cinx]; - } - return RIG_OK; + retval = thd72_get_freq_info(rig, vfo, buf); + + if (retval != RIG_OK) + { + return retval; + } + + if (buf[26] == '0') /* no tone */ + { + *code = 0; + } + else + { + sscanf(buf + 36, "%d", &cinx); + *code = thd72dcs_list[cinx]; + } + + return RIG_OK; } static int thd72_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone) { - int retval, tinx; - char buf[64], tmp[4]; + int retval, tinx; + char buf[64], tmp[4]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - tinx = 0; /* default */ - if (tone != 0) { - for (tinx = 0; tinx < 42; tinx++) { - if (tone == kenwood42_ctcss_list[tinx]) - break; - } - if (tinx >= 42) - return -RIG_EINVAL; + tinx = 0; /* default */ + + if (tone != 0) + { + for (tinx = 0; tinx < 42; tinx++) + { + if (tone == kenwood42_ctcss_list[tinx]) + { + break; + } } - retval = thd72_get_freq_info(rig, vfo, buf); - if (retval != RIG_OK) - return retval; - buf[24] = (tone == 0) ? '0' : '1'; - sprintf(tmp, "%02d", tinx); - memcpy(buf+33, tmp, 2); - return kenwood_simple_transaction(rig, buf, 52); + + if (tinx >= 42) + { + return -RIG_EINVAL; + } + } + + retval = thd72_get_freq_info(rig, vfo, buf); + + if (retval != RIG_OK) + { + return retval; + } + + buf[24] = (tone == 0) ? '0' : '1'; + sprintf(tmp, "%02d", tinx); + memcpy(buf + 33, tmp, 2); + return kenwood_simple_transaction(rig, buf, 52); } static int thd72_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone) { - int retval, tinx; - char buf[64]; + int retval, tinx; + char buf[64]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = thd72_get_freq_info(rig, vfo, buf); - if (retval != RIG_OK) - return retval; - if (buf[24] == '0') /* no tsql */ - *tone = 0; - else { - sscanf(buf+33, "%d", &tinx); - if (tinx >= 0 && tinx <= 41) - *tone = kenwood42_ctcss_list[tinx]; - else - return -RIG_EINVAL; + retval = thd72_get_freq_info(rig, vfo, buf); + + if (retval != RIG_OK) + { + return retval; + } + + if (buf[24] == '0') /* no tsql */ + { + *tone = 0; + } + else + { + sscanf(buf + 33, "%d", &tinx); + + if (tinx >= 0 && tinx <= 41) + { + *tone = kenwood42_ctcss_list[tinx]; } - return RIG_OK; + else + { + return -RIG_EINVAL; + } + } + + return RIG_OK; } static int thd72_get_menu_info(RIG *rig, char *buf) { - int retval; + int retval; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = kenwood_transaction(rig, "MU", buf, 41); - if (retval != RIG_OK) - return retval; - if (strlen(buf) != 40) - return -RIG_ERJCTED; - return RIG_OK; + retval = kenwood_transaction(rig, "MU", buf, 41); + + if (retval != RIG_OK) + { + return retval; + } + + if (strlen(buf) != 40) + { + return -RIG_ERJCTED; + } + + return RIG_OK; } /* each menu item is a single hex digit */ -static int thd72_get_menu_item(RIG* rig, int item, int hi, int *val) +static int thd72_get_menu_item(RIG *rig, int item, int hi, int *val) { - int retval, lval; - char c, buf[48]; + int retval, lval; + char c, buf[48]; - retval = thd72_get_menu_info(rig, buf); - if (retval != RIG_OK) - return retval; - c = buf[3 + 2*item]; /* "MU 0,1,2 ... */ - if (c >= '0' && c <= '9') lval = c - '0'; - else if (c >= 'A' && c <= 'F') lval = c - 'A' + 10; - else - return -RIG_EPROTO; - if (lval > hi) - return -RIG_EPROTO; - *val = lval; - return RIG_OK; + retval = thd72_get_menu_info(rig, buf); + + if (retval != RIG_OK) + { + return retval; + } + + c = buf[3 + 2 * item]; /* "MU 0,1,2 ... */ + + if (c >= '0' && c <= '9') { lval = c - '0'; } + else if (c >= 'A' && c <= 'F') { lval = c - 'A' + 10; } + else + { + return -RIG_EPROTO; + } + + if (lval > hi) + { + return -RIG_EPROTO; + } + + *val = lval; + return RIG_OK; } -static int thd72_set_menu_item(RIG* rig, int item, int val) +static int thd72_set_menu_item(RIG *rig, int item, int val) { - int retval; - char c, buf[48]; + int retval; + char c, buf[48]; - retval = thd72_get_menu_info(rig, buf); - if (retval != RIG_OK) - return retval; - if (val < 10) c = val + '0'; - else c = val - 10 + 'A'; - buf[3 + 2*item] = c; - return kenwood_simple_transaction(rig, buf, 40); + retval = thd72_get_menu_info(rig, buf); + + if (retval != RIG_OK) + { + return retval; + } + + if (val < 10) { c = val + '0'; } + else { c = val - 10 + 'A'; } + + buf[3 + 2 * item] = c; + return kenwood_simple_transaction(rig, buf, 40); } static int thd72_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) { - int retval, lvl; - char c, lvlc, cmd[10]; + int retval, lvl; + char c, lvlc, cmd[10]; - rig_debug(RIG_DEBUG_TRACE, "%s: called VFO=%s, level=%s, val=%g\n", __func__, rig_strvfo(vfo), rig_strlevel(level), val.f); + rig_debug(RIG_DEBUG_TRACE, "%s: called VFO=%s, level=%s, val=%g\n", __func__, + rig_strvfo(vfo), rig_strlevel(level), val.f); - retval = thd72_vfoc(rig, vfo, &c); - if (retval != RIG_OK) - return retval; - switch (level) { - case RIG_LEVEL_RFPOWER: - if (val.f <= 0.01) lvlc = '2'; - else if (val.f <= 0.10) lvlc = '1'; - else lvlc = '0'; - sprintf(cmd, "PC %c,%c", c, lvlc); - return kenwood_simple_transaction(rig, cmd, 6); - case RIG_LEVEL_VOXGAIN: - return thd72_set_menu_item(rig, 8, (int)(val.f*10.0 - 0.5)); - case RIG_LEVEL_VOXDELAY: - if (val.i > 20000) lvl = 6; - else if (val.i > 10000) lvl = val.i/10000 + 3; - else lvl = val.i/2500; - return thd72_set_menu_item(rig, 9, lvl); - case RIG_LEVEL_SQL: - lvlc = '0' + (int)(val.f*5); - sprintf(cmd, "PC %c,%c", c, lvlc); - return kenwood_simple_transaction(rig, cmd, 6); - case RIG_LEVEL_BALANCE: - /* FIXME - is balance 0.0 .. 1.0 or -1.0 .. 1.0? */ - lvl = (int)(val.f*4.0); - return thd72_set_menu_item(rig, 13, lvl); - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Level %d\n", __func__, level); - return -RIG_EINVAL; - } + retval = thd72_vfoc(rig, vfo, &c); + + if (retval != RIG_OK) + { return retval; + } + + switch (level) + { + case RIG_LEVEL_RFPOWER: + if (val.f <= 0.01) { lvlc = '2'; } + else if (val.f <= 0.10) { lvlc = '1'; } + else { lvlc = '0'; } + + sprintf(cmd, "PC %c,%c", c, lvlc); + return kenwood_simple_transaction(rig, cmd, 6); + + case RIG_LEVEL_VOXGAIN: + return thd72_set_menu_item(rig, 8, (int)(val.f * 10.0 - 0.5)); + + case RIG_LEVEL_VOXDELAY: + if (val.i > 20000) { lvl = 6; } + else if (val.i > 10000) { lvl = val.i / 10000 + 3; } + else { lvl = val.i / 2500; } + + return thd72_set_menu_item(rig, 9, lvl); + + case RIG_LEVEL_SQL: + lvlc = '0' + (int)(val.f * 5); + sprintf(cmd, "PC %c,%c", c, lvlc); + return kenwood_simple_transaction(rig, cmd, 6); + + case RIG_LEVEL_BALANCE: + /* FIXME - is balance 0.0 .. 1.0 or -1.0 .. 1.0? */ + lvl = (int)(val.f * 4.0); + return thd72_set_menu_item(rig, 13, lvl); + + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Level %d\n", __func__, level); + return -RIG_EINVAL; + } + + return retval; } static int thd72_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) { - int retval, v, l; - char c, cmd[10], buf[48]; + int retval, v, l; + char c, cmd[10], buf[48]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + + retval = thd72_vfoc(rig, vfo, &c); + + if (retval != RIG_OK) + { + return retval; + } + + switch (level) + { + case RIG_LEVEL_RFPOWER: + sprintf(cmd, "PC %c", c); + retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); - retval = thd72_vfoc(rig, vfo, &c); if (retval != RIG_OK) - return retval; - switch (level) { - case RIG_LEVEL_RFPOWER: - sprintf(cmd, "PC %c", c); - retval = kenwood_transaction(rig, cmd, buf, sizeof (buf)); - if (retval != RIG_OK) - return retval; - retval = sscanf(buf, "PC %d,%d", &v, &l); - if (retval != 2 || l < 0 || l > 3) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf); - return -RIG_ERJCTED; - } - switch (l) { - case 0: val->f = 1.00; break; /* 5.0 W */ - case 1: val->f = 0.10; break; /* 500 mW */ - case 2: val->f = 0.01; break; /* 50 mW */ - } - break; - case RIG_LEVEL_VOXGAIN: - retval = thd72_get_menu_item(rig, 8, 9, &l); - if (retval != RIG_OK) - return retval; - /* FIXME - if VOX is off, what do we return */ - val->f = l / 9.0; - break; - case RIG_LEVEL_VOXDELAY: - retval = thd72_get_menu_item(rig, 9, 7, &l); - if (retval != RIG_OK) - return retval; - /* FIXME - if VOX is off, what do we return */ - val->i = thd72voxdelay[l]; - break; - case RIG_LEVEL_SQL: - sprintf(cmd, "SQ %c", c); - retval = kenwood_transaction(rig, cmd, buf, sizeof (buf)); - if (retval != RIG_OK) - return retval; - retval = sscanf(buf, "SQ %d,%d", &v, &l); - if (retval != 2 || l < 0 || l > 6) { - rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf); - return -RIG_ERJCTED; - } - val->f = thd72sqlevel[l]; - break; - case RIG_LEVEL_BALANCE: - retval = thd72_get_menu_item(rig, 13, 4, &l); - if (retval != RIG_OK) - return retval; - /* FIXME - is balance 0.0 .. 1.0 or -1.0 .. 1.0? */ - val->f = (float)(l)/4.0; - break; - default: - rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Level %d\n", __func__, level); - return -RIG_EINVAL; - } - return RIG_OK; + { + return retval; + } + + retval = sscanf(buf, "PC %d,%d", &v, &l); + + if (retval != 2 || l < 0 || l > 3) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf); + return -RIG_ERJCTED; + } + + switch (l) + { + case 0: val->f = 1.00; break; /* 5.0 W */ + + case 1: val->f = 0.10; break; /* 500 mW */ + + case 2: val->f = 0.01; break; /* 50 mW */ + } + + break; + + case RIG_LEVEL_VOXGAIN: + retval = thd72_get_menu_item(rig, 8, 9, &l); + + if (retval != RIG_OK) + { + return retval; + } + + /* FIXME - if VOX is off, what do we return */ + val->f = l / 9.0; + break; + + case RIG_LEVEL_VOXDELAY: + retval = thd72_get_menu_item(rig, 9, 7, &l); + + if (retval != RIG_OK) + { + return retval; + } + + /* FIXME - if VOX is off, what do we return */ + val->i = thd72voxdelay[l]; + break; + + case RIG_LEVEL_SQL: + sprintf(cmd, "SQ %c", c); + retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); + + if (retval != RIG_OK) + { + return retval; + } + + retval = sscanf(buf, "SQ %d,%d", &v, &l); + + if (retval != 2 || l < 0 || l > 6) + { + rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf); + return -RIG_ERJCTED; + } + + val->f = thd72sqlevel[l]; + break; + + case RIG_LEVEL_BALANCE: + retval = thd72_get_menu_item(rig, 13, 4, &l); + + if (retval != RIG_OK) + { + return retval; + } + + /* FIXME - is balance 0.0 .. 1.0 or -1.0 .. 1.0? */ + val->f = (float)(l) / 4.0; + break; + + default: + rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Level %d\n", __func__, level); + return -RIG_EINVAL; + } + + return RIG_OK; } static int thd72_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) { - int retval; - char c; + int retval; + char c; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - switch (func) { - case RIG_FUNC_AIP: - retval = thd72_vfoc(rig, vfo, &c); - if (retval != RIG_OK) - return retval; - return thd72_set_menu_item(rig, c == '0'?5:6, status); - case RIG_FUNC_ARO: - return thd72_set_menu_item(rig, 18, status); - case RIG_FUNC_TONE: - return thd72_set_freq_item(rig, vfo, 22, status); - case RIG_FUNC_TSQL: - return thd72_set_freq_item(rig, vfo, 24, status); - default: - return -RIG_EINVAL; + switch (func) + { + case RIG_FUNC_AIP: + retval = thd72_vfoc(rig, vfo, &c); + + if (retval != RIG_OK) + { + return retval; } - return RIG_OK; + + return thd72_set_menu_item(rig, c == '0' ? 5 : 6, status); + + case RIG_FUNC_ARO: + return thd72_set_menu_item(rig, 18, status); + + case RIG_FUNC_TONE: + return thd72_set_freq_item(rig, vfo, 22, status); + + case RIG_FUNC_TSQL: + return thd72_set_freq_item(rig, vfo, 24, status); + + default: + return -RIG_EINVAL; + } + + return RIG_OK; } static int thd72_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) { - int retval, f; - char c; + int retval, f; + char c; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + + switch (func) + { + case RIG_FUNC_AIP: + retval = thd72_vfoc(rig, vfo, &c); - switch (func) { - case RIG_FUNC_AIP: - retval = thd72_vfoc(rig, vfo, &c); - if (retval != RIG_OK) - return retval; - retval = thd72_get_menu_item(rig, c == '0'?5:6, 1, &f); - break; - case RIG_FUNC_ARO: - retval = thd72_get_menu_item(rig, 18, 1, &f); - break; - case RIG_FUNC_TONE: - retval = thd72_get_freq_item(rig, vfo, 22, 1, &f); - break; - case RIG_FUNC_TSQL: - retval = thd72_get_freq_item(rig, vfo, 24, 1, &f); - break; - default: - retval = -RIG_EINVAL; - } if (retval != RIG_OK) - return retval; - *status = f; - return RIG_OK; + { + return retval; + } + + retval = thd72_get_menu_item(rig, c == '0' ? 5 : 6, 1, &f); + break; + + case RIG_FUNC_ARO: + retval = thd72_get_menu_item(rig, 18, 1, &f); + break; + + case RIG_FUNC_TONE: + retval = thd72_get_freq_item(rig, vfo, 22, 1, &f); + break; + + case RIG_FUNC_TSQL: + retval = thd72_get_freq_item(rig, vfo, 24, 1, &f); + break; + + default: + retval = -RIG_EINVAL; + } + + if (retval != RIG_OK) + { + return retval; + } + + *status = f; + return RIG_OK; } static int thd72_set_parm(RIG *rig, setting_t parm, value_t val) { - int l; + int l; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - switch (parm) { - case RIG_PARM_APO: - if (val.i == 0) l = 0; - else if (val.i <= 15) l = 1; - else if (val.i <= 30) l = 2; - else l = 3; - return thd72_set_menu_item(rig, 3, l); - case RIG_PARM_TIME: - default: - return -RIG_EINVAL; - } - return RIG_OK; + switch (parm) + { + case RIG_PARM_APO: + if (val.i == 0) { l = 0; } + else if (val.i <= 15) { l = 1; } + else if (val.i <= 30) { l = 2; } + else { l = 3; } + + return thd72_set_menu_item(rig, 3, l); + + case RIG_PARM_TIME: + default: + return -RIG_EINVAL; + } + + return RIG_OK; } static int thd72_get_parm(RIG *rig, setting_t parm, value_t *val) { - int retval, l, hh, mm, ss; - char buf[48]; + int retval, l, hh, mm, ss; + char buf[48]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - switch (parm) { - case RIG_PARM_APO: - retval = thd72_get_menu_item(rig, 3, 3, &l); - if (retval != RIG_OK) - return retval; - val->i = thd72apo[l]; - break; - case RIG_PARM_TIME: - retval = kenwood_transaction(rig, "RT", buf, sizeof (buf)); - if (retval != RIG_OK) - return retval; - sscanf(buf+11, "%2d%2d%2d", &hh, &mm, &ss); - val->i = ss + 60*(mm + 60*hh); - break; - default: - return -RIG_EINVAL; + switch (parm) + { + case RIG_PARM_APO: + retval = thd72_get_menu_item(rig, 3, 3, &l); + + if (retval != RIG_OK) + { + return retval; } - return RIG_OK; + + val->i = thd72apo[l]; + break; + + case RIG_PARM_TIME: + retval = kenwood_transaction(rig, "RT", buf, sizeof(buf)); + + if (retval != RIG_OK) + { + return retval; + } + + sscanf(buf + 11, "%2d%2d%2d", &hh, &mm, &ss); + val->i = ss + 60 * (mm + 60 * hh); + break; + + default: + return -RIG_EINVAL; + } + + return RIG_OK; } static int thd72_set_mem(RIG *rig, vfo_t vfo, int ch) { - int retval; - char c, cmd[10]; + int retval; + char c, cmd[10]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = thd72_vfoc(rig, vfo, &c); - if (retval != RIG_OK) -return retval; - sprintf(cmd, "MR %c,%03d", c, ch); - return kenwood_simple_transaction(rig, cmd, 10); + retval = thd72_vfoc(rig, vfo, &c); + + if (retval != RIG_OK) + { + return retval; + } + + sprintf(cmd, "MR %c,%03d", c, ch); + return kenwood_simple_transaction(rig, cmd, 10); } static int thd72_get_mem(RIG *rig, vfo_t vfo, int *ch) { - int retval; - char c, cmd[10], buf[10]; + int retval; + char c, cmd[10], buf[10]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - retval = thd72_vfoc(rig, vfo, &c); - if (retval != RIG_OK) - return retval; - sprintf(cmd, "MR %c", c); - retval = kenwood_transaction(rig, cmd, buf, sizeof (buf)); - if (retval != RIG_OK) - return retval; - sscanf(buf+5, "%d", ch); - return RIG_OK; + retval = thd72_vfoc(rig, vfo, &c); + + if (retval != RIG_OK) + { + return retval; + } + + sprintf(cmd, "MR %c", c); + retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); + + if (retval != RIG_OK) + { + return retval; + } + + sscanf(buf + 5, "%d", ch); + return RIG_OK; } static int thd72_set_channel(RIG *rig, const channel_t *chan) { - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - return -RIG_EINVAL; + return -RIG_EINVAL; } static int thd72_parse_channel(int kind, const char *buf, channel_t *chan) { - int tmp; - char c; - const char *data; + int tmp; + char c; + const char *data; - if (kind == 0) data = buf+5; else data = buf+7; - sscanf(data, "%"SCNfreq, &chan->freq); - c = data[46]; // mode - if (c >= '0' && c <= '2') { - chan->mode = thd72_mode_table[c - '0']; - chan->width = thd72_width_table[c - '0']; + if (kind == 0) { data = buf + 5; } + else { data = buf + 7; } + + sscanf(data, "%"SCNfreq, &chan->freq); + c = data[46]; // mode + + if (c >= '0' && c <= '2') + { + chan->mode = thd72_mode_table[c - '0']; + chan->width = thd72_width_table[c - '0']; + } + + c = data[11]; // tuning step + + if (c >= '0' && c <= '9') + { + chan->tuning_step = thd72tuningstep[c - '0']; + } + + c = data[13]; // repeater shift + + if (c >= '0' && c <= '2') + { + chan->rptr_shift = thd72_rshf_table[c - '0']; + } + + sscanf(data + 37, "%ld", &chan->rptr_offs); + c = data[17]; // Tone status + + if (c != '0') + { + sscanf(data + 25, "%d", &tmp); + + if (tmp > 0 && tmp < 42) + { + chan->ctcss_tone = kenwood42_ctcss_list[tmp]; } - c = data[11]; // tuning step - if (c >= '0' && c <= '9') - chan->tuning_step = thd72tuningstep[c - '0']; - c = data[13]; // repeater shift - if (c >= '0' && c <= '2') - chan->rptr_shift = thd72_rshf_table[c - '0']; - sscanf(data+37, "%ld", &chan->rptr_offs); - c = data[17]; // Tone status - if (c != '0') { - sscanf(data+25, "%d", &tmp); - if (tmp > 0 && tmp < 42) - chan->ctcss_tone = kenwood42_ctcss_list[tmp]; - } else - chan->ctcss_tone = 0; - c = data[19]; // TSQL status - if (c != '0') { - sscanf(data+28, "%d", &tmp); - if (tmp > 0 && tmp < 42) - chan->ctcss_sql = kenwood42_ctcss_list[tmp]; - } else - chan->ctcss_sql = 0; - c = data[21]; // DCS status - if (c != '0') { - sscanf(data+31, "%d", &tmp); - chan->dcs_code = tmp; - } else - chan->dcs_code = 0; - return RIG_OK; + } + else + { + chan->ctcss_tone = 0; + } + + c = data[19]; // TSQL status + + if (c != '0') + { + sscanf(data + 28, "%d", &tmp); + + if (tmp > 0 && tmp < 42) + { + chan->ctcss_sql = kenwood42_ctcss_list[tmp]; + } + } + else + { + chan->ctcss_sql = 0; + } + + c = data[21]; // DCS status + + if (c != '0') + { + sscanf(data + 31, "%d", &tmp); + chan->dcs_code = tmp; + } + else + { + chan->dcs_code = 0; + } + + return RIG_OK; } static int thd72_get_channel(RIG *rig, channel_t *chan) { - int retval, len; - char cmd[8], buf[72]; + int retval, len; + char cmd[8], buf[72]; - rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); + rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - if (chan->vfo == RIG_VFO_MEM) { /* memory channel */ - sprintf(cmd, "ME %03d", chan->channel_num); - retval = kenwood_transaction(rig, cmd, buf, sizeof (buf)); - if (retval != RIG_OK) - return retval; - retval = thd72_parse_channel(1, buf, chan); - if (retval != RIG_OK) - return retval; - cmd[1] = 'N'; /* change ME to MN */ - retval = kenwood_transaction(rig, cmd, buf, sizeof (buf)); - if (retval != RIG_OK) - return retval; - len = strlen(buf); - memcpy(chan->channel_desc, buf+7, len-7); - } else { /* current channel */ - retval = thd72_get_freq_info(rig, chan->vfo, buf); - if (retval != RIG_OK) - return retval; - return thd72_parse_channel(0, buf, chan); + if (chan->vfo == RIG_VFO_MEM) /* memory channel */ + { + sprintf(cmd, "ME %03d", chan->channel_num); + retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); + + if (retval != RIG_OK) + { + return retval; } - return RIG_OK; + + retval = thd72_parse_channel(1, buf, chan); + + if (retval != RIG_OK) + { + return retval; + } + + cmd[1] = 'N'; /* change ME to MN */ + retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); + + if (retval != RIG_OK) + { + return retval; + } + + len = strlen(buf); + memcpy(chan->channel_desc, buf + 7, len - 7); + } + else /* current channel */ + { + retval = thd72_get_freq_info(rig, chan->vfo, buf); + + if (retval != RIG_OK) + { + return retval; + } + + return thd72_parse_channel(0, buf, chan); + } + + return RIG_OK; } -#ifdef false /* not working */ +#ifdef false /* not working */ #define CMD_SZ 5 #define BLOCK_SZ 256 #define BLOCK_COUNT 256 #define CHAN_PER_BLOCK 4 -static int thd72_get_block (RIG *rig, int block_num, char *block) +static int thd72_get_block(RIG *rig, int block_num, char *block) { - hamlib_port_t *rp = &rig->state.rigport; - char cmd[CMD_SZ] = "R\0\0\0\0"; - char resp[CMD_SZ]; - int ret; + hamlib_port_t *rp = &rig->state.rigport; + char cmd[CMD_SZ] = "R\0\0\0\0"; + char resp[CMD_SZ]; + int ret; - /* fetching block i */ - cmd[2] = block_num & 0xff; + /* fetching block i */ + cmd[2] = block_num & 0xff; - ret = write_block(rp, cmd, CMD_SZ); - if (ret != RIG_OK) - return ret; + ret = write_block(rp, cmd, CMD_SZ); - /* read response first */ - ret = read_block(rp, resp, CMD_SZ); - if (ret != CMD_SZ) - return ret; + if (ret != RIG_OK) + { + return ret; + } - if (resp[0] != 'W' || memcmp(cmd+1, resp+1, CMD_SZ-1)) - return -RIG_EPROTO; + /* read response first */ + ret = read_block(rp, resp, CMD_SZ); - /* read block */ - ret = read_block(rp, block, BLOCK_SZ); - if (ret != BLOCK_SZ) - return ret; + if (ret != CMD_SZ) + { + return ret; + } - ret = write_block(rp, "\006", 1); - if (ret != RIG_OK) - return ret; + if (resp[0] != 'W' || memcmp(cmd + 1, resp + 1, CMD_SZ - 1)) + { + return -RIG_EPROTO; + } - ret = read_block(rp, resp, 1); - if (ret != 1) - return ret; + /* read block */ + ret = read_block(rp, block, BLOCK_SZ); - if (resp[0] != 0x06) - return -RIG_EPROTO; + if (ret != BLOCK_SZ) + { + return ret; + } - return RIG_OK; + ret = write_block(rp, "\006", 1); + + if (ret != RIG_OK) + { + return ret; + } + + ret = read_block(rp, resp, 1); + + if (ret != 1) + { + return ret; + } + + if (resp[0] != 0x06) + { + return -RIG_EPROTO; + } + + return RIG_OK; } -int thd72_get_chan_all_cb (RIG * rig, chan_cb_t chan_cb, rig_ptr_t arg) +int thd72_get_chan_all_cb(RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg) { - int i, j, ret; - hamlib_port_t *rp = &rig->state.rigport; - channel_t *chan; - chan_t *chan_list = rig->state.chan_list; - int chan_next = chan_list[0].start; - char block[BLOCK_SZ]; - char resp[CMD_SZ]; + int i, j, ret; + hamlib_port_t *rp = &rig->state.rigport; + channel_t *chan; + chan_t *chan_list = rig->state.chan_list; + int chan_next = chan_list[0].start; + char block[BLOCK_SZ]; + char resp[CMD_SZ]; + + ret = kenwood_transaction(rig, "0M PROGRAM", resp, CMD_SZ); + + if (ret != RIG_OK) + { + return ret; + } + + if (strlen(resp) != 2 || memcmp(resp, "0M", 2)) + { + return -RIG_EPROTO; + } + + rp->parm.serial.rate = 57600; + serial_setup(rp); + + + usleep(100 * 1000); /* let the pcr settle */ + serial_flush(rp); /* flush any remaining data */ + ret = ser_set_rts(rp, 1); /* setRTS or Hardware flow control? */ + + if (ret != RIG_OK) + { + return ret; + } + + /* + * setting chan to NULL means the application + * has to provide a struct where to store data + * future data for channel channel_num + */ + chan = NULL; + ret = chan_cb(rig, &chan, chan_next, chan_list, arg); + + if (ret != RIG_OK) + { + return ret; + } + + if (chan == NULL) + { + return -RIG_ENOMEM; + } + + for (i = 0; i < BLOCK_COUNT; i++) + { + + ret = thd72_get_block(rig, i, block); - ret = kenwood_transaction(rig, "0M PROGRAM", resp, CMD_SZ); if (ret != RIG_OK) - return ret; - if (strlen(resp) != 2 || memcmp(resp, "0M", 2)) - return -RIG_EPROTO; - - rp->parm.serial.rate = 57600; - serial_setup(rp); - - - usleep(100*1000); /* let the pcr settle */ - serial_flush(rp); /* flush any remaining data */ - ret = ser_set_rts(rp, 1); /* setRTS or Hardware flow control? */ - if (ret != RIG_OK) - return ret; - /* - * setting chan to NULL means the application - * has to provide a struct where to store data - * future data for channel channel_num - */ - chan = NULL; - ret = chan_cb(rig, &chan, chan_next, chan_list, arg); - if (ret != RIG_OK) - return ret; - if (chan == NULL) - return -RIG_ENOMEM; - - for (i=0; ivfo = RIG_VFO_MEM; - chan->channel_num = i*CHAN_PER_BLOCK + j; - - /* What are the extra 64 channels ? */ - if (chan->channel_num >= 1000) - break; - - /* non-empty channel ? */ - // if (block_chan[0] != 0xff) { - // since block_chan is *signed* char, this maps to -1 - if (block_chan[0] != -1) { - - memcpy(chan->channel_desc, block_chan, 8); - /* TODO: chop off trailing chars */ - chan->channel_desc[8] = '\0'; - - /* TODO: parse block and fill in chan */ - } - - /* notify the end? */ - chan_next = chan_next < chan_list[i].end ? chan_next+1 : chan_next; - - /* - * provide application with channel data, - * and ask for a new channel structure - */ - chan_cb(rig, &chan, chan_next, chan_list, arg); - } + { + return ret; } - ret = write_block(rp, "E", 1); - if (ret != RIG_OK) - return ret; + /* + * Most probably, there's 64 bytes per channel (256*256 / 1000+) + */ + for (j = 0; j < CHAN_PER_BLOCK; j++) + { + char *block_chan = block + j * (BLOCK_SZ / CHAN_PER_BLOCK); + memset(chan, 0, sizeof(channel_t)); + chan->vfo = RIG_VFO_MEM; + chan->channel_num = i * CHAN_PER_BLOCK + j; - ret = read_block(rp, resp, 1); - if (ret != 1) - return ret; + /* What are the extra 64 channels ? */ + if (chan->channel_num >= 1000) + { + break; + } - if (resp[0] != 0x06) { - return -RIG_EPROTO; + /* non-empty channel ? */ + // if (block_chan[0] != 0xff) { + // since block_chan is *signed* char, this maps to -1 + if (block_chan[0] != -1) + { + + memcpy(chan->channel_desc, block_chan, 8); + /* TODO: chop off trailing chars */ + chan->channel_desc[8] = '\0'; + + /* TODO: parse block and fill in chan */ + } + + /* notify the end? */ + chan_next = chan_next < chan_list[i].end ? chan_next + 1 : chan_next; + + /* + * provide application with channel data, + * and ask for a new channel structure + */ + chan_cb(rig, &chan, chan_next, chan_list, arg); } + } - /* setRTS?? getCTS needed? */ - ret = ser_set_rts(rp, 1); - if (ret != RIG_OK) - return ret; + ret = write_block(rp, "E", 1); - return RIG_OK; + if (ret != RIG_OK) + { + return ret; + } + + ret = read_block(rp, resp, 1); + + if (ret != 1) + { + return ret; + } + + if (resp[0] != 0x06) + { + return -RIG_EPROTO; + } + + /* setRTS?? getCTS needed? */ + ret = ser_set_rts(rp, 1); + + if (ret != RIG_OK) + { + return ret; + } + + return RIG_OK; } -#endif /* none working stuff */ +#endif /* none working stuff */ /* * th-d72a rig capabilities. */ -const struct rig_caps thd72a_caps = { -.rig_model = RIG_MODEL_THD72A, -.model_name = "TH-D72A", -.mfg_name = "Kenwood", -.version = TH_VER ".2", -.copyright = "LGPL", -.status = RIG_STATUS_BETA, -.rig_type = RIG_TYPE_HANDHELD|RIG_FLAG_APRS|RIG_FLAG_TNC|RIG_FLAG_DXCLUSTER, -.ptt_type = RIG_PTT_RIG, -.dcd_type = RIG_DCD_RIG, -.port_type = RIG_PORT_SERIAL, -.serial_rate_min = 9600, -.serial_rate_max = 9600, -.serial_data_bits = 8, -.serial_stop_bits = 1, -.serial_parity = RIG_PARITY_NONE, -.serial_handshake = RIG_HANDSHAKE_XONXOFF, -.write_delay = 0, -.post_write_delay = 0, -.timeout = 500, -.retry = 3, -.has_get_func = THD72_FUNC_ALL, -.has_set_func = THD72_FUNC_ALL, -.has_get_level = THD72_LEVEL_ALL, -.has_set_level = RIG_LEVEL_SET(THD72_LEVEL_ALL), -.has_get_parm = THD72_PARMS, -.has_set_parm = THD72_PARMS, /* FIXME: parms */ -.level_gran = { - [LVL_RAWSTR] = { .min = { .i = 0 }, .max = { .i = 5 } }, - [LVL_SQL] = { .min = { .i = 0 }, .max = { .i = 5 } }, - [LVL_RFPOWER] = { .min = { .i = 2 }, .max = { .i = 0 } }, -}, -.parm_gran = {}, -.ctcss_list = kenwood42_ctcss_list, -.dcs_list = thd72dcs_list, -.preamp = { RIG_DBLST_END, }, -.attenuator = { RIG_DBLST_END, }, -.max_rit = Hz(0), -.max_xit = Hz(0), -.max_ifshift = Hz(0), -.vfo_ops = THD72_VFO_OP, -.targetable_vfo = RIG_TARGETABLE_FREQ, -.transceive = RIG_TRN_RIG, -.bank_qty = 0, -.chan_desc_sz = 6, /* TBC */ -.chan_list = { - { 0, 999, RIG_MTYPE_MEM , {TH_CHANNEL_CAPS}}, /* TBC MEM */ +const struct rig_caps thd72a_caps = +{ + .rig_model = RIG_MODEL_THD72A, + .model_name = "TH-D72A", + .mfg_name = "Kenwood", + .version = TH_VER ".2", + .copyright = "LGPL", + .status = RIG_STATUS_BETA, + .rig_type = RIG_TYPE_HANDHELD | RIG_FLAG_APRS | RIG_FLAG_TNC | RIG_FLAG_DXCLUSTER, + .ptt_type = RIG_PTT_RIG, + .dcd_type = RIG_DCD_RIG, + .port_type = RIG_PORT_SERIAL, + .serial_rate_min = 9600, + .serial_rate_max = 9600, + .serial_data_bits = 8, + .serial_stop_bits = 1, + .serial_parity = RIG_PARITY_NONE, + .serial_handshake = RIG_HANDSHAKE_XONXOFF, + .write_delay = 0, + .post_write_delay = 0, + .timeout = 500, + .retry = 3, + .has_get_func = THD72_FUNC_ALL, + .has_set_func = THD72_FUNC_ALL, + .has_get_level = THD72_LEVEL_ALL, + .has_set_level = RIG_LEVEL_SET(THD72_LEVEL_ALL), + .has_get_parm = THD72_PARMS, + .has_set_parm = THD72_PARMS, /* FIXME: parms */ + .level_gran = { + [LVL_RAWSTR] = { .min = { .i = 0 }, .max = { .i = 5 } }, + [LVL_SQL] = { .min = { .i = 0 }, .max = { .i = 5 } }, + [LVL_RFPOWER] = { .min = { .i = 2 }, .max = { .i = 0 } }, + }, + .parm_gran = {}, + .ctcss_list = kenwood42_ctcss_list, + .dcs_list = thd72dcs_list, + .preamp = { RIG_DBLST_END, }, + .attenuator = { RIG_DBLST_END, }, + .max_rit = Hz(0), + .max_xit = Hz(0), + .max_ifshift = Hz(0), + .vfo_ops = THD72_VFO_OP, + .targetable_vfo = RIG_TARGETABLE_FREQ, + .transceive = RIG_TRN_RIG, + .bank_qty = 0, + .chan_desc_sz = 6, /* TBC */ + .chan_list = { + { 0, 999, RIG_MTYPE_MEM, {TH_CHANNEL_CAPS}}, /* TBC MEM */ RIG_CHAN_END, }, -.rx_range_list1 = { RIG_FRNG_END, }, /* FIXME: enter region 1 setting */ -.tx_range_list1 = { RIG_FRNG_END, }, -.rx_range_list2 = { - {MHz(118),MHz(174),THD72_MODES,-1,-1,THD72_VFO}, - {MHz(320),MHz(524),THD72_MODES,-1,-1,THD72_VFO}, + .rx_range_list1 = { RIG_FRNG_END, }, /* FIXME: enter region 1 setting */ + .tx_range_list1 = { RIG_FRNG_END, }, + .rx_range_list2 = { + {MHz(118), MHz(174), THD72_MODES, -1, -1, THD72_VFO}, + {MHz(320), MHz(524), THD72_MODES, -1, -1, THD72_VFO}, RIG_FRNG_END, }, -.tx_range_list2 = { - {MHz(144),MHz(148),THD72_MODES_TX,W(0.05),W(5),THD72_VFO}, - {MHz(430),MHz(440),THD72_MODES_TX,W(0.05),W(5),THD72_VFO}, + .tx_range_list2 = { + {MHz(144), MHz(148), THD72_MODES_TX, W(0.05), W(5), THD72_VFO}, + {MHz(430), MHz(440), THD72_MODES_TX, W(0.05), W(5), THD72_VFO}, RIG_FRNG_END, }, -.tuning_steps = { - {THD72_MODES,kHz(5)}, - {THD72_MODES,kHz(6.25)}, - {THD72_MODES,kHz(8.33)}, - {THD72_MODES,kHz(10)}, - {THD72_MODES,kHz(12.5)}, - {THD72_MODES,kHz(15)}, - {THD72_MODES,kHz(20)}, - {THD72_MODES,kHz(25)}, - {THD72_MODES,kHz(30)}, - {THD72_MODES,kHz(50)}, + .tuning_steps = { + {THD72_MODES, kHz(5)}, + {THD72_MODES, kHz(6.25)}, + {THD72_MODES, kHz(8.33)}, + {THD72_MODES, kHz(10)}, + {THD72_MODES, kHz(12.5)}, + {THD72_MODES, kHz(15)}, + {THD72_MODES, kHz(20)}, + {THD72_MODES, kHz(25)}, + {THD72_MODES, kHz(30)}, + {THD72_MODES, kHz(50)}, RIG_TS_END, }, - .filters = { /* mode/filter list, remember: order matters! */ + .filters = { /* mode/filter list, remember: order matters! */ {RIG_MODE_FM, kHz(14)}, {RIG_MODE_FMN, kHz(7)}, {RIG_MODE_AM, kHz(9)}, RIG_FLT_END, }, -.priv = (void *)&thd72_priv_caps, -.rig_init = kenwood_init, -.rig_cleanup = kenwood_cleanup, -.rig_open = thd72_open, -.set_freq = thd72_set_freq, -.get_freq = thd72_get_freq, -.set_mode = thd72_set_mode, -.get_mode = thd72_get_mode, -.set_vfo = thd72_set_vfo, -.get_vfo = thd72_get_vfo, -.set_rptr_shift = thd72_set_rptr_shft, -.get_rptr_shift = thd72_get_rptr_shft, -.set_rptr_offs = thd72_set_rptr_offs, -.get_rptr_offs = thd72_get_rptr_offs, -.set_ts = thd72_set_ts, -.get_ts = thd72_get_ts, -.set_ctcss_tone = thd72_set_ctcss_tone, -.get_ctcss_tone = thd72_get_ctcss_tone, -.set_dcs_code = thd72_set_dcs_code, -.get_dcs_code = thd72_get_dcs_code, -.set_ctcss_sql = thd72_set_ctcss_sql, -.get_ctcss_sql = thd72_get_ctcss_sql, -.set_level = thd72_set_level, -.get_level = thd72_get_level, -.set_func = thd72_set_func, -.get_func = thd72_get_func, -.set_parm = thd72_set_parm, -.get_parm = thd72_get_parm, -.set_mem = thd72_set_mem, -.get_mem = thd72_get_mem, -.set_channel = thd72_set_channel, -.get_channel = thd72_get_channel, -//.get_chan_all_cb = thd72_get_chan_all_cb, this doesn't work yet -.get_info = th_get_info, + .priv = (void *)& thd72_priv_caps, + .rig_init = kenwood_init, + .rig_cleanup = kenwood_cleanup, + .rig_open = thd72_open, + .set_freq = thd72_set_freq, + .get_freq = thd72_get_freq, + .set_mode = thd72_set_mode, + .get_mode = thd72_get_mode, + .set_vfo = thd72_set_vfo, + .get_vfo = thd72_get_vfo, + .set_rptr_shift = thd72_set_rptr_shft, + .get_rptr_shift = thd72_get_rptr_shft, + .set_rptr_offs = thd72_set_rptr_offs, + .get_rptr_offs = thd72_get_rptr_offs, + .set_ts = thd72_set_ts, + .get_ts = thd72_get_ts, + .set_ctcss_tone = thd72_set_ctcss_tone, + .get_ctcss_tone = thd72_get_ctcss_tone, + .set_dcs_code = thd72_set_dcs_code, + .get_dcs_code = thd72_get_dcs_code, + .set_ctcss_sql = thd72_set_ctcss_sql, + .get_ctcss_sql = thd72_get_ctcss_sql, + .set_level = thd72_set_level, + .get_level = thd72_get_level, + .set_func = thd72_set_func, + .get_func = thd72_get_func, + .set_parm = thd72_set_parm, + .get_parm = thd72_get_parm, + .set_mem = thd72_set_mem, + .get_mem = thd72_get_mem, + .set_channel = thd72_set_channel, + .get_channel = thd72_get_channel, +//.get_chan_all_cb = thd72_get_chan_all_cb, this doesn't work yet + .get_info = th_get_info, };