SOME/IP -SD

[GokulKumar1103]

Dear Armin,
I am using the SOME/IP protocol in the project Repo given . My question was in the { SOME/IP Service Discovery Protocol Specification } document there they mentioned , the server offer its services continuosly ( we can see in the below image send(offerservice)) irrespective of the Client state and connection.
. But in my Case I am commenting the someip client start in diagnostic_manager.cpp file and only using the someip server start in the extended_vehicle.cpp .But why I can't able to send the offer's .

[langroodi]

I guess there is a bug in the implementation of the SD server while transiting from the _Initial Wait Phase _ to the Repetition Phase. In that transition, the server should send the offer once, and because a potential bug (I don't have a time to check it now), it won't send it.
If you also commented out the send of FindService message from the SD client side, then based on the diagram, you should never get any OfferService (if the potential bug is not there, then you would receive the OfferService once.

[GokulKumar1103]

Thanks Armin for your answer .
Yes as you said , by commenting the FindService message from the SD client side also I can't see the sever OfferService Messages. I have created a new application file named udp_communication.cpp ( similar to the Extended_vehicle.cpp ) from that i am able to individually send the Server OfferService Messages . Please Check the below Code snippet

#include "udp_communication.h"
#include
#include
#include

#include "../ara/com/someip/sd/sd_network_layer.h"
#include "../ara/com/entry/service_entry.h"

namespace application
{
const std::string cNicIpAddress{"172.20.4.5"};
Udp_communication::Udp_communication(
AsyncBsdSocketLib::Poller *poller,
ara::phm::CheckpointCommunicator *checkpointCommunicator)
: ara::exec::helper::ModelledProcess(cAppId, poller),
mPoller(poller),
mClient(cNicIpAddress, tcpport)
{
std::cout << "UDP Constructor initialized.\n";
}

void Udp_communication::configure_udp()
{
mNetworkLayer = new ara::com::someip::sd::SdNetworkLayer(
mPoller, cNicIpAddress, SD_IP, SD_PORT);

mSdServer1 = std::make_unique<ara::com::someip::sd::SomeIpSdServer>(
    mNetworkLayer,
    SAMPLE_SERVICE_ID,
    SAMPLE_INSTANCE_ID,
    0x00, // Major
    0x00, // Minor
    SD_IP,
    SD_PORT,
    10, // Min delay
    100, // Max delay
    200, // Repetition base
    2000, // Cycle delay
    3); // Max repetition

msd.AddEntry(std::move(entry));


    // Enqueue and trigger offer
    mSdServer1->EnqueueMessage(std::move(msd));  // <-- Enqueue your SD message
    mSdServer1->sendOffer();                     // <-- Trigger sendOffer
    std::chrono::microseconds(10);    

std::cout << "Service Discovery message enqueued and offered.\n";

}

int Udp_communication::Main(
const std::atomic_bool *cancellationToken,
const std::map<std::string, std::string> &arguments)
{
configure_udp();

while (_running && !cancellationToken->load())
{
    _running = WaitForActivation();
}

return 0;

}

} // namespace application
and its .h file was

#ifndef UDP_COMMUNICATION_H
#define UDP_COMMUNICATION_H

#include "../ara/exec/helper/modelled_process.h"
#include "../ara/phm/supervised_entity.h"
#include "../ara/com/someip/rpc/rpc_client.h"
#include "../ara/com/someip/rpc/socket_rpc_client.h"
#include "../ara/com/helper/concurrent_queue.h"
#include "./helper/network_configuration.h"
#include "../ara/com/someip/sd/someip_sd_server.h"
#include "../../../OBD-II-Emulator/include/obdemulator/obd_service.h"
#include "./doip/obd_to_doip_converter.h"

#include
#include
#include
#include
#include
#include
#include
#include

#define SAMPLE_INSTANCE_ID 0x5678
#define SAMPLE_SERVICE_ID 0x1234
// #define SAMPLE_METHOD_ID 0x0421
// #define SD_IP "239.0.0.1" //"172.20.5.43"
#define tcpport 8081
#define SD_PORT 30490

namespace application
{
class Udp_communication : public ara::exec::helper::ModelledProcess
{
private:
AsyncBsdSocketLib::Poller *mPoller;
AsyncBsdSocketLib::TcpClient mClient;
ara::com::helper::NetworkLayerara::com::someip::sd::SomeIpSdMessage *mNetworkLayer;

void configure_udp();

// Using unique_ptr for automatic memory management
// std::unique_ptr<application::doip::ObdToDoipConverter> udps;

public:
const std::string cAppId{"Udp-Communication"};

Udp_communication(AsyncBsdSocketLib::Poller *poller,
                  ara::phm::CheckpointCommunicator *checkpointCommunicator);

int Main(const std::atomic_bool *cancellationToken,
         const std::map<std::string, std::string> &arguments) override;

std::unique_ptr<ara::com::someip::sd::SomeIpSdServer> mSdServer1;// New_today 

ara::com::someip::sd::SomeIpSdMessage msd;
bool _running{true};
// Create a valid SD entry with correct constructor
// std::unique_ptr<ara::com::entry::Entry> entry =

std::unique_ptrara::com::entry::Entry entry = std::make_uniqueara::com::entry::ServiceEntry(
ara::com::entry::EntryType::Offering,
0x1111, // service_id from JSON
0x2222, // instance_id from JSON
0x03, // TTL (forever)
0x00, // major version
0xFF // minor version
); // This was not used instead the constructor instance was used
std::string SD_IP{"239.0.0.1"};

};
} // namespace application

#endif
*) My Question was in the new udp_communication.cpp , I manually send the offer messages but i want to run automatically like in the Extended_vehcile.cpp we just done the { mSdServer->Start(); } all the offer messages are sent via ara::com::someip::sd::network_layer .