From 64d080af2ee694292c923475d04bd3d874eb25ac Mon Sep 17 00:00:00 2001 From: Bill Somerville Date: Wed, 24 Dec 2014 13:02:25 +0000 Subject: [PATCH] Removed kenwood_cmd function and replaced uses of it The function kenwood_cmd doesn't add value and it uses a reply buffer that is not required. Also the use of a reply buffer disables the verification of commands that have no reply feature. Substituted kenwood_simple_cmd calls that do the job correctly without a reply buffer. Added delay to busy retry loop when sending commands to rig. Implemented retries on wrong length repies from rig also with a delay. --- kenwood/kenwood.c | 66 ++++++++++++++++++++++++++++------------------- kenwood/kenwood.h | 19 +++----------- kenwood/th.c | 48 +++++++++++++++++----------------- kenwood/tmd710.c | 4 +-- kenwood/ts570.c | 14 +++++----- kenwood/ts870s.c | 1 + 6 files changed, 76 insertions(+), 76 deletions(-) diff --git a/kenwood/kenwood.c b/kenwood/kenwood.c index e6fcd3d17..01ff1fd71 100644 --- a/kenwood/kenwood.c +++ b/kenwood/kenwood.c @@ -205,6 +205,7 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, int cmd_len, int len; int retry_read = 0; int reply_expected = data && *datasize > 0; + size_t length = *datasize; static char const verify[] = "AI;"; /* command we can always send to any rig even when the rig is busy */ @@ -235,6 +236,8 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, int cmd_len, len++; } + *datasize = length; /* reset as may be a retry */ + serial_flush(&rs->rigport); retval = write_block(&rs->rigport, cmd, len); @@ -256,7 +259,7 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, int cmd_len, retval = read_string(&rs->rigport, priv->info, reply_expected ? *datasize : strlen (verify) + 2, cmdtrm, strlen(cmdtrm)); if (retval < 0) { - if (retry_read++ < rig->state.rigport.retry) + if (retry_read++ < rig->caps->retry) goto transaction_write; goto transaction_quit; } @@ -264,7 +267,7 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, int cmd_len, /* Check that command termination is correct */ if (strchr(cmdtrm, priv->info[strlen(priv->info)-1])==NULL) { rig_debug(RIG_DEBUG_ERR, "%s: Command is not correctly terminated '%s'\n", __func__, priv->info); - if (retry_read++ < rig->state.rigport.retry) + if (retry_read++ < rig->caps->retry) goto transaction_write; retval = -RIG_EPROTO; goto transaction_quit; @@ -280,22 +283,26 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, int cmd_len, case 'O': /* Too many characters sent without a carriage return */ rig_debug(RIG_DEBUG_VERBOSE, "%s: Overflow for '%s'\n", __func__, cmdstr); - if (retry_read++ < rig->state.rigport.retry) + if (retry_read++ < rig->caps->retry) goto transaction_write; retval = -RIG_EPROTO; goto transaction_quit; case 'E': /* Communication error */ rig_debug(RIG_DEBUG_VERBOSE, "%s: Communication error for '%s'\n", __func__, cmdstr); - if (retry_read++ < rig->state.rigport.retry) + if (retry_read++ < rig->caps->retry) goto transaction_write; retval = -RIG_EIO; goto transaction_quit; case '?': - /* Command not understood by rig */ - rig_debug(RIG_DEBUG_ERR, "%s: Unknown command '%s'\n", __func__, cmdstr); - if (retry_read++ < rig->state.rigport.retry) - goto transaction_write; + /* Command not understood by rig or rig busy */ + rig_debug(RIG_DEBUG_ERR, "%s: Unknown command or rig busy '%s'\n", __func__, cmdstr); + if (retry_read++ < rig->caps->retry) + { + rig_debug(RIG_DEBUG_ERR, "%s: Retrying shortly\n", __func__); + usleep (rig->caps->timeout * 1000); + goto transaction_write; + } retval = -RIG_ERJCTED; goto transaction_quit; } @@ -317,15 +324,13 @@ int kenwood_transaction(RIG *rig, const char *cmdstr, int cmd_len, rig_debug(RIG_DEBUG_ERR, "%s: wrong reply %c%c for command %c%c\n", __func__, priv->info[0], priv->info[1], cmdstr[0], cmdstr[1]); - if (retry_read++ < rig->state.rigport.retry) - goto transaction_write; + if (retry_read++ < rig->caps->retry) + goto transaction_write; - retval = -RIG_EPROTO; - goto transaction_quit; - } + retval = -RIG_EPROTO; + goto transaction_quit; + } - if (reply_expected) - { /* always give back a null terminated string without * the command terminator. */ @@ -368,26 +373,35 @@ int kenwood_safe_transaction(RIG *rig, const char *cmd, char *buf, { rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - if (!rig || !buf) + if (!rig || !cmd) return -RIG_EINVAL; int err; + int retry = 0; if (expected == 0) buf_size = 0; - err = kenwood_transaction(rig, cmd, strlen(cmd), buf, &buf_size); - if (err != RIG_OK) - return err; + do + { + size_t length = buf_size; + err = kenwood_transaction(rig, cmd, strlen(cmd), buf, &length); + if (err != RIG_OK) /* return immediately on error as any + retries handled at lower level */ + return err; - if (buf_size != expected) { - rig_debug(RIG_DEBUG_ERR, "%s: wrong answer; len for cmd %s: " - "expected = %d, got %d\n", - __func__, cmd, expected, buf_size); - return -RIG_EPROTO; - } + if (length != expected) /* worth retrying as some rigs + occasionally send short results */ + { + rig_debug(RIG_DEBUG_ERR, "%s: wrong answer; len for cmd %s: " + "expected = %d, got %d\n", + __func__, cmd, expected, length); + err = -RIG_EPROTO; + usleep (rig->caps->timeout * 1000); + } + } while (err != RIG_OK && ++retry < rig->caps->retry); - return RIG_OK; + return err; } rmode_t kenwood2rmode(unsigned char mode, const rmode_t mode_table[]) diff --git a/kenwood/kenwood.h b/kenwood/kenwood.h index 87f979691..b6efe508c 100644 --- a/kenwood/kenwood.h +++ b/kenwood/kenwood.h @@ -199,27 +199,14 @@ extern const struct rig_caps f6k_caps; /* use when not interested in the answer, but want to check its len */ static int inline kenwood_simple_transaction(RIG *rig, const char *cmd, size_t expected) { - char buf[20]; - return kenwood_safe_transaction(rig, cmd, buf, sizeof(buf), expected); + struct kenwood_priv_data *priv = rig->state.priv; + return kenwood_safe_transaction(rig, cmd, priv->info, KENWOOD_MAX_BUF_LEN, expected); } /* no answer needed at all */ static int inline kenwood_simple_cmd(RIG *rig, const char *cmd) { - char buf[20]; - return kenwood_safe_transaction(rig, cmd, buf, sizeof(buf), 0); -} - -/* answer is the same as the command */ -static int inline kenwood_cmd(RIG *rig, const char *cmd) -{ - char buf[20]; - int lenz = strlen(cmd)+1; - - if (lenz > sizeof(buf)) - return -RIG_ENOMEM; - else - return kenwood_safe_transaction(rig, cmd, buf, sizeof(buf), lenz); + return kenwood_safe_transaction(rig, cmd, NULL, 0, 0); } #endif /* _KENWOOD_H */ diff --git a/kenwood/th.c b/kenwood/th.c index 16e5a7d6d..1dd0d49e5 100644 --- a/kenwood/th.c +++ b/kenwood/th.c @@ -197,7 +197,7 @@ th_set_freq(RIG *rig, vfo_t vfo, freq_t freq) freq_sent = freq_sent >= MHz(470) ? (round(freq_sent/10000)*10000) : freq_sent; sprintf(buf, "FQ %011"PRIll",%X", (int64_t) freq_sent, step); - return kenwood_cmd(rig, buf); + return kenwood_simple_cmd(rig, buf); } /* @@ -270,7 +270,7 @@ th_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) sprintf(mdbuf, "MD %c", kmode); - retval = kenwood_cmd(rig, mdbuf); + retval = kenwood_simple_cmd(rig, mdbuf); if (retval != RIG_OK) return retval; @@ -403,7 +403,7 @@ th_set_vfo(RIG *rig, vfo_t vfo) return kenwood_wrong_vfo(__func__, vfo); } - return kenwood_cmd(rig, cmd); + return kenwood_simple_cmd(rig, cmd); } int @@ -548,7 +548,7 @@ int tm_set_vfo_bc2 (RIG *rig, vfo_t vfo) } sprintf(vfobuf, "VMC %d,%d", vfonum, vfomode); - retval = kenwood_cmd(rig, vfobuf); + retval = kenwood_simple_cmd(rig, vfobuf); if (retval != RIG_OK) return retval; @@ -556,7 +556,7 @@ int tm_set_vfo_bc2 (RIG *rig, vfo_t vfo) return RIG_OK; sprintf(vfobuf, "BC %d,%d", vfonum, txvfonum); - retval = kenwood_cmd(rig, vfobuf); + retval = kenwood_simple_cmd(rig, vfobuf); if (retval != RIG_OK) return retval; @@ -599,12 +599,12 @@ int th_set_split_vfo (RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo) /* Set VFO mode. To be done for TX vfo also? */ sprintf(vfobuf, "VMC %d,0", vfonum); - retval = kenwood_cmd(rig, vfobuf); + retval = kenwood_simple_cmd(rig, vfobuf); if (retval != RIG_OK) return retval; sprintf(vfobuf, "BC %d,%d", vfonum, txvfonum); - retval = kenwood_cmd(rig, vfobuf); + retval = kenwood_simple_cmd(rig, vfobuf); if (retval != RIG_OK) return retval; @@ -652,7 +652,7 @@ 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_cmd(rig, (trn == RIG_TRN_RIG) ? "AI 1" : "AI 0"); + return kenwood_simple_cmd(rig, (trn == RIG_TRN_RIG) ? "AI 1" : "AI 0"); } /* @@ -747,7 +747,7 @@ th_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) static int th_tburst(RIG *rig, vfo_t vfo, int status) { - return kenwood_cmd(rig, (status == 1) ? "TT" : "RX"); + return kenwood_simple_cmd(rig, (status == 1) ? "TT" : "RX"); } /* @@ -766,7 +766,7 @@ static int th_set_kenwood_func(RIG *rig, const char *cmd, int status) buf[BUFSZ-1] = '\0'; strncat(buf, status ? " 1" : " 0", BUFSZ-1); - return kenwood_cmd(rig, buf); + return kenwood_simple_cmd(rig, buf); } @@ -901,11 +901,11 @@ th_set_parm(RIG *rig, setting_t parm, value_t val) case RIG_PARM_APO: if (val.i > 30) - return kenwood_cmd(rig, "APO 2"); + return kenwood_simple_cmd(rig, "APO 2"); else if (val.i > 0) - return kenwood_cmd(rig, "APO 1"); + return kenwood_simple_cmd(rig, "APO 1"); else - return kenwood_cmd(rig, "APO 0"); + return kenwood_simple_cmd(rig, "APO 0"); default: rig_debug(RIG_DEBUG_ERR, "%s: Unsupported parm %#x\n", __func__, parm); @@ -1089,29 +1089,29 @@ int th_set_level (RIG *rig, vfo_t vfo, setting_t level, value_t val) (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); - return kenwood_cmd(rig, buf); + return kenwood_simple_cmd(rig, buf); 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_cmd(rig, buf); + return kenwood_simple_cmd(rig, buf); case RIG_LEVEL_AF : sprintf(buf, "AG %c,%02x", vch, (int)(val.f * 32.0)); - return kenwood_cmd(rig, buf); + return kenwood_simple_cmd(rig, buf); case RIG_LEVEL_ATT : sprintf(buf, "ATT %c", val.i ? '1' : '0'); - return kenwood_cmd(rig, buf); + return kenwood_simple_cmd(rig, buf); case RIG_LEVEL_BALANCE : sprintf(buf, "BAL %c", '4' - (int) (val.f * ('4'-'0'))); - return kenwood_cmd(rig, buf); + return kenwood_simple_cmd(rig, buf); case RIG_LEVEL_VOXGAIN: sprintf(buf, "VXG %d", (int) (val.f * 9)); - return kenwood_cmd(rig, buf); + return kenwood_simple_cmd(rig, buf); case RIG_LEVEL_VOXDELAY: /* "VXD" */ return -RIG_ENIMPL; @@ -1501,7 +1501,7 @@ th_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) { rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__); - return kenwood_cmd(rig, (ptt == RIG_PTT_ON) ? "TX" : "RX"); + return kenwood_simple_cmd(rig, (ptt == RIG_PTT_ON) ? "TX" : "RX"); } int th_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd) @@ -1558,13 +1558,13 @@ int th_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) switch (op) { case RIG_OP_UP: - return kenwood_cmd(rig, "UP"); + return kenwood_simple_cmd(rig, "UP"); case RIG_OP_DOWN: - return kenwood_cmd(rig, "DW"); + return kenwood_simple_cmd(rig, "DW"); case RIG_OP_TO_VFO: - return kenwood_cmd(rig, "MSH"); + return kenwood_simple_cmd(rig, "MSH"); default: return -RIG_EINVAL; @@ -2037,7 +2037,7 @@ int th_set_ant(RIG * rig, vfo_t vfo, ant_t ant) return -RIG_EINVAL; } - return kenwood_cmd(rig, cmd); + return kenwood_simple_cmd(rig, cmd); } diff --git a/kenwood/tmd710.c b/kenwood/tmd710.c index 2608ef253..4047f17c0 100644 --- a/kenwood/tmd710.c +++ b/kenwood/tmd710.c @@ -943,7 +943,7 @@ int tmd710_set_vfo (RIG *rig, vfo_t vfo) } snprintf(vfobuf,9, "VM %d,%d", vfonum, vfomode); - retval = kenwood_cmd(rig, vfobuf); + retval = kenwood_simple_cmd(rig, vfobuf); if (retval != RIG_OK) return retval; @@ -951,7 +951,7 @@ int tmd710_set_vfo (RIG *rig, vfo_t vfo) return RIG_OK; snprintf(vfobuf, 15, "BC %d,%d", vfonum, txvfonum); - retval = kenwood_cmd(rig, vfobuf); + retval = kenwood_simple_cmd(rig, vfobuf); if (retval != RIG_OK) return retval; diff --git a/kenwood/ts570.c b/kenwood/ts570.c index 528a6d737..50c248b59 100644 --- a/kenwood/ts570.c +++ b/kenwood/ts570.c @@ -30,8 +30,6 @@ #include #include "kenwood.h" -#include "ic10.h" - #define TS570_ALL_MODES (RIG_MODE_AM|RIG_MODE_CW|RIG_MODE_SSB|RIG_MODE_FM|RIG_MODE_RTTY) #define TS570_OTHER_TX_MODES (RIG_MODE_CW|RIG_MODE_SSB|RIG_MODE_FM|RIG_MODE_RTTY) @@ -710,8 +708,8 @@ const struct rig_caps ts570s_caps = { .serial_handshake = RIG_HANDSHAKE_NONE, .write_delay = 0, .post_write_delay = 30, -.timeout = 1000, -.retry = 3, +.timeout = 400, +.retry = 5, .has_get_func = TS570_FUNC_ALL, .has_set_func = TS570_FUNC_ALL, @@ -825,7 +823,7 @@ const struct rig_caps ts570s_caps = { .rig_init = kenwood_init, .rig_cleanup = kenwood_cleanup, .set_freq = kenwood_set_freq, -.get_freq = ic10_get_freq, +.get_freq = kenwood_get_freq_if, .set_rit = ts570_set_rit, .get_rit = kenwood_get_rit, .set_xit = ts570_set_xit, @@ -889,8 +887,8 @@ const struct rig_caps ts570d_caps = { .serial_handshake = RIG_HANDSHAKE_NONE, .write_delay = 0, .post_write_delay = 30, -.timeout = 1000, -.retry = 3, +.timeout = 400, +.retry = 5, .has_get_func = TS570_FUNC_ALL, .has_set_func = TS570_FUNC_ALL, @@ -1009,7 +1007,7 @@ const struct rig_caps ts570d_caps = { .rig_init = kenwood_init, .rig_cleanup = kenwood_cleanup, .set_freq = kenwood_set_freq, -.get_freq = ic10_get_freq, +.get_freq = kenwood_get_freq_if, .set_rit = ts570_set_rit, .get_rit = kenwood_get_rit, .set_xit = ts570_set_xit, diff --git a/kenwood/ts870s.c b/kenwood/ts870s.c index 80418958e..c2dbb7743 100644 --- a/kenwood/ts870s.c +++ b/kenwood/ts870s.c @@ -532,6 +532,7 @@ const struct rig_caps ts870s_caps = { .priv = (void *)&ts870s_priv_caps, .rig_init = kenwood_init, +.rig_open = kenwood_open, .rig_cleanup = kenwood_cleanup, .set_freq = kenwood_set_freq, .get_freq = kenwood_get_freq,