ROS2Publisher.h

Go to the documentation of this file.

 
#pragma once
 
 
 
#include <Components/ActorComponent.h>
 
#include <CoreMinimal.h>
 
 
 
// rclUE
 
#include "Msgs/ROS2GenericMsg.h"
 
#include "ROS2NodeComponent.h"
 
#include "ROS2Topic.h"
 
 
 
#include "ROS2Publisher.generated.h"
 
 
 
class RCLUE_API UROS2Publisher : public UROS2Topic
 
{
 
 
 
public:
 
    static UROS2Publisher* CreateLoopPublisherWithClass(UObject* InOwner,
 
                                                        const FString& InTopicName,
 
                                                        const TSubclassOf<UROS2Publisher>& InPublisherClass,
 
                                                        const float InPubFrequency);
 
 
 
    static UROS2Publisher* CreateLoopPublisher(UObject* InOwner,
 
                                               const FString& InTopicName,
 
                                               const TSubclassOf<UROS2Publisher>& InPublisherClass,
 
                                               const TSubclassOf<UROS2GenericMsg>& InMsgClass,
 
                                               float InPubFrequency,
 
                                               const FTopicCallback& InUpdateDelegate,
 
                                               const UROS2QoS InQoS = UROS2QoS::Default);
 
    static UROS2Publisher* CreatePublisherWithClass(UObject* InOwner,
 
                                                    const TSubclassOf<UROS2Publisher>& InPublisherClass,
 
                                                    const FString& InTopicName = TEXT(""));
 
 
 
    static UROS2Publisher* CreatePublisher(UObject* InOwner,
 
                                           const FString& InTopicName,
 
                                           const TSubclassOf<UROS2Publisher>& InPublisherClass,
 
                                           const TSubclassOf<UROS2GenericMsg>& InMsgClass,
 
                                           float InPubFrequency,
 
                                           const UROS2QoS InQoS = UROS2QoS::Default);
 
 
 
    static UROS2Publisher* CreatePublisher(UObject* InOwner,
 
                                           const FString& InTopicName,
 
                                           const TSubclassOf<UROS2Publisher>& InPublisherClass,
 
                                           const TSubclassOf<UROS2GenericMsg>& InMsgClass,
 
                                           float InPubFrequency,
 
                                           const rmw_qos_profile_t& InCustomQoS);
 
 
 
    void UpdateAndPublish();
 
 
 
    void Publish();
 
 
 
    template<typename TUEMessage, typename TUEStruct>
 
    void Publish(const TUEStruct& InMessageData)
 
    {
 
        // can't use macro in here.
 
        // if (IsValid(OwnerNode) && OwnerNode->State == UROS2State::Initialized && State == UROS2State::Initialized)
 
        if (State == UROS2State::Initialized)
 
        {
 
            // Update [TopicMessage] with [InMessageData]
 
            CastChecked<TUEMessage>(TopicMessage)->SetMsg(InMessageData);
 
 
 
            // Publish [TopicMessage]
 
            Publish();
 
        }
 
        else
 
        {
 
            UE_LOG_WITH_INFO_NAMED(LogTemp, Log, TEXT("Publisher or node is not yet initialized"));
 
        }
 
    }
 
 
 
    virtual void Destroy();
 
 
 
    void StopPublishTimer();
 
 
 
    void StartPublishTimer();
 
 
 
 
 
    float PublicationFrequencyHz = 1.f;
 
 
 
 
 
    FTopicCallback UpdateDelegate;
 
 
 
    virtual void UpdateMessage(UROS2GenericMsg* InMessage)
 
    {
 
        checkNoEntry();
 
    }
 
 
 
    void SetDefaultDelegates();
 
 
 
    void SetDelegates(const FTopicCallback& InUpdateDelegate);
 
 
 
protected:
 
 
 
    FTimerHandle TimerHandle;
 
 
 
 
    const void* PublishedMsg = nullptr;
 
 
 
 
    rcl_publisher_t RclPublisher;
 
 
 
 
 
    URRTimerManager* TimerManager = nullptr;
 
 
 
    virtual void InitializeTopicComponent();
 
};
 
 
 
class RCLUE_API UROS2PublisherComponent : public UActorComponent
 
{
 
 
 
public:
 
 
    UROS2Publisher* Publisher = nullptr;
 
 
 
 
 
    FString TopicName = TEXT("");
 
 
 
 
 
    TSubclassOf<UROS2Publisher> PublisherClass = UROS2Publisher::StaticClass();
 
 
 
 
 
    TSubclassOf<UROS2GenericMsg> MsgClass = UROS2GenericMsg::StaticClass();
 
 
 
 
 
    float PublicationFrequencyHz = 1.f;
 
 
 
 
 
    UROS2QoS QoS = UROS2QoS::Default;
 
 
 
 
 
    FTopicCallback UpdateDelegate;
 
 
 
 
    virtual void DefaultCreatePublisher()
 
    {
 
        if (Publisher == nullptr)
 
        {
 
            Publisher = UROS2Publisher::CreateLoopPublisher(
 
                this, TopicName, PublisherClass, MsgClass, PublicationFrequencyHz, UpdateDelegate, QoS);
 
        }
 
    }
 
 
 
    virtual void BeginPlay() override
 
    {
 
        DefaultCreatePublisher();
 
        Super::BeginPlay();
 
    };
 
 
 
    virtual void SetParams()
 
    {
 
        if (Publisher != nullptr)
 
        {
 
            Publisher->TopicName = TopicName;
 
            Publisher->PublicationFrequencyHz = PublicationFrequencyHz;
 
            Publisher->QoS = QoS;
 
        }
 
        else
 
        {
 
            UE_LOG_WITH_INFO(LogTemp, Warning, TEXT("Publisher is not created yet."));
 
        }
 
    }
 
};
 
 
 
class RCLUE_API UROS2CustomPublisherComponent : public UActorComponent
 
{
 
 
 
public:
 
 
    UROS2Publisher* Publisher = nullptr;
 
 
 
 
 
    FString TopicName = TEXT("");
 
 
 
 
 
    TSubclassOf<UROS2Publisher> PublisherClass = UROS2Publisher::StaticClass();
 
 
 
 
 
    float PublicationFrequencyHz = 1.f;
 
 
 
 
    virtual void DefaultCreatePublisher()
 
    {
 
        if (Publisher == nullptr)
 
        {
 
            Publisher = UROS2Publisher::CreateLoopPublisherWithClass(this, TopicName, PublisherClass, PublicationFrequencyHz);
 
        }
 
    }
 
    virtual void BeginPlay() override
 
    {
 
        DefaultCreatePublisher();
 
        Super::BeginPlay();
 
    };
 
};