Merge branch 'development' into mueller/linuxtcpip-printout-fix
This commit is contained in:
commit
b38e9ede0c
@ -16,9 +16,9 @@ ReturnValue_t HealthDevice::performOperation(uint8_t opCode) {
|
||||
CommandMessage command;
|
||||
ReturnValue_t result = commandQueue->receiveMessage(&command);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
healthHelper.handleHealthCommand(&command);
|
||||
result = healthHelper.handleHealthCommand(&command);
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t HealthDevice::initialize() {
|
||||
|
@ -1,350 +1,352 @@
|
||||
#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
|
||||
#include "Heater.h"
|
||||
|
||||
#include "../devicehandlers/DeviceHandlerFailureIsolation.h"
|
||||
#include "../power/Fuse.h"
|
||||
#include "../ipc/QueueFactory.h"
|
||||
|
||||
Heater::Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1) :
|
||||
HealthDevice(objectId, 0), internalState(STATE_OFF), powerSwitcher(
|
||||
NULL), pcduQueueId(0), switch0(switch0), switch1(switch1), wasOn(
|
||||
false), timedOut(false), reactedToBeingFaulty(false), passive(
|
||||
false), eventQueue(NULL), heaterOnCountdown(10800000)/*about two orbits*/, parameterHelper(
|
||||
this), lastAction(CLEAR) {
|
||||
eventQueue = QueueFactory::instance()->createMessageQueue();
|
||||
HealthDevice(objectId, 0), internalState(STATE_OFF), switch0(switch0), switch1(switch1),
|
||||
heaterOnCountdown(10800000)/*about two orbits*/,
|
||||
parameterHelper(this) {
|
||||
eventQueue = QueueFactory::instance()->createMessageQueue();
|
||||
}
|
||||
|
||||
Heater::~Heater() {
|
||||
QueueFactory::instance()->deleteMessageQueue(eventQueue);
|
||||
QueueFactory::instance()->deleteMessageQueue(eventQueue);
|
||||
}
|
||||
|
||||
ReturnValue_t Heater::set() {
|
||||
passive = false;
|
||||
//wait for clear before doing anything
|
||||
if (internalState == STATE_WAIT) {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
if (healthHelper.healthTable->isHealthy(getObjectId())) {
|
||||
doAction(SET);
|
||||
if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)){
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
} else {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
} else {
|
||||
if (healthHelper.healthTable->isFaulty(getObjectId())) {
|
||||
if (!reactedToBeingFaulty) {
|
||||
reactedToBeingFaulty = true;
|
||||
doAction(CLEAR);
|
||||
}
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
passive = false;
|
||||
//wait for clear before doing anything
|
||||
if (internalState == STATE_WAIT) {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
if (healthHelper.healthTable->isHealthy(getObjectId())) {
|
||||
doAction(SET);
|
||||
if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)){
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
} else {
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
} else {
|
||||
if (healthHelper.healthTable->isFaulty(getObjectId())) {
|
||||
if (!reactedToBeingFaulty) {
|
||||
reactedToBeingFaulty = true;
|
||||
doAction(CLEAR);
|
||||
}
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
}
|
||||
|
||||
void Heater::clear(bool passive) {
|
||||
this->passive = passive;
|
||||
//Force switching off
|
||||
if (internalState == STATE_WAIT) {
|
||||
internalState = STATE_ON;
|
||||
}
|
||||
if (healthHelper.healthTable->isHealthy(getObjectId())) {
|
||||
doAction(CLEAR);
|
||||
} else if (healthHelper.healthTable->isFaulty(getObjectId())) {
|
||||
if (!reactedToBeingFaulty) {
|
||||
reactedToBeingFaulty = true;
|
||||
doAction(CLEAR);
|
||||
}
|
||||
}
|
||||
this->passive = passive;
|
||||
//Force switching off
|
||||
if (internalState == STATE_WAIT) {
|
||||
internalState = STATE_ON;
|
||||
}
|
||||
if (healthHelper.healthTable->isHealthy(getObjectId())) {
|
||||
doAction(CLEAR);
|
||||
} else if (healthHelper.healthTable->isFaulty(getObjectId())) {
|
||||
if (!reactedToBeingFaulty) {
|
||||
reactedToBeingFaulty = true;
|
||||
doAction(CLEAR);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Heater::doAction(Action action) {
|
||||
//only act if we are not in the right state or in a transition
|
||||
if (action == SET) {
|
||||
if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)
|
||||
|| (internalState == STATE_EXTERNAL_CONTROL)) {
|
||||
switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
|
||||
internalState = STATE_WAIT_FOR_SWITCHES_ON;
|
||||
powerSwitcher->sendSwitchCommand(switch0, PowerSwitchIF::SWITCH_ON);
|
||||
powerSwitcher->sendSwitchCommand(switch1, PowerSwitchIF::SWITCH_ON);
|
||||
}
|
||||
} else { //clear
|
||||
if ((internalState == STATE_ON) || (internalState == STATE_FAULTY)
|
||||
|| (internalState == STATE_EXTERNAL_CONTROL)) {
|
||||
internalState = STATE_WAIT_FOR_SWITCHES_OFF;
|
||||
switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
|
||||
powerSwitcher->sendSwitchCommand(switch0,
|
||||
PowerSwitchIF::SWITCH_OFF);
|
||||
powerSwitcher->sendSwitchCommand(switch1,
|
||||
PowerSwitchIF::SWITCH_OFF);
|
||||
}
|
||||
}
|
||||
//only act if we are not in the right state or in a transition
|
||||
if (action == SET) {
|
||||
if ((internalState == STATE_OFF) || (internalState == STATE_PASSIVE)
|
||||
|| (internalState == STATE_EXTERNAL_CONTROL)) {
|
||||
switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
|
||||
internalState = STATE_WAIT_FOR_SWITCHES_ON;
|
||||
powerSwitcher->sendSwitchCommand(switch0, PowerSwitchIF::SWITCH_ON);
|
||||
powerSwitcher->sendSwitchCommand(switch1, PowerSwitchIF::SWITCH_ON);
|
||||
}
|
||||
} else { //clear
|
||||
if ((internalState == STATE_ON) || (internalState == STATE_FAULTY)
|
||||
|| (internalState == STATE_EXTERNAL_CONTROL)) {
|
||||
internalState = STATE_WAIT_FOR_SWITCHES_OFF;
|
||||
switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
|
||||
powerSwitcher->sendSwitchCommand(switch0,
|
||||
PowerSwitchIF::SWITCH_OFF);
|
||||
powerSwitcher->sendSwitchCommand(switch1,
|
||||
PowerSwitchIF::SWITCH_OFF);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Heater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
|
||||
this->powerSwitcher = powerSwitch;
|
||||
this->powerSwitcher = powerSwitch;
|
||||
}
|
||||
|
||||
ReturnValue_t Heater::performOperation(uint8_t opCode) {
|
||||
handleQueue();
|
||||
handleEventQueue();
|
||||
handleQueue();
|
||||
handleEventQueue();
|
||||
|
||||
if (!healthHelper.healthTable->isFaulty(getObjectId())) {
|
||||
reactedToBeingFaulty = false;
|
||||
}
|
||||
if (!healthHelper.healthTable->isFaulty(getObjectId())) {
|
||||
reactedToBeingFaulty = false;
|
||||
}
|
||||
|
||||
switch (internalState) {
|
||||
case STATE_ON:
|
||||
if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_OFF)
|
||||
|| (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_OFF)) {
|
||||
//switch went off on its own
|
||||
//trigger event. FDIR can confirm if it is caused by MniOps and decide on the action
|
||||
//do not trigger FD events when under external control
|
||||
if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
|
||||
triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
|
||||
} else {
|
||||
internalState = STATE_EXTERNAL_CONTROL;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case STATE_OFF:
|
||||
//check if heater is on, ie both switches are on
|
||||
//if so, just command it to off, to resolve the situation or force a switch stayed on event
|
||||
//But, only do anything if not already faulty (state off is the stable point for being faulty)
|
||||
if ((!healthHelper.healthTable->isFaulty(getObjectId()))
|
||||
&& (powerSwitcher->getSwitchState(switch0)
|
||||
== PowerSwitchIF::SWITCH_ON)
|
||||
&& (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_ON)) {
|
||||
//do not trigger FD events when under external control
|
||||
if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
|
||||
internalState = STATE_WAIT_FOR_SWITCHES_OFF;
|
||||
switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
|
||||
powerSwitcher->sendSwitchCommand(switch0,
|
||||
PowerSwitchIF::SWITCH_OFF);
|
||||
powerSwitcher->sendSwitchCommand(switch1,
|
||||
PowerSwitchIF::SWITCH_OFF);
|
||||
} else {
|
||||
internalState = STATE_EXTERNAL_CONTROL;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case STATE_PASSIVE:
|
||||
break;
|
||||
case STATE_WAIT_FOR_SWITCHES_ON:
|
||||
if (switchCountdown.hasTimedOut()) {
|
||||
if ((powerSwitcher->getSwitchState(switch0)
|
||||
== PowerSwitchIF::SWITCH_OFF)
|
||||
|| (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_OFF)) {
|
||||
triggerEvent(HEATER_STAYED_OFF);
|
||||
internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
|
||||
} else {
|
||||
triggerEvent(HEATER_ON);
|
||||
internalState = STATE_ON;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case STATE_WAIT_FOR_SWITCHES_OFF:
|
||||
if (switchCountdown.hasTimedOut()) {
|
||||
//only check for both being on (ie heater still on)
|
||||
if ((powerSwitcher->getSwitchState(switch0)
|
||||
== PowerSwitchIF::SWITCH_ON)
|
||||
&& (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_ON)) {
|
||||
if (healthHelper.healthTable->isFaulty(getObjectId())) {
|
||||
if (passive) {
|
||||
internalState = STATE_PASSIVE;
|
||||
} else {
|
||||
internalState = STATE_OFF; //just accept it
|
||||
}
|
||||
triggerEvent(HEATER_ON); //but throw an event to make it more visible
|
||||
break;
|
||||
}
|
||||
triggerEvent(HEATER_STAYED_ON);
|
||||
internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
|
||||
} else {
|
||||
triggerEvent(HEATER_OFF);
|
||||
if (passive) {
|
||||
internalState = STATE_PASSIVE;
|
||||
} else {
|
||||
internalState = STATE_OFF;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
switch (internalState) {
|
||||
case STATE_ON:
|
||||
if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_OFF)
|
||||
|| (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_OFF)) {
|
||||
//switch went off on its own
|
||||
//trigger event. FDIR can confirm if it is caused by MniOps and decide on the action
|
||||
//do not trigger FD events when under external control
|
||||
if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
|
||||
triggerEvent(PowerSwitchIF::SWITCH_WENT_OFF);
|
||||
} else {
|
||||
internalState = STATE_EXTERNAL_CONTROL;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case STATE_OFF:
|
||||
//check if heater is on, ie both switches are on
|
||||
//if so, just command it to off, to resolve the situation or force a switch stayed on event
|
||||
//But, only do anything if not already faulty (state off is the stable point for being faulty)
|
||||
if ((!healthHelper.healthTable->isFaulty(getObjectId()))
|
||||
&& (powerSwitcher->getSwitchState(switch0)
|
||||
== PowerSwitchIF::SWITCH_ON)
|
||||
&& (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_ON)) {
|
||||
//do not trigger FD events when under external control
|
||||
if (healthHelper.getHealth() != EXTERNAL_CONTROL) {
|
||||
internalState = STATE_WAIT_FOR_SWITCHES_OFF;
|
||||
switchCountdown.setTimeout(powerSwitcher->getSwitchDelayMs());
|
||||
powerSwitcher->sendSwitchCommand(switch0,
|
||||
PowerSwitchIF::SWITCH_OFF);
|
||||
powerSwitcher->sendSwitchCommand(switch1,
|
||||
PowerSwitchIF::SWITCH_OFF);
|
||||
} else {
|
||||
internalState = STATE_EXTERNAL_CONTROL;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case STATE_PASSIVE:
|
||||
break;
|
||||
case STATE_WAIT_FOR_SWITCHES_ON:
|
||||
if (switchCountdown.hasTimedOut()) {
|
||||
if ((powerSwitcher->getSwitchState(switch0)
|
||||
== PowerSwitchIF::SWITCH_OFF)
|
||||
|| (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_OFF)) {
|
||||
triggerEvent(HEATER_STAYED_OFF);
|
||||
internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
|
||||
} else {
|
||||
triggerEvent(HEATER_ON);
|
||||
internalState = STATE_ON;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case STATE_WAIT_FOR_SWITCHES_OFF:
|
||||
if (switchCountdown.hasTimedOut()) {
|
||||
//only check for both being on (ie heater still on)
|
||||
if ((powerSwitcher->getSwitchState(switch0)
|
||||
== PowerSwitchIF::SWITCH_ON)
|
||||
&& (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_ON)) {
|
||||
if (healthHelper.healthTable->isFaulty(getObjectId())) {
|
||||
if (passive) {
|
||||
internalState = STATE_PASSIVE;
|
||||
} else {
|
||||
internalState = STATE_OFF; //just accept it
|
||||
}
|
||||
triggerEvent(HEATER_ON); //but throw an event to make it more visible
|
||||
break;
|
||||
}
|
||||
triggerEvent(HEATER_STAYED_ON);
|
||||
internalState = STATE_WAIT_FOR_FDIR; //wait before retrying or anything
|
||||
} else {
|
||||
triggerEvent(HEATER_OFF);
|
||||
if (passive) {
|
||||
internalState = STATE_PASSIVE;
|
||||
} else {
|
||||
internalState = STATE_OFF;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_ON)
|
||||
&& (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_ON)) {
|
||||
if (wasOn) {
|
||||
if (heaterOnCountdown.hasTimedOut()) {
|
||||
//SHOULDDO this means if a heater fails in single mode, the timeout will start again
|
||||
//I am not sure if this is a bug, but atm I have no idea how to fix this and think
|
||||
//it will be ok. whatcouldpossiblygowrong™
|
||||
if (!timedOut) {
|
||||
triggerEvent(HEATER_TIMEOUT);
|
||||
timedOut = true;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
wasOn = true;
|
||||
heaterOnCountdown.resetTimer();
|
||||
timedOut = false;
|
||||
}
|
||||
} else {
|
||||
wasOn = false;
|
||||
}
|
||||
if ((powerSwitcher->getSwitchState(switch0) == PowerSwitchIF::SWITCH_ON)
|
||||
&& (powerSwitcher->getSwitchState(switch1)
|
||||
== PowerSwitchIF::SWITCH_ON)) {
|
||||
if (wasOn) {
|
||||
if (heaterOnCountdown.hasTimedOut()) {
|
||||
//SHOULDDO this means if a heater fails in single mode, the timeout will start again
|
||||
//I am not sure if this is a bug, but atm I have no idea how to fix this and think
|
||||
//it will be ok. whatcouldpossiblygowrong™
|
||||
if (!timedOut) {
|
||||
triggerEvent(HEATER_TIMEOUT);
|
||||
timedOut = true;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
wasOn = true;
|
||||
heaterOnCountdown.resetTimer();
|
||||
timedOut = false;
|
||||
}
|
||||
} else {
|
||||
wasOn = false;
|
||||
}
|
||||
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
void Heater::setSwitch(uint8_t number, ReturnValue_t state,
|
||||
uint32_t* uptimeOfSwitching) {
|
||||
if (powerSwitcher == NULL) {
|
||||
return;
|
||||
}
|
||||
if (powerSwitcher->getSwitchState(number) == state) {
|
||||
*uptimeOfSwitching = INVALID_UPTIME;
|
||||
} else {
|
||||
if ((*uptimeOfSwitching == INVALID_UPTIME)) {
|
||||
powerSwitcher->sendSwitchCommand(number, state);
|
||||
Clock::getUptime(uptimeOfSwitching);
|
||||
} else {
|
||||
uint32_t currentUptime;
|
||||
Clock::getUptime(¤tUptime);
|
||||
if (currentUptime - *uptimeOfSwitching
|
||||
> powerSwitcher->getSwitchDelayMs()) {
|
||||
*uptimeOfSwitching = INVALID_UPTIME;
|
||||
if (healthHelper.healthTable->isHealthy(getObjectId())) {
|
||||
if (state == PowerSwitchIF::SWITCH_ON) {
|
||||
triggerEvent(HEATER_STAYED_OFF);
|
||||
} else {
|
||||
triggerEvent(HEATER_STAYED_ON);
|
||||
}
|
||||
}
|
||||
//SHOULDDO MiniOps during switch timeout leads to a faulty switch
|
||||
}
|
||||
}
|
||||
}
|
||||
uint32_t* uptimeOfSwitching) {
|
||||
if (powerSwitcher == NULL) {
|
||||
return;
|
||||
}
|
||||
if (powerSwitcher->getSwitchState(number) == state) {
|
||||
*uptimeOfSwitching = INVALID_UPTIME;
|
||||
} else {
|
||||
if ((*uptimeOfSwitching == INVALID_UPTIME)) {
|
||||
powerSwitcher->sendSwitchCommand(number, state);
|
||||
Clock::getUptime(uptimeOfSwitching);
|
||||
} else {
|
||||
uint32_t currentUptime;
|
||||
Clock::getUptime(¤tUptime);
|
||||
if (currentUptime - *uptimeOfSwitching
|
||||
> powerSwitcher->getSwitchDelayMs()) {
|
||||
*uptimeOfSwitching = INVALID_UPTIME;
|
||||
if (healthHelper.healthTable->isHealthy(getObjectId())) {
|
||||
if (state == PowerSwitchIF::SWITCH_ON) {
|
||||
triggerEvent(HEATER_STAYED_OFF);
|
||||
} else {
|
||||
triggerEvent(HEATER_STAYED_ON);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
MessageQueueId_t Heater::getCommandQueue() const {
|
||||
return commandQueue->getId();
|
||||
return commandQueue->getId();
|
||||
}
|
||||
|
||||
ReturnValue_t Heater::initialize() {
|
||||
ReturnValue_t result = SystemObject::initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
ReturnValue_t result = SystemObject::initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
EventManagerIF* manager = objectManager->get<EventManagerIF>(
|
||||
objects::EVENT_MANAGER);
|
||||
if (manager == NULL) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
result = manager->registerListener(eventQueue->getId());
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
EventManagerIF* manager = objectManager->get<EventManagerIF>(
|
||||
objects::EVENT_MANAGER);
|
||||
if (manager == NULL) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
result = manager->registerListener(eventQueue->getId());
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
|
||||
DeviceHandlerFailureIsolation::powerConfirmationId);
|
||||
if (pcdu == NULL) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
pcduQueueId = pcdu->getEventReceptionQueue();
|
||||
ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
|
||||
DeviceHandlerFailureIsolation::powerConfirmationId);
|
||||
if (pcdu == NULL) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
pcduQueueId = pcdu->getEventReceptionQueue();
|
||||
|
||||
result = manager->subscribeToAllEventsFrom(eventQueue->getId(),
|
||||
getObjectId());
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
result = manager->subscribeToAllEventsFrom(eventQueue->getId(),
|
||||
getObjectId());
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
result = parameterHelper.initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
result = parameterHelper.initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
result = healthHelper.initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
result = healthHelper.initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
void Heater::handleQueue() {
|
||||
CommandMessage command;
|
||||
ReturnValue_t result = commandQueue->receiveMessage(&command);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
result = healthHelper.handleHealthCommand(&command);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
return;
|
||||
}
|
||||
parameterHelper.handleParameterMessage(&command);
|
||||
}
|
||||
CommandMessage command;
|
||||
ReturnValue_t result = commandQueue->receiveMessage(&command);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
result = healthHelper.handleHealthCommand(&command);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
return;
|
||||
}
|
||||
result = parameterHelper.handleParameterMessage(&command);
|
||||
if (result == HasReturnvaluesIF::RETURN_OK) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t Heater::getParameter(uint8_t domainId, uint8_t uniqueId,
|
||||
ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
|
||||
uint16_t startAtIndex) {
|
||||
if (domainId != DOMAIN_ID_BASE) {
|
||||
return INVALID_DOMAIN_ID;
|
||||
}
|
||||
switch (uniqueId) {
|
||||
case 0:
|
||||
parameterWrapper->set(heaterOnCountdown.timeout);
|
||||
break;
|
||||
default:
|
||||
return INVALID_IDENTIFIER_ID;
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
uint16_t startAtIndex) {
|
||||
if (domainId != DOMAIN_ID_BASE) {
|
||||
return INVALID_DOMAIN_ID;
|
||||
}
|
||||
switch (uniqueId) {
|
||||
case 0:
|
||||
parameterWrapper->set(heaterOnCountdown.timeout);
|
||||
break;
|
||||
default:
|
||||
return INVALID_IDENTIFIER_ID;
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
void Heater::handleEventQueue() {
|
||||
EventMessage event;
|
||||
for (ReturnValue_t result = eventQueue->receiveMessage(&event);
|
||||
result == HasReturnvaluesIF::RETURN_OK;
|
||||
result = eventQueue->receiveMessage(&event)) {
|
||||
switch (event.getMessageId()) {
|
||||
case EventMessage::EVENT_MESSAGE:
|
||||
switch (event.getEvent()) {
|
||||
case Fuse::FUSE_WENT_OFF:
|
||||
case HEATER_STAYED_OFF:
|
||||
case HEATER_STAYED_ON://Setting it faulty does not help, but we need to reach a stable state and can check for being faulty before throwing this event again.
|
||||
if (healthHelper.healthTable->isCommandable(getObjectId())) {
|
||||
healthHelper.setHealth(HasHealthIF::FAULTY);
|
||||
internalState = STATE_FAULTY;
|
||||
}
|
||||
break;
|
||||
case PowerSwitchIF::SWITCH_WENT_OFF:
|
||||
internalState = STATE_WAIT;
|
||||
event.setMessageId(EventMessage::CONFIRMATION_REQUEST);
|
||||
if (pcduQueueId != 0) {
|
||||
eventQueue->sendMessage(pcduQueueId, &event);
|
||||
} else {
|
||||
healthHelper.setHealth(HasHealthIF::FAULTY);
|
||||
internalState = STATE_FAULTY;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case EventMessage::YOUR_FAULT:
|
||||
healthHelper.setHealth(HasHealthIF::FAULTY);
|
||||
internalState = STATE_FAULTY;
|
||||
break;
|
||||
case EventMessage::MY_FAULT:
|
||||
//do nothing, we are already in STATE_WAIT and wait for a clear()
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
}
|
||||
EventMessage event;
|
||||
for (ReturnValue_t result = eventQueue->receiveMessage(&event);
|
||||
result == HasReturnvaluesIF::RETURN_OK;
|
||||
result = eventQueue->receiveMessage(&event)) {
|
||||
switch (event.getMessageId()) {
|
||||
case EventMessage::EVENT_MESSAGE:
|
||||
switch (event.getEvent()) {
|
||||
case Fuse::FUSE_WENT_OFF:
|
||||
case HEATER_STAYED_OFF:
|
||||
// HEATER_STAYED_ON is a setting if faulty does not help, but we need to reach a stable state and can check
|
||||
// for being faulty before throwing this event again.
|
||||
case HEATER_STAYED_ON:
|
||||
if (healthHelper.healthTable->isCommandable(getObjectId())) {
|
||||
healthHelper.setHealth(HasHealthIF::FAULTY);
|
||||
internalState = STATE_FAULTY;
|
||||
}
|
||||
break;
|
||||
case PowerSwitchIF::SWITCH_WENT_OFF:
|
||||
internalState = STATE_WAIT;
|
||||
event.setMessageId(EventMessage::CONFIRMATION_REQUEST);
|
||||
if (pcduQueueId != 0) {
|
||||
eventQueue->sendMessage(pcduQueueId, &event);
|
||||
} else {
|
||||
healthHelper.setHealth(HasHealthIF::FAULTY);
|
||||
internalState = STATE_FAULTY;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case EventMessage::YOUR_FAULT:
|
||||
healthHelper.setHealth(HasHealthIF::FAULTY);
|
||||
internalState = STATE_FAULTY;
|
||||
break;
|
||||
case EventMessage::MY_FAULT:
|
||||
//do nothing, we are already in STATE_WAIT and wait for a clear()
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
115
thermal/Heater.h
115
thermal/Heater.h
@ -1,90 +1,93 @@
|
||||
#ifndef FRAMEWORK_THERMAL_HEATER_H_
|
||||
#define FRAMEWORK_THERMAL_HEATER_H_
|
||||
#ifndef FSFW_THERMAL_HEATER_H_
|
||||
#define FSFW_THERMAL_HEATER_H_
|
||||
|
||||
#include "../devicehandlers/HealthDevice.h"
|
||||
#include "../parameters/ParameterHelper.h"
|
||||
#include "../power/PowerSwitchIF.h"
|
||||
#include "../returnvalues/HasReturnvaluesIF.h"
|
||||
#include "../timemanager/Countdown.h"
|
||||
#include <stdint.h>
|
||||
//class RedundantHeater;
|
||||
#include <cstdint>
|
||||
|
||||
|
||||
class Heater: public HealthDevice, public ReceivesParameterMessagesIF {
|
||||
friend class RedundantHeater;
|
||||
friend class RedundantHeater;
|
||||
public:
|
||||
|
||||
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
|
||||
static const Event HEATER_ON = MAKE_EVENT(0, severity::INFO);
|
||||
static const Event HEATER_OFF = MAKE_EVENT(1, severity::INFO);
|
||||
static const Event HEATER_TIMEOUT = MAKE_EVENT(2, severity::LOW);
|
||||
static const Event HEATER_STAYED_ON = MAKE_EVENT(3, severity::LOW);
|
||||
static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, severity::LOW);
|
||||
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::HEATER;
|
||||
static const Event HEATER_ON = MAKE_EVENT(0, severity::INFO);
|
||||
static const Event HEATER_OFF = MAKE_EVENT(1, severity::INFO);
|
||||
static const Event HEATER_TIMEOUT = MAKE_EVENT(2, severity::LOW);
|
||||
static const Event HEATER_STAYED_ON = MAKE_EVENT(3, severity::LOW);
|
||||
static const Event HEATER_STAYED_OFF = MAKE_EVENT(4, severity::LOW);
|
||||
|
||||
Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
|
||||
virtual ~Heater();
|
||||
Heater(uint32_t objectId, uint8_t switch0, uint8_t switch1);
|
||||
virtual ~Heater();
|
||||
|
||||
ReturnValue_t performOperation(uint8_t opCode);
|
||||
ReturnValue_t performOperation(uint8_t opCode);
|
||||
|
||||
ReturnValue_t initialize();
|
||||
ReturnValue_t initialize();
|
||||
|
||||
ReturnValue_t set();
|
||||
void clear(bool passive);
|
||||
ReturnValue_t set();
|
||||
void clear(bool passive);
|
||||
|
||||
void setPowerSwitcher(PowerSwitchIF *powerSwitch);
|
||||
void setPowerSwitcher(PowerSwitchIF *powerSwitch);
|
||||
|
||||
MessageQueueId_t getCommandQueue() const;
|
||||
MessageQueueId_t getCommandQueue() const;
|
||||
|
||||
ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
|
||||
ParameterWrapper *parameterWrapper,
|
||||
const ParameterWrapper *newValues, uint16_t startAtIndex);
|
||||
ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
|
||||
ParameterWrapper *parameterWrapper,
|
||||
const ParameterWrapper *newValues, uint16_t startAtIndex);
|
||||
|
||||
protected:
|
||||
static const uint32_t INVALID_UPTIME = 0;
|
||||
static const uint32_t INVALID_UPTIME = 0;
|
||||
|
||||
enum InternalState {
|
||||
STATE_ON,
|
||||
STATE_OFF,
|
||||
STATE_PASSIVE,
|
||||
STATE_WAIT_FOR_SWITCHES_ON,
|
||||
STATE_WAIT_FOR_SWITCHES_OFF,
|
||||
STATE_WAIT_FOR_FDIR, //used to avoid doing anything until fdir decided what to do
|
||||
STATE_FAULTY,
|
||||
STATE_WAIT, //used when waiting for system to recover from miniops
|
||||
STATE_EXTERNAL_CONTROL //entered when under external control and a fdir reaction would be triggered. This is useful when leaving external control into an unknown state
|
||||
//if no fdir reaction is triggered under external control the state is still ok and no need for any special treatment is needed
|
||||
} internalState;
|
||||
enum InternalState {
|
||||
STATE_ON,
|
||||
STATE_OFF,
|
||||
STATE_PASSIVE,
|
||||
STATE_WAIT_FOR_SWITCHES_ON,
|
||||
STATE_WAIT_FOR_SWITCHES_OFF,
|
||||
STATE_WAIT_FOR_FDIR, // Used to avoid doing anything until fdir decided what to do
|
||||
STATE_FAULTY,
|
||||
STATE_WAIT, // Used when waiting for system to recover from miniops
|
||||
// Entered when under external control and a fdir reaction would be triggered.
|
||||
// This is useful when leaving external control into an unknown state
|
||||
STATE_EXTERNAL_CONTROL
|
||||
// If no fdir reaction is triggered under external control the state is still ok and
|
||||
// no need for any special treatment is needed
|
||||
} internalState;
|
||||
|
||||
PowerSwitchIF *powerSwitcher;
|
||||
MessageQueueId_t pcduQueueId;
|
||||
PowerSwitchIF *powerSwitcher = nullptr;
|
||||
MessageQueueId_t pcduQueueId = MessageQueueIF::NO_QUEUE;
|
||||
|
||||
uint8_t switch0;
|
||||
uint8_t switch1;
|
||||
uint8_t switch0;
|
||||
uint8_t switch1;
|
||||
|
||||
bool wasOn;
|
||||
bool wasOn = false;
|
||||
|
||||
bool timedOut;
|
||||
bool timedOut = false;
|
||||
|
||||
bool reactedToBeingFaulty;
|
||||
bool reactedToBeingFaulty = false;
|
||||
|
||||
bool passive;
|
||||
bool passive = false;
|
||||
|
||||
MessageQueueIF* eventQueue;
|
||||
Countdown heaterOnCountdown;
|
||||
Countdown switchCountdown;
|
||||
ParameterHelper parameterHelper;
|
||||
MessageQueueIF* eventQueue = nullptr;
|
||||
Countdown heaterOnCountdown;
|
||||
Countdown switchCountdown;
|
||||
ParameterHelper parameterHelper;
|
||||
|
||||
enum Action {
|
||||
SET, CLEAR
|
||||
} lastAction;
|
||||
enum Action {
|
||||
SET, CLEAR
|
||||
} lastAction = CLEAR;
|
||||
|
||||
void doAction(Action action);
|
||||
void doAction(Action action);
|
||||
|
||||
void setSwitch(uint8_t number, ReturnValue_t state,
|
||||
uint32_t *upTimeOfSwitching);
|
||||
void setSwitch(uint8_t number, ReturnValue_t state,
|
||||
uint32_t *upTimeOfSwitching);
|
||||
|
||||
void handleQueue();
|
||||
void handleQueue();
|
||||
|
||||
void handleEventQueue();
|
||||
void handleEventQueue();
|
||||
};
|
||||
|
||||
#endif /* FRAMEWORK_THERMAL_HEATER_H_ */
|
||||
#endif /* FSFW_THERMAL_HEATER_H_ */
|
||||
|
@ -1,11 +1,14 @@
|
||||
#ifndef TEMPERATURESENSOR_H_
|
||||
#define TEMPERATURESENSOR_H_
|
||||
#ifndef FSFW_THERMAL_TEMPERATURESENSOR_H_
|
||||
#define FSFW_THERMAL_TEMPERATURESENSOR_H_
|
||||
|
||||
#include "../thermal/AbstractTemperatureSensor.h"
|
||||
#include "../datapoolglob/GlobalDataSet.h"
|
||||
#include "../datapoolglob/GlobalPoolVariable.h"
|
||||
#include "tcsDefinitions.h"
|
||||
#include "AbstractTemperatureSensor.h"
|
||||
|
||||
#include "../datapoollocal/LocalPoolDataSetBase.h"
|
||||
#include "../datapoollocal/LocalPoolVariable.h"
|
||||
#include "../monitoring/LimitMonitor.h"
|
||||
|
||||
|
||||
/**
|
||||
* @brief This building block handles non-linear value conversion and
|
||||
* range checks for analog temperature sensors.
|
||||
@ -57,27 +60,25 @@ public:
|
||||
|
||||
/**
|
||||
* Instantiate Temperature Sensor Object.
|
||||
* @param setObjectid objectId of the sensor object
|
||||
* @param inputValue Input value which is converted to a temperature
|
||||
* @param poolVariable Pool Variable to store the temperature value
|
||||
* @param vectorIndex Vector Index for the sensor monitor
|
||||
* @param parameters Calculation parameters, temperature limits, gradient limit
|
||||
* @param datapoolId Datapool ID of the output temperature
|
||||
* @param outputSet Output dataset for the output temperature to fetch it with read()
|
||||
* @param thermalModule respective thermal module, if it has one
|
||||
* @param setObjectid objectId of the sensor object
|
||||
* @param inputTemperature Pointer to a raw input value which is converted to an floating
|
||||
* point C output temperature
|
||||
* @param outputGpid Global Pool ID of the output value
|
||||
* @param vectorIndex Vector Index for the sensor monitor
|
||||
* @param parameters Calculation parameters, temperature limits, gradient limit
|
||||
* @param outputSet Output dataset for the output temperature to fetch it with read()
|
||||
* @param thermalModule Respective thermal module, if it has one
|
||||
*/
|
||||
TemperatureSensor(object_id_t setObjectid,
|
||||
inputType *inputValue, PoolVariableIF *poolVariable,
|
||||
uint8_t vectorIndex, uint32_t datapoolId, Parameters parameters = {0, 0, 0, 0, 0, 0},
|
||||
GlobDataSet *outputSet = NULL, ThermalModuleIF *thermalModule = NULL) :
|
||||
TemperatureSensor(object_id_t setObjectid,lp_var_t<limitType>* inputTemperature,
|
||||
gp_id_t outputGpid, uint8_t vectorIndex, Parameters parameters = {0, 0, 0, 0, 0, 0},
|
||||
LocalPoolDataSetBase *outputSet = nullptr, ThermalModuleIF *thermalModule = nullptr) :
|
||||
AbstractTemperatureSensor(setObjectid, thermalModule), parameters(parameters),
|
||||
inputValue(inputValue), poolVariable(poolVariable),
|
||||
outputTemperature(datapoolId, outputSet, PoolVariableIF::VAR_WRITE),
|
||||
sensorMonitor(setObjectid, DOMAIN_ID_SENSOR,
|
||||
GlobalDataPool::poolIdAndPositionToPid(poolVariable->getDataPoolId(), vectorIndex),
|
||||
inputTemperature(inputTemperature),
|
||||
outputTemperature(outputGpid, outputSet, PoolVariableIF::VAR_WRITE),
|
||||
sensorMonitor(setObjectid, DOMAIN_ID_SENSOR, outputGpid,
|
||||
DEFAULT_CONFIRMATION_COUNT, parameters.lowerLimit, parameters.upperLimit,
|
||||
TEMP_SENSOR_LOW, TEMP_SENSOR_HIGH),
|
||||
oldTemperature(20), uptimeOfOldTemperature( { INVALID_TEMPERATURE, 0 }) {
|
||||
oldTemperature(20), uptimeOfOldTemperature({ thermal::INVALID_TEMPERATURE, 0 }) {
|
||||
}
|
||||
|
||||
|
||||
@ -98,7 +99,7 @@ protected:
|
||||
|
||||
private:
|
||||
void setInvalid() {
|
||||
outputTemperature = INVALID_TEMPERATURE;
|
||||
outputTemperature = thermal::INVALID_TEMPERATURE;
|
||||
outputTemperature.setValid(false);
|
||||
uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
|
||||
sensorMonitor.setToInvalid();
|
||||
@ -108,11 +109,8 @@ protected:
|
||||
|
||||
UsedParameters parameters;
|
||||
|
||||
inputType * inputValue;
|
||||
|
||||
PoolVariableIF *poolVariable;
|
||||
|
||||
gp_float_t outputTemperature;
|
||||
lp_var_t<limitType>* inputTemperature;
|
||||
lp_var_t<float> outputTemperature;
|
||||
|
||||
LimitMonitor<limitType> sensorMonitor;
|
||||
|
||||
@ -120,22 +118,27 @@ protected:
|
||||
timeval uptimeOfOldTemperature;
|
||||
|
||||
void doChildOperation() {
|
||||
if (!poolVariable->isValid()
|
||||
|| !healthHelper.healthTable->isHealthy(getObjectId())) {
|
||||
ReturnValue_t result = inputTemperature->read(MutexIF::TimeoutType::WAITING, 20);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ((not inputTemperature->isValid()) or
|
||||
(not healthHelper.healthTable->isHealthy(getObjectId()))) {
|
||||
setInvalid();
|
||||
return;
|
||||
}
|
||||
|
||||
outputTemperature = calculateOutputTemperature(*inputValue);
|
||||
outputTemperature = calculateOutputTemperature(inputTemperature->value);
|
||||
outputTemperature.setValid(PoolVariableIF::VALID);
|
||||
|
||||
timeval uptime;
|
||||
Clock::getUptime(&uptime);
|
||||
|
||||
if (uptimeOfOldTemperature.tv_sec != INVALID_UPTIME) {
|
||||
//In theory, we could use an AbsValueMonitor to monitor the gradient.
|
||||
//But this would require storing the maxGradient in DP and quite some overhead.
|
||||
//The concept of delta limits is a bit strange anyway.
|
||||
// In theory, we could use an AbsValueMonitor to monitor the gradient.
|
||||
// But this would require storing the maxGradient in DP and quite some overhead.
|
||||
// The concept of delta limits is a bit strange anyway.
|
||||
float deltaTime;
|
||||
float deltaTemp;
|
||||
|
||||
@ -148,17 +151,17 @@ protected:
|
||||
}
|
||||
if (parameters.gradient < deltaTemp / deltaTime) {
|
||||
triggerEvent(TEMP_SENSOR_GRADIENT);
|
||||
//Don't set invalid, as we did not recognize it as invalid with full authority, let FDIR handle it
|
||||
// Don't set invalid, as we did not recognize it as invalid with full authority,
|
||||
// let FDIR handle it
|
||||
}
|
||||
}
|
||||
|
||||
//Check is done against raw limits. SHOULDDO: Why? Using <20>C would be more easy to handle.
|
||||
sensorMonitor.doCheck(outputTemperature.value);
|
||||
|
||||
if (sensorMonitor.isOutOfLimits()) {
|
||||
uptimeOfOldTemperature.tv_sec = INVALID_UPTIME;
|
||||
outputTemperature.setValid(PoolVariableIF::INVALID);
|
||||
outputTemperature = INVALID_TEMPERATURE;
|
||||
outputTemperature = thermal::INVALID_TEMPERATURE;
|
||||
} else {
|
||||
oldTemperature = outputTemperature;
|
||||
uptimeOfOldTemperature = uptime;
|
||||
@ -179,7 +182,10 @@ public:
|
||||
static const uint16_t ADDRESS_C = 2;
|
||||
static const uint16_t ADDRESS_GRADIENT = 3;
|
||||
|
||||
static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1; //!< Changed due to issue with later temperature checking even tough the sensor monitor was confirming already (Was 10 before with comment = Correlates to a 10s confirmation time. Chosen rather large, should not be so bad for components and helps survive glitches.)
|
||||
//! Changed due to issue with later temperature checking even tough the sensor monitor was
|
||||
//! confirming already (Was 10 before with comment = Correlates to a 10s confirmation time.
|
||||
//! Chosen rather large, should not be so bad for components and helps survive glitches.)
|
||||
static const uint16_t DEFAULT_CONFIRMATION_COUNT = 1;
|
||||
|
||||
static const uint8_t DOMAIN_ID_SENSOR = 1;
|
||||
|
||||
@ -219,4 +225,4 @@ public:
|
||||
|
||||
};
|
||||
|
||||
#endif /* TEMPERATURESENSOR_H_ */
|
||||
#endif /* FSFW_THERMAL_TEMPERATURESENSOR_H_ */
|
||||
|
Loading…
Reference in New Issue
Block a user