Hi All, I have been battling with this for the last week and still have not found a solution.
I've include some more info for anyone who can help. USRP1 Daughterboard: RFX2400 [using TX/RX port for Transmission & RX2 port for Reception] Carrier Freq: 2.43 GHz I've also included the constellation diagrams (for the output of the differential Phasor) for each of the 4 cases. So once again recapping, i'm inputting the byte [108] through a vector source, but only get the correct output sequence [108] SOME of the time, while at other times i will get either 177, 27, or 28. Case 1) The correct decoded sequence [108] = [0x6x] = [01101100] http://users.tpg.com.au/marcinw//correct.PNG Case 2) Incorrectly decoded sequence [177] http://users.tpg.com.au/marcinw//incorrect1.PNG Case 3) Incorrectly decoded sequence [27] http://users.tpg.com.au/marcinw//incorrect2.PNG Case 4) Incorrectly decoded sequence [198] http://users.tpg.com.au/marcinw//incorrect3.PNG Note: When inputting less complicated input sequences however, eg: 11111111 ,00000000, 01010101, were only 1 possible QPSK symbol is contained within the byte, the output sequence seems to decode correctly. Once i complicate the input byte though, to something like [01101100] = [108] , where ALL possible QPSK symbols are contained within that byte, i will receive the incorrect sequence at the output (most of the time). Some final questions: 1) Can anybody work out why the sequence isn't decoding correctly? 2) Has anybody actually successfully created DQPSK transmission/reception using a Byte Vector Source as the input and Byte vector sink as the output? 3) Will i have to resort to some sort of Channel Coding/Decoding to correct the received sequence? Regards, Marcin marcin_w wrote: > > I've recently been working on transmitting data from a vector source via > DQPSK. > > I've created a Simulation [non USRP] with the following flow graph: > > TX > Vector Source [0x6c] ie 01 10 11 00 > Packed To Unpacked > Mapper > [Binary 2 Gray] > Differential Encoder > > Chunks to Symbols > > RX > Differential Phasor > Constellation Decoder > Mapper [Gray 2 Binary] > > Unpacked To Packed > Vector Sink > > For differential encoding, i've also ammended the first input byte to be > 0. > The Output for the simulation is as expected: > > ie. Input = 0 108 108 108 108 108 108 ....... > Output = 0 108 108 108 108 108 108 ....... > > When i try transmitting this data through the USRP however, i receive 4 > possible outputs. These include: > > 108 [which is correct] > 177 [wrong] > 108 [wrong] > 27 [wrong] > > These are funnily the 4 possible outputs which have all possible symbols > in 1 byte. ie 00 01 10 11 > The output varies, one time i might get all 108s as expected , and other > times ill get one of the other 3 outputs. > The signal constellation at the output of the differential phasor looks > correct. > > Does anyone have any idea what is going wrong here? > I've included my python source code below: > > ################################################## > # Gnuradio Python Flow Graph > # Title: Qpsktest > # Generated: Thu Apr 22 02:01:45 2010 > ################################################## > > from gnuradio import gr > from gnuradio.blks2impl import psk > from gnuradio.eng_option import eng_option > from gnuradio.gr import firdes > from grc_gnuradio import usrp as grc_usrp > from grc_gnuradio import wxgui as grc_wxgui > from optparse import OptionParser > import wx > > class QPSKtest(gr.top_block): > > def __init__(self): > gr.top_block.__init__(self) > > ################################################## > # Variables > ################################################## > self.arity = arity = pow(2,2) > self.samp_rate = samp_rate = 256000 > self.rotated_const = rotated_const = map(lambda pt: pt * > 1, psk.constellation[arity]) > self.rot = rot = .707 + .707j > self.data = 100000 * [0x6C,] > > ## Initial Block to Capture data from Vector Source and > then Add 0 at the beginning > > fg = gr.top_block() > > self.vectorSource = gr.vector_source_b(self.data, False, > 1) > self.VSINK = gr.vector_sink_b(1) > > fg.connect(self.vectorSource, self.VSINK) > > fg.run() > > actual_data = self.VSINK.data() > > ##make first data element 0 for the sake of the Diff > Encoder etc > actual_data_copy = (0,) + actual_data[1:] > print actual_data_copy > > ################################################## > # Main Blocks > ################################################## > self.gr_chunks_to_symbols_xx_0 = > gr.chunks_to_symbols_bc((map(lambda pt: pt * rot, > psk.constellation[arity])), 1) > self.gr_clock_recovery_mm_xx_0 = > gr.clock_recovery_mm_cc(2, 0.25 * 0.03 * 0.03, 0.05, 0.03, 0.005) > self.gr_constellation_decoder_cb_0 = > gr.constellation_decoder_cb((rotated_const), (range(arity))) > self.gr_costas_loop_cc_0 = gr.costas_loop_cc(0.10, 0.25 * > 0.1 * 0.1, 0.002, -0.002, 4) > self.gr_diff_encoder_bb_0 = gr.diff_encoder_bb(arity) > self.gr_diff_phasor_cc_0 = gr.diff_phasor_cc() > self.gr_feedforward_agc_cc_0 = gr.feedforward_agc_cc(16, > 1.0) > self.gr_fir_filter_xxx_1 = gr.fir_filter_ccf(1, > (gr.firdes.root_raised_cosine(2,2,1.0,0.35,22))) > self.gr_interp_fir_filter_xxx_0 = > gr.interp_fir_filter_ccf(2, (gr.firdes.root_raised_cosine(2, 2, 1.0, 0.35, > 22))) > self.gr_map_bb_0 = gr.map_bb((psk.binary_to_gray[arity])) > self.gr_map_bb_0_0 = > gr.map_bb((psk.gray_to_binary[arity])) > self.gr_multiply_const_vxx_0 = > gr.multiply_const_vcc(((1.0/16384.0), )) > self.gr_multiply_const_vxx_0_1 = > gr.multiply_const_vcc((16384.0, )) > self.gr_packed_to_unpacked_xx_0 = > gr.packed_to_unpacked_bb(2, gr.GR_MSB_FIRST) > self.gr_unpacked_to_packed_xx_0 = > gr.unpacked_to_packed_bb(2, gr.GR_MSB_FIRST) > > self.dataSource = gr.vector_source_b(actual_data_copy, > False, 1) > > self.usrp_simple_sink_x = grc_usrp.simple_sink_c(which=0, > side="B") > self.usrp_simple_sink_x.set_interp_rate(500) > self.usrp_simple_sink_x.set_frequency(2430000000, > verbose=True) > self.usrp_simple_sink_x.set_gain(0) > self.usrp_simple_sink_x.set_enable(True) > self.usrp_simple_source_x_0_0 = > grc_usrp.simple_source_c(which=0, side="B", rx_ant="RX2") > self.usrp_simple_source_x_0_0.set_decim_rate(250) > self.usrp_simple_source_x_0_0.set_frequency(2430000000, > verbose=True) > self.usrp_simple_source_x_0_0.set_gain(0) > self.vOut = gr.vector_sink_b(1) > > ################################################## > # Connections > ################################################## > self.connect((self.gr_feedforward_agc_cc_0, 0), > (self.gr_costas_loop_cc_0, 0)) > self.connect((self.gr_multiply_const_vxx_0, 0), > (self.gr_feedforward_agc_cc_0, 0)) > self.connect((self.gr_diff_encoder_bb_0, 0), > (self.gr_chunks_to_symbols_xx_0, 0)) > self.connect((self.gr_map_bb_0, 0), > (self.gr_diff_encoder_bb_0, 0)) > self.connect((self.gr_packed_to_unpacked_xx_0, 0), > (self.gr_map_bb_0, 0)) > self.connect(self.dataSource, > self.gr_packed_to_unpacked_xx_0) > self.connect((self.gr_costas_loop_cc_0, 0), > (self.gr_fir_filter_xxx_1, 0)) > self.connect((self.gr_interp_fir_filter_xxx_0, 0), > (self.gr_multiply_const_vxx_0_1, 0)) > self.connect((self.usrp_simple_source_x_0_0, 0), > (self.gr_multiply_const_vxx_0, 0)) > self.connect((self.gr_constellation_decoder_cb_0, 0), > (self.gr_map_bb_0_0, 0)) > self.connect((self.gr_diff_phasor_cc_0, 0), > (self.gr_constellation_decoder_cb_0, 0)) > self.connect((self.gr_clock_recovery_mm_xx_0, 0), > (self.gr_diff_phasor_cc_0, 0)) > self.connect((self.gr_multiply_const_vxx_0_1, 0), > (self.usrp_simple_sink_x, 0)) > self.connect((self.gr_chunks_to_symbols_xx_0, 0), > (self.gr_interp_fir_filter_xxx_0, 0)) > self.connect((self.gr_fir_filter_xxx_1, 0), > (self.gr_clock_recovery_mm_xx_0, 0)) > self.connect((self.gr_map_bb_0_0, 0), > (self.gr_unpacked_to_packed_xx_0, 0)) > self.connect((self.gr_unpacked_to_packed_xx_0, 0), > (self.vOut, 0)) > > self.run() > > output = self.vOut.data() > print output[0:5000] > > def set_arity(self, arity): > self.arity = arity > self.set_rotated_const(map(lambda pt: pt * 1, > psk.constellation[self.arity])) > > def set_samp_rate(self, samp_rate): > self.samp_rate = samp_rate > > def set_rotated_const(self, rotated_const): > self.rotated_const = rotated_const > > def set_rot(self, rot): > self.rot = rot > > if __name__ == '__main__': > QPSKtest() > > Regards, > > Marcin > > -- View this message in context: http://old.nabble.com/DQPSK-Modulation-Demodulation-issue-tp28288015p28379148.html Sent from the GnuRadio mailing list archive at Nabble.com. _______________________________________________ Discuss-gnuradio mailing list Discuss-gnuradio@gnu.org http://lists.gnu.org/mailman/listinfo/discuss-gnuradio
