kopia lustrzana https://github.com/NanoVNA-Saver/nanovna-saver
177 wiersze
7.3 KiB
Python
177 wiersze
7.3 KiB
Python
# NanoVNASaver
|
|
#
|
|
# A python program to view and export Touchstone data from a NanoVNA
|
|
# Copyright (C) 2019, 2020 Rune B. Broberg
|
|
# Copyright (C) 2020ff NanoVNA-Saver Authors
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
import math
|
|
import unittest
|
|
|
|
# Import targets to be tested
|
|
from NanoVNASaver.RFTools import Datapoint, \
|
|
norm_to_impedance, impedance_to_norm, \
|
|
reflection_coefficient, gamma_to_impedance, clamp_value, \
|
|
parallel_to_serial, serial_to_parallel, \
|
|
impedance_to_capacitance, impedance_to_inductance, \
|
|
groupDelay, corr_att_data
|
|
|
|
|
|
class TestRFTools(unittest.TestCase):
|
|
|
|
def test_norm_to_impedance(self):
|
|
self.assertEqual(norm_to_impedance(50, 0), 0)
|
|
self.assertEqual(norm_to_impedance(1), 50)
|
|
self.assertEqual(norm_to_impedance(-1), -50)
|
|
self.assertEqual(norm_to_impedance(1.5), 75)
|
|
self.assertEqual(norm_to_impedance(1, 75), 75)
|
|
self.assertEqual(norm_to_impedance(complex(0, 1)), complex(0, 50))
|
|
self.assertEqual(norm_to_impedance(complex(1, 1)), complex(50, 50))
|
|
self.assertEqual(norm_to_impedance(complex(0, -1)), complex(0, -50))
|
|
self.assertAlmostEqual(
|
|
norm_to_impedance(complex(3.33333, 3.33333), 30),
|
|
complex(100, 100), 3)
|
|
|
|
def test_impedance_to_norm(self):
|
|
self.assertRaises(ZeroDivisionError, impedance_to_norm, 0, 0)
|
|
self.assertEqual(impedance_to_norm(0), 0)
|
|
self.assertEqual(impedance_to_norm(50), 1)
|
|
self.assertEqual(impedance_to_norm(-50), -1)
|
|
self.assertEqual(impedance_to_norm(75), 1.5)
|
|
self.assertEqual(impedance_to_norm(75, 75), 1)
|
|
self.assertEqual(impedance_to_norm(complex(0, 50)), complex(0, 1))
|
|
self.assertEqual(impedance_to_norm(complex(50, 50)), complex(1, 1))
|
|
self.assertEqual(impedance_to_norm(complex(0, -50)), complex(0, -1))
|
|
|
|
self.assertAlmostEqual(impedance_to_norm(
|
|
complex(100, 100), 30), (complex(3.333, 3.333)), 3)
|
|
|
|
def test_reflection_coefficient(self):
|
|
self.assertRaises(ZeroDivisionError, reflection_coefficient, -50)
|
|
self.assertEqual(reflection_coefficient(50), 0)
|
|
self.assertEqual(reflection_coefficient(75), 0.2)
|
|
# TODO: insert more test values here
|
|
|
|
def test_gamma_to_impedance(self):
|
|
self.assertEqual(gamma_to_impedance(0), 50)
|
|
self.assertAlmostEqual(gamma_to_impedance(0.2), 75)
|
|
self.assertEqual(gamma_to_impedance(1), math.inf)
|
|
# TODO: insert more test values here
|
|
|
|
def test_clamp_value(self):
|
|
self.assertEqual(clamp_value(1, 0, 10), 1)
|
|
self.assertEqual(clamp_value(1, 2, 10), 2)
|
|
self.assertEqual(clamp_value(1, -10, -1), -1)
|
|
|
|
def test_parallel_to_serial(self):
|
|
self.assertEqual(parallel_to_serial(0), complex(0, 0))
|
|
self.assertAlmostEqual(
|
|
parallel_to_serial(complex(52, 260)),
|
|
complex(50, 10))
|
|
|
|
def test_serial_to_parallel(self):
|
|
self.assertEqual(
|
|
serial_to_parallel(complex(0, 0)),
|
|
complex(math.inf, math.inf))
|
|
self.assertEqual(
|
|
serial_to_parallel(complex(50, 0)),
|
|
complex(50, math.inf))
|
|
self.assertEqual(
|
|
serial_to_parallel(complex(0, 50)),
|
|
complex(math.inf, 50))
|
|
self.assertAlmostEqual(
|
|
serial_to_parallel(complex(50, 10)),
|
|
complex(52, 260))
|
|
|
|
def test_impedance_to_capacity(self):
|
|
self.assertEqual(impedance_to_capacitance(0, 0), -math.inf)
|
|
self.assertEqual(impedance_to_capacitance(0, 10), math.inf)
|
|
self.assertAlmostEqual(
|
|
impedance_to_capacitance(complex(50, 159.1549), 100000),
|
|
1e-8)
|
|
|
|
def test_impedance_to_inductance(self):
|
|
self.assertEqual(impedance_to_inductance(0, 0), 0)
|
|
self.assertAlmostEqual(
|
|
impedance_to_inductance(complex(50, 159.1549), 100000),
|
|
2.533e-4)
|
|
|
|
def test_groupDelay(self):
|
|
dpoints = [
|
|
Datapoint(100000, 0.1091, 0.3118),
|
|
Datapoint(100001, 0.1091, 0.3124),
|
|
Datapoint(100002, 0.1091, 0.3130),
|
|
]
|
|
dpoints0 = [
|
|
Datapoint(100000, 0.1091, 0.3124),
|
|
Datapoint(100000, 0.1091, 0.3124),
|
|
Datapoint(100000, 0.1091, 0.3124),
|
|
]
|
|
self.assertAlmostEqual(groupDelay(dpoints, 1), -9.514e-5)
|
|
self.assertEqual(groupDelay(dpoints0, 1), 0.0)
|
|
|
|
def test_cor_att_data(self):
|
|
dp1 = [
|
|
Datapoint(100000, 0.1091, 0.3118),
|
|
Datapoint(100001, 0.1091, 0.3124),
|
|
Datapoint(100002, 0.1091, 0.3130),
|
|
]
|
|
dp2 = corr_att_data(dp1, 10)
|
|
self.assertEqual(dp2[0].gain - dp1[0].gain, 10)
|
|
self.assertEqual(len(dp1), len(dp2))
|
|
# ignore negative attenuation
|
|
dp3 = corr_att_data(dp1, -10)
|
|
self.assertEqual(dp1, dp3)
|
|
|
|
|
|
class TestRFToolsDatapoint(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
self.dp = Datapoint(100000, 0.1091, 0.3118)
|
|
self.dp0 = Datapoint(100000, 0, 0)
|
|
self.dp50 = Datapoint(100000, 1, 0)
|
|
self.dp75 = Datapoint(100000, 0.2, 0)
|
|
self.dp_im50 = Datapoint(100000, 0, 1)
|
|
self.dp_ill = Datapoint(100000, 1.1, 0)
|
|
self.dp_div0 = Datapoint(100000, 0.0, 1.0)
|
|
|
|
def test_properties(self):
|
|
self.assertEqual(self.dp.z, complex(0.1091, 0.3118))
|
|
self.assertEqual(self.dp.wavelength, 2997.92458)
|
|
self.assertAlmostEqual(self.dp.phase, 1.23420722)
|
|
self.assertEqual(self.dp0.gain, -math.inf)
|
|
self.assertAlmostEqual(self.dp.gain, -9.6208748)
|
|
self.assertEqual(self.dp50.vswr, math.inf)
|
|
self.assertEqual(self.dp_im50.vswr, math.inf)
|
|
self.assertEqual(self.dp_ill.vswr, math.inf)
|
|
self.assertEqual(self.dp0.vswr, 1)
|
|
self.assertAlmostEqual(self.dp.vswr, 1.9865736)
|
|
self.assertAlmostEqual(self.dp.impedance(),
|
|
complex(49.997525, 34.9974501))
|
|
self.assertAlmostEqual(self.dp.impedance(75),
|
|
complex(74.99628755, 52.49617517))
|
|
self.assertEqual(self.dp0.qFactor(), 0.0)
|
|
self.assertEqual(self.dp75.qFactor(), 0.0)
|
|
self.assertEqual(self.dp_im50.qFactor(), -1.0)
|
|
self.assertAlmostEqual(self.dp.qFactor(), 0.6999837)
|
|
self.assertAlmostEqual(self.dp.capacitiveEquivalent(), -4.54761539e-08)
|
|
self.assertAlmostEqual(self.dp.inductiveEquivalent(), 5.57001e-05)
|
|
self.assertAlmostEqual(self.dp.shuntImpedance(),
|
|
complex(-6.18740998e-04, 8.749362528))
|
|
self.assertAlmostEqual(self.dp.seriesImpedance(),
|
|
complex(-2.02067318e-2, -285.7351012))
|
|
self.assertAlmostEqual(self.dp0.shuntImpedance(), 0)
|
|
self.assertAlmostEqual(self.dp0.seriesImpedance(), math.inf)
|
|
self.assertAlmostEqual(self.dp50.shuntImpedance(), math.inf)
|