From 2079c1324c06445dd7624f7f74331019870992e8 Mon Sep 17 00:00:00 2001 From: Merlin Chlosta Date: Wed, 4 Sep 2019 16:51:02 +0200 Subject: [PATCH] UHD: Wait for `lo_locked` after frequency change (#635) * UHD: clang-tidy rf_uhd_imp.c * UHD: wait for LO_lock after frequency change --- lib/src/phy/rf/rf_uhd_imp.c | 605 +++++++++++++++++++----------------- 1 file changed, 321 insertions(+), 284 deletions(-) diff --git a/lib/src/phy/rf/rf_uhd_imp.c b/lib/src/phy/rf/rf_uhd_imp.c index e75dd2850..bd7bc257d 100644 --- a/lib/src/phy/rf/rf_uhd_imp.c +++ b/lib/src/phy/rf/rf_uhd_imp.c @@ -19,17 +19,18 @@ * */ -#include -#include +#include #include +#include +#include #include -#include -#include "srslte/srslte.h" -#include "rf_uhd_imp.h" #include "rf_helper.h" +#include "srslte/srslte.h" #include "uhd_c_api.h" +#include "rf_uhd_imp.h" + #define HAVE_ASYNC_THREAD 1 #if UHD_VERSION < 3130000 @@ -37,41 +38,42 @@ #endif /* UHD_VERSION < 3140000 */ typedef struct { - char *devname; - uhd_usrp_handle usrp; + char* devname; + uhd_usrp_handle usrp; uhd_rx_streamer_handle rx_stream; uhd_tx_streamer_handle tx_stream; - - uhd_rx_metadata_handle rx_md, rx_md_first; - uhd_tx_metadata_handle tx_md; - + + uhd_rx_metadata_handle rx_md, rx_md_first; + uhd_tx_metadata_handle tx_md; + srslte_rf_info_t info; - size_t rx_nof_samples; - size_t tx_nof_samples; - double tx_rate; - bool dynamic_rate; - bool has_rssi; - uint32_t nof_rx_channels; - int nof_tx_channels; + size_t rx_nof_samples; + size_t tx_nof_samples; + double tx_rate; + bool dynamic_rate; + bool has_rssi; + uint32_t nof_rx_channels; + int nof_tx_channels; - srslte_rf_error_handler_t uhd_error_handler; + srslte_rf_error_handler_t uhd_error_handler; float current_master_clock; - bool async_thread_running; + bool async_thread_running; pthread_t async_thread; pthread_mutex_t tx_mutex; } rf_uhd_handler_t; -void suppress_handler(const char *x) +void suppress_handler(const char* x) { // do nothing } -cf_t zero_mem[64*1024]; +cf_t zero_mem[64 * 1024]; -static void log_overflow(rf_uhd_handler_t *h) { +static void log_overflow(rf_uhd_handler_t* h) +{ if (h->uhd_error_handler) { srslte_rf_error_t error; bzero(&error, sizeof(srslte_rf_error_t)); @@ -80,18 +82,20 @@ static void log_overflow(rf_uhd_handler_t *h) { } } -static void log_late(rf_uhd_handler_t *h, bool is_rx) { +static void log_late(rf_uhd_handler_t* h, bool is_rx) +{ if (h->uhd_error_handler) { srslte_rf_error_t error; bzero(&error, sizeof(srslte_rf_error_t)); - error.opt = is_rx?1:0; + error.opt = is_rx ? 1 : 0; error.type = SRSLTE_RF_ERROR_LATE; h->uhd_error_handler(error); } } #if HAVE_ASYNC_THREAD -static void log_underflow(rf_uhd_handler_t *h) { +static void log_underflow(rf_uhd_handler_t* h) +{ if (h->uhd_error_handler) { srslte_rf_error_t error; bzero(&error, sizeof(srslte_rf_error_t)); @@ -101,7 +105,8 @@ static void log_underflow(rf_uhd_handler_t *h) { } #endif -static void log_rx_error(rf_uhd_handler_t *h) { +static void log_rx_error(rf_uhd_handler_t* h) +{ if (h->uhd_error_handler) { char error_string[512]; uhd_usrp_last_error(h->usrp, error_string, 512); @@ -115,18 +120,19 @@ static void log_rx_error(rf_uhd_handler_t *h) { } #if HAVE_ASYNC_THREAD -static void* async_thread(void *h) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; - uhd_async_metadata_handle md; - uhd_async_metadata_make(&md); - while(handler->async_thread_running) { - bool valid; +static void* async_thread(void* h) +{ + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; + uhd_async_metadata_handle md; + uhd_async_metadata_make(&md); + while (handler->async_thread_running) { + bool valid; uhd_error err = uhd_tx_streamer_recv_async_msg(handler->tx_stream, &md, 0.5, &valid); if (err == UHD_ERROR_NONE) { if (valid) { - uhd_async_metadata_event_code_t event_code; + uhd_async_metadata_event_code_t event_code; uhd_async_metadata_event_code(md, &event_code); - if (event_code == UHD_ASYNC_METADATA_EVENT_CODE_UNDERFLOW || + if (event_code == UHD_ASYNC_METADATA_EVENT_CODE_UNDERFLOW || event_code == UHD_ASYNC_METADATA_EVENT_CODE_UNDERFLOW_IN_PACKET) { log_underflow(handler); } else if (event_code == UHD_ASYNC_METADATA_EVENT_CODE_TIME_ERROR) { @@ -135,108 +141,124 @@ static void* async_thread(void *h) { } } else { ERROR("Error while receiving aync metadata: 0x%x\n", err); - return NULL; + return NULL; } } uhd_async_metadata_free(&md); - return NULL; + return NULL; } #endif -void rf_uhd_suppress_stdout(void *h) { +void rf_uhd_suppress_stdout(void* h) +{ rf_uhd_register_msg_handler_c(suppress_handler); } -void rf_uhd_register_error_handler(void *h, srslte_rf_error_handler_t new_handler) +void rf_uhd_register_error_handler(void* h, srslte_rf_error_handler_t new_handler) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; handler->uhd_error_handler = new_handler; } -static bool find_string(uhd_string_vector_handle h, char *str) +static bool find_string(uhd_string_vector_handle h, char* str) { - char buff[128]; + char buff[128]; size_t n; uhd_string_vector_size(h, &n); - for (int i=0;iusrp, sensor_name, 0, value_h); - } else { - uhd_usrp_get_mboard_sensor(handler->usrp, sensor_name, 0, value_h); - } - uhd_sensor_value_to_bool(*value_h, &val_out); + uhd_error error; + *is_locked = false; + + uhd_sensor_value_handle value_h; + uhd_string_vector_handle sensors; + + uhd_string_vector_make(&sensors); + uhd_sensor_value_make_from_bool(&value_h, "", true, "True", "False"); + if (is_mboard) { + // motherboard sensor + error = uhd_usrp_get_mboard_sensor_names(handler->usrp, 0, &sensors); } else { - usleep(500); - val_out = true; + // daughterboard sensor + error = uhd_usrp_get_rx_sensor_names(handler->usrp, 0, &sensors); } - - return val_out; + + if (error == UHD_ERROR_NONE && find_string(sensors, sensor_name)) { + do { + if (is_mboard) { + error = uhd_usrp_get_mboard_sensor(handler->usrp, sensor_name, 0, &value_h); + } else { + error = uhd_usrp_get_rx_sensor(handler->usrp, sensor_name, 0, &value_h); + } + if (error != UHD_ERROR_NONE) { + break; + } + uhd_sensor_value_to_bool(value_h, is_locked); + usleep(1000); // 1ms + timeout -= 1; // 1ms + } while (*is_locked == false && timeout > 0); + } + if (error != UHD_ERROR_NONE) { + fprintf(stderr, + "%s has no sensor \"%s\", or reading failed. UHD error: %i\n", + is_mboard ? "Motherboard" : "Daugherboard", + sensor_name, + error); + // board doesn't have this sensor, sleep for timeout + *is_locked = true; + usleep(timeout * 1000); + } + + uhd_string_vector_free(&sensors); + uhd_sensor_value_free(&value_h); + + return error; } char* rf_uhd_devname(void* h) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; - return handler->devname; + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; + return handler->devname; } -bool rf_uhd_rx_wait_lo_locked(void *h) +bool rf_uhd_rx_wait_lo_locked(void* h) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; - - uhd_string_vector_handle mb_sensors; - uhd_string_vector_handle rx_sensors; - char *sensor_name; - uhd_sensor_value_handle value_h; - uhd_string_vector_make(&mb_sensors); - uhd_string_vector_make(&rx_sensors); - uhd_sensor_value_make_from_bool(&value_h, "", true, "True", "False"); - uhd_usrp_get_mboard_sensor_names(handler->usrp, 0, &mb_sensors); - uhd_usrp_get_rx_sensor_names(handler->usrp, 0, &rx_sensors); + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; - /*if (find_string(rx_sensors, "lo_locked")) { - sensor_name = "lo_locked"; - } else */if (find_string(mb_sensors, "ref_locked")) { - sensor_name = "ref_locked"; - } else { - sensor_name = NULL; - } - - double report = 0.0; - while (!isLocked(handler, sensor_name, false, &value_h) && report < 30.0) { - report += 0.1; - usleep(1000); - } + // wait for clock source to lock + char* sensor_name = "lo_locked"; + bool is_locked = false; - bool val = isLocked(handler, sensor_name, false, &value_h); - - uhd_string_vector_free(&mb_sensors); - uhd_string_vector_free(&rx_sensors); - uhd_sensor_value_free(&value_h); + // blocks until sensor is blocked + uhd_error error = wait_sensor_locked(handler, sensor_name, false, 300, &is_locked); - return val; + if (!is_locked || error != UHD_ERROR_NONE) { + fprintf(stderr, + "Could not lock reference clock source. Sensor: %s=%s, UHD error: %i\n", + sensor_name, + is_locked ? "true" : "false", + error); + } + + return is_locked; } -int rf_uhd_start_rx_stream(void *h, bool now) +int rf_uhd_start_rx_stream(void* h, bool now) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; - uhd_stream_cmd_t stream_cmd = { - .stream_mode = UHD_STREAM_MODE_START_CONTINUOUS, - .stream_now = now - }; + uhd_stream_cmd_t stream_cmd = {.stream_mode = UHD_STREAM_MODE_START_CONTINUOUS, .stream_now = now}; if (!now) { uhd_usrp_get_time_now(handler->usrp, 0, &stream_cmd.time_spec_full_secs, &stream_cmd.time_spec_frac_secs); stream_cmd.time_spec_frac_secs += 0.2; @@ -249,45 +271,45 @@ int rf_uhd_start_rx_stream(void *h, bool now) return 0; } -int rf_uhd_stop_rx_stream(void *h) +int rf_uhd_stop_rx_stream(void* h) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; - uhd_stream_cmd_t stream_cmd = { - .stream_mode = UHD_STREAM_MODE_STOP_CONTINUOUS, - .stream_now = true - }; + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; + uhd_stream_cmd_t stream_cmd = {.stream_mode = UHD_STREAM_MODE_STOP_CONTINUOUS, .stream_now = true}; uhd_rx_streamer_issue_stream_cmd(handler->rx_stream, &stream_cmd); return 0; } -void rf_uhd_flush_buffer(void *h) +void rf_uhd_flush_buffer(void* h) { - int n; - cf_t tmp1[1024]; - cf_t tmp2[1024]; - void *data[2] = {tmp1, tmp2}; + int n; + cf_t tmp1[1024]; + cf_t tmp2[1024]; + void* data[2] = {tmp1, tmp2}; do { n = rf_uhd_recv_with_time_multi(h, data, 1024, 0, NULL, NULL); - } while (n > 0); + } while (n > 0); } -bool rf_uhd_has_rssi(void *h) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; +bool rf_uhd_has_rssi(void* h) +{ + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; return handler->has_rssi; } -bool get_has_rssi(void *h) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; - uhd_string_vector_handle rx_sensors; +bool get_has_rssi(void* h) +{ + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; + uhd_string_vector_handle rx_sensors; uhd_string_vector_make(&rx_sensors); uhd_usrp_get_rx_sensor_names(handler->usrp, 0, &rx_sensors); - bool ret = find_string(rx_sensors, "rssi"); + bool ret = find_string(rx_sensors, "rssi"); uhd_string_vector_free(&rx_sensors); - return ret; + return ret; } -float rf_uhd_get_rssi(void *h) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; +float rf_uhd_get_rssi(void* h) +{ + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; if (handler->has_rssi) { double val_out; @@ -303,23 +325,23 @@ float rf_uhd_get_rssi(void *h) { } } -int rf_uhd_open(char *args, 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_channels) +int rf_uhd_open_multi(char* args, void** h, uint32_t nof_channels) { if (h) { - *h = NULL; - - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) malloc(sizeof(rf_uhd_handler_t)); + *h = NULL; + + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)malloc(sizeof(rf_uhd_handler_t)); if (!handler) { perror("malloc"); - return -1; + return -1; } bzero(handler, sizeof(rf_uhd_handler_t)); - *h = handler; + *h = handler; // Disable fast-path (U/L/O) messages setenv("UHD_LOG_FASTPATH_DISABLE", "1", 0); @@ -331,26 +353,26 @@ int rf_uhd_open_multi(char *args, void **h, uint32_t nof_channels) uhd_string_vector_handle devices_str; uhd_string_vector_make(&devices_str); uhd_usrp_find("", &devices_str); - - char args2[512]; - + + char args2[512]; + handler->dynamic_rate = true; - + // Allow NULL parameter if (args == NULL) { args = ""; - } + } handler->devname = NULL; pthread_mutex_init(&handler->tx_mutex, NULL); // Initialize handler handler->uhd_error_handler = NULL; - - bzero(zero_mem, sizeof(cf_t)*64*1024); + + bzero(zero_mem, sizeof(cf_t) * 64 * 1024); // Check external clock argument - enum {DEFAULT, EXTERNAL, GPSDO} clock_src; + enum { DEFAULT, EXTERNAL, GPSDO } clock_src; if (strstr(args, "clock=external")) { REMOVE_SUBSTRING_WITHCOMAS(args, "clock=external"); clock_src = EXTERNAL; @@ -371,7 +393,7 @@ int rf_uhd_open_multi(char *args, void **h, uint32_t nof_channels) #endif // Set over the wire format - char *otw_format = "sc16"; + char* otw_format = "sc16"; if (strstr(args, "otw_format=sc12")) { REMOVE_SUBSTRING_WITHCOMAS(args, "otw_format=sc12"); otw_format = "sc12"; @@ -384,17 +406,17 @@ int rf_uhd_open_multi(char *args, void **h, uint32_t nof_channels) } // Set transmitter subdevice spec string - const char tx_subdev_arg[] = "tx_subdev_spec="; - char tx_subdev_str[64] = {0}; - char *tx_subdev_ptr = strstr(args, tx_subdev_arg); + const char tx_subdev_arg[] = "tx_subdev_spec="; + char tx_subdev_str[64] = {0}; + char* tx_subdev_ptr = strstr(args, tx_subdev_arg); if (tx_subdev_ptr) { copy_subdev_string(tx_subdev_str, tx_subdev_ptr + strlen(tx_subdev_arg)); } // Set receiver subdevice spec string - const char rx_subdev_arg[] = "rx_subdev_spec="; - char rx_subdev_str[64] = {0}; - char *rx_subdev_ptr = strstr(args, rx_subdev_arg); + const char rx_subdev_arg[] = "rx_subdev_spec="; + char rx_subdev_str[64] = {0}; + char* rx_subdev_ptr = strstr(args, rx_subdev_arg); if (rx_subdev_ptr) { copy_subdev_string(rx_subdev_str, rx_subdev_ptr + strlen(rx_subdev_arg)); } @@ -410,66 +432,66 @@ int rf_uhd_open_multi(char *args, void **h, uint32_t nof_channels) } /* If device type or name not given in args, choose a B200 */ - if (args[0]=='\0') { + if (args[0] == '\0') { if (find_string(devices_str, "type=b200") && !strstr(args, "recv_frame_size")) { // If B200 is available, use it args = "type=b200,master_clock_rate=23.04e6"; handler->current_master_clock = 23040000; - handler->devname = DEVNAME_B200; + handler->devname = DEVNAME_B200; } else if (find_string(devices_str, "type=x300")) { // Else if X300 is available, set master clock rate now (can't be changed later) - args = "type=x300,master_clock_rate=184.32e6"; + args = "type=x300,master_clock_rate=184.32e6"; handler->current_master_clock = 184320000; - handler->dynamic_rate = false; - handler->devname = DEVNAME_X300; + handler->dynamic_rate = false; + handler->devname = DEVNAME_X300; } else if (find_string(devices_str, "type=e3x0")) { // Else if E3X0 is available, set master clock rate now (can't be changed later) - args = "type=e3x0,master_clock_rate=30.72e6"; + args = "type=e3x0,master_clock_rate=30.72e6"; handler->dynamic_rate = false; - handler->devname = DEVNAME_E3X0; + handler->devname = DEVNAME_E3X0; } else if (find_string(devices_str, "type=n3xx")) { - args = "type=n3xx,master_clock_rate=122.88e6"; + args = "type=n3xx,master_clock_rate=122.88e6"; handler->current_master_clock = 122880000; - handler->dynamic_rate = false; - handler->devname = DEVNAME_N300; + handler->dynamic_rate = false; + handler->devname = DEVNAME_N300; srslte_use_standard_symbol_size(true); } } else { // If args is set and x300 type is specified, make sure master_clock_rate is defined if (strstr(args, "type=x300") && !strstr(args, "master_clock_rate")) { - sprintf(args2, "%s,master_clock_rate=184.32e6",args); - args = args2; + sprintf(args2, "%s,master_clock_rate=184.32e6", args); + args = args2; handler->current_master_clock = 184320000; - handler->dynamic_rate = false; - handler->devname = DEVNAME_X300; + handler->dynamic_rate = false; + handler->devname = DEVNAME_X300; } else if (strstr(args, "type=n3xx")) { sprintf(args2, "%s,master_clock_rate=122.88e6", args); - args = args2; + args = args2; handler->current_master_clock = 122880000; - handler->dynamic_rate = false; - handler->devname = DEVNAME_N300; + handler->dynamic_rate = false; + handler->devname = DEVNAME_N300; srslte_use_standard_symbol_size(true); - } else if (strstr(args, "type=e3x0")) { + } else if (strstr(args, "type=e3x0")) { snprintf(args2, sizeof(args2), "%s,master_clock_rate=30.72e6", args); - args = args2; + args = args2; handler->devname = DEVNAME_E3X0; } else { snprintf(args2, sizeof(args2), "%s,master_clock_rate=23.04e6", args); - args = args2; + args = args2; handler->current_master_clock = 23040000; - handler->devname = DEVNAME_B200; + handler->devname = DEVNAME_B200; } } - + uhd_string_vector_free(&devices_str); - + /* Create UHD handler */ printf("Opening USRP with args: %s\n", args); uhd_error error = uhd_usrp_make(&handler->usrp, args); if (error) { fprintf(stderr, "Error opening UHD: code %d\n", error); free(handler); - return -1; + return -1; } /* Set transmitter subdev spec if specified */ @@ -500,61 +522,79 @@ int rf_uhd_open_multi(char *args, void **h, uint32_t nof_channels) if (strstr(dev_str, "B2") || strstr(dev_str, "B2")) { handler->devname = DEVNAME_B200; } else if (strstr(dev_str, "X3") || strstr(dev_str, "X3")) { - handler->devname = DEVNAME_X300; + handler->devname = DEVNAME_X300; } else if (strstr(dev_str, "n3xx")) { handler->devname = DEVNAME_N300; } } if (!handler->devname) { - handler->devname = "uhd_unknown"; + handler->devname = "uhd_unknown"; } - - // Set external clock reference + + bool is_locked = false; + char* sensor_name = ""; + + // Set external clock reference if (clock_src == EXTERNAL) { uhd_usrp_set_clock_source(handler->usrp, "external", 0); uhd_usrp_set_time_source(handler->usrp, "external", 0); + sensor_name = "ref_locked"; } else if (clock_src == GPSDO) { uhd_usrp_set_clock_source(handler->usrp, "gpsdo", 0); uhd_usrp_set_time_source(handler->usrp, "gpsdo", 0); + sensor_name = "gps_locked"; + } + // wait until external reference / GPS is locked + if (clock_src != DEFAULT) { + // blocks until clock source is locked + error = wait_sensor_locked(handler, sensor_name, true, 300, &is_locked); + + if (!is_locked || error != UHD_ERROR_NONE) { + fprintf(stderr, + "Could not lock reference clock source. Sensor: %s=%s, UHD error: %i\n", + sensor_name, + is_locked ? "true" : "false", + error); + } } handler->has_rssi = get_has_rssi(handler); - size_t channel[4] = {0, 1, 2, 3}; + size_t channel[4] = {0, 1, 2, 3}; uhd_stream_args_t stream_args = { - .cpu_format = "fc32", - .otw_format = otw_format, - .args = "", - .channel_list = channel, - .n_channels = nof_channels, + .cpu_format = "fc32", + .otw_format = otw_format, + .args = "", + .channel_list = channel, + .n_channels = nof_channels, }; - + handler->nof_rx_channels = nof_channels; handler->nof_tx_channels = nof_channels; /* Set default rate to avoid decimation warnings */ - for (int i=0;iusrp, 1.92e6, i); uhd_usrp_set_tx_rate(handler->usrp, 1.92e6, i); } if (nof_channels > 1) - uhd_usrp_set_time_unknown_pps(handler->usrp, 0, 0.0); + uhd_usrp_set_time_unknown_pps(handler->usrp, 0, 0.0); /* Initialize rx and tx stremers */ uhd_rx_streamer_make(&handler->rx_stream); error = uhd_usrp_get_rx_stream(handler->usrp, &stream_args, handler->rx_stream); if (error) { ERROR("Error opening RX stream: %d\n", error); - return -1; + return -1; } uhd_tx_streamer_make(&handler->tx_stream); error = uhd_usrp_get_tx_stream(handler->usrp, &stream_args, handler->tx_stream); if (error) { ERROR("Error opening TX stream: %d\n", error); - return -1; + return -1; } - + 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); @@ -578,7 +618,7 @@ int rf_uhd_open_multi(char *args, void **h, uint32_t nof_channels) uhd_tx_metadata_make(&handler->tx_md, false, 0, 0, false, false); // Set starting gain to half maximum in case of using AGC - rf_uhd_set_rx_gain(handler, handler->info.max_rx_gain*0.7); + rf_uhd_set_rx_gain(handler, handler->info.max_rx_gain * 0.7); #if HAVE_ASYNC_THREAD if (start_async_thread) { @@ -596,17 +636,16 @@ int rf_uhd_open_multi(char *args, void **h, uint32_t nof_channels) return 0; } else { - return SRSLTE_ERROR_INVALID_INPUTS; + return SRSLTE_ERROR_INVALID_INPUTS; } } - -int rf_uhd_close(void *h) +int rf_uhd_close(void* h) { rf_uhd_stop_rx_stream(h); - - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; - + + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; + uhd_tx_metadata_free(&handler->tx_md); uhd_rx_metadata_free(&handler->rx_md_first); uhd_rx_metadata_free(&handler->rx_md); @@ -623,13 +662,14 @@ int rf_uhd_close(void *h) uhd_usrp_free(&handler->usrp); free(handler); - + /** Something else to close the USRP?? */ return SRSLTE_SUCCESS; } -void rf_uhd_set_master_clock_rate(void *h, double rate) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; +void rf_uhd_set_master_clock_rate(void* h, double rate) +{ + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; if (fmod(handler->current_master_clock, rate)) { if (handler->dynamic_rate) { uhd_usrp_set_master_clock_rate(handler->usrp, rate, 0); @@ -638,21 +678,25 @@ void rf_uhd_set_master_clock_rate(void *h, double rate) { } } -bool rf_uhd_is_master_clock_dynamic(void *h) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; +bool rf_uhd_is_master_clock_dynamic(void* h) +{ + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; return handler->dynamic_rate; } -double rf_uhd_set_rx_srate(void *h, double freq) +double rf_uhd_set_rx_srate(void* h, double freq) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; if (handler->nof_rx_channels > 1) { #ifdef UHD_SUPPORTS_COMMAND_TIME time_t full; double frac; uhd_usrp_get_time_now(handler->usrp, 0, &full, &frac); frac += 0.100; - if (frac >= 1.0) { full++; frac -= 1.0; }; + if (frac >= 1.0) { + full++; + frac -= 1.0; + }; uhd_usrp_set_command_time(handler->usrp, full, frac, 0); #endif /* UHD_SUPPORTS_COMMAND_TIME */ for (int i = 0; i < handler->nof_rx_channels; i++) { @@ -667,16 +711,19 @@ double rf_uhd_set_rx_srate(void *h, double freq) return freq; } -double rf_uhd_set_tx_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; + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; if (handler->nof_tx_channels > 1) { #ifdef UHD_SUPPORTS_COMMAND_TIME time_t full; double frac; uhd_usrp_get_time_now(handler->usrp, 0, &full, &frac); frac += 0.100; - if (frac >= 1.0) { full++; frac -= 1.0; }; + if (frac >= 1.0) { + full++; + frac -= 1.0; + }; uhd_usrp_set_command_time(handler->usrp, full, frac, 0); #endif /* UHD_SUPPORTS_COMMAND_TIME */ for (int i = 0; i < handler->nof_tx_channels; i++) { @@ -689,49 +736,49 @@ double rf_uhd_set_tx_srate(void *h, double freq) uhd_usrp_set_tx_rate(handler->usrp, freq, 0); } handler->tx_rate = freq; - return freq; + return freq; } -double rf_uhd_set_rx_gain(void *h, double gain) +double rf_uhd_set_rx_gain(void* h, double gain) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; - for (int i=0;inof_rx_channels;i++) { + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; + for (int i = 0; i < handler->nof_rx_channels; i++) { uhd_usrp_set_rx_gain(handler->usrp, gain, i, ""); } return gain; } -double rf_uhd_set_tx_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; - for (int i=0;inof_tx_channels;i++) { + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; + for (int i = 0; i < handler->nof_tx_channels; i++) { uhd_usrp_set_tx_gain(handler->usrp, gain, i, ""); } return gain; } -double rf_uhd_get_rx_gain(void *h) +double rf_uhd_get_rx_gain(void* h) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; - double gain; + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; + double gain; uhd_usrp_get_rx_gain(handler->usrp, 0, "", &gain); return gain; } -double rf_uhd_get_tx_gain(void *h) +double rf_uhd_get_tx_gain(void* h) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; - double gain; + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; + double gain; uhd_usrp_get_tx_gain(handler->usrp, 0, "", &gain); return gain; } -srslte_rf_info_t *rf_uhd_get_info(void *h) +srslte_rf_info_t* rf_uhd_get_info(void* h) { - srslte_rf_info_t *info = NULL; + srslte_rf_info_t* info = NULL; if (h) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; - info = &handler->info; + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; + info = &handler->info; } return info; } @@ -739,12 +786,12 @@ srslte_rf_info_t *rf_uhd_get_info(void *h) double rf_uhd_set_rx_freq(void* h, uint32_t ch, double freq) { uhd_tune_request_t tune_request = { - .target_freq = freq, - .rf_freq_policy = UHD_TUNE_REQUEST_POLICY_AUTO, + .target_freq = freq, + .rf_freq_policy = UHD_TUNE_REQUEST_POLICY_AUTO, .dsp_freq_policy = UHD_TUNE_REQUEST_POLICY_AUTO, }; uhd_tune_result_t tune_result; - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; if (ch < handler->nof_rx_channels) { uhd_usrp_set_rx_freq(handler->usrp, &tune_request, ch, &tune_result); } else { @@ -758,12 +805,12 @@ double rf_uhd_set_rx_freq(void* h, uint32_t ch, double freq) double rf_uhd_set_tx_freq(void* h, uint32_t ch, double freq) { uhd_tune_request_t tune_request = { - .target_freq = freq, - .rf_freq_policy = UHD_TUNE_REQUEST_POLICY_AUTO, + .target_freq = freq, + .rf_freq_policy = UHD_TUNE_REQUEST_POLICY_AUTO, .dsp_freq_policy = UHD_TUNE_REQUEST_POLICY_AUTO, }; uhd_tune_result_t tune_result; - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; if (ch < handler->nof_tx_channels) { uhd_usrp_set_tx_freq(handler->usrp, &tune_request, ch, &tune_result); } else { @@ -774,9 +821,9 @@ double rf_uhd_set_tx_freq(void* h, uint32_t ch, double freq) return freq; } - -void rf_uhd_get_time(void *h, time_t *secs, double *frac_secs) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; +void rf_uhd_get_time(void* h, time_t* secs, double* frac_secs) +{ + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; uhd_usrp_get_time_now(handler->usrp, 0, secs, frac_secs); } @@ -788,33 +835,24 @@ void rf_uhd_sync_pps(void* h) } } -int rf_uhd_recv_with_time(void *h, - void *data, - uint32_t nsamples, - bool blocking, - time_t *secs, - double *frac_secs) +int rf_uhd_recv_with_time(void* h, void* data, uint32_t nsamples, bool blocking, 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[SRSLTE_MAX_PORTS], - uint32_t nsamples, - bool blocking, - time_t *secs, - double *frac_secs) +int rf_uhd_recv_with_time_multi( + void* h, void* data[SRSLTE_MAX_PORTS], uint32_t nsamples, bool blocking, time_t* secs, double* frac_secs) { - rf_uhd_handler_t *handler = (rf_uhd_handler_t*) h; - uhd_rx_metadata_handle *md = &handler->rx_md_first; - size_t rxd_samples = 0; - size_t rxd_samples_total = 0; - int trials = 0; + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; + uhd_rx_metadata_handle* md = &handler->rx_md_first; + size_t rxd_samples = 0; + size_t rxd_samples_total = 0; + int trials = 0; if (blocking) { while (rxd_samples_total < nsamples && trials < 100) { - void *buffs_ptr[4]; - for (int i=0;inof_rx_channels;i++) { - cf_t *data_c = (cf_t*) data[i]; + 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[rxd_samples_total]; } @@ -822,12 +860,12 @@ int rf_uhd_recv_with_time_multi(void *h, size_t num_rx_samples = (num_samps_left > handler->rx_nof_samples) ? handler->rx_nof_samples : num_samps_left; rxd_samples = 0; - uhd_error error = uhd_rx_streamer_recv(handler->rx_stream, buffs_ptr, - num_rx_samples, md, 1.0, false, &rxd_samples); + uhd_error error = + uhd_rx_streamer_recv(handler->rx_stream, buffs_ptr, num_rx_samples, md, 1.0, false, &rxd_samples); if (error) { ERROR("Error receiving from UHD: %d\n", error); log_rx_error(handler); - return -1; + return -1; } uhd_rx_metadata_error_code_t error_code = 0; @@ -850,7 +888,7 @@ int rf_uhd_recv_with_time_multi(void *h, } } } else { - uhd_error error = uhd_rx_streamer_recv(handler->rx_stream, data, nsamples, md, 0.0, false, &rxd_samples); + uhd_error error = uhd_rx_streamer_recv(handler->rx_stream, data, nsamples, md, 0.0, false, &rxd_samples); rxd_samples_total = rxd_samples; if (error) { ERROR("Error receiving from UHD: %d\n", error); @@ -863,33 +901,34 @@ int rf_uhd_recv_with_time_multi(void *h, } return rxd_samples_total; } - -int rf_uhd_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) + +int rf_uhd_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) { - void *_data[SRSLTE_MAX_PORTS]= {data, zero_mem, zero_mem, zero_mem}; + void* _data[SRSLTE_MAX_PORTS] = {data, zero_mem, zero_mem, zero_mem}; - return rf_uhd_send_timed_multi(h, _data, nsamples, secs, frac_secs, has_time_spec, blocking, is_start_of_burst, is_end_of_burst); + return rf_uhd_send_timed_multi( + h, _data, nsamples, secs, frac_secs, has_time_spec, blocking, is_start_of_burst, is_end_of_burst); } -int rf_uhd_send_timed_multi(void *h, - void *data[4], - int nsamples, +int rf_uhd_send_timed_multi(void* h, + void* data[4], + int nsamples, time_t secs, double frac_secs, - bool has_time_spec, - bool blocking, - bool is_start_of_burst, - bool is_end_of_burst) + bool has_time_spec, + bool blocking, + bool is_start_of_burst, + bool is_end_of_burst) { - rf_uhd_handler_t* handler = (rf_uhd_handler_t*) h; + rf_uhd_handler_t* handler = (rf_uhd_handler_t*)h; pthread_mutex_lock(&handler->tx_mutex); int ret = -1; @@ -901,13 +940,13 @@ int rf_uhd_send_timed_multi(void *h, } size_t txd_samples; - int trials = 0; + int trials = 0; if (blocking) { if (has_time_spec) { uhd_tx_metadata_set_time_spec(&handler->tx_md, secs, frac_secs); } - int n = 0; - cf_t *data_c[4]; + int n = 0; + cf_t* data_c[4]; for (int i = 0; i < 4; i++) { data_c[i] = data[i] ? data[i] : zero_mem; } @@ -920,28 +959,28 @@ int rf_uhd_send_timed_multi(void *h, } else { uhd_tx_metadata_set_start(&handler->tx_md, false); } - + // middle packets are never end of burst, last one as defined if (nsamples - n > tx_samples) { uhd_tx_metadata_set_end(&handler->tx_md, false); } else { - tx_samples = nsamples - n; + tx_samples = nsamples - n; uhd_tx_metadata_set_end(&handler->tx_md, is_end_of_burst); } - const void *buffs_ptr[4]; + const void* buffs_ptr[4]; for (int i = 0; i < 4; i++) { - void *buff = (void*) &data_c[i][n]; + void* buff = (void*)&data_c[i][n]; buffs_ptr[i] = buff; } - uhd_error error = uhd_tx_streamer_send(handler->tx_stream, buffs_ptr, - tx_samples, &handler->tx_md, 1.0, &txd_samples); + uhd_error error = + uhd_tx_streamer_send(handler->tx_stream, buffs_ptr, tx_samples, &handler->tx_md, 1.0, &txd_samples); if (error) { ERROR("Error sending to UHD: %d\n", error); goto unlock; } - // Increase time spec - uhd_tx_metadata_add_time_spec(&handler->tx_md, txd_samples/handler->tx_rate); + // Increase time spec + uhd_tx_metadata_add_time_spec(&handler->tx_md, txd_samples / handler->tx_rate); n += txd_samples; trials++; } while (n < nsamples && trials < 100); @@ -950,9 +989,9 @@ int rf_uhd_send_timed_multi(void *h, } else { - const void *buffs_ptr[4]; + const void* buffs_ptr[4]; for (int i = 0; i < 4; i++) { - buffs_ptr[i] = data[i]; + buffs_ptr[i] = data[i]; } uhd_tx_metadata_set_has_time_spec(&handler->tx_md, is_start_of_burst); uhd_tx_metadata_set_start(&handler->tx_md, is_start_of_burst); @@ -964,10 +1003,8 @@ int rf_uhd_send_timed_multi(void *h, } ret = txd_samples; - } unlock: pthread_mutex_unlock(&handler->tx_mutex); return ret; } -