def test_ccf_000(self):
N = 1000 # number of samples to use
fs = 1000 # baseband sampling rate
rrate = 1.123 # resampling rate
nfilts = 32
freq = 100
signal = gr.sig_source_c(fs, gr.GR_SIN_WAVE, freq, 1)
head = gr.head(gr.sizeof_gr_complex, N)
pfb = filter.pfb_arb_resampler_ccf(rrate, taps)
snk = gr.vector_sink_c()
self.tb.connect(signal, head, pfb, snk)
self.tb.run()
Ntest = 50
L = len(snk.data())
t = map(lambda x: float(x)/(fs*rrate), xrange(L))
phase = 0.53013
expected_data = map(lambda x: math.cos(2.*math.pi*freq*x+phase) + \
1j*math.sin(2.*math.pi*freq*x+phase), t)
dst_data = snk.data()
self.assertComplexTuplesAlmostEqual(expected_data[-Ntest:], dst_data[-Ntest:], 3)
def __init__(self, rate, taps=None, flt_size=32, atten=100):
gr.hier_block2.__init__(self, "pfb_arb_resampler_ccf",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._rate = rate
self._size = flt_size
if (taps is not None) and (len(taps) > 0):
self._taps = taps
else:
# Create a filter that covers the full bandwidth of the input signal
bw = 0.4
tb = 0.2
ripple = 0.1
#self._taps = filter.firdes.low_pass_2(self._size, self._size, bw, tb, atten)
made = False
while not made:
try:
self._taps = optfir.low_pass(self._size, self._size, bw, bw+tb, ripple, atten)
made = True
except RuntimeError:
ripple += 0.01
made = False
print("Warning: set ripple to %.4f dB. If this is a problem, adjust the attenuation or create your own filter taps." % (ripple))
# Build in an exit strategy; if we've come this far, it ain't working.
if(ripple >= 1.0):
raise RuntimeError("optfir could not generate an appropriate filter.")
self.pfb = filter.pfb_arb_resampler_ccf(self._rate, self._taps, self._size)
#print "PFB has %d taps\n" % (len(self._taps),)
self.connect(self, self.pfb)
self.connect(self.pfb, self)
def test_ccf_000(self):
N = 1000 # number of samples to use
fs = 1000 # baseband sampling rate
rrate = 1.123 # resampling rate
nfilts = 32
taps = filter.firdes.low_pass_2(
nfilts,
nfilts * fs,
fs / 2,
fs / 10,
attenuation_dB=80,
window=filter.firdes.WIN_BLACKMAN_hARRIS)
freq = 100
data = sig_source_c(fs, freq, 1, N)
signal = blocks.vector_source_c(data)
pfb = filter.pfb_arb_resampler_ccf(rrate, taps)
snk = blocks.vector_sink_c()
self.tb.connect(signal, pfb, snk)
self.tb.run()
Ntest = 50
L = len(snk.data())
t = map(lambda x: float(x) / (fs * rrate), xrange(L))
phase = 0.53013
expected_data = map(lambda x: math.cos(2.*math.pi*freq*x+phase) + \
1j*math.sin(2.*math.pi*freq*x+phase), t)
dst_data = snk.data()
self.assertComplexTuplesAlmostEqual(expected_data[-Ntest:],
dst_data[-Ntest:], 3)
def __init__(self, rate, taps=None, flt_size=32, atten=100):
gr.hier_block2.__init__(self, "pfb_arb_resampler_ccf",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._rate = rate
self._size = flt_size
if (taps is not None) and (len(taps) > 0):
self._taps = taps
else:
# Create a filter that covers the full bandwidth of the input signal
bw = 0.4
tb = 0.2
ripple = 0.1
#self._taps = filter.firdes.low_pass_2(self._size, self._size, bw, tb, atten)
made = False
while not made:
try:
self._taps = optfir.low_pass(self._size, self._size, bw, bw+tb, ripple, atten)
made = True
except RuntimeError:
ripple += 0.01
made = False
print("Warning: set ripple to %.4f dB. If this is a problem, adjust the attenuation or create your own filter taps." % (ripple))
# Build in an exit strategy; if we've come this far, it ain't working.
if(ripple >= 1.0):
raise RuntimeError("optfir could not generate an appropriate filter.")
self.pfb = filter.pfb_arb_resampler_ccf(self._rate, self._taps, self._size)
#print "PFB has %d taps\n" % (len(self._taps),)
self.connect(self, self.pfb)
self.connect(self.pfb, self)
def test_ccf_000(self):
N = 1000 # number of samples to use
fs = 1000 # baseband sampling rate
rrate = 1.123 # resampling rate
nfilts = 32
freq = 100
signal = gr.sig_source_c(fs, gr.GR_SIN_WAVE, freq, 1)
head = gr.head(gr.sizeof_gr_complex, N)
pfb = filter.pfb_arb_resampler_ccf(rrate, taps)
snk = gr.vector_sink_c()
self.tb.connect(signal, head, pfb, snk)
self.tb.run()
Ntest = 50
L = len(snk.data())
t = map(lambda x: float(x) / (fs * rrate), xrange(L))
phase = 0.53013
expected_data = map(lambda x: math.cos(2.*math.pi*freq*x+phase) + \
1j*math.sin(2.*math.pi*freq*x+phase), t)
dst_data = snk.data()
self.assertComplexTuplesAlmostEqual(expected_data[-Ntest:],
dst_data[-Ntest:], 3)
def test02(self):
# Test QPSK sync
M = 4
theta = 0
loop_bw = cmath.pi/100.0
fmin = -0.5
fmax = 0.5
mu = 0.5
gain_mu = 0.01
omega = 2
gain_omega = 0.001
omega_rel = 0.001
self.test = digital.mpsk_receiver_cc(M, theta, loop_bw,
fmin, fmax, mu, gain_mu,
omega, gain_omega,
omega_rel)
data = 10000*[complex( 0.707, 0.707),
complex(-0.707, 0.707),
complex(-0.707, -0.707),
complex( 0.707, -0.707)]
data = [0.5*d for d in data]
self.src = gr.vector_source_c(data, False)
self.snk = gr.vector_sink_c()
# pulse shaping interpolation filter
nfilts = 32
excess_bw = 0.35
ntaps = 11 * int(omega*nfilts)
rrc_taps0 = filter.firdes.root_raised_cosine(
nfilts, nfilts, 1.0, excess_bw, ntaps)
rrc_taps1 = filter.firdes.root_raised_cosine(
1, omega, 1.0, excess_bw, 11*omega)
self.rrc0 = filter.pfb_arb_resampler_ccf(omega, rrc_taps0)
self.rrc1 = filter.fir_filter_ccf(1, rrc_taps1)
self.tb.connect(self.src, self.rrc0, self.rrc1, self.test, self.snk)
self.tb.run()
expected_result = 10000*[complex(-0.5, +0.0), complex(+0.0, -0.5),
complex(+0.5, +0.0), complex(+0.0, +0.5)]
# get data after a settling period
dst_data = self.snk.data()[200:]
# Only compare last Ncmp samples
Ncmp = 1000
len_e = len(expected_result)
len_d = len(dst_data)
expected_result = expected_result[len_e - Ncmp - 1:-1]
dst_data = dst_data[len_d - Ncmp:]
#for e,d in zip(expected_result, dst_data):
# print "{0:+.02f} {1:+.02f}".format(e, d)
self.assertComplexTuplesAlmostEqual(expected_result, dst_data, 1)
def __init__(self, rate, taps=None, flt_size=32, atten=100):
gr.hier_block2.__init__(self, "pfb_arb_resampler_ccf",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._rate = rate
self._size = flt_size
if (taps is not None) and (len(taps) > 0):
self._taps = taps
else:
# Create a filter that covers the full bandwidth of the output signal
# If rate >= 1, we need to prevent images in the output,
# so we have to filter it to less than half the channel
# width of 0.5. If rate < 1, we need to filter to less
# than half the output signal's bw to avoid aliasing, so
# the half-band here is 0.5*rate.
percent = 0.80
if(self._rate < 1):
halfband = 0.5*self._rate
bw = percent*halfband
tb = (percent/2.0)*halfband
ripple = 0.1
# As we drop the bw factor, the optfir filter has a harder time converging;
# using the firdes method here for better results.
self._taps = filter.firdes.low_pass_2(self._size, self._size, bw, tb, atten,
filter.firdes.WIN_BLACKMAN_HARRIS)
else:
halfband = 0.5
bw = percent*halfband
tb = (percent/2.0)*halfband
ripple = 0.1
made = False
while not made:
try:
self._taps = optfir.low_pass(self._size, self._size, bw, bw+tb, ripple, atten)
made = True
except RuntimeError:
ripple += 0.01
made = False
print("Warning: set ripple to %.4f dB. If this is a problem, adjust the attenuation or create your own filter taps." % (ripple))
# Build in an exit strategy; if we've come this far, it ain't working.
if(ripple >= 1.0):
raise RuntimeError("optfir could not generate an appropriate filter.")
self.pfb = filter.pfb_arb_resampler_ccf(self._rate, self._taps, self._size)
#print "PFB has %d taps\n" % (len(self._taps),)
self.connect(self, self.pfb)
self.connect(self.pfb, self)
def test01(self):
# Test BPSK sync
excess_bw = 0.35
sps = 4
loop_bw = cmath.pi/100.0
nfilts = 32
init_phase = nfilts/2
max_rate_deviation = 1.5
osps = 1
ntaps = 11 * int(sps*nfilts)
taps = filter.firdes.root_raised_cosine(nfilts, nfilts*sps,
1.0, excess_bw, ntaps)
self.test = digital.pfb_clock_sync_ccf(sps, loop_bw, taps,
nfilts, init_phase,
max_rate_deviation,
osps)
data = 10000*[complex(1,0), complex(-1,0)]
self.src = blocks.vector_source_c(data, False)
# pulse shaping interpolation filter
rrc_taps = filter.firdes.root_raised_cosine(
nfilts, # gain
nfilts, # sampling rate based on 32 filters in resampler
1.0, # symbol rate
excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter = filter.pfb_arb_resampler_ccf(sps, rrc_taps)
self.snk = blocks.vector_sink_c()
self.tb.connect(self.src, self.rrc_filter, self.test, self.snk)
self.tb.run()
expected_result = 10000*[complex(-1,0), complex(1,0)]
dst_data = self.snk.data()
# Only compare last Ncmp samples
Ncmp = 1000
len_e = len(expected_result)
len_d = len(dst_data)
expected_result = expected_result[len_e - Ncmp:]
dst_data = dst_data[len_d - Ncmp:]
#for e,d in zip(expected_result, dst_data):
# print e, d
self.assertComplexTuplesAlmostEqual(expected_result, dst_data, 1)
def test01(self):
# Test BPSK sync
excess_bw = 0.35
sps = 4
loop_bw = cmath.pi / 100.0
nfilts = 32
init_phase = nfilts / 2
max_rate_deviation = 1.5
osps = 1
ntaps = 11 * int(sps * nfilts)
taps = filter.firdes.root_raised_cosine(nfilts, nfilts * sps, 1.0,
excess_bw, ntaps)
self.test = digital.pfb_clock_sync_ccf(sps, loop_bw, taps, nfilts,
init_phase, max_rate_deviation,
osps)
data = 10000 * [complex(1, 0), complex(-1, 0)]
self.src = blocks.vector_source_c(data, False)
# pulse shaping interpolation filter
rrc_taps = filter.firdes.root_raised_cosine(
nfilts, # gain
nfilts, # sampling rate based on 32 filters in resampler
1.0, # symbol rate
excess_bw, # excess bandwidth (roll-off factor)
ntaps)
self.rrc_filter = filter.pfb_arb_resampler_ccf(sps, rrc_taps)
self.snk = blocks.vector_sink_c()
self.tb.connect(self.src, self.rrc_filter, self.test, self.snk)
self.tb.run()
expected_result = 10000 * [complex(-1, 0), complex(1, 0)]
dst_data = self.snk.data()
# Only compare last Ncmp samples
Ncmp = 1000
len_e = len(expected_result)
len_d = len(dst_data)
expected_result = expected_result[len_e - Ncmp:]
dst_data = dst_data[len_d - Ncmp:]
#for e,d in zip(expected_result, dst_data):
# print e, d
self.assertComplexTuplesAlmostEqual(expected_result, dst_data, 1)
def test01(self):
# Test BPSK sync
M = 2
theta = 0
loop_bw = cmath.pi / 100.0
fmin = -0.5
fmax = 0.5
mu = 0.5
gain_mu = 0.01
omega = 2
gain_omega = 0.001
omega_rel = 0.001
self.test = digital.mpsk_receiver_cc(M, theta, loop_bw, fmin, fmax, mu,
gain_mu, omega, gain_omega,
omega_rel)
data = 10000 * [complex(1, 0), complex(-1, 0)]
#data = [2*random.randint(0,1)-1 for x in xrange(10000)]
self.src = blocks.vector_source_c(data, False)
self.snk = blocks.vector_sink_c()
# pulse shaping interpolation filter
nfilts = 32
excess_bw = 0.35
ntaps = 11 * int(omega * nfilts)
rrc_taps0 = filter.firdes.root_raised_cosine(nfilts, nfilts, 1.0,
excess_bw, ntaps)
rrc_taps1 = filter.firdes.root_raised_cosine(1, omega, 1.0, excess_bw,
11 * omega)
self.rrc0 = filter.pfb_arb_resampler_ccf(omega, rrc_taps0)
self.rrc1 = filter.fir_filter_ccf(1, rrc_taps1)
self.tb.connect(self.src, self.rrc0, self.rrc1, self.test, self.snk)
self.tb.run()
expected_result = [0.5 * d for d in data]
dst_data = self.snk.data()
# Only compare last Ncmp samples
Ncmp = 1000
len_e = len(expected_result)
len_d = len(dst_data)
expected_result = expected_result[len_e - Ncmp - 1:-1]
dst_data = dst_data[len_d - Ncmp:]
#for e,d in zip(expected_result, dst_data):
# print "{0:+.02f} {1:+.02f}".format(e, d)
self.assertComplexTuplesAlmostEqual(expected_result, dst_data, 1)
def __init__(self, rate, taps=None, flt_size=32, atten=100):
gr.hier_block2.__init__(
self,
"pfb_arb_resampler_ccf",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._rate = rate
self._size = flt_size
if (taps is not None) and (len(taps) > 0):
self._taps = taps
else:
# Create a filter that covers the full bandwidth of the output signal
# If rate >= 1, we need to prevent images in the output,
# so we have to filter it to less than half the channel
# width of 0.5. If rate < 1, we need to filter to less
# than half the output signal's bw to avoid aliasing, so
# the half-band here is 0.5*rate.
percent = 0.80
if (self._rate < 1):
halfband = 0.5 * self._rate
bw = percent * halfband
tb = (percent / 2.0) * halfband
ripple = 0.1
# As we drop the bw factor, the optfir filter has a harder time converging;
# using the firdes method here for better results.
self._taps = filter.firdes.low_pass_2(
self._size, self._size, bw, tb, atten,
filter.firdes.WIN_BLACKMAN_HARRIS)
else:
halfband = 0.5
bw = percent * halfband
tb = (percent / 2.0) * halfband
ripple = 0.1
made = False
while not made:
try:
self._taps = optfir.low_pass(self._size, self._size,
bw, bw + tb, ripple,
atten)
made = True
except RuntimeError:
ripple += 0.01
made = False
print(
"Warning: set ripple to %.4f dB. If this is a problem, adjust the attenuation or create your own filter taps."
% (ripple))
# Build in an exit strategy; if we've come this far, it ain't working.
if (ripple >= 1.0):
raise RuntimeError(
"optfir could not generate an appropriate filter."
)
self.pfb = filter.pfb_arb_resampler_ccf(self._rate, self._taps,
self._size)
#print "PFB has %d taps\n" % (len(self._taps),)
self.connect(self, self.pfb)
self.connect(self.pfb, self)
