Source Code for Demo FlexRay Config Decoder Filter

Location

./src/examples/src/flexray_config_decoder/

This example shows:

• howto implement a basic decoder filter
• howto configure a basic decoder 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 decoder FlexRay samples
• howto use the SampleCodecFactory to access DDL elements directly by its name index

Header file for the FlexRay Config Decoder Filter Example

 
#pragma once
 
#include <adtf_filtersdk.h>
#include <adtf_ucom3.h>
#include <adtf_mediadescription.h>
 
#include <sdk/flexray_coder_intf.h>
#include <sdk/flexray_support_srv_intf.h>
 
#include "fc_decoder.h"
 
//*************************************************************************************************
#define CID_DEMO_FLEXRAY_DECODER_FILTER "demo_flexray_decoder.filter.devicetb.cid"
 
 
class cFlexRay2DDLFilter : public adtf::filter::cFilter
{
public:
    ADTF_CLASS_ID_NAME(cFlexRay2DDLFilter, CID_DEMO_FLEXRAY_DECODER_FILTER, "Demo FlexRay Config Decoder");
    ADTF_CLASS_DEPENDENCIES(REQUIRE_INTERFACE(adtf::services::IReferenceClock),
                            REQUIRE_INTERFACE(adtf::devicetb::sdk::flexray::IFlexRaySupport));
 
    cFlexRay2DDLFilter();
    tResult Init(adtf::filter::cFilter::tInitStage eStage) override;
    tResult ProcessInput(adtf::streaming::ISampleReader* pReader,
        const adtf::ucom::iobject_ptr<const adtf::streaming::ISample>& pSample) override;
 
private:
    adtf::streaming::ISampleWriter* m_pWriter = nullptr;
 
    // properties
    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::IFlexRayDatabase> m_pFlexRayDatabase;
    adtf::ucom::object_ptr<adtf::devicetb::sdk::flexray::IFlexRayCoder> m_pFlexRayCoder;
};

Implementation for the FlexRay Config Decoder Filter Example

 
#include "demo_flexray_decoder.h"
 
#include <sdk/stream_meta_type_flexray.h>
#include <sdk/flexray_types.h>
#include <sdk/flexray_database_intf.h>
#include <cstring>
#include <string>
#include <map>
 
using namespace adtf;
using namespace adtf::devicetb::sdk::flexray;
 
ADTF_PLUGIN_VERSION("Demo FlexRay Decoder",
    devicetb,
    DEVICETB_VERSION_MAJOR,
    DEVICETB_VERSION_MINOR,
    DEVICETB_VERSION_PATCH,
    cFlexRay2DDLFilter)
 
 
cFlexRay2DDLFilter::cFlexRay2DDLFilter()
{
    CreateInputPin("input_flexray", stream_meta_type_flexray());
    SetDescription("input_flexray", "The FlexRay sample stream to decode.");
 
    m_pWriter = CreateOutputPin("output_ddl", mediadescription::description<output_ddl>());
    SetDescription("output_ddl", "The decoded content of the CAN 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_MAX);
    RegisterPropertyVariable("ChannelID", m_nChannelID);
 
    SetDescription("Demo filter for decoding FlexRay samples into previous specified signals.");
    SetHelpLink("$(ADTF_DEVICE_TOOLBOX_DIR)/doc/adtf_device_toolbox_html/page_example_source_flexray_config_decoder.html");
}
 
tResult cFlexRay2DDLFilter::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<tDeviceChannel>(m_nChannelID), m_pFlexRayDatabase));
        RETURN_IF_FAILED(m_pFlexRaySupport->CreateCoder(m_pFlexRayDatabase, m_pFlexRayCoder));
    }
    RETURN_NOERROR;
}
 
tResult cFlexRay2DDLFilter::ProcessInput(streaming::ISampleReader* /*pReader*/,
    const ucom::iobject_ptr<const streaming::ISample>& pSample)
{
    ucom::object_ptr_shared_locked<const streaming::ISampleBuffer> pSampleBuffer;
    RETURN_IF_FAILED(pSample->Lock(pSampleBuffer));
 
    streaming::output_sample_data<output_ddl> oDDLOutput(pSample->GetTime());
 
    // Initialize FlexRay Coder
    RETURN_IF_FAILED(m_pFlexRayCoder->ReceiveData(pSampleBuffer->GetPtr(), static_cast<tInt>(pSampleBuffer->GetSize()), pSample->GetTime()));
 
    tPDUID nPDUID = static_cast<tPDUID>(IFlexRayCoder::ENUM_PDU_START);
    tChannelID nChannel = 0;
    tECUID nECUID = 0;
    tTimeStamp tmTimeStamp = 0;
    // Decode the sample via the coder
    while (IS_OK(m_pFlexRayCoder->EnumPDUs(&nPDUID, &nChannel, &nECUID, &tmTimeStamp, tTrue)))
    {
        const tPDUInfo* pPduInfo = nullptr;
        RETURN_IF_FAILED(m_pFlexRayDatabase->GetPDUInfo(nPDUID, &pPduInfo));
 
        for (tUInt32 nSigIdx = 0; nSigIdx < pPduInfo->nSignalCount; nSigIdx++)
        {
            tSignalID nSignalID = pPduInfo->aSignalID[nSigIdx];
            const tChar* pstrSignalName = nullptr;
            RETURN_IF_FAILED(m_pFlexRayDatabase->GetSignalName(nSignalID, &pstrSignalName));
            tSignalValue oSignalValue;
            RETURN_IF_FAILED(m_pFlexRayCoder->GetSignalValue(nSignalID, &oSignalValue));
 
            switch (nSignalID)
            {
            case 2: oDDLOutput->Signal_3 = static_cast<tInt8>(oSignalValue.nf64Value); break;
            case 3: oDDLOutput->Signal_4 = static_cast<tInt8>(oSignalValue.nf64Value); break;
            case 4: oDDLOutput->Signal_5 = static_cast<tInt8>(oSignalValue.nf64Value); break;
            default: break;
            }
        }
    }
 
    m_pFlexRayCoder->ResetModifiedFlag();
 
    m_pWriter->Write(oDDLOutput.Release());
 
    RETURN_NOERROR;
}