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

Merge remote-tracking branch 'origin/next' into restruct_update

This commit is contained in:
Andre Puschmann 2017-05-31 12:18:29 +02:00
parent 5ed2c3d5a5 d2e5099428
commit 9d9d4435e2
3 changed files with 254 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/src/phy/phch/pdsch.c
View File

@ -542,7 +542,7 @@ int srslte_pdsch_encode(srslte_pdsch_t *q,
if (srslte_sequence_pdsch(&seq, rnti, 0, 2 * cfg->sf_idx, q->cell.id, cfg->nbits.nof_bits)) { if (srslte_sequence_pdsch(&seq, rnti, 0, 2 * cfg->sf_idx, q->cell.id, cfg->nbits.nof_bits)) {
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
srslte_scrambling_bytes(&q->users[rnti]->seq[cfg->sf_idx], (uint8_t*) q->e, cfg->nbits.nof_bits); srslte_scrambling_bytes(&seq, (uint8_t*) q->e, cfg->nbits.nof_bits);
srslte_sequence_free(&seq); srslte_sequence_free(&seq);
} else { } else {
srslte_scrambling_bytes(&q->users[rnti]->seq[cfg->sf_idx], (uint8_t*) q->e, cfg->nbits.nof_bits); srslte_scrambling_bytes(&q->users[rnti]->seq[cfg->sf_idx], (uint8_t*) q->e, cfg->nbits.nof_bits);

176
lib/src/phy/rf/rf_soapy_imp.c
View File

@ -36,87 +36,84 @@
#include <SoapySDR/Device.h> #include <SoapySDR/Device.h>
#include <SoapySDR/Formats.h> #include <SoapySDR/Formats.h>
//#include "lime/LimeSuite.h"
typedef struct { typedef struct {
SoapySDRKwargs args; SoapySDRKwargs args;
SoapySDRDevice *device; SoapySDRDevice *device;
SoapySDRRange *ranges; SoapySDRRange *ranges;
SoapySDRStream *rxStream; SoapySDRStream *rxStream;
SoapySDRStream *txStream; SoapySDRStream *txStream;
} rf_soapy_handler_t; } rf_soapy_handler_t;
int soapy_error(void *h) int soapy_error(void *h)
{ {
return 0;
} }
void rf_soapy_get_freq_range(void *h) void rf_soapy_get_freq_range(void *h)
{ {
} }
void rf_soapy_suppress_handler(const char *x) void rf_soapy_suppress_handler(const char *x)
{ {
// not supported // not supported
} }
void rf_soapy_msg_handler(const char *msg) void rf_soapy_msg_handler(const char *msg)
{ {
// not supported // not supported
} }
void rf_soapy_suppress_stdout(void *h) void rf_soapy_suppress_stdout(void *h)
{ {
// not supported // not supported
} }
void rf_soapy_register_error_handler(void *notused, srslte_rf_error_handler_t new_handler) void rf_soapy_register_error_handler(void *notused, srslte_rf_error_handler_t new_handler)
{ {
// not supported // not supported
} }
static bool isLocked(rf_soapy_handler_t *handler, char *sensor_name, void *value_h)
{
// not supported
return true;
}
char* rf_soapy_devname(void* h) char* rf_soapy_devname(void* h)
{ {
return "soapy";
} }
bool rf_soapy_rx_wait_lo_locked(void *h) bool rf_soapy_rx_wait_lo_locked(void *h)
{ {
// not supported printf("TODO: implement rf_soapy_rx_wait_lo_locked()\n");
return true; return true;
} }
void rf_soapy_set_tx_cal(void *h, srslte_rf_cal_t *cal) void rf_soapy_set_tx_cal(void *h, srslte_rf_cal_t *cal)
{ {
printf("TODO: implement rf_soapy_rx_wait_lo_locked()\n");
// not supported // not supported
} }
void rf_soapy_set_rx_cal(void *h, srslte_rf_cal_t *cal) void rf_soapy_set_rx_cal(void *h, srslte_rf_cal_t *cal)
{ {
// not supported printf("TODO: implement rf_soapy_set_rx_cal()\n");
} }
int rf_soapy_start_rx_stream(void *h) int rf_soapy_start_rx_stream(void *h)
{ {
//printf("starting SOAPY rx stream \n");
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h; rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h;
//SoapySDRStream *rxStream;
if(SoapySDRDevice_activateStream(handler->device, handler->rxStream, 0, 0, 0)!=0)//start streaming if (SoapySDRDevice_activateStream(handler->device, handler->rxStream, 0, 0, 0) != 0)
return SRSLTE_ERROR; return SRSLTE_ERROR;
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
@ -124,41 +121,38 @@ int rf_soapy_start_rx_stream(void *h)
int rf_soapy_start_tx_stream(void *h) int rf_soapy_start_tx_stream(void *h)
{ {
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h; rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h;
//SoapySDRStream *rxStream; if (SoapySDRDevice_setupStream(handler->device, &(handler->txStream), SOAPY_SDR_TX, SOAPY_SDR_CF32, NULL, 0, NULL) != 0) {
if (SoapySDRDevice_setupStream(handler->device, &(handler->txStream), SOAPY_SDR_TX, SOAPY_SDR_CF32, NULL, 0, NULL) != 0)
{
printf("setupStream fail: %s\n", SoapySDRDevice_lastError()); printf("setupStream fail: %s\n", SoapySDRDevice_lastError());
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
if(SoapySDRDevice_activateStream(handler->device, handler->txStream, 0, 0, 0) != 0) if(SoapySDRDevice_activateStream(handler->device, handler->txStream, 0, 0, 0) != 0)
return SRSLTE_ERROR; return SRSLTE_ERROR;
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
int rf_soapy_stop_rx_stream(void *h) int rf_soapy_stop_rx_stream(void *h)
{ {
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h; rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h;
if (SoapySDRDevice_deactivateStream(handler->device, handler->rxStream, 0, 0) != 0) if (SoapySDRDevice_deactivateStream(handler->device, handler->rxStream, 0, 0) != 0)
return SRSLTE_ERROR; return SRSLTE_ERROR;
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
int rf_soapy_stop_tx_stream(void *h) int rf_soapy_stop_tx_stream(void *h)
{ {
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h; rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h;
if(SoapySDRDevice_deactivateStream(handler->device, handler->txStream, 0, 0) != 0) if(SoapySDRDevice_deactivateStream(handler->device, handler->txStream, 0, 0) != 0)
return SRSLTE_ERROR; return SRSLTE_ERROR;
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
void rf_soapy_flush_buffer(void *h) void rf_soapy_flush_buffer(void *h)
{ {
int n; int n;
@ -170,29 +164,33 @@ void rf_soapy_flush_buffer(void *h)
} while (n > 0); } while (n > 0);
} }
bool rf_soapy_has_rssi(void *h) bool rf_soapy_has_rssi(void *h)
{ {
printf("TODO: implement rf_soapy_has_rssi()\n");
return false;
} }
float rf_soapy_get_rssi(void *h) float rf_soapy_get_rssi(void *h)
{ {
printf("TODO: implement rf_soapy_get_rssi()\n");
return 0.0;
} }
//TODO: add multi-channel support //TODO: add multi-channel support
int rf_soapy_open_multi(char *args, void **h, uint32_t nof_rx_antennas) int rf_soapy_open_multi(char *args, void **h, uint32_t nof_rx_antennas)
{//SoapySDRKwargs soapy_args = {}; {
size_t length; size_t length;
const SoapySDRKwargs *soapy_args = SoapySDRDevice_enumerate(NULL, &length); const SoapySDRKwargs *soapy_args = SoapySDRDevice_enumerate(NULL, &length);
if(length == 0) if (length == 0) {
{ printf("No Soapy devices found.\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
for (size_t i = 0; i < length; i++) for (size_t i = 0; i < length; i++) {
{
printf("Soapy Has Found device #%d: ", (int)i); printf("Soapy Has Found device #%d: ", (int)i);
for (size_t j = 0; j < soapy_args[i].size; j++) for (size_t j = 0; j < soapy_args[i].size; j++)
{ {
@ -201,38 +199,27 @@ int rf_soapy_open_multi(char *args, void **h, uint32_t nof_rx_antennas)
printf("\n"); printf("\n");
} }
// SoapySDRrgs_set(&soapy_args, "driver", "rtlsdr");
SoapySDRDevice *sdr = SoapySDRDevice_make(&(soapy_args[0])); SoapySDRDevice *sdr = SoapySDRDevice_make(&(soapy_args[0]));
if (sdr == NULL) {
if(sdr == NULL)
{
printf("failed to create SOAPY object\n"); printf("failed to create SOAPY object\n");
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
//SoapySDRKwargs_clear(&soapy_args); // create handler
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) malloc(sizeof(rf_soapy_handler_t)); rf_soapy_handler_t *handler = (rf_soapy_handler_t*) malloc(sizeof(rf_soapy_handler_t));
bzero(handler, sizeof(rf_soapy_handler_t));
*h = handler; *h = handler;
handler->device = sdr; handler->device = sdr;
if (SoapySDRDevice_setupStream(handler->device, &(handler->rxStream), SOAPY_SDR_RX, SOAPY_SDR_CF32, NULL, 0, NULL) != 0) {
//size_t channels[1];
//channels[0] = 0;
if (SoapySDRDevice_setupStream(handler->device, &(handler->rxStream), SOAPY_SDR_RX, SOAPY_SDR_CF32, NULL, 0, NULL) != 0)
{
printf("setupStream fail: %s\n", SoapySDRDevice_lastError()); printf("setupStream fail: %s\n", SoapySDRDevice_lastError());
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
return SRSLTE_SUCCESS; return SRSLTE_SUCCESS;
} }
int rf_soapy_open(char *args, void **h) int rf_soapy_open(char *args, void **h)
{ {
return rf_soapy_open_multi(args, h, 1); return rf_soapy_open_multi(args, h, 1);
@ -242,64 +229,69 @@ int rf_soapy_open(char *args, void **h)
int rf_soapy_close(void *h) int rf_soapy_close(void *h)
{ {
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h; rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h;
if (handler->txStream) {
rf_soapy_stop_tx_stream(handler);
SoapySDRDevice_closeStream(handler->device, handler->txStream); SoapySDRDevice_closeStream(handler->device, handler->txStream);
}
if (handler->rxStream) {
rf_soapy_stop_rx_stream(handler);
SoapySDRDevice_closeStream(handler->device, handler->rxStream); SoapySDRDevice_closeStream(handler->device, handler->rxStream);
}
SoapySDRDevice_unmake(handler->device); SoapySDRDevice_unmake(handler->device);
free(handler);
return SRSLTE_SUCCESS;
} }
void rf_soapy_set_master_clock_rate(void *h, double rate) void rf_soapy_set_master_clock_rate(void *h, double rate)
{ {
// Allow the soapy to automatically set the appropriate clock rate // Allow the soapy to automatically set the appropriate clock rate
// TODO: implement this function
printf("SET MASTER CLOCK RATE\n");
} }
bool rf_soapy_is_master_clock_dynamic(void *h) bool rf_soapy_is_master_clock_dynamic(void *h)
{ {
printf("TODO: implement rf_soapy_is_master_clock_dynamic()\n");
return false;
} }
double rf_soapy_set_rx_srate(void *h, double rate) double rf_soapy_set_rx_srate(void *h, double rate)
{ {
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h; rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h;
if (SoapySDRDevice_setSampleRate(handler->device, SOAPY_SDR_RX, 0, rate) != 0) if (SoapySDRDevice_setSampleRate(handler->device, SOAPY_SDR_RX, 0, rate) != 0) {
{
printf("setSampleRate fail: %s\n", SoapySDRDevice_lastError()); printf("setSampleRate fail: %s\n", SoapySDRDevice_lastError());
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
return SoapySDRDevice_getSampleRate(handler->device, SOAPY_SDR_RX,0);
double ret = SoapySDRDevice_getSampleRate(handler->device, SOAPY_SDR_RX,0);
printf("Sampling rate is set to %f.3 : \n",ret);
return ret;
} }
double rf_soapy_set_tx_srate(void *h, double rate) double rf_soapy_set_tx_srate(void *h, double rate)
{ {
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h; rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h;
if (SoapySDRDevice_setSampleRate(handler->device, SOAPY_SDR_TX, 0, rate) != 0) if (SoapySDRDevice_setSampleRate(handler->device, SOAPY_SDR_TX, 0, rate) != 0) {
{
printf("setSampleRate fail: %s\n", SoapySDRDevice_lastError()); printf("setSampleRate fail: %s\n", SoapySDRDevice_lastError());
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
double ret = SoapySDRDevice_getSampleRate(handler->device, SOAPY_SDR_TX,0); return SoapySDRDevice_getSampleRate(handler->device, SOAPY_SDR_TX,0);
printf("Sampling rate is set to %f.3 : \n",ret);
return ret;
} }
double rf_soapy_set_rx_gain(void *h, double gain) double rf_soapy_set_rx_gain(void *h, double gain)
{ {
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h; rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h;
if (SoapySDRDevice_setGain(handler->device, SOAPY_SDR_RX, 0, gain) != 0) if (SoapySDRDevice_setGain(handler->device, SOAPY_SDR_RX, 0, gain) != 0)
{ {
printf("setGain fail: %s\n", SoapySDRDevice_lastError()); printf("setGain fail: %s\n", SoapySDRDevice_lastError());
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
double ret = rf_soapy_get_rx_gain(h); return rf_soapy_get_rx_gain(h);
printf("gain has been set to %f.2 \n",ret);
return ret;
} }
double rf_soapy_set_tx_gain(void *h, double gain) double rf_soapy_set_tx_gain(void *h, double gain)
{ {
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h; rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h;
@ -308,28 +300,26 @@ double rf_soapy_set_tx_gain(void *h, double gain)
printf("setGain fail: %s\n", SoapySDRDevice_lastError()); printf("setGain fail: %s\n", SoapySDRDevice_lastError());
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
double ret = rf_soapy_get_rx_gain(h); return rf_soapy_get_rx_gain(h);
printf("gain has been set to %f.2 \n",ret);
return ret;
} }
double rf_soapy_get_rx_gain(void *h) double rf_soapy_get_rx_gain(void *h)
{ {
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h; rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h;
return SoapySDRDevice_getGain(handler->device,SOAPY_SDR_RX,0); return SoapySDRDevice_getGain(handler->device,SOAPY_SDR_RX,0);
} }
double rf_soapy_get_tx_gain(void *h) double rf_soapy_get_tx_gain(void *h)
{ {
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h; rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h;
return SoapySDRDevice_getGain(handler->device,SOAPY_SDR_TX,0); return SoapySDRDevice_getGain(handler->device,SOAPY_SDR_TX,0);
} }
double rf_soapy_set_rx_freq(void *h, double freq) double rf_soapy_set_rx_freq(void *h, double freq)
{ {
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h; rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h;
if (SoapySDRDevice_setFrequency(handler->device, SOAPY_SDR_RX, 0, freq, NULL) != 0) if (SoapySDRDevice_setFrequency(handler->device, SOAPY_SDR_RX, 0, freq, NULL) != 0)
{ {
@ -337,10 +327,7 @@ double rf_soapy_set_rx_freq(void *h, double freq)
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
double ret = SoapySDRDevice_getFrequency(handler->device, SOAPY_SDR_RX, 0); return SoapySDRDevice_getFrequency(handler->device, SOAPY_SDR_RX, 0);
printf("Frequency has been set to %f : \n",ret);
return ret;
} }
double rf_soapy_set_tx_freq(void *h, double freq) double rf_soapy_set_tx_freq(void *h, double freq)
@ -351,10 +338,7 @@ double rf_soapy_set_tx_freq(void *h, double freq)
printf("setFrequency fail: %s\n", SoapySDRDevice_lastError()); printf("setFrequency fail: %s\n", SoapySDRDevice_lastError());
return SRSLTE_ERROR; return SRSLTE_ERROR;
} }
double ret = SoapySDRDevice_getFrequency(handler->device, SOAPY_SDR_RX, 0); return SoapySDRDevice_getFrequency(handler->device, SOAPY_SDR_RX, 0);
printf("Frequency has been set to %f : \n",ret);
return ret;
} }
@ -382,7 +366,6 @@ int rf_soapy_recv_with_time_multi(void *h,
long long timeNs; //timestamp for receive buffer long long timeNs; //timestamp for receive buffer
int n = 0; int n = 0;
do { do {
size_t rx_samples = nsamples; size_t rx_samples = nsamples;
if (rx_samples > nsamples - n) if (rx_samples > nsamples - n)
@ -396,9 +379,17 @@ int rf_soapy_recv_with_time_multi(void *h,
buffs_ptr[i] = &data_c[n]; buffs_ptr[i] = &data_c[n];
} //(void*)(&data) } //(void*)(&data)
ret = SoapySDRDevice_readStream(handler->device, handler->rxStream, buffs_ptr , rx_samples, &flags, &timeNs, 1000000); ret = SoapySDRDevice_readStream(handler->device, handler->rxStream, buffs_ptr , rx_samples, &flags, &timeNs, 1000000);
if(ret < 0) {
if(ret < 0) // continue when getting overflows
if (ret == SOAPY_SDR_OVERFLOW) {
fprintf(stderr, "O");
fflush(stderr);
continue;
} else {
return SRSLTE_ERROR; return SRSLTE_ERROR;
}
}
n += ret; n += ret;
trials++; trials++;
} while (n < nsamples && trials < 100); } while (n < nsamples && trials < 100);
@ -408,8 +399,6 @@ int rf_soapy_recv_with_time_multi(void *h,
//*frac_secs = (timeNs % 1000000000)/1000000000; //*frac_secs = (timeNs % 1000000000)/1000000000;
// printf("ret=%d, flags=%d, timeNs=%lld\n", ret, flags, timeNs); // printf("ret=%d, flags=%d, timeNs=%lld\n", ret, flags, timeNs);
return n; return n;
} }
int rf_soapy_recv_with_time(void *h, int rf_soapy_recv_with_time(void *h,
@ -433,25 +422,14 @@ int rf_soapy_send_timed(void *h,
bool is_start_of_burst, bool is_start_of_burst,
bool is_end_of_burst) bool is_end_of_burst)
{ {
int flags; int flags;
long long timeNs; long long timeNs;
rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h; rf_soapy_handler_t *handler = (rf_soapy_handler_t*) h;
timeNs = secs * 1000000000; timeNs = secs * 1000000000;
timeNs = timeNs + (frac_secs * 1000000000); timeNs = timeNs + (frac_secs * 1000000000);
int ret = SoapySDRDevice_writeStream(handler->device, handler->txStream, &data, nsamples, &flags, timeNs, 100000); int ret = SoapySDRDevice_writeStream(handler->device, handler->txStream, data, nsamples, &flags, timeNs, 100000);
if(ret != nsamples) if(ret != nsamples)
return SRSLTE_ERROR; return SRSLTE_ERROR;
return ret; return ret;
} }