Source Code for Demo CAN Custom Parser

Location

./src/examples/src/can_parser/

Take a further look at

• Custom Bus-Database Parser SDK
• adtf::devicetb::sdk::IBusDatabaseLoader
• adtf::devicetb::sdk::can::ICANDatabase

Header for the DB

 
#pragma once
 
#include <adtf_devicetb_sdk.h>
#include "adtf_ucom3.h"
#include <unordered_map>
#include <vector>
 
using adtf::devicetb::sdk::can::axle::tMessageID;
using adtf::devicetb::sdk::can::axle::tMessageInfo;
using adtf::devicetb::sdk::can::axle::tSignalID;
using adtf::devicetb::sdk::can::axle::tSignalInfo;
 
class CANDb_MOCK : public adtf::ucom::catwo::object<adtf::devicetb::sdk::can::axle::ICANDatabase>
{
private:
    std::unordered_map<adtf::devicetb::sdk::can::axle::tMessageID, const tChar*> mapMessages{ {0x100,"ESP"},{0x30B,"Kombi"} };
    std::vector<const tChar*> setSignals{ "ESP_v_Signal","KBI_angez_Geschw" };
    std::vector<const tChar*> setNetworkNodes{ "example_can" };
    std::vector<const tChar*> setNetworkNames{ "example_can" };
 
public:
    // Inherited via ICANDatabase
    virtual tResult GetMessageCount(tUInt32 * pnMessageCount) const override;
    virtual tResult GetMessageID(const tChar * strMessageName, 
                                 adtf::devicetb::sdk::can::axle::tMessageID * pnMessageID, 
                                 tBool * pbExtended) const override;
    virtual tResult GetMessageName(adtf::devicetb::sdk::can::axle::tMessageID nMessageID, 
                                   tBool bExtended, 
                                   const tChar ** pMessageName) const override;
    virtual tResult GetMessageInfo(adtf::devicetb::sdk::can::axle::tMessageID nMessageID, 
                                   tBool bExtended, 
                                   const adtf::devicetb::sdk::can::axle::tMessageInfo ** pMessageInfo) const override;
    virtual tResult GetSignalCount(tUInt32 * pnSignalCount) const override;
    virtual tResult GetSignalID(const tChar* strSignalName, adtf::devicetb::sdk::can::axle::tSignalID* pnSignalID) const override;
    virtual tResult GetSignalName(adtf::devicetb::sdk::can::axle::tSignalID nSignalID, const tChar** pSignalName) const override;
    virtual tResult GetSignalUnit(adtf::devicetb::sdk::can::axle::tSignalID nSignalID, const tChar** pSignalUnit) const override;
    virtual tResult GetSignalDescription(adtf::devicetb::sdk::can::axle::tSignalID nSignalID, const tChar** pSignalDescription) const override;
    virtual tResult GetSignalInfo(adtf::devicetb::sdk::can::axle::tSignalID nSignalID, const adtf::devicetb::sdk::can::axle::tSignalInfo** pSignalInfo) const override;
    virtual tResult GetNetworkNodes(std::vector<const tChar*>& astrNetworkNodes) const override;
    virtual tResult GetNetworkNames(std::vector<const tChar*>& astrNetworkNames) const override;
};

Implementation for the DB

 
#include "canDb_Mock.h"
#include <algorithm>
#include <cstring>
#include <iterator>
 
using namespace adtf::devicetb::sdk::can::axle;
 
tResult CANDb_MOCK::GetMessageCount(tUInt32 * pnMessageCount) const
{
    *pnMessageCount = static_cast<tUInt32>(mapMessages.size());
    RETURN_NOERROR;
}
 
tResult CANDb_MOCK::GetMessageID(const tChar * strMessageName, tMessageID * pnMessageID, tBool * pbExtended) const
{
    auto it = std::find_if(mapMessages.begin(), mapMessages.end(), [&strMessageName](const auto& it) -> tBool
    { 
        return (std::strcmp(strMessageName,it.second) == 0); 
    });
 
    if (it != mapMessages.end())
    {
        *pbExtended = tFalse;
        *pnMessageID = it->first;
        RETURN_NOERROR;
    }
    RETURN_ERROR(ERR_INVALID_ARG);
}
 
tResult CANDb_MOCK::GetMessageName(tMessageID nMessageID, tBool /*bExtended*/, const tChar **pMessageName) const
{
    *pMessageName = mapMessages.at(nMessageID);
    RETURN_NOERROR;
}
 
tResult CANDb_MOCK::GetMessageInfo(tMessageID /*nMessageID*/, tBool /*bExtended*/, const tMessageInfo** /*pMessageInfo*/) const
{
    RETURN_ERROR(ERR_NOT_IMPL);
}
 
tResult CANDb_MOCK::GetSignalCount(tUInt32 * pnSignalCount) const
{
    *pnSignalCount = static_cast<tUInt32>(setSignals.size());
    RETURN_NOERROR;
}
 
tResult CANDb_MOCK::GetSignalID(const tChar * strSignalName, tSignalID * pnSignalID) const
{
    auto it = find_if(setSignals.begin(), setSignals.end(), [&strSignalName](const tChar* it)->bool
    { 
        return (std::strcmp(strSignalName, it) == 0);
    });
 
    if (it != setSignals.end())
    {
        *pnSignalID = static_cast<tSignalID>(std::distance(it, setSignals.begin()));
        RETURN_NOERROR;
    }
    RETURN_ERROR(ERR_INVALID_ARG);
}
 
tResult CANDb_MOCK::GetSignalName(tSignalID nSignalID, const tChar** pSignalName) const
{
    *pSignalName = setSignals.at(nSignalID);
    RETURN_NOERROR;
}
 
tResult CANDb_MOCK::GetSignalUnit(tSignalID /*nSignalID*/, const tChar** /*pSignalUnit*/) const
{
    RETURN_ERROR(ERR_NOT_IMPL);
}
 
tResult CANDb_MOCK::GetSignalDescription(tSignalID /*nSignalID*/, const tChar** /*pSignalDescription*/) const
{
    RETURN_ERROR(ERR_NOT_IMPL);
}
 
tResult CANDb_MOCK::GetSignalInfo(tSignalID /*nSignalID*/, const tSignalInfo** /*pSignalInfo*/) const
{
    RETURN_ERROR(ERR_NOT_IMPL);
}
 
tResult CANDb_MOCK::GetNetworkNodes(std::vector<const tChar*>& astrNetworkNodes) const
{
    astrNetworkNodes = setNetworkNodes;
 
    RETURN_NOERROR;
}
 
tResult CANDb_MOCK::GetNetworkNames(std::vector<const tChar*>& astrNetworkNames) const
{
    astrNetworkNames = setNetworkNames;
 
    RETURN_NOERROR;
}

Header for the DB Loader

 
#pragma once
 
#include <adtf_systemsdk.h>
#include <sdk/bus_database_intf.h>
#include <sdk/can_database_intf.h>
#include "adtf_base.h"
#include "adtf_ucom3.h"
 
 
class CANDbLoader_MOCK : public adtf::ucom::catwo::object<adtf::system::cADTFService,
    adtf::devicetb::sdk::IBusDatabaseLoader>
{
public:
    ADTF_CLASS_ID_NAME(CANDbLoader_MOCK, CID_DEVTB_CANDB_PARSER, "MOCK CAN Database Parser");
 
    CANDbLoader_MOCK();
    virtual ~CANDbLoader_MOCK() = default;
 
    // implements IBusDatabaseLoader
    tResult Accept(const adtf::base::ant::IProperties& pProperties) const override;
    tResult Load(const adtf::base::ant::IProperties& pProperties,
                 adtf::ucom::ant::iobject_ptr<adtf::ucom::IObject>& pDatabase) override;
    const tChar* GetName() const override;
};

Implementation for the DB Loader

 
#include "canDbLoader_Mock.h"
#include "canDb_Mock.h"
 
using namespace adtf;
using namespace adtf::devicetb::sdk::can::axle;
 
ADTF_PLUGIN(CID_DEVTB_CANDB_PARSER, CANDbLoader_MOCK);
 
CANDbLoader_MOCK::CANDbLoader_MOCK()
{
    SetDefaultRunlevel(adtf::base::tADTFRunLevel::RL_Session);
    SetDescription("Use this service to show how a custom parser service can be implemented.");
}
 
tResult CANDbLoader_MOCK::Accept(const base::ant::IProperties& pProperties) const
{
    util::cString strBusType = adtf::base::get_property<util::cString>(pProperties,
        adtf::devicetb::sdk::BUSDB_PARSER_BUSTYPE_PROP);
 
    if (!util::cStringUtil::IsEqual(strBusType, CID_DEVTB_CANDB_PARSER))
    {
        RETURN_ERROR_DESC(ERR_INVALID_ARG, util::cString::Format("Only CID: %s allowed", CID_DEVTB_CANDB_PARSER));
    }
 
    util::cFilename strDabase = base::get_property<util::cFilename>(pProperties, devicetb::sdk::BUSDB_PARSER_DATABASE_PROP);
 
    RETURN_NOERROR;
}
 
tResult CANDbLoader_MOCK::Load(const base::ant::IProperties& pProperties,
                               ucom::ant::iobject_ptr<ucom::IObject>& pDatabase)
{
    util::cString strAdditionalProperties = base::get_property<util::cString>(pProperties, adtf::devicetb::sdk::BUSDB_PARSER_ADDITIONAL_PARAMETERS_PROP);
    RETURN_IF_FAILED(pDatabase.Reset(ucom::ant::make_object_ptr<CANDb_MOCK>()));
    RETURN_NOERROR;
}
 
const tChar * CANDbLoader_MOCK::GetName() const
{
    return "CANDbLoader_MOCK";
}