From 83168860635dfba5bbb227a2a7dbe57b91b46d6a Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Sun, 29 Jun 2025 12:14:21 -0400 Subject: [PATCH 01/16] Adds a backend for the Drake R8 for non-intrusive testing. Module contains copies of parts of drake.c because several routines are significantly different than R8a/b. Resopnses will be different. Test rig includes better debugging of message transfers, that replace nulls, CRs and LFs with token strings so they can be properly seen and counted as part of the sending and receiving messages. --- rigs/drake/Makefile.am | 2 +- rigs/drake/drake.c | 13 +- rigs/drake/drake.h | 2 + rigs/drake/r8.c | 1377 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 1392 insertions(+), 2 deletions(-) create mode 100644 rigs/drake/r8.c diff --git a/rigs/drake/Makefile.am b/rigs/drake/Makefile.am index 63be8b534..6534b6b9d 100644 --- a/rigs/drake/Makefile.am +++ b/rigs/drake/Makefile.am @@ -1,4 +1,4 @@ -DRAKESRC = r8a.c r8b.c drake.c drake.h +DRAKESRC = r8.c r8a.c r8b.c drake.c drake.h noinst_LTLIBRARIES = libhamlib-drake.la libhamlib_drake_la_SOURCES = $(DRAKESRC) diff --git a/rigs/drake/drake.c b/rigs/drake/drake.c index dcddfce0f..40806ed14 100644 --- a/rigs/drake/drake.c +++ b/rigs/drake/drake.c @@ -161,7 +161,7 @@ int drake_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) return retval; } - /* RA command returns *fffff.ff*mHz */ + /* RA command returns ffffff.ff*mHz */ if (freq_len != 15) { rig_debug(RIG_DEBUG_ERR, "drake_get_freq: wrong answer %s, " @@ -1214,6 +1214,7 @@ DECLARE_INITRIG_BACKEND(drake) { rig_debug(RIG_DEBUG_VERBOSE, "%s: _init called\n", __func__); + rig_register(&r8_caps); rig_register(&r8a_caps); rig_register(&r8b_caps); @@ -1282,6 +1283,16 @@ DECLARE_PROBERIG_BACKEND(drake) return RIG_MODEL_DKR8A; } + if (!strcmp(idbuf, "R8")) + { + if (cfunc) + { + (*cfunc)(port, RIG_MODEL_DKR8, data); + } + + return RIG_MODEL_DKR8; + } + /* * not found... */ diff --git a/rigs/drake/drake.h b/rigs/drake/drake.h index 58e404933..13bd52c5f 100644 --- a/rigs/drake/drake.h +++ b/rigs/drake/drake.h @@ -52,7 +52,9 @@ int drake_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val); int drake_set_powerstat (RIG * rig, powerstat_t status); int drake_get_powerstat (RIG * rig, powerstat_t *status); const char *drake_get_info(RIG *rig); +int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, int *data_len); +extern struct rig_caps r8_caps; extern struct rig_caps r8a_caps; extern struct rig_caps r8b_caps; diff --git a/rigs/drake/r8.c b/rigs/drake/r8.c new file mode 100644 index 000000000..7d4ba90f2 --- /dev/null +++ b/rigs/drake/r8.c @@ -0,0 +1,1377 @@ +/* + * Hamlib Drake backend - R-8 description + * Copyright (c) 2001-2010, 2025 by Stephane Fillod + * + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +//#include +#include +//#include /* String function definitions */ +//#include /* UNIX standard function definitions */ + +#include +//#include "serial.h" +//#include "cal.h" +//#include "register.h" + +#include "drake.h" + +int drake_r8_set_freq(RIG *rig, vfo_t vfo, freq_t freq); +int drake_r8_get_freq(RIG *rig, vfo_t vfo, freq_t *freq); +int drake_r8_set_vfo(RIG *rig, vfo_t vfo); +int drake_r8_get_vfo(RIG *rig, vfo_t *vfo); +int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width); +int drake_r8_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width); +int drake_r8_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option); +int drake_r8_get_ant(RIG *rig, vfo_t vfo, ant_t dummy, value_t *option, ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx); +int drake_r8_set_mem(RIG *rig, vfo_t vfo, int ch); +int drake_r8_get_mem(RIG *rig, vfo_t vfo, int *ch); +int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan); +int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only); +int drake_r8_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op); +int drake_r8_set_func(RIG *rig, vfo_t vfo, setting_t func, int status); +int drake_r8_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status); +int drake_r8_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val); +int drake_r8_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val); +int drake_r8_set_powerstat (RIG * rig, powerstat_t status); +int drake_r8_get_powerstat (RIG * rig, powerstat_t *status); +const char *drake_r8_get_info(RIG *rig); + +#define BUFSZ 64 + +#define CR "\x0d" +#define LF "\x0a" +#define EOM CR + +#define MD_USB '1' +#define MD_LSB '2' +#define MD_RTTY '3' +#define MD_CW '4' +#define MD_FM '5' +#define MD_AM '6' + +#define R8_MODES (RIG_MODE_SSB|RIG_MODE_CW|RIG_MODE_RTTY|RIG_MODE_AM|RIG_MODE_AMS|RIG_MODE_FM) + +#define R8_FUNC (RIG_FUNC_MN|RIG_FUNC_NB|RIG_FUNC_NB2) + +#define R8_LEVEL_ALL (RIG_LEVEL_PREAMP|RIG_LEVEL_ATT|RIG_LEVEL_AGC) + +#define R8_PARM_ALL (RIG_PARM_TIME) + +#define R8_VFO (RIG_VFO_A|RIG_VFO_B|RIG_VFO_VFO|RIG_VFO_MEM) + +#define R8_VFO_OPS (RIG_OP_UP|RIG_OP_DOWN|RIG_OP_TO_VFO|RIG_OP_FROM_VFO) + +#define R8_ANTS (RIG_ANT_1|RIG_ANT_2|RIG_ANT_3) + +/* + * channel caps. + */ +#define DRAKE_MEM_CAP { \ + .freq = 1, \ + .mode = 1, \ + .width = 1, \ + .ant = 1, \ + .funcs = R8_FUNC, \ + .levels = RIG_LEVEL_AGC|RIG_LEVEL_ATT|RIG_LEVEL_PREAMP, \ +} + +/* + * R-8 rig capabilities. + * + * specs: http://www.dxing.com/rx/r8.htm + * + */ + +struct rig_caps r8_caps = +{ + RIG_MODEL(RIG_MODEL_DKR8), + .model_name = "R-8", + .mfg_name = "Drake", + .version = BACKEND_VER ".0", + .copyright = "LGPL", + .status = RIG_STATUS_NEW, + .rig_type = RIG_TYPE_RECEIVER, + .ptt_type = RIG_PTT_NONE, + .dcd_type = RIG_DCD_SERIAL_CAR, + .port_type = RIG_PORT_SERIAL, + .serial_rate_min = 9600, + .serial_rate_max = 9600, + .serial_data_bits = 7, + .serial_stop_bits = 1, + .serial_parity = RIG_PARITY_EVEN, + .serial_handshake = RIG_HANDSHAKE_HARDWARE, + .write_delay = 0, + .post_write_delay = 1, + .timeout = 200, + .retry = 3, + + .has_get_func = R8_FUNC, + .has_set_func = R8_FUNC, + .has_get_level = R8_LEVEL_ALL, + .has_set_level = RIG_LEVEL_SET(R8_LEVEL_ALL), + .has_get_parm = R8_PARM_ALL, + .has_set_parm = RIG_PARM_SET(R8_PARM_ALL), + .level_gran = {}, + .parm_gran = {}, + .ctcss_list = NULL, + .dcs_list = NULL, + .preamp = { 10, RIG_DBLST_END }, + .attenuator = { 10, RIG_DBLST_END }, + .max_rit = Hz(0), + .max_xit = Hz(0), + .max_ifshift = Hz(0), + .targetable_vfo = 0, + .transceive = RIG_TRN_OFF, + .bank_qty = 0, + .chan_desc_sz = 0, + .vfo_ops = R8_VFO_OPS, + + .chan_list = { + { 0, 99, RIG_MTYPE_MEM, DRAKE_MEM_CAP }, + RIG_CHAN_END + }, + + .rx_range_list1 = { + {kHz(100), MHz(30), R8_MODES, -1, -1, R8_VFO, R8_ANTS}, + RIG_FRNG_END, + }, + .tx_range_list1 = { RIG_FRNG_END, }, + .rx_range_list2 = { + {kHz(100), MHz(30), R8_MODES, -1, -1, R8_VFO, R8_ANTS}, + RIG_FRNG_END, + }, + .tx_range_list2 = { RIG_FRNG_END, }, + + .tuning_steps = { + {R8_MODES, 10}, + {R8_MODES, 100}, + {R8_MODES, kHz(1)}, + {R8_MODES, kHz(10)}, + RIG_TS_END, + }, + /* mode/filter list, remember: order matters! */ + .filters = { + {RIG_MODE_FM, kHz(12)}, + {RIG_MODE_AM | RIG_MODE_AMS, kHz(6)}, + {RIG_MODE_AM | RIG_MODE_AMS, kHz(4)}, + {RIG_MODE_AM | RIG_MODE_AMS, kHz(2.3)}, + {RIG_MODE_AM | RIG_MODE_AMS, kHz(1.8)}, + {RIG_MODE_AM | RIG_MODE_AMS, Hz(500)}, + {RIG_MODE_SSB | RIG_MODE_RTTY, kHz(2.3)}, + {RIG_MODE_SSB | RIG_MODE_RTTY, kHz(1.8)}, + {RIG_MODE_SSB | RIG_MODE_RTTY, Hz(500)}, + {RIG_MODE_SSB | RIG_MODE_RTTY, kHz(4)}, + {RIG_MODE_SSB | RIG_MODE_RTTY, kHz(6)}, + {RIG_MODE_CW, Hz(500)}, + {RIG_MODE_CW, kHz(1.8)}, + {RIG_MODE_CW, kHz(2.3)}, + {RIG_MODE_CW, kHz(4)}, + {RIG_MODE_CW, kHz(6)}, + RIG_FLT_END, + }, + .str_cal = {0,{}}, + .priv = NULL, + + .rig_init = drake_init, + .rig_cleanup = drake_cleanup, + + .set_freq = drake_r8_set_freq, + .get_freq = drake_r8_get_freq, + .set_vfo = drake_r8_set_vfo, + .get_vfo = drake_r8_get_vfo, + .set_mode = drake_r8_set_mode, + .get_mode = drake_r8_get_mode, + .set_func = drake_r8_set_func, + .get_func = drake_r8_get_func, + .set_level = drake_r8_set_level, + .get_level = drake_r8_get_level, + .set_ant = drake_r8_set_ant, + .get_ant = drake_r8_get_ant, + .set_mem = drake_r8_set_mem, + .get_mem = drake_r8_get_mem, + .set_channel = drake_r8_set_chan, + .get_channel = drake_r8_get_chan, + .vfo_op = drake_r8_vfo_op, + .set_powerstat = drake_r8_set_powerstat, + .get_powerstat = drake_r8_get_powerstat, + .get_info = drake_r8_get_info, + .hamlib_check_rig_caps = HAMLIB_CHECK_RIG_CAPS +}; + +/* + * Function definitions below + */ + +/* + * drake_r8_fix_string + * recursively replaces all special characters so they are readable at output + * + */ +void drake_r8_fix_string(char** inStr) +{ + char chChkAry[3] = {0x20, 0x0d, 0x0a}; + char* chRepAry[3] = {"", "", ""}; + char* chPos; + char newStr[100]; + char* repStr; + int newLen; + int i; + int offset; + + repStr = *inStr; + for (i = 0; i < 3; i++) + { + do { + chPos = strchr(repStr, chChkAry[i]); + if (chPos != NULL) + { + offset = chPos - repStr; + strncpy(newStr, repStr, offset); + strcat(newStr, chRepAry[i]); + strcat(newStr, repStr + offset + 1); + newLen = strlen(repStr) + 3; + newStr[newLen] = 0x00; + free(repStr); + repStr = strdup((char*)newStr); + } + } + while (chPos); + } + *inStr = strdup(repStr); + free(repStr); +} + + +/* + * drake_r8_trans_rept + * non-destructively echoes transaction in a readable way for debugging + */ +void drake_r8_trans_rept(char* hdrStr, char* sentStr, int sentLen, char* recdStr, int recdLen, int res) +{ + char* sent; + char* recd; + + //in most cases each string is a buffer, so we need to ensure both command and response + //are not NULL and null-terminated before duplicastion and conversion. + + if (sentStr != NULL) + { + //sentStr[sentLen] = '\0'; + sent = strdup(sentStr); + drake_r8_fix_string(&sent); + } + else + { + sent = strdup(""); + } + + if (recdStr != NULL) + { + //recdStr[recdLen] = '\0'; + recd = strdup(recdStr); + drake_r8_fix_string(&recd); + } + else + { + recd = strdup(""); + } + + rig_debug(RIG_DEBUG_WARN, "Hamlib %s: Result %d - Sent %d chars: %s, Recd %d chars: %s\n", hdrStr, res, sentLen, sent, recdLen, recd); + + free(sent); + free(recd); +} + + +/* + * drake_set_freq + * Assumes rig!=NULL + */ +int drake_r8_set_freq(RIG *rig, vfo_t vfo, freq_t freq) +{ + unsigned char freqbuf[16], ackbuf[16]; + int ack_len, retval; + + /* + * 10Hz resolution + * TODO: round nearest? + */ + SNPRINTF((char *) freqbuf, sizeof(freqbuf), "F%07u" EOM, + (unsigned int)freq / 10); + retval = drake_transaction(rig, (char *) freqbuf, strlen((char *)freqbuf), + (char *) ackbuf, + &ack_len); + + drake_r8_trans_rept("set_freq", (char*)freqbuf, strlen((char*)freqbuf), (char*)ackbuf, ack_len, retval); + + return retval; +} + + +/* + * drake_get_freq + * Assumes rig!=NULL, freq!=NULL + */ +int drake_r8_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) +{ + int freq_len, retval; + char freqbuf[BUFSZ]; + double f; + //char fmult; + + retval = drake_transaction(rig, "RF" EOM, 3, freqbuf, &freq_len); + + drake_r8_trans_rept("get_freq", "RF" EOM, 3, (char*)freqbuf, freq_len, retval); + + if (retval != RIG_OK) + { + return retval; + } + + /* RA command returns fff.fffff*mHz */ + if (freq_len < 15) + { + rig_debug(RIG_DEBUG_ERR, "drake_get_freq: wrong answer %s, " + "len=%d\n", freqbuf, freq_len); + return -RIG_ERJCTED; + } + + freqbuf[9] = '\0'; + + /* extract freq */ + sscanf(freqbuf + 1, "%lf", &f); + f *= 1000000.0; + + *freq = (freq_t)f; + + return RIG_OK; +} + + +/* + * drake_set_vfo + * Assumes rig!=NULL + */ +int drake_r8_set_vfo(RIG *rig, vfo_t vfo) +{ + unsigned char cmdbuf[16], ackbuf[16]; + int ack_len, retval; + char vfo_function; + + switch (vfo) + { + case RIG_VFO_A : vfo_function = 'A'; break; + + case RIG_VFO_B : vfo_function = 'B'; break; + + case RIG_VFO_VFO: vfo_function = 'F'; break; + + case RIG_VFO_MEM: vfo_function = 'C'; break; + + default: + rig_debug(RIG_DEBUG_ERR, "drake_set_vfo: unsupported VFO %s\n", + rig_strvfo(vfo)); + return -RIG_EINVAL; + } + + if ((vfo_function == 'A') || (vfo_function == 'B')) + { + SNPRINTF((char *) cmdbuf, sizeof(cmdbuf), "V%c" EOM, vfo_function); + } + + if ((vfo_function == 'F') || (vfo_function == 'C')) + { + SNPRINTF((char *) cmdbuf, sizeof(cmdbuf), "%c" EOM, vfo_function); + } + + retval = drake_transaction(rig, (char *) cmdbuf, strlen((char *)cmdbuf), + (char *) ackbuf, + &ack_len); + + drake_r8_trans_rept("set_vfo", (char*)cmdbuf, strlen((char*)cmdbuf), (char*)ackbuf, ack_len, retval); + + return retval; +} + + + +/* + * drake_get_vfo + * Assumes rig!=NULL + */ +int drake_r8_get_vfo(RIG *rig, vfo_t *vfo) +{ + int mdbuf_len, retval; + char mdbuf[BUFSZ]; + + retval = drake_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); + + drake_r8_trans_rept("get_vfo", "RA" EOM, 3, (char*)mdbuf, mdbuf_len, retval); + + if (retval != RIG_OK) + { + return retval; + } + + if (mdbuf_len != 25) + { + rig_debug(RIG_DEBUG_ERR, "drake_get_vfo: wrong answer %s, " + "len=%d\n", mdbuf, mdbuf_len); + return -RIG_ERJCTED; + } + + if (mdbuf[0] == '*') + { + *vfo = RIG_VFO_MEM; + } + else + { + char cvfo = (mdbuf[8] & 0x38); + + switch (cvfo) + { + case '0' : *vfo = RIG_VFO_B; break; + + case '8' : *vfo = RIG_VFO_A; break; + + default : rig_debug(RIG_DEBUG_ERR, + "drake_get_vfo: unsupported vfo %c\n", cvfo); + *vfo = RIG_VFO_VFO; + return -RIG_EINVAL; + } + } + + return RIG_OK; +} + + +/* + * drake_set_mode + * Assumes rig!=NULL + */ +int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) +{ + unsigned char mdbuf[16], ackbuf[16]; + unsigned char mode_sel; + int ack_len, retval; + + switch (mode) + { + case RIG_MODE_CW: mode_sel = MD_CW; break; + + case RIG_MODE_USB: mode_sel = MD_USB; break; + + case RIG_MODE_LSB: mode_sel = MD_LSB; break; + + case RIG_MODE_FM: mode_sel = MD_FM; break; + + case RIG_MODE_AMS: + case RIG_MODE_AM: mode_sel = MD_AM; break; + + case RIG_MODE_RTTY: mode_sel = MD_RTTY; break; + + default: + rig_debug(RIG_DEBUG_ERR, "drake_set_mode: " + "unsupported mode %s\n", rig_strrmode(mode)); + return -RIG_EINVAL; + } + + SNPRINTF((char *) mdbuf, sizeof(mdbuf), "M%c" EOM, mode_sel); + retval = drake_transaction(rig, (char *) mdbuf, strlen((char *)mdbuf), + (char *) ackbuf, + &ack_len); + + drake_r8_trans_rept("set_mode", (char*)mdbuf, strlen((char*)mdbuf), (char*)ackbuf, ack_len, retval); + + if (retval != RIG_OK) + { + return retval; + } + + if (width != RIG_PASSBAND_NOCHANGE) + { + if (mode != RIG_MODE_FM) + { + unsigned int width_sel; + + if (width == RIG_PASSBAND_NORMAL) + { + width = rig_passband_normal(rig, mode); + } + + if (width <= 500) + { + width_sel = '0'; + } + else if (width <= 1800) + { + width_sel = '1'; + } + else if (width <= 2300) + { + width_sel = '2'; + } + else if (width <= 4000) + { + width_sel = '4'; + } + else + { + width_sel = '6'; + } + + SNPRINTF((char *) mdbuf, sizeof(mdbuf), "W%c" EOM, width_sel); + retval = drake_transaction(rig, (char *) mdbuf, strlen((char *)mdbuf), + (char *) ackbuf, + &ack_len); + drake_r8_trans_rept("set_bw", (char*)mdbuf, strlen((char*)mdbuf), (char*)ackbuf, ack_len, retval); + + } + } + + if ((mode == RIG_MODE_AMS) || (mode == RIG_MODE_AM)) + { + SNPRINTF((char *) mdbuf, sizeof(mdbuf), "S%c" EOM, + (mode == RIG_MODE_AMS) ? 'O' : 'F'); + retval = drake_transaction(rig, (char *) mdbuf, strlen((char *)mdbuf), + (char *) ackbuf, + &ack_len); + + drake_r8_trans_rept("set_synch", (char*)mdbuf, strlen((char*)mdbuf), (char*)ackbuf, ack_len, retval); + } + + return retval; +} + + +/* + * drake_get_mode + * Assumes rig!=NULL + */ +int drake_r8_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) +{ + int mdbuf_len, retval; + char mdbuf[BUFSZ]; + char cmode; + char cwidth; + char csynch; + + retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + + drake_r8_trans_rept("get_mode", "RM" EOM, 3, (char*)mdbuf, mdbuf_len, retval); + + if (retval != RIG_OK) + { + return retval; + } + + if (mdbuf_len < 7) + { + rig_debug(RIG_DEBUG_ERR, "drake_get_mode: wrong answer %s, " + "len=%d\n", mdbuf, mdbuf_len); + return -RIG_ERJCTED; + } + + cmode = mdbuf[2]; + cwidth = mdbuf[3]; + csynch = mdbuf[4]; + + switch (cwidth & 0x37) + { + case '0': *width = s_Hz(500); break; + + case '1': *width = s_Hz(1800); break; + + case '2': *width = s_Hz(2300); break; + + case '3': *width = s_Hz(4000); break; + + case '4': *width = s_Hz(6000); break; + + default : + rig_debug(RIG_DEBUG_ERR, + "drake_get_mode: unsupported width %c\n", + cwidth); + *width = RIG_PASSBAND_NORMAL; + return -RIG_EINVAL; + } + + if ((cwidth >= '0') && (cwidth <= '4')) + { + switch (cmode & 0x33) + { + case '0': *mode = RIG_MODE_LSB; break; + + case '1': *mode = RIG_MODE_RTTY; break; + + case '2': *mode = RIG_MODE_FM; *width = s_Hz(12000); break; + + default : + rig_debug(RIG_DEBUG_ERR, + "drake_get_mode: unsupported mode %c\n", + cmode); + *mode = RIG_MODE_NONE; + return -RIG_EINVAL; + } + } + else + { + switch (cmode & 0x33) + { + case '0': *mode = RIG_MODE_USB; break; + + case '1': *mode = RIG_MODE_CW; break; + + case '2': *mode = RIG_MODE_AM; break; + + default : + rig_debug(RIG_DEBUG_ERR, + "drake_get_mode: unsupported mode %c\n", + cmode); + *mode = RIG_MODE_NONE; + return -RIG_EINVAL; + } + } + + if ((csynch & 0x34) == '4') + { + if (*mode == RIG_MODE_AM) + { + *mode = RIG_MODE_AMS; + } + else if (*mode == RIG_MODE_USB) + { + *mode = RIG_MODE_ECSSUSB; + } + else if (*mode == RIG_MODE_LSB) + { + *mode = RIG_MODE_ECSSLSB; + } + } + + return RIG_OK; +} + + +/* + * drake_set_ant + * Assumes rig!=NULL + */ +int drake_r8_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) +{ + unsigned char buf[16], ackbuf[16]; + int ack_len, retval; + + SNPRINTF((char *) buf, sizeof(buf), "A%c" EOM, + ant == RIG_ANT_1 ? '1' : (ant == RIG_ANT_2 ? '2' : 'C')); + + retval = drake_transaction(rig, (char *) buf, strlen((char *)buf), + (char *) ackbuf, &ack_len); + + drake_r8_trans_rept("set_ant", (char*)buf, strlen((char*)buf), (char*)ackbuf, ack_len, retval); + + return retval; +} + + +/* + * drake_get_ant + * Assumes rig!=NULL + */ +int drake_r8_get_ant(RIG *rig, vfo_t vfo, ant_t dummy, value_t *option, + ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx) +{ + int mdbuf_len, retval; + char mdbuf[BUFSZ]; + char cant; + + retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + + if (retval != RIG_OK) + { + return retval; + } + + if (mdbuf_len < 7) + { + rig_debug(RIG_DEBUG_ERR, "drake_get_ant: wrong answer %s, " + "len=%d\n", mdbuf, mdbuf_len); + return -RIG_ERJCTED; + } + + cant = mdbuf[2]; + + switch (cant & 0x3c) + { + case '0': *ant_curr = RIG_ANT_1; break; + + case '4': *ant_curr = RIG_ANT_3; break; + + case '8': *ant_curr = RIG_ANT_2; break; + + default : + rig_debug(RIG_DEBUG_ERR, + "drake_get_ant: unsupported antenna %c\n", + cant); + return -RIG_EINVAL; + } + + return RIG_OK; +} + + +/* + * drake_set_mem + * Assumes rig!=NULL + */ +int drake_r8_set_mem(RIG *rig, vfo_t vfo, int ch) +{ + int ack_len, retval; + char buf[16], ackbuf[16]; + struct drake_priv_data *priv = STATE(rig)->priv; + + priv->curr_ch = ch; + + SNPRINTF(buf, sizeof(buf), "C%02d" , ch); + + ack_len = 0; // fix compile-time warning "possibly uninitialized" + retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + + drake_r8_trans_rept("set_mem", (char*)buf, strlen((char*)buf), (char*)ackbuf, ack_len, retval); + + if (ack_len != 2) + { + rig_debug(RIG_DEBUG_ERR, "drake_set_mem: could not set channel %02d.\n", ch); + retval = -RIG_ERJCTED; + } + + return retval; +} + +/* + * drake_get_mem + * Assumes rig!=NULL + */ +int drake_r8_get_mem(RIG *rig, vfo_t vfo, int *ch) +{ + struct drake_priv_data *priv = STATE(rig)->priv; + int mdbuf_len, retval; + char mdbuf[BUFSZ]; + int chan; + + retval = drake_transaction(rig, "RC" EOM, 3, mdbuf, &mdbuf_len); + + drake_r8_trans_rept("get_mem", "RC" EOM, 3, (char*)mdbuf, mdbuf_len, retval); + + if (retval != RIG_OK) + { + return retval; + } + + if (mdbuf_len < 5) + { + rig_debug(RIG_DEBUG_ERR, "drake_get_mem: wrong answer %s, " + "len=%d\n", mdbuf, mdbuf_len); + return -RIG_ERJCTED; + } + + mdbuf[3] = '\0'; + + /* extract channel no */ + sscanf(mdbuf + 1, "%02d", &chan); + *ch = chan; + + priv->curr_ch = chan; + + return RIG_OK; +} + + +/* + * drake_set_chan + * Assumes rig!=NULL + */ +int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) +{ + const struct drake_priv_data *priv = STATE(rig)->priv; + vfo_t old_vfo; + int old_chan; + char mdbuf[16], ackbuf[16]; + int ack_len, retval; + value_t dummy; + + dummy.i = 0; + + drake_r8_get_vfo(rig, &old_vfo); + old_chan = 0; + + /* set to vfo if needed */ + if (old_vfo == RIG_VFO_MEM) + { + old_chan = priv->curr_ch; + retval = drake_r8_set_vfo(rig, RIG_VFO_VFO); + + if (retval != RIG_OK) + { + return retval; + } + } + + /* set all memory features */ + drake_r8_set_ant(rig, RIG_VFO_CURR, chan->ant, dummy); + drake_r8_set_freq(rig, RIG_VFO_CURR, chan->freq); + drake_r8_set_mode(rig, RIG_VFO_CURR, chan->mode, chan->width); + drake_r8_set_func(rig, RIG_VFO_CURR, RIG_FUNC_NB, + (chan->funcs & RIG_FUNC_NB) == RIG_FUNC_NB); + drake_r8_set_level(rig, RIG_VFO_CURR, RIG_LEVEL_AGC, + chan->levels[rig_setting2idx(RIG_LEVEL_AGC)]); + drake_r8_set_level(rig, RIG_VFO_CURR, RIG_LEVEL_PREAMP, + chan->levels[rig_setting2idx(RIG_LEVEL_PREAMP)]); + drake_r8_set_level(rig, RIG_VFO_CURR, RIG_LEVEL_ATT, + chan->levels[rig_setting2idx(RIG_LEVEL_ATT)]); + drake_r8_set_func(rig, RIG_VFO_CURR, RIG_FUNC_MN, + (chan->funcs & RIG_FUNC_MN) == RIG_FUNC_MN); + + SNPRINTF(mdbuf, sizeof(mdbuf), "PR" EOM "%02d" EOM, chan->channel_num); + retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); + + drake_r8_trans_rept("set_chan", (char*)mdbuf, strlen((char*)mdbuf), (char*)ackbuf, ack_len, retval); + + if (old_vfo == RIG_VFO_MEM) + { + drake_r8_set_mem(rig, RIG_VFO_CURR, old_chan); + } + + return retval; +} + + +/* + * drake_get_chan + * Assumes rig!=NULL + */ +int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) +{ + const struct drake_priv_data *priv = STATE(rig)->priv; + vfo_t old_vfo; + int old_chan; + char mdbuf[BUFSZ], freqstr[BUFSZ]; + int mdbuf_len, retval; + + chan->vfo = RIG_VFO_MEM; + chan->ant = RIG_ANT_NONE; + chan->freq = 0; + chan->mode = RIG_MODE_NONE; + chan->width = RIG_PASSBAND_NORMAL; + chan->tx_freq = 0; + chan->tx_mode = RIG_MODE_NONE; + chan->tx_width = RIG_PASSBAND_NORMAL; + chan->split = RIG_SPLIT_OFF; + chan->tx_vfo = RIG_VFO_NONE; + chan->rptr_shift = RIG_RPT_SHIFT_NONE; + chan->rptr_offs = 0; + chan->tuning_step = 0; + chan->rit = 0; + chan->xit = 0; + chan->funcs = 0; + chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_OFF; + chan->levels[rig_setting2idx(RIG_LEVEL_ATT)].i = 0; + chan->levels[rig_setting2idx(RIG_LEVEL_PREAMP)].i = 0; + chan->ctcss_tone = 0; + chan->ctcss_sql = 0; + chan->dcs_code = 0; + chan->dcs_sql = 0; + chan->scan_group = 0; + chan->flags = RIG_CHFLAG_SKIP; + strcpy(chan->channel_desc, " "); + + drake_r8_get_vfo(rig, &old_vfo); + old_chan = 0; + + if (old_vfo == RIG_VFO_MEM) + { + old_chan = priv->curr_ch; + } + + //go to new channel + retval = drake_r8_set_mem(rig, RIG_VFO_CURR, chan->channel_num); + + if (retval != RIG_OK) + { + return RIG_OK; + } + + //now decipher it + retval = drake_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); + + if (retval != RIG_OK) + { + return retval; + } + + if (mdbuf_len != 25) + { + rig_debug(RIG_DEBUG_ERR, "drake_get_channel: wrong answer %s, " + "len=%d\n", mdbuf, mdbuf_len); + return -RIG_ERJCTED; + } + + if ((mdbuf[4] >= '<') && (mdbuf[4] <= '?')) + { + chan->funcs |= RIG_FUNC_NB; + } + if ((mdbuf[4] >= '4') && (mdbuf[4] <= '7')) + { + chan->funcs |= RIG_FUNC_NB2; + } + + switch (mdbuf[4] & 0x33) + { + case '0': chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_OFF; break; + + case '2': chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_FAST; break; + + case '3': chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_SLOW; break; + + default : chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_FAST; + } + + if ((mdbuf[5] & 0x3c) == '8') + { + chan->levels[rig_setting2idx(RIG_LEVEL_PREAMP)].i = 10; + } + + if ((mdbuf[5] & 0x3c) == '4') + { + chan->levels[rig_setting2idx(RIG_LEVEL_ATT)].i = 10; + } + + if ((mdbuf[5] & 0x32) == '2') + { + chan->funcs |= RIG_FUNC_MN; + } + + switch (mdbuf[6] & 0x3c) + { + case '0': chan->ant = RIG_ANT_1; break; + + case '4': chan->ant = RIG_ANT_3; break; + + case '8': chan->ant = RIG_ANT_2; break; + + default : chan->ant = RIG_ANT_NONE; + } + + switch (mdbuf[7] & 0x37) + { + case '0': chan->width = s_Hz(500); break; + + case '1': chan->width = s_Hz(1800); break; + + case '2': chan->width = s_Hz(2300); break; + + case '3': chan->width = s_Hz(4000); break; + + case '4': chan->width = s_Hz(6000); break; + + default : chan->width = RIG_PASSBAND_NORMAL; + } + + if ((mdbuf[7] >= '0') && (mdbuf[7] <= '4')) + { + switch (mdbuf[6] & 0x33) + { + case '0': chan->mode = RIG_MODE_LSB; break; + + case '1': chan->mode = RIG_MODE_RTTY; break; + + case '2': chan->mode = RIG_MODE_FM; + chan->width = s_Hz(12000); break; + + default : chan->mode = RIG_MODE_NONE; + } + } + else + { + switch (mdbuf[6] & 0x33) + { + case '0': chan->mode = RIG_MODE_USB; break; + + case '1': chan->mode = RIG_MODE_CW; break; + + case '2': chan->mode = RIG_MODE_AM; break; + + default : chan->mode = RIG_MODE_NONE; + } + } + + if ((mdbuf[8] & 0x34) == '4') + { + if (chan->mode == RIG_MODE_AM) + { + chan->mode = RIG_MODE_AMS; + } + } + + strncpy(freqstr, mdbuf + 10, 9); + freqstr[9] = 0x00; + + if ((mdbuf[20] == 'k') || (mdbuf[20] == 'K')) + { + chan->freq = strtod(freqstr, NULL) * 1000.0; + } + + if ((mdbuf[20] == 'm') || (mdbuf[20] == 'M')) + { + chan->freq = strtod(freqstr, NULL) * 1000000.0; + } + + //now put the radio back the way it was + //we apparently can't do a read-only channel read + if (old_vfo != RIG_VFO_MEM) + { + retval = drake_r8_set_vfo(rig, RIG_VFO_VFO); + + if (retval != RIG_OK) + { + return retval; + } + } + else + { + retval = drake_r8_set_mem(rig, RIG_VFO_CURR, old_chan); + + if (retval != RIG_OK) + { + return retval; + } + } + + return RIG_OK; +} + + +/* + * drake_vfo_op + * Assumes rig!=NULL + */ +int drake_r8_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) +{ + const struct drake_priv_data *priv = STATE(rig)->priv; + char buf[16], ackbuf[16]; + int len, ack_len, retval; + + switch (op) + { + case RIG_OP_UP: + SNPRINTF(buf, sizeof(buf), "U"); + break; + + case RIG_OP_DOWN: + SNPRINTF(buf, sizeof(buf), "D"); + break; + + case RIG_OP_TO_VFO: + SNPRINTF(buf, sizeof(buf), "F" EOM); + break; + + case RIG_OP_FROM_VFO: + SNPRINTF(buf, sizeof(buf), "PR" EOM "%02d" EOM, priv->curr_ch); + break; + + default: + return -RIG_EINVAL; + } + + len = strlen(buf); + retval = drake_transaction(rig, buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, + &ack_len); + + drake_r8_trans_rept("vfo_op", (char*)buf, len, buf[len - 1] == 0x0d ? (char*)ackbuf : NULL, ack_len, retval); + + return retval; +} + + +/* + * drake_set_func + * Assumes rig!=NULL + */ +int drake_r8_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) +{ + char buf[16], ackbuf[16]; + int ack_len, retval; + char blanker = ' '; + + switch (func) + { + case RIG_FUNC_MN: + SNPRINTF(buf, sizeof(buf), "N%c" EOM, status ? 'O' : 'F'); + break; + + case RIG_FUNC_NB: + case RIG_FUNC_NB2: + if (!status) + blanker = 'F'; + else if (func == RIG_FUNC_NB) + blanker = 'W'; + else //if (func == RIG_FUNC_NB2) + blanker = 'N'; + SNPRINTF(buf, sizeof(buf), "B%c" EOM, blanker); + break; + + default: + return -RIG_EINVAL; + } + + retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + + drake_r8_trans_rept("set_func", (char*)buf, strlen((char*)buf), (char*)ackbuf, ack_len, retval); + + return retval; +} + + +/* + * drake_get_func + * Assumes rig!=NULL + */ +int drake_r8_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) +{ + int mdbuf_len, retval; + char mdbuf[BUFSZ]; + char mc; + char blanker; + + retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + + if (retval != RIG_OK) + { + return retval; + } + + if (mdbuf_len < 7) + { + rig_debug(RIG_DEBUG_ERR, "drake_get_func: wrong answer %s, " + "len=%d\n", mdbuf, mdbuf_len); + return -RIG_ERJCTED; + } + + switch (func) + { + case RIG_FUNC_MN: + mc = mdbuf[1]; + *status = ((mc & 0x32) == '2'); + break; + + case RIG_FUNC_NB: + case RIG_FUNC_NB2: + mc = mdbuf[0]; + blanker = ' '; + if ((mc >= '<') && (mc <= '?')) + blanker = 'W'; + else + if ((mc >= '4') && (mc <= '7')) + blanker = 'N'; + else + blanker = 'F'; + *status = (((func == RIG_FUNC_NB) && (blanker == 'W')) || ((func == RIG_FUNC_NB2) && (blanker == 'N'))); + break; + + default: + rig_debug(RIG_DEBUG_ERR, "Unsupported get func %s\n", rig_strfunc(func)); + return -RIG_EINVAL; + } + + return RIG_OK; +} + + +/* + * drake_set_level + * Assumes rig!=NULL + */ +int drake_r8_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) +{ + char buf[16], ackbuf[16]; + int ack_len, retval; + + switch (level) + { + case RIG_LEVEL_PREAMP: + SNPRINTF(buf, sizeof(buf), "G%c" EOM, val.i ? '+' : '0'); + break; + + case RIG_LEVEL_ATT: + SNPRINTF(buf, sizeof(buf), "G%c" EOM, val.i ? '-' : '0'); + break; + + case RIG_LEVEL_AGC: + SNPRINTF(buf, sizeof(buf), "A%c" EOM, + val.i == RIG_AGC_OFF ? 'O' : + (val.i == RIG_AGC_FAST ? 'F' : 'S')); + break; + + default: + return -RIG_EINVAL; + } + + retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + + drake_r8_trans_rept("set_level", (char*)buf, strlen((char*)buf), (char*)ackbuf, ack_len, retval); + + return retval; +} + + +/* + * drake_get_level + * Assumes rig!=NULL + */ +int drake_r8_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) +{ + int lvl_len, retval; + char lvlbuf[BUFSZ]; + char mc; + + retval = drake_transaction(rig, "RM" EOM, 3, lvlbuf, &lvl_len); + + if (retval != RIG_OK) + { + return retval; + } + + if (lvl_len < 7) + { + rig_debug(RIG_DEBUG_ERR, "drake_get_level: wrong answer %s, " + "len=%d\n", lvlbuf, lvl_len); + return -RIG_ERJCTED; + } + + switch (level) + { + case RIG_LEVEL_PREAMP: + mc = lvlbuf[1]; + + if ((mc & 0x3c) == '8') + { + val->i = 10; + } + else + { + val->i = 0; + } + + break; + + case RIG_LEVEL_ATT: + mc = lvlbuf[1]; + + if ((mc & 0x3c) == '4') + { + val->i = 10; + } + else + { + val->i = 0; + } + + break; + + case RIG_LEVEL_AGC: + mc = lvlbuf[0]; + + switch (mc & 0x33) + { + case '0': val->i = RIG_AGC_OFF; break; + + case '2': val->i = RIG_AGC_FAST; break; + + case '3': val->i = RIG_AGC_SLOW; break; + + default : val->i = RIG_AGC_FAST; + } + + break; + + default: + rig_debug(RIG_DEBUG_ERR, "Unsupported get_level %s\n", rig_strlevel(level)); + return -RIG_EINVAL; + } + + return RIG_OK; +} + + +int drake_r8_set_powerstat(RIG *rig, powerstat_t status) +{ + char buf[16], ackbuf[16]; + int ack_len, retval; + + SNPRINTF(buf, sizeof(buf), "P%c" EOM, status == RIG_POWER_OFF ? 'F' : 'O'); + + retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + + drake_r8_trans_rept("set_power", (char*)buf, strlen((char*)buf), (char*)ackbuf, ack_len, retval); + + return retval; +} + + +int drake_r8_get_powerstat(RIG *rig, powerstat_t *status) +{ + int mdlen, retval; + char mdbuf[BUFSZ]; + + retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdlen); + + if (retval != RIG_OK) + { + return retval; + } + + *status = (mdlen >= 7); + + return RIG_OK; +} + + +/* + * drake_get_info + * Assumes rig!=NULL + */ +const char *drake_r8_get_info(RIG *rig) +{ + static char idbuf[BUFSZ]; + int retval, id_len; + + retval = drake_transaction(rig, "ID" EOM, 3, idbuf, &id_len); + + drake_r8_trans_rept("get_id", "ID" EOM, 3, (char*)idbuf, id_len, retval); + + if (retval != RIG_OK) + { + return NULL; + } + + idbuf[id_len] = '\0'; + + return idbuf; +} + From f94ec6a47b3b06f166a19d74cf34148342a9bea2 Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Mon, 30 Jun 2025 21:17:37 -0400 Subject: [PATCH 02/16] Changes to smooth out the transaction process for all Drakes, and more test edits for the R8. --- rigs/drake/drake.c | 11 +- rigs/drake/drake.h | 1 - rigs/drake/r8.c | 619 +++++++++++++++++++++++++++++++++++++-------- 3 files changed, 526 insertions(+), 105 deletions(-) diff --git a/rigs/drake/drake.c b/rigs/drake/drake.c index 40806ed14..cf2024f74 100644 --- a/rigs/drake/drake.c +++ b/rigs/drake/drake.c @@ -67,6 +67,11 @@ int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, if (retval != RIG_OK) { + if ((data) && (data_len)) + { + data[0] = 0x00; + *data_len = 0; + } return retval; } @@ -81,15 +86,19 @@ int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, if (retval == -RIG_ETIMEOUT) { - retval = 0; + data[0] = 0x00; + *data_len = 0; } if (retval < 0) { + data[0] = 0x00; + *data_len = 0; return retval; } *data_len = retval; + data[*data_len] = 0x00; return RIG_OK; } diff --git a/rigs/drake/drake.h b/rigs/drake/drake.h index 13bd52c5f..b3ddae5a7 100644 --- a/rigs/drake/drake.h +++ b/rigs/drake/drake.h @@ -52,7 +52,6 @@ int drake_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val); int drake_set_powerstat (RIG * rig, powerstat_t status); int drake_get_powerstat (RIG * rig, powerstat_t *status); const char *drake_get_info(RIG *rig); -int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, int *data_len); extern struct rig_caps r8_caps; extern struct rig_caps r8a_caps; diff --git a/rigs/drake/r8.c b/rigs/drake/r8.c index 7d4ba90f2..ab5311434 100644 --- a/rigs/drake/r8.c +++ b/rigs/drake/r8.c @@ -25,7 +25,9 @@ //#include /* UNIX standard function definitions */ #include -//#include "serial.h" +#include "serial.h" +#include "misc.h" +#include "idx_builtin.h" //#include "cal.h" //#include "register.h" @@ -37,6 +39,8 @@ int drake_r8_set_vfo(RIG *rig, vfo_t vfo); int drake_r8_get_vfo(RIG *rig, vfo_t *vfo); int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width); int drake_r8_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width); +int drake_r8_init(RIG *rig); +int drake_r8_cleanup(RIG *rig); int drake_r8_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option); int drake_r8_get_ant(RIG *rig, vfo_t vfo, ant_t dummy, value_t *option, ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx); int drake_r8_set_mem(RIG *rig, vfo_t vfo, int ch); @@ -69,7 +73,7 @@ const char *drake_r8_get_info(RIG *rig); #define R8_FUNC (RIG_FUNC_MN|RIG_FUNC_NB|RIG_FUNC_NB2) -#define R8_LEVEL_ALL (RIG_LEVEL_PREAMP|RIG_LEVEL_ATT|RIG_LEVEL_AGC) +#define R8_LEVEL_ALL (RIG_LEVEL_PREAMP|RIG_LEVEL_ATT|RIG_LEVEL_AGC|RIG_LEVEL_RAWSTR|RIG_LEVEL_STRENGTH) #define R8_PARM_ALL (RIG_PARM_TIME) @@ -79,6 +83,11 @@ const char *drake_r8_get_info(RIG *rig); #define R8_ANTS (RIG_ANT_1|RIG_ANT_2|RIG_ANT_3) +#define R8_STR_CAL { 2, { \ + { 0, -60 }, \ + { 1, 0 }, \ + } } + /* * channel caps. */ @@ -108,7 +117,7 @@ struct rig_caps r8_caps = .status = RIG_STATUS_NEW, .rig_type = RIG_TYPE_RECEIVER, .ptt_type = RIG_PTT_NONE, - .dcd_type = RIG_DCD_SERIAL_CAR, + .dcd_type = RIG_DCD_NONE, .port_type = RIG_PORT_SERIAL, .serial_rate_min = 9600, .serial_rate_max = 9600, @@ -116,9 +125,9 @@ struct rig_caps r8_caps = .serial_stop_bits = 1, .serial_parity = RIG_PARITY_EVEN, .serial_handshake = RIG_HANDSHAKE_HARDWARE, - .write_delay = 0, - .post_write_delay = 1, - .timeout = 200, + .write_delay = 1, + .post_write_delay = 100, //1, + .timeout = 250, .retry = 3, .has_get_func = R8_FUNC, @@ -127,7 +136,11 @@ struct rig_caps r8_caps = .has_set_level = RIG_LEVEL_SET(R8_LEVEL_ALL), .has_get_parm = R8_PARM_ALL, .has_set_parm = RIG_PARM_SET(R8_PARM_ALL), - .level_gran = {}, + .level_gran = { + [LVL_RAWSTR] = { .min = { .i = 0 }, .max = { .i = 255 } }, + [LVL_ATT] = { .min = { .i = 0 }, .max = { .i = 10 } }, + [LVL_PREAMP] = { .min = { .i = 0 }, .max = { .i = 10 } }, + }, .parm_gran = {}, .ctcss_list = NULL, .dcs_list = NULL, @@ -138,9 +151,11 @@ struct rig_caps r8_caps = .max_ifshift = Hz(0), .targetable_vfo = 0, .transceive = RIG_TRN_OFF, + .vfo_ops = R8_VFO_OPS, + .scan_ops = 0, .bank_qty = 0, .chan_desc_sz = 0, - .vfo_ops = R8_VFO_OPS, + .priv = NULL, .chan_list = { { 0, 99, RIG_MTYPE_MEM, DRAKE_MEM_CAP }, @@ -185,11 +200,10 @@ struct rig_caps r8_caps = {RIG_MODE_CW, kHz(6)}, RIG_FLT_END, }, - .str_cal = {0,{}}, - .priv = NULL, + .str_cal = R8_STR_CAL, - .rig_init = drake_init, - .rig_cleanup = drake_cleanup, + .rig_init = drake_r8_init, + .rig_cleanup = drake_r8_cleanup, .set_freq = drake_r8_set_freq, .get_freq = drake_r8_get_freq, @@ -218,43 +232,42 @@ struct rig_caps r8_caps = * Function definitions below */ + /* * drake_r8_fix_string * recursively replaces all special characters so they are readable at output * */ -void drake_r8_fix_string(char** inStr) +void drake_r8_fix_string(char* inStr) { char chChkAry[3] = {0x20, 0x0d, 0x0a}; char* chRepAry[3] = {"", "", ""}; char* chPos; - char newStr[100]; - char* repStr; int newLen; - int i; int offset; + int i; + int j; - repStr = *inStr; for (i = 0; i < 3; i++) { do { - chPos = strchr(repStr, chChkAry[i]); + chPos = strchr(inStr, chChkAry[i]); if (chPos != NULL) { - offset = chPos - repStr; - strncpy(newStr, repStr, offset); - strcat(newStr, chRepAry[i]); - strcat(newStr, repStr + offset + 1); - newLen = strlen(repStr) + 3; - newStr[newLen] = 0x00; - free(repStr); - repStr = strdup((char*)newStr); + newLen = strlen(inStr); + offset = chPos - inStr; + for (j = newLen; j > offset; j--) + { + inStr[j+3] = inStr[j]; + } + for (j = 0; j < 4; j++) + { + inStr[offset+j] = chRepAry[i][j]; + } } } while (chPos); } - *inStr = strdup(repStr); - free(repStr); } @@ -264,38 +277,130 @@ void drake_r8_fix_string(char** inStr) */ void drake_r8_trans_rept(char* hdrStr, char* sentStr, int sentLen, char* recdStr, int recdLen, int res) { - char* sent; - char* recd; + char sent[BUFSZ]; + char recd[BUFSZ]; + char nullStr[7] = {'<','N','U','L','L','>',0x00}; + int i; //in most cases each string is a buffer, so we need to ensure both command and response //are not NULL and null-terminated before duplicastion and conversion. - if (sentStr != NULL) + if ((sentStr != NULL) && (sentLen > 0)) { - //sentStr[sentLen] = '\0'; - sent = strdup(sentStr); - drake_r8_fix_string(&sent); + for (i = 0; i < sentLen; i++) + sent[i] = sentStr[i]; + sent[sentLen] = 0x00; + drake_r8_fix_string((char*)sent); } else { - sent = strdup(""); + for (i = 0; i < 7; i++) + sent[i] = nullStr[i]; } - if (recdStr != NULL) + if ((recdStr != NULL) && (recdLen > 0)) { - //recdStr[recdLen] = '\0'; - recd = strdup(recdStr); - drake_r8_fix_string(&recd); + for (i = 0; i < recdLen; i++) + recd[i] = recdStr[i]; + recd[recdLen] = 0x00; + drake_r8_fix_string((char*)recd); } else { - recd = strdup(""); + for (i = 0; i < 7; i++) + recd[i] = nullStr[i]; } rig_debug(RIG_DEBUG_WARN, "Hamlib %s: Result %d - Sent %d chars: %s, Recd %d chars: %s\n", hdrStr, res, sentLen, sent, recdLen, recd); - free(sent); - free(recd); +} + + +/* + * drake_r8_transaction + * We assume that rig!=NULL, STATE(rig)!= NULL, data!=NULL, data_len!=NULL + */ +int drake_r8_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, + int *data_len) +{ + int retval; + hamlib_port_t *rp = RIGPORT(rig); + + rig_flush(rp); + + //fprintf(stderr, "Sending %d bytes: %s.\n", cmd_len, cmd); + retval = write_block(rp, (unsigned char *) cmd, cmd_len); + + if (retval != RIG_OK) + { + //fprintf(stderr, "Send error %d.\n", retval); + if ((data) && (data_len)) + { + data[0] = 0x00; + *data_len = 0; + } + return retval; + } + + /* no data expected, TODO: flush input? */ + if (!data || !data_len) + { + //fprintf(stderr, "No response expected.\n"); + return 0; + } + + //fprintf(stderr, "Receiving...\n"); + retval = read_string(rp, (unsigned char *) data, BUFSZ, + LF, 1, 0, 1); + + if (retval == -RIG_ETIMEOUT) + { + //fprintf(stderr, "Receive timeout.\n"); + data[0] = 0x00; + *data_len = 0; + } + + if (retval < 0) + { + //fprintf(stderr, "Receive error %d.\n", retval); + data[0] = 0x00; + *data_len = 0; + return retval; + } + + //fprintf(stderr, "Received %d bytes.\n", retval); + *data_len = retval; + data[*data_len] = 0x00; + + return RIG_OK; +} + + +int drake_r8_init(RIG *rig) +{ + struct drake_priv_data *priv; + STATE(rig)->priv = calloc(1, sizeof(struct drake_priv_data)); + + if (!STATE(rig)->priv) + { + return -RIG_ENOMEM; + } + + priv = STATE(rig)->priv; + + priv->curr_ch = 0; + + return RIG_OK; +} + + +int drake_r8_cleanup(RIG *rig) +{ + struct drake_priv_data *priv = STATE(rig)->priv; + + free(priv); + + return RIG_OK; } @@ -305,20 +410,30 @@ void drake_r8_trans_rept(char* hdrStr, char* sentStr, int sentLen, char* recdStr */ int drake_r8_set_freq(RIG *rig, vfo_t vfo, freq_t freq) { - unsigned char freqbuf[16], ackbuf[16]; + char freqbuf[16], ackbuf[16]; int ack_len, retval; /* * 10Hz resolution * TODO: round nearest? */ - SNPRINTF((char *) freqbuf, sizeof(freqbuf), "F%07u" EOM, - (unsigned int)freq / 10); - retval = drake_transaction(rig, (char *) freqbuf, strlen((char *)freqbuf), - (char *) ackbuf, - &ack_len); + SNPRINTF((char *) freqbuf, sizeof(freqbuf), "F%07u" EOM, (unsigned int)freq / 10); + + retval = drake_r8_transaction(rig, freqbuf, strlen(freqbuf), ackbuf, &ack_len); - drake_r8_trans_rept("set_freq", (char*)freqbuf, strlen((char*)freqbuf), (char*)ackbuf, ack_len, retval); + //let's trick it + /* + char testbuf[2] = {0x0d, 0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ackbuf[1] = testbuf[1]; + ack_len = 2; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("set_freq", freqbuf, strlen(freqbuf), ackbuf, ack_len, retval); return retval; } @@ -335,9 +450,22 @@ int drake_r8_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) double f; //char fmult; - retval = drake_transaction(rig, "RF" EOM, 3, freqbuf, &freq_len); + retval = drake_r8_transaction(rig, "RF" EOM, 3, freqbuf, &freq_len); - drake_r8_trans_rept("get_freq", "RF" EOM, 3, (char*)freqbuf, freq_len, retval); + //let's trick it + /* + char testbuf[15] = {' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; //mem off, ch 00, NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + if (freq_len == 0) + { + for (int i=0; i < 15; i++) { + freqbuf[i] = testbuf[i]; + } + freq_len = 15; + freqbuf[freq_len] = 0x00; + retval = RIG_OK; + }*/ + + drake_r8_trans_rept("get_freq", "RF" EOM, 3, freqbuf, freq_len, retval); if (retval != RIG_OK) { @@ -345,7 +473,7 @@ int drake_r8_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) } /* RA command returns fff.fffff*mHz */ - if (freq_len < 15) + if (freq_len != 15) { rig_debug(RIG_DEBUG_ERR, "drake_get_freq: wrong answer %s, " "len=%d\n", freqbuf, freq_len); @@ -370,7 +498,7 @@ int drake_r8_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) */ int drake_r8_set_vfo(RIG *rig, vfo_t vfo) { - unsigned char cmdbuf[16], ackbuf[16]; + char cmdbuf[16], ackbuf[16]; int ack_len, retval; char vfo_function; @@ -400,11 +528,20 @@ int drake_r8_set_vfo(RIG *rig, vfo_t vfo) SNPRINTF((char *) cmdbuf, sizeof(cmdbuf), "%c" EOM, vfo_function); } - retval = drake_transaction(rig, (char *) cmdbuf, strlen((char *)cmdbuf), - (char *) ackbuf, - &ack_len); + retval = drake_r8_transaction(rig, cmdbuf, strlen(cmdbuf), ackbuf, &ack_len); - drake_r8_trans_rept("set_vfo", (char*)cmdbuf, strlen((char*)cmdbuf), (char*)ackbuf, ack_len, retval); + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = RIG_OK; + }*/ + + drake_r8_trans_rept("set_vfo", cmdbuf, strlen(cmdbuf), ackbuf, ack_len, retval); return retval; } @@ -420,9 +557,22 @@ int drake_r8_get_vfo(RIG *rig, vfo_t *vfo) int mdbuf_len, retval; char mdbuf[BUFSZ]; - retval = drake_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_r8_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); - drake_r8_trans_rept("get_vfo", "RA" EOM, 3, (char*)mdbuf, mdbuf_len, retval); + //let's trick it + /* + char testbuf[25] = {' ','0','0',' ','2','0','2','<','8', ' ', ' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; //mem off, ch 00, NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + if (mdbuf_len == 0) + { + for (int i=0; i < 25; i++) { + mdbuf[i] = testbuf[i]; + } + mdbuf_len = 25; + mdbuf[mdbuf_len] = 0x00; + retval = RIG_OK; + }*/ + + drake_r8_trans_rept("get_vfo", "RA" EOM, 3, mdbuf, mdbuf_len, retval); if (retval != RIG_OK) { @@ -467,8 +617,8 @@ int drake_r8_get_vfo(RIG *rig, vfo_t *vfo) */ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { - unsigned char mdbuf[16], ackbuf[16]; - unsigned char mode_sel; + char mdbuf[16], ackbuf[16]; + char mode_sel; int ack_len, retval; switch (mode) @@ -493,11 +643,20 @@ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) } SNPRINTF((char *) mdbuf, sizeof(mdbuf), "M%c" EOM, mode_sel); - retval = drake_transaction(rig, (char *) mdbuf, strlen((char *)mdbuf), - (char *) ackbuf, - &ack_len); + retval = drake_r8_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); - drake_r8_trans_rept("set_mode", (char*)mdbuf, strlen((char*)mdbuf), (char*)ackbuf, ack_len, retval); + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("set_mode", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); if (retval != RIG_OK) { @@ -537,10 +696,20 @@ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) } SNPRINTF((char *) mdbuf, sizeof(mdbuf), "W%c" EOM, width_sel); - retval = drake_transaction(rig, (char *) mdbuf, strlen((char *)mdbuf), - (char *) ackbuf, - &ack_len); - drake_r8_trans_rept("set_bw", (char*)mdbuf, strlen((char*)mdbuf), (char*)ackbuf, ack_len, retval); + retval = drake_r8_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); + + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("set_bw", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); } } @@ -549,11 +718,20 @@ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { SNPRINTF((char *) mdbuf, sizeof(mdbuf), "S%c" EOM, (mode == RIG_MODE_AMS) ? 'O' : 'F'); - retval = drake_transaction(rig, (char *) mdbuf, strlen((char *)mdbuf), - (char *) ackbuf, - &ack_len); + retval = drake_r8_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); - drake_r8_trans_rept("set_synch", (char*)mdbuf, strlen((char*)mdbuf), (char*)ackbuf, ack_len, retval); + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("set_synch", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); } return retval; @@ -572,9 +750,22 @@ int drake_r8_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) char cwidth; char csynch; - retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_r8_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); - drake_r8_trans_rept("get_mode", "RM" EOM, 3, (char*)mdbuf, mdbuf_len, retval); + //let's trick it + /* + char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + if (mdbuf_len == 0) + { + for (int i=0; i < 7; i++) { + mdbuf[i] = testbuf[i]; + } + mdbuf_len = 7; + mdbuf[mdbuf_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("get_mode", "RM" EOM, 3, mdbuf, mdbuf_len, retval); if (retval != RIG_OK) { @@ -675,16 +866,26 @@ int drake_r8_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) */ int drake_r8_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) { - unsigned char buf[16], ackbuf[16]; + char buf[16], ackbuf[16]; int ack_len, retval; SNPRINTF((char *) buf, sizeof(buf), "A%c" EOM, ant == RIG_ANT_1 ? '1' : (ant == RIG_ANT_2 ? '2' : 'C')); - retval = drake_transaction(rig, (char *) buf, strlen((char *)buf), - (char *) ackbuf, &ack_len); + retval = drake_r8_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - drake_r8_trans_rept("set_ant", (char*)buf, strlen((char*)buf), (char*)ackbuf, ack_len, retval); + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("set_ant", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } @@ -701,7 +902,22 @@ int drake_r8_get_ant(RIG *rig, vfo_t vfo, ant_t dummy, value_t *option, char mdbuf[BUFSZ]; char cant; - retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_r8_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + + //let's trick it + /* + char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + if (mdbuf_len == 0) + { + for (int i=0; i < 7; i++) { + mdbuf[i] = testbuf[i]; + } + mdbuf_len = 7; + mdbuf[mdbuf_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("get_ant", "RM" EOM, 3, mdbuf, mdbuf_len, retval); if (retval != RIG_OK) { @@ -751,9 +967,21 @@ int drake_r8_set_mem(RIG *rig, vfo_t vfo, int ch) SNPRINTF(buf, sizeof(buf), "C%02d" , ch); ack_len = 0; // fix compile-time warning "possibly uninitialized" - retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + retval = drake_r8_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - drake_r8_trans_rept("set_mem", (char*)buf, strlen((char*)buf), (char*)ackbuf, ack_len, retval); + //let's trick it + /* + char testbuf[2] = {0x0d, 0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ackbuf[1] = testbuf[1]; + ack_len = 2; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("set_mem", buf, strlen(buf), ackbuf, ack_len, retval); if (ack_len != 2) { @@ -775,16 +1003,29 @@ int drake_r8_get_mem(RIG *rig, vfo_t vfo, int *ch) char mdbuf[BUFSZ]; int chan; - retval = drake_transaction(rig, "RC" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_r8_transaction(rig, "RC" EOM, 3, mdbuf, &mdbuf_len); - drake_r8_trans_rept("get_mem", "RC" EOM, 3, (char*)mdbuf, mdbuf_len, retval); + //let's trick it + /* + char testbuf[5] = {' ','0','0', 0x0d, 0x0a }; + if (mdbuf_len == 0) + { + for (int i=0; i < 5; i++) { + mdbuf[i] = testbuf[i]; + } + mdbuf_len = 5; + mdbuf[mdbuf_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("get_mem", "RC" EOM, 3, mdbuf, mdbuf_len, retval); if (retval != RIG_OK) { return retval; } - if (mdbuf_len < 5) + if (mdbuf_len != 5) { rig_debug(RIG_DEBUG_ERR, "drake_get_mem: wrong answer %s, " "len=%d\n", mdbuf, mdbuf_len); @@ -849,9 +1090,21 @@ int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) (chan->funcs & RIG_FUNC_MN) == RIG_FUNC_MN); SNPRINTF(mdbuf, sizeof(mdbuf), "PR" EOM "%02d" EOM, chan->channel_num); - retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); + retval = drake_r8_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); - drake_r8_trans_rept("set_chan", (char*)mdbuf, strlen((char*)mdbuf), (char*)ackbuf, ack_len, retval); + //let's trick it + /* + char testbuf[2] = {0x0d, 0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ackbuf[1] = testbuf[1]; + ack_len = 2; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("set_chan", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); if (old_vfo == RIG_VFO_MEM) { @@ -918,7 +1171,9 @@ int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) } //now decipher it - retval = drake_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_r8_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); + + drake_r8_trans_rept("get_chan", "RA" EOM, 3, mdbuf, mdbuf_len, retval); if (retval != RIG_OK) { @@ -1100,10 +1355,25 @@ int drake_r8_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) } len = strlen(buf); - retval = drake_transaction(rig, buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, - &ack_len); + retval = drake_r8_transaction(rig, buf, len, len == 1 ? ackbuf : NULL, + len == 1 ? &ack_len : NULL); - drake_r8_trans_rept("vfo_op", (char*)buf, len, buf[len - 1] == 0x0d ? (char*)ackbuf : NULL, ack_len, retval); + //let's trick it + /* + if ((op == RIG_OP_TO_VFO) || (op == RIG_OP_FROM_VFO)) + { + char testbuf[2] = {0x0d, 0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ackbuf[1] = testbuf[1]; + ack_len = 2; + ackbuf[ack_len] = 0x00; + retval = 0; + } + }*/ + + drake_r8_trans_rept("vfo_op", buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, ack_len, retval); return retval; } @@ -1140,9 +1410,20 @@ int drake_r8_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) return -RIG_EINVAL; } - retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + retval = drake_r8_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - drake_r8_trans_rept("set_func", (char*)buf, strlen((char*)buf), (char*)ackbuf, ack_len, retval); + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("set_func", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } @@ -1159,7 +1440,22 @@ int drake_r8_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) char mc; char blanker; - retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_r8_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + + //let's trick it + /* + char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + if (mdbuf_len == 0) + { + for (int i=0; i < 7; i++) { + mdbuf[i] = testbuf[i]; + } + mdbuf_len = 7; + mdbuf[mdbuf_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("get_func", "RM" EOM, 3, mdbuf, mdbuf_len, retval); if (retval != RIG_OK) { @@ -1232,9 +1528,20 @@ int drake_r8_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) return -RIG_EINVAL; } - retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + retval = drake_r8_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - drake_r8_trans_rept("set_level", (char*)buf, strlen((char*)buf), (char*)ackbuf, ack_len, retval); + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("set_level", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } @@ -1250,7 +1557,47 @@ int drake_r8_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) char lvlbuf[BUFSZ]; char mc; - retval = drake_transaction(rig, "RM" EOM, 3, lvlbuf, &lvl_len); + if ((level == RIG_LEVEL_STRENGTH) || (level == RIG_LEVEL_RAWSTR)) + { + retval = drake_r8_transaction(rig, "RA" EOM, 3, lvlbuf, &lvl_len); + + //let's trick it + /* + char testbuf[25] = {' ','0','0',' ','2','0','2','<','8', ' ', ' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; //mem off, ch 00, NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + if (lvl_len == 0) + { + for (int i=0; i < 25; i++) { + lvlbuf[i] = testbuf[i]; + } + lvl_len = 25; + lvlbuf[lvl_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("get_level", "RA" EOM, 3, lvlbuf, lvl_len, retval); + + } + else + { + retval = drake_r8_transaction(rig, "RM" EOM, 3, lvlbuf, &lvl_len); + + //let's trick it + /* + char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + if (lvl_len == 0) + { + for (int i=0; i < 7; i++) { + lvlbuf[i] = testbuf[i]; + } + lvl_len = 7; + lvlbuf[lvl_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("get_level", "RM" EOM, 3, lvlbuf, lvl_len, retval); + + } + if (retval != RIG_OK) { @@ -1310,6 +1657,34 @@ int drake_r8_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) break; + case RIG_LEVEL_RAWSTR: + mc = lvlbuf[19]; + + switch (mc) + { + case ' ': val->i = 0; break; + + case '#': val->i = 1; break; + + default : val->i = 0; + } + + break; + + case RIG_LEVEL_STRENGTH: + mc = lvlbuf[19]; + + switch (mc) + { + case ' ': val->i = -60; break; + + case '#': val->i = 0; break; + + default : val->i = -60; + } + + break; + default: rig_debug(RIG_DEBUG_ERR, "Unsupported get_level %s\n", rig_strlevel(level)); return -RIG_EINVAL; @@ -1326,10 +1701,21 @@ int drake_r8_set_powerstat(RIG *rig, powerstat_t status) SNPRINTF(buf, sizeof(buf), "P%c" EOM, status == RIG_POWER_OFF ? 'F' : 'O'); - retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + retval = drake_r8_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - drake_r8_trans_rept("set_power", (char*)buf, strlen((char*)buf), (char*)ackbuf, ack_len, retval); + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + drake_r8_trans_rept("set_power", buf, strlen(buf), ackbuf, ack_len, retval); + return retval; } @@ -1339,7 +1725,22 @@ int drake_r8_get_powerstat(RIG *rig, powerstat_t *status) int mdlen, retval; char mdbuf[BUFSZ]; - retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdlen); + retval = drake_r8_transaction(rig, "RM" EOM, 3, &mdbuf[0], &mdlen); + + //let's trick it + /* + char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + if (mdlen == 0) + { + for (int i=0; i < 7; i++) { + mdbuf[i] = testbuf[i]; + } + mdlen = 7; + mdbuf[mdlen] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("get_power", "RM" EOM, 3, mdbuf, mdlen, retval); if (retval != RIG_OK) { @@ -1361,16 +1762,28 @@ const char *drake_r8_get_info(RIG *rig) static char idbuf[BUFSZ]; int retval, id_len; - retval = drake_transaction(rig, "ID" EOM, 3, idbuf, &id_len); + retval = drake_r8_transaction(rig, "ID" EOM, 3, idbuf, &id_len); - drake_r8_trans_rept("get_id", "ID" EOM, 3, (char*)idbuf, id_len, retval); + //let's trick it + /* + char testbuf[4] = {'R','8',0x0d,0x0a}; + if (id_len == 0) + { + for (int i = 0; i < 4; i++) + idbuf[i] = testbuf[i]; + id_len = 4; + idbuf[id_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept("get_id", "ID" EOM, 3, idbuf, id_len, retval); if (retval != RIG_OK) { return NULL; } - idbuf[id_len] = '\0'; + idbuf[id_len - 2] = '\0'; return idbuf; } From 03bf68c45925999af7aaf31af8f7cb01d1397f89 Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Mon, 30 Jun 2025 21:30:49 -0400 Subject: [PATCH 03/16] Removed redundant timout-specific error block. --- rigs/drake/drake.c | 10 +++++----- rigs/drake/r8.c | 10 +++++----- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/rigs/drake/drake.c b/rigs/drake/drake.c index cf2024f74..9778d9525 100644 --- a/rigs/drake/drake.c +++ b/rigs/drake/drake.c @@ -84,11 +84,11 @@ int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, retval = read_string(rp, (unsigned char *) data, BUFSZ, LF, 1, 0, 1); - if (retval == -RIG_ETIMEOUT) - { - data[0] = 0x00; - *data_len = 0; - } + //if (retval == -RIG_ETIMEOUT) + //{ + //data[0] = 0x00; + //*data_len = 0; + //} if (retval < 0) { diff --git a/rigs/drake/r8.c b/rigs/drake/r8.c index ab5311434..0183d47e7 100644 --- a/rigs/drake/r8.c +++ b/rigs/drake/r8.c @@ -353,12 +353,12 @@ int drake_r8_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, retval = read_string(rp, (unsigned char *) data, BUFSZ, LF, 1, 0, 1); - if (retval == -RIG_ETIMEOUT) - { + //if (retval == -RIG_ETIMEOUT) + //{ //fprintf(stderr, "Receive timeout.\n"); - data[0] = 0x00; - *data_len = 0; - } + //data[0] = 0x00; + //*data_len = 0; + //} if (retval < 0) { From e1562e675feb19b302c445363af0fe791dd6b748 Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Tue, 1 Jul 2025 23:47:41 -0400 Subject: [PATCH 04/16] Organized most of the redundant rig freq, mode, mem, and all reporting into their individual routines that decode and pool most of the 'get' settings into the private data area. --- rigs/drake/drake.h | 15 +- rigs/drake/r8.c | 1092 +++++++++++++++++++------------------------- 2 files changed, 489 insertions(+), 618 deletions(-) diff --git a/rigs/drake/drake.h b/rigs/drake/drake.h index b3ddae5a7..246cc7a38 100644 --- a/rigs/drake/drake.h +++ b/rigs/drake/drake.h @@ -27,7 +27,20 @@ #define BACKEND_VER "20200319" struct drake_priv_data { - int curr_ch; + int curr_ch; + dcd_t curr_dcd; + freq_t curr_freq; + ant_t curr_ant; + vfo_t curr_vfo; + int curr_agc; + rmode_t curr_mode; + pbwidth_t curr_width; + int curr_nb; + int curr_nb2; + int curr_att; + int curr_pre; + int curr_notch; + int curr_pwr; }; int drake_set_freq(RIG *rig, vfo_t vfo, freq_t freq); diff --git a/rigs/drake/r8.c b/rigs/drake/r8.c index 0183d47e7..5849a6591 100644 --- a/rigs/drake/r8.c +++ b/rigs/drake/r8.c @@ -358,6 +358,7 @@ int drake_r8_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, //fprintf(stderr, "Receive timeout.\n"); //data[0] = 0x00; //*data_len = 0; + //retval = 0; //} if (retval < 0) @@ -389,6 +390,18 @@ int drake_r8_init(RIG *rig) priv = STATE(rig)->priv; priv->curr_ch = 0; + priv->curr_dcd = RIG_DCD_OFF; + priv->curr_freq = 0.0; + priv->curr_ant = RIG_ANT_1; + priv->curr_vfo = RIG_VFO_VFO; + priv->curr_agc = RIG_AGC_OFF; + priv->curr_mode = RIG_MODE_NONE; + priv->curr_width = RIG_PASSBAND_NORMAL; + priv->curr_nb = false; + priv->curr_nb2 = false; + priv->curr_att = false; + priv->curr_pre = false; + priv->curr_pwr = false; return RIG_OK; } @@ -404,6 +417,361 @@ int drake_r8_cleanup(RIG *rig) } +/* + * drake_decode_frequency + * Common routine to decode the frequency block + */ +void drake_r8_decode_frequency(RIG *rig, char* freqbuf, int offset) +{ + double f; + char fmult; + struct drake_priv_data *priv = STATE(rig)->priv; + + switch (freqbuf[9+offset]) + { + case ' ' : priv->curr_dcd = RIG_DCD_OFF; break; + + case '#' : priv->curr_dcd = RIG_DCD_ON; break; + + default : priv->curr_dcd = RIG_DCD_OFF; + } + + fmult = freqbuf[10+offset]; + + freqbuf[9+offset] = '\0'; + /* extract freq */ + sscanf(freqbuf+offset, "%lf", &f); + f *= 1000.0; + + if ((fmult == 'm') || (fmult == 'M')) + f *= 1000.0; + + priv->curr_freq = (freq_t)f; +} + + +/* + * drake_report_freq + * Common routine to retrieve frequency and dcd settings + * Data stored in priv for any routine to use + * Assumes rig!=NULL + */ +int drake_r8_report_frequency(RIG *rig, char* owner) +{ + int freq_len; + int retval; + char freqbuf[BUFSZ]; + + retval = drake_r8_transaction(rig, "RF" EOM, 3, freqbuf, &freq_len); + + //let's trick it + /* + char testbuf[15] = {' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; + if (freq_len == 0) + { + for (int i=0; i < 15; i++) { + freqbuf[i] = testbuf[i]; + } + freq_len = 15; + freqbuf[freq_len] = 0x00; + retval = RIG_OK; + }*/ + + drake_r8_trans_rept(owner, "RF" EOM, 3, freqbuf, freq_len, retval); + + if (retval != RIG_OK) + { + return retval; + } + + if (freq_len != 15) + { + rig_debug(RIG_DEBUG_ERR, "%s: wrong answer %s, " + "len=%d\n", owner, freqbuf, freq_len); + return -RIG_ERJCTED; + } + + drake_r8_decode_frequency(rig, freqbuf, 0); + + return RIG_OK; +} + + +/* + * drake_decode_mode + * Common routine to break out the 5-character mode string + */ +void drake_r8_decode_mode(RIG *rig, char* mdbuf, int offset) +{ + struct drake_priv_data *priv = STATE(rig)->priv; + + //noise blanker + priv->curr_nb = ((mdbuf[offset] >= '<') && (mdbuf[offset] <= '?')); + priv->curr_nb2 = ((mdbuf[offset] >= '4') && (mdbuf[offset] <= '7')); + + //agc + switch (mdbuf[offset] & 0x33) + { + case '0': priv->curr_agc = RIG_AGC_OFF; break; + + case '2': priv->curr_agc = RIG_AGC_FAST; break; + + case '3': priv->curr_agc = RIG_AGC_SLOW; break; + + default : priv->curr_agc = RIG_AGC_OFF; + } + + //preamp, attenuator and notch + priv->curr_pre = ((mdbuf[1+offset] & 0x3c) == '8'); + priv->curr_att = ((mdbuf[1+offset] & 0x3c) == '4'); + priv->curr_notch = ((mdbuf[1+offset] & 0x32) == '2'); + + //ant + switch (mdbuf[2+offset] & 0x3c) + { + case '0': priv->curr_ant = RIG_ANT_1; break; + + case '4': priv->curr_ant = RIG_ANT_3; break; + + case '8': priv->curr_ant = RIG_ANT_2; break; + + default : priv->curr_ant = RIG_ANT_1; + } + + //width + switch (mdbuf[3+offset] & 0x37) + { + case '0': priv->curr_width = s_Hz(500); break; + + case '1': priv->curr_width = s_Hz(1800); break; + + case '2': priv->curr_width = s_Hz(2300); break; + + case '3': priv->curr_width = s_Hz(4000); break; + + case '4': priv->curr_width = s_Hz(6000); break; + + default : priv->curr_width = RIG_PASSBAND_NORMAL; + } + + //mode + if ((mdbuf[3+offset] >= '0') && (mdbuf[3+offset] <= '4')) + { + switch (mdbuf[2+offset] & 0x33) + { + case '0': priv->curr_mode = RIG_MODE_LSB; break; + + case '1': priv->curr_mode = RIG_MODE_RTTY; break; + + case '2': priv->curr_mode = RIG_MODE_FM; priv->curr_width = s_Hz(12000); break; + + default : priv->curr_mode = RIG_MODE_NONE; + } + } + else + { + switch (mdbuf[2+offset] & 0x33) + { + case '0': priv->curr_mode = RIG_MODE_USB; break; + + case '1': priv->curr_mode = RIG_MODE_CW; break; + + case '2': priv->curr_mode = RIG_MODE_AM; break; + + default : priv->curr_mode = RIG_MODE_NONE; + } + } + //synch + if ((mdbuf[4+offset] & 0x34) == '4') + { + if (priv->curr_mode == RIG_MODE_AM) + { + priv->curr_mode = RIG_MODE_AMS; + } + else if (priv->curr_mode == RIG_MODE_USB) + { + priv->curr_mode = RIG_MODE_ECSSUSB; + } + else if (priv->curr_mode == RIG_MODE_LSB) + { + priv->curr_mode = RIG_MODE_ECSSLSB; + } + } + + //vfo + switch (mdbuf[4+offset] & 0x38) + { + case '0' : priv->curr_vfo = RIG_VFO_B; break; + + case '8' : priv->curr_vfo = RIG_VFO_A; break; + + default : priv->curr_vfo = RIG_VFO_VFO; + } +} + + +/* + * drake_report_mode + * Common routine to retrieve NB, AGC, ATT, PRE, NF, ANT, MODE, BW, and VFO (and scanning) settings + * Data stored in priv for any routine to use + * Assumes rig!=NULL + */ +int drake_r8_report_mode(RIG *rig, char* owner) +{ + int mdbuf_len; + int retval; + char mdbuf[BUFSZ]; + struct drake_priv_data *priv = STATE(rig)->priv; + + retval = drake_r8_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + + //let's trick it + /* + char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + if (mdbuf_len == 0) + { + for (int i=0; i < 7; i++) { + mdbuf[i] = testbuf[i]; + } + mdbuf_len = 7; + mdbuf[mdbuf_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept(owner, "RM" EOM, 3, mdbuf, mdbuf_len, retval); + + if (retval != RIG_OK) + { + return retval; + } + + if (mdbuf_len != 7) + { + priv->curr_pwr = false; + rig_debug(RIG_DEBUG_ERR, "%s: wrong answer %s, " + "len=%d\n", owner, mdbuf, mdbuf_len); + return -RIG_ERJCTED; + } + + priv->curr_pwr = true; + drake_r8_decode_mode(rig, mdbuf, 0); + + return RIG_OK; +} + + +/* + * drake_r8_decode_mem_channel + * Common routine to break out the 3-character mem string + */ +void drake_r8_decode_mem_channel(RIG *rig, char* mdbuf, int offset) +{ + struct drake_priv_data *priv = STATE(rig)->priv; + + if (mdbuf[offset] == '*') + { + priv->curr_vfo = RIG_VFO_MEM; + } + + priv->curr_ch = (mdbuf[1+offset] & 0x0f) * 10 + (mdbuf[2+offset] & 0x0f); +} + +/* + * drake_report_mem_channel + * Common routine to retrieve the memory channel number + * Data stored in priv for any routine to use + * Assumes rig!=NULL + */ +int drake_r8_report_mem_channel(RIG *rig, char* owner) +{ + int mdbuf_len; + int retval; + char mdbuf[BUFSZ]; + + retval = drake_r8_transaction(rig, "RC" EOM, 3, mdbuf, &mdbuf_len); + + //let's trick it + /* + char testbuf[5] = {' ','0','0', 0x0d, 0x0a }; + if (mdbuf_len == 0) + { + for (int i=0; i < 5; i++) { + mdbuf[i] = testbuf[i]; + } + mdbuf_len = 5; + mdbuf[mdbuf_len] = 0x00; + retval = 0; + }*/ + + drake_r8_trans_rept(owner, "RC" EOM, 3, mdbuf, mdbuf_len, retval); + + if (retval != RIG_OK) + { + return retval; + } + + if (mdbuf_len != 5) + { + rig_debug(RIG_DEBUG_ERR, "%s: wrong answer %s, " + "len=%d\n", owner, mdbuf, mdbuf_len); + return -RIG_ERJCTED; + } + + drake_r8_decode_mem_channel(rig, mdbuf, 0); + + return RIG_OK; +} + + +/* + * drake_report_all + * Common routine to retrieve all of the radio's settings + * Data stored in priv for any routine to use + * Assumes rig!=NULL + */ +int drake_r8_report_all(RIG *rig, char* owner) +{ + int mdbuf_len; + int retval; + char mdbuf[BUFSZ]; + + retval = drake_r8_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); + + //let's trick it + /* + char testbuf[25] = {' ','0','0',' ','2','0','2','<','8', ' ', ' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; //mem off, ch 00, NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + if (mdbuf_len == 0) + { + for (int i=0; i < 25; i++) { + mdbuf[i] = testbuf[i]; + } + mdbuf_len = 25; + mdbuf[mdbuf_len] = 0x00; + retval = RIG_OK; + }*/ + + drake_r8_trans_rept(owner, "RA" EOM, 3, mdbuf, mdbuf_len, retval); + + if (retval != RIG_OK) + { + return retval; + } + + if (mdbuf_len != 25) + { + rig_debug(RIG_DEBUG_ERR, "%s: wrong answer %s, " + "len=%d\n", owner, mdbuf, mdbuf_len); + return -RIG_ERJCTED; + } + + drake_r8_decode_mem_channel(rig, mdbuf, 0); + drake_r8_decode_mode(rig, mdbuf, 4); + drake_r8_decode_frequency(rig, mdbuf, 10); + + return RIG_OK; +} + + /* * drake_set_freq * Assumes rig!=NULL @@ -433,7 +801,7 @@ int drake_r8_set_freq(RIG *rig, vfo_t vfo, freq_t freq) retval = 0; }*/ - drake_r8_trans_rept("set_freq", freqbuf, strlen(freqbuf), ackbuf, ack_len, retval); + drake_r8_trans_rept("drake_set_freq", freqbuf, strlen(freqbuf), ackbuf, ack_len, retval); return retval; } @@ -445,50 +813,17 @@ int drake_r8_set_freq(RIG *rig, vfo_t vfo, freq_t freq) */ int drake_r8_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) { - int freq_len, retval; - char freqbuf[BUFSZ]; - double f; - //char fmult; + int retval; + struct drake_priv_data *priv = STATE(rig)->priv; + + retval = drake_r8_report_frequency(rig, "drake_get_freq"); - retval = drake_r8_transaction(rig, "RF" EOM, 3, freqbuf, &freq_len); - - //let's trick it - /* - char testbuf[15] = {' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; //mem off, ch 00, NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning - if (freq_len == 0) + if (retval == RIG_OK) { - for (int i=0; i < 15; i++) { - freqbuf[i] = testbuf[i]; - } - freq_len = 15; - freqbuf[freq_len] = 0x00; - retval = RIG_OK; - }*/ - - drake_r8_trans_rept("get_freq", "RF" EOM, 3, freqbuf, freq_len, retval); - - if (retval != RIG_OK) - { - return retval; + *freq = priv->curr_freq; } - /* RA command returns fff.fffff*mHz */ - if (freq_len != 15) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_freq: wrong answer %s, " - "len=%d\n", freqbuf, freq_len); - return -RIG_ERJCTED; - } - - freqbuf[9] = '\0'; - - /* extract freq */ - sscanf(freqbuf + 1, "%lf", &f); - f *= 1000000.0; - - *freq = (freq_t)f; - - return RIG_OK; + return retval; } @@ -541,7 +876,7 @@ int drake_r8_set_vfo(RIG *rig, vfo_t vfo) retval = RIG_OK; }*/ - drake_r8_trans_rept("set_vfo", cmdbuf, strlen(cmdbuf), ackbuf, ack_len, retval); + drake_r8_trans_rept("drake_set_vfo", cmdbuf, strlen(cmdbuf), ackbuf, ack_len, retval); return retval; } @@ -554,60 +889,17 @@ int drake_r8_set_vfo(RIG *rig, vfo_t vfo) */ int drake_r8_get_vfo(RIG *rig, vfo_t *vfo) { - int mdbuf_len, retval; - char mdbuf[BUFSZ]; + int retval; + struct drake_priv_data *priv = STATE(rig)->priv; + + retval = drake_r8_report_all(rig, "drake_get_vfo"); - retval = drake_r8_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); - - //let's trick it - /* - char testbuf[25] = {' ','0','0',' ','2','0','2','<','8', ' ', ' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; //mem off, ch 00, NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning - if (mdbuf_len == 0) + if (retval == RIG_OK) { - for (int i=0; i < 25; i++) { - mdbuf[i] = testbuf[i]; - } - mdbuf_len = 25; - mdbuf[mdbuf_len] = 0x00; - retval = RIG_OK; - }*/ - - drake_r8_trans_rept("get_vfo", "RA" EOM, 3, mdbuf, mdbuf_len, retval); - - if (retval != RIG_OK) - { - return retval; + *vfo = priv->curr_vfo; } - if (mdbuf_len != 25) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_vfo: wrong answer %s, " - "len=%d\n", mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - if (mdbuf[0] == '*') - { - *vfo = RIG_VFO_MEM; - } - else - { - char cvfo = (mdbuf[8] & 0x38); - - switch (cvfo) - { - case '0' : *vfo = RIG_VFO_B; break; - - case '8' : *vfo = RIG_VFO_A; break; - - default : rig_debug(RIG_DEBUG_ERR, - "drake_get_vfo: unsupported vfo %c\n", cvfo); - *vfo = RIG_VFO_VFO; - return -RIG_EINVAL; - } - } - - return RIG_OK; + return retval; } @@ -656,7 +948,7 @@ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) retval = 0; }*/ - drake_r8_trans_rept("set_mode", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + drake_r8_trans_rept("drake_set_mode", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); if (retval != RIG_OK) { @@ -709,7 +1001,7 @@ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) retval = 0; }*/ - drake_r8_trans_rept("set_bw", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + drake_r8_trans_rept("drake_set_bw", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); } } @@ -731,7 +1023,7 @@ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) retval = 0; }*/ - drake_r8_trans_rept("set_synch", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + drake_r8_trans_rept("drake_set_synch", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); } return retval; @@ -744,119 +1036,18 @@ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) */ int drake_r8_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) { - int mdbuf_len, retval; - char mdbuf[BUFSZ]; - char cmode; - char cwidth; - char csynch; + int retval; + struct drake_priv_data *priv = STATE(rig)->priv; + + retval = drake_r8_report_mode(rig, "drake_get_mode"); - retval = drake_r8_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); - - //let's trick it - /* - char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning - if (mdbuf_len == 0) + if (retval == RIG_OK) { - for (int i=0; i < 7; i++) { - mdbuf[i] = testbuf[i]; - } - mdbuf_len = 7; - mdbuf[mdbuf_len] = 0x00; - retval = 0; - }*/ - - drake_r8_trans_rept("get_mode", "RM" EOM, 3, mdbuf, mdbuf_len, retval); - - if (retval != RIG_OK) - { - return retval; + *mode = priv->curr_mode; + *width = priv->curr_width; } - - if (mdbuf_len < 7) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_mode: wrong answer %s, " - "len=%d\n", mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - cmode = mdbuf[2]; - cwidth = mdbuf[3]; - csynch = mdbuf[4]; - - switch (cwidth & 0x37) - { - case '0': *width = s_Hz(500); break; - - case '1': *width = s_Hz(1800); break; - - case '2': *width = s_Hz(2300); break; - - case '3': *width = s_Hz(4000); break; - - case '4': *width = s_Hz(6000); break; - - default : - rig_debug(RIG_DEBUG_ERR, - "drake_get_mode: unsupported width %c\n", - cwidth); - *width = RIG_PASSBAND_NORMAL; - return -RIG_EINVAL; - } - - if ((cwidth >= '0') && (cwidth <= '4')) - { - switch (cmode & 0x33) - { - case '0': *mode = RIG_MODE_LSB; break; - - case '1': *mode = RIG_MODE_RTTY; break; - - case '2': *mode = RIG_MODE_FM; *width = s_Hz(12000); break; - - default : - rig_debug(RIG_DEBUG_ERR, - "drake_get_mode: unsupported mode %c\n", - cmode); - *mode = RIG_MODE_NONE; - return -RIG_EINVAL; - } - } - else - { - switch (cmode & 0x33) - { - case '0': *mode = RIG_MODE_USB; break; - - case '1': *mode = RIG_MODE_CW; break; - - case '2': *mode = RIG_MODE_AM; break; - - default : - rig_debug(RIG_DEBUG_ERR, - "drake_get_mode: unsupported mode %c\n", - cmode); - *mode = RIG_MODE_NONE; - return -RIG_EINVAL; - } - } - - if ((csynch & 0x34) == '4') - { - if (*mode == RIG_MODE_AM) - { - *mode = RIG_MODE_AMS; - } - else if (*mode == RIG_MODE_USB) - { - *mode = RIG_MODE_ECSSUSB; - } - else if (*mode == RIG_MODE_LSB) - { - *mode = RIG_MODE_ECSSLSB; - } - } - - return RIG_OK; + + return retval; } @@ -885,7 +1076,7 @@ int drake_r8_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) retval = 0; }*/ - drake_r8_trans_rept("set_ant", buf, strlen(buf), ackbuf, ack_len, retval); + drake_r8_trans_rept("drake_set_ant", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } @@ -898,57 +1089,17 @@ int drake_r8_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) int drake_r8_get_ant(RIG *rig, vfo_t vfo, ant_t dummy, value_t *option, ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx) { - int mdbuf_len, retval; - char mdbuf[BUFSZ]; - char cant; + int retval; + struct drake_priv_data *priv = STATE(rig)->priv; + + retval = drake_r8_report_mode(rig, "drake_get_ant"); - retval = drake_r8_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); - - //let's trick it - /* - char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning - if (mdbuf_len == 0) + if (retval == RIG_OK) { - for (int i=0; i < 7; i++) { - mdbuf[i] = testbuf[i]; - } - mdbuf_len = 7; - mdbuf[mdbuf_len] = 0x00; - retval = 0; - }*/ - - drake_r8_trans_rept("get_ant", "RM" EOM, 3, mdbuf, mdbuf_len, retval); - - if (retval != RIG_OK) - { - return retval; + *ant_curr = priv->curr_ant; } - - if (mdbuf_len < 7) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_ant: wrong answer %s, " - "len=%d\n", mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - cant = mdbuf[2]; - - switch (cant & 0x3c) - { - case '0': *ant_curr = RIG_ANT_1; break; - - case '4': *ant_curr = RIG_ANT_3; break; - - case '8': *ant_curr = RIG_ANT_2; break; - - default : - rig_debug(RIG_DEBUG_ERR, - "drake_get_ant: unsupported antenna %c\n", - cant); - return -RIG_EINVAL; - } - - return RIG_OK; + + return retval; } @@ -981,7 +1132,7 @@ int drake_r8_set_mem(RIG *rig, vfo_t vfo, int ch) retval = 0; }*/ - drake_r8_trans_rept("set_mem", buf, strlen(buf), ackbuf, ack_len, retval); + drake_r8_trans_rept("drake_set_mem", buf, strlen(buf), ackbuf, ack_len, retval); if (ack_len != 2) { @@ -998,49 +1149,17 @@ int drake_r8_set_mem(RIG *rig, vfo_t vfo, int ch) */ int drake_r8_get_mem(RIG *rig, vfo_t vfo, int *ch) { + int retval; struct drake_priv_data *priv = STATE(rig)->priv; - int mdbuf_len, retval; - char mdbuf[BUFSZ]; - int chan; + + retval = drake_r8_report_mode(rig, "drake_get_mem"); - retval = drake_r8_transaction(rig, "RC" EOM, 3, mdbuf, &mdbuf_len); - - //let's trick it - /* - char testbuf[5] = {' ','0','0', 0x0d, 0x0a }; - if (mdbuf_len == 0) + if (retval == RIG_OK) { - for (int i=0; i < 5; i++) { - mdbuf[i] = testbuf[i]; - } - mdbuf_len = 5; - mdbuf[mdbuf_len] = 0x00; - retval = 0; - }*/ - - drake_r8_trans_rept("get_mem", "RC" EOM, 3, mdbuf, mdbuf_len, retval); - - if (retval != RIG_OK) - { - return retval; + *ch = priv->curr_ch; } - - if (mdbuf_len != 5) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_mem: wrong answer %s, " - "len=%d\n", mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - mdbuf[3] = '\0'; - - /* extract channel no */ - sscanf(mdbuf + 1, "%02d", &chan); - *ch = chan; - - priv->curr_ch = chan; - - return RIG_OK; + + return retval; } @@ -1104,7 +1223,7 @@ int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) retval = 0; }*/ - drake_r8_trans_rept("set_chan", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + drake_r8_trans_rept("drake_set_chan", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); if (old_vfo == RIG_VFO_MEM) { @@ -1124,8 +1243,7 @@ int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) const struct drake_priv_data *priv = STATE(rig)->priv; vfo_t old_vfo; int old_chan; - char mdbuf[BUFSZ], freqstr[BUFSZ]; - int mdbuf_len, retval; + int retval; chan->vfo = RIG_VFO_MEM; chan->ant = RIG_ANT_NONE; @@ -1170,132 +1288,35 @@ int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) return RIG_OK; } - //now decipher it - retval = drake_r8_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); - - drake_r8_trans_rept("get_chan", "RA" EOM, 3, mdbuf, mdbuf_len, retval); + retval = drake_r8_report_all(rig, "drake_get_chan"); if (retval != RIG_OK) { - return retval; + return RIG_OK; } - if (mdbuf_len != 25) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_channel: wrong answer %s, " - "len=%d\n", mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - if ((mdbuf[4] >= '<') && (mdbuf[4] <= '?')) + if (priv->curr_nb) { chan->funcs |= RIG_FUNC_NB; } - if ((mdbuf[4] >= '4') && (mdbuf[4] <= '7')) + if (priv->curr_nb2) { chan->funcs |= RIG_FUNC_NB2; } - switch (mdbuf[4] & 0x33) - { - case '0': chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_OFF; break; + chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = priv->curr_agc; + chan->levels[rig_setting2idx(RIG_LEVEL_PREAMP)].i = (priv->curr_pre ? 10 : 0); + chan->levels[rig_setting2idx(RIG_LEVEL_ATT)].i = (priv->curr_att ? 10 : 0); - case '2': chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_FAST; break; - - case '3': chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_SLOW; break; - - default : chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_FAST; - } - - if ((mdbuf[5] & 0x3c) == '8') - { - chan->levels[rig_setting2idx(RIG_LEVEL_PREAMP)].i = 10; - } - - if ((mdbuf[5] & 0x3c) == '4') - { - chan->levels[rig_setting2idx(RIG_LEVEL_ATT)].i = 10; - } - - if ((mdbuf[5] & 0x32) == '2') + if (priv->curr_notch) { chan->funcs |= RIG_FUNC_MN; } - - switch (mdbuf[6] & 0x3c) - { - case '0': chan->ant = RIG_ANT_1; break; - - case '4': chan->ant = RIG_ANT_3; break; - - case '8': chan->ant = RIG_ANT_2; break; - - default : chan->ant = RIG_ANT_NONE; - } - - switch (mdbuf[7] & 0x37) - { - case '0': chan->width = s_Hz(500); break; - - case '1': chan->width = s_Hz(1800); break; - - case '2': chan->width = s_Hz(2300); break; - - case '3': chan->width = s_Hz(4000); break; - - case '4': chan->width = s_Hz(6000); break; - - default : chan->width = RIG_PASSBAND_NORMAL; - } - - if ((mdbuf[7] >= '0') && (mdbuf[7] <= '4')) - { - switch (mdbuf[6] & 0x33) - { - case '0': chan->mode = RIG_MODE_LSB; break; - - case '1': chan->mode = RIG_MODE_RTTY; break; - - case '2': chan->mode = RIG_MODE_FM; - chan->width = s_Hz(12000); break; - - default : chan->mode = RIG_MODE_NONE; - } - } - else - { - switch (mdbuf[6] & 0x33) - { - case '0': chan->mode = RIG_MODE_USB; break; - - case '1': chan->mode = RIG_MODE_CW; break; - - case '2': chan->mode = RIG_MODE_AM; break; - - default : chan->mode = RIG_MODE_NONE; - } - } - - if ((mdbuf[8] & 0x34) == '4') - { - if (chan->mode == RIG_MODE_AM) - { - chan->mode = RIG_MODE_AMS; - } - } - - strncpy(freqstr, mdbuf + 10, 9); - freqstr[9] = 0x00; - - if ((mdbuf[20] == 'k') || (mdbuf[20] == 'K')) - { - chan->freq = strtod(freqstr, NULL) * 1000.0; - } - - if ((mdbuf[20] == 'm') || (mdbuf[20] == 'M')) - { - chan->freq = strtod(freqstr, NULL) * 1000000.0; - } + + chan->ant = priv->curr_ant; + chan->width = priv->curr_width; + chan->mode = priv->curr_mode; + chan->freq = priv->curr_freq; //now put the radio back the way it was //we apparently can't do a read-only channel read @@ -1373,7 +1394,7 @@ int drake_r8_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) } }*/ - drake_r8_trans_rept("vfo_op", buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, ack_len, retval); + drake_r8_trans_rept("drake_vfo_op", buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, ack_len, retval); return retval; } @@ -1423,7 +1444,7 @@ int drake_r8_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) retval = 0; }*/ - drake_r8_trans_rept("set_func", buf, strlen(buf), ackbuf, ack_len, retval); + drake_r8_trans_rept("drake_set_func", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } @@ -1435,67 +1456,27 @@ int drake_r8_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) */ int drake_r8_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) { - int mdbuf_len, retval; - char mdbuf[BUFSZ]; - char mc; - char blanker; + int retval; + const struct drake_priv_data *priv = STATE(rig)->priv; - retval = drake_r8_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_r8_report_mode(rig, "drake_get_func"); - //let's trick it - /* - char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning - if (mdbuf_len == 0) + if (retval == RIG_OK) { - for (int i=0; i < 7; i++) { - mdbuf[i] = testbuf[i]; + switch (func) + { + case RIG_FUNC_MN: *status = priv->curr_notch; break; + + case RIG_FUNC_NB: *status = priv->curr_nb; break; + + case RIG_FUNC_NB2: *status = priv->curr_nb2; break; + + default: rig_debug(RIG_DEBUG_ERR, "Unsupported get func %s\n", rig_strfunc(func)); + return -RIG_EINVAL; } - mdbuf_len = 7; - mdbuf[mdbuf_len] = 0x00; - retval = 0; - }*/ - - drake_r8_trans_rept("get_func", "RM" EOM, 3, mdbuf, mdbuf_len, retval); - - if (retval != RIG_OK) - { - return retval; } - - if (mdbuf_len < 7) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_func: wrong answer %s, " - "len=%d\n", mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - switch (func) - { - case RIG_FUNC_MN: - mc = mdbuf[1]; - *status = ((mc & 0x32) == '2'); - break; - - case RIG_FUNC_NB: - case RIG_FUNC_NB2: - mc = mdbuf[0]; - blanker = ' '; - if ((mc >= '<') && (mc <= '?')) - blanker = 'W'; - else - if ((mc >= '4') && (mc <= '7')) - blanker = 'N'; - else - blanker = 'F'; - *status = (((func == RIG_FUNC_NB) && (blanker == 'W')) || ((func == RIG_FUNC_NB2) && (blanker == 'N'))); - break; - - default: - rig_debug(RIG_DEBUG_ERR, "Unsupported get func %s\n", rig_strfunc(func)); - return -RIG_EINVAL; - } - - return RIG_OK; + + return retval; } @@ -1553,144 +1534,38 @@ int drake_r8_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) */ int drake_r8_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) { - int lvl_len, retval; - char lvlbuf[BUFSZ]; - char mc; + int retval; + const struct drake_priv_data *priv = STATE(rig)->priv; if ((level == RIG_LEVEL_STRENGTH) || (level == RIG_LEVEL_RAWSTR)) { - retval = drake_r8_transaction(rig, "RA" EOM, 3, lvlbuf, &lvl_len); - - //let's trick it - /* - char testbuf[25] = {' ','0','0',' ','2','0','2','<','8', ' ', ' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; //mem off, ch 00, NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning - if (lvl_len == 0) - { - for (int i=0; i < 25; i++) { - lvlbuf[i] = testbuf[i]; - } - lvl_len = 25; - lvlbuf[lvl_len] = 0x00; - retval = 0; - }*/ - - drake_r8_trans_rept("get_level", "RA" EOM, 3, lvlbuf, lvl_len, retval); - + retval = drake_r8_report_all(rig, "drake_get_level"); } else { - retval = drake_r8_transaction(rig, "RM" EOM, 3, lvlbuf, &lvl_len); - - //let's trick it - /* - char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning - if (lvl_len == 0) - { - for (int i=0; i < 7; i++) { - lvlbuf[i] = testbuf[i]; - } - lvl_len = 7; - lvlbuf[lvl_len] = 0x00; - retval = 0; - }*/ - - drake_r8_trans_rept("get_level", "RM" EOM, 3, lvlbuf, lvl_len, retval); - + retval = drake_r8_report_mode(rig, "drake_get_level"); } - - if (retval != RIG_OK) + if (retval == RIG_OK) { - return retval; + switch (level) + { + case RIG_LEVEL_PREAMP: val->i = (priv->curr_pre ? 10 : 0); break; + + case RIG_LEVEL_ATT: val->i = (priv->curr_att ? 10 : 0); break; + + case RIG_LEVEL_AGC: val->i = priv->curr_agc; break; + + case RIG_LEVEL_RAWSTR: val->i = (priv->curr_dcd ? 1 : 0); break; + + case RIG_LEVEL_STRENGTH: val->i = (priv->curr_dcd ? 0 : -60); break; + + default: rig_debug(RIG_DEBUG_ERR, "Unsupported get_level %s\n", rig_strlevel(level)); + return -RIG_EINVAL; + } } - if (lvl_len < 7) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_level: wrong answer %s, " - "len=%d\n", lvlbuf, lvl_len); - return -RIG_ERJCTED; - } - - switch (level) - { - case RIG_LEVEL_PREAMP: - mc = lvlbuf[1]; - - if ((mc & 0x3c) == '8') - { - val->i = 10; - } - else - { - val->i = 0; - } - - break; - - case RIG_LEVEL_ATT: - mc = lvlbuf[1]; - - if ((mc & 0x3c) == '4') - { - val->i = 10; - } - else - { - val->i = 0; - } - - break; - - case RIG_LEVEL_AGC: - mc = lvlbuf[0]; - - switch (mc & 0x33) - { - case '0': val->i = RIG_AGC_OFF; break; - - case '2': val->i = RIG_AGC_FAST; break; - - case '3': val->i = RIG_AGC_SLOW; break; - - default : val->i = RIG_AGC_FAST; - } - - break; - - case RIG_LEVEL_RAWSTR: - mc = lvlbuf[19]; - - switch (mc) - { - case ' ': val->i = 0; break; - - case '#': val->i = 1; break; - - default : val->i = 0; - } - - break; - - case RIG_LEVEL_STRENGTH: - mc = lvlbuf[19]; - - switch (mc) - { - case ' ': val->i = -60; break; - - case '#': val->i = 0; break; - - default : val->i = -60; - } - - break; - - default: - rig_debug(RIG_DEBUG_ERR, "Unsupported get_level %s\n", rig_strlevel(level)); - return -RIG_EINVAL; - } - - return RIG_OK; + return retval; } @@ -1722,34 +1597,17 @@ int drake_r8_set_powerstat(RIG *rig, powerstat_t status) int drake_r8_get_powerstat(RIG *rig, powerstat_t *status) { - int mdlen, retval; - char mdbuf[BUFSZ]; + int retval; + const struct drake_priv_data *priv = STATE(rig)->priv; - retval = drake_r8_transaction(rig, "RM" EOM, 3, &mdbuf[0], &mdlen); + retval = drake_r8_report_mode(rig, "drake_get_powerstat"); - //let's trick it - /* - char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning - if (mdlen == 0) + if (retval == RIG_OK) { - for (int i=0; i < 7; i++) { - mdbuf[i] = testbuf[i]; - } - mdlen = 7; - mdbuf[mdlen] = 0x00; - retval = 0; - }*/ - - drake_r8_trans_rept("get_power", "RM" EOM, 3, mdbuf, mdlen, retval); - - if (retval != RIG_OK) - { - return retval; + *status = priv->curr_pwr; } - - *status = (mdlen >= 7); - - return RIG_OK; + + return retval; } @@ -1780,7 +1638,7 @@ const char *drake_r8_get_info(RIG *rig) if (retval != RIG_OK) { - return NULL; + return ""; } idbuf[id_len - 2] = '\0'; From 3b8a24179ee06a6dabc262284ad40fda805ef930 Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Wed, 2 Jul 2025 09:23:59 -0400 Subject: [PATCH 05/16] Fixed issue in comms loop where receive buffer was too small, causing buffer overflow crashes. Also, added buffer initialization in case some receive errors are not handled properly. Fixed potential C99 stdbool error. --- rigs/drake/r8.c | 89 ++++++++++++++++++++++++++++--------------------- 1 file changed, 51 insertions(+), 38 deletions(-) diff --git a/rigs/drake/r8.c b/rigs/drake/r8.c index 5849a6591..6c5333905 100644 --- a/rigs/drake/r8.c +++ b/rigs/drake/r8.c @@ -21,6 +21,7 @@ //#include #include +#include //#include /* String function definitions */ //#include /* UNIX standard function definitions */ @@ -327,49 +328,41 @@ int drake_r8_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, hamlib_port_t *rp = RIGPORT(rig); rig_flush(rp); + + //assume nothing. + //initialize the buffer in case empty on return + if ((data) && (data_len)) + { + data[0] = 0x00; + *data_len = 0; + } - //fprintf(stderr, "Sending %d bytes: %s.\n", cmd_len, cmd); retval = write_block(rp, (unsigned char *) cmd, cmd_len); if (retval != RIG_OK) { - //fprintf(stderr, "Send error %d.\n", retval); - if ((data) && (data_len)) - { - data[0] = 0x00; - *data_len = 0; - } return retval; } /* no data expected, TODO: flush input? */ if (!data || !data_len) { - //fprintf(stderr, "No response expected.\n"); return 0; } - //fprintf(stderr, "Receiving...\n"); retval = read_string(rp, (unsigned char *) data, BUFSZ, - LF, 1, 0, 1); + LF, 1, 0, 1); //if (retval == -RIG_ETIMEOUT) //{ - //fprintf(stderr, "Receive timeout.\n"); - //data[0] = 0x00; - //*data_len = 0; //retval = 0; //} if (retval < 0) { - //fprintf(stderr, "Receive error %d.\n", retval); - data[0] = 0x00; - *data_len = 0; return retval; } - //fprintf(stderr, "Received %d bytes.\n", retval); *data_len = retval; data[*data_len] = 0x00; @@ -778,8 +771,10 @@ int drake_r8_report_all(RIG *rig, char* owner) */ int drake_r8_set_freq(RIG *rig, vfo_t vfo, freq_t freq) { - char freqbuf[16], ackbuf[16]; - int ack_len, retval; + char freqbuf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; /* * 10Hz resolution @@ -833,8 +828,10 @@ int drake_r8_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) */ int drake_r8_set_vfo(RIG *rig, vfo_t vfo) { - char cmdbuf[16], ackbuf[16]; - int ack_len, retval; + char cmdbuf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; char vfo_function; switch (vfo) @@ -909,9 +906,11 @@ int drake_r8_get_vfo(RIG *rig, vfo_t *vfo) */ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { - char mdbuf[16], ackbuf[16]; + char mdbuf[16]; + char ackbuf[BUFSZ]; + int ack_len; char mode_sel; - int ack_len, retval; + int retval; switch (mode) { @@ -1057,8 +1056,10 @@ int drake_r8_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) */ int drake_r8_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) { - char buf[16], ackbuf[16]; - int ack_len, retval; + char buf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; SNPRINTF((char *) buf, sizeof(buf), "A%c" EOM, ant == RIG_ANT_1 ? '1' : (ant == RIG_ANT_2 ? '2' : 'C')); @@ -1109,8 +1110,10 @@ int drake_r8_get_ant(RIG *rig, vfo_t vfo, ant_t dummy, value_t *option, */ int drake_r8_set_mem(RIG *rig, vfo_t vfo, int ch) { - int ack_len, retval; - char buf[16], ackbuf[16]; + char buf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; struct drake_priv_data *priv = STATE(rig)->priv; priv->curr_ch = ch; @@ -1172,8 +1175,10 @@ int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) const struct drake_priv_data *priv = STATE(rig)->priv; vfo_t old_vfo; int old_chan; - char mdbuf[16], ackbuf[16]; - int ack_len, retval; + char mdbuf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; value_t dummy; dummy.i = 0; @@ -1240,10 +1245,10 @@ int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) */ int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) { - const struct drake_priv_data *priv = STATE(rig)->priv; vfo_t old_vfo; int old_chan; int retval; + const struct drake_priv_data *priv = STATE(rig)->priv; chan->vfo = RIG_VFO_MEM; chan->ant = RIG_ANT_NONE; @@ -1350,7 +1355,8 @@ int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) int drake_r8_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) { const struct drake_priv_data *priv = STATE(rig)->priv; - char buf[16], ackbuf[16]; + char buf[16]; + char ackbuf[BUFSZ]; int len, ack_len, retval; switch (op) @@ -1406,8 +1412,10 @@ int drake_r8_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) */ int drake_r8_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) { - char buf[16], ackbuf[16]; - int ack_len, retval; + char buf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; char blanker = ' '; switch (func) @@ -1486,8 +1494,10 @@ int drake_r8_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) */ int drake_r8_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) { - char buf[16], ackbuf[16]; - int ack_len, retval; + char buf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; switch (level) { @@ -1571,8 +1581,10 @@ int drake_r8_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) int drake_r8_set_powerstat(RIG *rig, powerstat_t status) { - char buf[16], ackbuf[16]; - int ack_len, retval; + char buf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; SNPRINTF(buf, sizeof(buf), "P%c" EOM, status == RIG_POWER_OFF ? 'F' : 'O'); @@ -1618,7 +1630,8 @@ int drake_r8_get_powerstat(RIG *rig, powerstat_t *status) const char *drake_r8_get_info(RIG *rig) { static char idbuf[BUFSZ]; - int retval, id_len; + int retval; + int id_len; retval = drake_r8_transaction(rig, "ID" EOM, 3, idbuf, &id_len); From d32d605be67f46d75fd1185224ebb9606324ad6c Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Wed, 2 Jul 2025 11:13:06 -0400 Subject: [PATCH 06/16] Fix crashing when attempting to receive data on 'set' actions... helps if the receive buffer is appropriately sized. Also, added intialization to the receive buffer in the comms loop. --- rigs/drake/drake.c | 35 ++++++++++++++++++----------------- 1 file changed, 18 insertions(+), 17 deletions(-) diff --git a/rigs/drake/drake.c b/rigs/drake/drake.c index 9778d9525..5abe2dcb2 100644 --- a/rigs/drake/drake.c +++ b/rigs/drake/drake.c @@ -63,15 +63,18 @@ int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, rig_flush(rp); + //assume nothing. + //initialize the buffer in case empty on return + if ((data) && (data_len)) + { + data[0] = 0x00; + *data_len = 0; + } + retval = write_block(rp, (unsigned char *) cmd, cmd_len); if (retval != RIG_OK) { - if ((data) && (data_len)) - { - data[0] = 0x00; - *data_len = 0; - } return retval; } @@ -92,8 +95,6 @@ int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, if (retval < 0) { - data[0] = 0x00; - *data_len = 0; return retval; } @@ -135,7 +136,7 @@ int drake_cleanup(RIG *rig) */ int drake_set_freq(RIG *rig, vfo_t vfo, freq_t freq) { - unsigned char freqbuf[16], ackbuf[16]; + unsigned char freqbuf[16], ackbuf[BUFSZ]; int ack_len, retval; /* @@ -201,7 +202,7 @@ int drake_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) */ int drake_set_vfo(RIG *rig, vfo_t vfo) { - unsigned char cmdbuf[16], ackbuf[16]; + unsigned char cmdbuf[16], ackbuf[BUFSZ]; int ack_len, retval; char vfo_function; @@ -291,7 +292,7 @@ int drake_get_vfo(RIG *rig, vfo_t *vfo) */ int drake_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { - unsigned char mdbuf[16], ackbuf[16]; + unsigned char mdbuf[16], ackbuf[BUFSZ]; unsigned char mode_sel; int ack_len, retval; @@ -496,7 +497,7 @@ int drake_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) */ int drake_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) { - unsigned char buf[16], ackbuf[16]; + unsigned char buf[16], ackbuf[BUFSZ]; int ack_len, retval; SNPRINTF((char *) buf, sizeof(buf), "A%c" EOM, @@ -560,7 +561,7 @@ int drake_get_ant(RIG *rig, vfo_t vfo, ant_t dummy, value_t *option, int drake_set_mem(RIG *rig, vfo_t vfo, int ch) { int ack_len, retval; - char buf[16], ackbuf[16]; + char buf[16], ackbuf[BUFSZ]; struct drake_priv_data *priv = STATE(rig)->priv; priv->curr_ch = ch; @@ -624,7 +625,7 @@ int drake_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) const struct drake_priv_data *priv = STATE(rig)->priv; vfo_t old_vfo; int old_chan; - char mdbuf[16], ackbuf[16]; + char mdbuf[16], ackbuf[BUFSZ]; int ack_len, retval; value_t dummy; @@ -890,7 +891,7 @@ int drake_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) int drake_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) { const struct drake_priv_data *priv = STATE(rig)->priv; - char buf[16], ackbuf[16]; + char buf[16], ackbuf[BUFSZ]; int len, ack_len, retval; switch (op) @@ -937,7 +938,7 @@ int drake_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) */ int drake_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) { - char buf[16], ackbuf[16]; + char buf[16], ackbuf[BUFSZ]; int ack_len, retval; switch (func) @@ -1015,7 +1016,7 @@ int drake_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) */ int drake_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) { - char buf[16], ackbuf[16]; + char buf[16], ackbuf[BUFSZ]; int ack_len, retval; switch (level) @@ -1165,7 +1166,7 @@ int drake_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) int drake_set_powerstat(RIG *rig, powerstat_t status) { - char buf[16], ackbuf[16]; + char buf[16], ackbuf[BUFSZ]; int ack_len, retval; SNPRINTF(buf, sizeof(buf), "P%c" EOM, status == RIG_POWER_OFF ? 'F' : 'O'); From 3ff4bc99cc843a014ff8bc55aba5be9653ca87a5 Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Wed, 2 Jul 2025 11:33:50 -0400 Subject: [PATCH 07/16] Moved all r8's command debug routines over to drake.c and out of the r8-specifc backend. Removed the r8-specific transaction routine and repointed it to the revised common one in drake.c. --- rigs/drake/drake.c | 95 +++++++++++++++++ rigs/drake/drake.h | 2 + rigs/drake/r8.c | 254 +++++++-------------------------------------- 3 files changed, 135 insertions(+), 216 deletions(-) diff --git a/rigs/drake/drake.c b/rigs/drake/drake.c index 5abe2dcb2..b4afb4d48 100644 --- a/rigs/drake/drake.c +++ b/rigs/drake/drake.c @@ -51,6 +51,89 @@ #define MD_AM '6' +/* + * drake_fix_string + * recursively replaces all special characters so they are readable at output + * + */ +void drake_fix_string(char* inStr) +{ + char chChkAry[3] = {0x20, 0x0d, 0x0a}; + char* chRepAry[3] = {"", "", ""}; + char* chPos; + int newLen; + int offset; + int i; + int j; + + for (i = 0; i < 3; i++) + { + do { + chPos = strchr(inStr, chChkAry[i]); + if (chPos != NULL) + { + newLen = strlen(inStr); + offset = chPos - inStr; + for (j = newLen; j > offset; j--) + { + inStr[j+3] = inStr[j]; + } + for (j = 0; j < 4; j++) + { + inStr[offset+j] = chRepAry[i][j]; + } + } + } + while (chPos); + } +} + + +/* + * drake_r8_trans_rept + * non-destructively echoes transaction in a readable way for debugging + */ +void drake_trans_rept(char* hdrStr, char* sentStr, int sentLen, char* recdStr, int recdLen, int res) +{ + char sent[BUFSZ]; + char recd[BUFSZ]; + char nullStr[7] = {'<','N','U','L','L','>',0x00}; + int i; + + //in most cases each string is a buffer, so we need to ensure both command and response + //are not NULL and null-terminated before duplicastion and conversion. + + if ((sentStr != NULL) && (sentLen > 0)) + { + for (i = 0; i < sentLen; i++) + sent[i] = sentStr[i]; + sent[sentLen] = 0x00; + drake_fix_string((char*)sent); + } + else + { + for (i = 0; i < 7; i++) + sent[i] = nullStr[i]; + } + + if ((recdStr != NULL) && (recdLen > 0)) + { + for (i = 0; i < recdLen; i++) + recd[i] = recdStr[i]; + recd[recdLen] = 0x00; + drake_fix_string((char*)recd); + } + else + { + for (i = 0; i < 7; i++) + recd[i] = nullStr[i]; + } + + rig_debug(RIG_DEBUG_WARN, "Hamlib %s: Result %d - Sent %d chars: %s, Recd %d chars: %s\n", hdrStr, res, sentLen, sent, recdLen, recd); + +} + + /* * drake_transaction * We assume that rig!=NULL, STATE(rig)!= NULL, data!=NULL, data_len!=NULL @@ -117,6 +200,18 @@ int drake_init(RIG *rig) priv = STATE(rig)->priv; priv->curr_ch = 0; + priv->curr_dcd = RIG_DCD_OFF; + priv->curr_freq = 0.0; + priv->curr_ant = RIG_ANT_1; + priv->curr_vfo = RIG_VFO_VFO; + priv->curr_agc = RIG_AGC_OFF; + priv->curr_mode = RIG_MODE_NONE; + priv->curr_width = RIG_PASSBAND_NORMAL; + priv->curr_nb = false; + priv->curr_nb2 = false; + priv->curr_att = false; + priv->curr_pre = false; + priv->curr_pwr = false; return RIG_OK; } diff --git a/rigs/drake/drake.h b/rigs/drake/drake.h index 246cc7a38..bdb610249 100644 --- a/rigs/drake/drake.h +++ b/rigs/drake/drake.h @@ -65,6 +65,8 @@ int drake_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val); int drake_set_powerstat (RIG * rig, powerstat_t status); int drake_get_powerstat (RIG * rig, powerstat_t *status); const char *drake_get_info(RIG *rig); +int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, int *data_len); +void drake_trans_rept(char* hdrStr, char* sentStr, int sentLen, char* recdStr, int recdLen, int res); extern struct rig_caps r8_caps; extern struct rig_caps r8a_caps; diff --git a/rigs/drake/r8.c b/rigs/drake/r8.c index 6c5333905..025cf1905 100644 --- a/rigs/drake/r8.c +++ b/rigs/drake/r8.c @@ -26,8 +26,8 @@ //#include /* UNIX standard function definitions */ #include -#include "serial.h" -#include "misc.h" +//#include "serial.h" +//#include "misc.h" #include "idx_builtin.h" //#include "cal.h" //#include "register.h" @@ -40,8 +40,6 @@ int drake_r8_set_vfo(RIG *rig, vfo_t vfo); int drake_r8_get_vfo(RIG *rig, vfo_t *vfo); int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width); int drake_r8_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width); -int drake_r8_init(RIG *rig); -int drake_r8_cleanup(RIG *rig); int drake_r8_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option); int drake_r8_get_ant(RIG *rig, vfo_t vfo, ant_t dummy, value_t *option, ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx); int drake_r8_set_mem(RIG *rig, vfo_t vfo, int ch); @@ -203,8 +201,8 @@ struct rig_caps r8_caps = }, .str_cal = R8_STR_CAL, - .rig_init = drake_r8_init, - .rig_cleanup = drake_r8_cleanup, + .rig_init = drake_init, + .rig_cleanup = drake_cleanup, .set_freq = drake_r8_set_freq, .get_freq = drake_r8_get_freq, @@ -234,182 +232,6 @@ struct rig_caps r8_caps = */ -/* - * drake_r8_fix_string - * recursively replaces all special characters so they are readable at output - * - */ -void drake_r8_fix_string(char* inStr) -{ - char chChkAry[3] = {0x20, 0x0d, 0x0a}; - char* chRepAry[3] = {"", "", ""}; - char* chPos; - int newLen; - int offset; - int i; - int j; - - for (i = 0; i < 3; i++) - { - do { - chPos = strchr(inStr, chChkAry[i]); - if (chPos != NULL) - { - newLen = strlen(inStr); - offset = chPos - inStr; - for (j = newLen; j > offset; j--) - { - inStr[j+3] = inStr[j]; - } - for (j = 0; j < 4; j++) - { - inStr[offset+j] = chRepAry[i][j]; - } - } - } - while (chPos); - } -} - - -/* - * drake_r8_trans_rept - * non-destructively echoes transaction in a readable way for debugging - */ -void drake_r8_trans_rept(char* hdrStr, char* sentStr, int sentLen, char* recdStr, int recdLen, int res) -{ - char sent[BUFSZ]; - char recd[BUFSZ]; - char nullStr[7] = {'<','N','U','L','L','>',0x00}; - int i; - - //in most cases each string is a buffer, so we need to ensure both command and response - //are not NULL and null-terminated before duplicastion and conversion. - - if ((sentStr != NULL) && (sentLen > 0)) - { - for (i = 0; i < sentLen; i++) - sent[i] = sentStr[i]; - sent[sentLen] = 0x00; - drake_r8_fix_string((char*)sent); - } - else - { - for (i = 0; i < 7; i++) - sent[i] = nullStr[i]; - } - - if ((recdStr != NULL) && (recdLen > 0)) - { - for (i = 0; i < recdLen; i++) - recd[i] = recdStr[i]; - recd[recdLen] = 0x00; - drake_r8_fix_string((char*)recd); - } - else - { - for (i = 0; i < 7; i++) - recd[i] = nullStr[i]; - } - - rig_debug(RIG_DEBUG_WARN, "Hamlib %s: Result %d - Sent %d chars: %s, Recd %d chars: %s\n", hdrStr, res, sentLen, sent, recdLen, recd); - -} - - -/* - * drake_r8_transaction - * We assume that rig!=NULL, STATE(rig)!= NULL, data!=NULL, data_len!=NULL - */ -int drake_r8_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, - int *data_len) -{ - int retval; - hamlib_port_t *rp = RIGPORT(rig); - - rig_flush(rp); - - //assume nothing. - //initialize the buffer in case empty on return - if ((data) && (data_len)) - { - data[0] = 0x00; - *data_len = 0; - } - - retval = write_block(rp, (unsigned char *) cmd, cmd_len); - - if (retval != RIG_OK) - { - return retval; - } - - /* no data expected, TODO: flush input? */ - if (!data || !data_len) - { - return 0; - } - - retval = read_string(rp, (unsigned char *) data, BUFSZ, - LF, 1, 0, 1); - - //if (retval == -RIG_ETIMEOUT) - //{ - //retval = 0; - //} - - if (retval < 0) - { - return retval; - } - - *data_len = retval; - data[*data_len] = 0x00; - - return RIG_OK; -} - - -int drake_r8_init(RIG *rig) -{ - struct drake_priv_data *priv; - STATE(rig)->priv = calloc(1, sizeof(struct drake_priv_data)); - - if (!STATE(rig)->priv) - { - return -RIG_ENOMEM; - } - - priv = STATE(rig)->priv; - - priv->curr_ch = 0; - priv->curr_dcd = RIG_DCD_OFF; - priv->curr_freq = 0.0; - priv->curr_ant = RIG_ANT_1; - priv->curr_vfo = RIG_VFO_VFO; - priv->curr_agc = RIG_AGC_OFF; - priv->curr_mode = RIG_MODE_NONE; - priv->curr_width = RIG_PASSBAND_NORMAL; - priv->curr_nb = false; - priv->curr_nb2 = false; - priv->curr_att = false; - priv->curr_pre = false; - priv->curr_pwr = false; - - return RIG_OK; -} - - -int drake_r8_cleanup(RIG *rig) -{ - struct drake_priv_data *priv = STATE(rig)->priv; - - free(priv); - - return RIG_OK; -} - - /* * drake_decode_frequency * Common routine to decode the frequency block @@ -455,7 +277,7 @@ int drake_r8_report_frequency(RIG *rig, char* owner) int retval; char freqbuf[BUFSZ]; - retval = drake_r8_transaction(rig, "RF" EOM, 3, freqbuf, &freq_len); + retval = drake_transaction(rig, "RF" EOM, 3, freqbuf, &freq_len); //let's trick it /* @@ -470,7 +292,7 @@ int drake_r8_report_frequency(RIG *rig, char* owner) retval = RIG_OK; }*/ - drake_r8_trans_rept(owner, "RF" EOM, 3, freqbuf, freq_len, retval); + drake_trans_rept(owner, "RF" EOM, 3, freqbuf, freq_len, retval); if (retval != RIG_OK) { @@ -616,7 +438,7 @@ int drake_r8_report_mode(RIG *rig, char* owner) char mdbuf[BUFSZ]; struct drake_priv_data *priv = STATE(rig)->priv; - retval = drake_r8_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); //let's trick it /* @@ -631,7 +453,7 @@ int drake_r8_report_mode(RIG *rig, char* owner) retval = 0; }*/ - drake_r8_trans_rept(owner, "RM" EOM, 3, mdbuf, mdbuf_len, retval); + drake_trans_rept(owner, "RM" EOM, 3, mdbuf, mdbuf_len, retval); if (retval != RIG_OK) { @@ -681,7 +503,7 @@ int drake_r8_report_mem_channel(RIG *rig, char* owner) int retval; char mdbuf[BUFSZ]; - retval = drake_r8_transaction(rig, "RC" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_transaction(rig, "RC" EOM, 3, mdbuf, &mdbuf_len); //let's trick it /* @@ -696,7 +518,7 @@ int drake_r8_report_mem_channel(RIG *rig, char* owner) retval = 0; }*/ - drake_r8_trans_rept(owner, "RC" EOM, 3, mdbuf, mdbuf_len, retval); + drake_trans_rept(owner, "RC" EOM, 3, mdbuf, mdbuf_len, retval); if (retval != RIG_OK) { @@ -728,7 +550,7 @@ int drake_r8_report_all(RIG *rig, char* owner) int retval; char mdbuf[BUFSZ]; - retval = drake_r8_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); //let's trick it /* @@ -743,7 +565,7 @@ int drake_r8_report_all(RIG *rig, char* owner) retval = RIG_OK; }*/ - drake_r8_trans_rept(owner, "RA" EOM, 3, mdbuf, mdbuf_len, retval); + drake_trans_rept(owner, "RA" EOM, 3, mdbuf, mdbuf_len, retval); if (retval != RIG_OK) { @@ -782,7 +604,7 @@ int drake_r8_set_freq(RIG *rig, vfo_t vfo, freq_t freq) */ SNPRINTF((char *) freqbuf, sizeof(freqbuf), "F%07u" EOM, (unsigned int)freq / 10); - retval = drake_r8_transaction(rig, freqbuf, strlen(freqbuf), ackbuf, &ack_len); + retval = drake_transaction(rig, freqbuf, strlen(freqbuf), ackbuf, &ack_len); //let's trick it /* @@ -796,7 +618,7 @@ int drake_r8_set_freq(RIG *rig, vfo_t vfo, freq_t freq) retval = 0; }*/ - drake_r8_trans_rept("drake_set_freq", freqbuf, strlen(freqbuf), ackbuf, ack_len, retval); + drake_trans_rept("drake_set_freq", freqbuf, strlen(freqbuf), ackbuf, ack_len, retval); return retval; } @@ -860,7 +682,7 @@ int drake_r8_set_vfo(RIG *rig, vfo_t vfo) SNPRINTF((char *) cmdbuf, sizeof(cmdbuf), "%c" EOM, vfo_function); } - retval = drake_r8_transaction(rig, cmdbuf, strlen(cmdbuf), ackbuf, &ack_len); + retval = drake_transaction(rig, cmdbuf, strlen(cmdbuf), ackbuf, &ack_len); //let's trick it /* @@ -873,7 +695,7 @@ int drake_r8_set_vfo(RIG *rig, vfo_t vfo) retval = RIG_OK; }*/ - drake_r8_trans_rept("drake_set_vfo", cmdbuf, strlen(cmdbuf), ackbuf, ack_len, retval); + drake_trans_rept("drake_set_vfo", cmdbuf, strlen(cmdbuf), ackbuf, ack_len, retval); return retval; } @@ -934,7 +756,7 @@ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) } SNPRINTF((char *) mdbuf, sizeof(mdbuf), "M%c" EOM, mode_sel); - retval = drake_r8_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); + retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); //let's trick it /* @@ -947,7 +769,7 @@ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) retval = 0; }*/ - drake_r8_trans_rept("drake_set_mode", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + drake_trans_rept("drake_set_mode", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); if (retval != RIG_OK) { @@ -987,7 +809,7 @@ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) } SNPRINTF((char *) mdbuf, sizeof(mdbuf), "W%c" EOM, width_sel); - retval = drake_r8_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); + retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); //let's trick it /* @@ -1000,7 +822,7 @@ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) retval = 0; }*/ - drake_r8_trans_rept("drake_set_bw", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + drake_trans_rept("drake_set_bw", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); } } @@ -1009,7 +831,7 @@ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { SNPRINTF((char *) mdbuf, sizeof(mdbuf), "S%c" EOM, (mode == RIG_MODE_AMS) ? 'O' : 'F'); - retval = drake_r8_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); + retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); //let's trick it /* @@ -1022,7 +844,7 @@ int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) retval = 0; }*/ - drake_r8_trans_rept("drake_set_synch", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + drake_trans_rept("drake_set_synch", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); } return retval; @@ -1064,7 +886,7 @@ int drake_r8_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) SNPRINTF((char *) buf, sizeof(buf), "A%c" EOM, ant == RIG_ANT_1 ? '1' : (ant == RIG_ANT_2 ? '2' : 'C')); - retval = drake_r8_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); //let's trick it /* @@ -1077,7 +899,7 @@ int drake_r8_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) retval = 0; }*/ - drake_r8_trans_rept("drake_set_ant", buf, strlen(buf), ackbuf, ack_len, retval); + drake_trans_rept("drake_set_ant", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } @@ -1121,7 +943,7 @@ int drake_r8_set_mem(RIG *rig, vfo_t vfo, int ch) SNPRINTF(buf, sizeof(buf), "C%02d" , ch); ack_len = 0; // fix compile-time warning "possibly uninitialized" - retval = drake_r8_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); //let's trick it /* @@ -1135,7 +957,7 @@ int drake_r8_set_mem(RIG *rig, vfo_t vfo, int ch) retval = 0; }*/ - drake_r8_trans_rept("drake_set_mem", buf, strlen(buf), ackbuf, ack_len, retval); + drake_trans_rept("drake_set_mem", buf, strlen(buf), ackbuf, ack_len, retval); if (ack_len != 2) { @@ -1214,7 +1036,7 @@ int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) (chan->funcs & RIG_FUNC_MN) == RIG_FUNC_MN); SNPRINTF(mdbuf, sizeof(mdbuf), "PR" EOM "%02d" EOM, chan->channel_num); - retval = drake_r8_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); + retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); //let's trick it /* @@ -1228,7 +1050,7 @@ int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) retval = 0; }*/ - drake_r8_trans_rept("drake_set_chan", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + drake_trans_rept("drake_set_chan", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); if (old_vfo == RIG_VFO_MEM) { @@ -1382,7 +1204,7 @@ int drake_r8_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) } len = strlen(buf); - retval = drake_r8_transaction(rig, buf, len, len == 1 ? ackbuf : NULL, + retval = drake_transaction(rig, buf, len, len == 1 ? ackbuf : NULL, len == 1 ? &ack_len : NULL); //let's trick it @@ -1400,7 +1222,7 @@ int drake_r8_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) } }*/ - drake_r8_trans_rept("drake_vfo_op", buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, ack_len, retval); + drake_trans_rept("drake_vfo_op", buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, ack_len, retval); return retval; } @@ -1439,7 +1261,7 @@ int drake_r8_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) return -RIG_EINVAL; } - retval = drake_r8_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); //let's trick it /* @@ -1452,7 +1274,7 @@ int drake_r8_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) retval = 0; }*/ - drake_r8_trans_rept("drake_set_func", buf, strlen(buf), ackbuf, ack_len, retval); + drake_trans_rept("drake_set_func", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } @@ -1519,7 +1341,7 @@ int drake_r8_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) return -RIG_EINVAL; } - retval = drake_r8_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); //let's trick it /* @@ -1532,7 +1354,7 @@ int drake_r8_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) retval = 0; }*/ - drake_r8_trans_rept("set_level", buf, strlen(buf), ackbuf, ack_len, retval); + drake_trans_rept("set_level", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } @@ -1588,7 +1410,7 @@ int drake_r8_set_powerstat(RIG *rig, powerstat_t status) SNPRINTF(buf, sizeof(buf), "P%c" EOM, status == RIG_POWER_OFF ? 'F' : 'O'); - retval = drake_r8_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); //let's trick it /* @@ -1601,7 +1423,7 @@ int drake_r8_set_powerstat(RIG *rig, powerstat_t status) retval = 0; }*/ - drake_r8_trans_rept("set_power", buf, strlen(buf), ackbuf, ack_len, retval); + drake_trans_rept("set_power", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } @@ -1633,7 +1455,7 @@ const char *drake_r8_get_info(RIG *rig) int retval; int id_len; - retval = drake_r8_transaction(rig, "ID" EOM, 3, idbuf, &id_len); + retval = drake_transaction(rig, "ID" EOM, 3, idbuf, &id_len); //let's trick it /* @@ -1647,7 +1469,7 @@ const char *drake_r8_get_info(RIG *rig) retval = 0; }*/ - drake_r8_trans_rept("get_id", "ID" EOM, 3, idbuf, id_len, retval); + drake_trans_rept("get_id", "ID" EOM, 3, idbuf, id_len, retval); if (retval != RIG_OK) { From db863a69212291ea6acbb93eaff54d349a9b0cc1 Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Wed, 2 Jul 2025 20:34:17 -0400 Subject: [PATCH 08/16] Added stdbool.h for c99 compilers in drake.c --- rigs/drake/drake.c | 1 + 1 file changed, 1 insertion(+) diff --git a/rigs/drake/drake.c b/rigs/drake/drake.c index b4afb4d48..64737f938 100644 --- a/rigs/drake/drake.c +++ b/rigs/drake/drake.c @@ -23,6 +23,7 @@ #include #include /* String function definitions */ #include /* UNIX standard function definitions */ +#include #include "hamlib/rig.h" #include "serial.h" From 48405744b534fbef90db88f63cf08fd09bd47a2f Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Wed, 2 Jul 2025 22:08:47 -0400 Subject: [PATCH 09/16] Silence uninitiated variable warning in vfo_op on C99 compuler. --- rigs/drake/r8.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/rigs/drake/r8.c b/rigs/drake/r8.c index 025cf1905..ffa81b77d 100644 --- a/rigs/drake/r8.c +++ b/rigs/drake/r8.c @@ -1176,10 +1176,12 @@ int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) */ int drake_r8_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) { - const struct drake_priv_data *priv = STATE(rig)->priv; char buf[16]; char ackbuf[BUFSZ]; - int len, ack_len, retval; + int ack_len; + int len; + int retval; + const struct drake_priv_data *priv = STATE(rig)->priv; switch (op) { @@ -1205,7 +1207,7 @@ int drake_r8_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) len = strlen(buf); retval = drake_transaction(rig, buf, len, len == 1 ? ackbuf : NULL, - len == 1 ? &ack_len : NULL); + len == 1 ? &ack_len : NULL); //let's trick it /* @@ -1222,7 +1224,8 @@ int drake_r8_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) } }*/ - drake_trans_rept("drake_vfo_op", buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, ack_len, retval); + drake_trans_rept("drake_vfo_op", buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, + buf[len - 1] == 0x0d ? ack_len : 0, retval); return retval; } From 6ac3dd596be40f5b2ea20d6316394fcf25a5f948 Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Thu, 3 Jul 2025 00:30:11 -0400 Subject: [PATCH 10/16] Fixed squelch detection to use an asterisk instead of a hash (like in the manual). Also fixed setting of meter based on the status of RIG_DCD_ON/OFF instead of true/false. --- rigs/drake/r8.c | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/rigs/drake/r8.c b/rigs/drake/r8.c index ffa81b77d..a696643dd 100644 --- a/rigs/drake/r8.c +++ b/rigs/drake/r8.c @@ -242,14 +242,10 @@ void drake_r8_decode_frequency(RIG *rig, char* freqbuf, int offset) char fmult; struct drake_priv_data *priv = STATE(rig)->priv; - switch (freqbuf[9+offset]) - { - case ' ' : priv->curr_dcd = RIG_DCD_OFF; break; - - case '#' : priv->curr_dcd = RIG_DCD_ON; break; - - default : priv->curr_dcd = RIG_DCD_OFF; - } + if ((freqbuf[9+offset] == '*') || (freqbuf[9+offset] == '#')) + priv->curr_dcd = RIG_DCD_ON; + else + priv->curr_dcd = RIG_DCD_OFF; fmult = freqbuf[10+offset]; @@ -267,7 +263,7 @@ void drake_r8_decode_frequency(RIG *rig, char* freqbuf, int offset) /* * drake_report_freq - * Common routine to retrieve frequency and dcd settings + * Common routine to retrieve frequency and squelch settings (used for DCD) * Data stored in priv for any routine to use * Assumes rig!=NULL */ @@ -1391,9 +1387,9 @@ int drake_r8_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) case RIG_LEVEL_AGC: val->i = priv->curr_agc; break; - case RIG_LEVEL_RAWSTR: val->i = (priv->curr_dcd ? 1 : 0); break; + case RIG_LEVEL_RAWSTR: val->i = ((priv->curr_dcd == RIG_DCD_ON) ? 1 : 0); break; - case RIG_LEVEL_STRENGTH: val->i = (priv->curr_dcd ? 0 : -60); break; + case RIG_LEVEL_STRENGTH: val->i = ((priv->curr_dcd == RIG_DCD_ON) ? 0 : -60); break; default: rig_debug(RIG_DEBUG_ERR, "Unsupported get_level %s\n", rig_strlevel(level)); return -RIG_EINVAL; From 7a975784769b2b45605f7ecde22f4d49d15d40ba Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Thu, 3 Jul 2025 11:02:50 -0400 Subject: [PATCH 11/16] Fixed error in get_mem(), which was reading mode, not memory channel. Adusted Report All to decode memory status AFTER mode, so VFO_MEM wouldn't get squashed. --- rigs/drake/r8.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/rigs/drake/r8.c b/rigs/drake/r8.c index a696643dd..de6202238 100644 --- a/rigs/drake/r8.c +++ b/rigs/drake/r8.c @@ -575,8 +575,10 @@ int drake_r8_report_all(RIG *rig, char* owner) return -RIG_ERJCTED; } - drake_r8_decode_mem_channel(rig, mdbuf, 0); + //check RC *after* decoding the VFO in RM + //otherwise RIG_VFO_MEM gets squashed drake_r8_decode_mode(rig, mdbuf, 4); + drake_r8_decode_mem_channel(rig, mdbuf, 0); drake_r8_decode_frequency(rig, mdbuf, 10); return RIG_OK; @@ -972,8 +974,8 @@ int drake_r8_get_mem(RIG *rig, vfo_t vfo, int *ch) { int retval; struct drake_priv_data *priv = STATE(rig)->priv; - - retval = drake_r8_report_mode(rig, "drake_get_mem"); + + retval = drake_r8_report_mem_channel(rig, "drake_get_mem"); if (retval == RIG_OK) { From cb0646c7275eebe254b3da857b1f5791a59995d6 Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Fri, 4 Jul 2025 00:53:28 -0400 Subject: [PATCH 12/16] Merged all R8 testing routines (except set/get memory channel) into their equivalents within drake. Will do the same with memory channel routines once they are better tested. --- rigs/drake/drake.c | 1232 +++++++++++++++++++++++++++++--------------- rigs/drake/drake.h | 10 +- rigs/drake/r8.c | 1179 ++---------------------------------------- 3 files changed, 873 insertions(+), 1548 deletions(-) diff --git a/rigs/drake/drake.c b/rigs/drake/drake.c index 64737f938..193f6b52f 100644 --- a/rigs/drake/drake.c +++ b/rigs/drake/drake.c @@ -91,7 +91,7 @@ void drake_fix_string(char* inStr) /* - * drake_r8_trans_rept + * drake_trans_rept * non-destructively echoes transaction in a readable way for debugging */ void drake_trans_rept(char* hdrStr, char* sentStr, int sentLen, char* recdStr, int recdLen, int res) @@ -188,6 +188,450 @@ int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, return RIG_OK; } + +int drake_report_signal(RIG *rig, char* owner) +{ + char lvlbuf[BUFSZ]; + int lvl_len; + int retval; + struct drake_priv_data *priv = STATE(rig)->priv; + + retval = drake_transaction(rig, "RSS" EOM, 4, lvlbuf, &lvl_len); + + drake_trans_rept(owner, "RSS" EOM, 4, lvlbuf, lvl_len, retval); + + if (retval != RIG_OK) + { + return retval; + } + + if (lvl_len != 5) + { + rig_debug(RIG_DEBUG_ERR, "drake_get_level: wrong answer" + "len=%d\n", lvl_len); + return -RIG_ERJCTED; + } + + lvlbuf[3] = '\0'; + priv->curr_ss = strtol(lvlbuf + 1, (char **)NULL, 16); + + return RIG_OK; +} + + +/* + * drake_decode_frequency + * Common routine to decode the frequency block + */ +void drake_decode_frequency(RIG *rig, char* freqbuf, int offset) +{ + double f; + char fmult; + struct drake_priv_data *priv = STATE(rig)->priv; + + if ((freqbuf[9+offset] == '*') || (freqbuf[9+offset] == '#')) + priv->curr_dcd = RIG_DCD_ON; + else + priv->curr_dcd = RIG_DCD_OFF; + + fmult = freqbuf[10+offset]; + + freqbuf[9+offset] = '\0'; + + /* extract freq */ + sscanf(freqbuf+offset, "%lf", &f); + f *= 1000.0; + + if ((fmult == 'm') || (fmult == 'M')) + f *= 1000.0; + + priv->curr_freq = (freq_t)f; +} + + +/* + * drake_report_freq + * Common routine to retrieve frequency and squelch settings (used for DCD) + * Data stored in priv for any routine to use + * Assumes rig!=NULL + */ +int drake_report_frequency(RIG *rig, char* owner) +{ + char freqbuf[BUFSZ]; + int freq_len; + int retval; + + retval = drake_transaction(rig, "RF" EOM, 3, freqbuf, &freq_len); + + //let's trick it + /* + char testbuf[15] = {' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; + if (freq_len == 0) + { + for (int i=0; i < 15; i++) { + freqbuf[i] = testbuf[i]; + } + freq_len = 15; + freqbuf[freq_len] = 0x00; + retval = RIG_OK; + }*/ + + drake_trans_rept(owner, "RF" EOM, 3, freqbuf, freq_len, retval); + + if (retval != RIG_OK) + { + return retval; + } + + if (freq_len != 15) + { + rig_debug(RIG_DEBUG_ERR, "%s: wrong answer %s, " + "len=%d\n", owner, freqbuf, freq_len); + return -RIG_ERJCTED; + } + + drake_decode_frequency(rig, freqbuf, 0); + + return RIG_OK; +} + + +/* + * drake_decode_mode + * Common routine to break out the 5-character mode string + */ +void drake_decode_mode(RIG *rig, char* mdbuf, int offset) +{ + struct drake_priv_data *priv = STATE(rig)->priv; + + //noise blanker + priv->curr_nb = ((mdbuf[offset] >= '<') && (mdbuf[offset] <= '?')); + priv->curr_nb2 = ((mdbuf[offset] >= '4') && (mdbuf[offset] <= '7')); + + //agc + switch (mdbuf[offset] & 0x33) + { + case '0': priv->curr_agc = RIG_AGC_OFF; break; + + case '2': priv->curr_agc = RIG_AGC_FAST; break; + + case '3': priv->curr_agc = RIG_AGC_SLOW; break; + + default : priv->curr_agc = RIG_AGC_OFF; + } + + //preamp, attenuator and notch + priv->curr_pre = ((mdbuf[1+offset] & 0x3c) == '8'); + priv->curr_att = ((mdbuf[1+offset] & 0x3c) == '4'); + priv->curr_notch = ((mdbuf[1+offset] & 0x32) == '2'); + + //ant + switch (mdbuf[2+offset] & 0x3c) + { + case '0': priv->curr_ant = RIG_ANT_1; break; + + case '4': priv->curr_ant = RIG_ANT_3; break; + + case '8': priv->curr_ant = RIG_ANT_2; break; + + default : priv->curr_ant = RIG_ANT_1; + } + + //width + switch (mdbuf[3+offset] & 0x37) + { + case '0': priv->curr_width = s_Hz(500); break; + + case '1': priv->curr_width = s_Hz(1800); break; + + case '2': priv->curr_width = s_Hz(2300); break; + + case '3': priv->curr_width = s_Hz(4000); break; + + case '4': priv->curr_width = s_Hz(6000); break; + + default : priv->curr_width = RIG_PASSBAND_NORMAL; + } + + //mode + if ((mdbuf[3+offset] >= '0') && (mdbuf[3+offset] <= '4')) + { + switch (mdbuf[2+offset] & 0x33) + { + case '0': priv->curr_mode = RIG_MODE_LSB; break; + + case '1': priv->curr_mode = RIG_MODE_RTTY; break; + + case '2': priv->curr_mode = RIG_MODE_FM; priv->curr_width = s_Hz(12000); break; + + default : priv->curr_mode = RIG_MODE_NONE; + } + } + else + { + switch (mdbuf[2+offset] & 0x33) + { + case '0': priv->curr_mode = RIG_MODE_USB; break; + + case '1': priv->curr_mode = RIG_MODE_CW; break; + + case '2': priv->curr_mode = RIG_MODE_AM; break; + + default : priv->curr_mode = RIG_MODE_NONE; + } + } + //synch + if ((mdbuf[4+offset] & 0x34) == '4') + { + if (priv->curr_mode == RIG_MODE_AM) + { + priv->curr_mode = RIG_MODE_AMS; + } + else if (priv->curr_mode == RIG_MODE_USB) + { + priv->curr_mode = RIG_MODE_ECSSUSB; + } + else if (priv->curr_mode == RIG_MODE_LSB) + { + priv->curr_mode = RIG_MODE_ECSSLSB; + } + } + + //vfo + switch (mdbuf[4+offset] & 0x38) + { + case '0' : priv->curr_vfo = RIG_VFO_B; break; + + case '8' : priv->curr_vfo = RIG_VFO_A; break; + + default : priv->curr_vfo = RIG_VFO_VFO; + } +} + + +/* + * drake_report_mode + * Common routine to retrieve NB, AGC, ATT, PRE, NF, ANT, MODE, BW, and VFO (and scanning) settings + * Data stored in priv for any routine to use + * Assumes rig!=NULL + */ +int drake_report_mode(RIG *rig, char* owner) +{ + char mdbuf[BUFSZ]; + int mdbuf_len; + int retval; + int retlen; + int mode_offset; + struct drake_priv_data *priv = STATE(rig)->priv; + + retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + + //let's trick it + /* + //r8 + char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + //r8a/b + char testbuf[7] = {' ','2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + if (mdbuf_len == 0) + { + for (int i=0; i < 7; i++) { + mdbuf[i] = testbuf[i]; + } + mdbuf_len = 7; + mdbuf[mdbuf_len] = 0x00; + retval = 0; + }*/ + + drake_trans_rept(owner, "RM" EOM, 3, mdbuf, mdbuf_len, retval); + + if (rig->caps->rig_model == RIG_MODEL_DKR8) + { + retlen = 7; + mode_offset = 0; + } + else + { + retlen = 8; + mode_offset = 1; + } + + if (retval != RIG_OK) + { + return retval; + } + + if (mdbuf_len != retlen) + { + priv->curr_pwr = false; + rig_debug(RIG_DEBUG_ERR, "%s: wrong answer %s, " + "len=%d\n", owner, mdbuf, mdbuf_len); + return -RIG_ERJCTED; + } + + priv->curr_pwr = true; + drake_decode_mode(rig, mdbuf, mode_offset); + + return RIG_OK; +} + + +/* + * drake_decode_mem_channel + * Common routine to break out the 3 or 4-character mem string + */ +void drake_decode_mem_channel(RIG *rig, char* mdbuf, int offset) +{ + struct drake_priv_data *priv = STATE(rig)->priv; + + if (mdbuf[offset] == '*') + { + priv->curr_vfo = RIG_VFO_MEM; + } + + if (rig->caps->rig_model == RIG_MODEL_DKR8) + { + priv->curr_ch = (mdbuf[1+offset] & 0x0f) * 10 + (mdbuf[2+offset] & 0x0f); + } + else + { + priv->curr_ch = (mdbuf[1+offset] & 0x0f) * 100 + (mdbuf[2+offset] & 0x0f) * 10 + (mdbuf[3+offset] & 0x0f); + } +} + +/* + * drake_report_mem_channel + * Common routine to retrieve the memory channel number + * Data stored in priv for any routine to use + * Assumes rig!=NULL + */ +int drake_report_mem_channel(RIG *rig, char* owner) +{ + char mdbuf[BUFSZ]; + int mdbuf_len; + int retval; + int retlen; + int chan_offset; + + retval = drake_transaction(rig, "RC" EOM, 3, mdbuf, &mdbuf_len); + + //let's trick it + /* + char testbuf[5] = {' ','0','0', 0x0d, 0x0a }; + if (mdbuf_len == 0) + { + for (int i=0; i < 5; i++) { + mdbuf[i] = testbuf[i]; + } + mdbuf_len = 5; + mdbuf[mdbuf_len] = 0x00; + retval = 0; + }*/ + + drake_trans_rept(owner, "RC" EOM, 3, mdbuf, mdbuf_len, retval); + + if (rig->caps->rig_model == RIG_MODEL_DKR8) + { + retlen = 5; + chan_offset = 0; + } + else + { + retlen = 6; + chan_offset = 0; + } + + if (retval != RIG_OK) + { + return retval; + } + + if (mdbuf_len != retlen) + { + rig_debug(RIG_DEBUG_ERR, "%s: wrong answer %s, " + "len=%d\n", owner, mdbuf, mdbuf_len); + return -RIG_ERJCTED; + } + + drake_decode_mem_channel(rig, mdbuf, chan_offset); + + return RIG_OK; +} + + +/* + * drake_report_all + * Common routine to retrieve all of the radio's settings + * Data stored in priv for any routine to use + * Assumes rig!=NULL + */ +int drake_report_all(RIG *rig, char* owner) +{ + char mdbuf[BUFSZ]; + int mdbuf_len; + int retval; + int retlen; + int mode_offset; + int chan_offset; + int freq_offset; + + retval = drake_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); + + //let's trick it + /* + // mem off, ch 00, NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + // r8 + char testbuf[25] = {' ','0','0',' ','2','0','2','<','8',' ',' ','1','5','.','0','0','0','0','0','#','m','H','z', 0x0d, 0x0a }; + // r8a/b 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 + char testbuf[35] = {' ','0','0','0',' ','2','0','2','<','8',' ',' ','1','5','.','0','0','0','0','0','#','m','H','z',' ','M','E','M','N','A','M','E',' ', 0x0d, 0x0a }; + if (mdbuf_len == 0) + { + for (int i=0; i < 25; i++) { + mdbuf[i] = testbuf[i]; + } + mdbuf_len = 25; + mdbuf[mdbuf_len] = 0x00; + retval = RIG_OK; + }*/ + + drake_trans_rept(owner, "RA" EOM, 3, mdbuf, mdbuf_len, retval); + + if (rig->caps->rig_model == RIG_MODEL_DKR8) + { + retlen = 25; + mode_offset = 4; + chan_offset = 0; + freq_offset = 10; + } + else + { + retlen = 35; + mode_offset = 5; + chan_offset = 0; + freq_offset = 11; + } + + if (retval != RIG_OK) + { + return retval; + } + + if (mdbuf_len < retlen) + { + rig_debug(RIG_DEBUG_ERR, "%s: wrong answer %s, " + "len=%d\n", owner, mdbuf, mdbuf_len); + return -RIG_ERJCTED; + } + + //check RC *after* decoding the VFO in RM + //otherwise RIG_VFO_MEM gets squashed + drake_decode_mode(rig, mdbuf, mode_offset); + drake_decode_mem_channel(rig, mdbuf, chan_offset); + drake_decode_frequency(rig, mdbuf, freq_offset); + + return RIG_OK; +} + + int drake_init(RIG *rig) { struct drake_priv_data *priv; @@ -213,10 +657,12 @@ int drake_init(RIG *rig) priv->curr_att = false; priv->curr_pre = false; priv->curr_pwr = false; + priv->curr_ss = -60; return RIG_OK; } + int drake_cleanup(RIG *rig) { struct drake_priv_data *priv = STATE(rig)->priv; @@ -226,24 +672,39 @@ int drake_cleanup(RIG *rig) return RIG_OK; } + /* * drake_set_freq * Assumes rig!=NULL */ int drake_set_freq(RIG *rig, vfo_t vfo, freq_t freq) { - unsigned char freqbuf[16], ackbuf[BUFSZ]; - int ack_len, retval; + char freqbuf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; /* * 10Hz resolution * TODO: round nearest? */ - SNPRINTF((char *) freqbuf, sizeof(freqbuf), "F%07u" EOM, - (unsigned int)freq / 10); - retval = drake_transaction(rig, (char *) freqbuf, strlen((char *)freqbuf), - (char *) ackbuf, - &ack_len); + SNPRINTF((char *) freqbuf, sizeof(freqbuf), "F%07u" EOM, (unsigned int)freq / 10); + + retval = drake_transaction(rig, freqbuf, strlen(freqbuf), ackbuf, &ack_len); + + //let's trick it + /* + char testbuf[2] = {0x0d, 0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ackbuf[1] = testbuf[1]; + ack_len = 2; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_trans_rept("drake_set_freq", freqbuf, strlen(freqbuf), ackbuf, ack_len, retval); return retval; } @@ -255,51 +716,30 @@ int drake_set_freq(RIG *rig, vfo_t vfo, freq_t freq) */ int drake_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) { - int freq_len, retval; - char freqbuf[BUFSZ]; - double f; - char fmult; + int retval; + struct drake_priv_data *priv = STATE(rig)->priv; - retval = drake_transaction(rig, "RF" EOM, 3, freqbuf, &freq_len); + retval = drake_report_frequency(rig, "drake_get_freq"); - if (retval != RIG_OK) + if (retval == RIG_OK) { - return retval; + *freq = priv->curr_freq; } - /* RA command returns ffffff.ff*mHz */ - if (freq_len != 15) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_freq: wrong answer %s, " - "len=%d\n", freqbuf, freq_len); - return -RIG_ERJCTED; - } - - fmult = freqbuf[10]; - freqbuf[9] = '\0'; - - /* extract freq */ - sscanf(freqbuf + 1, "%lf", &f); - f *= 1000.0; - - if (fmult == 'M' || fmult == 'm') - { - f *= 1000.0; - } - - *freq = (freq_t)f; - - return RIG_OK; + return retval; } + /* * drake_set_vfo * Assumes rig!=NULL */ int drake_set_vfo(RIG *rig, vfo_t vfo) { - unsigned char cmdbuf[16], ackbuf[BUFSZ]; - int ack_len, retval; + char cmdbuf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; char vfo_function; switch (vfo) @@ -328,9 +768,21 @@ int drake_set_vfo(RIG *rig, vfo_t vfo) SNPRINTF((char *) cmdbuf, sizeof(cmdbuf), "%c" EOM, vfo_function); } - retval = drake_transaction(rig, (char *) cmdbuf, strlen((char *)cmdbuf), - (char *) ackbuf, - &ack_len); + retval = drake_transaction(rig, cmdbuf, strlen(cmdbuf), ackbuf, &ack_len); + + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = RIG_OK; + }*/ + + drake_trans_rept("drake_set_vfo", cmdbuf, strlen(cmdbuf), ackbuf, ack_len, retval); + return retval; } @@ -341,56 +793,31 @@ int drake_set_vfo(RIG *rig, vfo_t vfo) */ int drake_get_vfo(RIG *rig, vfo_t *vfo) { - int mdbuf_len, retval; - char mdbuf[BUFSZ]; + int retval; + struct drake_priv_data *priv = STATE(rig)->priv; - retval = drake_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_report_all(rig, "drake_get_vfo"); - if (retval != RIG_OK) + if (retval == RIG_OK) { - return retval; + *vfo = priv->curr_vfo; } - if (mdbuf_len < 35) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_vfo: wrong answer %s, " - "len=%d\n", mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - if (mdbuf[0] == '*') - { - *vfo = RIG_VFO_MEM; - } - else - { - char cvfo = (mdbuf[9] & 0x38); - - switch (cvfo) - { - case '0' : *vfo = RIG_VFO_B; break; - - case '8' : *vfo = RIG_VFO_A; break; - - default : rig_debug(RIG_DEBUG_ERR, - "drake_get_vfo: unsupported vfo %c\n", cvfo); - *vfo = RIG_VFO_VFO; - return -RIG_EINVAL; - } - } - - return RIG_OK; + return retval; } + /* * drake_set_mode * Assumes rig!=NULL */ int drake_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) { - unsigned char mdbuf[16], ackbuf[BUFSZ]; - unsigned char mode_sel; - int ack_len, retval; + char mdbuf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; + char mode_sel; switch (mode) { @@ -416,9 +843,21 @@ int drake_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) } SNPRINTF((char *) mdbuf, sizeof(mdbuf), "M%c" EOM, mode_sel); - retval = drake_transaction(rig, (char *) mdbuf, strlen((char *)mdbuf), - (char *) ackbuf, - &ack_len); + + retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); + + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_trans_rept("drake_set_mode", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); if (retval != RIG_OK) { @@ -458,23 +897,44 @@ int drake_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) } SNPRINTF((char *) mdbuf, sizeof(mdbuf), "W%c" EOM, width_sel); - retval = drake_transaction(rig, (char *) mdbuf, strlen((char *)mdbuf), - (char *) ackbuf, - &ack_len); + retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); + + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_trans_rept("drake_set_bw", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + } } - if ((mode == RIG_MODE_AMS) || (mode == RIG_MODE_ECSSUSB) - || (mode == RIG_MODE_ECSSLSB) || + if ((mode == RIG_MODE_AMS) || (mode == RIG_MODE_ECSSUSB) || (mode == RIG_MODE_ECSSLSB) || (mode == RIG_MODE_AM) || (mode == RIG_MODE_USB) || (mode == RIG_MODE_LSB)) { SNPRINTF((char *) mdbuf, sizeof(mdbuf), "S%c" EOM, - ((mode == RIG_MODE_AMS) || (mode == RIG_MODE_ECSSUSB) - || (mode == RIG_MODE_ECSSLSB)) - ? 'O' : 'F'); - retval = drake_transaction(rig, (char *) mdbuf, strlen((char *)mdbuf), - (char *) ackbuf, - &ack_len); + ((mode == RIG_MODE_AMS) || (mode == RIG_MODE_ECSSUSB) || + (mode == RIG_MODE_ECSSLSB)) ? 'O' : 'F'); + retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); + + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_trans_rept("drake_set_synch", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); } return retval; @@ -487,124 +947,54 @@ int drake_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) */ int drake_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) { - int mdbuf_len, retval; - char mdbuf[BUFSZ]; - char cmode; - char cwidth; - char csynch; + int retval; + struct drake_priv_data *priv = STATE(rig)->priv; - retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_report_mode(rig, "drake_get_mode"); - if (retval != RIG_OK) + if (retval == RIG_OK) { - return retval; + *mode = priv->curr_mode; + *width = priv->curr_width; } - - if (mdbuf_len != 8) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_mode: wrong answer %s, " - "len=%d\n", mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - cmode = mdbuf[3]; - cwidth = mdbuf[4]; - csynch = mdbuf[5]; - - switch (cwidth & 0x37) - { - case '0': *width = s_Hz(500); break; - - case '1': *width = s_Hz(1800); break; - - case '2': *width = s_Hz(2300); break; - - case '3': *width = s_Hz(4000); break; - - case '4': *width = s_Hz(6000); break; - - default : - rig_debug(RIG_DEBUG_ERR, - "drake_get_mode: unsupported width %c\n", - cwidth); - *width = RIG_PASSBAND_NORMAL; - return -RIG_EINVAL; - } - - if ((cwidth >= '0') && (cwidth <= '4')) - { - switch (cmode & 0x33) - { - case '0': *mode = RIG_MODE_LSB; break; - - case '1': *mode = RIG_MODE_RTTY; break; - - case '2': *mode = RIG_MODE_FM; *width = s_Hz(12000); break; - - default : - rig_debug(RIG_DEBUG_ERR, - "drake_get_mode: unsupported mode %c\n", - cmode); - *mode = RIG_MODE_NONE; - return -RIG_EINVAL; - } - } - else - { - switch (cmode & 0x33) - { - case '0': *mode = RIG_MODE_USB; break; - - case '1': *mode = RIG_MODE_CW; break; - - case '2': *mode = RIG_MODE_AM; break; - - default : - rig_debug(RIG_DEBUG_ERR, - "drake_get_mode: unsupported mode %c\n", - cmode); - *mode = RIG_MODE_NONE; - return -RIG_EINVAL; - } - } - - if ((csynch & 0x34) == '4') - { - if (*mode == RIG_MODE_AM) - { - *mode = RIG_MODE_AMS; - } - else if (*mode == RIG_MODE_USB) - { - *mode = RIG_MODE_ECSSUSB; - } - else if (*mode == RIG_MODE_LSB) - { - *mode = RIG_MODE_ECSSLSB; - } - } - - return RIG_OK; + + return retval; } + /* * drake_set_ant * Assumes rig!=NULL */ int drake_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) { - unsigned char buf[16], ackbuf[BUFSZ]; - int ack_len, retval; + char buf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; SNPRINTF((char *) buf, sizeof(buf), "A%c" EOM, ant == RIG_ANT_1 ? '1' : (ant == RIG_ANT_2 ? '2' : 'C')); - retval = drake_transaction(rig, (char *) buf, strlen((char *)buf), - (char *) ackbuf, &ack_len); + retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_trans_rept("drake_set_ant", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } + /* * drake_get_ant * Assumes rig!=NULL @@ -612,61 +1002,60 @@ int drake_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) int drake_get_ant(RIG *rig, vfo_t vfo, ant_t dummy, value_t *option, ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx) { - int mdbuf_len, retval; - char mdbuf[BUFSZ]; - char cant; + int retval; + struct drake_priv_data *priv = STATE(rig)->priv; - retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_report_mode(rig, "drake_get_ant"); - if (retval != RIG_OK) + if (retval == RIG_OK) { - return retval; + *ant_curr = priv->curr_ant; } - - if (mdbuf_len != 8) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_ant: wrong answer %s, " - "len=%d\n", mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - cant = mdbuf[3]; - - switch (cant & 0x3c) - { - case '0': *ant_curr = RIG_ANT_1; break; - - case '4': *ant_curr = RIG_ANT_3; break; - - case '8': *ant_curr = RIG_ANT_2; break; - - default : - rig_debug(RIG_DEBUG_ERR, - "drake_get_ant: unsupported antenna %c\n", - cant); - return -RIG_EINVAL; - } - - return RIG_OK; + + return retval; } + /* * drake_set_mem * Assumes rig!=NULL */ int drake_set_mem(RIG *rig, vfo_t vfo, int ch) { - int ack_len, retval; - char buf[16], ackbuf[BUFSZ]; + char buf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; struct drake_priv_data *priv = STATE(rig)->priv; priv->curr_ch = ch; - SNPRINTF(buf, sizeof(buf), "C%03d" EOM, ch); + if (rig->caps->rig_model == RIG_MODEL_DKR8) + { + SNPRINTF(buf, sizeof(buf), "C%02d" EOM, ch); + } + else + { + SNPRINTF(buf, sizeof(buf), "C%03d" EOM, ch); + } ack_len = 0; // fix compile-time warning "possibly uninitialized" retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + //let's trick it + /* + char testbuf[2] = {0x0d, 0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ackbuf[1] = testbuf[1]; + ack_len = 2; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_trans_rept("drake_set_mem", buf, strlen(buf), ackbuf, ack_len, retval); + if (ack_len != 2) { rig_debug(RIG_DEBUG_ERR, "drake_set_mem: could not set channel %03d.\n", ch); @@ -676,42 +1065,27 @@ int drake_set_mem(RIG *rig, vfo_t vfo, int ch) return retval; } + /* * drake_get_mem * Assumes rig!=NULL */ int drake_get_mem(RIG *rig, vfo_t vfo, int *ch) { + int retval; struct drake_priv_data *priv = STATE(rig)->priv; - int mdbuf_len, retval; - char mdbuf[BUFSZ]; - int chan; - retval = drake_transaction(rig, "RC" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_report_mem_channel(rig, "drake_get_mem"); - if (retval != RIG_OK) + if (retval == RIG_OK) { - return retval; + *ch = priv->curr_ch; } - - if (mdbuf_len != 6) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_mem: wrong answer %s, " - "len=%d\n", mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - mdbuf[4] = '\0'; - - /* extract channel no */ - sscanf(mdbuf + 1, "%03d", &chan); - *ch = chan; - - priv->curr_ch = chan; - - return RIG_OK; + + return retval; } + /* * drake_set_chan * Assumes rig!=NULL @@ -768,6 +1142,7 @@ int drake_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) return retval; } + /* * drake_get_chan * Assumes rig!=NULL @@ -980,15 +1355,19 @@ int drake_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) return RIG_OK; } + /* * drake_vfo_op * Assumes rig!=NULL */ int drake_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) { + char buf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int len; + int retval; const struct drake_priv_data *priv = STATE(rig)->priv; - char buf[16], ackbuf[BUFSZ]; - int len, ack_len, retval; switch (op) { @@ -1014,7 +1393,14 @@ int drake_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) break; case RIG_OP_FROM_VFO: - SNPRINTF(buf, sizeof(buf), "PR" EOM "%03d" EOM, priv->curr_ch); + if (rig->caps->rig_model == RIG_MODEL_DKR8) + { + SNPRINTF(buf, sizeof(buf), "PR" EOM "%02d" EOM, priv->curr_ch); + } + else + { + SNPRINTF(buf, sizeof(buf), "PR" EOM "%03d" EOM, priv->curr_ch); + } break; default: @@ -1023,19 +1409,41 @@ int drake_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) len = strlen(buf); retval = drake_transaction(rig, buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, - &ack_len); + buf[len - 1] == 0x0d ? &ack_len : NULL); + + //let's trick it + /* + if ((op == RIG_OP_TO_VFO) || (op == RIG_OP_FROM_VFO)) + { + char testbuf[2] = {0x0d, 0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ackbuf[1] = testbuf[1]; + ack_len = 2; + ackbuf[ack_len] = 0x00; + retval = 0; + } + }*/ + + drake_trans_rept("drake_vfo_op", buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, + buf[len - 1] == 0x0d ? ack_len : 0, retval); return retval; } + /* * drake_set_func * Assumes rig!=NULL */ int drake_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) { - char buf[16], ackbuf[BUFSZ]; - int ack_len, retval; + char buf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; + char blanker = ' '; switch (func) { @@ -1048,8 +1456,23 @@ int drake_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) break; case RIG_FUNC_NB: - /* TODO: NB narrow */ - SNPRINTF(buf, sizeof(buf), "B%c" EOM, status ? 'W' : 'F'); + case RIG_FUNC_NB2: + if (!status) + { + blanker = 'F'; + } + else + { + if (func == RIG_FUNC_NB) + { + blanker = 'W'; + } + else //if (func == RIG_FUNC_NB2) + { + blanker = 'N'; + } + } + SNPRINTF(buf, sizeof(buf), "B%c" EOM, blanker); break; default: @@ -1058,62 +1481,63 @@ int drake_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_trans_rept("drake_set_func", buf, strlen(buf), ackbuf, ack_len, retval); + return retval; } + /* * drake_get_func * Assumes rig!=NULL */ int drake_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) { - int mdbuf_len, retval; - char mdbuf[BUFSZ]; - char mc; + int retval; + const struct drake_priv_data *priv = STATE(rig)->priv; - retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); + retval = drake_report_mode(rig, "drake_get_func"); - if (retval != RIG_OK) + if (retval == RIG_OK) { - return retval; + switch (func) + { + case RIG_FUNC_MN: *status = priv->curr_notch; break; + + case RIG_FUNC_NB: *status = priv->curr_nb; break; + + case RIG_FUNC_NB2: *status = priv->curr_nb2; break; + + default: rig_debug(RIG_DEBUG_ERR, "Unsupported get func %s\n", rig_strfunc(func)); + return -RIG_EINVAL; + } } - - if (mdbuf_len != 8) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_func: wrong answer %s, " - "len=%d\n", mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - switch (func) - { - case RIG_FUNC_MN: - mc = mdbuf[2]; - *status = ((mc & 0x32) == '2'); - break; - - case RIG_FUNC_NB: - /* TODO: NB narrow */ - mc = mdbuf[1]; - *status = ((mc >= '4') && (mc <= '?')); - break; - - default: - rig_debug(RIG_DEBUG_ERR, "Unsupported get func %s\n", rig_strfunc(func)); - return -RIG_EINVAL; - } - - return RIG_OK; + + return retval; } + /* * drake_set_level * Assumes rig!=NULL */ int drake_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) { - char buf[16], ackbuf[BUFSZ]; - int ack_len, retval; + char buf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; switch (level) { @@ -1137,177 +1561,165 @@ int drake_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_trans_rept("set_level", buf, strlen(buf), ackbuf, ack_len, retval); + return retval; } + /* * drake_get_level * Assumes rig!=NULL */ int drake_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) { - int lvl_len, retval, ss; - char lvlbuf[BUFSZ]; - char mc; + int retval; + const struct drake_priv_data *priv = STATE(rig)->priv; if ((level != RIG_LEVEL_RAWSTR) && (level != RIG_LEVEL_STRENGTH)) { - retval = drake_transaction(rig, "RM" EOM, 3, lvlbuf, &lvl_len); - - if (retval != RIG_OK) - { - return retval; - } - - if (lvl_len != 8) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_level: wrong answer %s, " - "len=%d\n", lvlbuf, lvl_len); - return -RIG_ERJCTED; - } + retval = drake_report_mode(rig, "drake_get_level"); } - - switch (level) + else { - case RIG_LEVEL_RAWSTR: - retval = drake_transaction(rig, "RSS" EOM, 4, lvlbuf, &lvl_len); - - if (retval != RIG_OK) + if (rig->caps->rig_model == RIG_MODEL_DKR8) { - return retval; - } - - if (lvl_len != 5) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_level: wrong answer" - "len=%d\n", lvl_len); - return -RIG_ERJCTED; - } - - lvlbuf[3] = '\0'; - val->i = strtol(lvlbuf + 1, (char **)NULL, 16); - break; - - case RIG_LEVEL_STRENGTH: - retval = drake_transaction(rig, "RSS" EOM, 4, lvlbuf, &lvl_len); - - if (retval != RIG_OK) - { - return retval; - } - - if (lvl_len != 5) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_level: wrong answer" - "len=%d\n", lvl_len); - return -RIG_ERJCTED; - } - - lvlbuf[3] = '\0'; - ss = strtol(lvlbuf + 1, (char **)NULL, 16); - val->i = (int)rig_raw2val(ss, &rig->caps->str_cal); - break; - - case RIG_LEVEL_PREAMP: - mc = lvlbuf[2]; - - if ((mc & 0x3c) == '8') - { - val->i = 10; + retval = drake_report_all(rig, "drake_get_level"); } else { - val->i = 0; + retval = drake_report_signal(rig, "drake_get_level"); } - - break; - - case RIG_LEVEL_ATT: - mc = lvlbuf[2]; - - if ((mc & 0x3c) == '4') - { - val->i = 10; - } - else - { - val->i = 0; - } - - break; - - case RIG_LEVEL_AGC: - mc = lvlbuf[1]; - - switch (mc & 0x33) - { - case '0': val->i = RIG_AGC_OFF; break; - - case '2': val->i = RIG_AGC_FAST; break; - - case '3': val->i = RIG_AGC_SLOW; break; - - default : val->i = RIG_AGC_FAST; - } - - break; - - default: - rig_debug(RIG_DEBUG_ERR, "Unsupported get_level %s\n", rig_strlevel(level)); - return -RIG_EINVAL; } - return RIG_OK; + if (retval == RIG_OK) + { + switch (level) + { + case RIG_LEVEL_PREAMP: val->i = (priv->curr_pre ? 10 : 0); break; + + case RIG_LEVEL_ATT: val->i = (priv->curr_att ? 10 : 0); break; + + case RIG_LEVEL_AGC: val->i = priv->curr_agc; break; + + case RIG_LEVEL_RAWSTR: + if (rig->caps->rig_model == RIG_MODEL_DKR8) + { + val->i = ((priv->curr_dcd == RIG_DCD_ON) ? 1 : 0); + } + else + { + val->i = priv->curr_ss; + } + break; + + case RIG_LEVEL_STRENGTH: + if (rig->caps->rig_model == RIG_MODEL_DKR8) + { + val->i = ((priv->curr_dcd == RIG_DCD_ON) ? 0 : -60); + } + else + { + val->i = (int)rig_raw2val(priv->curr_ss, &rig->caps->str_cal); + } + break; + + default: rig_debug(RIG_DEBUG_ERR, "Unsupported get_level %s\n", rig_strlevel(level)); + return -RIG_EINVAL; + } + } + + return retval; } + int drake_set_powerstat(RIG *rig, powerstat_t status) { - char buf[16], ackbuf[BUFSZ]; - int ack_len, retval; + char buf[16]; + char ackbuf[BUFSZ]; + int ack_len; + int retval; SNPRINTF(buf, sizeof(buf), "P%c" EOM, status == RIG_POWER_OFF ? 'F' : 'O'); retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); + //let's trick it + /* + char testbuf[1] = {0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ack_len = 1; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_trans_rept("set_power", buf, strlen(buf), ackbuf, ack_len, retval); + return retval; } + int drake_get_powerstat(RIG *rig, powerstat_t *status) { - int mdlen, retval; - char mdbuf[BUFSZ]; + int retval; + const struct drake_priv_data *priv = STATE(rig)->priv; - retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdlen); + retval = drake_report_mode(rig, "drake_get_powerstat"); - if (retval != RIG_OK) + if (retval == RIG_OK) { - return retval; + *status = priv->curr_pwr; } - - *status = (mdlen == 8); - - return RIG_OK; + + return retval; } - /* - * drake_set_freq + * drake_get_info * Assumes rig!=NULL */ const char *drake_get_info(RIG *rig) { static char idbuf[BUFSZ]; - int retval, id_len; + int id_len; + int retval; retval = drake_transaction(rig, "ID" EOM, 3, idbuf, &id_len); + //let's trick it + /* + char testbuf[4] = {'R','8',0x0d,0x0a}; + if (id_len == 0) + { + for (int i = 0; i < 4; i++) + idbuf[i] = testbuf[i]; + id_len = 4; + idbuf[id_len] = 0x00; + retval = 0; + }*/ + + drake_trans_rept("get_id", "ID" EOM, 3, idbuf, id_len, retval); + if (retval != RIG_OK) { - return NULL; + return ""; } - idbuf[id_len] = '\0'; + idbuf[id_len - 2] = '\0'; return idbuf; } @@ -1367,7 +1779,7 @@ DECLARE_PROBERIG_BACKEND(drake) return RIG_MODEL_NONE; } - idbuf[id_len] = '\0'; + idbuf[id_len - 2] = '\0'; if (!strcmp(idbuf, "R8B")) { diff --git a/rigs/drake/drake.h b/rigs/drake/drake.h index bdb610249..e1f5f6cd7 100644 --- a/rigs/drake/drake.h +++ b/rigs/drake/drake.h @@ -40,7 +40,8 @@ struct drake_priv_data { int curr_att; int curr_pre; int curr_notch; - int curr_pwr; + int curr_pwr; + int curr_ss; }; int drake_set_freq(RIG *rig, vfo_t vfo, freq_t freq); @@ -65,8 +66,13 @@ int drake_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val); int drake_set_powerstat (RIG * rig, powerstat_t status); int drake_get_powerstat (RIG * rig, powerstat_t *status); const char *drake_get_info(RIG *rig); -int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, int *data_len); +//temporary until everything from r8.c is moved back over to drake.c void drake_trans_rept(char* hdrStr, char* sentStr, int sentLen, char* recdStr, int recdLen, int res); +int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, int *data_len); +int drake_report_frequency(RIG *rig, char* owner); +int drake_report_mode(RIG *rig, char* owner); +int drake_report_mem_channel(RIG *rig, char* owner); +int drake_report_all(RIG *rig, char* owner); extern struct rig_caps r8_caps; extern struct rig_caps r8a_caps; diff --git a/rigs/drake/r8.c b/rigs/drake/r8.c index de6202238..9e831b0f8 100644 --- a/rigs/drake/r8.c +++ b/rigs/drake/r8.c @@ -21,39 +21,21 @@ //#include #include -#include +//#include //#include /* String function definitions */ //#include /* UNIX standard function definitions */ #include +#include "idx_builtin.h" //#include "serial.h" //#include "misc.h" -#include "idx_builtin.h" //#include "cal.h" //#include "register.h" #include "drake.h" -int drake_r8_set_freq(RIG *rig, vfo_t vfo, freq_t freq); -int drake_r8_get_freq(RIG *rig, vfo_t vfo, freq_t *freq); -int drake_r8_set_vfo(RIG *rig, vfo_t vfo); -int drake_r8_get_vfo(RIG *rig, vfo_t *vfo); -int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width); -int drake_r8_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width); -int drake_r8_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option); -int drake_r8_get_ant(RIG *rig, vfo_t vfo, ant_t dummy, value_t *option, ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx); -int drake_r8_set_mem(RIG *rig, vfo_t vfo, int ch); -int drake_r8_get_mem(RIG *rig, vfo_t vfo, int *ch); int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan); int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only); -int drake_r8_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op); -int drake_r8_set_func(RIG *rig, vfo_t vfo, setting_t func, int status); -int drake_r8_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status); -int drake_r8_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val); -int drake_r8_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val); -int drake_r8_set_powerstat (RIG * rig, powerstat_t status); -int drake_r8_get_powerstat (RIG * rig, powerstat_t *status); -const char *drake_r8_get_info(RIG *rig); #define BUFSZ 64 @@ -61,13 +43,6 @@ const char *drake_r8_get_info(RIG *rig); #define LF "\x0a" #define EOM CR -#define MD_USB '1' -#define MD_LSB '2' -#define MD_RTTY '3' -#define MD_CW '4' -#define MD_FM '5' -#define MD_AM '6' - #define R8_MODES (RIG_MODE_SSB|RIG_MODE_CW|RIG_MODE_RTTY|RIG_MODE_AM|RIG_MODE_AMS|RIG_MODE_FM) #define R8_FUNC (RIG_FUNC_MN|RIG_FUNC_NB|RIG_FUNC_NB2) @@ -204,26 +179,26 @@ struct rig_caps r8_caps = .rig_init = drake_init, .rig_cleanup = drake_cleanup, - .set_freq = drake_r8_set_freq, - .get_freq = drake_r8_get_freq, - .set_vfo = drake_r8_set_vfo, - .get_vfo = drake_r8_get_vfo, - .set_mode = drake_r8_set_mode, - .get_mode = drake_r8_get_mode, - .set_func = drake_r8_set_func, - .get_func = drake_r8_get_func, - .set_level = drake_r8_set_level, - .get_level = drake_r8_get_level, - .set_ant = drake_r8_set_ant, - .get_ant = drake_r8_get_ant, - .set_mem = drake_r8_set_mem, - .get_mem = drake_r8_get_mem, + .set_freq = drake_set_freq, + .get_freq = drake_get_freq, + .set_vfo = drake_set_vfo, + .get_vfo = drake_get_vfo, + .set_mode = drake_set_mode, + .get_mode = drake_get_mode, + .set_func = drake_set_func, + .get_func = drake_get_func, + .set_level = drake_set_level, + .get_level = drake_get_level, + .set_ant = drake_set_ant, + .get_ant = drake_get_ant, + .set_mem = drake_set_mem, + .get_mem = drake_get_mem, .set_channel = drake_r8_set_chan, .get_channel = drake_r8_get_chan, - .vfo_op = drake_r8_vfo_op, - .set_powerstat = drake_r8_set_powerstat, - .get_powerstat = drake_r8_get_powerstat, - .get_info = drake_r8_get_info, + .vfo_op = drake_vfo_op, + .set_powerstat = drake_set_powerstat, + .get_powerstat = drake_get_powerstat, + .get_info = drake_get_info, .hamlib_check_rig_caps = HAMLIB_CHECK_RIG_CAPS }; @@ -231,761 +206,6 @@ struct rig_caps r8_caps = * Function definitions below */ - -/* - * drake_decode_frequency - * Common routine to decode the frequency block - */ -void drake_r8_decode_frequency(RIG *rig, char* freqbuf, int offset) -{ - double f; - char fmult; - struct drake_priv_data *priv = STATE(rig)->priv; - - if ((freqbuf[9+offset] == '*') || (freqbuf[9+offset] == '#')) - priv->curr_dcd = RIG_DCD_ON; - else - priv->curr_dcd = RIG_DCD_OFF; - - fmult = freqbuf[10+offset]; - - freqbuf[9+offset] = '\0'; - /* extract freq */ - sscanf(freqbuf+offset, "%lf", &f); - f *= 1000.0; - - if ((fmult == 'm') || (fmult == 'M')) - f *= 1000.0; - - priv->curr_freq = (freq_t)f; -} - - -/* - * drake_report_freq - * Common routine to retrieve frequency and squelch settings (used for DCD) - * Data stored in priv for any routine to use - * Assumes rig!=NULL - */ -int drake_r8_report_frequency(RIG *rig, char* owner) -{ - int freq_len; - int retval; - char freqbuf[BUFSZ]; - - retval = drake_transaction(rig, "RF" EOM, 3, freqbuf, &freq_len); - - //let's trick it - /* - char testbuf[15] = {' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; - if (freq_len == 0) - { - for (int i=0; i < 15; i++) { - freqbuf[i] = testbuf[i]; - } - freq_len = 15; - freqbuf[freq_len] = 0x00; - retval = RIG_OK; - }*/ - - drake_trans_rept(owner, "RF" EOM, 3, freqbuf, freq_len, retval); - - if (retval != RIG_OK) - { - return retval; - } - - if (freq_len != 15) - { - rig_debug(RIG_DEBUG_ERR, "%s: wrong answer %s, " - "len=%d\n", owner, freqbuf, freq_len); - return -RIG_ERJCTED; - } - - drake_r8_decode_frequency(rig, freqbuf, 0); - - return RIG_OK; -} - - -/* - * drake_decode_mode - * Common routine to break out the 5-character mode string - */ -void drake_r8_decode_mode(RIG *rig, char* mdbuf, int offset) -{ - struct drake_priv_data *priv = STATE(rig)->priv; - - //noise blanker - priv->curr_nb = ((mdbuf[offset] >= '<') && (mdbuf[offset] <= '?')); - priv->curr_nb2 = ((mdbuf[offset] >= '4') && (mdbuf[offset] <= '7')); - - //agc - switch (mdbuf[offset] & 0x33) - { - case '0': priv->curr_agc = RIG_AGC_OFF; break; - - case '2': priv->curr_agc = RIG_AGC_FAST; break; - - case '3': priv->curr_agc = RIG_AGC_SLOW; break; - - default : priv->curr_agc = RIG_AGC_OFF; - } - - //preamp, attenuator and notch - priv->curr_pre = ((mdbuf[1+offset] & 0x3c) == '8'); - priv->curr_att = ((mdbuf[1+offset] & 0x3c) == '4'); - priv->curr_notch = ((mdbuf[1+offset] & 0x32) == '2'); - - //ant - switch (mdbuf[2+offset] & 0x3c) - { - case '0': priv->curr_ant = RIG_ANT_1; break; - - case '4': priv->curr_ant = RIG_ANT_3; break; - - case '8': priv->curr_ant = RIG_ANT_2; break; - - default : priv->curr_ant = RIG_ANT_1; - } - - //width - switch (mdbuf[3+offset] & 0x37) - { - case '0': priv->curr_width = s_Hz(500); break; - - case '1': priv->curr_width = s_Hz(1800); break; - - case '2': priv->curr_width = s_Hz(2300); break; - - case '3': priv->curr_width = s_Hz(4000); break; - - case '4': priv->curr_width = s_Hz(6000); break; - - default : priv->curr_width = RIG_PASSBAND_NORMAL; - } - - //mode - if ((mdbuf[3+offset] >= '0') && (mdbuf[3+offset] <= '4')) - { - switch (mdbuf[2+offset] & 0x33) - { - case '0': priv->curr_mode = RIG_MODE_LSB; break; - - case '1': priv->curr_mode = RIG_MODE_RTTY; break; - - case '2': priv->curr_mode = RIG_MODE_FM; priv->curr_width = s_Hz(12000); break; - - default : priv->curr_mode = RIG_MODE_NONE; - } - } - else - { - switch (mdbuf[2+offset] & 0x33) - { - case '0': priv->curr_mode = RIG_MODE_USB; break; - - case '1': priv->curr_mode = RIG_MODE_CW; break; - - case '2': priv->curr_mode = RIG_MODE_AM; break; - - default : priv->curr_mode = RIG_MODE_NONE; - } - } - //synch - if ((mdbuf[4+offset] & 0x34) == '4') - { - if (priv->curr_mode == RIG_MODE_AM) - { - priv->curr_mode = RIG_MODE_AMS; - } - else if (priv->curr_mode == RIG_MODE_USB) - { - priv->curr_mode = RIG_MODE_ECSSUSB; - } - else if (priv->curr_mode == RIG_MODE_LSB) - { - priv->curr_mode = RIG_MODE_ECSSLSB; - } - } - - //vfo - switch (mdbuf[4+offset] & 0x38) - { - case '0' : priv->curr_vfo = RIG_VFO_B; break; - - case '8' : priv->curr_vfo = RIG_VFO_A; break; - - default : priv->curr_vfo = RIG_VFO_VFO; - } -} - - -/* - * drake_report_mode - * Common routine to retrieve NB, AGC, ATT, PRE, NF, ANT, MODE, BW, and VFO (and scanning) settings - * Data stored in priv for any routine to use - * Assumes rig!=NULL - */ -int drake_r8_report_mode(RIG *rig, char* owner) -{ - int mdbuf_len; - int retval; - char mdbuf[BUFSZ]; - struct drake_priv_data *priv = STATE(rig)->priv; - - retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); - - //let's trick it - /* - char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning - if (mdbuf_len == 0) - { - for (int i=0; i < 7; i++) { - mdbuf[i] = testbuf[i]; - } - mdbuf_len = 7; - mdbuf[mdbuf_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept(owner, "RM" EOM, 3, mdbuf, mdbuf_len, retval); - - if (retval != RIG_OK) - { - return retval; - } - - if (mdbuf_len != 7) - { - priv->curr_pwr = false; - rig_debug(RIG_DEBUG_ERR, "%s: wrong answer %s, " - "len=%d\n", owner, mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - priv->curr_pwr = true; - drake_r8_decode_mode(rig, mdbuf, 0); - - return RIG_OK; -} - - -/* - * drake_r8_decode_mem_channel - * Common routine to break out the 3-character mem string - */ -void drake_r8_decode_mem_channel(RIG *rig, char* mdbuf, int offset) -{ - struct drake_priv_data *priv = STATE(rig)->priv; - - if (mdbuf[offset] == '*') - { - priv->curr_vfo = RIG_VFO_MEM; - } - - priv->curr_ch = (mdbuf[1+offset] & 0x0f) * 10 + (mdbuf[2+offset] & 0x0f); -} - -/* - * drake_report_mem_channel - * Common routine to retrieve the memory channel number - * Data stored in priv for any routine to use - * Assumes rig!=NULL - */ -int drake_r8_report_mem_channel(RIG *rig, char* owner) -{ - int mdbuf_len; - int retval; - char mdbuf[BUFSZ]; - - retval = drake_transaction(rig, "RC" EOM, 3, mdbuf, &mdbuf_len); - - //let's trick it - /* - char testbuf[5] = {' ','0','0', 0x0d, 0x0a }; - if (mdbuf_len == 0) - { - for (int i=0; i < 5; i++) { - mdbuf[i] = testbuf[i]; - } - mdbuf_len = 5; - mdbuf[mdbuf_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept(owner, "RC" EOM, 3, mdbuf, mdbuf_len, retval); - - if (retval != RIG_OK) - { - return retval; - } - - if (mdbuf_len != 5) - { - rig_debug(RIG_DEBUG_ERR, "%s: wrong answer %s, " - "len=%d\n", owner, mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - drake_r8_decode_mem_channel(rig, mdbuf, 0); - - return RIG_OK; -} - - -/* - * drake_report_all - * Common routine to retrieve all of the radio's settings - * Data stored in priv for any routine to use - * Assumes rig!=NULL - */ -int drake_r8_report_all(RIG *rig, char* owner) -{ - int mdbuf_len; - int retval; - char mdbuf[BUFSZ]; - - retval = drake_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); - - //let's trick it - /* - char testbuf[25] = {' ','0','0',' ','2','0','2','<','8', ' ', ' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; //mem off, ch 00, NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning - if (mdbuf_len == 0) - { - for (int i=0; i < 25; i++) { - mdbuf[i] = testbuf[i]; - } - mdbuf_len = 25; - mdbuf[mdbuf_len] = 0x00; - retval = RIG_OK; - }*/ - - drake_trans_rept(owner, "RA" EOM, 3, mdbuf, mdbuf_len, retval); - - if (retval != RIG_OK) - { - return retval; - } - - if (mdbuf_len != 25) - { - rig_debug(RIG_DEBUG_ERR, "%s: wrong answer %s, " - "len=%d\n", owner, mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - //check RC *after* decoding the VFO in RM - //otherwise RIG_VFO_MEM gets squashed - drake_r8_decode_mode(rig, mdbuf, 4); - drake_r8_decode_mem_channel(rig, mdbuf, 0); - drake_r8_decode_frequency(rig, mdbuf, 10); - - return RIG_OK; -} - - -/* - * drake_set_freq - * Assumes rig!=NULL - */ -int drake_r8_set_freq(RIG *rig, vfo_t vfo, freq_t freq) -{ - char freqbuf[16]; - char ackbuf[BUFSZ]; - int ack_len; - int retval; - - /* - * 10Hz resolution - * TODO: round nearest? - */ - SNPRINTF((char *) freqbuf, sizeof(freqbuf), "F%07u" EOM, (unsigned int)freq / 10); - - retval = drake_transaction(rig, freqbuf, strlen(freqbuf), ackbuf, &ack_len); - - //let's trick it - /* - char testbuf[2] = {0x0d, 0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ackbuf[1] = testbuf[1]; - ack_len = 2; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept("drake_set_freq", freqbuf, strlen(freqbuf), ackbuf, ack_len, retval); - - return retval; -} - - -/* - * drake_get_freq - * Assumes rig!=NULL, freq!=NULL - */ -int drake_r8_get_freq(RIG *rig, vfo_t vfo, freq_t *freq) -{ - int retval; - struct drake_priv_data *priv = STATE(rig)->priv; - - retval = drake_r8_report_frequency(rig, "drake_get_freq"); - - if (retval == RIG_OK) - { - *freq = priv->curr_freq; - } - - return retval; -} - - -/* - * drake_set_vfo - * Assumes rig!=NULL - */ -int drake_r8_set_vfo(RIG *rig, vfo_t vfo) -{ - char cmdbuf[16]; - char ackbuf[BUFSZ]; - int ack_len; - int retval; - char vfo_function; - - switch (vfo) - { - case RIG_VFO_A : vfo_function = 'A'; break; - - case RIG_VFO_B : vfo_function = 'B'; break; - - case RIG_VFO_VFO: vfo_function = 'F'; break; - - case RIG_VFO_MEM: vfo_function = 'C'; break; - - default: - rig_debug(RIG_DEBUG_ERR, "drake_set_vfo: unsupported VFO %s\n", - rig_strvfo(vfo)); - return -RIG_EINVAL; - } - - if ((vfo_function == 'A') || (vfo_function == 'B')) - { - SNPRINTF((char *) cmdbuf, sizeof(cmdbuf), "V%c" EOM, vfo_function); - } - - if ((vfo_function == 'F') || (vfo_function == 'C')) - { - SNPRINTF((char *) cmdbuf, sizeof(cmdbuf), "%c" EOM, vfo_function); - } - - retval = drake_transaction(rig, cmdbuf, strlen(cmdbuf), ackbuf, &ack_len); - - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = RIG_OK; - }*/ - - drake_trans_rept("drake_set_vfo", cmdbuf, strlen(cmdbuf), ackbuf, ack_len, retval); - - return retval; -} - - - -/* - * drake_get_vfo - * Assumes rig!=NULL - */ -int drake_r8_get_vfo(RIG *rig, vfo_t *vfo) -{ - int retval; - struct drake_priv_data *priv = STATE(rig)->priv; - - retval = drake_r8_report_all(rig, "drake_get_vfo"); - - if (retval == RIG_OK) - { - *vfo = priv->curr_vfo; - } - - return retval; -} - - -/* - * drake_set_mode - * Assumes rig!=NULL - */ -int drake_r8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) -{ - char mdbuf[16]; - char ackbuf[BUFSZ]; - int ack_len; - char mode_sel; - int retval; - - switch (mode) - { - case RIG_MODE_CW: mode_sel = MD_CW; break; - - case RIG_MODE_USB: mode_sel = MD_USB; break; - - case RIG_MODE_LSB: mode_sel = MD_LSB; break; - - case RIG_MODE_FM: mode_sel = MD_FM; break; - - case RIG_MODE_AMS: - case RIG_MODE_AM: mode_sel = MD_AM; break; - - case RIG_MODE_RTTY: mode_sel = MD_RTTY; break; - - default: - rig_debug(RIG_DEBUG_ERR, "drake_set_mode: " - "unsupported mode %s\n", rig_strrmode(mode)); - return -RIG_EINVAL; - } - - SNPRINTF((char *) mdbuf, sizeof(mdbuf), "M%c" EOM, mode_sel); - retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); - - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept("drake_set_mode", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); - - if (retval != RIG_OK) - { - return retval; - } - - if (width != RIG_PASSBAND_NOCHANGE) - { - if (mode != RIG_MODE_FM) - { - unsigned int width_sel; - - if (width == RIG_PASSBAND_NORMAL) - { - width = rig_passband_normal(rig, mode); - } - - if (width <= 500) - { - width_sel = '0'; - } - else if (width <= 1800) - { - width_sel = '1'; - } - else if (width <= 2300) - { - width_sel = '2'; - } - else if (width <= 4000) - { - width_sel = '4'; - } - else - { - width_sel = '6'; - } - - SNPRINTF((char *) mdbuf, sizeof(mdbuf), "W%c" EOM, width_sel); - retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); - - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept("drake_set_bw", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); - - } - } - - if ((mode == RIG_MODE_AMS) || (mode == RIG_MODE_AM)) - { - SNPRINTF((char *) mdbuf, sizeof(mdbuf), "S%c" EOM, - (mode == RIG_MODE_AMS) ? 'O' : 'F'); - retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); - - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept("drake_set_synch", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); - } - - return retval; -} - - -/* - * drake_get_mode - * Assumes rig!=NULL - */ -int drake_r8_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) -{ - int retval; - struct drake_priv_data *priv = STATE(rig)->priv; - - retval = drake_r8_report_mode(rig, "drake_get_mode"); - - if (retval == RIG_OK) - { - *mode = priv->curr_mode; - *width = priv->curr_width; - } - - return retval; -} - - -/* - * drake_set_ant - * Assumes rig!=NULL - */ -int drake_r8_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) -{ - char buf[16]; - char ackbuf[BUFSZ]; - int ack_len; - int retval; - - SNPRINTF((char *) buf, sizeof(buf), "A%c" EOM, - ant == RIG_ANT_1 ? '1' : (ant == RIG_ANT_2 ? '2' : 'C')); - - retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept("drake_set_ant", buf, strlen(buf), ackbuf, ack_len, retval); - - return retval; -} - - -/* - * drake_get_ant - * Assumes rig!=NULL - */ -int drake_r8_get_ant(RIG *rig, vfo_t vfo, ant_t dummy, value_t *option, - ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx) -{ - int retval; - struct drake_priv_data *priv = STATE(rig)->priv; - - retval = drake_r8_report_mode(rig, "drake_get_ant"); - - if (retval == RIG_OK) - { - *ant_curr = priv->curr_ant; - } - - return retval; -} - - -/* - * drake_set_mem - * Assumes rig!=NULL - */ -int drake_r8_set_mem(RIG *rig, vfo_t vfo, int ch) -{ - char buf[16]; - char ackbuf[BUFSZ]; - int ack_len; - int retval; - struct drake_priv_data *priv = STATE(rig)->priv; - - priv->curr_ch = ch; - - SNPRINTF(buf, sizeof(buf), "C%02d" , ch); - - ack_len = 0; // fix compile-time warning "possibly uninitialized" - retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - - //let's trick it - /* - char testbuf[2] = {0x0d, 0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ackbuf[1] = testbuf[1]; - ack_len = 2; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept("drake_set_mem", buf, strlen(buf), ackbuf, ack_len, retval); - - if (ack_len != 2) - { - rig_debug(RIG_DEBUG_ERR, "drake_set_mem: could not set channel %02d.\n", ch); - retval = -RIG_ERJCTED; - } - - return retval; -} - -/* - * drake_get_mem - * Assumes rig!=NULL - */ -int drake_r8_get_mem(RIG *rig, vfo_t vfo, int *ch) -{ - int retval; - struct drake_priv_data *priv = STATE(rig)->priv; - - retval = drake_r8_report_mem_channel(rig, "drake_get_mem"); - - if (retval == RIG_OK) - { - *ch = priv->curr_ch; - } - - return retval; -} - - /* * drake_set_chan * Assumes rig!=NULL @@ -1003,14 +223,14 @@ int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) dummy.i = 0; - drake_r8_get_vfo(rig, &old_vfo); + drake_get_vfo(rig, &old_vfo); old_chan = 0; /* set to vfo if needed */ if (old_vfo == RIG_VFO_MEM) { old_chan = priv->curr_ch; - retval = drake_r8_set_vfo(rig, RIG_VFO_VFO); + retval = drake_set_vfo(rig, RIG_VFO_VFO); if (retval != RIG_OK) { @@ -1019,19 +239,21 @@ int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) } /* set all memory features */ - drake_r8_set_ant(rig, RIG_VFO_CURR, chan->ant, dummy); - drake_r8_set_freq(rig, RIG_VFO_CURR, chan->freq); - drake_r8_set_mode(rig, RIG_VFO_CURR, chan->mode, chan->width); - drake_r8_set_func(rig, RIG_VFO_CURR, RIG_FUNC_NB, - (chan->funcs & RIG_FUNC_NB) == RIG_FUNC_NB); - drake_r8_set_level(rig, RIG_VFO_CURR, RIG_LEVEL_AGC, - chan->levels[rig_setting2idx(RIG_LEVEL_AGC)]); - drake_r8_set_level(rig, RIG_VFO_CURR, RIG_LEVEL_PREAMP, - chan->levels[rig_setting2idx(RIG_LEVEL_PREAMP)]); - drake_r8_set_level(rig, RIG_VFO_CURR, RIG_LEVEL_ATT, - chan->levels[rig_setting2idx(RIG_LEVEL_ATT)]); - drake_r8_set_func(rig, RIG_VFO_CURR, RIG_FUNC_MN, - (chan->funcs & RIG_FUNC_MN) == RIG_FUNC_MN); + drake_set_ant(rig, RIG_VFO_CURR, chan->ant, dummy); + drake_set_freq(rig, RIG_VFO_CURR, chan->freq); + drake_set_mode(rig, RIG_VFO_CURR, chan->mode, chan->width); + drake_set_func(rig, RIG_VFO_CURR, RIG_FUNC_NB, + (chan->funcs & RIG_FUNC_NB) == RIG_FUNC_NB); + drake_set_func(rig, RIG_VFO_CURR, RIG_FUNC_NB2, + (chan->funcs & RIG_FUNC_NB2) == RIG_FUNC_NB2); + drake_set_level(rig, RIG_VFO_CURR, RIG_LEVEL_AGC, + chan->levels[rig_setting2idx(RIG_LEVEL_AGC)]); + drake_set_level(rig, RIG_VFO_CURR, RIG_LEVEL_PREAMP, + chan->levels[rig_setting2idx(RIG_LEVEL_PREAMP)]); + drake_set_level(rig, RIG_VFO_CURR, RIG_LEVEL_ATT, + chan->levels[rig_setting2idx(RIG_LEVEL_ATT)]); + drake_set_func(rig, RIG_VFO_CURR, RIG_FUNC_MN, + (chan->funcs & RIG_FUNC_MN) == RIG_FUNC_MN); SNPRINTF(mdbuf, sizeof(mdbuf), "PR" EOM "%02d" EOM, chan->channel_num); retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); @@ -1052,7 +274,7 @@ int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) if (old_vfo == RIG_VFO_MEM) { - drake_r8_set_mem(rig, RIG_VFO_CURR, old_chan); + drake_set_mem(rig, RIG_VFO_CURR, old_chan); } return retval; @@ -1097,7 +319,7 @@ int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) chan->flags = RIG_CHFLAG_SKIP; strcpy(chan->channel_desc, " "); - drake_r8_get_vfo(rig, &old_vfo); + drake_get_vfo(rig, &old_vfo); old_chan = 0; if (old_vfo == RIG_VFO_MEM) @@ -1106,14 +328,14 @@ int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) } //go to new channel - retval = drake_r8_set_mem(rig, RIG_VFO_CURR, chan->channel_num); + retval = drake_set_mem(rig, RIG_VFO_CURR, chan->channel_num); if (retval != RIG_OK) { return RIG_OK; } - retval = drake_r8_report_all(rig, "drake_get_chan"); + retval = drake_report_all(rig, "drake_get_chan"); if (retval != RIG_OK) { @@ -1147,7 +369,7 @@ int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) //we apparently can't do a read-only channel read if (old_vfo != RIG_VFO_MEM) { - retval = drake_r8_set_vfo(rig, RIG_VFO_VFO); + retval = drake_set_vfo(rig, RIG_VFO_VFO); if (retval != RIG_OK) { @@ -1156,7 +378,7 @@ int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) } else { - retval = drake_r8_set_mem(rig, RIG_VFO_CURR, old_chan); + retval = drake_set_mem(rig, RIG_VFO_CURR, old_chan); if (retval != RIG_OK) { @@ -1167,318 +389,3 @@ int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) return RIG_OK; } - -/* - * drake_vfo_op - * Assumes rig!=NULL - */ -int drake_r8_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) -{ - char buf[16]; - char ackbuf[BUFSZ]; - int ack_len; - int len; - int retval; - const struct drake_priv_data *priv = STATE(rig)->priv; - - switch (op) - { - case RIG_OP_UP: - SNPRINTF(buf, sizeof(buf), "U"); - break; - - case RIG_OP_DOWN: - SNPRINTF(buf, sizeof(buf), "D"); - break; - - case RIG_OP_TO_VFO: - SNPRINTF(buf, sizeof(buf), "F" EOM); - break; - - case RIG_OP_FROM_VFO: - SNPRINTF(buf, sizeof(buf), "PR" EOM "%02d" EOM, priv->curr_ch); - break; - - default: - return -RIG_EINVAL; - } - - len = strlen(buf); - retval = drake_transaction(rig, buf, len, len == 1 ? ackbuf : NULL, - len == 1 ? &ack_len : NULL); - - //let's trick it - /* - if ((op == RIG_OP_TO_VFO) || (op == RIG_OP_FROM_VFO)) - { - char testbuf[2] = {0x0d, 0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ackbuf[1] = testbuf[1]; - ack_len = 2; - ackbuf[ack_len] = 0x00; - retval = 0; - } - }*/ - - drake_trans_rept("drake_vfo_op", buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, - buf[len - 1] == 0x0d ? ack_len : 0, retval); - - return retval; -} - - -/* - * drake_set_func - * Assumes rig!=NULL - */ -int drake_r8_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) -{ - char buf[16]; - char ackbuf[BUFSZ]; - int ack_len; - int retval; - char blanker = ' '; - - switch (func) - { - case RIG_FUNC_MN: - SNPRINTF(buf, sizeof(buf), "N%c" EOM, status ? 'O' : 'F'); - break; - - case RIG_FUNC_NB: - case RIG_FUNC_NB2: - if (!status) - blanker = 'F'; - else if (func == RIG_FUNC_NB) - blanker = 'W'; - else //if (func == RIG_FUNC_NB2) - blanker = 'N'; - SNPRINTF(buf, sizeof(buf), "B%c" EOM, blanker); - break; - - default: - return -RIG_EINVAL; - } - - retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept("drake_set_func", buf, strlen(buf), ackbuf, ack_len, retval); - - return retval; -} - - -/* - * drake_get_func - * Assumes rig!=NULL - */ -int drake_r8_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) -{ - int retval; - const struct drake_priv_data *priv = STATE(rig)->priv; - - retval = drake_r8_report_mode(rig, "drake_get_func"); - - if (retval == RIG_OK) - { - switch (func) - { - case RIG_FUNC_MN: *status = priv->curr_notch; break; - - case RIG_FUNC_NB: *status = priv->curr_nb; break; - - case RIG_FUNC_NB2: *status = priv->curr_nb2; break; - - default: rig_debug(RIG_DEBUG_ERR, "Unsupported get func %s\n", rig_strfunc(func)); - return -RIG_EINVAL; - } - } - - return retval; -} - - -/* - * drake_set_level - * Assumes rig!=NULL - */ -int drake_r8_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) -{ - char buf[16]; - char ackbuf[BUFSZ]; - int ack_len; - int retval; - - switch (level) - { - case RIG_LEVEL_PREAMP: - SNPRINTF(buf, sizeof(buf), "G%c" EOM, val.i ? '+' : '0'); - break; - - case RIG_LEVEL_ATT: - SNPRINTF(buf, sizeof(buf), "G%c" EOM, val.i ? '-' : '0'); - break; - - case RIG_LEVEL_AGC: - SNPRINTF(buf, sizeof(buf), "A%c" EOM, - val.i == RIG_AGC_OFF ? 'O' : - (val.i == RIG_AGC_FAST ? 'F' : 'S')); - break; - - default: - return -RIG_EINVAL; - } - - retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept("set_level", buf, strlen(buf), ackbuf, ack_len, retval); - - return retval; -} - - -/* - * drake_get_level - * Assumes rig!=NULL - */ -int drake_r8_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) -{ - int retval; - const struct drake_priv_data *priv = STATE(rig)->priv; - - if ((level == RIG_LEVEL_STRENGTH) || (level == RIG_LEVEL_RAWSTR)) - { - retval = drake_r8_report_all(rig, "drake_get_level"); - } - else - { - retval = drake_r8_report_mode(rig, "drake_get_level"); - } - - if (retval == RIG_OK) - { - switch (level) - { - case RIG_LEVEL_PREAMP: val->i = (priv->curr_pre ? 10 : 0); break; - - case RIG_LEVEL_ATT: val->i = (priv->curr_att ? 10 : 0); break; - - case RIG_LEVEL_AGC: val->i = priv->curr_agc; break; - - case RIG_LEVEL_RAWSTR: val->i = ((priv->curr_dcd == RIG_DCD_ON) ? 1 : 0); break; - - case RIG_LEVEL_STRENGTH: val->i = ((priv->curr_dcd == RIG_DCD_ON) ? 0 : -60); break; - - default: rig_debug(RIG_DEBUG_ERR, "Unsupported get_level %s\n", rig_strlevel(level)); - return -RIG_EINVAL; - } - } - - return retval; -} - - -int drake_r8_set_powerstat(RIG *rig, powerstat_t status) -{ - char buf[16]; - char ackbuf[BUFSZ]; - int ack_len; - int retval; - - SNPRINTF(buf, sizeof(buf), "P%c" EOM, status == RIG_POWER_OFF ? 'F' : 'O'); - - retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept("set_power", buf, strlen(buf), ackbuf, ack_len, retval); - - return retval; -} - - -int drake_r8_get_powerstat(RIG *rig, powerstat_t *status) -{ - int retval; - const struct drake_priv_data *priv = STATE(rig)->priv; - - retval = drake_r8_report_mode(rig, "drake_get_powerstat"); - - if (retval == RIG_OK) - { - *status = priv->curr_pwr; - } - - return retval; -} - - -/* - * drake_get_info - * Assumes rig!=NULL - */ -const char *drake_r8_get_info(RIG *rig) -{ - static char idbuf[BUFSZ]; - int retval; - int id_len; - - retval = drake_transaction(rig, "ID" EOM, 3, idbuf, &id_len); - - //let's trick it - /* - char testbuf[4] = {'R','8',0x0d,0x0a}; - if (id_len == 0) - { - for (int i = 0; i < 4; i++) - idbuf[i] = testbuf[i]; - id_len = 4; - idbuf[id_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept("get_id", "ID" EOM, 3, idbuf, id_len, retval); - - if (retval != RIG_OK) - { - return ""; - } - - idbuf[id_len - 2] = '\0'; - - return idbuf; -} - From 49b01e196874961d64a60136cfe44c29c5c7ebd8 Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Fri, 4 Jul 2025 20:54:45 -0400 Subject: [PATCH 13/16] Removed EOM from set_mem's "Cxx" command because it was leaving an extra LF in the receive queue, messing up the response to any subsequent command. --- rigs/drake/drake.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rigs/drake/drake.c b/rigs/drake/drake.c index 193f6b52f..32999d6cc 100644 --- a/rigs/drake/drake.c +++ b/rigs/drake/drake.c @@ -1032,11 +1032,11 @@ int drake_set_mem(RIG *rig, vfo_t vfo, int ch) if (rig->caps->rig_model == RIG_MODEL_DKR8) { - SNPRINTF(buf, sizeof(buf), "C%02d" EOM, ch); + SNPRINTF(buf, sizeof(buf), "C%02d", ch); } else { - SNPRINTF(buf, sizeof(buf), "C%03d" EOM, ch); + SNPRINTF(buf, sizeof(buf), "C%03d", ch); } ack_len = 0; // fix compile-time warning "possibly uninitialized" From ec0a04669c3dd658d5b7fbe57ffc1af642a48552 Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Sat, 5 Jul 2025 09:41:52 -0400 Subject: [PATCH 14/16] Merged remaining R8 set/get memory channel routines over to drake.c Cleaned up comments and added interface documentation to newly added routines Added TODO notes for things yet to be handled on R8A/B, such as channel name --- rigs/drake/drake.c | 505 ++++++++++++++------------------------------- rigs/drake/drake.h | 7 - rigs/drake/r8.c | 207 +------------------ 3 files changed, 159 insertions(+), 560 deletions(-) diff --git a/rigs/drake/drake.c b/rigs/drake/drake.c index 32999d6cc..a247a9734 100644 --- a/rigs/drake/drake.c +++ b/rigs/drake/drake.c @@ -51,10 +51,13 @@ #define MD_FM '5' #define MD_AM '6' +/* DEBUGGING ROUTINES TO ECHO TRANSACTIONS WITH SCREEN READABLE CTRL CHARS */ /* * drake_fix_string * recursively replaces all special characters so they are readable at output + * + * input: inStr - the raw string to expand * */ void drake_fix_string(char* inStr) @@ -93,6 +96,13 @@ void drake_fix_string(char* inStr) /* * drake_trans_rept * non-destructively echoes transaction in a readable way for debugging + * + * inputs: hdrStr - the calling routine identifier + * sentStr - the command sent to the radio + * sentLen - the length of sentSt + * recdStr - the radio's response string + * recdLen - the length of recdStr + * res - The transaction reposnse */ void drake_trans_rept(char* hdrStr, char* sentStr, int sentLen, char* recdStr, int recdLen, int res) { @@ -134,10 +144,20 @@ void drake_trans_rept(char* hdrStr, char* sentStr, int sentLen, char* recdStr, i } +/* PRIMARY COMMS LOOP TO RADIO */ /* * drake_transaction + * + * inputs: rig - pointer to RIG structure + * cmd - buffer containing command to be sent to the radio + * cmd_len - the length of cmd + * data - buffer that will receive the radio's response string + * data_len - the length of data + * returns : transaction error status + * * We assume that rig!=NULL, STATE(rig)!= NULL, data!=NULL, data_len!=NULL + * Note: size of data buffer must be BUFSZ otherwise a buffer overrun is possible */ int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, int *data_len) @@ -147,8 +167,8 @@ int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, rig_flush(rp); - //assume nothing. - //initialize the buffer in case empty on return + // assume nothing. + // initialize the buffer in case empty on return if ((data) && (data_len)) { data[0] = 0x00; @@ -162,7 +182,7 @@ int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, return retval; } - /* no data expected, TODO: flush input? */ + // no data expected, TODO: flush input? if (!data || !data_len) { return 0; @@ -171,12 +191,6 @@ int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, retval = read_string(rp, (unsigned char *) data, BUFSZ, LF, 1, 0, 1); - //if (retval == -RIG_ETIMEOUT) - //{ - //data[0] = 0x00; - //*data_len = 0; - //} - if (retval < 0) { return retval; @@ -188,7 +202,20 @@ int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, return RIG_OK; } +/* COMMON RADIO POLLING AND RESPONSE DECODING ROUTINES */ +/* + * drake_report_signal + * Common routine to retrieve signal strength on R8A/B + * Note that we use dcd to emulate signal presence on the R8 + * since it has no actual signal strength reporting capability + * + * inputs: rig - pointer to RIG structure + * owner - the calling routine identifier + * returns: command error status + * + * Assumes rig!=NULL + */ int drake_report_signal(RIG *rig, char* owner) { char lvlbuf[BUFSZ]; @@ -198,6 +225,8 @@ int drake_report_signal(RIG *rig, char* owner) retval = drake_transaction(rig, "RSS" EOM, 4, lvlbuf, &lvl_len); + //char testbuf[5] = {'2', '5', '5', 0x0d, 0x0a }; + drake_trans_rept(owner, "RSS" EOM, 4, lvlbuf, lvl_len, retval); if (retval != RIG_OK) @@ -207,8 +236,8 @@ int drake_report_signal(RIG *rig, char* owner) if (lvl_len != 5) { - rig_debug(RIG_DEBUG_ERR, "drake_get_level: wrong answer" - "len=%d\n", lvl_len); + rig_debug(RIG_DEBUG_ERR, "%s: wrong answer" + "len=%d\n", owner, lvl_len); return -RIG_ERJCTED; } @@ -222,6 +251,13 @@ int drake_report_signal(RIG *rig, char* owner) /* * drake_decode_frequency * Common routine to decode the frequency block + * + * inputs: rig - pointer to RIG structure + * freqbuf - buffer containung radio's response string + * offset - offset to beginning of string due to differnces in R8 vs. R8A/B + * Note: strings are virtually identical. offset is provided as a failsafe. + * + * Assumes rig!=NULL */ void drake_decode_frequency(RIG *rig, char* freqbuf, int offset) { @@ -238,7 +274,7 @@ void drake_decode_frequency(RIG *rig, char* freqbuf, int offset) freqbuf[9+offset] = '\0'; - /* extract freq */ + // extract freq sscanf(freqbuf+offset, "%lf", &f); f *= 1000.0; @@ -253,6 +289,11 @@ void drake_decode_frequency(RIG *rig, char* freqbuf, int offset) * drake_report_freq * Common routine to retrieve frequency and squelch settings (used for DCD) * Data stored in priv for any routine to use + * + * inputs: rig - pointer to RIG structure + * owner - the calling routine identifier + * returns: command error status + * * Assumes rig!=NULL */ int drake_report_frequency(RIG *rig, char* owner) @@ -263,19 +304,8 @@ int drake_report_frequency(RIG *rig, char* owner) retval = drake_transaction(rig, "RF" EOM, 3, freqbuf, &freq_len); - //let's trick it - /* - char testbuf[15] = {' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; - if (freq_len == 0) - { - for (int i=0; i < 15; i++) { - freqbuf[i] = testbuf[i]; - } - freq_len = 15; - freqbuf[freq_len] = 0x00; - retval = RIG_OK; - }*/ - + //char testbuf[15] = {' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; + drake_trans_rept(owner, "RF" EOM, 3, freqbuf, freq_len, retval); if (retval != RIG_OK) @@ -299,6 +329,12 @@ int drake_report_frequency(RIG *rig, char* owner) /* * drake_decode_mode * Common routine to break out the 5-character mode string + * + * inputs: rig - pointer to RIG structure + * mdbuf - buffer containung radio's response string + * offset - offset to beginning of string due to differnces in R8 vs. R8A/B + * + * Assumes rig!=NULL */ void drake_decode_mode(RIG *rig, char* mdbuf, int offset) { @@ -413,7 +449,12 @@ void drake_decode_mode(RIG *rig, char* mdbuf, int offset) * drake_report_mode * Common routine to retrieve NB, AGC, ATT, PRE, NF, ANT, MODE, BW, and VFO (and scanning) settings * Data stored in priv for any routine to use - * Assumes rig!=NULL + * + * inputs: rig - pointer to RIG structure + * owner - the calling routine identifier + * returns: command error status + * + * Assumes rig!=NULL */ int drake_report_mode(RIG *rig, char* owner) { @@ -426,21 +467,10 @@ int drake_report_mode(RIG *rig, char* owner) retval = drake_transaction(rig, "RM" EOM, 3, mdbuf, &mdbuf_len); - //let's trick it - /* //r8 - char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning - //r8a/b - char testbuf[7] = {' ','2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning - if (mdbuf_len == 0) - { - for (int i=0; i < 7; i++) { - mdbuf[i] = testbuf[i]; - } - mdbuf_len = 7; - mdbuf[mdbuf_len] = 0x00; - retval = 0; - }*/ + //char testbuf[7] = {'2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + //r8a/b - TODO Seems to be undocumented extra character at beginning of string, pushing everything to the right + //char testbuf[8] = {'?','2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning drake_trans_rept(owner, "RM" EOM, 3, mdbuf, mdbuf_len, retval); @@ -478,6 +508,13 @@ int drake_report_mode(RIG *rig, char* owner) /* * drake_decode_mem_channel * Common routine to break out the 3 or 4-character mem string + * + * inputs: rig - pointer to RIG structure + * mdbuf - buffer containung radio's response string + * offset - offset to beginning of string due to differnces in R8 vs. R8A/B + * Note: except for channel number size, strings are virtually identical. offset is provided as a failsafe. + * + * Assumes rig!=NULL */ void drake_decode_mem_channel(RIG *rig, char* mdbuf, int offset) { @@ -502,6 +539,11 @@ void drake_decode_mem_channel(RIG *rig, char* mdbuf, int offset) * drake_report_mem_channel * Common routine to retrieve the memory channel number * Data stored in priv for any routine to use + * + * inputs: rig - pointer to RIG structure + * owner - the calling routine identifier + * returns: command error status + * * Assumes rig!=NULL */ int drake_report_mem_channel(RIG *rig, char* owner) @@ -514,18 +556,10 @@ int drake_report_mem_channel(RIG *rig, char* owner) retval = drake_transaction(rig, "RC" EOM, 3, mdbuf, &mdbuf_len); - //let's trick it - /* - char testbuf[5] = {' ','0','0', 0x0d, 0x0a }; - if (mdbuf_len == 0) - { - for (int i=0; i < 5; i++) { - mdbuf[i] = testbuf[i]; - } - mdbuf_len = 5; - mdbuf[mdbuf_len] = 0x00; - retval = 0; - }*/ + // r8 00 - 99 + //char testbuf[5] = {' ','0','0', 0x0d, 0x0a }; + // r8a/b 000 - 439 + //char testbuf[6] = {' ','0','0','0', 0x0d, 0x0a }; drake_trans_rept(owner, "RC" EOM, 3, mdbuf, mdbuf_len, retval); @@ -562,6 +596,11 @@ int drake_report_mem_channel(RIG *rig, char* owner) * drake_report_all * Common routine to retrieve all of the radio's settings * Data stored in priv for any routine to use + * + * inputs: rig - pointer to RIG structure + * owner - the calling routine identifier + * returns: command error status + * * Assumes rig!=NULL */ int drake_report_all(RIG *rig, char* owner) @@ -576,22 +615,11 @@ int drake_report_all(RIG *rig, char* owner) retval = drake_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); - //let's trick it - /* - // mem off, ch 00, NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning + // strings show mem off, ch 00, NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning // r8 - char testbuf[25] = {' ','0','0',' ','2','0','2','<','8',' ',' ','1','5','.','0','0','0','0','0','#','m','H','z', 0x0d, 0x0a }; - // r8a/b 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 - char testbuf[35] = {' ','0','0','0',' ','2','0','2','<','8',' ',' ','1','5','.','0','0','0','0','0','#','m','H','z',' ','M','E','M','N','A','M','E',' ', 0x0d, 0x0a }; - if (mdbuf_len == 0) - { - for (int i=0; i < 25; i++) { - mdbuf[i] = testbuf[i]; - } - mdbuf_len = 25; - mdbuf[mdbuf_len] = 0x00; - retval = RIG_OK; - }*/ + //char testbuf[25] = {' ','0','0',' ','2','0','2','<','8',' ',' ','1','5','.','0','0','0','0','0','#','m','H','z', 0x0d, 0x0a }; + // r8a/b - TODO Note 7-char channel name that eitehr starts at [25] or [26] + //char testbuf[35] = {' ','0','0','0',' ','2','0','2','<','8',' ',' ','1','5','.','0','0','0','0','0','#','m','H','z',' ','M','E','M','N','A','M','E',' ', 0x0d, 0x0a }; drake_trans_rept(owner, "RA" EOM, 3, mdbuf, mdbuf_len, retval); @@ -622,15 +650,19 @@ int drake_report_all(RIG *rig, char* owner) return -RIG_ERJCTED; } - //check RC *after* decoding the VFO in RM - //otherwise RIG_VFO_MEM gets squashed + // check RC *after* decoding the VFO in RM + // otherwise RIG_VFO_MEM gets squashed drake_decode_mode(rig, mdbuf, mode_offset); drake_decode_mem_channel(rig, mdbuf, chan_offset); drake_decode_frequency(rig, mdbuf, freq_offset); + + // TODO handle channel name on R8A/B + // TODO These models also have an additonal RN (Report Name) command for polling channel names that is not handled here return RIG_OK; } +/* COMMON HAMLIB INTERFACE ROUTINES */ int drake_init(RIG *rig) { @@ -684,27 +716,12 @@ int drake_set_freq(RIG *rig, vfo_t vfo, freq_t freq) int ack_len; int retval; - /* - * 10Hz resolution - * TODO: round nearest? - */ + // 10Hz resolution - TODO: round nearest? SNPRINTF((char *) freqbuf, sizeof(freqbuf), "F%07u" EOM, (unsigned int)freq / 10); retval = drake_transaction(rig, freqbuf, strlen(freqbuf), ackbuf, &ack_len); - //let's trick it - /* - char testbuf[2] = {0x0d, 0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ackbuf[1] = testbuf[1]; - ack_len = 2; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept("drake_set_freq", freqbuf, strlen(freqbuf), ackbuf, ack_len, retval); + //drake_trans_rept("drake_set_freq", freqbuf, strlen(freqbuf), ackbuf, ack_len, retval); return retval; } @@ -770,17 +787,6 @@ int drake_set_vfo(RIG *rig, vfo_t vfo) retval = drake_transaction(rig, cmdbuf, strlen(cmdbuf), ackbuf, &ack_len); - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = RIG_OK; - }*/ - drake_trans_rept("drake_set_vfo", cmdbuf, strlen(cmdbuf), ackbuf, ack_len, retval); return retval; @@ -846,17 +852,6 @@ int drake_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - drake_trans_rept("drake_set_mode", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); if (retval != RIG_OK) @@ -899,17 +894,6 @@ int drake_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) SNPRINTF((char *) mdbuf, sizeof(mdbuf), "W%c" EOM, width_sel); retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - drake_trans_rept("drake_set_bw", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); } @@ -923,17 +907,6 @@ int drake_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) (mode == RIG_MODE_ECSSLSB)) ? 'O' : 'F'); retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - drake_trans_rept("drake_set_synch", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); } @@ -978,17 +951,6 @@ int drake_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - drake_trans_rept("drake_set_ant", buf, strlen(buf), ackbuf, ack_len, retval); return retval; @@ -1042,18 +1004,6 @@ int drake_set_mem(RIG *rig, vfo_t vfo, int ch) ack_len = 0; // fix compile-time warning "possibly uninitialized" retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - //let's trick it - /* - char testbuf[2] = {0x0d, 0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ackbuf[1] = testbuf[1]; - ack_len = 2; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - drake_trans_rept("drake_set_mem", buf, strlen(buf), ackbuf, ack_len, retval); if (ack_len != 2) @@ -1092,19 +1042,21 @@ int drake_get_mem(RIG *rig, vfo_t vfo, int *ch) */ int drake_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) { - const struct drake_priv_data *priv = STATE(rig)->priv; + char mdbuf[16]; + char ackbuf[BUFSZ]; + int ack_len; vfo_t old_vfo; int old_chan; - char mdbuf[16], ackbuf[BUFSZ]; - int ack_len, retval; + int retval; value_t dummy; + const struct drake_priv_data *priv = STATE(rig)->priv; dummy.i = 0; drake_get_vfo(rig, &old_vfo); old_chan = 0; - /* set to vfo if needed */ + // set to vfo if needed if (old_vfo == RIG_VFO_MEM) { old_chan = priv->curr_ch; @@ -1116,7 +1068,7 @@ int drake_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) } } - /* set all memory features */ + // set all memory features drake_set_ant(rig, RIG_VFO_CURR, chan->ant, dummy); drake_set_freq(rig, RIG_VFO_CURR, chan->freq); drake_set_mode(rig, RIG_VFO_CURR, chan->mode, chan->width); @@ -1131,9 +1083,30 @@ int drake_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) drake_set_func(rig, RIG_VFO_CURR, RIG_FUNC_MN, (chan->funcs & RIG_FUNC_MN) == RIG_FUNC_MN); - SNPRINTF(mdbuf, sizeof(mdbuf), "PR" EOM "%03d" EOM, chan->channel_num); + if (rig->caps->rig_model == RIG_MODEL_DKR8) + { + SNPRINTF(mdbuf, sizeof(mdbuf), "PR" EOM "%02d" EOM, chan->channel_num); + } + else + { + SNPRINTF(mdbuf, sizeof(mdbuf), "PR" EOM "%03d" EOM, chan->channel_num); + } retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); + //let's trick it + /* + char testbuf[2] = {0x0d, 0x0a}; + if (ack_len == 0) + { + ackbuf[0] = testbuf[0]; + ackbuf[1] = testbuf[1]; + ack_len = 2; + ackbuf[ack_len] = 0x00; + retval = 0; + }*/ + + drake_trans_rept("drake_set_chan", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + if (old_vfo == RIG_VFO_MEM) { drake_set_mem(rig, RIG_VFO_CURR, old_chan); @@ -1149,11 +1122,10 @@ int drake_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) */ int drake_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) { - const struct drake_priv_data *priv = STATE(rig)->priv; vfo_t old_vfo; int old_chan; - char mdbuf[BUFSZ], freqstr[BUFSZ]; - int mdbuf_len, retval; + int retval; + const struct drake_priv_data *priv = STATE(rig)->priv; chan->vfo = RIG_VFO_MEM; chan->ant = RIG_ANT_NONE; @@ -1190,7 +1162,7 @@ int drake_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) old_chan = priv->curr_ch; } - //go to new channel + // go to new channel retval = drake_set_mem(rig, RIG_VFO_CURR, chan->channel_num); if (retval != RIG_OK) @@ -1198,141 +1170,39 @@ int drake_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) return RIG_OK; } - //now decipher it - retval = drake_transaction(rig, "RA" EOM, 3, mdbuf, &mdbuf_len); + // now decipher it into priv + retval = drake_report_all(rig, "drake_get_chan"); if (retval != RIG_OK) { - return retval; + return RIG_OK; } - if (mdbuf_len < 35) - { - rig_debug(RIG_DEBUG_ERR, "drake_get_channel: wrong answer %s, " - "len=%d\n", mdbuf, mdbuf_len); - return -RIG_ERJCTED; - } - - if ((mdbuf[5] >= '4') && (mdbuf[5] <= '?')) + if (priv->curr_nb) { chan->funcs |= RIG_FUNC_NB; } - - switch (mdbuf[5] & 0x33) + if (priv->curr_nb2) { - case '0': chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_OFF; break; - - case '2': chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_FAST; break; - - case '3': chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_SLOW; break; - - default : chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_FAST; + chan->funcs |= RIG_FUNC_NB2; } - if ((mdbuf[6] & 0x3c) == '8') - { - chan->levels[rig_setting2idx(RIG_LEVEL_PREAMP)].i = 10; - } + chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = priv->curr_agc; + chan->levels[rig_setting2idx(RIG_LEVEL_PREAMP)].i = (priv->curr_pre ? 10 : 0); + chan->levels[rig_setting2idx(RIG_LEVEL_ATT)].i = (priv->curr_att ? 10 : 0); - if ((mdbuf[6] & 0x3c) == '4') - { - chan->levels[rig_setting2idx(RIG_LEVEL_ATT)].i = 10; - } - - if ((mdbuf[6] & 0x32) == '2') + if (priv->curr_notch) { chan->funcs |= RIG_FUNC_MN; } + + chan->ant = priv->curr_ant; + chan->width = priv->curr_width; + chan->mode = priv->curr_mode; + chan->freq = priv->curr_freq; - switch (mdbuf[7] & 0x3c) - { - case '0': chan->ant = RIG_ANT_1; break; - - case '4': chan->ant = RIG_ANT_3; break; - - case '8': chan->ant = RIG_ANT_2; break; - - default : chan->ant = RIG_ANT_NONE; - } - - switch (mdbuf[8] & 0x37) - { - case '0': chan->width = s_Hz(500); break; - - case '1': chan->width = s_Hz(1800); break; - - case '2': chan->width = s_Hz(2300); break; - - case '3': chan->width = s_Hz(4000); break; - - case '4': chan->width = s_Hz(6000); break; - - default : chan->width = RIG_PASSBAND_NORMAL; - } - - if ((mdbuf[8] >= '0') && (mdbuf[8] <= '4')) - { - switch (mdbuf[7] & 0x33) - { - case '0': chan->mode = RIG_MODE_LSB; break; - - case '1': chan->mode = RIG_MODE_RTTY; break; - - case '2': chan->mode = RIG_MODE_FM; - chan->width = s_Hz(12000); break; - - default : chan->mode = RIG_MODE_NONE; - } - } - else - { - switch (mdbuf[7] & 0x33) - { - case '0': chan->mode = RIG_MODE_USB; break; - - case '1': chan->mode = RIG_MODE_CW; break; - - case '2': chan->mode = RIG_MODE_AM; break; - - default : chan->mode = RIG_MODE_NONE; - } - } - - if ((mdbuf[9] & 0x34) == '4') - { - if (chan->mode == RIG_MODE_AM) - { - chan->mode = RIG_MODE_AMS; - } - else if (chan->mode == RIG_MODE_USB) - { - chan->mode = RIG_MODE_ECSSUSB; - } - else if (chan->mode == RIG_MODE_LSB) - { - chan->mode = RIG_MODE_ECSSLSB; - } - } - - strncpy(freqstr, mdbuf + 11, 9); - freqstr[9] = 0x00; - - if ((mdbuf[21] == 'k') || (mdbuf[21] == 'K')) - { - chan->freq = strtod(freqstr, NULL) * 1000.0; - } - - if ((mdbuf[21] == 'm') || (mdbuf[21] == 'M')) - { - chan->freq = strtod(freqstr, NULL) * 1000000.0; - } - - - strncpy(chan->channel_desc, mdbuf + 25, 7); - chan->channel_desc[7] = '\0'; // in case strncpy did not terminate the string - - //now put the radio back the way it was - //we apparently can't do a read-only channel read + // now put the radio back the way it was + // we apparently can't do a read-only channel read if (old_vfo != RIG_VFO_MEM) { retval = drake_set_vfo(rig, RIG_VFO_VFO); @@ -1384,7 +1254,6 @@ int drake_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) break; case RIG_OP_TO_VFO: - /* len = SNPRINTF(buf,"C%03d" EOM, priv->curr_ch); */ SNPRINTF(buf, sizeof(buf), "F" EOM); break; @@ -1411,21 +1280,6 @@ int drake_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) retval = drake_transaction(rig, buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, buf[len - 1] == 0x0d ? &ack_len : NULL); - //let's trick it - /* - if ((op == RIG_OP_TO_VFO) || (op == RIG_OP_FROM_VFO)) - { - char testbuf[2] = {0x0d, 0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ackbuf[1] = testbuf[1]; - ack_len = 2; - ackbuf[ack_len] = 0x00; - retval = 0; - } - }*/ - drake_trans_rept("drake_vfo_op", buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, buf[len - 1] == 0x0d ? ack_len : 0, retval); @@ -1481,17 +1335,6 @@ int drake_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - drake_trans_rept("drake_set_func", buf, strlen(buf), ackbuf, ack_len, retval); return retval; @@ -1561,17 +1404,6 @@ int drake_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - drake_trans_rept("set_level", buf, strlen(buf), ackbuf, ack_len, retval); return retval; @@ -1655,17 +1487,6 @@ int drake_set_powerstat(RIG *rig, powerstat_t status) retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - //let's trick it - /* - char testbuf[1] = {0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ack_len = 1; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - drake_trans_rept("set_power", buf, strlen(buf), ackbuf, ack_len, retval); return retval; @@ -1700,18 +1521,6 @@ const char *drake_get_info(RIG *rig) retval = drake_transaction(rig, "ID" EOM, 3, idbuf, &id_len); - //let's trick it - /* - char testbuf[4] = {'R','8',0x0d,0x0a}; - if (id_len == 0) - { - for (int i = 0; i < 4; i++) - idbuf[i] = testbuf[i]; - id_len = 4; - idbuf[id_len] = 0x00; - retval = 0; - }*/ - drake_trans_rept("get_id", "ID" EOM, 3, idbuf, id_len, retval); if (retval != RIG_OK) @@ -1779,7 +1588,7 @@ DECLARE_PROBERIG_BACKEND(drake) return RIG_MODEL_NONE; } - idbuf[id_len - 2] = '\0'; + idbuf[id_len - 2] = '\0'; //strip off if (!strcmp(idbuf, "R8B")) { @@ -1791,7 +1600,7 @@ DECLARE_PROBERIG_BACKEND(drake) return RIG_MODEL_DKR8B; } - if (!strcmp(idbuf, "R8A")) /* TBC */ + if (!strcmp(idbuf, "R8A")) // TBC { if (cfunc) { @@ -1811,10 +1620,8 @@ DECLARE_PROBERIG_BACKEND(drake) return RIG_MODEL_DKR8; } - /* - * not found... - */ - if (memcmp(idbuf, "ID" EOM, 3)) /* catch loopback serial */ + // not found... + if (memcmp(idbuf, "ID" EOM, 3)) // catch loopback serial rig_debug(RIG_DEBUG_VERBOSE, "probe_drake: found unknown device " "with ID '%s', please report to Hamlib " "developers.\n", idbuf); diff --git a/rigs/drake/drake.h b/rigs/drake/drake.h index e1f5f6cd7..2645c182b 100644 --- a/rigs/drake/drake.h +++ b/rigs/drake/drake.h @@ -66,13 +66,6 @@ int drake_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val); int drake_set_powerstat (RIG * rig, powerstat_t status); int drake_get_powerstat (RIG * rig, powerstat_t *status); const char *drake_get_info(RIG *rig); -//temporary until everything from r8.c is moved back over to drake.c -void drake_trans_rept(char* hdrStr, char* sentStr, int sentLen, char* recdStr, int recdLen, int res); -int drake_transaction(RIG *rig, const char *cmd, int cmd_len, char *data, int *data_len); -int drake_report_frequency(RIG *rig, char* owner); -int drake_report_mode(RIG *rig, char* owner); -int drake_report_mem_channel(RIG *rig, char* owner); -int drake_report_all(RIG *rig, char* owner); extern struct rig_caps r8_caps; extern struct rig_caps r8a_caps; diff --git a/rigs/drake/r8.c b/rigs/drake/r8.c index 9e831b0f8..09858b965 100644 --- a/rigs/drake/r8.c +++ b/rigs/drake/r8.c @@ -19,30 +19,12 @@ * */ -//#include #include -//#include -//#include /* String function definitions */ -//#include /* UNIX standard function definitions */ #include #include "idx_builtin.h" -//#include "serial.h" -//#include "misc.h" -//#include "cal.h" -//#include "register.h" - #include "drake.h" -int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan); -int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only); - -#define BUFSZ 64 - -#define CR "\x0d" -#define LF "\x0a" -#define EOM CR - #define R8_MODES (RIG_MODE_SSB|RIG_MODE_CW|RIG_MODE_RTTY|RIG_MODE_AM|RIG_MODE_AMS|RIG_MODE_FM) #define R8_FUNC (RIG_FUNC_MN|RIG_FUNC_NB|RIG_FUNC_NB2) @@ -100,7 +82,7 @@ struct rig_caps r8_caps = .serial_parity = RIG_PARITY_EVEN, .serial_handshake = RIG_HANDSHAKE_HARDWARE, .write_delay = 1, - .post_write_delay = 100, //1, + .post_write_delay = 100, .timeout = 250, .retry = 3, @@ -193,8 +175,8 @@ struct rig_caps r8_caps = .get_ant = drake_get_ant, .set_mem = drake_set_mem, .get_mem = drake_get_mem, - .set_channel = drake_r8_set_chan, - .get_channel = drake_r8_get_chan, + .set_channel = drake_set_chan, + .get_channel = drake_get_chan, .vfo_op = drake_vfo_op, .set_powerstat = drake_set_powerstat, .get_powerstat = drake_get_powerstat, @@ -206,186 +188,3 @@ struct rig_caps r8_caps = * Function definitions below */ -/* - * drake_set_chan - * Assumes rig!=NULL - */ -int drake_r8_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) -{ - const struct drake_priv_data *priv = STATE(rig)->priv; - vfo_t old_vfo; - int old_chan; - char mdbuf[16]; - char ackbuf[BUFSZ]; - int ack_len; - int retval; - value_t dummy; - - dummy.i = 0; - - drake_get_vfo(rig, &old_vfo); - old_chan = 0; - - /* set to vfo if needed */ - if (old_vfo == RIG_VFO_MEM) - { - old_chan = priv->curr_ch; - retval = drake_set_vfo(rig, RIG_VFO_VFO); - - if (retval != RIG_OK) - { - return retval; - } - } - - /* set all memory features */ - drake_set_ant(rig, RIG_VFO_CURR, chan->ant, dummy); - drake_set_freq(rig, RIG_VFO_CURR, chan->freq); - drake_set_mode(rig, RIG_VFO_CURR, chan->mode, chan->width); - drake_set_func(rig, RIG_VFO_CURR, RIG_FUNC_NB, - (chan->funcs & RIG_FUNC_NB) == RIG_FUNC_NB); - drake_set_func(rig, RIG_VFO_CURR, RIG_FUNC_NB2, - (chan->funcs & RIG_FUNC_NB2) == RIG_FUNC_NB2); - drake_set_level(rig, RIG_VFO_CURR, RIG_LEVEL_AGC, - chan->levels[rig_setting2idx(RIG_LEVEL_AGC)]); - drake_set_level(rig, RIG_VFO_CURR, RIG_LEVEL_PREAMP, - chan->levels[rig_setting2idx(RIG_LEVEL_PREAMP)]); - drake_set_level(rig, RIG_VFO_CURR, RIG_LEVEL_ATT, - chan->levels[rig_setting2idx(RIG_LEVEL_ATT)]); - drake_set_func(rig, RIG_VFO_CURR, RIG_FUNC_MN, - (chan->funcs & RIG_FUNC_MN) == RIG_FUNC_MN); - - SNPRINTF(mdbuf, sizeof(mdbuf), "PR" EOM "%02d" EOM, chan->channel_num); - retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); - - //let's trick it - /* - char testbuf[2] = {0x0d, 0x0a}; - if (ack_len == 0) - { - ackbuf[0] = testbuf[0]; - ackbuf[1] = testbuf[1]; - ack_len = 2; - ackbuf[ack_len] = 0x00; - retval = 0; - }*/ - - drake_trans_rept("drake_set_chan", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); - - if (old_vfo == RIG_VFO_MEM) - { - drake_set_mem(rig, RIG_VFO_CURR, old_chan); - } - - return retval; -} - - -/* - * drake_get_chan - * Assumes rig!=NULL - */ -int drake_r8_get_chan(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) -{ - vfo_t old_vfo; - int old_chan; - int retval; - const struct drake_priv_data *priv = STATE(rig)->priv; - - chan->vfo = RIG_VFO_MEM; - chan->ant = RIG_ANT_NONE; - chan->freq = 0; - chan->mode = RIG_MODE_NONE; - chan->width = RIG_PASSBAND_NORMAL; - chan->tx_freq = 0; - chan->tx_mode = RIG_MODE_NONE; - chan->tx_width = RIG_PASSBAND_NORMAL; - chan->split = RIG_SPLIT_OFF; - chan->tx_vfo = RIG_VFO_NONE; - chan->rptr_shift = RIG_RPT_SHIFT_NONE; - chan->rptr_offs = 0; - chan->tuning_step = 0; - chan->rit = 0; - chan->xit = 0; - chan->funcs = 0; - chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = RIG_AGC_OFF; - chan->levels[rig_setting2idx(RIG_LEVEL_ATT)].i = 0; - chan->levels[rig_setting2idx(RIG_LEVEL_PREAMP)].i = 0; - chan->ctcss_tone = 0; - chan->ctcss_sql = 0; - chan->dcs_code = 0; - chan->dcs_sql = 0; - chan->scan_group = 0; - chan->flags = RIG_CHFLAG_SKIP; - strcpy(chan->channel_desc, " "); - - drake_get_vfo(rig, &old_vfo); - old_chan = 0; - - if (old_vfo == RIG_VFO_MEM) - { - old_chan = priv->curr_ch; - } - - //go to new channel - retval = drake_set_mem(rig, RIG_VFO_CURR, chan->channel_num); - - if (retval != RIG_OK) - { - return RIG_OK; - } - - retval = drake_report_all(rig, "drake_get_chan"); - - if (retval != RIG_OK) - { - return RIG_OK; - } - - if (priv->curr_nb) - { - chan->funcs |= RIG_FUNC_NB; - } - if (priv->curr_nb2) - { - chan->funcs |= RIG_FUNC_NB2; - } - - chan->levels[rig_setting2idx(RIG_LEVEL_AGC)].i = priv->curr_agc; - chan->levels[rig_setting2idx(RIG_LEVEL_PREAMP)].i = (priv->curr_pre ? 10 : 0); - chan->levels[rig_setting2idx(RIG_LEVEL_ATT)].i = (priv->curr_att ? 10 : 0); - - if (priv->curr_notch) - { - chan->funcs |= RIG_FUNC_MN; - } - - chan->ant = priv->curr_ant; - chan->width = priv->curr_width; - chan->mode = priv->curr_mode; - chan->freq = priv->curr_freq; - - //now put the radio back the way it was - //we apparently can't do a read-only channel read - if (old_vfo != RIG_VFO_MEM) - { - retval = drake_set_vfo(rig, RIG_VFO_VFO); - - if (retval != RIG_OK) - { - return retval; - } - } - else - { - retval = drake_set_mem(rig, RIG_VFO_CURR, old_chan); - - if (retval != RIG_OK) - { - return retval; - } - } - - return RIG_OK; -} - From 22636be85e7a33e42077860112b858ecdac79449 Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Sat, 5 Jul 2025 17:11:33 -0400 Subject: [PATCH 15/16] Commented out the embedded debugging (WARN level) that echoes all transaction data. --- rigs/drake/drake.c | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/rigs/drake/drake.c b/rigs/drake/drake.c index a247a9734..251cfccd1 100644 --- a/rigs/drake/drake.c +++ b/rigs/drake/drake.c @@ -227,7 +227,7 @@ int drake_report_signal(RIG *rig, char* owner) //char testbuf[5] = {'2', '5', '5', 0x0d, 0x0a }; - drake_trans_rept(owner, "RSS" EOM, 4, lvlbuf, lvl_len, retval); + //drake_trans_rept(owner, "RSS" EOM, 4, lvlbuf, lvl_len, retval); if (retval != RIG_OK) { @@ -306,7 +306,7 @@ int drake_report_frequency(RIG *rig, char* owner) //char testbuf[15] = {' ', '1', '5', '.', '0', '0', '0', '0', '0', '#', 'm', 'H', 'z', 0x0d, 0x0a }; - drake_trans_rept(owner, "RF" EOM, 3, freqbuf, freq_len, retval); + //drake_trans_rept(owner, "RF" EOM, 3, freqbuf, freq_len, retval); if (retval != RIG_OK) { @@ -472,7 +472,7 @@ int drake_report_mode(RIG *rig, char* owner) //r8a/b - TODO Seems to be undocumented extra character at beginning of string, pushing everything to the right //char testbuf[8] = {'?','2','0','2','<','8', 0x0d, 0x0a}; //NB off, AGC fast, RF off, MN off, ant 1, AM mode, 6.0 bw, VFOA, sync off, not scanning - drake_trans_rept(owner, "RM" EOM, 3, mdbuf, mdbuf_len, retval); + //drake_trans_rept(owner, "RM" EOM, 3, mdbuf, mdbuf_len, retval); if (rig->caps->rig_model == RIG_MODEL_DKR8) { @@ -561,7 +561,7 @@ int drake_report_mem_channel(RIG *rig, char* owner) // r8a/b 000 - 439 //char testbuf[6] = {' ','0','0','0', 0x0d, 0x0a }; - drake_trans_rept(owner, "RC" EOM, 3, mdbuf, mdbuf_len, retval); + //drake_trans_rept(owner, "RC" EOM, 3, mdbuf, mdbuf_len, retval); if (rig->caps->rig_model == RIG_MODEL_DKR8) { @@ -621,7 +621,7 @@ int drake_report_all(RIG *rig, char* owner) // r8a/b - TODO Note 7-char channel name that eitehr starts at [25] or [26] //char testbuf[35] = {' ','0','0','0',' ','2','0','2','<','8',' ',' ','1','5','.','0','0','0','0','0','#','m','H','z',' ','M','E','M','N','A','M','E',' ', 0x0d, 0x0a }; - drake_trans_rept(owner, "RA" EOM, 3, mdbuf, mdbuf_len, retval); + //drake_trans_rept(owner, "RA" EOM, 3, mdbuf, mdbuf_len, retval); if (rig->caps->rig_model == RIG_MODEL_DKR8) { @@ -787,7 +787,7 @@ int drake_set_vfo(RIG *rig, vfo_t vfo) retval = drake_transaction(rig, cmdbuf, strlen(cmdbuf), ackbuf, &ack_len); - drake_trans_rept("drake_set_vfo", cmdbuf, strlen(cmdbuf), ackbuf, ack_len, retval); + //drake_trans_rept("drake_set_vfo", cmdbuf, strlen(cmdbuf), ackbuf, ack_len, retval); return retval; } @@ -852,7 +852,7 @@ int drake_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); - drake_trans_rept("drake_set_mode", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + //drake_trans_rept("drake_set_mode", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); if (retval != RIG_OK) { @@ -894,7 +894,7 @@ int drake_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) SNPRINTF((char *) mdbuf, sizeof(mdbuf), "W%c" EOM, width_sel); retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); - drake_trans_rept("drake_set_bw", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + //drake_trans_rept("drake_set_bw", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); } } @@ -907,7 +907,7 @@ int drake_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) (mode == RIG_MODE_ECSSLSB)) ? 'O' : 'F'); retval = drake_transaction(rig, mdbuf, strlen(mdbuf), ackbuf, &ack_len); - drake_trans_rept("drake_set_synch", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + //drake_trans_rept("drake_set_synch", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); } return retval; @@ -951,7 +951,7 @@ int drake_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - drake_trans_rept("drake_set_ant", buf, strlen(buf), ackbuf, ack_len, retval); + //drake_trans_rept("drake_set_ant", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } @@ -1004,7 +1004,7 @@ int drake_set_mem(RIG *rig, vfo_t vfo, int ch) ack_len = 0; // fix compile-time warning "possibly uninitialized" retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - drake_trans_rept("drake_set_mem", buf, strlen(buf), ackbuf, ack_len, retval); + //drake_trans_rept("drake_set_mem", buf, strlen(buf), ackbuf, ack_len, retval); if (ack_len != 2) { @@ -1105,7 +1105,7 @@ int drake_set_chan(RIG *rig, vfo_t vfo, const channel_t *chan) retval = 0; }*/ - drake_trans_rept("drake_set_chan", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); + //drake_trans_rept("drake_set_chan", mdbuf, strlen(mdbuf), ackbuf, ack_len, retval); if (old_vfo == RIG_VFO_MEM) { @@ -1280,8 +1280,8 @@ int drake_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op) retval = drake_transaction(rig, buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, buf[len - 1] == 0x0d ? &ack_len : NULL); - drake_trans_rept("drake_vfo_op", buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, - buf[len - 1] == 0x0d ? ack_len : 0, retval); + //drake_trans_rept("drake_vfo_op", buf, len, buf[len - 1] == 0x0d ? ackbuf : NULL, + // buf[len - 1] == 0x0d ? ack_len : 0, retval); return retval; } @@ -1335,7 +1335,7 @@ int drake_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - drake_trans_rept("drake_set_func", buf, strlen(buf), ackbuf, ack_len, retval); + //drake_trans_rept("drake_set_func", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } @@ -1404,7 +1404,7 @@ int drake_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - drake_trans_rept("set_level", buf, strlen(buf), ackbuf, ack_len, retval); + //drake_trans_rept("set_level", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } @@ -1487,7 +1487,7 @@ int drake_set_powerstat(RIG *rig, powerstat_t status) retval = drake_transaction(rig, buf, strlen(buf), ackbuf, &ack_len); - drake_trans_rept("set_power", buf, strlen(buf), ackbuf, ack_len, retval); + //drake_trans_rept("set_power", buf, strlen(buf), ackbuf, ack_len, retval); return retval; } @@ -1521,7 +1521,7 @@ const char *drake_get_info(RIG *rig) retval = drake_transaction(rig, "ID" EOM, 3, idbuf, &id_len); - drake_trans_rept("get_id", "ID" EOM, 3, idbuf, id_len, retval); + //drake_trans_rept("get_id", "ID" EOM, 3, idbuf, id_len, retval); if (retval != RIG_OK) { From 256037296f3d6785a74e8f6877d78afa9b6da7f9 Mon Sep 17 00:00:00 2001 From: "Mark J. Fine" Date: Mon, 7 Jul 2025 16:49:25 -0400 Subject: [PATCH 16/16] Fixed typos and copyright attribution on drake.c and r8.c --- rigs/drake/drake.c | 10 +++++----- rigs/drake/r8.c | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/rigs/drake/drake.c b/rigs/drake/drake.c index 251cfccd1..3d00eb8cf 100644 --- a/rigs/drake/drake.c +++ b/rigs/drake/drake.c @@ -1,6 +1,6 @@ /* * Hamlib Drake backend - main file - * Copyright (c) 2001-2008 by Stephane Fillod + * Copyright (c) 2001-2008 by Stephane Fillod, 2025 Mark J. Fine * * * This library is free software; you can redistribute it and/or @@ -254,7 +254,7 @@ int drake_report_signal(RIG *rig, char* owner) * * inputs: rig - pointer to RIG structure * freqbuf - buffer containung radio's response string - * offset - offset to beginning of string due to differnces in R8 vs. R8A/B + * offset - offset to beginning of string due to differences in R8 vs. R8A/B * Note: strings are virtually identical. offset is provided as a failsafe. * * Assumes rig!=NULL @@ -332,7 +332,7 @@ int drake_report_frequency(RIG *rig, char* owner) * * inputs: rig - pointer to RIG structure * mdbuf - buffer containung radio's response string - * offset - offset to beginning of string due to differnces in R8 vs. R8A/B + * offset - offset to beginning of string due to differences in R8 vs. R8A/B * * Assumes rig!=NULL */ @@ -511,7 +511,7 @@ int drake_report_mode(RIG *rig, char* owner) * * inputs: rig - pointer to RIG structure * mdbuf - buffer containung radio's response string - * offset - offset to beginning of string due to differnces in R8 vs. R8A/B + * offset - offset to beginning of string due to differences in R8 vs. R8A/B * Note: except for channel number size, strings are virtually identical. offset is provided as a failsafe. * * Assumes rig!=NULL @@ -657,7 +657,7 @@ int drake_report_all(RIG *rig, char* owner) drake_decode_frequency(rig, mdbuf, freq_offset); // TODO handle channel name on R8A/B - // TODO These models also have an additonal RN (Report Name) command for polling channel names that is not handled here + // TODO These models also have an additional RN (Report Name) command for polling channel names that is not handled here return RIG_OK; } diff --git a/rigs/drake/r8.c b/rigs/drake/r8.c index 09858b965..80cd81acd 100644 --- a/rigs/drake/r8.c +++ b/rigs/drake/r8.c @@ -1,6 +1,6 @@ /* * Hamlib Drake backend - R-8 description - * Copyright (c) 2001-2010, 2025 by Stephane Fillod + * Copyright (c) 2025 by Mark J. Fine * * * This library is free software; you can redistribute it and/or