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

2146 wiersze
46 KiB
C
Czysty Wina Historia

/*
* Hamlib Kenwood backend - main file
* Copyright (c) 2000-2009 by Stephane Fillod
* Copyright (C) 2009 Alessandro Zummo <a.zummo@towertech.it>
*
* $Id: kenwood.c,v 1.118 2009-02-13 19:34:21 azummo Exp $
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program 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 Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h> /* String function definitions */
#include <unistd.h> /* UNIX standard function definitions */
#include <math.h>
#include <ctype.h>
#include "hamlib/rig.h"
#include "serial.h"
#include "misc.h"
#include "register.h"
#include "cal.h"
#include "kenwood.h"
struct kenwood_id {
rig_model_t model;
int id;
};
struct kenwood_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 kenwood_id kenwood_id_list[] = {
{ RIG_MODEL_TS940, 1 },
{ RIG_MODEL_TS811, 2 },
{ RIG_MODEL_TS711, 3 },
{ RIG_MODEL_TS440, 4 },
{ RIG_MODEL_R5000, 5 },
{ RIG_MODEL_TS790, 7 },
{ RIG_MODEL_TS950SDX, 8 }, /* reported as RIG_MODEL_TS950SD originally */
{ RIG_MODEL_TS850, 9 },
{ RIG_MODEL_TS450S, 10 },
{ RIG_MODEL_TS690S, 11 },
{ RIG_MODEL_TS870S, 15 },
{ RIG_MODEL_TRC80, 16 },
{ RIG_MODEL_TS570D, 17 }, /* Elecraft K2 also returns 17 */
{ RIG_MODEL_TS570S, 18 },
{ RIG_MODEL_TS2000, 19 },
{ RIG_MODEL_TS480, 20 },
{ RIG_MODEL_NONE, UNKNOWN_ID }, /* end marker */
};
/* XXX numeric ids have been tested only with the TS-450 */
static const struct kenwood_id_string kenwood_id_string_list[] = {
{ RIG_MODEL_TS940, "001" },
{ RIG_MODEL_TS811, "002" },
{ RIG_MODEL_TS711, "003" },
{ RIG_MODEL_TS440, "004" },
{ RIG_MODEL_R5000, "005" },
{ RIG_MODEL_TS790, "007" },
{ RIG_MODEL_TS950SDX, "008" }, /* reported as RIG_MODEL_TS950SD originally */
{ RIG_MODEL_TS850, "009" },
{ RIG_MODEL_TS450S, "010" },
{ RIG_MODEL_TS690S, "011" },
{ RIG_MODEL_TS870S, "015" },
{ RIG_MODEL_TS570D, "017" }, /* Elecraft K2 also returns 17 */
{ RIG_MODEL_TS570S, "018" },
{ RIG_MODEL_TS2000, "019" },
{ RIG_MODEL_TS480, "020" },
{ RIG_MODEL_THD7A, "TH-D7" },
{ RIG_MODEL_THD7AG, "TH-D7G" },
{ RIG_MODEL_TMD700, "TM-D700" },
{ RIG_MODEL_TMV7, "TM-V7" },
{ RIG_MODEL_THF6A, "TH-F6" },
{ RIG_MODEL_THF7E, "TH-F7" },
{ RIG_MODEL_THG71, "TH-G71" },
{ RIG_MODEL_NONE, NULL }, /* end marker */
};
rmode_t kenwood_mode_table[KENWOOD_MODE_TABLE_MAX] = {
[0] = RIG_MODE_NONE,
[1] = RIG_MODE_LSB,
[2] = RIG_MODE_USB,
[3] = RIG_MODE_CW,
[4] = RIG_MODE_FM,
[5] = RIG_MODE_AM,
[6] = RIG_MODE_RTTY,
[7] = RIG_MODE_CWR,
[8] = RIG_MODE_NONE, /* TUNE mode */
[9] = RIG_MODE_RTTYR
};
/*
* 38 CTCSS sub-audible tones
*/
const tone_t kenwood38_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,
0,
};
/**
* 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.
*/
int
kenwood_transaction(RIG *rig, const char *cmdstr, int cmd_len,
char *data, size_t *datasize)
{
struct kenwood_priv_caps *caps = kenwood_caps(rig);
struct rig_state *rs;
int retval;
char cmdtrm[2]; /* Default Command/Reply termination char */
int retry_read = 0;
rs = &rig->state;
rs->hold_decode = 1;
rig_debug(RIG_DEBUG_TRACE, "%s: %s\n", __func__, cmdstr);
cmdtrm[0] = caps->cmdtrm;
cmdtrm[1] = '\0';
transaction_write:
serial_flush(&rs->rigport);
if (cmdstr) {
char *cmd;
int len = strlen(cmdstr);
cmd = malloc(len + 2);
if (cmd == NULL) {
retval = -RIG_ENOMEM;
goto transaction_quit;
}
memcpy(cmd, cmdstr, len);
/* XXX the if is temporary, until all invocations are fixed */
if (cmdstr[len - 1] != ';' && cmdstr[len - 1] != '\r') {
cmd[len] = '\r';
len++;
}
retval = write_block(&rs->rigport, cmd, len);
free(cmd);
if (retval != RIG_OK)
goto transaction_quit;
}
if (data == NULL || *datasize <= 0) {
rig->state.hold_decode = 0;
return RIG_OK; /* don't want a reply */
}
memset(data,0,*datasize);
retval = read_string(&rs->rigport, data, *datasize, cmdtrm, strlen(cmdtrm));
if (retval < 0) {
if (retry_read++ < rig->state.rigport.retry)
goto transaction_write;
goto transaction_quit;
} else
*datasize = retval;
/* Check that command termination is correct */
if (strchr(cmdtrm, data[strlen(data)-1])==NULL) {
rig_debug(RIG_DEBUG_ERR, "%s: Command is not correctly terminated '%s'\n", __func__, data);
if (retry_read++ < rig->state.rigport.retry)
goto transaction_write;
retval = -RIG_EPROTO;
goto transaction_quit;
}
if (strlen(data) == 2) {
switch (data[0]) {
case 'N':
/* Command recognised by rig but invalid data entered. */
rig_debug(RIG_DEBUG_VERBOSE, "%s: NegAck for '%s'\n", __func__, cmdstr);
retval = -RIG_ENAVAIL;
goto transaction_quit;
case 'O':
/* Too many characters sent without a carriage return */
rig_debug(RIG_DEBUG_VERBOSE, "%s: Overflow for '%s'\n", __func__, cmdstr);
retval = -RIG_EPROTO;
goto transaction_quit;
case 'E':
/* Communication error */
rig_debug(RIG_DEBUG_VERBOSE, "%s: Communication error for '%s'\n", __func__, cmdstr);
retval = -RIG_EIO;
goto transaction_quit;
case '?':
/* Command not understood by rig */
rig_debug(RIG_DEBUG_ERR, "%s: Unknown command '%s'\n", __func__, cmdstr);
retval = -RIG_ERJCTED;
goto transaction_quit;
}
}
/* always give back a null terminated string without
* the command terminator.
*/
if (strlen(data) > 0)
data[strlen(data) - 1] = '\0'; /* not elegant, but works */
else
data[0] = '\0';
/*
* Check that received the correct reply. The first two characters
* should be the same as command.
*/
if (cmdstr && (data[0] != cmdstr[0] || data[1] != 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.
*/
rig_debug(RIG_DEBUG_ERR, "%s: wrong reply %c%c for command %c%c\n",
__func__, data[0], data[1], cmdstr[0], cmdstr[1]);
if (retry_read++ < rig->state.rigport.retry)
goto transaction_write;
retval = -RIG_EPROTO;
goto transaction_quit;
}
retval = RIG_OK;
transaction_quit:
rs->hold_decode = 0;
return retval;
}
int
kenwood_safe_transaction(RIG *rig, const char *cmd, char *buf,
size_t buf_size, size_t expected)
{
int err;
if (expected == 0)
buf_size = 0;
err = kenwood_transaction(rig, cmd, strlen(cmd), buf, &buf_size);
if (err != RIG_OK)
return err;
if (buf_size != expected) {
rig_debug(RIG_DEBUG_ERR, "%s: wrong answer len for cmd %s: "
"expected = %d, got %d\n",
__func__, cmd, expected, buf_size);
return -RIG_EPROTO;
}
return RIG_OK;
}
rmode_t kenwood2rmode(unsigned char mode, const rmode_t mode_table[])
{
if (mode >= KENWOOD_MODE_TABLE_MAX)
return RIG_MODE_NONE;
return mode_table[mode];
}
char rmode2kenwood(rmode_t mode, const rmode_t mode_table[])
{
int i;
for(i = 0; i < KENWOOD_MODE_TABLE_MAX; i++) {
if (mode_table[i] == mode)
return i;
}
return -1;
}
int kenwood_init(RIG *rig)
{
struct kenwood_priv_data *priv;
struct kenwood_priv_caps *caps = kenwood_caps(rig);
rig_debug(RIG_DEBUG_TRACE, "%s\n", __func__);
priv = malloc(sizeof(struct kenwood_priv_data));
if (priv == NULL)
return -RIG_ENOMEM;
memset(priv, 0x00, sizeof(struct kenwood_priv_data));
priv->split = RIG_SPLIT_OFF;
rig->state.priv = priv;
/* default mode_table */
if (caps->mode_table == NULL)
caps->mode_table = kenwood_mode_table;
/* default if_len */
if (caps->if_len == 0)
caps->if_len = 38;
rig_debug(RIG_DEBUG_TRACE, "%s: if_len = %d\n", __func__, caps->if_len);
return RIG_OK;
}
int kenwood_cleanup(RIG *rig)
{
if (rig == NULL)
return -RIG_EINVAL;
free(rig->state.priv);
rig->state.priv = NULL;
return RIG_OK;
}
int kenwood_open(RIG *rig)
{
int err, i;
char *idptr;
char id[KENWOOD_MAX_BUF_LEN];
rig_debug(RIG_DEBUG_TRACE, "%s\n", __func__);
/* get id in buffer, will be null terminated */
err = kenwood_get_id(rig, id);
if (err != RIG_OK) {
rig_debug(RIG_DEBUG_ERR, "%s: cannot get identification\n",
__func__);
return err;
}
/* id is something like 'IDXXX' or 'ID XXX' */
if (strlen(id) < 5) {
rig_debug(RIG_DEBUG_ERR, "%s: unknown id type (%s)\n", id);
return -RIG_EPROTO;
}
/* check for a white space and skip it */
idptr = &id[2];
if (*idptr == ' ')
idptr++;
/* compare id string */
for (i = 0; kenwood_id_string_list[i].model != RIG_MODEL_NONE; i++) {
if (strcmp(kenwood_id_string_list[i].id, idptr) != 0)
continue;
/* found matching id, verify driver */
rig_debug(RIG_DEBUG_TRACE, "%s: found match %s\n",
__func__, kenwood_id_string_list[i].id);
if (kenwood_id_string_list[i].model == rig->caps->rig_model)
return RIG_OK;
/* driver mismatch */
rig_debug(RIG_DEBUG_ERR,
"%s: wrong driver selected (%d instead of %d)\n",
__func__, rig->caps->rig_model,
kenwood_id_string_list[i].model);
return -RIG_EINVAL;
}
rig_debug(RIG_DEBUG_ERR, "%s: your rig (%s) is unknown\n",
__func__, id);
return -RIG_EPROTO;
}
/* caller must give a buffer of KENWOOD_MAX_BUF_LEN size */
int kenwood_get_id(RIG *rig, char *buf)
{
size_t size = KENWOOD_MAX_BUF_LEN;
return kenwood_transaction(rig, "ID", 2, buf, &size);
}
static int kenwood_get_if(RIG *rig)
{
struct kenwood_priv_data *priv = rig->state.priv;
struct kenwood_priv_caps *caps = kenwood_caps(rig);
return kenwood_safe_transaction(rig, "IF", priv->info,
KENWOOD_MAX_BUF_LEN, caps->if_len);
}
/*
* kenwood_set_vfo
* Assumes rig!=NULL
*/
int kenwood_set_vfo(RIG *rig, vfo_t vfo)
{
struct kenwood_priv_data *priv = rig->state.priv;
char cmdbuf[6];
int retval;
char vfo_function;
switch (vfo) {
case RIG_VFO_VFO:
case RIG_VFO_A:
vfo_function = '0';
break;
case RIG_VFO_B:
vfo_function = '1';
break;
case RIG_VFO_MEM:
vfo_function = '2';
break;
case RIG_VFO_CURR:
return RIG_OK;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n",
__func__, vfo);
return -RIG_EINVAL;
}
sprintf(cmdbuf, "FR%c", vfo_function);
/* set RX VFO */
retval = kenwood_simple_cmd(rig, cmdbuf);
if (retval != RIG_OK)
return retval;
/* If split mode on, the don't change TxVFO */
if (priv->split != RIG_SPLIT_OFF)
return RIG_OK;
/* set TX VFO */
cmdbuf[1] = 'T';
return kenwood_simple_cmd(rig, cmdbuf);
}
int kenwood_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
{
struct kenwood_priv_data *priv = rig->state.priv;
char cmdbuf[6];
int retval;
unsigned char vfo_function;
if(vfo != RIG_VFO_CURR) {
switch (vfo) {
case RIG_VFO_VFO:
case RIG_VFO_A: vfo_function = '0'; break;
case RIG_VFO_B: vfo_function = '1'; break;
case RIG_VFO_MEM: vfo_function = '2'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__,
vfo);
return -RIG_EINVAL;
}
/* set RX VFO */
sprintf(cmdbuf, "FR%c", vfo_function);
retval = kenwood_simple_cmd(rig, cmdbuf);
if (retval != RIG_OK)
return retval;
}
/* Split off means Rx and Tx are the same */
if (split==RIG_SPLIT_OFF) {
txvfo = vfo;
if (txvfo == RIG_VFO_CURR) {
retval = rig_get_vfo(rig, &txvfo);
if (retval != RIG_OK)
return retval;
}
}
switch (txvfo) {
case RIG_VFO_VFO:
case RIG_VFO_A: vfo_function = '0'; break;
case RIG_VFO_B: vfo_function = '1'; break;
case RIG_VFO_MEM: vfo_function = '2'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n",
__func__, txvfo);
return -RIG_EINVAL;
}
/* set TX VFO */
sprintf(cmdbuf, "FT%c", vfo_function);
retval = kenwood_simple_cmd(rig, cmdbuf);
if (retval != RIG_OK)
return retval;
/* Remember whether split is on, for kenwood_set_vfo */
priv->split = split;
return RIG_OK;
}
int kenwood_get_split_vfo_if(RIG *rig, vfo_t rxvfo, split_t *split, vfo_t *txvfo)
{
struct kenwood_priv_data *priv = rig->state.priv;
int retval;
retval = kenwood_get_if(rig);
if (retval != RIG_OK)
return retval;
switch (priv->info[32]) {
case '0':
*split = RIG_SPLIT_OFF;
break;
case '1':
*split = RIG_SPLIT_ON;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported split %c\n",
__func__, priv->info[32]);
return -RIG_EPROTO;
}
/* Remember whether split is on, for kenwood_set_vfo */
priv->split = *split;
/* TODO: find where is the txvfo.. */
return RIG_OK;
}
/*
* kenwood_get_vfo_if using byte 31 of the IF information field
* Assumes rig!=NULL, !vfo
*/
int kenwood_get_vfo_if(RIG *rig, vfo_t *vfo)
{
int retval;
struct kenwood_priv_data *priv = rig->state.priv;
retval = kenwood_get_if(rig);
if (retval != RIG_OK)
return retval;
switch (priv->info[30]) {
case '0':
*vfo = RIG_VFO_A;
break;
case '1':
*vfo = RIG_VFO_B;
break;
case '2':
*vfo = RIG_VFO_MEM;
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %c\n",
__func__, priv->info[30]);
return -RIG_EPROTO;
}
return RIG_OK;
}
/*
* kenwood_set_freq
* Assumes rig!=NULL
*/
int kenwood_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
char freqbuf[16];
unsigned char vfo_letter;
vfo_t tvfo;
tvfo = (vfo==RIG_VFO_CURR || vfo==RIG_VFO_VFO) ? rig->state.current_vfo : vfo;
switch (tvfo) {
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, "%s: unsupported VFO %d\n",
__func__, vfo);
return -RIG_EINVAL;
}
sprintf(freqbuf, "F%c%011ld", vfo_letter, (long)freq);
return kenwood_simple_cmd(rig, freqbuf);
}
int kenwood_get_freq_if(RIG *rig, vfo_t vfo, freq_t *freq)
{
struct kenwood_priv_data *priv = rig->state.priv;
char freqbuf[50];
int retval;
retval = kenwood_get_if(rig);
if (retval != RIG_OK)
return retval;
memcpy(freqbuf, priv->info, 15);
freqbuf[14] = '\0';
sscanf(freqbuf + 2, "%"SCNfreq, freq);
return RIG_OK;
}
/*
* kenwood_get_freq
* Assumes rig!=NULL, freq!=NULL
*/
int kenwood_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
char freqbuf[50];
char cmdbuf[4];
int retval;
unsigned char vfo_letter;
vfo_t tvfo;
tvfo = (vfo == RIG_VFO_CURR || vfo==RIG_VFO_VFO) ? rig->state.current_vfo : vfo;
/* memory frequency cannot be read with an Fx command, use IF */
if (tvfo == RIG_VFO_MEM) {
return kenwood_get_freq_if(rig, vfo, freq);
}
switch (tvfo) {
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, "%s: unsupported VFO %d\n",
__func__, vfo);
return -RIG_EINVAL;
}
sprintf(cmdbuf, "F%c", vfo_letter);
retval = kenwood_safe_transaction(rig, cmdbuf, freqbuf, 50, 14);
if (retval != RIG_OK)
return retval;
sscanf(freqbuf+2, "%"SCNfreq, freq);
return RIG_OK;
}
int kenwood_get_rit(RIG *rig, vfo_t vfo, shortfreq_t * rit)
{
int retval;
char buf[6];
struct kenwood_priv_data *priv = rig->state.priv;
retval = kenwood_get_if(rig);
if (retval != RIG_OK)
return retval;
memcpy(buf, &priv->info[18], 5);
buf[5] = '\0';
*rit = atoi(buf);
return RIG_OK;
}
/*
* rit can only move up/down by 10 Hz, so we use a loop...
*/
int kenwood_set_rit(RIG * rig, vfo_t vfo, shortfreq_t rit)
{
char buf[4];
int retval, i;
if (rit == 0)
return kenwood_simple_cmd(rig, "RC");
sprintf(buf, "R%c", (rit > 0) ? 'U' : 'D');
retval = kenwood_simple_cmd(rig, "RC");
if (retval != RIG_OK)
return retval;
for (i = 0; i < abs(rint(rit/10)); i++)
retval = kenwood_simple_cmd(rig, buf);
return retval;
}
/*
* rit and xit are the same
*/
int kenwood_get_xit(RIG * rig, vfo_t vfo, shortfreq_t * rit)
{
return kenwood_get_rit(rig, vfo, rit);
}
int kenwood_set_xit(RIG * rig, vfo_t vfo, shortfreq_t rit)
{
return kenwood_set_rit(rig, vfo, rit);
}
int kenwood_scan(RIG * rig, vfo_t vfo, scan_t scan, int ch)
{
return kenwood_simple_cmd(rig,
scan == RIG_SCAN_STOP ? "SC0" : "SC1");
}
/*
* 000 No select
* 002 FM Wide
* 003 FM Narrow
* 005 AM
* 007 SSB
* 009 CW
* 010 CW NARROW
*/
/* XXX revise */
static int kenwood_set_filter(RIG *rig, pbwidth_t width)
{
char *cmd;
if (width <= Hz(250))
cmd = "FL010009";
else if(width <= Hz(500))
cmd = "FL009009";
else if(width <= kHz(2.7))
cmd = "FL007007";
else if(width <= kHz(6))
cmd = "FL005005";
else
cmd = "FL002002";
return kenwood_simple_cmd(rig, cmd);
}
/*
* kenwood_set_mode
* Assumes rig!=NULL
*/
int kenwood_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
struct kenwood_priv_caps *caps = kenwood_caps(rig);
char buf[6];
char kmode;
int err;
kmode = rmode2kenwood(mode, caps->mode_table);
if (kmode < 0 ) {
rig_debug(RIG_DEBUG_WARN, "%s: unsupported mode '%s'\n",
__func__, rig_strrmode(mode));
return -RIG_EINVAL;
}
sprintf(buf, "MD%c", '0' + kmode);
err = kenwood_simple_cmd(rig, buf);
if (err != RIG_OK)
return err;
if (rig->caps->rig_model == RIG_MODEL_TS450S
|| rig->caps->rig_model == RIG_MODEL_TS690S
|| rig->caps->rig_model == RIG_MODEL_TS850) {
err = kenwood_set_filter(rig, width);
/* non fatal */
}
return RIG_OK;
}
static int kenwood_get_filter(RIG *rig, pbwidth_t *width)
{
int err, f, f1, f2;
char buf[10];
err = kenwood_safe_transaction(rig, "FL", buf, sizeof(buf), 9);
if (err != RIG_OK)
return err;
buf[8] = '\0';
f2 = atoi(&buf[5]);
buf[5] = '\0';
f1 = atoi(&buf[2]);
if (f2 > f1)
f = f2;
else
f = f1;
switch (f) {
case 2:
*width = kHz(12);
break;
case 3:
case 5:
*width = kHz(6);
break;
case 7:
*width = kHz(2.7);
break;
case 9:
*width = Hz(500);
break;
case 10:
*width = Hz(250);
break;
}
return RIG_OK;
}
/*
* kenwood_get_mode
* Assumes rig!=NULL, mode!=NULL
*/
int kenwood_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
struct kenwood_priv_caps *caps = kenwood_caps(rig);
char modebuf[10];
int retval;
retval = kenwood_safe_transaction(rig, "MD", modebuf, 6, 4);
if (retval != RIG_OK)
return retval;
*mode = kenwood2rmode(modebuf[2] - '0', caps->mode_table);
/* XXX ? */
*width = rig_passband_normal(rig, *mode);
return RIG_OK;
}
/* This is used when the radio does not support MD; for mode reading */
int kenwood_get_mode_if(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
int err;
struct kenwood_priv_caps *caps = kenwood_caps(rig);
struct kenwood_priv_data *priv = rig->state.priv;
err = kenwood_get_if(rig);
if (err != RIG_OK)
return err;
*mode = kenwood2rmode(priv->info[29] - '0', caps->mode_table);
*width = rig_passband_normal(rig, *mode);
if (rig->caps->rig_model == RIG_MODEL_TS450S
|| rig->caps->rig_model == RIG_MODEL_TS690S
|| rig->caps->rig_model == RIG_MODEL_TS850) {
err = kenwood_get_filter(rig, width);
/* non fatal */
}
return RIG_OK;
}
int kenwood_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
char levelbuf[16];
int i, kenwood_val;
if (RIG_LEVEL_IS_FLOAT(level))
kenwood_val = val.f * 255;
else
kenwood_val = val.i;
switch (level) {
case RIG_LEVEL_RFPOWER:
/* XXX check level range */
sprintf(levelbuf, "PC%03d", kenwood_val);
break;
case RIG_LEVEL_AF:
sprintf(levelbuf, "AG%03d", kenwood_val);
break;
case RIG_LEVEL_RF:
/* XXX check level range */
sprintf(levelbuf, "RG%03d", kenwood_val);
break;
case RIG_LEVEL_SQL:
sprintf(levelbuf, "SQ%03d", kenwood_val);
break;
case RIG_LEVEL_AGC:
if (kenwood_val > 3)
kenwood_val = 3; /* 0.. 255 */
sprintf(levelbuf, "GT%03d", 84*kenwood_val);
break;
case RIG_LEVEL_ATT:
/* set the attenuator if a correct value is entered */
if (val.i == 0)
sprintf(levelbuf, "RA00");
else {
for (i=0; i<MAXDBLSTSIZ && rig->state.attenuator[i]; i++) {
if (val.i == rig->state.attenuator[i])
{
sprintf(levelbuf, "RA%02d", i+1);
break;
}
}
if (val.i != rig->state.attenuator[i])
return -RIG_EINVAL;
}
break;
case RIG_LEVEL_PREAMP:
/* set the preamp if a correct value is entered */
if (val.i == 0)
sprintf(levelbuf, "PA0");
else {
for (i=0; i<MAXDBLSTSIZ && rig->state.preamp[i]; i++) {
if (val.i == rig->state.preamp[i])
{
sprintf(levelbuf, "PA%01d", i+1);
break;
}
}
if (val.i != rig->state.preamp[i])
return -RIG_EINVAL;
}
break;
case RIG_LEVEL_SLOPE_HIGH:
if(val.i>20 || val.i < 0)
return -RIG_EINVAL;
sprintf(levelbuf, "SH%02d",(val.i));
break;
case RIG_LEVEL_SLOPE_LOW:
if(val.i>20 || val.i < 0)
return -RIG_EINVAL;
sprintf(levelbuf, "SL%02d",(val.i));
break;
case RIG_LEVEL_CWPITCH:
if(val.i > 1000 || val.i < 400)
return -RIG_EINVAL;
sprintf(levelbuf, "PT%02d", (val.i / 50) - 8);
break;
case RIG_LEVEL_KEYSPD:
if(val.i > 50 || val.i < 5)
return -RIG_EINVAL;
sprintf(levelbuf, "KS%03d", val.i);
break;
default:
rig_debug(RIG_DEBUG_ERR, "Unsupported set_level %d", level);
return -RIG_EINVAL;
}
return kenwood_simple_cmd(rig, levelbuf);
}
/*
* assumes f!=NULL
*/
int get_kenwood_level(RIG *rig, const char *cmd, int cmd_len, float *f)
{
char lvlbuf[10];
int retval;
int lvl;
retval = kenwood_safe_transaction(rig, cmd, lvlbuf, 10, 6);
if (retval != RIG_OK)
return retval;
/* 000..255 */
sscanf(lvlbuf+2, "%d", &lvl);
*f = (float)lvl/255.0;
return RIG_OK;
};
/*
* kenwood_get_level
* Assumes rig!=NULL, val!=NULL
*/
int kenwood_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
char lvlbuf[50];
int retval;
int lvl;
int i, ret, agclevel;
size_t lvl_len;
switch (level) {
case RIG_LEVEL_RAWSTR:
retval = kenwood_safe_transaction(rig, "SM", lvlbuf, 10, 7);
if (retval != RIG_OK)
return retval;
/* XXX atoi ? */
sscanf(lvlbuf+2, "%d", &val->i); /* rawstr */
break;
case RIG_LEVEL_STRENGTH:
retval = kenwood_safe_transaction(rig, "SM", lvlbuf, 10, 7);
if (retval != RIG_OK)
return retval;
sscanf(lvlbuf+2, "%d", &val->i); /* rawstr */
if (rig->caps->str_cal.size)
val->i = (int) rig_raw2val(val->i, &rig->caps->str_cal);
else
val->i = (val->i * 4) - 54;
break;
case RIG_LEVEL_ATT:
retval = kenwood_safe_transaction(rig, "RA", lvlbuf, 50, 5);
if (retval != RIG_OK)
return retval;
sscanf(lvlbuf+2, "%d", &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, "%s: "
"unexpected att level %d\n",
__func__, lvl);
return -RIG_EPROTO;
}
}
if (i != lvl)
return -RIG_EINTERNAL;
val->i = rig->state.attenuator[i-1];
}
break;
case RIG_LEVEL_PREAMP:
retval = kenwood_safe_transaction(rig, "PA", lvlbuf, 50, 4);
if (retval != RIG_OK)
return retval;
if (lvlbuf[2] == '0')
val->i = 0;
else if (isdigit(lvlbuf[2])) {
lvl = lvlbuf[2]-'0';
for (i=0; i<lvl && i<MAXDBLSTSIZ; i++) {
if (rig->state.preamp[i] == 0) {
rig_debug(RIG_DEBUG_ERR,"%s: "
"unexpected preamp level %d\n",
__func__, lvl);
return -RIG_EPROTO;
}
}
if (i != lvl)
return -RIG_EINTERNAL;
val->i = rig->state.preamp[i-1];
} else {
rig_debug(RIG_DEBUG_ERR,"%s: "
"unexpected preamp char '%c'\n",
__func__, lvlbuf[2]);
return -RIG_EPROTO;
}
break;
case RIG_LEVEL_RFPOWER:
return get_kenwood_level(rig, "PC", 3, &val->f);
case RIG_LEVEL_AF:
return get_kenwood_level(rig, "AG", 3, &val->f);
case RIG_LEVEL_RF:
return get_kenwood_level(rig, "RG", 3, &val->f);
case RIG_LEVEL_SQL:
return get_kenwood_level(rig, "SQ", 3, &val->f);
case RIG_LEVEL_MICGAIN:
return get_kenwood_level(rig, "MG", 3, &val->f);
case RIG_LEVEL_AGC:
ret = get_kenwood_level(rig, "GT", 3, &val->f);
agclevel = 255 * val->f;
if (agclevel == 0) val->i = 0;
else if (agclevel < 85) val->i = 1;
else if (agclevel < 170) val->i = 2;
else if (agclevel <= 255) val->i = 3;
return ret;
case RIG_LEVEL_SLOPE_LOW:
lvl_len = 50;
retval = kenwood_transaction (rig, "SL", 3, lvlbuf, &lvl_len);
if (retval != RIG_OK)
return retval;
lvlbuf[4]='\0';
val->i=atoi(&lvlbuf[2]);
break;
case RIG_LEVEL_SLOPE_HIGH:
lvl_len = 50;
retval = kenwood_transaction (rig, "SH", 3, lvlbuf, &lvl_len);
if (retval != RIG_OK)
return retval;
lvlbuf[4]='\0';
val->i=atoi(&lvlbuf[2]);
break;
case RIG_LEVEL_CWPITCH:
retval = kenwood_safe_transaction(rig, "PT", lvlbuf, 50, 5);
if (retval != RIG_OK)
return retval;
sscanf(lvlbuf+2, "%d", &val->i);
val->i = (val->i * 1000) + 1000; /* 00 - 08 */
break;
case RIG_LEVEL_KEYSPD:
retval = kenwood_safe_transaction(rig, "KS", lvlbuf, 50, 6);
if (retval != RIG_OK)
return retval;
sscanf(lvlbuf+2, "%d", &val->i);
break;
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_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 %d", level);
return -RIG_EINVAL;
}
return RIG_OK;
}
int kenwood_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
{
char buf[6]; /* longest cmd is GTxxx */
switch (func) {
case RIG_FUNC_NB:
sprintf(buf, "NB%c", (status == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
case RIG_FUNC_ABM:
sprintf(buf, "AM%c", (status == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
case RIG_FUNC_COMP:
sprintf(buf, "PR%c", (status == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
case RIG_FUNC_TONE:
sprintf(buf, "TO%c", (status == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
case RIG_FUNC_TSQL:
sprintf(buf, "CT%c", (status == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
case RIG_FUNC_VOX:
sprintf(buf, "VX%c", (status == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
case RIG_FUNC_FAGC:
sprintf(buf, "GT00%c", (status == 0) ? '4' : '2');
return kenwood_simple_cmd(rig, buf);
case RIG_FUNC_NR:
sprintf(buf, "NR%c", (status == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
case RIG_FUNC_BC:
sprintf(buf, "BC%c", (status == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
case RIG_FUNC_ANF:
sprintf(buf, "NT%c", (status == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
case RIG_FUNC_LOCK:
sprintf(buf, "LK%c", (status == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
case RIG_FUNC_AIP:
sprintf(buf, "MX%c", (status == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
default:
rig_debug(RIG_DEBUG_ERR, "Unsupported set_func %#x", func);
return -RIG_EINVAL;
}
return -RIG_EINVAL;
}
/*
* assumes status!=NULL
* works for any 'format 1' command
* answer is always 4 bytes: two byte command id, status and terminator
*/
static int get_kenwood_func(RIG *rig, const char *cmd, int *status)
{
int retval;
char buf[10];
retval = kenwood_safe_transaction(rig, cmd, buf, 10, 4);
if (retval != RIG_OK)
return retval;
*status = buf[2] == '0' ? 0 : 1;
return RIG_OK;
};
/*
* kenwood_get_func
* Assumes rig!=NULL, val!=NULL
*/
int kenwood_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
{
char fctbuf[20];
int retval;
switch (func) {
case RIG_FUNC_FAGC:
retval = kenwood_safe_transaction(rig, "GT", fctbuf, 20, 6);
if (retval != RIG_OK)
return retval;
*status = fctbuf[4] != '4' ? 1 : 0;
return RIG_OK;
case RIG_FUNC_NB:
return get_kenwood_func(rig, "NB", status);
case RIG_FUNC_ABM:
return get_kenwood_func(rig, "AM", status);
case RIG_FUNC_COMP:
return get_kenwood_func(rig, "PR", status);
case RIG_FUNC_TONE:
return get_kenwood_func(rig, "TO", status);
case RIG_FUNC_TSQL:
return get_kenwood_func(rig, "CT", status);
case RIG_FUNC_VOX:
return get_kenwood_func(rig, "VX", status);
case RIG_FUNC_NR:
return get_kenwood_func(rig, "NR", status);
/* FIXME on TS2000 */
case RIG_FUNC_BC:
return get_kenwood_func(rig, "BC", status);
case RIG_FUNC_ANF:
return get_kenwood_func(rig, "NT", status);
case RIG_FUNC_LOCK:
return get_kenwood_func(rig, "LK", status);
case RIG_FUNC_AIP:
return get_kenwood_func(rig, "MX", status);
default:
rig_debug(RIG_DEBUG_ERR, "Unsupported get_func %#x", func);
return -RIG_EINVAL;
}
return -RIG_EINVAL;
}
/*
* 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
*/
int kenwood_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
{
const struct rig_caps *caps;
char tonebuf[16];
int i;
caps = rig->caps;
/* TODO: replace 200 by something like RIGTONEMAX */
for (i = 0; caps->ctcss_list[i] != 0 && i<200; i++) {
if (caps->ctcss_list[i] == tone)
break;
}
if (caps->ctcss_list[i] != tone)
return -RIG_EINVAL;
/* TODO: replace menu no 57 by a define */
sprintf(tonebuf, "EX%03d%04d", 57, i+1);
return kenwood_simple_cmd(rig, tonebuf);
}
int kenwood_set_ctcss_tone_tn(RIG *rig, vfo_t vfo, tone_t tone)
{
const struct rig_caps *caps = rig->caps;
char buf[6];
int i;
/* XXX 38 is a fixed constant */
for (i = 0; caps->ctcss_list[i] != 0 && i < 38; i++) {
if (tone == caps->ctcss_list[i])
break;
}
if (tone != caps->ctcss_list[i])
return -RIG_EINVAL;
sprintf(buf, "TN%02d", i + 1);
return kenwood_simple_cmd(rig, buf);
}
/*
* kenwood_get_ctcss_tone
* Assumes rig!=NULL, rig->state.priv!=NULL
*/
int kenwood_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone)
{
struct kenwood_priv_data *priv = rig->state.priv;
const struct rig_caps *caps;
char tonebuf[3];
int i, retval;
unsigned int tone_idx;
caps = rig->caps;
retval = kenwood_get_if(rig);
if (retval != RIG_OK)
return retval;
memcpy(tonebuf, &priv->info[34], 2);
tonebuf[2] = '\0';
tone_idx = atoi(tonebuf);
if (tone_idx == 0) {
rig_debug(RIG_DEBUG_ERR, "%s: CTCSS tone is zero (%s)\n",
__func__, tonebuf);
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, "%s: CTCSS NG (%04d)\n",
__func__, tone_idx);
return -RIG_EPROTO;
}
}
*tone = caps->ctcss_list[tone_idx-1];
return RIG_OK;
}
/*
* set the aerial/antenna to use
*/
int kenwood_set_ant(RIG * rig, vfo_t vfo, ant_t ant)
{
const char *cmd;
switch (ant) {
case RIG_ANT_1:
cmd = "AN1";
break;
case RIG_ANT_2:
cmd = "AN2";
break;
case RIG_ANT_3:
cmd = "AN3";
break;
case RIG_ANT_4:
cmd = "AN4";
break;
default:
return -RIG_EINVAL;
}
return kenwood_simple_transaction(rig, cmd, 4);
}
int kenwood_set_ant_no_ack(RIG * rig, vfo_t vfo, ant_t ant)
{
const char *cmd;
switch (ant) {
case RIG_ANT_1:
cmd = "AN1";
break;
case RIG_ANT_2:
cmd = "AN2";
break;
case RIG_ANT_3:
cmd = "AN3";
break;
case RIG_ANT_4:
cmd = "AN4";
break;
default:
return -RIG_EINVAL;
}
return kenwood_simple_cmd(rig, cmd);
}
/*
* get the aerial/antenna in use
*/
int kenwood_get_ant (RIG * rig, vfo_t vfo, ant_t * ant)
{
char ackbuf[6];
int retval;
retval = kenwood_safe_transaction(rig, "AN", ackbuf, 6, 4);
if (retval != RIG_OK)
return retval;
if (ackbuf[2] < '1' || ackbuf[2] > '9')
return -RIG_EPROTO;
*ant = RIG_ANT_N(ackbuf[2]-'1');
/* XXX check that the returned antenna is valid for the current rig */
return RIG_OK;
}
/*
* kenwood_get_ptt
* Assumes rig!=NULL, ptt!=NULL
*/
int kenwood_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
{
struct kenwood_priv_data *priv = rig->state.priv;
int retval;
retval = kenwood_get_if(rig);
if (retval != RIG_OK)
return retval;
*ptt = priv->info[28] == '0' ? RIG_PTT_OFF : RIG_PTT_ON;
return RIG_OK;
}
/*
* kenwood_set_ptt
* Assumes rig!=NULL
*/
int kenwood_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
{
return kenwood_simple_cmd(rig,
(ptt == RIG_PTT_ON) ? "TX" : "RX");
}
int kenwood_set_ptt_safe(RIG *rig, vfo_t vfo, ptt_t ptt)
{
int err;
ptt_t current_ptt;
err = kenwood_get_ptt(rig, vfo, &current_ptt);
if (err != RIG_OK)
return err;
if (current_ptt == ptt)
return RIG_OK;
return kenwood_simple_cmd(rig,
(ptt == RIG_PTT_ON) ? "TX" : "RX");
}
/*
* kenwood_get_dcd
* Assumes rig!=NULL, dcd!=NULL
*/
int kenwood_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
{
char busybuf[10];
int retval;
retval = kenwood_safe_transaction(rig, "BY", busybuf, 10, 4);
if (retval != RIG_OK)
return retval;
*dcd = (busybuf[2] == '1') ? RIG_DCD_ON : RIG_DCD_OFF;
return RIG_OK;
}
/*
* kenwood_set_trn
* Assumes rig!=NULL
*/
int kenwood_set_trn(RIG *rig, int trn)
{
return kenwood_simple_transaction(rig,
(trn == RIG_TRN_RIG) ? "AI1" : "AI0", 4);
}
/*
* kenwood_get_trn
* Assumes rig!=NULL, trn!=NULL
*/
int kenwood_get_trn(RIG *rig, int *trn)
{
char trnbuf[6];
int retval;
retval = kenwood_safe_transaction(rig, "AI", trnbuf, 6, 4);
if (retval != RIG_OK)
return retval;
*trn = trnbuf[2] != '0' ? RIG_TRN_RIG : RIG_TRN_OFF;
return RIG_OK;
}
/*
* kenwood_set_powerstat
* Assumes rig!=NULL
*/
int kenwood_set_powerstat(RIG *rig, powerstat_t status)
{
return kenwood_simple_transaction(rig,
(status == RIG_POWER_ON) ? "PS1" : "PS0", 4);
}
/*
* kenwood_get_powerstat
* Assumes rig!=NULL, trn!=NULL
*/
int kenwood_get_powerstat(RIG *rig, powerstat_t *status)
{
char pwrbuf[6];
int retval;
retval = kenwood_safe_transaction(rig, "PS", pwrbuf, 6, 4);
if (retval != RIG_OK)
return retval;
*status = pwrbuf[2] == '0' ? RIG_POWER_OFF : RIG_POWER_ON;
return RIG_OK;
}
/*
* kenwood_reset
* Assumes rig!=NULL
*/
int kenwood_reset(RIG *rig, reset_t reset)
{
char rstbuf[6];
char rst;
switch(reset) {
case RIG_RESET_VFO:
rst = '1';
break;
case RIG_RESET_MASTER:
rst = '2';
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported reset %d\n",
__func__, reset);
return -RIG_EINVAL;
}
sprintf(rstbuf, "SR%c", rst);
/* this command has no answer */
return kenwood_simple_cmd(rig, rstbuf);
}
/*
* kenwood_send_morse
* Assumes rig!=NULL
*/
int kenwood_send_morse(RIG *rig, vfo_t vfo, const char *msg)
{
char morsebuf[30], m2[30];
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.
*
* Make the total message segments 28 characters
* in length because Kenwood demands it.
* Spaces fill in the message end.
*/
buff_len = msg_len > 24 ? 24 : msg_len;
strncpy(m2, p, 24);
m2[24] = '\0';
/* the command must consist of 28 bytes */
sprintf(morsebuf, "KY %-24s", m2);
retval = kenwood_simple_cmd(rig, morsebuf);
if (retval != RIG_OK)
return retval;
msg_len -= buff_len;
p += buff_len;
}
return RIG_OK;
}
/*
* kenwood_vfo_op
* Assumes rig!=NULL
*/
int kenwood_vfo_op(RIG *rig, vfo_t vfo, vfo_op_t op)
{
switch(op) {
case RIG_OP_UP:
return kenwood_simple_cmd(rig, "UP");
case RIG_OP_DOWN:
return kenwood_simple_cmd(rig, "DN");
case RIG_OP_BAND_UP:
return kenwood_simple_cmd(rig, "BU");
case RIG_OP_BAND_DOWN:
return kenwood_simple_cmd(rig, "BD");
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported op %#x\n",
__func__, op);
return -RIG_EINVAL;
}
}
/*
* kenwood_set_mem
* Assumes rig!=NULL
*/
int kenwood_set_mem(RIG *rig, vfo_t vfo, int ch)
{
char buf[8];
/*
* "MCbmm;"
* where b is the bank number, mm the memory number.
* b can be a space
*/
sprintf(buf, "MC %02d", ch);
return kenwood_simple_cmd(rig, buf);
}
/*
* kenwood_get_mem
* Assumes rig!=NULL
*/
int kenwood_get_mem(RIG *rig, vfo_t vfo, int *ch)
{
char membuf[10];
int retval;
/*
* "MCbmm;"
* where b is the bank number, mm the memory number.
* b can be a space
*/
retval = kenwood_safe_transaction(rig, "MC", membuf, 10, 6);
if (retval != RIG_OK)
return retval;
*ch = atoi(membuf+2);
return RIG_OK;
}
int kenwood_get_mem_if(RIG *rig, vfo_t vfo, int *ch)
{
int err;
char buf[4];
struct kenwood_priv_data *priv = rig->state.priv;
err = kenwood_get_if(rig);
if (err != RIG_OK)
return err;
memcpy(buf, &priv->info[26], 2);
buf[2] = '\0';
*ch = atoi(buf);
return RIG_OK;
}
int kenwood_get_channel(RIG *rig, channel_t *chan)
{
int err;
char buf[26];
char cmd[8];
struct kenwood_priv_caps *caps = kenwood_caps(rig);
/* put channel num in the command string */
sprintf(cmd, "MR0 %02d", chan->channel_num);
err = kenwood_safe_transaction(rig, cmd, buf, 26, 24);
if (err != RIG_OK)
return err;
memset(chan, 0x00, sizeof(channel_t));
chan->vfo = RIG_VFO_VFO;
/* MR0 1700005890000510 ;
* MRs ccfffffffffffMLTtt ;
*/
/* parse from right to left */
/* XXX based on the available documentation, there is no command
* to read out the filters of a given memory channel. The rig, however,
* stores this information.
*/
if (buf[19] == '0' || buf[19] == ' ')
chan->ctcss_tone = 0;
else {
buf[22] = '\0';
if (rig->caps->ctcss_list)
chan->ctcss_tone = rig->caps->ctcss_list[atoi(&buf[20])];
}
/* memory lockout */
if (buf[18] == '1')
chan->flags |= RIG_CHFLAG_SKIP;
chan->mode = kenwood2rmode(buf[17] - '0', caps->mode_table);
buf[17] = '\0';
chan->freq = atoi(&buf[6]);
if (chan->freq == RIG_FREQ_NONE)
return -RIG_ENAVAIL;
buf[6] = '\0';
chan->channel_num = atoi(&buf[4]);
/* split freq */
cmd[2] = '1';
err = kenwood_safe_transaction(rig, cmd, buf, 26, 24);
if (err != RIG_OK)
return err;
chan->tx_mode = kenwood2rmode(buf[17] - '0', caps->mode_table);
buf[17] = '\0';
chan->tx_freq = atoi(&buf[6]);
if (chan->freq == chan->tx_freq) {
chan->tx_freq = RIG_FREQ_NONE;
chan->tx_mode = RIG_MODE_NONE;
chan->split = RIG_SPLIT_OFF;
} else
chan->split = RIG_SPLIT_ON;
return RIG_OK;
}
int kenwood_set_channel(RIG *rig, const channel_t *chan)
{
char buf[26];
char mode, tx_mode = 0;
int err;
int tone = 0;
struct kenwood_priv_caps *caps = kenwood_caps(rig);
mode = rmode2kenwood(chan->mode, caps->mode_table);
if (mode < 0 ) {
rig_debug(RIG_DEBUG_ERR, "%s: unsupported mode '%s'\n",
__func__, rig_strrmode(chan->mode));
return -RIG_EINVAL;
}
if (chan->split == RIG_SPLIT_ON) {
tx_mode = rmode2kenwood(chan->tx_mode, caps->mode_table);
if (tx_mode < 0 ) {
rig_debug(RIG_DEBUG_ERR, "%s: unsupported mode '%s'\n",
__func__, rig_strrmode(chan->tx_mode));
return -RIG_EINVAL;
}
}
/* find tone */
if (chan->ctcss_tone) {
for (tone = 0; rig->caps->ctcss_list[tone] != 0; tone++) {
if (chan->ctcss_tone == rig->caps->ctcss_list[tone])
break;
}
if (chan->ctcss_tone != rig->caps->ctcss_list[tone])
tone = 0;
}
sprintf(buf, "MW0 %02d%011d%c%c%c%02d ", /* note the space at the end */
chan->channel_num,
(int) chan->freq,
'0' + mode,
(chan->flags & RIG_CHFLAG_SKIP) ? '1' : '0',
chan->ctcss_tone ? '1' : '0',
chan->ctcss_tone ? (tone + 1) : 0);
err = kenwood_simple_cmd(rig, buf);
if (err != RIG_OK)
return err;
sprintf(buf, "MW1 %02d%011d%c%c%c%02d ",
chan->channel_num,
(chan->split == RIG_SPLIT_ON) ? ((int) chan->tx_freq) : 0,
(chan->split == RIG_SPLIT_ON) ? ('0' + tx_mode) : '0',
(chan->flags & RIG_CHFLAG_SKIP) ? '1' : '0',
chan->ctcss_tone ? '1' : '0',
chan->ctcss_tone ? (tone + 1) : 0);
return kenwood_simple_cmd(rig, buf);
}
int kenwood_set_ext_parm(RIG *rig, token_t token, value_t val)
{
char buf[4];
switch (token) {
case TOK_VOICE:
return kenwood_simple_cmd(rig, "VR");
case TOK_FINE:
sprintf(buf, "FS%c", (val.i == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
case TOK_XIT:
sprintf(buf, "XT%c", (val.i == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
case TOK_RIT:
sprintf(buf, "RT%c", (val.i == 0) ? '0' : '1');
return kenwood_simple_cmd(rig, buf);
}
return -RIG_EINVAL;
}
int kenwood_get_ext_parm(RIG *rig, token_t token, value_t *val)
{
int err;
struct kenwood_priv_data *priv = rig->state.priv;
switch (token) {
case TOK_FINE:
return get_kenwood_func(rig, "FS", &val->i);
case TOK_XIT:
err = kenwood_get_if(rig);
if (err != RIG_OK)
return err;
val->i = (priv->info[24] == '1') ? 1 : 0;
return RIG_OK;
case TOK_RIT:
err = kenwood_get_if(rig);
if (err != RIG_OK)
return err;
val->i = (priv->info[23] == '1') ? 1 : 0;
return RIG_OK;
}
return -RIG_ENIMPL;
}
/*
* kenwood_get_info
* supposed to work only for TS2000...
* Assumes rig!=NULL
*/
const char* kenwood_get_info(RIG *rig)
{
char firmbuf[10];
int retval;
retval = kenwood_safe_transaction(rig, "TY", firmbuf, 10, 6);
if (retval != RIG_OK)
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
/*
* proberigs_kenwood
*
* Notes:
* There's only one rig possible per port.
*
* rig_model_t probeallrigs_kenwood(port_t *port, rig_probe_func_t cfunc, rig_ptr_t data)
*/
DECLARE_PROBERIG_BACKEND(kenwood)
{
char idbuf[IDBUFSZ];
int id_len=-1, i, k_id;
int retval=-1;
int rates[] = { 115200, 57600, 9600, 4800, 1200, 0 }; /* possible baud rates */
int rates_idx;
if (!port)
return RIG_MODEL_NONE;
if (port->type.rig != RIG_PORT_SERIAL)
return RIG_MODEL_NONE;
port->write_delay = port->post_write_delay = 0;
port->parm.serial.stop_bits = 2;
port->retry = 1;
/*
* try for all different baud rates
*/
for (rates_idx = 0; rates[rates_idx]; rates_idx++) {
port->parm.serial.rate = rates[rates_idx];
port->timeout = 2*1000/rates[rates_idx] + 50;
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, ";\r", 2);
close(port->fd);
if (retval != RIG_OK || id_len < 0)
continue;
}
if (retval != RIG_OK || id_len < 0 || !strcmp(idbuf, "ID;"))
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_kenwood: protocol error, "
" expected %d, received %d: %s\n",
6, id_len, idbuf);
return RIG_MODEL_NONE;
}
/* first, try ID string */
for (i=0; kenwood_id_string_list[i].model != RIG_MODEL_NONE; i++) {
if (!strncmp(kenwood_id_string_list[i].id, idbuf+2, 16)) {
rig_debug(RIG_DEBUG_VERBOSE, "probe_kenwood: "
"found %s\n", idbuf+2);
if (cfunc)
(*cfunc)(port, kenwood_id_string_list[i].model, data);
return kenwood_id_string_list[i].model;
}
}
/* then, try ID numbers */
k_id = atoi(idbuf+2);
/*
* Elecraft K2 returns same ID as TS570
*/
if (k_id == 17) {
retval = serial_open(port);
if (retval != RIG_OK)
return RIG_MODEL_NONE;
retval = write_block(port, "K2;", 3);
id_len = read_string(port, idbuf, IDBUFSZ, ";\r", 2);
close(port->fd);
if (retval != RIG_OK)
return RIG_MODEL_NONE;
/*
* reply should be something like 'K2n;'
*/
if (id_len == 4 || !strcmp(idbuf, "K2")) {
rig_debug(RIG_DEBUG_VERBOSE, "probe_kenwood: found K2\n");
if (cfunc)
(*cfunc)(port, RIG_MODEL_K2, data);
return RIG_MODEL_K2;
}
}
for (i=0; kenwood_id_list[i].model != RIG_MODEL_NONE; i++) {
if (kenwood_id_list[i].id == k_id) {
rig_debug(RIG_DEBUG_VERBOSE, "probe_kenwood: "
"found %03d\n", k_id);
if (cfunc)
(*cfunc)(port, kenwood_id_list[i].model, data);
return kenwood_id_list[i].model;
}
}
/*
* not found in known table....
* update kenwood_id_list[]!
*/
rig_debug(RIG_DEBUG_WARN, "probe_kenwood: found unknown device "
"with ID %03d, please report to Hamlib "
"developers.\n", k_id);
return RIG_MODEL_NONE;
}
/*
* initrigs_kenwood is called by rig_backend_load
*/
DECLARE_INITRIG_BACKEND(kenwood)
{
rig_debug(RIG_DEBUG_VERBOSE, "kenwood: _init called\n");
rig_register(&ts950sdx_caps);
rig_register(&ts50s_caps);
rig_register(&ts140_caps);
rig_register(&ts450s_caps);
rig_register(&ts570d_caps);
rig_register(&ts570s_caps);
rig_register(&ts680s_caps);
rig_register(&ts690s_caps);
rig_register(&ts790_caps);
rig_register(&ts850_caps);
rig_register(&ts870s_caps);
rig_register(&ts930_caps);
rig_register(&ts2000_caps);
rig_register(&trc80_caps);
rig_register(&k2_caps);
rig_register(&k3_caps);
rig_register(&ts440_caps);
rig_register(&ts940_caps);
rig_register(&ts711_caps);
rig_register(&ts811_caps);
rig_register(&r5000_caps);
rig_register(&tmd700_caps);
rig_register(&thd7a_caps);
rig_register(&thf7e_caps);
rig_register(&thg71_caps);
rig_register(&tmv7_caps);
rig_register(&ts480_caps);
return RIG_OK;
}
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik