done
This commit is contained in:
parent
c558a117b0
commit
027955597f
GPG Key ID:
A649FB78196E3849
@ -33,6 +33,7 @@ ThermalController::ThermalController(object_id_t objectId, HeaterHandler& heater
|
||||
susTemperatures(this),
|
||||
deviceTemperatures(this),
|
||||
heaterInfo(this),
|
||||
tcsCtrlInfo(this),
|
||||
imtqThermalSet(objects::IMTQ_HANDLER, ThermalStateCfg()),
|
||||
maxSet0PlocHspd(objects::RTD_0_IC3_PLOC_HEATSPREADER,
|
||||
EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
|
||||
@ -174,7 +175,7 @@ void ThermalController::performControlOperation() {
|
||||
}
|
||||
}
|
||||
|
||||
HeaterSwitchStates heaterSwitchStateArray{};
|
||||
tcsCtrl::HeaterSwitchStates heaterSwitchStateArray{};
|
||||
heaterHandler.getAllSwitchStates(heaterSwitchStateArray);
|
||||
{
|
||||
PoolReadGuard pg(&heaterInfo);
|
||||
@ -191,12 +192,11 @@ void ThermalController::performControlOperation() {
|
||||
if (transitionWhenHeatersOff) {
|
||||
bool allSwitchersOff = true;
|
||||
for (size_t idx = 0; idx < heaterSwitchStateArray.size(); idx++) {
|
||||
if (heaterSwitchStateArray[idx] != HeaterHandler::SwitchState::OFF) {
|
||||
if (heaterSwitchStateArray[idx] != heater::SwitchState::OFF) {
|
||||
allSwitchersOff = false;
|
||||
// if heater still ON after 3 cycles, switch OFF again
|
||||
if (transitionWhenHeatersOffCycles == 3) {
|
||||
heaterHandler.switchHeater(static_cast<heater::Switch>(idx),
|
||||
HeaterHandler::SwitchState::OFF);
|
||||
heaterHandler.switchHeater(static_cast<heater::Switch>(idx), heater::SwitchState::OFF);
|
||||
triggerEvent(tcsCtrl::HEATER_NOT_OFF_FOR_OFF_MODE);
|
||||
}
|
||||
}
|
||||
@ -215,6 +215,14 @@ void ThermalController::performControlOperation() {
|
||||
}
|
||||
heaterTransitionControl(heaterSwitchStateArray);
|
||||
heaterMaxDurationControl(heaterSwitchStateArray);
|
||||
PoolReadGuard pg(&tcsCtrlInfo);
|
||||
for (uint8_t i = 0; i < thermalStates.size(); i++) {
|
||||
tcsCtrlInfo.heatingOnVec[i] = thermalStates[i].heating;
|
||||
tcsCtrlInfo.sensorIdxUsedForTcsCtrl[i] = thermalStates[i].sensorIndex;
|
||||
tcsCtrlInfo.heaterSwitchIdx[i] = thermalStates[i].heaterSwitch;
|
||||
tcsCtrlInfo.heaterStartTimes[i] = thermalStates[i].heaterStartTime;
|
||||
tcsCtrlInfo.heaterEndTimes[i] = thermalStates[i].heaterEndTime;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -284,6 +292,11 @@ ReturnValue_t ThermalController::initializeLocalDataPool(localpool::DataPool& lo
|
||||
localDataPoolMap.emplace(tcsCtrl::TEMP_ADC_PAYLOAD_PCDU, new PoolEntry<float>({0.0}));
|
||||
localDataPoolMap.emplace(tcsCtrl::HEATER_SWITCH_LIST, &heaterSwitchStates);
|
||||
localDataPoolMap.emplace(tcsCtrl::HEATER_CURRENT, &heaterCurrent);
|
||||
localDataPoolMap.emplace(tcsCtrl::HEATER_ON_FOR_COMPONENT_VEC, &tcsCtrlHeaterOn);
|
||||
localDataPoolMap.emplace(tcsCtrl::SENSOR_USED_FOR_TCS_CTRL, &tcsCtrlSensorIdx);
|
||||
localDataPoolMap.emplace(tcsCtrl::HEATER_IDX_USED_FOR_TCS_CTRL, &tcsCtrlHeaterIdx);
|
||||
localDataPoolMap.emplace(tcsCtrl::HEATER_START_TIME, &tcsCtrlStartTimes);
|
||||
localDataPoolMap.emplace(tcsCtrl::HEATER_END_TIME, &tcsCtrlEndTimes);
|
||||
|
||||
bool enableHkSets = false;
|
||||
#if OBSW_ENABLE_PERIODIC_HK == 1
|
||||
@ -297,6 +310,8 @@ ReturnValue_t ThermalController::initializeLocalDataPool(localpool::DataPool& lo
|
||||
subdp::RegularHkPeriodicParams(deviceTemperatures.getSid(), enableHkSets, 120.0));
|
||||
poolManager.subscribeForDiagPeriodicPacket(
|
||||
subdp::DiagnosticsHkPeriodicParams(heaterInfo.getSid(), enableHkSets, 120.0));
|
||||
poolManager.subscribeForRegularPeriodicPacket(
|
||||
subdp::RegularHkPeriodicParams(tcsCtrlInfo.getSid(), enableHkSets, 120.0));
|
||||
|
||||
return returnvalue::OK;
|
||||
}
|
||||
@ -311,6 +326,8 @@ LocalPoolDataSetBase* ThermalController::getDataSetHandle(sid_t sid) {
|
||||
return &deviceTemperatures;
|
||||
case tcsCtrl::HEATER_SET:
|
||||
return &heaterInfo;
|
||||
case tcsCtrl::TCS_CTRL_INFO:
|
||||
return &tcsCtrlInfo;
|
||||
default:
|
||||
return nullptr;
|
||||
}
|
||||
@ -1012,7 +1029,7 @@ void ThermalController::ctrlAcsBoard() {
|
||||
heater::Switch redSwitchNr = heater::HEATER_3_OBC_BRD;
|
||||
|
||||
// A side
|
||||
thermalComponent = ACS_BOARD;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::ACS_BOARD;
|
||||
sensors[0].first = deviceTemperatures.gyro0SideA.isValid();
|
||||
sensors[0].second = deviceTemperatures.gyro0SideA.value;
|
||||
sensors[1].first = deviceTemperatures.gyro2SideB.isValid();
|
||||
@ -1056,7 +1073,7 @@ void ThermalController::ctrlAcsBoard() {
|
||||
if (chooseHeater(switchNr, redSwitchNr)) {
|
||||
if (heaterHandler.getSwitchState(switchNr)) {
|
||||
if (submode != SUBMODE_NO_HEATER_CTRL) {
|
||||
heaterSwitchHelper(switchNr, HeaterHandler::SwitchState::OFF, thermalComponent);
|
||||
heaterSwitchHelper(switchNr, heater::SwitchState::OFF, ctrlCtx.thermalComponent);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1066,7 +1083,7 @@ void ThermalController::ctrlAcsBoard() {
|
||||
}
|
||||
|
||||
void ThermalController::ctrlMgt() {
|
||||
thermalComponent = MGT;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::MGT;
|
||||
sensors[0].first = sensorTemperatures.mgt.isValid();
|
||||
sensors[0].second = sensorTemperatures.mgt.value;
|
||||
sensors[1].first = deviceTemperatures.mgt.isValid();
|
||||
@ -1076,11 +1093,11 @@ void ThermalController::ctrlMgt() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_2_ACS_BRD, heater::HEATER_1_PCDU_PDU, mgtLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
if (componentAboveUpperLimit and not mgtTooHotFlag) {
|
||||
if (ctrlCtx.componentAboveUpperLimit and not tooHotFlags.mgtTooHotFlag) {
|
||||
triggerEvent(tcsCtrl::MGT_OVERHEATING, tempFloatToU32());
|
||||
mgtTooHotFlag = true;
|
||||
} else if (not componentAboveUpperLimit) {
|
||||
mgtTooHotFlag = false;
|
||||
tooHotFlags.mgtTooHotFlag = true;
|
||||
} else if (not ctrlCtx.componentAboveUpperLimit) {
|
||||
tooHotFlags.mgtTooHotFlag = false;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1091,7 +1108,7 @@ void ThermalController::ctrlRw() {
|
||||
std::array<uint32_t, 4> sensorTemps{};
|
||||
|
||||
// RW1
|
||||
thermalComponent = RW;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::RW;
|
||||
sensors[0].first = sensorTemperatures.rw1.isValid();
|
||||
sensors[0].second = sensorTemperatures.rw1.value;
|
||||
sensors[1].first = deviceTemperatures.rw1.isValid();
|
||||
@ -1105,14 +1122,14 @@ void ThermalController::ctrlRw() {
|
||||
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_6_DRO, rwLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
sensorTemps[0] = tempFloatToU32();
|
||||
if (componentAboveUpperLimit) {
|
||||
if (ctrlCtx.componentAboveUpperLimit) {
|
||||
oneIsAboveLimit = true;
|
||||
eventToTrigger = overHeatEventToTrigger;
|
||||
eventToTrigger = ctrlCtx.overHeatEventToTrigger;
|
||||
}
|
||||
}
|
||||
|
||||
// RW2
|
||||
thermalComponent = RW;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::RW;
|
||||
sensors[0].first = deviceTemperatures.rw2.isValid();
|
||||
sensors[0].second = deviceTemperatures.rw2.value;
|
||||
sensors[1].first = deviceTemperatures.rw3.isValid();
|
||||
@ -1126,15 +1143,15 @@ void ThermalController::ctrlRw() {
|
||||
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_6_DRO, rwLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
sensorTemps[1] = tempFloatToU32();
|
||||
if (componentAboveUpperLimit) {
|
||||
if (ctrlCtx.componentAboveUpperLimit) {
|
||||
oneIsAboveLimit = true;
|
||||
if (eventToTrigger != ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH) {
|
||||
eventToTrigger = overHeatEventToTrigger;
|
||||
eventToTrigger = ctrlCtx.overHeatEventToTrigger;
|
||||
}
|
||||
}
|
||||
}
|
||||
// RW3
|
||||
thermalComponent = RW;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::RW;
|
||||
sensors[0].first = deviceTemperatures.rw3.isValid();
|
||||
sensors[0].second = deviceTemperatures.rw3.value;
|
||||
sensors[1].first = deviceTemperatures.rw4.isValid();
|
||||
@ -1148,16 +1165,16 @@ void ThermalController::ctrlRw() {
|
||||
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_6_DRO, rwLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
sensorTemps[2] = tempFloatToU32();
|
||||
if (componentAboveUpperLimit) {
|
||||
if (ctrlCtx.componentAboveUpperLimit) {
|
||||
oneIsAboveLimit = true;
|
||||
if (eventToTrigger != ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH) {
|
||||
eventToTrigger = overHeatEventToTrigger;
|
||||
eventToTrigger = ctrlCtx.overHeatEventToTrigger;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// RW4
|
||||
thermalComponent = RW;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::RW;
|
||||
sensors[0].first = deviceTemperatures.rw4.isValid();
|
||||
sensors[0].second = deviceTemperatures.rw4.value;
|
||||
sensors[1].first = deviceTemperatures.rw1.isValid();
|
||||
@ -1171,27 +1188,27 @@ void ThermalController::ctrlRw() {
|
||||
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_6_DRO, rwLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
sensorTemps[3] = tempFloatToU32();
|
||||
if (componentAboveUpperLimit) {
|
||||
if (ctrlCtx.componentAboveUpperLimit) {
|
||||
oneIsAboveLimit = true;
|
||||
if (eventToTrigger != ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH) {
|
||||
eventToTrigger = overHeatEventToTrigger;
|
||||
eventToTrigger = ctrlCtx.overHeatEventToTrigger;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (oneIsAboveLimit and not rwTooHotFlag) {
|
||||
if (oneIsAboveLimit and not tooHotFlags.rwTooHotFlag) {
|
||||
EventManagerIF::triggerEvent(objects::RW1, eventToTrigger, sensorTemps[0]);
|
||||
EventManagerIF::triggerEvent(objects::RW2, eventToTrigger, sensorTemps[1]);
|
||||
EventManagerIF::triggerEvent(objects::RW3, eventToTrigger, sensorTemps[2]);
|
||||
EventManagerIF::triggerEvent(objects::RW4, eventToTrigger, sensorTemps[3]);
|
||||
rwTooHotFlag = true;
|
||||
tooHotFlags.rwTooHotFlag = true;
|
||||
} else if (not oneIsAboveLimit) {
|
||||
rwTooHotFlag = false;
|
||||
tooHotFlags.rwTooHotFlag = false;
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalController::ctrlStr() {
|
||||
thermalComponent = STR;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::STR;
|
||||
sensors[0].first = sensorTemperatures.startracker.isValid();
|
||||
sensors[0].second = sensorTemperatures.startracker.value;
|
||||
sensors[1].first = deviceTemperatures.startracker.isValid();
|
||||
@ -1201,11 +1218,11 @@ void ThermalController::ctrlStr() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_5_STR, heater::HEATER_6_DRO, strLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
tooHotHandlerWhichClearsOneShotFlag(objects::STAR_TRACKER, strTooHotFlag);
|
||||
tooHotHandlerWhichClearsOneShotFlag(objects::STAR_TRACKER, tooHotFlags.strTooHotFlag);
|
||||
}
|
||||
|
||||
void ThermalController::ctrlIfBoard() {
|
||||
thermalComponent = IF_BOARD;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::IF_BOARD;
|
||||
sensors[0].first = sensorTemperatures.tmp1075IfBrd.isValid();
|
||||
sensors[0].second = sensorTemperatures.tmp1075IfBrd.value;
|
||||
sensors[1].first = sensorTemperatures.mgt.isValid();
|
||||
@ -1219,7 +1236,7 @@ void ThermalController::ctrlIfBoard() {
|
||||
}
|
||||
|
||||
void ThermalController::ctrlTcsBoard() {
|
||||
thermalComponent = TCS_BOARD;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::TCS_BOARD;
|
||||
sensors[0].first = sensorTemperatures.tcsBoard.isValid();
|
||||
sensors[0].second = sensorTemperatures.tcsBoard.value;
|
||||
sensors[1].first = sensorTemperatures.tmp1075Tcs0.isValid();
|
||||
@ -1233,7 +1250,7 @@ void ThermalController::ctrlTcsBoard() {
|
||||
}
|
||||
|
||||
void ThermalController::ctrlObc() {
|
||||
thermalComponent = OBC;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::OBC;
|
||||
sensors[0].first = deviceTemperatures.q7s.isValid();
|
||||
sensors[0].second = deviceTemperatures.q7s.value;
|
||||
sensors[1].first = sensorTemperatures.tmp1075Tcs1.isValid();
|
||||
@ -1243,16 +1260,16 @@ void ThermalController::ctrlObc() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_3_OBC_BRD, heater::HEATER_2_ACS_BRD, obcLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
if (componentAboveUpperLimit and not obcTooHotFlag) {
|
||||
if (ctrlCtx.componentAboveUpperLimit and not tooHotFlags.obcTooHotFlag) {
|
||||
triggerEvent(tcsCtrl::OBC_OVERHEATING, tempFloatToU32());
|
||||
obcTooHotFlag = true;
|
||||
} else if (not componentAboveUpperLimit) {
|
||||
obcTooHotFlag = false;
|
||||
tooHotFlags.obcTooHotFlag = true;
|
||||
} else if (not ctrlCtx.componentAboveUpperLimit) {
|
||||
tooHotFlags.obcTooHotFlag = false;
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalController::ctrlObcIfBoard() {
|
||||
thermalComponent = OBCIF_BOARD;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::OBCIF_BOARD;
|
||||
sensors[0].first = deviceTemperatures.q7s.isValid();
|
||||
sensors[0].second = deviceTemperatures.q7s.value;
|
||||
sensors[1].first = sensorTemperatures.tmp1075Tcs0.isValid();
|
||||
@ -1262,16 +1279,16 @@ void ThermalController::ctrlObcIfBoard() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_3_OBC_BRD, heater::HEATER_2_ACS_BRD, obcIfBoardLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
if (componentAboveUpperLimit and not obcTooHotFlag) {
|
||||
if (ctrlCtx.componentAboveUpperLimit and not tooHotFlags.obcTooHotFlag) {
|
||||
triggerEvent(tcsCtrl::OBC_OVERHEATING, tempFloatToU32());
|
||||
obcTooHotFlag = true;
|
||||
} else if (not componentAboveUpperLimit) {
|
||||
obcTooHotFlag = false;
|
||||
tooHotFlags.obcTooHotFlag = true;
|
||||
} else if (not ctrlCtx.componentAboveUpperLimit) {
|
||||
tooHotFlags.obcTooHotFlag = false;
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalController::ctrlSBandTransceiver() {
|
||||
thermalComponent = SBAND_TRANSCEIVER;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::SBAND_TRANSCEIVER;
|
||||
sensors[0].first = deviceTemperatures.syrlinksPowerAmplifier.isValid();
|
||||
sensors[0].second = deviceTemperatures.syrlinksPowerAmplifier.value;
|
||||
sensors[1].first = deviceTemperatures.syrlinksBasebandBoard.isValid();
|
||||
@ -1281,15 +1298,15 @@ void ThermalController::ctrlSBandTransceiver() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_7_S_BAND, heater::HEATER_4_CAMERA, sBandTransceiverLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
if (componentAboveUpperLimit and not syrlinksTooHotFlag) {
|
||||
if (ctrlCtx.componentAboveUpperLimit and not tooHotFlags.syrlinksTooHotFlag) {
|
||||
triggerEvent(tcsCtrl::SYRLINKS_OVERHEATING, tempFloatToU32());
|
||||
syrlinksTooHotFlag = true;
|
||||
} else if (not componentAboveUpperLimit) {
|
||||
syrlinksTooHotFlag = false;
|
||||
tooHotFlags.syrlinksTooHotFlag = true;
|
||||
} else if (not ctrlCtx.componentAboveUpperLimit) {
|
||||
tooHotFlags.syrlinksTooHotFlag = false;
|
||||
}
|
||||
}
|
||||
void ThermalController::ctrlPcduP60Board() {
|
||||
thermalComponent = PCDUP60_BOARD;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::PCDUP60_BOARD;
|
||||
sensors[0].first = deviceTemperatures.temp1P60dock.isValid();
|
||||
sensors[0].second = deviceTemperatures.temp1P60dock.value;
|
||||
sensors[1].first = deviceTemperatures.temp2P60dock.isValid();
|
||||
@ -1297,16 +1314,16 @@ void ThermalController::ctrlPcduP60Board() {
|
||||
numSensors = 2;
|
||||
HeaterContext htrCtx(heater::HEATER_1_PCDU_PDU, heater::HEATER_2_ACS_BRD, pcduP60BoardLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
if (componentAboveUpperLimit and not pcduSystemTooHotFlag) {
|
||||
if (ctrlCtx.componentAboveUpperLimit and not tooHotFlags.pcduSystemTooHotFlag) {
|
||||
triggerEvent(tcsCtrl::PCDU_SYSTEM_OVERHEATING, tempFloatToU32());
|
||||
pcduSystemTooHotFlag = true;
|
||||
} else if (not componentAboveUpperLimit) {
|
||||
pcduSystemTooHotFlag = false;
|
||||
tooHotFlags.pcduSystemTooHotFlag = true;
|
||||
} else if (not ctrlCtx.componentAboveUpperLimit) {
|
||||
tooHotFlags.pcduSystemTooHotFlag = false;
|
||||
} // TODO: !
|
||||
}
|
||||
|
||||
void ThermalController::ctrlPcduAcu() {
|
||||
thermalComponent = PCDUACU;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::PCDUACU;
|
||||
heater::Switch switchNr = heater::HEATER_1_PCDU_PDU;
|
||||
heater::Switch redSwitchNr = heater::HEATER_2_ACS_BRD;
|
||||
|
||||
@ -1314,15 +1331,15 @@ void ThermalController::ctrlPcduAcu() {
|
||||
bool sensorTempAvailable = true;
|
||||
// TODO: check
|
||||
if (deviceTemperatures.acu.value[0] != INVALID_TEMPERATURE) {
|
||||
sensorTemp = deviceTemperatures.acu.value[0];
|
||||
ctrlCtx.sensorTemp = deviceTemperatures.acu.value[0];
|
||||
} else if (deviceTemperatures.acu.value[1] != INVALID_TEMPERATURE) {
|
||||
sensorTemp = deviceTemperatures.acu.value[1];
|
||||
ctrlCtx.sensorTemp = deviceTemperatures.acu.value[1];
|
||||
} else if (deviceTemperatures.acu.value[2] != INVALID_TEMPERATURE) {
|
||||
sensorTemp = deviceTemperatures.acu.value[2];
|
||||
ctrlCtx.sensorTemp = deviceTemperatures.acu.value[2];
|
||||
} else if (sensorTemperatures.acu.isValid()) {
|
||||
sensorTemp = sensorTemperatures.acu.value;
|
||||
ctrlCtx.sensorTemp = sensorTemperatures.acu.value;
|
||||
} else {
|
||||
triggerEvent(tcsCtrl::NO_VALID_SENSOR_TEMPERATURE, thermalComponent);
|
||||
triggerEvent(tcsCtrl::NO_VALID_SENSOR_TEMPERATURE, ctrlCtx.thermalComponent);
|
||||
sensorTempAvailable = false;
|
||||
}
|
||||
if (sensorTempAvailable) {
|
||||
@ -1330,16 +1347,16 @@ void ThermalController::ctrlPcduAcu() {
|
||||
checkLimitsAndCtrlHeater(htrCtx);
|
||||
}
|
||||
}
|
||||
if (componentAboveUpperLimit and not pcduSystemTooHotFlag) {
|
||||
if (ctrlCtx.componentAboveUpperLimit and not tooHotFlags.pcduSystemTooHotFlag) {
|
||||
triggerEvent(tcsCtrl::PCDU_SYSTEM_OVERHEATING, tempFloatToU32());
|
||||
pcduSystemTooHotFlag = true;
|
||||
} else if (not componentAboveUpperLimit) {
|
||||
pcduSystemTooHotFlag = false;
|
||||
tooHotFlags.pcduSystemTooHotFlag = true;
|
||||
} else if (not ctrlCtx.componentAboveUpperLimit) {
|
||||
tooHotFlags.pcduSystemTooHotFlag = false;
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalController::ctrlPcduPdu() {
|
||||
thermalComponent = PCDUPDU;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::PCDUPDU;
|
||||
sensors[0].first = deviceTemperatures.pdu1.isValid();
|
||||
sensors[0].second = deviceTemperatures.pdu1.value;
|
||||
sensors[1].first = deviceTemperatures.pdu2.isValid();
|
||||
@ -1349,16 +1366,16 @@ void ThermalController::ctrlPcduPdu() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_1_PCDU_PDU, heater::HEATER_2_ACS_BRD, pcduPduLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
if (componentAboveUpperLimit and not pcduSystemTooHotFlag) {
|
||||
if (ctrlCtx.componentAboveUpperLimit and not tooHotFlags.pcduSystemTooHotFlag) {
|
||||
triggerEvent(tcsCtrl::PCDU_SYSTEM_OVERHEATING, tempFloatToU32());
|
||||
pcduSystemTooHotFlag = true;
|
||||
} else if (not componentAboveUpperLimit) {
|
||||
pcduSystemTooHotFlag = false;
|
||||
tooHotFlags.pcduSystemTooHotFlag = true;
|
||||
} else if (not ctrlCtx.componentAboveUpperLimit) {
|
||||
tooHotFlags.pcduSystemTooHotFlag = false;
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalController::ctrlPlPcduBoard() {
|
||||
thermalComponent = PLPCDU_BOARD;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::PLPCDU_BOARD;
|
||||
sensors[0].first = sensorTemperatures.tmp1075PlPcdu0.isValid();
|
||||
sensors[0].second = sensorTemperatures.tmp1075PlPcdu0.value;
|
||||
sensors[1].first = sensorTemperatures.tmp1075PlPcdu1.isValid();
|
||||
@ -1370,11 +1387,11 @@ void ThermalController::ctrlPlPcduBoard() {
|
||||
numSensors = 4;
|
||||
HeaterContext htrCtx(heater::HEATER_1_PCDU_PDU, heater::HEATER_2_ACS_BRD, plPcduBoardLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, tooHotFlags.eBandTooHotFlag);
|
||||
}
|
||||
|
||||
void ThermalController::ctrlPlocMissionBoard() {
|
||||
thermalComponent = PLOCMISSION_BOARD;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::PLOCMISSION_BOARD;
|
||||
sensors[0].first = sensorTemperatures.plocHeatspreader.isValid();
|
||||
sensors[0].second = sensorTemperatures.plocHeatspreader.value;
|
||||
sensors[1].first = sensorTemperatures.plocMissionboard.isValid();
|
||||
@ -1385,11 +1402,11 @@ void ThermalController::ctrlPlocMissionBoard() {
|
||||
HeaterContext htrCtx(heater::HEATER_0_PLOC_PROC_BRD, heater::HEATER_3_OBC_BRD,
|
||||
plocMissionBoardLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
tooHotHandler(objects::PLOC_SUPERVISOR_HANDLER, plocTooHotFlag);
|
||||
tooHotHandler(objects::PLOC_SUPERVISOR_HANDLER, tooHotFlags.plocTooHotFlag);
|
||||
}
|
||||
|
||||
void ThermalController::ctrlPlocProcessingBoard() {
|
||||
thermalComponent = PLOCPROCESSING_BOARD;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::PLOCPROCESSING_BOARD;
|
||||
sensors[0].first = sensorTemperatures.plocMissionboard.isValid();
|
||||
sensors[0].second = sensorTemperatures.plocMissionboard.value;
|
||||
sensors[1].first = sensorTemperatures.plocHeatspreader.isValid();
|
||||
@ -1400,11 +1417,11 @@ void ThermalController::ctrlPlocProcessingBoard() {
|
||||
HeaterContext htrCtx(heater::HEATER_0_PLOC_PROC_BRD, heater::HEATER_3_OBC_BRD,
|
||||
plocProcessingBoardLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
tooHotHandler(objects::PLOC_SUPERVISOR_HANDLER, plocTooHotFlag);
|
||||
tooHotHandler(objects::PLOC_SUPERVISOR_HANDLER, tooHotFlags.plocTooHotFlag);
|
||||
}
|
||||
|
||||
void ThermalController::ctrlDac() {
|
||||
thermalComponent = DAC;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::DAC;
|
||||
sensors[0].first = sensorTemperatures.dacHeatspreader.isValid();
|
||||
sensors[0].second = sensorTemperatures.dacHeatspreader.value;
|
||||
sensors[1].first = sensorTemperatures.plocMissionboard.isValid();
|
||||
@ -1414,11 +1431,11 @@ void ThermalController::ctrlDac() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_0_PLOC_PROC_BRD, heater::HEATER_3_OBC_BRD, dacLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, tooHotFlags.eBandTooHotFlag);
|
||||
}
|
||||
|
||||
void ThermalController::ctrlCameraBody() {
|
||||
thermalComponent = CAMERA;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::CAMERA;
|
||||
sensors[0].first = sensorTemperatures.payload4kCamera.isValid();
|
||||
sensors[0].second = sensorTemperatures.payload4kCamera.value;
|
||||
sensors[1].first = sensorTemperatures.dro.isValid();
|
||||
@ -1428,7 +1445,7 @@ void ThermalController::ctrlCameraBody() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_4_CAMERA, heater::HEATER_6_DRO, cameraLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
if (componentAboveUpperLimit and not camTooHotOneShotFlag) {
|
||||
if (ctrlCtx.componentAboveUpperLimit and not tooHotFlags.camTooHotOneShotFlag) {
|
||||
triggerEvent(tcsCtrl::CAMERA_OVERHEATING, tempFloatToU32());
|
||||
CommandMessage msg;
|
||||
HealthMessage::setHealthMessage(&msg, HealthMessage::HEALTH_SET, HealthState::FAULTY);
|
||||
@ -1437,14 +1454,14 @@ void ThermalController::ctrlCameraBody() {
|
||||
sif::error << "ThermalController::ctrlCameraBody(): Sending health message failed"
|
||||
<< std::endl;
|
||||
}
|
||||
camTooHotOneShotFlag = true;
|
||||
} else if (not componentAboveUpperLimit) {
|
||||
camTooHotOneShotFlag = false;
|
||||
tooHotFlags.camTooHotOneShotFlag = true;
|
||||
} else if (not ctrlCtx.componentAboveUpperLimit) {
|
||||
tooHotFlags.camTooHotOneShotFlag = false;
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalController::ctrlDro() {
|
||||
thermalComponent = DRO;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::DRO;
|
||||
sensors[0].first = sensorTemperatures.dro.isValid();
|
||||
sensors[0].second = sensorTemperatures.dro.value;
|
||||
sensors[1].first = sensorTemperatures.payload4kCamera.isValid();
|
||||
@ -1454,11 +1471,11 @@ void ThermalController::ctrlDro() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, droLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, tooHotFlags.eBandTooHotFlag);
|
||||
}
|
||||
|
||||
void ThermalController::ctrlX8() {
|
||||
thermalComponent = X8;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::X8;
|
||||
sensors[0].first = sensorTemperatures.x8.isValid();
|
||||
sensors[0].second = sensorTemperatures.x8.value;
|
||||
sensors[1].first = sensorTemperatures.hpa.isValid();
|
||||
@ -1468,11 +1485,11 @@ void ThermalController::ctrlX8() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, x8Limits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, tooHotFlags.eBandTooHotFlag);
|
||||
}
|
||||
|
||||
void ThermalController::ctrlTx() {
|
||||
thermalComponent = TX;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::TX;
|
||||
sensors[0].first = sensorTemperatures.eBandTx.isValid();
|
||||
sensors[0].second = sensorTemperatures.eBandTx.value;
|
||||
sensors[1].first = sensorTemperatures.x8.isValid();
|
||||
@ -1482,11 +1499,11 @@ void ThermalController::ctrlTx() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, txLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, tooHotFlags.eBandTooHotFlag);
|
||||
}
|
||||
|
||||
void ThermalController::ctrlMpa() {
|
||||
thermalComponent = MPA;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::MPA;
|
||||
sensors[0].first = sensorTemperatures.mpa.isValid();
|
||||
sensors[0].second = sensorTemperatures.mpa.value;
|
||||
sensors[1].first = sensorTemperatures.hpa.isValid();
|
||||
@ -1496,11 +1513,11 @@ void ThermalController::ctrlMpa() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, mpaLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, tooHotFlags.eBandTooHotFlag);
|
||||
}
|
||||
|
||||
void ThermalController::ctrlHpa() {
|
||||
thermalComponent = HPA;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::HPA;
|
||||
sensors[0].first = sensorTemperatures.hpa.isValid();
|
||||
sensors[0].second = sensorTemperatures.hpa.value;
|
||||
sensors[1].first = sensorTemperatures.x8.isValid();
|
||||
@ -1510,11 +1527,11 @@ void ThermalController::ctrlHpa() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, hpaLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
||||
tooHotHandler(objects::PLPCDU_HANDLER, tooHotFlags.eBandTooHotFlag);
|
||||
}
|
||||
|
||||
void ThermalController::ctrlScexBoard() {
|
||||
thermalComponent = SCEX_BOARD;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::SCEX_BOARD;
|
||||
sensors[0].first = sensorTemperatures.scex.isValid();
|
||||
sensors[0].second = sensorTemperatures.scex.value;
|
||||
sensors[1].first = sensorTemperatures.x8.isValid();
|
||||
@ -1524,10 +1541,11 @@ void ThermalController::ctrlScexBoard() {
|
||||
numSensors = 3;
|
||||
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_5_STR, scexBoardLimits);
|
||||
ctrlComponentTemperature(htrCtx);
|
||||
tooHotHandlerWhichClearsOneShotFlag(objects::SCEX, scexTooHotFlag);
|
||||
tooHotHandlerWhichClearsOneShotFlag(objects::SCEX, tooHotFlags.scexTooHotFlag);
|
||||
}
|
||||
|
||||
void ThermalController::performThermalModuleCtrl(const HeaterSwitchStates& heaterSwitchStates) {
|
||||
void ThermalController::performThermalModuleCtrl(
|
||||
const tcsCtrl::HeaterSwitchStates& heaterSwitchStates) {
|
||||
ctrlAcsBoard();
|
||||
ctrlMgt();
|
||||
ctrlRw();
|
||||
@ -1544,11 +1562,11 @@ void ThermalController::performThermalModuleCtrl(const HeaterSwitchStates& heate
|
||||
// Payload components
|
||||
std::array<bool, 2> plocInAllowedRange{};
|
||||
ctrlPlocMissionBoard();
|
||||
plocInAllowedRange.at(0) = not componentAboveUpperLimit;
|
||||
plocInAllowedRange.at(0) = not ctrlCtx.componentAboveUpperLimit;
|
||||
ctrlPlocProcessingBoard();
|
||||
plocInAllowedRange.at(1) = not componentAboveUpperLimit;
|
||||
plocInAllowedRange.at(1) = not ctrlCtx.componentAboveUpperLimit;
|
||||
|
||||
if (plocTooHotFlag) {
|
||||
if (tooHotFlags.plocTooHotFlag) {
|
||||
bool clearFlag = true;
|
||||
for (const auto& inRange : plocInAllowedRange) {
|
||||
if (not inRange) {
|
||||
@ -1556,7 +1574,7 @@ void ThermalController::performThermalModuleCtrl(const HeaterSwitchStates& heate
|
||||
}
|
||||
}
|
||||
if (clearFlag) {
|
||||
plocTooHotFlag = false;
|
||||
tooHotFlags.plocTooHotFlag = false;
|
||||
}
|
||||
}
|
||||
ctrlCameraBody();
|
||||
@ -1565,21 +1583,21 @@ void ThermalController::performThermalModuleCtrl(const HeaterSwitchStates& heate
|
||||
// E-Band
|
||||
std::array<bool, 7> eBandInAllowedRange{};
|
||||
ctrlPlPcduBoard();
|
||||
eBandInAllowedRange.at(0) = not componentAboveUpperLimit;
|
||||
eBandInAllowedRange.at(0) = not ctrlCtx.componentAboveUpperLimit;
|
||||
ctrlDac();
|
||||
eBandInAllowedRange.at(1) = not componentAboveUpperLimit;
|
||||
eBandInAllowedRange.at(1) = not ctrlCtx.componentAboveUpperLimit;
|
||||
ctrlDro();
|
||||
eBandInAllowedRange.at(2) = not componentAboveUpperLimit;
|
||||
eBandInAllowedRange.at(2) = not ctrlCtx.componentAboveUpperLimit;
|
||||
ctrlX8();
|
||||
eBandInAllowedRange.at(3) = not componentAboveUpperLimit;
|
||||
eBandInAllowedRange.at(3) = not ctrlCtx.componentAboveUpperLimit;
|
||||
ctrlHpa();
|
||||
eBandInAllowedRange.at(4) = not componentAboveUpperLimit;
|
||||
eBandInAllowedRange.at(4) = not ctrlCtx.componentAboveUpperLimit;
|
||||
ctrlTx();
|
||||
eBandInAllowedRange.at(5) = not componentAboveUpperLimit;
|
||||
eBandInAllowedRange.at(5) = not ctrlCtx.componentAboveUpperLimit;
|
||||
ctrlMpa();
|
||||
eBandInAllowedRange.at(6) = not componentAboveUpperLimit;
|
||||
eBandInAllowedRange.at(6) = not ctrlCtx.componentAboveUpperLimit;
|
||||
|
||||
if (eBandTooHotFlag) {
|
||||
if (tooHotFlags.eBandTooHotFlag) {
|
||||
bool clearFlag = true;
|
||||
for (const auto& inRange : eBandInAllowedRange) {
|
||||
if (not inRange) {
|
||||
@ -1587,7 +1605,7 @@ void ThermalController::performThermalModuleCtrl(const HeaterSwitchStates& heate
|
||||
}
|
||||
}
|
||||
if (clearFlag) {
|
||||
eBandTooHotFlag = false;
|
||||
tooHotFlags.eBandTooHotFlag = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1603,8 +1621,8 @@ void ThermalController::ctrlComponentTemperature(HeaterContext& htrCtx) {
|
||||
// are blind..
|
||||
if (chooseHeater(htrCtx.switchNr, htrCtx.redSwitchNr)) {
|
||||
if (heaterCtrlAllowed() and
|
||||
(heaterHandler.getSwitchState(htrCtx.switchNr) == HeaterHandler::SwitchState::ON)) {
|
||||
heaterSwitchHelper(htrCtx.switchNr, HeaterHandler::SwitchState::OFF, thermalComponent);
|
||||
(heaterHandler.getSwitchState(htrCtx.switchNr) == heater::SwitchState::ON)) {
|
||||
heaterSwitchHelper(htrCtx.switchNr, heater::SwitchState::OFF, ctrlCtx.thermalComponent);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1615,21 +1633,21 @@ bool ThermalController::selectAndReadSensorTemp(HeaterContext& htrCtx) {
|
||||
if (sensors[i].first and sensors[i].second != INVALID_TEMPERATURE and
|
||||
sensors[i].second > SANITY_LIMIT_LOWER_TEMP and
|
||||
sensors[i].second < SANITY_LIMIT_UPPER_TEMP) {
|
||||
sensorTemp = sensors[i].second;
|
||||
currentSensorIndex = i;
|
||||
thermalStates[thermalComponent].errorCounter = 0;
|
||||
ctrlCtx.sensorTemp = sensors[i].second;
|
||||
ctrlCtx.currentSensorIndex = i;
|
||||
thermalStates[ctrlCtx.thermalComponent].errorCounter = 0;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
thermalStates[thermalComponent].errorCounter++;
|
||||
if (thermalComponent != RW and thermalComponent != ACS_BOARD) {
|
||||
if (thermalStates[thermalComponent].errorCounter <= 3) {
|
||||
triggerEvent(tcsCtrl::NO_VALID_SENSOR_TEMPERATURE, thermalComponent);
|
||||
thermalStates[ctrlCtx.thermalComponent].errorCounter++;
|
||||
if (ctrlCtx.thermalComponent != tcsCtrl::RW and ctrlCtx.thermalComponent != tcsCtrl::ACS_BOARD) {
|
||||
if (thermalStates[ctrlCtx.thermalComponent].errorCounter <= 3) {
|
||||
triggerEvent(tcsCtrl::NO_VALID_SENSOR_TEMPERATURE, ctrlCtx.thermalComponent);
|
||||
}
|
||||
} else {
|
||||
if (thermalStates[thermalComponent].errorCounter <= 8) {
|
||||
triggerEvent(tcsCtrl::NO_VALID_SENSOR_TEMPERATURE, thermalComponent);
|
||||
if (thermalStates[ctrlCtx.thermalComponent].errorCounter <= 8) {
|
||||
triggerEvent(tcsCtrl::NO_VALID_SENSOR_TEMPERATURE, ctrlCtx.thermalComponent);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1643,7 +1661,7 @@ bool ThermalController::chooseHeater(heater::Switch& switchNr, heater::Switch re
|
||||
if (mainHealth != HasHealthIF::HEALTHY) {
|
||||
if (redHealth == HasHealthIF::HEALTHY) {
|
||||
switchNr = redSwitchNr;
|
||||
redSwitchNrInUse = true;
|
||||
ctrlCtx.redSwitchNrInUse = true;
|
||||
} else {
|
||||
heaterAvailable = false;
|
||||
// Special case: Ground might command/do something with the heaters, so prevent spam.
|
||||
@ -1652,7 +1670,7 @@ bool ThermalController::chooseHeater(heater::Switch& switchNr, heater::Switch re
|
||||
}
|
||||
}
|
||||
} else {
|
||||
redSwitchNrInUse = false;
|
||||
ctrlCtx.redSwitchNrInUse = false;
|
||||
}
|
||||
return heaterAvailable;
|
||||
}
|
||||
@ -1661,23 +1679,23 @@ void ThermalController::heaterCtrlTempTooHighHandler(HeaterContext& htrCtx, cons
|
||||
if (not heaterCtrlAllowed()) {
|
||||
return;
|
||||
}
|
||||
if (htrCtx.switchState == HeaterHandler::SwitchState::ON) {
|
||||
sif::info << "TCS: Component " << static_cast<int>(thermalComponent) << " too warm, above "
|
||||
<< whatLimit << ", switching off heater" << std::endl;
|
||||
heaterSwitchHelper(htrCtx.switchNr, HeaterHandler::SwitchState::OFF, thermalComponent);
|
||||
if (htrCtx.switchState == heater::SwitchState::ON) {
|
||||
sif::info << "TCS: Component " << static_cast<int>(ctrlCtx.thermalComponent)
|
||||
<< " too warm, above " << whatLimit << ", switching off heater" << std::endl;
|
||||
heaterSwitchHelper(htrCtx.switchNr, heater::SwitchState::OFF, ctrlCtx.thermalComponent);
|
||||
heaterStates[htrCtx.switchNr].switchTransition = true;
|
||||
heaterStates[htrCtx.switchNr].target = HeaterHandler::SwitchState::OFF;
|
||||
heaterStates[htrCtx.switchNr].target = heater::SwitchState::OFF;
|
||||
}
|
||||
if (heaterHandler.getSwitchState(htrCtx.redSwitchNr) == HeaterHandler::SwitchState::ON) {
|
||||
heaterSwitchHelper(htrCtx.redSwitchNr, HeaterHandler::SwitchState::OFF, thermalComponent);
|
||||
if (heaterHandler.getSwitchState(htrCtx.redSwitchNr) == heater::SwitchState::ON) {
|
||||
heaterSwitchHelper(htrCtx.redSwitchNr, heater::SwitchState::OFF, ctrlCtx.thermalComponent);
|
||||
heaterStates[htrCtx.redSwitchNr].switchTransition = true;
|
||||
heaterStates[htrCtx.redSwitchNr].target = HeaterHandler::SwitchState::OFF;
|
||||
heaterStates[htrCtx.redSwitchNr].target = heater::SwitchState::OFF;
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalController::checkLimitsAndCtrlHeater(HeaterContext& htrCtx) {
|
||||
componentAboveCutOffLimit = false;
|
||||
componentAboveUpperLimit = false;
|
||||
ctrlCtx.componentAboveCutOffLimit = false;
|
||||
ctrlCtx.componentAboveUpperLimit = false;
|
||||
// Stay passive during switch transitions, wait for heater switching to complete. Otherwise,
|
||||
// still check whether components are out of range, which might be important information for the
|
||||
// top level control loop.
|
||||
@ -1689,35 +1707,38 @@ void ThermalController::checkLimitsAndCtrlHeater(HeaterContext& htrCtx) {
|
||||
|
||||
htrCtx.switchState = heaterHandler.getSwitchState(htrCtx.switchNr);
|
||||
// Heater off
|
||||
if (htrCtx.switchState == HeaterHandler::SwitchState::OFF) {
|
||||
if (sensorTemp < htrCtx.tempLimit.opLowerLimit and heaterCtrlAllowed()) {
|
||||
sif::info << "TCS: Heater " << static_cast<int>(thermalComponent) << " ON" << std::endl;
|
||||
heaterSwitchHelper(htrCtx.switchNr, HeaterHandler::SwitchState::ON, thermalComponent);
|
||||
if (htrCtx.switchState == heater::SwitchState::OFF) {
|
||||
if (ctrlCtx.sensorTemp < htrCtx.tempLimit.opLowerLimit and heaterCtrlAllowed()) {
|
||||
sif::info << "TCS: Heater " << static_cast<int>(ctrlCtx.thermalComponent) << " ON"
|
||||
<< std::endl;
|
||||
heaterSwitchHelper(htrCtx.switchNr, heater::SwitchState::ON, ctrlCtx.thermalComponent);
|
||||
} else {
|
||||
// Even if heater control is now allowed, we can update the state.
|
||||
thermalStates[thermalComponent].heating = false;
|
||||
thermalStates[ctrlCtx.thermalComponent].heating = false;
|
||||
}
|
||||
heaterCtrlCheckUpperLimits(htrCtx);
|
||||
return;
|
||||
}
|
||||
|
||||
// Heater on
|
||||
if (htrCtx.switchState == HeaterHandler::SwitchState::ON) {
|
||||
if (thermalStates[thermalComponent].heating) {
|
||||
if (htrCtx.switchState == heater::SwitchState::ON) {
|
||||
if (thermalStates[ctrlCtx.thermalComponent].heating) {
|
||||
// We are already in a heating cycle, so need to check whether heating task is complete.
|
||||
if (sensorTemp >= htrCtx.tempLimit.opLowerLimit + TEMP_OFFSET and heaterCtrlAllowed()) {
|
||||
sif::info << "TCS: Heater " << static_cast<int>(thermalComponent) << " OFF" << std::endl;
|
||||
heaterSwitchHelper(htrCtx.switchNr, HeaterHandler::SwitchState::OFF, thermalComponent);
|
||||
if (ctrlCtx.sensorTemp >= htrCtx.tempLimit.opLowerLimit + TEMP_OFFSET and
|
||||
heaterCtrlAllowed()) {
|
||||
sif::info << "TCS: Heater " << static_cast<int>(ctrlCtx.thermalComponent) << " OFF"
|
||||
<< std::endl;
|
||||
heaterSwitchHelper(htrCtx.switchNr, heater::SwitchState::OFF, ctrlCtx.thermalComponent);
|
||||
heaterStates[htrCtx.switchNr].switchTransition = true;
|
||||
heaterStates[htrCtx.switchNr].target = HeaterHandler::SwitchState::OFF;
|
||||
heaterStates[htrCtx.switchNr].target = heater::SwitchState::OFF;
|
||||
}
|
||||
return;
|
||||
}
|
||||
// This can happen if heater is used as alternative heater (no regular heating cycle), so we
|
||||
// should still check the upper limits.
|
||||
bool tooHighHandlerAlreadyCalled = heaterCtrlCheckUpperLimits(htrCtx);
|
||||
if (sensorTemp >= htrCtx.tempLimit.cutOffLimit) {
|
||||
componentAboveCutOffLimit = true;
|
||||
if (ctrlCtx.sensorTemp >= htrCtx.tempLimit.cutOffLimit) {
|
||||
ctrlCtx.componentAboveCutOffLimit = true;
|
||||
if (not tooHighHandlerAlreadyCalled) {
|
||||
heaterCtrlTempTooHighHandler(htrCtx, "CutOff-Limit");
|
||||
}
|
||||
@ -1726,19 +1747,19 @@ void ThermalController::checkLimitsAndCtrlHeater(HeaterContext& htrCtx) {
|
||||
}
|
||||
|
||||
bool ThermalController::heaterCtrlCheckUpperLimits(HeaterContext& htrCtx) {
|
||||
if (sensorTemp >= htrCtx.tempLimit.nopUpperLimit) {
|
||||
componentAboveUpperLimit = true;
|
||||
if (ctrlCtx.sensorTemp >= htrCtx.tempLimit.nopUpperLimit) {
|
||||
ctrlCtx.componentAboveUpperLimit = true;
|
||||
if (htrCtx.doHeaterHandling) {
|
||||
heaterCtrlTempTooHighHandler(htrCtx, "NOP-Limit");
|
||||
}
|
||||
overHeatEventToTrigger = ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH;
|
||||
ctrlCtx.overHeatEventToTrigger = ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH;
|
||||
return true;
|
||||
} else if (sensorTemp >= htrCtx.tempLimit.opUpperLimit) {
|
||||
componentAboveUpperLimit = true;
|
||||
} else if (ctrlCtx.sensorTemp >= htrCtx.tempLimit.opUpperLimit) {
|
||||
ctrlCtx.componentAboveUpperLimit = true;
|
||||
if (htrCtx.doHeaterHandling) {
|
||||
heaterCtrlTempTooHighHandler(htrCtx, "OP-Limit");
|
||||
}
|
||||
overHeatEventToTrigger = ThermalComponentIF::COMPONENT_TEMP_HIGH;
|
||||
ctrlCtx.overHeatEventToTrigger = ThermalComponentIF::COMPONENT_TEMP_HIGH;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
@ -1749,15 +1770,16 @@ void ThermalController::resetSensorsArray() {
|
||||
validValuePair.first = false;
|
||||
validValuePair.second = INVALID_TEMPERATURE;
|
||||
}
|
||||
thermalComponent = NONE;
|
||||
ctrlCtx.thermalComponent = tcsCtrl::NONE;
|
||||
}
|
||||
|
||||
void ThermalController::heaterTransitionControl(const HeaterSwitchStates& currentHeaterStates) {
|
||||
void ThermalController::heaterTransitionControl(
|
||||
const tcsCtrl::HeaterSwitchStates& currentHeaterStates) {
|
||||
for (unsigned i = 0; i < heater::Switch::NUMBER_OF_SWITCHES; i++) {
|
||||
if (heaterStates[i].switchTransition) {
|
||||
if (currentHeaterStates[i] == heaterStates[i].target) {
|
||||
// Required for max heater period control
|
||||
if (currentHeaterStates[i] == HeaterHandler::SwitchState::ON) {
|
||||
if (currentHeaterStates[i] == heater::SwitchState::ON) {
|
||||
heaterStates[i].heaterOnPeriod.setTimeout(MAX_HEATER_ON_DURATIONS[i]);
|
||||
heaterStates[i].heaterOnPeriod.resetTimer();
|
||||
} else {
|
||||
@ -1777,13 +1799,14 @@ void ThermalController::heaterTransitionControl(const HeaterSwitchStates& curren
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalController::heaterMaxDurationControl(const HeaterSwitchStates& currentHeaterStates) {
|
||||
void ThermalController::heaterMaxDurationControl(
|
||||
const tcsCtrl::HeaterSwitchStates& currentHeaterStates) {
|
||||
for (unsigned i = 0; i < heater::Switch::NUMBER_OF_SWITCHES; i++) {
|
||||
if (currentHeaterStates[i] == HeaterHandler::SwitchState::ON and
|
||||
if (currentHeaterStates[i] == heater::SwitchState::ON and
|
||||
heaterStates[i].heaterOnPeriod.hasTimedOut()) {
|
||||
heaterStates[i].switchTransition = false;
|
||||
heaterStates[i].heaterSwitchControlCycles = 0;
|
||||
heaterHandler.switchHeater(static_cast<heater::Switch>(i), HeaterHandler::SwitchState::OFF);
|
||||
heaterHandler.switchHeater(static_cast<heater::Switch>(i), heater::SwitchState::OFF);
|
||||
// The heater might still be one for some thermal components, so cross-check
|
||||
// those components
|
||||
crossCheckHeaterStateOfComponentsWhenHeaterGoesOff(static_cast<heater::Switch>(i));
|
||||
@ -1792,7 +1815,7 @@ void ThermalController::heaterMaxDurationControl(const HeaterSwitchStates& curre
|
||||
}
|
||||
|
||||
uint32_t ThermalController::tempFloatToU32() const {
|
||||
auto sensorTempAsFloat = static_cast<float>(sensorTemp);
|
||||
auto sensorTempAsFloat = static_cast<float>(ctrlCtx.sensorTemp);
|
||||
uint32_t tempRaw = 0;
|
||||
size_t dummyLen = 0;
|
||||
SerializeAdapter::serialize(&sensorTempAsFloat, reinterpret_cast<uint8_t*>(&tempRaw), &dummyLen,
|
||||
@ -1811,9 +1834,9 @@ void ThermalController::setMode(Mode_t mode, Submode_t submode) {
|
||||
}
|
||||
|
||||
bool ThermalController::tooHotHandler(object_id_t object, bool& oneShotFlag) {
|
||||
if (componentAboveUpperLimit and not oneShotFlag) {
|
||||
if (ctrlCtx.componentAboveUpperLimit and not oneShotFlag) {
|
||||
// Too hot -> returns true
|
||||
EventManagerIF::triggerEvent(object, overHeatEventToTrigger, tempFloatToU32());
|
||||
EventManagerIF::triggerEvent(object, ctrlCtx.overHeatEventToTrigger, tempFloatToU32());
|
||||
oneShotFlag = true;
|
||||
return true;
|
||||
}
|
||||
@ -1833,16 +1856,15 @@ void ThermalController::resetThermalStates() {
|
||||
}
|
||||
}
|
||||
|
||||
void ThermalController::heaterSwitchHelper(heater::Switch switchNr,
|
||||
HeaterHandler::SwitchState targetState,
|
||||
void ThermalController::heaterSwitchHelper(heater::Switch switchNr, heater::SwitchState targetState,
|
||||
unsigned componentIdx) {
|
||||
timeval currentTime;
|
||||
Clock::getClockMonotonic(¤tTime);
|
||||
if (targetState == HeaterHandler::SwitchState::ON) {
|
||||
if (targetState == heater::SwitchState::ON) {
|
||||
heaterHandler.switchHeater(switchNr, targetState);
|
||||
heaterStates[switchNr].target = HeaterHandler::SwitchState::ON;
|
||||
heaterStates[switchNr].target = heater::SwitchState::ON;
|
||||
heaterStates[switchNr].switchTransition = true;
|
||||
thermalStates[componentIdx].sensorIndex = currentSensorIndex;
|
||||
thermalStates[componentIdx].sensorIndex = ctrlCtx.currentSensorIndex;
|
||||
thermalStates[componentIdx].heaterSwitch = switchNr;
|
||||
thermalStates[componentIdx].heating = true;
|
||||
thermalStates[componentIdx].heaterStartTime = currentTime.tv_sec;
|
||||
@ -1858,7 +1880,7 @@ void ThermalController::heaterSwitchHelperAllOff() {
|
||||
Clock::getClockMonotonic(¤tTime);
|
||||
size_t idx = 0;
|
||||
for (; idx < heater::Switch::NUMBER_OF_SWITCHES; idx++) {
|
||||
heaterHandler.switchHeater(static_cast<heater::Switch>(idx), HeaterHandler::SwitchState::OFF);
|
||||
heaterHandler.switchHeater(static_cast<heater::Switch>(idx), heater::SwitchState::OFF);
|
||||
}
|
||||
for (idx = 0; idx < thermalStates.size(); idx++) {
|
||||
thermalStates[idx].heating = false;
|
||||
@ -1886,7 +1908,7 @@ void ThermalController::crossCheckHeaterStateOfComponentsWhenHeaterGoesOff(
|
||||
|
||||
void ThermalController::tooHotHandlerWhichClearsOneShotFlag(object_id_t object, bool& oneShotFlag) {
|
||||
// Clear the one shot flag is the component is in acceptable temperature range.
|
||||
if (not tooHotHandler(object, oneShotFlag) and not componentAboveUpperLimit) {
|
||||
if (not tooHotHandler(object, oneShotFlag) and not ctrlCtx.componentAboveUpperLimit) {
|
||||
oneShotFlag = false;
|
||||
}
|
||||
}
|
||||
|
||||
@ -25,78 +25,6 @@
|
||||
#include <atomic>
|
||||
#include <list>
|
||||
|
||||
/**
|
||||
* NOP Limit: Hard limit for device, usually from datasheet. Device damage is possible lif NOP limit
|
||||
* is exceeded.
|
||||
* OP Limit: Soft limit. Device should be switched off or TCS controller should take action if the
|
||||
* limit is exceeded to avoid reaching NOP limit
|
||||
*/
|
||||
struct TempLimits {
|
||||
TempLimits(float nopLowerLimit, float opLowerLimit, float cutOffLimit, float opUpperLimit,
|
||||
float nopUpperLimit)
|
||||
: opLowerLimit(opLowerLimit),
|
||||
opUpperLimit(opUpperLimit),
|
||||
cutOffLimit(cutOffLimit),
|
||||
nopLowerLimit(nopLowerLimit),
|
||||
nopUpperLimit(nopUpperLimit) {}
|
||||
float opLowerLimit;
|
||||
float opUpperLimit;
|
||||
float cutOffLimit;
|
||||
float nopLowerLimit;
|
||||
float nopUpperLimit;
|
||||
};
|
||||
|
||||
struct ThermalState {
|
||||
uint8_t errorCounter;
|
||||
// Which sensor is used for this component?
|
||||
uint8_t sensorIndex = 0;
|
||||
// Is heating on for that thermal module?
|
||||
bool heating = false;
|
||||
// Which switch is being used for heating the component
|
||||
heater::Switch heaterSwitch = heater::Switch::NUMBER_OF_SWITCHES;
|
||||
// Heater start time and end times as UNIX seconds. Please note that these times will be updated
|
||||
// when a switch command is sent, with no guarantess that the heater actually went on.
|
||||
uint32_t heaterStartTime = 0;
|
||||
uint32_t heaterEndTime = 0;
|
||||
};
|
||||
|
||||
struct HeaterState {
|
||||
bool switchTransition;
|
||||
HeaterHandler::SwitchState target;
|
||||
uint8_t heaterSwitchControlCycles;
|
||||
Countdown heaterOnPeriod;
|
||||
};
|
||||
|
||||
using HeaterSwitchStates = std::array<HeaterHandler::SwitchState, heater::NUMBER_OF_SWITCHES>;
|
||||
|
||||
enum ThermalComponents : uint8_t {
|
||||
NONE = 0,
|
||||
ACS_BOARD = 1,
|
||||
MGT = 2,
|
||||
RW = 3,
|
||||
STR = 4,
|
||||
IF_BOARD = 5,
|
||||
TCS_BOARD = 6,
|
||||
OBC = 7,
|
||||
OBCIF_BOARD = 8,
|
||||
SBAND_TRANSCEIVER = 9,
|
||||
PCDUP60_BOARD = 10,
|
||||
PCDUACU = 11,
|
||||
PCDUPDU = 12,
|
||||
PLPCDU_BOARD = 13,
|
||||
PLOCMISSION_BOARD = 14,
|
||||
PLOCPROCESSING_BOARD = 15,
|
||||
DAC = 16,
|
||||
CAMERA = 17,
|
||||
DRO = 18,
|
||||
X8 = 19,
|
||||
HPA = 20,
|
||||
TX = 21,
|
||||
MPA = 22,
|
||||
SCEX_BOARD = 23,
|
||||
NUM_ENTRIES
|
||||
};
|
||||
|
||||
class ThermalController : public ExtendedControllerBase {
|
||||
public:
|
||||
static constexpr uint8_t SUBMODE_NO_HEATER_CTRL = 1;
|
||||
@ -135,16 +63,16 @@ class ThermalController : public ExtendedControllerBase {
|
||||
struct HeaterContext {
|
||||
public:
|
||||
HeaterContext(heater::Switch switchNr, heater::Switch redundantSwitchNr,
|
||||
const TempLimits& tempLimit)
|
||||
const tcsCtrl::TempLimits& tempLimit)
|
||||
: switchNr(switchNr), redSwitchNr(redundantSwitchNr), tempLimit(tempLimit) {}
|
||||
bool doHeaterHandling = true;
|
||||
heater::Switch switchNr;
|
||||
HeaterHandler::SwitchState switchState = HeaterHandler::SwitchState::OFF;
|
||||
heater::SwitchState switchState = heater::SwitchState::OFF;
|
||||
heater::Switch redSwitchNr;
|
||||
const TempLimits& tempLimit;
|
||||
const tcsCtrl::TempLimits& tempLimit;
|
||||
};
|
||||
|
||||
void performThermalModuleCtrl(const HeaterSwitchStates& heaterSwitchStates);
|
||||
void performThermalModuleCtrl(const tcsCtrl::HeaterSwitchStates& heaterSwitchStates);
|
||||
ReturnValue_t handleCommandMessage(CommandMessage* message) override;
|
||||
void performControlOperation() override;
|
||||
ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
|
||||
@ -171,8 +99,7 @@ class ThermalController : public ExtendedControllerBase {
|
||||
tcsCtrl::SusTemperatures susTemperatures;
|
||||
tcsCtrl::DeviceTemperatures deviceTemperatures;
|
||||
tcsCtrl::HeaterInfo heaterInfo;
|
||||
lp_vec_t<int16_t, 9> currentVecPdu2 =
|
||||
lp_vec_t<int16_t, 9>(gp_id_t(objects::PDU2_HANDLER, PDU::pool::PDU_CURRENTS));
|
||||
tcsCtrl::TcsCtrlInfo tcsCtrlInfo;
|
||||
|
||||
DeviceHandlerThermalSet imtqThermalSet;
|
||||
|
||||
@ -252,58 +179,66 @@ class ThermalController : public ExtendedControllerBase {
|
||||
lp_var_t<float> tempMgm2 =
|
||||
lp_var_t<float>(objects::MGM_2_LIS3_HANDLER, mgmLis3::TEMPERATURE_CELCIUS);
|
||||
lp_var_t<float> tempAdcPayloadPcdu = lp_var_t<float>(objects::PLPCDU_HANDLER, plpcdu::TEMP);
|
||||
lp_vec_t<int16_t, 9> currentVecPdu2 =
|
||||
lp_vec_t<int16_t, 9>(gp_id_t(objects::PDU2_HANDLER, PDU::pool::PDU_CURRENTS));
|
||||
|
||||
// TempLimits
|
||||
TempLimits acsBoardLimits = TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
|
||||
TempLimits mgtLimits = TempLimits(-40.0, -40.0, 65.0, 70.0, 70.0);
|
||||
TempLimits rwLimits = TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
|
||||
TempLimits strLimits = TempLimits(-30.0, -20.0, 65.0, 70.0, 80.0);
|
||||
TempLimits ifBoardLimits = TempLimits(-65.0, -40.0, 80.0, 85.0, 150.0);
|
||||
TempLimits tcsBoardLimits = TempLimits(-60.0, -40.0, 80.0, 85.0, 130.0);
|
||||
TempLimits obcLimits = TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
|
||||
TempLimits obcIfBoardLimits = TempLimits(-65.0, -40.0, 80.0, 85.0, 125.0);
|
||||
TempLimits sBandTransceiverLimits = TempLimits(-40.0, -25.0, 35.0, 40.0, 65.0);
|
||||
TempLimits pcduP60BoardLimits = TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
|
||||
TempLimits pcduAcuLimits = TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
|
||||
TempLimits pcduPduLimits = TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
|
||||
TempLimits plPcduBoardLimits = TempLimits(-55.0, -40.0, 80.0, 85.0, 125.0);
|
||||
TempLimits plocMissionBoardLimits = TempLimits(-30.0, -10.0, 40.0, 45.0, 60);
|
||||
TempLimits plocProcessingBoardLimits = TempLimits(-30.0, -10.0, 40.0, 45.0, 60.0);
|
||||
TempLimits dacLimits = TempLimits(-65.0, -40.0, 113.0, 118.0, 150.0);
|
||||
TempLimits cameraLimits = TempLimits(-40.0, -30.0, 60.0, 65.0, 85.0);
|
||||
TempLimits droLimits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
|
||||
TempLimits x8Limits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
|
||||
TempLimits hpaLimits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
|
||||
TempLimits txLimits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
|
||||
TempLimits mpaLimits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
|
||||
TempLimits scexBoardLimits = TempLimits(-60.0, -40.0, 80.0, 85.0, 150.0);
|
||||
tcsCtrl::TempLimits acsBoardLimits = tcsCtrl::TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
|
||||
tcsCtrl::TempLimits mgtLimits = tcsCtrl::TempLimits(-40.0, -40.0, 65.0, 70.0, 70.0);
|
||||
tcsCtrl::TempLimits rwLimits = tcsCtrl::TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
|
||||
tcsCtrl::TempLimits strLimits = tcsCtrl::TempLimits(-30.0, -20.0, 65.0, 70.0, 80.0);
|
||||
tcsCtrl::TempLimits ifBoardLimits = tcsCtrl::TempLimits(-65.0, -40.0, 80.0, 85.0, 150.0);
|
||||
tcsCtrl::TempLimits tcsBoardLimits = tcsCtrl::TempLimits(-60.0, -40.0, 80.0, 85.0, 130.0);
|
||||
tcsCtrl::TempLimits obcLimits = tcsCtrl::TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
|
||||
tcsCtrl::TempLimits obcIfBoardLimits = tcsCtrl::TempLimits(-65.0, -40.0, 80.0, 85.0, 125.0);
|
||||
tcsCtrl::TempLimits sBandTransceiverLimits = tcsCtrl::TempLimits(-40.0, -25.0, 35.0, 40.0, 65.0);
|
||||
tcsCtrl::TempLimits pcduP60BoardLimits = tcsCtrl::TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
|
||||
tcsCtrl::TempLimits pcduAcuLimits = tcsCtrl::TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
|
||||
tcsCtrl::TempLimits pcduPduLimits = tcsCtrl::TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
|
||||
tcsCtrl::TempLimits plPcduBoardLimits = tcsCtrl::TempLimits(-55.0, -40.0, 80.0, 85.0, 125.0);
|
||||
tcsCtrl::TempLimits plocMissionBoardLimits = tcsCtrl::TempLimits(-30.0, -10.0, 40.0, 45.0, 60);
|
||||
tcsCtrl::TempLimits plocProcessingBoardLimits =
|
||||
tcsCtrl::TempLimits(-30.0, -10.0, 40.0, 45.0, 60.0);
|
||||
tcsCtrl::TempLimits dacLimits = tcsCtrl::TempLimits(-65.0, -40.0, 113.0, 118.0, 150.0);
|
||||
tcsCtrl::TempLimits cameraLimits = tcsCtrl::TempLimits(-40.0, -30.0, 60.0, 65.0, 85.0);
|
||||
tcsCtrl::TempLimits droLimits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
|
||||
tcsCtrl::TempLimits x8Limits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
|
||||
tcsCtrl::TempLimits hpaLimits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
|
||||
tcsCtrl::TempLimits txLimits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
|
||||
tcsCtrl::TempLimits mpaLimits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
|
||||
tcsCtrl::TempLimits scexBoardLimits = tcsCtrl::TempLimits(-60.0, -40.0, 80.0, 85.0, 150.0);
|
||||
|
||||
double sensorTemp = INVALID_TEMPERATURE;
|
||||
uint8_t currentSensorIndex = 0;
|
||||
ThermalComponents thermalComponent = NONE;
|
||||
bool redSwitchNrInUse = false;
|
||||
struct CtrlContext {
|
||||
double sensorTemp = INVALID_TEMPERATURE;
|
||||
uint8_t currentSensorIndex = 0;
|
||||
tcsCtrl::ThermalComponents thermalComponent = tcsCtrl::NONE;
|
||||
bool redSwitchNrInUse = false;
|
||||
bool componentAboveCutOffLimit = false;
|
||||
bool componentAboveUpperLimit = false;
|
||||
Event overHeatEventToTrigger;
|
||||
} ctrlCtx;
|
||||
MessageQueueId_t camId = MessageQueueIF::NO_QUEUE;
|
||||
bool componentAboveCutOffLimit = false;
|
||||
bool componentAboveUpperLimit = false;
|
||||
Event overHeatEventToTrigger;
|
||||
bool eBandTooHotFlag = false;
|
||||
bool camTooHotOneShotFlag = false;
|
||||
bool scexTooHotFlag = false;
|
||||
bool plocTooHotFlag = false;
|
||||
bool pcduSystemTooHotFlag = false;
|
||||
bool syrlinksTooHotFlag = false;
|
||||
bool obcTooHotFlag = false;
|
||||
bool mgtTooHotFlag = false;
|
||||
bool strTooHotFlag = false;
|
||||
bool rwTooHotFlag = false;
|
||||
|
||||
struct TooHotFlags {
|
||||
bool eBandTooHotFlag = false;
|
||||
bool camTooHotOneShotFlag = false;
|
||||
bool scexTooHotFlag = false;
|
||||
bool plocTooHotFlag = false;
|
||||
bool pcduSystemTooHotFlag = false;
|
||||
bool syrlinksTooHotFlag = false;
|
||||
bool obcTooHotFlag = false;
|
||||
bool mgtTooHotFlag = false;
|
||||
bool strTooHotFlag = false;
|
||||
bool rwTooHotFlag = false;
|
||||
} tooHotFlags;
|
||||
|
||||
bool transitionWhenHeatersOff = false;
|
||||
uint32_t transitionWhenHeatersOffCycles = 0;
|
||||
Mode_t targetMode = MODE_OFF;
|
||||
Submode_t targetSubmode = SUBMODE_NONE;
|
||||
uint32_t cycles = 0;
|
||||
std::array<ThermalState, ThermalComponents::NUM_ENTRIES> thermalStates{};
|
||||
std::array<HeaterState, heater::NUMBER_OF_SWITCHES> heaterStates{};
|
||||
std::array<tcsCtrl::ThermalState, tcsCtrl::NUM_THERMAL_COMPONENTS> thermalStates{};
|
||||
std::array<tcsCtrl::HeaterState, heater::NUMBER_OF_SWITCHES> heaterStates{};
|
||||
|
||||
// Initial delay to make sure all pool variables have been initialized their owners.
|
||||
// Also, wait for system initialization to complete.
|
||||
@ -324,6 +259,12 @@ class ThermalController : public ExtendedControllerBase {
|
||||
PoolEntry<uint8_t> heaterSwitchStates = PoolEntry<uint8_t>(heater::NUMBER_OF_SWITCHES);
|
||||
PoolEntry<int16_t> heaterCurrent = PoolEntry<int16_t>();
|
||||
|
||||
PoolEntry<uint8_t> tcsCtrlHeaterOn = PoolEntry<uint8_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
|
||||
PoolEntry<uint8_t> tcsCtrlSensorIdx = PoolEntry<uint8_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
|
||||
PoolEntry<uint8_t> tcsCtrlHeaterIdx = PoolEntry<uint8_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
|
||||
PoolEntry<uint32_t> tcsCtrlStartTimes = PoolEntry<uint32_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
|
||||
PoolEntry<uint32_t> tcsCtrlEndTimes = PoolEntry<uint32_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
|
||||
|
||||
static constexpr dur_millis_t MUTEX_TIMEOUT = 50;
|
||||
|
||||
void startTransition(Mode_t mode, Submode_t submode) override;
|
||||
@ -345,7 +286,7 @@ class ThermalController : public ExtendedControllerBase {
|
||||
bool selectAndReadSensorTemp(HeaterContext& htrCtx);
|
||||
|
||||
void heaterSwitchHelperAllOff();
|
||||
void heaterSwitchHelper(heater::Switch switchNr, HeaterHandler::SwitchState state,
|
||||
void heaterSwitchHelper(heater::Switch switchNr, heater::SwitchState state,
|
||||
unsigned componentIdx);
|
||||
|
||||
void ctrlAcsBoard();
|
||||
@ -378,14 +319,14 @@ class ThermalController : public ExtendedControllerBase {
|
||||
* of tracking transition and capturing their completion.
|
||||
* @param currentHeaterStates
|
||||
*/
|
||||
void heaterTransitionControl(const HeaterSwitchStates& currentHeaterStates);
|
||||
void heaterTransitionControl(const tcsCtrl::HeaterSwitchStates& currentHeaterStates);
|
||||
/**
|
||||
* Control tasks to prevent heaters being on for prolonged periods. Ideally, this
|
||||
* should never happen, but this task prevents bugs from causing heaters to stay on
|
||||
* for a long time, which draws a lot of power.
|
||||
* @param currentHeaterStates
|
||||
*/
|
||||
void heaterMaxDurationControl(const HeaterSwitchStates& currentHeaterStates);
|
||||
void heaterMaxDurationControl(const tcsCtrl::HeaterSwitchStates& currentHeaterStates);
|
||||
void crossCheckHeaterStateOfComponentsWhenHeaterGoesOff(heater::Switch switchIdx);
|
||||
void setMode(Mode_t mode, Submode_t submode);
|
||||
uint32_t tempFloatToU32() const;
|
||||
|
||||
@ -9,6 +9,84 @@
|
||||
|
||||
namespace tcsCtrl {
|
||||
|
||||
/**
|
||||
* NOP Limit: Hard limit for device, usually from datasheet. Device damage is possible lif NOP limit
|
||||
* is exceeded.
|
||||
* OP Limit: Soft limit. Device should be switched off or TCS controller should take action if the
|
||||
* limit is exceeded to avoid reaching NOP limit
|
||||
*/
|
||||
struct TempLimits {
|
||||
TempLimits(float nopLowerLimit, float opLowerLimit, float cutOffLimit, float opUpperLimit,
|
||||
float nopUpperLimit)
|
||||
: opLowerLimit(opLowerLimit),
|
||||
opUpperLimit(opUpperLimit),
|
||||
cutOffLimit(cutOffLimit),
|
||||
nopLowerLimit(nopLowerLimit),
|
||||
nopUpperLimit(nopUpperLimit) {}
|
||||
float opLowerLimit;
|
||||
float opUpperLimit;
|
||||
float cutOffLimit;
|
||||
float nopLowerLimit;
|
||||
float nopUpperLimit;
|
||||
};
|
||||
|
||||
/**
|
||||
* Abstraction for the state of a single thermal component
|
||||
*/
|
||||
struct ThermalState {
|
||||
uint8_t errorCounter;
|
||||
// Which sensor is used for this component?
|
||||
uint8_t sensorIndex = 0;
|
||||
// Is heating on for that thermal module?
|
||||
bool heating = false;
|
||||
// Which switch is being used for heating the component
|
||||
heater::Switch heaterSwitch = heater::Switch::NUMBER_OF_SWITCHES;
|
||||
// Heater start time and end times as UNIX seconds. Please note that these times will be updated
|
||||
// when a switch command is sent, with no guarantess that the heater actually went on.
|
||||
uint32_t heaterStartTime = 0;
|
||||
uint32_t heaterEndTime = 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Abstraction for the state of a single heater.
|
||||
*/
|
||||
struct HeaterState {
|
||||
bool switchTransition;
|
||||
heater::SwitchState target;
|
||||
uint8_t heaterSwitchControlCycles;
|
||||
Countdown heaterOnPeriod;
|
||||
};
|
||||
|
||||
using HeaterSwitchStates = std::array<heater::SwitchState, heater::NUMBER_OF_SWITCHES>;
|
||||
|
||||
enum ThermalComponents : uint8_t {
|
||||
NONE = 0,
|
||||
ACS_BOARD = 1,
|
||||
MGT = 2,
|
||||
RW = 3,
|
||||
STR = 4,
|
||||
IF_BOARD = 5,
|
||||
TCS_BOARD = 6,
|
||||
OBC = 7,
|
||||
OBCIF_BOARD = 8,
|
||||
SBAND_TRANSCEIVER = 9,
|
||||
PCDUP60_BOARD = 10,
|
||||
PCDUACU = 11,
|
||||
PCDUPDU = 12,
|
||||
PLPCDU_BOARD = 13,
|
||||
PLOCMISSION_BOARD = 14,
|
||||
PLOCPROCESSING_BOARD = 15,
|
||||
DAC = 16,
|
||||
CAMERA = 17,
|
||||
DRO = 18,
|
||||
X8 = 19,
|
||||
HPA = 20,
|
||||
TX = 21,
|
||||
MPA = 22,
|
||||
SCEX_BOARD = 23,
|
||||
NUM_THERMAL_COMPONENTS
|
||||
};
|
||||
|
||||
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_CONTROLLER;
|
||||
static constexpr Event NO_VALID_SENSOR_TEMPERATURE = MAKE_EVENT(0, severity::MEDIUM);
|
||||
static constexpr Event NO_HEALTHY_HEATER_AVAILABLE = MAKE_EVENT(1, severity::MEDIUM);
|
||||
@ -25,6 +103,7 @@ enum SetId : uint32_t {
|
||||
SUS_TEMPERATURES = 2,
|
||||
COMPONENT_TEMPERATURES = 3,
|
||||
HEATER_SET = 4,
|
||||
TCS_CTRL_INFO = 5
|
||||
};
|
||||
|
||||
enum PoolIds : lp_id_t {
|
||||
@ -92,7 +171,13 @@ enum PoolIds : lp_id_t {
|
||||
TEMP_ADC_PAYLOAD_PCDU,
|
||||
|
||||
HEATER_SWITCH_LIST,
|
||||
HEATER_CURRENT
|
||||
HEATER_CURRENT,
|
||||
|
||||
HEATER_ON_FOR_COMPONENT_VEC,
|
||||
SENSOR_USED_FOR_TCS_CTRL,
|
||||
HEATER_IDX_USED_FOR_TCS_CTRL,
|
||||
HEATER_START_TIME,
|
||||
HEATER_END_TIME
|
||||
};
|
||||
|
||||
static const uint8_t ENTRIES_SENSOR_TEMPERATURE_SET = 25;
|
||||
@ -232,6 +317,29 @@ class HeaterInfo : public StaticLocalDataSet<3> {
|
||||
lp_var_t<int16_t> heaterCurrent = lp_var_t<int16_t>(sid.objectId, PoolIds::HEATER_CURRENT, this);
|
||||
};
|
||||
|
||||
class TcsCtrlInfo : public StaticLocalDataSet<6> {
|
||||
public:
|
||||
explicit TcsCtrlInfo(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TCS_CTRL_INFO) {}
|
||||
|
||||
explicit TcsCtrlInfo(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, TCS_CTRL_INFO)) {}
|
||||
|
||||
lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS> heatingOnVec =
|
||||
lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(
|
||||
sid.objectId, PoolIds::HEATER_ON_FOR_COMPONENT_VEC, this);
|
||||
lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS> sensorIdxUsedForTcsCtrl =
|
||||
lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(sid.objectId,
|
||||
PoolIds::SENSOR_USED_FOR_TCS_CTRL, this);
|
||||
lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS> heaterSwitchIdx =
|
||||
lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(
|
||||
sid.objectId, PoolIds::HEATER_IDX_USED_FOR_TCS_CTRL, this);
|
||||
lp_vec_t<uint32_t, tcsCtrl::NUM_THERMAL_COMPONENTS> heaterStartTimes =
|
||||
lp_vec_t<uint32_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(sid.objectId, PoolIds::HEATER_START_TIME,
|
||||
this);
|
||||
lp_vec_t<uint32_t, tcsCtrl::NUM_THERMAL_COMPONENTS> heaterEndTimes =
|
||||
lp_vec_t<uint32_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(sid.objectId, PoolIds::HEATER_END_TIME,
|
||||
this);
|
||||
};
|
||||
|
||||
} // namespace tcsCtrl
|
||||
|
||||
#endif /* MISSION_CONTROLLER_CONTROLLERDEFINITIONS_THERMALCONTROLLERDEFINITIONS_H_ */
|
||||
|
||||
@ -97,7 +97,7 @@ ReturnValue_t HeaterHandler::initialize() {
|
||||
|
||||
ReturnValue_t HeaterHandler::initializeHeaterMap() {
|
||||
for (power::Switch_t switchNr = 0; switchNr < heater::NUMBER_OF_SWITCHES; switchNr++) {
|
||||
heaterVec.push_back(HeaterWrapper(helper.heaters[switchNr], SwitchState::OFF));
|
||||
heaterVec.push_back(HeaterWrapper(helper.heaters[switchNr], heater::SwitchState::OFF));
|
||||
}
|
||||
return returnvalue::OK;
|
||||
}
|
||||
@ -214,7 +214,7 @@ ReturnValue_t HeaterHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t o
|
||||
void HeaterHandler::handleSwitchHandling() {
|
||||
for (uint8_t idx = 0; idx < heater::NUMBER_OF_SWITCHES; idx++) {
|
||||
auto health = heaterVec[idx].healthDevice->getHealth();
|
||||
if (heaterVec[idx].switchState == SwitchState::ON) {
|
||||
if (heaterVec[idx].switchState == heater::SwitchState::ON) {
|
||||
// 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) {
|
||||
@ -277,7 +277,7 @@ void HeaterHandler::handleSwitchOnCommand(heater::Switch heaterIdx) {
|
||||
triggerEvent(HEATER_WENT_ON, heaterIdx, 0);
|
||||
{
|
||||
MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
|
||||
heater.switchState = ON;
|
||||
heater.switchState = heater::SwitchState::ON;
|
||||
}
|
||||
EventManagerIF::triggerEvent(helper.heaters[heaterIdx].first->getObjectId(), MODE_INFO,
|
||||
MODE_ON, 0);
|
||||
@ -326,10 +326,10 @@ void HeaterHandler::handleSwitchOffCommand(heater::Switch heaterIdx) {
|
||||
}
|
||||
if (result == returnvalue::OK) {
|
||||
// Check whether switch is already off
|
||||
if (getSwitchState(heaterIdx) == SwitchState::ON) {
|
||||
if (getSwitchState(heaterIdx) == heater::SwitchState::ON) {
|
||||
{
|
||||
MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
|
||||
heater.switchState = OFF;
|
||||
heater.switchState = heater::SwitchState::OFF;
|
||||
}
|
||||
triggerEvent(HEATER_WENT_OFF, heaterIdx, 0);
|
||||
} else {
|
||||
@ -356,15 +356,15 @@ void HeaterHandler::handleSwitchOffCommand(heater::Switch heaterIdx) {
|
||||
heater.cmdActive = false;
|
||||
}
|
||||
|
||||
HeaterHandler::SwitchState HeaterHandler::getSwitchState(heater::Switch switchNr) const {
|
||||
heater::SwitchState HeaterHandler::getSwitchState(heater::Switch switchNr) const {
|
||||
MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
|
||||
return heaterVec.at(switchNr).switchState;
|
||||
}
|
||||
|
||||
ReturnValue_t HeaterHandler::switchHeater(heater::Switch heater, SwitchState switchState) {
|
||||
if (switchState == SwitchState::ON) {
|
||||
ReturnValue_t HeaterHandler::switchHeater(heater::Switch heater, heater::SwitchState switchState) {
|
||||
if (switchState == heater::SwitchState::ON) {
|
||||
return sendSwitchCommand(heater, PowerSwitchIF::SWITCH_ON);
|
||||
} else if (switchState == SwitchState::OFF) {
|
||||
} else if (switchState == heater::SwitchState::OFF) {
|
||||
return sendSwitchCommand(heater, PowerSwitchIF::SWITCH_OFF);
|
||||
}
|
||||
return returnvalue::FAILED;
|
||||
@ -373,10 +373,10 @@ ReturnValue_t HeaterHandler::switchHeater(heater::Switch heater, SwitchState swi
|
||||
void HeaterHandler::announceMode(bool recursive) {
|
||||
triggerEvent(MODE_INFO, mode, submode);
|
||||
|
||||
std::array<SwitchState, 8> states;
|
||||
std::array<heater::SwitchState, 8> states;
|
||||
getAllSwitchStates(states);
|
||||
for (unsigned idx = 0; idx < helper.heaters.size(); idx++) {
|
||||
if (states[idx] == ON) {
|
||||
if (states[idx] == heater::SwitchState::ON) {
|
||||
EventManagerIF::triggerEvent(helper.heaters[idx].first->getObjectId(), MODE_INFO, MODE_ON, 0);
|
||||
} else {
|
||||
EventManagerIF::triggerEvent(helper.heaters[idx].first->getObjectId(), MODE_INFO, MODE_OFF,
|
||||
@ -405,7 +405,7 @@ ModeTreeChildIF& HeaterHandler::getModeTreeChildIF() { return *this; }
|
||||
|
||||
object_id_t HeaterHandler::getObjectId() const { return SystemObject::getObjectId(); }
|
||||
|
||||
ReturnValue_t HeaterHandler::getAllSwitchStates(std::array<SwitchState, 8>& statesBuf) {
|
||||
ReturnValue_t HeaterHandler::getAllSwitchStates(std::array<heater::SwitchState, 8>& statesBuf) {
|
||||
{
|
||||
MutexGuard mg(handlerLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
|
||||
if (mg.getLockResult() != returnvalue::OK) {
|
||||
@ -440,7 +440,7 @@ ReturnValue_t HeaterHandler::getSwitchState(uint8_t switchNr) const {
|
||||
if (switchNr > 7) {
|
||||
return returnvalue::FAILED;
|
||||
}
|
||||
if (getSwitchState(static_cast<heater::Switch>(switchNr)) == SwitchState::ON) {
|
||||
if (getSwitchState(static_cast<heater::Switch>(switchNr)) == heater::SwitchState::ON) {
|
||||
return PowerSwitchIF::SWITCH_ON;
|
||||
}
|
||||
return PowerSwitchIF::SWITCH_OFF;
|
||||
|
||||
@ -60,7 +60,6 @@ class HeaterHandler : public ExecutableObjectIF,
|
||||
static const ReturnValue_t COMMAND_ALREADY_WAITING = MAKE_RETURN_CODE(0xA5);
|
||||
|
||||
enum CmdSourceParam : uint8_t { INTERNAL = 0, EXTERNAL = 1 };
|
||||
enum SwitchState : uint8_t { ON = 1, OFF = 0 };
|
||||
|
||||
/** Device command IDs */
|
||||
static const DeviceCommandId_t SWITCH_HEATER = 0x0;
|
||||
@ -69,14 +68,14 @@ class HeaterHandler : public ExecutableObjectIF,
|
||||
PowerSwitchIF* mainLineSwitcherObjectId, power::Switch_t mainLineSwitch);
|
||||
|
||||
ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent) override;
|
||||
ReturnValue_t getAllSwitchStates(std::array<SwitchState, 8>& statesBuf);
|
||||
ReturnValue_t getAllSwitchStates(std::array<heater::SwitchState, 8>& statesBuf);
|
||||
|
||||
virtual ~HeaterHandler();
|
||||
|
||||
protected:
|
||||
enum SwitchAction : uint8_t { SET_SWITCH_OFF, SET_SWITCH_ON, NONE };
|
||||
|
||||
ReturnValue_t switchHeater(heater::Switch heater, SwitchState switchState);
|
||||
ReturnValue_t switchHeater(heater::Switch heater, heater::SwitchState switchState);
|
||||
HasHealthIF::HealthState getHealth(heater::Switch heater);
|
||||
|
||||
ReturnValue_t performOperation(uint8_t operationCode = 0) override;
|
||||
@ -121,14 +120,14 @@ class HeaterHandler : public ExecutableObjectIF,
|
||||
* @param mainSwitchCountdown Sets timeout to wait for main switch being set on.
|
||||
*/
|
||||
struct HeaterWrapper {
|
||||
HeaterWrapper(HeaterPair pair, SwitchState initState)
|
||||
HeaterWrapper(HeaterPair pair, heater::SwitchState initState)
|
||||
: healthDevice(pair.first), gpioId(pair.second), switchState(initState) {}
|
||||
HealthDevice* healthDevice = nullptr;
|
||||
gpioId_t gpioId = gpio::NO_GPIO;
|
||||
SwitchAction action = SwitchAction::NONE;
|
||||
MessageQueueId_t replyQueue = MessageQueueIF::NO_QUEUE;
|
||||
bool cmdActive = false;
|
||||
SwitchState switchState = SwitchState::OFF;
|
||||
heater::SwitchState switchState = heater::SwitchState::OFF;
|
||||
bool waitMainSwitchOn = false;
|
||||
Countdown mainSwitchCountdown;
|
||||
};
|
||||
@ -177,7 +176,7 @@ class HeaterHandler : public ExecutableObjectIF,
|
||||
* @brief Returns the state of a switch (ON - true, or OFF - false).
|
||||
* @param switchNr The number of the switch to check.
|
||||
*/
|
||||
SwitchState getSwitchState(heater::Switch switchNr) const;
|
||||
heater::SwitchState getSwitchState(heater::Switch switchNr) const;
|
||||
|
||||
/**
|
||||
* @brief This function runs commands waiting for execution.
|
||||
|
||||
@ -4,6 +4,7 @@
|
||||
#include <cstdint>
|
||||
|
||||
namespace heater {
|
||||
|
||||
enum Switch : uint8_t {
|
||||
HEATER_0_PLOC_PROC_BRD,
|
||||
HEATER_1_PCDU_PDU,
|
||||
@ -15,7 +16,10 @@ enum Switch : uint8_t {
|
||||
HEATER_7_S_BAND,
|
||||
NUMBER_OF_SWITCHES
|
||||
};
|
||||
}
|
||||
|
||||
enum SwitchState : uint8_t { ON = 1, OFF = 0 };
|
||||
|
||||
} // namespace heater
|
||||
|
||||
namespace tcs {
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user