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
_______________________________________________
Discuss-gnuradio mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/discuss-gnuradio
