mohr/fsfw
1
0
Fork 0
forked from fsfw/fsfw
Code Pull Requests Activity

renormalized line endings

Browse Source
This commit is contained in:
Robin Müller
2020-08-28 18:33:29 +02:00
parent 9abd796e6f
commit 1b9c8446b7
381 changed files with 38723 additions and 38723 deletions
Download Patch File Download Diff File Expand all files Collapse all files

520
power/Fuse.cpp
View File

@ -1,260 +1,260 @@
#include "../monitoring/LimitViolationReporter.h"
#include "../monitoring/MonitoringMessageContent.h"
#include "../objectmanager/ObjectManagerIF.h"
#include "../power/Fuse.h"
#include "../serialize/SerialFixedArrayListAdapter.h"
#include "../ipc/QueueFactory.h"
object_id_t Fuse::powerSwitchId = 0;
Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
float maxCurrent, uint16_t confirmationCount) :
SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
ids.pidCurrent, &set), state(ids.pidState, &set), power(
ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
NULL), parameterHelper(this), healthHelper(this, fuseObjectId) {
commandQueue = QueueFactory::instance()->createMessageQueue();
}
Fuse::~Fuse() {
QueueFactory::instance()->deleteMessageQueue(commandQueue);
}
void Fuse::addDevice(PowerComponentIF* switchSet) {
devices.push_back(switchSet);
}
ReturnValue_t Fuse::initialize() {
ReturnValue_t result = SystemObject::initialize();
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = parameterHelper.initialize();
if (result != RETURN_OK) {
return result;
}
result = healthHelper.initialize();
if (result != RETURN_OK) {
return result;
}
powerIF = objectManager->get<PowerSwitchIF>(powerSwitchId);
if (powerIF == NULL) {
return RETURN_FAILED;
}
return RETURN_OK;
}
void Fuse::calculatePowerLimits(float* low, float* high) {
for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
iter++) {
if (areSwitchesOfComponentOn(iter)) {
*low += (*iter)->getMin();
*high += (*iter)->getMax();
}
}
}
ReturnValue_t Fuse::check() {
set.read();
if (!healthHelper.healthTable->isHealthy(getObjectId())) {
setAllMonitorsToUnchecked();
set.commit(PoolVariableIF::INVALID);
return RETURN_OK;
}
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
checkFuseState();
calculateFusePower();
//Check if power is valid and if fuse state is off or invalid.
if (!power.isValid() || (state == 0) || !state.isValid()) {
result = powerMonitor.setToInvalid();
} else {
float lowLimit = 0.0;
float highLimit = RESIDUAL_POWER;
calculatePowerLimits(&lowLimit, &highLimit);
result = powerMonitor.checkPower(power, lowLimit, highLimit);
if (result == MonitoringIF::BELOW_LOW_LIMIT) {
reportEvents(POWER_BELOW_LOW_LIMIT);
} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
reportEvents(POWER_ABOVE_HIGH_LIMIT);
}
}
set.commit();
return result;
}
ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = RETURN_FAILED;
for (DeviceList::const_iterator iter = devices.begin();
iter != devices.end(); iter++) {
result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
if (result != RETURN_OK) {
return result;
}
}
return RETURN_OK;
}
size_t Fuse::getSerializedSize() const {
uint32_t size = 0;
for (DeviceList::const_iterator iter = devices.begin();
iter != devices.end(); iter++) {
size += (*iter)->getSerializedSize();
}
return size;
}
ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness) {
ReturnValue_t result = RETURN_FAILED;
for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
iter++) {
result = (*iter)->deSerialize(buffer, size, streamEndianness);
if (result != RETURN_OK) {
return result;
}
}
return RETURN_OK;
}
uint8_t Fuse::getFuseId() const {
return fuseId;
}
void Fuse::calculateFusePower() {
ReturnValue_t result1 = currentLimit.check();
if (result1 != HasReturnvaluesIF::RETURN_OK || !(voltage.isValid())) {
power.setValid(PoolVariableIF::INVALID);
return;
}
//Calculate fuse power.
power = current * voltage;
power.setValid(PoolVariableIF::VALID);
}
ReturnValue_t Fuse::performOperation(uint8_t opCode) {
checkCommandQueue();
return HasReturnvaluesIF::RETURN_OK;
}
void Fuse::reportEvents(Event event) {
if (!powerMonitor.isEventEnabled()) {
return;
}
for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
iter++) {
if (areSwitchesOfComponentOn(iter)) {
EventManagerIF::triggerEvent((*iter)->getDeviceObjectId(), event);
}
}
}
MessageQueueId_t Fuse::getCommandQueue() const {
return commandQueue->getId();
}
void Fuse::setAllMonitorsToUnchecked() {
currentLimit.setToUnchecked();
powerMonitor.setToUnchecked();
}
void Fuse::checkCommandQueue() {
CommandMessage command;
ReturnValue_t result = commandQueue->receiveMessage(&command);
if (result != HasReturnvaluesIF::RETURN_OK) {
return;
}
result = healthHelper.handleHealthCommand(&command);
if (result == HasReturnvaluesIF::RETURN_OK) {
return;
}
result = parameterHelper.handleParameterMessage(&command);
if (result == HasReturnvaluesIF::RETURN_OK) {
return;
}
command.setToUnknownCommand();
commandQueue->reply(&command);
}
void Fuse::checkFuseState() {
if (!state.isValid()) {
oldFuseState = 0;
return;
}
if (state == 0) {
if (oldFuseState != 0) {
reportEvents(FUSE_WENT_OFF);
}
}
oldFuseState = state;
}
float Fuse::getPower() {
if (power.isValid()) {
return power;
} else {
return 0.0;
}
}
void Fuse::setDataPoolEntriesInvalid() {
set.read();
set.commit(PoolVariableIF::INVALID);
}
ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
uint16_t startAtIndex) {
ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
parameterWrapper, newValues, startAtIndex);
if (result != INVALID_DOMAIN_ID) {
return result;
}
result = powerMonitor.getParameter(domainId, parameterId, parameterWrapper,
newValues, startAtIndex);
return result;
}
bool Fuse::areSwitchesOfComponentOn(DeviceList::iterator iter) {
if (powerIF->getSwitchState((*iter)->getSwitchId1())
!= PowerSwitchIF::SWITCH_ON) {
return false;
}
if ((*iter)->hasTwoSwitches()) {
if ((powerIF->getSwitchState((*iter)->getSwitchId2())
!= PowerSwitchIF::SWITCH_ON)) {
return false;
}
}
return true;
}
bool Fuse::isPowerValid() {
return power.isValid();
}
ReturnValue_t Fuse::setHealth(HealthState health) {
healthHelper.setHealth(health);
return RETURN_OK;
}
HasHealthIF::HealthState Fuse::getHealth() {
return healthHelper.getHealth();
}
ReturnValue_t Fuse::PowerMonitor::checkPower(float sample, float lowerLimit,
float upperLimit) {
if (sample > upperLimit) {
return this->monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
upperLimit);
} else if (sample < lowerLimit) {
return this->monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
lowerLimit);
} else {
return this->monitorStateIs(RETURN_OK, sample, 0.0); //Within limits.
}
}
#include "../monitoring/LimitViolationReporter.h"
#include "../monitoring/MonitoringMessageContent.h"
#include "../objectmanager/ObjectManagerIF.h"
#include "../power/Fuse.h"
#include "../serialize/SerialFixedArrayListAdapter.h"
#include "../ipc/QueueFactory.h"
object_id_t Fuse::powerSwitchId = 0;
Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
float maxCurrent, uint16_t confirmationCount) :
SystemObject(fuseObjectId), oldFuseState(0), fuseId(fuseId), powerIF(
NULL), currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount,
maxCurrent, FUSE_CURRENT_HIGH), powerMonitor(fuseObjectId, 2,
GlobalDataPool::poolIdAndPositionToPid(ids.poolIdPower, 0),
confirmationCount), set(), voltage(ids.pidVoltage, &set), current(
ids.pidCurrent, &set), state(ids.pidState, &set), power(
ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE), commandQueue(
NULL), parameterHelper(this), healthHelper(this, fuseObjectId) {
commandQueue = QueueFactory::instance()->createMessageQueue();
}
Fuse::~Fuse() {
QueueFactory::instance()->deleteMessageQueue(commandQueue);
}
void Fuse::addDevice(PowerComponentIF* switchSet) {
devices.push_back(switchSet);
}
ReturnValue_t Fuse::initialize() {
ReturnValue_t result = SystemObject::initialize();
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = parameterHelper.initialize();
if (result != RETURN_OK) {
return result;
}
result = healthHelper.initialize();
if (result != RETURN_OK) {
return result;
}
powerIF = objectManager->get<PowerSwitchIF>(powerSwitchId);
if (powerIF == NULL) {
return RETURN_FAILED;
}
return RETURN_OK;
}
void Fuse::calculatePowerLimits(float* low, float* high) {
for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
iter++) {
if (areSwitchesOfComponentOn(iter)) {
*low += (*iter)->getMin();
*high += (*iter)->getMax();
}
}
}
ReturnValue_t Fuse::check() {
set.read();
if (!healthHelper.healthTable->isHealthy(getObjectId())) {
setAllMonitorsToUnchecked();
set.commit(PoolVariableIF::INVALID);
return RETURN_OK;
}
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
checkFuseState();
calculateFusePower();
//Check if power is valid and if fuse state is off or invalid.
if (!power.isValid() || (state == 0) || !state.isValid()) {
result = powerMonitor.setToInvalid();
} else {
float lowLimit = 0.0;
float highLimit = RESIDUAL_POWER;
calculatePowerLimits(&lowLimit, &highLimit);
result = powerMonitor.checkPower(power, lowLimit, highLimit);
if (result == MonitoringIF::BELOW_LOW_LIMIT) {
reportEvents(POWER_BELOW_LOW_LIMIT);
} else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
reportEvents(POWER_ABOVE_HIGH_LIMIT);
}
}
set.commit();
return result;
}
ReturnValue_t Fuse::serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = RETURN_FAILED;
for (DeviceList::const_iterator iter = devices.begin();
iter != devices.end(); iter++) {
result = (*iter)->serialize(buffer, size, maxSize, streamEndianness);
if (result != RETURN_OK) {
return result;
}
}
return RETURN_OK;
}
size_t Fuse::getSerializedSize() const {
uint32_t size = 0;
for (DeviceList::const_iterator iter = devices.begin();
iter != devices.end(); iter++) {
size += (*iter)->getSerializedSize();
}
return size;
}
ReturnValue_t Fuse::deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness) {
ReturnValue_t result = RETURN_FAILED;
for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
iter++) {
result = (*iter)->deSerialize(buffer, size, streamEndianness);
if (result != RETURN_OK) {
return result;
}
}
return RETURN_OK;
}
uint8_t Fuse::getFuseId() const {
return fuseId;
}
void Fuse::calculateFusePower() {
ReturnValue_t result1 = currentLimit.check();
if (result1 != HasReturnvaluesIF::RETURN_OK || !(voltage.isValid())) {
power.setValid(PoolVariableIF::INVALID);
return;
}
//Calculate fuse power.
power = current * voltage;
power.setValid(PoolVariableIF::VALID);
}
ReturnValue_t Fuse::performOperation(uint8_t opCode) {
checkCommandQueue();
return HasReturnvaluesIF::RETURN_OK;
}
void Fuse::reportEvents(Event event) {
if (!powerMonitor.isEventEnabled()) {
return;
}
for (DeviceList::iterator iter = devices.begin(); iter != devices.end();
iter++) {
if (areSwitchesOfComponentOn(iter)) {
EventManagerIF::triggerEvent((*iter)->getDeviceObjectId(), event);
}
}
}
MessageQueueId_t Fuse::getCommandQueue() const {
return commandQueue->getId();
}
void Fuse::setAllMonitorsToUnchecked() {
currentLimit.setToUnchecked();
powerMonitor.setToUnchecked();
}
void Fuse::checkCommandQueue() {
CommandMessage command;
ReturnValue_t result = commandQueue->receiveMessage(&command);
if (result != HasReturnvaluesIF::RETURN_OK) {
return;
}
result = healthHelper.handleHealthCommand(&command);
if (result == HasReturnvaluesIF::RETURN_OK) {
return;
}
result = parameterHelper.handleParameterMessage(&command);
if (result == HasReturnvaluesIF::RETURN_OK) {
return;
}
command.setToUnknownCommand();
commandQueue->reply(&command);
}
void Fuse::checkFuseState() {
if (!state.isValid()) {
oldFuseState = 0;
return;
}
if (state == 0) {
if (oldFuseState != 0) {
reportEvents(FUSE_WENT_OFF);
}
}
oldFuseState = state;
}
float Fuse::getPower() {
if (power.isValid()) {
return power;
} else {
return 0.0;
}
}
void Fuse::setDataPoolEntriesInvalid() {
set.read();
set.commit(PoolVariableIF::INVALID);
}
ReturnValue_t Fuse::getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
uint16_t startAtIndex) {
ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
parameterWrapper, newValues, startAtIndex);
if (result != INVALID_DOMAIN_ID) {
return result;
}
result = powerMonitor.getParameter(domainId, parameterId, parameterWrapper,
newValues, startAtIndex);
return result;
}
bool Fuse::areSwitchesOfComponentOn(DeviceList::iterator iter) {
if (powerIF->getSwitchState((*iter)->getSwitchId1())
!= PowerSwitchIF::SWITCH_ON) {
return false;
}
if ((*iter)->hasTwoSwitches()) {
if ((powerIF->getSwitchState((*iter)->getSwitchId2())
!= PowerSwitchIF::SWITCH_ON)) {
return false;
}
}
return true;
}
bool Fuse::isPowerValid() {
return power.isValid();
}
ReturnValue_t Fuse::setHealth(HealthState health) {
healthHelper.setHealth(health);
return RETURN_OK;
}
HasHealthIF::HealthState Fuse::getHealth() {
return healthHelper.getHealth();
}
ReturnValue_t Fuse::PowerMonitor::checkPower(float sample, float lowerLimit,
float upperLimit) {
if (sample > upperLimit) {
return this->monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
upperLimit);
} else if (sample < lowerLimit) {
return this->monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
lowerLimit);
} else {
return this->monitorStateIs(RETURN_OK, sample, 0.0); //Within limits.
}
}

212
power/Fuse.h
View File

@ -1,106 +1,106 @@
#ifndef FUSE_H_
#define FUSE_H_
#include "../datapoolglob/GlobalDataSet.h"
#include "../datapoolglob/GlobalPoolVariable.h"
#include "../datapoolglob/PIDReader.h"
#include "../devicehandlers/HealthDevice.h"
#include "../monitoring/AbsLimitMonitor.h"
#include "../power/PowerComponentIF.h"
#include "../power/PowerSwitchIF.h"
#include "../returnvalues/HasReturnvaluesIF.h"
#include "../parameters/ParameterHelper.h"
#include <list>
namespace Factory {
void setStaticFrameworkObjectIds();
}
class Fuse: public SystemObject,
public HasHealthIF,
public HasReturnvaluesIF,
public ReceivesParameterMessagesIF,
public SerializeIF {
friend void (Factory::setStaticFrameworkObjectIds)();
private:
static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
public:
struct VariableIds {
uint32_t pidVoltage;
uint32_t pidCurrent;
uint32_t pidState;
uint32_t poolIdPower;
};
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, SEVERITY::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
static const Event FUSE_WENT_OFF = MAKE_EVENT(2, SEVERITY::LOW); //!< PSS detected a fuse that went off.
static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
typedef std::list<PowerComponentIF*> DeviceList;
Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
float maxCurrent, uint16_t confirmationCount = 2);
virtual ~Fuse();
void addDevice(PowerComponentIF *set);
float getPower();
bool isPowerValid();
ReturnValue_t check();
uint8_t getFuseId() const;
ReturnValue_t initialize();
DeviceList devices;
ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const override;
size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
SerializeIF::Endianness streamEndianness) override;
void setAllMonitorsToUnchecked();
ReturnValue_t performOperation(uint8_t opCode);
MessageQueueId_t getCommandQueue() const;
void setDataPoolEntriesInvalid();
ReturnValue_t setHealth(HealthState health);
HasHealthIF::HealthState getHealth();
ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper *parameterWrapper,
const ParameterWrapper *newValues, uint16_t startAtIndex);
private:
uint8_t oldFuseState;
uint8_t fuseId;
PowerSwitchIF *powerIF; //could be static in our case.
AbsLimitMonitor<float> currentLimit;
class PowerMonitor: public MonitorReporter<float> {
public:
template<typename ... Args>
PowerMonitor(Args ... args) :
MonitorReporter<float>(std::forward<Args>(args)...) {
}
ReturnValue_t checkPower(float sample, float lowerLimit,
float upperLimit);
void sendTransitionEvent(float currentValue, ReturnValue_t state) {
}
};
PowerMonitor powerMonitor;
GlobDataSet set;
PIDReader<float> voltage;
PIDReader<float> current;
PIDReader<uint8_t> state;
gp_float_t power;
MessageQueueIF* commandQueue;
ParameterHelper parameterHelper;
HealthHelper healthHelper;
static object_id_t powerSwitchId;
void calculatePowerLimits(float *low, float *high);
void calculateFusePower();
void checkFuseState();
void reportEvents(Event event);
void checkCommandQueue();
bool areSwitchesOfComponentOn(DeviceList::iterator iter);
};
#endif /* FUSE_H_ */
#ifndef FUSE_H_
#define FUSE_H_
#include "../datapoolglob/GlobalDataSet.h"
#include "../datapoolglob/GlobalPoolVariable.h"
#include "../datapoolglob/PIDReader.h"
#include "../devicehandlers/HealthDevice.h"
#include "../monitoring/AbsLimitMonitor.h"
#include "../power/PowerComponentIF.h"
#include "../power/PowerSwitchIF.h"
#include "../returnvalues/HasReturnvaluesIF.h"
#include "../parameters/ParameterHelper.h"
#include <list>
namespace Factory {
void setStaticFrameworkObjectIds();
}
class Fuse: public SystemObject,
public HasHealthIF,
public HasReturnvaluesIF,
public ReceivesParameterMessagesIF,
public SerializeIF {
friend void (Factory::setStaticFrameworkObjectIds)();
private:
static constexpr float RESIDUAL_POWER = 0.005 * 28.5; //!< This is the upper limit of residual power lost by fuses and switches. Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
public:
struct VariableIds {
uint32_t pidVoltage;
uint32_t pidCurrent;
uint32_t pidState;
uint32_t poolIdPower;
};
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_1;
static const Event FUSE_CURRENT_HIGH = MAKE_EVENT(1, SEVERITY::LOW); //!< PSS detected that current on a fuse is totally out of bounds.
static const Event FUSE_WENT_OFF = MAKE_EVENT(2, SEVERITY::LOW); //!< PSS detected a fuse that went off.
static const Event POWER_ABOVE_HIGH_LIMIT = MAKE_EVENT(4, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, SEVERITY::LOW); //!< PSS detected a fuse that violates its limits.
typedef std::list<PowerComponentIF*> DeviceList;
Fuse(object_id_t fuseObjectId, uint8_t fuseId, VariableIds ids,
float maxCurrent, uint16_t confirmationCount = 2);
virtual ~Fuse();
void addDevice(PowerComponentIF *set);
float getPower();
bool isPowerValid();
ReturnValue_t check();
uint8_t getFuseId() const;
ReturnValue_t initialize();
DeviceList devices;
ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
SerializeIF::Endianness streamEndianness) const override;
size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
SerializeIF::Endianness streamEndianness) override;
void setAllMonitorsToUnchecked();
ReturnValue_t performOperation(uint8_t opCode);
MessageQueueId_t getCommandQueue() const;
void setDataPoolEntriesInvalid();
ReturnValue_t setHealth(HealthState health);
HasHealthIF::HealthState getHealth();
ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper *parameterWrapper,
const ParameterWrapper *newValues, uint16_t startAtIndex);
private:
uint8_t oldFuseState;
uint8_t fuseId;
PowerSwitchIF *powerIF; //could be static in our case.
AbsLimitMonitor<float> currentLimit;
class PowerMonitor: public MonitorReporter<float> {
public:
template<typename ... Args>
PowerMonitor(Args ... args) :
MonitorReporter<float>(std::forward<Args>(args)...) {
}
ReturnValue_t checkPower(float sample, float lowerLimit,
float upperLimit);
void sendTransitionEvent(float currentValue, ReturnValue_t state) {
}
};
PowerMonitor powerMonitor;
GlobDataSet set;
PIDReader<float> voltage;
PIDReader<float> current;
PIDReader<uint8_t> state;
gp_float_t power;
MessageQueueIF* commandQueue;
ParameterHelper parameterHelper;
HealthHelper healthHelper;
static object_id_t powerSwitchId;
void calculatePowerLimits(float *low, float *high);
void calculateFusePower();
void checkFuseState();
void reportEvents(Event event);
void checkCommandQueue();
bool areSwitchesOfComponentOn(DeviceList::iterator iter);
};
#endif /* FUSE_H_ */

172
power/PowerComponent.cpp
View File

@ -1,86 +1,86 @@
/**
* @file PowerComponent.cpp
* @brief This file defines the PowerComponent class.
* @date 28.08.2014
* @author baetz
*/
#include "../power/PowerComponent.h"
PowerComponent::PowerComponent() :
deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(
false), min(0.0), max(0.0), moduleId(0) {
}
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), min(min), max(max), moduleId(moduleId) {
}
ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return SerializeAdapter::serialize(&max, buffer, size, maxSize,
streamEndianness);
}
size_t PowerComponent::getSerializedSize() const {
return sizeof(min) + sizeof(max);
}
object_id_t PowerComponent::getDeviceObjectId() {
return deviceObjectId;
}
uint8_t PowerComponent::getSwitchId1() {
return switchId1;
}
uint8_t PowerComponent::getSwitchId2() {
return switchId2;
}
bool PowerComponent::hasTwoSwitches() {
return doIHaveTwoSwitches;
}
float PowerComponent::getMin() {
return min;
}
float PowerComponent::getMax() {
return max;
}
ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
}
ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
uint16_t parameterId, ParameterWrapper* parameterWrapper,
const ParameterWrapper* newValues, uint16_t startAtIndex) {
if (domainId != moduleId) {
return INVALID_DOMAIN_ID;
}
switch (parameterId) {
case 0:
parameterWrapper->set<>(min);
break;
case 1:
parameterWrapper->set<>(max);
break;
default:
return INVALID_MATRIX_ID;
}
return HasReturnvaluesIF::RETURN_OK;
}
/**
* @file PowerComponent.cpp
* @brief This file defines the PowerComponent class.
* @date 28.08.2014
* @author baetz
*/
#include "../power/PowerComponent.h"
PowerComponent::PowerComponent() :
deviceObjectId(0), switchId1(0xFF), switchId2(0xFF), doIHaveTwoSwitches(
false), min(0.0), max(0.0), moduleId(0) {
}
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), min(min), max(max), moduleId(moduleId) {
}
ReturnValue_t PowerComponent::serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const {
ReturnValue_t result = SerializeAdapter::serialize(&min, buffer,
size, maxSize, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return SerializeAdapter::serialize(&max, buffer, size, maxSize,
streamEndianness);
}
size_t PowerComponent::getSerializedSize() const {
return sizeof(min) + sizeof(max);
}
object_id_t PowerComponent::getDeviceObjectId() {
return deviceObjectId;
}
uint8_t PowerComponent::getSwitchId1() {
return switchId1;
}
uint8_t PowerComponent::getSwitchId2() {
return switchId2;
}
bool PowerComponent::hasTwoSwitches() {
return doIHaveTwoSwitches;
}
float PowerComponent::getMin() {
return min;
}
float PowerComponent::getMax() {
return max;
}
ReturnValue_t PowerComponent::deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness) {
ReturnValue_t result = SerializeAdapter::deSerialize(&min, buffer,
size, streamEndianness);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return SerializeAdapter::deSerialize(&max, buffer, size, streamEndianness);
}
ReturnValue_t PowerComponent::getParameter(uint8_t domainId,
uint16_t parameterId, ParameterWrapper* parameterWrapper,
const ParameterWrapper* newValues, uint16_t startAtIndex) {
if (domainId != moduleId) {
return INVALID_DOMAIN_ID;
}
switch (parameterId) {
case 0:
parameterWrapper->set<>(min);
break;
case 1:
parameterWrapper->set<>(max);
break;
default:
return INVALID_MATRIX_ID;
}
return HasReturnvaluesIF::RETURN_OK;
}

96
power/PowerComponent.h
View File

@ -1,48 +1,48 @@
#ifndef POWERCOMPONENT_H_
#define POWERCOMPONENT_H_
#include "../objectmanager/SystemObjectIF.h"
#include "../power/PowerComponentIF.h"
class PowerComponent: public PowerComponentIF {
public:
PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max, uint8_t switchId1,
bool twoSwitches = false, uint8_t switchId2 = 0xFF);
virtual object_id_t getDeviceObjectId();
virtual uint8_t getSwitchId1();
virtual uint8_t getSwitchId2();
bool hasTwoSwitches();
float getMin();
float getMax();
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const override;
size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness) override;
ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper *parameterWrapper,
const ParameterWrapper *newValues, uint16_t startAtIndex);
private:
const object_id_t deviceObjectId;
const uint8_t switchId1;
const uint8_t switchId2;
const bool doIHaveTwoSwitches;
float min;
float max;
uint8_t moduleId;
PowerComponent();
};
#endif /* POWERCOMPONENT_H_ */
#ifndef POWERCOMPONENT_H_
#define POWERCOMPONENT_H_
#include "../objectmanager/SystemObjectIF.h"
#include "../power/PowerComponentIF.h"
class PowerComponent: public PowerComponentIF {
public:
PowerComponent(object_id_t setId, uint8_t moduleId, float min, float max, uint8_t switchId1,
bool twoSwitches = false, uint8_t switchId2 = 0xFF);
virtual object_id_t getDeviceObjectId();
virtual uint8_t getSwitchId1();
virtual uint8_t getSwitchId2();
bool hasTwoSwitches();
float getMin();
float getMax();
ReturnValue_t serialize(uint8_t** buffer, size_t* size,
size_t maxSize, Endianness streamEndianness) const override;
size_t getSerializedSize() const override;
ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
Endianness streamEndianness) override;
ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper *parameterWrapper,
const ParameterWrapper *newValues, uint16_t startAtIndex);
private:
const object_id_t deviceObjectId;
const uint8_t switchId1;
const uint8_t switchId2;
const bool doIHaveTwoSwitches;
float min;
float max;
uint8_t moduleId;
PowerComponent();
};
#endif /* POWERCOMPONENT_H_ */

48
power/PowerComponentIF.h
View File

@ -1,24 +1,24 @@
#ifndef POWERCOMPONENTIF_H_
#define POWERCOMPONENTIF_H_
#include "../serialize/SerializeIF.h"
#include "../parameters/HasParametersIF.h"
class PowerComponentIF : public SerializeIF, public HasParametersIF {
public:
virtual ~PowerComponentIF() {
}
virtual object_id_t getDeviceObjectId()=0;
virtual uint8_t getSwitchId1()=0;
virtual uint8_t getSwitchId2()=0;
virtual bool hasTwoSwitches()=0;
virtual float getMin() = 0;
virtual float getMax() = 0;
};
#endif /* POWERCOMPONENTIF_H_ */
#ifndef POWERCOMPONENTIF_H_
#define POWERCOMPONENTIF_H_
#include "../serialize/SerializeIF.h"
#include "../parameters/HasParametersIF.h"
class PowerComponentIF : public SerializeIF, public HasParametersIF {
public:
virtual ~PowerComponentIF() {
}
virtual object_id_t getDeviceObjectId()=0;
virtual uint8_t getSwitchId1()=0;
virtual uint8_t getSwitchId2()=0;
virtual bool hasTwoSwitches()=0;
virtual float getMin() = 0;
virtual float getMax() = 0;
};
#endif /* POWERCOMPONENTIF_H_ */

256
power/PowerSensor.cpp
View File

@ -1,128 +1,128 @@
#include "../power/PowerSensor.h"
#include "../ipc/QueueFactory.h"
PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
SystemObject(setId), commandQueue(NULL), parameterHelper(this), healthHelper(this, setId), set(), current(
ids.pidCurrent, &set), voltage(ids.pidVoltage, &set), power(
ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE), currentLimit(
setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
limits.currentMin, limits.currentMax, events.currentLow,
events.currentHigh), voltageLimit(setId, MODULE_ID_VOLTAGE,
ids.pidVoltage, confirmationCount, limits.voltageMin,
limits.voltageMax, events.voltageLow, events.voltageHigh) {
commandQueue = QueueFactory::instance()->createMessageQueue();
}
PowerSensor::~PowerSensor() {
QueueFactory::instance()->deleteMessageQueue(commandQueue);
}
ReturnValue_t PowerSensor::calculatePower() {
set.read();
ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
&& current.isValid()) {
result1 = voltageLimit.doCheck(voltage);
result2 = currentLimit.doCheck(current);
} else {
voltageLimit.setToInvalid();
currentLimit.setToInvalid();
result1 = OBJECT_NOT_HEALTHY;
}
if (result1 != HasReturnvaluesIF::RETURN_OK
|| result2 != HasReturnvaluesIF::RETURN_OK) {
result1 = MonitoringIF::INVALID;
power.setValid(PoolVariableIF::INVALID);
} else {
power.setValid(PoolVariableIF::VALID);
power = current * voltage;
}
set.commit();
return result1;
}
ReturnValue_t PowerSensor::performOperation(uint8_t opCode) {
checkCommandQueue();
return HasReturnvaluesIF::RETURN_OK;
}
MessageQueueId_t PowerSensor::getCommandQueue() const {
return commandQueue->getId();
}
ReturnValue_t PowerSensor::initialize() {
ReturnValue_t result = SystemObject::initialize();
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = healthHelper.initialize();
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = parameterHelper.initialize();
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return result;
}
void PowerSensor::setAllMonitorsToUnchecked() {
currentLimit.setToUnchecked();
voltageLimit.setToUnchecked();
}
void PowerSensor::checkCommandQueue() {
CommandMessage command;
ReturnValue_t result = commandQueue->receiveMessage(&command);
if (result != HasReturnvaluesIF::RETURN_OK) {
return;
}
result = healthHelper.handleHealthCommand(&command);
if (result == HasReturnvaluesIF::RETURN_OK) {
return;
}
result = parameterHelper.handleParameterMessage(&command);
if (result == HasReturnvaluesIF::RETURN_OK) {
return;
}
command.setToUnknownCommand();
commandQueue->reply(&command);
}
void PowerSensor::setDataPoolEntriesInvalid() {
set.read();
set.commit(PoolVariableIF::INVALID);
}
float PowerSensor::getPower() {
if (power.isValid()) {
return power.value;
} else {
return 0.0;
}
}
ReturnValue_t PowerSensor::setHealth(HealthState health) {
healthHelper.setHealth(health);
return HasReturnvaluesIF::RETURN_OK;
}
HasHealthIF::HealthState PowerSensor::getHealth() {
return healthHelper.getHealth();
}
ReturnValue_t PowerSensor::getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
uint16_t startAtIndex) {
ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
parameterWrapper, newValues, startAtIndex);
if (result != INVALID_DOMAIN_ID) {
return result;
}
result = voltageLimit.getParameter(domainId, parameterId, parameterWrapper,
newValues, startAtIndex);
return result;
}
#include "../power/PowerSensor.h"
#include "../ipc/QueueFactory.h"
PowerSensor::PowerSensor(object_id_t setId, VariableIds ids,
DefaultLimits limits, SensorEvents events, uint16_t confirmationCount) :
SystemObject(setId), commandQueue(NULL), parameterHelper(this), healthHelper(this, setId), set(), current(
ids.pidCurrent, &set), voltage(ids.pidVoltage, &set), power(
ids.poolIdPower, &set, PoolVariableIF::VAR_WRITE), currentLimit(
setId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
limits.currentMin, limits.currentMax, events.currentLow,
events.currentHigh), voltageLimit(setId, MODULE_ID_VOLTAGE,
ids.pidVoltage, confirmationCount, limits.voltageMin,
limits.voltageMax, events.voltageLow, events.voltageHigh) {
commandQueue = QueueFactory::instance()->createMessageQueue();
}
PowerSensor::~PowerSensor() {
QueueFactory::instance()->deleteMessageQueue(commandQueue);
}
ReturnValue_t PowerSensor::calculatePower() {
set.read();
ReturnValue_t result1 = HasReturnvaluesIF::RETURN_FAILED;
ReturnValue_t result2 = HasReturnvaluesIF::RETURN_FAILED;
if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid()
&& current.isValid()) {
result1 = voltageLimit.doCheck(voltage);
result2 = currentLimit.doCheck(current);
} else {
voltageLimit.setToInvalid();
currentLimit.setToInvalid();
result1 = OBJECT_NOT_HEALTHY;
}
if (result1 != HasReturnvaluesIF::RETURN_OK
|| result2 != HasReturnvaluesIF::RETURN_OK) {
result1 = MonitoringIF::INVALID;
power.setValid(PoolVariableIF::INVALID);
} else {
power.setValid(PoolVariableIF::VALID);
power = current * voltage;
}
set.commit();
return result1;
}
ReturnValue_t PowerSensor::performOperation(uint8_t opCode) {
checkCommandQueue();
return HasReturnvaluesIF::RETURN_OK;
}
MessageQueueId_t PowerSensor::getCommandQueue() const {
return commandQueue->getId();
}
ReturnValue_t PowerSensor::initialize() {
ReturnValue_t result = SystemObject::initialize();
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = healthHelper.initialize();
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
result = parameterHelper.initialize();
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return result;
}
void PowerSensor::setAllMonitorsToUnchecked() {
currentLimit.setToUnchecked();
voltageLimit.setToUnchecked();
}
void PowerSensor::checkCommandQueue() {
CommandMessage command;
ReturnValue_t result = commandQueue->receiveMessage(&command);
if (result != HasReturnvaluesIF::RETURN_OK) {
return;
}
result = healthHelper.handleHealthCommand(&command);
if (result == HasReturnvaluesIF::RETURN_OK) {
return;
}
result = parameterHelper.handleParameterMessage(&command);
if (result == HasReturnvaluesIF::RETURN_OK) {
return;
}
command.setToUnknownCommand();
commandQueue->reply(&command);
}
void PowerSensor::setDataPoolEntriesInvalid() {
set.read();
set.commit(PoolVariableIF::INVALID);
}
float PowerSensor::getPower() {
if (power.isValid()) {
return power.value;
} else {
return 0.0;
}
}
ReturnValue_t PowerSensor::setHealth(HealthState health) {
healthHelper.setHealth(health);
return HasReturnvaluesIF::RETURN_OK;
}
HasHealthIF::HealthState PowerSensor::getHealth() {
return healthHelper.getHealth();
}
ReturnValue_t PowerSensor::getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
uint16_t startAtIndex) {
ReturnValue_t result = currentLimit.getParameter(domainId, parameterId,
parameterWrapper, newValues, startAtIndex);
if (result != INVALID_DOMAIN_ID) {
return result;
}
result = voltageLimit.getParameter(domainId, parameterId, parameterWrapper,
newValues, startAtIndex);
return result;
}

142
power/PowerSensor.h
View File

@ -1,71 +1,71 @@
#ifndef POWERSENSOR_H_
#define POWERSENSOR_H_
#include "../datapoolglob/GlobalDataSet.h"
#include "../datapoolglob/GlobalPoolVariable.h"
#include "../datapoolglob/PIDReader.h"
#include "../devicehandlers/HealthDevice.h"
#include "../monitoring/LimitMonitor.h"
#include "../parameters/ParameterHelper.h"
#include "../objectmanager/SystemObject.h"
#include "../ipc/MessageQueueIF.h"
class PowerController;
class PowerSensor: public SystemObject,
public ReceivesParameterMessagesIF,
public HasHealthIF {
friend class PowerController;
public:
struct VariableIds {
uint32_t pidCurrent;
uint32_t pidVoltage;
uint32_t poolIdPower;
};
struct DefaultLimits {
float currentMin;
float currentMax;
float voltageMin;
float voltageMax;
};
struct SensorEvents {
Event currentLow;
Event currentHigh;
Event voltageLow;
Event voltageHigh;
};
PowerSensor(object_id_t setId, VariableIds setIds, DefaultLimits limits,
SensorEvents events, uint16_t confirmationCount = 0);
virtual ~PowerSensor();
ReturnValue_t calculatePower();
ReturnValue_t performOperation(uint8_t opCode);
void setAllMonitorsToUnchecked();
MessageQueueId_t getCommandQueue() const;
ReturnValue_t initialize();
void setDataPoolEntriesInvalid();
float getPower();
ReturnValue_t setHealth(HealthState health);
HasHealthIF::HealthState getHealth();
ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper *parameterWrapper,
const ParameterWrapper *newValues, uint16_t startAtIndex);
private:
MessageQueueIF* commandQueue;
ParameterHelper parameterHelper;
HealthHelper healthHelper;
GlobDataSet set;
//Variables in
PIDReader<float> current;
PIDReader<float> voltage;
//Variables out
gp_float_t power;
static const uint8_t MODULE_ID_CURRENT = 1;
static const uint8_t MODULE_ID_VOLTAGE = 2;
void checkCommandQueue();
protected:
LimitMonitor<float> currentLimit;
LimitMonitor<float> voltageLimit;
};
#endif /* POWERSENSOR_H_ */
#ifndef POWERSENSOR_H_
#define POWERSENSOR_H_
#include "../datapoolglob/GlobalDataSet.h"
#include "../datapoolglob/GlobalPoolVariable.h"
#include "../datapoolglob/PIDReader.h"
#include "../devicehandlers/HealthDevice.h"
#include "../monitoring/LimitMonitor.h"
#include "../parameters/ParameterHelper.h"
#include "../objectmanager/SystemObject.h"
#include "../ipc/MessageQueueIF.h"
class PowerController;
class PowerSensor: public SystemObject,
public ReceivesParameterMessagesIF,
public HasHealthIF {
friend class PowerController;
public:
struct VariableIds {
uint32_t pidCurrent;
uint32_t pidVoltage;
uint32_t poolIdPower;
};
struct DefaultLimits {
float currentMin;
float currentMax;
float voltageMin;
float voltageMax;
};
struct SensorEvents {
Event currentLow;
Event currentHigh;
Event voltageLow;
Event voltageHigh;
};
PowerSensor(object_id_t setId, VariableIds setIds, DefaultLimits limits,
SensorEvents events, uint16_t confirmationCount = 0);
virtual ~PowerSensor();
ReturnValue_t calculatePower();
ReturnValue_t performOperation(uint8_t opCode);
void setAllMonitorsToUnchecked();
MessageQueueId_t getCommandQueue() const;
ReturnValue_t initialize();
void setDataPoolEntriesInvalid();
float getPower();
ReturnValue_t setHealth(HealthState health);
HasHealthIF::HealthState getHealth();
ReturnValue_t getParameter(uint8_t domainId, uint16_t parameterId,
ParameterWrapper *parameterWrapper,
const ParameterWrapper *newValues, uint16_t startAtIndex);
private:
MessageQueueIF* commandQueue;
ParameterHelper parameterHelper;
HealthHelper healthHelper;
GlobDataSet set;
//Variables in
PIDReader<float> current;
PIDReader<float> voltage;
//Variables out
gp_float_t power;
static const uint8_t MODULE_ID_CURRENT = 1;
static const uint8_t MODULE_ID_VOLTAGE = 2;
void checkCommandQueue();
protected:
LimitMonitor<float> currentLimit;
LimitMonitor<float> voltageLimit;
};
#endif /* POWERSENSOR_H_ */

160
power/PowerSwitchIF.h
View File

@ -1,80 +1,80 @@
/**
* @file PowerSwitchIF.h
* @brief This file defines the PowerSwitchIF class.
* @date 20.03.2013
* @author baetz
*/
#ifndef POWERSWITCHIF_H_
#define POWERSWITCHIF_H_
#include "../events/Event.h"
#include "../returnvalues/HasReturnvaluesIF.h"
/**
*
* @brief This interface defines a connection to a device that is capable of turning on and off
* switches of devices identified by a switch ID.
* @details The virtual functions of this interface do not allow to make any assignments
* because they can be called asynchronosuly (const ending).
*
* @ingroup interfaces
*/
class PowerSwitchIF : public HasReturnvaluesIF {
public:
/**
* Empty dtor.
*/
virtual ~PowerSwitchIF() {
}
/**
* The Returnvalues id of this class, required by HasReturnvaluesIF
*/
static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCH_IF;
static const ReturnValue_t SWITCH_ON = MAKE_RETURN_CODE(1);
static const ReturnValue_t SWITCH_OFF = MAKE_RETURN_CODE(0);
static const ReturnValue_t SWITCH_TIMEOUT = MAKE_RETURN_CODE(2);
static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, SEVERITY::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
/**
* send a direct command to the Power Unit to enable/disable the specified switch.
*
* @param switchNr
* @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
*/
virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const = 0;
/**
* Sends a command to the Power Unit to enable a certain fuse.
*/
virtual void sendFuseOnCommand(uint8_t fuseNr) const = 0;
/**
* get the state of the Switches.
* @param switchNr
* @return
* - @c SWITCH_ON if the specified switch is on.
* - @c SWITCH_OFF if the specified switch is off.
* - @c RETURN_FAILED if an error occured
*/
virtual ReturnValue_t getSwitchState( uint8_t switchNr ) const = 0;
/**
* get state of a fuse.
* @param fuseNr
* @return
* - @c FUSE_ON if the specified fuse is on.
* - @c FUSE_OFF if the specified fuse is off.
* - @c RETURN_FAILED if an error occured
*/
virtual ReturnValue_t getFuseState( uint8_t fuseNr ) const = 0;
/**
* The maximum delay that it will take to change a switch
*
* This may take into account the time to send a command, wait for it to be executed and see the switch changed.
*/
virtual uint32_t getSwitchDelayMs(void) const = 0;
};
#endif /* POWERSWITCHIF_H_ */
/**
* @file PowerSwitchIF.h
* @brief This file defines the PowerSwitchIF class.
* @date 20.03.2013
* @author baetz
*/
#ifndef POWERSWITCHIF_H_
#define POWERSWITCHIF_H_
#include "../events/Event.h"
#include "../returnvalues/HasReturnvaluesIF.h"
/**
*
* @brief This interface defines a connection to a device that is capable of turning on and off
* switches of devices identified by a switch ID.
* @details The virtual functions of this interface do not allow to make any assignments
* because they can be called asynchronosuly (const ending).
*
* @ingroup interfaces
*/
class PowerSwitchIF : public HasReturnvaluesIF {
public:
/**
* Empty dtor.
*/
virtual ~PowerSwitchIF() {
}
/**
* The Returnvalues id of this class, required by HasReturnvaluesIF
*/
static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCH_IF;
static const ReturnValue_t SWITCH_ON = MAKE_RETURN_CODE(1);
static const ReturnValue_t SWITCH_OFF = MAKE_RETURN_CODE(0);
static const ReturnValue_t SWITCH_TIMEOUT = MAKE_RETURN_CODE(2);
static const ReturnValue_t FUSE_ON = MAKE_RETURN_CODE(3);
static const ReturnValue_t FUSE_OFF = MAKE_RETURN_CODE(4);
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PCDU_2;
static const Event SWITCH_WENT_OFF = MAKE_EVENT(0, SEVERITY::LOW); //!< Someone detected that a switch went off which shouldn't. Severity: Low, Parameter1: switchId1, Parameter2: switchId2
/**
* send a direct command to the Power Unit to enable/disable the specified switch.
*
* @param switchNr
* @param onOff on == @c SWITCH_ON; off != @c SWITCH_ON
*/
virtual void sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) const = 0;
/**
* Sends a command to the Power Unit to enable a certain fuse.
*/
virtual void sendFuseOnCommand(uint8_t fuseNr) const = 0;
/**
* get the state of the Switches.
* @param switchNr
* @return
* - @c SWITCH_ON if the specified switch is on.
* - @c SWITCH_OFF if the specified switch is off.
* - @c RETURN_FAILED if an error occured
*/
virtual ReturnValue_t getSwitchState( uint8_t switchNr ) const = 0;
/**
* get state of a fuse.
* @param fuseNr
* @return
* - @c FUSE_ON if the specified fuse is on.
* - @c FUSE_OFF if the specified fuse is off.
* - @c RETURN_FAILED if an error occured
*/
virtual ReturnValue_t getFuseState( uint8_t fuseNr ) const = 0;
/**
* The maximum delay that it will take to change a switch
*
* This may take into account the time to send a command, wait for it to be executed and see the switch changed.
*/
virtual uint32_t getSwitchDelayMs(void) const = 0;
};
#endif /* POWERSWITCHIF_H_ */

254
power/PowerSwitcher.cpp
View File

@ -1,127 +1,127 @@
#include "../objectmanager/ObjectManagerIF.h"
#include "../power/PowerSwitcher.h"
#include "../serviceinterface/ServiceInterfaceStream.h"
PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
PowerSwitcher::State_t setStartState) :
state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2), power(NULL) {
}
ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
power = objectManager->get<PowerSwitchIF>(powerSwitchId);
if (power == NULL) {
return HasReturnvaluesIF::RETURN_FAILED;
}
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t PowerSwitcher::getStateOfSwitches() {
SwitchReturn_t result = howManySwitches();
switch (result) {
case ONE_SWITCH:
return power->getSwitchState(firstSwitch);
case TWO_SWITCHES:
if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_ON)
&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_ON)) {
return PowerSwitchIF::SWITCH_ON;
} else if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_OFF)
&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_OFF)) {
return PowerSwitchIF::SWITCH_OFF;
} else {
return HasReturnvaluesIF::RETURN_FAILED;
}
default:
return HasReturnvaluesIF::RETURN_FAILED;
}
}
void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
SwitchReturn_t result = howManySwitches();
switch (result) {
case TWO_SWITCHES:
power->sendSwitchCommand(secondSwitch, onOff);
/* NO BREAK falls through*/
case ONE_SWITCH:
power->sendSwitchCommand(firstSwitch, onOff);
break;
}
return;
}
void PowerSwitcher::turnOn() {
commandSwitches(PowerSwitchIF::SWITCH_ON);
state = WAIT_ON;
}
void PowerSwitcher::turnOff() {
commandSwitches(PowerSwitchIF::SWITCH_OFF);
state = WAIT_OFF;
}
PowerSwitcher::SwitchReturn_t PowerSwitcher::howManySwitches() {
if (secondSwitch == NO_SWITCH) {
return ONE_SWITCH;
} else {
return TWO_SWITCHES;
}
}
void PowerSwitcher::doStateMachine() {
switch (state) {
case SWITCH_IS_OFF:
case SWITCH_IS_ON:
//Do nothing.
break;
case WAIT_OFF:
if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
state = SWITCH_IS_OFF;
}
break;
case WAIT_ON:
if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
state = SWITCH_IS_ON;
}
break;
default:
//Should never happen.
break;
}
}
ReturnValue_t PowerSwitcher::checkSwitchState() {
switch (state) {
case WAIT_OFF:
case WAIT_ON:
return IN_POWER_TRANSITION;
case SWITCH_IS_OFF:
if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
return RETURN_OK;
} else {
return SWITCH_STATE_MISMATCH;
}
case SWITCH_IS_ON:
if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
return RETURN_OK;
} else {
return SWITCH_STATE_MISMATCH;
}
}
return RETURN_FAILED;
}
PowerSwitcher::State_t PowerSwitcher::getState() {
return state;
}
uint32_t PowerSwitcher::getSwitchDelay() {
return power->getSwitchDelayMs();
}
uint8_t PowerSwitcher::getFirstSwitch() const {
return firstSwitch;
}
uint8_t PowerSwitcher::getSecondSwitch() const {
return secondSwitch;
}
#include "../objectmanager/ObjectManagerIF.h"
#include "../power/PowerSwitcher.h"
#include "../serviceinterface/ServiceInterfaceStream.h"
PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
PowerSwitcher::State_t setStartState) :
state(setStartState), firstSwitch(setSwitch1), secondSwitch(setSwitch2), power(NULL) {
}
ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
power = objectManager->get<PowerSwitchIF>(powerSwitchId);
if (power == NULL) {
return HasReturnvaluesIF::RETURN_FAILED;
}
return HasReturnvaluesIF::RETURN_OK;
}
ReturnValue_t PowerSwitcher::getStateOfSwitches() {
SwitchReturn_t result = howManySwitches();
switch (result) {
case ONE_SWITCH:
return power->getSwitchState(firstSwitch);
case TWO_SWITCHES:
if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_ON)
&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_ON)) {
return PowerSwitchIF::SWITCH_ON;
} else if ((power->getSwitchState(firstSwitch) == PowerSwitchIF::SWITCH_OFF)
&& (power->getSwitchState(secondSwitch) == PowerSwitchIF::SWITCH_OFF)) {
return PowerSwitchIF::SWITCH_OFF;
} else {
return HasReturnvaluesIF::RETURN_FAILED;
}
default:
return HasReturnvaluesIF::RETURN_FAILED;
}
}
void PowerSwitcher::commandSwitches(ReturnValue_t onOff) {
SwitchReturn_t result = howManySwitches();
switch (result) {
case TWO_SWITCHES:
power->sendSwitchCommand(secondSwitch, onOff);
/* NO BREAK falls through*/
case ONE_SWITCH:
power->sendSwitchCommand(firstSwitch, onOff);
break;
}
return;
}
void PowerSwitcher::turnOn() {
commandSwitches(PowerSwitchIF::SWITCH_ON);
state = WAIT_ON;
}
void PowerSwitcher::turnOff() {
commandSwitches(PowerSwitchIF::SWITCH_OFF);
state = WAIT_OFF;
}
PowerSwitcher::SwitchReturn_t PowerSwitcher::howManySwitches() {
if (secondSwitch == NO_SWITCH) {
return ONE_SWITCH;
} else {
return TWO_SWITCHES;
}
}
void PowerSwitcher::doStateMachine() {
switch (state) {
case SWITCH_IS_OFF:
case SWITCH_IS_ON:
//Do nothing.
break;
case WAIT_OFF:
if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
state = SWITCH_IS_OFF;
}
break;
case WAIT_ON:
if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
state = SWITCH_IS_ON;
}
break;
default:
//Should never happen.
break;
}
}
ReturnValue_t PowerSwitcher::checkSwitchState() {
switch (state) {
case WAIT_OFF:
case WAIT_ON:
return IN_POWER_TRANSITION;
case SWITCH_IS_OFF:
if (getStateOfSwitches() == PowerSwitchIF::SWITCH_OFF) {
return RETURN_OK;
} else {
return SWITCH_STATE_MISMATCH;
}
case SWITCH_IS_ON:
if (getStateOfSwitches() == PowerSwitchIF::SWITCH_ON) {
return RETURN_OK;
} else {
return SWITCH_STATE_MISMATCH;
}
}
return RETURN_FAILED;
}
PowerSwitcher::State_t PowerSwitcher::getState() {
return state;
}
uint32_t PowerSwitcher::getSwitchDelay() {
return power->getSwitchDelayMs();
}
uint8_t PowerSwitcher::getFirstSwitch() const {
return firstSwitch;
}
uint8_t PowerSwitcher::getSecondSwitch() const {
return secondSwitch;
}

90
power/PowerSwitcher.h
View File

@ -1,45 +1,45 @@
#ifndef POWERSWITCHER_H_
#define POWERSWITCHER_H_
#include "../power/PowerSwitchIF.h"
#include "../returnvalues/HasReturnvaluesIF.h"
#include "../timemanager/Countdown.h"
class PowerSwitcher : public HasReturnvaluesIF {
public:
enum State_t {
WAIT_OFF,
WAIT_ON,
SWITCH_IS_OFF,
SWITCH_IS_ON,
};
State_t state;
static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH, State_t setStartState = SWITCH_IS_OFF );
ReturnValue_t initialize(object_id_t powerSwitchId);
void turnOn();
void turnOff();
void doStateMachine();
State_t getState();
ReturnValue_t checkSwitchState();
uint32_t getSwitchDelay();
uint8_t getFirstSwitch() const;
uint8_t getSecondSwitch() const;
private:
uint8_t firstSwitch;
uint8_t secondSwitch;
PowerSwitchIF* power;
static const uint8_t NO_SWITCH = 0xFF;
enum SwitchReturn_t {
ONE_SWITCH = 1,
TWO_SWITCHES = 2
};
ReturnValue_t getStateOfSwitches();
void commandSwitches( ReturnValue_t onOff );
SwitchReturn_t howManySwitches();
};
#endif /* POWERSWITCHER_H_ */
#ifndef POWERSWITCHER_H_
#define POWERSWITCHER_H_
#include "../power/PowerSwitchIF.h"
#include "../returnvalues/HasReturnvaluesIF.h"
#include "../timemanager/Countdown.h"
class PowerSwitcher : public HasReturnvaluesIF {
public:
enum State_t {
WAIT_OFF,
WAIT_ON,
SWITCH_IS_OFF,
SWITCH_IS_ON,
};
State_t state;
static const uint8_t INTERFACE_ID = CLASS_ID::POWER_SWITCHER;
static const ReturnValue_t IN_POWER_TRANSITION = MAKE_RETURN_CODE(1);
static const ReturnValue_t SWITCH_STATE_MISMATCH = MAKE_RETURN_CODE(2);
PowerSwitcher( uint8_t setSwitch1, uint8_t setSwitch2 = NO_SWITCH, State_t setStartState = SWITCH_IS_OFF );
ReturnValue_t initialize(object_id_t powerSwitchId);
void turnOn();
void turnOff();
void doStateMachine();
State_t getState();
ReturnValue_t checkSwitchState();
uint32_t getSwitchDelay();
uint8_t getFirstSwitch() const;
uint8_t getSecondSwitch() const;
private:
uint8_t firstSwitch;
uint8_t secondSwitch;
PowerSwitchIF* power;
static const uint8_t NO_SWITCH = 0xFF;
enum SwitchReturn_t {
ONE_SWITCH = 1,
TWO_SWITCHES = 2
};
ReturnValue_t getStateOfSwitches();
void commandSwitches( ReturnValue_t onOff );
SwitchReturn_t howManySwitches();
};
#endif /* POWERSWITCHER_H_ */