> does the error occur exactly in the "make" call, or in the get_device3
It occurs in the make. > call, or somewhere else? > What is your UHD version? Are you running the right FPGA image for that > version? My uhd version is UHD_4.0.0.rfnoc-devel-409-gec9138eb. Yes it’s a custom fpga image. > > Best regards, > Marcus > > >> On Sat, 2018-03-17 at 20:13 +0000, Snehasish Kar wrote: >> 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 <marcus.muel...@ettus.com> >> Sent: Saturday, March 17, 2018 8:36:10 PM >> To: Snehasish Kar; usrp-users@lists.ettus.com >> 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 >>> USRP-users@lists.ettus.com >>> http://lists.ettus.com/mailman/listinfo/usrp-users_lists.ettus.com _______________________________________________ USRP-users mailing list USRP-users@lists.ettus.com http://lists.ettus.com/mailman/listinfo/usrp-users_lists.ettus.com