/*
* Handle S-meter (SM, SMH) level locally and pass rest to kenwood_get_level()
*/
int k3_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
if (!rig || !val)
return -RIG_EINVAL;
char lvlbuf[50];
int retval;
struct kenwood_priv_data *priv = rig->state.priv;
switch (level) {
case RIG_LEVEL_STRENGTH:
/* As of FW rev 4.37 the K3 supports an 'SMH' command that
* offers a higher resolution, 0-100 (mine went to 106),
* rawstr value for more precise S-meter reporting.
*/
retval = strncmp(priv->fw_rev, "4.37", 4);
if (retval < 0) {
cal_table_t str_cal = K3_SM_CAL;
retval = kenwood_safe_transaction(rig, "SM", lvlbuf, 10, 7);
if (retval != RIG_OK)
return retval;
sscanf(lvlbuf+2, "%d", &val->i); /* rawstr */
val->i = (int) rig_raw2val(val->i, &str_cal);
} else if (retval >= 0) {
cal_table_t str_cal = K3_SMH_CAL;
retval = kenwood_safe_transaction(rig, "SMH", lvlbuf, 10, 7);
if (retval != RIG_OK)
return retval;
sscanf(lvlbuf+3, "%d", &val->i); /* rawstr */
val->i = (int) rig_raw2val(val->i, &str_cal);
} else {
rig_debug(RIG_DEBUG_ERR, "%s: Firmware version comparison failed!\n",
__func__);
return -RIG_EINVAL;
}
break;
default:
retval = kenwood_get_level(rig, vfo, level, val);
if (retval != RIG_OK)
return retval;
break;
}
return RIG_OK;
}
int
pcr_get_level(RIG * rig, vfo_t vfo, setting_t level, value_t * val)
{
int err;
struct pcr_priv_data *priv = (struct pcr_priv_data *) rig->state.priv;
struct pcr_rcvr *rcvr = is_sub_rcvr(rig, vfo) ? &priv->sub_rcvr : &priv->main_rcvr;
// rig_debug(RIG_DEBUG_TRACE, "%s: level = %d\n", __func__, level);
switch (level) {
case RIG_LEVEL_SQL:
val->f = rcvr->squelch;
return RIG_OK;
case RIG_LEVEL_AF:
val->f = rcvr->volume;
return RIG_OK;
case RIG_LEVEL_STRENGTH:
if (priv->auto_update == 0) {
err = pcr_transaction(rig, is_sub_rcvr(rig, vfo) ? "I5?" : "I1?");
if (err != RIG_OK)
return err;
}
val->i = rig_raw2val(rcvr->raw_level, &rig->state.str_cal);
/* rig_debug(RIG_DEBUG_TRACE, "%s, raw = %d, converted = %d\n",
__func__, rcvr->raw_level, val->i);
*/
return RIG_OK;
case RIG_LEVEL_RAWSTR:
if (priv->auto_update == 0) {
err = pcr_transaction(rig, is_sub_rcvr(rig, vfo) ? "I5?" : "I1?");
if (err != RIG_OK)
return err;
}
val->i = rcvr->raw_level;
return RIG_OK;
case RIG_LEVEL_IF:
val->i = rcvr->last_shift;
return RIG_OK;
case RIG_LEVEL_ATT:
val->i = rcvr->last_att;
return RIG_OK;
case RIG_LEVEL_AGC:
val->i = rcvr->last_agc;
return RIG_OK;
}
return -RIG_ENIMPL;
}
/*
* drake_get_level
* Assumes rig!=NULL
*/
int drake_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
int lvl_len, retval, ss;
char lvlbuf[BUFSZ];
char mc;
if ((level != RIG_LEVEL_RAWSTR) && (level != RIG_LEVEL_STRENGTH)) {
retval = drake_transaction(rig, "RM" EOM, 3, lvlbuf, &lvl_len);
if (retval != RIG_OK)
return retval;
if (lvl_len != 8) {
rig_debug(RIG_DEBUG_ERR, "drake_get_level: wrong answer %s, "
"len=%d\n", lvlbuf, lvl_len);
return -RIG_ERJCTED;
}
}
switch (level) {
case RIG_LEVEL_RAWSTR:
retval = drake_transaction(rig, "RSS" EOM, 4, lvlbuf, &lvl_len);
if (retval != RIG_OK)
return retval;
if (lvl_len != 5) {
rig_debug(RIG_DEBUG_ERR, "drake_get_level: wrong answer"
"len=%d\n", lvl_len);
return -RIG_ERJCTED;
}
lvlbuf[3] = '\0';
val->i = strtol(lvlbuf + 1, (char **)NULL, 16);
break;
case RIG_LEVEL_STRENGTH:
retval = drake_transaction(rig, "RSS" EOM, 4, lvlbuf, &lvl_len);
if (retval != RIG_OK)
return retval;
if (lvl_len != 5) {
rig_debug(RIG_DEBUG_ERR, "drake_get_level: wrong answer"
"len=%d\n", lvl_len);
return -RIG_ERJCTED;
}
lvlbuf[3] = '\0';
ss = strtol(lvlbuf + 1, (char **)NULL, 16);
val->i = (int)rig_raw2val(ss, &rig->caps->str_cal);
break;
case RIG_LEVEL_PREAMP:
mc = lvlbuf[2];
if ((mc & 0x3c) == '8')
val->i = 10;
else
val->i = 0;
break;
case RIG_LEVEL_ATT:
mc = lvlbuf[2];
if ((mc & 0x3c) == '4')
val->i = 10;
else
val->i = 0;
break;
case RIG_LEVEL_AGC:
mc = lvlbuf[1];
switch (mc & 0x33) {
case '0': val->i = RIG_AGC_OFF; break;
case '2': val->i = RIG_AGC_FAST; break;
case '3': val->i = RIG_AGC_SLOW; break;
default : val->i = RIG_AGC_FAST;
}
break;
default:
rig_debug(RIG_DEBUG_ERR, "Unsupported get_level %d\n", level);
return -RIG_EINVAL;
}
return RIG_OK;
}
int main(int argc, char *argv[]) {
RIG *my_rig;
char *rig_file, *info_buf, *mm;
freq_t freq;
value_t rawstrength, power, strength;
float s_meter, rig_raw2val();
int status, retcode, isz;
unsigned int mwpower;
rmode_t mode;
pbwidth_t width;
rig_model_t myrig_model;
char portname[64];
port_t myport;
strncpy(portname, argv[2], 63);
portname[63] = '\0';
if ((strcmp(argv[2], "--help") == 0) || (argc < 2)) {
printf("use like: ./%s <portname>\n", argv[0]);
printf("example: ./%s /dev/ttyS0\n", argv[0]);
return 0;
}
/* Try to detect rig */
/* may be overridden by backend probe */
myport.type.rig = RIG_PORT_SERIAL;
myport.parm.serial.rate = 9600;
myport.parm.serial.data_bits = 8;
myport.parm.serial.stop_bits = 1;
myport.parm.serial.parity = RIG_PARITY_NONE;
myport.parm.serial.handshake = RIG_HANDSHAKE_NONE;
strncpy(myport.pathname, portname, FILPATHLEN);
rig_load_all_backends();
myrig_model = rig_probe(&myport);
/* Set verbosity level - errors only */
rig_set_debug(RIG_DEBUG_ERR);
/* Instantiate a rig - your rig */
/* my_rig = rig_init(RIG_MODEL_TT565); */
my_rig = rig_init(myrig_model);
/* Set up serial port, baud rate - serial device + baudrate */
rig_file = "/dev/ttyUSB0";
strncpy(my_rig->state.rigport.pathname, rig_file, FILPATHLEN - 1);
my_rig->state.rigport.parm.serial.rate = 57600;
my_rig->state.rigport.parm.serial.rate = 9600;
/* Open my rig */
retcode = rig_open(my_rig);
printf("retcode of rig_open = %d \n", retcode);
/* Give me ID info, e.g., firmware version. */
info_buf = (char *)rig_get_info(my_rig);
printf("Rig_info: '%s'\n", info_buf);
/* Note: As a general practice, we should check to see if a given
* function is within the rig's capabilities before calling it, but
* we are simplifying here. Also, we should check each call's returned
* status in case of error. (That's an inelegant way to catch an unsupported
* operation.)
*/
/* Main VFO frequency */
status = rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
printf("status of rig_get_freq = %d \n", status);
printf("VFO freq. = %.1f Hz\n", freq);
/* Current mode */
status = rig_get_mode(my_rig, RIG_VFO_CURR, &mode, &width);
printf("status of rig_get_mode = %d \n", status);
switch(mode) {
case RIG_MODE_USB: mm = "USB"; break;
case RIG_MODE_LSB: mm = "LSB"; break;
case RIG_MODE_CW: mm = "CW"; break;
case RIG_MODE_CWR: mm = "CWR"; break;
case RIG_MODE_AM: mm = "AM"; break;
case RIG_MODE_FM: mm = "FM"; break;
case RIG_MODE_WFM: mm = "WFM"; break;
case RIG_MODE_RTTY:mm = "RTTY"; break;
default: mm = "unrecognized"; break; /* there are more possibilities! */
}
printf("Current mode = 0x%X = %s, width = %d\n", mode, mm, (int) width);
/* rig power output */
status = rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_RFPOWER, &power);
printf("RF Power relative setting = %.3f (0.0 - 1.0)\n", power.f);
/* Convert power reading to watts */
status = rig_power2mW(my_rig, &mwpower, power.f, freq, mode);
printf("RF Power calibrated = %.1f Watts\n", mwpower/1000.);
/* Raw and calibrated S-meter values */
status = rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_RAWSTR, &rawstrength);
printf("Raw receive strength = %d\n", rawstrength.i);
isz = my_rig->caps->str_cal.size;
printf("isz = %d \n", isz);
s_meter = rig_raw2val(rawstrength.i, &my_rig->caps->str_cal);
printf("S-meter value = %.2f dB relative to S9\n", s_meter);
/* now try using RIG_LEVEL_STRENGTH itself */
status = rig_get_strength(my_rig, RIG_VFO_CURR, &strength);
printf("status of rig_get_strength = %d \n", status);
printf("LEVEL_STRENGTH returns %d\n", strength.i);
return 0;
}
