Hi,
I'm trying to synchronize multiple B210s to receive data at the same
time. I'm only concerned about sample time alignment across devices,
and am aware there is a phase offset that will need to be calibrated
out separately. I've had success with 1 RX channel across 2 B210s, but
something seems wrong when using 2 RX channels across 2 B210s.
I've pasted a program below to help reproduce this issue. It uses 1
B210 to TX noise and 2 separate B210s to RX at the same time. There is
a 40 dB attenuator on the output of the transmitting B210, then a 4
way splitter, and equal length cables to both receivers on the other 2
B210s. Additionally, the 2 receiving B210s get 10 MHz and PPS from a
common OctoClock-G.
Here are 10 observations of sample offsets between devices (1 MSPS rate):
Only channel 0 on both RX: [0,0,0,0,0,0,0,0,0,0]
Only channel 1 on both RX: [0,0,0,0,0,0,0,0,0,0]
Channels 0 and 1 simultaneously on both
RX: [14,1,-126,48,2,-88,17,-204,-96,2]
In the 2 channel case both channels on one device are always aligned,
but are offset from the channels on the other device. Both of the
receiving B210s show the same time last PPS when asked before the
streams start. The times in the RX metadata also match. But after the
streams stop, the devices respond with different times - neither of
which are correct - and the difference between them matches what I'm
measuring.
I'm using UHD 3.14.1.1 and GNU Radio 3.8 on RHEL 7.7. Any ideas?
Thanks,
Michael
----------
#!/usr/bin/env python3
from gnuradio import gr, uhd, analog, blocks
import time
import numpy as np
tx_serial = '30D1***'
rx_serials = ['3153***', '3153***']
rx_channels = [0, 1]
n_rx = len(rx_serials)
n_chan = len(rx_channels)
class top_block(gr.top_block):
def __init__(self):
gr.top_block.__init__(self)
# transmit path
noise_src = analog.noise_source_c(analog.GR_GAUSSIAN, 0.1)
tx_strm_args = uhd.stream_args(cpu_format='fc32', channels=[0])
tx = uhd.usrp_sink('serial=' + tx_serial, tx_strm_args)
tx.set_clock_rate(16e6)
tx.set_samp_rate(1e6)
tx.set_center_freq(1e9)
tx.set_gain(40)
tx.set_antenna('TX/RX')
self.connect(noise_src, tx)
# receive path
rx_strm_args = uhd.stream_args(cpu_format='fc32',
channels=rx_channels)
self.rx = [None]*n_rx
head = [None]*n_rx*n_chan
file_sink = [None]*n_rx*n_chan
for i in range(n_rx):
self.rx[i] = uhd.usrp_source('serial=' + rx_serials[i],
rx_strm_args)
self.rx[i].set_clock_rate(16e6)
self.rx[i].set_samp_rate(1e6)
self.rx[i].set_center_freq(1e9)
self.rx[i].set_gain(40)
self.rx[i].set_antenna('RX2')
self.rx[i].set_time_source('external')
self.rx[i].set_clock_source('external')
for j in range(n_chan):
ch = i*n_chan + j
head[ch] = blocks.head(2*gr.sizeof_float, 10000)
f = 'rx_%d%d.dat' % (i, j)
file_sink[ch] = blocks.file_sink(2*gr.sizeof_float, f)
file_sink[ch].set_unbuffered(True)
self.connect((self.rx[i], j), head[ch], file_sink[ch])
# make sure 10 MHz ref is locked
for i in range(n_rx):
while not
self.rx[i].get_mboard_sensor('ref_locked').to_bool():
print('RX %d waiting for 10 MHz ref lock...' % i)
time.sleep(1)
print('RX %d 10 MHz ref locked' % i)
# time sync the two receivers
for i in range(n_rx):
t = self.rx[i].get_time_last_pps().get_real_secs()
print('RX %d time before align: %r' % (i, t))
time_last_pps = self.rx[0].get_time_last_pps().get_real_secs()
while time_last_pps ==
self.rx[0].get_time_last_pps().get_real_secs():
time.sleep(0.1)
for i in range(n_rx):
self.rx[i].set_time_next_pps(uhd.time_spec_t(0))
time_last_pps = self.rx[0].get_time_last_pps().get_real_secs()
while time_last_pps ==
self.rx[0].get_time_last_pps().get_real_secs():
time.sleep(0.1)
for i in range(n_rx):
t = self.rx[i].get_time_last_pps().get_real_secs()
print('RX %d time after align: %r' % (i, t))
# collect in the future
rx_time = uhd.time_spec_t(2)
for i in range(n_rx):
self.rx[i].set_start_time(rx_time)
self.rx[i].set_recv_timeout(3)
# run flowgraph
tb = top_block()
tb.start()
time.sleep(5)
tb.stop()
# print time
t = tb.rx[0].get_time_last_pps().get_real_secs()
while t == tb.rx[0].get_time_last_pps().get_real_secs():
time.sleep(0.1)
for i in range(n_rx):
t = tb.rx[i].get_time_last_pps().get_real_secs()
print('RX %d time after run: %r' % (i, t))
# cross-correlate receivers and print delay
y = [None]*n_rx*n_chan
for i in range(n_rx):
for j in range(n_chan):
ch = i*n_chan + j
y[ch] = np.fromfile('rx_%d%d.dat' % (i, j), dtype=np.complex64)
r = np.correlate(y[0], y[ch], mode='full')
max_lag = np.max([len(y[0]), len(y[ch])]) - 1
lags = np.arange(-max_lag, max_lag+1)
d = lags[np.argmax(np.abs(r))]
print('RX %d, channel %d: %d samples' % (i, j, d))
_______________________________________________
USRP-users mailing list
USRP-users@lists.ettus.com
http://lists.ettus.com/mailman/listinfo/usrp-users_lists.ettus.com
