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

UDP interface support besides IPC 

git-svn-id: https://hamlib.svn.sourceforge.net/svnroot/hamlib/trunk@2743 7ae35d74-ebe9-4afe-98af-79ac388436b8
Hamlib-1.2.10
Stéphane Fillod, F8CFE 2009-10-30 23:43:50 +00:00
rodzic 8a9a351e9d
commit 033d4f6519
1 zmienionych plików z 157 dodań i 85 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

242
flexradio/dttsp.c
Wyświetl plik

@ -1,6 +1,9 @@
/* /*
* Hamlib DttSP backend - main file * Hamlib DttSP backend - main file
* Copyright (c) 2001-2008 by Stephane Fillod * Copyright (c) 2001-2009 by Stephane Fillod
*
* Some code derived from DttSP
* Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 by Frank Brickle, AB2KT and Bob McGwier, N4HY
* *
* $Id: dttsp.c,v 1.2 2008-05-07 22:18:25 fillods Exp $ * $Id: dttsp.c,v 1.2 2008-05-07 22:18:25 fillods Exp $
* *
@ -33,6 +36,7 @@
#include <math.h> #include <math.h>
#include "hamlib/rig.h" #include "hamlib/rig.h"
#include "iofunc.h"
#include "misc.h" #include "misc.h"
#include "token.h" #include "token.h"
#include "register.h" #include "register.h"
@ -40,8 +44,11 @@
#include "flexradio.h" #include "flexradio.h"
/* /*
* TODO: * This backend is a two layer rig control: DttSP core over a mundane tuner
* *
* 2 interfaces of DttSP are supported: IPC & UDP
*
* TODO: Transmit setup
*/ */
#define DEFAULT_DTTSP_CMD_PATH "/dev/shm/SDRcommands" #define DEFAULT_DTTSP_CMD_PATH "/dev/shm/SDRcommands"
@ -51,6 +58,13 @@
#define MAXRX 4 #define MAXRX 4
#define RXMETERPTS 5 #define RXMETERPTS 5
#define TXMETERPTS 9 #define TXMETERPTS 9
#define MAXMETERPTS 9
#define DTTSP_PORT_CLIENT_COMMAND 19001
#define DTTSP_PORT_CLIENT_SPECTRUM 19002
#define DTTSP_PORT_CLIENT_METER 19003
#define DTTSP_PORT_CLIENT_BUFSIZE 65536
struct dttsp_priv_data { struct dttsp_priv_data {
/* tuner providing IF */ /* tuner providing IF */
@ -58,17 +72,39 @@ struct dttsp_priv_data {
RIG *tuner; RIG *tuner;
shortfreq_t IF_center_freq; shortfreq_t IF_center_freq;
/* DttSP meter handle */
int meter_fd;
int sample_rate; int sample_rate;
int rx_delta_f; int rx_delta_f;
hamlib_port_t meter_port;
#if 0
union {
/* IPC specific */
struct {
/* DttSP meter handle */
int meter_fd;
};
/* UDP specific RIG_PORT_NETWORK_UDP */
struct {
unsigned short port;
struct sockaddr_in clnt;
int clen, flags, sock;
char buff[DTTSP_PORT_CLIENT_BUFSIZE];
int size, used;
};
#endif
}; };
static int dttsp_init(RIG *rig); static int dttsp_ipc_init(RIG *rig);
static int dttsp_cleanup(RIG *rig); static int dttsp_ipc_cleanup(RIG *rig);
static int dttsp_open(RIG *rig); static int dttsp_ipc_open(RIG *rig);
static int dttsp_close(RIG *rig); static int dttsp_ipc_close(RIG *rig);
static int dttsp_udp_init(RIG *rig);
static int dttsp_udp_cleanup(RIG *rig);
static int dttsp_udp_open(RIG *rig);
static int dttsp_udp_close(RIG *rig);
static int dttsp_set_freq(RIG *rig, vfo_t vfo, freq_t freq); static int dttsp_set_freq(RIG *rig, vfo_t vfo, freq_t freq);
static int dttsp_get_freq(RIG *rig, vfo_t vfo, freq_t *freq); static int dttsp_get_freq(RIG *rig, vfo_t vfo, freq_t *freq);
static int dttsp_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width); static int dttsp_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width);
@ -140,7 +176,7 @@ static const struct hamlib_vs_dttsp {
const struct rig_caps dttsp_rig_caps = { const struct rig_caps dttsp_rig_caps = {
.rig_model = RIG_MODEL_DTTSP, .rig_model = RIG_MODEL_DTTSP,
.model_name = "DttSP", .model_name = "DttSP IPC",
.mfg_name = "DTTS Microwave Society", .mfg_name = "DTTS Microwave Society",
.version = "0.1", .version = "0.1",
.copyright = "GPL", .copyright = "GPL",
@ -166,14 +202,15 @@ const struct rig_caps dttsp_rig_caps = {
.transceive = RIG_TRN_OFF, .transceive = RIG_TRN_OFF,
.attenuator = { RIG_DBLST_END, }, .attenuator = { RIG_DBLST_END, },
.preamp = { RIG_DBLST_END, }, .preamp = { RIG_DBLST_END, },
/* In fact, RX and TX ranges are dependant on the tuner */
.rx_range_list1 = { {.start=kHz(150),.end=MHz(1500),.modes=DTTSP_MODES, .rx_range_list1 = { {.start=kHz(150),.end=MHz(1500),.modes=DTTSP_MODES,
.low_power=-1,.high_power=-1,DTTSP_VFO}, .low_power=-1,.high_power=-1,DTTSP_VFO},
RIG_FRNG_END, }, RIG_FRNG_END, },
.tx_range_list1 = { RIG_FRNG_END, }, .tx_range_list1 = { RIG_FRNG_END, }, /* TODO */
.rx_range_list2 = { {.start=kHz(150),.end=MHz(1500),.modes=DTTSP_MODES, .rx_range_list2 = { {.start=kHz(150),.end=MHz(1500),.modes=DTTSP_MODES,
.low_power=-1,.high_power=-1,DTTSP_VFO}, .low_power=-1,.high_power=-1,DTTSP_VFO},
RIG_FRNG_END, }, RIG_FRNG_END, },
.tx_range_list2 = { RIG_FRNG_END, }, .tx_range_list2 = { RIG_FRNG_END, }, /* TODO */
.tuning_steps = { {DTTSP_MODES,1}, {DTTSP_MODES,RIG_TS_ANY}, RIG_TS_END, }, .tuning_steps = { {DTTSP_MODES,1}, {DTTSP_MODES,RIG_TS_ANY}, RIG_TS_END, },
.filters = { .filters = {
{RIG_MODE_SSB|RIG_MODE_CW|RIG_MODE_CWR, kHz(2.4)}, {RIG_MODE_SSB|RIG_MODE_CW|RIG_MODE_CWR, kHz(2.4)},
@ -187,10 +224,10 @@ const struct rig_caps dttsp_rig_caps = {
.priv = NULL, .priv = NULL,
.rig_init = dttsp_init, .rig_init = dttsp_ipc_init,
.rig_cleanup = dttsp_cleanup, .rig_cleanup = dttsp_ipc_cleanup,
.rig_open = dttsp_open, .rig_open = dttsp_ipc_open,
.rig_close = dttsp_close, .rig_close = dttsp_ipc_close,
.cfgparams = dttsp_cfg_params, .cfgparams = dttsp_cfg_params,
.set_conf = dttsp_set_conf, .set_conf = dttsp_set_conf,
@ -213,38 +250,61 @@ const struct rig_caps dttsp_rig_caps = {
}; };
static int send_command(RIG *rig, const char *cmdstr, size_t buflen)
int dttsp_init(RIG *rig)
{ {
struct dttsp_priv_data *priv; int ret;
const char *cmdpath;
char *p;
priv = (struct dttsp_priv_data*)malloc(sizeof(struct dttsp_priv_data)); if (rig->state.rigport.type.rig == RIG_PORT_NETWORK) {
if (!priv) } else {
return -RIG_ENOMEM; /* IPC */
rig->state.priv = (void*)priv; ret = write_block (&rig->state.rigport, cmdstr, buflen);
}
rig_debug(RIG_DEBUG_VERBOSE,"%s called\n", __FUNCTION__ ); return ret;
}
priv->tuner = NULL; static int fetch_meter (RIG *rig, int *label, float *data, int npts)
priv->tuner_model = RIG_MODEL_DUMMY; {
priv->IF_center_freq = 0; struct dttsp_priv_data *priv = (struct dttsp_priv_data*)rig->state.priv;
int ret, buf_len;
char buf[sizeof(float)*MAXMETERPTS*MAXRX];
if (priv->meter_port.type.rig == RIG_PORT_NETWORK) {
#if 0
if (!select(cp->sock + 1, &fds, 0, 0, &tv))
return -1;
if (recvfrom(cp->sock, cp->buff, cp->size, cp->flags,
(struct sockaddr *) &cp->clnt, &cp->clen) <= 0)
return -2;
#endif
buf_len = sizeof(int) + npts * sizeof(float);
p = getenv ( "SDR_DEFRATE" ); ret = read_block(&priv->meter_port, buf, buf_len);
if (p) if (ret != buf_len)
priv->sample_rate = atoi(p); ret = -RIG_EIO;
else
priv->sample_rate = DEFAULT_SAMPLE_RATE;
cmdpath = getenv ( "SDR_PARMPATH" ); /* copy payload back to client space */
if (!cmdpath) memcpy((char *) label, buf, sizeof(int));
cmdpath = DEFAULT_DTTSP_CMD_PATH; memcpy((char *) data, buf + sizeof(int), npts * sizeof(float));
strncpy(rig->state.rigport.pathname, cmdpath, FILPATHLEN); } else {
/* IPC */
buf_len = sizeof(int);
ret = read_block(&priv->meter_port, (char*)label, buf_len);
if (ret != buf_len)
ret = -RIG_EIO;
if (ret < 0)
return ret;
return RIG_OK; buf_len = sizeof(float) * npts;
ret = read_block(&priv->meter_port, (char*)data, buf_len);
if (ret != buf_len)
ret = -RIG_EIO;
if (ret < 0)
return ret;
}
return ret;
} }
@ -300,12 +360,46 @@ int dttsp_get_conf(RIG *rig, token_t token, char *val)
return RIG_OK; return RIG_OK;
} }
int dttsp_open(RIG *rig) int dttsp_ipc_init(RIG *rig)
{
struct dttsp_priv_data *priv;
const char *cmdpath;
char *p;
priv = (struct dttsp_priv_data*)malloc(sizeof(struct dttsp_priv_data));
if (!priv)
return -RIG_ENOMEM;
rig->state.priv = (void*)priv;
rig_debug(RIG_DEBUG_VERBOSE,"%s called\n", __FUNCTION__ );
priv->tuner = NULL;
priv->tuner_model = RIG_MODEL_DUMMY;
priv->IF_center_freq = 0;
p = getenv ( "SDR_DEFRATE" );
if (p)
priv->sample_rate = atoi(p);
else
priv->sample_rate = DEFAULT_SAMPLE_RATE;
cmdpath = getenv ( "SDR_PARMPATH" );
if (!cmdpath)
cmdpath = DEFAULT_DTTSP_CMD_PATH;
strncpy(rig->state.rigport.pathname, cmdpath, FILPATHLEN);
return RIG_OK;
}
int dttsp_ipc_open(RIG *rig)
{ {
struct dttsp_priv_data *priv = (struct dttsp_priv_data*)rig->state.priv; struct dttsp_priv_data *priv = (struct dttsp_priv_data*)rig->state.priv;
int ret; int ret;
char *p; char *p;
char meterpath[FILPATHLEN]; char *meterpath;
rig_debug(RIG_DEBUG_TRACE,"%s called\n", __FUNCTION__); rig_debug(RIG_DEBUG_TRACE,"%s called\n", __FUNCTION__);
@ -333,6 +427,7 @@ int dttsp_open(RIG *rig)
/* open DttSP meter pipe */ /* open DttSP meter pipe */
p = getenv ( "SDR_METERPATH" ); p = getenv ( "SDR_METERPATH" );
if (!p) { if (!p) {
meterpath = priv->meter_port.pathname;
strncpy(meterpath, rig->state.rigport.pathname, FILPATHLEN); strncpy(meterpath, rig->state.rigport.pathname, FILPATHLEN);
p = strrchr(meterpath, '/'); p = strrchr(meterpath, '/');
strcpy(p+1, "SDRmeter"); strcpy(p+1, "SDRmeter");
@ -340,9 +435,12 @@ int dttsp_open(RIG *rig)
} }
if (!p) { if (!p) {
/* disabled */ /* disabled */
priv->meter_fd = -1; priv->meter_port.fd = -1;
} else { } else {
priv->meter_fd = open(p, O_RDWR); priv->meter_port.type.rig = RIG_PORT_DEVICE;
ret = port_open(&priv->meter_port);
if (ret < 0)
return ret;
} }
@ -370,20 +468,19 @@ int dttsp_open(RIG *rig)
} }
int dttsp_close(RIG *rig) int dttsp_ipc_close(RIG *rig)
{ {
struct dttsp_priv_data *priv = (struct dttsp_priv_data*)rig->state.priv; struct dttsp_priv_data *priv = (struct dttsp_priv_data*)rig->state.priv;
rig_debug(RIG_DEBUG_VERBOSE,"%s called\n", __FUNCTION__); rig_debug(RIG_DEBUG_VERBOSE,"%s called\n", __FUNCTION__);
close(priv->meter_fd); port_close(&priv->meter_port, priv->meter_port.type.rig);
rig_close(priv->tuner); rig_close(priv->tuner);
/* TODO: close meter */
return RIG_OK; return RIG_OK;
} }
int dttsp_cleanup(RIG *rig) int dttsp_ipc_cleanup(RIG *rig)
{ {
struct dttsp_priv_data *priv = (struct dttsp_priv_data*)rig->state.priv; struct dttsp_priv_data *priv = (struct dttsp_priv_data*)rig->state.priv;
@ -401,6 +498,7 @@ int dttsp_cleanup(RIG *rig)
return RIG_OK; return RIG_OK;
} }
/* /*
* rig_set_freq is a good candidate for the GNUradio GUI setFrequency callback? * rig_set_freq is a good candidate for the GNUradio GUI setFrequency callback?
*/ */
@ -449,11 +547,7 @@ int dttsp_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
/* setRxFrequenc */ /* setRxFrequenc */
buf_len = sprintf (buf, "setOsc %d\n", priv->rx_delta_f ); buf_len = sprintf (buf, "setOsc %d\n", priv->rx_delta_f );
ret = write (rig->state.rigport.fd, buf, buf_len ); ret = send_command (rig, buf, buf_len);
if (ret == buf_len)
ret = RIG_OK;
else
ret = -RIG_EIO;
return ret; return ret;
} }
@ -531,18 +625,10 @@ int dttsp_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
/* DttSP set mode */ /* DttSP set mode */
buf_len = sprintf (buf, "setMode %d\n", rmode2dttsp(mode) ); buf_len = sprintf (buf, "setMode %d\n", rmode2dttsp(mode) );
ret = write (rig->state.rigport.fd, buf, buf_len ); ret = send_command (rig, buf, buf_len);
if (ret == buf_len)
ret = RIG_OK;
else
ret = -RIG_EIO;
buf_len = sprintf (buf, "setFilter %d %d\n", filter_l, filter_h ); buf_len = sprintf (buf, "setFilter %d %d\n", filter_l, filter_h );
ret = write (rig->state.rigport.fd, buf, buf_len ); ret = send_command (rig, buf, buf_len);
if (ret == buf_len)
ret = RIG_OK;
else
ret = -RIG_EIO;
rig_debug(RIG_DEBUG_VERBOSE,"%s: %s\n", rig_debug(RIG_DEBUG_VERBOSE,"%s: %s\n",
__FUNCTION__, buf); __FUNCTION__, buf);
@ -575,11 +661,7 @@ int dttsp_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
switch (level) { switch (level) {
case RIG_LEVEL_AGC: case RIG_LEVEL_AGC:
buf_len = sprintf (buf, "setRXAGC %d\n", agc_level2dttsp(val.i)); buf_len = sprintf (buf, "setRXAGC %d\n", agc_level2dttsp(val.i));
ret = write (rig->state.rigport.fd, buf, buf_len ); ret = send_command (rig, buf, buf_len);
if (ret == buf_len)
ret = RIG_OK;
else
ret = -RIG_EIO;
break; break;
default: default:
rig_debug(RIG_DEBUG_TRACE, "%s: level %s, try tuner\n", rig_debug(RIG_DEBUG_TRACE, "%s: level %s, try tuner\n",
@ -606,21 +688,15 @@ int dttsp_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
case RIG_LEVEL_RAWSTR: case RIG_LEVEL_RAWSTR:
case RIG_LEVEL_STRENGTH: case RIG_LEVEL_STRENGTH:
buf_len = sprintf (buf, "reqRXMeter %d\n", getpid()); buf_len = sprintf (buf, "reqRXMeter %d\n", getpid());
ret = write (rig->state.rigport.fd, buf, buf_len ); ret = send_command (rig, buf, buf_len);
if (ret != buf_len) if (ret < 0)
ret = -RIG_EIO; return ret;
buf_len = sizeof(int); ret = fetch_meter (rig, (int*)buf, (float*)rxm, MAXRX * RXMETERPTS);
ret = read(priv->meter_fd, buf, buf_len); if (ret < 0)
if (ret != buf_len) return ret;
ret = -RIG_EIO;
buf_len = sizeof(float) * MAXRX * RXMETERPTS; val->i = (int)rxm[0][0];
ret = read(priv->meter_fd, rxm, buf_len);
if (ret != buf_len)
ret = -RIG_EIO;
val->i = rxm[0][0];
if (level == RIG_LEVEL_STRENGTH) if (level == RIG_LEVEL_STRENGTH)
val->i = (int)rig_raw2val(val->i,&rig->state.str_cal); val->i = (int)rig_raw2val(val->i,&rig->state.str_cal);
@ -666,11 +742,7 @@ int dttsp_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
} }
buf_len = sprintf (buf, "%s %d\n", cmd, status); buf_len = sprintf (buf, "%s %d\n", cmd, status);
ret = write (rig->state.rigport.fd, buf, buf_len ); ret = send_command (rig, buf, buf_len);
if (ret == buf_len)
ret = RIG_OK;
else
ret = -RIG_EIO;
return ret; return ret;
} }