def gpu_version(self, sig, up, down, axis, window, gpupath):
with cp.cuda.Stream.null:
out = cusignal.resample_poly(
sig, up, down, axis, window=window, gpupath=gpupath
)
cp.cuda.Stream.null.synchronize()
return out
def test_resample_poly(num_samps, up, down, window):
cpu_time = np.linspace(0, 10, num_samps, endpoint=False)
cpu_sig = np.cos(-cpu_time**2 / 6.0)
gpu_sig = cp.asarray(cpu_sig)
cpu_resample = signal.resample_poly(cpu_sig, up, down, window=window)
gpu_resample = cp.asnumpy(
cusignal.resample_poly(cpu_sig, up, down, window=window))
assert array_equal(cpu_resample, gpu_resample)
def test_resample_poly(self, linspace_data_gen, num_samps, up, down,
window, use_numba):
cpu_sig, gpu_sig = linspace_data_gen(0, 10, num_samps, endpoint=False)
cpu_resample = signal.resample_poly(cpu_sig, up, down, window=window)
gpu_resample = cp.asnumpy(
cusignal.resample_poly(gpu_sig,
up,
down,
window=window,
use_numba=use_numba))
assert array_equal(cpu_resample, gpu_resample)
def prop(signal, new_sps):
if signal.is_on_cuda:
import cusignal
signal.samples = cusignal.resample_poly(signal[:],
signal.sps,
new_sps,
axis=-1)
else:
import resampy
signal.samples = resampy.resample(signal[:],
signal.sps,
new_sps,
axis=-1,
filter='kaiser_fast')
signal.sps = new_sps
return signal
def prop(signal, new_fs):
if signal.is_on_cuda:
import cusignal
signal.samples = cusignal.resample_poly(signal[:],
1,
signal.fs_in_fiber /
new_fs,
axis=-1)
else:
import resampy
signal.samples = resampy.resample(signal[:],
signal.fs_in_fiber,
new_fs,
axis=-1,
filter='kaiser_fast')
signal.sps = new_fs / signal.baudrate
signal.sps = int(signal.sps)
return signal
def prepare(self, roll_off, is_cuda=False):
self.ds = upsampling(self.symbol, self.sps)
self.ds_in_fiber = np.zeros((self.pol_number, self.symbol.shape[1] * self.sps_in_fiber),
dtype=self.symbol.dtype)
if is_cuda:
self.cuda()
for index, row in enumerate(self.ds):
row[:] = rrcos_pulseshaping_freq(row, self.fs, 1 / self.baudrate, roll_off, self.is_on_cuda)
if not self.is_on_cuda:
import resampy
from scipy.signal import resample
#self.ds_in_fiber[index] = resample_po(row,self.sps_in_fiber//self.sps * row.shape[0])
self.ds_in_fiber[index] = resampy.resample(row, self.sps, self.sps_in_fiber, filter='kaiser_fast')
else:
import cusignal
self.ds_in_fiber[index] = cusignal.resample_poly(row, self.sps_in_fiber / self.sps, 1, axis=-1)
# self.symbol[1] = self.symbol[0]
# self.ds_in_fiber[1] = self.ds_in_fiber[0]
return self
import polyphase_plot
buffer_size = 2**19 # Number of complex samples per transfer
t_test = 20 # Test time in seconds
freq = 1350e6 # Tune frequency in Hz
fs = 62.5e6 # Sample rate
# Create polyphase filter
fc = 1. / max(16, 25) # cutoff of FIR filter (rel. to Nyquist)
nc = 10 * max(16, 25) # reasonable cutoff for our sinc-like function
win = signal.fir_filter_design.firwin(2 * nc + 1, fc, window=('kaiser', 0.5))
win = cupy.asarray(win, dtype=cupy.float32)
# Init buffer and polyphase filter
buff = signal.get_shared_mem(buffer_size, dtype=cupy.complex64)
s = signal.resample_poly(buff, 16, 25, window=win, use_numba=False)
# Initialize the AIR-T receiver using SoapyAIRT
sdr = SoapySDR.Device(dict(driver="SoapyAIRT")) # Create AIR-T instance
sdr.setSampleRate(SoapySDR.SOAPY_SDR_RX, 1, fs) # Set sample rate
sdr.setGainMode(SoapySDR.SOAPY_SDR_RX, 1, True) # Set the gain mode
sdr.setFrequency(SoapySDR.SOAPY_SDR_RX, 1, freq) # Tune the frequency
rx_stream = sdr.setupStream(SoapySDR.SOAPY_SDR_RX, SoapySDR.SOAPY_SDR_CF32,
[1])
sdr.activateStream(rx_stream)
# Run test
n_reads = int(t_test * fs / buffer_size) + 1
drop_count = 0
for _ in range(n_reads):
sr = sdr.readStream(rx_stream, [buff], buffer_size)
