From 6e57454b06c15cc45d585d9a7b6758d0544fb70e Mon Sep 17 00:00:00 2001 From: Bill Somerville Date: Fri, 1 Nov 2013 22:08:41 +0000 Subject: [PATCH] Add spilt mode get and set for Elecraft K3. --- kenwood/k3.c | 164 +++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 153 insertions(+), 11 deletions(-) diff --git a/kenwood/k3.c b/kenwood/k3.c index 5fba615ac..346cf966a 100644 --- a/kenwood/k3.c +++ b/kenwood/k3.c @@ -562,27 +562,169 @@ int k3_set_xit(RIG * rig, vfo_t vfo, shortfreq_t rit) } -/* The K3 *always* uses VFOB for TX. Do we continually switch VFOs and - * possibly irritate the user? Better just to return -RIG_ENAVAIL - * until this is resolved. +/* + * The K3 *always* uses VFOB for TX. */ -int k3_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width) +int k3_set_split_mode(RIG * rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width) { - rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return -RIG_ENAVAIL; + if (!rig) + return -RIG_EINVAL; + + int err; + char cmd_s[16]; + + switch (tx_mode) { + case RIG_MODE_PKTLSB: + tx_mode = RIG_MODE_RTTYR; + strncpy(cmd_s, "DT0", 5); + break; + case RIG_MODE_PKTUSB: + tx_mode = RIG_MODE_RTTY; + strncpy(cmd_s, "DT0", 5); + break; + case RIG_MODE_RTTY: + case RIG_MODE_RTTYR: + strncpy(cmd_s, "DT1", 5); + break; + default: + break; + } + + struct kenwood_priv_caps *caps = kenwood_caps(rig); + char buf[6]; + char kmode; + + kmode = rmode2kenwood(tx_mode, caps->mode_table); + if (kmode < 0 ) { + rig_debug(RIG_DEBUG_WARN, "%s: unsupported mode '%s'\n", + __func__, rig_strrmode(tx_mode)); + return -RIG_EINVAL; + } + + sprintf(buf, "MD$%c", '0' + kmode); + err = kenwood_simple_cmd(rig, buf); + if (err != RIG_OK) + return err; + + /* Now set data sub-mode. K3 needs to be in a DATA mode before setting + * the sub-mode. + */ + if (tx_mode == RIG_MODE_PKTLSB || tx_mode == RIG_MODE_PKTUSB + || tx_mode == RIG_MODE_RTTY || tx_mode == RIG_MODE_RTTYR) { + err = kenwood_simple_cmd(rig, cmd_s); + if (err != RIG_OK) + return err; + } + + /* and set the requested bandwidth. On my K3, the bandwidth is rounded + * down to the nearest 50 Hz, i.e. sending BW0239; will cause the bandwidth + * to be set to 2.350 kHz. As the width must be divided by 10, 10 Hz values + * between 0 and 4 round down to the nearest 100 Hz and values between 5 + * and 9 round down to the nearest 50 Hz. + * + * tx_width string value must be padded with leading '0' to equal four + * characters. + */ + + /* passband widths vary by mode so gather lower and upper limits */ + pbwidth_t pb_nar = rig_passband_narrow(rig, tx_mode); + pbwidth_t pb_wid = rig_passband_wide(rig, tx_mode); + + if (tx_width < 0) + tx_width = labs(tx_width); + + if (tx_width == RIG_PASSBAND_NORMAL) + tx_width = rig_passband_normal(rig, tx_mode); + else if (tx_width < pb_nar) + tx_width = pb_nar; + else if (tx_width > pb_wid) + tx_width = pb_wid; + + sprintf(cmd_s, "BW$%04ld", tx_width / 10); + err = kenwood_simple_cmd(rig, cmd_s); + if (err != RIG_OK) + return err; + + return RIG_OK; } -/* The K3 *always* uses VFOB for TX. Do we continually switch VFOs and - * possibly irritate the user? Better just to return -RIG_ENAVAIL - * until this is resolved. +/* The K3 *always* uses VFOB for TX. */ int k3_get_split_mode(RIG *rig, vfo_t vfo, rmode_t *tx_mode, pbwidth_t *tx_width) { - rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); + rig_debug (RIG_DEBUG_VERBOSE, "%s called\n", __func__); - return -RIG_ENAVAIL; + if (!rig || !tx_mode || !tx_width) + return -RIG_EINVAL; + + char buf[KENWOOD_MAX_BUF_LEN]; + int err; + rmode_t temp_m; + + struct kenwood_priv_caps *caps = kenwood_caps (rig); + + err = kenwood_safe_transaction(rig, "MD$", buf, KENWOOD_MAX_BUF_LEN, 5); + if (err != RIG_OK) + return err; + + temp_m = kenwood2rmode (buf[3] - '0', caps->mode_table); + + if (temp_m == RIG_MODE_RTTY) { + err = kenwood_safe_transaction(rig, "DT", buf, KENWOOD_MAX_BUF_LEN, 4); + if (err != RIG_OK) { + rig_debug(RIG_DEBUG_VERBOSE, "%s: Cannot read K3 DT value\n", + __func__); + return err; + } + switch(atoi(&buf[2])) { + case K3_MODE_DATA_A: + *tx_mode = RIG_MODE_PKTUSB; + break; + case K3_MODE_AFSK_A: + *tx_mode = RIG_MODE_RTTY; + break; + default: + rig_debug(RIG_DEBUG_VERBOSE, "%s: unsupported data sub-mode %c\n", + __func__, buf[2]); + return -RIG_EINVAL; + } + } else if (temp_m == RIG_MODE_RTTYR) { + err = kenwood_safe_transaction(rig, "DT", buf, KENWOOD_MAX_BUF_LEN, 4); + if (err != RIG_OK) { + rig_debug(RIG_DEBUG_VERBOSE, "%s: Cannot read K3 DT value\n", + __func__); + return err; + } + switch(atoi(&buf[2])) { + case K3_MODE_DATA_A: + *tx_mode = RIG_MODE_PKTLSB; + break; + case K3_MODE_AFSK_A: + *tx_mode = RIG_MODE_RTTYR; + break; + default: + rig_debug(RIG_DEBUG_VERBOSE, "%s: unsupported data sub-mode %c\n", + __func__, buf[2]); + return -RIG_EINVAL; + } + } else { + *tx_mode = temp_m; + } + + /* The K3 is not limited to specific filter widths so we can query + * the actual bandwidth using the BW$ command + */ + err = kenwood_safe_transaction(rig, "BW$", buf, KENWOOD_MAX_BUF_LEN, 9); + if (err != RIG_OK) { + rig_debug(RIG_DEBUG_VERBOSE, "%s: Cannot read K3 BW$ value\n", __func__); + return err; + } + *tx_width = atoi(&buf[3]) * 10; + + return RIG_OK; }