Question Regarding an Error Related to the DiagnosticManager's Event

[KEDW0316]

Hello,

I've been gradually delving deeper into this project.

I referred to a previous discussion at this link and am trying to integrate the features I have in mind based on that discussion.

After applying the TestApp from the link, I modified the Execution Management to run the TestApp instead of the Extended Vehicle.

Upon running the TestApp, I encountered an error that hadn't appeared before. The error is as follows:
"DiagnosticManager Context ID: Lifetime; Context Description: Application lifetime logs; Log Level: Error; TelematicControlModuleEvent has failed with DTC 49560."

Upon investigation, I found that this error occurs when the DebouncingStatus detected by the Diagnostic_manager for an event (named mEvent in the code) changes to the value kFinallyDefective.

void DiagnosticManager::onEventStatusChanged(
            ara::diag::EventStatusByte eventStatus)
        {
            const auto cDebouncingStatusResult{mEvent->GetDebouncingStatus()};

            if (!cDebouncingStatusResult.HasValue())
            {
                return;
            }

            const ara::diag::DebouncingState cDebouncingStatus{
                cDebouncingStatusResult.Value()};

            if (cDebouncingStatus ==
                ara::diag::DebouncingState::kFinallyHealed)
            {
                ara::log::LogStream _logStream;
                _logStream << "Telematic Control Module (Extended Vehicle AA) is discovered.";
                Log(cLogLevel, _logStream);

                std::string _ipAddress;
                uint16_t _port;
                bool _successful{
                    mSdClient->TryGetOfferedEndpoint(_ipAddress, _port)};
                if (!_successful)
                {
                    throw std::runtime_error("Fetching offered endpoint failed.");
                }

                mObdToDoipConverter =
                    new doip::ObdToDoipConverter(Poller, _ipAddress, _port);

                // mObdEmulator =
                //     new ObdEmulator::ObdEmulator(
                //         &mSerialCommunication,
                //         &mCanDriver,
                //         {mObdToDoipConverter});

                // _successful = mObdEmulator->TryStartAsync();
                // if (!_successful)
                // {
                //     throw std::runtime_error("Starting OBD-II emulator failed.");
                // }
            }
            else if (cDebouncingStatus ==
                     ara::diag::DebouncingState::kFinallyDefective)
            {
                const ara::diag::DTCFormatType cDtcFormat{
                    ara::diag::DTCFormatType::kDTCFormatUDS};
                const auto cDtcNumberResult{mEvent->GetDTCNumber(cDtcFormat)};

                ara::log::LogStream _logStream;
                _logStream << mEventSpecifier->ToString()
                           << " is failed with DTC "
                           << cDtcNumberResult.Value();
                Log(cErrorLevel, _logStream);
            }
        }

However, I have been unable to identify what influences the GetDebouncingStatus of this event.

The only change I made to the code was replacing the ExtendedVehicle with the TestApp from the link, but I don't understand how this could affect mEvent.

I would appreciate any insights you might have.

I am attaching the relevant code separately.

Thank you as always.

// TestApp ( => ExtendedVehicle)
#include "../ara/com/someip/sd/sd_network_layer.h"
#include "./test_app.h"

// ---- server ---- //
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
// ---- server ---- //

namespace application
{
    const std::string TestApp::cAppId{"TestApp"};

    static std::string sevrPort;

    TestApp::TestApp(
        AsyncBsdSocketLib::Poller *poller,
        ara::phm::CheckpointCommunicator *checkpointCommunicator) : ara::exec::helper::ModelledProcess(cAppId, poller),
                                                                    mNetworkLayer{nullptr},
                                                                    mSdServer{nullptr},
                                                                    mCurl{nullptr}
    {
    }

    void TestApp::configureSocket(const arxml::ArxmlReader &reader)
    {
        const arxml::ArxmlNode cSkPortNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "ETHERNET-COMMUNICATION-CONNECTOR",
                                "AP-APPLICATION-ENDPOINTS",
                                "TP-CONFIGURATION",
                                "UDP-TP",
                                "UDP-TP-PORT",
                                "PORT-NUMBER"})};

        const auto cSkPort{cSkPortNode.GetValue<uint16_t>()};
        sevrPort = std::to_string(cSkPort);
        std::cout << "\n server sevrPort :" << sevrPort <<"\n" << std::endl;
    }

    void TestApp::configureNetworkLayer(const arxml::ArxmlReader &reader)
    {
        const std::string cNicIpAddress{"127.0.0.1"};

        const arxml::ArxmlNode cSdPortNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "PROVIDED-EVENT-GROUPS",
                                "SOMEIP-PROVIDED-EVENT-GROUP",
                                "EVENT-MULTICAST-UDP-PORT"})};

        const arxml::ArxmlNode cSdIpNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "PROVIDED-EVENT-GROUPS",
                                "SOMEIP-PROVIDED-EVENT-GROUP",
                                "IPV-4-MULTICAST-IP-ADDRESS"})};

        const auto cSdPort{cSdPortNode.GetValue<uint16_t>()};
        const auto cSdIp{cSdIpNode.GetValue<std::string>()};
        mNetworkLayer =
            new ara::com::someip::sd::SdNetworkLayer(
                Poller, cNicIpAddress, cSdIp, cSdPort);
    }

    helper::NetworkConfiguration TestApp::getNetworkConfiguration(
        const arxml::ArxmlReader &reader)
    {
        const std::string cNetworkEndpoint{"ExtendedVehicleEP"};
        const std::string cApplicationEndpoint{"ServerUnicastTcp"};
        const ara::com::option::Layer4ProtocolType cProtocol{
            ara::com::option::Layer4ProtocolType::Tcp};
        
        helper::NetworkConfiguration _result;

        bool _successful{
            helper::TryGetNetworkConfiguration(
                reader, cNetworkEndpoint, cApplicationEndpoint, cProtocol,
                _result)};

        if (_successful)
        {
            return _result;
        }
        else
        {
            throw std::runtime_error("Fetching network configuration failed.");
        }
    }

    void TestApp::configureSdServer(const arxml::ArxmlReader &reader)
    {
        const arxml::ArxmlNode cServiceIdNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "SERVICE-INTERFACE-DEPLOYMENT",
                                "SERVICE-INTERFACE-ID"})};

        const arxml::ArxmlNode cInstanceIdNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "SERVICE-INSTANCE-ID"})};

        const arxml::ArxmlNode cMajorVersionNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "SERVICE-INTERFACE-DEPLOYMENT",
                                "SERVICE-INTERFACE-VERSION",
                                "MAJOR-VERSION"})};

        const arxml::ArxmlNode cMinorVersionNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "SERVICE-INTERFACE-DEPLOYMENT",
                                "SERVICE-INTERFACE-VERSION",
                                "MINOR-VERSION"})};

        const arxml::ArxmlNode cInitialDelayMinNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "SD-SERVER-CONFIG",
                                "INITIAL-OFFER-BEHAVIOR",
                                "INITIAL-DELAY-MIN-VALUE"})};

        const arxml::ArxmlNode cInitialDelayMaxNode{
            reader.GetRootNode({"AUTOSAR",
                                "AR-PACKAGES",
                                "AR-PACKAGE",
                                "ELEMENTS",
                                "PROVIDED-SOMEIP-SERVICE-INSTANCE",
                                "SD-SERVER-CONFIG",
                                "INITIAL-OFFER-BEHAVIOR",
                                "INITIAL-DELAY-MAX-VALUE"})};

        const auto cServiceId{cServiceIdNode.GetValue<uint16_t>()};
        const auto cInstanceId{cInstanceIdNode.GetValue<uint16_t>()};
        const auto cMajorVersion{cMajorVersionNode.GetValue<uint8_t>()};
        const auto cMinorVersion{cMinorVersionNode.GetValue<uint32_t>()};
        const auto cInitialDelayMin{cInitialDelayMinNode.GetValue<int>()};
        const auto cInitialDelayMax{cInitialDelayMaxNode.GetValue<int>()};

        helper::NetworkConfiguration _networkConfiguration{
            getNetworkConfiguration(reader)};

        mSdServer =
            new ara::com::someip::sd::SomeIpSdServer(
                mNetworkLayer,
                cServiceId,
                cInstanceId,
                cMajorVersion,
                cMinorVersion,
                _networkConfiguration.ipAddress,
                _networkConfiguration.portNumber,
                cInitialDelayMin,
                cInitialDelayMax);
    }

    // add
    void error_handling(const char *message)
    {
        fputs(message, stderr);
        fputc('\n', stderr);
    }

    int TestApp::Main(
        const std::atomic_bool *cancellationToken,
        const std::map<std::string, std::string> &arguments)
    {
        const std::string cEvConfigArgument{"evconfig"};
        const std::string cEvConfigFilepath{arguments.at(cEvConfigArgument)};
        const arxml::ArxmlReader cReader(cEvConfigFilepath);

        const std::string cSkConfigArgument{"skconfig"};
        const std::string cSkConfigFilepath{arguments.at(cSkConfigArgument)};
        const arxml::ArxmlReader kReader(cSkConfigFilepath); // socket
        
        ara::log::LogStream _logStream;

        // --------------------- server --------------------- //

        configureSocket(kReader);

        int serv_sock=socket(PF_INET, SOCK_DGRAM, 0); // UDP/IP
        if(serv_sock == -1)
            error_handling("server socket() error");

        struct sockaddr_in serv_addr;
        struct sockaddr_in clnt_addr;
        socklen_t clnt_addr_size;

        char message[30] = "";
        int str_len = 0;
        std::cout << "\n server bind1 :" << sevrPort <<"\n" << std::endl;
        memset(&serv_addr, 0, sizeof(serv_addr));
        serv_addr.sin_family=AF_INET;
        serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
        serv_addr.sin_port=htons(stoi(sevrPort));
        // serv_addr.sin_port=htons(atoi("11111"));

        std::cout << "\n server bind2 :" << sevrPort <<"\n" << std::endl;

        bool binding = false;
        if(bind(serv_sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr))==-1 )
        {
            error_handling("bind() error");
            binding = false;
        }
        else
        {
            binding = true;
        }

        std::cout << "\n server bind \n" << std::endl;

        // --------------------- connect --------------------- //

        // char message[]="Hello World!"; // TCP
        // write(clnt_sock, message, sizeof(message));

        while(1){
            clnt_addr_size = sizeof(clnt_addr);

            str_len = recvfrom(serv_sock, message , 30, 0, (struct sockaddr*)&clnt_addr , &clnt_addr_size);
            
            if (strstr(message, "out"))
			    break;
            else
                std::cout << "\n server receive message:: " << message <<" \n" << std::endl;
        }
        
        // close(clnt_sock);	
        close(serv_sock);
        
        std::cout << "\n server out \n" << std::endl;
        // --------------------- server --------------------- //


        try
        {
            configureNetworkLayer(cReader);
            configureSdServer(cReader);

            _logStream << "TestApp has been initialized.";
            Log(cLogLevel, _logStream);

            bool _running{true};
            mSdServer->Start();

            static bool startpoint = true;

            while (!cancellationToken->load() && _running)
            {
                if(startpoint){
                    _logStream << "\nReady Start!!\n"; // add
                    Log(cLogLevel, _logStream); // add
                    startpoint = false;
                }

                _running = WaitForActivation();
                // mPoller.TryPoll();
            }

            delete mSdServer;
            mSdServer = nullptr;

            _logStream.Flush();
            _logStream << "State management has been terminated.";
            Log(cLogLevel, _logStream);

            return cSuccessfulExitCode;
        }
        catch (const std::runtime_error &ex)
        {
            _logStream.Flush();
            _logStream << ex.what();
            Log(cErrorLevel, _logStream);

            return cUnsuccessfulExitCode;
        }
    }

    TestApp::~TestApp(){
        if (mSdServer)
            delete mSdServer;

        if (mNetworkLayer)
            delete mNetworkLayer;
    }

}'

[langroodi]

The DM has a SD client to discover your TestApp. There is a standard Monitor mechanism on DM that checks if the SD was successful or not. If within 6 seconds (by default) the TestApp is discovered via SOME/IP SD, the SD is reported as successful. Otherwise, the Monitor sets the Event to kFinallyHealed which leads to the reported DTC.

At the first stage of debugging, you can put a breakpoint on void DiagnosticManager::checkServiceDiscovery() function to see if the FSM state changes to SdClientState::ServiceReady/SdClientState::ServiceSeen or not. If yes, then you can increase the TIME-FAILED-THRESHOLD value on DM ARXML to something higher than 6000. If not, then you need to check whether the mSdServer on your TestApp broadcasts the SD packets on the multicast address or not via some network tracing tools like Wireshark.

[KEDW0316]

Thank you for your response.

I want to confirm if my understanding is correct:

The SOME/IP SD server offers services to the 239.0.0.1 group on the 5555 UDP port. In this project's demo, it's provided by the Extended Vehicle.

The DM's SOME/IP SD client subscribes to this group and waits for the Network Endpoint Address coming from the Extended Vehicle.

Once the DM receives this Network Endpoint Address (which is port 8081 at 127.0.0.1 in the demo), it can establish a connection with the Extended Vehicle through TCP/IP communication.

Is my understanding correct?

If so, based on the current question I asked, I understand that my TestApp is currently not broadcasting the Network Endpoint via SD.

Thank you.

[langroodi]

Not a problem. Yes, your understanding is totally correct. Good luck with the debugging ;)