1 files changed, 204 insertions, 35 deletions

diff --git a/usrp/host/lib/inband/qa_inband_usrp_server.cc b/usrp/host/lib/inband/qa_inband_usrp_server.cc
index b01e74e00..e457e8d64 100644
--- a/usrp/host/lib/inband/qa_inband_usrp_server.cc
+++ b/usrp/host/lib/inband/qa_inband_usrp_server.cc
@@ -46,6 +46,8 @@ typedef usrp_inband_usb_packet transport_pkt;   // makes conversion to gigabit e
 
 static bool verbose = false;
 
+static pmt_t s_timeout = pmt_intern("%timeout");
+
 // ----------------------------------------------------------------------------------------------
 
 class qa_alloc_top : public mb_mblock
@@ -903,10 +905,10 @@ class qa_rx_top : public mb_mblock
 
   long d_rx_chan;
 
-  long d_got_response_recv;
+  bool d_got_response_recv;
 
-  long d_nmsg_to_recv;
-  long d_nmsg_recvd;
+  mb_time d_t0;
+  double d_delta_t;
 
  public:
   qa_rx_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
@@ -927,18 +929,19 @@ qa_rx_top::qa_rx_top(mb_runtime *runtime, const std::string &instance_name, pmt_
     d_got_response_recv(false)
 { 
 
-  d_nmsg_to_recv=12;
-  d_nmsg_recvd=0;
-  
   d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
   d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
 
   // Use the stub with the usrp_server
-  pmt_t usrp_server_dict = pmt_make_dict();
-  pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"), PMT_T);
+  pmt_t usrp_dict = pmt_make_dict();
+  // Set TX and RX interpolations
+  pmt_dict_set(usrp_dict,
+               pmt_intern("decim-rx"),
+               pmt_from_long(128));
+  pmt_dict_set(usrp_dict, pmt_intern("fake-usrp"), PMT_T);
 
   // Test the TX side
-  define_component("server", "usrp_server", usrp_server_dict);
+  define_component("server", "usrp_server", usrp_dict);
   connect("self", "rx0", "server", "rx0");
   connect("self", "cs", "server", "cs");
 }
@@ -967,17 +970,10 @@ qa_rx_top::run_tests()
              pmt_list2(PMT_NIL, 
                        pmt_from_long(0)));
 
-  // A small sleep is used to ensure, if working properly, a recv
-  // response comes through successfully before the close gets
-  // through
-  usleep(1000);
-
-  d_rx->send(s_cmd_stop_recv_raw_samples, 
-             pmt_list2(PMT_NIL, 
-                       pmt_from_long(0)));
-
-  d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close,PMT_T)));
-  
+  // Schedule a small timeout in which we expect to have received at least one
+  // packet worth of samples from the stub
+  d_t0 = mb_time::time();
+  schedule_one_shot_timeout(d_t0 + 0.01, PMT_NIL);
 }
 
 
@@ -992,26 +988,37 @@ qa_rx_top::handle_message(mb_message_sptr msg)
   
   pmt_t expected = pmt_nth(0, data);
   pmt_t status = pmt_nth(1, data);
+
+  // If we get a timeout we shutdown
+  if(pmt_eq(event, s_timeout)) {
+    if(verbose)
+      std::cout << "[qa_rx_top] Got timeout\n";
+    d_rx->send(s_cmd_stop_recv_raw_samples, 
+               pmt_list2(PMT_NIL, 
+                         pmt_from_long(0)));
+
+    d_cs->send(s_cmd_close, pmt_list1(pmt_list2(s_response_close,PMT_T)));
+    return;
+  }
   
   // For testing RX, an invocation handle is not generated by the stub,
   // therefore the same approach for testing is not used.  We simply
   // expect all responses to be true.
   if(pmt_eq(event, s_response_recv_raw_samples)) {
-    if(!pmt_eqv(status, PMT_T)) {
-      if(verbose)
-        std::cout << "Got: " << status << " Expected: " << PMT_T << "\n";
-      shutdown_all(PMT_F);
-      return;
-    }
-    else {
+    if(pmt_eqv(status, PMT_T)) {
+
       if(verbose)
         std::cout << "[qa_rx_top] Received expected response for message " 
-                  << d_nmsg_recvd
                   << " (" << event << ")\n";
 
       // All we want is 1 response receive!  Can't guarantee exact numbers
       d_got_response_recv = true;
     }
+    else {
+      if(verbose)
+        std::cout << "Got: " << status << " Expected: " << PMT_T << "\n";
+      shutdown_all(PMT_F);
+    }
     return;
   }
 
@@ -1026,8 +1033,7 @@ qa_rx_top::handle_message(mb_message_sptr msg)
   } else {
     if(verbose)
       std::cout << "[qa_rx_top] Received expected response for message " 
-                << d_nmsg_recvd
-      << " (" << event << ")\n";
+                << " (" << event << ")\n";
   }
 
   if (pmt_eq(msg->port_id(), d_rx->port_symbol())) {
@@ -1051,12 +1057,7 @@ qa_rx_top::handle_message(mb_message_sptr msg)
         std::cout << "[qa_rx_top] No response message before close\n";
       return;
     }
-
   }
-    
-  
-  d_nmsg_recvd++;
-
 }
 
 
@@ -1079,6 +1080,160 @@ qa_rx_top::check_allocation(mb_message_sptr msg)
 
 REGISTER_MBLOCK_CLASS(qa_rx_top);
 
+// ----------------------------------------------------------------------------------------------
+
+class qa_rid_top : public mb_mblock
+{
+  mb_port_sptr d_tx;
+  mb_port_sptr d_rx;
+  mb_port_sptr d_cs;
+
+  long d_npongs;
+  long d_tcycles;
+  long d_cycles;
+  long d_max_rid;
+  
+  mb_time d_t0;
+  double d_delta_t;
+
+ public:
+  qa_rid_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg);
+  ~qa_rid_top();
+  void initial_transition();
+  void handle_message(mb_message_sptr msg);
+
+ protected:
+  void run_tests();
+  void send_max_pings();
+};
+
+qa_rid_top::qa_rid_top(mb_runtime *runtime, const std::string &instance_name, pmt_t user_arg)
+  : mb_mblock(runtime, instance_name, user_arg)
+{ 
+  d_npongs = 0;
+  d_tcycles = 3;
+  d_cycles = d_tcycles;
+  d_max_rid = usrp_server::D_MAX_RID;
+  d_delta_t = 0.1;
+
+
+  d_rx = define_port("rx0", "usrp-rx", false, mb_port::INTERNAL);
+  d_tx = define_port("tx0", "usrp-tx", false, mb_port::INTERNAL);
+  d_cs = define_port("cs", "usrp-server-cs", false, mb_port::INTERNAL);
+ 
+  // Use the stub with the usrp_server
+  pmt_t usrp_server_dict = pmt_make_dict();
+  pmt_dict_set(usrp_server_dict, pmt_intern("fake-usrp"),PMT_T);
+
+  // Test the TX side
+  define_component("server", "usrp_server", usrp_server_dict);
+  connect("self", "tx0", "server", "tx0");
+  connect("self", "rx0", "server", "rx0");
+  connect("self", "cs", "server", "cs");
+
+}
+
+qa_rid_top::~qa_rid_top(){}
+
+void
+qa_rid_top::initial_transition()
+{
+  run_tests();
+}
+
+void
+qa_rid_top::run_tests()
+{
+  if(verbose)
+    std::cout << "[qa_rid_top] Starting tests...\n";
+  
+  // Retrieve information about the USRP, then run tests
+  d_cs->send(s_cmd_open, 
+             pmt_list2(pmt_list2(s_response_open, PMT_T), 
+             pmt_from_long(0)));
+
+  // should be able to allocate 1 byte
+  d_tx->send(s_cmd_allocate_channel, 
+             pmt_list2(pmt_list2(s_response_allocate_channel, PMT_T), 
+                       pmt_from_long(1)));
+  
+  d_rx->send(s_cmd_allocate_channel, 
+             pmt_list2(pmt_list2(s_response_allocate_channel, PMT_T), 
+                       pmt_from_long(1)));
+  
+  // Need to start receiving to read from the USRP to get C/S responses
+  d_rx->send(s_cmd_start_recv_raw_samples, 
+             pmt_list2(PMT_NIL, 
+                       pmt_from_long(0)));
+
+  // Build a subpacket of MAX_RID pings and wait a small amount for all of the
+  // responses and fire off another MAX_RID.  If MAX_RID*2 responses are
+  // received, the RID recycling is working correctly.
+  // Schedule a timer in which we expect to have received all of the responses,
+  // which will send off another MAX_RID worth.
+  send_max_pings();
+  d_t0 = mb_time::time();
+  schedule_one_shot_timeout(d_t0 + d_delta_t, PMT_NIL);
+}
+
+void
+qa_rid_top::send_max_pings()
+{
+  pmt_t ping = pmt_list2(s_op_ping_fixed,
+                         pmt_list2(pmt_from_long(0),
+                                   pmt_from_long(0)));
+
+  pmt_t sub_packets = PMT_NIL;
+
+  for(int i=0; i<d_max_rid; i++) 
+    sub_packets = pmt_list_add(sub_packets, ping);
+
+  d_tx->send(s_cmd_to_control_channel,
+             pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T),
+                       sub_packets));
+}
+
+void
+qa_rid_top::handle_message(mb_message_sptr msg)
+{
+  pmt_t data = msg->data();
+  pmt_t event = msg->signal();
+
+  // If we get a timeout we ensure we got a maximum RID number of responses.
+  if(pmt_eq(event, s_timeout)) {
+    if(verbose)
+      std::cout << "[qa_rid_top] Got timeout, received so far: " 
+                << d_npongs << "\n";
+
+    d_cycles--;
+    
+    if(d_cycles==0 && d_npongs == d_max_rid*d_tcycles) {
+      shutdown_all(PMT_T);
+    }
+    else if(d_cycles==0) {
+
+      std::cout << "[qa_rid_top] d_npongs: " << d_npongs
+                << " expected: " << d_max_rid*d_tcycles
+                << std::endl;
+
+      shutdown_all(PMT_F);
+    }
+    else {
+      send_max_pings();
+      d_t0 = mb_time::time();
+      schedule_one_shot_timeout(d_t0 + d_delta_t, PMT_NIL);
+    }
+
+  }
+  else if(pmt_eq(event, s_response_from_control_channel))
+  {
+    d_npongs++;
+  }
+
+}
+
+REGISTER_MBLOCK_CLASS(qa_rid_top);
+
 
 // ----------------------------------------------------------------------------------------------
 
@@ -1398,3 +1553,17 @@ qa_inband_usrp_server::test_cs()
   
   CPPUNIT_ASSERT(pmt_equal(PMT_T, result));
 }
+
+void
+qa_inband_usrp_server::test_rid()
+{
+  mb_runtime_sptr rt = mb_make_runtime();
+  pmt_t result = PMT_T;
+
+  // std::cout << "\n\n-----------------\n";
+  // std::cout << "  RUNNING RID TESTS  \n";
+
+  rt->run("top", "qa_rid_top", PMT_F, &result);
+  
+  CPPUNIT_ASSERT(pmt_equal(PMT_T, result));
+}