2021-07-13 20:22:54 +02:00
|
|
|
#include "fsfw/power/PowerComponent.h"
|
2022-02-02 10:29:30 +01:00
|
|
|
|
2021-07-13 20:22:54 +02:00
|
|
|
#include "fsfw/serialize/SerializeAdapter.h"
|
2018-07-12 16:29:32 +02:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
PowerComponent::PowerComponent() : switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(false) {}
|
2021-03-07 01:35:55 +01:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
PowerComponent::PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max,
|
|
|
|
uint8_t switchId1, bool twoSwitches, uint8_t switchId2)
|
|
|
|
: deviceObjectId(setId),
|
|
|
|
switchId1(switchId1),
|
|
|
|
switchId2(switchId2),
|
|
|
|
doIHaveTwoSwitches(twoSwitches),
|
|
|
|
minPower(min),
|
|
|
|
maxPower(max),
|
|
|
|
moduleId(moduleId) {}
|
2020-12-03 18:29:28 +01:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size, size_t maxSize,
|
|
|
|
Endianness streamEndianness) const {
|
|
|
|
ReturnValue_t result =
|
|
|
|
SerializeAdapter::serialize(&minPower, buffer, size, maxSize, streamEndianness);
|
2022-08-15 20:28:16 +02:00
|
|
|
if (result != returnvalue::OK) {
|
2022-02-02 10:29:30 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
return SerializeAdapter::serialize(&maxPower, buffer, size, maxSize, streamEndianness);
|
2018-07-12 16:29:32 +02:00
|
|
|
}
|
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
size_t PowerComponent::getSerializedSize() const { return sizeof(minPower) + sizeof(maxPower); }
|
2018-07-12 16:29:32 +02:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
object_id_t PowerComponent::getDeviceObjectId() { return deviceObjectId; }
|
2018-07-12 16:29:32 +02:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
uint8_t PowerComponent::getSwitchId1() { return switchId1; }
|
2018-07-12 16:29:32 +02:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
uint8_t PowerComponent::getSwitchId2() { return switchId2; }
|
2018-07-12 16:29:32 +02:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
bool PowerComponent::hasTwoSwitches() { return doIHaveTwoSwitches; }
|
2018-07-12 16:29:32 +02:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
float PowerComponent::getMin() { return minPower; }
|
2018-07-12 16:29:32 +02:00
|
|
|
|
2022-02-02 10:29:30 +01:00
|
|
|
float PowerComponent::getMax() { return maxPower; }
|
2018-07-12 16:29:32 +02:00
|
|
|
|
2020-04-21 22:28:43 +02:00
|
|
|
ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
|
2022-02-02 10:29:30 +01:00
|
|
|
Endianness streamEndianness) {
|
|
|
|
ReturnValue_t result = SerializeAdapter::deSerialize(&minPower, buffer, size, streamEndianness);
|
2022-08-15 20:28:16 +02:00
|
|
|
if (result != returnvalue::OK) {
|
2022-02-02 10:29:30 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
return SerializeAdapter::deSerialize(&maxPower, buffer, size, streamEndianness);
|
2018-07-12 16:29:32 +02:00
|
|
|
}
|
|
|
|
|
2021-01-29 22:45:53 +01:00
|
|
|
ReturnValue_t PowerComponent::getParameter(uint8_t domainId, uint8_t uniqueId,
|
2022-02-02 10:29:30 +01:00
|
|
|
ParameterWrapper* parameterWrapper,
|
|
|
|
const ParameterWrapper* newValues,
|
|
|
|
uint16_t startAtIndex) {
|
|
|
|
if (domainId != moduleId) {
|
|
|
|
return INVALID_DOMAIN_ID;
|
|
|
|
}
|
|
|
|
switch (uniqueId) {
|
|
|
|
case 0:
|
|
|
|
parameterWrapper->set<>(minPower);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
parameterWrapper->set<>(maxPower);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return INVALID_IDENTIFIER_ID;
|
|
|
|
}
|
2022-08-15 20:28:16 +02:00
|
|
|
return returnvalue::OK;
|
2018-07-12 16:29:32 +02:00
|
|
|
}
|