def testDAQ2DDS(self):
global URI
# Test DMA
daq = DAQ2(uri=URI)
daq.tx_cyclic_buffer = True
daq.tx_enabled_channels = [0, 1]
daq.rx_buffer_size = 2**14
# Enable DDSs
fs = int(daq.sample_rate)
fc1 = 20 * 1e6
fc2 = 70 * 1e6
daq.dds_enabled = [1, 1, 1, 1, 1, 1, 1, 1]
daq.dds_frequencies = [fc1, 0, fc2, 0, 0, 0, 0, 0]
daq.dds_scales = [1, 0, 1, 0, 0, 0, 0, 0]
daq.dds_phases = [0, 0, 0, 0, 0, 0, 0, 0]
# Flush buffers
for _ in range(10):
data = daq.rx()
# Estimate frequency
fc1_est = self.freq_est(data[0], fs)
fc2_est = self.freq_est(data[1], fs)
# Check Data
diff = np.abs(fc1_est - fc1)
self.assertGreater(fc1 * 0.01, diff, "Frequency offset TX1")
diff = np.abs(fc2_est - fc2)
self.assertGreater(fc2 * 0.01, diff, "Frequency offset TX2")
def testDAQ2DMA(self):
global URI
# Test DMA
daq = DAQ2(uri=URI)
daq.tx_cyclic_buffer = True
daq.tx_enabled_channels = [0, 1]
# Create signal
fs = int(daq.sample_rate)
fc1 = 30 * 1e6
fc2 = 100 * 1e6
N = 2**14
ts = 1 / float(fs)
t = np.arange(0, N * ts, ts)
f1 = np.cos(2 * np.pi * t * fc1) * 2**14
f2 = np.cos(2 * np.pi * t * fc2) * 2**14
daq.rx_buffer_size = len(f1) * 2
daq.tx([f1, f2])
# Flush buffers
for _ in range(10):
data = daq.rx()
# Estimate frequency
fc1_est = self.freq_est(data[0], fs)
fc2_est = self.freq_est(data[1], fs)
# Check Data
diff = np.abs(fc1_est - fc1)
self.assertGreater(fc1 * 0.01, diff, "Frequency offset TX1")
diff = np.abs(fc2_est - fc2)
self.assertGreater(fc2 * 0.01, diff, "Frequency offset TX2")
def testDAQ2DDS_SimpleAPI(self):
global URI
# Test DMA
daq = DAQ2(uri=URI)
daq.tx_cyclic_buffer = True
daq.tx_enabled_channels = [0, 1]
daq.rx_buffer_size = 2**14
fs = int(daq.sample_rate)
# Enable DDSs
fc1 = 200000000
daq.dds_single_tone(fc1, 0.5)
# Flush buffers
for _ in range(10):
data = daq.rx()
# Estimate frequency
fc1_est = self.freq_est(data[0], fs)
# Change DDS channel
fc2 = 200000000
daq.dds_single_tone(fc2, 0.5, 1)
# Flush buffers
for _ in range(10):
data = daq.rx()
del daq
fc2_est = self.freq_est(data[1], fs)
# Check Data
diff = np.abs(fc1_est - fc1)
self.assertGreater(fc1 * 0.01, diff, "Frequency offset TX1")
diff = np.abs(fc2_est - fc2)
self.assertGreater(fc2 * 0.01, diff, "Frequency offset TX2")
def testDAQ2ADC_p2(self):
global URI
# See if we can get non-zero data from ADC
adc = DAQ2(uri=URI)
adc.rx_enabled_channels = [1]
data = adc.rx()
s = np.sum(np.abs(data))
self.assertGreater(s, 0, "check non-zero data")
def testDAQ2DAC_dual(self):
global URI
# See if we tx data from DAC
dac = DAQ2(uri=URI)
TXFS = dac.sample_rate
dac.tx_enabled_channels = [0, 1]
N = 2**15
ts = 1 / float(TXFS)
t = np.arange(0, N * ts, ts)
fc = 10000
d = np.cos(2 * np.pi * t * fc) * 2**15 * 0.5
dac.tx([d, d])
self.assertEqual(True, True, "transmit data failed")
def testDAQ2ADC_dual_real(self):
global URI
# See if we can get non-zero data from ADC
adc = DAQ2(uri=URI)
adc.rx_enabled_channels = [0, 1]
data = adc.rx()
is_complex = False
for d in data[0]:
is_complex = is_complex or np.iscomplex(d)
for d in data[1]:
is_complex = is_complex or np.iscomplex(d)
self.assertEqual(is_complex, False, "check real data")
