PIDDrone.h

Go to the documentation of this file.

// Copyright (c) 2023 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Vehicle.h"
#include "DroneParameters.h"
 
#include "Components/SkeletalMeshComponent.h"
#include "Components/StaticMeshComponent.h"
 
#include "ROSIntegration/Public/std_msgs/Float32.h"
 
#include "PIDDrone.generated.h"
 
class UTopic;
 
UCLASS()
class AGRARSENSE_API APIDDrone : public AVehicle
{
    GENERATED_BODY()
 
public:
 
    APIDDrone();
 
    virtual EVehicleTypes GetVehicleType() const override { return EVehicleTypes::Drone; }
 
    virtual FTransform GetInteractableWorldTransform_Implementation() const override
    {
        if (DroneSkeletalMesh)
        {
            return DroneSkeletalMesh->GetComponentTransform();
        }
        else
        {
            return GetActorTransform();
        }
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    void SetDroneAction(EDroneAction mode)
    {
        DroneParameters.DroneAction = mode;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    EDroneAction GetDroneAction() const
    {
        return DroneParameters.DroneAction;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    FDroneParameters GetDroneParameters() const
    {
        return DroneParameters;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    void ChangeDroneParameters(const FDroneParameters& newParameters)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("Parameters Changed!"));
#endif
        SetDroneParameters(newParameters);
    }
 
    void SetDroneParameters(const FDroneParameters& InParameters)
    {
        DroneParameters = InParameters;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    void AddWayPoint(FVector Waypoint)
    {
        FTransform transform;
        transform.SetLocation(Waypoint);
 
        DroneParameters.Points.Add(transform);
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    void ClearWaypoints()
    {
        DroneParameters.Points.Empty();
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    void SetFlightpath();
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    void SetManualControl(bool value) 
    {
        manualControl = value;
    }
 
    void MoveDroneToPosition(const FTransform Transform);
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    TArray<FTransform> GenerateRoamingPoints(float radius, int32 roamingPoints);
 
    virtual void SetCurrentTransformToMovedFromGarageTransform() override
    {
        if (DroneSkeletalMesh)
        {
            MovedFromGarageTransform = DroneSkeletalMesh->GetComponentTransform();
            UE_LOG(LogTemp, Warning, TEXT("Moved from garage transform %s"), *MovedFromGarageTransform.ToString());
 
        }
        else
        {
            MovedFromGarageTransform = GetActorTransform();
            UE_LOG(LogTemp, Warning, TEXT("ACTOR Moved from garage transform WHAT IS THIS: %s"), *MovedFromGarageTransform.ToString());
 
        }
    }
 
    void SetShowForwardArrow(bool Show)
    {
        ShowForwardArrow = Show;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Drone")
    bool GetShowForwardArrow() const
    {
        return ShowForwardArrow;
    }
 
protected:
 
    void ROSBridgeStateChanged(EROSState ROSState) override;
 
    UPROPERTY()
    UTopic* ROSTopic = nullptr;
 
    TSharedPtr<ROSMessages::std_msgs::Float32> ROSMessage;
 
private:
 
    virtual void BeginPlay() override;
 
    virtual void Tick(float DeltaTime) override;
 
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    void CreateTopic();
 
    void DestroyTopic();
 
    void AutoPilot(const float DeltaTime);
 
    UFUNCTION(BlueprintCallable)
    void AssignRoamingPoints(const TArray<FTransform> Points);
 
    UFUNCTION(BlueprintCallable)
    void SetDroneRotation(USkeletalMeshComponent* target, FRotator rotator);
 
    void UpdateGroundHeight();
 
    UFUNCTION(BlueprintCallable)
    bool IsRoaming() const
    {
        return DroneParameters.DroneAction == EDroneAction::Roaming;
    }
 
    UFUNCTION(BlueprintCallable)
    void SetDesiredLocationMesh(UStaticMeshComponent* meshcomponent)
    {
        PositionMesh = meshcomponent;
    }
 
    UFUNCTION(BlueprintCallable)
    FVector GetCurrentWaypointTarget();
 
    FDroneParameters DroneParameters;
 
    UPROPERTY()
    EFlightMode flightmode = EFlightMode::Roaming;
 
    UPROPERTY()
    UWorld* World = nullptr;
 
    FVector StartingPosition;
 
    UPROPERTY()
    USkeletalMeshComponent* DroneSkeletalMesh = nullptr;
 
    UPROPERTY()
    UStaticMeshComponent* PositionMesh = nullptr;
 
    /* For testing purposes. Hardcoded coordinates */
    TArray<FVector> WayPoints = {
        {3790, 8050, 5000},
        {11779.536955,6566.541435,5000}
    };
 
    bool waypointReached = false;
 
    bool manualControl = false;
 
    bool ShowForwardArrow = false;
 
    int32 passedWaypoints = 0;
 
    float DroneHeightFromGround = 0.0f;
};