Changeset 11094 for ossiedev/branches/june/trunk/platform/USRP_UHD/src/USRP_UHD.cpp

Timestamp:

04/05/12 13:02:33 (15 months ago)

Author:

june

Message:

Completing test on USRP1, USRP2

Files:

• ossiedev/branches/june/trunk/platform/USRP_UHD/src/USRP_UHD.cpp (modified) (10 diffs)

ossiedev/branches/june/trunk/platform/USRP_UHD/src/USRP_UHD.cpp

@@ -26 +26 @@
 #include <vector>
 #include <complex>
+#include <boost/program_options.hpp>
+#include <boost/format.hpp>
+#include <boost/thread.hpp>
 
 #include "ossie/cf.h"
@@ -39 +42 @@
         set_rx_packet_count(-1),
         rx_packet_count(1024),
-        rx_packet_size(256),
+        rx_packet_size(8192),
         rx_data_size(2),
         number_of_channels(1),
@@ -50 +53 @@
 {
 // Create USRP_UHD Control ports for TX and RX
-    rx_control_port = new USRP_UHD_RX_Control_i(this, "U2_RX_Control", "DomainName1");
-    tx_control_port = new USRP_UHD_TX_Control_i(this, "U2_TX_Control", "DomainName1");
+    rx_control_port = new USRP_UHD_RX_Control_i(this, "UHD_RX_Control", "DomainName1");
+    tx_control_port = new USRP_UHD_TX_Control_i(this, "UHD_TX_Control", "DomainName1");
 
 // Create the ports for TX data
-    tx_data_port = new standardInterfaces_i::complexShort_p("U2_TX_Data", "DomainName1");
+    for(int i=0;i<MAX_TX_CHANNEL;i++)
+        tx_data_ports[i] = new standardInterfaces_i::complexShort_p(boost::str(boost::format("UHD_TX_Data_%d") % (i+1)).c_str(), "DomainName1");
 
 // Create the ports for RX Data
-    rx_data_1_port = new standardInterfaces_i::complexShort_u("U2_RX_Data_1", "DomainName1");
-    rx_data_2_port = new standardInterfaces_i::complexShort_u("U2_RX_Data_2", "DomainName1");
+    for(int i=0;i<MAX_RX_CHANNEL;i++)
+        rx_data_ports[i] = new standardInterfaces_i::complexShort_u(boost::str(boost::format("UHD_RX_Data_%d") % (i+1)).c_str(), "DomainName1");
+
 }
 
@@ -81 +86 @@
     if (!CORBA::is_nil(p = rx_control_port->getPort(portName)))
         return p._retn();
-    else if (!CORBA::is_nil(p = rx_data_1_port->getPort(portName)))
+    else if (!CORBA::is_nil(p = tx_control_port->getPort(portName)))
         return p._retn();
-    else if (!CORBA::is_nil(p = rx_data_1_port->getPort(portName))) {
-        return p._retn();
-    } else if (!CORBA::is_nil(p = tx_control_port->getPort(portName))) {
-        return p._retn();
-    } else if (!CORBA::is_nil(p = tx_data_port->getPort(portName))) {
-        return p._retn();
+    else {
+        for(int i=0;i<MAX_RX_CHANNEL;i++)
+                if (!CORBA::is_nil(p = rx_data_ports[i]->getPort(portName)))
+                        return p._retn();
+
+        for(int i=0;i<MAX_TX_CHANNEL;i++)
+                if (!CORBA::is_nil(p = tx_data_ports[i]->getPort(portName)))
+                        return p._retn();
     }
+
     std::cerr << "Couldn't find port " << portName << "Throwing exception" << std::endl;
-    throw CF::PortSupplier::UnknownPort();
+   // throw CF::PortSupplier::UnknownPort();
 }
 
@@ -100 +108 @@
     DEBUG(1, USRP_UHD, "Creating the usrp device with: "<< args)
     sdev = uhd::usrp::multi_usrp::make(args);
-    dev = sdev->get_device();
+    dev = sdev->get_device();//uhd::device::make(args);
+    probe_usrp();
+    rx_control_port->set_number_of_channels(1);
+    tx_control_port->set_number_of_channels(1);
     sdev->set_rx_antenna("RX2");
     sdev->set_rx_antenna("TX/RX");
@@ -127 +138 @@
 }
 
+void USRP_UHD_i::rx_error_helper(uhd::rx_metadata_t::error_code_t error)
+{
+    switch(error){
+        case uhd::rx_metadata_t::ERROR_CODE_NONE:
+            break;
+        case uhd::rx_metadata_t::ERROR_CODE_TIMEOUT:
+            DEBUG(2, USRP_UHD, "Got timeout before all samples received, possible packet loss")
+            break;
+        case uhd::rx_metadata_t::ERROR_CODE_LATE_COMMAND:
+                DEBUG(2, USRP_UHD, "UHD::ERROR_CODE_LATE_COMMAND")
+                break;
+        case uhd::rx_metadata_t::ERROR_CODE_BROKEN_CHAIN:
+                DEBUG(2, USRP_UHD, "UHD::ERROR_CODE_BROKEN_CHAIN")
+                break;
+        case uhd::rx_metadata_t::ERROR_CODE_OVERFLOW:
+                //DEBUG(2, USRP_UHD, "UHD::ERROR_CODE_OVERFLOW")
+                break;
+        case uhd::rx_metadata_t::ERROR_CODE_ALIGNMENT:
+                DEBUG(2, USRP_UHD, "UHD::ERROR_CODE_ALIGNMENT")
+                break;
+        case uhd::rx_metadata_t::ERROR_CODE_BAD_PACKET:
+                DEBUG(2, USRP_UHD, "UHD::ERROR_CODE_BAD_PACKET")
+                break;
+        default:
+            DEBUG(3, USRP_UHD, "Got Error Code 0x"<<error)
+    }
+}
 
 void USRP_UHD_i::rx_data_process()
@@ -146 +184 @@
     sdev->issue_stream_cmd(stream_cmd);
 
-    uhd::stream_args_t stream_args("sc16");
+    uhd::stream_args_t stream_args("sc16"); //complex floats
     stream_args.args["noclear"] = "1";
+    for (size_t chan = 0; chan < rx_channels; chan++)
+        stream_args.channels.push_back(chan); //linear mapping
     uhd::rx_streamer::sptr rx_stream = sdev->get_rx_stream(stream_args);
-
+    DEBUG(3, USRP_UHD, "Rx Channels = " << rx_channels)
     PortTypes::ShortSequence I;
     PortTypes::ShortSequence Q;
     
 ///\TODO Make sure rx_packet_size is >= than USRP_UHD_MIN_RX_SAMPLES!!!!!
-    rx_buff.resize(rx_packet_size);
+    std::vector<std::vector< std::complex<short> > > rx_buff(
+                rx_channels, std::vector< std::complex<short> >(rx_packet_size)
+    );
     I.length(rx_packet_size);
     Q.length(rx_packet_size);
+
+    std::vector<std::complex<short> *> rx_buff_ptrs;
+    for (size_t i = 0; i < rx_buff.size(); i++)
+        rx_buff_ptrs.push_back(&rx_buff[i].front());
 
     DEBUG(3, USRP_UHD, "RX packet count " << rx_packet_count)
@@ -168 +214 @@
                         did_rx = true;
                 }
+                //DEBUG(9, USRP_UHD, "issue cmd")
 
         
 //TODO get rid of num_rx_samps variable
-        size_t num_rx_samps = rx_stream->recv( &rx_buff.front(), rx_packet_size, md);
+        size_t num_rx_samps = rx_stream->recv( rx_buff_ptrs, rx_packet_size, md);
+                //DEBUG(9, USRP_UHD, "recv data")
         
         //Handle UHD error codes
-        switch(md.error_code){
-            case uhd::rx_metadata_t::ERROR_CODE_NONE:
-                break;
-            case uhd::rx_metadata_t::ERROR_CODE_TIMEOUT:
-                DEBUG(3, USRP_UHD, "Got timeout before all samples received, possible packet loss")
-                break;
-            default:
-                DEBUG(3, USRP_UHD, "Got error code 0x"<<md.error_code)
+        rx_error_helper(md.error_code);
+
+        for(int j=0;j<rx_channels;j++){
+
+                        for (unsigned int i = 0; i < num_rx_samps; i++) {
+                                I[i] = (CORBA::Short) rx_buff[j][i].real();
+                                Q[i] = (CORBA::Short) rx_buff[j][i].imag();
+                        }
+
+                        //DEBUG(9, USRP_UHD, "before push packet")
+                        rx_data_ports[j]->pushPacket(I, Q);
+                        //DEBUG(9, USRP_UHD, "after push packet")
         }
 
-                for (unsigned int i = 0; i < num_rx_samps; i++) {
-                        I[i] = (CORBA::Short) rx_buff[i].real();
-                        Q[i] = (CORBA::Short) rx_buff[i].imag();
-                }
-                rx_data_1_port->pushPacket(I, Q);
+
 
                 if (rx_packet_count != -1)
@@ -220 +268 @@
     const unsigned int tx_buf_len(USRP_UHD_MAX_TX_SAMPLES);
 
-    uhd::stream_args_t stream_args("sc16");
+    uhd::stream_args_t stream_args("sc16"); //complex short
     stream_args.args["noclear"] = "1";
+    for (size_t chan = 0; chan < tx_channels; chan++)
+        stream_args.channels.push_back(chan); //linear mapping
     uhd::tx_streamer::sptr tx_stream = sdev->get_tx_stream(stream_args);
-
 
     uhd::tx_metadata_t md3;
@@ -238 +287 @@
     //md.time_spec = uhd::time_spec_t((time_t)0 );
 
-    std::vector< std::complex<short int> > tx_buff(tx_buf_len);
 
     DEBUG(3, USRP_UHD, "Starting tx_data_process thread.")
     
     tx_active = true; // Cleared to stop TX in USRP_UHD_TX_Control->stop()
-
+    size_t samps_to_send = 0;
+    std::vector<std::complex<short> *> tx_buff_ptrs;
+    DEBUG(3, USRP_UHD, "Max Number of Sample="<<tx_stream->get_max_num_samps())
     while (tx_active) {
-                //if running half duplex mode we want to stop Rx streaming while transmitting
-                if (full_duplex == false && did_rx == true)  {
-                                did_rx = false;
-                        uhd::rx_metadata_t md;
-                        size_t num_rx_samps = dev->recv( &rx_buff.front(), rx_packet_size, md,
-                                                                                                uhd::io_type_t::COMPLEX_INT16,
-                                                                                                uhd::device::RECV_MODE_FULL_BUFF);
-                        sdev->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
-
+
+                for(int i=0;i<tx_channels;i++){
+
+                        tx_data_ports[i]->getData(I_in, Q_in);
+                        samps_to_send = I_in->length();
+
+                    std::vector<std::complex<short> > tx_buff(samps_to_send);
+
+                        for (unsigned int j = 0; j < samps_to_send; ++j) {
+                                tx_buff[j] = std::complex<short int> (convertToLE((*I_in)[j]),convertToLE((*Q_in)[j]));
+                        }
+
+                        tx_buff_ptrs.push_back(&tx_buff.front());
+                tx_data_ports[i]->bufferEmptied();
                 }
 
-
-        tx_data_port->getData(I_in, Q_in);
-        size_t samps_to_send = I_in->length();
-        
-        if(samps_to_send > tx_buf_len){
-            std::cerr << "USRP_UHD Tx Buffer Overflow. Throwing Exception"<<std::endl;
-            throw std::runtime_error("USRP_UHD buffer overflow");
-        }
-
-        for (unsigned int i = 0; i < samps_to_send; ++i) {
-            tx_buff[i] = std::complex<short int> (convertToLE((*I_in)[i]),convertToLE((*Q_in)[i]));
-        }
-
         //send the entire packet (driver fragments internally)
-        size_t num_tx_samps = tx_stream->send( &tx_buff.front(), samps_to_send, md3);
-        tx_data_port->bufferEmptied();
+        size_t num_tx_samps = tx_stream->send(tx_buff_ptrs, samps_to_send, md3);
+
+
                 
     }
-    
     DEBUG(3, USRP_UHD, "Exiting tx_data_process thread.")
     tx_thread->exit();
 }
+
+void print_tree(const uhd::fs_path &path, uhd::property_tree::sptr tree){
+    std::cout << path << std::endl;
+    BOOST_FOREACH(const std::string &name, tree->list(path)){
+        print_tree(path / name, tree);
+    }
+}
+
+
+void USRP_UHD_i::probe_usrp()
+{
+        DEBUG(3, USRP_UHD, "Probing daughter board of USRP..")
+    uhd::property_tree::sptr tree = dev->get_tree();
+        uhd::fs_path db_path, mb_path = "/mboards";
+        mb_count = tree->list("/mboards").size();
+        std::cout<<" The number of MB : "<<mb_count<<std::endl;
+        for(int i=0;i<mb_count;i++){
+                mb_path = "/mboards";
+                mb_path = mb_path / tree->list("/mboards")[i];
+                db_count = tree->list( mb_path / "dboards").size();
+                std::cout<<"  The number of DB slot: "<<db_count<<std::endl;
+                for(int j=0;j<db_count;j++){
+                        db_path = mb_path / "dboards" / tree->list( mb_path / "dboards")[j];
+                        uhd::usrp::dboard_eeprom_t prom = tree->access<uhd::usrp::dboard_eeprom_t>(db_path / "tx_eeprom").get();
+                        std::cout<<"   TxDB ID : "<<prom.id.to_string()<<std::endl;
+
+                        prom = tree->access<uhd::usrp::dboard_eeprom_t>(db_path / "rx_eeprom").get();
+                        std::cout<<"   RxDB ID : "<<prom.id.to_string()<<std::endl;
+                }
+
+
+        }
+
+}