fsfw/datapoollocal/LocalDataPoolManager.h

283 lines
9.8 KiB
C
Raw Normal View History

2020-07-09 00:59:10 +02:00
#ifndef FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
#define FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
2020-09-06 14:57:05 +02:00
#include "HasLocalDataPoolIF.h"
#include "../housekeeping/HousekeepingPacketDownlink.h"
2020-09-06 14:57:05 +02:00
#include "../housekeeping/HousekeepingMessage.h"
#include "../datapool/DataSetIF.h"
2020-09-06 14:57:05 +02:00
#include "../datapool/PoolEntry.h"
#include "../objectmanager/SystemObjectIF.h"
#include "../ipc/MutexIF.h"
#include "../ipc/CommandMessage.h"
#include "../ipc/MessageQueueIF.h"
#include "../ipc/MutexHelper.h"
2020-05-17 01:17:11 +02:00
#include <map>
2020-08-23 21:00:25 +02:00
namespace Factory {
void setStaticFrameworkObjectIds();
}
class LocalDataSetBase;
2020-06-19 03:03:17 +02:00
2020-08-23 21:00:25 +02:00
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
2020-07-09 00:59:10 +02:00
* the HasLocalDataPoolIF.
2020-06-07 02:22:18 +02:00
*
* 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.
2020-08-08 19:56:42 +02:00
* @author R. Mueller
2020-06-07 02:22:18 +02:00
*/
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;
2020-08-08 12:51:31 +02:00
friend class LocalPoolDataSetBase;
2020-08-23 21:00:25 +02:00
friend void (Factory::setStaticFrameworkObjectIds)();
2020-05-17 01:17:11 +02:00
public:
2020-06-19 03:03:17 +02:00
static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x0);
static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x1);
2020-06-30 21:22:26 +02:00
static constexpr ReturnValue_t QUEUE_OR_DESTINATION_NOT_SET = MAKE_RETURN_CODE(0x2);
2020-05-17 01:17:11 +02:00
2020-06-30 21:22:26 +02:00
/**
* This constructor is used by a class which wants to implement
* a personal local data pool. The queueToUse can be supplied if it
* is already known.
*
* initialize() has to be called in any case before using the object!
* @param owner
* @param queueToUse
* @param appendValidityBuffer
*/
2020-07-09 00:59:10 +02:00
LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
2020-06-30 21:22:26 +02:00
bool appendValidityBuffer = true);
2020-07-09 00:59:10 +02:00
virtual~ LocalDataPoolManager();
2020-06-30 21:22:26 +02:00
/**
* Initializes the map by calling the map initialization function of the
2020-07-09 00:59:10 +02:00
* owner and assigns the queue to use.
2020-06-30 21:22:26 +02:00
* @param queueToUse
2020-08-08 19:43:28 +02:00
* @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
2020-06-30 21:22:26 +02:00
* @return
*/
2020-08-24 22:08:27 +02:00
ReturnValue_t initialize(MessageQueueIF* queueToUse);
ReturnValue_t initializeAfterTaskCreation(uint8_t nonDiagInvlFactor = 5);
2020-08-08 19:43:28 +02:00
2020-08-23 23:24:48 +02:00
/**
* @return
*/
ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
float collectionInterval, bool isDiagnostics,
object_id_t packetDestination = defaultHkDestination);
2020-08-08 19:43:28 +02:00
/**
* Non-Diagnostics packets usually have a lower minimum sampling frequency
* than diagnostic packets.
* A factor can be specified to determine the minimum sampling frequency
* for non-diagnostic packets. The minimum sampling frequency of the
* diagnostics packets,which is usually jusst the period of the
* performOperation calls, is multiplied with that factor.
* @param factor
*/
void setNonDiagnosticIntervalFactor(uint8_t nonDiagInvlFactor);
2020-07-09 16:31:33 +02:00
2020-07-09 00:59:10 +02:00
/**
* This should be called in the periodic handler of the owner.
* It performs all the periodic functionalities of the data pool manager.
* @return
*/
ReturnValue_t performHkOperation();
2020-05-17 01:17:11 +02:00
2020-06-30 21:22:26 +02:00
/**
* Generate a housekeeping packet with a given SID.
* @param sid
* @return
*/
2020-08-24 22:08:27 +02:00
ReturnValue_t generateHousekeepingPacket(sid_t sid,
float collectionInterval = 0,
MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
ReturnValue_t generateSetStructurePacket(sid_t sid);
ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
2020-05-17 01:17:11 +02:00
/**
* 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();
2020-07-09 00:59:10 +02:00
const HasLocalDataPoolIF* 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);
2020-07-09 00:59:10 +02:00
/**
* Different types of housekeeping reporting are possible.
2020-07-16 11:45:23 +02:00
* 1. PERIODIC: HK packets are generated in fixed intervals and sent to
* destination. Fromat will be raw.
* 2. UPDATED: Notification will be sent out if HK data has changed.
* Question: Send Raw data directly or just the message?
* 3. REQUESTED: HK packets are only generated if explicitely requested.
* Propably not necessary, just use multiple local data sets or
* shared datasets.
*
* Notifications should also be possible for single variables instead of
* full dataset updates.
2020-07-09 00:59:10 +02:00
*/
enum class ReportingType: uint8_t {
2020-08-23 21:52:44 +02:00
//! Periodic generation of HK packets.
2020-07-09 00:59:10 +02:00
PERIODIC,
2020-08-23 21:52:44 +02:00
//! Update notification will be sent out as message.
2020-08-23 21:00:25 +02:00
UPDATE_NOTIFICATION,
2020-08-23 21:52:44 +02:00
//! Notification will be sent out as message and a snapshot of the
//! current data will be generated.
2020-08-23 21:00:25 +02:00
UPDATE_SNAPSHOT,
2020-07-09 00:59:10 +02:00
};
2020-06-30 21:22:26 +02:00
/* Copying forbidden */
LocalDataPoolManager(const LocalDataPoolManager &) = delete;
LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
2020-07-09 00:59:10 +02:00
2020-06-05 20:35:08 +02:00
private:
2020-07-09 00:59:10 +02:00
LocalDataPool localPoolMap;
2020-08-08 19:43:28 +02:00
//! Every housekeeping data manager has a mutex to protect access
//! to it's data pool.
2020-07-09 00:59:10 +02:00
MutexIF* mutex = nullptr;
/** The class which actually owns the manager (and its datapool). */
HasLocalDataPoolIF* owner = nullptr;
2020-08-08 19:43:28 +02:00
uint8_t nonDiagnosticIntervalFactor = 0;
dur_millis_t regularMinimumInterval = 0;
dur_millis_t diagnosticMinimumInterval = 0;
2020-08-23 21:00:25 +02:00
/** Default receiver for periodic HK packets */
static object_id_t defaultHkDestination;
2020-08-24 22:08:27 +02:00
MessageQueueId_t defaultHkDestinationId = MessageQueueIF::NO_QUEUE;
2020-08-23 21:00:25 +02:00
2020-08-08 19:43:28 +02:00
/** The data pool manager will keep an internal map of HK receivers. */
2020-07-09 00:59:10 +02:00
struct HkReceiver {
2020-08-08 19:56:42 +02:00
/** Different member of this union will be used depending on the
type of data the receiver is interested in (full datasets or
single data variables. */
union DataId {
2020-08-23 23:24:48 +02:00
DataId(): dataSetSid() {}
2020-08-08 19:56:42 +02:00
/** Will be initialized to INVALID_ADDRESS */
sid_t dataSetSid;
lp_id_t localPoolId = HasLocalDataPoolIF::NO_POOL_ID;
};
DataId dataId;
2020-07-09 00:59:10 +02:00
ReportingType reportingType = ReportingType::PERIODIC;
2020-08-23 23:24:48 +02:00
MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
2020-08-08 19:43:28 +02:00
bool reportingEnabled = true;
2020-07-09 00:59:10 +02:00
/** Different members of this union will be used depending on reporting
2020-08-08 19:56:42 +02:00
type */
2020-08-08 19:43:28 +02:00
union HkParameter {
2020-07-09 00:59:10 +02:00
/** This parameter will be used for the PERIODIC type */
2020-08-24 22:08:27 +02:00
uint32_t collectionIntervalTicks = 0;
2020-07-09 00:59:10 +02:00
/** This parameter will be used for the ON_UPDATE type */
bool hkDataChanged;
};
2020-08-08 19:43:28 +02:00
HkParameter hkParameter;
bool isDiagnostics;
2020-08-08 19:56:42 +02:00
/** General purpose counter which is used for periodic generation. */
2020-08-08 19:43:28 +02:00
uint32_t intervalCounter;
2020-07-09 00:59:10 +02:00
};
/** Using a multimap as the same object might request multiple datasets */
using HkReceiversMap = std::multimap<object_id_t, struct HkReceiver>;
HkReceiversMap hkReceiversMap;
/** This is the map holding the actual data. Should only be initialized
* once ! */
bool mapInitialized = false;
/** This specifies whether a validity buffer is appended at the end
* of generated housekeeping packets. */
bool appendValidityBuffer = true;
2020-06-30 21:22:26 +02:00
/**
* @brief Queue used for communication, for example commands.
* Is also used to send messages. Can be set either in the constructor
* or in the initialize() function.
*/
2020-06-19 03:03:17 +02:00
MessageQueueIF* hkQueue = nullptr;
2020-06-30 21:22:26 +02:00
/** Global IPC store is used to store all packets. */
2020-06-07 18:53:55 +02:00
StorageManagerIF* ipcStore = 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);
ReturnValue_t serializeHkPacketIntoStore(
HousekeepingPacketDownlink& hkPacket,
store_address_t *storeId);
2020-08-08 19:43:28 +02:00
uint32_t intervalSecondsToInterval(bool isDiagnostics,
float collectionIntervalSeconds);
float intervalToIntervalSeconds(bool isDiagnostics,
uint32_t collectionInterval);
void performPeriodicHkGeneration(HkReceiver* hkReceiver);
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-07-09 00:59:10 +02:00
auto poolIter = localPoolMap.find(localPoolId);
if (poolIter == localPoolMap.end()) {
sif::warning << "HousekeepingManager::fechPoolEntry: Pool entry "
"not found." << std::endl;
2020-06-19 03:03:17 +02:00
return 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-19 03:03:17 +02:00
return 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-07-09 00:59:10 +02:00
#endif /* FRAMEWORK_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */