restructure repository
This commit is contained in:
70
src/core/thermal/AbstractTemperatureSensor.cpp
Normal file
70
src/core/thermal/AbstractTemperatureSensor.cpp
Normal file
@ -0,0 +1,70 @@
|
||||
#include "AbstractTemperatureSensor.h"
|
||||
#include "../ipc/QueueFactory.h"
|
||||
|
||||
AbstractTemperatureSensor::AbstractTemperatureSensor(object_id_t setObjectid,
|
||||
ThermalModuleIF *thermalModule) :
|
||||
SystemObject(setObjectid), commandQueue(NULL), healthHelper(this,
|
||||
setObjectid), parameterHelper(this) {
|
||||
if (thermalModule != NULL) {
|
||||
thermalModule->registerSensor(this);
|
||||
}
|
||||
commandQueue = QueueFactory::instance()->createMessageQueue();
|
||||
}
|
||||
|
||||
AbstractTemperatureSensor::~AbstractTemperatureSensor() {
|
||||
QueueFactory::instance()->deleteMessageQueue(commandQueue);
|
||||
}
|
||||
|
||||
MessageQueueId_t AbstractTemperatureSensor::getCommandQueue() const {
|
||||
return commandQueue->getId();
|
||||
}
|
||||
|
||||
ReturnValue_t AbstractTemperatureSensor::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();
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t AbstractTemperatureSensor::performOperation(uint8_t opCode) {
|
||||
handleCommandQueue();
|
||||
doChildOperation();
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t AbstractTemperatureSensor::performHealthOp() {
|
||||
handleCommandQueue();
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
void AbstractTemperatureSensor::handleCommandQueue() {
|
||||
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;
|
||||
}
|
||||
command.setToUnknownCommand();
|
||||
commandQueue->reply(&command);
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t AbstractTemperatureSensor::setHealth(HealthState health) {
|
||||
healthHelper.setHealth(health);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
HasHealthIF::HealthState AbstractTemperatureSensor::getHealth() {
|
||||
return healthHelper.getHealth();
|
||||
}
|
||||
10
src/core/thermal/CMakeLists.txt
Normal file
10
src/core/thermal/CMakeLists.txt
Normal file
@ -0,0 +1,10 @@
|
||||
target_sources(${LIB_FSFW_NAME}
|
||||
PRIVATE
|
||||
AbstractTemperatureSensor.cpp
|
||||
Heater.cpp
|
||||
RedundantHeater.cpp
|
||||
ThermalComponentCore.cpp
|
||||
ThermalComponent.cpp
|
||||
ThermalModule.cpp
|
||||
ThermalMonitorReporter.cpp
|
||||
)
|
||||
353
src/core/thermal/Heater.cpp
Normal file
353
src/core/thermal/Heater.cpp
Normal file
@ -0,0 +1,353 @@
|
||||
#include "Heater.h"
|
||||
|
||||
#include "../objectmanager/ObjectManager.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), switch0(switch0), switch1(switch1),
|
||||
heaterOnCountdown(10800000)/*about two orbits*/,
|
||||
parameterHelper(this) {
|
||||
eventQueue = QueueFactory::instance()->createMessageQueue();
|
||||
}
|
||||
|
||||
Heater::~Heater() {
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Heater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
|
||||
this->powerSwitcher = powerSwitch;
|
||||
}
|
||||
|
||||
ReturnValue_t Heater::performOperation(uint8_t opCode) {
|
||||
handleQueue();
|
||||
handleEventQueue();
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
MessageQueueId_t Heater::getCommandQueue() const {
|
||||
return commandQueue->getId();
|
||||
}
|
||||
|
||||
ReturnValue_t Heater::initialize() {
|
||||
ReturnValue_t result = SystemObject::initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
EventManagerIF* manager = ObjectManager::instance()->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::instance()->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 = parameterHelper.initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
result = healthHelper.initialize();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
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:
|
||||
// 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
40
src/core/thermal/RedundantHeater.cpp
Normal file
40
src/core/thermal/RedundantHeater.cpp
Normal file
@ -0,0 +1,40 @@
|
||||
#include "RedundantHeater.h"
|
||||
|
||||
RedundantHeater::~RedundantHeater() {
|
||||
}
|
||||
|
||||
RedundantHeater::RedundantHeater(Parameters parameters) :
|
||||
heater0(parameters.objectIdHeater0, parameters.switch0Heater0,
|
||||
parameters.switch1Heater0), heater1(parameters.objectIdHeater1,
|
||||
parameters.switch0Heater1, parameters.switch1Heater1) {
|
||||
}
|
||||
|
||||
void RedundantHeater::performOperation(uint8_t opCode) {
|
||||
heater0.performOperation(0);
|
||||
heater1.performOperation(0);
|
||||
}
|
||||
|
||||
void RedundantHeater::set(bool on, bool both, bool passive) {
|
||||
if (on) {
|
||||
ReturnValue_t result = heater0.set();
|
||||
if (result != HasReturnvaluesIF::RETURN_OK || both) {
|
||||
heater1.set();
|
||||
} else {
|
||||
heater1.clear(passive);
|
||||
}
|
||||
} else {
|
||||
heater0.clear(passive);
|
||||
heater1.clear(passive);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void RedundantHeater::triggerHeaterEvent(Event event) {
|
||||
heater0.triggerEvent(event);
|
||||
heater1.triggerEvent(event);
|
||||
}
|
||||
|
||||
void RedundantHeater::setPowerSwitcher(PowerSwitchIF* powerSwitch) {
|
||||
heater0.setPowerSwitcher(powerSwitch);
|
||||
heater1.setPowerSwitcher(powerSwitch);
|
||||
}
|
||||
169
src/core/thermal/ThermalComponent.cpp
Normal file
169
src/core/thermal/ThermalComponent.cpp
Normal file
@ -0,0 +1,169 @@
|
||||
#include "ThermalComponent.h"
|
||||
|
||||
ThermalComponent::ThermalComponent(object_id_t reportingObjectId,
|
||||
uint8_t domainId, gp_id_t temperaturePoolId,
|
||||
gp_id_t targetStatePoolId, gp_id_t currentStatePoolId,
|
||||
gp_id_t requestPoolId, LocalPoolDataSetBase* dataSet,
|
||||
AbstractTemperatureSensor* sensor,
|
||||
AbstractTemperatureSensor* firstRedundantSensor,
|
||||
AbstractTemperatureSensor* secondRedundantSensor,
|
||||
ThermalModuleIF* thermalModule, Parameters parameters,
|
||||
Priority priority) :
|
||||
ThermalComponentCore(reportingObjectId, domainId, temperaturePoolId,
|
||||
targetStatePoolId, currentStatePoolId, requestPoolId, dataSet,
|
||||
{ parameters.lowerOpLimit, parameters.upperOpLimit,
|
||||
parameters.heaterOn, parameters.hysteresis,
|
||||
parameters.heaterSwitchoff },
|
||||
ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL),
|
||||
nopParameters({ parameters.lowerNopLimit, parameters.upperNopLimit }) {
|
||||
}
|
||||
|
||||
ThermalComponent::~ThermalComponent() {
|
||||
}
|
||||
|
||||
ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
|
||||
targetState.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
|
||||
targetState.read();
|
||||
if ((targetState == STATE_REQUEST_OPERATIONAL)
|
||||
and (newState != STATE_REQUEST_IGNORE)) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
switch (newState) {
|
||||
case STATE_REQUEST_NON_OPERATIONAL:
|
||||
targetState = newState;
|
||||
targetState.setValid(true);
|
||||
targetState.commit(PoolVariableIF::VALID);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
default:
|
||||
return ThermalComponentCore::setTargetState(newState);
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t ThermalComponent::setLimits(const uint8_t* data, size_t size) {
|
||||
if (size != 4 * sizeof(parameters.lowerOpLimit)) {
|
||||
return MonitoringIF::INVALID_SIZE;
|
||||
}
|
||||
size_t readSize = size;
|
||||
SerializeAdapter::deSerialize(&nopParameters.lowerNopLimit, &data,
|
||||
&readSize, SerializeIF::Endianness::BIG);
|
||||
SerializeAdapter::deSerialize(¶meters.lowerOpLimit, &data,
|
||||
&readSize, SerializeIF::Endianness::BIG);
|
||||
SerializeAdapter::deSerialize(¶meters.upperOpLimit, &data,
|
||||
&readSize, SerializeIF::Endianness::BIG);
|
||||
SerializeAdapter::deSerialize(&nopParameters.upperNopLimit, &data,
|
||||
&readSize, SerializeIF::Endianness::BIG);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ThermalComponentIF::State ThermalComponent::getState(float temperature,
|
||||
ThermalComponentCore::Parameters parameters, int8_t targetState) {
|
||||
if (temperature < nopParameters.lowerNopLimit) {
|
||||
return OUT_OF_RANGE_LOW;
|
||||
} else {
|
||||
State state = ThermalComponentCore::getState(temperature, parameters,
|
||||
targetState);
|
||||
if (state != NON_OPERATIONAL_HIGH
|
||||
&& state != NON_OPERATIONAL_HIGH_IGNORED) {
|
||||
return state;
|
||||
}
|
||||
if (temperature > nopParameters.upperNopLimit) {
|
||||
state = OUT_OF_RANGE_HIGH;
|
||||
}
|
||||
if (targetState == STATE_REQUEST_IGNORE) {
|
||||
state = getIgnoredState(state);
|
||||
}
|
||||
return state;
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalComponent::checkLimits(ThermalComponentIF::State state) {
|
||||
if ((targetState == STATE_REQUEST_OPERATIONAL) or
|
||||
(targetState == STATE_REQUEST_IGNORE)) {
|
||||
ThermalComponentCore::checkLimits(state);
|
||||
return;
|
||||
}
|
||||
// If component is not operational, it checks the NOP limits.
|
||||
temperatureMonitor.translateState(state, temperature.value,
|
||||
nopParameters.lowerNopLimit, nopParameters.upperNopLimit, false);
|
||||
}
|
||||
|
||||
ThermalComponentIF::HeaterRequest ThermalComponent::getHeaterRequest(
|
||||
int8_t targetState, float temperature,
|
||||
ThermalComponentCore::Parameters parameters) {
|
||||
if (targetState == STATE_REQUEST_IGNORE) {
|
||||
isHeating = false;
|
||||
return HEATER_DONT_CARE;
|
||||
}
|
||||
|
||||
if (temperature
|
||||
> nopParameters.upperNopLimit - parameters.heaterSwitchoff) {
|
||||
isHeating = false;
|
||||
return HEATER_REQUEST_EMERGENCY_OFF;
|
||||
}
|
||||
|
||||
float nopHeaterLimit = nopParameters.lowerNopLimit + parameters.heaterOn;
|
||||
float opHeaterLimit = parameters.lowerOpLimit + parameters.heaterOn;
|
||||
|
||||
if (isHeating) {
|
||||
nopHeaterLimit += parameters.hysteresis;
|
||||
opHeaterLimit += parameters.hysteresis;
|
||||
}
|
||||
|
||||
if (temperature < nopHeaterLimit) {
|
||||
isHeating = true;
|
||||
return HEATER_REQUEST_EMERGENCY_ON;
|
||||
}
|
||||
|
||||
if ((targetState == STATE_REQUEST_OPERATIONAL)
|
||||
|| (targetState == STATE_REQUEST_HEATING)) {
|
||||
if (temperature < opHeaterLimit) {
|
||||
isHeating = true;
|
||||
return HEATER_REQUEST_ON;
|
||||
}
|
||||
if (temperature
|
||||
> parameters.upperOpLimit - parameters.heaterSwitchoff) {
|
||||
isHeating = false;
|
||||
return HEATER_REQUEST_OFF;
|
||||
}
|
||||
}
|
||||
|
||||
isHeating = false;
|
||||
return HEATER_DONT_CARE;
|
||||
}
|
||||
|
||||
ThermalComponentIF::State ThermalComponent::getIgnoredState(int8_t state) {
|
||||
switch (state) {
|
||||
case OUT_OF_RANGE_LOW:
|
||||
return OUT_OF_RANGE_LOW_IGNORED;
|
||||
case OUT_OF_RANGE_HIGH:
|
||||
return OUT_OF_RANGE_HIGH_IGNORED;
|
||||
case OUT_OF_RANGE_LOW_IGNORED:
|
||||
return OUT_OF_RANGE_LOW_IGNORED;
|
||||
case OUT_OF_RANGE_HIGH_IGNORED:
|
||||
return OUT_OF_RANGE_HIGH_IGNORED;
|
||||
default:
|
||||
return ThermalComponentCore::getIgnoredState(state);
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t ThermalComponent::getParameter(uint8_t domainId,
|
||||
uint8_t uniqueId, ParameterWrapper* parameterWrapper,
|
||||
const ParameterWrapper* newValues, uint16_t startAtIndex) {
|
||||
ReturnValue_t result = ThermalComponentCore::getParameter(domainId, uniqueId,
|
||||
parameterWrapper, newValues, startAtIndex);
|
||||
if (result != INVALID_IDENTIFIER_ID) {
|
||||
return result;
|
||||
}
|
||||
switch (uniqueId) {
|
||||
case 12:
|
||||
parameterWrapper->set(nopParameters.lowerNopLimit);
|
||||
break;
|
||||
case 13:
|
||||
parameterWrapper->set(nopParameters.upperNopLimit);
|
||||
break;
|
||||
default:
|
||||
return INVALID_IDENTIFIER_ID;
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
286
src/core/thermal/ThermalComponentCore.cpp
Normal file
286
src/core/thermal/ThermalComponentCore.cpp
Normal file
@ -0,0 +1,286 @@
|
||||
#include "ThermalComponentCore.h"
|
||||
#include "tcsDefinitions.h"
|
||||
|
||||
ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId,
|
||||
uint8_t domainId, gp_id_t temperaturePoolId,
|
||||
gp_id_t targetStatePoolId, gp_id_t currentStatePoolId,
|
||||
gp_id_t requestPoolId, LocalPoolDataSetBase* dataSet,
|
||||
Parameters parameters, StateRequest initialTargetState) :
|
||||
temperature(temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE),
|
||||
targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ),
|
||||
currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
|
||||
heaterRequest(requestPoolId, dataSet, PoolVariableIF::VAR_WRITE),
|
||||
parameters(parameters), domainId(domainId),
|
||||
temperatureMonitor(reportingObjectId, domainId + 1,temperaturePoolId,
|
||||
COMPONENT_TEMP_CONFIRMATION) {
|
||||
//Set thermal state once, then leave to operator.
|
||||
targetState.setReadWriteMode(PoolVariableIF::VAR_WRITE);
|
||||
ReturnValue_t result = targetState.read();
|
||||
if(result == HasReturnvaluesIF::RETURN_OK) {
|
||||
targetState = initialTargetState;
|
||||
targetState.setValid(true);
|
||||
targetState.commit();
|
||||
}
|
||||
targetState.setReadWriteMode(PoolVariableIF::VAR_READ);
|
||||
}
|
||||
|
||||
void ThermalComponentCore::addSensor(AbstractTemperatureSensor* sensor) {
|
||||
this->sensor = sensor;
|
||||
}
|
||||
|
||||
void ThermalComponentCore::addFirstRedundantSensor(
|
||||
AbstractTemperatureSensor *firstRedundantSensor) {
|
||||
this->firstRedundantSensor = firstRedundantSensor;
|
||||
}
|
||||
|
||||
void ThermalComponentCore::addSecondRedundantSensor(
|
||||
AbstractTemperatureSensor *secondRedundantSensor) {
|
||||
this->secondRedundantSensor = secondRedundantSensor;
|
||||
}
|
||||
|
||||
void ThermalComponentCore::addThermalModule(ThermalModule *thermalModule,
|
||||
Priority priority) {
|
||||
this->thermalModule = thermalModule;
|
||||
if(thermalModule != nullptr) {
|
||||
thermalModule->registerComponent(this, priority);
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalComponentCore::setPriority(Priority priority) {
|
||||
if(priority == SAFE) {
|
||||
this->isSafeComponent = true;
|
||||
}
|
||||
}
|
||||
|
||||
ThermalComponentCore::~ThermalComponentCore() {
|
||||
}
|
||||
|
||||
ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(
|
||||
uint8_t opCode) {
|
||||
HeaterRequest request = HEATER_DONT_CARE;
|
||||
//SHOULDDO: Better pass db_float_t* to getTemperature and set it invalid if invalid.
|
||||
temperature = getTemperature();
|
||||
updateMinMaxTemp();
|
||||
if (temperature != thermal::INVALID_TEMPERATURE) {
|
||||
temperature.setValid(PoolVariableIF::VALID);
|
||||
State state = getState(temperature.value, getParameters(),
|
||||
targetState.value);
|
||||
currentState = state;
|
||||
checkLimits(state);
|
||||
request = getHeaterRequest(targetState.value, temperature.value,
|
||||
getParameters());
|
||||
} else {
|
||||
temperatureMonitor.setToInvalid();
|
||||
temperature.setValid(PoolVariableIF::INVALID);
|
||||
currentState = UNKNOWN;
|
||||
request = HEATER_DONT_CARE;
|
||||
}
|
||||
currentState.setValid(PoolVariableIF::VALID);
|
||||
heaterRequest = request;
|
||||
heaterRequest.setValid(PoolVariableIF::VALID);
|
||||
return request;
|
||||
}
|
||||
|
||||
void ThermalComponentCore::markStateIgnored() {
|
||||
currentState = getIgnoredState(currentState.value);
|
||||
}
|
||||
|
||||
object_id_t ThermalComponentCore::getObjectId() {
|
||||
return temperatureMonitor.getReporterId();
|
||||
return 0;
|
||||
}
|
||||
|
||||
float ThermalComponentCore::getLowerOpLimit() {
|
||||
return parameters.lowerOpLimit;
|
||||
}
|
||||
|
||||
|
||||
|
||||
ReturnValue_t ThermalComponentCore::setTargetState(int8_t newState) {
|
||||
targetState.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
|
||||
targetState.read();
|
||||
if((targetState == STATE_REQUEST_OPERATIONAL) and
|
||||
(newState != STATE_REQUEST_IGNORE)) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
|
||||
switch (newState) {
|
||||
case STATE_REQUEST_HEATING:
|
||||
case STATE_REQUEST_IGNORE:
|
||||
case STATE_REQUEST_OPERATIONAL:
|
||||
targetState = newState;
|
||||
break;
|
||||
case STATE_REQUEST_NON_OPERATIONAL:
|
||||
default:
|
||||
return INVALID_TARGET_STATE;
|
||||
}
|
||||
targetState.setValid(true);
|
||||
targetState.commit();
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
void ThermalComponentCore::setOutputInvalid() {
|
||||
temperature = thermal::INVALID_TEMPERATURE;
|
||||
temperature.setValid(PoolVariableIF::INVALID);
|
||||
currentState.setValid(PoolVariableIF::INVALID);
|
||||
heaterRequest = HEATER_DONT_CARE;
|
||||
heaterRequest.setValid(PoolVariableIF::INVALID);
|
||||
temperatureMonitor.setToUnchecked();
|
||||
}
|
||||
|
||||
float ThermalComponentCore::getTemperature() {
|
||||
if ((sensor != nullptr) && (sensor->isValid())) {
|
||||
return sensor->getTemperature();
|
||||
}
|
||||
|
||||
if ((firstRedundantSensor != nullptr) &&
|
||||
(firstRedundantSensor->isValid())) {
|
||||
return firstRedundantSensor->getTemperature();
|
||||
}
|
||||
|
||||
if ((secondRedundantSensor != nullptr) &&
|
||||
(secondRedundantSensor->isValid())) {
|
||||
return secondRedundantSensor->getTemperature();
|
||||
}
|
||||
|
||||
if (thermalModule != nullptr) {
|
||||
float temperature = thermalModule->getTemperature();
|
||||
if (temperature != thermal::INVALID_TEMPERATURE) {
|
||||
return temperature;
|
||||
} else {
|
||||
return thermal::INVALID_TEMPERATURE;
|
||||
}
|
||||
} else {
|
||||
return thermal::INVALID_TEMPERATURE;
|
||||
}
|
||||
}
|
||||
|
||||
ThermalComponentIF::State ThermalComponentCore::getState(float temperature,
|
||||
Parameters parameters, int8_t targetState) {
|
||||
ThermalComponentIF::State state;
|
||||
|
||||
if (temperature < parameters.lowerOpLimit) {
|
||||
state = NON_OPERATIONAL_LOW;
|
||||
} else if (temperature < parameters.upperOpLimit) {
|
||||
state = OPERATIONAL;
|
||||
} else {
|
||||
state = NON_OPERATIONAL_HIGH;
|
||||
}
|
||||
if (targetState == STATE_REQUEST_IGNORE) {
|
||||
state = getIgnoredState(state);
|
||||
}
|
||||
|
||||
return state;
|
||||
}
|
||||
|
||||
void ThermalComponentCore::checkLimits(ThermalComponentIF::State state) {
|
||||
//Checks operational limits only.
|
||||
temperatureMonitor.translateState(state, temperature.value,
|
||||
getParameters().lowerOpLimit, getParameters().upperOpLimit);
|
||||
|
||||
}
|
||||
|
||||
ThermalComponentIF::HeaterRequest ThermalComponentCore::getHeaterRequest(
|
||||
int8_t targetState, float temperature, Parameters parameters) {
|
||||
if (targetState == STATE_REQUEST_IGNORE) {
|
||||
isHeating = false;
|
||||
return HEATER_DONT_CARE;
|
||||
}
|
||||
|
||||
if (temperature > parameters.upperOpLimit - parameters.heaterSwitchoff) {
|
||||
isHeating = false;
|
||||
return HEATER_REQUEST_EMERGENCY_OFF;
|
||||
}
|
||||
|
||||
float opHeaterLimit = parameters.lowerOpLimit + parameters.heaterOn;
|
||||
|
||||
if (isHeating) {
|
||||
opHeaterLimit += parameters.hysteresis;
|
||||
}
|
||||
|
||||
if (temperature < opHeaterLimit) {
|
||||
isHeating = true;
|
||||
return HEATER_REQUEST_EMERGENCY_ON;
|
||||
}
|
||||
isHeating = false;
|
||||
return HEATER_DONT_CARE;
|
||||
}
|
||||
|
||||
ThermalComponentIF::State ThermalComponentCore::getIgnoredState(int8_t state) {
|
||||
switch (state) {
|
||||
case NON_OPERATIONAL_LOW:
|
||||
return NON_OPERATIONAL_LOW_IGNORED;
|
||||
case OPERATIONAL:
|
||||
return OPERATIONAL_IGNORED;
|
||||
case NON_OPERATIONAL_HIGH:
|
||||
return NON_OPERATIONAL_HIGH_IGNORED;
|
||||
case NON_OPERATIONAL_LOW_IGNORED:
|
||||
return NON_OPERATIONAL_LOW_IGNORED;
|
||||
case OPERATIONAL_IGNORED:
|
||||
return OPERATIONAL_IGNORED;
|
||||
case NON_OPERATIONAL_HIGH_IGNORED:
|
||||
return NON_OPERATIONAL_HIGH_IGNORED;
|
||||
default:
|
||||
case UNKNOWN:
|
||||
return UNKNOWN;
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalComponentCore::updateMinMaxTemp() {
|
||||
if (temperature == thermal::INVALID_TEMPERATURE) {
|
||||
return;
|
||||
}
|
||||
if (temperature < minTemp) {
|
||||
minTemp = static_cast<float>(temperature);
|
||||
}
|
||||
if (temperature > maxTemp) {
|
||||
maxTemp = static_cast<float>(temperature);
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t ThermalComponentCore::getDomainId() const {
|
||||
return domainId;
|
||||
}
|
||||
|
||||
ThermalComponentCore::Parameters ThermalComponentCore::getParameters() {
|
||||
return parameters;
|
||||
}
|
||||
|
||||
ReturnValue_t ThermalComponentCore::getParameter(uint8_t domainId,
|
||||
uint8_t uniqueId, ParameterWrapper* parameterWrapper,
|
||||
const ParameterWrapper* newValues, uint16_t startAtIndex) {
|
||||
ReturnValue_t result = temperatureMonitor.getParameter(domainId,
|
||||
uniqueId, parameterWrapper, newValues, startAtIndex);
|
||||
if (result != INVALID_DOMAIN_ID) {
|
||||
return result;
|
||||
}
|
||||
if (domainId != this->domainId) {
|
||||
return INVALID_DOMAIN_ID;
|
||||
}
|
||||
switch (uniqueId) {
|
||||
case 0:
|
||||
parameterWrapper->set(parameters.heaterOn);
|
||||
break;
|
||||
case 1:
|
||||
parameterWrapper->set(parameters.hysteresis);
|
||||
break;
|
||||
case 2:
|
||||
parameterWrapper->set(parameters.heaterSwitchoff);
|
||||
break;
|
||||
case 3:
|
||||
parameterWrapper->set(minTemp);
|
||||
break;
|
||||
case 4:
|
||||
parameterWrapper->set(maxTemp);
|
||||
break;
|
||||
case 10:
|
||||
parameterWrapper->set(parameters.lowerOpLimit);
|
||||
break;
|
||||
case 11:
|
||||
parameterWrapper->set(parameters.upperOpLimit);
|
||||
break;
|
||||
default:
|
||||
return INVALID_IDENTIFIER_ID;
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
295
src/core/thermal/ThermalModule.cpp
Normal file
295
src/core/thermal/ThermalModule.cpp
Normal file
@ -0,0 +1,295 @@
|
||||
#include "ThermalModule.h"
|
||||
#include "AbstractTemperatureSensor.h"
|
||||
|
||||
#include "../monitoring/LimitViolationReporter.h"
|
||||
#include "../monitoring/MonitoringMessageContent.h"
|
||||
|
||||
|
||||
ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId,
|
||||
gp_id_t currentStatePoolId, gp_id_t targetStatePoolId,
|
||||
LocalPoolDataSetBase *dataSet, Parameters parameters,
|
||||
RedundantHeater::Parameters heaterParameters) :
|
||||
oldStrategy(ACTIVE_SINGLE), parameters(parameters),
|
||||
moduleTemperature(moduleTemperaturePoolId, dataSet,
|
||||
PoolVariableIF::VAR_WRITE),
|
||||
currentState(currentStatePoolId, dataSet, PoolVariableIF::VAR_WRITE),
|
||||
targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ) {
|
||||
heater = new RedundantHeater(heaterParameters);
|
||||
}
|
||||
|
||||
ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId,
|
||||
LocalPoolDataSetBase* dataSet) :
|
||||
oldStrategy(ACTIVE_SINGLE), parameters( { 0, 0 }),
|
||||
moduleTemperature(moduleTemperaturePoolId, dataSet,
|
||||
PoolVariableIF::VAR_WRITE),
|
||||
currentState(gp_id_t(), dataSet,
|
||||
PoolVariableIF::VAR_WRITE),
|
||||
targetState(gp_id_t(), dataSet,
|
||||
PoolVariableIF::VAR_READ) {
|
||||
}
|
||||
|
||||
ThermalModule::~ThermalModule() {
|
||||
delete heater;
|
||||
}
|
||||
|
||||
void ThermalModule::performOperation(uint8_t opCode) {
|
||||
if (heater != nullptr) {
|
||||
heater->performOperation(0);
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalModule::performMode(Strategy strategy) {
|
||||
calculateTemperature();
|
||||
|
||||
bool safeOnly = (strategy == ACTIVE_SURVIVAL);
|
||||
ThermalComponentIF::HeaterRequest componentHeaterRequest =
|
||||
letComponentsPerformAndDeciceIfWeNeedToHeat(safeOnly);
|
||||
|
||||
if (heater == nullptr) {
|
||||
informComponentsAboutHeaterState(false, NONE);
|
||||
return;
|
||||
}
|
||||
|
||||
bool heating = calculateModuleHeaterRequestAndSetModuleStatus(strategy);
|
||||
|
||||
if (componentHeaterRequest != ThermalComponentIF::HEATER_DONT_CARE) {
|
||||
//Components overwrite the module request.
|
||||
heating = ((componentHeaterRequest
|
||||
== ThermalComponentIF::HEATER_REQUEST_ON)
|
||||
or (componentHeaterRequest
|
||||
== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON));
|
||||
}
|
||||
|
||||
bool dual = (strategy == ACTIVE_DUAL);
|
||||
|
||||
if (strategy == PASSIVE) {
|
||||
informComponentsAboutHeaterState(false, NONE);
|
||||
if (oldStrategy != PASSIVE) {
|
||||
heater->set(false, false, true);
|
||||
}
|
||||
} else {
|
||||
if (safeOnly) {
|
||||
informComponentsAboutHeaterState(heating, SAFE);
|
||||
} else {
|
||||
informComponentsAboutHeaterState(heating, ALL);
|
||||
}
|
||||
heater->set(heating, dual);
|
||||
}
|
||||
oldStrategy = strategy;
|
||||
}
|
||||
|
||||
float ThermalModule::getTemperature() {
|
||||
return moduleTemperature.value;
|
||||
}
|
||||
|
||||
void ThermalModule::registerSensor(AbstractTemperatureSensor * sensor) {
|
||||
sensors.push_back(sensor);
|
||||
}
|
||||
|
||||
void ThermalModule::registerComponent(ThermalComponentIF* component,
|
||||
ThermalComponentIF::Priority priority) {
|
||||
components.push_back(ComponentData( { component, priority,
|
||||
ThermalComponentIF::HEATER_DONT_CARE }));
|
||||
}
|
||||
|
||||
void ThermalModule::calculateTemperature() {
|
||||
uint32_t numberOfValidSensors = 0;
|
||||
moduleTemperature = 0;
|
||||
std::list<AbstractTemperatureSensor *>::iterator iter = sensors.begin();
|
||||
for (; iter != sensors.end(); iter++) {
|
||||
if ((*iter)->isValid()) {
|
||||
moduleTemperature = moduleTemperature.value +
|
||||
(*iter)->getTemperature();
|
||||
numberOfValidSensors++;
|
||||
}
|
||||
}
|
||||
if (numberOfValidSensors != 0) {
|
||||
moduleTemperature = moduleTemperature.value / numberOfValidSensors;
|
||||
moduleTemperature.setValid(PoolVariableIF::VALID);
|
||||
} else {
|
||||
moduleTemperature.value = thermal::INVALID_TEMPERATURE;
|
||||
moduleTemperature.setValid(PoolVariableIF::INVALID);
|
||||
}
|
||||
}
|
||||
|
||||
ThermalComponentIF* ThermalModule::findComponent(object_id_t objectId) {
|
||||
std::list<ComponentData>::iterator iter = components.begin();
|
||||
for (; iter != components.end(); iter++) {
|
||||
if (iter->component->getObjectId() == objectId) {
|
||||
return iter->component;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ThermalComponentIF::HeaterRequest
|
||||
ThermalModule::letComponentsPerformAndDeciceIfWeNeedToHeat(bool safeOnly) {
|
||||
ThermalComponentIF::HeaterRequest
|
||||
heaterRequests[ThermalComponentIF::NUMBER_OF_PRIORITIES];
|
||||
|
||||
survivalTargetTemp = -999;
|
||||
targetTemp = -999;
|
||||
|
||||
for (uint8_t i = 0; i < ThermalComponentIF::NUMBER_OF_PRIORITIES; i++) {
|
||||
heaterRequests[i] = ThermalComponentIF::HEATER_DONT_CARE;
|
||||
}
|
||||
|
||||
std::list<ComponentData>::iterator iter = components.begin();
|
||||
for (; iter != components.end(); iter++) {
|
||||
updateTargetTemperatures(iter->component,
|
||||
iter->priority == ThermalComponentIF::SAFE);
|
||||
ThermalComponentIF::HeaterRequest request =
|
||||
iter->component->performOperation(0);
|
||||
iter->request = request;
|
||||
if (request != ThermalComponentIF::HEATER_DONT_CARE) {
|
||||
if (request < heaterRequests[iter->priority]) {
|
||||
heaterRequests[iter->priority] = request;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!safeOnly) {
|
||||
for (uint8_t i = ThermalComponentIF::NUMBER_OF_PRIORITIES - 1; i > 0;
|
||||
i--) {
|
||||
if (heaterRequests[i - 1] == ThermalComponentIF::HEATER_DONT_CARE) {
|
||||
heaterRequests[i - 1] = heaterRequests[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
return heaterRequests[0];
|
||||
}
|
||||
|
||||
void ThermalModule::informComponentsAboutHeaterState(bool heaterIsOn,
|
||||
Informee whomToInform) {
|
||||
std::list<ComponentData>::iterator iter = components.begin();
|
||||
for (; iter != components.end(); iter++) {
|
||||
switch (whomToInform) {
|
||||
case ALL:
|
||||
break;
|
||||
case SAFE:
|
||||
if (!(iter->priority == ThermalComponentIF::SAFE)) {
|
||||
iter->component->markStateIgnored();
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
case NONE:
|
||||
iter->component->markStateIgnored();
|
||||
continue;
|
||||
}
|
||||
|
||||
if (heaterIsOn) {
|
||||
if ((iter->request
|
||||
== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_OFF)
|
||||
|| (iter->request == ThermalComponentIF::HEATER_REQUEST_OFF)) {
|
||||
iter->component->markStateIgnored();
|
||||
}
|
||||
} else {
|
||||
if ((iter->request
|
||||
== ThermalComponentIF::HEATER_REQUEST_EMERGENCY_ON)
|
||||
|| (iter->request == ThermalComponentIF::HEATER_REQUEST_ON)) {
|
||||
iter->component->markStateIgnored();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
|
||||
if (heater != NULL) {
|
||||
heater->setPowerSwitcher(powerSwitch);
|
||||
}
|
||||
|
||||
std::list<ComponentData>::iterator iter = components.begin();
|
||||
for (; iter != components.end(); iter++) {
|
||||
float componentLowerOpLimit = iter->component->getLowerOpLimit();
|
||||
if (iter->priority == ThermalComponentIF::SAFE) {
|
||||
if (componentLowerOpLimit > survivalTargetTemp) {
|
||||
survivalTargetTemp = componentLowerOpLimit;
|
||||
}
|
||||
} else {
|
||||
if (componentLowerOpLimit > targetTemp) {
|
||||
targetTemp = componentLowerOpLimit;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (survivalTargetTemp > targetTemp) {
|
||||
targetTemp = survivalTargetTemp;
|
||||
}
|
||||
}
|
||||
|
||||
bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(
|
||||
Strategy strategy) {
|
||||
currentState.setValid(PoolVariableIF::VALID);
|
||||
if (moduleTemperature == thermal::INVALID_TEMPERATURE) {
|
||||
currentState = UNKNOWN;
|
||||
return false;
|
||||
}
|
||||
|
||||
float limit = targetTemp;
|
||||
bool heaterRequest = false;
|
||||
if (strategy == ACTIVE_SURVIVAL) {
|
||||
limit = survivalTargetTemp;
|
||||
}
|
||||
|
||||
if (moduleTemperature.value >= limit) {
|
||||
currentState = OPERATIONAL;
|
||||
} else {
|
||||
currentState = NON_OPERATIONAL;
|
||||
}
|
||||
|
||||
limit += parameters.heaterOn;
|
||||
|
||||
if (heating) {
|
||||
limit += parameters.hysteresis;
|
||||
}
|
||||
|
||||
if (targetState == STATE_REQUEST_HEATING) {
|
||||
if (moduleTemperature < limit) {
|
||||
heaterRequest = true;
|
||||
} else {
|
||||
heaterRequest = false;
|
||||
}
|
||||
}
|
||||
|
||||
heating = heaterRequest;
|
||||
|
||||
return heaterRequest;
|
||||
}
|
||||
|
||||
void ThermalModule::setHeating(bool on) {
|
||||
ReturnValue_t result = targetState.read();
|
||||
if(result == HasReturnvaluesIF::RETURN_OK) {
|
||||
if(on) {
|
||||
targetState.value = STATE_REQUEST_HEATING;
|
||||
}
|
||||
else {
|
||||
targetState.value = STATE_REQUEST_PASSIVE;
|
||||
}
|
||||
}
|
||||
targetState.setValid(true);
|
||||
}
|
||||
|
||||
void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component,
|
||||
bool isSafe) {
|
||||
if (isSafe) {
|
||||
if (component->getLowerOpLimit() > survivalTargetTemp) {
|
||||
survivalTargetTemp = component->getLowerOpLimit();
|
||||
}
|
||||
} else {
|
||||
if (component->getLowerOpLimit() > targetTemp) {
|
||||
targetTemp = component->getLowerOpLimit();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalModule::setOutputInvalid() {
|
||||
moduleTemperature = thermal::INVALID_TEMPERATURE;
|
||||
moduleTemperature.setValid(PoolVariableIF::INVALID);
|
||||
currentState.setValid(PoolVariableIF::INVALID);
|
||||
std::list<ComponentData>::iterator iter = components.begin();
|
||||
for (; iter != components.end(); iter++) {
|
||||
iter->component->setOutputInvalid();
|
||||
}
|
||||
if (heater != NULL) {
|
||||
heater->set(false,true);
|
||||
}
|
||||
}
|
||||
75
src/core/thermal/ThermalMonitorReporter.cpp
Normal file
75
src/core/thermal/ThermalMonitorReporter.cpp
Normal file
@ -0,0 +1,75 @@
|
||||
#include "ThermalMonitorReporter.h"
|
||||
#include "ThermalComponentIF.h"
|
||||
|
||||
#include "../monitoring/MonitoringIF.h"
|
||||
|
||||
ThermalMonitorReporter::~ThermalMonitorReporter() {
|
||||
}
|
||||
|
||||
void ThermalMonitorReporter::sendTransitionEvent(float currentValue,
|
||||
ReturnValue_t state) {
|
||||
switch (state) {
|
||||
case MonitoringIF::BELOW_LOW_LIMIT:
|
||||
EventManagerIF::triggerEvent(reportingId,
|
||||
ThermalComponentIF::COMPONENT_TEMP_OOL_LOW, state);
|
||||
break;
|
||||
case MonitoringIF::ABOVE_HIGH_LIMIT:
|
||||
EventManagerIF::triggerEvent(reportingId,
|
||||
ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH, state);
|
||||
break;
|
||||
case ThermalComponentIF::BELOW_OPERATIONAL_LIMIT:
|
||||
EventManagerIF::triggerEvent(reportingId,
|
||||
ThermalComponentIF::COMPONENT_TEMP_LOW, state);
|
||||
break;
|
||||
case ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT:
|
||||
EventManagerIF::triggerEvent(reportingId,
|
||||
ThermalComponentIF::COMPONENT_TEMP_HIGH, state);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
bool ThermalMonitorReporter::isAboveHighLimit() {
|
||||
if (oldState == ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
ReturnValue_t ThermalMonitorReporter::translateState(
|
||||
ThermalComponentIF::State state, float sample, float lowerLimit,
|
||||
float upperLimit, bool componentIsOperational) {
|
||||
if (ThermalComponentIF::isIgnoredState(state)) {
|
||||
setToUnchecked();
|
||||
return MonitoringIF::UNCHECKED;
|
||||
}
|
||||
switch (state) {
|
||||
case ThermalComponentIF::OUT_OF_RANGE_LOW:
|
||||
return monitorStateIs(MonitoringIF::BELOW_LOW_LIMIT, sample,
|
||||
lowerLimit);
|
||||
case ThermalComponentIF::NON_OPERATIONAL_LOW:
|
||||
if (componentIsOperational) {
|
||||
return monitorStateIs(ThermalComponentIF::BELOW_OPERATIONAL_LIMIT,
|
||||
sample, lowerLimit);
|
||||
} else {
|
||||
return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
|
||||
}
|
||||
case ThermalComponentIF::OPERATIONAL:
|
||||
return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
|
||||
case ThermalComponentIF::NON_OPERATIONAL_HIGH:
|
||||
if (componentIsOperational) {
|
||||
return monitorStateIs(ThermalComponentIF::ABOVE_OPERATIONAL_LIMIT,
|
||||
sample, upperLimit);
|
||||
} else {
|
||||
return monitorStateIs(HasReturnvaluesIF::RETURN_OK, sample, 0.0);
|
||||
}
|
||||
case ThermalComponentIF::OUT_OF_RANGE_HIGH:
|
||||
return monitorStateIs(MonitoringIF::ABOVE_HIGH_LIMIT, sample,
|
||||
upperLimit);
|
||||
default:
|
||||
//Never reached, all states covered.
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user