DBPSK rework (SDPSK implementation)

My goal is to rework DBPSK module, so that it is possible to easily
implement
SDPSK module.

DBPSK goes like this: differential_encoding > ordinary BPSK, so there is
no
actual constellation rotation. All rotation part is done by
diff.encoder.
But this can be done only when shifting between 2 states. SDPSK shifts
between 4 states (1 = +90’, 0 = -90’).

So my intention was to make a class which would do something like the
following:

state = 1+0j #initial phase

if (chunk&0x01==1)
state = state * p_change;
else
state = state * n_change;

for DBPSK p_change=1+0j (no change in phase if bit = 1)
n_change=-1+0j (reverse phase if bit = 0)

for SDPSK p_change =0+1j (+90’ turn if bit = 1)
n_change =0-1j (-90’ turn if bit = 0)

It can’t be implemented as a function because it has to store current
state
somewhere. So I should probably write a class, where state would be
initialized at constructor.

So I have read this “How to write a signal processing block” guide.

Also have written howto_diffconst.h file:

#ifndef INCLUDED_HOWTO_DIFFCONST_BC_H
#define INCLUDED_HOWTO_DIFFCONST_BC_H

#include <gr_block.h>

class howto_diffconst_bc;

typedef boost::shared_ptr<howto_diffconst_bc> howto_diffconst_bc_sptr;

howto_diffconst_bc_sptr howto_make_diffconst_bc ();

class howto_diffconst_bc : public gr_block
{
private:
friend howto_diffconst_bc_sptr howto_make_diffconst_bc ();
howto_diffconst_bc ();

public:
~howto_diffconst_bc ();
int general_work (int noutput_items, gr_vector_int &ninput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items);
};

#endif

and stopped at howto_diffconst.cc file:

#ifdef HAVE_CONFIG_H
#include “config.h”
#endif

#include <howto_diffconst_bc.h>
#include <gr_io_signature.h>

howto_diffconst_bc_sptr howto_make_diffconst_bc () {return
howto_diffconst_bc_sptr

(new howto_diffconst_bc ());}

howto_diffconst_bc::howto_diffconst_bc (): gr_block (“diffconst_bc”,

gr_make_io_signature (1, 1, 1),

gr_make_io_signature (1, 1, 8)) {}

howto_diffconst_bc::~howto_diffconst_bc () {}

int howto_diffconst_bc::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];
//out[0] = in[0] * in[0];

consume_each (noutput_items);
return noutput_items;
}

Now, finally about what bothers me.

First - signatures. Input should be a single chunk, output - signle
complex.
So I wrote input signature: gr_make_io_signature(1,1,1), output
signature:
gr_make_io_signature(1,1,8)

Would that be correct?

Next - variables. Thing is I have no idea what type of variables to use
for
chunk and complex.

My guess - int for chunk, and complex class (complex) from
standart
c++ library ( http://cplusplus.com/reference/std/complex/complex/
std/complex ) for complex. But would that be compatible with gnu-radio
complex?

Third - initialization. Do I set initial phase

howto_diffconst_bc::howto_diffconst_bc (): gr_block (“diffconst_bc”,

gr_make_io_signature (1, 1, 1),

gr_make_io_signature (1, 1, 8)) {here?}

Please help! Any suggestions accepted.

View this message in context:
http://old.nabble.com/DBPSK-rework-(SDPSK-implementation)-tp29249098p29249098.html
Sent from the GnuRadio mailing list archive at Nabble.com.

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs