mirror
/
Hamlib
kopia lustrzana https://github.com/Hamlib/Hamlib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
Hamlib/kenwood/ts2k.c

2939 wiersze
68 KiB
C
Czysty Bezpośredni odnośnik Wina Historia

/*
* Hamlib Kenwood backend - TS2000 description
* Copyright (c) 2000-2002 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
*
*/
/*
* This code is has been substatiantially altered from the original
* author's. Also, many new functions have been added and are
* (C) Copyrighted 2002 by Dale E. Edmons (KD7ENI). The license
* is unchanged, and fitness disclaimers still apply.
*/
/*
* Copied kenwood.c to end of this file. When I change a function for the
* ts2000 I will already have the kenwood version with the function prefix
* changed to ts2k. Unique functions will be pointed to in this file,
* whereas the unmodified version will be in kenwood.c. This simplifies
* things during development and unused ts2k_() functions should go away
* as soon as possible.
*
* Dale KD7ENI
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <ctype.h>
#include <hamlib/rig.h>
#include "kenwood.h"
#include "ts2k.h"
/*
* I just read in kenwood.c and will modify the functions here. This way,
* kenwood functions that actually work on other rigs won't be broken by
* my hacks. Anything that works for all can be sent back over to kenwood.c
*
* Note: due to my compulsive laziness, I often abbreviate Kenwood TS-2000
* as simply ts2k, especially for code!
*
* Dale kd7eni
*/
/*
* Hamlib Kenwood backend - main file
* Copyright (c) 2000-2002 by Stephane Fillod
*
*/
#include <stdlib.h>
#include <stdio.h> /* Standard input/output definitions */
#include <string.h> /* String function definitions */
#include <unistd.h> /* UNIX standard function definitions */
#include <fcntl.h> /* File control definitions */
#include <errno.h> /* Error number definitions */
#include <termios.h> /* POSIX terminal control definitions */
#include <sys/ioctl.h>
#include <math.h>
#include <serial.h>
#include <misc.h>
// Added the following two lists --Dale, kd7eni
// FIXME: RIG_MODE_[FSKR|CWR] undefined in rig.h
const int ts2k_mode_list[] = {
RIG_MODE_NONE, RIG_MODE_LSB, RIG_MODE_USB, RIG_MODE_CW,
RIG_MODE_FM, RIG_MODE_AM, RIG_MODE_RTTY, RIG_MODE_CW,
RIG_MODE_RTTY
};
long int ts2k_steps[2][10] = {
{1000, 2500, 5000, 10000, 0, 0, 0, 0, 0, 0}, // ssb, cw, fsk
{5000, 6250, 10000, 12500, 15000, 20000,
25000, 30000, 50000, 100000} // am/fm
};
struct ts2k_id {
rig_model_t model;
int id;
};
struct ts2k_id_string {
rig_model_t model;
const char *id;
};
#define UNKNOWN_ID -1
/*
* Identification number as returned by "ID;"
* Please, if the model number of your rig is listed as UNKNOWN_ID,
* send the value to <fillods@users.sourceforge.net> for inclusion. Thanks --SF
*
* TODO: sort this list with most frequent rigs first.
*/
static const struct ts2k_id ts2k_id_list[] = {
{RIG_MODEL_R5000, 5},
{RIG_MODEL_TS870S, 15},
{RIG_MODEL_TS570D, 17},
{RIG_MODEL_TS570S, 18},
{RIG_MODEL_TS2000, 19}, /* correct --kd7eni */
{RIG_MODEL_NONE, UNKNOWN_ID}, /* end marker */
};
static const struct ts2k_id_string ts2k_id_string_list[] = {
{RIG_MODEL_THD7A, "TH-D7"},
{RIG_MODEL_THD7AG, "TH-D7G"},
{RIG_MODEL_THF6A, "TH-F6"},
{RIG_MODEL_THF7E, "TH-F7"},
{RIG_MODEL_NONE, NULL}, /* end marker */
};
/*
* 38 CTCSS sub-audible tones (17500 invalid for ctcss --kd7eni)
*/
const int ts2k_ctcss_list[] = {
670, 719, 744, 770, 797, 825, 854, 885, 915, 948,
974, 1000, 1035, 1072, 1109, 1148, 1188, 1230, 1273, 1318,
1365, 1413, 1462, 1514, 1567, 1622, 1679, 1738, 1799, 1862,
1928, 2035, 2107, 2181, 2257, 2336, 2418, 2503, // 17500,
/* Note: 17500 is not available as ctcss, only tone. --kd7eni */
0,
};
#define cmd_trm(rig) ((struct ts2k_priv_caps *)(rig)->caps->priv)->cmdtrm
#define ta_quit rs->hold_decode = 0; return retval
/**
* kenwood_transaction
* Assumes rig!=NULL rig->state!=NULL rig->caps!=NULL
*
* cmdstr - Command to be sent to the rig. Cmdstr can also be NULL, indicating
* that only a reply is needed (nothing will be send).
* data - Buffer for reply string. Can be NULL, indicating that no reply is
* is needed and will return with RIG_OK after command was sent.
* datasize - in: Size of buffer. It is the caller's responsibily to provide
* a large enough buffer for all possible replies for a command.
* out: location where to store number of bytes read.
*
* returns:
* RIG_OK - if no error occured.
* RIG_EIO - if an I/O error occured while sending/receiving data.
* RIG_ETIMEOUT - if timeout expires without any characters received.
* RIG_REJECTED - if a negative acknowledge was received or command not
* recognized by rig.
*/
/* FIXME: cmd_len appears to change and needs set every invocation? --Dale */
int
ts2k_transaction(RIG * rig, const char *cmdstr, int cmd_len,
char *data, size_t * datasize)
{
// return kenwood_transaction(rig, cmdstr, data, datasize);
struct rig_state *rs;
int retval;
const char *cmdtrm = EOM_KEN; /* Default Command/Reply termination char */
int retry_read = 0;
char *errtxt;
#define MAX_RETRY_READ 5
rs = &rig->state;
rs->hold_decode = 1;
serial_flush(&rs->rigport);
cmdtrm = cmd_trm(rig);
if (cmdstr != NULL) {
// rig_debug(RIG_DEBUG_ERR, __func__": 1) sending '%s'\n\n", cmdstr);
retval = write_block(&rs->rigport, cmdstr, strlen(cmdstr));
if (retval != RIG_OK)
{ ta_quit; }
#undef TH_ADD_CMDTRM
#ifdef TH_ADD_CMDTRM
// rig_debug(RIG_DEBUG_ERR, __func__": 2) sending '%s'\n\n", cmdtrm);
retval = write_block(&rs->rigport, cmdtrm, strlen(cmdtrm));
if (retval != RIG_OK)
{ ta_quit; }
#endif
}
/* FIXME: Everything below this line wants to be completely rewritten!!!! */
if (data == NULL || datasize <= 0) {
rig->state.hold_decode = 0;
return RIG_OK; /* don't want a reply */
}
transaction_read:
/* FIXME : TS-2000 gets alot of 'timedout' on read_string()! */
//rig_debug(RIG_DEBUG_ERR, __func__": 3a) reading %u bytes...\n", *datasize);
retval =
read_string(&rs->rigport, data, *datasize, cmdtrm,
strlen(cmdtrm));
//rig_debug(RIG_DEBUG_ERR, __func__": 3b) read '%s', retval=%u\n\n", data, retval);
*datasize = retval;
if (retval > 0) {
//rig_debug(RIG_DEBUG_ERR, __func__": 3b) read cmd '%s', retval=%u\n\n", data, retval);
retval = RIG_OK;
goto transaction_check;
}
/* Check that command termination is correct */
if (!strchr(cmdtrm, data[strlen(data)])) {
if (retry_read++ < MAX_RETRY_READ)
goto transaction_read;
rig_debug(RIG_DEBUG_ERR,
__func__
": Command is not correctly terminated '%s'\n",
data);
retval = -RIG_EPROTO;
ta_quit;
}
/* Errors */
if (strlen(data) == 2 && data[0] == 'E') {
switch (data[0]) {
case 'E':
rig_debug(RIG_DEBUG_ERR,
__func__
": Communication Error for '%s'\n",
cmdstr);
break;
case 'O':
rig_debug(RIG_DEBUG_ERR,
__func__
": Communication Error for '%s'\n",
cmdstr);
break;
case '?':
rig_debug(RIG_DEBUG_ERR,
__func__
": Communication Error for '%s'\n",
cmdstr);
break;
default:
rig_debug(RIG_DEBUG_ERR,
__func__ ": Hamlib Error for '%s'\n",
cmdstr);
break;
}
retval = -RIG_ERJCTED;
ta_quit;
}
#undef CONFIG_STRIP_CMDTRM
#ifdef CONFIG_STRIP_CMDTRM
if (strlen(data) > 0)
data[strlen(data) - 1] = '\0'; /* not very elegant, but should work. */
else
data[0] = '\0';
#endif
/*
* Check that received the correct reply. The first two characters
* should be the same as command.
*/
transaction_check:
if (cmdstr && (toupper(data[0]) != toupper(cmdstr[0])
|| toupper(data[1]) != toupper(cmdstr[1]))) {
/*
* TODO: When RIG_TRN is enabled, we can pass the string
* to the decoder for callback. That way we don't ignore
* any commands.
*/
if (retry_read++ < MAX_RETRY_READ)
goto transaction_read;
rig_debug(RIG_DEBUG_ERR,
__func__ ": Unexpected reply '%s'\n", data);
retval = -RIG_EPROTO;
{ ta_quit; }
}
retval = RIG_OK;
transaction_quit:
{ ta_quit; }
}
/*
* kenwood_set_vfo
* Assumes rig!=NULL
*
* status: VFOA, VFOB, VFOC, Main, Sub,
* MEMA, MEMC, CALLA, CALLC
* VFO_AB, VFO_BA, ...
* They all work! --Dale
*/
int ts2k_set_vfo(RIG * rig, vfo_t vfo)
{
unsigned char cmdbuf[10];
int ptt, ctrl, v,cmd_len, retval;
static int sat_on; // temporary! to be removed!
char vfo_function;
// trivial case, but needs checked if enabled
/*// if( (vfo == RIG_CTRL_MODE(RIG_CTRL_MAIN,RIG_VFO_ALL))
// || (vfo == RIG_CTRL_MODE(RIG_CTRL_SUB,RIG_VFO_ALL)) ) {
// rig_debug(RIG_DEBUG_ERR, __func__ \
// ": Geez, you can't set *all* VFO's!\n");
// return -RIG_EINVAL;
// }
*/
cmd_len = 10;
ptt = ctrl = v = 0;
// be optimistic (and ensure initialization)
retval = RIG_OK;
// Main/Sub Active Transceiver
switch (vfo) {
case RIG_VFO_A:
case RIG_VFO_B:
case RIG_VFO_AB: // split
case RIG_VFO_BA:
case RIG_CTRL_SAT: // FIXME: Not even close to correct
case RIG_VFO_MAIN:
case RIG_VFO_MEM_A:
case RIG_VFO_CALL_A:
ctrl = TS2K_CTRL_ON_MAIN; // FIXME : these are independent!
ptt = TS2K_PTT_ON_MAIN;
break;
case RIG_VFO_C:
case RIG_VFO_SUB:
case RIG_VFO_MEM_C:
case RIG_VFO_CALL_C:
ctrl = TS2K_CTRL_ON_SUB;
ptt = TS2K_PTT_ON_SUB;
break;
default:
break;
}
// set now so "ft...;" and "fr...;" don't fail
retval = ts2k_set_ctrl(rig, ptt, ctrl);
if (retval != RIG_OK)
return -RIG_EINVAL;
// check if we need to skip the remainder
v = (vfo == RIG_VFO_SUB)
|| (vfo == RIG_VFO_MAIN)
|| (vfo == RIG_VFO_CURR)
|| (vfo == RIG_VFO_VFO)
// || (vfo == RIG_VFO_ALL) // yea, I know
/* bit mask checks */
|| (vfo & RIG_CTRL_SAT) // "fr...;", "ft...;" won't do!
;
rig_debug(RIG_DEBUG_ERR, __func__ \
": starting check.... vfo = 0x%X, v=%d\n", vfo, v);
if (!v) { // start check
// FIXME: this is a speed-up kludge but won't *always* work!
if(sat_on) {
retval = ts2k_sat_off(rig, vfo); // we gotta do it.
if(retval != RIG_OK)
return retval;
sat_on = 0;
}
// RX Active Tuning
switch (vfo) {
case RIG_VFO_AB: // TX is opposite
case RIG_VFO_A:
case RIG_VFO_C:
vfo_function = '0';
break;
case RIG_VFO_BA: // TX is opposite
case RIG_VFO_B:
vfo_function = '1';
break;
case RIG_VFO_MEM_A:
case RIG_VFO_MEM_C:
vfo_function = '2';
break;
case RIG_VFO_CALL_A:
case RIG_VFO_CALL_C:
vfo_function = '3';
break;
default:
rig_debug(RIG_DEBUG_ERR, __func__
": unsupported VFO %u\n", vfo);
return -RIG_EINVAL;
break;
}
// ack_len is tmp
cmd_len =
sprintf(cmdbuf, "fr%c%s", vfo_function, cmd_trm(rig));
/* set RX VFO */
retval =
ts2k_transaction(rig, cmdbuf, cmd_len, NULL, NULL);
if (retval != RIG_OK)
return -RIG_EINVAL;
// TX Active tuning
switch (vfo) {
case RIG_VFO_A:
case RIG_VFO_C:
case RIG_VFO_BA: // opposite of above
vfo_function = '0';
break;
case RIG_VFO_AB: // opposite of above
case RIG_VFO_B:
vfo_function = '1';
break;
case RIG_VFO_MEM_A:
case RIG_VFO_MEM_C: // FIXME: need to handle vfo/mem split
vfo_function = '2';
break;
case RIG_VFO_CALL_A:
case RIG_VFO_CALL_C:
vfo_function = '3';
break;
default:
rig_debug(RIG_DEBUG_ERR, __func__
": unsupported VFO %u\n",
vfo);
return -RIG_EINVAL;
}
/* set TX VFO */
cmdbuf[1] = 't';
// removing this causes split to not function!!!!
cmd_len =
sprintf(cmdbuf, "ft%c%s", vfo_function, cmd_trm(rig));
retval =
ts2k_transaction(rig, cmdbuf, cmd_len, NULL, NULL);
if (retval != RIG_OK)
return retval;
} else { // Check further for special modes not using "fr...;", "ft...;"
if(vfo & RIG_CTRL_SAT) { // test the SAT bit
retval = ts2k_sat_on(rig, vfo);
if (retval != RIG_OK)
return retval;
sat_on = 1;
} else {
rig_debug(RIG_DEBUG_ERR, __func__ \
": VFO not changed, only PTT/CTRL\n");
}
}
/*
* FIXME: some items like scan, satellite need checked and turned off here.
* I've got a simple kludge to turn SAT *off* but it wants to be done
* here. It's a bit expensive though and I'm trying to find a better
* way to do SAT as well as others. ts2k_sat_off() reads the current,
* sets it off, then writes it back so the user selected stuff don't
* change unexpectedly. Now, SAT won't get turned off if first turned
* on via the front panel. MEM and SCAN have similar quirks.
* --Dale
*/
return retval;
}
/* we just turn SAT on here. It'll take some doing to run it! */
int ts2k_sat_on(RIG *rig, vfo_t vfo)
{
char cmd[20], ack[20];
int cmdlen, acklen;
acklen = 20;
if(!(vfo & RIG_CTRL_SAT))
return -RIG_EINTERNAL; // All right. Who called us!?
// cmdlen = sprintf(cmd, "sa%07u;", 0); // Initial string to modify
acklen = ts2k_transaction(rig, "sa;", 3, ack, &acklen);
// Sat mode ON
ack[2] = '1'; // Everything below is *nice*, this is *required*
goto STest; // testing
/* cmd is already full of '0's, but we set them again explicitly */
// SAT_VFO or SAT_MEM?
if(vfo & RIG_CTRL_MEM)
ack[8] = '1'; // sat mem ch 0-9
else
ack[8] = '0'; // sat vfo
/* Main or Sub as uplink? */
// Note: if both are set, Main is still uplink
if(vfo & RIG_CTRL_MAIN) {
ack[4] = '0'; // sat main=uplink
} else if(vfo & RIG_CTRL_SUB) {
ack[4] = '1'; // sat sub=uplink
}
// FIXME: Add Sat Trace here!
// Trace REV
if(vfo & RIG_CTRL_REV)
ack[7] = '1'; // sat trace REV
else
ack[7] = '0';
// CTRL to main or sub?
if ((vfo & RIG_VFO_CTRL) && (vfo & RIG_CTRL_SUB))
ack[5] = '1'; // sat CTRL on sub
else
ack[5] = '0'; // sat CTRL on main
STest:
rig_debug(RIG_DEBUG_ERR, __func__ \
": sat = %s, vfo = 0x%X\n", cmd, vfo);
// of coure, this is *required* too!
return ts2k_transaction(rig, ack, acklen, NULL, NULL);
}
int ts2k_sat_off(RIG *rig, vfo_t vfo)
{
char cmd[20], ack[20];
int cmdlen, acklen, retval;
acklen = 10;
cmdlen = sprintf(cmd, "sa;");
retval = ts2k_transaction(rig, cmd, cmdlen, ack, &acklen);
if(retval != RIG_OK)
return retval;
ack[2] = '0';
cmdlen = 20;
return ts2k_transaction(rig, ack, acklen, NULL, NULL);
}
/*
* kenwood_get_vfo_if
* Assumes rig!=NULL, !vfo
*
* status: works perfect for implemented modes! --Dale
* code's getting a little ugly. okay, real ugly.
*/
int ts2k_get_vfo(RIG * rig, vfo_t * vfo)
{
char vfobuf[50], r_vfo;
char *ctrl_ptt;
int vfo_len, retval, tmp;
/*
* FIXME: if FR != FT && rcvr==main, the mode = split! --kd7eni
*/
// Check which receiver so VFO_C may be detected (PTT/CTRL)
ctrl_ptt = ts2k_get_ctrl(rig);
if (ctrl_ptt == NULL)
return -RIG_EINVAL;
// rig_debug(RIG_DEBUG_ERR, "ts2k_get_vfo: PTT/CTRL is %s\n", ctrl_ptt);
/* query RX VFO */
vfo_len = 50;
rig_debug(RIG_DEBUG_ERR, __func__
": sending fr; cmd/checking SAT. Expect TIMEDOUT if in SAT mode!\n");
retval = ts2k_transaction(rig, "fr;", 3, vfobuf, &vfo_len);
/* "fr;" fails in satellite mode; interesting... */
if (retval != RIG_OK) {
rig_debug(RIG_DEBUG_ERR, __func__": kenwood/ts2k.c\n"
"FIXME: ts2k.c,\tThis is timeout cannot be prevented.\n");
tmp = retval;
retval = ts2k_transaction(rig, "sa;", 3, vfobuf, &vfo_len);
if (retval == RIG_OK) {
rig_debug(RIG_DEBUG_ERR, __func__": SAT=%s\n", vfobuf);
if(vfobuf[2] == '1') {
/* yes, we're in satellite mode! */
*vfo = RIG_CTRL_SAT; // FIXME: set the rest!
/* TODO: write get_sat() and let it do the work */
return RIG_OK;
}
}
return tmp; // return original "fr;" error!
}
// rig_debug(RIG_DEBUG_ERR, __func__": checking fr; cmd.\n");
r_vfo = vfobuf[2];
//if (vfo_len != 4 || vfobuf[1] != 'R') {
if (vfobuf[1] != 'R') {
rig_debug(RIG_DEBUG_ERR, __func__
": unexpected answer %s, "
"len=%u\n", vfobuf, vfo_len);
return -RIG_ERJCTED;
}
rig_debug(RIG_DEBUG_ERR, __func__": sending ft; cmd.\n");
vfo_len = 50;
retval = ts2k_transaction(rig, "ft;", 3, vfobuf, &vfo_len);
if (retval != RIG_OK)
return retval;
rig_debug(RIG_DEBUG_ERR, __func__": checking ft; cmd.\n");
if (vfobuf[2] == r_vfo) { // check most common first
rig_debug(RIG_DEBUG_ERR, "ts2k_get_vfo: Non-Split.\n");
/* TODO: replace 0,1,2,.. constants by defines */
/* FIXME: return based on RIG_PTT_ON_???? or RIG_CTRL_ON_????
* may be different. We need to specify actual status.
* Right now we pretend things are simpler. --kd7eni
*/
switch (vfobuf[2]) {
case '0':
if (ctrl_ptt[3] == '0') // we use CTRL as Active Transceiver
*vfo = RIG_VFO_A;
else if (ctrl_ptt[3] == '1')
*vfo = RIG_VFO_C;
else { // "There be errors here!"
rig_debug(RIG_DEBUG_ERR,
"ts2k_get_vfo: VFO1 on erroneous xcvr %c\n",
vfobuf[2]);
return -RIG_EPROTO;
}
break;
case '1':
// only valid on Main--no checks required.
*vfo = RIG_VFO_B;
break;
case '2':
if (ctrl_ptt[3] == '0') // we use CTRL as Active Transceiver.
*vfo = RIG_VFO_MEM_A;
else if (ctrl_ptt[3] == '1')
*vfo = RIG_VFO_MEM_C;
else
return -RIG_EPROTO;
break;
case '3':
if (ctrl_ptt[3] == '0') // we use CTRL as current
*vfo = RIG_VFO_CALL_A;
else if (ctrl_ptt[3] == '1') // we use CTRL as current
*vfo = RIG_VFO_CALL_C;
else
return -RIG_EPROTO;
break;
default: // Different or newer rig types...
rig_debug(RIG_DEBUG_ERR,
"ts2k_get_vfo: unsupported VFO %c\n",
vfobuf[2]);
return -RIG_EPROTO;
} // end switch
} else { // end rx == tx; start split checks.
rig_debug(RIG_DEBUG_ERR, "ts2k_get_vfo: Split.\n");
if (r_vfo == '0' && vfobuf[2] == '1')
*vfo = RIG_VFO_AB;
else if (r_vfo == '1' && vfobuf[2] == '0')
*vfo = RIG_VFO_BA;
else { // FIXME: need vfo <--> mem split
rig_debug(RIG_DEBUG_ERR,
__func__
":FIXME: vfo<->mem split! -kd7eni!\n");
return -RIG_EPROTO;
}
}
return RIG_OK;
}
/*
* kenwood_set_freq
* Assumes rig!=NULL
*
* status: correctly sets FA, FB, FC --Dale
*/
int ts2k_set_freq(RIG * rig, vfo_t vfo, freq_t freq)
{
unsigned char freqbuf[16];
int freq_len, ack_len = 0, retval;
char vfo_letter;
/*
* better FIXME: vfo==RIG_VFO_CURR
*/
if (vfo == RIG_VFO_CURR) {
retval = ts2k_get_vfo(rig, &vfo);
if (retval != RIG_OK)
return retval;
}
switch (vfo) {
case RIG_VFO_A:
vfo_letter = 'A';
break;
case RIG_VFO_B:
vfo_letter = 'B';
break;
case RIG_VFO_C:
vfo_letter = 'C';
break;
default:
rig_debug(RIG_DEBUG_ERR,
"ts2k_set_freq: unsupported VFO %u\n", vfo);
return -RIG_EINVAL;
}
freq_len = sprintf(freqbuf, "F%c%011"PRIll";", vfo_letter, freq);
ack_len = 14;
retval = ts2k_transaction(rig, freqbuf, freq_len, NULL, NULL);
return retval;
}
/*
* kenwood_get_freq
* Assumes rig!=NULL, freq!=NULL
*/
int ts2k_get_freq(RIG * rig, vfo_t vfo, freq_t * freq)
{
unsigned char freqbuf[50];
unsigned char cmdbuf[4];
int cmd_len, freq_len, retval;
char vfo_letter;
/*
* FIXME: need to handle RIG_VFO_MEM, etc...
*/
if (vfo == RIG_VFO_CURR) {
retval = ts2k_get_vfo(rig, &vfo);
if (retval != RIG_OK)
return retval;
}
switch (vfo) {
case RIG_VFO_A:
vfo_letter = 'a';
break;
case RIG_VFO_B:
vfo_letter = 'b';
break;
case RIG_VFO_C:
vfo_letter = 'c';
break;
default:
rig_debug(RIG_DEBUG_ERR,
__func__": unsupported VFO %u\n", vfo);
return -RIG_EPROTO;
}
cmd_len = sprintf(cmdbuf, "f%c%s", vfo_letter, cmd_trm(rig));
freq_len = 15;
retval =
ts2k_transaction(rig, cmdbuf, cmd_len, freqbuf, &freq_len);
//rig_debug(RIG_DEBUG_ERR,"__func__: received %s\n", cmdbuf);
if (retval != RIG_OK)
return retval;
//if (freq_len != 14 || freqbuf[0] != 'F') {
if (freqbuf[0] != 'F') {
rig_debug(RIG_DEBUG_ERR,
__func__": unexpected answer '%s', "
"len=%u\n", freqbuf, freq_len);
return -RIG_ERJCTED;
}
sscanf(freqbuf + 2, "%"SCNll, freq);
return RIG_OK;
}
/*
* kenwood_set_mode
* Assumes rig!=NULL
*/
int ts2k_set_mode(RIG * rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
unsigned char mdbuf[16], ackbuf[16];
int mdbuf_len, ack_len = 0, kmode, retval;
switch (mode) {
case RIG_MODE_CW:
kmode = MD_CW;
break;
case RIG_MODE_USB:
kmode = MD_USB;
break;
case RIG_MODE_LSB:
kmode = MD_LSB;
break;
case RIG_MODE_FM:
kmode = MD_FM;
break;
case RIG_MODE_AM:
kmode = MD_AM;
break;
case RIG_MODE_RTTY:
kmode = MD_FSK;
break;
default:
rig_debug(RIG_DEBUG_ERR, "ts2k_set_mode: "
"unsupported mode %u\n", mode);
return -RIG_EINVAL;
}
mdbuf_len = sprintf(mdbuf, "MD%c;", kmode);
ack_len = 16;
rig_debug(RIG_DEBUG_ERR, "ts2k_set_mode: sending %s\n", mdbuf);
retval = ts2k_transaction(rig, mdbuf, mdbuf_len, NULL, NULL);
return retval;
}
/*
* kenwood_get_mode
* Assumes rig!=NULL, mode!=NULL
*/
int ts2k_get_mode(RIG * rig, vfo_t vfo, rmode_t * mode, pbwidth_t * width)
{
unsigned char modebuf[50];
int mode_len, retval;
mode_len = 50;
retval = ts2k_transaction(rig, "MD;", 3, modebuf, &mode_len);
if (retval != RIG_OK)
return retval;
if (mode_len != 4 || modebuf[1] != 'D') {
rig_debug(RIG_DEBUG_ERR,
"ts2k_get_mode: unexpected answer, len=%u\n",
mode_len);
return -RIG_ERJCTED;
}
*width = RIG_PASSBAND_NORMAL; /* FIXME */
switch (modebuf[2]) {
case MD_CW:
*mode = RIG_MODE_CW;
break;
case MD_USB:
*mode = RIG_MODE_USB;
break;
case MD_LSB:
*mode = RIG_MODE_LSB;
break;
case MD_FM:
*mode = RIG_MODE_FM;
break;
case MD_AM:
*mode = RIG_MODE_AM;
break;
case MD_FSK:
*mode = RIG_MODE_RTTY;
break;
#ifdef RIG_MODE_CWR
case MD_CWR:
*mode = RIG_MODE_CWR;
break;
#endif
#ifdef RIG_MODE_RTTYR
case MD_FSKR:
*mode = RIG_MODE_RTTY;
break;
#endif
case MD_NONE:
*mode = RIG_MODE_NONE;
break;
default:
rig_debug(RIG_DEBUG_ERR, "ts2k_get_mode: "
"unsupported mode '%c'\n", modebuf[2]);
return -RIG_EINVAL;
}
return RIG_OK;
}
/* added a whole buch of stuff --Dale */
int ts2k_set_level(RIG * rig, vfo_t vfo, setting_t level, value_t val)
{
unsigned char levelbuf[16], ackbuf[16], ctrl;
char *dc; // to be replaced.
// char dc[10]; // use this when ts2k_get_ctrl() is fixed.
// int dc_len; // use this when ts2k_get_ctrl() is fixed.
int level_len, ack_len = 0, retval, reply;
int ts2k_val;
if (RIG_LEVEL_IS_FLOAT(level))
ts2k_val = val.f * 255;
else
ts2k_val = val.i;
/* Several commands need to know status of CTRL */
// dc_len = 10; // these are to be used when ts2k_get_ctrl() is changed.
// if( ts2k_get_ctrl(rig, dc, 10) != RIG_OK)
// return -RIG_EINVAL;
// we shouldn't really change dc; its a static and will get changed.
dc = ts2k_get_ctrl(rig); // will get fixed
// m = dc[2]; s = dc[3]; // set defaults
// FIXME: Just handles simple stuff RIG_VFO_CURR,VFOA,VFOB,VFOC; *may* work as intended.
ctrl = '0'; // Assume Main
if(vfo & RIG_CTRL_SUB) // Change only if sub (bitwise, not logical)
ctrl = '1';
// assume no replies
reply = 0;
switch (level) {
case RIG_LEVEL_RFPOWER:
level_len = sprintf(levelbuf, "pc%03d;", ts2k_val);
break;
case RIG_LEVEL_AF: // I call this volume. :)
level_len = sprintf(levelbuf, "ag%c%03u;", ctrl, ts2k_val);
break;
case RIG_LEVEL_RF:
level_len = sprintf(levelbuf, "rg%03d;", ts2k_val);
break;
case RIG_LEVEL_SQL: // fixed: uses main/sub --Dale
level_len = sprintf(levelbuf, "sq%c%03u;", ctrl, ts2k_val);
break;
/* I added the following levels --Dale */
case RIG_LEVEL_PREAMP:
level_len = sprintf(levelbuf, "pa%c;", (ts2k_val==0)? '0' : '1');
break;
case RIG_LEVEL_ATT:
if(ts2k_val<1 || ts2k_val>2) // only 1 or 2, 0=read
return -RIG_EINVAL;
level_len = sprintf(levelbuf, "an%01u;", ts2k_val);
break;
case RIG_LEVEL_NR:
if(ts2k_val<0 || ts2k_val>2) // only 1 or 2, 0=read
return -RIG_EINVAL;
level_len = sprintf(levelbuf, "nr%01u;", ts2k_val);
break;
/* FIXME: FM mic gain is low/mid/high; cmd="ex0410000n;" 0=low --Dale */
case RIG_LEVEL_MICGAIN:
level_len = sprintf(levelbuf, "mg%03u;", (ts2k_val>100)? 100 : ts2k_val);
break;
/* no rig error on invalid values */
case RIG_LEVEL_KEYSPD:
if(ts2k_val<10 || ts2k_val>60) // only 1 or 2, 0=read
return -RIG_EINVAL;
level_len = sprintf(levelbuf, "ks%03u;", ts2k_val);
break;
case RIG_LEVEL_NOTCHF: // actually, this is autonotch--same thing?
level_len = sprintf(levelbuf, "al%03u;", (ts2k_val>4)? 4 : ts2k_val);
break;
case RIG_LEVEL_AGC:
level_len = sprintf(levelbuf, "gt%03u;", (ts2k_val>20)? 20 : ts2k_val);
break;
case RIG_LEVEL_BKINDL: // 0-1000ms in 50ms steps; this'll be good 'nuff.
level_len = sprintf(levelbuf, "sd%04u;",(int)((float) ts2k_val*1000.0/255.0));
break;
case RIG_LEVEL_VOXGAIN:
level_len = sprintf(levelbuf, "vg%03u;",(ts2k_val>9)? 9 : ts2k_val);
// alternate
// level_len = sprintf(levelbuf, "vg%03u;",(int)((float) ts2k_val*9.0/255.0));
break;
// case RIG_LEVEL_VOX: // header file declares these the same
case RIG_LEVEL_VOXDELAY:
level_len = sprintf(levelbuf, "vg%03u;",(int)((float) ts2k_val*3000.0/255.0));
break;
// vox on/off
// level_len = sprintf(levelbuf, "vx%c;", (ts2k_val==0)? '0' : '1');
// break;
/* Check unsupported just so we can complain if one is found. :) */
case RIG_LEVEL_APF:
/* readonly */
case RIG_LEVEL_SWR:
case RIG_LEVEL_ALC:
case RIG_LEVEL_STRENGTH:
return -RIG_EINTERNAL; // and complain loud!
/* not currently implemented */
case RIG_LEVEL_METER: // readonly + needs rechecked.
case RIG_LEVEL_PBT_IN: // nnn
case RIG_LEVEL_PBT_OUT: // NNN; "plnnnNNN;"
case RIG_LEVEL_IF: // hmmmm....
case RIG_LEVEL_CWPITCH: // "ex0310000n;" and a fair bit of programming...
case RIG_LEVEL_COMP: // available?, processor's not the same is it?
case RIG_LEVEL_BALANCE: // AF R/L balance? See "ex01600002;" for similar(?)
case RIG_LEVEL_SQLSTAT: // need more info; avail?
return -RIG_ENIMPL;
default:
rig_debug(RIG_DEBUG_ERR,
"Unsupported set_level %u", level);
return -RIG_EINVAL;
}
// The following might make a nifty macro --Dale
ack_len = reply? 16 : 0; // This'd work by itself wouldn't it? --Dale
retval = ts2k_transaction(rig, levelbuf, level_len,
reply? ackbuf : NULL, reply? &ack_len : NULL);
if (retval != RIG_OK)
return retval;
return RIG_OK;
}
/*
* assumes f!=NULL
*/
static int
get_ts2k_level(RIG * rig, const char *cmd, int cmd_len, float *f)
{
unsigned char lvlbuf[50];
int lvl_len, retval;
int lvl;
lvl_len = 50;
retval = ts2k_transaction(rig, cmd, cmd_len, lvlbuf, &lvl_len);
if (retval != RIG_OK)
return retval;
if (lvl_len != 6) {
rig_debug(RIG_DEBUG_ERR,
"ts2k_get_level: wrong answer len=%u\n",
lvl_len);
return -RIG_ERJCTED;
}
/*
* 000..255
*/
sscanf(lvlbuf + 2, "%u", &lvl);
*f = (float) lvl / 255.0;
return RIG_OK;
};
/*
* kenwood_get_level
* Assumes rig!=NULL, val!=NULL
*/
int ts2k_get_level(RIG * rig, vfo_t vfo, setting_t level, value_t * val)
{
unsigned char lvlbuf[50];
int lvl_len, retval;
int lvl;
int i;
lvl_len = 50;
/* Optimize:
* sort the switch cases with the most frequent first
*/
switch (level) {
case RIG_LEVEL_STRENGTH:
// fixme: "sm0;" VFO must be specified! --kd7eni
retval = ts2k_transaction(rig, "SM;", 3, lvlbuf, &lvl_len);
if (retval != RIG_OK)
return retval;
if (lvl_len != 7 || lvlbuf[1] != 'M') {
rig_debug(RIG_DEBUG_ERR, "ts2k_get_level: "
"wrong answer len=%u\n", lvl_len);
return -RIG_ERJCTED;
}
/*
* Frontend expects:
* -54 = S0
* 0 = S9
*/
sscanf(lvlbuf + 2, "%u", &val->i);
val->i = (val->i * 4) - 54;
break;
case RIG_LEVEL_SQLSTAT:
return -RIG_ENIMPL; /* get_dcd ? */
case RIG_LEVEL_PREAMP:
return -RIG_ENIMPL;
case RIG_LEVEL_ATT:
retval = ts2k_transaction(rig, "RA;", 3, lvlbuf, &lvl_len);
if (retval != RIG_OK)
return retval;
if (lvl_len != 5) {
rig_debug(RIG_DEBUG_ERR, "ts2k_get_level: "
"unexpected answer len=%u\n", lvl_len);
return -RIG_ERJCTED;
}
sscanf(lvlbuf + 2, "%u", &lvl);
if (lvl == 0) {
val->i = 0;
} else {
for (i = 0; i < lvl && i < MAXDBLSTSIZ; i++)
if (rig->state.attenuator[i] == 0) {
rig_debug(RIG_DEBUG_ERR,
"ts2k_get_level: "
"unexpected att level %u\n",
lvl);
return -RIG_EPROTO;
}
if (i != lvl)
return -RIG_EINTERNAL;
val->i = rig->state.attenuator[i - 1];
}
break;
case RIG_LEVEL_RFPOWER:
return get_ts2k_level(rig, "PC;", 3, &val->f);
case RIG_LEVEL_AF:
return get_ts2k_level(rig, "AG;", 3, &val->f);
case RIG_LEVEL_RF:
return get_ts2k_level(rig, "RG;", 3, &val->f);
case RIG_LEVEL_SQL:
return get_ts2k_level(rig, "SQ;", 3, &val->f);
case RIG_LEVEL_MICGAIN:
return get_ts2k_level(rig, "MG;", 3, &val->f);
case RIG_LEVEL_AGC:
return get_ts2k_level(rig, "GT;", 3, &val->f);
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,
"Unsupported get_level %u", level);
return -RIG_EINVAL;
}
return RIG_OK;
}
int ts2k_set_func(RIG * rig, vfo_t vfo, setting_t func, int status)
{
unsigned char fctbuf[16], ackbuf[16];
int fct_len, ack_len = 16;
/* Optimize:
* sort the switch cases with the most frequent first
*/
switch (func) {
case RIG_FUNC_NB:
fct_len =
sprintf(fctbuf, "NB%c;",
status == RIG_FUNC_NB ? '0' : '1');
return ts2k_transaction(rig, fctbuf, fct_len, NULL, NULL);
case RIG_FUNC_ABM:
fct_len =
sprintf(fctbuf, "AM%c;",
status == RIG_FUNC_ABM ? '0' : '1');
return ts2k_transaction(rig, fctbuf, fct_len, NULL, NULL);
case RIG_FUNC_COMP:
fct_len =
sprintf(fctbuf, "PR%c;",
status == RIG_FUNC_COMP ? '0' : '1');
return ts2k_transaction(rig, fctbuf, fct_len, NULL, NULL);
case RIG_FUNC_TONE:
fct_len =
sprintf(fctbuf, "TO%c;",
status == RIG_FUNC_TONE ? '0' : '1');
return ts2k_transaction(rig, fctbuf, fct_len, NULL, NULL);
case RIG_FUNC_TSQL:
// fixme: see ts2000.doc and follow the proceedure! --kdeni
// rigbug!
fct_len =
sprintf(fctbuf, "CT%c;",
status == RIG_FUNC_TSQL ? '0' : '1');
return ts2k_transaction(rig, fctbuf, fct_len,
ackbuf, &ack_len);
case RIG_FUNC_VOX:
fct_len =
sprintf(fctbuf, "VX%c;",
status == RIG_FUNC_VOX ? '0' : '1');
return ts2k_transaction(rig, fctbuf, fct_len, NULL, NULL);
case RIG_FUNC_NR:
fct_len =
sprintf(fctbuf, "NR%c;",
status == RIG_FUNC_NR ? '0' : '1');
return ts2k_transaction(rig, fctbuf, fct_len, NULL, NULL);
case RIG_FUNC_BC:
fct_len =
sprintf(fctbuf, "BC%c;",
status == RIG_FUNC_BC ? '0' : '1');
return ts2k_transaction(rig, fctbuf, fct_len, NULL, NULL);
case RIG_FUNC_ANF:
fct_len =
sprintf(fctbuf, "NT%c;",
status == RIG_FUNC_ANF ? '0' : '1');
return ts2k_transaction(rig, fctbuf, fct_len, NULL, NULL);
case RIG_FUNC_LOCK:
fct_len =
sprintf(fctbuf, "LK%c0;",
status == RIG_FUNC_LOCK ? '0' : '1');
return ts2k_transaction(rig, fctbuf, fct_len, NULL, NULL);
default:
rig_debug(RIG_DEBUG_ERR, "Unsupported set_func %#x", func);
return -RIG_EINVAL;
}
return RIG_OK;
}
/*
* assumes status!=NULL
* works for any 'format 1' command
*/
static int
get_ts2k_func(RIG * rig, const char *cmd, int cmd_len, int *status)
{
unsigned char fctbuf[50];
int fct_len, retval;
fct_len = 50;
retval = ts2k_transaction(rig, cmd, cmd_len, fctbuf, &fct_len);
if (retval != RIG_OK)
return retval;
if (fct_len != 4) {
rig_debug(RIG_DEBUG_ERR,
__func__": wrong answer len=%u\n", fct_len);
return -RIG_ERJCTED;
}
*status = fctbuf[2] == '0' ? 0 : 1;
return RIG_OK;
};
/*
* kenwood_get_func
* Assumes rig!=NULL, val!=NULL
*/
int ts2k_get_func(RIG * rig, vfo_t vfo, setting_t func, int *status)
{
unsigned char fctbuf[50];
int fct_len, retval;
fct_len = 50;
/* Optimize:
* sort the switch cases with the most frequent first
*/
switch (func) {
case RIG_FUNC_FAGC:
retval = ts2k_transaction(rig, "GT;", 3, fctbuf, &fct_len);
if (retval != RIG_OK)
return retval;
if (fct_len != 6) {
rig_debug(RIG_DEBUG_ERR, "ts2k_get_func: "
"wrong answer len=%u\n", fct_len);
return -RIG_ERJCTED;
}
*status = fctbuf[4] != '4' ? 1 : 0;
break;
case RIG_FUNC_NB:
return get_ts2k_func(rig, "NB;", 3, status);
case RIG_FUNC_ABM:
return get_ts2k_func(rig, "AM;", 3, status);
case RIG_FUNC_COMP:
return get_ts2k_func(rig, "PR;", 3, status);
case RIG_FUNC_TONE:
return get_ts2k_func(rig, "TO;", 3, status);
case RIG_FUNC_TSQL:
return get_ts2k_func(rig, "CT;", 3, status);
case RIG_FUNC_VOX:
return get_ts2k_func(rig, "VX;", 3, status);
case RIG_FUNC_NR:
return get_ts2k_func(rig, "NR;", 3, status);
/* FIXME on TS2000 */
case RIG_FUNC_BC:
return get_ts2k_func(rig, "BC;", 3, status);
case RIG_FUNC_ANF:
return get_ts2k_func(rig, "NT;", 3, status);
case RIG_FUNC_LOCK:
return get_ts2k_func(rig, "LK;", 3, status);
default:
rig_debug(RIG_DEBUG_ERR, "Unsupported get_func %#x", func);
return -RIG_EINVAL;
}
return RIG_OK;
}
/*
* kenwood_set_ctcss_tone
* Assumes rig!=NULL, rig->caps->ctcss_list != NULL
*
* Warning! This is untested stuff! May work at least on TS-870S
* Please owners report to me <fillods@users.sourceforge.net>, thanks. --SF
*
* TODO: TS-2000 uses CN/CT
* ex057 menu is AutoPower off for TS-2000 --kd7eni
*/
int ts2k_set_ctcss_tone(RIG * rig, vfo_t vfo, tone_t tone)
{
return ts2k_set_Tones(rig, vfo, tone, (char)'c');
}
int ts2k_set_tone(RIG * rig, vfo_t vfo, tone_t tone)
{
return ts2k_set_Tones(rig, vfo, tone, (char)'t');
}
int ts2k_set_Tones(RIG * rig, vfo_t vfo, tone_t tone, const char ct)
{
const struct rig_caps *caps;
unsigned char tonebuf[16], ackbuf[16];
int tone_len, ack_len = 0;
int i;
caps = rig->caps;
/* TODO: replace 200 by something like RIGTONEMAX */
for (i = 0; ts2k_ctcss_list[i] != 0 && i < 38; i++) {
if ((ts2k_ctcss_list[i] >= tone)
&& (ts2k_ctcss_list[i-1] < tone)) // at least get close
break;
}
if (ts2k_ctcss_list[i-1] == tone)
i--;
if (ts2k_ctcss_list[i] > tone)
return -RIG_EINVAL;
tone_len = sprintf(tonebuf, "%cn%02u;", ct, i+1);
ack_len = 16;
return ts2k_transaction(rig, tonebuf, tone_len, NULL, NULL);
rig_debug(RIG_DEBUG_ERR, __func__": sent %s", tonebuf);
}
/*
* kenwood_get_ctcss_tone
* Assumes rig!=NULL, rig->state.priv!=NULL
*/
int ts2k_get_ctcss_tone(RIG * rig, vfo_t vfo, tone_t * tone)
{
return ts2k_get_Tones(rig, vfo, tone, "cn;");
}
int ts2k_get_tone(RIG * rig, vfo_t vfo, tone_t * tone)
{
return ts2k_get_Tones(rig, vfo, tone, "tn;");
}
int ts2k_get_Tones(RIG * rig, vfo_t vfo, tone_t * tone, const char *ct)
{
const struct rig_caps *caps;
unsigned char tonebuf[10];
int tone_len, i, retval;
unsigned int tone_idx;
caps = rig->caps;
tone_len = 10;
retval = ts2k_transaction(rig, ct, 3, tonebuf, &tone_len);
if (retval != RIG_OK)
return retval;
if (tone_len != 5) {
rig_debug(RIG_DEBUG_ERR,
__func__": unexpected reply "
"'%s', len=%u\n", tonebuf, tone_len);
return -RIG_ERJCTED;
}
sscanf(tonebuf + 2, "%u", (int *) &tone_idx);
if (tone_idx == 0) {
rig_debug(RIG_DEBUG_ERR,
__func__": Unexpected Tone "
"no (%04d)\n", tone_idx);
return -RIG_EPROTO;
}
/* check this tone exists. That's better than nothing. */
for (i = 0; i < tone_idx; i++) {
if (caps->ctcss_list[i] == 0) {
rig_debug(RIG_DEBUG_ERR,
__func__": Tone NG "
"(%04d)\n", tone_idx);
return -RIG_EPROTO;
}
}
*tone = caps->ctcss_list[tone_idx - 1];
return RIG_OK;
}
/*
* kenwood_get_ptt
* Assumes rig!=NULL, ptt!=NULL
*/
int ts2k_get_ptt(RIG * rig, vfo_t vfo, ptt_t * ptt)
{
unsigned char infobuf[50];
int info_len, retval;
info_len = 50;
retval = ts2k_transaction(rig, "IF;", 3, infobuf, &info_len);
if (retval != RIG_OK)
return retval;
if (info_len != 38 || infobuf[1] != 'F') {
rig_debug(RIG_DEBUG_ERR,
"ts2k_get_ptt: wrong answer len=%u\n", info_len);
return -RIG_ERJCTED;
}
*ptt = infobuf[28] == '0' ? RIG_PTT_OFF : RIG_PTT_ON;
return RIG_OK;
}
/*
* kenwood_set_ptt
* Assumes rig!=NULL
*/
int ts2k_set_ptt(RIG * rig, vfo_t vfo, ptt_t ptt)
{
unsigned char ackbuf[16];
int ack_len = 16;
return ts2k_transaction(rig,
ptt ==
RIG_PTT_ON ? "TX;" : "RX;", 3, NULL, NULL);
}
/*
* kenwood_get_dcd
* Assumes rig!=NULL, dcd!=NULL
*/
int ts2k_get_dcd(RIG * rig, vfo_t vfo, dcd_t * dcd)
{
unsigned char busybuf[50];
int busy_len, retval;
busy_len = 50;
retval = ts2k_transaction(rig, "BY;", 3, busybuf, &busy_len);
if (retval != RIG_OK)
return retval;
if (busy_len != 4) {
rig_debug(RIG_DEBUG_ERR,
"ts2k_get_dcd: wrong answer len=%u\n", busy_len);
return -RIG_ERJCTED;
}
*dcd = (busybuf[2] == 0x01) ? RIG_DCD_ON : RIG_DCD_OFF;
return RIG_OK;
}
/*
* kenwood_set_trn
* Assumes rig!=NULL
*/
int ts2k_set_trn(RIG * rig, int trn)
{
unsigned char trnbuf[16], ackbuf[16];
int trn_len, ack_len = 16;
/* changed to TS-2000 --D.E. kd7eni */
trn_len = sprintf(trnbuf, "AI%c;", trn == RIG_TRN_RIG ? '2' : '0');
return ts2k_transaction(rig, trnbuf, trn_len, NULL, NULL);
// No reply on "ai2;"--how quaint!
}
/*
* kenwood_get_trn
* Assumes rig!=NULL, trn!=NULL
*/ int ts2k_get_trn(RIG * rig, int *trn)
{
unsigned char trnbuf[50];
int trn_len, retval;
trn_len = 50;
retval = ts2k_transaction(rig, "AI;", 3, trnbuf, &trn_len);
if (retval != RIG_OK)
return retval;
if (trn_len != 4) {
rig_debug(RIG_DEBUG_ERR,
"ts2k_get_trn: wrong answer" "len=%u\n",
trn_len);
return -RIG_ERJCTED;
}
*trn = trnbuf[2] != '0' ? RIG_TRN_RIG : RIG_TRN_OFF;
return RIG_OK;
}
/*
* kenwood_set_powerstat
* Assumes rig!=NULL
*/
int ts2k_set_powerstat(RIG * rig, powerstat_t status)
{
unsigned char pwrbuf[16], ackbuf[16];
int pwr_len, ack_len = 16;
pwr_len =
sprintf(pwrbuf, "PS%c;", status == RIG_POWER_ON ? '1' : '0');
return ts2k_transaction(rig, pwrbuf, pwr_len, ackbuf, &ack_len);
}
/*
* kenwood_get_powerstat
* Assumes rig!=NULL, trn!=NULL
*/
int ts2k_get_powerstat(RIG * rig, powerstat_t * status)
{
unsigned char pwrbuf[50];
int pwr_len = 50, retval;
// No reply when powered off, 1=power on. Geez!
retval = ts2k_transaction(rig, "PS;", 3, pwrbuf, &pwr_len);
if (retval != RIG_OK)
return retval;
if (pwr_len != 4) {
rig_debug(RIG_DEBUG_ERR,
"ts2k_get_powerstat: wrong answer "
"len=%u\n", pwr_len);
return -RIG_ERJCTED;
}
*status = pwrbuf[2] == '0' ? RIG_POWER_OFF : RIG_POWER_ON;
return RIG_OK;
}
/*
* kenwood_reset
* Assumes rig!=NULL
*/
int ts2k_reset(RIG * rig, reset_t reset)
{
unsigned char rstbuf[16], ackbuf[16];
int rst_len, ack_len = 16;
char rst;
switch (reset) {
case RIG_RESET_VFO:
rst = '1';
break;
case RIG_RESET_MASTER:
rst = '2';
break;
default:
rig_debug(RIG_DEBUG_ERR,
"ts2k_reset: unsupported reset %u\n", reset);
return -RIG_EINVAL;
}
rst_len = sprintf(rstbuf, "SR%c;", rst);
// Largely untested! ;) --kd7eni
return ts2k_transaction(rig, rstbuf, rst_len, ackbuf, &ack_len);
}
/*
* kenwood_send_morse
* Assumes rig!=NULL
*/
int ts2k_send_morse(RIG * rig, vfo_t vfo, const char *msg)
{
unsigned char morsebuf[30], ackbuf[16];
int morse_len, ack_len = 0;
int msg_len, buff_len, retval;
const char *p;
p = msg;
msg_len = strlen(msg);
while (msg_len > 0) {
/*
* TODO: check with "KY;" if char buffer is available.
* if not, sleep.
*/
buff_len = msg_len > 24 ? 24 : msg_len;
strcpy(morsebuf, "KY ");
strncat(morsebuf, p, buff_len);
strcat(morsebuf, ";");
morse_len = 4 + buff_len;
ack_len = 16;
retval =
ts2k_transaction(rig, morsebuf, morse_len,
ackbuf, &ack_len);
if (retval != RIG_OK)
return retval;
msg_len -= buff_len;
p += buff_len;
}
return RIG_OK;
}
/*
* kenwood_vfo_op
* Assumes rig!=NULL
*/
int ts2k_vfo_op(RIG * rig, vfo_t vfo, vfo_op_t op)
{
unsigned char *cmd, ackbuf[16];
int ack_len = 0;
switch (op) {
case RIG_OP_UP:
cmd = "UP;";
break;
case RIG_OP_DOWN:
cmd = "DN;";
break;
case RIG_OP_BAND_UP:
cmd = "BD;";
break;
case RIG_OP_BAND_DOWN:
cmd = "BU;";
break;
default:
rig_debug(RIG_DEBUG_ERR,
"ts2k_vfo_op: unsupported op %#x\n", op);
return -RIG_EINVAL;
}
ack_len = 16;
return ts2k_transaction(rig, cmd, 3, NULL, NULL);
}
/*
* kenwood_set_mem
* Assumes rig!=NULL
*/
int ts2k_set_mem(RIG * rig, vfo_t vfo, int ch)
{
unsigned char membuf[16], ackbuf[16];
int mem_len, ack_len = 16;
/*
* "MCbmm;"
* where b is the bank number, mm the memory number.
* b can be a space ( *not*! manual wrong. --kd7eni
*/
mem_len = sprintf(membuf, "MC%03d;", ch);
return ts2k_transaction(rig, membuf, mem_len, NULL, NULL);
}
/*
* kenwood_get_mem
* Assumes rig!=NULL
*/ int ts2k_get_mem(RIG * rig, vfo_t vfo, int *ch)
{
unsigned char membuf[50];
int retval, mem_len;
/*
* "MCbmm;"
* where b is the bank number, mm the memory number.
* b can be a space (*not* --kd7eni)
*/
mem_len = 10;
retval = ts2k_transaction(rig, "MC;", 3, membuf, &mem_len);
if (retval != RIG_OK)
return retval;
if (mem_len != 6) {
rig_debug(RIG_DEBUG_ERR,
"ts2k_get_mem: wrong answer " "len=%u\n",
mem_len);
return -RIG_ERJCTED;
}
membuf[5] = '\0';
*ch = atoi(membuf + 2);
return RIG_OK;
}
/*
* kenwood_get_info
* supposed to work only for TS2000...
* Assumes rig!=NULL
*/
const char *ts2k_get_info(RIG * rig)
{
unsigned char firmbuf[50];
int firm_len, retval;
firm_len = 50;
retval = ts2k_transaction(rig, "TY;", 3, firmbuf, &firm_len);
if (retval != RIG_OK)
return NULL;
if (firm_len != 6) {
rig_debug(RIG_DEBUG_ERR,
"ts2k_get_info: wrong answer len=%u\n",
firm_len);
return NULL;
}
switch (firmbuf[4]) {
case '0':
return "Firmware: Overseas type";
case '1':
return "Firmware: Japanese 100W type";
case '2':
return "Firmware: Japanese 20W type";
default:
return "Firmware: unknown";
}
}
#define IDBUFSZ 16
/*
* probe_kenwood
*/
rig_model_t probe_ts2k(port_t * port)
{
unsigned char idbuf[IDBUFSZ];
int id_len, i, k_id;
int retval;
if (!port)
return RIG_MODEL_NONE;
port->write_delay = port->post_write_delay = 0;
port->timeout = 50;
port->retry = 1;
retval = serial_open(port);
if (retval != RIG_OK)
return RIG_MODEL_NONE;
retval = write_block(port, "ID;", 3);
id_len = read_string(port, idbuf, IDBUFSZ, EOM_KEN EOM_TH, 2);
close(port->fd);
if (retval != RIG_OK)
return RIG_MODEL_NONE;
/*
* reply should be something like 'IDxxx;'
*/
if (id_len != 5 && id_len != 6) {
idbuf[7] = '\0';
rig_debug(RIG_DEBUG_VERBOSE,
"probe_ts2k: protocol error,"
" expected %u, received %u: %s\n", 6,
id_len, idbuf);
return RIG_MODEL_NONE;
}
/* first, try ID string */
for (i = 0; ts2k_id_string_list[i].model != RIG_MODEL_NONE; i++) {
if (!strncmp(ts2k_id_string_list[i].id, idbuf + 2, 16)) {
rig_debug(RIG_DEBUG_VERBOSE,
"probe_ts2k: " "found %s\n", idbuf + 2);
return ts2k_id_string_list[i].model;
}
}
/* then, try ID numbers */
k_id = atoi(idbuf + 2);
for (i = 0; ts2k_id_list[i].model != RIG_MODEL_NONE; i++) {
if (ts2k_id_list[i].id == k_id) {
rig_debug(RIG_DEBUG_VERBOSE,
"probe_ts2k: " "found %03d\n", k_id);
return ts2k_id_list[i].model;
}
}
/*
* not found in known table....
* update ts2k_id_list[]!
*/
rig_debug(RIG_DEBUG_WARN,
"probe_ts2k: found unknown device "
"with ID %03d, please report to Hamlib "
"developers.\n", k_id);
return RIG_MODEL_NONE;
}
/* kenwood_init
*
* Basically, it sets up *priv
* REM: serial port is already open (rig->state.rigport.fd)
*/
int ts2k_init(RIG * rig)
{
const struct rig_caps *caps;
const struct ts2k_priv_caps *priv_caps;
rig_debug(RIG_DEBUG_TRACE, __func__ ": called\n");
if (!rig || !rig->caps)
return -RIG_EINVAL;
caps = rig->caps;
if (!caps->priv)
return -RIG_ECONF;
priv_caps = (const struct ts2k_priv_caps *) caps->priv;
#if 0 /* No private data for Kenwood backends */
priv = (struct ts2k_priv_data *)
malloc(sizeof(struct ts2k_priv_data));
if (!priv) {
/* whoops! memory shortage! */
return -RIG_ENOMEM;
}
rig->state.priv = (void *) priv;
/* Assign default values */
priv->dummy = -1; // placeholder for real entries.
#endif
return RIG_OK;
}
/* kenwood_cleanup
* the serial port is closed by the frontend
*/
int ts2k_cleanup(RIG * rig)
{
rig_debug(RIG_DEBUG_TRACE, __func__ ": called\n");
if (!rig)
return -RIG_EINVAL;
if (rig->state.priv)
free(rig->state.priv);
rig->state.priv = NULL;
return RIG_OK;
}
/*
* initrigs_kenwood is called by rig_backend_load
*/ int initrigs_ts2k(void *be_handle)
{
rig_debug(RIG_DEBUG_VERBOSE, "ts2k: _init called\n");
rig_register(&ts950sdx_caps);
rig_register(&ts50s_caps);
rig_register(&ts450s_caps);
rig_register(&ts570d_caps);
rig_register(&ts570s_caps);
rig_register(&ts790_caps);
rig_register(&ts850_caps);
rig_register(&ts870s_caps);
rig_register(&ts2000_caps);
rig_register(&thd7a_caps);
rig_register(&thf7e_caps);
return RIG_OK;
}
/*****************************************************************************
Added the following functions.
(C) Copyright 2002 by Dale E. Edmons. All rights Reserved.
License: Identical to all other Hamlib code.
*****************************************************************************/
#define CHKERR(c) if((c) != RIG_OK) return c
#define STUFF(c) int retval, acklen=(c); char ack[c]
//#define STUFF(c) static int retval, acklen=(c); static char ack[c]
// The following two are expensive but convenient!
int ncpy(char *tmp, char *src, int cnt)
{
strncpy(tmp, src, cnt);
tmp[cnt] = '\0';
return RIG_OK;
}
int int_n(char *tmp, char *src, const int cnt)
{
ncpy(tmp, src, cnt);
return atoi(tmp);
}
/*
* ts2k_get_ctrl() ts2000 transceiver check. Tests and returns the value of the current
* PTT/CTRL (using "dc;") for main and sub transceivers. The settings are:
*
* PTT __ __ CTRL '0' = main; '1' = sub
* \ /
* "dc00;" PTT && CTRL both on main
* "dc01;" PTT on main; CTRL on sub
* "dc10;" PTT on sub; CTRL both on main
* "dc11;" PTT && CTRL both on sub
*/
//int ts2k_get_ctrl(RIG * rig, char *dc_buf, int dc_len) // use this when static removed.
char *ts2k_get_ctrl(RIG * rig)
{
// FIXME: I guess this shouldn't be static for re-entrancy --Dale
static char dc_buf[16];
static int dc_len;
static int retval;
dc_len = 16;
// rig_debug(RIG_DEBUG_VERBOSE, "ts2k_get_ctrl: getting PTT/CTRL bytes\n");
retval = ts2k_transaction(rig, "dc;", 3, dc_buf, &dc_len);
if (retval != RIG_OK) {
rig_debug(RIG_DEBUG_VERBOSE,
"ts2k_get_ctrl:error: retval=%u, dc_buf=%s\n",
retval, dc_buf);
return NULL;
}
// rig_debug(RIG_DEBUG_VERBOSE, "ts2k_get_ctrl: returning %u PTT/CTRL bytes\n", dc_len);
// return RIG_OK; // use this when static variable removed and all other code changed.
return dc_buf;
}
/* NOTE: PTT/CTRL enable is set only if ptt != 0 (or ctrl) */
int ts2k_set_ctrl(RIG * rig, int ptt, int ctrl)
{
STUFF(10);
char *buf;
int buflen = 10;
buf = ts2k_get_ctrl(rig);
if(buf==NULL) {
rig_debug(RIG_DEBUG_VERBOSE, __func__ \
": returned NULL!\n");
return -RIG_EINVAL;
}
rig_debug(RIG_DEBUG_VERBOSE, __func__": curr='%s',"
"ptt=%u, ctrl=%u\n", buf, ptt, ctrl);
if (ptt != 0)
buf[2] = (TS2K_PTT_ON_SUB == ptt) ? '1' : '0';
if (ctrl != 0)
buf[3] = (TS2K_CTRL_ON_SUB == ctrl) ? '1' : '0';
buf[4] = ';';
buf[5] = '\0'; // just for printing debug
acklen=10;
retval = ts2k_transaction(rig, buf, 5, NULL, NULL);
CHKERR(retval);
return RIG_OK;
}
/*
* FIXME: simple ascii to integer converter--expensive!
* Prevents trashing original string, otherwise
* just drop a (char)0 where you need it.
*/
int ts2k_get_int(char *src, int cnt)
{
static char buf[20];
strncpy(buf, src, cnt);
buf[cnt] = (char) 0;
return atoi(buf);
}
int ts2k_get_rit(RIG * rig, vfo_t vfo, shortfreq_t * rit)
{
int retval, acklen;
char ack[40];
char *ctrl;
ctrl = ts2k_get_ctrl(rig);
if (ctrl == NULL) // do we have valid "dc;" ?
return -RIG_EINVAL; // don't know proper errors yet!
// sub shows main's rit! We return 0 if subreceiver.
if (ctrl[3] == '1') {
*rit = 0;
return RIG_OK; // not really, but it's paid for...
}
retval = ts2k_transaction(rig, "if;", 3, ack, &acklen);
CHKERR(retval);
ack[23] = (char) 0;
*rit = atoi(&ack[17]);
return RIG_OK;
}
/*
* ts2k_get_xit() We just call ts2k_get_rit()
* On the ts2k, they're the same. The rig
* acts this way.
*/
int ts2k_get_xit(RIG * rig, vfo_t vfo, shortfreq_t * rit)
{
return ts2k_get_rit(rig, vfo, rit);
}
int ts2k_set_rit(RIG * rig, vfo_t vfo, shortfreq_t rit)
{
char buf[40], c;
int retval, i, len;
// Clear current rit/xit.
retval = ts2k_transaction(rig, "rc;", 3, NULL, NULL);
CHKERR(retval);
// Execute up/down request.
if (rit > 0) {
c = 'u';
i = rit;
} else {
c = 'd';
i = -rit;
}
len = sprintf(buf, "r%c%6d;", c, i);
return ts2k_transaction(rig, buf, len, NULL, NULL);
}
int ts2k_set_xit(RIG * rig, vfo_t vfo, shortfreq_t rit)
{
return ts2k_set_rit(rig, vfo, rit);
}
int ts2k_get_ts(RIG * rig, vfo_t vfo, shortfreq_t * ts)
{
STUFF(10);
int m, s;
retval = ts2k_transaction(rig, "ST;", 5, ack, &acklen);
CHKERR(retval);
ack[4] = '\0';
s = atoi(&ack[2]);
rig_debug(RIG_DEBUG_VERBOSE, __func__": received: '%s', %u\n", ack, s);
retval = ts2k_transaction(rig, "MD;", 5, ack, &acklen);
CHKERR(retval);
// fm or am mode selects 1
m = (ack[2] == '4' || ack[2] == '5') ? 1 : 0;
rig_debug(RIG_DEBUG_VERBOSE, __func__": received: '%s', %u\n", ack, m);
*ts = ts2k_steps[m][s];
return RIG_OK;
}
// FIXME: should get nearest, not easiest. :)
/*
* status: working. fixed timeout. --Dale
*/
int ts2k_set_ts(RIG * rig, vfo_t vfo, shortfreq_t ts)
{
STUFF(10);
char st[10];
int m, s, k;
long int aver, diff[2];
retval = ts2k_transaction(rig, "md;", 5, ack, &acklen);
CHKERR(retval);
// fm or am mode selects 1
m = (ack[2] == '4' || ack[2] == '5') ? 1 : 0;
// fm or am selects 10 step freq. else 4.
k = ( m )? 10 : 4;
s=0;
if( ts < ts2k_steps[m][0] ) {
k=s;
}
if( ts > ts2k_steps[m][9] ) {
s=9;
}
for ( s=1 ; s<k; s++) {
if ( ts2k_steps[m][s-1] <= ts && ts <= ts2k_steps[m][s]) {
diff[0] = ts - ts2k_steps[m][s-1];
diff[1] = ts2k_steps[m][s] - ts;
if( diff[0] > diff[1] ) { // closer to [s]
break;
} else { // closer to [s-1]
s--;
break;
}
}
}
// m is tmp now
m = sprintf(st, "st0%1u;", s);
// no reply!
retval = ts2k_transaction(rig, st, m, NULL, NULL);
CHKERR(retval);
return RIG_OK;
}
/* Rig truncates in kHz(50) steps, so we don't. */
int ts2k_get_rptr_offs(RIG * rig, vfo_t vfo, shortfreq_t * rptr_offs)
{
STUFF(20);
retval = ts2k_transaction(rig, "of;", 3, ack, &acklen);
CHKERR(retval);
if (ack[0] != 'O' || ack[1] != 'F')
return -RIG_EINVAL;
if (acklen != 12)
return -RIG_EINVAL;
ack[11] = '\0';
*rptr_offs = atoi(&ack[2]);
return RIG_OK;
}
/* Rig truncates in kHz(50) steps, so we don't. */
int ts2k_set_rptr_offs(RIG * rig, vfo_t vfo, shortfreq_t rptr_offs)
{
STUFF(20);
char buf[20];
int buflen = 20, i;
i = sprintf(buf, "of%09u;", (unsigned int) rptr_offs);
retval = ts2k_transaction(rig, buf, i, NULL, NULL);
CHKERR(retval);
return RIG_OK;
}
/*
* status: working, leaves vfo intact.
*/
int ts2k_get_rptr_shift(RIG * rig, vfo_t vfo, rptr_shift_t * rptr_shift)
{
STUFF(20);
vfo_t vfo_tmp;
// FIXME: I don't know if I should change back to currVFO, but I do.
retval = ts2k_get_vfo(rig, &vfo_tmp);
CHKERR(retval);
retval = ts2k_transaction(rig, "os;", 3, ack, &acklen);
CHKERR(retval);
retval = ts2k_vfo_ctrl(rig, vfo);
if (ack[0] != 'O' || ack[1] != 'S')
return -RIG_EINVAL;
//if(acklen != 4) return -RIG_EINVAL;
switch (ack[2]) {
case '0':
*rptr_shift = RIG_RPT_SHIFT_NONE;
break;
case '1':
*rptr_shift = RIG_RPT_SHIFT_MINUS;
break;
case '2':
*rptr_shift = RIG_RPT_SHIFT_PLUS;
break;
case '3':
*rptr_shift = RIG_RPT_SHIFT_1750;
break;
default:
return -RIG_EINVAL;
break;
}
// FIXME: I don't know if I should change back to currVFO, but I do.
retval = ts2k_set_vfo(rig, vfo_tmp);
CHKERR(retval);
return RIG_OK;
}
/*
* ts2k_set_rptr_shift()
*
* status: doesn't check VFO yet --Dale
*/
int ts2k_set_rptr_shift(RIG * rig, vfo_t vfo, rptr_shift_t rptr_shift)
{
STUFF(10);
char c;
switch (rptr_shift) {
case RIG_RPT_SHIFT_NONE:
c = '0';
break;
case RIG_RPT_SHIFT_PLUS:
c = '1';
break;
case RIG_RPT_SHIFT_MINUS:
c = '2';
break;
case RIG_RPT_SHIFT_1750: // FIXME: invalid for mine! (non-Etype)
c = '3';
break;
default:
return -RIG_EINVAL;
break;
}
acklen = sprintf(ack, "os%c;", c);
retval = ts2k_transaction(rig, ack, 4, NULL, NULL);
CHKERR(retval);
return RIG_OK;
}
int ts2k_get_split(RIG * rig, vfo_t vfo, split_t * split)
{
STUFF(10);
char ack2[10];
int ack2len = 10;
retval = ts2k_transaction(rig, "fr;", 3, ack, &acklen);
CHKERR(retval);
retval = ts2k_transaction(rig, "ft;", 3, ack2, &ack2len);
CHKERR(retval);
if (ack[2] != ack2[2])
*split = RIG_SPLIT_ON;
else
*split = RIG_SPLIT_OFF;
return RIG_OK;
}
/* no VFO check, and no mem. Yet. */
int ts2k_set_split(RIG * rig, vfo_t vfo, split_t split)
{
STUFF(10);
char ack2[10];
int ack2len = 10;
retval = ts2k_transaction(rig, "fr;", 3, ack, &acklen);
CHKERR(retval);
retval = ts2k_transaction(rig, "ft;", 3, ack2, &ack2len);
CHKERR(retval);
if (split == RIG_SPLIT_ON) { // RX/TX on different vfo's
if (ack[2] == '0')
ack2[2] = '1';
else if (ack[2] == '1')
ack2[2] = '0';
/* FIXME: mem split. mem/vfo split must enable menu 6a
* with the "ex...;" or mem/vfo won't work. A split
* memory operates simply by storing a memory with the
* freq with RX != TX then recalling it. Don't know if
* if two separate memories can be used (e.g. 100/101)
*/
else
return -RIG_EINVAL;
} else { // RX/TX on same vfo (or mem etc...)
ack2[2] = ack[2];
}
// now, just send back the rig's strings :)
retval = ts2k_transaction(rig, ack, acklen, NULL, NULL);
CHKERR(retval);
retval = ts2k_transaction(rig, ack2, ack2len, NULL, NULL);
CHKERR(retval);
return RIG_OK;
}
int ts2k_get_split_freq(RIG * rig, vfo_t vfo, freq_t * tx_freq)
{
// FIXME : This makes too many assumptions--I'll fix it later...d PTT/CTRL bytes\n", dc_len);*//* The following are functions I've added for the TS-2000. (C) 2002 D. Edmons and all that. *//*-------------------------------------------------------------------------------------------*/
return ts2k_get_freq(rig, vfo, tx_freq);
}
int ts2k_set_split_freq(RIG * rig, vfo_t vfo, freq_t tx_freq)
{
// FIXME : This makes too many assumptions--I'll fix it later...d PTT/CTRL bytes\n", dc_len);*//* The following are functions I've added for the TS-2000. (C) 2002 D. Edmons and all that. *//*-------------------------------------------------------------------------------------------*/
return ts2k_set_freq(rig, vfo, tx_freq);
}
/* ts2k_get_channel()
*
* status: working! reading unset memory is an error. this
* is the rig. vfo_t is not needed for regular memory
* and we don't check it now. when we start to access
* other memory we'll split into multiple functions
* each dedicated to the unique type (e.g. quick/tmp).
*
* memory range not checked.
*
* Note: the manual erroneously states bank should be ' ' if
* memory is <100. The "correct" way is to *never*
* send a ' ' or you'll get a "?;" response. Always
* set memory with (e.g.) "mc1020;". --kd7eni
*/
int ts2k_get_channel(RIG * rig, channel_t *chan)
{
// channel_t tch; // needed?
char rxtx, mrtxt[2][60], mrcmd[15], ack[60], tmp[20];
int i, check, retval, curr_mem, mrtxt_len, mrcmd_len, ack_len;
vfo_t curr_vfo;
#ifdef _USEVFO
vfo_t v;
v = vfo;
// check the memory bit
if( !(v & RIG_VFO_MEM) ) {
rig_debug(RIG_DEBUG_ERR, __func__
": Non Memory VFO='%u', v=%u\n", vfo, v);
return -RIG_EINVAL; // not a channel!
}
// get needed info if rig's mem pointers used
if( ( vfo == RIG_VFO_MEM_A
|| vfo == RIG_VFO_MEM_C ) ) {
rig_debug(RIG_DEBUG_ERR, __func__": using rig's ptr\n");
retval = ts2k_get_vfo(rig, &curr_vfo);
CHKERR(retval);
retval = ts2k_get_mem(rig, curr_vfo, &curr_mem);
CHKERR(retval);
chan->channel_num = curr_mem;
}
#endif
mrtxt_len = ack_len = 60;
mrcmd_len=15;
if(chan==NULL)
return -RIG_EINVAL;
// send request for both rx mem and tx mem
for(i=0; i<2; i++) { // 0=rx; 1=tx
mrcmd_len = sprintf(mrcmd, "mr%01d%03u;", i, chan->channel_num);
ack_len = 60; // must be reset inside loop!
retval = ts2k_transaction(rig, mrcmd, mrcmd_len, ack, &ack_len);
CHKERR(retval);
rig_debug(RIG_DEBUG_ERR, __func__": read \n\t'%s'\n", ack);
ack[50] = '\0'; // May be too far, but helps.
// watch out. |= and != look the same!
// Perform checks on data.
check = (ack[0] != 'M');
check |= (ack[1] != 'R');
check |= (ack[2] != ((i == 0)? '0' : '1'));
check |= (chan->channel_num != int_n(tmp, &ack[3], 3));
if( check ) {
rig_debug(RIG_DEBUG_ERR, __func__
":check failed!\n");
return -RIG_EINVAL; // correct error type?
}
// all is well, save string
strncpy( &mrtxt[i][0], ack, 52);
}
// FIXME: handle mem split
// final check on data. (if RX!=TX mem split, or limit!)
if( strncmp( &mrtxt[0][3], &mrtxt[1][3], 41-3) != 0 ) {
rig_debug(RIG_DEBUG_ERR, "\n"__func__
": MEM split and band limits not yet supported!\n");
return -RIG_EINVAL; // FIXME: sending proper error?
}
// FIXME: 1) Since chan is not an array, we fudge and only do TX!
// even if split!!!!!!!!
// FIXME: 2) we only handle regular memories, not everything
// FIXME: 3) I store only data ts2k actually saves in memory
// some values are the ts2k value, not the hamlib value!
// (keep same order as channel struct to ease debugging!)
// chan->channel_num = ; // already set?
// The following may be used to indicate we're reading limits (290-299).
// At any rate, it's currently unused.
chan->bank_num = 0; // I merge the two--do not use! --Dale
chan->lock = int_n(tmp, &mrtxt[0][18], 1);
chan->freq = int_n(tmp, &mrtxt[0][06], 11);
chan->mode = ts2k_mode_list[ int_n(tmp, &mrtxt[0][17], 1) ];
if(chan->mode == RIG_MODE_AM || chan->tx_mode == RIG_MODE_FM)
i = 1;
else
i = 0;
chan->width = 0;
chan->tx_freq = int_n(tmp, &mrtxt[1][06], 11);
chan->tx_mode = ts2k_mode_list[ int_n(tmp, &mrtxt[1][17], 1)];
chan->tx_width = 0;
chan->split = 0;
chan->rptr_shift = int_n(tmp, &mrtxt[1][28], 1);
chan->rptr_offs = int_n(tmp, &mrtxt[1][29], 9);
if(chan->tx_mode == RIG_MODE_AM || chan->tx_mode == RIG_MODE_FM)
i = 1;
else
i = 0;
chan->tuning_step = ts2k_steps[i][ int_n(tmp,& mrtxt[1][38], 2) ];
chan->rit = 0;
chan->xit = 0;
chan->funcs = 0;
for( i=0; i<RIG_SETTING_MAX; i++) {
// the following shamelessly stolen from rigctl.c --Dale
setting_t level = rig_idx2setting(i); // now, I understand
if(RIG_LEVEL_IS_FLOAT(level))
chan->levels[i].f = 0.0; // I'd figured this out.
else
chan->levels[i].f = 0.0;
}
chan->ctcss_tone = ts2k_ctcss_list[ int_n(tmp, &mrtxt[1][22], 2) + 1 ];
chan->ctcss_sql = int_n(tmp, &mrtxt[1][19], 1);
chan->dcs_code = ts2k_dcs_list[ int_n(tmp, &mrtxt[1][24], 3) ];
chan->dcs_sql = int_n(tmp, &mrtxt[1][19], 1);
chan->scan_group = int_n(tmp, &mrtxt[1][40], 1);
// chan->flags = curr_vfo; // n/a
// FIXME : The following may have trailing garbage
strncpy( chan->channel_desc, &mrtxt[1][41], 8);
chan->channel_desc[8] = '\0';
#ifdef _USEVFO
// if curr mem is changed at top, this'll restore it
if( ( vfo == RIG_VFO_MEM_A
|| vfo == RIG_VFO_MEM_C ) ) {
}
rig_debug(RIG_DEBUG_ERR, __func__": restoring mem=%i\n", curr_mem);
retval = ts2k_set_mem(rig, curr_vfo, curr_mem);
CHKERR(retval);
#endif
return RIG_OK;
}
/*
* ts2k_set_channel() Here I read a channel_t and memory data. I'm
* assuming this is correct. Anyway, this is a useful function.
* The only quirk is that the TS-2000 saves both TX as well
* as RX data separately. This function can easily be modified
* to write as if there were 600 memories but that would lead
* to confusion and the rig certainly don't operate that way.
* I hope to channel_t *chan changed to channel_t *chan[2].
* (As well as vfo_t too.) Much thanks to Stephane for already
* having the most important stuff working from the start
* (mostly anyway).
*
* From here on out I'm gonna try to use hamlib-1.1.0.pdf
* for the design document and hopefully I'll know which way
* to go when things aren't the way they should be. We'll
* see how things go.
* --Dale kd7e
*/
int ts2k_set_channel(RIG * rig, const channel_t *chan)
{
char mrtxt[2][60], mrcmd[10], ack[60];
int retval, i, j, mr_len[2], ack_len;
// the following are the actual memory data to be written.
unsigned int
p1, // RX/TX (bool)
p2p3, // this is not a bug--I combine bank/channel
p4, // freq
p5, // mode
p6, // lockout
p7, // tone, ctcss, dcs
p8, // tone #
p9, // CTCSS #
p10, // DCS code
p11, // revers status
p12, // repeater shift
p13, // offset freq
p14, // step size
p15; // memory group (0-9)
char *p16; // 8 char + 1 null byte
ack_len = 10;
/*
* Write everthing in order. We only set things that
* the rig actually puts in memory. This way, a set
* followed by a get will match exactly. Otherwise,
* we'll have to fudge and won't know when we have
* a valid save. (FIXME: delete all this useless
* comment stuff after the code is working. --Dale)
*/
/* FIXME: we are required to have RX/TX match */
if(chan->freq != chan->tx_freq)
return -RIG_EINVAL; // should be 'unimplemented'
for(i=0; i<2; i++) {
p1 = (unsigned int) i; // 0=RX, 1=TX
p2p3 = (unsigned int) chan->channel_num; // we'll compare 'em later
if( i == 0 )
p4 = (unsigned int) chan->freq;
else
p4 = (unsigned int) chan->tx_freq;
for(j=0; j<(sizeof(ts2k_mode_list)/sizeof(int)); j++) {
if(chan->mode == ts2k_mode_list[j])
break;
}
p5 = (unsigned int) j; // FIXME: either not found, or last!
p6 = (unsigned int) chan->lock;
p7 = 0; // FIXME: to lazy to sort this out right now
p8 = 0; // " " " " "
p9 = 0; // " " " " "
p10 = 0; // " " " " "
p11 = 0; // " " " " "
p12 = 0; // " " " " "
p13 = 0; // " " " " "
p14 = 0; // " " " " "
p15 = (unsigned int) chan->scan_group;
p16 = &(chan->channel_desc[0]);
mr_len[i] = sprintf( &(mrtxt[i][0]),
"mr%1u%3u%11u%1u%1u%1u%2u%2u%3u%1u%1u%9u%2u%1u%s;",
p1, p2p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
p14, p15,
p16
); // yikes!
retval = ts2k_transaction(rig, &mrtxt[i][0], mr_len[i],
ack, &ack_len);
CHKERR(retval);
// FIXME: now readback the string and make sure it worked!
}
return retval;
}
/*
* ts2k_vfo_ctrl() set PTT/CTRL based on VFO arg
*
* (Taken from my revision of ts2k_set_vfo())
*
* status: VFOA, VFOB, VFOC, Main, Sub,
* MEMA, MEMC, CALLA, CALLC
* VFO_AB, VFO_BA, ...
* They all work! --Dale
*/
int ts2k_vfo_ctrl(RIG * rig, vfo_t vfo)
{
int ptt, ctrl;
int retval;
ptt = ctrl = 0;
// Main/Sub Active Transceiver
switch (vfo) {
case RIG_VFO_A:
case RIG_VFO_B:
case RIG_VFO_AB: // split
case RIG_VFO_BA:
case RIG_CTRL_SAT: // Should be PTT on main CTRL on sub (?)
case RIG_VFO_MAIN:
case RIG_VFO_MEM_A:
case RIG_VFO_CALL_A:
ctrl = TS2K_CTRL_ON_MAIN; // FIXME : these are independent!
ptt = TS2K_PTT_ON_MAIN;
break;
case RIG_VFO_C:
case RIG_VFO_SUB:
case RIG_VFO_MEM_C:
case RIG_VFO_CALL_C:
ctrl = TS2K_CTRL_ON_SUB;
ptt = TS2K_PTT_ON_SUB;
break;
default:
break;
}
// set PTT/CTRL
retval = ts2k_set_ctrl(rig, ptt, ctrl);
if (retval != RIG_OK)
return -RIG_EINVAL;
return retval;
}
/*
* status: ok, no vfo checks
*/
int ts2k_get_dcs_code(RIG * rig, vfo_t vfo, tone_t *code)
{
char ack[10], tmp[10];
int retval, acklen, i;
acklen = 10;
retval = ts2k_transaction(rig, "qc;", 6, ack, &acklen);
CHKERR(retval);
i = int_n(tmp, &ack[2], 3);
*code = ts2k_dcs_list[i];
return RIG_OK;
}
/*
* status: ok, no vfo checks
*/
int ts2k_set_dcs_code(RIG * rig, vfo_t vfo, tone_t code)
{
char ack[10], cmd[10], tmp[10];
int retval, acklen, cmdlen, i;
// we only allow exact matches here
i=0;
while(code != ts2k_dcs_list[i]) {
if(ts2k_dcs_list[i] == 0)
return -RIG_EINVAL;
i++;
}
cmdlen = sprintf(cmd, "qc%03u;", i);
return ts2k_transaction(rig, cmd, cmdlen, NULL, NULL);
}
/*
* status: new, all guesses and assumptions!
* know nothing about txwidth (which one?)
* or tx = rx + txwidth?
*/
int ts2k_set_split_mode(RIG * rig,
vfo_t vfo, rmode_t txmode, pbwidth_t txwidth)
{
vfo_t vtmp;
switch(vfo) {
case RIG_VFO_AB:
vtmp = RIG_VFO_B; break;
case RIG_VFO_BA:
vtmp = RIG_VFO_A; break;
default:
return -RIG_EINVAL;
}
return ts2k_set_mode(rig, vtmp, txmode, txwidth);
}
int ts2k_get_split_mode(RIG *rig,
vfo_t vfo, rmode_t *txmode, pbwidth_t *txwidth)
{
vfo_t vtmp;
switch(vfo) {
case RIG_VFO_AB:
vtmp = RIG_VFO_B; break;
case RIG_VFO_BA:
vtmp = RIG_VFO_A; break;
default:
return -RIG_EINVAL;
}
return ts2k_get_mode(rig, vtmp, txmode, txwidth);
}
/*
* status: new
*/
int ts2k_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch)
{
int retval;
vfo_t v;
rig_debug(RIG_DEBUG_ERR, __func__": starting...\n");
if(vfo==RIG_VFO_CURR) {
retval = ts2k_get_vfo(rig, &v);
CHKERR(retval);
} else
v = vfo;
// hopefully, this'll work. rig does nothing if already in scan!
retval = ts2k_scan_off(rig);
CHKERR(retval);
rig_debug(RIG_DEBUG_ERR, __func__": got VFO = %x\n", v);
// set proper vfo first (already done?)
switch(v) {
case RIG_VFO_MEM: // Currently selected Main/Sub
case RIG_VFO_MEM_A: // Main
case RIG_VFO_MEM_C: // Sub
// FIXME: we should set the group and fall through
/* nobreak */
// case RIG_VFO_VFO: // Currently selected Main/Sub
case RIG_VFO_A: // Main
case RIG_VFO_B: // Main
case RIG_VFO_C: // Sub
retval = ts2k_set_vfo(rig, v); // already set?
CHKERR(retval);
break;
case RIG_VFO_CALL_A: //
case RIG_VFO_CALL_C:
default:
rig_debug(RIG_DEBUG_ERR, __func__": vfo 'defaulted'\n");
return -RIG_ENIMPL; // unimplemented, but valid scan
}
rig_debug(RIG_DEBUG_ERR, __func__": VFO set!\n");
retval = ts2k_scan_off(rig);
CHKERR(retval);
switch(scan) {
case RIG_SCAN_STOP:
return ts2k_scan_off(rig);
break;
case RIG_SCAN_PROG:
if(ch<290)
return -RIG_EINVAL;
retval = ts2k_set_mem(rig, vfo, ch);
CHKERR(retval);
/* nobreak */
case RIG_SCAN_MEM:
/* nobreak */
case RIG_SCAN_VFO:
return ts2k_scan_on(rig, '1'); // Look Ma, I'm scanning!
break;
case RIG_SCAN_SLCT:
/* nobreak */
case RIG_SCAN_PRIO:
/* nobreak */
default:
rig_debug(RIG_DEBUG_ERR, __func__": scan 'defaulted'\n");
return -RIG_ENIMPL; // unimplemented, but valid scan
}
}
int ts2k_scan_on(RIG *rig, char sc)
{
char cmd[]="sc0;", ack[10];
int retval, cmdlen, acklen, i;
rig_debug(RIG_DEBUG_ERR, __func__": turning scan on\n");
cmd[2] = sc;
retval = ts2k_transaction(rig, cmd, 4, NULL, NULL);
CHKERR(retval);
rig_debug(RIG_DEBUG_ERR, __func__": turned scan on\n");
// force reply when turning scan on
if(sc != '0') {
cmd[2] = ';'; cmd[3] = '\0';
retval = ts2k_transaction(rig, cmd, 3, ack, &acklen);
CHKERR(retval);
if(ack[2] != sc)
return -RIG_EINVAL;
}
return RIG_OK;
}
int ts2k_scan_off(RIG *rig)
{
rig_debug(RIG_DEBUG_ERR, __func__": turning scan off\n");
return ts2k_scan_on(rig, '0');
}
int ts2k_get_parm(RIG *rig, setting_t parm, value_t *val)
{
int retval, acklen, cmdlen;
char ack[30], cmd[30];
switch( parm ) {
case RIG_PARM_BEEP:
cmdlen = sprintf(cmd, "ex0120000;"); break;
case RIG_PARM_BACKLIGHT:
cmdlen = sprintf(cmd, "ex0000000;"); break;
case RIG_PARM_KEYLIGHT:
cmdlen = sprintf(cmd, "ex0010000;"); break;
case RIG_PARM_APO:
cmdlen = sprintf(cmd, "ex0570000;"); break;
case RIG_PARM_ANN:
return -RIG_ENIMPL;
case RIG_PARM_TIME:
return -RIG_ENAVAIL;
default:
return -RIG_EINTERNAL;
}
acklen = 30;
retval = ts2k_transaction(rig, cmd, cmdlen, ack, &acklen);
if(retval == RIG_OK) {
switch( parm ) {
case RIG_PARM_BEEP:
val->i = (int)(ack[9] - '0');
break;
case RIG_PARM_BACKLIGHT:
case RIG_PARM_KEYLIGHT:
val->f = (float)(ack[9] - '0');
break;
case RIG_PARM_APO:
val->i = (int) int_n(cmd, &ack[9], 2); // cmd is TMP now
break;
default:
return -RIG_EINTERNAL;
}
}
return retval;
}
int ts2k_set_parm(RIG *rig, setting_t parm, value_t val)
{
char cmd[30];
int retval, cmdlen, i;
rig_debug(RIG_DEBUG_ERR, __func__": val.i = %u\n", val.i);
rig_debug(RIG_DEBUG_ERR, __func__": val.f = %f\n", val.f);
switch( parm ) {
case RIG_PARM_APO:
cmdlen = sprintf(cmd, "ex0570000%01u;",
(val.i>180)? 3: val.i/60);
break;
case RIG_PARM_BEEP:
cmdlen = sprintf(cmd, "ex0120000%01u;", (val.i>9)? 9: val.i);
break;
case RIG_PARM_BACKLIGHT:
cmdlen = sprintf(cmd, "ex0000000%01u;",
(int) ((val.f>1.0)? 4.0 : val.f*4.0) );
break;
case RIG_PARM_KEYLIGHT:
cmdlen = sprintf(cmd, "ex0010000%01u;", (val.i==0)? 0: 1);
break;
case RIG_PARM_ANN:
return -RIG_ENIMPL;
case RIG_PARM_TIME:
case RIG_PARM_BAT:
return -RIG_ENAVAIL;
default:
return -RIG_EINTERNAL;
}
retval = ts2k_transaction(rig, cmd, cmdlen, NULL, NULL);
return retval;
}
#undef CHKERR
#undef STUFF
// End
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik