PentHertz
/
srsLTE
mirror of https://github.com/PentHertz/srsLTE.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

added uhd option to receive 2 antennas

This commit is contained in:
Ismael Gomez 2017-02-08 23:21:07 +01:00
parent b37a18f9df
commit eb110f26c6
7 changed files with 126 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
srslte/include/srslte/rf/rf.h
View File

@ -73,7 +73,8 @@ SRSLTE_API int srslte_rf_open(srslte_rf_t *h,
SRSLTE_API int srslte_rf_open_devname(srslte_rf_t *h,
char *devname,
char *args);
char *args,
uint32_t nof_rx_antennas);
SRSLTE_API const char *srslte_rf_name(srslte_rf_t *h);
@ -139,6 +140,13 @@ SRSLTE_API int srslte_rf_recv_with_time(srslte_rf_t *h,
time_t *secs,
double *frac_secs);
SRSLTE_API int srslte_rf_recv_with_time_multi(srslte_rf_t *h,
void **data,
uint32_t nsamples,
bool blocking,
time_t *secs,
double *frac_secs);
SRSLTE_API double srslte_rf_set_tx_srate(srslte_rf_t *h,
double freq);

16
srslte/lib/rf/rf_blade_imp.c
View File

@ -178,6 +178,11 @@ float rf_blade_get_rssi(void *h)
return 0;
}
int rf_blade_open_multi(char *args, void **h, uint32_t nof_rx_antennas)
{
return rf_blade_open(args, h);
}
int rf_blade_open(char *args, void **h)
{
*h = NULL;
@ -413,6 +418,17 @@ void rf_blade_get_time(void *h, time_t *secs, double *frac_secs)
timestamp_to_secs(handler->rx_rate, meta.timestamp, secs, frac_secs);
}
int rf_blade_recv_with_time_multi(void *h,
void **data,
uint32_t nsamples,
bool blocking,
time_t *secs,
double *frac_secs)
{
return rf_blade_recv_with_time(h, *data, nsamples, blocking, secs, frac_secs);
}
int rf_blade_recv_with_time(void *h,
void *data,
uint32_t nsamples,

9
srslte/lib/rf/rf_blade_imp.h
View File

@ -33,6 +33,8 @@
SRSLTE_API int rf_blade_open(char *args,
void **handler);
SRSLTE_API int rf_blade_open_multi(char *args,
void **handler, uint32_t nof_rx_antennas);
SRSLTE_API char* rf_blade_devname(void *h);
@ -82,6 +84,13 @@ SRSLTE_API void rf_blade_register_error_handler(void *h,
SRSLTE_API double rf_blade_set_rx_freq(void *h,
double freq);
SRSLTE_API int rf_blade_recv_with_time_multi(void *h,
void **data,
uint32_t nsamples,
bool blocking,
time_t *secs,
double *frac_secs);
SRSLTE_API int rf_blade_recv_with_time(void *h,
void *data,
uint32_t nsamples,

7
srslte/lib/rf/rf_dev.h
View File

@ -38,6 +38,7 @@ typedef struct {
void (*srslte_rf_suppress_stdout)(void *h);
void (*srslte_rf_register_error_handler)(void *h, srslte_rf_error_handler_t error_handler);
int (*srslte_rf_open)(char *args, void **h);
int (*srslte_rf_open_multi)(char *args, void **h, uint32_t nof_rx_antennas);
int (*srslte_rf_close)(void *h);
void (*srslte_rf_set_master_clock_rate)(void *h, double rate);
bool (*srslte_rf_is_master_clock_dynamic)(void *h);
@ -52,6 +53,8 @@ typedef struct {
void (*srslte_rf_get_time)(void *h, time_t *secs, double *frac_secs);
int (*srslte_rf_recv_with_time)(void *h, void *data, uint32_t nsamples,
bool blocking, time_t *secs,double *frac_secs);
int (*srslte_rf_recv_with_time_multi)(void *h, void **data, uint32_t nsamples,
bool blocking, time_t *secs,double *frac_secs);
int (*srslte_rf_send_timed)(void *h, void *data, int nsamples,
time_t secs, double frac_secs, bool has_time_spec,
bool blocking, bool is_start_of_burst, bool is_end_of_burst);
@ -78,6 +81,7 @@ static rf_dev_t dev_uhd = {
rf_uhd_suppress_stdout,
rf_uhd_register_error_handler,
rf_uhd_open,
rf_uhd_open_multi,
rf_uhd_close,
rf_uhd_set_master_clock_rate,
rf_uhd_is_master_clock_dynamic,
@ -91,6 +95,7 @@ static rf_dev_t dev_uhd = {
rf_uhd_set_tx_freq,
rf_uhd_get_time,
rf_uhd_recv_with_time,
rf_uhd_recv_with_time_multi,
rf_uhd_send_timed,
rf_uhd_set_tx_cal,
rf_uhd_set_rx_cal
@ -114,6 +119,7 @@ static rf_dev_t dev_blade = {
rf_blade_suppress_stdout,
rf_blade_register_error_handler,
rf_blade_open,
rf_blade_open_multi,
rf_blade_close,
rf_blade_set_master_clock_rate,
rf_blade_is_master_clock_dynamic,
@ -127,6 +133,7 @@ static rf_dev_t dev_blade = {
rf_blade_set_tx_freq,
rf_blade_get_time,
rf_blade_recv_with_time,
rf_blade_recv_with_time_multi,
rf_blade_send_timed,
rf_blade_set_tx_cal,
rf_blade_set_rx_cal

26
srslte/lib/rf/rf_imp.c
View File

@ -98,7 +98,7 @@ const char* srslte_rf_get_devname(srslte_rf_t *rf) {
return ((rf_dev_t*) rf->dev)->name;
}
int srslte_rf_open_devname(srslte_rf_t *rf, char *devname, char *args) {
int srslte_rf_open_devname(srslte_rf_t *rf, char *devname, char *args, uint32_t nof_rx_antennas) {
/* Try to open the device if name is provided */
if (devname) {
if (devname[0] != '\0') {
@ -106,7 +106,7 @@ int srslte_rf_open_devname(srslte_rf_t *rf, char *devname, char *args) {
while(available_devices[i] != NULL) {
if (!strcmp(available_devices[i]->name, devname)) {
rf->dev = available_devices[i];
return available_devices[i]->srslte_rf_open(args, &rf->handler);
return available_devices[i]->srslte_rf_open_multi(args, &rf->handler, nof_rx_antennas);
}
i++;
}
@ -182,7 +182,12 @@ void srslte_rf_register_error_handler(srslte_rf_t *rf, srslte_rf_error_handler_t
int srslte_rf_open(srslte_rf_t *h, char *args)
{
return srslte_rf_open_devname(h, NULL, args);
return srslte_rf_open_devname(h, NULL, args, 1);
}
int srslte_rf_open_multi(srslte_rf_t *h, char *args, uint32_t nof_rx_antennas)
{
return srslte_rf_open_devname(h, NULL, args, nof_rx_antennas);
}
int srslte_rf_close(srslte_rf_t *rf)
@ -231,6 +236,11 @@ int srslte_rf_recv(srslte_rf_t *rf, void *data, uint32_t nsamples, bool blocking
return srslte_rf_recv_with_time(rf, data, nsamples, blocking, NULL, NULL);
}
int srslte_rf_recv_multi(srslte_rf_t *rf, void **data, uint32_t nsamples, bool blocking)
{
return srslte_rf_recv_with_time_multi(rf, data, nsamples, blocking, NULL, NULL);
}
int srslte_rf_recv_with_time(srslte_rf_t *rf,
void *data,
uint32_t nsamples,
@ -241,6 +251,16 @@ int srslte_rf_recv_with_time(srslte_rf_t *rf,
return ((rf_dev_t*) rf->dev)->srslte_rf_recv_with_time(rf->handler, data, nsamples, blocking, secs, frac_secs);
}
int srslte_rf_recv_with_time_multi(srslte_rf_t *rf,
void **data,
uint32_t nsamples,
bool blocking,
time_t *secs,
double *frac_secs)
{
return ((rf_dev_t*) rf->dev)->srslte_rf_recv_with_time_multi(rf->handler, data, nsamples, blocking, secs, frac_secs);
}
double srslte_rf_set_tx_gain(srslte_rf_t *rf, double gain)
{
return ((rf_dev_t*) rf->dev)->srslte_rf_set_tx_gain(rf->handler, gain);

69
srslte/lib/rf/rf_uhd_imp.c
View File

@ -51,6 +51,8 @@ typedef struct {
bool dynamic_rate;
bool has_rssi;
uhd_sensor_value_handle rssi_value;
uint32_t nof_rx_channels;
int nof_tx_channels;
} rf_uhd_handler_t;
void suppress_handler(const char *x)
@ -231,6 +233,11 @@ float rf_uhd_get_rssi(void *h) {
}
int rf_uhd_open(char *args, void **h)
{
return rf_uhd_open_multi(args, h, 1);
}
int rf_uhd_open_multi(char *args, void **h, uint32_t nof_rx_antennas)
{
if (h) {
*h = NULL;
@ -306,14 +313,17 @@ int rf_uhd_open(char *args, void **h)
if (!handler->devname) {
handler->devname = "uhd_unknown";
}
size_t channel = 0;
size_t channel[4] = {0, 1, 2, 3};
uhd_stream_args_t stream_args = {
.cpu_format = "fc32",
.otw_format = "sc16",
.args = "",
.channel_list = &channel,
.n_channels = 1
.channel_list = channel,
.n_channels = nof_rx_antennas
};
handler->nof_rx_channels = nof_rx_antennas;
handler->nof_tx_channels = 1;
// Set external clock reference
if (strstr(args, "clock=external")) {
@ -393,7 +403,9 @@ bool rf_uhd_is_master_clock_dynamic(void *h) {
double rf_uhd_set_rx_srate(void *h, double freq)
{
rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h;
uhd_usrp_set_rx_rate(handler->usrp, freq, 0);
for (int i=0;i<handler->nof_rx_channels;i++) {
uhd_usrp_set_rx_rate(handler->usrp, freq, i);
}
uhd_usrp_get_rx_rate(handler->usrp, 0, &freq);
return freq;
}
@ -401,7 +413,9 @@ double rf_uhd_set_rx_srate(void *h, double freq)
double rf_uhd_set_tx_srate(void *h, double freq)
{
rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h;
uhd_usrp_set_tx_rate(handler->usrp, freq, 0);
for (int i=0;i<handler->nof_tx_channels;i++) {
uhd_usrp_set_tx_rate(handler->usrp, freq, i);
}
uhd_usrp_get_tx_rate(handler->usrp, 0, &freq);
handler->tx_rate = freq;
return freq;
@ -410,7 +424,9 @@ double rf_uhd_set_tx_srate(void *h, double freq)
double rf_uhd_set_rx_gain(void *h, double gain)
{
rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h;
uhd_usrp_set_rx_gain(handler->usrp, gain, 0, "");
for (int i=0;i<handler->nof_rx_channels;i++) {
uhd_usrp_set_rx_gain(handler->usrp, gain, i, "");
}
uhd_usrp_get_rx_gain(handler->usrp, 0, "", &gain);
return gain;
}
@ -418,7 +434,9 @@ double rf_uhd_set_rx_gain(void *h, double gain)
double rf_uhd_set_tx_gain(void *h, double gain)
{
rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h;
uhd_usrp_set_tx_gain(handler->usrp, gain, 0, "");
for (int i=0;i<handler->nof_tx_channels;i++) {
uhd_usrp_set_tx_gain(handler->usrp, gain, i, "");
}
uhd_usrp_get_tx_gain(handler->usrp, 0, "", &gain);
return gain;
}
@ -448,7 +466,9 @@ double rf_uhd_set_rx_freq(void *h, double freq)
};
uhd_tune_result_t tune_result;
rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h;
uhd_usrp_set_rx_freq(handler->usrp, &tune_request, 0, &tune_result);
for (int i=0;i<handler->nof_rx_channels;i++) {
uhd_usrp_set_rx_freq(handler->usrp, &tune_request, i, &tune_result);
}
uhd_usrp_get_rx_freq(handler->usrp, 0, &freq);
return freq;
}
@ -462,7 +482,9 @@ double rf_uhd_set_tx_freq(void *h, double freq)
};
uhd_tune_result_t tune_result;
rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h;
uhd_usrp_set_tx_freq(handler->usrp, &tune_request, 0, &tune_result);
for (int i=0;i<handler->nof_tx_channels;i++) {
uhd_usrp_set_tx_freq(handler->usrp, &tune_request, i, &tune_result);
}
uhd_usrp_get_tx_freq(handler->usrp, 0, &freq);
return freq;
}
@ -480,37 +502,48 @@ int rf_uhd_recv_with_time(void *h,
time_t *secs,
double *frac_secs)
{
return rf_uhd_recv_with_time_multi(h, &data, nsamples, blocking, secs, frac_secs);
}
int rf_uhd_recv_with_time_multi(void *h,
void **data,
uint32_t nsamples,
bool blocking,
time_t *secs,
double *frac_secs)
{
rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h;
size_t rxd_samples;
size_t rxd_samples[4];
uhd_rx_metadata_handle *md = &handler->rx_md_first;
int trials = 0;
if (blocking) {
int n = 0;
cf_t *data_c = (cf_t*) data;
do {
size_t rx_samples = handler->rx_nof_samples;
if (rx_samples > nsamples - n) {
rx_samples = nsamples - n;
}
void *buff = (void*) &data_c[n];
void **buffs_ptr = (void**) &buff;
void *buffs_ptr[4];
for (int i=0;i<handler->nof_rx_channels;i++) {
cf_t *data_c = (cf_t*) data[i];
buffs_ptr[i] = &data_c[n];
}
uhd_error error = uhd_rx_streamer_recv(handler->rx_stream, buffs_ptr,
rx_samples, md, 5.0, false, &rxd_samples);
rx_samples, md, 1.0, false, rxd_samples);
if (error) {
fprintf(stderr, "Error receiving from UHD: %d\n", error);
return -1;
}
md = &handler->rx_md;
n += rxd_samples;
n += rxd_samples[0];
trials++;
} while (n < nsamples && trials < 100);
} else {
void **buffs_ptr = (void**) &data;
return uhd_rx_streamer_recv(handler->rx_stream, buffs_ptr,
nsamples, md, 0.0, false, &rxd_samples);
return uhd_rx_streamer_recv(handler->rx_stream, data,
nsamples, md, 0.0, false, rxd_samples);
}
if (secs && frac_secs) {
uhd_rx_metadata_time_spec(handler->rx_md_first, secs, frac_secs);

11
srslte/lib/rf/rf_uhd_imp.h
View File

@ -37,6 +37,10 @@
SRSLTE_API int rf_uhd_open(char *args,
void **handler);
SRSLTE_API int rf_uhd_open_multi(char *args,
void **handler,
uint32_t nof_rx_antennas);
SRSLTE_API char* rf_uhd_devname(void *h);
SRSLTE_API int rf_uhd_close(void *h);
@ -89,6 +93,13 @@ SRSLTE_API int rf_uhd_recv_with_time(void *h,
time_t *secs,
double *frac_secs);
SRSLTE_API int rf_uhd_recv_with_time_multi(void *h,
void **data,
uint32_t nsamples,
bool blocking,
time_t *secs,
double *frac_secs);
SRSLTE_API double rf_uhd_set_tx_srate(void *h,
double freq);