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

Moved AGC thread to rf module

This commit is contained in:
ismagom 2015-12-17 09:30:49 +01:00
parent 95deb18c39
commit ec6e0bf071
11 changed files with 103 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
srslte/examples/cell_measurement.c
View File

@ -158,20 +158,20 @@ int main(int argc, char **argv) {
exit(-1);
}
printf("Opening RF device...\n");
if (srslte_rf_open(&rf, prog_args.rf_args)) {
fprintf(stderr, "Error opening rf\n");
exit(-1);
}
if (prog_args.rf_gain > 0) {
printf("Opening RF device...\n");
if (srslte_rf_open(&rf, prog_args.rf_args)) {
fprintf(stderr, "Error opening rf\n");
exit(-1);
}
srslte_rf_set_rx_gain(&rf, prog_args.rf_gain);
} else {
printf("Opening RF device with threaded RX Gain control ...\n");
if (srslte_rf_open_th(&rf, prog_args.rf_args, false)) {
printf("Starting AGC thread...\n");
if (srslte_rf_start_gain_thread(&rf, false)) {
fprintf(stderr, "Error opening rf\n");
exit(-1);
}
srslte_rf_set_rx_gain(&rf, 50);
srslte_rf_set_rx_gain(&rf, 50);
}
sigset_t sigset;

14
srslte/examples/cell_search.c
View File

@ -154,16 +154,16 @@ int main(int argc, char **argv) {
parse_args(argc, argv);
printf("Opening RF device...\n");
if (srslte_rf_open(&rf, rf_args)) {
fprintf(stderr, "Error opening rf\n");
exit(-1);
}
if (!config.init_agc) {
printf("Opening RF device...\n");
if (srslte_rf_open(&rf, rf_args)) {
fprintf(stderr, "Error opening rf\n");
exit(-1);
}
srslte_rf_set_rx_gain(&rf, rf_gain);
} else {
printf("Opening RF device with threaded RX Gain control ...\n");
if (srslte_rf_open_th(&rf, rf_args, false)) {
printf("Starting AGC thread...\n");
if (srslte_rf_start_gain_thread(&rf, false)) {
fprintf(stderr, "Error opening rf\n");
exit(-1);
}

14
srslte/examples/pdsch_ue.c
View File

@ -298,17 +298,17 @@ int main(int argc, char **argv) {
#ifndef DISABLE_RF
if (!prog_args.input_file_name) {
printf("Opening RF device...\n");
if (srslte_rf_open(&rf, prog_args.rf_args)) {
fprintf(stderr, "Error opening rf\n");
exit(-1);
}
/* Set receiver gain */
if (prog_args.rf_gain > 0) {
printf("Opening RF device...\n");
if (srslte_rf_open(&rf, prog_args.rf_args)) {
fprintf(stderr, "Error opening rf\n");
exit(-1);
}
srslte_rf_set_rx_gain(&rf, prog_args.rf_gain);
} else {
printf("Opening RF device with threaded RX Gain control ...\n");
if (srslte_rf_open_th(&rf, prog_args.rf_args, false)) {
printf("Starting AGC thread...\n");
if (srslte_rf_start_gain_thread(&rf, false)) {
fprintf(stderr, "Error opening rf\n");
exit(-1);
}

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

@ -30,11 +30,22 @@
#include <sys/time.h>
#include <stdbool.h>
#include <stdint.h>
#include <pthread.h>
#include "srslte/config.h"
typedef struct {
void *handler;
void *dev;
// The following variables are for threaded RX gain control
pthread_t thread_gain;
pthread_cond_t cond;
pthread_mutex_t mutex;
double cur_rx_gain;
double new_rx_gain;
bool tx_gain_same_rx;
float tx_rx_gain_offset;
} srslte_rf_t;
typedef void (*srslte_rf_msg_handler_t)(const char*);
@ -42,15 +53,12 @@ typedef void (*srslte_rf_msg_handler_t)(const char*);
SRSLTE_API int srslte_rf_open(srslte_rf_t *h,
char *args);
SRSLTE_API int srslte_rf_open_th(srslte_rf_t *h,
char *args,
bool tx_gain_same_rx);
SRSLTE_API int srslte_rf_open_devname(srslte_rf_t *h,
char *devname,
char *args,
bool agc_thread,
bool tx_gain_same_rx);
char *args);
SRSLTE_API int srslte_rf_start_gain_thread(srslte_rf_t *rf,
bool tx_gain_same_rx);
SRSLTE_API int srslte_rf_close(srslte_rf_t *h);

6
srslte/lib/agc/src/agc.c
View File

@ -124,11 +124,11 @@ void srslte_agc_process(srslte_agc_t *q, cf_t *signal, uint32_t len) {
if (!q->uhd_handler) {
srslte_vec_sc_prod_cfc(signal, q->gain, signal, len);
} else {
if (q->gain < 1) {
q->gain = 1.0;
if (gain_db < 0) {
gain_db = 0.0;
}
if (isinf(gain_db) || isnan(gain_db)) {
q->gain = 10.0;
gain_db = 10.0;
} else {
gain_uhd_db = q->set_gain_callback(q->uhd_handler, gain_db);
q->gain = pow(10, gain_uhd_db/10);

11
srslte/lib/rf/src/rf_blade_imp.c
View File

@ -172,16 +172,7 @@ float rf_blade_get_rssi(void *h)
return 0;
}
double rf_blade_set_rx_gain_th(void *h, double gain)
{
return rf_blade_set_rx_gain(h, gain);
}
void rf_blade_set_tx_rx_gain_offset(void *h, double offset)
{
}
int rf_blade_open(char *args, void **h, bool create_thread_gain, bool tx_gain_same_rx)
int rf_blade_open(char *args, void **h)
{
*h = NULL;

13
srslte/lib/rf/src/rf_blade_imp.h
View File

@ -29,9 +29,7 @@
#include "srslte/rf/rf.h"
SRSLTE_API int rf_blade_open(char *args,
void **handler,
bool agc_thread,
bool tx_gain_same_rx);
void **handler);
SRSLTE_API int rf_blade_close(void *h);
@ -61,15 +59,6 @@ SRSLTE_API double rf_blade_set_rx_srate(void *h,
SRSLTE_API double rf_blade_set_rx_gain(void *h,
double gain);
SRSLTE_API void rf_blade_set_tx_rx_gain_offset(void *h,
double offset);
SRSLTE_API double rf_blade_set_rx_gain_th(void *h,
double gain);
SRSLTE_API double rf_blade_set_tx_gain_th(void *h,
double gain);
SRSLTE_API float rf_blade_get_rx_gain_offset(void *h);
SRSLTE_API double rf_blade_get_rx_gain(void *h);

8
srslte/lib/rf/src/rf_dev.h
View File

@ -34,11 +34,9 @@ typedef struct {
void (*srslte_rf_flush_buffer)(void *h);
bool (*srslte_rf_has_rssi)(void *h);
float (*srslte_rf_get_rssi)(void *h);
double (*srslte_rf_set_rx_gain_th)(void *h, double gain);
void (*srslte_rf_set_tx_rx_gain_offset)(void *h, double offset);
void (*srslte_rf_suppress_stdout)(void *h);
void (*srslte_rf_register_msg_handler)(void *h, srslte_rf_msg_handler_t msg_handler);
int (*srslte_rf_open)(char *args, void **h, bool agc_thread, bool tx_gain_same_rx);
int (*srslte_rf_open)(char *args, void **h);
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);
@ -71,8 +69,6 @@ static rf_dev_t dev_uhd = {
rf_uhd_flush_buffer,
rf_uhd_has_rssi,
rf_uhd_get_rssi,
rf_uhd_set_rx_gain_th,
rf_uhd_set_tx_rx_gain_offset,
rf_uhd_suppress_stdout,
rf_uhd_register_msg_handler,
rf_uhd_open,
@ -106,8 +102,6 @@ static rf_dev_t dev_blade = {
rf_blade_flush_buffer,
rf_blade_has_rssi,
rf_blade_get_rssi,
rf_blade_set_rx_gain_th,
rf_blade_set_tx_rx_gain_offset,
rf_blade_suppress_stdout,
rf_blade_register_msg_handler,
rf_blade_open,

77
srslte/lib/rf/src/rf_imp.c
View File

@ -39,15 +39,69 @@ int rf_get_available_devices(char **devnames, int max_strlen) {
return i;
}
double srslte_rf_set_rx_gain_th(srslte_rf_t *rf, double gain)
{
if (gain > rf->new_rx_gain + 0.5 || gain < rf->new_rx_gain - 0.5) {
pthread_mutex_lock(&rf->mutex);
rf->new_rx_gain = gain;
pthread_cond_signal(&rf->cond);
pthread_mutex_unlock(&rf->mutex);
}
return gain;
}
int srslte_rf_open_devname(srslte_rf_t *rf, char *devname, char *args, bool agc_thread, bool tx_gain_same_rx) {
void srslte_rf_set_tx_rx_gain_offset(srslte_rf_t *rf, double offset) {
rf->tx_rx_gain_offset = offset;
}
/* This thread listens for set_rx_gain commands to the USRP */
static void* thread_gain_fcn(void *h) {
srslte_rf_t* rf = (srslte_rf_t*) h;
while(1) {
pthread_mutex_lock(&rf->mutex);
while(rf->cur_rx_gain == rf->new_rx_gain)
{
pthread_cond_wait(&rf->cond, &rf->mutex);
}
if (rf->new_rx_gain != rf->cur_rx_gain) {
rf->cur_rx_gain = rf->new_rx_gain;
srslte_rf_set_rx_gain(h, rf->cur_rx_gain);
}
if (rf->tx_gain_same_rx) {
srslte_rf_set_tx_gain(h, rf->cur_rx_gain+rf->tx_rx_gain_offset);
}
pthread_mutex_unlock(&rf->mutex);
}
return NULL;
}
/* Create auxiliary thread and mutexes for AGC */
int srslte_rf_start_gain_thread(srslte_rf_t *rf, bool tx_gain_same_rx) {
rf->tx_gain_same_rx = tx_gain_same_rx;
rf->tx_rx_gain_offset = 0.0;
if (pthread_mutex_init(&rf->mutex, NULL)) {
return -1;
}
if (pthread_cond_init(&rf->cond, NULL)) {
return -1;
}
if (pthread_create(&rf->thread_gain, NULL, thread_gain_fcn, rf)) {
perror("pthread_create");
return -1;
}
return 0;
}
int srslte_rf_open_devname(srslte_rf_t *rf, char *devname, char *args) {
/* Try to open the device if name is provided */
if (devname) {
int i=0;
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, agc_thread, tx_gain_same_rx);
return available_devices[i]->srslte_rf_open(args, &rf->handler);
}
i++;
}
@ -57,7 +111,7 @@ int srslte_rf_open_devname(srslte_rf_t *rf, char *devname, char *args, bool agc_
/* If in auto mode or provided device not found, try to open in order of apperance in available_devices[] array */
int i=0;
while(available_devices[i] != NULL) {
if (!available_devices[i]->srslte_rf_open(args, &rf->handler, agc_thread, tx_gain_same_rx)) {
if (!available_devices[i]->srslte_rf_open(args, &rf->handler)) {
rf->dev = available_devices[i];
return 0;
}
@ -98,16 +152,6 @@ float srslte_rf_get_rssi(srslte_rf_t *rf)
return ((rf_dev_t*) rf->dev)->srslte_rf_get_rssi(rf->handler);
}
double srslte_rf_set_rx_gain_th(srslte_rf_t *rf, double gain)
{
return ((rf_dev_t*) rf->dev)->srslte_rf_set_rx_gain_th(rf->handler, gain);
}
void srslte_rf_set_tx_rx_gain_offset(srslte_rf_t *rf, double offset)
{
((rf_dev_t*) rf->dev)->srslte_rf_set_tx_rx_gain_offset(rf->handler, offset);
}
void srslte_rf_suppress_stdout(srslte_rf_t *rf)
{
((rf_dev_t*) rf->dev)->srslte_rf_suppress_stdout(rf->handler);
@ -120,12 +164,7 @@ void srslte_rf_register_msg_handler(srslte_rf_t *rf, srslte_rf_msg_handler_t msg
int srslte_rf_open(srslte_rf_t *h, char *args)
{
return srslte_rf_open_devname(h, NULL, args, false, false);
}
int srslte_rf_open_th(srslte_rf_t *h, char *args, bool tx_gain_same_rx)
{
return srslte_rf_open_devname(h, NULL, args, true, tx_gain_same_rx);
return srslte_rf_open_devname(h, NULL, args);
}
int srslte_rf_close(srslte_rf_t *rf)

66
srslte/lib/rf/src/rf_uhd_imp.c
View File

@ -43,15 +43,7 @@ typedef struct {
uhd_rx_metadata_handle rx_md, rx_md_first;
uhd_tx_metadata_handle tx_md;
// The following variables are for threaded RX gain control
uhd_meta_range_handle rx_gain_range;
pthread_t thread_gain;
pthread_cond_t cond;
pthread_mutex_t mutex;
double cur_rx_gain;
double new_rx_gain;
bool tx_gain_same_rx;
float tx_rx_gain_offset;
size_t rx_nof_samples;
size_t tx_nof_samples;
double tx_rate;
@ -190,47 +182,7 @@ float rf_uhd_get_rssi(void *h) {
return val_out;
}
double rf_uhd_set_rx_gain_th(void *h, double gain)
{
rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h;
double gain_clipped;
uhd_meta_range_clip(handler->rx_gain_range, gain, true, &gain_clipped);
if (gain_clipped > handler->new_rx_gain + 0.5 || gain_clipped < handler->new_rx_gain - 0.5) {
pthread_mutex_lock(&handler->mutex);
handler->new_rx_gain = gain_clipped;
pthread_cond_signal(&handler->cond);
pthread_mutex_unlock(&handler->mutex);
}
return gain_clipped;
}
void rf_uhd_set_tx_rx_gain_offset(void *h, double offset) {
rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h;
handler->tx_rx_gain_offset = offset;
}
/* This thread listens for set_rx_gain commands to the USRP */
static void* thread_gain_fcn(void *h) {
rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h;
while(1) {
pthread_mutex_lock(&handler->mutex);
while(handler->cur_rx_gain == handler->new_rx_gain)
{
pthread_cond_wait(&handler->cond, &handler->mutex);
}
if (handler->new_rx_gain != handler->cur_rx_gain) {
handler->cur_rx_gain = handler->new_rx_gain;
rf_uhd_set_rx_gain(h, handler->cur_rx_gain);
}
if (handler->tx_gain_same_rx) {
rf_uhd_set_tx_gain(h, handler->cur_rx_gain+handler->tx_rx_gain_offset);
}
pthread_mutex_unlock(&handler->mutex);
}
return NULL;
}
int rf_uhd_open(char *args, void **h, bool create_thread_gain, bool tx_gain_same_rx)
int rf_uhd_open(char *args, void **h)
{
*h = NULL;
@ -291,8 +243,6 @@ int rf_uhd_open(char *args, void **h, bool create_thread_gain, bool tx_gain_same
uhd_rx_streamer_max_num_samps(handler->rx_stream, &handler->rx_nof_samples);
uhd_tx_streamer_max_num_samps(handler->tx_stream, &handler->tx_nof_samples);
handler->tx_gain_same_rx = tx_gain_same_rx;
handler->tx_rx_gain_offset = 0.0;
uhd_meta_range_make(&handler->rx_gain_range);
uhd_usrp_get_rx_gain_range(handler->usrp, "", 0, handler->rx_gain_range);
@ -300,20 +250,6 @@ int rf_uhd_open(char *args, void **h, bool create_thread_gain, bool tx_gain_same
uhd_rx_metadata_make(&handler->rx_md);
uhd_rx_metadata_make(&handler->rx_md_first);
uhd_tx_metadata_make(&handler->tx_md, false, 0, 0, false, false);
/* Create auxiliary thread and mutexes for AGC */
if (create_thread_gain) {
if (pthread_mutex_init(&handler->mutex, NULL)) {
return -1;
}
if (pthread_cond_init(&handler->cond, NULL)) {
return -1;
}
if (pthread_create(&handler->thread_gain, NULL, thread_gain_fcn, handler)) {
perror("pthread_create");
return -1;
}
}
/* Find out if the master clock rate is configurable */
double cur_clock, new_clock;

15
srslte/lib/rf/src/rf_uhd_imp.h
View File

@ -31,9 +31,7 @@
#include "srslte/rf/rf.h"
SRSLTE_API int rf_uhd_open(char *args,
void **handler,
bool agc_thread,
bool tx_gain_same_rx);
void **handler);
SRSLTE_API int rf_uhd_close(void *h);
@ -63,17 +61,6 @@ SRSLTE_API double rf_uhd_set_rx_srate(void *h,
SRSLTE_API double rf_uhd_set_rx_gain(void *h,
double gain);
SRSLTE_API void rf_uhd_set_tx_rx_gain_offset(void *h,
double offset);
SRSLTE_API double rf_uhd_set_rx_gain_th(void *h,
double gain);
SRSLTE_API double rf_uhd_set_tx_gain_th(void *h,
double gain);
SRSLTE_API float rf_uhd_get_rx_gain_offset(void *h);
SRSLTE_API double rf_uhd_get_rx_gain(void *h);
SRSLTE_API double rf_uhd_get_tx_gain(void *h);