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

applied astyle on thd74.c

pull/19/head
Sebastian Denz 2018-05-01 13:56:30 +02:00
rodzic c907a512c8
commit d06e4c306f
1 zmienionych plików z 401 dodań i 286 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

687
kenwood/thd74.c
Wyświetl plik

@ -35,7 +35,7 @@
#include "serial.h"
#define THD74_MODES (RIG_MODE_FM|RIG_MODE_AM)
#define THD74_MODES (RIG_MODE_FM|RIG_MODE_AM)
#define THD74_MODES_TX (RIG_MODE_FM)
#define THD74_FUNC_ALL (RIG_FUNC_TSQL| \
@ -53,7 +53,7 @@
RIG_LEVEL_RF|\
RIG_LEVEL_MICGAIN)
#define THD74_PARMS (RIG_PARM_BACKLIGHT)
#define THD74_PARMS (RIG_PARM_BACKLIGHT)
#define THD74_VFO_OP (RIG_OP_NONE)
@ -62,26 +62,28 @@
*/
#define THD74_VFO (RIG_VFO_A|RIG_VFO_B)
static rmode_t td74_mode_table[KENWOOD_MODE_TABLE_MAX] = {
[0] = RIG_MODE_FM,
[1] = RIG_MODE_DR,
[2] = RIG_MODE_AM,
[3] = RIG_MODE_LSB,
[4] = RIG_MODE_USB,
[5] = RIG_MODE_CW,
[6] = RIG_MODE_FMN,
[7] = RIG_MODE_DR,
[8] = RIG_MODE_WFM,
[9] = RIG_MODE_CWR,
static rmode_t td74_mode_table[KENWOOD_MODE_TABLE_MAX] =
{
[0] = RIG_MODE_FM,
[1] = RIG_MODE_DR,
[2] = RIG_MODE_AM,
[3] = RIG_MODE_LSB,
[4] = RIG_MODE_USB,
[5] = RIG_MODE_CW,
[6] = RIG_MODE_FMN,
[7] = RIG_MODE_DR,
[8] = RIG_MODE_WFM,
[9] = RIG_MODE_CWR,
};
static struct kenwood_priv_caps thd74_priv_caps = {
static struct kenwood_priv_caps thd74_priv_caps =
{
.cmdtrm = EOM_TH, /* Command termination character */
.mode_table = td74_mode_table,
};
//static int thd74_open(RIG *rig);
static int thd74_get_chan_all_cb (RIG * rig, chan_cb_t chan_cb, rig_ptr_t arg);
static int thd74_get_chan_all_cb(RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg);
static int thd74_get_freq(RIG *rig, vfo_t vfo, freq_t *freq);
static int thd74_set_freq(RIG *rig, vfo_t vfo, freq_t freq);
@ -93,121 +95,122 @@ static int thd74_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt);
/*
* th-d72a rig capabilities.
*/
const struct rig_caps thd74_caps = {
.rig_model = RIG_MODEL_THD74,
.model_name = "TH-D74",
.mfg_name = "Kenwood",
.version = TH_VER ".1",
.copyright = "LGPL",
.status = RIG_STATUS_ALPHA,
.rig_type = RIG_TYPE_HANDHELD|RIG_FLAG_APRS|RIG_FLAG_TNC|RIG_FLAG_DXCLUSTER,
.ptt_type = RIG_PTT_RIG,
.dcd_type = RIG_DCD_RIG,
.port_type = RIG_PORT_SERIAL,
.serial_rate_min = 9600,
.serial_rate_max = 9600,
.serial_data_bits = 8,
.serial_stop_bits = 1,
.serial_parity = RIG_PARITY_NONE,
.serial_handshake = RIG_HANDSHAKE_XONXOFF,
.write_delay = 100,
.post_write_delay = 100,
.timeout = 250,
.retry = 3,
const struct rig_caps thd74_caps =
{
.rig_model = RIG_MODEL_THD74,
.model_name = "TH-D74",
.mfg_name = "Kenwood",
.version = TH_VER ".1",
.copyright = "LGPL",
.status = RIG_STATUS_ALPHA,
.rig_type = RIG_TYPE_HANDHELD | RIG_FLAG_APRS | RIG_FLAG_TNC | RIG_FLAG_DXCLUSTER,
.ptt_type = RIG_PTT_RIG,
.dcd_type = RIG_DCD_RIG,
.port_type = RIG_PORT_SERIAL,
.serial_rate_min = 9600,
.serial_rate_max = 9600,
.serial_data_bits = 8,
.serial_stop_bits = 1,
.serial_parity = RIG_PARITY_NONE,
.serial_handshake = RIG_HANDSHAKE_XONXOFF,
.write_delay = 100,
.post_write_delay = 100,
.timeout = 250,
.retry = 3,
.has_get_func = THD74_FUNC_ALL,
.has_set_func = THD74_FUNC_ALL,
.has_get_level = THD74_LEVEL_ALL,
.has_set_level = RIG_LEVEL_SET(THD74_LEVEL_ALL),
.has_get_parm = THD74_PARMS,
.has_set_parm = THD74_PARMS, /* FIXME: parms */
.level_gran = {
.has_get_func = THD74_FUNC_ALL,
.has_set_func = THD74_FUNC_ALL,
.has_get_level = THD74_LEVEL_ALL,
.has_set_level = RIG_LEVEL_SET(THD74_LEVEL_ALL),
.has_get_parm = THD74_PARMS,
.has_set_parm = THD74_PARMS, /* FIXME: parms */
.level_gran = {
[LVL_RAWSTR] = { .min = { .i = 0 }, .max = { .i = 5 } },
[LVL_SQL] = { .min = { .i = 0 }, .max = { .i = 5 } },
[LVL_RFPOWER] = { .min = { .i = 3 }, .max = { .i = 0 } },
},
.parm_gran = {},
.ctcss_list = kenwood38_ctcss_list,
.dcs_list = NULL,
.preamp = { RIG_DBLST_END, },
.attenuator = { RIG_DBLST_END, },
.max_rit = Hz(0),
.max_xit = Hz(0),
.max_ifshift = Hz(0),
.vfo_ops = THD74_VFO_OP,
.targetable_vfo = RIG_TARGETABLE_FREQ,
.transceive = RIG_TRN_RIG,
.bank_qty = 0,
.chan_desc_sz = 6, /* TBC */
},
.parm_gran = {},
.ctcss_list = kenwood38_ctcss_list,
.dcs_list = NULL,
.preamp = { RIG_DBLST_END, },
.attenuator = { RIG_DBLST_END, },
.max_rit = Hz(0),
.max_xit = Hz(0),
.max_ifshift = Hz(0),
.vfo_ops = THD74_VFO_OP,
.targetable_vfo = RIG_TARGETABLE_FREQ,
.transceive = RIG_TRN_RIG,
.bank_qty = 0,
.chan_desc_sz = 6, /* TBC */
.chan_list = {
{ 0, 999, RIG_MTYPE_MEM , {TH_CHANNEL_CAPS}}, /* TBC MEM */
RIG_CHAN_END,
},
.chan_list = {
{ 0, 999, RIG_MTYPE_MEM, {TH_CHANNEL_CAPS}}, /* TBC MEM */
RIG_CHAN_END,
},
.rx_range_list1 = { RIG_FRNG_END, }, /* FIXME: enter region 1 setting */
.tx_range_list1 = { RIG_FRNG_END, },
.rx_range_list2 = {
{MHz(118),MHz(174),THD74_MODES,-1,-1,THD74_VFO},
{MHz(320),MHz(524),THD74_MODES,-1,-1,THD74_VFO},
RIG_FRNG_END,
}, /* rx range */
.tx_range_list2 = {
{MHz(144),MHz(148),THD74_MODES_TX,W(0.05),W(5),THD74_VFO},
{MHz(430),MHz(440),THD74_MODES_TX,W(0.05),W(5),THD74_VFO},
RIG_FRNG_END,
}, /* tx range */
.rx_range_list1 = { RIG_FRNG_END, }, /* FIXME: enter region 1 setting */
.tx_range_list1 = { RIG_FRNG_END, },
.rx_range_list2 = {
{MHz(118), MHz(174), THD74_MODES, -1, -1, THD74_VFO},
{MHz(320), MHz(524), THD74_MODES, -1, -1, THD74_VFO},
RIG_FRNG_END,
}, /* rx range */
.tx_range_list2 = {
{MHz(144), MHz(148), THD74_MODES_TX, W(0.05), W(5), THD74_VFO},
{MHz(430), MHz(440), THD74_MODES_TX, W(0.05), W(5), THD74_VFO},
RIG_FRNG_END,
}, /* tx range */
.tuning_steps = {
{THD74_MODES,kHz(5)},
{THD74_MODES,kHz(6.25)},
/* kHz(8.33) ?? */
{THD74_MODES,kHz(10)},
{THD74_MODES,kHz(12.5)},
{THD74_MODES,kHz(15)},
{THD74_MODES,kHz(20)},
{THD74_MODES,kHz(25)},
{THD74_MODES,kHz(30)},
{THD74_MODES,kHz(50)},
{THD74_MODES,kHz(100)},
RIG_TS_END,
},
/* mode/filter list, remember: order matters! */
.filters = {
{RIG_MODE_FM, kHz(14)},
{RIG_MODE_AM, kHz(9)},
RIG_FLT_END,
},
.priv = (void *)&thd74_priv_caps,
.tuning_steps = {
{THD74_MODES, kHz(5)},
{THD74_MODES, kHz(6.25)},
/* kHz(8.33) ?? */
{THD74_MODES, kHz(10)},
{THD74_MODES, kHz(12.5)},
{THD74_MODES, kHz(15)},
{THD74_MODES, kHz(20)},
{THD74_MODES, kHz(25)},
{THD74_MODES, kHz(30)},
{THD74_MODES, kHz(50)},
{THD74_MODES, kHz(100)},
RIG_TS_END,
},
/* mode/filter list, remember: order matters! */
.filters = {
{RIG_MODE_FM, kHz(14)},
{RIG_MODE_AM, kHz(9)},
RIG_FLT_END,
},
.priv = (void *)& thd74_priv_caps,
.rig_init = kenwood_init,
.rig_cleanup = kenwood_cleanup,
.rig_open = kenwood_open,
.set_vfo = th_set_vfo,
.get_vfo = th_get_vfo,
.rig_init = kenwood_init,
.rig_cleanup = kenwood_cleanup,
.rig_open = kenwood_open,
.set_vfo = th_set_vfo,
.get_vfo = th_get_vfo,
// need to understand
//.get_chan_all_cb = thd74_get_chan_all_cb,
.get_info = th_get_info,
.get_info = th_get_info,
// add functions step by step...
.set_freq = thd74_set_freq,
.get_freq = thd74_get_freq,
.set_trn = kenwood_set_trn,
.get_trn = kenwood_get_trn,
.set_freq = thd74_set_freq,
.get_freq = thd74_get_freq,
.set_trn = kenwood_set_trn,
.get_trn = kenwood_get_trn,
//.set_rit = kenwood_set_rit,
//.get_rit = kenwood_get_rit,
//.set_xit = kenwood_set_xit,
//.get_xit = kenwood_get_xit,
.set_mode = thd74_set_mode,
.get_mode = thd74_get_mode,
.set_mode = thd74_set_mode,
.get_mode = thd74_get_mode,
//.set_split_vfo = kenwood_set_split_vfo,
//.get_split_vfo = kenwood_get_split_vfo_if,
.get_ptt = kenwood_get_ptt,
.set_ptt = thd74_set_ptt,
.get_dcd = th_get_dcd,
.get_ptt = kenwood_get_ptt,
.set_ptt = thd74_set_ptt,
.get_dcd = th_get_dcd,
};
@ -216,30 +219,38 @@ const struct rig_caps thd74_caps = {
#define BLOCK_SZ 256
#define BLOCK_COUNT 256
static char thd74_get_vfo_letter(RIG *rig, vfo_t vfo){
unsigned char vfo_letter;
vfo_t tvfo;
static char thd74_get_vfo_letter(RIG *rig, vfo_t vfo)
{
unsigned char vfo_letter;
vfo_t tvfo;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
tvfo = (vfo==RIG_VFO_CURR || vfo==RIG_VFO_VFO) ? rig->state.current_vfo : vfo;
switch (tvfo) {
case RIG_VFO_A:
case RIG_VFO_MAIN:
vfo_letter = '0';
break;
case RIG_VFO_B:
case RIG_VFO_SUB:
vfo_letter = '1';
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
return -RIG_EINVAL;
}
return vfo_letter;
tvfo = (vfo == RIG_VFO_CURR
|| vfo == RIG_VFO_VFO) ? rig->state.current_vfo : vfo;
switch (tvfo)
{
case RIG_VFO_A:
case RIG_VFO_MAIN:
vfo_letter = '0';
break;
case RIG_VFO_B:
case RIG_VFO_SUB:
vfo_letter = '1';
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported VFO %d\n", __func__, vfo);
return -RIG_EINVAL;
}
return vfo_letter;
}
static int thd74_get_block (RIG *rig, int block_num, char *block) {
static int thd74_get_block(RIG *rig, int block_num, char *block)
{
hamlib_port_t *rp = &rig->state.rigport;
char cmd[CMD_SZ] = "R\0\0\0\0";
char resp[CMD_SZ];
@ -249,102 +260,142 @@ static int thd74_get_block (RIG *rig, int block_num, char *block) {
cmd[2] = block_num & 0xff;
ret = write_block(rp, cmd, CMD_SZ);
if (ret != RIG_OK)
{
return ret;
}
/* read response first */
ret = read_block(rp, resp, CMD_SZ);
if (ret != RIG_OK)
return ret;
if (resp[0] != 'W' || memcmp(cmd+1, resp+1, CMD_SZ-1))
if (ret != RIG_OK)
{
return ret;
}
if (resp[0] != 'W' || memcmp(cmd + 1, resp + 1, CMD_SZ - 1))
{
return -RIG_EPROTO;
}
/* read block */
ret = read_block(rp, block, BLOCK_SZ);
if (ret != BLOCK_SZ)
{
return ret;
}
ret = write_block(rp, "\006", 1);
if (ret != RIG_OK)
{
return ret;
}
ret = read_block(rp, resp, 1);
if (ret != 1)
{
return ret;
}
if (resp[0] != 0x06)
{
return -RIG_EPROTO;
}
return RIG_OK;
}
int thd74_get_chan_all_cb (RIG * rig, chan_cb_t chan_cb, rig_ptr_t arg) {
int thd74_get_chan_all_cb(RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg)
{
int i, j, ret;
hamlib_port_t *rp = &rig->state.rigport;
channel_t *chan;
chan_t *chan_list = rig->state.chan_list;
int chan_next = chan_list[0].start;
channel_t *chan;
chan_t *chan_list = rig->state.chan_list;
int chan_next = chan_list[0].start;
char block[BLOCK_SZ];
char resp[CMD_SZ];
ret = kenwood_transaction(rig, "0M PROGRAM", NULL, 0);
if (ret != RIG_OK)
{
return ret;
}
rp->parm.serial.rate = 57600;
serial_setup(rp);
/* let the pcr settle and flush any remaining data*/
usleep(100*1000);
usleep(100 * 1000);
serial_flush(rp);
/* setRTS or Hardware flow control? */
ret = ser_set_rts(rp, 1);
if (ret != RIG_OK)
return ret;
/*
* setting chan to NULL means the application
* has to provide a struct where to store data
* future data for channel channel_num
*/
if (ret != RIG_OK)
{
return ret;
}
/*
* setting chan to NULL means the application
* has to provide a struct where to store data
* future data for channel channel_num
*/
chan = NULL;
ret = chan_cb(rig, &chan, chan_next, chan_list, arg);
if (ret != RIG_OK)
{
return ret;
}
if (chan == NULL)
{
return -RIG_ENOMEM;
}
for (i=0; i<BLOCK_COUNT; i++) {
for (i = 0; i < BLOCK_COUNT; i++)
{
ret = thd74_get_block(rig, i, block);
ret = thd74_get_block (rig, i, block);
if (ret != RIG_OK)
{
return ret;
}
/*
* Most probably, there's 64 bytes per channel (256*256 / 1000+)
*/
#define CHAN_PER_BLOCK 4
for (j=0; j<CHAN_PER_BLOCK; j++) {
for (j = 0; j < CHAN_PER_BLOCK; j++)
{
char *block_chan = block + j*(BLOCK_SZ/CHAN_PER_BLOCK);
char *block_chan = block + j * (BLOCK_SZ / CHAN_PER_BLOCK);
memset(chan, 0, sizeof(channel_t));
chan->vfo = RIG_VFO_MEM;
chan->channel_num = i*CHAN_PER_BLOCK + j;
chan->vfo = RIG_VFO_MEM;
chan->channel_num = i * CHAN_PER_BLOCK + j;
/* What are the extra 64 channels ? */
if (chan->channel_num >= 1000)
{
break;
}
/* non-empty channel ? */
// if (block_chan[0] != 0xff) {
// since block_chan is *signed* char, this maps to -1
if (block_chan[0] != -1) {
// since block_chan is *signed* char, this maps to -1
if (block_chan[0] != -1)
{
memcpy(chan->channel_desc, block_chan, 8);
/* TODO: chop off trailing chars */
@ -353,33 +404,43 @@ int thd74_get_chan_all_cb (RIG * rig, chan_cb_t chan_cb, rig_ptr_t arg) {
/* TODO: parse block and fill in chan */
}
/* notify the end? */
chan_next = chan_next < chan_list[i].end ? chan_next+1 : chan_next;
/* notify the end? */
chan_next = chan_next < chan_list[i].end ? chan_next + 1 : chan_next;
/*
* provide application with channel data,
* and ask for a new channel structure
*/
chan_cb(rig, &chan, chan_next, chan_list, arg);
/*
* provide application with channel data,
* and ask for a new channel structure
*/
chan_cb(rig, &chan, chan_next, chan_list, arg);
}
}
ret = write_block(rp, "E", 1);
if (ret != RIG_OK)
{
return ret;
}
ret = read_block(rp, resp, 1);
if (ret != 1)
return ret;
if (resp[0] != 0x06) {
if (ret != 1)
{
return ret;
}
if (resp[0] != 0x06)
{
return -RIG_EPROTO;
}
/* setRTS?? getCTS needed? */
ret = ser_set_rts(rp, 1);
if (ret != RIG_OK)
{
return ret;
}
return RIG_OK;
}
@ -390,75 +451,90 @@ int thd74_get_chan_all_cb (RIG * rig, chan_cb_t chan_cb, rig_ptr_t arg) {
*/
int thd74_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
if (!rig || !freq)
return -RIG_EINVAL;
if (!rig || !freq)
{
return -RIG_EINVAL;
}
char freqbuf[50];
char cmdbuf[5];
int retval;
unsigned char vfo_letter;
vfo_t tvfo;
char freqbuf[50];
char cmdbuf[5];
int retval;
unsigned char vfo_letter;
vfo_t tvfo;
tvfo = (vfo == RIG_VFO_CURR || vfo==RIG_VFO_VFO) ? rig->state.current_vfo : vfo;
tvfo = (vfo == RIG_VFO_CURR
|| vfo == RIG_VFO_VFO) ? rig->state.current_vfo : vfo;
if (RIG_VFO_CURR == tvfo) {
/* fetch from rig */
retval = rig_get_vfo (rig, &tvfo);
if (RIG_OK != retval) return retval;
}
if (RIG_VFO_CURR == tvfo)
{
/* fetch from rig */
retval = rig_get_vfo(rig, &tvfo);
/* memory frequency cannot be read with an Fx command, use IF */
if (tvfo == RIG_VFO_MEM) {
if (RIG_OK != retval) { return retval; }
}
return kenwood_get_freq_if(rig, vfo, freq);
}
/* memory frequency cannot be read with an Fx command, use IF */
if (tvfo == RIG_VFO_MEM)
{
vfo_letter = thd74_get_vfo_letter(rig, vfo);
return kenwood_get_freq_if(rig, vfo, freq);
}
snprintf(cmdbuf, sizeof (cmdbuf), "FQ %c", vfo_letter);
rig_debug(RIG_DEBUG_ERR, "%s: cmd: %s\n", __func__, cmdbuf);
vfo_letter = thd74_get_vfo_letter(rig, vfo);
retval = kenwood_safe_transaction(rig, cmdbuf, freqbuf, 50, 15);
if (retval != RIG_OK)
return retval;
snprintf(cmdbuf, sizeof(cmdbuf), "FQ %c", vfo_letter);
rig_debug(RIG_DEBUG_ERR, "%s: cmd: %s\n", __func__, cmdbuf);
rig_debug(RIG_DEBUG_ERR, "%s: response is %s\n", __func__, freqbuf);
sscanf(freqbuf,"FQ %d,%10"SCNfreq, &retval, freq);
retval = kenwood_safe_transaction(rig, cmdbuf, freqbuf, 50, 15);
return RIG_OK;
if (retval != RIG_OK)
{
return retval;
}
rig_debug(RIG_DEBUG_ERR, "%s: response is %s\n", __func__, freqbuf);
sscanf(freqbuf, "FQ %d,%10"SCNfreq, &retval, freq);
return RIG_OK;
}
/*
* thd74_set_freq
*/
int thd74_set_freq(RIG *rig, vfo_t vfo, freq_t freq) {
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
int thd74_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
if (!rig)
return -RIG_EINVAL;
if (!rig)
{
return -RIG_EINVAL;
}
char freqbuf[16],replybuf[16];
unsigned char vfo_letter;
int err;
vfo_t tvfo;
char freqbuf[16], replybuf[16];
unsigned char vfo_letter;
int err;
vfo_t tvfo;
tvfo = (vfo == RIG_VFO_CURR || vfo==RIG_VFO_VFO) ? rig->state.current_vfo : vfo;
tvfo = (vfo == RIG_VFO_CURR
|| vfo == RIG_VFO_VFO) ? rig->state.current_vfo : vfo;
if (RIG_VFO_CURR == tvfo) {
/* fetch from rig */
err = rig_get_vfo (rig, &tvfo);
if (RIG_OK != err) return err;
}
if (RIG_VFO_CURR == tvfo)
{
/* fetch from rig */
err = rig_get_vfo(rig, &tvfo);
vfo_letter = thd74_get_vfo_letter(rig, vfo);
if (RIG_OK != err) { return err; }
}
snprintf(freqbuf, sizeof (freqbuf), "FQ %c,%010ld", vfo_letter, (int64_t)freq);
rig_debug(RIG_DEBUG_ERR, "%s: freqbuf: %s\n", __func__, freqbuf);
vfo_letter = thd74_get_vfo_letter(rig, vfo);
err = kenwood_transaction(rig, freqbuf, replybuf, 16);
return err;
snprintf(freqbuf, sizeof(freqbuf), "FQ %c,%010ld", vfo_letter, (int64_t)freq);
rig_debug(RIG_DEBUG_ERR, "%s: freqbuf: %s\n", __func__, freqbuf);
err = kenwood_transaction(rig, freqbuf, replybuf, 16);
return err;
}
@ -466,105 +542,144 @@ int thd74_set_freq(RIG *rig, vfo_t vfo, freq_t freq) {
* thd74_get_mode
* Assumes rig!=NULL, mode!=NULL
*/
int thd74_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) {
char buf[64];
char modebuf[8];
int retval;
const struct kenwood_priv_caps *priv=(const struct kenwood_priv_caps *)rig->caps->priv;
unsigned char vfo_letter;
int thd74_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
char buf[64];
char modebuf[8];
int retval;
const struct kenwood_priv_caps *priv = (const struct kenwood_priv_caps *)
rig->caps->priv;
unsigned char vfo_letter;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo)
return kenwood_wrong_vfo(__func__, vfo);
if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo)
{
return kenwood_wrong_vfo(__func__, vfo);
}
vfo_letter = thd74_get_vfo_letter(rig, vfo);
vfo_letter = thd74_get_vfo_letter(rig, vfo);
snprintf(modebuf, sizeof (modebuf), "MD %c", vfo_letter);
retval = kenwood_safe_transaction(rig, modebuf, buf, sizeof(buf), 6);
//retval = kenwood_safe_transaction(rig, modebuf, buf, sizeof(buf), 0);
if (retval != RIG_OK)
return retval;
snprintf(modebuf, sizeof(modebuf), "MD %c", vfo_letter);
retval = kenwood_safe_transaction(rig, modebuf, buf, sizeof(buf), 6);
rig_debug(RIG_DEBUG_ERR, "%s: buf%s\n", __func__, buf);
if (buf[5] < '0' || buf[5] > '9') {
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf);
return -RIG_ERJCTED;
}
//retval = kenwood_safe_transaction(rig, modebuf, buf, sizeof(buf), 0);
if (retval != RIG_OK)
{
return retval;
}
if (priv->mode_table) {
*mode = kenwood2rmode(buf[5]-'0', priv->mode_table);
if (*mode == RIG_MODE_NONE) {
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode (table)value '%c'\n",
__func__, buf[5]);
return -RIG_EINVAL;
}
}
else {
return -RIG_EINVAL;
}
rig_debug(RIG_DEBUG_ERR, "%s: buf%s\n", __func__, buf);
if (width)
*width = RIG_PASSBAND_NORMAL;
if (buf[5] < '0' || buf[5] > '9')
{
rig_debug(RIG_DEBUG_ERR, "%s: Unexpected reply '%s'\n", __func__, buf);
return -RIG_ERJCTED;
}
return RIG_OK;
if (priv->mode_table)
{
*mode = kenwood2rmode(buf[5] - '0', priv->mode_table);
if (*mode == RIG_MODE_NONE)
{
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode (table)value '%c'\n",
__func__, buf[5]);
return -RIG_EINVAL;
}
}
else
{
return -RIG_EINVAL;
}
if (width)
{
*width = RIG_PASSBAND_NORMAL;
}
return RIG_OK;
}
/*
* th_set_mode
* Assumes rig!=NULL
*/
int thd74_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) {
char kmode, mdbuf[8], replybuf[8];
int retval;
const struct kenwood_priv_caps *priv=(const struct kenwood_priv_caps *)rig->caps->priv;
unsigned char vfo_letter;
int thd74_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
char kmode, mdbuf[8], replybuf[8];
int retval;
const struct kenwood_priv_caps *priv = (const struct kenwood_priv_caps *)
rig->caps->priv;
unsigned char vfo_letter;
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo) // FIXME thinkabout
return kenwood_wrong_vfo(__func__, vfo);
if (vfo != RIG_VFO_CURR && vfo != rig->state.current_vfo) // FIXME thinkabout
{
return kenwood_wrong_vfo(__func__, vfo);
}
vfo_letter = thd74_get_vfo_letter(rig, vfo);
vfo_letter = thd74_get_vfo_letter(rig, vfo);
if (priv->mode_table) {
kmode = rmode2kenwood(mode, priv->mode_table);
if (kmode == -1) {
rig_debug(RIG_DEBUG_WARN, "%s: Unsupported Mode value '%s'\n",
__func__, rig_strrmode(mode));
return -RIG_EINVAL;
}
kmode += '0';
} else {
switch (mode) {
case RIG_MODE_FM: kmode = '0'; break;
case RIG_MODE_AM: kmode = '1'; break;
// case RIG_MODE_AM: kmode = '2'; break; // FIXME
case RIG_MODE_LSB: kmode = '3'; break;
case RIG_MODE_USB: kmode = '4'; break;
case RIG_MODE_CW: kmode = '5'; break;
case RIG_MODE_FMN: kmode = '6'; break;
case RIG_MODE_DR: kmode = '7'; break;
case RIG_MODE_WFM: kmode = '8'; break;
case RIG_MODE_CWR: kmode = '9'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode %d\n", __func__, mode);
return -RIG_EINVAL;
}
if (priv->mode_table)
{
kmode = rmode2kenwood(mode, priv->mode_table);
if (kmode == -1)
{
rig_debug(RIG_DEBUG_WARN, "%s: Unsupported Mode value '%s'\n",
__func__, rig_strrmode(mode));
return -RIG_EINVAL;
}
sprintf(mdbuf, "MD %c,%c", vfo_letter, kmode);
rig_debug(RIG_DEBUG_ERR, "%s: mdbuf: %s\n", __func__, mdbuf);
kmode += '0';
}
else
{
switch (mode)
{
case RIG_MODE_FM: kmode = '0'; break;
retval = kenwood_transaction(rig, mdbuf, replybuf, 7);
rig_debug(RIG_DEBUG_ERR, "%s: retval: %d\n", __func__, retval);
if (retval != RIG_OK)
return retval;
case RIG_MODE_AM: kmode = '1'; break;
return RIG_OK;
// case RIG_MODE_AM: kmode = '2'; break; // FIXME
case RIG_MODE_LSB: kmode = '3'; break;
case RIG_MODE_USB: kmode = '4'; break;
case RIG_MODE_CW: kmode = '5'; break;
case RIG_MODE_FMN: kmode = '6'; break;
case RIG_MODE_DR: kmode = '7'; break;
case RIG_MODE_WFM: kmode = '8'; break;
case RIG_MODE_CWR: kmode = '9'; break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported Mode %d\n", __func__, mode);
return -RIG_EINVAL;
}
}
sprintf(mdbuf, "MD %c,%c", vfo_letter, kmode);
rig_debug(RIG_DEBUG_ERR, "%s: mdbuf: %s\n", __func__, mdbuf);
retval = kenwood_transaction(rig, mdbuf, replybuf, 7);
rig_debug(RIG_DEBUG_ERR, "%s: retval: %d\n", __func__, retval);
if (retval != RIG_OK)
{
return retval;
}
return RIG_OK;
}
static int thd74_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) {
char buf[6];
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
return kenwood_transaction(rig, (ptt == RIG_PTT_ON) ? "TX" : "RX", buf, 5);
static int thd74_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
{
char buf[6];
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
return kenwood_transaction(rig, (ptt == RIG_PTT_ON) ? "TX" : "RX", buf, 5);
}