done
This commit is contained in:
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user