diff --git a/rigs/kenwood/Makefile.am b/rigs/kenwood/Makefile.am index 8758a8164..5c97ff0f4 100644 --- a/rigs/kenwood/Makefile.am +++ b/rigs/kenwood/Makefile.am @@ -1,7 +1,7 @@ TSSRC = ts850.c ts870s.c ts570.c ts450s.c ts950.c ts50s.c \ ts790.c ts2000.c k2.c k3.c xg3.c ts930.c \ - ts680.c ts690.c ts140.c ts480.c trc80.c ts590.c \ + ts680.c ts690.c ts140.c ts480.c trc80.c ts590.c ts890s.c \ ts990s.c ts990s.h flex6xxx.c pihpsdr.c IC10SRC = ts440.c ts940.c ts711.c ts811.c r5000.c diff --git a/rigs/kenwood/kenwood.c b/rigs/kenwood/kenwood.c index 685aeb3bd..c78e09181 100644 --- a/rigs/kenwood/kenwood.c +++ b/rigs/kenwood/kenwood.c @@ -1691,6 +1691,7 @@ int kenwood_get_rit(RIG *rig, vfo_t vfo, shortfreq_t *rit) return retval; } + // TODO: Fix for different rigs memcpy(buf, &priv->info[17], 6); buf[6] = '\0'; @@ -2566,7 +2567,7 @@ int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) break; case RIG_LEVEL_KEYSPD: - if (val.i > 50 || val.i < 5) + if (val.i > 60 || val.i < 5) { return -RIG_EINVAL; } @@ -2662,7 +2663,7 @@ int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) break; case RIG_LEVEL_STRENGTH: - if (RIG_IS_TS590S || RIG_IS_TS590SG) + if (RIG_IS_TS590S || RIG_IS_TS590SG || RIG_IS_TS480) { cmd = "SM0"; len = 3; diff --git a/rigs/kenwood/ts480.c b/rigs/kenwood/ts480.c index 0f6a97ac7..1197f1d49 100644 --- a/rigs/kenwood/ts480.c +++ b/rigs/kenwood/ts480.c @@ -1,6 +1,5 @@ /* - * Hamlib Kenwood backend - TS480 description - * Hamlib Kenwood backend - TS890s description + * Hamlib Kenwood backend - TS-480 description * Copyright (c) 2000-2004 by Stephane Fillod and Juergen Rinas * * @@ -24,32 +23,24 @@ #include "config.h" #endif -#include #include #include -#include "idx_builtin.h" #include "kenwood.h" #define TS480_ALL_MODES (RIG_MODE_AM|RIG_MODE_CW|RIG_MODE_CWR|RIG_MODE_SSB|RIG_MODE_FM|RIG_MODE_RTTY|RIG_MODE_RTTYR) #define PS8000A_ALL_MODES (RIG_MODE_AM|RIG_MODE_AMS|RIG_MODE_CW|RIG_MODE_CWR|RIG_MODE_SSB|RIG_MODE_FM|RIG_MODE_RTTY|RIG_MODE_RTTYR) -#define TS890_ALL_MODES (RIG_MODE_LSB|RIG_MODE_USB|RIG_MODE_CW|RIG_MODE_FM|RIG_MODE_AM|RIG_MODE_RTTY|RIG_MODE_CWR|RIG_MODE_RTTYR|RIG_MODE_PSK|RIG_MODE_PSKR|RIG_MODE_PKTLSB|RIG_MODE_PKTUSB|RIG_MODE_PKTFM|RIG_MODE_PKTAM) #define TS480_OTHER_TX_MODES (RIG_MODE_CW|RIG_MODE_SSB|RIG_MODE_FM|RIG_MODE_RTTY) #define TS480_AM_TX_MODES RIG_MODE_AM #define TS480_VFO (RIG_VFO_A|RIG_VFO_B) -#define TS480_LEVEL_ALL (RIG_LEVEL_RFPOWER|RIG_LEVEL_AF|RIG_LEVEL_RF|RIG_LEVEL_SQL|RIG_LEVEL_AGC) +#define TS480_LEVEL_ALL (RIG_LEVEL_RFPOWER|RIG_LEVEL_AF|RIG_LEVEL_RF|RIG_LEVEL_SQL|RIG_LEVEL_AGC|RIG_LEVEL_KEYSPD|RIG_LEVEL_STRENGTH) #define TS480_FUNC_ALL (RIG_FUNC_NB|RIG_FUNC_COMP|RIG_FUNC_VOX|RIG_FUNC_NR|RIG_FUNC_NR|RIG_FUNC_BC|RIG_FUNC_BC2|RIG_FUNC_RIT|RIG_FUNC_XIT) -#define TS890_FUNC_ALL (RIG_FUNC_NB|RIG_FUNC_NB2|RIG_FUNC_COMP|RIG_FUNC_VOX|RIG_FUNC_NR|RIG_FUNC_NR|RIG_FUNC_BC|RIG_FUNC_BC2|RIG_FUNC_RIT|RIG_FUNC_XIT) +// TODO: add S-meter calibration table: 0-20 -/* - * kenwood_ts480_get_info - * Assumes rig!=NULL - */ -static const char * -kenwood_ts480_get_info(RIG *rig) +static const char *kenwood_ts480_get_info(RIG *rig) { char firmbuf[50]; int retval; @@ -91,191 +82,74 @@ kenwood_ts480_get_info(RIG *rig) /* - * kenwood_ts480_set_level - * Assumes rig!=NULL - * - * set levels of most functions - * - * WARNING: the commands differ slightly from the general versions in kenwood.c + * WARNING: The commands differ slightly from the general versions in kenwood.c * e.g.: "SQ"=>"SQ0" , "AG"=>"AG0" */ -int -kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) +int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) { char levelbuf[16]; int kenwood_val; - int rf_max_level = 100; /* 100 for TS-480 and 255 for TS-890S */ rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__); switch (level) { - case RIG_LEVEL_RFPOWER: - return kenwood_set_level(rig, vfo, level, val); - - case RIG_LEVEL_AF: - return kenwood_set_level(rig, vfo, level, val); - case RIG_LEVEL_RF: - if (rig->caps->rig_model == RIG_MODEL_TS890S) - { - rf_max_level = 255; - } - - kenwood_val = val.f * - rf_max_level; /* possible values for TS480 are 000.. 100 */ + kenwood_val = val.f * 100; sprintf(levelbuf, "RG%03d", kenwood_val); break; case RIG_LEVEL_SQL: - kenwood_val = val.f * 255; /* possible values for TS480 are 000.. 255 */ - - if (rig->caps->rig_model == RIG_MODEL_TS890S) - { - sprintf(levelbuf, "SQ%03d", kenwood_val); - } - else - { - sprintf(levelbuf, "SQ0%03d", kenwood_val); - } - + kenwood_val = val.f * 255; + sprintf(levelbuf, "SQ0%03d", kenwood_val); break; case RIG_LEVEL_AGC: - /* hamlib argument is int, possible values rig.h:enum agc_level_e */ /* possible values for TS480 000(=off), 001(=fast), 002(=slow) */ - /* possible values for TS890 0(=off), 1(=slow), 2(=mid), 3(=fast), 4(=off/Last) */ - if (rig->caps->rig_model == RIG_MODEL_TS890S) + rig_debug(RIG_DEBUG_VERBOSE, "%s TS480 RIG_LEVEL_AGC\n", __func__); + + switch (val.i) { - rig_debug(RIG_DEBUG_VERBOSE, "%s TS890S RIG_LEVEL_AGC\n", __func__); + case RIG_AGC_OFF: + kenwood_val = 0; + break; - switch (val.i) - { - case RIG_AGC_OFF: - kenwood_val = 0; - break; + case RIG_AGC_FAST: + kenwood_val = 1; + break; - case RIG_AGC_SLOW: - kenwood_val = 1; - break; + case RIG_AGC_SLOW: + kenwood_val = 2; + break; - case RIG_AGC_MEDIUM: - kenwood_val = 2; - break; - - case RIG_AGC_FAST: - kenwood_val = 3; - break; - - case RIG_AGC_AUTO: - kenwood_val = 4; - break; - - default: - rig_debug(RIG_DEBUG_ERR, "%s: unsupported agc value", __func__); - return -RIG_EINVAL; - } - - sprintf(levelbuf, "GC%d", kenwood_val); - } - else - { - rig_debug(RIG_DEBUG_VERBOSE, "%s TS480 RIG_LEVEL_AGC\n", __func__); - - switch (val.i) - { - case RIG_AGC_OFF: - kenwood_val = 0; - break; - - case RIG_AGC_FAST: - kenwood_val = 1; - break; - - case RIG_AGC_SLOW: - kenwood_val = 2; - break; - - default: - rig_debug(RIG_DEBUG_ERR, "%s: unsupported agc value", __func__); - return -RIG_EINVAL; - } - - sprintf(levelbuf, "GT%03d", kenwood_val); + default: + rig_debug(RIG_DEBUG_ERR, "%s: unsupported agc value", __func__); + return -RIG_EINVAL; } + sprintf(levelbuf, "GT%03d", kenwood_val); break; default: - rig_debug(RIG_DEBUG_ERR, "%s: unsupported set_level %s", __func__, - rig_strlevel(level)); - return -RIG_EINVAL; + return kenwood_set_level(rig, vfo, level, val); } return kenwood_transaction(rig, levelbuf, NULL, 0); } -/* - * kenwood_get_level - * Assumes rig!=NULL, val!=NULL - */ -int -kenwood_ts480_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) +int kenwood_ts480_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) { char ackbuf[50]; size_t ack_len, ack_len_expected; int levelint; - int offset_level = 3; // default offset for the level return value int retval; - int rf_max_level; rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__); - if (rig->caps->rig_model == RIG_MODEL_TS890S) - { - rf_max_level = 255; - } - else - { - rf_max_level = 100; - } - switch (level) { - case RIG_LEVEL_AF: - if (rig->caps->rig_model == RIG_MODEL_TS890S) - { - retval = kenwood_transaction(rig, "AG", ackbuf, sizeof(ackbuf)); - offset_level = 2; - } - else - { - retval = kenwood_transaction(rig, "AG0", ackbuf, sizeof(ackbuf)); - offset_level = 3; - } - - if (RIG_OK != retval) - { - return retval; - } - - ack_len = strlen(ackbuf); - - if (offset_level + 3 != ack_len) - { - return -RIG_EPROTO; - } - - if (1 != sscanf(&ackbuf[offset_level], "%d", &levelint)) - { - return -RIG_EPROTO; - } - - val->f = levelint / (float) rf_max_level; - return RIG_OK; - case RIG_LEVEL_RF: retval = kenwood_transaction(rig, "RG", ackbuf, sizeof(ackbuf)); @@ -296,20 +170,12 @@ kenwood_ts480_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) return -RIG_EPROTO; } - val->f = levelint / (float) rf_max_level; + val->f = levelint / (float) 100; return RIG_OK; case RIG_LEVEL_SQL: - if (rig->caps->rig_model == RIG_MODEL_TS890S) - { - retval = kenwood_transaction(rig, "SQ", ackbuf, sizeof(ackbuf)); - ack_len_expected = 5; - } - else - { - retval = kenwood_transaction(rig, "SQ0", ackbuf, sizeof(ackbuf)); - ack_len_expected = 6; - } + retval = kenwood_transaction(rig, "SQ0", ackbuf, sizeof(ackbuf)); + ack_len_expected = 6; if (RIG_OK != retval) { @@ -332,16 +198,8 @@ kenwood_ts480_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) return RIG_OK; case RIG_LEVEL_AGC: - if (rig->caps->rig_model == RIG_MODEL_TS890S) - { - retval = kenwood_transaction(rig, "GC", ackbuf, sizeof(ackbuf)); - ack_len_expected = 3; - } - else - { - retval = kenwood_transaction(rig, "GT", ackbuf, sizeof(ackbuf)); - ack_len_expected = 5; - } + retval = kenwood_transaction(rig, "GT", ackbuf, sizeof(ackbuf)); + ack_len_expected = 5; if (RIG_OK != retval) { @@ -362,85 +220,32 @@ kenwood_ts480_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) break; case '1': - if (rig->caps->rig_model == RIG_MODEL_TS890S) - { - val->i = RIG_AGC_SLOW; - } - else - { - val->i = RIG_AGC_FAST; - } - - break; - - case '2': - if (rig->caps->rig_model == RIG_MODEL_TS890S) - { - val->i = RIG_AGC_MEDIUM; - } - else - { - val->i = RIG_AGC_SLOW; - } - - break; - - case '3': val->i = RIG_AGC_FAST; break; - case '4': - val->i = RIG_AGC_AUTO; + case '2': + val->i = RIG_AGC_SLOW; break; default: return -RIG_EPROTO; } - return RIG_OK; - case RIG_LEVEL_RFPOWER: - return kenwood_get_level(rig, vfo, level, val); - - case RIG_LEVEL_MICGAIN: - case RIG_LEVEL_PREAMP: - case RIG_LEVEL_IF: - case RIG_LEVEL_APF: - case RIG_LEVEL_NR: - case RIG_LEVEL_PBT_IN: - case RIG_LEVEL_PBT_OUT: - case RIG_LEVEL_CWPITCH: - case RIG_LEVEL_KEYSPD: - case RIG_LEVEL_NOTCHF: - case RIG_LEVEL_COMP: - case RIG_LEVEL_BKINDL: - case RIG_LEVEL_BALANCE: - return -RIG_ENIMPL; - default: - rig_debug(RIG_DEBUG_ERR, "%s: unsupported get_level %s", __func__, - rig_strlevel(level)); - return -RIG_EINVAL; + return kenwood_get_level(rig, vfo, level, val); } - - return RIG_OK; /* never reached */ } static struct kenwood_priv_caps ts480_priv_caps = { .cmdtrm = EOM_KEN, -}; -static struct kenwood_priv_caps ts890s_priv_caps = -{ - .cmdtrm = EOM_KEN, }; - /* - * ts480 rig capabilities. + * TS-480 rig capabilities * Notice that some rigs share the same functions. - * Also this struct is READONLY! */ const struct rig_caps ts480_caps = { @@ -589,12 +394,12 @@ const struct rig_caps ts480_caps = .has_set_func = TS480_FUNC_ALL, .set_func = kenwood_set_func, .get_func = kenwood_get_func, + .send_morse = kenwood_send_morse, }; /* * Hilberling PS8000A TS480 emulation * Notice that some rigs share the same functions. - * Also this struct is READONLY! */ const struct rig_caps pt8000a_caps = { @@ -722,9 +527,9 @@ const struct rig_caps pt8000a_caps = .rig_cleanup = kenwood_cleanup, .set_freq = kenwood_set_freq, .get_freq = kenwood_get_freq, - .set_rit = kenwood_set_rit, /* FIXME should this switch to rit mode or just set the frequency? */ + .set_rit = kenwood_set_rit, .get_rit = kenwood_get_rit, - .set_xit = kenwood_set_xit, /* FIXME should this switch to xit mode or just set the frequency? */ + .set_xit = kenwood_set_xit, .get_xit = kenwood_get_xit, .set_mode = kenwood_set_mode, .get_mode = kenwood_get_mode, @@ -751,160 +556,3 @@ const struct rig_caps pt8000a_caps = .set_func = kenwood_set_func, .get_func = kenwood_get_func, }; - -/* - * ts890s rig capabilities. - * Copied from ts480_caps - * Where you see TS480 in this the values have not been verified - * Notice that some rigs share the same functions. - * Also this struct is READONLY! - */ -const struct rig_caps ts890s_caps = -{ - RIG_MODEL(RIG_MODEL_TS890S), - .model_name = "TS-890S", - .mfg_name = "Kenwood", - .version = BACKEND_VER ".0", - .copyright = "LGPL", - .status = RIG_STATUS_STABLE, - .rig_type = RIG_TYPE_TRANSCEIVER, - .ptt_type = RIG_PTT_RIG_MICDATA, - .dcd_type = RIG_DCD_RIG, - .port_type = RIG_PORT_SERIAL, - .serial_rate_min = 4800, - .serial_rate_max = 115200, - .serial_data_bits = 8, - .serial_stop_bits = 1, - .serial_parity = RIG_PARITY_NONE, - .serial_handshake = RIG_HANDSHAKE_NONE, - .write_delay = 0, - .post_write_delay = 0, - .timeout = 200, - .retry = 10, - .preamp = {12, RIG_DBLST_END,}, - .attenuator = {12, RIG_DBLST_END,}, - .max_rit = kHz(9.99), - .max_xit = kHz(9.99), - .max_ifshift = Hz(0), - .targetable_vfo = RIG_TARGETABLE_FREQ, - .transceive = RIG_TRN_RIG, - - - .rx_range_list1 = { - {kHz(100), Hz(59999999), TS890_ALL_MODES, -1, -1, TS480_VFO}, - RIG_FRNG_END, - }, /*!< Receive frequency range list for ITU region 1 */ - .tx_range_list1 = { - {kHz(1810), kHz(1850), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, /* 100W class */ - {kHz(1810), kHz(1850), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, /* 25W class */ - {kHz(3500), kHz(3800), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {kHz(3500), kHz(3800), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {MHz(7), kHz(7200), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {MHz(7), kHz(7200), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {kHz(10100), kHz(10150), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {kHz(10100), kHz(10150), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {MHz(14), kHz(14350), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {MHz(14), kHz(14350), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {kHz(18068), kHz(18168), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {kHz(18068), kHz(18168), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {MHz(21), kHz(21450), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {MHz(21), kHz(21450), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {kHz(24890), kHz(24990), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {kHz(24890), kHz(24990), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {MHz(28), kHz(29700), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {MHz(28), kHz(29700), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {MHz(50), kHz(52000), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {MHz(50), kHz(52000), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - RIG_FRNG_END, - }, /*!< Transmit frequency range list for ITU region 1 */ - .rx_range_list2 = { - {kHz(100), Hz(59999999), TS890_ALL_MODES, -1, -1, TS480_VFO}, - RIG_FRNG_END, - }, /*!< Receive frequency range list for ITU region 2 */ - .tx_range_list2 = { - {kHz(1800), MHz(2) - 1, TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, /* 100W class */ - {kHz(1800), MHz(2) - 1, TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, /* 25W class */ - {kHz(3500), MHz(4) - 1, TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {kHz(3500), MHz(4) - 1, TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {kHz(5250), kHz(5450), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {kHz(5250), kHz(5450), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {MHz(7), kHz(7300), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {MHz(7), kHz(7300), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {kHz(10100), kHz(10150), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {kHz(10100), kHz(10150), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {MHz(14), kHz(14350), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {MHz(14), kHz(14350), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {kHz(18068), kHz(18168), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {kHz(18068), kHz(18168), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {MHz(21), kHz(21450), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {MHz(21), kHz(21450), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {kHz(24890), kHz(24990), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {kHz(24890), kHz(24990), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {MHz(28), kHz(29700), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {MHz(28), kHz(29700), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - {MHz(50), kHz(52000), TS480_OTHER_TX_MODES, 5000, 100000, TS480_VFO}, - {MHz(50), kHz(52000), TS480_AM_TX_MODES, 5000, 25000, TS480_VFO}, - RIG_FRNG_END, - }, /*!< Transmit frequency range list for ITU region 2 */ - .tuning_steps = { - {TS890_ALL_MODES, kHz(1)}, - {TS890_ALL_MODES, Hz(2500)}, - {TS890_ALL_MODES, kHz(5)}, - {TS890_ALL_MODES, Hz(6250)}, - {TS890_ALL_MODES, kHz(10)}, - {TS890_ALL_MODES, Hz(12500)}, - {TS890_ALL_MODES, kHz(15)}, - {TS890_ALL_MODES, kHz(20)}, - {TS890_ALL_MODES, kHz(25)}, - {TS890_ALL_MODES, kHz(30)}, - {TS890_ALL_MODES, kHz(100)}, - {TS890_ALL_MODES, kHz(500)}, - {TS890_ALL_MODES, MHz(1)}, - {TS890_ALL_MODES, 0}, /* any tuning step */ - RIG_TS_END, - }, - /* mode/filter list, remember: order matters! */ - .filters = { - {RIG_MODE_SSB, kHz(2.4)}, - {RIG_MODE_CW, Hz(200)}, - {RIG_MODE_RTTY, Hz(500)}, - {RIG_MODE_AM, kHz(9)}, - {RIG_MODE_FM, kHz(15)}, - RIG_FLT_END, - }, - .priv = (void *)& ts890s_priv_caps, - .rig_init = kenwood_init, - .rig_open = kenwood_open, - .rig_cleanup = kenwood_cleanup, - .set_freq = kenwood_set_freq, - .get_freq = kenwood_get_freq, - .set_rit = kenwood_set_rit, /* FIXME should this switch to rit mode or just set the frequency? */ - .get_rit = kenwood_get_rit, - .set_xit = kenwood_set_xit, /* FIXME should this switch to xit mode or just set the frequency? */ - .get_xit = kenwood_get_xit, - .set_mode = kenwood_set_mode, - .get_mode = kenwood_get_mode, - .set_vfo = kenwood_set_vfo, - .get_vfo = kenwood_get_vfo_if, - .set_split_vfo = kenwood_set_split_vfo, - .get_split_vfo = kenwood_get_split_vfo_if, - .get_ptt = kenwood_get_ptt, - .set_ptt = kenwood_set_ptt, - .get_dcd = kenwood_get_dcd, - .set_powerstat = kenwood_set_powerstat, - .get_powerstat = kenwood_get_powerstat, - .get_info = kenwood_ts480_get_info, - .reset = kenwood_reset, - .set_ant = kenwood_set_ant, - .get_ant = kenwood_get_ant, - .scan = kenwood_scan, /* not working, invalid arguments using rigctl; kenwood_scan does only support on/off and not tone and CTCSS scan */ - .has_set_level = TS480_LEVEL_ALL, - .has_get_level = TS480_LEVEL_ALL, - .set_level = kenwood_ts480_set_level, - .get_level = kenwood_ts480_get_level, - .has_get_func = TS890_FUNC_ALL, - .has_set_func = TS890_FUNC_ALL, - .set_func = kenwood_set_func, - .get_func = kenwood_get_func, -}; - diff --git a/rigs/kenwood/ts890s.c b/rigs/kenwood/ts890s.c new file mode 100644 index 000000000..2bce07a3c --- /dev/null +++ b/rigs/kenwood/ts890s.c @@ -0,0 +1,410 @@ +/* + * Hamlib Kenwood backend - TS-890S description + * Copyright (c) 2000-2004 by Stephane Fillod and Juergen Rinas + * + * 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 + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include +#include "kenwood.h" + +// TODO: Copied from TS-480, to be verified +#define TS890_VFO (RIG_VFO_A|RIG_VFO_B) + +#define TS890_ALL_MODES (RIG_MODE_LSB|RIG_MODE_USB|RIG_MODE_CW|RIG_MODE_FM|RIG_MODE_AM|RIG_MODE_RTTY|RIG_MODE_CWR|RIG_MODE_RTTYR|RIG_MODE_PSK|RIG_MODE_PSKR|RIG_MODE_PKTLSB|RIG_MODE_PKTUSB|RIG_MODE_PKTFM|RIG_MODE_PKTAM) + +// TODO: Copied from TS-480, to be verified +#define TS890_OTHER_TX_MODES (RIG_MODE_CW|RIG_MODE_SSB|RIG_MODE_FM|RIG_MODE_RTTY) +// TODO: Copied from TS-480, to be verified +#define TS890_AM_TX_MODES RIG_MODE_AM + +// TODO: Copied from TS-480, to be verified +#define TS890_LEVEL_ALL (RIG_LEVEL_RFPOWER|RIG_LEVEL_AF|RIG_LEVEL_RF|RIG_LEVEL_SQL|RIG_LEVEL_AGC) +#define TS890_FUNC_ALL (RIG_FUNC_NB|RIG_FUNC_NB2|RIG_FUNC_COMP|RIG_FUNC_VOX|RIG_FUNC_NR|RIG_FUNC_NR|RIG_FUNC_BC|RIG_FUNC_BC2|RIG_FUNC_RIT|RIG_FUNC_XIT) + +int kenwood_ts890_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val) +{ + char levelbuf[16]; + int kenwood_val; + + rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__); + + switch (level) + { + case RIG_LEVEL_RF: + kenwood_val = val.f * 255; + sprintf(levelbuf, "RG%03d", kenwood_val); + break; + + case RIG_LEVEL_SQL: + kenwood_val = val.f * 255; + + if (rig->caps->rig_model == RIG_MODEL_TS890S) + { + sprintf(levelbuf, "SQ%03d", kenwood_val); + } + else + { + sprintf(levelbuf, "SQ0%03d", kenwood_val); + } + + break; + + case RIG_LEVEL_AGC: + /* hamlib argument is int, possible values rig.h:enum agc_level_e */ + /* possible values for TS890 0(=off), 1(=slow), 2(=mid), 3(=fast), 4(=off/Last) */ + if (rig->caps->rig_model == RIG_MODEL_TS890S) + { + rig_debug(RIG_DEBUG_VERBOSE, "%s TS890S RIG_LEVEL_AGC\n", __func__); + + switch (val.i) + { + case RIG_AGC_OFF: + kenwood_val = 0; + break; + + case RIG_AGC_SLOW: + kenwood_val = 1; + break; + + case RIG_AGC_MEDIUM: + kenwood_val = 2; + break; + + case RIG_AGC_FAST: + kenwood_val = 3; + break; + + case RIG_AGC_AUTO: + kenwood_val = 4; + break; + + default: + rig_debug(RIG_DEBUG_ERR, "%s: unsupported agc value", __func__); + return -RIG_EINVAL; + } + + sprintf(levelbuf, "GC%d", kenwood_val); + } + else + { + rig_debug(RIG_DEBUG_VERBOSE, "%s TS480 RIG_LEVEL_AGC\n", __func__); + + switch (val.i) + { + case RIG_AGC_OFF: + kenwood_val = 0; + break; + + case RIG_AGC_FAST: + kenwood_val = 1; + break; + + case RIG_AGC_SLOW: + kenwood_val = 2; + break; + + default: + rig_debug(RIG_DEBUG_ERR, "%s: unsupported agc value", __func__); + return -RIG_EINVAL; + } + + sprintf(levelbuf, "GT%03d", kenwood_val); + } + + break; + + default: + return kenwood_set_level(rig, vfo, level, val); + } + + return kenwood_transaction(rig, levelbuf, NULL, 0); +} + + +int kenwood_ts890_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val) +{ + char ackbuf[50]; + size_t ack_len, ack_len_expected; + int levelint; + int retval; + + rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__); + + switch (level) + { + case RIG_LEVEL_RF: + retval = kenwood_transaction(rig, "RG", ackbuf, sizeof(ackbuf)); + + if (RIG_OK != retval) + { + return retval; + } + + ack_len = strlen(ackbuf); + + if (5 != ack_len) + { + return -RIG_EPROTO; + } + + if (1 != sscanf(&ackbuf[2], "%d", &levelint)) + { + return -RIG_EPROTO; + } + + val->f = levelint / (float) 255; + return RIG_OK; + + case RIG_LEVEL_SQL: + retval = kenwood_transaction(rig, "SQ", ackbuf, sizeof(ackbuf)); + ack_len_expected = 5; + + if (RIG_OK != retval) + { + return retval; + } + + ack_len = strlen(ackbuf); + + if (ack_len != ack_len_expected) + { + return -RIG_EPROTO; + } + + if (1 != sscanf(&ackbuf[ack_len_expected - 3], "%d", &levelint)) + { + return -RIG_EPROTO; + } + + val->f = (float) levelint / 255.; + return RIG_OK; + + case RIG_LEVEL_AGC: + retval = kenwood_transaction(rig, "GC", ackbuf, sizeof(ackbuf)); + ack_len_expected = 3; + + if (RIG_OK != retval) + { + return retval; + } + + ack_len = strlen(ackbuf); + + if (ack_len != ack_len_expected) + { + return -RIG_EPROTO; + } + + switch (ackbuf[ack_len_expected - 1]) + { + case '0': + val->i = RIG_AGC_OFF; + break; + + case '1': + val->i = RIG_AGC_SLOW; + + break; + + case '2': + val->i = RIG_AGC_MEDIUM; + + break; + + case '3': + val->i = RIG_AGC_FAST; + break; + + case '4': + val->i = RIG_AGC_AUTO; + break; + + default: + return -RIG_EPROTO; + } + + return RIG_OK; + + default: + return kenwood_get_level(rig, vfo, level, val); + } +} + +static struct kenwood_priv_caps ts890s_priv_caps = +{ + .cmdtrm = EOM_KEN, +}; + +/* + * TS-890S rig capabilities + * Copied from ts480_caps, many of the values have not been verified. + * Notice that some rigs share the same functions. + */ +const struct rig_caps ts890s_caps = +{ + RIG_MODEL(RIG_MODEL_TS890S), + .model_name = "TS-890S", + .mfg_name = "Kenwood", + .version = BACKEND_VER ".0", + .copyright = "LGPL", + .status = RIG_STATUS_STABLE, + .rig_type = RIG_TYPE_TRANSCEIVER, + .ptt_type = RIG_PTT_RIG_MICDATA, + .dcd_type = RIG_DCD_RIG, + .port_type = RIG_PORT_SERIAL, + .serial_rate_min = 4800, + .serial_rate_max = 115200, + .serial_data_bits = 8, + .serial_stop_bits = 1, + .serial_parity = RIG_PARITY_NONE, + .serial_handshake = RIG_HANDSHAKE_NONE, + .write_delay = 0, + .post_write_delay = 0, + .timeout = 200, + .retry = 10, + .preamp = {12, RIG_DBLST_END,}, + .attenuator = {12, RIG_DBLST_END,}, + .max_rit = kHz(9.99), + .max_xit = kHz(9.99), + .max_ifshift = Hz(0), + .targetable_vfo = RIG_TARGETABLE_FREQ, + .transceive = RIG_TRN_RIG, + + + .rx_range_list1 = { + {kHz(100), Hz(59999999), TS890_ALL_MODES, -1, -1, TS890_VFO}, + RIG_FRNG_END, + }, /*!< Receive frequency range list for ITU region 1 */ + .tx_range_list1 = { + {kHz(1810), kHz(1850), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, /* 100W class */ + {kHz(1810), kHz(1850), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, /* 25W class */ + {kHz(3500), kHz(3800), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {kHz(3500), kHz(3800), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {MHz(7), kHz(7200), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {MHz(7), kHz(7200), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {kHz(10100), kHz(10150), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {kHz(10100), kHz(10150), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {MHz(14), kHz(14350), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {MHz(14), kHz(14350), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {kHz(18068), kHz(18168), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {kHz(18068), kHz(18168), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {MHz(21), kHz(21450), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {MHz(21), kHz(21450), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {kHz(24890), kHz(24990), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {kHz(24890), kHz(24990), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {MHz(28), kHz(29700), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {MHz(28), kHz(29700), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {MHz(50), kHz(52000), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {MHz(50), kHz(52000), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + RIG_FRNG_END, + }, /*!< Transmit frequency range list for ITU region 1 */ + .rx_range_list2 = { + {kHz(100), Hz(59999999), TS890_ALL_MODES, -1, -1, TS890_VFO}, + RIG_FRNG_END, + }, /*!< Receive frequency range list for ITU region 2 */ + .tx_range_list2 = { + {kHz(1800), MHz(2) - 1, TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, /* 100W class */ + {kHz(1800), MHz(2) - 1, TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, /* 25W class */ + {kHz(3500), MHz(4) - 1, TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {kHz(3500), MHz(4) - 1, TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {kHz(5250), kHz(5450), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {kHz(5250), kHz(5450), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {MHz(7), kHz(7300), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {MHz(7), kHz(7300), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {kHz(10100), kHz(10150), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {kHz(10100), kHz(10150), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {MHz(14), kHz(14350), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {MHz(14), kHz(14350), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {kHz(18068), kHz(18168), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {kHz(18068), kHz(18168), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {MHz(21), kHz(21450), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {MHz(21), kHz(21450), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {kHz(24890), kHz(24990), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {kHz(24890), kHz(24990), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {MHz(28), kHz(29700), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {MHz(28), kHz(29700), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + {MHz(50), kHz(52000), TS890_OTHER_TX_MODES, 5000, 100000, TS890_VFO}, + {MHz(50), kHz(52000), TS890_AM_TX_MODES, 5000, 25000, TS890_VFO}, + RIG_FRNG_END, + }, /*!< Transmit frequency range list for ITU region 2 */ + .tuning_steps = { + {TS890_ALL_MODES, kHz(1)}, + {TS890_ALL_MODES, Hz(2500)}, + {TS890_ALL_MODES, kHz(5)}, + {TS890_ALL_MODES, Hz(6250)}, + {TS890_ALL_MODES, kHz(10)}, + {TS890_ALL_MODES, Hz(12500)}, + {TS890_ALL_MODES, kHz(15)}, + {TS890_ALL_MODES, kHz(20)}, + {TS890_ALL_MODES, kHz(25)}, + {TS890_ALL_MODES, kHz(30)}, + {TS890_ALL_MODES, kHz(100)}, + {TS890_ALL_MODES, kHz(500)}, + {TS890_ALL_MODES, MHz(1)}, + {TS890_ALL_MODES, 0}, /* any tuning step */ + RIG_TS_END, + }, + /* mode/filter list, remember: order matters! */ + .filters = { + {RIG_MODE_SSB, kHz(2.4)}, + {RIG_MODE_CW, Hz(200)}, + {RIG_MODE_RTTY, Hz(500)}, + {RIG_MODE_AM, kHz(9)}, + {RIG_MODE_FM, kHz(15)}, + RIG_FLT_END, + }, + .priv = (void *)& ts890s_priv_caps, + .rig_init = kenwood_init, + .rig_open = kenwood_open, + .rig_cleanup = kenwood_cleanup, + .set_freq = kenwood_set_freq, + .get_freq = kenwood_get_freq, + .set_rit = kenwood_set_rit, + .get_rit = kenwood_get_rit, + .set_xit = kenwood_set_xit, + .get_xit = kenwood_get_xit, + .set_mode = kenwood_set_mode, + .get_mode = kenwood_get_mode, + .set_vfo = kenwood_set_vfo, + .get_vfo = kenwood_get_vfo_if, + .set_split_vfo = kenwood_set_split_vfo, + .get_split_vfo = kenwood_get_split_vfo_if, + .get_ptt = kenwood_get_ptt, + .set_ptt = kenwood_set_ptt, + .get_dcd = kenwood_get_dcd, + .set_powerstat = kenwood_set_powerstat, + .get_powerstat = kenwood_get_powerstat, + .get_info = NULL, + .reset = kenwood_reset, + .set_ant = kenwood_set_ant, + .get_ant = kenwood_get_ant, + .scan = kenwood_scan, /* not working, invalid arguments using rigctl; kenwood_scan does only support on/off and not tone and CTCSS scan */ + .has_set_level = TS890_LEVEL_ALL, + .has_get_level = TS890_LEVEL_ALL, + .set_level = kenwood_ts890_set_level, + .get_level = kenwood_ts890_get_level, + .has_get_func = TS890_FUNC_ALL, + .has_set_func = TS890_FUNC_ALL, + .set_func = kenwood_set_func, + .get_func = kenwood_get_func, +};