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

Convert rigs/yaesu 

No more code references to raw port structures in rigs/*
pull/1508/head
George Baltz N3GB 2024-02-05 11:25:06 -05:00
rodzic 12552bff64
commit e26e6cd7f2
26 zmienionych plików z 315 dodań i 322 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

26
rigs/yaesu/frg100.c
Wyświetl plik

@ -253,7 +253,7 @@ static int frg100_do_transaction(RIG *rig,
const unsigned char cmd[YAESU_CMD_LENGTH],
unsigned char *retbuf, size_t retbuf_len)
{
struct rig_state *rs;
hamlib_port_t *rp = RIGPORT(rig);
unsigned char default_retbuf[1];
int retval;
@ -263,15 +263,14 @@ static int frg100_do_transaction(RIG *rig,
retbuf_len = sizeof(default_retbuf);
}
rs = &rig->state;
memset(retbuf, 0, retbuf_len);
rig_flush(&rs->rigport);
retval = write_block(&rs->rigport, cmd, YAESU_CMD_LENGTH);
rig_flush(rp);
retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
if (retval != RIG_OK) { return retval; }
retval = read_block(&rs->rigport, retbuf, retbuf_len);
retval = read_block(rp, retbuf, retbuf_len);
if (retval != retbuf_len)
{
@ -353,7 +352,7 @@ int frg100_open(RIG *rig)
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
/* send 0 delay pacing */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -372,7 +371,7 @@ int frg100_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
to_bcd(cmd, freq / 10, 8);
/* Frequency set */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -384,7 +383,7 @@ int frg100_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
/* fill in p1 */
cmd[3] = mode2rig(rig, mode, width);
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -400,7 +399,7 @@ int frg100_set_powerstat(RIG *rig, powerstat_t status)
cmd[3] = status == RIG_POWER_OFF ? 0x00 : 0x01;
/* Frequency set */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -428,7 +427,7 @@ int frg100_set_vfo(RIG *rig, vfo_t vfo)
return -RIG_EINVAL; /* sorry, wrong VFO */
}
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -436,16 +435,17 @@ int frg100_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0xf7};
int retval;
hamlib_port_t *rp = RIGPORT(rig);
if (level != RIG_LEVEL_RAWSTR)
{
return -RIG_EINVAL;
}
rig_flush(&rig->state.rigport);
rig_flush(rp);
/* send READ STATUS(Meter only) cmd to rig */
retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
if (retval < 0)
{
@ -453,7 +453,7 @@ int frg100_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
}
/* read back the 1 byte */
retval = read_block(&rig->state.rigport, cmd, 5);
retval = read_block(rp, cmd, 5);
if (retval < 1)
{

10
rigs/yaesu/frg8800.c
Wyświetl plik

@ -160,7 +160,7 @@ int frg8800_open(RIG *rig)
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
/* send Ext Cntl ON: Activate CAT */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -171,7 +171,7 @@ int frg8800_close(RIG *rig)
rig_debug(RIG_DEBUG_TRACE, "%s: called\n", __func__);
/* send Ext Cntl OFF: Deactivate CAT */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -189,7 +189,7 @@ int frg8800_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
cmd[0] = (cmd[0] & 0xf0) | (1 << ((((long long)freq) % 100) / 25));
/* Frequency set */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -232,7 +232,7 @@ int frg8800_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
cmd[3] = md;
/* Mode set */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -246,6 +246,6 @@ int frg8800_set_powerstat(RIG *rig, powerstat_t status)
cmd[3] = status == RIG_POWER_OFF ? 0xff : 0xfe;
/* Frequency set */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}

4
rigs/yaesu/frg9600.c
Wyświetl plik

@ -148,7 +148,7 @@ int frg9600_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
to_bcd_be(cmd + 1, freq / 10, 8);
/* Frequency set */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -191,6 +191,6 @@ int frg9600_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
cmd[0] = md;
/* Mode set */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}

22
rigs/yaesu/ft100.c
Wyświetl plik

@ -526,20 +526,21 @@ static int ft100_send_priv_cmd(RIG *rig, unsigned char cmd_index)
if (!rig) { return -RIG_EINVAL; }
return write_block(&rig->state.rigport, (unsigned char *) &ncmd[cmd_index].nseq,
return write_block(RIGPORT(rig), (unsigned char *) &ncmd[cmd_index].nseq,
YAESU_CMD_LENGTH);
}
static int ft100_read_status(RIG *rig)
{
struct ft100_priv_data *priv;
hamlib_port_t *rp = RIGPORT(rig);
int ret;
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
priv = (struct ft100_priv_data *)rig->state.priv;
rig_flush(&rig->state.rigport);
rig_flush(rp);
ret = ft100_send_priv_cmd(rig, FT100_NATIVE_CAT_READ_STATUS);
@ -548,7 +549,7 @@ static int ft100_read_status(RIG *rig)
return ret;
}
ret = read_block(&rig->state.rigport, (unsigned char *) &priv->status,
ret = read_block(rp, (unsigned char *) &priv->status,
sizeof(FT100_STATUS_INFO));
rig_debug(RIG_DEBUG_VERBOSE, "%s: read status=%i \n", __func__, ret);
@ -564,10 +565,11 @@ static int ft100_read_flags(RIG *rig)
{
struct ft100_priv_data *priv = (struct ft100_priv_data *)rig->state.priv;
int ret;
hamlib_port_t *rp = RIGPORT(rig);
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
rig_flush(&rig->state.rigport);
rig_flush(rp);
ret = ft100_send_priv_cmd(rig, FT100_NATIVE_CAT_READ_FLAGS);
@ -576,7 +578,7 @@ static int ft100_read_flags(RIG *rig)
return ret;
}
ret = read_block(&rig->state.rigport, (unsigned char *) &priv->flags,
ret = read_block(rp, (unsigned char *) &priv->flags,
sizeof(FT100_FLAG_INFO));
rig_debug(RIG_DEBUG_VERBOSE, "%s: read flags=%i \n", __func__, ret);
@ -605,7 +607,7 @@ int ft100_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
freq = (int) freq / 10;
to_bcd(p_cmd, freq, 8); /* store bcd format in in p_cmd */
return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
}
int ft100_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
@ -731,7 +733,7 @@ int ft100_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
else if (width <= 2400) { p_cmd[3] = 0x00; }
else { p_cmd[3] = 0x01; }
ret = write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
ret = write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
if (ret != RIG_OK)
{
@ -992,7 +994,7 @@ int ft100_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return ret;
}
ret = read_block(&rig->state.rigport, (unsigned char *) &ft100_meter,
ret = read_block(RIGPORT(rig), (unsigned char *) &ft100_meter,
sizeof(FT100_METER_INFO));
rig_debug(RIG_DEBUG_VERBOSE, "%s: read meters=%d\n", __func__, ret);
@ -1209,7 +1211,7 @@ int ft100_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code)
p_cmd[3] = (char)pcode;
return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
}
int ft100_get_dcs_code(RIG *rig, vfo_t vfo, tone_t *code)
@ -1263,7 +1265,7 @@ int ft100_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
p_cmd[3] = (char)ptone;
return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
}
int ft100_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone)

39
rigs/yaesu/ft1000d.c
Wyświetl plik

@ -633,7 +633,6 @@ static int ft1000d_cleanup(RIG *rig)
*/
static int ft1000d_open(RIG *rig)
{
struct rig_state *rig_s;
struct ft1000d_priv_data *priv;
int err;
@ -645,12 +644,11 @@ static int ft1000d_open(RIG *rig)
}
priv = (struct ft1000d_priv_data *)rig->state.priv;
rig_s = &rig->state;
rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
__func__, rig_s->rigport.write_delay);
__func__, RIGPORT(rig)->write_delay);
rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
__func__, rig_s->rigport.post_write_delay);
__func__, RIGPORT(rig)->post_write_delay);
rig_debug(RIG_DEBUG_TRACE,
"%s: read pacing = %i\n", __func__, priv->pacing);
@ -2648,7 +2646,7 @@ static int ft1000d_get_level(RIG *rig, vfo_t vfo, setting_t level,
return err;
}
err = read_block(&rig->state.rigport, mdata, FT1000D_READ_METER_LENGTH);
err = read_block(RIGPORT(rig), mdata, FT1000D_READ_METER_LENGTH);
if (err < 0)
{
@ -3451,7 +3449,7 @@ static int ft1000d_get_channel(RIG *rig, vfo_t vfo, channel_t *chan,
static int ft1000d_get_update_data(RIG *rig, unsigned char ci,
unsigned short ch)
{
struct rig_state *rig_s;
hamlib_port_t *rp = RIGPORT(rig);
struct ft1000d_priv_data *priv;
int n;
int err;
@ -3470,9 +3468,8 @@ static int ft1000d_get_update_data(RIG *rig, unsigned char ci,
}
priv = (struct ft1000d_priv_data *)rig->state.priv;
rig_s = &rig->state;
retry = rig_s->rigport.retry;
retry = rp->retry;
do
{
@ -3541,7 +3538,7 @@ static int ft1000d_get_update_data(RIG *rig, unsigned char ci,
return -RIG_EINVAL;
}
n = read_block(&rig->state.rigport, p, rl);
n = read_block(rp, p, rl);
}
while (n < 0 && retry-- >= 0);
@ -3575,6 +3572,7 @@ static int ft1000d_get_update_data(RIG *rig, unsigned char ci,
static int ft1000d_send_static_cmd(RIG *rig, unsigned char ci)
{
int err;
hamlib_port_t *rp = RIGPORT(rig);
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
rig_debug(RIG_DEBUG_TRACE, "%s: ci = 0x%02x\n", __func__, ci);
@ -3591,15 +3589,14 @@ static int ft1000d_send_static_cmd(RIG *rig, unsigned char ci)
return -RIG_EINVAL;
}
err = write_block(&rig->state.rigport, ncmd[ci].nseq,
YAESU_CMD_LENGTH);
err = write_block(rp, ncmd[ci].nseq, YAESU_CMD_LENGTH);
if (err != RIG_OK)
{
return err;
}
hl_usleep(rig->state.rigport.write_delay * 1000);
hl_usleep(rp->write_delay * 1000);
return RIG_OK;
}
@ -3621,6 +3618,7 @@ static int ft1000d_send_dynamic_cmd(RIG *rig, unsigned char ci,
unsigned char p3, unsigned char p4)
{
struct ft1000d_priv_data *priv;
hamlib_port_t *rp = RIGPORT(rig);
int err;
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
@ -3652,15 +3650,14 @@ static int ft1000d_send_dynamic_cmd(RIG *rig, unsigned char ci,
priv->p_cmd[1] = p3;
priv->p_cmd[0] = p4;
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
err = write_block(rp, (unsigned char *) &priv->p_cmd, YAESU_CMD_LENGTH);
if (err != RIG_OK)
{
return err;
}
hl_usleep(rig->state.rigport.write_delay * 1000);
hl_usleep(rp->write_delay * 1000);
return RIG_OK;
}
@ -3679,6 +3676,7 @@ static int ft1000d_send_dynamic_cmd(RIG *rig, unsigned char ci,
static int ft1000d_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
{
struct ft1000d_priv_data *priv;
hamlib_port_t *rp = RIGPORT(rig);
int err;
// cppcheck-suppress *
char *fmt = "%s: requested freq after conversion = %"PRIll" Hz\n";
@ -3711,15 +3709,14 @@ static int ft1000d_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
FT1000D_BCD_DIAL) * 10);
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
err = write_block(rp, (unsigned char *) &priv->p_cmd, YAESU_CMD_LENGTH);
if (err != RIG_OK)
{
return err;
}
hl_usleep(rig->state.rigport.write_delay * 1000);
hl_usleep(rp->write_delay * 1000);
return RIG_OK;
}
@ -3737,6 +3734,7 @@ static int ft1000d_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
static int ft1000d_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
{
struct ft1000d_priv_data *priv;
hamlib_port_t *rp = RIGPORT(rig);
int err;
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
@ -3777,15 +3775,14 @@ static int ft1000d_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
// Store bcd format into privat command storage area
to_bcd(priv->p_cmd, labs(rit) / 10, FT1000D_BCD_RIT);
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
err = write_block(rp, (unsigned char *) &priv->p_cmd, YAESU_CMD_LENGTH);
if (err != RIG_OK)
{
return err;
}
hl_usleep(rig->state.rigport.write_delay * 1000);
hl_usleep(rp->write_delay * 1000);
return RIG_OK;
}

29
rigs/yaesu/ft1000mp.c
Wyświetl plik

@ -796,6 +796,7 @@ static int ft1000mp_cleanup(RIG *rig)
static int ft1000mp_open(RIG *rig)
{
struct rig_state *rig_s;
hamlib_port_t *rp = RIGPORT(rig);
struct ft1000mp_priv_data *p;
unsigned char *cmd; /* points to sequence to send */
@ -805,10 +806,10 @@ static int ft1000mp_open(RIG *rig)
p = (struct ft1000mp_priv_data *)rig_s->priv;
rig_debug(RIG_DEBUG_TRACE, "%s: rig_open: write_delay = %i msec \n", __func__,
rig_s->rigport.write_delay);
rp->write_delay);
rig_debug(RIG_DEBUG_TRACE, "%s: rig_open: post_write_delay = %i msec \n",
__func__,
rig_s->rigport.post_write_delay);
rp->post_write_delay);
/*
* Copy native cmd PACING to private cmd storage area
@ -819,7 +820,7 @@ static int ft1000mp_open(RIG *rig)
/* send PACING cmd to rig */
cmd = p->p_cmd;
write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
write_block(rp, cmd, YAESU_CMD_LENGTH);
ft1000mp_get_vfo(rig, &rig->state.current_vfo);
/* TODO */
@ -881,7 +882,7 @@ static int ft1000mp_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
(freq_t)from_bcd(p->p_cmd, 8) * 10);
cmd = p->p_cmd; /* get native sequence */
write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
RETURNFUNC(RIG_OK);
}
@ -1308,11 +1309,10 @@ static int ft1000mp_get_vfo(RIG *rig, vfo_t *vfo)
static int ft1000mp_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
{
struct ft1000mp_priv_data *priv;
struct rig_state *rs;
hamlib_port_t *rp = RIGPORT(rig);
unsigned char *cmd;
ENTERFUNC;
rs = &rig->state;
priv = (struct ft1000mp_priv_data *)rig->state.priv;
switch (func)
@ -1329,7 +1329,7 @@ static int ft1000mp_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
cmd = priv->p_cmd;
write_block(&rs->rigport, cmd, YAESU_CMD_LENGTH);
write_block(rp, cmd, YAESU_CMD_LENGTH);
RETURNFUNC(RIG_OK);
case RIG_FUNC_XIT:
@ -1344,7 +1344,7 @@ static int ft1000mp_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
cmd = priv->p_cmd;
write_block(&rs->rigport, cmd, YAESU_CMD_LENGTH);
write_block(rp, cmd, YAESU_CMD_LENGTH);
RETURNFUNC(RIG_OK);
default:
@ -1486,7 +1486,7 @@ static int ft1000mp_set_rxit(RIG *rig, vfo_t vfo, shortfreq_t rit)
priv->p_cmd[2] = direction;
cmd = priv->p_cmd; /* get native sequence */
write_block(&rs->rigport, cmd, YAESU_CMD_LENGTH);
write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
RETURNFUNC(RIG_OK);
}
@ -1548,10 +1548,11 @@ static int ft1000mp_get_level(RIG *rig, vfo_t vfo, setting_t level,
{
struct ft1000mp_priv_data *priv;
struct rig_state *rs;
hamlib_port_t *rp = RIGPORT(rig);
unsigned char lvl_data[YAESU_CMD_LENGTH];
int m;
int retval;
int retry = rig->state.rigport.retry;
int retry = rp->retry;
ENTERFUNC;
rs = &rig->state;
@ -1611,9 +1612,9 @@ static int ft1000mp_get_level(RIG *rig, vfo_t vfo, setting_t level,
do
{
write_block(&rs->rigport, priv->p_cmd, YAESU_CMD_LENGTH);
write_block(rp, priv->p_cmd, YAESU_CMD_LENGTH);
retval = read_block(&rs->rigport, lvl_data, YAESU_CMD_LENGTH);
retval = read_block(rp, lvl_data, YAESU_CMD_LENGTH);
}
while (retry-- && retval == -RIG_ETIMEOUT);
@ -1688,7 +1689,7 @@ static int ft1000mp_get_update_data(RIG *rig, unsigned char ci,
/* send UPDATE command to fetch data*/
ft1000mp_send_priv_cmd(rig, ci);
n = read_block(&rig->state.rigport, p->update_data, rl);
n = read_block(RIGPORT(rig), p->update_data, rl);
if (n == -RIG_ETIMEOUT)
{
@ -1717,7 +1718,7 @@ static int ft1000mp_send_priv_cmd(RIG *rig, unsigned char ci)
RETURNFUNC(-RIG_EINVAL);
}
write_block(&rig->state.rigport, ncmd[ci].nseq, YAESU_CMD_LENGTH);
write_block(RIGPORT(rig), ncmd[ci].nseq, YAESU_CMD_LENGTH);
RETURNFUNC(RIG_OK);

15
rigs/yaesu/ft600.c
Wyświetl plik

@ -389,20 +389,21 @@ static int ft600_send_priv_cmd(RIG *rig, unsigned char cmd_index)
if (!rig) { return -RIG_EINVAL; }
return write_block(&rig->state.rigport, (unsigned char *) &ncmd[cmd_index].nseq,
return write_block(RIGPORT(rig), (unsigned char *) &ncmd[cmd_index].nseq,
YAESU_CMD_LENGTH);
}
static int ft600_read_status(RIG *rig)
{
struct ft600_priv_data *priv;
hamlib_port_t *rp = RIGPORT(rig);
int ret;
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
priv = (struct ft600_priv_data *)rig->state.priv;
rig_flush(&rig->state.rigport);
rig_flush(rp);
ret = ft600_send_priv_cmd(rig, FT600_NATIVE_CAT_READ_STATUS);
@ -412,8 +413,8 @@ static int ft600_read_status(RIG *rig)
}
ret = read_block(&rig->state.rigport,
(unsigned char *) &priv->status, FT600_STATUS_UPDATE_DATA_LENGTH);
ret = read_block(rp, (unsigned char *) &priv->status,
FT600_STATUS_UPDATE_DATA_LENGTH);
rig_debug(RIG_DEBUG_VERBOSE, "%s: read status=%i \n", __func__, ret);
@ -444,7 +445,7 @@ static int ft600_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
rig_debug(RIG_DEBUG_VERBOSE, "%s: read tx status=%i \n", __func__, ret);
ret = read_block(&rig->state.rigport, &priv->s_meter, 5);
ret = read_block(RIGPORT(rig), &priv->s_meter, 5);
if (ret < 0)
{
@ -475,7 +476,7 @@ static int ft600_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
freq = (int)freq / 10;
to_bcd(p_cmd, freq, 8); /* store bcd format in in p_cmd */
return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
}
static int ft600_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
@ -643,7 +644,7 @@ static int ft600_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
else if (width <= 2400) { p_cmd[3] = 0x00; }
else { p_cmd[3] = 0x01; }
ret = write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
ret = write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
if (ret != RIG_OK)
{

38
rigs/yaesu/ft736.c
Wyświetl plik

@ -240,7 +240,7 @@ int ft736_open(RIG *rig)
/* send Ext Cntl ON: Activate CAT */
ret = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
ret = write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
if (ret != RIG_OK)
{
@ -259,7 +259,7 @@ int ft736_close(RIG *rig)
free(rig->state.priv);
/* send Ext Cntl OFF: Deactivate CAT */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -287,7 +287,7 @@ int ft736_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
cmd[0] = (cmd[0] & 0x0f) | 0xc0;
}
retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
retval = write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
if (retval == RIG_OK) { rig_set_cache_freq(rig, vfo, freq); }
@ -358,7 +358,7 @@ int ft736_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
cmd[0] = md;
/* Mode set */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -375,7 +375,7 @@ int ft736_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
*/
cmd[4] = split == RIG_SPLIT_ON ? 0x0e : 0x8e;
ret = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
ret = write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
if (ret == RIG_OK)
{
@ -403,7 +403,7 @@ int ft736_set_split_freq(RIG *rig, vfo_t vfo, freq_t freq)
}
/* Frequency set */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -444,7 +444,7 @@ int ft736_set_split_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
cmd[0] = md;
/* Mode set */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -457,17 +457,18 @@ int ft736_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
cmd[4] = ptt == RIG_PTT_ON ? 0x08 : 0x88;
/* Tx/Rx set */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
int ft736_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
{
unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0xe7};
int retval;
hamlib_port_t *rp = RIGPORT(rig);
rig_flush(&rig->state.rigport);
rig_flush(rp);
retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
if (retval < 0)
{
@ -475,7 +476,7 @@ int ft736_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
}
/* read back the 1 byte */
retval = read_block(&rig->state.rigport, cmd, 5);
retval = read_block(rp, cmd, 5);
if (retval < 1)
{
@ -494,16 +495,17 @@ int ft736_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0xf7};
int retval;
hamlib_port_t *rp = RIGPORT(rig);
if (level != RIG_LEVEL_RAWSTR)
{
return -RIG_EINVAL;
}
rig_flush(&rig->state.rigport);
rig_flush(rp);
/* send Test S-meter cmd to rig */
retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
if (retval < 0)
{
@ -511,7 +513,7 @@ int ft736_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
}
/* read back the 1 byte */
retval = read_block(&rig->state.rigport, cmd, 5);
retval = read_block(rp, cmd, 5);
if (retval < 1)
{
@ -553,7 +555,7 @@ int ft736_set_rptr_shift(RIG *rig, vfo_t vfo, rptr_shift_t shift)
return -RIG_EINVAL;
}
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
int ft736_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t offs)
@ -564,7 +566,7 @@ int ft736_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t offs)
to_bcd_be(cmd, offs / 10, 8);
/* Offset set */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
int ft736_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
@ -585,7 +587,7 @@ int ft736_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
return -RIG_EINVAL;
}
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
int ft736_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
@ -608,7 +610,7 @@ int ft736_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
cmd[0] = 0x3e - i;
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
int ft736_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)

16
rigs/yaesu/ft747.c
Wyświetl plik

@ -483,17 +483,17 @@ int ft747_cleanup(RIG *rig)
int ft747_open(RIG *rig)
{
struct rig_state *rig_s;
hamlib_port_t *rp = RIGPORT(rig);
struct ft747_priv_data *p;
int ret;
rig_s = &rig->state;
p = (struct ft747_priv_data *)rig_s->priv;
rig_debug(RIG_DEBUG_VERBOSE, "ft747:rig_open: write_delay = %i msec \n",
rig_s->rigport.write_delay);
rp->write_delay);
rig_debug(RIG_DEBUG_VERBOSE, "ft747:rig_open: post_write_delay = %i msec \n",
rig_s->rigport.post_write_delay);
rp->post_write_delay);
/*
* Copy native cmd PACING to private cmd storage area
@ -507,7 +507,7 @@ int ft747_open(RIG *rig)
/* send PACING cmd to rig, once for all */
ret = write_block(&rig->state.rigport, p->p_cmd, YAESU_CMD_LENGTH);
ret = write_block(rp, p->p_cmd, YAESU_CMD_LENGTH);
if (ret < 0)
{
@ -568,7 +568,7 @@ int ft747_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
rig_force_cache_timeout(&p->status_tv);
cmd = p->p_cmd; /* get native sequence */
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -958,7 +958,7 @@ int ft747_set_mem(RIG *rig, vfo_t vfo, int ch)
rig_force_cache_timeout(&p->status_tv);
return write_block(&rig->state.rigport, p->p_cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), p->p_cmd, YAESU_CMD_LENGTH);
}
int ft747_get_mem(RIG *rig, vfo_t vfo, int *ch)
@ -1003,7 +1003,7 @@ static int ft747_get_update_data(RIG *rig)
//unsigned char last_byte;
p = (struct ft747_priv_data *)rig->state.priv;
rigport = &rig->state.rigport;
rigport = RIGPORT(rig);
if (rig->state.cache.ptt == RIG_PTT_ON
|| !rig_check_cache_timeout(&p->status_tv, FT747_CACHE_TIMEOUT))
@ -1064,7 +1064,7 @@ static int ft747_send_priv_cmd(RIG *rig, unsigned char ci)
return -RIG_EINVAL;
}
return write_block(&rig->state.rigport, ft747_ncmd[ci].nseq, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), ft747_ncmd[ci].nseq, YAESU_CMD_LENGTH);
}

25
rigs/yaesu/ft757gx.c
Wyświetl plik

@ -465,7 +465,7 @@ static int ft757_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
to_bcd(cmd, freq / 10, BCD_LEN);
priv->curfreq = freq;
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -491,7 +491,7 @@ static int ft757_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
/* fill in p1 */
cmd[3] = mode2rig(rig, mode, width);
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -622,7 +622,7 @@ static int ft757_set_vfo(RIG *rig, vfo_t vfo)
priv->current_vfo = vfo;
RETURNFUNC(write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH));
RETURNFUNC(write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH));
}
static int ft757gx_get_vfo(RIG *rig, vfo_t *vfo)
@ -687,6 +687,7 @@ static int ft757_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x01, 0x10};
int retval;
hamlib_port_t *rp = RIGPORT(rig);
rig_debug(RIG_DEBUG_VERBOSE, "%s called.\n", __func__);
@ -700,10 +701,10 @@ static int ft757_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return -RIG_EINVAL;
}
rig_flush(&rig->state.rigport);
rig_flush(rp);
/* send READ STATUS(Meter only) cmd to rig */
retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
if (retval < 0)
{
@ -711,7 +712,7 @@ static int ft757_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
}
/* read back the 1 byte */
retval = read_block(&rig->state.rigport, cmd, 1);
retval = read_block(rp, cmd, 1);
if (retval != 1)
{
@ -738,22 +739,23 @@ static int ft757_get_update_data(RIG *rig)
{
const unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0x10};
struct ft757_priv_data *priv = (struct ft757_priv_data *)rig->state.priv;
hamlib_port_t *rp = RIGPORT(rig);
int retval = 0;
long nbtries;
/* Maximum number of attempts to ask/read the data. */
int maxtries = rig->state.rigport.retry ;
int maxtries = rp->retry ;
rig_debug(RIG_DEBUG_VERBOSE, "%s called Timeout=%d ms, Retry=%d\n",
__func__, rig->state.rigport.timeout, maxtries);
__func__, rp->timeout, maxtries);
/* At least on one model, returns erraticaly a timeout. Increasing the timeout
does not fix things. So we restart the read from scratch, it works most of times. */
for (nbtries = 0 ; nbtries < maxtries ; nbtries++)
{
rig_flush(&rig->state.rigport);
rig_flush(rp);
/* send READ STATUS cmd to rig */
retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
if (retval < 0)
{
@ -761,8 +763,7 @@ static int ft757_get_update_data(RIG *rig)
}
/* read back the 75 status bytes */
retval = read_block(&rig->state.rigport,
priv->update_data,
retval = read_block(rp, priv->update_data,
FT757GX_STATUS_UPDATE_DATA_LENGTH);
if (retval == FT757GX_STATUS_UPDATE_DATA_LENGTH)

21
rigs/yaesu/ft767gx.c
Wyświetl plik

@ -456,7 +456,7 @@ int ft767_open(RIG *rig)
struct ft767_priv_data *priv = (struct ft767_priv_data *)rig->state.priv;
int retval;
rig_flush(&rig->state.rigport);
rig_flush(RIGPORT(rig));
/* send 0 delay PACING cmd to rig */
retval = ft767_enter_CAT(rig);
@ -1232,7 +1232,7 @@ int ft767_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
return -RIG_EINVAL; /* sorry, wrong VFO */
}
rig_flush(&rig->state.rigport);
rig_flush(RIGPORT(rig));
retval = ft767_enter_CAT(rig);
@ -1407,6 +1407,7 @@ int ft767_leave_CAT(RIG *rig)
int ft767_send_block_and_ack(RIG *rig, unsigned char *cmd, size_t length)
{
struct ft767_priv_data *priv = (struct ft767_priv_data *)rig->state.priv;
hamlib_port_t *rp = RIGPORT(rig);
size_t replylen, cpycnt;
unsigned char cmd_echo_buf[5];
int retval;
@ -1480,12 +1481,10 @@ int ft767_send_block_and_ack(RIG *rig, unsigned char *cmd, size_t length)
}
/* send the command block */
write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
write_block(rp, cmd, YAESU_CMD_LENGTH);
/* read back the command block echo */
retval = read_block(&rig->state.rigport,
cmd_echo_buf,
YAESU_CMD_LENGTH);
retval = read_block(rp, cmd_echo_buf, YAESU_CMD_LENGTH);
if (retval < 0)
{
@ -1503,12 +1502,10 @@ int ft767_send_block_and_ack(RIG *rig, unsigned char *cmd, size_t length)
}
/* send the ACK */
write_block(&rig->state.rigport, priv->ack_cmd, YAESU_CMD_LENGTH);
write_block(rp, priv->ack_cmd, YAESU_CMD_LENGTH);
/* read back the response (status bytes) */
retval = read_block(&rig->state.rigport,
priv->rx_data,
replylen);
retval = read_block(rp, priv->rx_data, replylen);
// update data
if (retval != replylen)
@ -1545,7 +1542,7 @@ int ft767_get_update_data(RIG *rig)
struct ft767_priv_data *priv = (struct ft767_priv_data *)rig->state.priv;
int retval;
rig_flush(&rig->state.rigport);
rig_flush(RIGPORT(rig));
/* Entering CAT updates our data structures */
retval = ft767_enter_CAT(rig);
@ -1576,7 +1573,7 @@ int ft767_set_split(RIG *rig, unsigned int split)
int retval;
unsigned int curr_split;
rig_flush(&rig->state.rigport);
rig_flush(RIGPORT(rig));
/* Entering CAT updates our data structures */
retval = ft767_enter_CAT(rig);

37
rigs/yaesu/ft817.c
Wyświetl plik

@ -829,6 +829,7 @@ static int check_cache_timeout(struct timeval *tv)
static int ft817_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
{
unsigned char data[YAESU_CMD_LENGTH];
hamlib_port_t *rp = RIGPORT(rig);
int n;
rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
@ -838,9 +839,9 @@ static int ft817_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
data[0] = addr >> 8;
data[1] = addr & 0xff;
write_block(&rig->state.rigport, data, YAESU_CMD_LENGTH);
write_block(rp, data, YAESU_CMD_LENGTH);
if ((n = read_block(&rig->state.rigport, data, 2)) < 0)
if ((n = read_block(rp, data, 2)) < 0)
{
return n;
}
@ -869,11 +870,12 @@ static int ft817_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
static int ft817_get_status(RIG *rig, int status)
{
struct ft817_priv_data *p = (struct ft817_priv_data *) rig->state.priv;
hamlib_port_t *rp = RIGPORT(rig);
struct timeval *tv;
unsigned char *data;
int len;
int n;
int retries = rig->state.rigport.retry;
int retries = rp->retry;
unsigned char result[2];
rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
@ -913,10 +915,9 @@ static int ft817_get_status(RIG *rig, int status)
do
{
rig_flush(&rig->state.rigport);
write_block(&rig->state.rigport, ncmd[status].nseq,
YAESU_CMD_LENGTH);
n = read_block(&rig->state.rigport, data, len);
rig_flush(rp);
write_block(rp, ncmd[status].nseq, YAESU_CMD_LENGTH);
n = read_block(rp, data, len);
}
while (retries-- && n < 0);
@ -987,7 +988,7 @@ static int ft817_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
struct ft817_priv_data *p = (struct ft817_priv_data *) rig->state.priv;
freq_t f1 = 0, f2 = 0;
int retries = rig->state.rigport.retry +
int retries = RIGPORT(rig)->retry +
1; // +1 because, because 2 steps are needed even in best scenario
rig_debug(RIG_DEBUG_VERBOSE, "%s: called, vfo=%s, ptt=%d, split=%d\n", __func__,
@ -1488,16 +1489,17 @@ static int ft818_get_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t *option,
int ft817_read_ack(RIG *rig)
{
unsigned char dummy;
hamlib_port_t *rp = RIGPORT(rig);
rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
if (rig->state.rigport.post_write_delay == 0)
if (rp->post_write_delay == 0)
{
if (read_block(&rig->state.rigport, &dummy, 1) < 0)
if (read_block(rp, &dummy, 1) < 0)
{
rig_debug(RIG_DEBUG_ERR, "%s: error reading ack\n", __func__);
rig_debug(RIG_DEBUG_ERR, "%s: adjusting post_write_delay to avoid ack\n",
__func__);
rig->state.rigport.post_write_delay =
rp->post_write_delay =
10; // arbitrary choice right now of max 100 cmds/sec
return RIG_OK; // let it continue without checking for ack now
}
@ -1519,6 +1521,7 @@ int ft817_read_ack(RIG *rig)
*/
static int ft817_send_cmd(RIG *rig, int index)
{
hamlib_port_t *rp = RIGPORT(rig);
rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
if (ncmd[index].ncomp == 0)
@ -1527,8 +1530,8 @@ static int ft817_send_cmd(RIG *rig, int index)
return -RIG_EINTERNAL;
}
rig_flush(&rig->state.rigport);
write_block(&rig->state.rigport, ncmd[index].nseq, YAESU_CMD_LENGTH);
rig_flush(rp);
write_block(rp, ncmd[index].nseq, YAESU_CMD_LENGTH);
return ft817_read_ack(rig);
}
@ -1550,7 +1553,7 @@ static int ft817_send_icmd(RIG *rig, int index, const unsigned char *data)
cmd[YAESU_CMD_LENGTH - 1] = ncmd[index].nseq[YAESU_CMD_LENGTH - 1];
memcpy(cmd, data, YAESU_CMD_LENGTH - 1);
write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
return ft817_read_ack(rig);
}
@ -1746,7 +1749,7 @@ static int ft817_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
{
int index;
ptt_t ptt_response = -1;
int retries = rig->state.rigport.retry;
int retries = RIGPORT(rig)->retry;
rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
@ -2059,10 +2062,10 @@ int ft817_set_powerstat(RIG *rig, powerstat_t status)
case RIG_POWER_ON:
// send 5 bytes first, snooze a bit, then PWR_ON
write_block(&rig->state.rigport,
write_block(RIGPORT(rig),
ncmd[FT817_NATIVE_CAT_PWR_WAKE].nseq, YAESU_CMD_LENGTH);
hl_usleep(200 * 1000);
write_block(&rig->state.rigport, ncmd[FT817_NATIVE_CAT_PWR_ON].nseq,
write_block(RIGPORT(rig), ncmd[FT817_NATIVE_CAT_PWR_ON].nseq,
YAESU_CMD_LENGTH);
return RIG_OK;

16
rigs/yaesu/ft840.c
Wyświetl plik

@ -440,7 +440,6 @@ static int ft840_cleanup(RIG *rig)
static int ft840_open(RIG *rig)
{
struct rig_state *rig_s;
struct ft840_priv_data *priv;
int err;
@ -452,12 +451,11 @@ static int ft840_open(RIG *rig)
}
priv = (struct ft840_priv_data *)rig->state.priv;
rig_s = &rig->state;
rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
__func__, rig_s->rigport.write_delay);
__func__, RIGPORT(rig)->write_delay);
rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
__func__, rig_s->rigport.post_write_delay);
__func__, RIGPORT(rig)->post_write_delay);
rig_debug(RIG_DEBUG_TRACE,
"%s: read pacing = %i\n", __func__, priv->pacing);
@ -1746,7 +1744,7 @@ static int ft840_get_update_data(RIG *rig, unsigned char ci, unsigned char rl)
return err;
}
n = read_block(&rig->state.rigport, priv->update_data, rl);
n = read_block(RIGPORT(rig), priv->update_data, rl);
if (n < 0)
{
@ -1789,7 +1787,7 @@ static int ft840_send_static_cmd(RIG *rig, unsigned char ci)
return -RIG_EINVAL;
}
err = write_block(&rig->state.rigport, ncmd[ci].nseq,
err = write_block(RIGPORT(rig), ncmd[ci].nseq,
YAESU_CMD_LENGTH);
if (err != RIG_OK)
@ -1850,7 +1848,7 @@ static int ft840_send_dynamic_cmd(RIG *rig, unsigned char ci,
priv->p_cmd[P3] = p3;
priv->p_cmd[P4] = p4;
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)
@ -1911,7 +1909,7 @@ static int ft840_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
FT840_BCD_DIAL) * 10);
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)
@ -1993,7 +1991,7 @@ static int ft840_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
priv->p_cmd[P1] = p1; /* ick */
priv->p_cmd[P2] = p2;
err = write_block(&rig->state.rigport, (char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)

29
rigs/yaesu/ft847.c
Wyświetl plik

@ -1119,7 +1119,7 @@ static int ft847_send_priv_cmd(RIG *rig, int cmd_index)
return -RIG_EINVAL;
}
return write_block(&rig->state.rigport, ncmd[cmd_index].nseq,
return write_block(RIGPORT(rig), ncmd[cmd_index].nseq,
YAESU_CMD_LENGTH);
}
@ -1213,7 +1213,7 @@ static int ft847_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
}
}
return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
}
#define MD_LSB 0x00
@ -1230,7 +1230,7 @@ static int ft847_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
static int get_freq_and_mode(RIG *rig, vfo_t vfo, freq_t *freq, rmode_t *mode,
pbwidth_t *width)
{
struct rig_state *rs = &rig->state;
hamlib_port_t *rp = RIGPORT(rig);
unsigned char p_cmd[YAESU_CMD_LENGTH]; /* sequence to send */
unsigned char cmd_index; /* index of sequence to send */
unsigned char data[8];
@ -1270,14 +1270,14 @@ static int get_freq_and_mode(RIG *rig, vfo_t vfo, freq_t *freq, rmode_t *mode,
return n;
}
n = write_block(&rs->rigport, p_cmd, YAESU_CMD_LENGTH);
n = write_block(rp, p_cmd, YAESU_CMD_LENGTH);
if (n < 0)
{
return n;
}
n = read_block(&rs->rigport, data, YAESU_CMD_LENGTH);
n = read_block(rp, data, YAESU_CMD_LENGTH);
if (n != YAESU_CMD_LENGTH)
{
@ -1358,7 +1358,6 @@ static int ft847_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
static int ft847_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
unsigned char cmd_index; /* index of sequence to send */
struct rig_state *rs = &rig->state;
unsigned char p_cmd[YAESU_CMD_LENGTH]; /* sequence to send */
int ret;
@ -1467,7 +1466,7 @@ static int ft847_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
return ret;
}
return write_block(&rs->rigport, p_cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
}
static int ft847_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
@ -1595,6 +1594,7 @@ static int ft847_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
static int ft847_get_status(RIG *rig, int status_ci)
{
struct ft847_priv_data *p = (struct ft847_priv_data *) rig->state.priv;
hamlib_port_t *rp = RIGPORT(rig);
unsigned char *data;
int len;
int n;
@ -1621,17 +1621,16 @@ static int ft847_get_status(RIG *rig, int status_ci)
return -RIG_EINTERNAL;
}
rig_flush(&rig->state.rigport);
rig_flush(rp);
n = write_block(&rig->state.rigport, ncmd[status_ci].nseq,
YAESU_CMD_LENGTH);
n = write_block(rp, ncmd[status_ci].nseq, YAESU_CMD_LENGTH);
if (n < 0)
{
return n;
}
n = read_block(&rig->state.rigport, data, len);
n = read_block(rp, data, len);
if (n < 0)
{
@ -1873,7 +1872,7 @@ static int ft847_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
return ret;
}
return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
}
@ -1918,7 +1917,7 @@ static int ft847_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
/* get associated CAT code */
p_cmd[0] = ft847_ctcss_cat[i];
return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
}
static int ft847_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
@ -1944,7 +1943,7 @@ static int ft847_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code)
/* DCS Code # (i.e. 07, 54=DCS Code 754) */
to_bcd_be(p_cmd, code, 4); /* store bcd format in in p_cmd */
return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
}
@ -1987,6 +1986,6 @@ static int ft847_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t rptr_offs)
to_bcd_be(p_cmd, rptr_offs / 10, 8); /* store bcd format in in p_cmd */
return write_block(&rig->state.rigport, p_cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), p_cmd, YAESU_CMD_LENGTH);
}

17
rigs/yaesu/ft857.c
Wyświetl plik

@ -470,6 +470,7 @@ static int check_cache_timeout(struct timeval *tv)
static int ft857_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
{
unsigned char data[YAESU_CMD_LENGTH];
hamlib_port_t *rp = RIGPORT(rig);
int n;
rig_debug(RIG_DEBUG_VERBOSE, "%s: called \n", __func__);
@ -479,9 +480,9 @@ static int ft857_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
data[0] = addr >> 8;
data[1] = addr & 0xfe;
write_block(&rig->state.rigport, data, YAESU_CMD_LENGTH);
write_block(rp, data, YAESU_CMD_LENGTH);
if ((n = read_block(&rig->state.rigport, data, 2)) < 0)
if ((n = read_block(rp, data, 2)) < 0)
{
return n;
}
@ -499,6 +500,7 @@ static int ft857_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
static int ft857_get_status(RIG *rig, int status)
{
struct ft857_priv_data *p = (struct ft857_priv_data *) rig->state.priv;
hamlib_port_t *rp = RIGPORT(rig);
struct timeval *tv;
unsigned char *data;
int len;
@ -531,12 +533,11 @@ static int ft857_get_status(RIG *rig, int status)
return -RIG_EINTERNAL;
}
rig_flush(&rig->state.rigport);
rig_flush(rp);
write_block(&rig->state.rigport, ncmd[status].nseq,
YAESU_CMD_LENGTH);
write_block(rp, ncmd[status].nseq, YAESU_CMD_LENGTH);
if ((n = read_block(&rig->state.rigport, data, len)) < 0)
if ((n = read_block(rp, data, len)) < 0)
{
return n;
}
@ -575,7 +576,7 @@ static int ft857_send_cmd(RIG *rig, int index)
return -RIG_EINTERNAL;
}
write_block(&rig->state.rigport, ncmd[index].nseq, YAESU_CMD_LENGTH);
write_block(RIGPORT(rig), ncmd[index].nseq, YAESU_CMD_LENGTH);
return ft817_read_ack(rig);
}
@ -597,7 +598,7 @@ static int ft857_send_icmd(RIG *rig, int index, const unsigned char *data)
cmd[YAESU_CMD_LENGTH - 1] = ncmd[index].nseq[YAESU_CMD_LENGTH - 1];
memcpy(cmd, data, YAESU_CMD_LENGTH - 1);
write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
return ft817_read_ack(rig);
}

17
rigs/yaesu/ft890.c
Wyświetl plik

@ -590,7 +590,7 @@ static int ft890_cleanup(RIG *rig)
static int ft890_open(RIG *rig)
{
struct rig_state *rig_s;
hamlib_port_t *rp = RIGPORT(rig);
struct ft890_priv_data *priv;
int err;
@ -602,12 +602,11 @@ static int ft890_open(RIG *rig)
}
priv = (struct ft890_priv_data *)rig->state.priv;
rig_s = &rig->state;
rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
__func__, rig_s->rigport.write_delay);
__func__, rp->write_delay);
rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
__func__, rig_s->rigport.post_write_delay);
__func__, rp->post_write_delay);
rig_debug(RIG_DEBUG_TRACE,
"%s: read pacing = %i\n", __func__, priv->pacing);
@ -1899,7 +1898,7 @@ static int ft890_get_update_data(RIG *rig, unsigned char ci, unsigned char rl)
return err;
}
n = read_block(&rig->state.rigport, priv->update_data, rl);
n = read_block(RIGPORT(rig), priv->update_data, rl);
if (n < 0)
{
@ -1942,7 +1941,7 @@ static int ft890_send_static_cmd(RIG *rig, unsigned char ci)
return -RIG_EINVAL;
}
err = write_block(&rig->state.rigport, ncmd[ci].nseq, YAESU_CMD_LENGTH);
err = write_block(RIGPORT(rig), ncmd[ci].nseq, YAESU_CMD_LENGTH);
if (err != RIG_OK)
{
@ -2002,7 +2001,7 @@ static int ft890_send_dynamic_cmd(RIG *rig, unsigned char ci,
priv->p_cmd[P3] = p3;
priv->p_cmd[P4] = p4;
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)
@ -2063,7 +2062,7 @@ static int ft890_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
FT890_BCD_DIAL) * 10);
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)
@ -2144,7 +2143,7 @@ static int ft890_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
priv->p_cmd[P1] = p1; /* ick */
priv->p_cmd[P2] = p2;
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)

9
rigs/yaesu/ft891.c
Wyświetl plik

@ -357,7 +357,6 @@ struct rig_caps ft891_caps =
static int ft891_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
{
struct newcat_priv_data *priv;
struct rig_state *state;
unsigned char ci;
int err;
@ -373,7 +372,6 @@ static int ft891_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
rig_debug(RIG_DEBUG_TRACE, "%s: passed tx_vfo = 0x%02x\n", __func__, tx_vfo);
priv = (struct newcat_priv_data *)rig->state.priv;
state = &rig->state;
// RX VFO and TX VFO cannot be the same, no support for MEM as TX VFO
if (vfo == tx_vfo || tx_vfo == RIG_VFO_MEM)
@ -397,7 +395,7 @@ static int ft891_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
SNPRINTF(priv->cmd_str, sizeof(priv->cmd_str), "ST%c;", ci);
if (RIG_OK != (err = write_block(&state->rigport,
if (RIG_OK != (err = write_block(RIGPORT(rig),
(unsigned char *) priv->cmd_str, strlen(priv->cmd_str))))
{
rig_debug(RIG_DEBUG_ERR, "%s: write_block err = %d\n", __func__, err);
@ -533,7 +531,6 @@ static int ft891_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode,
pbwidth_t tx_width)
{
struct newcat_priv_data *priv;
struct rig_state *state;
freq_t b_freq;
int err;
@ -544,8 +541,6 @@ static int ft891_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode,
return -RIG_EINVAL;
}
state = &rig->state;
rig_debug(RIG_DEBUG_TRACE, "%s: passed vfo = %s\n", __func__, rig_strvfo(vfo));
rig_debug(RIG_DEBUG_TRACE, "%s: passed mode = %s\n", __func__,
rig_strrmode(tx_mode));
@ -569,7 +564,7 @@ static int ft891_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode,
// Copy A to B
SNPRINTF(priv->cmd_str, sizeof(priv->cmd_str), "AB;");
if (RIG_OK != (err = write_block(&state->rigport,
if (RIG_OK != (err = write_block(RIGPORT(rig),
(unsigned char *) priv->cmd_str, strlen(priv->cmd_str))))
{
rig_debug(RIG_DEBUG_VERBOSE, "%s:%d write_block err = %d\n", __func__, __LINE__,

17
rigs/yaesu/ft897.c
Wyświetl plik

@ -623,6 +623,7 @@ static int ft897_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
{
unsigned char data[YAESU_CMD_LENGTH];
int n;
hamlib_port_t *rp = RIGPORT(rig);
rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
memcpy(data, (char *)ncmd[FT897_NATIVE_CAT_EEPROM_READ].nseq,
@ -631,9 +632,9 @@ static int ft897_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
data[0] = addr >> 8;
data[1] = addr & 0xfe;
write_block(&rig->state.rigport, data, YAESU_CMD_LENGTH);
write_block(rp, data, YAESU_CMD_LENGTH);
if ((n = read_block(&rig->state.rigport, data, 2)) < 0)
if ((n = read_block(rp, data, 2)) < 0)
{
return n;
}
@ -651,6 +652,7 @@ static int ft897_read_eeprom(RIG *rig, unsigned short addr, unsigned char *out)
static int ft897_get_status(RIG *rig, int status)
{
struct ft897_priv_data *p = (struct ft897_priv_data *) rig->state.priv;
hamlib_port_t *rp = RIGPORT(rig);
struct timeval *tv;
unsigned char *data;
int len;
@ -690,12 +692,11 @@ static int ft897_get_status(RIG *rig, int status)
return -RIG_EINTERNAL;
}
rig_flush(&rig->state.rigport);
rig_flush(rp);
write_block(&rig->state.rigport, ncmd[status].nseq,
YAESU_CMD_LENGTH);
write_block(rp, ncmd[status].nseq, YAESU_CMD_LENGTH);
if ((n = read_block(&rig->state.rigport, data, len)) < 0)
if ((n = read_block(rp, data, len)) < 0)
{
return n;
}
@ -1054,7 +1055,7 @@ static int ft897_send_cmd(RIG *rig, int index)
return -RIG_EINTERNAL;
}
write_block(&rig->state.rigport, ncmd[index].nseq, YAESU_CMD_LENGTH);
write_block(RIGPORT(rig), ncmd[index].nseq, YAESU_CMD_LENGTH);
return ft817_read_ack(rig);
}
@ -1076,7 +1077,7 @@ static int ft897_send_icmd(RIG *rig, int index, const unsigned char *data)
cmd[YAESU_CMD_LENGTH - 1] = ncmd[index].nseq[YAESU_CMD_LENGTH - 1];
memcpy(cmd, data, YAESU_CMD_LENGTH - 1);
write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
return ft817_read_ack(rig);
}

16
rigs/yaesu/ft900.c
Wyświetl plik

@ -612,7 +612,6 @@ static int ft900_cleanup(RIG *rig)
static int ft900_open(RIG *rig)
{
struct rig_state *rig_s;
struct ft900_priv_data *priv;
int err;
@ -624,12 +623,11 @@ static int ft900_open(RIG *rig)
}
priv = (struct ft900_priv_data *)rig->state.priv;
rig_s = &rig->state;
rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
__func__, rig_s->rigport.write_delay);
__func__, RIGPORT(rig)->write_delay);
rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
__func__, rig_s->rigport.post_write_delay);
__func__, RIGPORT(rig)->post_write_delay);
rig_debug(RIG_DEBUG_TRACE,
"%s: read pacing = %i\n", __func__, priv->pacing);
@ -1921,7 +1919,7 @@ static int ft900_get_update_data(RIG *rig, unsigned char ci, unsigned char rl)
return err;
}
n = read_block(&rig->state.rigport, priv->update_data, rl);
n = read_block(RIGPORT(rig), priv->update_data, rl);
if (n < 0)
{
@ -1964,7 +1962,7 @@ static int ft900_send_static_cmd(RIG *rig, unsigned char ci)
return -RIG_EINVAL;
}
err = write_block(&rig->state.rigport, ncmd[ci].nseq, YAESU_CMD_LENGTH);
err = write_block(RIGPORT(rig), ncmd[ci].nseq, YAESU_CMD_LENGTH);
if (err != RIG_OK)
{
@ -2024,7 +2022,7 @@ static int ft900_send_dynamic_cmd(RIG *rig, unsigned char ci,
priv->p_cmd[P3] = p3;
priv->p_cmd[P4] = p4;
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)
@ -2085,7 +2083,7 @@ static int ft900_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
FT900_BCD_DIAL) * 10);
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)
@ -2166,7 +2164,7 @@ static int ft900_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
priv->p_cmd[P1] = p1; /* ick */
priv->p_cmd[P2] = p2;
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)

19
rigs/yaesu/ft920.c
Wyświetl plik

@ -686,7 +686,7 @@ static int ft920_cleanup(RIG *rig)
static int ft920_open(RIG *rig)
{
struct rig_state *rig_s;
hamlib_port_t *rp = RIGPORT(rig);
struct ft920_priv_data *priv;
int err;
@ -698,12 +698,11 @@ static int ft920_open(RIG *rig)
}
priv = (struct ft920_priv_data *)rig->state.priv;
rig_s = &rig->state;
rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
__func__, rig_s->rigport.write_delay);
__func__, rp->write_delay);
rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
__func__, rig_s->rigport.post_write_delay);
__func__, rp->post_write_delay);
/* Copy native cmd PACING to private cmd storage area */
memcpy(&priv->p_cmd, &ncmd[FT920_NATIVE_PACING].nseq, YAESU_CMD_LENGTH);
@ -713,7 +712,7 @@ static int ft920_open(RIG *rig)
rig_debug(RIG_DEBUG_TRACE, "%s: read pacing = %i\n", __func__, priv->pacing);
err = write_block(&rig->state.rigport, priv->p_cmd, YAESU_CMD_LENGTH);
err = write_block(rp, priv->p_cmd, YAESU_CMD_LENGTH);
if (err != RIG_OK)
{
@ -2632,7 +2631,7 @@ static int ft920_get_update_data(RIG *rig, unsigned char ci, unsigned char rl)
return err;
}
n = read_block(&rig->state.rigport, priv->update_data, rl);
n = read_block(RIGPORT(rig), priv->update_data, rl);
if (n < 0)
{
@ -2679,7 +2678,7 @@ static int ft920_send_static_cmd(RIG *rig, unsigned char ci)
return -RIG_EINVAL;
}
err = write_block(&rig->state.rigport, ncmd[ci].nseq, YAESU_CMD_LENGTH);
err = write_block(RIGPORT(rig), ncmd[ci].nseq, YAESU_CMD_LENGTH);
if (err != RIG_OK)
{
@ -2744,7 +2743,7 @@ static int ft920_send_dynamic_cmd(RIG *rig, unsigned char ci,
priv->p_cmd[P3] = p3;
priv->p_cmd[P4] = p4;
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)
@ -2809,7 +2808,7 @@ static int ft920_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
FT920_BCD_DIAL) * 10);
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)
@ -2893,7 +2892,7 @@ static int ft920_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
priv->p_cmd[P1] = p1; /* ick */
priv->p_cmd[P2] = p2;
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)

41
rigs/yaesu/ft980.c
Wyświetl plik

@ -560,20 +560,21 @@ int ft980_transaction(RIG *rig, const unsigned char *cmd, unsigned char *data,
int expected_len)
{
int retval;
hamlib_port_t *rp = RIGPORT(rig);
unsigned char echo_back[YAESU_CMD_LENGTH];
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
rig_flush(&rig->state.rigport);
rig_flush(rp);
retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
if (retval < 0)
{
return retval;
}
retval = read_block(&rig->state.rigport, echo_back, YAESU_CMD_LENGTH);
retval = read_block(rp, echo_back, YAESU_CMD_LENGTH);
if (retval < 0)
{
@ -586,14 +587,14 @@ int ft980_transaction(RIG *rig, const unsigned char *cmd, unsigned char *data,
return -RIG_EPROTO;
}
retval = write_block(&rig->state.rigport, cmd_OK, YAESU_CMD_LENGTH);
retval = write_block(rp, cmd_OK, YAESU_CMD_LENGTH);
if (retval < 0)
{
return retval;
}
retval = read_block(&rig->state.rigport, data, expected_len);
retval = read_block(rp, data, expected_len);
if (retval < 0)
{
@ -733,6 +734,7 @@ int ft980_open(RIG *rig)
{
unsigned char echo_back[YAESU_CMD_LENGTH];
struct ft980_priv_data *priv;
hamlib_port_t *rp = RIGPORT(rig);
int retry_count1 = 0;
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
@ -747,18 +749,17 @@ int ft980_open(RIG *rig)
do
{
write_block(&rig->state.rigport, cmd_ON_OFF,
YAESU_CMD_LENGTH);
retval = read_block(&rig->state.rigport, echo_back, YAESU_CMD_LENGTH);
write_block(rp, cmd_ON_OFF, YAESU_CMD_LENGTH);
retval = read_block(rp, echo_back, YAESU_CMD_LENGTH);
}
while (retval != 5 && retry_count2++ < rig->state.rigport.retry);
while (retval != 5 && retry_count2++ < rp->retry);
write_block(&rig->state.rigport, cmd_OK, YAESU_CMD_LENGTH);
read_block(&rig->state.rigport, (unsigned char *) &priv->update_data,
write_block(rp, cmd_OK, YAESU_CMD_LENGTH);
read_block(rp, (unsigned char *) &priv->update_data,
FT980_ALL_STATUS_LENGTH);
}
while (!priv->update_data.ext_ctl_flag
&& retry_count1++ < rig->state.rigport.retry);
&& retry_count1++ < rp->retry);
return RIG_OK;
}
@ -782,6 +783,7 @@ int ft980_close(RIG *rig)
{
unsigned char echo_back[YAESU_CMD_LENGTH];
struct ft980_priv_data *priv = (struct ft980_priv_data *)rig->state.priv;
hamlib_port_t *rp = RIGPORT(rig);
int retry_count1 = 0;
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
@ -793,18 +795,17 @@ int ft980_close(RIG *rig)
do
{
write_block(&rig->state.rigport, cmd_ON_OFF,
YAESU_CMD_LENGTH);
retval = read_block(&rig->state.rigport, echo_back, YAESU_CMD_LENGTH);
write_block(rp, cmd_ON_OFF, YAESU_CMD_LENGTH);
retval = read_block(rp, echo_back, YAESU_CMD_LENGTH);
}
while (retval != 5 && retry_count2++ < rig->state.rigport.retry);
while (retval != 5 && retry_count2++ < rp->retry);
write_block(&rig->state.rigport, cmd_OK, YAESU_CMD_LENGTH);
read_block(&rig->state.rigport, (unsigned char *) &priv->update_data,
write_block(rp, cmd_OK, YAESU_CMD_LENGTH);
read_block(rp, (unsigned char *) &priv->update_data,
FT980_ALL_STATUS_LENGTH);
}
while (priv->update_data.ext_ctl_flag
&& retry_count1++ < rig->state.rigport.retry);
&& retry_count1++ < rp->retry);
return RIG_OK;
}
@ -1217,7 +1218,7 @@ int ft980_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
*/
cmd[4] = split == RIG_SPLIT_ON ? 0x0e : 0x8e;
return write_block(&rig->state.rigport, (char *) cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), (char *) cmd, YAESU_CMD_LENGTH);
#endif
}

18
rigs/yaesu/ft990.c
Wyświetl plik

@ -446,7 +446,6 @@ int ft990_cleanup(RIG *rig)
*/
int ft990_open(RIG *rig)
{
struct rig_state *rig_s;
struct ft990_priv_data *priv;
int err;
@ -458,12 +457,11 @@ int ft990_open(RIG *rig)
}
priv = (struct ft990_priv_data *)rig->state.priv;
rig_s = &rig->state;
rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
__func__, rig_s->rigport.write_delay);
__func__, RIGPORT(rig)->write_delay);
rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
__func__, rig_s->rigport.post_write_delay);
__func__, RIGPORT(rig)->post_write_delay);
rig_debug(RIG_DEBUG_TRACE,
"%s: read pacing = %i\n", __func__, priv->pacing);
@ -2430,7 +2428,7 @@ int ft990_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *value)
return err;
}
err = read_block(&rig->state.rigport, mdata, FT990_READ_METER_LENGTH);
err = read_block(RIGPORT(rig), mdata, FT990_READ_METER_LENGTH);
if (err < 0)
{
@ -3297,7 +3295,7 @@ int ft990_get_update_data(RIG *rig, unsigned char ci, unsigned short ch)
return -RIG_EINVAL;
}
n = read_block(&rig->state.rigport, p, rl);
n = read_block(RIGPORT(rig), p, rl);
if (n < 0)
{
@ -3343,7 +3341,7 @@ int ft990_send_static_cmd(RIG *rig, unsigned char ci)
return -RIG_EINVAL;
}
err = write_block(&rig->state.rigport, ncmd[ci].nseq, YAESU_CMD_LENGTH);
err = write_block(RIGPORT(rig), ncmd[ci].nseq, YAESU_CMD_LENGTH);
if (err != RIG_OK)
{
@ -3401,7 +3399,7 @@ int ft990_send_dynamic_cmd(RIG *rig, unsigned char ci,
priv->p_cmd[1] = p3;
priv->p_cmd[0] = p4;
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)
@ -3460,7 +3458,7 @@ int ft990_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
FT990_BCD_DIAL) * 10);
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)
@ -3525,7 +3523,7 @@ int ft990_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
// Store bcd format into privat command storage area
to_bcd(priv->p_cmd, labs(rit) / 10, FT990_BCD_RIT);
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)

20
rigs/yaesu/ft990v12.c
Wyświetl plik

@ -461,7 +461,6 @@ int ft990v12_cleanup(RIG *rig)
*/
int ft990v12_open(RIG *rig)
{
struct rig_state *rig_s;
struct ft990v12_priv_data *priv;
int err;
@ -473,12 +472,11 @@ int ft990v12_open(RIG *rig)
}
priv = (struct ft990v12_priv_data *)rig->state.priv;
rig_s = &rig->state;
rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
__func__, rig_s->rigport.write_delay);
__func__, RIGPORT(rig)->write_delay);
rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
__func__, rig_s->rigport.post_write_delay);
__func__, RIGPORT(rig)->post_write_delay);
rig_debug(RIG_DEBUG_TRACE,
"%s: read pacing = %i\n", __func__, priv->pacing);
@ -2462,7 +2460,7 @@ int ft990v12_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *value)
return err;
}
err = read_block(&rig->state.rigport, mdata, FT990_READ_METER_LENGTH);
err = read_block(RIGPORT(rig), mdata, FT990_READ_METER_LENGTH);
if (err < 0)
{
@ -3318,7 +3316,7 @@ int ft990v12_get_update_data(RIG *rig, unsigned char ci, unsigned short ch)
p = (unsigned char *)
&priv->update_data; // K1MMI: This seems like 1492 will be saved here
n = read_block(&rig->state.rigport, p, rl); /* M0EZP: copied here from below */
n = read_block(RIGPORT(rig), p, rl); /* M0EZP: copied here from below */
return RIG_OK;
break;
@ -3382,7 +3380,7 @@ int ft990v12_get_update_data(RIG *rig, unsigned char ci, unsigned short ch)
p = (unsigned char *)&priv->update_data;
rl = FT990_STATUS_FLAGS_LENGTH; // 5
n = read_block(&rig->state.rigport, (unsigned char *)&temp,
n = read_block(RIGPORT(rig), (unsigned char *)&temp,
rl); /* M0EZP: copied here from below */
if (n < 0)
@ -3437,7 +3435,7 @@ int ft990v12_send_static_cmd(RIG *rig, unsigned char ci)
return -RIG_EINVAL;
}
err = write_block(&rig->state.rigport, ncmd[ci].nseq, YAESU_CMD_LENGTH);
err = write_block(RIGPORT(rig), ncmd[ci].nseq, YAESU_CMD_LENGTH);
if (err != RIG_OK)
{
@ -3495,7 +3493,7 @@ int ft990v12_send_dynamic_cmd(RIG *rig, unsigned char ci,
priv->p_cmd[1] = p3;
priv->p_cmd[0] = p4;
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)
@ -3554,7 +3552,7 @@ int ft990v12_send_dial_freq(RIG *rig, unsigned char ci, freq_t freq)
rig_debug(RIG_DEBUG_TRACE, fmt, __func__, (int64_t)from_bcd(priv->p_cmd,
FT990_BCD_DIAL) * 10);
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)
@ -3619,7 +3617,7 @@ int ft990v12_send_rit_freq(RIG *rig, unsigned char ci, shortfreq_t rit)
// Store bcd format into privat command storage area
to_bcd(priv->p_cmd, labs(rit) / 10, FT990_BCD_RIT);
err = write_block(&rig->state.rigport, (unsigned char *) &priv->p_cmd,
err = write_block(RIGPORT(rig), (unsigned char *) &priv->p_cmd,
YAESU_CMD_LENGTH);
if (err != RIG_OK)

99
rigs/yaesu/newcat.c
Wyświetl plik

@ -556,6 +556,7 @@ int newcat_open(RIG *rig)
{
struct newcat_priv_data *priv = rig->state.priv;
struct rig_state *rig_s = &rig->state;
hamlib_port_t *rp = RIGPORT(rig);
const char *handshake[3] = {"None", "Xon/Xoff", "Hardware"};
int err;
int set_only = 0;
@ -565,10 +566,10 @@ int newcat_open(RIG *rig)
rig_debug(RIG_DEBUG_TRACE, "%s: Rig=%s, version=%s\n", __func__,
rig->caps->model_name, rig->caps->version);
rig_debug(RIG_DEBUG_TRACE, "%s: write_delay = %i msec\n",
__func__, rig_s->rigport.write_delay);
__func__, rp->write_delay);
rig_debug(RIG_DEBUG_TRACE, "%s: post_write_delay = %i msec\n",
__func__, rig_s->rigport.post_write_delay);
__func__, rp->post_write_delay);
rig_debug(RIG_DEBUG_TRACE, "%s: serial_handshake = %s \n",
__func__, handshake[rig->caps->serial_handshake]);
@ -586,8 +587,8 @@ int newcat_open(RIG *rig)
priv->trn_state = -1;
// for this sequence we will shorten the timeout so we can detect rig is powered off faster
int timeout = rig->state.rigport.timeout;
rig->state.rigport.timeout = 100;
int timeout = rp->timeout;
rp->timeout = 100;
newcat_get_trn(rig, &priv->trn_state); /* ignore errors */
/* Currently we cannot cope with AI mode so turn it off in case
@ -600,7 +601,7 @@ int newcat_open(RIG *rig)
/* Initialize rig_id in case any subsequent commands need it */
(void)newcat_get_rigid(rig);
rig_debug(RIG_DEBUG_VERBOSE, "%s: rig_id=%d\n", __func__, priv->rig_id);
rig->state.rigport.timeout = timeout;
rp->timeout = timeout;
// some rigs have a CAT TOT timeout that defaults to 10ms
// so we'll increase CAT timeout to 100ms
@ -636,8 +637,8 @@ int newcat_open(RIG *rig)
SNPRINTF(priv->cmd_str, sizeof(priv->cmd_str), "%s", cmd);
retry_save = rig->state.rigport.retry;
rig->state.rigport.retry = 0;
retry_save = rp->retry;
rp->retry = 0;
if (set_only)
{
@ -648,7 +649,7 @@ int newcat_open(RIG *rig)
err = newcat_get_cmd(rig);
}
rig->state.rigport.retry = retry_save;
rp->retry = retry_save;
if (err != RIG_OK)
{
@ -3671,7 +3672,7 @@ int newcat_mW2power(RIG *rig, float *power, unsigned int mwpower, freq_t freq,
int newcat_set_powerstat(RIG *rig, powerstat_t status)
{
struct rig_state *state = &rig->state;
hamlib_port_t *rp = RIGPORT(rig);
struct newcat_priv_data *priv = (struct newcat_priv_data *)rig->state.priv;
int retval;
int i = 0;
@ -3694,22 +3695,22 @@ int newcat_set_powerstat(RIG *rig, powerstat_t status)
// When powering on a Yaesu rig needs dummy bytes to wake it up,
// then wait from 1 to 2 seconds and issue the power-on command again
HAMLIB_TRACE;
write_block(&state->rigport, (unsigned char *) "PS1;", 4);
write_block(rp, (unsigned char *) "PS1;", 4);
hl_usleep(1200000);
write_block(&state->rigport, (unsigned char *) "PS1;", 4);
write_block(rp, (unsigned char *) "PS1;", 4);
// some rigs reset the serial port during power up
// so we reopen the com port again
HAMLIB_TRACE;
//oser_close(&state->rigport);
//oser_close(rp);
rig_close(rig);
hl_usleep(3000000);
//state->pttport.fd = ser_open(&state->rigport);
//PTTPORT(rig)->fd = ser_open(rp);
rig_open(rig);
break;
case RIG_POWER_OFF:
case RIG_POWER_STANDBY:
retval = write_block(&state->rigport, (unsigned char *) "PS0;", 4);
retval = write_block(rp, (unsigned char *) "PS0;", 4);
priv->poweron = 0;
RETURNFUNC(retval);
@ -3719,8 +3720,8 @@ int newcat_set_powerstat(RIG *rig, powerstat_t status)
HAMLIB_TRACE;
retry_save = rig->state.rigport.retry;
rig->state.rigport.retry = 0;
retry_save = rp->retry;
rp->retry = 0;
if (status == RIG_POWER_ON) // wait for wakeup only
{
@ -3728,25 +3729,25 @@ int newcat_set_powerstat(RIG *rig, powerstat_t status)
{
freq_t freq;
hl_usleep(1000000);
rig_flush(&state->rigport);
rig_flush(rp);
retval = rig_get_freq(rig, RIG_VFO_A, &freq);
if (retval == RIG_OK)
{
rig->state.rigport.retry = retry_save;
rp->retry = retry_save;
priv->poweron = 1;
RETURNFUNC(retval);
}
rig_debug(RIG_DEBUG_TRACE, "%s: Wait #%d for power up\n", __func__, i + 1);
retval = write_block(&state->rigport, (unsigned char *) priv->cmd_str,
retval = write_block(rp, (unsigned char *) priv->cmd_str,
strlen(priv->cmd_str));
if (retval != RIG_OK) { RETURNFUNC(retval); }
}
}
rig->state.rigport.retry = retry_save;
rp->retry = retry_save;
if (i == 9)
{
@ -3765,8 +3766,8 @@ int newcat_set_powerstat(RIG *rig, powerstat_t status)
*/
int newcat_get_powerstat(RIG *rig, powerstat_t *status)
{
struct rig_state *state = (struct rig_state *) &rig->state;
struct newcat_priv_data *priv = (struct newcat_priv_data *) rig->state.priv;
hamlib_port_t *rp = RIGPORT(rig);
int result;
char ps;
char command[] = "PS";
@ -3791,19 +3792,19 @@ int newcat_get_powerstat(RIG *rig, powerstat_t *status)
short timeout_retry_save;
int timeout_save;
retry_save = state->rigport.retry;
timeout_retry_save = state->rigport.timeout_retry;
timeout_save = state->rigport.timeout;
retry_save = rp->retry;
timeout_retry_save = rp->timeout_retry;
timeout_save = rp->timeout;
state->rigport.retry = 0;
state->rigport.timeout_retry = 0;
state->rigport.timeout = 500;
rp->retry = 0;
rp->timeout_retry = 0;
rp->timeout = 500;
result = newcat_get_cmd(rig);
state->rigport.retry = retry_save;
state->rigport.timeout_retry = timeout_retry_save;
state->rigport.timeout = timeout_save;
rp->retry = retry_save;
rp->timeout_retry = timeout_retry_save;
rp->timeout = timeout_save;
// Rig may respond here already
if (result == RIG_OK)
@ -3831,7 +3832,7 @@ int newcat_get_powerstat(RIG *rig, powerstat_t *status)
// Yeasu rigs in powered-off state require the PS command to be sent between 1 and 2 seconds after dummy data
hl_usleep(1100000);
// Discard any unsolicited data
rig_flush(&rig->state.rigport);
rig_flush(rp);
result = newcat_get_cmd(rig);
@ -11159,6 +11160,7 @@ int newcat_vfomem_toggle(RIG *rig)
int newcat_get_cmd(RIG *rig)
{
struct rig_state *state = &rig->state;
hamlib_port_t *rp = RIGPORT(rig);
struct newcat_priv_data *priv = (struct newcat_priv_data *)rig->state.priv;
int retry_count = 0;
int rc = -RIG_EPROTO;
@ -11253,16 +11255,16 @@ int newcat_get_cmd(RIG *rig)
priv->cache_start.tv_sec = 0;
}
while (rc != RIG_OK && retry_count++ <= state->rigport.retry)
while (rc != RIG_OK && retry_count++ <= rp->retry)
{
rig_flush(&state->rigport); /* discard any unsolicited data */
rig_flush(rp); /* discard any unsolicited data */
if (rc != -RIG_BUSBUSY)
{
/* send the command */
rig_debug(RIG_DEBUG_TRACE, "cmd_str = %s\n", priv->cmd_str);
rc = write_block(&state->rigport, (unsigned char *) priv->cmd_str,
rc = write_block(rp, (unsigned char *) priv->cmd_str,
strlen(priv->cmd_str));
if (rc != RIG_OK)
@ -11272,7 +11274,7 @@ int newcat_get_cmd(RIG *rig)
}
/* read the reply */
if ((rc = read_string(&state->rigport, (unsigned char *) priv->ret_data,
if ((rc = read_string(rp, (unsigned char *) priv->ret_data,
sizeof(priv->ret_data),
&cat_term, sizeof(cat_term), 0, 1)) <= 0)
{
@ -11362,7 +11364,7 @@ int newcat_get_cmd(RIG *rig)
}
rig_debug(RIG_DEBUG_WARN, "%s: Rig busy - retrying %d of %d: '%s'\n", __func__,
retry_count, state->rigport.retry, priv->cmd_str);
retry_count, rp->retry, priv->cmd_str);
// DX3000 was taking 1.6 seconds in certain command sequences
hl_usleep(600 * 1000); // 600ms wait should cover most cases hopefully
@ -11407,7 +11409,6 @@ int newcat_get_cmd(RIG *rig)
*/
int newcat_set_cmd_validate(RIG *rig)
{
struct rig_state *state = &rig->state;
struct newcat_priv_data *priv = (struct newcat_priv_data *)rig->state.priv;
char valcmd[16];
int retries = 8;
@ -11561,11 +11562,12 @@ int newcat_set_cmd_validate(RIG *rig)
while (rc != RIG_OK && retry++ < retries)
{
int bytes;
hamlib_port_t *rp = RIGPORT(rig);
char cmd[256]; // big enough
repeat:
rig_flush(&state->rigport); /* discard any unsolicited data */
rig_flush(rp); /* discard any unsolicited data */
SNPRINTF(cmd, sizeof(cmd), "%s", priv->cmd_str);
rc = write_block(&state->rigport, (unsigned char *) cmd, strlen(cmd));
rc = write_block(rp, (unsigned char *) cmd, strlen(cmd));
if (rc != RIG_OK) { RETURNFUNC(-RIG_EIO); }
@ -11576,11 +11578,11 @@ repeat:
// some rigs like FT-450/Signalink need a little time before we can ask for TX status again
if (strncmp(valcmd, "TX", 2) == 0) { hl_usleep(50 * 1000); }
rc = write_block(&state->rigport, (unsigned char *) cmd, strlen(cmd));
rc = write_block(rp, (unsigned char *) cmd, strlen(cmd));
if (rc != RIG_OK) { RETURNFUNC(-RIG_EIO); }
bytes = read_string(&state->rigport, (unsigned char *) priv->ret_data,
bytes = read_string(rp, (unsigned char *) priv->ret_data,
sizeof(priv->ret_data),
&cat_term, sizeof(cat_term), 0, 1);
@ -11652,7 +11654,7 @@ repeat:
*/
int newcat_set_cmd(RIG *rig)
{
struct rig_state *state = &rig->state;
hamlib_port_t *rp = RIGPORT(rig);
struct newcat_priv_data *priv = (struct newcat_priv_data *)rig->state.priv;
int retry_count = 0;
int rc = -RIG_EPROTO;
@ -11662,9 +11664,9 @@ int newcat_set_cmd(RIG *rig)
char const *const verify_cmd = RIG_MODEL_FT9000 == rig->caps->rig_model ?
"AI;" : "ID;";
while (rc != RIG_OK && retry_count++ <= state->rigport.retry)
while (rc != RIG_OK && retry_count++ <= rp->retry)
{
rig_flush(&state->rigport); /* discard any unsolicited data */
rig_flush(rp); /* discard any unsolicited data */
/* send the command */
rig_debug(RIG_DEBUG_TRACE, "cmd_str = %s\n", priv->cmd_str);
@ -11685,8 +11687,7 @@ int newcat_set_cmd(RIG *rig)
rig_debug(RIG_DEBUG_TRACE,
"%s: newcat_set_cmd_validate not implemented...continuing\n", __func__);
if (RIG_OK != (rc = write_block(&state->rigport,
(unsigned char *) priv->cmd_str,
if (RIG_OK != (rc = write_block(rp, (unsigned char *) priv->cmd_str,
strlen(priv->cmd_str))))
{
RETURNFUNC(rc);
@ -11721,14 +11722,14 @@ int newcat_set_cmd(RIG *rig)
/* send the verification command */
rig_debug(RIG_DEBUG_TRACE, "cmd_str = %s\n", verify_cmd);
if (RIG_OK != (rc = write_block(&state->rigport, (unsigned char *) verify_cmd,
if (RIG_OK != (rc = write_block(rp, (unsigned char *) verify_cmd,
strlen(verify_cmd))))
{
RETURNFUNC(rc);
}
/* read the reply */
if ((rc = read_string(&state->rigport, (unsigned char *) priv->ret_data,
if ((rc = read_string(rp, (unsigned char *) priv->ret_data,
sizeof(priv->ret_data),
&cat_term, sizeof(cat_term), 0, 1)) <= 0)
{
@ -11799,7 +11800,7 @@ int newcat_set_cmd(RIG *rig)
priv->cmd_str);
/* read/flush the verify command reply which should still be there */
if ((rc = read_string(&state->rigport, (unsigned char *) priv->ret_data,
if ((rc = read_string(rp, (unsigned char *) priv->ret_data,
sizeof(priv->ret_data),
&cat_term, sizeof(cat_term), 0, 1)) > 0)
{

28
rigs/yaesu/vr5000.c
Wyświetl plik

@ -279,13 +279,14 @@ int vr5000_cleanup(RIG *rig)
int vr5000_open(RIG *rig)
{
struct vr5000_priv_data *priv = rig->state.priv;
hamlib_port_t *rp = RIGPORT(rig);
const unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0x00};
const unsigned char b_off[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0x31};
int retval;
/* CAT write command on */
retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
if (retval != RIG_OK)
{
@ -293,7 +294,7 @@ int vr5000_open(RIG *rig)
}
/* disable RIG_VFO_B (only on display) */
retval = write_block(&rig->state.rigport, b_off, YAESU_CMD_LENGTH);
retval = write_block(rp, b_off, YAESU_CMD_LENGTH);
if (retval != RIG_OK)
{
@ -324,7 +325,7 @@ int vr5000_close(RIG *rig)
{
const unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0x80};
return write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
return write_block(RIGPORT(rig), cmd, YAESU_CMD_LENGTH);
}
@ -402,16 +403,17 @@ int vr5000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0xe7};
int retval;
hamlib_port_t *rp = RIGPORT(rig);
if (level != RIG_LEVEL_RAWSTR)
{
return -RIG_EINVAL;
}
rig_flush(&rig->state.rigport);
rig_flush(rp);
/* send READ STATUS(Meter only) cmd to rig */
retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
if (retval < 0)
{
@ -419,7 +421,7 @@ int vr5000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
}
/* read back the 1 byte */
retval = read_block(&rig->state.rigport, cmd, 1);
retval = read_block(rp, cmd, 1);
if (retval < 1)
{
@ -432,7 +434,6 @@ int vr5000_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
val->i = cmd[0] & 0x3f;
rig_debug(RIG_DEBUG_ERR, "Read(%x) RawValue(%x): \n", cmd[0], val->i);
return RIG_OK;
}
@ -441,11 +442,12 @@ int vr5000_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
{
unsigned char cmd[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0xe7};
int retval;
hamlib_port_t *rp = RIGPORT(rig);
rig_flush(&rig->state.rigport);
rig_flush(rp);
/* send READ STATUS(Meter only) cmd to rig */
retval = write_block(&rig->state.rigport, cmd, YAESU_CMD_LENGTH);
retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
if (retval < 0)
{
@ -453,7 +455,7 @@ int vr5000_get_dcd(RIG *rig, vfo_t vfo, dcd_t *dcd)
}
/* read back the 1 byte */
retval = read_block(&rig->state.rigport, cmd, 1);
retval = read_block(rp, cmd, 1);
if (retval < 1)
{
@ -571,6 +573,7 @@ int set_vr5000(RIG *rig, vfo_t vfo, freq_t freq, rmode_t mode, pbwidth_t width,
shortfreq_t ts)
{
struct vr5000_priv_data *priv = rig->state.priv;
hamlib_port_t *rp = RIGPORT(rig);
unsigned char cmd_mode_ts[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0x07};
unsigned char cmd_freq[YAESU_CMD_LENGTH] = { 0x00, 0x00, 0x00, 0x00, 0x01};
static const unsigned char steps[] =
@ -613,8 +616,7 @@ int set_vr5000(RIG *rig, vfo_t vfo, freq_t freq, rmode_t mode, pbwidth_t width,
/* fill in m2 */
cmd_mode_ts[1] = steps[i];
retval = write_block(&rig->state.rigport, cmd_mode_ts,
YAESU_CMD_LENGTH);
retval = write_block(rp, cmd_mode_ts, YAESU_CMD_LENGTH);
if (retval != RIG_OK)
{
@ -633,7 +635,7 @@ int set_vr5000(RIG *rig, vfo_t vfo, freq_t freq, rmode_t mode, pbwidth_t width,
cmd_freq[3] = frq & 0xff;
/* frequency set */
return write_block(&rig->state.rigport, cmd_freq, YAESU_CMD_LENGTH);
return write_block(rp, cmd_freq, YAESU_CMD_LENGTH);
}

9
rigs/yaesu/vx1700.c
Wyświetl plik

@ -336,7 +336,7 @@ static int vx1700_do_transaction(RIG *rig,
const unsigned char cmd[YAESU_CMD_LENGTH],
unsigned char *retbuf, size_t retbuf_len)
{
struct rig_state *rs;
hamlib_port_t *rp = RIGPORT(rig);
unsigned char default_retbuf[1];
int retval;
@ -346,15 +346,14 @@ static int vx1700_do_transaction(RIG *rig,
retbuf_len = sizeof(default_retbuf);
}
rs = &rig->state;
memset(retbuf, 0, retbuf_len);
rig_flush(&rs->rigport);
retval = write_block(&rs->rigport, cmd, YAESU_CMD_LENGTH);
rig_flush(rp);
retval = write_block(rp, cmd, YAESU_CMD_LENGTH);
if (retval != RIG_OK) { return retval; }
retval = read_block(&rs->rigport, retbuf, retbuf_len);
retval = read_block(rp, retbuf, retbuf_len);
if (retval != retbuf_len)
{