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

Apply Linux C style 

Update files modified to support libusb-1.0.
libusb-1-0
Nate Bargmann 2016-02-21 14:56:44 -06:00
rodzic 07353e1f80
commit 6a3214fd43
7 zmienionych plików z 1669 dodań i 1474 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

320
kit/dwt.c
Wyświetl plik

@ -58,12 +58,11 @@
/* Some type definitions needed for dll access */
typedef enum _tFrontendMode
{
eFrontendModeUndefined = 0,
eFrontendModeDrm = 1,
eFrontendModeAm = 2,
eFrontendModeFm = 6,
typedef enum _tFrontendMode {
eFrontendModeUndefined = 0,
eFrontendModeDrm = 1,
eFrontendModeAm = 2,
eFrontendModeFm = 6,
} tFrontendMode;
typedef short (__stdcall *FNCFrontendOpen)(void);
@ -132,7 +131,7 @@ static int dwtdll_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width);
static int dwtdll_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width);
static int dwtdll_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val);
static int dwtdll_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val);
static const char * dwtdll_get_info(RIG *rig);
static const char *dwtdll_get_info(RIG *rig);
/*
* Coding Technologies Digital World Traveller DRM tuner.
@ -143,79 +142,79 @@ static const char * dwtdll_get_info(RIG *rig);
*/
const struct rig_caps dwt_caps = {
.rig_model = RIG_MODEL_DWT,
.model_name = "Digital World Traveller",
.mfg_name = "Coding Technologies",
.version = "0.1.1",
.copyright = "LGPL",
.status = RIG_STATUS_STABLE,
.rig_type = RIG_TYPE_PCRECEIVER,
.ptt_type = RIG_PTT_NONE,
.dcd_type = RIG_DCD_NONE,
.port_type = RIG_PORT_NONE,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 200,
.retry = 0,
.rig_model = RIG_MODEL_DWT,
.model_name = "Digital World Traveller",
.mfg_name = "Coding Technologies",
.version = "0.1.1",
.copyright = "LGPL",
.status = RIG_STATUS_STABLE,
.rig_type = RIG_TYPE_PCRECEIVER,
.ptt_type = RIG_PTT_NONE,
.dcd_type = RIG_DCD_NONE,
.port_type = RIG_PORT_NONE,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 200,
.retry = 0,
.has_get_func = DWT_FUNC,
.has_set_func = DWT_FUNC,
.has_get_level = DWT_LEVEL_ALL,
.has_set_level = RIG_LEVEL_SET(DWT_LEVEL_ALL),
.has_get_parm = DWT_PARM_ALL,
.has_set_parm = RIG_PARM_SET(DWT_PARM_ALL),
.level_gran = {},
.parm_gran = {},
.ctcss_list = NULL,
.dcs_list = NULL,
.preamp = { RIG_DBLST_END },
.attenuator = { 20, RIG_DBLST_END, }, /* TBC */
.max_rit = Hz(0),
.max_xit = Hz(0),
.max_ifshift = Hz(0),
.targetable_vfo = 0,
.transceive = RIG_TRN_OFF,
.bank_qty = 0,
.chan_desc_sz = 0,
.has_get_func = DWT_FUNC,
.has_set_func = DWT_FUNC,
.has_get_level = DWT_LEVEL_ALL,
.has_set_level = RIG_LEVEL_SET(DWT_LEVEL_ALL),
.has_get_parm = DWT_PARM_ALL,
.has_set_parm = RIG_PARM_SET(DWT_PARM_ALL),
.level_gran = {},
.parm_gran = {},
.ctcss_list = NULL,
.dcs_list = NULL,
.preamp = { RIG_DBLST_END },
.attenuator = { 20, RIG_DBLST_END, }, /* TBC */
.max_rit = Hz(0),
.max_xit = Hz(0),
.max_ifshift = Hz(0),
.targetable_vfo = 0,
.transceive = RIG_TRN_OFF,
.bank_qty = 0,
.chan_desc_sz = 0,
.chan_list = { RIG_CHAN_END, },
.chan_list = { RIG_CHAN_END, },
.rx_range_list1 = {
{kHz(150),MHz(30)-kHz(1),DWT_MODES,-1,-1,DWT_VFO,DWT_ANT},
{kHz(87.5),MHz(108),RIG_MODE_WFM,-1,-1,DWT_VFO,DWT_ANT},
RIG_FRNG_END,
},
.tx_range_list1 = { RIG_FRNG_END, },
.rx_range_list2 = {
{kHz(150),MHz(30)-kHz(1),DWT_MODES,-1,-1,DWT_VFO,DWT_ANT},
{kHz(87.5),MHz(108),RIG_MODE_WFM,-1,-1,DWT_VFO,DWT_ANT},
RIG_FRNG_END,
},
.tx_range_list2 = { RIG_FRNG_END, },
.tuning_steps = {
{DWT_MODES,1},
RIG_TS_END,
.rx_range_list1 = {
{kHz(150), MHz(30) - kHz(1), DWT_MODES, -1, -1, DWT_VFO, DWT_ANT},
{kHz(87.5), MHz(108), RIG_MODE_WFM, -1, -1, DWT_VFO, DWT_ANT},
RIG_FRNG_END,
},
/* mode/filter list, remember: order matters! */
.filters = {
.tx_range_list1 = { RIG_FRNG_END, },
.rx_range_list2 = {
{kHz(150), MHz(30) - kHz(1), DWT_MODES, -1, -1, DWT_VFO, DWT_ANT},
{kHz(87.5), MHz(108), RIG_MODE_WFM, -1, -1, DWT_VFO, DWT_ANT},
RIG_FRNG_END,
},
.tx_range_list2 = { RIG_FRNG_END, },
.tuning_steps = {
{DWT_MODES, 1},
RIG_TS_END,
},
/* mode/filter list, remember: order matters! */
.filters = {
{RIG_MODE_USB, kHz(22)}, /* FIXME */
{RIG_MODE_AM, kHz(9)}, /* FIXME */
{RIG_MODE_WFM, kHz(230)}, /* FIXME */
RIG_FLT_END,
},
.rig_init = dwtdll_init,
.rig_cleanup = dwtdll_cleanup,
.rig_open = dwtdll_open,
.rig_close = dwtdll_close,
.rig_init = dwtdll_init,
.rig_cleanup = dwtdll_cleanup,
.rig_open = dwtdll_open,
.rig_close = dwtdll_close,
.set_freq = dwtdll_set_freq,
.get_freq = dwtdll_get_freq,
.set_mode = dwtdll_set_mode,
.get_mode = dwtdll_get_mode,
.set_level = dwtdll_set_level,
.get_level = dwtdll_get_level,
.get_info = dwtdll_get_info,
.set_freq = dwtdll_set_freq,
.get_freq = dwtdll_get_freq,
.set_mode = dwtdll_set_mode,
.get_mode = dwtdll_get_mode,
.set_level = dwtdll_set_level,
.get_level = dwtdll_get_level,
.get_info = dwtdll_get_info,
};
@ -224,7 +223,8 @@ int dwtdll_init(RIG *rig)
{
struct dwtdll_priv_data *priv;
priv = (struct dwtdll_priv_data*)malloc(sizeof(struct dwtdll_priv_data));
priv = (struct dwtdll_priv_data *)malloc(sizeof(struct dwtdll_priv_data));
if (!priv) {
/* whoops! memory shortage! */
return -RIG_ENOMEM;
@ -235,7 +235,7 @@ int dwtdll_init(RIG *rig)
if (!priv->dll) {
rig_debug(RIG_DEBUG_ERR, "%s: Unable to LoadLibrary %s\n",
__func__, DWTDLL);
__func__, DWTDLL);
free(priv);
return -RIG_EIO; /* huh! */
}
@ -278,7 +278,7 @@ int dwtdll_init(RIG *rig)
priv->FrontendGetFmMode =
(FNCFrontendGetFmMode) GetProcAddress(priv->dll, "FrontendGetFmMode");
rig->state.priv = (void*)priv;
rig->state.priv = (void *)priv;
return RIG_OK;
}
@ -290,11 +290,13 @@ int dwtdll_open(RIG *rig)
/* Open DWT receiver */
ret = priv->FrontendOpen();
if (ret < 0)
return -RIG_EIO; /* huh! */
/* default to DRM mode */
ret = priv->FrontendSetMode(eFrontendModeDrm);
if (ret < 0)
return -RIG_EIO; /* huh! */
@ -308,6 +310,7 @@ int dwtdll_close(RIG *rig)
/* Open DWT receiver */
ret = priv->FrontendClose();
if (ret < 0)
return -RIG_EIO; /* huh! */
@ -323,6 +326,7 @@ int dwtdll_cleanup(RIG *rig)
if (rig->state.priv)
free(rig->state.priv);
rig->state.priv = NULL;
return RIG_OK;
@ -355,8 +359,11 @@ int dwtdll_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
switch (mode) {
case RIG_MODE_USB: dwtmode = eFrontendModeDrm; break;
case RIG_MODE_AM: dwtmode = eFrontendModeAm; break;
case RIG_MODE_WFM: dwtmode = eFrontendModeFm; break;
default:
return -RIG_EINVAL;
}
@ -375,11 +382,15 @@ int dwtdll_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
switch (dwtmode) {
case eFrontendModeDrm: *mode = RIG_MODE_USB; break;
case eFrontendModeAm: *mode = RIG_MODE_AM; break;
case eFrontendModeFm: *mode = RIG_MODE_WFM; break;
default:
return -RIG_EPROTO;
}
*width = rig_passband_normal(rig, *mode);
return RIG_OK;
@ -389,9 +400,9 @@ int dwtdll_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
int dwtdll_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
struct dwtdll_priv_data *priv = (struct dwtdll_priv_data *)rig->state.priv;
short ret=0;
short ret = 0;
switch(level) {
switch (level) {
case RIG_LEVEL_ATT:
ret = priv->FrontendSetRfAttenuator(val.i ? 1 : 0);
break;
@ -406,13 +417,15 @@ int dwtdll_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
int dwtdll_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
{
struct dwtdll_priv_data *priv = (struct dwtdll_priv_data *)rig->state.priv;
signed short ret=0;
signed short ret = 0;
switch(level) {
switch (level) {
case RIG_LEVEL_ATT:
ret = priv->FrontendGetRfAttenuator();
if (ret < 0)
break;
/* local vs. DX mode */
val->i = ret ? 0 : rig->caps->attenuator[0];
break;
@ -420,17 +433,21 @@ int dwtdll_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
case RIG_LEVEL_STRENGTH:
/* actual RMS signal strength in dBuV */
ret = priv->FrontendGetRfLevel();
if (ret < 0)
break;
/* return actual RMS signal strength in dBuV, -34 to get dB rel S9 */
/* return actual RMS signal strength in dBuV, -34 to get dB rel S9 */
val->i = ret - 34;
break;
case RIG_LEVEL_RAWSTR:
/* actual RMS signal strength in dBuV */
ret = priv->FrontendGetRfLevel();
if (ret < 0)
break;
val->i = ret;
break;
@ -442,7 +459,7 @@ int dwtdll_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
}
static const char* dwtdll_get_info(RIG *rig)
static const char *dwtdll_get_info(RIG *rig)
{
struct dwtdll_priv_data *priv = (struct dwtdll_priv_data *)rig->state.priv;
static char info[22];
@ -485,7 +502,7 @@ static const char* dwtdll_get_info(RIG *rig)
static int dwt_init(RIG *rig);
static int dwt_set_freq(RIG *rig, vfo_t vfo, freq_t freq);
static const char * dwt_get_info(RIG *rig);
static const char *dwt_get_info(RIG *rig);
/*
* Coding Technologies Digital World Traveller DRM tuner.
@ -496,77 +513,77 @@ static const char * dwt_get_info(RIG *rig);
*/
const struct rig_caps dwt_caps = {
.rig_model = RIG_MODEL_DWT,
.model_name = "Digital World Traveller",
.mfg_name = "Coding Technologies",
.version = "0.2",
.copyright = "LGPL",
.status = RIG_STATUS_UNTESTED,
.rig_type = RIG_TYPE_TUNER,
.ptt_type = RIG_PTT_NONE,
.dcd_type = RIG_DCD_NONE,
.port_type = RIG_PORT_USB,
.serial_rate_min = 9600, /* don't care */
.serial_rate_max = 9600,
.serial_data_bits = 8,
.serial_stop_bits = 1,
.serial_parity = RIG_PARITY_NONE,
.serial_handshake = RIG_HANDSHAKE_NONE,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 200,
.retry = 0,
.rig_model = RIG_MODEL_DWT,
.model_name = "Digital World Traveller",
.mfg_name = "Coding Technologies",
.version = "0.2",
.copyright = "LGPL",
.status = RIG_STATUS_UNTESTED,
.rig_type = RIG_TYPE_TUNER,
.ptt_type = RIG_PTT_NONE,
.dcd_type = RIG_DCD_NONE,
.port_type = RIG_PORT_USB,
.serial_rate_min = 9600, /* don't care */
.serial_rate_max = 9600,
.serial_data_bits = 8,
.serial_stop_bits = 1,
.serial_parity = RIG_PARITY_NONE,
.serial_handshake = RIG_HANDSHAKE_NONE,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 200,
.retry = 0,
.has_get_func = DWT_FUNC,
.has_set_func = DWT_FUNC,
.has_get_level = DWT_LEVEL_ALL,
.has_set_level = RIG_LEVEL_SET(DWT_LEVEL_ALL),
.has_get_parm = DWT_PARM_ALL,
.has_set_parm = RIG_PARM_SET(DWT_PARM_ALL),
.level_gran = {},
.parm_gran = {},
.ctcss_list = NULL,
.dcs_list = NULL,
.preamp = { RIG_DBLST_END },
.attenuator = { RIG_DBLST_END },
.max_rit = Hz(0),
.max_xit = Hz(0),
.max_ifshift = Hz(0),
.targetable_vfo = 0,
.transceive = RIG_TRN_OFF,
.bank_qty = 0,
.chan_desc_sz = 0,
.has_get_func = DWT_FUNC,
.has_set_func = DWT_FUNC,
.has_get_level = DWT_LEVEL_ALL,
.has_set_level = RIG_LEVEL_SET(DWT_LEVEL_ALL),
.has_get_parm = DWT_PARM_ALL,
.has_set_parm = RIG_PARM_SET(DWT_PARM_ALL),
.level_gran = {},
.parm_gran = {},
.ctcss_list = NULL,
.dcs_list = NULL,
.preamp = { RIG_DBLST_END },
.attenuator = { RIG_DBLST_END },
.max_rit = Hz(0),
.max_xit = Hz(0),
.max_ifshift = Hz(0),
.targetable_vfo = 0,
.transceive = RIG_TRN_OFF,
.bank_qty = 0,
.chan_desc_sz = 0,
.chan_list = { RIG_CHAN_END, },
.chan_list = { RIG_CHAN_END, },
.rx_range_list1 = {
{kHz(150),MHz(30)-kHz(1),DWT_MODES,-1,-1,DWT_VFO},
{kHz(87.5),MHz(108),RIG_MODE_WFM,-1,-1,DWT_VFO},
RIG_FRNG_END,
},
.tx_range_list1 = { RIG_FRNG_END, },
.rx_range_list2 = {
{kHz(150),MHz(30)-kHz(1),DWT_MODES,-1,-1,DWT_VFO},
{kHz(87.5),MHz(108),RIG_MODE_WFM,-1,-1,DWT_VFO},
RIG_FRNG_END,
},
.tx_range_list2 = { RIG_FRNG_END, },
.tuning_steps = {
{DWT_MODES,kHz(1)},
RIG_TS_END,
.rx_range_list1 = {
{kHz(150), MHz(30) - kHz(1), DWT_MODES, -1, -1, DWT_VFO},
{kHz(87.5), MHz(108), RIG_MODE_WFM, -1, -1, DWT_VFO},
RIG_FRNG_END,
},
/* mode/filter list, remember: order matters! */
.filters = {
.tx_range_list1 = { RIG_FRNG_END, },
.rx_range_list2 = {
{kHz(150), MHz(30) - kHz(1), DWT_MODES, -1, -1, DWT_VFO},
{kHz(87.5), MHz(108), RIG_MODE_WFM, -1, -1, DWT_VFO},
RIG_FRNG_END,
},
.tx_range_list2 = { RIG_FRNG_END, },
.tuning_steps = {
{DWT_MODES, kHz(1)},
RIG_TS_END,
},
/* mode/filter list, remember: order matters! */
.filters = {
{RIG_MODE_USB, kHz(22)}, /* FIXME */
{RIG_MODE_AM, kHz(9)}, /* FIXME */
{RIG_MODE_WFM, kHz(230)}, /* FIXME */
RIG_FLT_END,
},
.rig_init = dwt_init,
.rig_init = dwt_init,
.set_freq = dwt_set_freq,
.get_info = dwt_get_info,
.set_freq = dwt_set_freq,
.get_info = dwt_get_info,
};
@ -591,23 +608,24 @@ int dwt_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
int request, value, index;
unsigned char buf[MSG_LEN] = { 0x4a, 0x00, 0x03, 0x00, 0xff, 0xff, 0x32 };
int requesttype, r;
int ifreq = (int)(freq/1000);
int ifreq = (int)(freq / 1000);
/* FIXME */
requesttype = 0x00;
request = 0x00;
value = 0x00;
index = 0x00;
requesttype = 0x00;
request = 0x00;
value = 0x00;
index = 0x00;
buf[8] = ifreq & 0xff;
buf[7] = (ifreq>>8) & 0xff;
buf[7] = (ifreq >> 8) & 0xff;
r = libusb_control_transfer(udh, requesttype, request, value, index,
buf, 9, 1000);
r = libusb_control_transfer (udh, requesttype, request, value, index,
buf, 9, 1000);
if (r < 0) {
rig_debug (RIG_DEBUG_ERR,
"libusb_control_transfer failed: %s\n",
libusb_error_name (r));
rig_debug(RIG_DEBUG_ERR,
"libusb_control_transfer failed: %s\n",
libusb_error_name(r));
return -RIG_EIO;
}
@ -615,7 +633,7 @@ int dwt_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
}
/* Rem: not reentrant */
const char * dwt_get_info(RIG *rig)
const char *dwt_get_info(RIG *rig)
{
static char buf[64];
libusb_device_handle *udh = rig->state.rigport.handle;

595
kit/elektor507.c
Wyświetl plik

Plik diff jest za duży Load Diff

469
kit/fifisdr.c
Wyświetl plik

@ -91,7 +91,7 @@ static int fifisdr_set_freq(RIG *rig, vfo_t vfo, freq_t freq);
static int fifisdr_get_freq(RIG *rig, vfo_t vfo, freq_t *freq);
static const char *fifisdr_get_info(RIG *rig);
static int fifisdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width);
static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t * width);
static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width);
static int fifisdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val);
static int fifisdr_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val);
static int fifisdr_get_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t *val);
@ -105,7 +105,8 @@ static int fifisdr_get_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t *va
/* Extra levels definitions */
static const struct confparams fifisdr_ext_levels[] = {
{ TOK_LVL_FMCENTER, "fmcenter", "FM center", "Center frequency deviation of FM signal",
{
TOK_LVL_FMCENTER, "fmcenter", "FM center", "Center frequency deviation of FM signal",
NULL, RIG_CONF_NUMERIC, { .n = { -kHz(5), kHz(5), Hz(1) } }
},
{ RIG_CONF_END, NULL, }
@ -169,18 +170,22 @@ const struct rig_caps fifisdr_caps = {
},
.rx_range_list1 = {
{.start = kHz(39.1), .end = MHz(175.0),
.modes = RIG_MODE_AM | RIG_MODE_SSB | RIG_MODE_FM,
.low_power = -1, .high_power = -1,
.vfo = RIG_VFO_A, .ant = RIG_ANT_1},
{
.start = kHz(39.1), .end = MHz(175.0),
.modes = RIG_MODE_AM | RIG_MODE_SSB | RIG_MODE_FM,
.low_power = -1, .high_power = -1,
.vfo = RIG_VFO_A, .ant = RIG_ANT_1
},
RIG_FRNG_END,
},
.tx_range_list1 = { RIG_FRNG_END, },
.rx_range_list2 = {
{.start = kHz(39.1), .end = MHz(175.0),
.modes = RIG_MODE_AM | RIG_MODE_SSB | RIG_MODE_FM,
.low_power = -1, .high_power = -1,
.vfo = RIG_VFO_A, .ant = RIG_ANT_1},
{
.start = kHz(39.1), .end = MHz(175.0),
.modes = RIG_MODE_AM | RIG_MODE_SSB | RIG_MODE_FM,
.low_power = -1, .high_power = -1,
.vfo = RIG_VFO_A, .ant = RIG_ANT_1
},
RIG_FRNG_END,
},
.tx_range_list2 = { RIG_FRNG_END, },
@ -239,7 +244,7 @@ const struct rig_caps fifisdr_caps = {
/** Convert from host endianness to FiFi-SDR little endian. */
static uint32_t fifisdr_tole32 (uint32_t x)
static uint32_t fifisdr_tole32(uint32_t x)
{
return
(((((x) / 1ul) % 256ul) << 0) |
@ -251,7 +256,7 @@ static uint32_t fifisdr_tole32 (uint32_t x)
/** Convert FiFi-SDR little endian to host endianness. */
static uint32_t fifisdr_fromle32 (uint32_t x)
static uint32_t fifisdr_fromle32(uint32_t x)
{
return
(((((x) >> 24) & 0xFF) * 16777216ul) +
@ -263,22 +268,22 @@ static uint32_t fifisdr_fromle32 (uint32_t x)
/** USB OUT transfer via vendor device command. */
static int fifisdr_usb_write (RIG *rig,
int request, int value, int index,
unsigned char *bytes, int size)
static int fifisdr_usb_write(RIG *rig,
int request, int value, int index,
unsigned char *bytes, int size)
{
int ret;
libusb_device_handle *udh = rig->state.rigport.handle;
ret = libusb_control_transfer(udh, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT,
request, value, index,
bytes, size, rig->state.rigport.timeout);
request, value, index,
bytes, size, rig->state.rigport.timeout);
if (ret != size) {
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer (%d/%d) failed: %s\n",
__func__,
request, value,
libusb_error_name (ret));
rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer (%d/%d) failed: %s\n",
__func__,
request, value,
libusb_error_name(ret));
return -RIG_EIO;
}
@ -288,22 +293,22 @@ static int fifisdr_usb_write (RIG *rig,
/** USB IN transfer via vendor device command. */
static int fifisdr_usb_read (RIG *rig,
int request, int value, int index,
unsigned char *bytes, int size)
static int fifisdr_usb_read(RIG *rig,
int request, int value, int index,
unsigned char *bytes, int size)
{
int ret;
libusb_device_handle *udh = rig->state.rigport.handle;
ret = libusb_control_transfer(udh, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_IN,
request, value, index,
bytes, size, rig->state.rigport.timeout);
request, value, index,
bytes, size, rig->state.rigport.timeout);
if (ret != size) {
rig_debug (RIG_DEBUG_ERR, "%s: libusb_control_transfer (%d/%d) failed: %s\n",
__func__,
request, value,
libusb_error_name (ret));
rig_debug(RIG_DEBUG_ERR, "%s: libusb_control_transfer (%d/%d) failed: %s\n",
__func__,
request, value,
libusb_error_name(ret));
return -RIG_EIO;
}
@ -312,12 +317,13 @@ static int fifisdr_usb_read (RIG *rig,
int fifisdr_init (RIG *rig)
int fifisdr_init(RIG *rig)
{
hamlib_port_t *rp = &rig->state.rigport;
struct fifisdr_priv_instance_data *priv;
priv = (struct fifisdr_priv_instance_data*)calloc(sizeof(struct fifisdr_priv_instance_data), 1);
priv = (struct fifisdr_priv_instance_data *)calloc(sizeof(struct fifisdr_priv_instance_data), 1);
if (!priv) {
/* whoops! memory shortage! */
return -RIG_ENOMEM;
@ -336,20 +342,21 @@ int fifisdr_init (RIG *rig)
rp->parm.usb.vendor_name = FIFISDR_VENDOR_NAME;
rp->parm.usb.product = FIFISDR_PRODUCT_NAME;
rig->state.priv = (void*)priv;
rig->state.priv = (void *)priv;
return RIG_OK;
}
int fifisdr_cleanup (RIG *rig)
int fifisdr_cleanup(RIG *rig)
{
if (!rig)
return -RIG_EINVAL;
if (rig->state.priv)
free(rig->state.priv);
rig->state.priv = NULL;
return RIG_OK;
@ -357,19 +364,20 @@ int fifisdr_cleanup (RIG *rig)
int fifisdr_open (RIG *rig)
int fifisdr_open(RIG *rig)
{
int ret;
uint32_t multiply;
struct fifisdr_priv_instance_data *priv;
priv = (struct fifisdr_priv_instance_data*)rig->state.priv;
priv = (struct fifisdr_priv_instance_data *)rig->state.priv;
/* The VCO is a multiple of the RX frequency. Typically 4 */
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
11, /* Read virtual VCO factor */
(unsigned char *)&multiply, sizeof(multiply));
11, /* Read virtual VCO factor */
(unsigned char *)&multiply, sizeof(multiply));
if (ret == RIG_OK) {
priv->multiplier = fifisdr_fromle32(multiply);
}
@ -379,13 +387,14 @@ int fifisdr_open (RIG *rig)
const char * fifisdr_get_info (RIG *rig)
const char *fifisdr_get_info(RIG *rig)
{
static char buf[64];
int ret;
uint32_t svn_version;
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0, 0, (unsigned char *)&svn_version, sizeof(svn_version));
if (ret != RIG_OK) {
return NULL;
}
@ -397,7 +406,7 @@ const char * fifisdr_get_info (RIG *rig)
int fifisdr_set_freq (RIG *rig, vfo_t vfo, freq_t freq)
int fifisdr_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
struct fifisdr_priv_instance_data *priv = (struct fifisdr_priv_instance_data *)rig->state.priv;
int ret;
@ -410,7 +419,8 @@ int fifisdr_set_freq (RIG *rig, vfo_t vfo, freq_t freq)
freq1121 = fifisdr_tole32(round(mhz * 2097152.0));
ret = fifisdr_usb_write(rig, REQUEST_SET_FREQ_BY_VALUE, 0, 0,
(unsigned char *)&freq1121, sizeof(freq1121));
(unsigned char *)&freq1121, sizeof(freq1121));
if (ret != RIG_OK) {
return -RIG_EIO;
}
@ -420,7 +430,7 @@ int fifisdr_set_freq (RIG *rig, vfo_t vfo, freq_t freq)
int fifisdr_get_freq (RIG *rig, vfo_t vfo, freq_t *freq)
int fifisdr_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{
struct fifisdr_priv_instance_data *priv = (struct fifisdr_priv_instance_data *)rig->state.priv;
int ret;
@ -447,25 +457,32 @@ static int fifisdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
/* Translate mode into FiFi-SDR language */
fifi_mode = 0;
switch (mode) {
case RIG_MODE_AM:
fifi_mode = 2;
break;
case RIG_MODE_LSB:
fifi_mode = 0;
break;
case RIG_MODE_USB:
fifi_mode = 1;
break;
case RIG_MODE_FM:
fifi_mode = 3;
break;
default:
return -RIG_EINVAL;
case RIG_MODE_AM:
fifi_mode = 2;
break;
case RIG_MODE_LSB:
fifi_mode = 0;
break;
case RIG_MODE_USB:
fifi_mode = 1;
break;
case RIG_MODE_FM:
fifi_mode = 3;
break;
default:
return -RIG_EINVAL;
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
15, /* Demodulator mode */
(unsigned char *)&fifi_mode, sizeof(fifi_mode));
15, /* Demodulator mode */
(unsigned char *)&fifi_mode, sizeof(fifi_mode));
if (ret != RIG_OK) {
return -RIG_EIO;
}
@ -473,8 +490,9 @@ static int fifisdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
/* Set filter width */
fifi_width = fifisdr_tole32(width);
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
16, /* Filter width */
(unsigned char *)&fifi_width, sizeof(fifi_width));
16, /* Filter width */
(unsigned char *)&fifi_width, sizeof(fifi_width));
if (ret != RIG_OK) {
return -RIG_EIO;
}
@ -484,7 +502,7 @@ static int fifisdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t * width)
static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
{
int ret;
uint8_t fifi_mode;
@ -493,8 +511,8 @@ static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t * widt
/* Read current mode */
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
15, /* Demodulator mode */
(unsigned char *)&fifi_mode, sizeof(fifi_mode));
15, /* Demodulator mode */
(unsigned char *)&fifi_mode, sizeof(fifi_mode));
if (ret != RIG_OK) {
return -RIG_EIO;
@ -502,25 +520,30 @@ static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t * widt
/* Translate mode coding */
*mode = RIG_MODE_NONE;
switch (fifi_mode) {
case 0:
*mode = RIG_MODE_LSB;
break;
case 1:
*mode = RIG_MODE_USB;
break;
case 2:
*mode = RIG_MODE_AM;
break;
case 3:
*mode = RIG_MODE_FM;
break;
case 0:
*mode = RIG_MODE_LSB;
break;
case 1:
*mode = RIG_MODE_USB;
break;
case 2:
*mode = RIG_MODE_AM;
break;
case 3:
*mode = RIG_MODE_FM;
break;
}
/* Read current filter width */
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
16, /* Filter width */
(unsigned char *)&fifi_width, sizeof(fifi_width));
16, /* Filter width */
(unsigned char *)&fifi_width, sizeof(fifi_width));
if (ret != RIG_OK) {
return -RIG_EIO;
}
@ -532,7 +555,7 @@ static int fifisdr_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t * widt
static int fifisdr_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val)
static int fifisdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{
int ret = RIG_OK;
uint8_t fifi_preamp;
@ -542,69 +565,85 @@ static int fifisdr_set_level (RIG * rig, vfo_t vfo, setting_t level, value_t val
switch (level) {
/* Preamplifier (ADC 0/+6dB switch) */
case RIG_LEVEL_PREAMP:
/* Value can be 0 (0 dB) or 1 (+6 dB) */
fifi_preamp = 0;
if (val.i == 6) {
fifi_preamp = 1;
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
19, /* Preamp */
(unsigned char *)&fifi_preamp, sizeof(fifi_preamp));
/* Preamplifier (ADC 0/+6dB switch) */
case RIG_LEVEL_PREAMP:
/* Value can be 0 (0 dB) or 1 (+6 dB) */
fifi_preamp = 0;
if (val.i == 6) {
fifi_preamp = 1;
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
19, /* Preamp */
(unsigned char *)&fifi_preamp, sizeof(fifi_preamp));
break;
/* RX volume control */
case RIG_LEVEL_AF:
/* Transform Hamlib value (float: 0...1) to an integer range (0...100) */
fifi_volume = (int16_t)(val.f * 100.0f);
if (fifi_volume < 0) {
fifi_volume = 0;
}
if (fifi_volume > 100) {
fifi_volume = 100;
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
14, /* Demodulator volume */
(unsigned char *)&fifi_volume, sizeof(fifi_volume));
/* RX volume control */
case RIG_LEVEL_AF:
/* Transform Hamlib value (float: 0...1) to an integer range (0...100) */
fifi_volume = (int16_t)(val.f * 100.0f);
if (fifi_volume < 0) {
fifi_volume = 0;
}
if (fifi_volume > 100) {
fifi_volume = 100;
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
14, /* Demodulator volume */
(unsigned char *)&fifi_volume, sizeof(fifi_volume));
break;
/* Squelch level */
case RIG_LEVEL_SQL:
/* Transform Hamlib value (float: 0...1) to an integer range (0...100) */
fifi_squelch = (uint8_t)(val.f * 100.0f);
if (fifi_squelch < 0) {
fifi_squelch = 0;
}
if (fifi_squelch > 100) {
fifi_squelch = 100;
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
20, /* Squelch control */
(unsigned char *)&fifi_squelch, sizeof(fifi_squelch));
/* Squelch level */
case RIG_LEVEL_SQL:
/* Transform Hamlib value (float: 0...1) to an integer range (0...100) */
fifi_squelch = (uint8_t)(val.f * 100.0f);
if (fifi_squelch < 0) {
fifi_squelch = 0;
}
if (fifi_squelch > 100) {
fifi_squelch = 100;
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
20, /* Squelch control */
(unsigned char *)&fifi_squelch, sizeof(fifi_squelch));
break;
/* AGC */
case RIG_LEVEL_AGC:
/* Transform Hamlib enum value to FiFi-SDR selector */
fifi_agc = 0;
switch ((enum agc_level_e)val.i) {
case RIG_AGC_OFF: fifi_agc = 0; break;
case RIG_AGC_SUPERFAST: fifi_agc = 1; break;
case RIG_AGC_FAST: fifi_agc = 2; break;
case RIG_AGC_SLOW: fifi_agc = 3; break;
case RIG_AGC_USER: fifi_agc = 4; break;
case RIG_AGC_MEDIUM: fifi_agc = 5; break;
case RIG_AGC_AUTO: fifi_agc = 6; break;
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
21, /* AGC template */
(unsigned char *)&fifi_agc, sizeof(fifi_agc));
/* AGC */
case RIG_LEVEL_AGC:
/* Transform Hamlib enum value to FiFi-SDR selector */
fifi_agc = 0;
switch ((enum agc_level_e)val.i) {
case RIG_AGC_OFF: fifi_agc = 0; break;
case RIG_AGC_SUPERFAST: fifi_agc = 1; break;
case RIG_AGC_FAST: fifi_agc = 2; break;
case RIG_AGC_SLOW: fifi_agc = 3; break;
case RIG_AGC_USER: fifi_agc = 4; break;
case RIG_AGC_MEDIUM: fifi_agc = 5; break;
case RIG_AGC_AUTO: fifi_agc = 6; break;
}
ret = fifisdr_usb_write(rig, REQUEST_FIFISDR_WRITE, 0,
21, /* AGC template */
(unsigned char *)&fifi_agc, sizeof(fifi_agc));
break;
/* Unsupported option */
default:
ret = -RIG_ENIMPL;
/* Unsupported option */
default:
ret = -RIG_ENIMPL;
}
return ret;
@ -623,80 +662,100 @@ static int fifisdr_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
switch (level) {
/* Preamplifier (ADC 0/+6dB switch) */
case RIG_LEVEL_PREAMP:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
19, /* Preamp */
(unsigned char *)&fifi_preamp, sizeof(fifi_preamp));
if (ret == RIG_OK) {
/* Value can be 0 (0 dB) or 1 (+6 dB) */
val->i = 0;
if (fifi_preamp != 0) {
val->i = 6;
}
/* Preamplifier (ADC 0/+6dB switch) */
case RIG_LEVEL_PREAMP:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
19, /* Preamp */
(unsigned char *)&fifi_preamp, sizeof(fifi_preamp));
if (ret == RIG_OK) {
/* Value can be 0 (0 dB) or 1 (+6 dB) */
val->i = 0;
if (fifi_preamp != 0) {
val->i = 6;
}
}
break;
/* RX volume control */
case RIG_LEVEL_AF:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
14, /* Demodulator volume */
(unsigned char *)&fifi_volume, sizeof(fifi_volume));
if (ret == RIG_OK) {
/* Value is in % (0...100) */
val->f = 0.0f;
if ((fifi_volume >=0) && (fifi_volume <= 100)) {
val->f = (float)fifi_volume / 100.0f;
}
/* RX volume control */
case RIG_LEVEL_AF:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
14, /* Demodulator volume */
(unsigned char *)&fifi_volume, sizeof(fifi_volume));
if (ret == RIG_OK) {
/* Value is in % (0...100) */
val->f = 0.0f;
if ((fifi_volume >= 0) && (fifi_volume <= 100)) {
val->f = (float)fifi_volume / 100.0f;
}
}
break;
/* Squelch level */
case RIG_LEVEL_SQL:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
20, /* Squelch control */
(unsigned char *)&fifi_squelch, sizeof(fifi_squelch));
if (ret == RIG_OK) {
/* Value is in % (0...100) */
val->f = 0.0f;
if (fifi_squelch <= 100) {
val->f = (float)fifi_squelch / 100.0f;
}
/* Squelch level */
case RIG_LEVEL_SQL:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
20, /* Squelch control */
(unsigned char *)&fifi_squelch, sizeof(fifi_squelch));
if (ret == RIG_OK) {
/* Value is in % (0...100) */
val->f = 0.0f;
if (fifi_squelch <= 100) {
val->f = (float)fifi_squelch / 100.0f;
}
}
break;
/* AGC */
case RIG_LEVEL_AGC:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
21, /* AGC template */
(unsigned char *)&fifi_agc, sizeof(fifi_agc));
if (ret == RIG_OK) {
val->i = 0;
switch (fifi_agc) {
case 0: val->i = RIG_AGC_OFF; break;
case 1: val->i = RIG_AGC_SUPERFAST; break;
case 2: val->i = RIG_AGC_FAST; break;
case 3: val->i = RIG_AGC_SLOW; break;
case 4: val->i = RIG_AGC_USER; break;
case 5: val->i = RIG_AGC_MEDIUM; break;
case 6: val->i = RIG_AGC_AUTO; break;
}
/* AGC */
case RIG_LEVEL_AGC:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
21, /* AGC template */
(unsigned char *)&fifi_agc, sizeof(fifi_agc));
if (ret == RIG_OK) {
val->i = 0;
switch (fifi_agc) {
case 0: val->i = RIG_AGC_OFF; break;
case 1: val->i = RIG_AGC_SUPERFAST; break;
case 2: val->i = RIG_AGC_FAST; break;
case 3: val->i = RIG_AGC_SLOW; break;
case 4: val->i = RIG_AGC_USER; break;
case 5: val->i = RIG_AGC_MEDIUM; break;
case 6: val->i = RIG_AGC_AUTO; break;
}
}
break;
/* Signal strength */
case RIG_LEVEL_STRENGTH:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
17, /* S-Meter */
(unsigned char *)&fifi_meter, sizeof(fifi_meter));
if (ret == RIG_OK) {
val->i = fifisdr_fromle32(fifi_meter);
}
/* Signal strength */
case RIG_LEVEL_STRENGTH:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
17, /* S-Meter */
(unsigned char *)&fifi_meter, sizeof(fifi_meter));
if (ret == RIG_OK) {
val->i = fifisdr_fromle32(fifi_meter);
}
break;
/* Unsupported option */
default:
ret = -RIG_ENIMPL;
/* Unsupported option */
default:
ret = -RIG_ENIMPL;
}
return ret;
@ -711,19 +770,21 @@ static int fifisdr_get_ext_level(RIG *rig, vfo_t vfo, token_t token, value_t *va
switch (token) {
/* FM center frequency deviation */
case TOK_LVL_FMCENTER:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
18, /* FM center frequency */
(unsigned char *)&u32, sizeof(u32));
if (ret == RIG_OK) {
val->f = Hz((int32_t)fifisdr_fromle32(u32));
}
/* FM center frequency deviation */
case TOK_LVL_FMCENTER:
ret = fifisdr_usb_read(rig, REQUEST_FIFISDR_READ, 0,
18, /* FM center frequency */
(unsigned char *)&u32, sizeof(u32));
if (ret == RIG_OK) {
val->f = Hz((int32_t)fifisdr_fromle32(u32));
}
break;
/* Unsupported option */
default:
ret = -RIG_ENIMPL;
/* Unsupported option */
default:
ret = -RIG_ENIMPL;
}
return ret;

586
kit/funcube.c
Wyświetl plik

@ -88,126 +88,126 @@ struct funcube_priv_data {
*/
const struct rig_caps funcube_caps = {
.rig_model = RIG_MODEL_FUNCUBEDONGLE,
.model_name = "FUNcube Dongle",
.mfg_name = "AMSAT-UK",
.version = "0.3",
.copyright = "GPL",
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TUNER,
.ptt_type = RIG_PTT_RIG,
.dcd_type = RIG_DCD_NONE,
.port_type = RIG_PORT_USB,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 1000,
.retry = 0,
.rig_model = RIG_MODEL_FUNCUBEDONGLE,
.model_name = "FUNcube Dongle",
.mfg_name = "AMSAT-UK",
.version = "0.3",
.copyright = "GPL",
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TUNER,
.ptt_type = RIG_PTT_RIG,
.dcd_type = RIG_DCD_NONE,
.port_type = RIG_PORT_USB,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 1000,
.retry = 0,
.has_get_func = RIG_FUNC_NONE,
.has_set_func = RIG_FUNC_NONE,
.has_get_level = RIG_LEVEL_ATT | RIG_LEVEL_STRENGTH | RIG_LEVEL_PREAMP,
.has_set_level = RIG_LEVEL_ATT | RIG_LEVEL_PREAMP,
.has_get_parm = RIG_PARM_NONE,
.has_set_parm = RIG_PARM_NONE,
.level_gran = {},
.parm_gran = {},
.ctcss_list = NULL,
.dcs_list = NULL,
.preamp = { 5, 10, 15, 20, 25, 30, RIG_DBLST_END, },
.attenuator = { 2, 5, RIG_DBLST_END, },
.max_rit = Hz(0),
.max_xit = Hz(0),
.max_ifshift = Hz(0),
.targetable_vfo = 0,
.transceive = RIG_TRN_OFF,
.bank_qty = 0,
.chan_desc_sz = 0,
.has_get_func = RIG_FUNC_NONE,
.has_set_func = RIG_FUNC_NONE,
.has_get_level = RIG_LEVEL_ATT | RIG_LEVEL_STRENGTH | RIG_LEVEL_PREAMP,
.has_set_level = RIG_LEVEL_ATT | RIG_LEVEL_PREAMP,
.has_get_parm = RIG_PARM_NONE,
.has_set_parm = RIG_PARM_NONE,
.level_gran = {},
.parm_gran = {},
.ctcss_list = NULL,
.dcs_list = NULL,
.preamp = { 5, 10, 15, 20, 25, 30, RIG_DBLST_END, },
.attenuator = { 2, 5, RIG_DBLST_END, },
.max_rit = Hz(0),
.max_xit = Hz(0),
.max_ifshift = Hz(0),
.targetable_vfo = 0,
.transceive = RIG_TRN_OFF,
.bank_qty = 0,
.chan_desc_sz = 0,
.chan_list = { RIG_CHAN_END, },
.chan_list = { RIG_CHAN_END, },
.rx_range_list1 = {
{MHz(50),MHz(2500),RIG_MODE_USB,-1,-1,RIG_VFO_A},
RIG_FRNG_END,
},
.tuning_steps = {
{RIG_MODE_USB,kHz(1)},
RIG_TS_END,
.rx_range_list1 = {
{MHz(50), MHz(2500), RIG_MODE_USB, -1, -1, RIG_VFO_A},
RIG_FRNG_END,
},
.filters = {
{RIG_MODE_USB, kHz(192)},
RIG_FLT_END,
},
.cfgparams = funcube_cfg_params,
.tuning_steps = {
{RIG_MODE_USB, kHz(1)},
RIG_TS_END,
},
.filters = {
{RIG_MODE_USB, kHz(192)},
RIG_FLT_END,
},
.cfgparams = funcube_cfg_params,
.rig_init = funcube_init,
.rig_cleanup = funcube_cleanup,
.set_freq = funcube_set_freq,
.get_freq = funcube_get_freq,
.get_level = funcube_get_level,
.set_level = funcube_set_level,
.get_info = funcube_get_info,
.rig_init = funcube_init,
.rig_cleanup = funcube_cleanup,
.set_freq = funcube_set_freq,
.get_freq = funcube_get_freq,
.get_level = funcube_get_level,
.set_level = funcube_set_level,
.get_info = funcube_get_info,
};
const struct rig_caps funcubeplus_caps = {
.rig_model = RIG_MODEL_FUNCUBEDONGLEPLUS,
.model_name = "FUNcube Dongle Pro+",
.mfg_name = "AMSAT-UK",
.version = "0.3",
.copyright = "GPL",
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TUNER,
.ptt_type = RIG_PTT_RIG,
.dcd_type = RIG_DCD_NONE,
.port_type = RIG_PORT_USB,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 1000,
.retry = 0,
.rig_model = RIG_MODEL_FUNCUBEDONGLEPLUS,
.model_name = "FUNcube Dongle Pro+",
.mfg_name = "AMSAT-UK",
.version = "0.3",
.copyright = "GPL",
.status = RIG_STATUS_BETA,
.rig_type = RIG_TYPE_TUNER,
.ptt_type = RIG_PTT_RIG,
.dcd_type = RIG_DCD_NONE,
.port_type = RIG_PORT_USB,
.write_delay = 0,
.post_write_delay = 0,
.timeout = 1000,
.retry = 0,
.has_get_func = RIG_FUNC_NONE,
.has_set_func = RIG_FUNC_NONE,
.has_get_level = RIG_LEVEL_ATT | RIG_LEVEL_STRENGTH | RIG_LEVEL_PREAMP,
.has_set_level = RIG_LEVEL_ATT | RIG_LEVEL_PREAMP,
.has_get_parm = RIG_PARM_NONE,
.has_set_parm = RIG_PARM_NONE,
.level_gran = {},
.parm_gran = {},
.ctcss_list = NULL,
.dcs_list = NULL,
.preamp = { 5, 10, 15, 20, 25, 30, RIG_DBLST_END, },
.attenuator = { 2, 5, RIG_DBLST_END, },
.max_rit = Hz(0),
.max_xit = Hz(0),
.max_ifshift = Hz(0),
.targetable_vfo = 0,
.transceive = RIG_TRN_OFF,
.bank_qty = 0,
.chan_desc_sz = 0,
.has_get_func = RIG_FUNC_NONE,
.has_set_func = RIG_FUNC_NONE,
.has_get_level = RIG_LEVEL_ATT | RIG_LEVEL_STRENGTH | RIG_LEVEL_PREAMP,
.has_set_level = RIG_LEVEL_ATT | RIG_LEVEL_PREAMP,
.has_get_parm = RIG_PARM_NONE,
.has_set_parm = RIG_PARM_NONE,
.level_gran = {},
.parm_gran = {},
.ctcss_list = NULL,
.dcs_list = NULL,
.preamp = { 5, 10, 15, 20, 25, 30, RIG_DBLST_END, },
.attenuator = { 2, 5, RIG_DBLST_END, },
.max_rit = Hz(0),
.max_xit = Hz(0),
.max_ifshift = Hz(0),
.targetable_vfo = 0,
.transceive = RIG_TRN_OFF,
.bank_qty = 0,
.chan_desc_sz = 0,
.chan_list = { RIG_CHAN_END, },
.chan_list = { RIG_CHAN_END, },
.rx_range_list1 = {
{kHz(150),MHz(1900),RIG_MODE_USB,-1,-1,RIG_VFO_A},
RIG_FRNG_END,
},
.tuning_steps = {
{RIG_MODE_USB,kHz(1)},
RIG_TS_END,
.rx_range_list1 = {
{kHz(150), MHz(1900), RIG_MODE_USB, -1, -1, RIG_VFO_A},
RIG_FRNG_END,
},
.filters = {
{RIG_MODE_USB, kHz(192)},
RIG_FLT_END,
},
.cfgparams = funcube_cfg_params,
.tuning_steps = {
{RIG_MODE_USB, kHz(1)},
RIG_TS_END,
},
.filters = {
{RIG_MODE_USB, kHz(192)},
RIG_FLT_END,
},
.cfgparams = funcube_cfg_params,
.rig_init = funcubeplus_init,
.rig_cleanup = funcube_cleanup,
.set_freq = funcube_set_freq,
.get_freq = funcube_get_freq,
.get_level = funcube_get_level,
.set_level = funcube_set_level,
.get_info = funcube_get_info,
.rig_init = funcubeplus_init,
.rig_cleanup = funcube_cleanup,
.set_freq = funcube_set_freq,
.get_freq = funcube_get_freq,
.get_level = funcube_get_level,
.set_level = funcube_set_level,
.get_info = funcube_get_info,
};
int funcube_init(RIG *rig)
@ -215,7 +215,8 @@ int funcube_init(RIG *rig)
hamlib_port_t *rp = &rig->state.rigport;
struct funcube_priv_data *priv;
priv = (struct funcube_priv_data*)calloc(sizeof(struct funcube_priv_data), 1);
priv = (struct funcube_priv_data *)calloc(sizeof(struct funcube_priv_data), 1);
if (!priv) {
/* whoops! memory shortage! */
return -RIG_ENOMEM;
@ -232,7 +233,7 @@ int funcube_init(RIG *rig)
rp->parm.usb.vendor_name = VENDOR_NAME;
rp->parm.usb.product = PRODUCT_NAME;
rig->state.priv = (void*)priv;
rig->state.priv = (void *)priv;
return RIG_OK;
}
@ -242,7 +243,8 @@ int funcubeplus_init(RIG *rig)
hamlib_port_t *rp = &rig->state.rigport;
struct funcube_priv_data *priv;
priv = (struct funcube_priv_data*)calloc(sizeof(struct funcube_priv_data), 1);
priv = (struct funcube_priv_data *)calloc(sizeof(struct funcube_priv_data), 1);
if (!priv) {
/* whoops! memory shortage! */
return -RIG_ENOMEM;
@ -259,7 +261,7 @@ int funcubeplus_init(RIG *rig)
rp->parm.usb.vendor_name = VENDOR_NAME;
rp->parm.usb.product = PRODUCT_NAMEPLUS;
rig->state.priv = (void*)priv;
rig->state.priv = (void *)priv;
return RIG_OK;
}
@ -271,13 +273,14 @@ int funcube_cleanup(RIG *rig)
if (rig->state.priv)
free(rig->state.priv);
rig->state.priv = NULL;
return RIG_OK;
}
/* Rem: not reentrant */
const char * funcube_get_info(RIG *rig)
const char *funcube_get_info(RIG *rig)
{
static char buf[64];
libusb_device_handle *udh = rig->state.rigport.handle;
@ -302,38 +305,36 @@ int set_freq_v0(libusb_device_handle *udh, unsigned int f, int timeout)
// frequency is in Hz, while the dongle expects it in kHz
f = f / 1000;
au8BufOut[0]=REQUEST_SET_FREQ; // Command to Set Frequency on dongle
au8BufOut[1]=(unsigned char)f;
au8BufOut[2]=(unsigned char)(f>>8);
au8BufOut[3]=(unsigned char)(f>>16);
au8BufOut[0] = REQUEST_SET_FREQ; // Command to Set Frequency on dongle
au8BufOut[1] = (unsigned char)f;
au8BufOut[2] = (unsigned char)(f >> 8);
au8BufOut[3] = (unsigned char)(f >> 16);
rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x\n",
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF);
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, timeout);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, timeout);
if( ret < 0 )
{
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__,ret, libusb_error_name (ret));
if (ret < 0) {
rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret, libusb_error_name(ret));
return -RIG_EIO;
}
}
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, timeout);
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, timeout);
if( ret < 0 || actual_length != sizeof(au8BufIn) )
{
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret, libusb_error_name (ret));
if (ret < 0 || actual_length != sizeof(au8BufIn)) {
rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret, libusb_error_name(ret));
return -RIG_EIO;
}
}
rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x\n",
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF);
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF);
if (au8BufIn[1] != FUNCUBE_SUCCESS) {
rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_SET_FREQ not supported\n",
__func__);
rig_debug(RIG_DEBUG_ERR, "%s: REQUEST_SET_FREQ not supported\n",
__func__);
return -RIG_EIO;
}
@ -348,43 +349,41 @@ int set_freq_v1(libusb_device_handle *udh, unsigned int f, int timeout)
unsigned char au8BufOut[64]; // endpoint size
unsigned char au8BufIn[64]; // endpoint size
au8BufOut[0]=REQUEST_SET_FREQ_HZ; // Command to Set Frequency in Hz on dongle
au8BufOut[1]=(unsigned char)f;
au8BufOut[2]=(unsigned char)(f>>8);
au8BufOut[3]=(unsigned char)(f>>16);
au8BufOut[4]=(unsigned char)(f>>24);
au8BufOut[0] = REQUEST_SET_FREQ_HZ; // Command to Set Frequency in Hz on dongle
au8BufOut[1] = (unsigned char)f;
au8BufOut[2] = (unsigned char)(f >> 8);
au8BufOut[3] = (unsigned char)(f >> 16);
au8BufOut[4] = (unsigned char)(f >> 24);
rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x%02x\n",
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF,
au8BufOut[4] & 0xFF);
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF,
au8BufOut[4] & 0xFF);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, timeout);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, timeout);
if( ret < 0 )
{
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__,ret,
libusb_error_name (ret));
if (ret < 0) {
rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
libusb_error_name(ret));
return -RIG_EIO;
}
}
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, timeout);
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, timeout);
if( ret < 0 || actual_length != sizeof(au8BufIn) )
{
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
libusb_error_name (ret));
if (ret < 0 || actual_length != sizeof(au8BufIn)) {
rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
libusb_error_name(ret));
return -RIG_EIO;
}
}
rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x%02x%02x%02x%02x\n",
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF, au8BufIn[3] & 0xFF,
au8BufIn[4] & 0xFF, au8BufIn[5] & 0xFF);
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF, au8BufIn[3] & 0xFF,
au8BufIn[4] & 0xFF, au8BufIn[5] & 0xFF);
if (au8BufIn[1] != FUNCUBE_SUCCESS) {
rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_SET_FREQ_HZ not supported\n",
__func__);
rig_debug(RIG_DEBUG_ERR, "%s: REQUEST_SET_FREQ_HZ not supported\n",
__func__);
return -RIG_EIO;
}
@ -401,8 +400,7 @@ int funcube_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
if ((ret = set_freq_v0(udh, freq, rig->state.rigport.timeout)) == RIG_OK) {
priv->freq = freq;
}
}
else {
} else {
priv->freq = freq;
}
@ -413,7 +411,7 @@ int get_freq_v0(RIG *rig, vfo_t vfo, freq_t *freq)
{
struct funcube_priv_data *priv = (struct funcube_priv_data *)rig->state.priv;
rig_debug(RIG_DEBUG_TRACE, "%s: frequency is not read from the device, the value shown is the last successfully set.\n",__func__);
rig_debug(RIG_DEBUG_TRACE, "%s: frequency is not read from the device, the value shown is the last successfully set.\n", __func__);
*freq = priv->freq;
return RIG_OK;
@ -429,43 +427,41 @@ int get_freq_v1(RIG *rig, vfo_t vfo, freq_t *freq)
unsigned char au8BufOut[64]; // endpoint size
unsigned char au8BufIn[64]; // endpoint size
au8BufOut[0]=REQUEST_GET_FREQ_HZ; // Command to Set Frequency on dongle
au8BufOut[0] = REQUEST_GET_FREQ_HZ; // Command to Set Frequency on dongle
rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x\n",
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF);
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout);
if( ret < 0 )
{
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__,ret,
libusb_error_name (ret));
}
if (ret < 0) {
rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
libusb_error_name(ret));
}
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout);
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout);
if( ret < 0 || actual_length != sizeof(au8BufIn) )
{
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
libusb_error_name (ret));
}
if (ret < 0 || actual_length != sizeof(au8BufIn)) {
rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
libusb_error_name(ret));
}
rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x%02x%02x%02x%02x\n",
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF, au8BufIn[3] & 0xFF,
au8BufIn[4] & 0xFF, au8BufIn[5] & 0xFF);
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF, au8BufIn[3] & 0xFF,
au8BufIn[4] & 0xFF, au8BufIn[5] & 0xFF);
if (au8BufIn[1] != FUNCUBE_SUCCESS) {
rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n",
__func__);
rig_debug(RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n",
__func__);
return -RIG_EIO;
}
f = (au8BufIn[2] & 0xFF) | ((au8BufIn[3] & 0xFF) << 8) |
((au8BufIn[4] & 0xFF) << 16) | ((au8BufIn[5] & 0xFF) << 24),
((au8BufIn[4] & 0xFF) << 16) | ((au8BufIn[5] & 0xFF) << 24),
*freq = f;
*freq = f;
return RIG_OK;
}
@ -491,79 +487,87 @@ int funcube_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
switch (level) {
case RIG_LEVEL_PREAMP:
au8BufOut[0]=REQUEST_SET_LNA_GAIN; // Command to Set LNA gain
au8BufOut[0] = REQUEST_SET_LNA_GAIN; // Command to Set LNA gain
switch (val.i) {
case 5:
au8BufOut[1]=6;
case 5:
au8BufOut[1] = 6;
break;
case 10:
au8BufOut[1]=8;
case 10:
au8BufOut[1] = 8;
break;
case 15:
au8BufOut[1]=10;
case 15:
au8BufOut[1] = 10;
break;
case 20:
au8BufOut[1]=12;
case 20:
au8BufOut[1] = 12;
break;
case 25:
au8BufOut[1]=13;
case 25:
au8BufOut[1] = 13;
break;
case 30:
au8BufOut[1]=14;
case 30:
au8BufOut[1] = 14;
break;
default:
au8BufOut[1]=4;
default:
au8BufOut[1] = 4;
}
break;
break;
case RIG_LEVEL_ATT:
au8BufOut[0]=REQUEST_SET_LNA_GAIN; // Command to Set LNA gain
au8BufOut[0] = REQUEST_SET_LNA_GAIN; // Command to Set LNA gain
switch (val.i) {
case 2:
au8BufOut[1]=1;
case 2:
au8BufOut[1] = 1;
break;
case 5:
au8BufOut[1]=0;
case 5:
au8BufOut[1] = 0;
break;
default:
au8BufOut[1]=4;
default:
au8BufOut[1] = 4;
}
break;
break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported level %d\n", __func__, level);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported level %d\n", __func__, level);
return -RIG_EINVAL;
}
rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x\n",
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF);
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout);
if( ret < 0 )
{
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__,ret,
libusb_error_name (ret));
}
if (ret < 0) {
rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
libusb_error_name(ret));
}
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout);
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout);
if( ret < 0 || actual_length != sizeof(au8BufIn) )
{
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
libusb_error_name (ret));
}
if (ret < 0 || actual_length != sizeof(au8BufIn)) {
rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
libusb_error_name(ret));
}
rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x\n",
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF);
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF);
if (au8BufIn[1] != FUNCUBE_SUCCESS) {
rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n",
__func__);
rig_debug(RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n",
__func__);
return -RIG_EIO;
}
@ -580,94 +584,102 @@ int funcube_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
switch (level) {
case RIG_LEVEL_ATT:
case RIG_LEVEL_PREAMP:
au8BufOut[0]=REQUEST_GET_LNA_GAIN; // Command to Get LNA / ATT gain
break;
au8BufOut[0] = REQUEST_GET_LNA_GAIN; // Command to Get LNA / ATT gain
break;
case RIG_LEVEL_STRENGTH:
au8BufOut[0]=REQUEST_GET_RSSI;
au8BufOut[0] = REQUEST_GET_RSSI;
break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported level %d\n", __func__, level);
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported level %d\n", __func__, level);
return -RIG_EINVAL;
}
rig_debug(RIG_DEBUG_TRACE, "%s: HID packet set to %02x%02x%02x%02x\n",
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF);
__func__, au8BufOut[0] & 0xFF, au8BufOut[1] & 0xFF, au8BufOut[2] & 0xFF, au8BufOut[3] & 0xFF);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout);
ret = libusb_interrupt_transfer(udh, OUTPUT_ENDPOINT, au8BufOut, sizeof(au8BufOut), &actual_length, rig->state.rigport.timeout);
if( ret < 0 )
{
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__,ret,
libusb_error_name (ret));
}
if (ret < 0) {
rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
libusb_error_name(ret));
}
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout);
ret = libusb_interrupt_transfer(udh, INPUT_ENDPOINT, au8BufIn, sizeof(au8BufIn), &actual_length, rig->state.rigport.timeout);
if( ret < 0 || actual_length != sizeof(au8BufIn) )
{
rig_debug (RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
libusb_error_name (ret));
}
if (ret < 0 || actual_length != sizeof(au8BufIn)) {
rig_debug(RIG_DEBUG_ERR, "%s: libusb_interrupt_transfer failed (%d): %s\n",
__func__, ret,
libusb_error_name(ret));
}
rig_debug(RIG_DEBUG_TRACE, "%s: Answer buf=%02x%02x%02x\n",
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF);
__func__, au8BufIn[0] & 0xFF, au8BufIn[1] & 0xFF, au8BufIn[2] & 0xFF);
if (au8BufIn[1] != FUNCUBE_SUCCESS) {
rig_debug (RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n",
__func__);
rig_debug(RIG_DEBUG_ERR, "%s: REQUEST_GET_FREQ_HZ not supported\n",
__func__);
return -RIG_EIO;
}
switch (level) {
case RIG_LEVEL_PREAMP:
switch (au8BufIn[2]) {
case 6:
val->i = 5;
break;
case 8:
val->i = 10;
break;
case 10:
val->i = 15;
break;
case 12:
val->i = 20;
break;
case 13:
val->i = 25;
break;
case 14:
val->i = 30;
break;
default:
val->i = 0;
}
break;
case RIG_LEVEL_PREAMP:
switch (au8BufIn[2]) {
case 6:
val->i = 5;
break;
case RIG_LEVEL_ATT:
switch (au8BufIn[2]) {
case 0:
val->i = 5;
break;
case 1:
val->i = 2;
break;
default:
val->i = 0;
}
break;
case 8:
val->i = 10;
break;
case RIG_LEVEL_STRENGTH:
val->i = (int)((float)au8BufIn[2] * 2.8 - 35);
break;
case 10:
val->i = 15;
break;
case 12:
val->i = 20;
break;
case 13:
val->i = 25;
break;
case 14:
val->i = 30;
break;
default:
rig_debug(RIG_DEBUG_ERR,"%s: Unsupported level %d\n", __func__, level);
return -RIG_EINVAL;
val->i = 0;
}
break;
case RIG_LEVEL_ATT:
switch (au8BufIn[2]) {
case 0:
val->i = 5;
break;
case 1:
val->i = 2;
break;
default:
val->i = 0;
}
break;
case RIG_LEVEL_STRENGTH:
val->i = (int)((float)au8BufIn[2] * 2.8 - 35);
break;
default:
rig_debug(RIG_DEBUG_ERR, "%s: Unsupported level %d\n", __func__, level);
return -RIG_EINVAL;
}
return RIG_OK;

2
kit/kit.c
Wyświetl plik

@ -57,7 +57,7 @@ DECLARE_INITRIG_BACKEND(kit)
rig_register(&funcubeplus_caps);
#endif
#if (defined(HAVE_LIBUSB) && (defined(HAVE_LIBUSB_H) || defined(HAVE_LIBUSB_1_0_LIBUSB_H))) || defined(_WIN32)
/* rigs with alternate DLL support on Win32 */
/* rigs with alternate DLL support on Win32 */
rig_register(&dwt_caps);
rig_register(&elektor507_caps);
#endif

1108
kit/si570avrusb.c
Wyświetl plik

Plik diff jest za duży Load Diff

63
src/usb_port.c
Wyświetl plik

@ -75,30 +75,32 @@ static libusb_device_handle *find_and_open_device(const hamlib_port_t *port)
int i, r;
rig_debug(RIG_DEBUG_VERBOSE, "%s: looking for device %04x:%04x...",
__func__, port->parm.usb.vid, port->parm.usb.pid);
__func__, port->parm.usb.vid, port->parm.usb.pid);
r = libusb_get_device_list(NULL, &devs);
if (r < 0) {
rig_debug(RIG_DEBUG_ERR, "%s: failed getting usb device list: %s",
__func__, libusb_error_name(r));
__func__, libusb_error_name(r));
return NULL;
}
for (i=0; (dev=devs[i]) != NULL; i++) {
for (i = 0; (dev = devs[i]) != NULL; i++) {
libusb_get_device_descriptor(dev, &desc);
rig_debug(RIG_DEBUG_VERBOSE, " %04x:%04x,",
desc.idVendor, desc.idProduct);
desc.idVendor, desc.idProduct);
if (desc.idVendor == port->parm.usb.vid &&
desc.idProduct == port->parm.usb.pid) {
desc.idProduct == port->parm.usb.pid) {
/* we need to open the device in order to query strings */
r = libusb_open(dev, &udh);
if (r < 0) {
rig_debug(RIG_DEBUG_WARN, "%s: Warning: Cannot open USB device: %s\n",
__func__, libusb_error_name(r));
__func__, libusb_error_name(r));
continue;
}
@ -107,6 +109,7 @@ static libusb_device_handle *find_and_open_device(const hamlib_port_t *port)
string[0] = '\0';
r = libusb_get_string_descriptor_ascii(udh, desc.iManufacturer, (unsigned char *)string, sizeof(string));
if (r < 0) {
rig_debug(RIG_DEBUG_WARN, "Warning: cannot query manufacturer for USB device: %s\n", libusb_error_name(r));
libusb_close(udh);
@ -126,6 +129,7 @@ static libusb_device_handle *find_and_open_device(const hamlib_port_t *port)
string[0] = '\0';
r = libusb_get_string_descriptor_ascii(udh, desc.iProduct, (unsigned char *)string, sizeof(string));
if (r < 0) {
rig_debug(RIG_DEBUG_WARN, "Warning: cannot query product for USB device: %s\n", libusb_error_name(r));
libusb_close(udh);
@ -176,10 +180,11 @@ int usb_port_open(hamlib_port_t *port)
int r;
/* init defaut libusb-1.0 library contexte, if needed */
r = libusb_init (NULL);
r = libusb_init(NULL);
if (r < 0) {
rig_debug(RIG_DEBUG_ERR, "%s: libusb_init failed: %s\n",
__func__, libusb_error_name(r));
__func__, libusb_error_name(r));
return -RIG_EIO;
}
@ -188,25 +193,29 @@ int usb_port_open(hamlib_port_t *port)
/* Extract VID/PID/Vendor/Product name from pathname. */
/* Duplicate the string since we may modify it. */
strncpy(pathname, port->pathname, sizeof pathname);
pathname[FILPATHLEN-1] = '\0';
pathname[FILPATHLEN - 1] = '\0';
p = pathname;
q = strchr(p, ':');
if (q) {
++q;
port->parm.usb.vid = strtol(q, NULL, 16);
p = q;
q = strchr(p, ':');
if (q) {
++q;
port->parm.usb.pid = strtol(q, NULL, 16);
p = q;
q = strchr(p, ':');
if (q) {
++q;
port->parm.usb.vendor_name = q;
p = q;
q = strchr(p, ':');
if (q) {
*q++ = '\0';
port->parm.usb.product = q;
@ -216,8 +225,9 @@ int usb_port_open(hamlib_port_t *port)
}
udh = find_and_open_device(port);
if (udh == 0) {
libusb_exit (NULL);
libusb_exit(NULL);
return -RIG_EIO;
}
@ -231,43 +241,48 @@ int usb_port_open(hamlib_port_t *port)
if (port->parm.usb.iface >= 0) {
#ifdef _WIN32
/* Is it still needed with libusb-1.0 ? */
if (port->parm.usb.conf >= 0 &&
(r=libusb_set_configuration (udh, port->parm.usb.conf)) < 0) {
(r = libusb_set_configuration(udh, port->parm.usb.conf)) < 0) {
rig_debug(RIG_DEBUG_ERR, "%s: libusb_set_configuration: failed conf %d: %s\n",
__func__, port->parm.usb.conf, libusb_error_name(r));
libusb_close (udh);
libusb_exit (NULL);
__func__, port->parm.usb.conf, libusb_error_name(r));
libusb_close(udh);
libusb_exit(NULL);
return -RIG_EIO;
}
#endif
rig_debug(RIG_DEBUG_VERBOSE, "%s: claiming %d\n", __func__, port->parm.usb.iface);
r = libusb_claim_interface (udh, port->parm.usb.iface);
r = libusb_claim_interface(udh, port->parm.usb.iface);
if (r < 0) {
rig_debug(RIG_DEBUG_ERR, "%s:libusb_claim_interface: failed interface %d: %s\n",
__func__,port->parm.usb.iface, libusb_error_name(r));
libusb_close (udh);
libusb_exit (NULL);
__func__, port->parm.usb.iface, libusb_error_name(r));
libusb_close(udh);
libusb_exit(NULL);
return -RIG_EIO;
}
#if 0
r = libusb_set_interface_alt_setting(udh, port->parm.usb.iface, port->parm.usb.alt);
if (r < 0) {
fprintf (stderr, "%s:usb_set_alt_interface: failed: %s\n", __func__,
fprintf(stderr, "%s:usb_set_alt_interface: failed: %s\n", __func__,
libusb_error_name(r));
libusb_release_interface (udh, port->parm.usb.iface);
libusb_close (udh);
libusb_exit (NULL);
libusb_release_interface(udh, port->parm.usb.iface);
libusb_close(udh);
libusb_exit(NULL);
return -RIG_EIO;
}
#endif
}
port->handle = (void*) udh;
port->handle = (void *) udh;
return RIG_OK;
}
@ -285,7 +300,7 @@ int usb_port_close(hamlib_port_t *port)
libusb_close(udh);
libusb_exit (NULL);
libusb_exit(NULL);
return RIG_OK;
}