Source Code for Demo Signal Generator Plugin

Location

./src/examples/src/adtf/filters/standard_filters/signal_generator/

Build Environment

To see how to set up the build environment have a look at ADTF CMake Environment

this implementation shows:

• how to create a time triggered Filter.
• how to generate and provide signals as a adtf::services::ant::ISignalRegistry::ISignalProvider

Header

 
#pragma once
 
#include <adtffiltersdk/filter.h>
#include <plugins/signal_registry_intf.h>
 
#include <unordered_set>
#include <mutex>
 
//*************************************************************************************************
#define CID_DEMO_SIGNAL_PROVIDER_FILTER "demo_signal_provider.filter.adtf.cid"
 
using namespace adtf::util;
using namespace adtf::ucom;
using namespace adtf::base;
using namespace adtf::streaming;
using namespace adtf::filter;
using namespace adtf::services;
 
class cCounterGenerator final : public cFilter,
                         public ISignalRegistry::ISignalProvider::IEnabledSignals
{
    public:
        ADTF_CLASS_ID_NAME(cCounterGenerator,
                           "demo_signal_provider.filter.adtf.cid",
                           "Demo Signal Generator");
 
        ADTF_CLASS_DEPENDENCIES(
            REQUIRE_INTERFACE(adtf::services::ISignalRegistry)
        );
 
        cCounterGenerator();
 
        virtual tResult Init(tInitStage eStage) override;
 
        virtual tResult EnableSignal(ISignalRegistry::tSignalID nSignalID) override;
 
        virtual tResult DisableSignal(ISignalRegistry::tSignalID nSignalID) override;
 
        tResult Process(tNanoSeconds tmTimeOfTrigger,
                        IRunner* pRunner) override;
 
    private:
        uint64_t m_nCounter = 0;
        ISignalRegistry::tSignalID m_nCounterID = 0;
 
        std::mutex m_oEnabledSignalsMutex;
        std::unordered_set<ISignalRegistry::tSignalID> m_oEnabledSignals;
 
        // Reference to the provider must the *first* member to be destroyed.
        // All methods from ISignalRegistry::ISignalProvider::IEnabledSignals can be called until destruction is complete!
        object_ptr<ISignalRegistry::ISignalProvider> m_pProvider;
};

Implementation

 
#include "demo_signal_generator.h"
 
ADTF_PLUGIN("Demo Signal Generator Plugin", cCounterGenerator);
 
cCounterGenerator::cCounterGenerator()
{
    CreateRunner("trigger", cTimerTriggerHint(std::chrono::seconds{1}));
    SetDescription("trigger", "Runner to periodically trigger the function which increases the signal value");
 
    // sets a short description for the component
    SetDescription("Use this filter to provide monotonically increasing values for Signal Registry.");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    SetHelpLink("$(ADTF_DIR)/doc/adtf_html/page_demo_signal_generator.html");
}
 
tResult cCounterGenerator::Init(tInitStage eStage)
{
    RETURN_IF_FAILED(cFilter::Init(eStage));
 
    if (eStage == StageNormal)
    {
        // get a hold of the signal registry service
        object_ptr<ISignalRegistry> pRegistry;
        RETURN_IF_FAILED(_runtime->GetObject(pRegistry));
 
        // create a new provider that we can add signals to
        RETURN_IF_FAILED(pRegistry->CreateProvider(get_named_graph_object_full_name(*this),
                                                   m_pProvider));
 
        // add our counter signal.
        RETURN_IF_FAILED(m_pProvider->AddSignal({m_nCounterID, "counter", "calls", "counter that increases monotonically", 0, 0}, this));
    }
 
    RETURN_NOERROR;
}
 
tResult cCounterGenerator::EnableSignal(ISignalRegistry::tSignalID nSignalID)
{
    // this is called when the first listener is interested in our signal.
    std::lock_guard<std::mutex> oGuard(m_oEnabledSignalsMutex);
    m_oEnabledSignals.insert(nSignalID);
 
    RETURN_NOERROR;
}
 
tResult cCounterGenerator::DisableSignal(ISignalRegistry::tSignalID nSignalID)
{
    // this is called when there is no longer a listener that is interested in our signal.
    std::lock_guard<std::mutex> oGuard(m_oEnabledSignalsMutex);
    m_oEnabledSignals.erase(nSignalID);
 
    RETURN_NOERROR;
}
 
tResult cCounterGenerator::Process(tNanoSeconds tmTimeOfTrigger,
                                   IRunner* /*pRunner*/)
{
    ++m_nCounter;
 
    std::lock_guard<std::mutex> oGuard(m_oEnabledSignalsMutex);
    if (m_oEnabledSignals.count(m_nCounterID))
    {
        // if enabled, update our signal value
        m_pProvider->UpdateSignal(m_nCounterID, {tmTimeOfTrigger, static_cast<double>(m_nCounter)});
    }
 
    RETURN_NOERROR;
}