Example Qt5 Logic Generator

Table of Contents

• Description
• Prebuilt Binaries
• Source Code
  • UI Filter

Description

Shows how to create an configurable UI to create logical values for sample data.

Prebuilt Binaries

• Qt5 Logic Generator

Source Code

./examples/demo_adtfplugins/qt5_logic_generator/

UI Filter

logic_generator_filter.h

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
 
#pragma once
 
#include <adtffiltersdk/adtf_filtersdk.h>
#include <adtffiltersdk/graph_object.h>
#include <adtffiltersdk/runner_fallback.h>
#include <adtfui/adtf_ui.h>
 
#include <QWidget>
 
#include <mutex>
 
class cLogicGeneratorWidget;
 
struct cLogicGeneratorParameters
{
    std::mutex m_oMutex;
 
    enum class eSignalType
    {
        Rectangle,
        Triangle,
        Sine
    };
    uint64_t m_nFrequency = 2;
    double m_fAmplitude = 1.0;
    double m_fOffset = 0.0;
    eSignalType m_tSignalType = eSignalType::Rectangle;
};
 
Q_DECLARE_METATYPE(cLogicGeneratorParameters::eSignalType)
 
#ifndef ADTF_EXAMPLES_CID
    #define ADTF_EXAMPLES_CID ".local.cid"
#endif
 
class cQtLogicGeneratorFilter : public adtf::ui::cQtUIFilter
{
public:
    ADTF_CLASS_ID_NAME(cQtLogicGeneratorFilter,
                       "qt_logic_generator.ui_filter" ADTF_EXAMPLES_CID,
                       "Qt5 Logic Generator");
 
    ADTF_CLASS_DEPENDENCIES(REQUIRE_INTERFACE(adtf::ui::IQtXSystem));
 
public:
    cQtLogicGeneratorFilter();
    ~cQtLogicGeneratorFilter() override;
 
    tResult Init(tInitStage eStage) override;
 
    tResult Start() override;
    tResult Stop() override;
 
    QWidget* CreateView() override;
    void ReleaseView() override;
 
private:
    void CreateSample(adtf::base::tNanoSeconds tmSampleTimeStampNs);
 
    adtf::streaming::ISampleWriter* m_pWriter = nullptr;
 
    adtf::ucom::object_ptr<adtf::services::IReferenceClock> m_pClock;
    adtf::filter::cRunnerFallback m_oTimer;
 
    cLogicGeneratorWidget* m_pLogicGeneratorWidget = nullptr;
    cLogicGeneratorParameters m_oParameters;
 
    adtf::base::tNanoSeconds m_tmStart;
};

logic_generator_filter.cpp

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
 
#include "logic_generator_filter.h"
 
#include "logic_generator_widget.h"
 
#define _USE_MATH_DEFINES
#include <math.h>
 
#include <QButtonGroup>
#include <QGroupBox>
#include <QRadioButton>
#include <QTimer>
#include <QLabel>
#include <QLineEdit>
 
#ifdef GetObject
    #undef GetObject
#endif
 
// cQtLogicGeneratorFilter
 
ADTF_PLUGIN("Qt5 Logic Generator Plugin", cQtLogicGeneratorFilter)
 
static const tTimeStamp tmDefaultPeriod = 10000;
 
cQtLogicGeneratorFilter::cQtLogicGeneratorFilter()
{
    // sets a short description for the component
    SetDescription("Use this UI filter to generate logical values for sample data.");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    SetHelpLink("$(ADTF_QT5_DIR)/doc/html/page_qt5_logic_generator.html");
 
    m_pWriter = CreateOutputPin("logic_value", adtf::streaming::stream_type_plain<float>());
    SetDescription("logic_value", "output pin for generated logic value");
 
    m_oTimer = adtf::filter::cRunnerFallback(this, "generate", cTimerTriggerHint(tmDefaultPeriod),
                                             [this]() { CreateSample(m_pClock->GetStreamTimeNs()); });
    SetDescription("generate", "Connect a timer runner which triggers the data generation.");
}
 
cQtLogicGeneratorFilter::~cQtLogicGeneratorFilter() = default;
 
tResult cQtLogicGeneratorFilter::Init(tInitStage eStage)
{
    RETURN_IF_FAILED(adtf::ui::cQtUIFilter::Init(eStage))
    if (eStage == StagePostConnect)
    {
        RETURN_IF_FAILED(_runtime->GetObject(m_pClock))
    }
    RETURN_NOERROR;
}
 
tResult cQtLogicGeneratorFilter::Start()
{
    RETURN_IF_FAILED(adtf::ui::cQtUIFilter::Start());
 
    m_tmStart = m_pClock->GetStreamTimeNs();
    RETURN_IF_FAILED(m_oTimer.Activate(tmDefaultPeriod));
    RETURN_NOERROR;
}
 
tResult cQtLogicGeneratorFilter::Stop()
{
    m_oTimer.Deactivate();
    return adtf::ui::cQtUIFilter::Stop();
}
 
QWidget* cQtLogicGeneratorFilter::CreateView()
{
    m_pLogicGeneratorWidget = new cLogicGeneratorWidget(m_oParameters);
    m_pLogicGeneratorWidget->setObjectName("qt_logic_generator_widget");
    return m_pLogicGeneratorWidget;
}
 
void cQtLogicGeneratorFilter::ReleaseView()
{
    delete m_pLogicGeneratorWidget;
    m_pLogicGeneratorWidget = nullptr;
}
 
void cQtLogicGeneratorFilter::CreateSample(adtf::base::tNanoSeconds tmSampleTimeStampNs)
{
    float fValue{};
    const auto tmRelativeTimeStampMicroseconds =
        std::chrono::duration_cast<std::chrono::microseconds>(
            adtf::base::duration_cast<std::chrono::nanoseconds>(tmSampleTimeStampNs - m_tmStart))
            .count();
 
    {
        std::scoped_lock oGuard(m_oParameters.m_oMutex);
 
        const float nPeriodDurationMicroseconds = 1.0f / m_oParameters.m_nFrequency * 1'000'000.0f;
        switch (m_oParameters.m_tSignalType)
        {
            case cLogicGeneratorParameters::eSignalType::Rectangle:
            {
                const float nHalfPeriodDurationMicroseconds = nPeriodDurationMicroseconds / 2.0f;
                fValue = std::fmod(m_oParameters.m_fOffset + tmRelativeTimeStampMicroseconds,
                                   nPeriodDurationMicroseconds) <= nHalfPeriodDurationMicroseconds ?
                             m_oParameters.m_fAmplitude :
                             0.0f;
                break;
            }
            case cLogicGeneratorParameters::eSignalType::Triangle:
            {
                fValue =
                    m_oParameters.m_fAmplitude *
                    std::fmod(m_oParameters.m_fOffset + tmRelativeTimeStampMicroseconds, nPeriodDurationMicroseconds) /
                    nPeriodDurationMicroseconds;
                break;
            }
            case cLogicGeneratorParameters::eSignalType::Sine:
            {
                fValue =
                    m_oParameters.m_fAmplitude * std::sin(2.0 * M_PI / nPeriodDurationMicroseconds *
                                                          (m_oParameters.m_fOffset + tmRelativeTimeStampMicroseconds));
                break;
            }
        }
    }
 
    adtf::streaming::output_sample_data<float> oSample(tmSampleTimeStampNs, fValue, 0);
    m_pWriter->Write(oSample.Release());
    m_pWriter->ManualTrigger(tmSampleTimeStampNs);
}