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

tab reformat 

git-svn-id: https://hamlib.svn.sourceforge.net/svnroot/hamlib/trunk@1989 7ae35d74-ebe9-4afe-98af-79ac388436b8
Hamlib-1.2.5
Stéphane Fillod, F8CFE 2005-04-04 18:31:00 +00:00
rodzic 9346d0096a
commit 20f5e6fc3c
8 zmienionych plików z 1980 dodań i 1965 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

449
src/conf.c
Wyświetl plik

@ -3,13 +3,13 @@
* \ingroup rig * \ingroup rig
* \brief Rig configuration interface * \brief Rig configuration interface
* \author Stephane Fillod * \author Stephane Fillod
* \date 2000-2004 * \date 2000-2005
*/ */
/* /*
* Hamlib Interface - configuration interface * Hamlib Interface - configuration interface
* Copyright (c) 2000-2004 by Stephane Fillod * Copyright (c) 2000-2005 by Stephane Fillod
* *
* $Id: conf.c,v 1.12 2004-10-02 10:32:08 fillods Exp $ * $Id: conf.c,v 1.13 2005-04-04 18:30:47 fillods Exp $
* *
* This library is free software; you can redistribute it and/or modify * This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as * it under the terms of the GNU Library General Public License as
@ -116,113 +116,113 @@ static const struct confparams frontend_cfg_params[] = {
*/ */
static int frontend_set_conf(RIG *rig, token_t token, const char *val) static int frontend_set_conf(RIG *rig, token_t token, const char *val)
{ {
const struct rig_caps *caps; const struct rig_caps *caps;
struct rig_state *rs; struct rig_state *rs;
caps = rig->caps; caps = rig->caps;
rs = &rig->state; rs = &rig->state;
switch(token) { switch(token) {
case TOK_PATHNAME: case TOK_PATHNAME:
strcpy(rs->rigport.pathname, val); strcpy(rs->rigport.pathname, val);
break; break;
case TOK_WRITE_DELAY: case TOK_WRITE_DELAY:
rs->rigport.write_delay = atoi(val); rs->rigport.write_delay = atoi(val);
break; break;
case TOK_POST_WRITE_DELAY: case TOK_POST_WRITE_DELAY:
rs->rigport.post_write_delay = atoi(val); rs->rigport.post_write_delay = atoi(val);
break; break;
case TOK_TIMEOUT: case TOK_TIMEOUT:
rs->rigport.timeout = atoi(val); rs->rigport.timeout = atoi(val);
break; break;
case TOK_RETRY: case TOK_RETRY:
rs->rigport.retry = atoi(val); rs->rigport.retry = atoi(val);
break; break;
case TOK_SERIAL_SPEED: case TOK_SERIAL_SPEED:
rs->rigport.parm.serial.rate = atoi(val); rs->rigport.parm.serial.rate = atoi(val);
break; break;
case TOK_DATA_BITS: case TOK_DATA_BITS:
rs->rigport.parm.serial.data_bits = atoi(val); rs->rigport.parm.serial.data_bits = atoi(val);
break; break;
case TOK_STOP_BITS: case TOK_STOP_BITS:
rs->rigport.parm.serial.stop_bits = atoi(val); rs->rigport.parm.serial.stop_bits = atoi(val);
break; break;
case TOK_PARITY: case TOK_PARITY:
if (!strncmp(val, "None", 8)) if (!strncmp(val, "None", 8))
rs->rigport.parm.serial.parity = RIG_PARITY_NONE; rs->rigport.parm.serial.parity = RIG_PARITY_NONE;
else if (!strncmp(val, "Odd", 8)) else if (!strncmp(val, "Odd", 8))
rs->rigport.parm.serial.parity = RIG_PARITY_ODD; rs->rigport.parm.serial.parity = RIG_PARITY_ODD;
else if (!strncmp(val, "Even", 8)) else if (!strncmp(val, "Even", 8))
rs->rigport.parm.serial.parity = RIG_PARITY_EVEN; rs->rigport.parm.serial.parity = RIG_PARITY_EVEN;
else else
return -RIG_EINVAL;
break;
case TOK_HANDSHAKE:
if (!strncmp(val, "None", 8))
rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_NONE;
else if (!strncmp(val, "XONXOFF", 8))
rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_XONXOFF;
else if (!strncmp(val, "Hardware", 8))
rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_HARDWARE;
else
return -RIG_EINVAL;
break;
case TOK_RTS_STATE:
if (!strcmp(val, "Unset"))
rs->rigport.parm.serial.rts_state = RIG_SIGNAL_UNSET;
else if (!strcmp(val, "ON"))
rs->rigport.parm.serial.rts_state = RIG_SIGNAL_ON;
else if (!strcmp(val, "OFF"))
rs->rigport.parm.serial.rts_state = RIG_SIGNAL_OFF;
else
return -RIG_EINVAL;
break;
case TOK_DTR_STATE:
if (!strcmp(val, "Unset"))
rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_UNSET;
else if (!strcmp(val, "ON"))
rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_ON;
else if (!strcmp(val, "OFF"))
rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_OFF;
else
return -RIG_EINVAL;
break;
case TOK_ITU_REGION:
rs->itu_region = atoi(val);
switch(rs->itu_region) {
case RIG_ITU_REGION1:
memcpy(rs->tx_range_list, caps->tx_range_list1,
sizeof(struct freq_range_list)*FRQRANGESIZ);
memcpy(rs->rx_range_list, caps->rx_range_list1,
sizeof(struct freq_range_list)*FRQRANGESIZ);
break;
case RIG_ITU_REGION2:
case RIG_ITU_REGION3:
default:
memcpy(rs->tx_range_list, caps->tx_range_list2,
sizeof(struct freq_range_list)*FRQRANGESIZ);
memcpy(rs->rx_range_list, caps->rx_range_list2,
sizeof(struct freq_range_list)*FRQRANGESIZ);
break;
}
break;
case TOK_VFO_COMP:
rs->vfo_comp = atof(val);
break;
case TOK_POLL_INTERVAL:
rs->poll_interval = atof(val);
break;
default:
return -RIG_EINVAL; return -RIG_EINVAL;
} break;
return RIG_OK; case TOK_HANDSHAKE:
if (!strncmp(val, "None", 8))
rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_NONE;
else if (!strncmp(val, "XONXOFF", 8))
rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_XONXOFF;
else if (!strncmp(val, "Hardware", 8))
rs->rigport.parm.serial.handshake = RIG_HANDSHAKE_HARDWARE;
else
return -RIG_EINVAL;
break;
case TOK_RTS_STATE:
if (!strcmp(val, "Unset"))
rs->rigport.parm.serial.rts_state = RIG_SIGNAL_UNSET;
else if (!strcmp(val, "ON"))
rs->rigport.parm.serial.rts_state = RIG_SIGNAL_ON;
else if (!strcmp(val, "OFF"))
rs->rigport.parm.serial.rts_state = RIG_SIGNAL_OFF;
else
return -RIG_EINVAL;
break;
case TOK_DTR_STATE:
if (!strcmp(val, "Unset"))
rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_UNSET;
else if (!strcmp(val, "ON"))
rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_ON;
else if (!strcmp(val, "OFF"))
rs->rigport.parm.serial.dtr_state = RIG_SIGNAL_OFF;
else
return -RIG_EINVAL;
break;
case TOK_ITU_REGION:
rs->itu_region = atoi(val);
switch(rs->itu_region) {
case RIG_ITU_REGION1:
memcpy(rs->tx_range_list, caps->tx_range_list1,
sizeof(struct freq_range_list)*FRQRANGESIZ);
memcpy(rs->rx_range_list, caps->rx_range_list1,
sizeof(struct freq_range_list)*FRQRANGESIZ);
break;
case RIG_ITU_REGION2:
case RIG_ITU_REGION3:
default:
memcpy(rs->tx_range_list, caps->tx_range_list2,
sizeof(struct freq_range_list)*FRQRANGESIZ);
memcpy(rs->rx_range_list, caps->rx_range_list2,
sizeof(struct freq_range_list)*FRQRANGESIZ);
break;
}
break;
case TOK_VFO_COMP:
rs->vfo_comp = atof(val);
break;
case TOK_POLL_INTERVAL:
rs->poll_interval = atof(val);
break;
default:
return -RIG_EINVAL;
}
return RIG_OK;
} }
/* /*
@ -231,93 +231,93 @@ static int frontend_set_conf(RIG *rig, token_t token, const char *val)
*/ */
static int frontend_get_conf(RIG *rig, token_t token, char *val) static int frontend_get_conf(RIG *rig, token_t token, char *val)
{ {
const struct rig_caps *caps; const struct rig_caps *caps;
struct rig_state *rs; struct rig_state *rs;
const char *s; const char *s;
caps = rig->caps; caps = rig->caps;
rs = &rig->state; rs = &rig->state;
switch(token) { switch(token) {
case TOK_PATHNAME: case TOK_PATHNAME:
strcpy(val, rs->rigport.pathname); strcpy(val, rs->rigport.pathname);
break; break;
case TOK_WRITE_DELAY: case TOK_WRITE_DELAY:
sprintf(val, "%d", rs->rigport.write_delay); sprintf(val, "%d", rs->rigport.write_delay);
break; break;
case TOK_POST_WRITE_DELAY: case TOK_POST_WRITE_DELAY:
sprintf(val, "%d", rs->rigport.post_write_delay); sprintf(val, "%d", rs->rigport.post_write_delay);
break; break;
case TOK_TIMEOUT: case TOK_TIMEOUT:
sprintf(val, "%d", rs->rigport.timeout); sprintf(val, "%d", rs->rigport.timeout);
break; break;
case TOK_RETRY: case TOK_RETRY:
sprintf(val, "%d", rs->rigport.retry); sprintf(val, "%d", rs->rigport.retry);
break; break;
case TOK_ITU_REGION: case TOK_ITU_REGION:
sprintf(val, "%d", sprintf(val, "%d",
rs->itu_region == 1 ? RIG_ITU_REGION1 : RIG_ITU_REGION2); rs->itu_region == 1 ? RIG_ITU_REGION1 : RIG_ITU_REGION2);
break; break;
case TOK_SERIAL_SPEED: case TOK_SERIAL_SPEED:
sprintf(val, "%d", rs->rigport.parm.serial.rate); sprintf(val, "%d", rs->rigport.parm.serial.rate);
break; break;
case TOK_DATA_BITS: case TOK_DATA_BITS:
sprintf(val, "%d", rs->rigport.parm.serial.data_bits); sprintf(val, "%d", rs->rigport.parm.serial.data_bits);
break; break;
case TOK_STOP_BITS: case TOK_STOP_BITS:
sprintf(val, "%d", rs->rigport.parm.serial.stop_bits); sprintf(val, "%d", rs->rigport.parm.serial.stop_bits);
break; break;
case TOK_PARITY: case TOK_PARITY:
switch (rs->rigport.parm.serial.parity) { switch (rs->rigport.parm.serial.parity) {
case RIG_PARITY_NONE: s = "None"; break; case RIG_PARITY_NONE: s = "None"; break;
case RIG_PARITY_ODD: s = "Odd"; break; case RIG_PARITY_ODD: s = "Odd"; break;
case RIG_PARITY_EVEN: s = "Even"; break; case RIG_PARITY_EVEN: s = "Even"; break;
default: return -RIG_EINVAL; default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_HANDSHAKE:
switch (rs->rigport.parm.serial.handshake) {
case RIG_HANDSHAKE_NONE: s = "None"; break;
case RIG_HANDSHAKE_XONXOFF: s = "XONXOFF"; break;
case RIG_HANDSHAKE_HARDWARE: s = "Hardware"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_RTS_STATE:
switch (rs->rigport.parm.serial.rts_state) {
case RIG_SIGNAL_UNSET: s = "Unset"; break;
case RIG_SIGNAL_ON: s = "ON"; break;
case RIG_SIGNAL_OFF: s = "OFF"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_DTR_STATE:
switch (rs->rigport.parm.serial.dtr_state) {
case RIG_SIGNAL_UNSET: s = "Unset"; break;
case RIG_SIGNAL_ON: s = "ON"; break;
case RIG_SIGNAL_OFF: s = "OFF"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_VFO_COMP:
sprintf(val, "%f", rs->vfo_comp);
break;
case TOK_POLL_INTERVAL:
sprintf(val, "%d", rs->poll_interval);
break;
default:
return -RIG_EINVAL;
} }
strcpy(val, s);
break;
case TOK_HANDSHAKE:
switch (rs->rigport.parm.serial.handshake) {
case RIG_HANDSHAKE_NONE: s = "None"; break;
case RIG_HANDSHAKE_XONXOFF: s = "XONXOFF"; break;
case RIG_HANDSHAKE_HARDWARE: s = "Hardware"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
return RIG_OK; case TOK_RTS_STATE:
switch (rs->rigport.parm.serial.rts_state) {
case RIG_SIGNAL_UNSET: s = "Unset"; break;
case RIG_SIGNAL_ON: s = "ON"; break;
case RIG_SIGNAL_OFF: s = "OFF"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_DTR_STATE:
switch (rs->rigport.parm.serial.dtr_state) {
case RIG_SIGNAL_UNSET: s = "Unset"; break;
case RIG_SIGNAL_ON: s = "ON"; break;
case RIG_SIGNAL_OFF: s = "OFF"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_VFO_COMP:
sprintf(val, "%f", rs->vfo_comp);
break;
case TOK_POLL_INTERVAL:
sprintf(val, "%d", rs->poll_interval);
break;
default:
return -RIG_EINVAL;
}
return RIG_OK;
} }
/** /**
@ -339,14 +339,16 @@ int HAMLIB_API rig_token_foreach(RIG *rig, int (*cfunc)(const struct confparams
const struct confparams *cfp; const struct confparams *cfp;
if (!rig || !rig->caps || !cfunc) if (!rig || !rig->caps || !cfunc)
return -RIG_EINVAL; return -RIG_EINVAL;
for (cfp = rig->caps->cfgparams; cfp && cfp->name; cfp++) for (cfp = rig->caps->cfgparams; cfp && cfp->name; cfp++)
if ((*cfunc)(cfp, data) == 0) if ((*cfunc)(cfp, data) == 0)
return RIG_OK; return RIG_OK;
for (cfp = frontend_cfg_params; cfp->name; cfp++) for (cfp = frontend_cfg_params; cfp->name; cfp++)
if ((*cfunc)(cfp, data) == 0) if ((*cfunc)(cfp, data) == 0)
return RIG_OK; return RIG_OK;
return RIG_OK; return RIG_OK;
} }
@ -362,17 +364,20 @@ int HAMLIB_API rig_token_foreach(RIG *rig, int (*cfunc)(const struct confparams
*/ */
const struct confparams * HAMLIB_API rig_confparam_lookup(RIG *rig, const char *name) const struct confparams * HAMLIB_API rig_confparam_lookup(RIG *rig, const char *name)
{ {
const struct confparams *cfp; const struct confparams *cfp;
if (!rig || !rig->caps) if (!rig || !rig->caps)
return NULL;
for (cfp = rig->caps->cfgparams; cfp && cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
for (cfp = frontend_cfg_params; cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
return NULL; return NULL;
for (cfp = rig->caps->cfgparams; cfp && cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
for (cfp = frontend_cfg_params; cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
return NULL;
} }
/** /**
@ -386,13 +391,13 @@ const struct confparams * HAMLIB_API rig_confparam_lookup(RIG *rig, const char *
*/ */
token_t HAMLIB_API rig_token_lookup(RIG *rig, const char *name) token_t HAMLIB_API rig_token_lookup(RIG *rig, const char *name)
{ {
const struct confparams *cfp; const struct confparams *cfp;
cfp = rig_confparam_lookup(rig, name); cfp = rig_confparam_lookup(rig, name);
if (!cfp) if (!cfp)
return RIG_CONF_END; return RIG_CONF_END;
return cfp->token; return cfp->token;
} }
/** /**
@ -411,16 +416,16 @@ token_t HAMLIB_API rig_token_lookup(RIG *rig, const char *name)
*/ */
int HAMLIB_API rig_set_conf(RIG *rig, token_t token, const char *val) int HAMLIB_API rig_set_conf(RIG *rig, token_t token, const char *val)
{ {
if (!rig || !rig->caps) if (!rig || !rig->caps)
return -RIG_EINVAL; return -RIG_EINVAL;
if (IS_TOKEN_FRONTEND(token)) if (IS_TOKEN_FRONTEND(token))
return frontend_set_conf(rig, token, val); return frontend_set_conf(rig, token, val);
if (rig->caps->set_conf == NULL) if (rig->caps->set_conf == NULL)
return -RIG_ENAVAIL; return -RIG_ENAVAIL;
return rig->caps->set_conf(rig, token, val); return rig->caps->set_conf(rig, token, val);
} }
/** /**
@ -440,15 +445,15 @@ int HAMLIB_API rig_set_conf(RIG *rig, token_t token, const char *val)
*/ */
int HAMLIB_API rig_get_conf(RIG *rig, token_t token, char *val) int HAMLIB_API rig_get_conf(RIG *rig, token_t token, char *val)
{ {
if (!rig || !rig->caps || !val) if (!rig || !rig->caps || !val)
return -RIG_EINVAL; return -RIG_EINVAL;
if (IS_TOKEN_FRONTEND(token)) if (IS_TOKEN_FRONTEND(token))
return frontend_get_conf(rig, token, val); return frontend_get_conf(rig, token, val);
if (rig->caps->get_conf == NULL) if (rig->caps->get_conf == NULL)
return -RIG_ENAVAIL; return -RIG_ENAVAIL;
return rig->caps->get_conf(rig, token, val); return rig->caps->get_conf(rig, token, val);
} }

142
src/misc.c
Wyświetl plik

@ -1,8 +1,8 @@
/* /*
* Hamlib Interface - toolbox * Hamlib Interface - toolbox
* Copyright (c) 2000-2004 by Stephane Fillod * Copyright (c) 2000-2005 by Stephane Fillod
* *
* $Id: misc.c,v 1.34 2004-10-02 10:32:08 fillods Exp $ * $Id: misc.c,v 1.35 2005-04-04 18:30:51 fillods Exp $
* *
* This library is free software; you can redistribute it and/or modify * This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as * it under the terms of the GNU Library General Public License as
@ -106,15 +106,15 @@ HAMLIB_API to_bcd(unsigned char bcd_data[], unsigned long long freq, unsigned bc
/* '450'/3-> 5,0;x,4 */ /* '450'/3-> 5,0;x,4 */
for (i=0; i < bcd_len/2; i++) { for (i=0; i < bcd_len/2; i++) {
a = freq%10; a = freq%10;
freq /= 10; freq /= 10;
a |= (freq%10)<<4; a |= (freq%10)<<4;
freq /= 10; freq /= 10;
bcd_data[i] = a; bcd_data[i] = a;
} }
if (bcd_len&1) { if (bcd_len&1) {
bcd_data[i] &= 0xf0; bcd_data[i] &= 0xf0;
bcd_data[i] |= freq%10; /* NB: high nibble is left uncleared */ bcd_data[i] |= freq%10; /* NB: high nibble is left uncleared */
} }
return bcd_data; return bcd_data;
@ -132,13 +132,13 @@ unsigned long long HAMLIB_API from_bcd(const unsigned char bcd_data[], unsigned
freq_t f = 0; freq_t f = 0;
if (bcd_len&1) if (bcd_len&1)
f = bcd_data[bcd_len/2] & 0x0f; f = bcd_data[bcd_len/2] & 0x0f;
for (i=(bcd_len/2)-1; i >= 0; i--) { for (i=(bcd_len/2)-1; i >= 0; i--) {
f *= 10; f *= 10;
f += bcd_data[i]>>4; f += bcd_data[i]>>4;
f *= 10; f *= 10;
f += bcd_data[i] & 0x0f; f += bcd_data[i] & 0x0f;
} }
return f; return f;
@ -157,16 +157,16 @@ HAMLIB_API to_bcd_be(unsigned char bcd_data[], unsigned long long freq, unsigned
/* '450'/3 -> 4,5;0,x */ /* '450'/3 -> 4,5;0,x */
if (bcd_len&1) { if (bcd_len&1) {
bcd_data[bcd_len/2] &= 0x0f; bcd_data[bcd_len/2] &= 0x0f;
bcd_data[bcd_len/2] |= (freq%10)<<4; /* NB: low nibble is left uncleared */ bcd_data[bcd_len/2] |= (freq%10)<<4; /* NB: low nibble is left uncleared */
freq /= 10; freq /= 10;
} }
for (i=(bcd_len/2)-1; i >= 0; i--) { for (i=(bcd_len/2)-1; i >= 0; i--) {
a = freq%10; a = freq%10;
freq /= 10; freq /= 10;
a |= (freq%10)<<4; a |= (freq%10)<<4;
freq /= 10; freq /= 10;
bcd_data[i] = a; bcd_data[i] = a;
} }
return bcd_data; return bcd_data;
@ -181,14 +181,14 @@ unsigned long long HAMLIB_API from_bcd_be(const unsigned char bcd_data[], unsign
freq_t f = 0; freq_t f = 0;
for (i=0; i < bcd_len/2; i++) { for (i=0; i < bcd_len/2; i++) {
f *= 10; f *= 10;
f += bcd_data[i]>>4; f += bcd_data[i]>>4;
f *= 10; f *= 10;
f += bcd_data[i] & 0x0f; f += bcd_data[i] & 0x0f;
} }
if (bcd_len&1) { if (bcd_len&1) {
f *= 10; f *= 10;
f += bcd_data[bcd_len/2]>>4; f += bcd_data[bcd_len/2]>>4;
} }
return f; return f;
@ -209,7 +209,7 @@ void HAMLIB_API rig_set_debug(enum rig_debug_level_e debug_level)
*/ */
int HAMLIB_API rig_need_debug(enum rig_debug_level_e debug_level) int HAMLIB_API rig_need_debug(enum rig_debug_level_e debug_level)
{ {
return (debug_level <= rig_debug_level); return (debug_level <= rig_debug_level);
} }
/* /*
@ -219,16 +219,16 @@ int HAMLIB_API rig_need_debug(enum rig_debug_level_e debug_level)
*/ */
void HAMLIB_API rig_debug(enum rig_debug_level_e debug_level, const char *fmt, ...) void HAMLIB_API rig_debug(enum rig_debug_level_e debug_level, const char *fmt, ...)
{ {
va_list ap; va_list ap;
if (debug_level <= rig_debug_level) { if (debug_level <= rig_debug_level) {
va_start(ap, fmt); va_start(ap, fmt);
/* /*
* Who cares about return code? * Who cares about return code?
*/ */
vfprintf (stderr, fmt, ap); vfprintf (stderr, fmt, ap);
va_end(ap); va_end(ap);
} }
} }
#ifndef llabs #ifndef llabs
@ -242,24 +242,24 @@ void HAMLIB_API rig_debug(enum rig_debug_level_e debug_level, const char *fmt, .
*/ */
int HAMLIB_API sprintf_freq(char *str, freq_t freq) int HAMLIB_API sprintf_freq(char *str, freq_t freq)
{ {
double f; double f;
char *hz; char *hz;
if (llabs(freq) >= GHz(1)) { if (llabs(freq) >= GHz(1)) {
hz = "GHz"; hz = "GHz";
f = (double)freq/GHz(1); f = (double)freq/GHz(1);
} else if (llabs(freq) >= MHz(1)) { } else if (llabs(freq) >= MHz(1)) {
hz = "MHz"; hz = "MHz";
f = (double)freq/MHz(1); f = (double)freq/MHz(1);
} else if (llabs(freq) >= kHz(1)) { } else if (llabs(freq) >= kHz(1)) {
hz = "kHz"; hz = "kHz";
f = (double)freq/kHz(1); f = (double)freq/kHz(1);
} else { } else {
hz = "Hz"; hz = "Hz";
f = (double)freq; f = (double)freq;
} }
return sprintf (str, "%g %s", f, hz); return sprintf (str, "%g %s", f, hz);
} }
const char * HAMLIB_API rig_strptrshift(rptr_shift_t shift) const char * HAMLIB_API rig_strptrshift(rptr_shift_t shift)
@ -277,17 +277,17 @@ const char * HAMLIB_API rig_strstatus(enum rig_status_e status)
{ {
switch (status) { switch (status) {
case RIG_STATUS_ALPHA: case RIG_STATUS_ALPHA:
return "Alpha"; return "Alpha";
case RIG_STATUS_UNTESTED: case RIG_STATUS_UNTESTED:
return "Untested"; return "Untested";
case RIG_STATUS_BETA: case RIG_STATUS_BETA:
return "Beta"; return "Beta";
case RIG_STATUS_STABLE: case RIG_STATUS_STABLE:
return "Stable"; return "Stable";
case RIG_STATUS_BUGGY: case RIG_STATUS_BUGGY:
return "Buggy"; return "Buggy";
case RIG_STATUS_NEW: case RIG_STATUS_NEW:
return "New"; return "New";
} }
return ""; return "";
} }
@ -422,8 +422,9 @@ setting_t HAMLIB_API rig_parse_func(const char *s)
int i; int i;
for (i=0 ; func_str[i].str != ""; i++) for (i=0 ; func_str[i].str != ""; i++)
if (!strcmp(s, func_str[i].str)) if (!strcmp(s, func_str[i].str))
return func_str[i].func; return func_str[i].func;
return RIG_FUNC_NONE; return RIG_FUNC_NONE;
} }
@ -482,8 +483,9 @@ setting_t HAMLIB_API rig_parse_level(const char *s)
int i; int i;
for (i=0 ; level_str[i].str != ""; i++) for (i=0 ; level_str[i].str != ""; i++)
if (!strcmp(s, level_str[i].str)) if (!strcmp(s, level_str[i].str))
return level_str[i].level; return level_str[i].level;
return RIG_LEVEL_NONE; return RIG_LEVEL_NONE;
} }
@ -520,10 +522,11 @@ setting_t HAMLIB_API rig_parse_parm(const char *s)
int i; int i;
for (i=0 ; parm_str[i].str != ""; i++) for (i=0 ; parm_str[i].str != ""; i++)
if (!strcmp(s, parm_str[i].str)) if (!strcmp(s, parm_str[i].str))
return parm_str[i].parm; return parm_str[i].parm;
return RIG_PARM_NONE; return RIG_PARM_NONE;
}
const char * HAMLIB_API rig_strparm(setting_t parm) const char * HAMLIB_API rig_strparm(setting_t parm)
{ {
@ -565,8 +568,9 @@ vfo_op_t HAMLIB_API rig_parse_vfo_op(const char *s)
int i; int i;
for (i=0 ; vfo_op_str[i].str != ""; i++) for (i=0 ; vfo_op_str[i].str != ""; i++)
if (!strcmp(s, vfo_op_str[i].str)) if (!strcmp(s, vfo_op_str[i].str))
return vfo_op_str[i].vfo_op; return vfo_op_str[i].vfo_op;
return RIG_OP_NONE; return RIG_OP_NONE;
} }

103
src/parallel.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Interface - parallel communication low-level support * Hamlib Interface - parallel communication low-level support
* Copyright (c) 2000-2005 by Stephane Fillod * Copyright (c) 2000-2005 by Stephane Fillod
* *
* $Id: parallel.c,v 1.3 2005-04-03 12:27:16 fillods Exp $ * $Id: parallel.c,v 1.4 2005-04-04 18:30:55 fillods Exp $
* *
* This library is free software; you can redistribute it and/or modify * This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as * it under the terms of the GNU Library General Public License as
@ -319,28 +319,29 @@ int HAMLIB_API par_unlock(hamlib_port_t *port)
int par_ptt_set(hamlib_port_t *p, ptt_t pttx) int par_ptt_set(hamlib_port_t *p, ptt_t pttx)
{ {
switch(p->type.ptt) { switch(p->type.ptt) {
case RIG_PTT_PARALLEL: case RIG_PTT_PARALLEL:
{ {
unsigned char reg; unsigned char reg;
int status; int status;
status = par_read_data(p, &reg); status = par_read_data(p, &reg);
if (status != RIG_OK) if (status != RIG_OK)
return status; return status;
if (pttx == RIG_PTT_ON) if (pttx == RIG_PTT_ON)
reg |= 1 << p->parm.parallel.pin; reg |= 1 << p->parm.parallel.pin;
else else
reg &= ~(1 << p->parm.parallel.pin); reg &= ~(1 << p->parm.parallel.pin);
return par_write_data(p, reg); return par_write_data(p, reg);
}
default:
rig_debug(RIG_DEBUG_ERR,"Unsupported PTT type %d\n",
p->type.ptt);
return -RIG_EINVAL;
} }
return RIG_OK; default:
rig_debug(RIG_DEBUG_ERR,"Unsupported PTT type %d\n",
p->type.ptt);
return -RIG_EINVAL;
}
return RIG_OK;
} }
/* /*
@ -348,23 +349,24 @@ int par_ptt_set(hamlib_port_t *p, ptt_t pttx)
*/ */
int par_ptt_get(hamlib_port_t *p, ptt_t *pttx) int par_ptt_get(hamlib_port_t *p, ptt_t *pttx)
{ {
switch(p->type.ptt) { switch(p->type.ptt) {
case RIG_PTT_PARALLEL: case RIG_PTT_PARALLEL:
{ {
unsigned char reg; unsigned char reg;
int status; int status;
status = par_read_data(p, &reg); status = par_read_data(p, &reg);
*pttx = reg & (1<<p->parm.parallel.pin) ? *pttx = reg & (1<<p->parm.parallel.pin) ?
RIG_PTT_ON:RIG_PTT_OFF; RIG_PTT_ON:RIG_PTT_OFF;
return status; return status;
}
default:
rig_debug(RIG_DEBUG_ERR,"Unsupported PTT type %d\n",
p->type.ptt);
return -RIG_ENAVAIL;
} }
return RIG_OK; default:
rig_debug(RIG_DEBUG_ERR,"Unsupported PTT type %d\n",
p->type.ptt);
return -RIG_ENAVAIL;
}
return RIG_OK;
} }
/* /*
@ -372,22 +374,23 @@ int par_ptt_get(hamlib_port_t *p, ptt_t *pttx)
*/ */
int par_dcd_get(hamlib_port_t *p, dcd_t *dcdx) int par_dcd_get(hamlib_port_t *p, dcd_t *dcdx)
{ {
switch(p->type.dcd) { switch(p->type.dcd) {
case RIG_DCD_PARALLEL: case RIG_DCD_PARALLEL:
{ {
unsigned char reg; unsigned char reg;
int status; int status;
status = par_read_data(p, &reg); status = par_read_data(p, &reg);
*dcdx = reg & (1<<p->parm.parallel.pin) ? *dcdx = reg & (1<<p->parm.parallel.pin) ?
RIG_DCD_ON:RIG_DCD_OFF; RIG_DCD_ON:RIG_DCD_OFF;
return status; return status;
}
default:
rig_debug(RIG_DEBUG_ERR,"Unsupported DCD type %d\n",
p->type.dcd);
return -RIG_ENAVAIL;
} }
return RIG_OK; default:
rig_debug(RIG_DEBUG_ERR,"Unsupported DCD type %d\n",
p->type.dcd);
return -RIG_ENAVAIL;
}
return RIG_OK;
} }

153
src/register.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Interface - provides registering for dynamically loadable backends. * Hamlib Interface - provides registering for dynamically loadable backends.
* Copyright (c) 2000-2005 by Stephane Fillod * Copyright (c) 2000-2005 by Stephane Fillod
* *
* $Id: register.c,v 1.22 2005-04-03 12:27:16 fillods Exp $ * $Id: register.c,v 1.23 2005-04-04 18:30:56 fillods Exp $
* *
* This library is free software; you can redistribute it and/or modify * This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as * it under the terms of the GNU Library General Public License as
@ -62,9 +62,9 @@ static struct {
* It is chained, and used in a hash table, see below. * It is chained, and used in a hash table, see below.
*/ */
struct rig_list { struct rig_list {
const struct rig_caps *caps; const struct rig_caps *caps;
lt_dlhandle handle; /* handle returned by lt_dlopen() */ lt_dlhandle handle; /* handle returned by lt_dlopen() */
struct rig_list *next; struct rig_list *next;
}; };
#define RIGLSTHASHSZ 16 #define RIGLSTHASHSZ 16
@ -84,30 +84,30 @@ static int rig_lookup_backend(rig_model_t rig_model);
*/ */
int HAMLIB_API rig_register(const struct rig_caps *caps) int HAMLIB_API rig_register(const struct rig_caps *caps)
{ {
int hval; int hval;
struct rig_list *p; struct rig_list *p;
if (!caps) if (!caps)
return -RIG_EINVAL; return -RIG_EINVAL;
rig_debug(RIG_DEBUG_VERBOSE, "rig_register (%d)\n",caps->rig_model); rig_debug(RIG_DEBUG_VERBOSE, "rig_register (%d)\n",caps->rig_model);
#ifndef DONT_WANT_DUP_CHECK #ifndef DONT_WANT_DUP_CHECK
if (rig_get_caps(caps->rig_model)!=NULL) if (rig_get_caps(caps->rig_model)!=NULL)
return -RIG_EINVAL; return -RIG_EINVAL;
#endif #endif
p = (struct rig_list*)malloc(sizeof(struct rig_list)); p = (struct rig_list*)malloc(sizeof(struct rig_list));
if (!p) if (!p)
return -RIG_ENOMEM; return -RIG_ENOMEM;
hval = HASH_FUNC(caps->rig_model); hval = HASH_FUNC(caps->rig_model);
p->caps = caps; p->caps = caps;
p->handle = NULL; p->handle = NULL;
p->next = rig_hash_table[hval]; p->next = rig_hash_table[hval];
rig_hash_table[hval] = p; rig_hash_table[hval] = p;
return RIG_OK; return RIG_OK;
} }
/* /*
@ -117,13 +117,14 @@ int HAMLIB_API rig_register(const struct rig_caps *caps)
const struct rig_caps * HAMLIB_API rig_get_caps(rig_model_t rig_model) const struct rig_caps * HAMLIB_API rig_get_caps(rig_model_t rig_model)
{ {
struct rig_list *p; struct rig_list *p;
for (p = rig_hash_table[HASH_FUNC(rig_model)]; p; p=p->next) { for (p = rig_hash_table[HASH_FUNC(rig_model)]; p; p=p->next) {
if (p->caps->rig_model == rig_model) if (p->caps->rig_model == rig_model)
return p->caps; return p->caps;
} }
return NULL; /* sorry, caps not registered! */
return NULL; /* sorry, caps not registered! */
} }
/* /*
@ -133,14 +134,15 @@ const struct rig_caps * HAMLIB_API rig_get_caps(rig_model_t rig_model)
*/ */
static int rig_lookup_backend(rig_model_t rig_model) static int rig_lookup_backend(rig_model_t rig_model)
{ {
int i; int i;
for (i=0; i<RIG_BACKEND_MAX && rig_backend_list[i].be_name; i++) { for (i=0; i<RIG_BACKEND_MAX && rig_backend_list[i].be_name; i++) {
if (RIG_BACKEND_NUM(rig_model) == if (RIG_BACKEND_NUM(rig_model) ==
rig_backend_list[i].be_num) rig_backend_list[i].be_num)
return i; return i;
} }
return -1;
return -1;
} }
/* /*
@ -151,54 +153,55 @@ static int rig_lookup_backend(rig_model_t rig_model)
*/ */
int HAMLIB_API rig_check_backend(rig_model_t rig_model) int HAMLIB_API rig_check_backend(rig_model_t rig_model)
{ {
const struct rig_caps *caps; const struct rig_caps *caps;
int be_idx; int be_idx;
int retval; int retval;
/* already loaded ? */ /* already loaded ? */
caps = rig_get_caps(rig_model); caps = rig_get_caps(rig_model);
if (caps) if (caps)
return RIG_OK; return RIG_OK;
be_idx = rig_lookup_backend(rig_model); be_idx = rig_lookup_backend(rig_model);
/* /*
* Never heard about this backend family! * Never heard about this backend family!
*/ */
if (be_idx == -1) { if (be_idx == -1) {
rig_debug(RIG_DEBUG_VERBOSE, "rig_check_backend: unsupported " rig_debug(RIG_DEBUG_VERBOSE, "rig_check_backend: unsupported "
"backend %d for model %d\n", "backend %d for model %d\n",
RIG_BACKEND_NUM(rig_model), rig_model RIG_BACKEND_NUM(rig_model), rig_model);
); return -RIG_ENAVAIL;
return -RIG_ENAVAIL; }
}
retval = rig_load_backend(rig_backend_list[be_idx].be_name);
return retval; retval = rig_load_backend(rig_backend_list[be_idx].be_name);
return retval;
} }
int HAMLIB_API rig_unregister(rig_model_t rig_model) int HAMLIB_API rig_unregister(rig_model_t rig_model)
{ {
int hval; int hval;
struct rig_list *p,*q; struct rig_list *p,*q;
hval = HASH_FUNC(rig_model); hval = HASH_FUNC(rig_model);
q = NULL; q = NULL;
for (p = rig_hash_table[hval]; p; p=p->next) { for (p = rig_hash_table[hval]; p; p=p->next) {
if (p->caps->rig_model == rig_model) { if (p->caps->rig_model == rig_model) {
if (q == NULL) if (q == NULL)
rig_hash_table[hval] = p->next; rig_hash_table[hval] = p->next;
else else
q->next = p->next; q->next = p->next;
free(p);
return RIG_OK; free(p);
} return RIG_OK;
q = p;
} }
return -RIG_EINVAL; /* sorry, caps not registered! */ q = p;
}
return -RIG_EINVAL; /* sorry, caps not registered! */
} }
/* /*
@ -211,13 +214,14 @@ int HAMLIB_API rig_list_foreach(int (*cfunc)(const struct rig_caps*, rig_ptr_t),
int i; int i;
if (!cfunc) if (!cfunc)
return -RIG_EINVAL; return -RIG_EINVAL;
for (i=0; i<RIGLSTHASHSZ; i++) { for (i=0; i<RIGLSTHASHSZ; i++) {
for (p=rig_hash_table[i]; p; p=p->next) for (p=rig_hash_table[i]; p; p=p->next)
if ((*cfunc)(p->caps,data) == 0) if ((*cfunc)(p->caps,data) == 0)
return RIG_OK; return RIG_OK;
} }
return RIG_OK; return RIG_OK;
} }
@ -271,6 +275,7 @@ int rig_load_all_backends()
for (i=0; i<RIG_BACKEND_MAX && rig_backend_list[i].be_name; i++) { for (i=0; i<RIG_BACKEND_MAX && rig_backend_list[i].be_name; i++) {
rig_load_backend(rig_backend_list[i].be_name); rig_load_backend(rig_backend_list[i].be_name);
} }
return RIG_OK; return RIG_OK;
} }

2160
src/rig.c
Wyświetl plik

Plik diff jest za duży Load Diff

301
src/rot_conf.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Interface - rotator configuration interface * Hamlib Interface - rotator configuration interface
* Copyright (c) 2000-2004 by Stephane Fillod * Copyright (c) 2000-2004 by Stephane Fillod
* *
* $Id: rot_conf.c,v 1.4 2004-10-02 10:32:08 fillods Exp $ * $Id: rot_conf.c,v 1.5 2005-04-04 18:31:00 fillods Exp $
* *
* This library is free software; you can redistribute it and/or modify * This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as * it under the terms of the GNU Library General Public License as
@ -108,76 +108,76 @@ static const struct confparams rotfrontend_cfg_params[] = {
*/ */
int frontrot_set_conf(ROT *rot, token_t token, const char *val) int frontrot_set_conf(ROT *rot, token_t token, const char *val)
{ {
const struct rot_caps *caps; const struct rot_caps *caps;
struct rot_state *rs; struct rot_state *rs;
caps = rot->caps; caps = rot->caps;
rs = &rot->state; rs = &rot->state;
switch(token) { switch(token) {
case TOK_PATHNAME: case TOK_PATHNAME:
strcpy(rs->rotport.pathname, val); strcpy(rs->rotport.pathname, val);
break; break;
case TOK_WRITE_DELAY: case TOK_WRITE_DELAY:
rs->rotport.write_delay = atoi(val); rs->rotport.write_delay = atoi(val);
break; break;
case TOK_POST_WRITE_DELAY: case TOK_POST_WRITE_DELAY:
rs->rotport.post_write_delay = atoi(val); rs->rotport.post_write_delay = atoi(val);
break; break;
case TOK_TIMEOUT: case TOK_TIMEOUT:
rs->rotport.timeout = atoi(val); rs->rotport.timeout = atoi(val);
break; break;
case TOK_RETRY: case TOK_RETRY:
rs->rotport.retry = atoi(val); rs->rotport.retry = atoi(val);
break; break;
case TOK_SERIAL_SPEED: case TOK_SERIAL_SPEED:
rs->rotport.parm.serial.rate = atoi(val); rs->rotport.parm.serial.rate = atoi(val);
break; break;
case TOK_DATA_BITS: case TOK_DATA_BITS:
rs->rotport.parm.serial.data_bits = atoi(val); rs->rotport.parm.serial.data_bits = atoi(val);
break; break;
case TOK_STOP_BITS: case TOK_STOP_BITS:
rs->rotport.parm.serial.stop_bits = atoi(val); rs->rotport.parm.serial.stop_bits = atoi(val);
break; break;
case TOK_PARITY: case TOK_PARITY:
if (!strncmp(val, "None", 8)) if (!strncmp(val, "None", 8))
rs->rotport.parm.serial.parity = RIG_PARITY_NONE; rs->rotport.parm.serial.parity = RIG_PARITY_NONE;
else if (!strncmp(val, "Odd", 8)) else if (!strncmp(val, "Odd", 8))
rs->rotport.parm.serial.parity = RIG_PARITY_ODD; rs->rotport.parm.serial.parity = RIG_PARITY_ODD;
else if (!strncmp(val, "Even", 8)) else if (!strncmp(val, "Even", 8))
rs->rotport.parm.serial.parity = RIG_PARITY_EVEN; rs->rotport.parm.serial.parity = RIG_PARITY_EVEN;
else else
return -RIG_EINVAL; return -RIG_EINVAL;
break; break;
case TOK_HANDSHAKE: case TOK_HANDSHAKE:
if (!strncmp(val, "None", 8)) if (!strncmp(val, "None", 8))
rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_NONE; rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_NONE;
else if (!strncmp(val, "XONXOFF", 8)) else if (!strncmp(val, "XONXOFF", 8))
rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_XONXOFF; rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_XONXOFF;
else if (!strncmp(val, "Hardware", 8)) else if (!strncmp(val, "Hardware", 8))
rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_HARDWARE; rs->rotport.parm.serial.handshake = RIG_HANDSHAKE_HARDWARE;
else else
return -RIG_EINVAL; return -RIG_EINVAL;
break; break;
case TOK_MIN_AZ: case TOK_MIN_AZ:
rs->min_az = atof(val); rs->min_az = atof(val);
break; break;
case TOK_MAX_AZ: case TOK_MAX_AZ:
rs->max_az = atof(val); rs->max_az = atof(val);
break; break;
case TOK_MIN_EL: case TOK_MIN_EL:
rs->min_el = atof(val); rs->min_el = atof(val);
break; break;
case TOK_MAX_EL: case TOK_MAX_EL:
rs->max_el = atof(val); rs->max_el = atof(val);
break; break;
default: default:
return -RIG_EINVAL; return -RIG_EINVAL;
} }
return RIG_OK; return RIG_OK;
} }
/* /*
@ -186,75 +186,75 @@ int frontrot_set_conf(ROT *rot, token_t token, const char *val)
*/ */
int frontrot_get_conf(ROT *rot, token_t token, char *val) int frontrot_get_conf(ROT *rot, token_t token, char *val)
{ {
const struct rot_caps *caps; const struct rot_caps *caps;
struct rot_state *rs; struct rot_state *rs;
const char *s; const char *s;
caps = rot->caps; caps = rot->caps;
rs = &rot->state; rs = &rot->state;
switch(token) { switch(token) {
case TOK_PATHNAME: case TOK_PATHNAME:
strcpy(val, rs->rotport.pathname); strcpy(val, rs->rotport.pathname);
break; break;
case TOK_WRITE_DELAY: case TOK_WRITE_DELAY:
sprintf(val, "%d", rs->rotport.write_delay); sprintf(val, "%d", rs->rotport.write_delay);
break; break;
case TOK_POST_WRITE_DELAY: case TOK_POST_WRITE_DELAY:
sprintf(val, "%d", rs->rotport.post_write_delay); sprintf(val, "%d", rs->rotport.post_write_delay);
break; break;
case TOK_TIMEOUT: case TOK_TIMEOUT:
sprintf(val, "%d", rs->rotport.timeout); sprintf(val, "%d", rs->rotport.timeout);
break; break;
case TOK_RETRY: case TOK_RETRY:
sprintf(val, "%d", rs->rotport.retry); sprintf(val, "%d", rs->rotport.retry);
break; break;
case TOK_SERIAL_SPEED: case TOK_SERIAL_SPEED:
sprintf(val, "%d", rs->rotport.parm.serial.rate); sprintf(val, "%d", rs->rotport.parm.serial.rate);
break; break;
case TOK_DATA_BITS: case TOK_DATA_BITS:
sprintf(val, "%d", rs->rotport.parm.serial.data_bits); sprintf(val, "%d", rs->rotport.parm.serial.data_bits);
break; break;
case TOK_STOP_BITS: case TOK_STOP_BITS:
sprintf(val, "%d", rs->rotport.parm.serial.stop_bits); sprintf(val, "%d", rs->rotport.parm.serial.stop_bits);
break; break;
case TOK_PARITY: case TOK_PARITY:
switch (rs->rotport.parm.serial.parity) { switch (rs->rotport.parm.serial.parity) {
case RIG_PARITY_NONE: s = "None"; break; case RIG_PARITY_NONE: s = "None"; break;
case RIG_PARITY_ODD: s = "Odd"; break; case RIG_PARITY_ODD: s = "Odd"; break;
case RIG_PARITY_EVEN: s = "Even"; break; case RIG_PARITY_EVEN: s = "Even"; break;
default: return -RIG_EINVAL; default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_HANDSHAKE:
switch (rs->rotport.parm.serial.handshake) {
case RIG_HANDSHAKE_NONE: s = "None"; break;
case RIG_HANDSHAKE_XONXOFF: s = "XONXOFF"; break;
case RIG_HANDSHAKE_HARDWARE: s = "Hardware"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
case TOK_MIN_AZ:
sprintf(val, "%f", rs->min_az);
break;
case TOK_MAX_AZ:
sprintf(val, "%f", rs->max_az);
break;
case TOK_MIN_EL:
sprintf(val, "%f", rs->min_el);
break;
case TOK_MAX_EL:
sprintf(val, "%f", rs->max_el);
break;
default:
return -RIG_EINVAL;
} }
strcpy(val, s);
break;
case TOK_HANDSHAKE:
switch (rs->rotport.parm.serial.handshake) {
case RIG_HANDSHAKE_NONE: s = "None"; break;
case RIG_HANDSHAKE_XONXOFF: s = "XONXOFF"; break;
case RIG_HANDSHAKE_HARDWARE: s = "Hardware"; break;
default: return -RIG_EINVAL;
}
strcpy(val, s);
break;
return RIG_OK; case TOK_MIN_AZ:
sprintf(val, "%f", rs->min_az);
break;
case TOK_MAX_AZ:
sprintf(val, "%f", rs->max_az);
break;
case TOK_MIN_EL:
sprintf(val, "%f", rs->min_el);
break;
case TOK_MAX_EL:
sprintf(val, "%f", rs->max_el);
break;
default:
return -RIG_EINVAL;
}
return RIG_OK;
} }
/* /*
@ -267,14 +267,14 @@ int HAMLIB_API rot_token_foreach(ROT *rot, int (*cfunc)(const struct confparams
const struct confparams *cfp; const struct confparams *cfp;
if (!rot || !rot->caps || !cfunc) if (!rot || !rot->caps || !cfunc)
return -RIG_EINVAL; return -RIG_EINVAL;
for (cfp = rot->caps->cfgparams; cfp && cfp->name; cfp++) for (cfp = rot->caps->cfgparams; cfp && cfp->name; cfp++)
if ((*cfunc)(cfp, data) == 0) if ((*cfunc)(cfp, data) == 0)
return RIG_OK; return RIG_OK;
for (cfp = rotfrontend_cfg_params; cfp->name; cfp++) for (cfp = rotfrontend_cfg_params; cfp->name; cfp++)
if ((*cfunc)(cfp, data) == 0) if ((*cfunc)(cfp, data) == 0)
return RIG_OK; return RIG_OK;
return RIG_OK; return RIG_OK;
} }
@ -287,17 +287,17 @@ int HAMLIB_API rot_token_foreach(ROT *rot, int (*cfunc)(const struct confparams
*/ */
const struct confparams * HAMLIB_API rot_confparam_lookup(ROT *rot, const char *name) const struct confparams * HAMLIB_API rot_confparam_lookup(ROT *rot, const char *name)
{ {
const struct confparams *cfp; const struct confparams *cfp;
if (!rot || !rot->caps) if (!rot || !rot->caps)
return NULL;
for (cfp = rot->caps->cfgparams; cfp && cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
for (cfp = rotfrontend_cfg_params; cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
return NULL; return NULL;
for (cfp = rot->caps->cfgparams; cfp && cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
for (cfp = rotfrontend_cfg_params; cfp->name; cfp++)
if (!strcmp(cfp->name, name))
return cfp;
return NULL;
} }
/* /*
@ -305,13 +305,12 @@ const struct confparams * HAMLIB_API rot_confparam_lookup(ROT *rot, const char *
*/ */
token_t HAMLIB_API rot_token_lookup(ROT *rot, const char *name) token_t HAMLIB_API rot_token_lookup(ROT *rot, const char *name)
{ {
const struct confparams *cfp; const struct confparams *cfp;
cfp = rot_confparam_lookup(rot, name); cfp = rot_confparam_lookup(rot, name);
if (!cfp) if (!cfp)
return RIG_CONF_END; return RIG_CONF_END;
return cfp->token; return cfp->token;
} }

159
src/rot_reg.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Interface - provides registering for dynamically loadable backends. * Hamlib Interface - provides registering for dynamically loadable backends.
* Copyright (c) 2000-2004 by Stephane Fillod * Copyright (c) 2000-2004 by Stephane Fillod
* *
* $Id: rot_reg.c,v 1.8 2005-04-03 12:27:17 fillods Exp $ * $Id: rot_reg.c,v 1.9 2005-04-04 18:31:00 fillods Exp $
* *
* This library is free software; you can redistribute it and/or modify * This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as * it under the terms of the GNU Library General Public License as
@ -62,9 +62,9 @@ static struct {
* It is chained, and used in a hash table, see below. * It is chained, and used in a hash table, see below.
*/ */
struct rot_list { struct rot_list {
const struct rot_caps *caps; const struct rot_caps *caps;
lt_dlhandle handle; /* handle returned by lt_dlopen() */ lt_dlhandle handle; /* handle returned by lt_dlopen() */
struct rot_list *next; struct rot_list *next;
}; };
#define ROTLSTHASHSZ 16 #define ROTLSTHASHSZ 16
@ -84,30 +84,30 @@ static int rot_lookup_backend(rot_model_t rot_model);
*/ */
int HAMLIB_API rot_register(const struct rot_caps *caps) int HAMLIB_API rot_register(const struct rot_caps *caps)
{ {
int hval; int hval;
struct rot_list *p; struct rot_list *p;
if (!caps) if (!caps)
return -RIG_EINVAL; return -RIG_EINVAL;
rot_debug(RIG_DEBUG_VERBOSE, "rot_register (%d)\n",caps->rot_model); rot_debug(RIG_DEBUG_VERBOSE, "rot_register (%d)\n",caps->rot_model);
#ifndef DONT_WANT_DUP_CHECK #ifndef DONT_WANT_DUP_CHECK
if (rot_get_caps(caps->rot_model)!=NULL) if (rot_get_caps(caps->rot_model)!=NULL)
return -RIG_EINVAL; return -RIG_EINVAL;
#endif #endif
p = (struct rot_list*)malloc(sizeof(struct rot_list)); p = (struct rot_list*)malloc(sizeof(struct rot_list));
if (!p) if (!p)
return -RIG_ENOMEM; return -RIG_ENOMEM;
hval = HASH_FUNC(caps->rot_model); hval = HASH_FUNC(caps->rot_model);
p->caps = caps; p->caps = caps;
p->handle = NULL; p->handle = NULL;
p->next = rot_hash_table[hval]; p->next = rot_hash_table[hval];
rot_hash_table[hval] = p; rot_hash_table[hval] = p;
return RIG_OK; return RIG_OK;
} }
/* /*
@ -117,13 +117,13 @@ int HAMLIB_API rot_register(const struct rot_caps *caps)
const struct rot_caps * HAMLIB_API rot_get_caps(rot_model_t rot_model) const struct rot_caps * HAMLIB_API rot_get_caps(rot_model_t rot_model)
{ {
struct rot_list *p; struct rot_list *p;
for (p = rot_hash_table[HASH_FUNC(rot_model)]; p; p=p->next) { for (p = rot_hash_table[HASH_FUNC(rot_model)]; p; p=p->next) {
if (p->caps->rot_model == rot_model) if (p->caps->rot_model == rot_model)
return p->caps; return p->caps;
} }
return NULL; /* sorry, caps not registered! */ return NULL; /* sorry, caps not registered! */
} }
/* /*
@ -133,14 +133,14 @@ const struct rot_caps * HAMLIB_API rot_get_caps(rot_model_t rot_model)
*/ */
static int rot_lookup_backend(rot_model_t rot_model) static int rot_lookup_backend(rot_model_t rot_model)
{ {
int i; int i;
for (i=0; i<ROT_BACKEND_MAX && rot_backend_list[i].be_name; i++) { for (i=0; i<ROT_BACKEND_MAX && rot_backend_list[i].be_name; i++) {
if (ROT_BACKEND_NUM(rot_model) == if (ROT_BACKEND_NUM(rot_model) ==
rot_backend_list[i].be_num) rot_backend_list[i].be_num)
return i; return i;
} }
return -1; return -1;
} }
/* /*
@ -151,54 +151,53 @@ static int rot_lookup_backend(rot_model_t rot_model)
*/ */
int HAMLIB_API rot_check_backend(rot_model_t rot_model) int HAMLIB_API rot_check_backend(rot_model_t rot_model)
{ {
const struct rot_caps *caps; const struct rot_caps *caps;
int be_idx; int be_idx;
int retval; int retval;
/* already loaded ? */ /* already loaded ? */
caps = rot_get_caps(rot_model); caps = rot_get_caps(rot_model);
if (caps) if (caps)
return RIG_OK; return RIG_OK;
be_idx = rot_lookup_backend(rot_model); be_idx = rot_lookup_backend(rot_model);
/* /*
* Never heard about this backend family! * Never heard about this backend family!
*/ */
if (be_idx == -1) { if (be_idx == -1) {
rot_debug(RIG_DEBUG_VERBOSE, "rot_check_backend: unsupported " rot_debug(RIG_DEBUG_VERBOSE, "rot_check_backend: unsupported "
"backend %d for model %d\n", "backend %d for model %d\n",
ROT_BACKEND_NUM(rot_model), rot_model ROT_BACKEND_NUM(rot_model), rot_model);
); return -RIG_ENAVAIL;
return -RIG_ENAVAIL; }
}
retval = rot_load_backend(rot_backend_list[be_idx].be_name);
retval = rot_load_backend(rot_backend_list[be_idx].be_name);
return retval; return retval;
} }
int HAMLIB_API rot_unregister(rot_model_t rot_model) int HAMLIB_API rot_unregister(rot_model_t rot_model)
{ {
int hval; int hval;
struct rot_list *p,*q; struct rot_list *p,*q;
hval = HASH_FUNC(rot_model); hval = HASH_FUNC(rot_model);
q = NULL; q = NULL;
for (p = rot_hash_table[hval]; p; p=p->next) { for (p = rot_hash_table[hval]; p; p=p->next) {
if (p->caps->rot_model == rot_model) { if (p->caps->rot_model == rot_model) {
if (q == NULL) if (q == NULL)
rot_hash_table[hval] = p->next; rot_hash_table[hval] = p->next;
else else
q->next = p->next; q->next = p->next;
free(p); free(p);
return RIG_OK; return RIG_OK;
}
q = p;
} }
return -RIG_EINVAL; /* sorry, caps not registered! */ q = p;
}
return -RIG_EINVAL; /* sorry, caps not registered! */
} }
/* /*
@ -211,12 +210,12 @@ int HAMLIB_API rot_list_foreach(int (*cfunc)(const struct rot_caps*, rig_ptr_t),
int i; int i;
if (!cfunc) if (!cfunc)
return -RIG_EINVAL; return -RIG_EINVAL;
for (i=0; i<ROTLSTHASHSZ; i++) { for (i=0; i<ROTLSTHASHSZ; i++) {
for (p=rot_hash_table[i]; p; p=p->next) for (p=rot_hash_table[i]; p; p=p->next)
if ((*cfunc)(p->caps,data) == 0) if ((*cfunc)(p->caps,data) == 0)
return RIG_OK; return RIG_OK;
} }
return RIG_OK; return RIG_OK;
} }
@ -231,11 +230,11 @@ rot_model_t HAMLIB_API rot_probe_all(hamlib_port_t *p)
rot_model_t rot_model; rot_model_t rot_model;
for (i=0; i<ROT_BACKEND_MAX && rot_backend_list[i].be_name; i++) { for (i=0; i<ROT_BACKEND_MAX && rot_backend_list[i].be_name; i++) {
if (rot_backend_list[i].be_probe) { if (rot_backend_list[i].be_probe) {
rot_model = (*rot_backend_list[i].be_probe)(p); rot_model = (*rot_backend_list[i].be_probe)(p);
if (rot_model != ROT_MODEL_NONE) if (rot_model != ROT_MODEL_NONE)
return rot_model; return rot_model;
} }
} }
return ROT_MODEL_NONE; return ROT_MODEL_NONE;
} }
@ -246,7 +245,7 @@ int rot_load_all_backends()
int i; int i;
for (i=0; i<ROT_BACKEND_MAX && rot_backend_list[i].be_name; i++) { for (i=0; i<ROT_BACKEND_MAX && rot_backend_list[i].be_name; i++) {
rot_load_backend(rot_backend_list[i].be_name); rot_load_backend(rot_backend_list[i].be_name);
} }
return RIG_OK; return RIG_OK;
} }

478
src/rotator.c
Wyświetl plik

@ -2,7 +2,7 @@
* Hamlib Interface - main file * Hamlib Interface - main file
* Copyright (c) 2000-2005 by Stephane Fillod and Frank Singleton * Copyright (c) 2000-2005 by Stephane Fillod and Frank Singleton
* *
* $Id: rotator.c,v 1.17 2005-02-20 02:38:29 fillods Exp $ * $Id: rotator.c,v 1.18 2005-04-04 18:31:00 fillods Exp $
* *
* This library is free software; you can redistribute it and/or modify * This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as * it under the terms of the GNU Library General Public License as
@ -105,16 +105,16 @@ static int remove_opened_rot(ROT *rot)
q = NULL; q = NULL;
for (p=opened_rot_list; p; p=p->next) { for (p=opened_rot_list; p; p=p->next) {
if (p->rot == rot) { if (p->rot == rot) {
if (q == NULL) { if (q == NULL) {
opened_rot_list = opened_rot_list->next; opened_rot_list = opened_rot_list->next;
} else { } else {
q->next = p->next; q->next = p->next;
}
free(p);
return RIG_OK;
} }
q = p; free(p);
return RIG_OK;
}
q = p;
} }
return -RIG_EINVAL; /* Not found in list ! */ return -RIG_EINVAL; /* Not found in list ! */
} }
@ -144,8 +144,8 @@ int foreach_opened_rot(int (*cfunc)(ROT *, rig_ptr_t), rig_ptr_t data)
struct opened_rot_l *p; struct opened_rot_l *p;
for (p=opened_rot_list; p; p=p->next) { for (p=opened_rot_list; p; p=p->next) {
if ((*cfunc)(p->rot,data) == 0) if ((*cfunc)(p->rot,data) == 0)
return RIG_OK; return RIG_OK;
} }
return RIG_OK; return RIG_OK;
} }
@ -165,90 +165,90 @@ int foreach_opened_rot(int (*cfunc)(ROT *, rig_ptr_t), rig_ptr_t data)
ROT * HAMLIB_API rot_init(rot_model_t rot_model) ROT * HAMLIB_API rot_init(rot_model_t rot_model)
{ {
ROT *rot; ROT *rot;
const struct rot_caps *caps; const struct rot_caps *caps;
struct rot_state *rs; struct rot_state *rs;
int retcode; int retcode;
rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_init called \n"); rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_init called \n");
rot_check_backend(rot_model); rot_check_backend(rot_model);
caps = rot_get_caps(rot_model); caps = rot_get_caps(rot_model);
if (!caps) if (!caps)
return NULL; return NULL;
/*
* okay, we've found it. Allocate some memory and set it to zeros,
* and especially the initialize the callbacks
*/
rot = calloc(1, sizeof(ROT));
if (rot == NULL) {
/* /*
* okay, we've found it. Allocate some memory and set it to zeros, * FIXME: how can the caller know it's a memory shortage,
* and especially the initialize the callbacks * and not "rot not found" ?
*/
rot = calloc(1, sizeof(ROT));
if (rot == NULL) {
/*
* FIXME: how can the caller know it's a memory shortage,
* and not "rot not found" ?
*/
return NULL;
}
rot->caps = caps;
/*
* populate the rot->state
* TODO: read the Preferences here!
*/ */
return NULL;
}
rs = &rot->state; rot->caps = caps;
rs->comm_state = 0; /*
rs->rotport.type.rig = caps->port_type; /* default from caps */ * populate the rot->state
* TODO: read the Preferences here!
*/
rs->rotport.write_delay = caps->write_delay; rs = &rot->state;
rs->rotport.post_write_delay = caps->post_write_delay;
rs->rotport.timeout = caps->timeout;
rs->rotport.retry = caps->retry;
switch (caps->port_type) { rs->comm_state = 0;
case RIG_PORT_SERIAL: rs->rotport.type.rig = caps->port_type; /* default from caps */
strncpy(rs->rotport.pathname, DEFAULT_SERIAL_PORT, FILPATHLEN);
rs->rotport.parm.serial.rate = caps->serial_rate_max; /* fastest ! */
rs->rotport.parm.serial.data_bits = caps->serial_data_bits;
rs->rotport.parm.serial.stop_bits = caps->serial_stop_bits;
rs->rotport.parm.serial.parity = caps->serial_parity;
rs->rotport.parm.serial.handshake = caps->serial_handshake;
break;
case RIG_PORT_PARALLEL: rs->rotport.write_delay = caps->write_delay;
strncpy(rs->rotport.pathname, DEFAULT_PARALLEL_PORT, FILPATHLEN); rs->rotport.post_write_delay = caps->post_write_delay;
break; rs->rotport.timeout = caps->timeout;
rs->rotport.retry = caps->retry;
default: switch (caps->port_type) {
strncpy(rs->rotport.pathname, "", FILPATHLEN); case RIG_PORT_SERIAL:
strncpy(rs->rotport.pathname, DEFAULT_SERIAL_PORT, FILPATHLEN);
rs->rotport.parm.serial.rate = caps->serial_rate_max; /* fastest ! */
rs->rotport.parm.serial.data_bits = caps->serial_data_bits;
rs->rotport.parm.serial.stop_bits = caps->serial_stop_bits;
rs->rotport.parm.serial.parity = caps->serial_parity;
rs->rotport.parm.serial.handshake = caps->serial_handshake;
break;
case RIG_PORT_PARALLEL:
strncpy(rs->rotport.pathname, DEFAULT_PARALLEL_PORT, FILPATHLEN);
break;
default:
strncpy(rs->rotport.pathname, "", FILPATHLEN);
}
rs->min_el = caps->min_el;
rs->max_el = caps->max_el;
rs->min_az = caps->min_az;
rs->max_az = caps->max_az;
rs->rotport.fd = -1;
/*
* let the backend a chance to setup his private data
* This must be done only once defaults are setup,
* so the backend init can override rot_state.
*/
if (caps->rot_init != NULL) {
retcode = caps->rot_init(rot);
if (retcode != RIG_OK) {
rot_debug(RIG_DEBUG_VERBOSE,"rot:backend_init failed!\n");
/* cleanup and exit */
free(rot);
return NULL;
} }
}
rs->min_el = caps->min_el; return rot;
rs->max_el = caps->max_el;
rs->min_az = caps->min_az;
rs->max_az = caps->max_az;
rs->rotport.fd = -1;
/*
* let the backend a chance to setup his private data
* This must be done only once defaults are setup,
* so the backend init can override rot_state.
*/
if (caps->rot_init != NULL) {
retcode = caps->rot_init(rot);
if (retcode != RIG_OK) {
rot_debug(RIG_DEBUG_VERBOSE,"rot:backend_init failed!\n");
/* cleanup and exit */
free(rot);
return NULL;
}
}
return rot;
} }
/** /**
@ -270,70 +270,70 @@ ROT * HAMLIB_API rot_init(rot_model_t rot_model)
int HAMLIB_API rot_open(ROT *rot) int HAMLIB_API rot_open(ROT *rot)
{ {
const struct rot_caps *caps; const struct rot_caps *caps;
struct rot_state *rs; struct rot_state *rs;
int status; int status;
rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_open called \n"); rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_open called \n");
if (!rot || !rot->caps) if (!rot || !rot->caps)
return -RIG_EINVAL; return -RIG_EINVAL;
caps = rot->caps; caps = rot->caps;
rs = &rot->state; rs = &rot->state;
if (rs->comm_state) if (rs->comm_state)
return -RIG_EINVAL; return -RIG_EINVAL;
rs->rotport.fd = -1; rs->rotport.fd = -1;
switch(rs->rotport.type.rig) { switch(rs->rotport.type.rig) {
case RIG_PORT_SERIAL: case RIG_PORT_SERIAL:
status = serial_open(&rs->rotport); status = serial_open(&rs->rotport);
if (status != 0) if (status != 0)
return status; return status;
break; break;
case RIG_PORT_PARALLEL: case RIG_PORT_PARALLEL:
status = par_open(&rs->rotport); status = par_open(&rs->rotport);
if (status < 0) if (status < 0)
return status; return status;
break; break;
case RIG_PORT_DEVICE: case RIG_PORT_DEVICE:
status = open(rs->rotport.pathname, O_RDWR, 0); status = open(rs->rotport.pathname, O_RDWR, 0);
if (status < 0) if (status < 0)
return -RIG_EIO; return -RIG_EIO;
rs->rotport.fd = status; rs->rotport.fd = status;
break; break;
case RIG_PORT_NONE: case RIG_PORT_NONE:
case RIG_PORT_RPC: case RIG_PORT_RPC:
break; /* ez :) */ break; /* ez :) */
case RIG_PORT_NETWORK: /* not implemented yet! */ case RIG_PORT_NETWORK: /* not implemented yet! */
return -RIG_ENIMPL; return -RIG_ENIMPL;
default: default:
return -RIG_EINVAL; return -RIG_EINVAL;
}
add_opened_rot(rot);
rs->comm_state = 1;
/*
* Maybe the backend has something to initialize
* In case of failure, just close down and report error code.
*/
if (caps->rot_open != NULL) {
status = caps->rot_open(rot);
if (status != RIG_OK) {
return status;
} }
}
return RIG_OK;
add_opened_rot(rot);
rs->comm_state = 1;
/*
* Maybe the backend has something to initialize
* In case of failure, just close down and report error code.
*/
if (caps->rot_open != NULL) {
status = caps->rot_open(rot);
if (status != RIG_OK) {
return status;
}
}
return RIG_OK;
} }
/** /**
@ -352,47 +352,47 @@ int HAMLIB_API rot_open(ROT *rot)
int HAMLIB_API rot_close(ROT *rot) int HAMLIB_API rot_close(ROT *rot)
{ {
const struct rot_caps *caps; const struct rot_caps *caps;
struct rot_state *rs; struct rot_state *rs;
rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_close called \n"); rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_close called \n");
if (!rot || !rot->caps) if (!rot || !rot->caps)
return -RIG_EINVAL; return -RIG_EINVAL;
caps = rot->caps; caps = rot->caps;
rs = &rot->state; rs = &rot->state;
if (!rs->comm_state) if (!rs->comm_state)
return -RIG_EINVAL; return -RIG_EINVAL;
/* /*
* Let the backend say 73s to the rot. * Let the backend say 73s to the rot.
* and ignore the return code. * and ignore the return code.
*/ */
if (caps->rot_close) if (caps->rot_close)
caps->rot_close(rot); caps->rot_close(rot);
if (rs->rotport.fd != -1) { if (rs->rotport.fd != -1) {
switch(rs->rotport.type.rig) { switch(rs->rotport.type.rig) {
case RIG_PORT_SERIAL: case RIG_PORT_SERIAL:
ser_close(&rs->rotport); ser_close(&rs->rotport);
break; break;
case RIG_PORT_PARALLEL: case RIG_PORT_PARALLEL:
par_close(&rs->rotport); par_close(&rs->rotport);
break; break;
default: default:
close(rs->rotport.fd); close(rs->rotport.fd);
}
rs->rotport.fd = -1;
} }
rs->rotport.fd = -1;
}
remove_opened_rot(rot); remove_opened_rot(rot);
rs->comm_state = 0; rs->comm_state = 0;
return RIG_OK; return RIG_OK;
} }
/** /**
@ -411,26 +411,26 @@ int HAMLIB_API rot_close(ROT *rot)
int HAMLIB_API rot_cleanup(ROT *rot) int HAMLIB_API rot_cleanup(ROT *rot)
{ {
rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_cleanup called \n"); rot_debug(RIG_DEBUG_VERBOSE,"rot:rot_cleanup called \n");
if (!rot || !rot->caps) if (!rot || !rot->caps)
return -RIG_EINVAL; return -RIG_EINVAL;
/* /*
* check if they forgot to close the rot * check if they forgot to close the rot
*/ */
if (rot->state.comm_state) if (rot->state.comm_state)
rot_close(rot); rot_close(rot);
/* /*
* basically free up the priv struct * basically free up the priv struct
*/ */
if (rot->caps->rot_cleanup) if (rot->caps->rot_cleanup)
rot->caps->rot_cleanup(rot); rot->caps->rot_cleanup(rot);
free(rot); free(rot);
return RIG_OK; return RIG_OK;
} }
@ -450,16 +450,16 @@ int HAMLIB_API rot_cleanup(ROT *rot)
*/ */
int HAMLIB_API rot_set_conf(ROT *rot, token_t token, const char *val) int HAMLIB_API rot_set_conf(ROT *rot, token_t token, const char *val)
{ {
if (!rot || !rot->caps) if (!rot || !rot->caps)
return -RIG_EINVAL; return -RIG_EINVAL;
if (IS_TOKEN_FRONTEND(token)) if (IS_TOKEN_FRONTEND(token))
return frontrot_set_conf(rot, token, val); return frontrot_set_conf(rot, token, val);
if (rot->caps->set_conf == NULL) if (rot->caps->set_conf == NULL)
return -RIG_ENAVAIL; return -RIG_ENAVAIL;
return rot->caps->set_conf(rot, token, val); return rot->caps->set_conf(rot, token, val);
} }
/** /**
@ -478,16 +478,16 @@ int HAMLIB_API rot_set_conf(ROT *rot, token_t token, const char *val)
*/ */
int HAMLIB_API rot_get_conf(ROT *rot, token_t token, char *val) int HAMLIB_API rot_get_conf(ROT *rot, token_t token, char *val)
{ {
if (!rot || !rot->caps || !val) if (!rot || !rot->caps || !val)
return -RIG_EINVAL; return -RIG_EINVAL;
if (IS_TOKEN_FRONTEND(token)) if (IS_TOKEN_FRONTEND(token))
return frontrot_get_conf(rot, token, val); return frontrot_get_conf(rot, token, val);
if (rot->caps->get_conf == NULL) if (rot->caps->get_conf == NULL)
return -RIG_ENAVAIL; return -RIG_ENAVAIL;
return rot->caps->get_conf(rot, token, val); return rot->caps->get_conf(rot, token, val);
} }
/** /**
@ -507,23 +507,23 @@ int HAMLIB_API rot_get_conf(ROT *rot, token_t token, char *val)
int HAMLIB_API rot_set_position (ROT *rot, azimuth_t azimuth, elevation_t elevation) int HAMLIB_API rot_set_position (ROT *rot, azimuth_t azimuth, elevation_t elevation)
{ {
const struct rot_caps *caps; const struct rot_caps *caps;
const struct rot_state *rs; const struct rot_state *rs;
if (CHECK_ROT_ARG(rot)) if (CHECK_ROT_ARG(rot))
return -RIG_EINVAL; return -RIG_EINVAL;
caps = rot->caps; caps = rot->caps;
rs = &rot->state; rs = &rot->state;
if (azimuth < rs->min_az || azimuth > rs->max_az || if (azimuth < rs->min_az || azimuth > rs->max_az ||
elevation < rs->min_el || elevation > rs->max_el) elevation < rs->min_el || elevation > rs->max_el)
return -RIG_EINVAL; return -RIG_EINVAL;
if (caps->set_position == NULL) if (caps->set_position == NULL)
return -RIG_ENAVAIL; return -RIG_ENAVAIL;
return caps->set_position(rot, azimuth, elevation); return caps->set_position(rot, azimuth, elevation);
} }
/** /**
@ -543,17 +543,17 @@ int HAMLIB_API rot_set_position (ROT *rot, azimuth_t azimuth, elevation_t elevat
int HAMLIB_API rot_get_position (ROT *rot, azimuth_t *azimuth, elevation_t *elevation) int HAMLIB_API rot_get_position (ROT *rot, azimuth_t *azimuth, elevation_t *elevation)
{ {
const struct rot_caps *caps; const struct rot_caps *caps;
if (CHECK_ROT_ARG(rot) || !azimuth || !elevation) if (CHECK_ROT_ARG(rot) || !azimuth || !elevation)
return -RIG_EINVAL; return -RIG_EINVAL;
caps = rot->caps; caps = rot->caps;
if (caps->get_position == NULL) if (caps->get_position == NULL)
return -RIG_ENAVAIL; return -RIG_ENAVAIL;
return caps->get_position(rot, azimuth, elevation); return caps->get_position(rot, azimuth, elevation);
} }
/** /**
@ -570,17 +570,17 @@ int HAMLIB_API rot_get_position (ROT *rot, azimuth_t *azimuth, elevation_t *elev
int HAMLIB_API rot_park (ROT *rot) int HAMLIB_API rot_park (ROT *rot)
{ {
const struct rot_caps *caps; const struct rot_caps *caps;
if (CHECK_ROT_ARG(rot)) if (CHECK_ROT_ARG(rot))
return -RIG_EINVAL; return -RIG_EINVAL;
caps = rot->caps; caps = rot->caps;
if (caps->park == NULL) if (caps->park == NULL)
return -RIG_ENAVAIL; return -RIG_ENAVAIL;
return caps->park(rot); return caps->park(rot);
} }
/** /**
@ -597,17 +597,17 @@ int HAMLIB_API rot_park (ROT *rot)
int HAMLIB_API rot_stop (ROT *rot) int HAMLIB_API rot_stop (ROT *rot)
{ {
const struct rot_caps *caps; const struct rot_caps *caps;
if (CHECK_ROT_ARG(rot)) if (CHECK_ROT_ARG(rot))
return -RIG_EINVAL; return -RIG_EINVAL;
caps = rot->caps; caps = rot->caps;
if (caps->stop == NULL) if (caps->stop == NULL)
return -RIG_ENAVAIL; return -RIG_ENAVAIL;
return caps->stop(rot); return caps->stop(rot);
} }
/** /**
@ -625,17 +625,17 @@ int HAMLIB_API rot_stop (ROT *rot)
int HAMLIB_API rot_reset (ROT *rot, rot_reset_t reset) int HAMLIB_API rot_reset (ROT *rot, rot_reset_t reset)
{ {
const struct rot_caps *caps; const struct rot_caps *caps;
if (CHECK_ROT_ARG(rot)) if (CHECK_ROT_ARG(rot))
return -RIG_EINVAL; return -RIG_EINVAL;
caps = rot->caps; caps = rot->caps;
if (caps->reset == NULL) if (caps->reset == NULL)
return -RIG_ENAVAIL; return -RIG_ENAVAIL;
return caps->reset(rot, reset); return caps->reset(rot, reset);
} }
/** /**
@ -675,14 +675,12 @@ int HAMLIB_API rot_move (ROT *rot, int direction, int speed)
*/ */
const char* HAMLIB_API rot_get_info(ROT *rot) const char* HAMLIB_API rot_get_info(ROT *rot)
{ {
if (CHECK_ROT_ARG(rot)) if (CHECK_ROT_ARG(rot))
return NULL; return NULL;
if (rot->caps->get_info == NULL) if (rot->caps->get_info == NULL)
return NULL; return NULL;
return rot->caps->get_info(rot); return rot->caps->get_info(rot);
} }