[Commit-gnuradio] r5876 - gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband

[gnychis]

Author: gnychis
Date: 2007-06-29 09:55:04 -0600 (Fri, 29 Jun 2007)
New Revision: 5876

Modified:
   
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/qa_inband_usrp_server.cc
   
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/qa_inband_usrp_server.h
   
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_inband_usb_packet.h
   
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_rx_stub.cc
   
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_rx_stub.h
   
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_server.cc
   
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_server.h
   
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_tx_stub.cc
   
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_tx_stub.h
Log:
Major changes to RX/TX stubs as well as the USRP server to support C/S and the
testing of it without a USRP.

Fixed improper reading of subpackets in usrp_inband_usb_packet

Wrote QA code for CS ping packet and get the proper response back.

The RX/TX stub communicate with each other via a shared queue which the TX will
parse control packets and generate responses in to the queue.  The RX stub
simply reads from the queue and passes the responses back the chain.

Pings are ready to test in hardware.


Modified: 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/qa_inband_usrp_server.cc
===================================================================
--- 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/qa_inband_usrp_server.cc
   2007-06-29 15:23:16 UTC (rev 5875)
+++ 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/qa_inband_usrp_server.cc
   2007-06-29 15:55:04 UTC (rev 5876)
@@ -44,7 +44,7 @@
 
 typedef usrp_inband_usb_packet transport_pkt;   // makes conversion to gigabit 
easy
 
-static bool verbose = false;
+static bool verbose = true;
 
 // 
----------------------------------------------------------------------------------------------
 
@@ -1105,7 +1105,7 @@
   : mb_mblock(runtime, instance_name, user_arg)
 { 
   d_nrecvd=0;
-  d_nmsgs_to_recv = 6;
+  d_nmsgs_to_recv = 4;
   d_nstatus=0;
   d_nstatus_to_recv = 50;
   
@@ -1146,10 +1146,24 @@
 
   // should be able to allocate 1 byte
   d_tx->send(s_cmd_allocate_channel, 
-             pmt_list2(PMT_T, pmt_from_long(1)));
+             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)));
 
   d_tx->send(s_cmd_to_control_channel,
-             pmt_list2(PMT_NIL, pmt_list1(pmt_list3(s_op_ping_fixed, PMT_NIL, 
PMT_NIL))));
+             pmt_list2(pmt_list2(s_response_from_control_channel, PMT_T),
+                       pmt_list1(
+                            pmt_list2(s_op_ping_fixed, 
+                                      pmt_list2(PMT_NIL, 
+                                      pmt_from_long(0))))));
   
 }
 
@@ -1162,6 +1176,10 @@
        || pmt_eq(msg->port_id(), d_rx->port_symbol()))
        && pmt_eq(msg->signal(), s_response_allocate_channel))
     check_message(msg);
+
+  if (pmt_eq(msg->port_id(), d_tx->port_symbol())
+      && pmt_eq(msg->signal(), s_response_from_control_channel))
+    check_message(msg);
   
   if (pmt_eq(msg->port_id(), d_cs->port_symbol())) {
       
@@ -1213,7 +1231,7 @@
 
   if(!pmt_eqv(e_status, status) || !pmt_eqv(e_event, event)) {
     if(verbose)
-      std::cout << "Got: " << status << " Expected: " << e_status << "\n";
+      std::cout << "[qa_cs_top] Got: " << status << " Expected: " << e_status 
<< "\n";
     shutdown_all(PMT_F);
     return;
   } else {

Modified: 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/qa_inband_usrp_server.h
===================================================================
--- 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/qa_inband_usrp_server.h
    2007-06-29 15:23:16 UTC (rev 5875)
+++ 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/qa_inband_usrp_server.h
    2007-06-29 15:55:04 UTC (rev 5876)
@@ -28,10 +28,10 @@
 class qa_inband_usrp_server : public CppUnit::TestCase {
 
   CPPUNIT_TEST_SUITE(qa_inband_usrp_server);
-  CPPUNIT_TEST(test_open_close);
-  CPPUNIT_TEST(test_chan_allocation);
-  CPPUNIT_TEST(test_chan_deallocation);
-  CPPUNIT_TEST(test_tx);
+//  CPPUNIT_TEST(test_open_close);
+//  CPPUNIT_TEST(test_chan_allocation);
+//  CPPUNIT_TEST(test_chan_deallocation);
+//  CPPUNIT_TEST(test_tx);
 //  CPPUNIT_TEST(test_rx);
   CPPUNIT_TEST(test_cs);
   CPPUNIT_TEST_SUITE_END();

Modified: 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_inband_usb_packet.h
===================================================================
--- 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_inband_usb_packet.h
   2007-06-29 15:23:16 UTC (rev 5875)
+++ 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_inband_usb_packet.h
   2007-06-29 15:55:04 UTC (rev 5876)
@@ -42,8 +42,8 @@
 public:
 
   enum opcodes {
-    OP_PING_FIXED         = 0x00,
-    OP_PING_FIXED_REPLY   = 0x01,
+    OP_PING_FIXED         = 0x0d,
+    OP_PING_FIXED_REPLY   = 0x0e,
     OP_WRITE_REG          = 0x02,
     OP_WRITE_REG_MASKED   = 0x03,
     OP_READ_REG           = 0x04,
@@ -203,7 +203,32 @@
 
     return ping;
   }
+  
+  uint32_t cs_ping_reply(long rid, long ping_val) {
 
+    uint32_t ping = ( 
+        ((OP_PING_FIXED_REPLY & CS_OPCODE_MASK) << CS_OPCODE_SHIFT)
+      | ((0x2 & CS_LENGTH_MASK) << CS_LENGTH_SHIFT)
+      | ((rid & CS_RID_MASK) << CS_RID_SHIFT)
+      | (ping_val & CS_PINGVAL_MASK)
+
+      );
+
+    int p_len = payload_len();
+    uint32_t *payload = (uint32_t *) d_payload + p_len;
+    *payload = host_to_usrp_u32(ping);
+
+    // Update payload length
+    int h_flags = flags();
+    int h_chan = chan();
+    int h_tag = tag();
+    int h_payload_len = payload_len() + 4;  // increased by fixed ping size
+
+    set_header(h_flags, h_chan, h_tag, h_payload_len);
+
+    return ping;
+  }
+
   // The following method takes an offset within the packet payload to extract
   // a control/status subpacket and construct a pmt response which includes the
   // proper signal and arguments specified by usrp-low-level-cs.  The USRP
@@ -214,19 +239,16 @@
   pmt_t read_subpacket(int payload_offset) {
 
     uint32_t subpkt = usrp_to_host_u32(*((uint32_t *)d_payload + 
payload_offset));
-    uint32_t opcode = (subpkt & CS_OPCODE_MASK) << CS_OPCODE_SHIFT;
-    uint32_t len = (subpkt & CS_LENGTH_MASK) << CS_LENGTH_SHIFT;
+    uint32_t opcode = (subpkt >> CS_OPCODE_SHIFT) & CS_OPCODE_MASK;
+    uint32_t len = (subpkt >> CS_LENGTH_SHIFT) & CS_LENGTH_MASK;
 
-    pmt_t response;
-
     switch(opcode) {
       
       case OP_PING_FIXED_REPLY:
       {
         pmt_t rid     = pmt_from_long((subpkt & CS_RID_MASK) << CS_RID_SHIFT);
         pmt_t pingval = pmt_from_long((subpkt & CS_PINGVAL_MASK) << 
CS_PINGVAL_SHIFT);
-        response = pmt_list3(s_op_ping_fixed_reply, rid, pingval);
-        break;
+        return pmt_list3(s_op_ping_fixed_reply, rid, pingval);
       }
 
       case OP_READ_REG_REPLY:
@@ -239,7 +261,11 @@
         return PMT_NIL;
 
       case OP_PING_FIXED:
-        return PMT_NIL;
+      {
+        pmt_t rid     = pmt_from_long((subpkt & CS_RID_MASK) << CS_RID_SHIFT);
+        pmt_t pingval = pmt_from_long((subpkt & CS_PINGVAL_MASK) << 
CS_PINGVAL_SHIFT);
+        return pmt_list3(s_op_ping_fixed, rid, pingval);
+      }
 
       case OP_WRITE_REG:
         return PMT_NIL;
@@ -269,15 +295,13 @@
         return PMT_NIL;
 
     }
-
-    return response;
   }
 
   // Takes an offset to the beginning of a subpacket and extracts the
   // length of the subpacket
   int cs_len(int payload_offset) {
     uint32_t subpkt = usrp_to_host_u32(*((uint32_t *)d_payload + 
payload_offset));
-    return (subpkt & CS_LENGTH_MASK) << CS_LENGTH_SHIFT;
+    return (subpkt >> CS_LENGTH_SHIFT) & CS_LENGTH_MASK;
   }
 
 };

Modified: 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_rx_stub.cc
===================================================================
--- 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_rx_stub.cc
    2007-06-29 15:23:16 UTC (rev 5875)
+++ 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_rx_stub.cc
    2007-06-29 15:55:04 UTC (rev 5876)
@@ -40,13 +40,13 @@
 
 typedef usrp_inband_usb_packet transport_pkt;
 
-static const bool verbose = false;
+static const bool verbose = true;
 
 bool usrp_rx_stop;
 
 // Used for the fake control packet response code to send the responses back up
 // the RX.  The TX stub dumps responses in to this queue.
-std::queue<transport_pkt> d_defer_queue;
+std::queue<pmt_t> d_cs_queue;
 
 usrp_rx_stub::usrp_rx_stub(mb_runtime *rt, const std::string &instance_name, 
pmt_t user_arg)
   : mb_mblock(rt, instance_name, user_arg),
@@ -94,7 +94,7 @@
   if(pmt_eq(port_id, d_cs->port_symbol())) {
 
     if(verbose)
-      std::cout << "Got start\n";
+      std::cout << "[USRP_RX_STUB] Starting...\n";
     
     if(pmt_eqv(event, s_cmd_usrp_rx_start_reading))
       read_and_respond(data);
@@ -149,12 +149,34 @@
     
     d_cs->send(s_response_usrp_rx_read, pmt_list3(PMT_NIL, PMT_T, v_pkt));
 
+    // Now lets check the shared CS queue between the TX and RX stub.  Each
+    // element in a queue is a list where the first element is an invocation
+    // handle and the second element is a PMT u8 vect representation of the
+    // CS packet response which can just be passed transparently.
+    while(!d_cs_queue.empty()) {
+      
+      pmt_t cs_pkt = d_cs_queue.front();
+      d_cs_queue.pop();
+
+      pmt_t invocation_handle = pmt_nth(0, cs_pkt);
+      pmt_t v_pkt = pmt_nth(1, cs_pkt);
+
+      d_cs->send(s_response_usrp_rx_read,   
+                 pmt_list3(invocation_handle, 
+                           PMT_T, 
+                           v_pkt));  // Take the front CS pkt
+
+      
+      if(verbose)
+        std::cout << "[USRP_RX_STUB] Received CS response from TX stub\n";
+    }
+
   }
   
   usrp_rx_stop = false;
 
   if(verbose)
-    std::cout << "[USRP_TX_STUB] Got fake RX stop\n";
+    std::cout << "[USRP_RX_STUB] Got fake RX stop\n";
 
 }
 

Modified: 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_rx_stub.h
===================================================================
--- 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_rx_stub.h 
    2007-06-29 15:23:16 UTC (rev 5875)
+++ 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_rx_stub.h 
    2007-06-29 15:55:04 UTC (rev 5876)
@@ -32,7 +32,7 @@
 typedef usrp_inband_usb_packet transport_pkt;
 
 extern bool usrp_rx_stop;   // used to communicate a 'stop' to the RX stub
-extern std::queue<transport_pkt> d_defer_queue;
+extern std::queue<pmt_t> d_cs_queue;
 
 /*!
  * \brief Implements the low level usb interface to the USRP

Modified: 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_server.cc
===================================================================
--- 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_server.cc 
    2007-06-29 15:23:16 UTC (rev 5875)
+++ 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_server.cc 
    2007-06-29 15:55:04 UTC (rev 5876)
@@ -38,7 +38,7 @@
 
 typedef usrp_inband_usb_packet transport_pkt;   // makes conversion to gigabit 
easy
 
-const static bool verbose = false;
+const static bool verbose = true;
 
 static std::string
 str(long x)
@@ -150,7 +150,7 @@
   if(!pmt_eq(event, pmt_intern("%shutdown")))
     invocation_handle = pmt_nth(0, data);
 
-  if (verbose){
+  if (0){
     std::cout << "[USRP_SERVER] event: " << event << std::endl;
     std::cout << "[USRP_SERVER] port_id: " << port_id << std::endl;
   }
@@ -677,6 +677,7 @@
 
     pmt_t subp = pmt_nth(i, subpackets);
     pmt_t subp_cmd = pmt_nth(0, subp);
+    pmt_t subp_data = pmt_nth(1, subp);
 
     // This code needs to become "smart" and only make a new packet when full
     pmt_t v_packet = pmt_make_u8vector(sizeof(transport_pkt), 0);
@@ -690,7 +691,7 @@
     //--------- PING FIXED --------------//
     if(pmt_eq(subp_cmd, s_op_ping_fixed)) {
 
-      long pingval = 0;
+      long pingval = pmt_to_long(pmt_nth(1, subp_data));
 
       // USRP server sets request ID's to keep track of which application gets
       // what response back.  We do not handle wrap around, if we wrap before 
we
@@ -806,9 +807,6 @@
   size_t n_bytes;
   size_t ignore;
 
-  if(verbose)
-    std::cout << "[USRP_SERVER] Received raw samples\n";
-
   if (d_fake_rx) {
 
     pmt_t pkt = pmt_nth(2, data);
@@ -837,7 +835,7 @@
   
   // If the packet is a C/S packet, parse it separately
   if(channel == 0x1f) {
-    parse_control_pkt(pkt);
+    parse_control_pkt(invocation_handle, pkt);
     return;
   }
 
@@ -859,13 +857,16 @@
 }
 
 void
-usrp_server::parse_control_pkt(transport_pkt *pkt)
+usrp_server::parse_control_pkt(pmt_t invocation_handle, transport_pkt *pkt)
 {
 
   long payload_len = pkt->payload_len();
   unsigned char *payload = pkt->payload();
   long curr_payload = 0;
   long port;
+  
+  if(verbose)
+    std::cout << "[USRP_SERVER] Received control/status packet, parsing...\n";
 
   // We dispatch based on the control packet type, however we can extract the
   // opcode and the length immediately which is consistent in all responses.
@@ -879,6 +880,10 @@
 
     int len = pkt->cs_len(curr_payload);
 
+    if(verbose)
+      std::cout << "[USRP_SERVER] Parsing subpacket " 
+                << op_symbol << " ... length " << len << std::endl;
+
     //----------------- PING RESPONSE ------------------//
     if(pmt_eq(op_symbol, s_op_ping_fixed_reply)) {
 
@@ -886,10 +891,17 @@
       pmt_t pingval = pmt_nth(2, sub_packet);
       pmt_t owner = d_op_ping_fixed_owners[pmt_to_long(rid)];
 
-      // FIXME: is the response really supposed to come back on the TX port?
+      // FIXME: should be 1 response for all subpackets here ?
       if((port = tx_port_index(owner)) != -1)
-        d_tx[port]->send(op_symbol, pmt_list2(rid, pingval));
+        d_tx[port]->send(s_response_from_control_channel,
+                         pmt_list3(invocation_handle,
+                                   PMT_T,
+                                   pmt_list2(s_op_ping_fixed_reply, // subp
+                                             pmt_list2(rid, pingval))));
 
+      if(verbose)
+        std::cout << "[USRP_SERVER] Sending control channel response...\n";
+
     }
 
     // Each subpacket has an unaccounted for 2 bytes which is the opcode

Modified: 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_server.h
===================================================================
--- 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_server.h  
    2007-06-29 15:23:16 UTC (rev 5875)
+++ 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_server.h  
    2007-06-29 15:55:04 UTC (rev 5876)
@@ -111,7 +111,7 @@
   void reset_channels();
   void handle_response_usrp_read(pmt_t data);
   bool check_valid(mb_port_sptr port, long channel, std::vector<struct 
channel_info> &chan_info, pmt_t signal_info);
-  void parse_control_pkt(transport_pkt *pkt);
+  void parse_control_pkt(pmt_t invocation_handle, transport_pkt *pkt);
 };
 
 #endif /* INCLUDED_USRP_SERVER_H */

Modified: 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_tx_stub.cc
===================================================================
--- 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_tx_stub.cc
    2007-06-29 15:23:16 UTC (rev 5875)
+++ 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_tx_stub.cc
    2007-06-29 15:55:04 UTC (rev 5876)
@@ -33,12 +33,13 @@
 #include "usrp_standard.h"
 #include <stdio.h>
 #include <fstream>
+#include <usrp_rx_stub.h>
 
 #include <symbols_usrp_tx_cs.h>
 
 typedef usrp_inband_usb_packet transport_pkt;
 
-static const bool verbose = false;
+static const bool verbose = true;
 
 usrp_tx_stub::usrp_tx_stub(mb_runtime *rt, const std::string &instance_name, 
pmt_t user_arg)
   : mb_mblock(rt, instance_name, user_arg),
@@ -46,16 +47,20 @@
 {
   d_cs = define_port("cs", "usrp-tx-cs", true, mb_port::EXTERNAL);
   
-  //d_disk_write=true;
+  d_disk_write=true;
   
-  if(d_disk_write)
-    d_ofile.open("pdump.dat",std::ios::binary|std::ios::out);
+  if(d_disk_write) {
+    d_ofile.open("tx_stub_data.dat",std::ios::binary|std::ios::out);
+    d_cs_ofile.open("tx_stub_cs.dat",std::ios::binary|std::ios::out);
+  }
 }
 
 usrp_tx_stub::~usrp_tx_stub() 
 {
-  if(d_disk_write)
+  if(d_disk_write) {
     d_ofile.close();
+    d_cs_ofile.close();
+  }
 }
 
 void 
@@ -96,11 +101,19 @@
   // Parse the packets looking for C/S packets and dump them to a disk if
   // necessary
   for(long i=0; i<n_packets; i++) {
-    if(d_disk_write)
-      d_ofile.write((const char*) pkts[i].payload(), pkts[i].payload_len());
 
+    if(d_disk_write) {
+      if(pkts[i].chan() == 0x1f)
+        d_cs_ofile.write((const char *)&pkts[i], 
transport_pkt::max_pkt_size());
+      else
+        d_ofile.write((const char *)&pkts[i], transport_pkt::max_pkt_size());
+
+      d_cs_ofile.flush();
+      d_ofile.flush();
+    }
+
     if(pkts[i].chan() == 0x1f)
-      parse_cs(pkts[i]);
+      parse_cs(invocation_handle, pkts[i]);
   }
 
   d_cs->send(s_response_usrp_tx_write,
@@ -110,8 +123,57 @@
 }
 
 void
-usrp_tx_stub::parse_cs(transport_pkt pkt)
+usrp_tx_stub::parse_cs(pmt_t invocation_handle, transport_pkt pkt)
 {
+  
+  long payload_len = pkt.payload_len();
+  long curr_payload = 0;
+
+  // We dispatch based on the control packet type, however we can extract the
+  // opcode and the length immediately which is consistent in all responses.
+  //
+  // Since each control packet can have multiple responses, we keep reading the
+  // lengths of each subpacket until we reach the payload length.  
+  while(curr_payload < payload_len) {
+
+    pmt_t sub_packet = pkt.read_subpacket(curr_payload);
+    pmt_t op_symbol = pmt_nth(0, sub_packet);
+
+    int len = pkt.cs_len(curr_payload);
+      
+    if(verbose)
+      std::cout << "[USRP_TX_STUB] Parsing subpacket " 
+                << op_symbol << " ... length " << len << std::endl;
+
+    //----------------- PING FIXED ------------------//
+    if(pmt_eq(op_symbol, s_op_ping_fixed)) {
+
+      size_t ignore;
+
+      long rid = pmt_to_long(pmt_nth(1, sub_packet));
+      long pingval = pmt_to_long(pmt_nth(2, sub_packet));
+
+      pmt_t v_pkt = pmt_make_u8vector(sizeof(transport_pkt), 0);
+      
+      transport_pkt *q_pkt =
+        (transport_pkt *) pmt_u8vector_writeable_elements(v_pkt, ignore);
+
+      q_pkt->set_header(0, 0x1f, 0, 0);
+      q_pkt->set_timestamp(0xffffffff);
+
+      // Generate a reply and put it in the queue for the RX stub to read
+      q_pkt->cs_ping_reply(rid, pingval);
+      d_cs_queue.push(pmt_list2(invocation_handle, v_pkt));
+
+      if(verbose)
+        std::cout << "[USRP_TX_STUB] Generated ping response\n";
+    }
+
+    // Each subpacket has an unaccounted for 2 bytes which is the opcode
+    // and the length field
+    curr_payload += len + 2;
+  }
+
   return;
 }
 

Modified: 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_tx_stub.h
===================================================================
--- 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_tx_stub.h 
    2007-06-29 15:23:16 UTC (rev 5875)
+++ 
gnuradio/branches/developers/gnychis/inband/usrp/host/lib/inband/usrp_tx_stub.h 
    2007-06-29 15:55:04 UTC (rev 5876)
@@ -40,6 +40,7 @@
   usrp_standard_tx* d_utx;
   
   std::ofstream d_ofile;
+  std::ofstream d_cs_ofile;
 
   bool d_disk_write;
 
@@ -51,7 +52,7 @@
 
  private:
   void write(pmt_t data);
-  void parse_cs(transport_pkt pkt);
+  void parse_cs(pmt_t invocation_handle, transport_pkt pkt);
  
 };