kopia lustrzana https://github.com/NanoVNA-Saver/nanovna-saver
137 wiersze
5.2 KiB
Python
137 wiersze
5.2 KiB
Python
# NanoVNASaver
|
|
#
|
|
# A python program to view and export Touchstone data from a NanoVNA
|
|
# Copyright (C) 2019, 2020 Rune B. Broberg
|
|
# Copyright (C) 2020 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/>.
|
|
from PyQt5 import QtCore
|
|
|
|
from NanoVNASaver import RFTools
|
|
from NanoVNASaver.Formatting import (
|
|
format_capacitance,
|
|
format_complex_imp,
|
|
format_frequency_space,
|
|
format_gain,
|
|
format_group_delay,
|
|
format_inductance,
|
|
format_magnitude,
|
|
format_phase,
|
|
format_q_factor,
|
|
format_resistance,
|
|
format_vswr,
|
|
format_wavelength,
|
|
)
|
|
|
|
from .Widget import Marker
|
|
|
|
class DeltaMarker(Marker):
|
|
def __init__(self, name: str = "", qsettings: QtCore.QSettings = None):
|
|
super().__init__(name, qsettings)
|
|
self.marker_a = None
|
|
self.marker_b = None
|
|
|
|
def set_markers(self, marker_a: Marker, marker_b: Marker):
|
|
self.marker_a = marker_a
|
|
self.marker_b = marker_b
|
|
self.name = f"Delta {marker_b.name} - {marker_a.name}"
|
|
self.group_box.setTitle(self.name)
|
|
|
|
def updateLabels(self): # pylint: disable=arguments-differ
|
|
a = self.marker_a
|
|
b = self.marker_b
|
|
s11_a = a.s11data[1]
|
|
s11_b = b.s11data[1]
|
|
|
|
imp_a = s11_a.impedance()
|
|
imp_b = s11_b.impedance()
|
|
imp = imp_b - imp_a
|
|
|
|
cap_str = format_capacitance(
|
|
RFTools.impedance_to_capacitance(imp_b, s11_b.freq) -
|
|
RFTools.impedance_to_capacitance(imp_a, s11_a.freq))
|
|
ind_str = format_inductance(
|
|
RFTools.impedance_to_inductance(imp_b, s11_b.freq) -
|
|
RFTools.impedance_to_inductance(imp_a, s11_a.freq))
|
|
|
|
imp_p_a = RFTools.serial_to_parallel(imp_a)
|
|
imp_p_b = RFTools.serial_to_parallel(imp_b)
|
|
imp_p = imp_p_b - imp_p_a
|
|
|
|
cap_p_str = format_capacitance(
|
|
RFTools.impedance_to_capacitance(imp_p_b, s11_b.freq)-
|
|
RFTools.impedance_to_capacitance(imp_p_a, s11_a.freq))
|
|
ind_p_str = format_inductance(
|
|
RFTools.impedance_to_inductance(imp_p_b, s11_b.freq)-
|
|
RFTools.impedance_to_inductance(imp_p_a, s11_a.freq))
|
|
|
|
if imp.imag < 0:
|
|
x_str = cap_str
|
|
else:
|
|
x_str = ind_str
|
|
|
|
if imp_p.imag < 0:
|
|
x_p_str = cap_p_str
|
|
else:
|
|
x_p_str = ind_p_str
|
|
|
|
self.label['actualfreq'].setText(
|
|
format_frequency_space(s11_b.freq - s11_a.freq))
|
|
self.label['lambda'].setText(
|
|
format_wavelength(s11_b.wavelength - s11_a.wavelength))
|
|
self.label['admittance'].setText(format_complex_imp(imp_p, True))
|
|
self.label['impedance'].setText(format_complex_imp(imp, True))
|
|
|
|
self.label['parc'].setText(cap_p_str)
|
|
self.label['parl'].setText(ind_p_str)
|
|
self.label['parlc'].setText(x_p_str)
|
|
|
|
self.label['parr'].setText(format_resistance(imp_p.real, True))
|
|
self.label['returnloss'].setText(
|
|
format_gain(s11_b.gain - s11_a.gain, self.returnloss_is_positive))
|
|
self.label['s11groupdelay'].setText(format_group_delay(
|
|
RFTools.groupDelay(b.s11data, 1) -
|
|
RFTools.groupDelay(a.s11data, 1)))
|
|
|
|
self.label['s11mag'].setText(
|
|
format_magnitude(abs(s11_b.z) - abs(s11_a.z)))
|
|
self.label['s11phase'].setText(format_phase(s11_b.phase - s11_a.phase))
|
|
self.label['s11polar'].setText(
|
|
f"{round(abs(s11_b.z) - abs(s11_a.z), 2)}∠"
|
|
f"{format_phase(s11_b.phase - s11_a.phase)}")
|
|
self.label['s11q'].setText(format_q_factor(
|
|
s11_b.qFactor() - s11_a.qFactor(), True))
|
|
self.label['s11z'].setText(format_resistance(abs(imp)))
|
|
self.label['serc'].setText(cap_str)
|
|
self.label['serl'].setText(ind_str)
|
|
self.label['serlc'].setText(x_str)
|
|
self.label['serr'].setText(format_resistance(imp.real, True))
|
|
self.label['vswr'].setText(format_vswr(s11_b.vswr - s11_a.vswr))
|
|
|
|
if len(a.s21data) == len(a.s11data):
|
|
s21_a = a.s21data[1]
|
|
s21_b = b.s21data[1]
|
|
self.label['s21gain'].setText(format_gain(
|
|
s21_b.gain - s21_a.gain))
|
|
self.label['s21groupdelay'].setText(format_group_delay(
|
|
(RFTools.groupDelay(b.s21data, 1) -
|
|
RFTools.groupDelay(a.s21data, 1)) / 2))
|
|
self.label['s21mag'].setText(format_magnitude(
|
|
abs(s21_b.z) - abs(s21_a.z)))
|
|
self.label['s21phase'].setText(format_phase(
|
|
s21_b.phase - s21_a.phase))
|
|
self.label['s21polar'].setText(
|
|
f"{round(abs(s21_b.z) - abs(s21_a.z) , 2)}∠"
|
|
f"{format_phase(s21_b.phase - s21_a.phase)}")
|