ddsctrl 0.5.4__tar.gz → 0.7.0__tar.gz

{ddsctrl-0.5.4/ddsctrl.egg-info → ddsctrl-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddsctrl
-Version: 0.5.4
+Version: 0.7.0
 Summary: ddscontroller allow basic handling of AD9912 and AD9915 DDS development board.
 Home-page: https://gitlab.com/bendub/ddsctrl
 Author: Benoit Dubois

{ddsctrl-0.5.4 → ddsctrl-0.7.0}/bin/ddscontroller

@@ -16,12 +16,15 @@ import sys
 import argparse
 import os.path as path
 import logging
-import itertools
 import usb.core
-import usb.util
+import serial
+import serial.tools.list_ports
+from decimal import Decimal
 from PyQt5.QtCore import QSettings
 from PyQt5.QtWidgets import QApplication, QMainWindow, QMessageBox
 
+from ad9xdds.interfaces.fx2intf import Fx2Intf
+from ad9xdds.interfaces.stm32intf import Stm32Intf
 import ad9xdds.sad9912dev as sad9912dev
 import ad9xdds.ad9912dev as ad9912dev
 import ad9xdds.sad9915dev_umr232hm as sad9915dev
@@ -34,7 +37,8 @@ from ddsctrl.constants import ORGANIZATION, APP_NAME, DEFAULT_AUTO_UPDATE, \
     DEFAULT_AD9912_CP_CURRENT, DEFAULT_AD9912_VCO_RANGE, \
     DEFAULT_AD9912_PLL_DOUBLER, DEFAULT_AD9912_HSTL_EN, \
     DEFAULT_AD9912_CMOS_EN, DEFAULT_AD9912_IFREQ, \
-    DEFAULT_AD9912_HSTL_DOUBLER
+    DEFAULT_AD9912_HSTL_DOUBLER, \
+    DDS_MODEL
 
 CONSOLE_LOG_LEVEL = logging.DEBUG
 FILE_LOG_LEVEL = logging.DEBUG
@@ -77,13 +81,15 @@ def parse_cmd_line():
                         type=str, default='', help='-ini=<str>')
     parser.add_argument('-wt', '--window_title', dest='wtitle',
                         type=str, default="DDS controller")
-    parser.add_argument('-d', '--dds_model', choices=["AD9912", "AD9915"],
+    parser.add_argument('-d', '--dds_model', choices=["AD9912_FX2", "AD9912_STM32", "AD9915"],
                         dest='model')
     parser.add_argument('-b', '--dds_bus', type=int, dest='bus')
     parser.add_argument('-a', '--dds_address', type=int, dest='address')
+    parser.add_argument('-s', '--serial_device', type=str, dest='serial_device')
     args = parser.parse_args()
-    if args.model and (args.bus is None or args.address is None):
-        parser.error("--dds_model requires --dds_bus and --dds_adress.")
+    if ( args.model and (args.bus is None or args.address is None) ) and \
+        args.model=="AD9912_STM32" and args.serial is None:
+        parser.error("--dds_model requires --dds_bus and --dds_adress or --serial_device.")
     if not args.model and (args.bus is not None or args.address is not None):
         parser.error("--dds_bus and --dds_adress requires --dds_model.")
     return args
@@ -129,7 +135,7 @@ def save_all_settings(ui):
     settings.setValue('dds_ctrl/phase', ui.ocontroller_ui.phy_tuning.value())
     settings.setValue('dds_ctrl/amp', ui.ocontroller_ui.amp_tuning.value())
     settings.setValue('dds_ctrl/ifreq', ui.icontroller_ui.ifreq_dsb.value())
-    if model == "AD9912":
+    if model == DDS_MODEL.AD9912_FX2 or model == DDS_MODEL.AD9912_STM32:
         settings.setValue('dds_ctrl/hstl_en',
                           int(ui.ocontroller_ui.out_hstl_ckbox.isChecked()))
         settings.setValue('dds_ctrl/cmos_en',
@@ -203,13 +209,13 @@ def check_ini_file(user_ini_file=None):
 
 
 # =============================================================================
-def init_ui(ui, model):
+def init_ui(ui, model, dds):
     """Init UI.
     :param ui: ddsctrlui class instance (object)
     :param model: dds model i.e. "AD9912" or "AD9915" (str)
     :returns: None
     """
-    if model == "AD9912":
+    if model == DDS_MODEL.AD9912_FX2 or model == DDS_MODEL.AD9912_STM32:
         amax = ad9912dev.AMAX
         ifmax = ad9912dev.IFMAX
     else:
@@ -221,9 +227,9 @@ def init_ui(ui, model):
     # Init UI with respect to (ini file) actual dds configuration
     settings = QSettings()
     auto_update = bool(settings.value('dds_ctrl/auto_update'))
-    ofreq = float(settings.value('dds_ctrl/ofreq'))
-    ifreq = float(settings.value('dds_ctrl/ifreq'))
-    phase = float(settings.value('dds_ctrl/phase'))
+    ofreq = Decimal(settings.value('dds_ctrl/ofreq'))
+    ifreq = Decimal(settings.value('dds_ctrl/ifreq'))
+    phase = Decimal(settings.value('dds_ctrl/phase'))
     amp = int(settings.value('dds_ctrl/amp'))
     ##ui.ocontroller_ui.auto_update_ckbox.setChecked(False)
     ui.ocontroller_ui.auto_update_ckbox.setChecked(auto_update)
@@ -231,7 +237,9 @@ def init_ui(ui, model):
     ui.ocontroller_ui.phy_tuning.setValue(phase)
     ui.ocontroller_ui.amp_tuning.setValue(amp)
     ui.icontroller_ui.ifreq_dsb.setValue(ifreq)
-    if model == "AD9912":
+
+    
+    if model == DDS_MODEL.AD9912_FX2 or model == DDS_MODEL.AD9912_STM32:
         hstl_en = bool(int(settings.value('dds_ctrl/hstl_en')))
         cmos_en = bool(int(settings.value('dds_ctrl/cmos_en')))
         hstl_doubler = bool(int(settings.value('dds_ctrl/hstl_doubler')))
@@ -249,7 +257,20 @@ def init_ui(ui, model):
         ui.icontroller_ui.vco_range_cbox.setCurrentIndex(vco_range)
         ui.icontroller_ui.cp_current_cbox.setCurrentIndex(cp_current)
         ui.icontroller_ui.update_sys_clock_label()
-
+    
+    elif model == DDS_MODEL.AD9915:
+        # Update input PLL configuration
+        ui.icontroller_ui.input_doubler_enable_ckbox.setChecked(dds.get_input_doubler_state())
+        ui.icontroller_ui.input_divider_sbox.setValue(dds.get_input_divider_factor())
+        # Update PLL attribute
+        ui.icontroller_ui.pll_enable_ckbox.setChecked(dds.get_pll_state())
+        ui.icontroller_ui.pll_multiplier_sbox.setValue(dds.get_pll_multiplier_factor())
+        #
+        if ui.icontroller_ui.pll_enable_ckbox.isChecked() is True:
+            if dds.vco_calibration() is False:
+                logging.error("PLL is not locked")
+        #
+        ui.icontroller_ui.update_sys_clock_label(dds.get_sysfreq())
 
 # =============================================================================
 def init_dev(dds, model):
@@ -259,15 +280,15 @@ def init_dev(dds, model):
     :returns: None
     """
     settings = QSettings()
-    ofreq = float(settings.value('dds_ctrl/ofreq'))
-    ifreq = float(settings.value('dds_ctrl/ifreq'))
-    phase = float(settings.value('dds_ctrl/phase'))
+    ofreq = Decimal(settings.value('dds_ctrl/ofreq'))
+    ifreq = Decimal(settings.value('dds_ctrl/ifreq'))
+    phase = Decimal(settings.value('dds_ctrl/phase'))
     amp = int(settings.value('dds_ctrl/amp'))
     dds.set_ofreq(ofreq)
     dds.set_ifreq(ifreq)
     dds.set_phy(phase)
     dds.set_amp(amp)
-    if model == "AD9912":
+    if model == DDS_MODEL.AD9912_FX2 or model == DDS_MODEL.AD9912_STM32:
         hstl_en = bool(int(settings.value('dds_ctrl/hstl_en')))
         cmos_en = bool(int(settings.value('dds_ctrl/cmos_en')))
         hstl_doubler = bool(int(settings.value('dds_ctrl/hstl_doubler')))
@@ -303,7 +324,7 @@ def handle_ocontroller_ui_behavior(ui, dds, model):
             lambda: amplitude_changed(ui, dds))
         ui.ocontroller_ui.phy_tuning.valueChanged[str].connect(
             lambda: phase_changed(ui, dds))
-        if model == "AD9912":
+        if model == DDS_MODEL.AD9912_FX2 or model == DDS_MODEL.AD9912_STM32:
             ui.ocontroller_ui.out_hstl_ckbox.stateChanged.connect(
                 lambda: hstl_output_changed(ui, dds))
             ui.ocontroller_ui.hstl_doubler_ckbox.stateChanged.connect(
@@ -337,8 +358,10 @@ def get_reg_btn_clicked(ui, dds):
     :returns: None
     """
     try:
-        reg_val = dds.get_reg(
-            int(str(ui.debug_ui.reg_add_led.text()), 16))
+        reg_val = dds._intf.get_reg(
+            int(str(ui.debug_ui.reg_add_led.text()), 16),
+            1
+        )
     except ValueError as ex:
         pass # Error handled in dds.get_reg
     except Exception as ex:
@@ -354,8 +377,11 @@ def set_reg_btn_clicked(ui, dds):
     :param dds: dds class instance (object)
     :returns: None
     """
-    dds.set_reg(int(str(ui.debug_ui.reg_add_led.text()), 16),
-                int(str(ui.debug_ui.reg_val_led.text()), 16))
+    dds._intf.set_reg(
+        int(str(ui.debug_ui.reg_add_led.text()), 16),
+        1,
+        int(str(ui.debug_ui.reg_val_led.text()), 16)
+    )
 
 
 # =============================================================================
@@ -366,7 +392,7 @@ def ofreq_changed(ui, dds, **kwargs):
     :returns: None
     """
     act_ofreq = dds.set_ofreq(ui.ocontroller_ui.ofreq_tuning.value())
-    ui.ocontroller_ui.ofreq_tuning.setValue(float(act_ofreq))
+    ui.ocontroller_ui.ofreq_tuning.setValue(Decimal(act_ofreq))
     QSettings().setValue('dds_ctrl/ofreq', act_ofreq)
 
 
@@ -378,7 +404,7 @@ def amplitude_changed(ui, dds):
     :returns: None
     """
     act_amp = dds.set_amp(int(ui.ocontroller_ui.amp_tuning.value()))
-    ui.ocontroller_ui.amp_tuning.setValue(float(act_amp))
+    ui.ocontroller_ui.amp_tuning.setValue(Decimal(act_amp))
     QSettings().setValue('dds_ctrl/amp', act_amp)
 
 
@@ -390,7 +416,7 @@ def phase_changed(ui, dds):
     :returns: None
     """
     act_phy = dds.set_phy(ui.ocontroller_ui.phy_tuning.value())
-    ui.ocontroller_ui.phy_tuning.setValue(float(act_phy))
+    ui.ocontroller_ui.phy_tuning.setValue(Decimal(act_phy))
     QSettings().setValue('dds_ctrl/phase', act_phy)
 
 
@@ -439,7 +465,9 @@ def apply_btn_ictrl_clicked(ui, dds, model):
     """
     # Update input frequency
     dds.set_ifreq(ui.icontroller_ui.ifreq_dsb.value())
-    if model == "AD9912":
+
+    # Configure System Clock
+    if model == DDS_MODEL.AD9912_FX2 or model == DDS_MODEL.AD9912_STM32:
         # Update PLL attribute
         dds.set_pll_state(ui.icontroller_ui.advanced_config_gbox.isChecked())
         dds.set_pll_doubler_state(
@@ -448,9 +476,25 @@ def apply_btn_ictrl_clicked(ui, dds, model):
             ui.icontroller_ui.pll_factor_sbox.value())
         dds.set_cp_current(ui.icontroller_ui.cp_current_cbox.currentIndex())
         dds.set_vco_range(ui.icontroller_ui.vco_range_cbox.currentIndex())
+    elif model == DDS_MODEL.AD9915:
+        # Update input PLL configuration
+        dds.set_input_doubler_state(ui.icontroller_ui.input_doubler_enable_ckbox.isChecked())
+        dds.set_input_divider_factor(ui.icontroller_ui.input_divider_sbox.value())
+        # Update PLL attribute
+        dds.set_pll_state(ui.icontroller_ui.pll_enable_ckbox.isChecked())
+        dds.set_pll_multiplier_factor(
+            ui.icontroller_ui.pll_multiplier_sbox.value())
+        if ui.icontroller_ui.pll_enable_ckbox.isChecked() is True:
+            if dds.vco_calibration() is False:
+                logging.error("PLL is not locked")
+
+    # Update system clock label after system clock configuration
+    ui.icontroller_ui.sfreq_led.setText(str(dds.get_sysfreq()))
+
     # Force update of output frequency in case of system clock is updated
     # because output is a function of system clock frequency value.
-    ####ofreq_changed(ui, dds)
+    ofreq_changed(ui, dds)
+
     # Save new settings in ini file.
     settings = QSettings()
     settings.setValue('dds_ctrl/ifreq', ui.icontroller_ui.ifreq_dsb.value())
@@ -468,6 +512,7 @@ def apply_btn_ictrl_clicked(ui, dds, model):
                           ui.icontroller_ui.cp_current_cbox.currentIndex())
 
 
+
 # =============================================================================
 def apply_btn_octrl_clicked(ui, dds, model):
     """Define action when apply button of output control form is clicked.
@@ -479,33 +524,49 @@ def apply_btn_octrl_clicked(ui, dds, model):
     ofreq_changed(ui, dds)
     amplitude_changed(ui, dds)
     phase_changed(ui, dds)
-    if model == "AD9912":
+    if model == DDS_MODEL.AD9912_FX2 or model == DDS_MODEL.AD9912_STM32:
         hstl_output_changed(ui, dds)
         hstl_doubler_changed(ui, dds)
         cmos_output_changed(ui, dds)
 
 
+# =============================================================================
+def list_registers(dds: ad9915dev.Ad9915Dev) -> None:
+    for reg_name in ad9915dev.REGNAME2ADDR:
+        reg_address = ad9915dev.REGNAME2ADDR[reg_name]
+        reg_value = dds.get_reg(reg_address)
+        print(f"{reg_name} (0x{reg_address:02X}): {reg_value:04X}")
+
+
 # =============================================================================
 def find_dds_board():
-    """Return list of AD9912 and AD9915 dds development board connected to
+    """Return dictionary of AD9912 and AD9915 dds development board connected to
     computer.
-    :returns: list of AD9912 and AD9915 dds (list of usb.core.Device)
+    :returns: dict of lists of AD9912 and AD9915 dds (list of usb.core.Device)
     """
-    # if firmware of AD9912Dev board is not loaded, display msgbox.
+    # if (FX2) firmware of AD9912Dev board is not loaded, display msgbox.
     if usb.core.find(idVendor=0x0456, idProduct=0xee08) is not None or \
        usb.core.find(idVendor=0x0456, idProduct=0xee24) is not None:
         QMessageBox().warning(None, title="AD9912 detected",
-                              text="AD9912 detected but firmware not loaded")
-    # AD9912 dev board
-    ad9912dev = usb.core.find(idVendor=0x0456, idProduct=0xee09, find_all=True)
+                              text="FX2 interface detected but firmware is not loaded")
+    # AD9912 dev board with FX2 interface (native USB port of eval board)
+    ad9912devFx2 = usb.core.find(idVendor=0x0456, idProduct=0xee09, find_all=True)
+    # AD9912 dev board with STM32 uC interface (external control of eval board)
+    ad9912devStm32 = usb.core.find(idVendor=0x0483, find_all=True)
     # AD9915 dev board (through FTDI UM232H)
     ad9915dev = usb.core.find(idVendor=0x0403, idProduct=0x6014, find_all=True)
-    return {'ad9912dev': ad9912dev, 'ad9915dev': ad9915dev}
+    return {
+        'ad9912devFx2': ad9912devFx2, 
+        'ad9912devStm32': ad9912devStm32, 
+        'ad9915dev': ad9915dev,
+        }
 
 
 # =============================================================================
 def ddscontroller(ini_file, window_title,
-                  dds_model=None, dds_bus=None, dds_address=None):
+                  dds_model=None,
+                  dds_bus=None, dds_address=None,
+                  serial_device=None):
     """Main program of DDS controller project.
     :returns: None
     """
@@ -513,33 +574,64 @@ def ddscontroller(ini_file, window_title,
     app.setOrganizationName(ORGANIZATION)
     app.setApplicationName(APP_NAME)
 
-    if dds_model is None or dds_bus is None or dds_address is None:
+    if dds_model is None or dds_bus is None or dds_address is None or serial_device is None:
         # Select board to handle
         dds_boards = find_dds_board()
-        dds_boards_for_human = \
+        if 'ad9912devStm32' in dds_boards:
+            dds_serial = serial.tools.list_ports.grep("0483*")
+            dds_boards_for_human =  [
+                f"AD9912 with serial ID {dds.device}" for dds in dds_serial
+            ]
+        else:
+            dds_boards_for_human = []
+        dds_boards_for_human += \
             ["AD9912 on bus {} address {}".format(dds.bus, dds.address)
-             for dds in dds_boards['ad9912dev']] + \
+             for dds in dds_boards['ad9912devFx2']] + \
             ["AD9915 on bus {} address {}".format(dds.bus, dds.address)
              for dds in dds_boards['ad9915dev']]
         msg = DdsBoardSelection(dds_boards_for_human)
         retval = msg.exec_()
         if retval == 1:
             dds_item = msg.dds_selected()
-            dds_model = dds_item.split()[0]
-            dds_bus = int(dds_item.split()[3])
-            dds_address = int(dds_item.split()[5])
+            if dds_item.split()[0] == "AD9915":
+                dds_model = DDS_MODEL.AD9915
+                dds_bus = int(dds_item.split()[3])
+                dds_address = int(dds_item.split()[5])
+            elif dds_item.split()[0] == "AD9912Fx2":
+                dds_model = DDS_MODEL.AD9912_FX2
+                dds_bus = int(dds_item.split()[3])
+                dds_address = int(dds_item.split()[5])
+            else:
+                dds_model= DDS_MODEL.AD9912_STM32
+                print(f"dds_item: {dds_item}")
+                serial_device = dds_item.split()[4]
         else:
             sys.exit()
-    if dds_model == "AD9912":
-        dds = sad9912dev.SAd9912Dev()
-        retval = dds.connect(bus=dds_bus, address=dds_address)
+    if dds_model == DDS_MODEL.AD9912_FX2:
+        intf = Fx2Intf(
+            vendor_id=0x0456,
+            product_id=0xee09,
+            bus=dds_bus,
+            address=dds_address)
+        dds = sad9912dev.SAd9912Dev(intf)
+        retval = dds.connect()
         if retval is False:
             logging.critical('DDS connection problem')
             QMessageBox.critical(None, 'DDS connection error',
                                  'DDS connection problem\nCheck connection')
             sys.exit()
-        ui = DdsCtrlUi("ad9912")
-    elif dds_model == "AD9915":
+        ui = DdsCtrlUi(DDS_MODEL.AD9912_FX2, dds)
+    elif dds_model == DDS_MODEL.AD9912_STM32:
+            intf = Stm32Intf(port=serial_device)
+            dds = sad9912dev.SAd9912Dev(intf)
+            retval = dds.connect()
+            if retval is False:
+                logging.critical('DDS connection problem')
+                QMessageBox.critical(None, 'DDS connection error',
+                                     'DDS connection problem\nCheck connection')
+                sys.exit()
+            ui = DdsCtrlUi(DDS_MODEL.AD9912_STM32, dds)
+    elif dds_model == DDS_MODEL.AD9915:
         dds = sad9915dev.SAd9915Dev()
         url = "ftdi://ftdi:232h:{:x}:{:x}/1".format(dds_bus, dds_address)
         retval = dds.connect(url)
@@ -548,8 +640,8 @@ def ddscontroller(ini_file, window_title,
             QMessageBox.critical(None, 'DDS connection error',
                                  'DDS connection problem\nCheck connection')
             sys.exit()
-        dds.set_operation_mode(ad9915dev.OPMODE['modulus'])
-        ui = DdsCtrlUi("ad9915")
+        dds.set_operation_mode(ad9915dev.OPMODE['modulus'])  # Fine output frequency tuning mode 
+        ui = DdsCtrlUi(DDS_MODEL.AD9915, dds)
     else:
         logging.critical('DDS selection problem')
         QMessageBox.critical(None, 'DDS selection error',
@@ -562,7 +654,7 @@ def ddscontroller(ini_file, window_title,
         check_ini_file()
 
     init_dev(dds, dds_model)
-    init_ui(ui, dds_model)
+    init_ui(ui, dds_model, dds)
     handle_ocontroller_ui_behavior(ui, dds, dds_model)
 
     # Logic
@@ -573,7 +665,8 @@ def ddscontroller(ini_file, window_title,
     # # - update dds frequency to current display of output frequency
     # # Choice was taken to used the last behavior.
     dds.ifreq_updated.connect(lambda **kwargs: ofreq_changed(ui, dds))
-    if dds_model == "AD9912":
+    if dds_model == DDS_MODEL.AD9912_FX2 \
+        or dds_model == DDS_MODEL.AD9912_STM32:
         dds.pll_state_updated.connect(
             lambda **kwargs: ofreq_changed(ui, dds))
         dds.pll_doubler_updated.connect(

ddsctrl-0.7.0/ddsctrl/ad9912ui.py

@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+
+"""package ddsctrl
+author    Benoit Dubois
+copyright FEMTO ENGINEERING, 2025
+license   GPL v3.0+
+brief     Specific User Interface for the AD9912 DDS device.
+"""
+
+from PyQt5.QtCore import pyqtSignal, pyqtSlot
+from PyQt5.QtWidgets import QWidget, QLineEdit, QPushButton, QLabel, \
+    QGridLayout, QVBoxLayout, QHBoxLayout, QGroupBox, QDoubleSpinBox, \
+    QCheckBox, QSpinBox, QComboBox
+
+import ddsctrl.constants as cst
+
+
+#==============================================================================
+class InControllerUi(QWidget):
+    """Controller UI form used to manage DDS input.
+    """
+
+    sys_clock_changed = pyqtSignal(float)
+
+    # def __init__(self, device):
+    def __init__(self):
+        """Initialization.
+        """
+        super().__init__()
+        # self._dev = device
+        self.ifreq_dsb = QDoubleSpinBox()
+        self.sfreq_led = QLineEdit()
+        self.sfreq_led.setReadOnly(True)
+        self.apply_btn = QPushButton("&Apply")
+        self.advanced_config_gbox = self._system_clock_frequency_config_gbox()
+        ifreq_layout = QVBoxLayout()
+        ifreq_layout.addWidget(QLabel("Input clock frequency (Hz)"))
+        ifreq_layout.addWidget(self.ifreq_dsb)
+        ifreq_layout.addWidget(QLabel("System clock frequency (Hz)"))
+        ifreq_layout.addWidget(self.sfreq_led)
+        ifreq_layout.addWidget(self.advanced_config_gbox)
+        ifreq_layout.addStretch(1)
+        ifreq_layout.addWidget(self.apply_btn)
+        self.setLayout(ifreq_layout)
+        # Device update
+        # self.advanced_config_gbox.toggled.connect(self._dev.set_pll_state)
+        # self.pll_doubler_ckbox.toggled.connect(self._dev.set_pll_doubler_state)
+        # self.pll_factor_sbox.valueChanged.connect(self._dev.set_pll_multiplier_factor)
+        # System clock display update
+        self.advanced_config_gbox.toggled.connect(self.update_sys_clock_label)
+        self.pll_doubler_ckbox.toggled.connect(self.update_sys_clock_label)
+        self.pll_factor_sbox.valueChanged.connect(self.update_sys_clock_label)
+        # UI enable/disable parts
+
+        self.apply_btn.released.connect(self.update_sys_clock_label)
+        self._init_ui()
+
+    @pyqtSlot(float)
+    def set_ifmax(self, value):
+        """Define maximum frequency handled by widget.
+        :param value: New maximal value of parameter (float)
+        :returns: None
+        """
+        self.ifreq_dsb.setMaximum(value)
+
+    def _system_clock_frequency_config_gbox(self):
+        """Create groupbox for system clock configuration.
+        :returns: the system frequency configuration groupbox (QGroupBox)
+        """
+        self.pll_doubler_ckbox = QCheckBox("Enable input frequency doubler")
+        self.pll_factor_sbox = QSpinBox()
+        self.pll_factor_sbox.setRange(4, 66)
+        self.pll_factor_sbox.setSingleStep(2)
+        self.vco_range_cbox = QComboBox()
+        self.cp_current_cbox = QComboBox()
+        group_box = QGroupBox("Enable System Clock PLL")
+        group_box.setCheckable(True)
+        group_box.setChecked(False)
+        advanced_layout = QVBoxLayout()
+        advanced_layout.addWidget(QLabel("Input PLL doubler"))
+        advanced_layout.addWidget(self.pll_doubler_ckbox)
+        advanced_layout.addWidget(QLabel("PLL multiplier"))
+        advanced_layout.addWidget(self.pll_factor_sbox)
+        advanced_layout.addWidget(QLabel("VCO range"))
+        advanced_layout.addWidget(self.vco_range_cbox)
+        advanced_layout.addWidget(QLabel("Charge pump current"))
+        advanced_layout.addWidget(self.cp_current_cbox)
+        group_box.setLayout(advanced_layout)
+        return group_box
+
+    def _init_ui(self):
+        """Init UI.
+        :returns: None
+        """
+        for k, val in cst.AD9912_VCO_RANGE.items():
+            self.vco_range_cbox.insertItem(k, val)
+        for k, val in cst.AD9912_CP_CURRENT.items():
+            self.cp_current_cbox.insertItem(k, val)
+        self.update_sys_clock_label()
+
+    @pyqtSlot()
+    def update_sys_clock_label(self):
+        """Procedure when system clock is modified.
+        :returns: None
+        """
+        if self.advanced_config_gbox.isChecked() is True:
+            if self.pll_doubler_ckbox.isChecked() is True:
+                doubler = 2.0
+            else:
+                doubler = 1.0
+            ifreq = self.ifreq_dsb.value()
+            factor = self.pll_factor_sbox.value()
+            sfreq_value = ifreq * doubler * factor
+        else:
+            sfreq_value = self.ifreq_dsb.value()
+        self.sys_clock_changed.emit(sfreq_value)
+        self.sfreq_led.setText(str(sfreq_value))
+
+    # @pyqtSlot()
+    # def update_sys_clock_label(self, value):
+    #     """Procedure when system clock is modified.
+    #     :returns: None
+    #     """
+    #     self.sfreq_led.setText(str(value))
+        # self.sfreq_led.setText(str(self._dev.get_sysfreq()))
+
+
+#==============================================================================
+class OutControllerUi(QWidget):
+    """Controller UI form used to control DDS device.
+    """
+
+    def __init__(self, device, ofmax=400000000.0, amax=1023):
+        """The constructor.
+        """
+        super().__init__()
+        self.auto_update_ckbox = QCheckBox("Automatic update")
+        ofreq_lab = QLabel("Output frequency (Hz)")
+        self.ofreq_tuning = QDoubleSpinBox()
+        self.ofreq_tuning.setDecimals(10)
+        self.ofreq_tuning.setRange(0.0, ofmax)
+        ofreq_layout = QVBoxLayout()
+        ofreq_layout.addWidget(ofreq_lab)
+        ofreq_layout.addWidget(self.ofreq_tuning)
+        ofreq_layout.addStretch(1)
+        phy_lab = QLabel("Output phase (deg.)")
+        self.phy_tuning = QDoubleSpinBox()
+        self.phy_tuning.setRange(0.0, 359.9)
+        self.phy_tuning.setDecimals(2)
+        self.phy_tuning.setSingleStep(1.0)
+        phy_layout = QVBoxLayout()
+        phy_layout.addWidget(phy_lab)
+        phy_layout.addWidget(self.phy_tuning)
+        phy_layout.addStretch(1)
+        amp_lab = QLabel("Output amplitude (a.u.)")
+        self.amp_tuning = QDoubleSpinBox()
+        self.amp_tuning.setRange(0, amax)
+        self.amp_tuning.setDecimals(0)
+        self.amp_tuning.setSingleStep(1)
+        amp_layout = QVBoxLayout()
+        amp_layout.addWidget(amp_lab)
+        amp_layout.addWidget(self.amp_tuning)
+        amp_layout.addStretch(1)
+        ctrl_layout = QHBoxLayout()
+        ctrl_layout.addLayout(ofreq_layout)
+        ctrl_layout.addLayout(phy_layout)
+        ctrl_layout.addLayout(amp_layout)
+        self.out_hstl_ckbox = QCheckBox("Enable HSTL output")
+        self.out_cmos_ckbox = QCheckBox("Enable CMOS output")
+        self.hstl_doubler_ckbox = QCheckBox("Enable HSTL frequency doubler")
+        ##self.out_cmos_div_sbox = QSpinBox()
+        ##self.out_cmos_div_sbox.setRange(1, 65535)
+        out_layout = QGridLayout()
+        out_layout.addWidget(self.out_hstl_ckbox, 0, 0)
+        out_layout.addWidget(self.out_cmos_ckbox, 1, 0)
+        out_layout.addWidget(self.hstl_doubler_ckbox, 2, 0)
+        ##out_layout.addWidget(self.out_cmos_div_sbox, 3, 0)
+        ##out_layout.addWidget(QLabel("CMOS output divider factor"), 3, 1)
+        self.apply_btn = QPushButton("&Apply")
+        btn_layout = QHBoxLayout()
+        btn_layout.addWidget(self.apply_btn)
+        self._layout = QVBoxLayout()
+        self._layout.addWidget(self.auto_update_ckbox)
+        self._layout.addLayout(ctrl_layout)
+        self._layout.addLayout(out_layout)
+        self._layout.addStretch(1)
+        self._layout.addLayout(btn_layout)
+        self.setLayout(self._layout)
+        # Set state of CMOS divider with respect to CMOS output state
+        ##self.out_cmos_ckbox.toggled.connect(self.out_cmos_div_sbox.setEnabled)
+        ##self.out_cmos_div_sbox.setEnabled(False)
+        # Set state of HSTL doubler with respect to HSTL output state
+        self.out_hstl_ckbox.toggled.connect(self.hstl_doubler_ckbox.setEnabled)
+        self.hstl_doubler_ckbox.setEnabled(False)
+        # Handle apply button state in respect with auto update checkbox
+        self.auto_update_ckbox.stateChanged.connect(self.apply_btn.setDisabled)
+
+    @pyqtSlot(float)
+    def set_ofmax(self, value):
+        """Define maximum frequency handled by widget.
+        :param value: New maximal value of parameter (float)
+        :returns: None
+        """
+        self.ofreq_tuning.setMaximum(value)
+
+    @pyqtSlot(int)
+    def set_amax(self, value):
+        """Define maximum amplitude handled by widget.
+        :param value: New maximal value of parameter (float)
+        :returns: None
+        """
+        self.amp_tuning.setMaximum(value)
+
+
+
+#==============================================================================
+if __name__ == '__main__':
+    import sys
+    from PyQt5.QtWidgets import QApplication
+    import ad9xdds.dds_emul as dds_emul
+
+    APP = QApplication(sys.argv)
+    UI = InControllerUi(dds_emul.Ad9912Emul())
+    UI.show()
+    sys.exit(APP.exec_())