def __init__(self,
fft_length,
cp_length,
occupied_tones,
snr,
ks,
carrier_map_bin,
nc_filter,
logging=False):
"""
Hierarchical block for receiving OFDM symbols.
The input is the complex modulated signal at baseband.
Synchronized packets are sent back to the demodulator.
@param fft_length: total number of subcarriers
@type fft_length: int
@param cp_length: length of cyclic prefix as specified in subcarriers (<= fft_length)
@type cp_length: int
@param occupied_tones: number of subcarriers used for data
@type occupied_tones: int
@param snr: estimated signal to noise ratio used to guide cyclic prefix synchronizer
@type snr: float
@param ks: known symbols used as preambles to each packet
@type ks: list of lists
@param logging: turn file logging on or off
@type logging: bool
"""
gr.hier_block2.__init__(
self,
"ofdm_receiver",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature2(2, 2, gr.sizeof_gr_complex * occupied_tones,
gr.sizeof_char)) # Output signature
bw = (float(occupied_tones) / float(fft_length)) / 2.0
tb = bw * 0.04
print "ofdm_receiver:__init__:occupied_tones %s fft_length %d " % (
occupied_tones, fft_length)
chan_coeffs = filter.firdes.low_pass(
1.0, # gain
1.0, # sampling rate
bw + tb, # midpoint of trans. band
tb, # width of trans. band
filter.firdes.WIN_HAMMING) # filter type
self.chan_filt = filter.fft_filter_ccc(1, chan_coeffs)
# linklab, get ofdm parameters
self._fft_length = fft_length
self._occupied_tones = occupied_tones
self._cp_length = cp_length
self._nc_filter = nc_filter
self._carrier_map_bin = carrier_map_bin
win = [1 for i in range(fft_length)]
# linklab, initialization function
self.initialize(ks, self._carrier_map_bin)
zeros_on_left = int(math.ceil((fft_length - occupied_tones) / 2.0))
ks0 = fft_length * [
0,
]
ks0[zeros_on_left:zeros_on_left + occupied_tones] = ks[0]
ks0 = np_fft.ifftshift(ks0)
ks0time = np_fft.ifft(ks0)
# ADD SCALING FACTOR
ks0time = ks0time.tolist()
SYNC = "pn"
if SYNC == "ml":
nco_sensitivity = -1.0 / fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_ml(fft_length, cp_length, snr, ks0time,
logging)
elif SYNC == "pn":
nco_sensitivity = -2.0 / fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_pn(fft_length, cp_length, logging)
elif SYNC == "pnac":
nco_sensitivity = -2.0 / fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_pnac(fft_length, cp_length, ks0time,
logging)
# for testing only; do not user over the air
# remove filter and filter delay for this
elif SYNC == "fixed":
self.chan_filt = gr.multiply_const_cc(1.0)
nsymbols = 18 # enter the number of symbols per packet
freq_offset = 0.0 # if you use a frequency offset, enter it here
nco_sensitivity = -2.0 / fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_fixed(fft_length, cp_length, nsymbols,
freq_offset, logging)
# Set up blocks
# Create a delay line, linklab
self.delay = blocks.delay(gr.sizeof_gr_complex, fft_length)
self.nco = analog.frequency_modulator_fc(
nco_sensitivity
) # generate a signal proportional to frequency error of sync block
self.sigmix = blocks.multiply_cc()
self.sampler = gr_papyrus.ofdm_sampler(fft_length,
fft_length + cp_length)
self.fft_demod = gr_fft.fft_vcc(fft_length, True, win, True)
self.ofdm_frame_acq = gr_papyrus.ofdm_frame_acquisition(
occupied_tones, fft_length, cp_length, ks[0])
# linklab, check current mode: non-contiguous OFDM or not
if self._nc_filter:
print '\nMulti-band Filter Turned ON!'
# linklab, non-contiguous filter
self.ncofdm_filt = ncofdm_filt(self._fft_length,
self._occupied_tones,
self._carrier_map_bin)
self.connect(self, self.chan_filt, self.ncofdm_filt)
self.connect(self.ncofdm_filt,
self.ofdm_sync) # into the synchronization alg.
self.connect(
(self.ofdm_sync, 0), self.nco,
(self.sigmix,
1)) # use sync freq. offset output to derotate input signal
self.connect(self.ncofdm_filt, self.delay,
(self.sigmix, 0)) # signal to be derotated
else:
print '\nMulti-band Filter Turned OFF!'
self.connect(self, self.chan_filt)
self.connect(self.chan_filt,
self.ofdm_sync) # into the synchronization alg.
self.connect(
(self.ofdm_sync, 0), self.nco,
(self.sigmix,
1)) # use sync freq. offset output to derotate input signal
self.connect(self.chan_filt, self.delay,
(self.sigmix, 0)) # signal to be derotated
self.connect(
self.sigmix,
(self.sampler, 0)) # sample off timing signal detected in sync alg
self.connect((self.ofdm_sync, 1),
(self.sampler, 1)) # timing signal to sample at
self.connect((self.sampler, 0),
self.fft_demod) # send derotated sampled signal to FFT
self.connect(
self.fft_demod,
(self.ofdm_frame_acq, 0)) # find frame start and equalize signal
self.connect((self.sampler, 1),
(self.ofdm_frame_acq,
1)) # send timing signal to signal frame start
self.connect((self.ofdm_frame_acq, 0),
(self, 0)) # finished with fine/coarse freq correction,
self.connect((self.ofdm_frame_acq, 1),
(self, 1)) # frame and symbol timing, and equalization
if logging:
self.connect(
self.chan_filt,
gr.file_sink(gr.sizeof_gr_complex,
"ofdm_receiver-chan_filt_c.dat"))
self.connect(
self.fft_demod,
gr.file_sink(gr.sizeof_gr_complex * fft_length,
"ofdm_receiver-fft_out_c.dat"))
self.connect(
self.ofdm_frame_acq,
gr.file_sink(gr.sizeof_gr_complex * occupied_tones,
"ofdm_receiver-frame_acq_c.dat"))
self.connect((self.ofdm_frame_acq, 1),
gr.file_sink(1, "ofdm_receiver-found_corr_b.dat"))
self.connect(
self.sampler,
gr.file_sink(gr.sizeof_gr_complex * fft_length,
"ofdm_receiver-sampler_c.dat"))
self.connect(
self.sigmix,
gr.file_sink(gr.sizeof_gr_complex,
"ofdm_receiver-sigmix_c.dat"))
self.connect(
self.nco,
gr.file_sink(gr.sizeof_gr_complex, "ofdm_receiver-nco_c.dat"))
def __init__(self, fft_length, cp_length, occupied_tones, snr, ks, carrier_map_bin, nc_filter, logging=False):
"""
Hierarchical block for receiving OFDM symbols.
The input is the complex modulated signal at baseband.
Synchronized packets are sent back to the demodulator.
@param fft_length: total number of subcarriers
@type fft_length: int
@param cp_length: length of cyclic prefix as specified in subcarriers (<= fft_length)
@type cp_length: int
@param occupied_tones: number of subcarriers used for data
@type occupied_tones: int
@param snr: estimated signal to noise ratio used to guide cyclic prefix synchronizer
@type snr: float
@param ks: known symbols used as preambles to each packet
@type ks: list of lists
@param logging: turn file logging on or off
@type logging: bool
"""
gr.hier_block2.__init__(self, "ofdm_receiver",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature2(2, 2, gr.sizeof_gr_complex*occupied_tones, gr.sizeof_char)) # Output signature
bw = (float(occupied_tones) / float(fft_length)) / 2.0
tb = bw*0.04
print "ofdm_receiver:__init__:occupied_tones %s fft_length %d " % (occupied_tones, fft_length)
chan_coeffs = filter.firdes.low_pass (1.0, # gain
1.0, # sampling rate
bw+tb, # midpoint of trans. band
tb, # width of trans. band
filter.firdes.WIN_HAMMING) # filter type
self.chan_filt = filter.fft_filter_ccc(1, chan_coeffs)
# linklab, get ofdm parameters
self._fft_length = fft_length
self._occupied_tones = occupied_tones
self._cp_length = cp_length
self._nc_filter = nc_filter
self._carrier_map_bin = carrier_map_bin
win = [1 for i in range(fft_length)]
# linklab, initialization function
self.initialize(ks, self._carrier_map_bin)
zeros_on_left = int(math.ceil((fft_length - occupied_tones)/2.0))
ks0 = fft_length*[0,]
ks0[zeros_on_left : zeros_on_left + occupied_tones] = ks[0]
ks0 = np_fft.ifftshift(ks0)
ks0time = np_fft.ifft(ks0)
# ADD SCALING FACTOR
ks0time = ks0time.tolist()
SYNC = "pn"
if SYNC == "ml":
nco_sensitivity = -1.0/fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_ml(fft_length,
cp_length,
snr,
ks0time,
logging)
elif SYNC == "pn":
nco_sensitivity = -2.0/fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_pn(fft_length,
cp_length,
logging)
elif SYNC == "pnac":
nco_sensitivity = -2.0/fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_pnac(fft_length,
cp_length,
ks0time,
logging)
# for testing only; do not user over the air
# remove filter and filter delay for this
elif SYNC == "fixed":
self.chan_filt = gr.multiply_const_cc(1.0)
nsymbols = 18 # enter the number of symbols per packet
freq_offset = 0.0 # if you use a frequency offset, enter it here
nco_sensitivity = -2.0/fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_fixed(fft_length,
cp_length,
nsymbols,
freq_offset,
logging)
# Set up blocks
# Create a delay line, linklab
self.delay = blocks.delay(gr.sizeof_gr_complex, fft_length)
self.nco = analog.frequency_modulator_fc(nco_sensitivity) # generate a signal proportional to frequency error of sync block
self.sigmix = blocks.multiply_cc()
self.sampler = gr_papyrus.ofdm_sampler(fft_length, fft_length+cp_length)
self.fft_demod = gr_fft.fft_vcc(fft_length, True, win, True)
self.ofdm_frame_acq = gr_papyrus.ofdm_frame_acquisition(occupied_tones,
fft_length,
cp_length, ks[0])
# linklab, check current mode: non-contiguous OFDM or not
if self._nc_filter:
print '\nMulti-band Filter Turned ON!'
# linklab, non-contiguous filter
self.ncofdm_filt = ncofdm_filt(self._fft_length, self._occupied_tones, self._carrier_map_bin)
self.connect(self, self.chan_filt, self.ncofdm_filt)
self.connect(self.ncofdm_filt, self.ofdm_sync) # into the synchronization alg.
self.connect((self.ofdm_sync,0), self.nco, (self.sigmix,1)) # use sync freq. offset output to derotate input signal
self.connect(self.ncofdm_filt, self.delay, (self.sigmix,0)) # signal to be derotated
else :
print '\nMulti-band Filter Turned OFF!'
self.connect(self, self.chan_filt)
self.connect(self.chan_filt, self.ofdm_sync) # into the synchronization alg.
self.connect((self.ofdm_sync,0), self.nco, (self.sigmix,1)) # use sync freq. offset output to derotate input signal
self.connect(self.chan_filt, self.delay, (self.sigmix,0)) # signal to be derotated
self.connect(self.sigmix, (self.sampler,0)) # sample off timing signal detected in sync alg
self.connect((self.ofdm_sync,1), (self.sampler,1)) # timing signal to sample at
self.connect((self.sampler,0), self.fft_demod) # send derotated sampled signal to FFT
self.connect(self.fft_demod, (self.ofdm_frame_acq,0)) # find frame start and equalize signal
self.connect((self.sampler,1), (self.ofdm_frame_acq,1)) # send timing signal to signal frame start
self.connect((self.ofdm_frame_acq,0), (self,0)) # finished with fine/coarse freq correction,
self.connect((self.ofdm_frame_acq,1), (self,1)) # frame and symbol timing, and equalization
if logging:
self.connect(self.chan_filt, gr.file_sink(gr.sizeof_gr_complex, "ofdm_receiver-chan_filt_c.dat"))
self.connect(self.fft_demod, gr.file_sink(gr.sizeof_gr_complex*fft_length, "ofdm_receiver-fft_out_c.dat"))
self.connect(self.ofdm_frame_acq,
gr.file_sink(gr.sizeof_gr_complex*occupied_tones, "ofdm_receiver-frame_acq_c.dat"))
self.connect((self.ofdm_frame_acq,1), gr.file_sink(1, "ofdm_receiver-found_corr_b.dat"))
self.connect(self.sampler, gr.file_sink(gr.sizeof_gr_complex*fft_length, "ofdm_receiver-sampler_c.dat"))
self.connect(self.sigmix, gr.file_sink(gr.sizeof_gr_complex, "ofdm_receiver-sigmix_c.dat"))
self.connect(self.nco, gr.file_sink(gr.sizeof_gr_complex, "ofdm_receiver-nco_c.dat"))
def __init__(self, fft_length, cp_length, occupied_tones, snr, ks, carrier_map_bin, nc_filter, logging=False):
gr.hier_block2.__init__(self, "ofdm_receiver",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature4(4, 4, gr.sizeof_gr_complex*occupied_tones, gr.sizeof_char, gr.sizeof_char, gr.sizeof_float)) # Output signature
self._fft_length = fft_length
self._occupied_tones = occupied_tones
self._cp_length = cp_length
self._nc_filter = nc_filter
self._carrier_map_bin = carrier_map_bin
win = [1 for i in range(self._fft_length)]
self.initialize(ks, self._carrier_map_bin)
SYNC = "pn"
if SYNC == "ml":
nco_sensitivity = -1.0/fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_ml(fft_length, cp_length, snr, self._ks0time, logging)
elif SYNC == "pn":
nco_sensitivity = -2.0/fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_pn.ofdm_sync_pn(fft_length, cp_length, logging)
elif SYNC == "pnac":
nco_sensitivity = -2.0/fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_pnac(fft_length, cp_length, self._ks0time, logging)
elif SYNC == "fixed": # for testing only; do not user over the air
self.chan_filt = gr.multiply_const_cc(1.0) # remove filter and filter delay for this
nsymbols = 18 # enter the number of symbols per packet
freq_offset = 0.0 # if you use a frequency offset, enter it here
nco_sensitivity = -2.0/fft_length # correct for fine frequency
self.ofdm_sync = ofdm_sync_fixed(fft_length, cp_length, nsymbols, freq_offset, logging)
self.reset_filter()
# TODO: why? Create a delay line, linklab
self.delay = gr.delay(gr.sizeof_gr_complex, fft_length)
self.nco = gr.frequency_modulator_fc(nco_sensitivity) # generate a signal proportional to frequency error of sync block
self.sigmix = gr.multiply_cc()
self.sampler = flex.ofdm_sampler(fft_length, fft_length+cp_length)
self.fft_demod = gr.fft_vcc(fft_length, True, win, True)
self.ofdm_frame_acq = flex.ofdm_frame_acquisition(self._occupied_tones, self._fft_length,
self._cp_length, self._ks[0], 1)
if self._nc_filter:
print '\nMulti-band Filter Turned ON!'
self.ncofdm_filt = ncofdm_filt(self._fft_length, self._occupied_tones, self._carrier_map_bin)
self.connect(self, self.chan_filt, self.ncofdm_filt)
self.connect(self.ncofdm_filt, self.ofdm_sync) # into the synchronization alg.
self.connect((self.ofdm_sync,0), self.nco, (self.sigmix,1)) # use sync freq. offset output to derotate input signal
self.connect(self.ncofdm_filt, self.delay, (self.sigmix,0)) # signal to be derotated
else :
print '\nMulti-band Filter Turned OFF!'
self.connect(self, self.chan_filt)
self.connect(self.chan_filt, self.ofdm_sync) # into the synchronization alg.
self.connect((self.ofdm_sync,0), self.nco, (self.sigmix,1)) # use sync freq. offset output to derotate input signal
self.connect(self.chan_filt, self.delay, (self.sigmix,0)) # signal to be derotated
self.connect(self.sigmix, (self.sampler,0)) # sample off timing signal detected in sync alg
self.connect((self.ofdm_sync,1), (self.sampler,1)) # timing signal to sample at
self.connect((self.sampler,0), self.fft_demod) # send derotated sampled signal to FFT
self.connect(self.fft_demod, (self.ofdm_frame_acq,0)) # find frame start and equalize signal
# TODO: do we need a char delay for the timing signal?
self.connect((self.sampler,1), (self.ofdm_frame_acq,1)) # send timing signal to signal frame start
# TODO: reconnect properly
self.connect((self.ofdm_frame_acq,0), (self,0)) # finished with fine/coarse freq correction,
self.connect((self.ofdm_sync,1), gr.delay(gr.sizeof_char,1), (self,1))
self.connect((self.ofdm_frame_acq,1), (self,2)) # frame and symbol timing, and equalization
self.connect((self.ofdm_frame_acq,2), (self,3)) # snr estimates
if logging:
self.connect(self.chan_filt, gr.file_sink(gr.sizeof_gr_complex, "flex_ofdm_recv-chan_filt_c.dat"))
self.connect(self.ncofdm_filt, gr.file_sink(gr.sizeof_gr_complex, "flex_ofdm_recv-ncofdm_filt_c.dat"))
self.connect(self.nco, gr.file_sink(gr.sizeof_gr_complex, "flex_ofdm_recv-nco_c.dat"))
self.connect(self.fft_demod, gr.file_sink(gr.sizeof_gr_complex*fft_length, "flex_ofdm_recv-fft_out_c.dat"))
self.connect(self.ofdm_frame_acq, gr.file_sink(gr.sizeof_gr_complex*occupied_tones, "flex_ofdm_recv-frame_acq_data_c.dat"))
self.connect((self.ofdm_frame_acq,3), gr.keep_one_in_n(gr.sizeof_float*occupied_tones, 32), gr.file_sink(gr.sizeof_float*occupied_tones, "flex_ofdm_recv-frame_acq_gain_f.dat"))
self.connect((self.ofdm_frame_acq,1), gr.file_sink(1, "flex_ofdm_recv-frame_acq_signal_b.dat"))
self.connect((self.ofdm_frame_acq,2), gr.file_sink(gr.sizeof_float, "flex_ofdm_recv-frame_acq_snr_f.dat"))
self.connect(self.sampler, gr.file_sink(gr.sizeof_gr_complex*fft_length, "flex_ofdm_recv-sampler_data_c.dat"))
self.connect(self.sampler, gr.file_sink(gr.sizeof_gr_complex*fft_length, "flex_ofdm_recv-sampler_data_c.dat"))
self.connect((self.sampler, 1), gr.file_sink(1*fft_length, "flex_ofdm_recv-sampler_signal_b.dat"))
self.connect((self.ofdm_sync, 1), gr.file_sink(1, "flex_ofdm_recv-sync_b.dat"))
self.connect(self.sigmix, gr.file_sink(gr.sizeof_gr_complex, "flex_ofdm_recv-sigmix_c.dat"))
else:
self.connect((self.ofdm_frame_acq,3), gr.null_sink(gr.sizeof_float*self._occupied_tones))
