henry/EntityLibrary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ADD: added prototype of sensormanager

Browse Source
This commit is contained in:
Henry Winkel
2024-02-12 18:43:53 +01:00
parent fc7fe2193b
commit cfe2aff5ce
11 changed files with 396 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
CMakeLists.txt
View File

@@ -49,6 +49,14 @@ add_library(EntityLibrary STATIC
include/Entities/Tracklist/TracklistItem.hpp
src/Entities/Tracklist/TrackListItem.cpp
include/Entities/SensorManager.hpp
src/Entities/SensorManager.cpp
include/Entities/SensorControl.hpp
src/Entities/SensorControl.cpp
)

8
include/Entities/Entity.hpp
View File

@@ -4,6 +4,7 @@
#include "DirectCommunicationServer.hpp"
#include "Entities/Movement.hpp"
#include "Entities/SensorManager.hpp"
#include "SimCore/Messages/SimTrack.hpp"
#include "SimCore/Orientation.hpp"
#include "SimCore/SafeMap.hpp"
@@ -59,6 +60,7 @@ namespace Entities {
std::string GroundTruthAddr,
std::uint32_t GroundTruthPort,
ushort CommandPort,
ushort SensorPort,
bool online);
~Entity();
@@ -89,11 +91,12 @@ namespace Entities {
SimCore::Side::EntitySide EntitySide_;
double RCS_;
ushort MovemntWorkerPort_;
ushort SensorPort_;
std::unique_ptr<kubecontrol::PodController> PodController_;
std::shared_ptr<kubecontrol::PodController> PodController_;
std::unique_ptr<SensorManager> SensorManager_;
std::shared_ptr<WHISPER::InternalUDPSender> BroadcastServer_;
@@ -105,6 +108,7 @@ namespace Entities {
private:
bool online_;
std::vector<std::thread> threads;
std::atomic<bool> stopMainLoop = false;

3
include/Entities/Sensor.hpp
View File

@@ -20,6 +20,9 @@
namespace Entities {
/**
*@brief this class represents a template class example for senor Applications like Radar, Sonar, eg.
*/
class Sensor {
public:
Sensor(

72
include/Entities/SensorControl.hpp Normal file
View File

@@ -0,0 +1,72 @@
#pragma once
#include "SimCore/SimCore.hpp"
#include <SimCore/Messages/SimTrack.hpp>
#include <kubecontrol/KubePod.hpp>
#include <Entities/Tracklist/Tracklist.hpp>
#include <loguru.hpp>
#include <memory>
#include <string>
#include <vector>
namespace Entities
{
class SensorControl
{
public:
SensorControl(std::string ID, std::string Name, std::string IP, SimCore::SensorKinds sensorKind);
/**
* @brief Get the Name of the Sensor
*
* @return std::string
*/
std::string getName();
/**
* @brief Get the UUID of the Sensor
*
* @return std::string
*/
std::string getID();
/**
* @brief Get the Sensor Kind
*
* @return SimCore::SensorKinds
*/
SimCore::SensorKinds getSensorKind();
/**
* @brief Get the Sensor Status
*
* @return SimCore::Status
*/
SimCore::Status getSensorStatus();
/**
* @brief updates the sensor status
*
* @param SimCore::Status
*/
void updateStatus(SimCore::Status status);
std::unique_ptr<TrackList::TrackList> TrackStore;
private:
const std::string ID_;
std::string Name_;
std::string IP_;
SimCore::SensorKinds SensorKind_;
SimCore::Status SensorSatus_;
};
}

79
include/Entities/SensorManager.hpp Normal file
View File

@@ -0,0 +1,79 @@
#pragma once
#include "DirectCommunicationServer.hpp"
#include "Entities/SensorControl.hpp"
#include "SimCore/Identifier.hpp"
#include "SimCore/Messages/SimTrack.hpp"
#include "SimCore/SimCore.hpp"
#include "kubecontrol/PodController.hpp"
#include <loguru.hpp>
#include <map>
#include <memory>
#include <string>
#include <sys/types.h>
namespace Entities
{
class SensorManager
{
public:
SensorManager(SimCore::Identifier OwnID,std::shared_ptr<kubecontrol::PodController> PodController, ushort sensorPort = 5557);
/**
*@brief starts a Sensor based on a KubePod Object
*@param KubePod - a KubePod Item ready to start
*@param SensorKind - numeric value of the SensorKind from SimCore
*/
void startSensor(std::shared_ptr<kubecontrol::KubePod> pod, SimCore::SensorKinds SensorKind);
/**
*@brief stops a Sensor based on a uuid ( the sensors just stops to operate)
*@param string uuid sensor
*/
void stopSenser(std::string uuid);
/**
*@brief deletes a sensor pod based on the uuid
*@param string uuid sensor
*/
void deleteSensor(std::string uuid);
/**
*@brief get the Tracklist as JSON formatted string where you can see the tracks every sensor detects
*@return string - JSON formatted string
*/
std::string getTracklistStringBySensor();
/**
*@brief get the Tracklist as JSON formatted string where the tracks are fusiond with a list for each track which sensor has detected that track
*@return string - JSON formatted string
*/
std::string getTracklistStringFusioned();
/**
*@brief Updates the Tracklist for the Specific Sensor
*@param string uuid for the Sensor
*@param SimTrack updated Track
*/
void updateTracklistForSensor(std::string uuidSensor, std::shared_ptr<SimCore::SimTrack> track);
private:
const SimCore::Identifier OwnId_;
ushort SensorPort_ = 5557;
std::map<std::string, std::unique_ptr<Entities::SensorControl>> SensorStore;
std::shared_ptr<kubecontrol::PodController> PodController_;
std::shared_ptr<DirectCommunication::DirectCommunicationServer> SensorServer_ = nullptr;
void handlSensorMessages(std::string Message);
};
}

2
libs/KubeControl

Submodule libs/KubeControl updated: d1024de907...2377948049

26
src/Entities/Entity.cpp
View File

@@ -1,5 +1,6 @@
#include "DirectCommunicationServer.hpp"
#include "Entities/Movement.hpp"
#include "Entities/SensorManager.hpp"
#include "Orders/MoveOrder.hpp"
#include "Orders/Order.hpp"
#include "SimCore/Messages/Control.hpp"
@@ -45,6 +46,7 @@ namespace Entities
std::string GroundTruthAddr,
std::uint32_t GroundTruthPort,
ushort CommandPort,
ushort SensorPort,
bool online):
EntityName_(EnttityName),
EntityKind_(EntityKind),
@@ -52,24 +54,30 @@ namespace Entities
EntitySide_(EntitySide),
GroundTruthPort_(GroundTruthPort),
GroundTruthAddr_(GroundTruthAddr),
SensorPort_(SensorPort),
online_(online)
{
PodController_ = std::make_unique<kubecontrol::PodController>("docs/config");
PodController_ = std::make_shared<kubecontrol::PodController>("docs/config");
SensorManager_ = std::make_unique<Entities::SensorManager>(OwnID, PodController_,SensorPort_);
OwnShipTrack = std::make_shared<SimCore::SimTrack>(OwnID, EnttityName, EntityKind,EntitySide);
OwnShipTrack->setPosition(SimCore::Position());
OwnShipTrack->RCS.setValue(RCS_);
MovemtServer_ = std::make_shared<DirectCommunication::DirectCommunicationServer>(__MOVEMENT_SERVER_PORT__);
MovemtServer_ = std::make_shared<DirectCommunication::DirectCommunicationServer>(__MOVEMENT_SERVER_PORT__,OwnID.getUUID());
CommandCommsServer_ = std::make_shared<DirectCommunication::DirectCommunicationServer>(CommandPort);
CommandCommsServer_ = std::make_shared<DirectCommunication::DirectCommunicationServer>(CommandPort,OwnID.getUUID());
CommandCommsServer_->registerMessageCallback(std::bind(&Entity::handleExternalComms,this,std::placeholders::_1));
BroadcastServer_ = std::make_shared<WHISPER::InternalUDPSender>(GroundTruthAddr, GroundTruthPort);
// BroadcastServer_ = std::make_shared<WHISPER::InternalUDPSender>("239.0.0.1", 10000);
TrackList_ = std::make_unique<TrackList::TrackList>();
// TrackList_ = std::make_unique<TrackList::TrackList>();
}
@@ -137,9 +145,9 @@ namespace Entities
void Entity::stop()
{
LOG_S(INFO)<<"Child pods:" << PodController_->getListOfChildPods();
LOG_S(INFO)<<"Child pods:" << PodController_->getInfoForAllPods().size();
PodController_->stopAllPods();
LOG_S(INFO)<<"Child pods after stopping:" << PodController_->getListOfChildPods();
LOG_S(INFO)<<"Child pods after stopping:" << PodController_->getInfoForAllPods().size();
std::this_thread::sleep_for(std::chrono::milliseconds(5000));
@@ -318,9 +326,9 @@ namespace Entities
}
case SimCore::GET_TRACKLIST:
{
nlohmann::json j;
this->TrackList_->getJsonTRackList(j);
this->CommandCommsServer_->sendMessage(j.dump());
break;
}

2
src/Entities/Sensor.cpp
View File

@@ -41,7 +41,7 @@ namespace Entities {
GroundTruthUDPListener_->connect();
GroundTruthUDPListener_->subscribe(WHISPER::MsgTopics::TRACK);
client_ = std::make_unique<DirectCommunication::DirectCommunicationClient>(ParentPort_,ParentIPAddress_);
client_ = std::make_unique<DirectCommunication::DirectCommunicationClient>(ParentPort_,ParentIPAddress_,this->OwnID_.getUUID());
client_->registerMessageCallback(std::bind(&Sensor::handlServerMessages,this,std::placeholders::_1));
client_->sendMessage("Hello Server");

49
src/Entities/SensorControl.cpp Normal file
View File

@@ -0,0 +1,49 @@
#include "Entities/Tracklist/Tracklist.hpp"
#include "nlohmann/json_fwd.hpp"
#include <Entities/SensorControl.hpp>
#include <memory>
#include <string>
namespace Entities
{
SensorControl::SensorControl(std::string ID, std::string Name, std::string IP, SimCore::SensorKinds sensorKind):
ID_(ID),IP_(IP),Name_(Name),SensorKind_(sensorKind)
{
TrackStore = std::make_unique<TrackList::TrackList>();
}
std::string SensorControl::getName()
{
return Name_;
}
std::string SensorControl::getID()
{
return ID_;
}
SimCore::SensorKinds SensorControl::getSensorKind()
{
return SensorKind_;
}
void SensorControl::updateStatus(SimCore::Status status)
{
SensorSatus_ = status;
}
SimCore::Status SensorControl::getSensorStatus()
{
return SensorSatus_;
}
}

158
src/Entities/SensorManager.cpp Normal file
View File

@@ -0,0 +1,158 @@
#include "Entities/SensorControl.hpp"
#include "SimCore/Messages/SimTrack.hpp"
#include "SimCore/SimCore.hpp"
#include "WHISPER/Messages/Message.hpp"
#include "nlohmann/json_fwd.hpp"
#include <Entities/SensorManager.hpp>
#include <memory>
#include <string>
#include <utility>
namespace Entities
{
SensorManager::SensorManager(SimCore::Identifier OwnID,std::shared_ptr<kubecontrol::PodController> PodController,ushort sensorPort):
OwnId_(OwnID),PodController_(PodController)
{
SensorServer_ = std::make_shared<DirectCommunication::DirectCommunicationServer>(SensorPort_,OwnID.getUUID());
SensorServer_->registerMessageCallback(std::bind(&SensorManager::handlSensorMessages,this,std::placeholders::_1));
}
void SensorManager::startSensor(std::shared_ptr<kubecontrol::KubePod> pod,SimCore::SensorKinds SensorKind)
{
PodController_->startPod(pod);
SensorStore[pod->getUUID()] = std::make_unique<Entities::SensorControl>(pod->getUUID(),pod->getName(),pod->getIp(),SensorKind);
}
void SensorManager::stopSenser(std::string uuid)
{
//TODO send stop message to sensor
}
void SensorManager::deleteSensor(std::string uuid)
{
PodController_->stopPod(uuid);
SensorStore.erase(uuid);
}
void SensorManager::handlSensorMessages(std::string Message)
{
WHISPER::Message msg(Message);
switch (msg.msgType_)
{
case WHISPER::MsgType::SIM_TRACK:
{
auto track = std::make_shared<SimCore::SimTrack>(SimCore::SimTrack::unpack(msg));
updateTracklistForSensor(msg.senderUUID_, track);
break;
}
case WHISPER::MsgType::SYSTEMSTATE_UPDATE:
{
break;
}
}
}
void SensorManager::updateTracklistForSensor(std::string uuidSensor, std::shared_ptr<SimCore::SimTrack> track)
{
auto it = SensorStore.find(uuidSensor);
it->second->TrackStore->addTrack(track);
}
std::string SensorManager::getTracklistStringBySensor()
{
nlohmann::json result;
nlohmann::json radar;
radar["SensorType"] = SimCore::toString(SimCore::SensorKinds::RADAR);
nlohmann::json esm;
esm["SensorType"] = SimCore::toString(SimCore::SensorKinds::ESM);
nlohmann::json sonar;
sonar["SensorType"] = SimCore::toString(SimCore::SensorKinds::SONAR);
nlohmann::json visual;
visual["SensorType"] = SimCore::toString(SimCore::SensorKinds::VISUAL);
for(const auto& [key, value] : SensorStore )
{
nlohmann::json sensor;
sensor["SensorName"] = value->getName();
sensor["SensorID"] = value->getID();
sensor["SensorStatus"] = SimCore::toString(value->getSensorStatus());
sensor["SensorEnabled"] = "false";
if (value->getSensorStatus() == SimCore::Status::ACTIVE)
{
sensor["SensorEnabled"] = "true";
}
sensor["SensorDamaged"] = "false";
if (value->getSensorStatus() == SimCore::Status::DEFEKT || value->getSensorStatus() == SimCore::Status::DEGRADED)
{
sensor["SensorDamaged"] = "true";
}
nlohmann::json contacts;
value->TrackStore->getJsonTRackList(contacts);
sensor["SensorContacts"].push_back(contacts);
switch (value->getSensorKind()) {
case SimCore::SensorKinds::RADAR:
{
radar["Sensors"].push_back(sensor);
break;
}
case SimCore::SensorKinds::ESM :
{
esm["Sensors"].push_back(sensor);
break;
}
case SimCore::SensorKinds::SONAR :
{
sonar["Sensors"].push_back(sensor);
break;
}
case SimCore::SensorKinds::VISUAL :
{
visual["Sensors"].push_back(sensor);
break;
}
}
result.push_back(radar);
result.push_back(esm);
result.push_back(sonar);
result.push_back(visual);
}
return result.dump();
}
std::string SensorManager::getTracklistStringFusioned()
{
}
}

3
tests/test_EntityClass.cpp
View File

@@ -15,6 +15,7 @@
// SimCore::Identifier OwnID, SimCore::Identifier ParentID, SimCore::SensorKinds SensorKind,std::uint32_t GroundTruthPort, std::uint32_t ParentPort,std::string ParentIPAddress
class Ship : public Entities::Entity
{
public:
Ship(SimCore::Identifier OwnID,
std::string EntityName,
@@ -23,7 +24,7 @@ class Ship : public Entities::Entity
std::uint32_t GroundTruthPort,
ushort CommandPort
):
Entity( OwnID,EntityName,ownType, 10000, EntityKind,SimCore::Side::EntitySide::FRIEND, "127.0.0.1",GroundTruthPort, CommandPort,false)
Entity( OwnID,EntityName,ownType, 10000, EntityKind,SimCore::Side::EntitySide::FRIEND, "127.0.0.1",GroundTruthPort, CommandPort, 5557,false)
{
SimCore::Position pos1;
pos1.setGeodesicPos(55, 6, 0);