[Discuss-gnuradio] Blocks handling vectors

[Galiero Casay Gabriele]

Hi, I have been struggling a bit trying to code a block that accept for example vectors of sync_len*sizeof(float) as input signature and outputs vectors of (sync_len+pkt_len)*sizeof(float) as output signature.

To understand how blocks handling vectors work, I tried to make the same block I did using single element items, which consists of a block that adds a preamble of sync_len at the beginning of the sequence. It worked using single element items, instead of vectors but in the receiving part, should be a block that basically removes that preamble. In this case, it was so difficult the coding and did not get it, that is why I decided to try with vectors.

Now some doubts came to my mind. In the tutorials there is a gap concerning vectors or I haven't found any processing block in the tutorial examples that explains a bit how vectors are processed.

- The io signatures would be defined like this:
        gr::io_signature::make(1,  1,  pkt_len*sizeof(float)),
        gr::io_signature::make(1, 1, sizeof(float) * (sync_word_len + pkt_len)))
 To clarify a bit what I want is to add a predefined preamble of length sync_word, which I define in the constructor and cannot be accessible.
 Now, one of my questions was, is the most suitable block that I have to use a general one? or is it possible to use a decimator?

- In my first implementation I used a general block:
 
 void
    add_sync_impl::forecast (int noutput_items, gr_vector_int &ninput_items_required)
    {
        ninput_items_required[0] = noutput_items * d_pkt_len;
    } 

  int
    add_sync_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 float *in = (const float *) input_items[0];
        float *out = (float *) output_items[0];

        // Do <+signal processing+>
        for (int i = 0; i < noutput_items; i++) {
            std::memcpy(&out[0], &d_sync_word[0], sizeof(float) * d_sync_word_len);
            std::memcpy(&out[d_sync_word_len], &in[0], sizeof(float) * d_pkt_len);
        }
        // Tell runtime system how many input items we consumed on
        // each input stream.
        consume_each (d_pkt_len);

        // Tell runtime system how many output items we produced.
        return noutput_items;
    }

 But when I try to connect the blocks to test them with python it gives me error:
  File "<stdin>", line 1, in <module>
  File "/usr/local/lib/python2.7/dist-packages/gnuradio/gr/hier_block2.py", line 48, in wrapped
    raise ValueError("Unable to coerce endpoint")
ValueError: Unable to coerce endpoint

I am doing something wrong, like copying the info into output wrongly, or I coded forecast wrongly or I am indicating wrongly the consumed items. I would thanks any kind of help or explanation about how block handles vectors.

As example: d_sync_word_len = 3
                     d_sync_word = {0, 0, 0}
                     d_pkt_len = 5

Result(passed from vector to stream with a vector to stream block):
            input = (1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
           output = (0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1)

I know that there are some blocks that already do this, but I was mostly interested in knowing how blocks handle vectors. Or also I would be interested to know the inverse block of vector_insert (in python).
Thanks before hand.

Gabriele Galiero