Dear all,
I’m trying to build a BPSK transmitter which is modulated with a group
of binary sequence of bits by USRP1 with LFTX/RX plugged on. The
frequence of the sequence in baseband should be 25kHz,
I’m modifying the digital-bert project in gnuradio-example, using the
following two line to take the place of the BERT data creation (.bits
and . scrambler):
self._bits = (1,0,0,1, 0,0,0,1, 0,1,1,1, 1,0,1,0,
1,1,1,0, 0,1,0,1, 1,0,1,1, 0,1,0,0,
1,1,1,0, 1,0,1,1, 1,1,0,1, 0,0,0,1,
0,0,1,1, 0,1,0,1, 1,1,0,0, 0,1,0,0,
0,0,1,0, 0,1,0,0, 0,0,1,1, 1,1,1,0,
0,1,1,0, 0,1,1,1, 1,0,1,0, 0,0,1,0,
0,1,0,0, 0,0,1,0, 0,0,1,1, 1,0,1,0,
1,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0)
self.in_data = gr.vector_source_b(self._bits, True )
Then the data will map to the same constellation and filtered by the
same rrc as BERT data does.
To meet the requirement of the baseband frequence, the parameters are
set as shown as following:
rate: 25e3
sps: 32
if_rate: 800e3 (=rate*sps)
interp: 160 (=_dac_rate/if_rate=128e6/800e3)
freq:3M
amplitude: 128
–excess-bw: 0.35
Are these parameters set correctly? How to decide the amplitude? Will
the signal be saturated at the receiver side, if the amplitude is too
large but less than 32767?
At the receiver side, the received raw signal in baseband will be
required to recorded in a data file without frequency recovery and time
offset correction. Such that my receiver only tune the signal back to
baseband and filter it by a matched filter rrc and sink the data in a
data file. My top block for the receiver is:
class rx_bpsk_block(gr.top_block):
def init(self, options):
gr.top_block.__init__(self, "rx_mpsk")
print "USRP decimation rate", options.decim_rate
# Create a USRP source at desired board, sample rate, frequency,
and gain
self._setup_usrp(options.which,
options.decim_rate,
options.rx_subdev_spec,
options.freq,
options.gain)
# Create the receiver
if_rate = self._usrp.adc_rate()/options.decim_rate
self._sps = int(if_rate/options.rate)
# Create RRC with specified excess bandwidth
taps = gr.firdes.root_raised_cosine(1.0, # Gain
self._sps, # Sampling rate
1.0, # Symbol rate
options.excess_bw, # Roll-off factor
11*self._sps) # Number of taps
self._rrc = gr.fir_filter_ccf(1, taps)
self._c2r = gr.complex_to_real()
#sink the data into a file
self._sink = gr.file_sink(gr.sizeof_float, options.filename)
self.connect(self._usrp, self._agc,self._rrc, self._c2r, self._sink)
The parameters are set as:
gain: 20
rate: 25e3
decim-rate: 8
freq:3M
How to determine the decim-rate?
By using octave to plot the data recorded, the received signal I got is
like a impulse response of root-raised-cosine filter. What I suppose to
get is the signal after tunning back to baseband and filtered by a
lowpass filter. What the problem will be?
Thank you so much in advance
Regards,
Yan