class Plot_Tran_Stim_UI(QWidget):
"""
Create the UI for the PlotImpz class
"""
# incoming:
sig_rx = pyqtSignal(object)
# outgoing: from various UI elements to PlotImpz ('ui_changed':'xxx')
sig_tx = pyqtSignal(object)
# outgoing: to fft related widgets (FFT window widget, qfft_win_select)
sig_tx_fft = pyqtSignal(object)
from pyfda.libs.pyfda_qt_lib import emit
# ------------------------------------------------------------------------------
def process_sig_rx(self, dict_sig=None):
"""
Process signals coming from
- FFT window widget
- qfft_win_select
"""
logger.warning("PROCESS_SIG_RX - vis: {0}\n{1}".format(
self.isVisible(), pprint_log(dict_sig)))
if 'id' in dict_sig and dict_sig['id'] == id(self):
logger.warning("Stopped infinite loop:\n{0}".format(
pprint_log(dict_sig)))
return
elif 'view_changed' in dict_sig:
if dict_sig['view_changed'] == 'f_S':
self.recalc_freqs()
# ------------------------------------------------------------------------------
def __init__(self):
super().__init__()
"""
Intitialize the widget, consisting of:
- top chkbox row
- coefficient table
- two bottom rows with action buttons
"""
# initial settings
self.N_FFT = 0 # TODO: FFT value needs to be passed here somehow?
# stimuli
self.cmb_stim_item = "impulse"
self.cmb_stim_periodic_item = 'square'
self.stim = "dirac"
self.impulse_type = 'dirac'
self.sinusoid_type = 'sine'
self.chirp_type = 'linear'
self.modulation_type = 'am'
self.noise = "None"
self.f1 = 0.02
self.f2 = 0.03
self.A1 = 1.0
self.A2 = 0.0
self.phi1 = self.phi2 = 0
self.T1 = self.T2 = 0
self.TW1 = self.TW2 = 1
self.BW1 = self.BW2 = 0.5
self.noi = 0.1
self.noise = 'none'
self.DC = 0.0
self.stim_formula = "A1 * abs(sin(2 * pi * f1 * n))"
self.stim_par1 = 0.5
self.scale_impz = 1 # optional energy scaling for impulses
# self.bottom_f = -120 # initial value for log. scale
# self.param = None
# dictionaries with widgets needed for the various stimuli
self.stim_wdg_dict = collections.OrderedDict()
self.stim_wdg_dict.update({
"none": {"dc", "noise"},
"dirac": {"dc", "a1", "T1", "norm", "noise"},
"sinc":
{"dc", "a1", "a2", "T1", "T2", "f1", "f2", "norm", "noise"},
"gauss": {
"dc", "a1", "a2", "T1", "T2", "f1", "f2", "BW1", "BW2", "norm",
"noise"
},
"rect": {"dc", "a1", "T1", "TW1", "norm", "noise"},
"step": {"a1", "T1", "noise"},
"cos": {"dc", "a1", "a2", "phi1", "phi2", "f1", "f2", "noise"},
"sine": {"dc", "a1", "a2", "phi1", "phi2", "f1", "f2", "noise"},
"exp": {"dc", "a1", "a2", "phi1", "phi2", "f1", "f2", "noise"},
"diric": {"dc", "a1", "phi1", "T1", "TW1", "f1", "noise"},
"chirp": {"dc", "a1", "phi1", "f1", "f2", "T2", "noise"},
"triang": {"dc", "a1", "phi1", "f1", "noise", "bl"},
"saw": {"dc", "a1", "phi1", "f1", "noise", "bl"},
"square": {"dc", "a1", "phi1", "f1", "noise", "bl", "par1"},
"comb": {"dc", "a1", "phi1", "f1", "noise"},
"am": {"dc", "a1", "a2", "phi1", "phi2", "f1", "f2", "noise"},
"pmfm": {"dc", "a1", "a2", "phi1", "phi2", "f1", "f2", "noise"},
"formula": {
"dc", "a1", "a2", "phi1", "phi2", "f1", "f2", "BW1", "BW2",
"noise"
}
})
# combobox tooltip + data / text / tooltip for stimulus category items
self.cmb_stim_items = [
("<span>Stimulus category.</span>"),
("none", "None",
"<span>Only noise and DC can be selected.</span>"),
("impulse", "Impulse", "<span>Different impulses</span>"),
("step", "Step",
"<span>Calculate step response and its error.</span>"),
("sinusoid", "Sinusoid", "<span>Sinusoidal waveforms</span>"),
("chirp", "Chirp", "<span>Different frequency sweeps.</span>"),
("periodic", "Periodic",
"<span>Periodic functions with discontinuities, "
"either band-limited or with aliasing.</span>"),
("modulation", "Modulat.", "<span>Modulated waveforms.</span>"),
("formula", "Formula", "<span>Formula defined stimulus.</span>")
]
# combobox tooltip + data / text / tooltip for periodic signals items
self.cmb_stim_periodic_items = [
"<span>Periodic functions with discontinuities.</span>",
("square", "Square",
"<span>Square signal with duty cycle α</span>"),
("saw", "Saw", "Sawtooth signal"),
("triang", "Triang", "Triangular signal"),
("comb", "Comb", "Comb signal")
]
# combobox tooltip + data / text / tooltip for chirp signals items
self.cmb_stim_chirp_items = [
"<span>Type of frequency sweep from <i>f</i><sub>1</sub> @ <i>t</i> = 0 to "
"<i>f</i><sub>2</sub> @ t = <i>T</i><sub>2</sub>.</span>",
("linear", "Lin", "Linear frequency sweep"),
("quadratic", "Square", "Quadratic frequency sweep"),
("logarithmic", "Log", "Logarithmic frequency sweep"),
("hyperbolic", "Hyper", "Hyperbolic frequency sweep")
]
self.cmb_stim_impulse_items = [
"<span>Different aperiodic impulse forms</span>",
("dirac", "Dirac",
"<span>Discrete-time dirac impulse for simulating impulse and "
"frequency response.</span>"),
("gauss", "Gauss",
"<span>Gaussian pulse with bandpass spectrum and controllable "
"relative -6 dB bandwidth.</span>"),
("sinc", "Sinc",
"<span>Sinc pulse with rectangular baseband spectrum</span>"),
("rect", "Rect",
"<span>Rectangular pulse with sinc-shaped spectrum</span>")
]
self.cmb_stim_sinusoid_items = [
"Sinusoidal or similar signals", ("sine", "Sine", "Sine signal"),
("cos", "Cos", "Cosine signal"),
("exp", "Exp", "Complex exponential"),
("diric", "Sinc",
"<span>Periodic Sinc (Dirichlet function)</span>")
]
# data / text / tooltip for noise stimulus combobox.
self.cmb_stim_noise_items = [
"Type of additive noise.", ("none", "None", ""),
("gauss", "Gauss",
"<span>Normal- or Gauss-distributed process with std. deviation σ."
"</span>"),
("uniform", "Uniform",
"<span>Uniformly distributed process in the range ± Δ/2."
"</span>"),
("prbs", "PRBS",
"<span>Pseudo-Random Binary Sequence with values ± A.</span>"
),
("mls", "MLS",
"<span>Maximum Length Sequence with values ± A. The sequence is "
"always the same as the state is not stored for the next sequence start."
"</span>"),
("brownian", "Brownian",
"<span>Brownian (cumulated sum) process based on Gaussian noise with"
" std. deviation σ.</span>")
]
self._construct_UI()
self._enable_stim_widgets()
self._update_noi()
def _construct_UI(self):
# =====================================================================
# Controls for stimuli
# =====================================================================
self.cmbStimulus = QComboBox(self)
qcmb_box_populate(self.cmbStimulus, self.cmb_stim_items,
self.cmb_stim_item)
self.lblStimPar1 = QLabel(to_html("α =", frmt='b'), self)
self.ledStimPar1 = QLineEdit(self)
self.ledStimPar1.setText("0.5")
self.ledStimPar1.setToolTip("Duty Cycle, 0 ... 1")
self.ledStimPar1.setObjectName("ledStimPar1")
self.but_stim_bl = QPushButton(self)
self.but_stim_bl.setText("BL")
self.but_stim_bl.setToolTip(
"<span>Bandlimit the signal to the Nyquist "
"frequency to avoid aliasing. However, this is much slower "
"to calculate especially for a large number of points.</span>")
self.but_stim_bl.setMaximumWidth(qtext_width(text="BL "))
self.but_stim_bl.setCheckable(True)
self.but_stim_bl.setChecked(True)
self.but_stim_bl.setObjectName("stim_bl")
# -------------------------------------
self.cmbChirpType = QComboBox(self)
qcmb_box_populate(self.cmbChirpType, self.cmb_stim_chirp_items,
self.chirp_type)
self.cmbImpulseType = QComboBox(self)
qcmb_box_populate(self.cmbImpulseType, self.cmb_stim_impulse_items,
self.impulse_type)
self.cmbSinusoidType = QComboBox(self)
qcmb_box_populate(self.cmbSinusoidType, self.cmb_stim_sinusoid_items,
self.sinusoid_type)
self.cmbPeriodicType = QComboBox(self)
qcmb_box_populate(self.cmbPeriodicType, self.cmb_stim_periodic_items,
self.cmb_stim_periodic_item)
self.cmbModulationType = QComboBox(self)
for t in [("AM", "am"), ("PM / FM", "pmfm")]: # text, data
self.cmbModulationType.addItem(*t)
qset_cmb_box(self.cmbModulationType, self.modulation_type, data=True)
# -------------------------------------
self.chk_step_err = QPushButton("Error", self)
self.chk_step_err.setToolTip(
"<span>Display the step response error.</span>")
self.chk_step_err.setMaximumWidth(qtext_width(text="Error "))
self.chk_step_err.setCheckable(True)
self.chk_step_err.setChecked(False)
self.chk_step_err.setObjectName("stim_step_err")
layHCmbStim = QHBoxLayout()
layHCmbStim.addWidget(self.cmbStimulus)
layHCmbStim.addWidget(self.cmbImpulseType)
layHCmbStim.addWidget(self.cmbSinusoidType)
layHCmbStim.addWidget(self.cmbChirpType)
layHCmbStim.addWidget(self.cmbPeriodicType)
layHCmbStim.addWidget(self.cmbModulationType)
layHCmbStim.addWidget(self.but_stim_bl)
layHCmbStim.addWidget(self.lblStimPar1)
layHCmbStim.addWidget(self.ledStimPar1)
layHCmbStim.addWidget(self.chk_step_err)
self.lblDC = QLabel(to_html("DC =", frmt='bi'), self)
self.ledDC = QLineEdit(self)
self.ledDC.setText(str(self.DC))
self.ledDC.setToolTip("DC Level")
self.ledDC.setObjectName("stimDC")
layHStimDC = QHBoxLayout()
layHStimDC.addWidget(self.lblDC)
layHStimDC.addWidget(self.ledDC)
# ======================================================================
self.lblAmp1 = QLabel(to_html(" A_1", frmt='bi') + " =", self)
self.ledAmp1 = QLineEdit(self)
self.ledAmp1.setText(str(self.A1))
self.ledAmp1.setToolTip(
"Stimulus amplitude, complex values like 3j - 1 are allowed")
self.ledAmp1.setObjectName("stimAmp1")
self.lblAmp2 = QLabel(to_html(" A_2", frmt='bi') + " =", self)
self.ledAmp2 = QLineEdit(self)
self.ledAmp2.setText(str(self.A2))
self.ledAmp2.setToolTip(
"Stimulus amplitude 2, complex values like 3j - 1 are allowed")
self.ledAmp2.setObjectName("stimAmp2")
# ----------------------------------------------
self.lblPhi1 = QLabel(to_html(" φ_1", frmt='bi') + " =", self)
self.ledPhi1 = QLineEdit(self)
self.ledPhi1.setText(str(self.phi1))
self.ledPhi1.setToolTip("Stimulus phase")
self.ledPhi1.setObjectName("stimPhi1")
self.lblPhU1 = QLabel(to_html("°", frmt='b'), self)
self.lblPhi2 = QLabel(to_html(" φ_2", frmt='bi') + " =", self)
self.ledPhi2 = QLineEdit(self)
self.ledPhi2.setText(str(self.phi2))
self.ledPhi2.setToolTip("Stimulus phase 2")
self.ledPhi2.setObjectName("stimPhi2")
self.lblPhU2 = QLabel(to_html("°", frmt='b'), self)
# ----------------------------------------------
self.lbl_T1 = QLabel(to_html(" T_1", frmt='bi') + " =", self)
self.led_T1 = QLineEdit(self)
self.led_T1.setText(str(self.T1))
self.led_T1.setToolTip("Time shift")
self.led_T1.setObjectName("stimT1")
self.lbl_TU1 = QLabel(to_html("T_S", frmt='b'), self)
self.lbl_T2 = QLabel(to_html(" T_2", frmt='bi') + " =", self)
self.led_T2 = QLineEdit(self)
self.led_T2.setText(str(self.T2))
self.led_T2.setToolTip("Time shift 2")
self.led_T2.setObjectName("stimT2")
self.lbl_TU2 = QLabel(to_html("T_S", frmt='b'), self)
# ---------------------------------------------
self.lbl_TW1 = QLabel(
to_html(" ΔT_1", frmt='bi') + " =", self)
self.led_TW1 = QLineEdit(self)
self.led_TW1.setText(str(self.TW1))
self.led_TW1.setToolTip("Time width")
self.led_TW1.setObjectName("stimTW1")
self.lbl_TWU1 = QLabel(to_html("T_S", frmt='b'), self)
self.lbl_TW2 = QLabel(
to_html(" ΔT_2", frmt='bi') + " =", self)
self.led_TW2 = QLineEdit(self)
self.led_TW2.setText(str(self.TW2))
self.led_TW2.setToolTip("Time width 2")
self.led_TW2.setObjectName("stimTW2")
self.lbl_TWU2 = QLabel(to_html("T_S", frmt='b'), self)
# ----------------------------------------------
self.txtFreq1_f = to_html(" f_1", frmt='bi') + " ="
self.txtFreq1_k = to_html(" k_1", frmt='bi') + " ="
self.lblFreq1 = QLabel(self.txtFreq1_f, self)
self.ledFreq1 = QLineEdit(self)
self.ledFreq1.setText(str(self.f1))
self.ledFreq1.setToolTip("Stimulus frequency")
self.ledFreq1.setObjectName("stimFreq1")
self.lblFreqUnit1 = QLabel("f_S", self)
self.txtFreq2_f = to_html(" f_2", frmt='bi') + " ="
self.txtFreq2_k = to_html(" k_2", frmt='bi') + " ="
self.lblFreq2 = QLabel(self.txtFreq2_f, self)
self.ledFreq2 = QLineEdit(self)
self.ledFreq2.setText(str(self.f2))
self.ledFreq2.setToolTip("Stimulus frequency 2")
self.ledFreq2.setObjectName("stimFreq2")
self.lblFreqUnit2 = QLabel("f_S", self)
# ----------------------------------------------
self.lbl_BW1 = QLabel(
to_html(self.tr(" BW_1"), frmt='bi') + " =", self)
self.led_BW1 = QLineEdit(self)
self.led_BW1.setText(str(self.BW1))
self.led_BW1.setToolTip(self.tr("Relative bandwidth"))
self.led_BW1.setObjectName("stimBW1")
self.lbl_BW2 = QLabel(
to_html(self.tr(" BW_2"), frmt='bi') + " =", self)
self.led_BW2 = QLineEdit(self)
self.led_BW2.setText(str(self.BW2))
self.led_BW2.setToolTip(self.tr("Relative bandwidth 2"))
self.led_BW2.setObjectName("stimBW2")
# ----------------------------------------------
self.lblNoise = QLabel(to_html(" Noise", frmt='bi'), self)
self.cmbNoise = QComboBox(self)
qcmb_box_populate(self.cmbNoise, self.cmb_stim_noise_items, self.noise)
self.lblNoi = QLabel("not initialized", self)
self.ledNoi = QLineEdit(self)
self.ledNoi.setText(str(self.noi))
self.ledNoi.setToolTip("not initialized")
self.ledNoi.setObjectName("stimNoi")
layGStim = QGridLayout()
layGStim.addLayout(layHCmbStim, 0, 1)
layGStim.addLayout(layHStimDC, 1, 1)
layGStim.addWidget(self.lblAmp1, 0, 2)
layGStim.addWidget(self.lblAmp2, 1, 2)
layGStim.addWidget(self.ledAmp1, 0, 3)
layGStim.addWidget(self.ledAmp2, 1, 3)
layGStim.addWidget(self.lblPhi1, 0, 4)
layGStim.addWidget(self.lblPhi2, 1, 4)
layGStim.addWidget(self.ledPhi1, 0, 5)
layGStim.addWidget(self.ledPhi2, 1, 5)
layGStim.addWidget(self.lblPhU1, 0, 6)
layGStim.addWidget(self.lblPhU2, 1, 6)
layGStim.addWidget(self.lbl_T1, 0, 7)
layGStim.addWidget(self.lbl_T2, 1, 7)
layGStim.addWidget(self.led_T1, 0, 8)
layGStim.addWidget(self.led_T2, 1, 8)
layGStim.addWidget(self.lbl_TU1, 0, 9)
layGStim.addWidget(self.lbl_TU2, 1, 9)
layGStim.addWidget(self.lbl_TW1, 0, 10)
layGStim.addWidget(self.lbl_TW2, 1, 10)
layGStim.addWidget(self.led_TW1, 0, 11)
layGStim.addWidget(self.led_TW2, 1, 11)
layGStim.addWidget(self.lbl_TWU1, 0, 12)
layGStim.addWidget(self.lbl_TWU2, 1, 12)
layGStim.addWidget(self.lblFreq1, 0, 13)
layGStim.addWidget(self.lblFreq2, 1, 13)
layGStim.addWidget(self.ledFreq1, 0, 14)
layGStim.addWidget(self.ledFreq2, 1, 14)
layGStim.addWidget(self.lblFreqUnit1, 0, 15)
layGStim.addWidget(self.lblFreqUnit2, 1, 15)
layGStim.addWidget(self.lbl_BW1, 0, 16)
layGStim.addWidget(self.lbl_BW2, 1, 16)
layGStim.addWidget(self.led_BW1, 0, 17)
layGStim.addWidget(self.led_BW2, 1, 17)
layGStim.addWidget(self.lblNoise, 0, 18)
layGStim.addWidget(self.lblNoi, 1, 18)
layGStim.addWidget(self.cmbNoise, 0, 19)
layGStim.addWidget(self.ledNoi, 1, 19)
# ----------------------------------------------
self.lblStimFormula = QLabel(to_html("x =", frmt='bi'), self)
self.ledStimFormula = QLineEdit(self)
self.ledStimFormula.setText(str(self.stim_formula))
self.ledStimFormula.setToolTip(
"<span>Enter formula for stimulus in numexpr syntax.</span>")
self.ledStimFormula.setObjectName("stimFormula")
layH_stim_formula = QHBoxLayout()
layH_stim_formula.addWidget(self.lblStimFormula)
layH_stim_formula.addWidget(self.ledStimFormula, 10)
# ----------------------------------------------------------------------
# Main Widget
# ----------------------------------------------------------------------
layH_stim_par = QHBoxLayout()
layH_stim_par.addLayout(layGStim)
layV_stim = QVBoxLayout()
layV_stim.addLayout(layH_stim_par)
layV_stim.addLayout(layH_stim_formula)
layH_stim = QHBoxLayout()
layH_stim.addLayout(layV_stim)
layH_stim.addStretch(10)
self.wdg_stim = QWidget(self)
self.wdg_stim.setLayout(layH_stim)
self.wdg_stim.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
# ----------------------------------------------------------------------
# Event Filter
# ----------------------------------------------------------------------
# frequency related widgets are scaled with f_s, requiring special handling
self.ledFreq1.installEventFilter(self)
self.ledFreq2.installEventFilter(self)
self.led_T1.installEventFilter(self)
self.led_T2.installEventFilter(self)
self.led_TW1.installEventFilter(self)
self.led_TW2.installEventFilter(self)
# ----------------------------------------------------------------------
# GLOBAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
self.sig_rx.connect(self.process_sig_rx)
# ----------------------------------------------------------------------
# LOCAL SIGNALS & SLOTs
# ----------------------------------------------------------------------
# --- stimulus control ---
self.but_stim_bl.clicked.connect(self._enable_stim_widgets)
self.chk_step_err.clicked.connect(self._enable_stim_widgets)
self.cmbStimulus.currentIndexChanged.connect(self._enable_stim_widgets)
self.cmbNoise.currentIndexChanged.connect(self._update_noi)
self.ledNoi.editingFinished.connect(self._update_noi)
self.ledAmp1.editingFinished.connect(self._update_amp1)
self.ledAmp2.editingFinished.connect(self._update_amp2)
self.ledPhi1.editingFinished.connect(self._update_phi1)
self.ledPhi2.editingFinished.connect(self._update_phi2)
self.led_BW1.editingFinished.connect(self._update_BW1)
self.led_BW2.editingFinished.connect(self._update_BW2)
self.cmbImpulseType.currentIndexChanged.connect(
self._update_impulse_type)
self.cmbSinusoidType.currentIndexChanged.connect(
self._update_sinusoid_type)
self.cmbChirpType.currentIndexChanged.connect(self._update_chirp_type)
self.cmbPeriodicType.currentIndexChanged.connect(
self._update_periodic_type)
self.cmbModulationType.currentIndexChanged.connect(
self._update_modulation_type)
self.ledDC.editingFinished.connect(self._update_DC)
self.ledStimFormula.editingFinished.connect(self._update_stim_formula)
self.ledStimPar1.editingFinished.connect(self._update_stim_par1)
# ------------------------------------------------------------------------------
def update_freq_units(self):
"""
Update labels referrring to frequency specs
"""
if fb.fil[0]['freq_specs_unit'] == 'k':
f_unit = ''
t_unit = ''
self.lblFreq1.setText(self.txtFreq1_k)
self.lblFreq2.setText(self.txtFreq2_k)
else:
f_unit = fb.fil[0]['plt_fUnit']
t_unit = fb.fil[0]['plt_tUnit'].replace(r"$\mu$", "μ")
self.lblFreq1.setText(self.txtFreq1_f)
self.lblFreq2.setText(self.txtFreq2_f)
if f_unit in {"f_S", "f_Ny"}:
unit_frmt = "i" # italic
else:
unit_frmt = None # don't print units like kHz in italic
self.lblFreqUnit1.setText(to_html(f_unit, frmt=unit_frmt))
self.lblFreqUnit2.setText(to_html(f_unit, frmt=unit_frmt))
self.lbl_TU1.setText(to_html(t_unit, frmt=unit_frmt))
self.lbl_TU2.setText(to_html(t_unit, frmt=unit_frmt))
# ------------------------------------------------------------------------------
def eventFilter(self, source, event):
"""
Filter all events generated by the monitored widgets (ledFreq1 and 2 and T1 / T2).
Source and type of all events generated by monitored objects are passed
to this eventFilter, evaluated and passed on to the next hierarchy level.
- When a QLineEdit widget gains input focus (``QEvent.FocusIn``), display
the stored value from filter dict with full precision
- When a key is pressed inside the text field, set the `spec_edited` flag
to True.
- When a QLineEdit widget loses input focus (``QEvent.FocusOut``), store
current value normalized to f_S with full precision (only if
``spec_edited == True``) and display the stored value in selected format
Emit 'ui_changed':'stim'
"""
def _reload_entry(source):
""" Reload text entry for active line edit field in rounded format """
if source.objectName() == "stimFreq1":
source.setText(
str(params['FMT'].format(self.f1 * self.f_scale)))
elif source.objectName() == "stimFreq2":
source.setText(
str(params['FMT'].format(self.f2 * self.f_scale)))
elif source.objectName() == "stimT1":
source.setText(
str(params['FMT'].format(self.T1 * self.t_scale)))
elif source.objectName() == "stimT2":
source.setText(
str(params['FMT'].format(self.T2 * self.t_scale)))
elif source.objectName() == "stimTW1":
source.setText(
str(params['FMT'].format(self.TW1 * self.t_scale)))
elif source.objectName() == "stimTW2":
source.setText(
str(params['FMT'].format(self.TW2 * self.t_scale)))
def _store_entry(source):
if self.spec_edited:
if source.objectName() == "stimFreq1":
self.f1 = safe_eval(source.text(),
self.f1 * self.f_scale,
return_type='float') / self.f_scale
source.setText(
str(params['FMT'].format(self.f1 * self.f_scale)))
elif source.objectName() == "stimFreq2":
self.f2 = safe_eval(source.text(),
self.f2 * self.f_scale,
return_type='float') / self.f_scale
source.setText(
str(params['FMT'].format(self.f2 * self.f_scale)))
elif source.objectName() == "stimT1":
self.T1 = safe_eval(source.text(),
self.T1 * self.t_scale,
return_type='float') / self.t_scale
source.setText(
str(params['FMT'].format(self.T1 * self.t_scale)))
elif source.objectName() == "stimT2":
self.T2 = safe_eval(source.text(),
self.T2 * self.t_scale,
return_type='float') / self.t_scale
source.setText(
str(params['FMT'].format(self.T2 * self.t_scale)))
elif source.objectName() == "stimTW1":
self.TW1 = safe_eval(source.text(),
self.TW1 * self.t_scale,
sign='pos',
return_type='float') / self.t_scale
source.setText(
str(params['FMT'].format(self.TW1 * self.t_scale)))
elif source.objectName() == "stimTW2":
self.TW2 = safe_eval(source.text(),
self.TW2 * self.t_scale,
sign='pos',
return_type='float') / self.t_scale
source.setText(
str(params['FMT'].format(self.TW2 * self.t_scale)))
self.spec_edited = False # reset flag
self._update_scale_impz()
self.emit({'ui_changed': 'stim'})
# nothing has changed, but display frequencies in rounded format anyway
else:
_reload_entry(source)
# --------------------------------------------------------------------
# if isinstance(source, QLineEdit):
# if source.objectName() in {"stimFreq1","stimFreq2"}:
if event.type() in {QEvent.FocusIn, QEvent.KeyPress, QEvent.FocusOut}:
if event.type() == QEvent.FocusIn:
self.spec_edited = False
self.update_freqs()
elif event.type() == QEvent.KeyPress:
self.spec_edited = True # entry has been changed
key = event.key()
if key in {Qt.Key_Return, Qt.Key_Enter}:
_store_entry(source)
elif key == Qt.Key_Escape: # revert changes
self.spec_edited = False
_reload_entry(source)
elif event.type() == QEvent.FocusOut:
_store_entry(source)
# Call base class method to continue normal event processing:
return super(Plot_Tran_Stim_UI, self).eventFilter(source, event)
# -------------------------------------------------------------
def recalc_freqs(self):
"""
Update normalized frequencies if required. This is called by via signal
['ui_changed':'f_S'] from plot_impz.process_sig_rx
"""
if fb.fil[0]['freq_locked']:
self.f1 *= fb.fil[0]['f_S_prev'] / fb.fil[0]['f_S']
self.f2 *= fb.fil[0]['f_S_prev'] / fb.fil[0]['f_S']
self.T1 *= fb.fil[0]['f_S'] / fb.fil[0]['f_S_prev']
self.T2 *= fb.fil[0]['f_S'] / fb.fil[0]['f_S_prev']
self.TW1 *= fb.fil[0]['f_S'] / fb.fil[0]['f_S_prev']
self.TW2 *= fb.fil[0]['f_S'] / fb.fil[0]['f_S_prev']
self._update_scale_impz()
self.update_freqs()
self.emit({'ui_changed': 'f1_f2'})
# -------------------------------------------------------------
def update_freqs(self):
"""
`update_freqs()` is called:
- when one of the stimulus frequencies has changed via eventFilter()
- sampling frequency has been changed via signal ['ui_changed':'f_S']
from plot_impz.process_sig_rx -> self.recalc_freqs
The sampling frequency is loaded from filter dictionary and stored as
`self.f_scale` (except when the frequency unit is k when `f_scale = self.N_FFT`).
Frequency field entries are always stored normalized w.r.t. f_S in the
dictionary: When the `f_S` lock button is unlocked, only the displayed
values for frequency entries are updated with f_S, not the dictionary.
When the `f_S` lock button is pressed, the absolute frequency values in
the widget fields are kept constant, and the dictionary entries are updated.
"""
# recalculate displayed freq spec values for (maybe) changed f_S
if fb.fil[0]['freq_specs_unit'] == 'k':
self.f_scale = self.N_FFT
else:
self.f_scale = fb.fil[0]['f_S']
self.t_scale = fb.fil[0]['T_S']
if self.ledFreq1.hasFocus():
# widget has focus, show full precision
self.ledFreq1.setText(str(self.f1 * self.f_scale))
elif self.ledFreq2.hasFocus():
self.ledFreq2.setText(str(self.f2 * self.f_scale))
elif self.led_T1.hasFocus():
self.led_T1.setText(str(self.T1 * self.t_scale))
elif self.led_T2.hasFocus():
self.led_T2.setText(str(self.T2 * self.t_scale))
elif self.led_TW1.hasFocus():
self.led_TW1.setText(str(self.TW1 * self.t_scale))
elif self.led_TW2.hasFocus():
self.led_TW2.setText(str(self.TW2 * self.t_scale))
else:
# widgets have no focus, round the display
self.ledFreq1.setText(
str(params['FMT'].format(self.f1 * self.f_scale)))
self.ledFreq2.setText(
str(params['FMT'].format(self.f2 * self.f_scale)))
self.led_T1.setText(
str(params['FMT'].format(self.T1 * self.t_scale)))
self.led_T2.setText(
str(params['FMT'].format(self.T2 * self.t_scale)))
self.led_TW1.setText(
str(params['FMT'].format(self.TW1 * self.t_scale)))
self.led_TW2.setText(
str(params['FMT'].format(self.TW2 * self.t_scale)))
self.update_freq_units(
) # TODO: should only be called at f_S / unit update
# -------------------------------------------------------------
def _enable_stim_widgets(self):
""" Enable / disable widgets depending on the selected stimulus """
self.cmb_stim = qget_cmb_box(self.cmbStimulus)
if self.cmb_stim == "impulse":
self.stim = qget_cmb_box(self.cmbImpulseType)
# recalculate the energy scaling for impulse functions
self._update_scale_impz()
elif self.cmb_stim == "sinusoid":
self.stim = qget_cmb_box(self.cmbSinusoidType)
elif self.cmb_stim == "periodic":
self.stim = qget_cmb_box(self.cmbPeriodicType)
elif self.cmb_stim == "modulation":
self.stim = qget_cmb_box(self.cmbModulationType)
else:
self.stim = self.cmb_stim
# read out which stimulus widgets are enabled
stim_wdg = self.stim_wdg_dict[self.stim]
self.lblDC.setVisible("dc" in stim_wdg)
self.ledDC.setVisible("dc" in stim_wdg)
self.chk_step_err.setVisible(self.stim == "step")
self.lblStimPar1.setVisible("par1" in stim_wdg)
self.ledStimPar1.setVisible("par1" in stim_wdg)
self.but_stim_bl.setVisible("bl" in stim_wdg)
self.lblAmp1.setVisible("a1" in stim_wdg)
self.ledAmp1.setVisible("a1" in stim_wdg)
self.lblPhi1.setVisible("phi1" in stim_wdg)
self.ledPhi1.setVisible("phi1" in stim_wdg)
self.lblPhU1.setVisible("phi1" in stim_wdg)
self.lbl_T1.setVisible("T1" in stim_wdg)
self.led_T1.setVisible("T1" in stim_wdg)
self.lbl_TU1.setVisible("T1" in stim_wdg)
self.lbl_TW1.setVisible("TW1" in stim_wdg)
self.led_TW1.setVisible("TW1" in stim_wdg)
self.lbl_TWU1.setVisible("TW1" in stim_wdg)
self.lblFreq1.setVisible("f1" in stim_wdg)
self.ledFreq1.setVisible("f1" in stim_wdg)
self.lblFreqUnit1.setVisible("f1" in stim_wdg)
self.lbl_BW1.setVisible("BW1" in stim_wdg)
self.led_BW1.setVisible("BW1" in stim_wdg)
self.lblAmp2.setVisible("a2" in stim_wdg)
self.ledAmp2.setVisible("a2" in stim_wdg)
self.lblPhi2.setVisible("phi2" in stim_wdg)
self.ledPhi2.setVisible("phi2" in stim_wdg)
self.lblPhU2.setVisible("phi2" in stim_wdg)
self.lbl_T2.setVisible("T2" in stim_wdg)
self.led_T2.setVisible("T2" in stim_wdg)
self.lbl_TU2.setVisible("T2" in stim_wdg)
self.lbl_TW2.setVisible("TW2" in stim_wdg)
self.led_TW2.setVisible("TW2" in stim_wdg)
self.lbl_TWU2.setVisible("TW2" in stim_wdg)
self.lblFreq2.setVisible("f2" in stim_wdg)
self.ledFreq2.setVisible("f2" in stim_wdg)
self.lblFreqUnit2.setVisible("f2" in stim_wdg)
self.lbl_BW2.setVisible("BW2" in stim_wdg)
self.led_BW2.setVisible("BW2" in stim_wdg)
self.lblStimFormula.setVisible(self.stim == "formula")
self.ledStimFormula.setVisible(self.stim == "formula")
self.cmbImpulseType.setVisible(self.cmb_stim == 'impulse')
self.cmbSinusoidType.setVisible(self.cmb_stim == 'sinusoid')
self.cmbChirpType.setVisible(self.cmb_stim == 'chirp')
self.cmbPeriodicType.setVisible(self.cmb_stim == 'periodic')
self.cmbModulationType.setVisible(self.cmb_stim == 'modulation')
self.emit({'ui_changed': 'stim'})
# -------------------------------------------------------------
def _update_amp1(self):
""" Update value for self.A1 from QLineEditWidget"""
self.A1 = safe_eval(self.ledAmp1.text(), self.A1, return_type='cmplx')
self.ledAmp1.setText(str(self.A1))
self.emit({'ui_changed': 'a1'})
def _update_amp2(self):
""" Update value for self.A2 from the QLineEditWidget"""
self.A2 = safe_eval(self.ledAmp2.text(), self.A2, return_type='cmplx')
self.ledAmp2.setText(str(self.A2))
self.emit({'ui_changed': 'a2'})
def _update_phi1(self):
""" Update value for self.phi1 from QLineEditWidget"""
self.phi1 = safe_eval(self.ledPhi1.text(),
self.phi1,
return_type='float')
self.ledPhi1.setText(str(self.phi1))
self.emit({'ui_changed': 'phi1'})
def _update_BW1(self):
""" Update value for self.BW1 from QLineEditWidget"""
self.BW1 = safe_eval(self.led_BW1.text(),
self.BW1,
return_type='float',
sign='pos')
self.led_BW1.setText(str(self.BW1))
self._update_scale_impz()
self.emit({'ui_changed': 'BW1'})
def _update_BW2(self):
""" Update value for self.BW2 from QLineEditWidget"""
self.BW2 = safe_eval(self.led_BW2.text(),
self.BW2,
return_type='float',
sign='pos')
self.led_BW2.setText(str(self.BW2))
self.emit({'ui_changed': 'BW2'})
def _update_scale_impz(self):
"""
recalculate the energy scaling for impulse functions when impulse type or
relevant frequency / bandwidth parameter have been updated
"""
if self.stim == "dirac":
self.scale_impz = 1.
elif self.stim == "sinc":
self.scale_impz = self.f1 * 2
elif self.stim == "gauss":
self.scale_impz = self.f1 * 2 * self.BW1
elif self.stim == "rect":
self.scale_impz = 1. / self.TW1
def _update_phi2(self):
""" Update value for self.phi2 from the QLineEditWidget"""
self.phi2 = safe_eval(self.ledPhi2.text(),
self.phi2,
return_type='float')
self.ledPhi2.setText(str(self.phi2))
self.emit({'ui_changed': 'phi2'})
def _update_chirp_type(self):
""" Update value for self.chirp_type from data field of ComboBox"""
self.chirp_type = qget_cmb_box(self.cmbChirpType)
self.emit({'ui_changed': 'chirp_type'})
def _update_impulse_type(self):
""" Update value for self.impulse_type from data field of ComboBox"""
self.impulse_type = qget_cmb_box(self.cmbImpulseType)
self._enable_stim_widgets()
def _update_sinusoid_type(self):
""" Update value for self.sinusoid_type from data field of ComboBox"""
self.sinusoid_type = qget_cmb_box(self.cmbSinusoidType)
self._enable_stim_widgets()
def _update_periodic_type(self):
""" Update value for self.periodic_type from data field of ComboBox"""
self.periodic_type = qget_cmb_box(self.cmbPeriodicType)
self._enable_stim_widgets()
def _update_modulation_type(self):
""" Update value for self.modulation_type from from data field of ComboBox"""
self.modulation_type = qget_cmb_box(self.cmbModulationType)
self._enable_stim_widgets()
# -------------------------------------------------------------
def _update_noi(self):
""" Update type + value + label for self.noi for noise"""
self.noise = qget_cmb_box(self.cmbNoise)
self.lblNoi.setVisible(self.noise != 'none')
self.ledNoi.setVisible(self.noise != 'none')
if self.noise != 'none':
self.noi = safe_eval(self.ledNoi.text(), 0, return_type='cmplx')
self.ledNoi.setText(str(self.noi))
if self.noise == 'gauss':
self.lblNoi.setText(to_html(" σ =", frmt='bi'))
self.ledNoi.setToolTip(
"<span>Standard deviation of statistical process,"
"noise power is <i>P</i> = σ<sup>2</sup></span>")
elif self.noise == 'uniform':
self.lblNoi.setText(to_html(" Δ =", frmt='bi'))
self.ledNoi.setToolTip(
"<span>Interval size for uniformly distributed process (e.g. "
"quantization step size for quantization noise), centered around 0. "
"Noise power is <i>P</i> = Δ<sup>2</sup>/12.</span>")
elif self.noise == 'prbs':
self.lblNoi.setText(to_html(" A =", frmt='bi'))
self.ledNoi.setToolTip(
"<span>Amplitude of bipolar Pseudorandom Binary Sequence. "
"Noise power is <i>P</i> = A<sup>2</sup>.</span>")
elif self.noise == 'mls':
self.lblNoi.setText(to_html(" A =", frmt='bi'))
self.ledNoi.setToolTip(
"<span>Amplitude of Maximum Length Sequence. "
"Noise power is <i>P</i> = A<sup>2</sup>.</span>")
elif self.noise == 'brownian':
self.lblNoi.setText(to_html(" σ =", frmt='bi'))
self.ledNoi.setToolTip(
"<span>Standard deviation of the Gaussian process "
"that is cumulated.</span>")
self.emit({'ui_changed': 'noi'})
def _update_DC(self):
""" Update value for self.DC from the QLineEditWidget"""
self.DC = safe_eval(self.ledDC.text(), 0, return_type='cmplx')
self.ledDC.setText(str(self.DC))
self.emit({'ui_changed': 'dc'})
def _update_stim_formula(self):
"""Update string with formula to be evaluated by numexpr"""
self.stim_formula = self.ledStimFormula.text().strip()
self.ledStimFormula.setText(str(self.stim_formula))
self.emit({'ui_changed': 'stim_formula'})
def _update_stim_par1(self):
""" Update value for self.par1 from QLineEditWidget"""
self.stim_par1 = safe_eval(self.ledStimPar1.text(),
self.stim_par1,
sign='pos',
return_type='float')
self.ledStimPar1.setText(str(self.stim_par1))
self.emit({'ui_changed': 'stim_par1'})
class Tran_IO_UI(QWidget):
"""
Create the UI for the PlotImpz class
"""
# incoming:
sig_rx = pyqtSignal(object)
# outgoing: from various UI elements to PlotImpz ('ui_changed':'xxx')
sig_tx = pyqtSignal(object)
from pyfda.libs.pyfda_qt_lib import emit
# ------------------------------------------------------------------------------
def process_sig_rx(self, dict_sig=None):
"""
Process signals coming from
-
-
"""
logger.warning("PROCESS_SIG_RX - vis: {0}\n{1}".format(
self.isVisible(), pprint_log(dict_sig)))
if 'id' in dict_sig and dict_sig['id'] == id(self):
logger.warning("Stopped infinite loop:\n{0}".format(
pprint_log(dict_sig)))
return
# elif 'view_changed' in dict_sig:
# if dict_sig['view_changed'] == 'f_S':
# self.recalc_freqs()
# ------------------------------------------------------------------------------
def __init__(self, parent=None):
"""
Pass instance `parent` of parent class (FilterCoeffs)
"""
super(Tran_IO_UI, self).__init__(parent)
self._construct_UI()
def _construct_UI(self):
# =====================================================================
# Controls
# =====================================================================
self.butLoad = PushButton(self,
icon=QIcon(':/file.svg'),
checkable=False)
# self.butLoad.setIconSize(q_icon_size)
self.butLoad.setToolTip("Load data from file.")
self.butLoad.setEnabled(False)
self.lbl_info = QLabel(to_html(" coming soon ...", frmt="b"))
# ----------------------------------------------------------------------
# Main Widget
# ----------------------------------------------------------------------
layH_io_par = QHBoxLayout()
layH_io_par.addWidget(self.butLoad)
layH_io_par.addWidget(self.lbl_info)
layV_io = QVBoxLayout()
layV_io.addLayout(layH_io_par)
layH_io = QHBoxLayout()
layH_io.addLayout(layV_io)
layH_io.addStretch(10)
self.wdg_top = QWidget(self)
self.wdg_top.setLayout(layH_io)
self.wdg_top.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)