Re: [Discuss-gnuradio] how to manage time!

[Activecat]

On Fri, May 9, 2014 at 2:14 PM, Mostafa Alizadeh <address@hidden> wrote:

I actually want to implement a transmitter. So in this transmitter different data streams come from different sources with different rates (or sample rates). Then all of these streams gather together in a block, may I call it "Collector" then it sends the gathered data stream to the USRP sink. The Collector block should gather the data stream in some specific manner to put the streams in a particular frame!

The only thing I don't know here is how could I generate these different-rate data?

To accomplish this, you need to forecast() and consume() different rates at different ports.

Let me give you a sample code similar to your "Collector" block.

Say both block A and block B are directly connected to your Collector block.

Block A output rate = rate1 = 200ksps

Block B output rate = rate2 =   10kbps

Collector block output rate = 200kbps

Below is the collector_impl.cc:

    namespace gr {
      namespace activecat {

        // make
        quad_up2::sptr
        quad_up2::make( float rate1, float rate2 )
        {
          return gnuradio::get_initial_sptr
            (new quad_up2_impl(rate1, rate2));
        }


        // constructor
        quad_up2_impl::quad_up2_impl( float rate1, float rate2 )
          : gr::block( "quad_up2",
                  gr::io_signature::make( 2, 2, sizeof(gr_complex) ),
                  gr::io_signature::make( 1, 1, sizeof(float) ) ),
              d_rate1( rate1 ),
              d_rate2( rate2 )
        {
            if ( (int)rate1 % (int)rate2 )
                throw std::runtime_error( "quad_up1: rate1 must be exact multiple of rate2" );
               
            d_ratio12 = int( rate1 / rate2 );         // equals to 20 in this example
           
            set_output_multiple( d_ratio12 );
        }


        // destructor
        quad_up2_impl::~quad_up2_impl()
        { }


        // forecast
        void
        quad_up2_impl::forecast (int noutput_items, gr_vector_int &ninput_items_required)
        {
            ninput_items_required[0] = noutput_items / d_ratio12;      // connected to Block B
            ninput_items_required[1] = noutput_items;                      // connected to Block A
        }


        // general_work
        int
        quad_up2_impl::general_work ( int noutput_items,
                           gr_vector_int &ninput_items,
                           gr_vector_const_void_star &input_items,
                           gr_vector_void_star &output_items)
        {
            const gr_complex *data = "" gr_complex *) input_items[0];              // connected to Block B
            const gr_complex *clk  = (const gr_complex *) input_items[1];               // connected to Block A
            float            *out  = (float *)           output_items[0];

            if ( noutput_items % d_ratio12 )
            {
                std::cout << "noutput_items = " << noutput_items << ",  d_ratio12 = " << d_ratio12 << std::endl;
                throw std::runtime_error("quad_up2: noutput_items is not exact multiple of d_ratio12");
            }
           
            for( int i=0; i < noutput_items; i++)    
                out[i] =  clk[i].real() * data[ i/d_ratio12 ].real()  -  clk[i].imag() * data[ i/d_ratio12 ].imag();


            consume(0, noutput_items / d_ratio12);       // consumes data from Block B
            consume(1, noutput_items );                      // consumes data from Block A

            return noutput_items;
        }

      } /* namespace activecat */
    } /* namespace gr */