fsfw/datapoollocal/LocalDataPoolManager.h

132 lines
4.3 KiB
C
Raw Normal View History

2020-05-17 01:17:11 +02:00
#ifndef FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_
#define FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_
#include <framework/datapool/DataSetIF.h>
#include <framework/objectmanager/SystemObjectIF.h>
#include <framework/ipc/MutexIF.h>
2020-06-05 20:35:08 +02:00
#include <framework/housekeeping/HousekeepingMessage.h>
2020-05-17 01:17:11 +02:00
#include <framework/datapool/PoolEntry.h>
2020-06-07 02:22:18 +02:00
#include <framework/datapoollocal/OwnsLocalDataPoolIF.h>
2020-05-17 01:17:11 +02:00
#include <framework/ipc/CommandMessage.h>
#include <framework/ipc/MessageQueueIF.h>
#include <framework/ipc/MutexHelper.h>
#include <map>
2020-06-07 02:22:18 +02:00
/**
* @brief This class is the managing instance for local data pool.
* @details
* The actual data pool structure is a member of this class. Any class which
* has a local data pool shall have this class as a member and implement
* the OwnsLocalDataPoolIF.
*
* Users of the data pool use the helper classes LocalDataSet,
* LocalPoolVariable and LocalPoolVector to access pool entries in
* a thread-safe and efficient way.
*
* The local data pools employ a blackboard logic: Only the most recent
* value is stored. The helper classes offer a read() and commit() interface
* through the PoolVariableIF which is used to read and update values.
* Each pool entry has a valid state too.
*
*/
class LocalDataPoolManager {
2020-06-05 20:35:08 +02:00
template<typename T>
friend class LocalPoolVar;
template<typename T, uint16_t vecSize>
friend class LocalPoolVector;
friend class LocalDataSet;
2020-05-17 01:17:11 +02:00
public:
static constexpr float MINIMAL_SAMPLING_FREQUENCY = 0.2;
2020-06-07 02:22:18 +02:00
LocalDataPoolManager(OwnsLocalDataPoolIF* owner);
virtual~ LocalDataPoolManager();
2020-05-17 01:17:11 +02:00
// propably will just call respective local data set functions.
2020-06-05 20:35:08 +02:00
void generateHousekeepingPacket(sid_t sid);
2020-05-17 01:17:11 +02:00
ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
/**
* This function is used to fill the local data pool map with pool
2020-06-05 20:35:08 +02:00
* entries. It should only be called once by the pool owner.
2020-05-17 01:17:11 +02:00
* @param localDataPoolMap
* @return
*/
ReturnValue_t initializeHousekeepingPoolEntriesOnce();
void setHkPacketQueue(MessageQueueIF* msgQueue);
2020-06-07 02:22:18 +02:00
const OwnsLocalDataPoolIF* getOwner() const;
2020-05-17 01:17:11 +02:00
2020-06-05 20:35:08 +02:00
ReturnValue_t printPoolEntry(lp_id_t localPoolId);
private:
2020-05-17 01:17:11 +02:00
//! This is the map holding the actual data. Should only be initialized
//! once !
bool mapInitialized = false;
2020-06-07 02:22:18 +02:00
LocalDataPool localDpMap;
2020-05-17 01:17:11 +02:00
//! Every housekeeping data manager has a mutex to protect access
//! to it's data pool.
MutexIF * mutex = nullptr;
//! The class which actually owns the manager (and its datapool).
2020-06-07 02:22:18 +02:00
OwnsLocalDataPoolIF* owner = nullptr;
2020-05-17 01:17:11 +02:00
//! Used for replies.
//! (maybe we dont need this, the sender can be retrieved from command
//! message..)
MessageQueueIF* hkReplyQueue = nullptr;
//! Used for HK packets, which are generated without requests.
2020-06-05 20:35:08 +02:00
//! Maybe this will just be the TM funnel.
2020-05-17 01:17:11 +02:00
MessageQueueIF* hkPacketQueue = nullptr;
2020-06-05 20:35:08 +02:00
/**
* Get the pointer to the mutex. Can be used to lock the data pool
* eternally. Use with care and don't forget to unlock locked mutexes!
* For now, only friend classes can accss this function.
* @return
*/
MutexIF* getMutexHandle();
/**
* Read a variable by supplying its local pool ID and assign the pool
* entry to the supplied PoolEntry pointer. The type of the pool entry
* is deduced automatically. This call is not thread-safe!
* For now, only friend classes like LocalPoolVar may access this
* function.
* @tparam T Type of the pool entry
* @param localPoolId Pool ID of the variable to read
* @param poolVar [out] Corresponding pool entry will be assigned to the
* supplied pointer.
* @return
*/
2020-06-07 02:22:18 +02:00
template <class T> ReturnValue_t fetchPoolEntry(lp_id_t localPoolId,
PoolEntry<T> **poolEntry);
2020-06-05 20:35:08 +02:00
2020-06-07 02:22:18 +02:00
void setMinimalSamplingFrequency(float frequencySeconds);
2020-05-17 01:17:11 +02:00
};
2020-06-07 02:22:18 +02:00
2020-05-17 01:17:11 +02:00
template<class T> inline
2020-06-07 02:22:18 +02:00
ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
2020-06-05 20:35:08 +02:00
PoolEntry<T> **poolEntry) {
2020-05-17 01:17:11 +02:00
auto poolIter = localDpMap.find(localPoolId);
if (poolIter == localDpMap.end()) {
2020-06-05 20:35:08 +02:00
sif::debug << "HousekeepingManager::fechPoolEntry:"
" Pool entry not found." << std::endl;
2020-06-07 02:22:18 +02:00
return OwnsLocalDataPoolIF::POOL_ENTRY_NOT_FOUND;
2020-05-17 01:17:11 +02:00
}
2020-06-05 20:35:08 +02:00
*poolEntry = dynamic_cast< PoolEntry<T>* >(poolIter->second);
if(*poolEntry == nullptr) {
sif::debug << "HousekeepingManager::fetchPoolEntry:"
" Pool entry not found." << std::endl;
2020-06-07 02:22:18 +02:00
return OwnsLocalDataPoolIF::POOL_ENTRY_TYPE_CONFLICT;
2020-05-17 01:17:11 +02:00
}
return HasReturnvaluesIF::RETURN_OK;
}
2020-06-05 20:35:08 +02:00
2020-05-17 01:17:11 +02:00
#endif /* FRAMEWORK_HK_HOUSEKEEPINGHELPER_H_ */