Hello Marcus
Sorry, but I didn't receive a copy of my previous mail or your response, so I
posted again.
For your reference below is my code:
#include <uhd/types/tune_request.hpp>
#include <uhd/types/sensors.hpp>
#include <uhd/utils/thread_priority.hpp>
#include <uhd/utils/safe_main.hpp>
#include <uhd/device3.hpp>
#include <uhd/rfnoc/radio_ctrl.hpp>
#include <uhd/rfnoc/source_block_ctrl_base.hpp>
#include <ppchan/chan128_block_ctrl.hpp>
#include <uhd/exception.hpp>
#include <boost/program_options.hpp>
#include <boost/format.hpp>
#include <boost/thread.hpp>
#include <iostream>
#include <fstream>
#include <csignal>
#include <complex>
#include <stdio.h>
#include <uhd/stream.hpp>
#include <SynchronousLabs/downSampler_block_ctrl.hpp>
#include <uhd/usrp/multi_usrp.hpp>
#define USRP_2954_R 0
#define USRP_2955_R 1
#define db_0 0
#define db_1 1
namespace po = boost::program_options;
double centre_freq_2954_db0 = 947.8e6;
double centre_freq_2954_db1 = 947.8e6-45e6;
static bool stop_signal_called = false;
void sig_int_handler(int){stop_signal_called = true;}
void recv_to_file(
uhd::rx_streamer::sptr rx_stream,
size_t samps_per_buff,
unsigned long long num_requested_samples,
bool continue_on_bad_packet = false
) {
unsigned long long num_total_samps = 0;
uhd::rx_metadata_t md;
std::vector<std::complex<float> > buff(samps_per_buff);
std::ofstream outfile;
#if 1
//outfile.open("/media/ramdd/rxfile.bin", std::ofstream::binary);
FILE *fp = fopen("/media/ramdd/rxfile.bin","w");
#endif
bool overflow_message = true;
//setup streaming
uhd::stream_cmd_t stream_cmd((num_requested_samples == 0)?
uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS:
uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE
);
stream_cmd.num_samps = num_requested_samples;
stream_cmd.stream_now = true;
stream_cmd.time_spec = uhd::time_spec_t();
std::cout << "Issuing start stream cmd" << std::endl;
// This actually goes to the null source; the processing block
// should propagate it.
rx_stream->issue_stream_cmd(stream_cmd);
unsigned long long last_update_samps = 0;
while(
not stop_signal_called
and (num_requested_samples != num_total_samps or num_requested_samples
== 0)
) {
size_t num_rx_samps = rx_stream->recv(&buff.front(), buff.size(), md, 3.0);
std::cout<<"number of samples "<<num_rx_samps<<std::endl;
if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) {
std::cout << boost::format("Timeout while streaming") << std::endl;
break;
}
if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW){
if (overflow_message){
overflow_message = false;
std::cerr << "Got an overflow indication. If writing to disk,
your\n"
"write medium may not be able to keep up.\n";
}
continue;
}
if (md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE){
std::string error = str(boost::format("Receiver error: %s") %
md.strerror());
if (continue_on_bad_packet){
std::cerr << error << std::endl;
continue;
}
else {
throw std::runtime_error(error);
}
}
num_total_samps += num_rx_samps;
#if 1
fwrite(&buff.front(),sizeof(std::complex<float>),num_rx_samps,fp);
#endif
#if 0
if (bw_summary) {
last_update_samps += num_rx_samps;
boost::posix_time::time_duration update_diff = now - last_update;
if (update_diff.ticks() >
boost::posix_time::time_duration::ticks_per_second()) {
double t = (double)update_diff.ticks() /
(double)boost::posix_time::time_duration::ticks_per_second();
double r = (double)last_update_samps / t;
std::cout << boost::format("\t%f Msps") % (r/1e6) << std::endl;
last_update_samps = 0;
last_update = now;
}
}
ticks_diff = now - start;
if (ticks_requested > 0){
if ((unsigned long long)ticks_diff.ticks() > ticks_requested)
break;
}
#endif
}
stream_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS;
rx_stream->issue_stream_cmd(stream_cmd);
#if 1
fclose(fp);
#endif
}
void pretty_print_flow_graph(std::vector<std::string> blocks)
{
std::string sep_str = "==>";
std::cout << std::endl;
// Line 1
for (size_t n = 0; n < blocks.size(); n++) {
const std::string name = blocks[n];
std::cout << "+";
for (size_t i = 0; i < name.size() + 2; i++) {
std::cout << "-";
}
std::cout << "+";
if (n == blocks.size() - 1) {
break;
}
for (size_t i = 0; i < sep_str.size(); i++) {
std::cout << " ";
}
}
std::cout << std::endl;
// Line 2
for (size_t n = 0; n < blocks.size(); n++) {
const std::string name = blocks[n];
std::cout << "| " << name << " |";
if (n == blocks.size() - 1) {
break;
}
std::cout << sep_str;
}
std::cout << std::endl;
// Line 3
for (size_t n = 0; n < blocks.size(); n++) {
const std::string name = blocks[n];
std::cout << "+";
for (size_t i = 0; i < name.size() + 2; i++) {
std::cout << "-";
}
std::cout << "+";
if (n == blocks.size() - 1) {
break;
}
for (size_t i = 0; i < sep_str.size(); i++) {
std::cout << " ";
}
}
std::cout << std::endl << std::endl;
}
#if 1
int c onfigure(int mboard_no, int dboard_no, uhd::device3::sptr usrp){
uhd::rfnoc::radio_ctrl::sptr radio_ctrl;
uhd::rfnoc::block_ctrl_base::sptr chan128_ctrl;
std::string downsample_make;
//uhd::rfnoc::block_ctrl_base::sptr downSampler;
uhd::rfnoc::block_ctrl_base::sptr fifo;
//uhd::rfnoc::
uhd::rfnoc::downSampler_block_ctrl::sptr downSampler;
usrp->clear();
uhd::rfnoc::block_ctrl_base::sptr packetresizer_ctrl;
std::string file, format, ant, subdev, ref, wirefmt, streamargs, block_id,
block_args;
size_t total_num_samps, spp = 128, spb=10e3;
double sampleRate = 0x00;
std::string radio_args("Radio channel");
std::vector<std::string> blocks;
uhd::device_addr_t stream_args_args;
usrp->clear();
uhd::rfnoc::graph::sptr rx_graph = usrp->create_graph("GSM_RF_DUPLEX_CHAIN");
uhd::rfnoc::block_id_t radio_ctrl_id(mboard_no, "Radio", dboard_no);
if(not(usrp->has_block(radio_ctrl_id))){
std::cout<<"error: radio block not found..please check whether the block exists
in the image! quiting"<<std::endl;
return (EXIT_FAILURE);
}else{
std::cout<<"radio_"<<dboard_no <<" block found.."<<std::endl;
radio_ctrl = usrp->get_block_ctrl< uhd::rfnoc::radio_ctrl >(radio_ctrl_id);
blocks.push_back(radio_ctrl->get_block_id());
if(mboard_no == 0x00){
sampleRate = 200e6;
}else{
sampleRate = 100e6;
}
radio_ctrl->set_args(radio_args);
radio_ctrl->set_rate(sampleRate);
if(dboard_no==0){
uhd::tune_request_t tune_request(centre_freq_2954_db0);
radio_ctrl->set_rx_frequency(centre_freq_2954_db0,0);
}else{
uhd::tune_request_t tune_request(centre_freq_2954_db1);
radio_ctrl->set_rx_frequency(centre_freq_2954_db1,0);
}
std::cout<<"freq "<<radio_ctrl->get_rx_frequency(0)<<std::endl;
radio_ctrl->set_rx_antenna("RX2",0);
radio_ctrl->set_rx_gain(25,0);
std::cout<<"gain "<<radio_ctrl->get_rx_gain(0)<<std::endl;
radio_ctrl->set_rx_bandwidth(56e6,0);
uhd::device_addr_t stream_args_args1;
stream_args_args1["block_id"] = radio_ctrl_id;
#if 1
uhd::stream_args_t stream_args1("fc32", "sc16");
stream_args1.args = stream_args_args1;
uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args1);
stream_args1.args["gr_vlen"] = boost::lexical_cast<std::string>(1);
uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args1);
#endif
//radio_ctrl->set_arg<int>("gr_vlen",(int)1);
}
#if 1
uhd::rfnoc::block_id_t downsampler_ctrl_id(mboard_no, "downSampler", dboard_no);
if(not(usrp->has_block(downsampler_ctrl_id))){
std::cout<<"error: downsampler block not found..please check whether the
block exists in the image"<<std::endl;
return (EXIT_FAILURE);
}else{
std::cout<<"downSampler_"<<dboard_no<<" block found.."<<std::endl;
downSampler =
usrp->get_block_ctrl<uhd::rfnoc::downSampler_block_ctrl>(downsampler_ctrl_id);
blocks.push_back(downSampler->get_block_id());
#if 1
downSampler->set_arg<int>("sr_n",(int)1000);
downSampler->set_arg<int>("sr_m",(int)128);
#endif
#if 0
uhd::device_addr_t stream_args_args1;
stream_args_args1["block_id"] = downsampler_ctrl_id;
uhd::stream_args_t stream_args1("fc32", "sc16");
stream_args1.args = stream_args_args1;
stream_args1.args["sr_n"] = boost::lexical_cast<std::string>(1000);
stream_args1.args["sr_m"] = boost::lexical_cast<std::string>(128);
uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args1);
uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args1);
#endif
}
#endif
#if 0
/*********************************************/
//downsampler = new downSampler_block_ctrl;
/*********************************************/
#endif
uhd::rfnoc::block_id_t packetresizer_ctrl_id(mboard_no, "PacketResizer",
dboard_no);
if(not(usrp->has_block(packetresizer_ctrl_id))){
std::cout<<"error: packetResizer block not found..please check whether the
block exists in the image"<<std::endl;
return (EXIT_FAILURE);
}else{
std::cout<<"packetResizer_"<<dboard_no<<" block found.."<<std::endl;
packetresizer_ctrl = usrp->get_block_ctrl(packetresizer_ctrl_id);
blocks.push_back(packetresizer_ctrl->get_block_id());
packetresizer_ctrl->set_arg<int>("pkt_size",(int)512);
//packetresizer_ctrl->set
#if 0
uhd::device_addr_t stream_args_args1;
stream_args_args1["block_id"] = packetresizer_ctrl_id;
uhd::stream_args_t stream_args1("fc32", "sc16");
stream_args1.args = stream_args_args1;
uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args1);
stream_args1.args["pkt_size"] = boost::lexical_cast<std::string>(512);
uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args1);
#endif
}
uhd::rfnoc::block_id_t chan128_ctrl_id(mboard_no, "chan128", dboard_no);
if(not(usrp->has_block(chan128_ctrl_id))){
std::cout<<"error: chan128 block not found..please check whether the block
exists in the image"<<std::endl;
return (EXIT_FAILURE);
}else{
std::cout<<"chan128_"<< dboard_no<<" block found.."<<std::endl;
chan128_ctrl = usrp->get_block_ctrl(chan128_ctrl_id);
blocks.push_back(chan128_ctrl->get_block_id());
//stream_args_args["block_id"] = chan128_ctrl_id;
spp = chan128_ctrl->get_args().cast<size_t>("spp",spp);
std::cout<<"spp "<<(int)spp<<std::endl;
uhd::device_addr_t stream_args_args1;
stream_args_args1["block_id"] = chan128_ctrl_id;
#if 0
uhd::stream_args_t stream_args1("fc32", "sc16");
stream_args1.args = stream_args_args1;
stream_args1.args["gr_vlen"] = boost::lexical_cast<std::string>(128);
stream_args1.args["spp"] = boost::lexical_cast<std::string>(128);
uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args1);
uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args1);
#endif
}
blocks.push_back("HOST");
pretty_print_flow_graph(blocks);
uhd::rfnoc::block_id_t fifo_ctrl_id(mboard_no, "FIFO", dboard_no);
if(not usrp->has_block(fifo_ctrl_id)){
std::cout<<"error:FIFO block not found"<<std::endl;
}else{
fifo = usrp->get_block_ctrl(fifo_ctrl_id);
}
// Connect blocks and create flow graph
uhd::device_addr_t stream_args_args1;
stream_args_args["block_id"] = fifo_ctrl_id;
rx_graph->connect(radio_ctrl->get_block_id(),downSampler->get_block_id());
//rx_graph->connect(downSampler->get_block_id(),packetresizer_ctrl->get_block_id());
//rx_graph->connect(packetresizer_ctrl->get_block_id(),chan128_ctrl->get_block_id());
rx_graph->connect(downSampler->get_block_id(),fifo->get_block_id());
uhd::stream_args_t stream_args("fc32", "sc16");
stream_args.args = stream_args_args;
//stream_args.args["spp"] = boost::lexical_cast<std::string>(spp);
//stream_args.args["gr_vlen"] = boost::lexical_cast<std::string>(spp);
uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
//uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);
recv_to_file(rx_stream, spb, 0, true);
return (EXIT_SUCCESS);
}
#endif
int UHD_SAFE_MAIN(int argc, char *argv[]){
uhd::set_thread_priority_safe();
std::string args2954R("addr=192.168.40.2");
std::string args2955R("addr=192.168.110.2");
double rate, freq, gain, bw, total_time, setup_time;
//Initializing the USRP Components
std::cout <<"Initializing USRP 2954R"<<std::endl;
uhd::usrp::multi_usrp::sptr usrp_temp =
uhd::usrp::multi_usrp::make(args2954R);
uhd::device3::sptr usrp = usrp_temp->get_device3();
if(configure(USRP_2954_R,db_0,usrp)==1){
std::cout<<"error: Configuring USRP 2954R not successful"<<std::endl;
}
//boost::thread usrp2954_db0(configure,USRP_2954_R,db_0,usrp);
/*if(configure(USRP_2954_R,db_1,usrp)==1){
std::cout<<"error: Configuring USRP 2954R not successful"<<std::endl;
}*/
usleep(100);
//boost::thread usrp2954_db1(configure,USRP_2954_R,db_1,usrp);
std::signal(SIGINT, &sig_int_handler);
}
________________________________
From: Marcus Müller <[email protected]>
Sent: Saturday, March 17, 2018 8:36:10 PM
To: Snehasish Kar; [email protected]
Subject: Re: [USRP-users] Help with uhd
Dear Shehasish,
Marcus Leech already responded to your last mail.
We can't help you without all your code, especially whatever sets up
"args2954R".
Best regards,
Marcus M
On Sat, 2018-03-17 at 06:22 +0000, Snehasish Kar via USRP-users wrote:
> hello
>
> On trying to use an multi usrp shared pointer, I get the following
> error in rfnoc enviroment:
>
> Error: TypeError: [0/FIFO_1] Invalid output port number (ANY).
>
> I declared the shared pointer as below
>
> uhd::usrp::multi_usrp::sptr usrp_temp =
> uhd::usrp::multi_usrp::make(args2954R);
> uhd::device3::sptr usrp = usrp_temp->get_device3();
>
> Any idea where I am going wrong.
>
> BR
> Snehasish
>
>
> _______________________________________________
> USRP-users mailing list
> [email protected]
> http://lists.ettus.com/mailman/listinfo/usrp-users_lists.ettus.com
_______________________________________________
USRP-users mailing list
[email protected]
http://lists.ettus.com/mailman/listinfo/usrp-users_lists.ettus.com
