eive-obsw/mission/tcs/HeaterHandler.cpp

461 lines
16 KiB
C++
Raw Normal View History

2022-05-02 17:37:00 +02:00
#include <fsfw/health/HealthTableIF.h>
#include <fsfw/ipc/QueueFactory.h>
2022-01-17 15:58:27 +01:00
#include <fsfw/objectmanager/ObjectManager.h>
2021-08-03 15:58:01 +02:00
#include <fsfw_hal/common/gpio/GpioCookie.h>
2023-03-26 16:42:00 +02:00
#include <mission/tcs/HeaterHandler.h>
2021-01-28 14:55:21 +01:00
2022-05-02 17:37:00 +02:00
#include <stdexcept>
2022-01-17 15:58:27 +01:00
#include "devices/powerSwitcherList.h"
2023-02-17 11:50:14 +01:00
#include "fsfw/subsystem/helper.h"
2022-01-17 15:58:27 +01:00
HeaterHandler::HeaterHandler(object_id_t setObjectId_, GpioIF* gpioInterface_, HeaterHelper helper,
PowerSwitchIF* mainLineSwitcher_, power::Switch_t mainLineSwitch_)
2022-01-17 15:58:27 +01:00
: SystemObject(setObjectId_),
helper(helper),
2023-02-17 11:50:14 +01:00
modeHelper(this),
gpioInterface(gpioInterface_),
2022-05-02 17:37:00 +02:00
mainLineSwitcher(mainLineSwitcher_),
2022-01-17 15:58:27 +01:00
mainLineSwitch(mainLineSwitch_),
actionHelper(this, nullptr) {
for (const auto& heater : helper.heaters) {
if (heater.first == nullptr) {
throw std::invalid_argument("HeaterHandler::HeaterHandler: Invalid Heater Object");
}
}
if (gpioInterface_ == nullptr) {
throw std::invalid_argument("HeaterHandler::HeaterHandler: Invalid Gpio IF");
}
2022-05-02 17:37:00 +02:00
if (mainLineSwitcher == nullptr) {
throw std::invalid_argument("HeaterHandler::HeaterHandler: Invalid PowerSwitchIF");
}
2023-03-02 15:32:12 +01:00
handlerLock = MutexFactory::instance()->createMutex();
if (handlerLock == nullptr) {
throw std::runtime_error("HeaterHandler::HeaterHandler: Creating Mutex failed");
}
2022-02-22 20:27:13 +01:00
auto mqArgs = MqArgs(setObjectId_, static_cast<void*>(this));
2022-01-17 15:58:27 +01:00
commandQueue = QueueFactory::instance()->createMessageQueue(
2022-02-22 20:27:13 +01:00
cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
2021-01-23 17:22:40 +01:00
}
2023-02-22 17:50:03 +01:00
HeaterHandler::~HeaterHandler() = default;
2021-01-23 17:22:40 +01:00
2021-01-28 14:55:21 +01:00
ReturnValue_t HeaterHandler::performOperation(uint8_t operationCode) {
2022-05-02 22:58:06 +02:00
try {
readCommandQueue();
for (const auto& heater : helper.heaters) {
heater.first->performOperation(0);
}
2022-05-12 20:44:36 +02:00
handleSwitchHandling();
2023-02-17 11:50:14 +01:00
if (waitForSwitchOff) {
if (mainLineSwitcher->getSwitchState(mainLineSwitch) == SWITCH_OFF) {
waitForSwitchOff = false;
mode = MODE_OFF;
2023-06-27 17:36:52 +02:00
busyWithSwitchCommanding = false;
2023-02-17 13:11:16 +01:00
modeHelper.modeChanged(mode, submode);
2023-02-17 11:50:14 +01:00
}
}
2023-06-27 17:36:52 +02:00
if (busyWithSwitchCommanding and heaterCmdBusyCd.hasTimedOut()) {
busyWithSwitchCommanding = false;
}
} catch (const std::out_of_range& e) {
2022-05-02 22:58:06 +02:00
sif::warning << "HeaterHandler::performOperation: "
"Out of range error | "
<< e.what() << std::endl;
2022-01-17 15:58:27 +01:00
}
2022-08-24 17:27:47 +02:00
return returnvalue::OK;
2021-01-23 17:22:40 +01:00
}
2021-01-28 14:55:21 +01:00
ReturnValue_t HeaterHandler::initialize() {
2022-01-17 15:58:27 +01:00
ReturnValue_t result = SystemObject::initialize();
2022-08-24 17:27:47 +02:00
if (result != returnvalue::OK) {
2022-01-17 15:58:27 +01:00
return ObjectManagerIF::CHILD_INIT_FAILED;
}
result = initializeHeaterMap();
2022-08-24 17:27:47 +02:00
if (result != returnvalue::OK) {
2022-01-17 15:58:27 +01:00
return ObjectManagerIF::CHILD_INIT_FAILED;
}
ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
if (ipcStore == nullptr) {
2022-01-17 15:58:27 +01:00
sif::error << "HeaterHandler::initialize: IPC store not set up in factory." << std::endl;
return ObjectManagerIF::CHILD_INIT_FAILED;
}
result = actionHelper.initialize(commandQueue);
2022-08-24 17:27:47 +02:00
if (result != returnvalue::OK) {
2022-01-17 15:58:27 +01:00
return ObjectManagerIF::CHILD_INIT_FAILED;
}
2023-02-17 11:50:14 +01:00
result = modeHelper.initialize();
if (result != returnvalue::OK) {
return ObjectManagerIF::CHILD_INIT_FAILED;
}
2022-08-24 17:27:47 +02:00
return returnvalue::OK;
2021-01-23 17:22:40 +01:00
}
2022-01-17 15:58:27 +01:00
ReturnValue_t HeaterHandler::initializeHeaterMap() {
2022-05-02 22:55:39 +02:00
for (power::Switch_t switchNr = 0; switchNr < heater::NUMBER_OF_SWITCHES; switchNr++) {
2023-07-06 23:06:50 +02:00
heaterVec.push_back(HeaterWrapper(helper.heaters[switchNr], heater::SwitchState::OFF));
2022-01-17 15:58:27 +01:00
}
2022-08-24 17:27:47 +02:00
return returnvalue::OK;
2021-01-28 14:55:21 +01:00
}
2021-01-23 17:22:40 +01:00
2021-01-28 14:55:21 +01:00
void HeaterHandler::readCommandQueue() {
2022-08-24 17:27:47 +02:00
ReturnValue_t result = returnvalue::OK;
2022-01-17 15:58:27 +01:00
CommandMessage command;
2023-06-27 17:55:49 +02:00
if (not busyWithSwitchCommanding) {
result = commandQueue->receiveMessage(&command);
if (result == MessageQueueIF::EMPTY) {
return;
} else if (result != returnvalue::OK) {
sif::warning << "HeaterHandler::readCommandQueue: Message reception error" << std::endl;
return;
2023-02-17 13:11:16 +01:00
}
2023-06-27 17:55:49 +02:00
result = modeHelper.handleModeCommand(&command);
if (result == returnvalue::OK) {
return;
}
result = actionHelper.handleActionMessage(&command);
if (result == returnvalue::OK) {
return;
}
}
2021-01-23 17:22:40 +01:00
}
2022-01-17 15:58:27 +01:00
ReturnValue_t HeaterHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
const uint8_t* data, size_t size) {
if (data == nullptr or size < 3) {
return HasActionsIF::INVALID_PARAMETERS;
}
2022-01-17 15:58:27 +01:00
if (actionId != SWITCH_HEATER) {
return COMMAND_NOT_SUPPORTED;
2022-01-17 15:58:27 +01:00
}
2022-05-04 10:34:11 +02:00
auto switchNr = data[0];
if (switchNr > 7) {
return HasActionsIF::INVALID_PARAMETERS;
}
2022-05-04 10:34:11 +02:00
auto& heater = heaterVec.at(switchNr);
2022-05-12 20:44:36 +02:00
auto actionRaw = data[1];
if (actionRaw != 0 and actionRaw != 1) {
return HasActionsIF::INVALID_PARAMETERS;
}
2022-05-12 20:44:36 +02:00
auto action = static_cast<SwitchAction>(data[1]);
// Always accepts OFF commands
if (action == SwitchAction::SET_SWITCH_ON) {
2023-02-21 01:53:23 +01:00
HasHealthIF::HealthState health;
{
2023-03-02 15:32:12 +01:00
MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
2023-02-21 01:53:23 +01:00
health = heater.healthDevice->getHealth();
}
2022-05-12 20:44:36 +02:00
if (health == HasHealthIF::FAULTY or health == HasHealthIF::PERMANENT_FAULTY or
health == HasHealthIF::NEEDS_RECOVERY) {
return HasHealthIF::OBJECT_NOT_HEALTHY;
}
CmdSourceParam cmdSource = CmdSourceParam::EXTERNAL;
uint8_t cmdSourceRaw = data[2];
if (cmdSourceRaw > 1) {
return HasActionsIF::INVALID_PARAMETERS;
}
cmdSource = static_cast<CmdSourceParam>(data[2]);
if (health == HasHealthIF::EXTERNAL_CONTROL and cmdSource == CmdSourceParam::INTERNAL) {
return HasHealthIF::IS_EXTERNALLY_CONTROLLED;
}
}
2022-05-12 20:44:36 +02:00
if (heater.cmdActive) {
return COMMAND_ALREADY_WAITING;
}
2022-05-12 20:44:36 +02:00
heater.action = action;
heater.cmdActive = true;
heater.replyQueue = commandedBy;
2023-06-27 17:36:52 +02:00
busyWithSwitchCommanding = true;
heaterCmdBusyCd.resetTimer();
2022-08-24 17:27:47 +02:00
return returnvalue::OK;
2021-01-23 17:22:40 +01:00
}
2022-03-30 12:22:49 +02:00
ReturnValue_t HeaterHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onOff) {
2022-01-17 15:58:27 +01:00
ReturnValue_t result;
store_address_t storeAddress;
uint8_t commandData[3] = {};
2022-01-17 15:58:27 +01:00
switch (onOff) {
case PowerSwitchIF::SWITCH_ON:
commandData[0] = switchNr;
commandData[1] = SET_SWITCH_ON;
commandData[2] = CmdSourceParam::INTERNAL;
2022-01-17 15:58:27 +01:00
break;
case PowerSwitchIF::SWITCH_OFF:
commandData[0] = switchNr;
commandData[1] = SET_SWITCH_OFF;
commandData[2] = CmdSourceParam::INTERNAL;
2022-01-17 15:58:27 +01:00
break;
default:
sif::error << "HeaterHandler::sendSwitchCommand: Invalid switch request" << std::endl;
break;
}
result = ipcStore->addData(&storeAddress, commandData, sizeof(commandData));
2022-08-24 17:27:47 +02:00
if (result == returnvalue::OK) {
2022-01-17 15:58:27 +01:00
CommandMessage message;
ActionMessage::setCommand(&message, SWITCH_HEATER, storeAddress);
/* Send heater command to own command queue */
result = commandQueue->sendMessage(commandQueue->getId(), &message, 0);
2022-08-24 17:27:47 +02:00
if (result != returnvalue::OK) {
2022-01-17 15:58:27 +01:00
sif::debug << "HeaterHandler::sendSwitchCommand: Failed to send switch"
<< "message" << std::endl;
}
}
2022-03-30 12:22:49 +02:00
return result;
2021-01-23 17:22:40 +01:00
}
2022-05-12 20:44:36 +02:00
void HeaterHandler::handleSwitchHandling() {
2022-05-02 22:55:39 +02:00
for (uint8_t idx = 0; idx < heater::NUMBER_OF_SWITCHES; idx++) {
2022-05-12 20:44:36 +02:00
auto health = heaterVec[idx].healthDevice->getHealth();
2023-07-06 23:06:50 +02:00
if (heaterVec[idx].switchState == heater::SwitchState::ON) {
2022-05-12 20:44:36 +02:00
// If a heater is still on but the device was marked faulty by the operator, the SW
// will shut down the heater
if (health == HasHealthIF::FAULTY or health == HasHealthIF::PERMANENT_FAULTY) {
heaterVec[idx].cmdActive = true;
heaterVec[idx].action = SET_SWITCH_OFF;
triggerEvent(FAULTY_HEATER_WAS_ON, idx, 0);
2023-04-06 12:13:24 +02:00
handleSwitchOffCommand(static_cast<heater::Switch>(idx));
2022-05-12 20:44:36 +02:00
continue;
}
}
if (heaterVec[idx].cmdActive) {
switch (heaterVec[idx].action) {
2022-01-17 15:58:27 +01:00
case SET_SWITCH_ON:
2023-04-06 12:13:24 +02:00
handleSwitchOnCommand(static_cast<heater::Switch>(idx));
2022-01-17 15:58:27 +01:00
break;
case SET_SWITCH_OFF:
2023-04-06 12:13:24 +02:00
handleSwitchOffCommand(static_cast<heater::Switch>(idx));
2022-01-17 15:58:27 +01:00
break;
default:
sif::error << "HeaterHandler::handleActiveCommands: Invalid action commanded"
<< std::endl;
break;
}
}
}
2021-01-23 17:22:40 +01:00
}
2023-04-06 12:13:24 +02:00
void HeaterHandler::handleSwitchOnCommand(heater::Switch heaterIdx) {
2022-08-24 17:27:47 +02:00
ReturnValue_t result = returnvalue::OK;
auto& heater = heaterVec.at(heaterIdx);
2023-02-17 11:50:14 +01:00
if (waitForSwitchOff) {
waitForSwitchOff = false;
}
2022-01-17 15:58:27 +01:00
/* Check if command waits for main switch being set on and whether the timeout has expired */
if (heater.waitMainSwitchOn && heater.mainSwitchCountdown.hasTimedOut()) {
2022-01-17 15:58:27 +01:00
// TODO - This requires the initiation of an FDIR procedure
triggerEvent(MAIN_SWITCH_TIMEOUT);
sif::error << "HeaterHandler::handleSwitchOnCommand: Main switch setting on timeout"
<< std::endl;
2022-05-12 20:44:36 +02:00
heater.cmdActive = false;
2023-06-27 17:36:52 +02:00
busyWithSwitchCommanding = false;
heater.waitMainSwitchOn = false;
if (heater.replyQueue != commandQueue->getId()) {
actionHelper.finish(false, heater.replyQueue, heater.action, MAIN_SWITCH_SET_TIMEOUT);
2021-02-11 08:19:48 +01:00
}
2022-01-17 15:58:27 +01:00
return;
}
// Check state of main line switch
2022-01-17 15:58:27 +01:00
ReturnValue_t mainSwitchState = mainLineSwitcher->getSwitchState(mainLineSwitch);
if (mainSwitchState == PowerSwitchIF::SWITCH_ON) {
2023-06-27 17:36:52 +02:00
gpioId_t gpioId = heater.gpioId;
result = gpioInterface->pullHigh(gpioId);
if (result != returnvalue::OK) {
sif::error << "HeaterHandler::handleSwitchOnCommand: Failed to pull GPIO with ID " << gpioId
<< " high" << std::endl;
triggerEvent(GPIO_PULL_HIGH_FAILED, result);
}
if (result == returnvalue::OK) {
2023-06-27 17:55:49 +02:00
triggerEvent(HEATER_WENT_ON, heaterIdx, 0);
{
MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
2023-07-06 23:06:50 +02:00
heater.switchState = heater::SwitchState::ON;
2022-01-17 15:58:27 +01:00
}
2023-06-27 17:36:52 +02:00
EventManagerIF::triggerEvent(helper.heaters[heaterIdx].first->getObjectId(), MODE_INFO,
MODE_ON, 0);
busyWithSwitchCommanding = false;
mode = HasModesIF::MODE_ON;
modeHelper.modeChanged(mode, submode);
}
// There is no need to send action finish replies if the sender was the
// HeaterHandler itself
if (heater.replyQueue != commandQueue->getId()) {
2022-08-24 17:27:47 +02:00
if (result == returnvalue::OK) {
actionHelper.finish(true, heater.replyQueue, heater.action, result);
2022-01-17 15:58:27 +01:00
} else {
actionHelper.finish(false, heater.replyQueue, heater.action, result);
2022-01-17 15:58:27 +01:00
}
}
2022-05-12 20:44:36 +02:00
heater.cmdActive = false;
heater.waitMainSwitchOn = false;
} else if (mainSwitchState == PowerSwitchIF::SWITCH_OFF && heater.waitMainSwitchOn) {
// Just waiting for the main switch being set on
2022-01-17 15:58:27 +01:00
return;
} else if (mainSwitchState == PowerSwitchIF::SWITCH_OFF or
2023-04-03 15:16:53 +02:00
mainSwitchState == PowerSwitchIF::SWITCH_UNKNOWN) {
2022-01-17 15:58:27 +01:00
mainLineSwitcher->sendSwitchCommand(mainLineSwitch, PowerSwitchIF::SWITCH_ON);
heater.mainSwitchCountdown.setTimeout(mainLineSwitcher->getSwitchDelayMs());
heater.waitMainSwitchOn = true;
2022-01-17 15:58:27 +01:00
} else {
2023-02-22 19:14:35 +01:00
sif::debug << "HeaterHandler::handleSwitchOnCommand: Failed to get state of"
2022-01-17 15:58:27 +01:00
<< " main line switch" << std::endl;
if (heater.replyQueue != commandQueue->getId()) {
actionHelper.finish(false, heater.replyQueue, heater.action, mainSwitchState);
}
2022-05-12 20:44:36 +02:00
heater.cmdActive = false;
2022-01-17 15:58:27 +01:00
}
}
2023-04-06 12:13:24 +02:00
void HeaterHandler::handleSwitchOffCommand(heater::Switch heaterIdx) {
2022-08-24 17:27:47 +02:00
ReturnValue_t result = returnvalue::OK;
auto& heater = heaterVec.at(heaterIdx);
2023-06-27 17:36:52 +02:00
gpioId_t gpioId = heater.gpioId;
result = gpioInterface->pullLow(gpioId);
if (result != returnvalue::OK) {
sif::error << "HeaterHandler::handleSwitchOffCommand: Failed to pull gpio with id" << gpioId
<< " low" << std::endl;
triggerEvent(GPIO_PULL_LOW_FAILED, result);
}
if (result == returnvalue::OK) {
// Check whether switch is already off
2023-07-06 23:06:50 +02:00
if (getSwitchState(heaterIdx) == heater::SwitchState::ON) {
2023-02-21 01:53:23 +01:00
{
2023-03-02 15:32:12 +01:00
MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
2023-07-06 23:06:50 +02:00
heater.switchState = heater::SwitchState::OFF;
}
triggerEvent(HEATER_WENT_OFF, heaterIdx, 0);
2023-06-27 17:36:52 +02:00
} else {
triggerEvent(SWITCH_ALREADY_OFF, heaterIdx);
}
EventManagerIF::triggerEvent(helper.heaters[heaterIdx].first->getObjectId(), MODE_INFO,
MODE_OFF, 0);
// When all switches are off, also main line switch will be turned off
if (allSwitchesOff()) {
mainLineSwitcher->sendSwitchCommand(mainLineSwitch, PowerSwitchIF::SWITCH_OFF);
waitForSwitchOff = true;
} else {
busyWithSwitchCommanding = false;
}
2022-01-17 15:58:27 +01:00
}
if (heater.replyQueue != NO_COMMANDER) {
// Report back switch command reply if necessary
2022-08-24 17:27:47 +02:00
if (result == returnvalue::OK) {
actionHelper.finish(true, heater.replyQueue, heater.action, result);
2022-01-17 15:58:27 +01:00
} else {
actionHelper.finish(false, heater.replyQueue, heater.action, result);
}
2022-01-17 15:58:27 +01:00
}
2022-05-12 20:44:36 +02:00
heater.cmdActive = false;
}
2023-07-06 23:06:50 +02:00
heater::SwitchState HeaterHandler::getSwitchState(heater::Switch switchNr) const {
2023-03-02 15:32:12 +01:00
MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
return heaterVec.at(switchNr).switchState;
}
2021-01-28 14:55:21 +01:00
2023-07-06 23:06:50 +02:00
ReturnValue_t HeaterHandler::switchHeater(heater::Switch heater, heater::SwitchState switchState) {
if (switchState == heater::SwitchState::ON) {
2022-11-28 08:56:36 +01:00
return sendSwitchCommand(heater, PowerSwitchIF::SWITCH_ON);
2023-07-06 23:06:50 +02:00
} else if (switchState == heater::SwitchState::OFF) {
2022-11-28 08:56:36 +01:00
return sendSwitchCommand(heater, PowerSwitchIF::SWITCH_OFF);
}
return returnvalue::FAILED;
2022-11-16 16:36:59 +01:00
}
2023-02-17 11:50:14 +01:00
void HeaterHandler::announceMode(bool recursive) {
triggerEvent(MODE_INFO, mode, submode);
2023-02-21 01:53:23 +01:00
2023-07-06 23:06:50 +02:00
std::array<heater::SwitchState, 8> states;
2023-02-21 02:28:57 +01:00
getAllSwitchStates(states);
2023-02-17 11:50:14 +01:00
for (unsigned idx = 0; idx < helper.heaters.size(); idx++) {
2023-07-06 23:06:50 +02:00
if (states[idx] == heater::SwitchState::ON) {
2023-02-17 11:50:14 +01:00
EventManagerIF::triggerEvent(helper.heaters[idx].first->getObjectId(), MODE_INFO, MODE_ON, 0);
} else {
EventManagerIF::triggerEvent(helper.heaters[idx].first->getObjectId(), MODE_INFO, MODE_OFF,
0);
}
}
}
void HeaterHandler::getMode(Mode_t* mode, Submode_t* submode) {
if (!mode || !submode) {
return;
}
*mode = this->mode;
*submode = this->submode;
}
const HasHealthIF* HeaterHandler::getOptHealthIF() const { return nullptr; }
const HasModesIF& HeaterHandler::getModeIF() const { return *this; }
ReturnValue_t HeaterHandler::connectModeTreeParent(HasModeTreeChildrenIF& parent) {
return modetree::connectModeTreeParent(parent, *this, nullptr, modeHelper);
}
ModeTreeChildIF& HeaterHandler::getModeTreeChildIF() { return *this; }
object_id_t HeaterHandler::getObjectId() const { return SystemObject::getObjectId(); }
2023-07-06 23:06:50 +02:00
ReturnValue_t HeaterHandler::getAllSwitchStates(std::array<heater::SwitchState, 8>& statesBuf) {
2023-02-21 02:28:57 +01:00
{
2023-03-02 15:32:12 +01:00
MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
2023-02-21 02:28:57 +01:00
if (mg.getLockResult() != returnvalue::OK) {
return returnvalue::FAILED;
}
for (unsigned idx = 0; idx < helper.heaters.size(); idx++) {
statesBuf[idx] = heaterVec[idx].switchState;
}
}
return returnvalue::OK;
}
2021-02-11 08:19:48 +01:00
bool HeaterHandler::allSwitchesOff() {
2023-03-02 15:32:12 +01:00
MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
2022-05-02 22:55:39 +02:00
for (power::Switch_t switchNr = 0; switchNr < heater::NUMBER_OF_SWITCHES; switchNr++) {
2023-07-07 12:24:48 +02:00
if (heaterVec.at(switchNr).switchState == heater::SwitchState::ON) {
2023-07-06 12:04:36 +02:00
return false;
}
2022-01-17 15:58:27 +01:00
}
2023-07-06 12:04:36 +02:00
return true;
2021-02-11 08:19:48 +01:00
}
2022-01-17 15:58:27 +01:00
MessageQueueId_t HeaterHandler::getCommandQueue() const { return commandQueue->getId(); }
2022-08-24 17:27:47 +02:00
ReturnValue_t HeaterHandler::sendFuseOnCommand(uint8_t fuseNr) { return returnvalue::OK; }
ReturnValue_t HeaterHandler::getSwitchState(uint8_t switchNr) const {
ReturnValue_t mainSwitchState = mainLineSwitcher->getSwitchState(mainLineSwitch);
if (mainSwitchState == PowerSwitchIF::SWITCH_OFF) {
return PowerSwitchIF::SWITCH_OFF;
}
if (switchNr > 7) {
2022-08-24 17:27:47 +02:00
return returnvalue::FAILED;
}
2023-07-06 23:06:50 +02:00
if (getSwitchState(static_cast<heater::Switch>(switchNr)) == heater::SwitchState::ON) {
return PowerSwitchIF::SWITCH_ON;
}
return PowerSwitchIF::SWITCH_OFF;
}
2022-01-17 15:58:27 +01:00
ReturnValue_t HeaterHandler::getFuseState(uint8_t fuseNr) const { return 0; }
2022-05-02 17:37:00 +02:00
uint32_t HeaterHandler::getSwitchDelayMs(void) const { return 2000; }
2022-12-13 10:19:28 +01:00
2023-04-06 12:13:24 +02:00
HasHealthIF::HealthState HeaterHandler::getHealth(heater::Switch heater) {
2022-12-13 10:19:28 +01:00
auto* healthDev = heaterVec.at(heater).healthDevice;
if (healthDev != nullptr) {
2023-03-02 15:32:12 +01:00
MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
2022-12-13 10:19:28 +01:00
return healthDev->getHealth();
}
return HasHealthIF::HealthState::FAULTY;
}