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

772 wiersze
20 KiB
C
Czysty Wina Historia

/*
* Hamlib Alinco backend - DXSR8 description
* Copyright (c) 2020 by Wes Bustraan (W8WJB)
*
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#include <hamlib/config.h>
#include <stdlib.h>
#include <string.h> /* String function definitions */
#include <unistd.h> /* UNIX standard function definitions */
#include <hamlib/rig.h>
#include <serial.h>
#include <misc.h>
#include <iofunc.h>
#include <num_stdio.h>
#include "idx_builtin.h"
#include "alinco.h"
#define DXSR8_ALL_MODES (RIG_MODE_USB|RIG_MODE_LSB|RIG_MODE_CW|RIG_MODE_CWR|RIG_MODE_AM|RIG_MODE_FM)
#define DXSR8_OTHER_TX_MODES (RIG_MODE_CW|RIG_MODE_SSB|RIG_MODE_FM)
#define DXSR8_AM_TX_MODES RIG_MODE_AM
#define DXSR8_FUNC (RIG_FUNC_FAGC|RIG_FUNC_NB)
#define DXSR8_LEVEL_ALL (RIG_LEVEL_RFPOWER|RIG_LEVEL_RF)
#define DXSR8_PARM_ALL RIG_PARM_NONE
#define DXSR8_VFO RIG_VFO_NONE
/* Line Feed */
#define EOM "\r\n"
#define LF "\n"
#define MD_USB 0
#define MD_LSB 1
#define MD_CWU 2
#define MD_CWL 3
#define MD_AM 4
#define MD_FM 5
int dxsr8_set_freq(RIG *rig, vfo_t vfo, freq_t freq);
int dxsr8_get_freq(RIG *rig, vfo_t vfo, freq_t *freq);
int dxsr8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width);
int dxsr8_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width);
int dxsr8_set_func(RIG *rig, vfo_t vfo, setting_t func, int status);
int dxsr8_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status);
int dxsr8_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val);
int dxsr8_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val);
int dxsr8_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt);
int dxsr8_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt);
/*
* DX-SR8 rig capabilities.
*
* thanks to
* https://yo5ptd.wordpress.com/2017/02/12/alinco-dx-sr8/
* for a partially documented protocol
*/
const struct rig_caps dxsr8_caps =
{
RIG_MODEL(RIG_MODEL_DXSR8),
.model_name = "DX-SR8",
.mfg_name = "Alinco",
.version = BACKEND_VER ".0",
.copyright = "LGPL",
.status = RIG_STATUS_STABLE,
.rig_type = RIG_TYPE_TRANSCEIVER,
.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_NONE,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 200,
.retry = 3,
.has_get_func = DXSR8_FUNC,
.has_set_func = DXSR8_FUNC,
.has_get_level = DXSR8_LEVEL_ALL,
.has_set_level = RIG_LEVEL_SET(DXSR8_LEVEL_ALL),
.has_get_parm = RIG_PARM_NONE,
.has_set_parm = RIG_PARM_NONE,
.level_gran =
{
[LVL_RAWSTR] = { .min = { .i = 0 }, .max = { .i = 255 } },
},
.parm_gran = {},
.ctcss_list = common_ctcss_list,
.dcs_list = NULL,
.preamp = { 10, RIG_DBLST_END },
.attenuator = { 10, 20, RIG_DBLST_END },
.max_rit = kHz(1.2),
.max_xit = kHz(1.2),
.max_ifshift = kHz(1.5),
.targetable_vfo = 0,
.transceive = RIG_TRN_OFF,
.bank_qty = 0,
.chan_desc_sz = 0,
.chan_list =
{
{ 0, 199, RIG_MTYPE_MEM },
{ 0, 199, RIG_MTYPE_MEM },
RIG_CHAN_END,
},
.rx_range_list1 =
{
{kHz(135), MHz(30), DXSR8_ALL_MODES, -1, -1, DXSR8_VFO, 0, "DX-SR8T"},
RIG_FRNG_END,
},
.tx_range_list1 =
{
{kHz(1800), MHz(2) - 100, DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8T"},
{kHz(1800), MHz(2) - 100, DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8T"},
{kHz(3500), MHz(4) - 100, DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8T"},
{kHz(3500), MHz(4) - 100, DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8T"},
{5330500, 5330500, DXSR8_AM_TX_MODES, W(1), W(50), DXSR8_VFO, 0, "DX-SR8T"},
{5346500, 5346500, DXSR8_AM_TX_MODES, W(1), W(50), DXSR8_VFO, 0, "DX-SR8T"},
{5366500, 5366500, DXSR8_AM_TX_MODES, W(1), W(50), DXSR8_VFO, 0, "DX-SR8T"},
{5371500, 5371500, DXSR8_AM_TX_MODES, W(1), W(50), DXSR8_VFO, 0, "DX-SR8T"},
{5403500, 5403500, DXSR8_AM_TX_MODES, W(1), W(50), DXSR8_VFO, 0, "DX-SR8T"},
{MHz(7), kHz(7300), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8T"},
{MHz(7), kHz(7300), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8T"},
{kHz(10100), kHz(10150), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8T"},
{kHz(10100), kHz(10150), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8T"},
{MHz(14), kHz(14350), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8T"},
{MHz(14), kHz(14350), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8T"},
{kHz(18068), kHz(18168), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8T"},
{kHz(18068), kHz(18168), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8T"},
{MHz(21), kHz(21450), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8T"},
{MHz(21), kHz(21450), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8T"},
{kHz(24890), kHz(24990), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8T"},
{kHz(24890), kHz(24990), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8T"},
{MHz(28), kHz(29700), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8T"},
{MHz(28), kHz(29700), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8T"},
RIG_FRNG_END,
},
.rx_range_list2 =
{
{kHz(135), MHz(30), DXSR8_ALL_MODES, -1, -1, DXSR8_VFO, 0, "DX-SR8E"},
RIG_FRNG_END,
},
.tx_range_list2 =
{
{kHz(1800), MHz(2) - 100, DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(1800), MHz(2) - 100, DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(3500), MHz(4) - 100, DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(3500), MHz(4) - 100, DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(6900), kHz(7500), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(6900), kHz(7500), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(9900), kHz(10500), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(9900), kHz(10500), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(13900), kHz(14500), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(13900), kHz(14500), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(17900), kHz(18500), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(17900), kHz(18500), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(20900), kHz(21500), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(20900), kHz(21500), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(24400), kHz(25099), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8E"},
{kHz(24400), kHz(25099), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8E"},
{MHz(28), MHz(30), DXSR8_OTHER_TX_MODES, W(10), W(100), DXSR8_VFO, 0, "DX-SR8E"},
{MHz(28), MHz(30), DXSR8_AM_TX_MODES, W(4), W(40), DXSR8_VFO, 0, "DX-SR8E"},
RIG_FRNG_END,
},
.tuning_steps =
{
{DXSR8_ALL_MODES, 10}, /* FIXME: add other ts */
RIG_TS_END,
},
/* mode/filter list, remember: order matters! */
.filters =
{
{RIG_MODE_CW, kHz(1)},
{RIG_MODE_CW, kHz(0.5)},
{RIG_MODE_SSB, kHz(2.4)},
{RIG_MODE_SSB, kHz(1)},
{RIG_MODE_AM | RIG_MODE_FM, kHz(9)},
{RIG_MODE_AM, kHz(2.4)},
RIG_FLT_END,
},
.set_freq = dxsr8_set_freq, // AL~RW_RXF14212000
.get_freq = dxsr8_get_freq, // AL~RR_RXF
.set_mode = dxsr8_set_mode, // AL~RW_RFM00, AL~RW_NAR00
.get_mode = dxsr8_get_mode, // AL~RR_RFM, AL~RR_NAR
.get_ptt = dxsr8_get_ptt, // AL~RR_PTT
.set_ptt = dxsr8_set_ptt, // AL~RW_PTT00
.set_func = dxsr8_set_func, // AL~RW_AGC00, AL~RW_NZB00
.get_func = dxsr8_get_func, // AL~RR_AGC, AL~RR_NZB
.set_level = dxsr8_set_level, // AL~RW_RFG00, AL~RW_PWR00
.get_level = dxsr8_get_level, // AL~RR_RFG, AL~RR_PWR
.hamlib_check_rig_caps = HAMLIB_CHECK_RIG_CAPS
};
/*
* Function definitions below
*/
/*
* dxsr8_transaction
* We assume that rig!=NULL, rig->state!= NULL, data!=NULL, data_len!=NULL
* Otherwise, you'll get a nice seg fault. You've been warned!
* TODO: error case handling
*/
int dxsr8_transaction(RIG *rig,
const char *cmd,
int cmd_len,
char *data,
int *data_len)
{
int retval;
struct rig_state *rs;
char replybuf[BUFSZ + 1];
int reply_len;
if (cmd == NULL)
{
rig_debug(RIG_DEBUG_ERR,
"%s: null argument for cmd?\n", __func__);
return -RIG_EINTERNAL;
}
rs = &rig->state;
rig_flush(&rs->rigport);
retval = write_block(&rs->rigport, (unsigned char *) cmd, cmd_len);
if (retval != RIG_OK)
{
return retval;
}
/*
* Transceiver sends an echo of cmd followed by a CR/LF
* TODO: check whether cmd and echobuf match (optional)
*/
retval = read_string(&rs->rigport, (unsigned char *) replybuf, BUFSZ,
LF, strlen(LF), 0, 1);
if (retval < 0)
{
return retval;
}
retval = read_string(&rs->rigport, (unsigned char *) replybuf, BUFSZ,
LF, strlen(LF), 0, 1);
if (retval < 0)
{
return retval;
}
/* no data expected, check for OK returned */
if (data == NULL)
{
if (retval > 2) { retval -= 2; }
replybuf[retval] = 0;
if (strcmp(replybuf, "OK") == 0)
{
return RIG_OK;
}
else
{
return -RIG_ERJCTED;
}
}
// strip CR/LF from string
reply_len = strcspn(replybuf, "\r\n");
replybuf[reply_len] = 0;
strcpy(data, replybuf);
*data_len = reply_len;
return RIG_OK;
}
/**
* dxsr8_read_num
* Convenience function to read a numeric value from the radio
*/
int dxsr8_read_num(RIG *rig,
const char *cmd,
int *reply_num)
{
int retval;
int reply_len;
char replybuf[10];
retval = dxsr8_transaction(rig, cmd, strlen(cmd), replybuf, &reply_len);
if (retval != RIG_OK)
{
return retval;
}
*reply_num = atoi(replybuf);
return RIG_OK;
}
/*
* dxsr8_set_freq
* Assumes rig!=NULL
*/
int dxsr8_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
char cmd[BUFSZ];
/* max 10 digits */
if (freq >= GHz(10))
{
return -RIG_EINVAL;
}
// cppcheck-suppress *
SNPRINTF(cmd, sizeof(cmd), AL "~RW_RXF%08"PRIll EOM, (int64_t)freq);
return dxsr8_transaction(rig, cmd, strlen(cmd), NULL, NULL);
}
/*
* dxsr8_get_freq
* Assumes rig!=NULL, freq!=NULL
*/
int dxsr8_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
int retval, data_len;
char cmd[] = AL "~RR_RXF" EOM;
char freqbuf[BUFSZ];
retval = dxsr8_transaction(rig, cmd, strlen(cmd), freqbuf, &data_len);
if (retval != RIG_OK)
{
return retval;
}
/* extract RX freq */
retval = num_sscanf(freqbuf, "%"SCNfreq, freq);
return RIG_OK;
}
/*
* dxsr8_set_mode
* Assumes rig!=NULL
*/
int dxsr8_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
char mdbuf[BUFSZ];
int wide_filter, retval;
int amode;
switch (mode)
{
case RIG_MODE_CW: amode = MD_CWU; break;
case RIG_MODE_CWR: amode = MD_CWL; break;
case RIG_MODE_USB: amode = MD_USB; break;
case RIG_MODE_LSB: amode = MD_LSB; break;
case RIG_MODE_FM: amode = MD_FM; break;
case RIG_MODE_AM: amode = MD_AM; break;
default:
rig_debug(RIG_DEBUG_ERR, "dxsr8_set_mode: unsupported mode %s\n",
rig_strrmode(mode));
return -RIG_EINVAL;
}
SNPRINTF(mdbuf, sizeof(mdbuf), AL "~RW_RFM%02d" EOM, amode);
retval = dxsr8_transaction(rig, mdbuf, strlen(mdbuf), NULL, NULL);
if (retval != RIG_OK)
{
return retval;
}
if (width == RIG_PASSBAND_NOCHANGE) { return retval; }
if (width != RIG_PASSBAND_NORMAL
&& width < rig_passband_normal(rig, mode))
{
wide_filter = 1; // AL~RW_NAR01 Set narrow bandwidth
}
else
{
wide_filter = 0; // AL~RW_NAR00 Set wide bandwidth
}
SNPRINTF(mdbuf, sizeof(mdbuf), AL "~RW_NAR%02d" EOM, wide_filter);
retval = dxsr8_transaction(rig, mdbuf, strlen(mdbuf), NULL, NULL);
return retval;
}
/*
* dxsr8_get_mode
* Assumes rig!=NULL, mode!=NULL
*/
int dxsr8_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
int retval;
int amode;
int filter;
retval = dxsr8_read_num(rig, AL "~RR_RFM" EOM, &amode);
if (retval != RIG_OK)
{
return retval;
}
switch (amode)
{
case MD_CWL:
case MD_CWU: *mode = RIG_MODE_CW; break;
case MD_USB: *mode = RIG_MODE_USB; break;
case MD_LSB: *mode = RIG_MODE_LSB; break;
case MD_AM: *mode = RIG_MODE_AM; break;
case MD_FM: *mode = RIG_MODE_FM; break;
default:
rig_debug(RIG_DEBUG_ERR,
"dxsr8_get_mode: unknown mode %02d\n",
amode);
return -RIG_EINVAL;
}
filter = 0; // avoid compiler warings of being possibly uninitialized
retval = dxsr8_read_num(rig, AL "~RR_NAR" EOM, &filter);
if (filter == 0)
{
*width = rig_passband_wide(rig, *mode);
}
else
{
*width = rig_passband_normal(rig, *mode);
}
return RIG_OK;
}
/*
* dxsr8_set_func
* Assumes rig!=NULL
*/
int dxsr8_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
{
char cmd[BUFSZ];
switch (func)
{
case RIG_FUNC_FAGC:
SNPRINTF(cmd, sizeof(cmd), AL "~RW_AGC%02d" EOM, status ? 0 : 1);
return dxsr8_transaction(rig, cmd, strlen(cmd), NULL, NULL);
case RIG_FUNC_NB:
SNPRINTF(cmd, sizeof(cmd), AL "~RW_NZB%d" EOM, status ? 1 : 0);
return dxsr8_transaction(rig, cmd, strlen(cmd), NULL, NULL);
default:
rig_debug(RIG_DEBUG_ERR, "Unsupported set_func %d\n", (int)func);
return -RIG_EINVAL;
}
return RIG_OK;
}
/*
* dxsr8_get_func
* Assumes rig!=NULL, status!=NULL
*/
int dxsr8_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
{
int retval;
int setting;
switch (func)
{
case RIG_FUNC_FAGC:
retval = dxsr8_read_num(rig, AL "~RR_AGC" EOM, &setting);
if (retval != RIG_OK)
{
return retval;
}
// 00 = Fast AGC
// 01 = Slow AGC
*status = setting ? 0 : 1;
break;
case RIG_FUNC_NB:
retval = dxsr8_read_num(rig, AL "~RR_NZB" EOM, &setting);
if (retval != RIG_OK)
{
return retval;
}
// 00 = noise blanker off
// 01 = noise blanker on
*status = setting ? 1 : 0;
break;
default:
rig_debug(RIG_DEBUG_ERR, "Unsupported get_func %d\n", (int)func);
return -RIG_EINVAL;
}
return RIG_OK;
}
/*
* dxsr8_set_level
* Assumes rig!=NULL
* FIXME: cannot support PREAMP and ATT both at same time (make sense though)
*/
int dxsr8_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
int lvl;
char cmd[BUFSZ];
switch (level)
{
case RIG_LEVEL_PREAMP:
switch (val.i)
{
case 0: lvl = 0; break; // AL~RW_RFG00 - RF gain 0dB
case 10: lvl = 3; break; // AL~RW_RFG03 - RF gain +10dB
default: rig_debug(RIG_DEBUG_ERR,
"Unsupported Preamp %d\n",
val.i);
return -RIG_EINVAL;
}
SNPRINTF(cmd, sizeof(cmd), AL "~RW_RFG%02d" EOM, lvl);
return dxsr8_transaction(rig, cmd, strlen(cmd), NULL, NULL);
case RIG_LEVEL_ATT:
switch (val.i)
{
case 0: lvl = 0; break; // AL~RW_RFG00 - RF gain 0dB
case 10: lvl = 1; break; // AL~RW_RFG01 - RF gain -10dB
case 20: lvl = 2; break; // AL~RW_RFG02 - RF gain -20dB
default: rig_debug(RIG_DEBUG_ERR,
"Unsupported Att %d\n",
val.i);
return -RIG_EINVAL;
}
SNPRINTF(cmd, sizeof(cmd), AL "~RW_RFG%02d" EOM, lvl);
return dxsr8_transaction(rig, cmd, strlen(cmd), NULL, NULL);
case RIG_LEVEL_RFPOWER:
if (val.f <= 0.01)
{
lvl = 2; // AL~RW_PWR02 - Sub low power (QRP mode)
}
else if (val.f <= 0.1)
{
lvl = 1; // AL~RW_PWR01 - Low power
}
else
{
lvl = 0; // AL~RW_PWR00 - High power
}
SNPRINTF(cmd, sizeof(cmd), AL "~RW_PWR%02d" EOM, lvl);
return dxsr8_transaction(rig, cmd, strlen(cmd), NULL, NULL);
default:
rig_debug(RIG_DEBUG_ERR, "Unsupported set_level %s\n", rig_strlevel(level));
return -RIG_EINVAL;
}
return RIG_OK;
}
/*
* dxsr8_get_level
* Assumes rig!=NULL, val!=NULL
*/
int dxsr8_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
int retval;
int lvl;
switch (level)
{
case RIG_LEVEL_PREAMP:
retval = dxsr8_read_num(rig, AL "~RR_RFG" EOM, &lvl);
if (retval != RIG_OK)
{
return retval;
}
switch (lvl)
{
case 0:
val->i = 0; break; // RF gain 0dB
case 3:
val->i = 10; break; // RF gain +10dB
default:
rig_debug(RIG_DEBUG_ERR, "Unknown RF Gain %02d\n", lvl);
}
break;
case RIG_LEVEL_ATT:
retval = dxsr8_read_num(rig, AL "~RR_RFG" EOM, &lvl);
if (retval != RIG_OK)
{
return retval;
}
switch (lvl)
{
case 0:
val->i = 0; break; // RF gain 0dB
case 1:
val->i = 10; break; // RF gain -10dB
case 2:
val->i = 10; break; // RF gain -20dB
default:
rig_debug(RIG_DEBUG_ERR, "Unknown RF Gain %02d\n", lvl);
}
break;
case RIG_LEVEL_RFPOWER:
retval = dxsr8_read_num(rig, AL "~RR_PWR" EOM, &lvl);
if (retval != RIG_OK)
{
return retval;
}
switch (lvl)
{
case 0: // 00 - High power
val->f = 1.0; // 100 W
break;
case 1: // 01 - Low power
val->f = 0.1; // 10 W
break;
case 3: // 02 - Sub low power (QRP mode)
val->f = 0.01; // 1 W
break;
default:
rig_debug(RIG_DEBUG_ERR, "Unknown RF Power %02d\n", lvl);
break;
}
break;
default:
rig_debug(RIG_DEBUG_ERR, "Unsupported get_level %s\n", rig_strlevel(level));
return -RIG_EINVAL;
}
return RIG_OK;
}
/*
* dxsr8_get_ptt
* Assumes rig!=NULL, ptt!=NULL
*/
int dxsr8_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
{
int retval;
int pttval;
retval = dxsr8_read_num(rig, AL "~RR_PTT" EOM, &pttval);
if (retval != RIG_OK)
{
return retval;
}
*ptt = pttval ? RIG_PTT_ON : RIG_PTT_OFF;
return RIG_OK;
}
/*
* dxsr8_set_ptt
* Assumes rig!=NULL
*/
int dxsr8_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
{
char cmd[BUFSZ];
SNPRINTF(cmd, sizeof(cmd), AL "~RW_PTT%02d" EOM, ptt);
return dxsr8_transaction(rig, cmd, strlen(cmd), NULL, NULL);
}
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik