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.