Source Code for Demo FlexRay Config Encoder Filter

Location

./src/examples/src/flexray_config_encoder/

This example shows:

• howto implement a basic encoder filter
• howto configure a basic encoder filter including its input and output pins
• howto use the adtf::devicetb::sdk::flexray::IFlexRaySupport interface to work with a FlexRay database
• howto use the adtf::devicetb::sdk::flexray::IFlexRayCoder interface to encoder FlexRay samples
• howto use the cSampleDecoder to access DDL elements directly by its name index (for more information take a look into the ADTF documentation)
• howto create a streamtype from your defined struct
• howto handle the new filtersdk, introduced in ADTF 3.5.0

Header file for the FlexRay Config Encoder Filter Example

 
#pragma once
 
#include <adtf_filtersdk.h>
#include <adtf_base.h>
#include <a_utils.h>
#include <adtf_ucom3.h>
#include <adtf_streaming3.h>
 
#include <sdk/flexray_support_srv_intf.h>
#include <sdk/flexray_coder_intf.h>
#include <sdk/flexray_database_intf.h>
 
#include "fc_encoder.h"
 
//*************************************************************************************************
#define CID_DEMO_FLEXRAY_ENCODER_FILTER "demo_flexray_encoder.filter.devicetb.cid"
 
 
class cDDL2FlexRayFilter : public  adtf::filter::cFilter
{
public:
    ADTF_CLASS_ID_NAME(cDDL2FlexRayFilter, CID_DEMO_FLEXRAY_ENCODER_FILTER, "Demo FlexRay Config Encoder");
    ADTF_CLASS_DEPENDENCIES(REQUIRE_INTERFACE(adtf::services::IReferenceClock),
                            REQUIRE_INTERFACE(adtf::devicetb::sdk::flexray::IFlexRaySupport));
 
    cDDL2FlexRayFilter();
 
    tResult Init(adtf::filter::cFilter::tInitStage eStage) override;
    tResult AcceptType(adtf::streaming::ISampleReader* pReader,
        const adtf::ucom::iobject_ptr<const adtf::streaming::IStreamType>& pType) override;
    tResult ProcessInput(adtf::streaming::ISampleReader* pReader,
        const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) override;
 
private:
    adtf::streaming::ISampleWriter* m_pWriter;
 
    adtf::base::property_variable<tUInt> m_nChannelID = 1;
 
    adtf::ucom::object_ptr<adtf::devicetb::sdk::flexray::IFlexRaySupport>  m_pFlexRaySupport;
    adtf::ucom::object_ptr<adtf::devicetb::sdk::flexray::IFlexRayCoder>    m_pFlexRayCoder;
    adtf::ucom::object_ptr<adtf::devicetb::sdk::flexray::IFlexRayDatabase> m_pFlexRayDatabase;
 
    adtf::mediadescription::md_sample_data_factory<input_ddl> m_oSampleDataFactory;
};

Implementation for the FlexRay Config Encoder Filter Example

 
#include "demo_flexray_encoder.h"
 
#include <sdk/stream_meta_type_flexray.h>
#include <sdk/flexray_frame.h>
#include <adtf_mediadescription.h>
#include <cstring>
#include <string>
 
using namespace adtf;
 
ADTF_PLUGIN_VERSION("Demo FlexRay Encoder", 
    devicetb,
    DEVICETB_VERSION_MAJOR,
    DEVICETB_VERSION_MINOR,
    DEVICETB_VERSION_PATCH,
    cDDL2FlexRayFilter)
 
cDDL2FlexRayFilter::cDDL2FlexRayFilter()
{
    CreateInputPin("input_ddl", mediadescription::description<input_ddl>());
    SetDescription("input_ddl", "The incoming FlexRay content to encode.");
 
    m_pWriter = CreateOutputPin("output_flexray", devicetb::sdk::flexray::stream_meta_type_flexray());
    SetDescription("output_flexray", "The encoded FlexRay sample stream.");
 
    m_nChannelID.SetDescription("Channel-ID for the desired FlexRay database, made available by FlexRay service");
    m_nChannelID.SetValidRange(FLEXRAY_DEVICECHANNEL_MIN, FLEXRAY_DEVICECHANNEL_MIN);
    RegisterPropertyVariable("ChannelID", m_nChannelID);
 
    SetDescription("Use this filter to encode FlexRay data for specific signals.");
    SetHelpLink("$(ADTF_DEVICE_TOOLBOX_DIR)/doc/adtf_device_toolbox_html/page_example_source_flexray_config_encoder.html");
}
 
tResult cDDL2FlexRayFilter::Init(filter::cFilter::tInitStage eStage)
{
    if (filter::cFilter::tInitStage::StageNormal == eStage)
    {
        RETURN_IF_FAILED(_runtime->GetObject(m_pFlexRaySupport));
        RETURN_IF_FAILED(m_pFlexRaySupport->GetDatabase(static_cast<devicetb::sdk::flexray::tChannelID>(*m_nChannelID), m_pFlexRayDatabase));
        RETURN_IF_FAILED(m_pFlexRaySupport->CreateCoder(m_pFlexRayDatabase, m_pFlexRayCoder));
    }
 
    RETURN_NOERROR;
}
 
tResult cDDL2FlexRayFilter::AcceptType(streaming::ISampleReader* /*pReader*/,
    const ucom::iobject_ptr<const streaming::IStreamType>& pType)
{
    // Here we update our factory each time we receive a new stream type.
    // This will throw an error if the stream type is not compatible.
    m_oSampleDataFactory = mediadescription::md_sample_data_factory<input_ddl>(pType);
 
    RETURN_NOERROR;
}
 
tResult cDDL2FlexRayFilter::ProcessInput(streaming::ISampleReader* /*pReader*/,
    const ucom::iobject_ptr<const streaming::ISample>& pSample)
{
    auto oSampleData = m_oSampleDataFactory.Make(pSample);
 
    devicetb::sdk::flexray::tSignalValue oValue;
    devicetb::sdk::flexray::tSignalID oSignalId = 0;
 
    // write signal values for PDU
    RETURN_IF_FAILED(m_pFlexRayDatabase->GetSignalID("Signal_3", &oSignalId));
    oValue.nf64Value = oSampleData.Signal_3();
    RETURN_IF_FAILED(m_pFlexRayCoder->SetSignalValue(oSignalId, &oValue));
 
    RETURN_IF_FAILED(m_pFlexRayDatabase->GetSignalID("Signal_4", &oSignalId));
    oValue.nf64Value = oSampleData.Signal_4();
    RETURN_IF_FAILED(m_pFlexRayCoder->SetSignalValue(oSignalId, &oValue));
 
    RETURN_IF_FAILED(m_pFlexRayDatabase->GetSignalID("Signal_5", &oSignalId));
    oValue.nf64Value = oSampleData.Signal_5();
    RETURN_IF_FAILED(m_pFlexRayCoder->SetSignalValue(oSignalId, &oValue));
 
    // determine the required sample size
    tInt nSampleSize = 0;
    RETURN_IF_FAILED(m_pFlexRayCoder->TransmitData(nullptr, &nSampleSize));
 
    // create sample
    ucom::object_ptr<streaming::ISample> pOutputSample;
    ucom::object_ptr_locked<streaming::ISampleBuffer> pBuffer;
    RETURN_IF_FAILED(alloc_sample(pOutputSample, pSample->GetTime()));
    RETURN_IF_FAILED(pOutputSample->WriteLock(pBuffer, nSampleSize));
 
    RETURN_IF_FAILED(m_pFlexRayCoder->TransmitData(pBuffer->GetPtr(), &nSampleSize));
 
    pBuffer->Unlock();
    m_pFlexRayCoder->ResetData();
 
    m_pWriter->Write(pOutputSample);
 
    RETURN_NOERROR;
}