KSat/fsfw
15
4
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests 1 Releases Wiki Activity

Merge branch 'mueller_framework' into front_branch

Browse Source
This commit is contained in:
Robin Müller 2020-06-26 13:33:19 +02:00
commit 71f997888b
7 changed files with 90 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
container/HybridIterator.h
View File

@ -1,5 +1,5 @@
#ifndef HYBRIDITERATOR_H_
#define HYBRIDITERATOR_H_
#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
#include <framework/container/ArrayList.h>
#include <framework/container/SinglyLinkedList.h>
@ -17,23 +17,23 @@ public:
}
HybridIterator(LinkedElement<T> *start) :
LinkedElement<T>::Iterator(start), value(
start->value), linked(true), end(NULL) {
LinkedElement<T>::Iterator(start), value(start->value),
linked(true) {
}
HybridIterator(typename ArrayList<T, count_t>::Iterator start,
typename ArrayList<T, count_t>::Iterator end) :
ArrayList<T, count_t>::Iterator(start), value(start.value), linked(
false), end(end.value) {
ArrayList<T, count_t>::Iterator(start), value(start.value),
linked(false), end(end.value) {
if (value == this->end) {
value = NULL;
}
}
HybridIterator(T *firstElement, T *lastElement) :
ArrayList<T, count_t>::Iterator(firstElement), value(firstElement), linked(
false), end(++lastElement) {
ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
linked(false), end(++lastElement) {
if (value == end) {
value = NULL;
}
@ -42,17 +42,17 @@ public:
HybridIterator& operator++() {
if (linked) {
LinkedElement<T>::Iterator::operator++();
if (LinkedElement<T>::Iterator::value != NULL) {
if (LinkedElement<T>::Iterator::value != nullptr) {
value = LinkedElement<T>::Iterator::value->value;
} else {
value = NULL;
value = nullptr;
}
} else {
ArrayList<T, count_t>::Iterator::operator++();
value = ArrayList<T, count_t>::Iterator::value;
if (value == end) {
value = NULL;
value = nullptr;
}
}
return *this;
@ -64,11 +64,11 @@ public:
return tmp;
}
bool operator==(const HybridIterator& other) {
bool operator==(const HybridIterator& other) const {
return value == other.value;
}
bool operator!=(const HybridIterator& other) {
bool operator!=(const HybridIterator& other) const {
return !(*this == other);
}
@ -87,4 +87,4 @@ private:
T *end = nullptr;
};
#endif /* HYBRIDITERATOR_H_ */
#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */

25
container/SinglyLinkedList.h
View File

@ -16,8 +16,13 @@ public:
class Iterator {
public:
LinkedElement<T> *value = nullptr;
//! Creates an uninitialized iterator which points to nullptr.
Iterator() {}
/**
* Initialize iterator at specified linked element.
* @param element
*/
Iterator(LinkedElement<T> *element) :
value(element) {
}
@ -72,6 +77,11 @@ private:
LinkedElement *next;
};
/**
* @brief SinglyLinkedList data structure which keeps a pointer to its
* first element to perform all operations.
* @tparam T
*/
template<typename T>
class SinglyLinkedList {
public:
@ -88,14 +98,19 @@ public:
ElementIterator begin() const {
return ElementIterator::Iterator(start);
}
typename ElementIterator::Iterator end() const {
return ElementIterator::Iterator();
ElementIterator end() const {
LinkedElement<T> *element = start;
while (element != nullptr) {
element = element->getNext();
}
return ElementIterator::Iterator(element);
}
uint32_t getSize() const {
uint32_t size = 0;
size_t getSize() const {
size_t size = 0;
LinkedElement<T> *element = start;
while (element != NULL) {
while (element != nullptr) {
size++;
element = element->getNext();
}

73
housekeeping/HousekeepingMessage.cpp
View File

@ -1,67 +1,48 @@
#include <framework/housekeeping/HousekeepingMessage.h>
#include <cstring>
HousekeepingMessage::HousekeepingMessage(): CommandMessage() {
}
HousekeepingMessage::~HousekeepingMessage() {}
void HousekeepingMessage::setParameter(uint32_t parameter) {
std::memcpy(getData(), &parameter, sizeof(parameter));
}
uint32_t HousekeepingMessage::getParameter() const {
uint32_t parameter;
std::memcpy(&parameter, getData(), sizeof(parameter));
return parameter;
}
void HousekeepingMessage::setHkReportMessage(sid_t sid,
void HousekeepingMessage::setHkReportMessage(CommandMessage* message, sid_t sid,
store_address_t storeId) {
CommandMessage::setCommand(HK_REPORT);
setSid(sid);
setParameter(storeId.raw);
message->setCommand(HK_REPORT);
message->setMessageSize(HK_MESSAGE_SIZE);
setSid(message, sid);
setParameter(message, storeId.raw);
}
void HousekeepingMessage::setHkDiagnosticsMessage(sid_t sid,
store_address_t storeId) {
CommandMessage::setCommand(DIAGNOSTICS_REPORT);
setSid(sid);
setParameter(storeId.raw);
void HousekeepingMessage::setHkDiagnosticsMessage(CommandMessage* message,
sid_t sid, store_address_t storeId) {
message->setCommand(DIAGNOSTICS_REPORT);
message->setMessageSize(HK_MESSAGE_SIZE);
setSid(message, sid);
setParameter(message, storeId.raw);
}
//size_t HousekeepingMessage::getMinimumMessageSize() const {
// return HK_MESSAGE_SIZE;
//}
sid_t HousekeepingMessage::getHkReportMessage(const CommandMessage *message,
store_address_t *storeIdToSet) {
if(storeIdToSet != nullptr) {
*storeIdToSet = getParameter(message);
}
return getSid(message);
}
sid_t HousekeepingMessage::getSid() const {
sid_t HousekeepingMessage::getSid(const CommandMessage* message) {
sid_t sid;
std::memcpy(&sid.raw, CommandMessage::getData(), sizeof(sid.raw));
std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
return sid;
}
sid_t HousekeepingMessage::getHkReportMessage(
store_address_t *storeIdToSet) const {
if(storeIdToSet != nullptr) {
*storeIdToSet = getParameter();
}
return getSid();
}
void HousekeepingMessage::setSid(sid_t sid) {
std::memcpy(CommandMessage::getData(), &sid.raw, sizeof(sid.raw));
void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
}
uint8_t* HousekeepingMessage::getData() {
return CommandMessage::getData() + sizeof(sid_t);
void HousekeepingMessage::setParameter(CommandMessage *message,
uint32_t parameter) {
message->setParameter3(parameter);
}
const uint8_t* HousekeepingMessage::getData() const {
return CommandMessage::getData() + sizeof(sid_t);
}
void HousekeepingMessage::clear() {
// clear IPC store where it is needed.
uint32_t HousekeepingMessage::getParameter(const CommandMessage *message) {
return message->getParameter3();
}

27
housekeeping/HousekeepingMessage.h
View File

@ -34,7 +34,7 @@ union sid_t {
* This message is slightly larger than regular command messages to accomodate
* the uint64_t structure ID (SID).
*/
class HousekeepingMessage : public CommandMessage {
class HousekeepingMessage {
public:
static constexpr size_t HK_MESSAGE_SIZE = CommandMessageIF::HEADER_SIZE +
@ -45,7 +45,7 @@ public:
* the message data, see CommandMessageIF and getInternalMessage().
* @param message
*/
HousekeepingMessage();
HousekeepingMessage() = delete;
virtual ~HousekeepingMessage();
static constexpr uint8_t MESSAGE_ID = messagetypes::HOUSEKEEPING;
@ -94,25 +94,22 @@ public:
static constexpr Command_t MODIFY_DIAGNOSTICS_REPORT_COLLECTION_INTERVAL =
MAKE_COMMAND_ID(32);
static sid_t getSid(const CommandMessage* message);
void setParameter(uint32_t parameter);
uint32_t getParameter() const;
sid_t getSid() const;
static void setHkReportMessage(CommandMessage* message, sid_t sid,
store_address_t storeId);
static void setHkDiagnosticsMessage(CommandMessage* message, sid_t sid,
store_address_t storeId);
void setHkReportMessage(sid_t sid, store_address_t storeId);
void setHkDiagnosticsMessage(sid_t sid, store_address_t storeId);
//! Get the respective SID and store ID. Command ID can be used beforehand
//! to distinguish between diagnostics and regular HK packets
sid_t getHkReportMessage(store_address_t * storeIdToSet) const;
static sid_t getHkReportMessage(const CommandMessage* message,
store_address_t * storeIdToSet);
//virtual size_t getMinimumMessageSize() const override;
virtual void clear() override;
private:
void setSid(sid_t sid);
virtual uint8_t* getData() override;
virtual const uint8_t* getData() const override;
static void setSid(CommandMessage* message, sid_t sid);
static void setParameter(CommandMessage* message, uint32_t parameter);
static uint32_t getParameter(const CommandMessage* message);
};

12
ipc/CommandMessage.cpp
View File

@ -52,6 +52,18 @@ void CommandMessage::setParameter2(uint32_t parameter2) {
sizeof(parameter2));
}
uint32_t CommandMessage::getParameter3() const {
uint32_t parameter3;
std::memcpy(&parameter3, this->getData() + 2 * sizeof(uint32_t),
sizeof(parameter3));
return parameter3;
}
void CommandMessage::setParameter3(uint32_t parameter3) {
std::memcpy(this->getData() + 2 * sizeof(uint32_t), &parameter3,
sizeof(parameter3));
}
size_t CommandMessage::getMinimumMessageSize() const {
return MINIMUM_COMMAND_MESSAGE_SIZE;
}

14
ipc/CommandMessage.h
View File

@ -66,29 +66,21 @@ public:
virtual uint8_t* getData() override;
virtual const uint8_t* getData() const override;
/**
* Get the first parameter of the message
* @return the first Parameter of the message
*/
uint32_t getParameter() const;
/**
* Set the first parameter of the message
* @param the first parameter of the message
*/
void setParameter(uint32_t parameter1);
/**
* Get the second parameter of the message
* @return the second Parameter of the message
*/
uint32_t getParameter2() const;
/**
* Set the second parameter of the message
* @param the second parameter of the message
*/
void setParameter2(uint32_t parameter2);
uint32_t getParameter3() const;
void setParameter3(uint32_t parameter3);
/**
* check if a message was cleared

5
tasks/FixedSlotSequence.h
View File

@ -6,9 +6,6 @@
#include <set>
using SlotList = std::multiset<FixedSequenceSlot>;
using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
/**
* @brief This class is the representation of a Polling Sequence Table in software.
* @details
@ -27,6 +24,8 @@ using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
*/
class FixedSlotSequence {
public:
using SlotList = std::multiset<FixedSequenceSlot>;
using SlotListIter = std::multiset<FixedSequenceSlot>::iterator;
/**
* @brief The constructor of the FixedSlotSequence object.