1 files changed, 135 insertions, 138 deletions
diff --git a/usrp/host/apps-inband/test_usrp_inband_rx.cc b/usrp/host/apps-inband/test_usrp_inband_rx.cc
index 4820c2d4ea..c37c19c005 100644
--- a/usrp/host/apps-inband/test_usrp_inband_rx.cc
+++ b/usrp/host/apps-inband/test_usrp_inband_rx.cc
@@ -39,32 +39,13 @@
 #include <iostream>
 #include <fstream>
 
-// Signal set for the USRP server
-static pmt_t s_cmd_allocate_channel = pmt_intern("cmd-allocate-channel");
-static pmt_t s_cmd_close = pmt_intern("cmd-close");
-static pmt_t s_cmd_deallocate_channel = pmt_intern("cmd-deallocate-channel");
-static pmt_t s_cmd_open = pmt_intern("cmd-open");
-static pmt_t s_cmd_start_recv_raw_samples = pmt_intern("cmd-start-recv-raw-samples");
-static pmt_t s_cmd_stop_recv_raw_samples = pmt_intern("cmd-stop-recv-raw-samples");
-static pmt_t s_cmd_to_control_channel = pmt_intern("cmd-to-control-channel");
-static pmt_t s_cmd_xmit_raw_frame  = pmt_intern("cmd-xmit-raw-frame");
-static pmt_t s_cmd_max_capacity  = pmt_intern("cmd-max-capacity");
-static pmt_t s_cmd_ntx_chan  = pmt_intern("cmd-ntx-chan");
-static pmt_t s_cmd_nrx_chan  = pmt_intern("cmd-nrx-chan");
-static pmt_t s_cmd_current_capacity_allocation  = pmt_intern("cmd-current-capacity-allocation");
-static pmt_t s_response_allocate_channel = pmt_intern("response-allocate-channel");
-static pmt_t s_response_close = pmt_intern("response-close");
-static pmt_t s_response_deallocate_channel = pmt_intern("response-deallocate-channel");
-static pmt_t s_response_from_control_channel = pmt_intern("response-from-control-channel");
-static pmt_t s_response_open = pmt_intern("response-open");
-static pmt_t s_response_recv_raw_samples = pmt_intern("response-recv-raw-samples");
-static pmt_t s_response_xmit_raw_frame = pmt_intern("response-xmit-raw-frame");
-static pmt_t s_response_max_capacity = pmt_intern("response-max-capacity");
-static pmt_t s_response_ntx_chan = pmt_intern("response-ntx-chan");
-static pmt_t s_response_nrx_chan = pmt_intern("response-nrx-chan");
-static pmt_t s_response_current_capacity_allocation  = pmt_intern("response-current-capacity-allocation");
-
-static bool verbose = false;
+// Include the symbols needed for communication with USRP server
+#include <symbols_usrp_server_cs.h>
+#include <symbols_usrp_channel.h>
+#include <symbols_usrp_low_level_cs.h>
+#include <symbols_usrp_rx.h>
+
+static bool verbose = true;
 
 class test_usrp_rx : public mb_mblock
 {
@@ -72,8 +53,6 @@ class test_usrp_rx : public mb_mblock
   mb_port_sptr 	d_cs;
   pmt_t		d_rx_chan;	// returned tx channel handle
 
-  bool d_disk_write;
-
   enum state_t {
     INIT,
     OPENING_USRP,
@@ -87,6 +66,9 @@ class test_usrp_rx : public mb_mblock
 
   std::ofstream d_ofile;
 
+  long d_samples_recvd;
+  long d_samples_to_recv;
+
  public:
   test_usrp_rx(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
   ~test_usrp_rx();
@@ -106,54 +88,34 @@ class test_usrp_rx : public mb_mblock
 
 test_usrp_rx::test_usrp_rx(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg)
   : mb_mblock(runtime, instance_name, user_arg),
-  d_disk_write(false)
+    d_samples_recvd(0),
+    d_samples_to_recv(5e6)
 { 
   
   d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
   d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
   
-  //bool fake_usrp_p = true;
-  bool fake_usrp_p = false;
-  
-  d_disk_write = true;
-
-  // Test the TX side
-
   // Pass a dictionary to usrp_server which specifies which interface to use, the stub or USRP
   pmt_t usrp_dict = pmt_make_dict();
 
-  if(fake_usrp_p)
-    pmt_dict_set(usrp_dict, 
-                 pmt_intern("fake-usrp"),
-		             PMT_T);
-  
   // Specify the RBF to use
   pmt_dict_set(usrp_dict,
                pmt_intern("rbf"),
-               pmt_intern("tmac6.rbf"));
+               pmt_intern("nanocell9.rbf"));
 
-  // Set TX and RX interpolations
   pmt_dict_set(usrp_dict,
-               pmt_intern("interp-tx"),
+               pmt_intern("decim-rx"),
                pmt_from_long(128));
 
-  pmt_dict_set(usrp_dict,
-               pmt_intern("interp-rx"),
-               pmt_from_long(16));
-
   define_component("server", "usrp_server", usrp_dict);
 
   connect("self", "rx0", "server", "rx0");
   connect("self", "cs", "server", "cs");
 
-  if(d_disk_write)
-    d_ofile.open("pdump_rx.dat",std::ios::binary|std::ios::out);
 }
 
 test_usrp_rx::~test_usrp_rx()
 {
-  if(d_disk_write)
-    d_ofile.close();
 }
 
 void
@@ -173,95 +135,119 @@ test_usrp_rx::handle_message(mb_message_sptr msg)
   std::string error_msg;
   
   switch(d_state){
-  case OPENING_USRP:
-    if (pmt_eq(event, s_response_open)){
-      status = pmt_nth(1, data);
-      if (pmt_eq(status, PMT_T)){
-        allocate_channel();
-        return;
-      }
-      else {
-        error_msg = "failed to open usrp:";
-        goto bail;
-      }
-    }
-    goto unhandled;
     
-  case ALLOCATING_CHANNEL:
-    if (pmt_eq(event, s_response_allocate_channel)){
-      status = pmt_nth(1, data);
-      d_rx_chan = pmt_nth(2, data);
-
-      if (pmt_eq(status, PMT_T)){
-        enter_receiving();
-        return;
+    //----------------------------- OPENING_USRP ----------------------------//
+    // We only expect a response from opening the USRP which should be succesful
+    // or failed.
+    case OPENING_USRP:
+      if (pmt_eq(event, s_response_open)){
+        status = pmt_nth(1, data);
+        if (pmt_eq(status, PMT_T)){
+          allocate_channel();
+          return;
+        }
+        else {
+          error_msg = "failed to open usrp:";
+          goto bail;
+        }
       }
-      else {
-        error_msg = "failed to allocate channel:";
-        goto bail;
+      goto unhandled;
+      
+    //----------------------- ALLOCATING CHANNELS --------------------//
+    // Allocate an RX channel to perform the overrun test.
+    case ALLOCATING_CHANNEL:
+      if (pmt_eq(event, s_response_allocate_channel)){
+        status = pmt_nth(1, data);
+        d_rx_chan = pmt_nth(2, data);
+
+        if (pmt_eq(status, PMT_T)){
+          enter_receiving();
+          return;
+        }
+        else {
+          error_msg = "failed to allocate channel:";
+          goto bail;
+        }
       }
-    }
-    goto unhandled;
-
-  case RECEIVING:
-    if (pmt_eq(event, s_response_recv_raw_samples)){
-      status = pmt_nth(1, data);
-
-      if (pmt_eq(status, PMT_T)){
-        handle_response_recv_raw_samples(data);
-        return;
+      goto unhandled;
+
+    //--------------------------- RECEIVING ------------------------------//
+    // In the receiving state, we receive samples until the specified amount
+    // while counting the number of overruns.
+    case RECEIVING:
+      if (pmt_eq(event, s_response_recv_raw_samples)){
+        status = pmt_nth(1, data);
+
+        if (pmt_eq(status, PMT_T)){
+          handle_response_recv_raw_samples(data);
+          return;
+        }
+        else {
+          error_msg = "bad response-xmit-raw-frame:";
+          goto bail;
+        }
       }
-      else {
-        error_msg = "bad response-xmit-raw-frame:";
-        goto bail;
+      goto unhandled;
+    
+    //------------------------- CLOSING CHANNEL ----------------------------//
+    // Check deallocation response for the RX channel 
+    case CLOSING_CHANNEL:
+      if (pmt_eq(event, s_response_deallocate_channel)){
+        status = pmt_nth(1, data);
+
+        if (pmt_eq(status, PMT_T)){
+          close_usrp();
+          return;
+        }
+        else {
+          error_msg = "failed to deallocate channel:";
+          goto bail;
+        }
       }
-    }
-    goto unhandled;
 
-  case CLOSING_CHANNEL:
-    if (pmt_eq(event, s_response_deallocate_channel)){
-      status = pmt_nth(1, data);
-
-      if (pmt_eq(status, PMT_T)){
-        close_usrp();
+      // Alternately, we ignore all response recv samples while waiting for the
+      // channel to actually close
+      if (pmt_eq(event, s_response_recv_raw_samples))
         return;
-      }
-      else {
-        error_msg = "failed to deallocate channel:";
-        goto bail;
-      }
-    }
-    goto unhandled;
-
-  case CLOSING_USRP:
-    if (pmt_eq(event, s_response_close)){
-      status = pmt_nth(1, data);
 
-      if (pmt_eq(status, PMT_T)){
-        shutdown_all(PMT_T);
-        return;
+      goto unhandled;
+
+    //--------------------------- CLOSING USRP ------------------------------//
+    // Once we have received a successful USRP close response, we shutdown all
+    // mblocks and exit.
+    case CLOSING_USRP:
+      if (pmt_eq(event, s_response_close)){
+        status = pmt_nth(1, data);
+
+        if (pmt_eq(status, PMT_T)){
+          fflush(stdout);
+          shutdown_all(PMT_T);
+          return;
+        }
+        else {
+          error_msg = "failed to close USRP:";
+          goto bail;
+        }
       }
-      else {
-        error_msg = "failed to close USRP:";
-        goto bail;
-      }
-    }
-    goto unhandled;
+      goto unhandled;
 
-  default:
-    goto unhandled;
+    default:
+      goto unhandled;
   }
   return;
 
+ // An error occured, print it, and shutdown all m-blocks
  bail:
   std::cerr << error_msg << data
 	    << "status = " << status << std::endl;
   shutdown_all(PMT_F);
   return;
 
+ // Received an unhandled message for a specific state
  unhandled:
-  std::cout << "test_usrp_inband_rx: unhandled msg: " << msg
-	    << "in state "<< d_state << std::endl;
+  if(verbose && !pmt_eq(event, pmt_intern("%shutdown")))
+    std::cout << "test_usrp_inband_tx: unhandled msg: " << msg
+              << "in state "<< d_state << std::endl;
 }
 
 
@@ -272,6 +258,9 @@ test_usrp_rx::open_usrp()
 
   d_cs->send(s_cmd_open, pmt_list2(PMT_NIL, which_usrp));
   d_state = OPENING_USRP;
+  
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_RX] Opening the USRP\n";
 }
 
 void
@@ -279,6 +268,9 @@ test_usrp_rx::close_usrp()
 {
   d_cs->send(s_cmd_close, pmt_list1(PMT_NIL));
   d_state = CLOSING_USRP;
+  
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_RX] Closing the USRP\n";
 }
 
 void
@@ -287,6 +279,9 @@ test_usrp_rx::allocate_channel()
   long capacity = (long) 16e6;
   d_rx->send(s_cmd_allocate_channel, pmt_list2(PMT_T, pmt_from_long(capacity)));
   d_state = ALLOCATING_CHANNEL;
+  
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_RX] Requesting RX channel allocation\n";
 }
 
 void
@@ -297,6 +292,9 @@ test_usrp_rx::enter_receiving()
   d_rx->send(s_cmd_start_recv_raw_samples,
              pmt_list2(PMT_F,
                        d_rx_chan));
+
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_RX] Receiving...\n";
 }
 
 void
@@ -308,26 +306,20 @@ test_usrp_rx::handle_response_recv_raw_samples(pmt_t data)
   pmt_t timestamp = pmt_nth(3, data);
   pmt_t properties = pmt_nth(4, data);
 
-  size_t n_bytes;
-  
-  const char *samples = (const char *) pmt_uniform_vector_elements(v_samples, n_bytes);
+  d_samples_recvd += pmt_length(v_samples) / 4;
 
-  if(d_disk_write)
-    d_ofile.write(samples, n_bytes);
+  // Check for overrun
+  if(!pmt_is_dict(properties)) {
+    std::cout << "[TEST_USRP_INBAND_RX] Recv samples dictionary is improper\n";
+    return;
+  }
 
-  if(verbose)
-    std::cout << ".";
-
-  if (pmt_is_dict(properties)) {
-    // Read the RSSI
-    if(pmt_t rssi = pmt_dict_ref(properties, 
-                                 pmt_intern("rssi"), 
-                                 PMT_NIL)) {
-      if(!pmt_eqv(rssi, PMT_NIL)) 
-        std::cout << "RSSI: " << rssi << std::endl;
-    }
+  // Check if the number samples we have received meets the test
+  if(d_samples_recvd >= d_samples_to_recv) {
+    d_rx->send(s_cmd_stop_recv_raw_samples, pmt_list2(PMT_NIL, d_rx_chan));
+    enter_closing_channel();
+    return;
   }
-  
 
 }
 
@@ -336,7 +328,12 @@ test_usrp_rx::enter_closing_channel()
 {
   d_state = CLOSING_CHANNEL;
   
+  sleep(2);
+  
   d_rx->send(s_cmd_deallocate_channel, pmt_list2(PMT_NIL, d_rx_chan));
+  
+  if(verbose)
+    std::cout << "[TEST_USRP_INBAND_RX] Deallocating RX channel\n";
 }
 
 REGISTER_MBLOCK_CLASS(test_usrp_rx);