Added proper error handling

srslte/include/srslte/rf/rf.h

@@ -48,7 +48,18 @@ typedef struct {
   float  tx_rx_gain_offset; 
 } srslte_rf_t;
 
-typedef void (*srslte_rf_msg_handler_t)(const char*);
+typedef struct {
+  enum { 
+    SRSLTE_RF_ERROR_LATE,
+    SRSLTE_RF_ERROR_UNDERFLOW,
+    SRSLTE_RF_ERROR_OVERFLOW,
+    SRSLTE_RF_ERROR_OTHER
+  } type;
+  int opt;
+  const char *msg; 
+} srslte_rf_error_t;
+
+typedef void (*srslte_rf_error_handler_t)(srslte_rf_error_t error);
 
 SRSLTE_API int srslte_rf_open(srslte_rf_t *h, 
                        char *args);
@@ -97,8 +108,8 @@ SRSLTE_API double srslte_rf_get_tx_gain(srslte_rf_t *h);
 
 SRSLTE_API void srslte_rf_suppress_stdout(srslte_rf_t *h);
 
-SRSLTE_API void srslte_rf_register_msg_handler(srslte_rf_t *h, 
+SRSLTE_API void srslte_rf_register_error_handler(srslte_rf_t *h, 
-                                        srslte_rf_msg_handler_t msg_handler);
+                                                 srslte_rf_error_handler_t error_handler);
 
 SRSLTE_API double srslte_rf_set_rx_freq(srslte_rf_t *h, 
                                  double freq);

srslte/lib/rf/src/rf_blade_imp.c

@@ -47,15 +47,17 @@ typedef struct {
   bool tx_stream_enabled; 
 } rf_blade_handler_t;
 
+srslte_rf_error_handler_t blade_error_handler = NULL; 
+
 void rf_blade_suppress_stdout(void *h) {
   bladerf_log_set_verbosity(BLADERF_LOG_LEVEL_SILENT);
 }
 
-void rf_blade_register_msg_handler(void *notused, srslte_rf_msg_handler_t new_handler)
+void rf_blade_register_error_handler(void *notused, srslte_rf_error_handler_t new_handler)
 {
+  new_handler = blade_error_handler;
 }
 
-
 bool rf_blade_rx_wait_lo_locked(void *h)
 {
   usleep(1000);
@@ -403,11 +405,17 @@ int rf_blade_recv_with_time(void *h,
   status = bladerf_sync_rx(handler->dev, handler->rx_buffer, nsamples, &meta, 0);
   if (status) {
     fprintf(stderr, "RX failed: %s\n\n", bladerf_strerror(status));
-    exit(-1);
     return -1;
   } else if (meta.status & BLADERF_META_STATUS_OVERRUN) {
-    fprintf(stderr, "Overrun detected in scheduled RX. "
+    if (blade_error_handler) {
+      srslte_rf_error_t error; 
+      error.opt = meta.actual_count;
+      error.type = SRSLTE_RF_ERROR_OVERFLOW;
+      blade_error_handler(error);
+    } else {     
+      fprintf(stderr, "Overrun detected in scheduled RX. "
             "%u valid samples were read.\n\n", meta.actual_count);
+    }
   }
   
   timestamp_to_secs(handler->rx_rate, meta.timestamp, secs, frac_secs);
@@ -454,10 +462,27 @@ int rf_blade_send_timed(void *h,
     meta.flags |= BLADERF_META_FLAG_TX_BURST_END;
   }
   status = bladerf_sync_tx(handler->dev, handler->tx_buffer, nsamples, &meta, 0);
-  if (status != 0) {
+  if (status == BLADERF_ERR_TIME_PAST) {
+    if (blade_error_handler) {
+      srslte_rf_error_t error; 
+      error.type = SRSLTE_RF_ERROR_LATE;
+      blade_error_handler(error);
+    } else {
+      fprintf(stderr, "TX failed: %s\n", bladerf_strerror(status));      
+    }
+  } else if (status) {
     fprintf(stderr, "TX failed: %s\n", bladerf_strerror(status));
     return status;
+  } else if (meta.status == BLADERF_META_STATUS_UNDERRUN) {
+    if (blade_error_handler) {
+      srslte_rf_error_t error; 
+      error.type = SRSLTE_RF_ERROR_UNDERFLOW;
+      blade_error_handler(error);
+    } else {
+      fprintf(stderr, "TX warning: underflow detected.\n");
+    }
   }
+  
   return nsamples;
 }
 

srslte/lib/rf/src/rf_blade_imp.h

@@ -67,7 +67,8 @@ SRSLTE_API double rf_blade_get_tx_gain(void *h);
 
 SRSLTE_API void rf_blade_suppress_stdout(void *h);
 
-SRSLTE_API void rf_blade_register_msg_handler(void *h, srslte_rf_msg_handler_t msg_handler);
+SRSLTE_API void rf_blade_register_error_handler(void *h, 
+                                              srslte_rf_error_handler_t error_handler);
 
 SRSLTE_API double rf_blade_set_rx_freq(void *h, 
                                   double freq);

srslte/lib/rf/src/rf_dev.h

@@ -35,7 +35,7 @@ typedef struct {
   bool   (*srslte_rf_has_rssi)(void *h);
   float  (*srslte_rf_get_rssi)(void *h);
   void   (*srslte_rf_suppress_stdout)(void *h);
-  void   (*srslte_rf_register_msg_handler)(void *h, srslte_rf_msg_handler_t msg_handler);
+  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_close)(void *h);
   void   (*srslte_rf_set_master_clock_rate)(void *h, double rate);
@@ -70,7 +70,7 @@ static rf_dev_t dev_uhd = {
   rf_uhd_has_rssi,
   rf_uhd_get_rssi,
   rf_uhd_suppress_stdout,
-  rf_uhd_register_msg_handler,
+  rf_uhd_register_error_handler,
   rf_uhd_open,
   rf_uhd_close,
   rf_uhd_set_master_clock_rate,
@@ -103,7 +103,7 @@ static rf_dev_t dev_blade = {
   rf_blade_has_rssi,
   rf_blade_get_rssi,
   rf_blade_suppress_stdout,
-  rf_blade_register_msg_handler,
+  rf_blade_register_error_handler,
   rf_blade_open,
   rf_blade_close,
   rf_blade_set_master_clock_rate,

srslte/lib/rf/src/rf_imp.c

@@ -161,9 +161,9 @@ void srslte_rf_suppress_stdout(srslte_rf_t *rf)
   ((rf_dev_t*) rf->dev)->srslte_rf_suppress_stdout(rf->handler);  
 }
 
-void srslte_rf_register_msg_handler(srslte_rf_t *rf, srslte_rf_msg_handler_t msg_handler)
+void srslte_rf_register_error_handler(srslte_rf_t *rf, srslte_rf_error_handler_t error_handler)
 {
-  ((rf_dev_t*) rf->dev)->srslte_rf_register_msg_handler(rf->handler, msg_handler);  
+  ((rf_dev_t*) rf->dev)->srslte_rf_register_error_handler(rf->handler, error_handler);  
 }
 
 int srslte_rf_open(srslte_rf_t *h, char *args) 

srslte/lib/rf/src/rf_uhd_imp.c

@@ -55,13 +55,33 @@ void suppress_handler(const char *x)
   // do nothing
 }
 
+srslte_rf_error_handler_t uhd_error_handler = NULL; 
+
+void msg_handler(const char *msg)
+{
+  srslte_rf_error_t error; 
+  if(0 == strcmp(msg, "O")) {
+    error.type = SRSLTE_RF_ERROR_OVERFLOW;
+  } else if(0 == strcmp(msg, "D")) {
+    error.type = SRSLTE_RF_ERROR_OVERFLOW;
+  }else if(0 == strcmp(msg, "U")) {
+    error.type = SRSLTE_RF_ERROR_UNDERFLOW;
+  } else if(0 == strcmp(msg, "L")) {
+    error.type = SRSLTE_RF_ERROR_LATE;
+  }
+  if (uhd_error_handler) {
+    uhd_error_handler(error);
+  }
+}
+
 void rf_uhd_suppress_stdout(void *h) {
-  rf_uhd_register_msg_handler(h, suppress_handler);
+  rf_uhd_register_msg_handler_c(suppress_handler);
 }
 
-void rf_uhd_register_msg_handler(void *notused, srslte_rf_msg_handler_t new_handler)
+void rf_uhd_register_error_handler(void *notused, srslte_rf_error_handler_t new_handler)
 {
-  rf_uhd_register_msg_handler_c(new_handler);
+  uhd_error_handler = new_handler;
+  rf_uhd_register_msg_handler_c(msg_handler);
 }
 
 static bool find_string(uhd_string_vector_handle h, char *str) 

srslte/lib/rf/src/rf_uhd_imp.h

@@ -67,7 +67,7 @@ SRSLTE_API double rf_uhd_get_tx_gain(void *h);
 
 SRSLTE_API void rf_uhd_suppress_stdout(void *h);
 
-SRSLTE_API void rf_uhd_register_msg_handler(void *h, srslte_rf_msg_handler_t msg_handler);
+SRSLTE_API void rf_uhd_register_error_handler(void *h, srslte_rf_error_handler_t error_handler);
 
 SRSLTE_API double rf_uhd_set_rx_freq(void *h, 
                                   double freq);

srslte/lib/rf/src/uhd_c_api.cpp

@@ -9,17 +9,17 @@ extern "C" {
 #include "uhd_c_api.h"
 }
 
-static srslte_rf_msg_handler_t msg_handler;
+static void (*handler)(const char*);
 
 void translate_handler(uhd::msg::type_t type, const std::string & msg)
 {
-  if(msg_handler)
+  if(handler)
-    msg_handler(msg.c_str());
+    handler(msg.c_str());
 }
 
-void rf_uhd_register_msg_handler_c(srslte_rf_msg_handler_t new_handler) 
+void rf_uhd_register_msg_handler_c(void (*new_handler)(const char*)) 
 {
-  msg_handler = new_handler;
+  handler = new_handler;
   uhd::msg::register_handler(translate_handler);
 }
 

srslte/lib/rf/src/uhd_c_api.h

@@ -4,7 +4,7 @@
 #include "srslte/rf/rf.h"
 
 /* Declare functions not currently provided by the C-API */
-SRSLTE_API void rf_uhd_register_msg_handler_c(srslte_rf_msg_handler_t new_handler);
+SRSLTE_API void rf_uhd_register_msg_handler_c(void (*new_handler)(const char*));
 SRSLTE_API void uhd_tx_metadata_set_time_spec(uhd_tx_metadata_handle *md, time_t secs, double frac_secs);
 SRSLTE_API void uhd_tx_metadata_set_start(uhd_tx_metadata_handle *md, bool is_start_of_burst);
 SRSLTE_API void uhd_tx_metadata_set_end(uhd_tx_metadata_handle *md, bool is_end_of_burst);