|
|
|
@ -984,7 +984,8 @@ void ThermalController::ctrlAcsBoard() {
|
|
|
|
|
numSensors = 5;
|
|
|
|
|
if (selectAndReadSensorTemp()) {
|
|
|
|
|
if (chooseHeater(switchNr, redSwitchNr)) {
|
|
|
|
|
checkLimitsAndCtrlHeater(switchNr, redSwitchNr, acsBoardLimits);
|
|
|
|
|
HeaterContext htrCtx(switchNr, redSwitchNr, acsBoardLimits);
|
|
|
|
|
checkLimitsAndCtrlHeater(htrCtx);
|
|
|
|
|
}
|
|
|
|
|
resetSensorsArray();
|
|
|
|
|
return;
|
|
|
|
@ -1002,11 +1003,12 @@ void ThermalController::ctrlAcsBoard() {
|
|
|
|
|
numSensors = 4;
|
|
|
|
|
if (selectAndReadSensorTemp()) {
|
|
|
|
|
if (chooseHeater(switchNr, redSwitchNr)) {
|
|
|
|
|
checkLimitsAndCtrlHeater(switchNr, redSwitchNr, acsBoardLimits);
|
|
|
|
|
HeaterContext htrCtx(switchNr, redSwitchNr, acsBoardLimits);
|
|
|
|
|
checkLimitsAndCtrlHeater(htrCtx);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (chooseHeater(switchNr, redSwitchNr)) {
|
|
|
|
|
if (heaterHandler.checkSwitchState(switchNr)) {
|
|
|
|
|
if (heaterHandler.getSwitchState(switchNr)) {
|
|
|
|
|
heaterHandler.switchHeater(switchNr, HeaterHandler::SwitchState::OFF);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
@ -1023,7 +1025,8 @@ void ThermalController::ctrlMgt() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.plpcduHeatspreader.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.plpcduHeatspreader.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_2_ACS_BRD, heater::HEATER_3_PCDU_PDU, mgtLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_2_ACS_BRD, heater::HEATER_3_PCDU_PDU, mgtLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
// TODO: trigger special event
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1044,11 +1047,14 @@ void ThermalController::ctrlRw() {
|
|
|
|
|
sensors[3].first = sensorTemperatures.dro.isValid();
|
|
|
|
|
sensors[3].second = sensorTemperatures.dro.value;
|
|
|
|
|
numSensors = 4;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_6_DRO, heater::HEATER_6_DRO, rwLimits);
|
|
|
|
|
sensorTemps[0] = tempFloatToU32();
|
|
|
|
|
if (componentAboveUpperLimit) {
|
|
|
|
|
oneIsAboveLimit = true;
|
|
|
|
|
eventToTrigger = overHeatEventToTrigger;
|
|
|
|
|
{
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_6_DRO, rwLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
sensorTemps[0] = tempFloatToU32();
|
|
|
|
|
if (componentAboveUpperLimit) {
|
|
|
|
|
oneIsAboveLimit = true;
|
|
|
|
|
eventToTrigger = overHeatEventToTrigger;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// RW2
|
|
|
|
@ -1062,15 +1068,17 @@ void ThermalController::ctrlRw() {
|
|
|
|
|
sensors[3].first = sensorTemperatures.dro.isValid();
|
|
|
|
|
sensors[3].second = sensorTemperatures.dro.value;
|
|
|
|
|
numSensors = 4;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_6_DRO, heater::HEATER_6_DRO, rwLimits);
|
|
|
|
|
sensorTemps[1] = tempFloatToU32();
|
|
|
|
|
if (componentAboveUpperLimit) {
|
|
|
|
|
oneIsAboveLimit = true;
|
|
|
|
|
if (eventToTrigger != ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH) {
|
|
|
|
|
eventToTrigger = overHeatEventToTrigger;
|
|
|
|
|
{
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_6_DRO, rwLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
sensorTemps[1] = tempFloatToU32();
|
|
|
|
|
if (componentAboveUpperLimit) {
|
|
|
|
|
oneIsAboveLimit = true;
|
|
|
|
|
if (eventToTrigger != ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH) {
|
|
|
|
|
eventToTrigger = overHeatEventToTrigger;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// RW3
|
|
|
|
|
thermalComponent = RW;
|
|
|
|
|
sensors[0].first = deviceTemperatures.rw3.isValid();
|
|
|
|
@ -1082,12 +1090,15 @@ void ThermalController::ctrlRw() {
|
|
|
|
|
sensors[3].first = sensorTemperatures.dro.isValid();
|
|
|
|
|
sensors[3].second = sensorTemperatures.dro.value;
|
|
|
|
|
numSensors = 4;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_6_DRO, heater::HEATER_6_DRO, rwLimits);
|
|
|
|
|
sensorTemps[2] = tempFloatToU32();
|
|
|
|
|
if (componentAboveUpperLimit) {
|
|
|
|
|
oneIsAboveLimit = true;
|
|
|
|
|
if (eventToTrigger != ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH) {
|
|
|
|
|
eventToTrigger = overHeatEventToTrigger;
|
|
|
|
|
{
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_6_DRO, rwLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
sensorTemps[2] = tempFloatToU32();
|
|
|
|
|
if (componentAboveUpperLimit) {
|
|
|
|
|
oneIsAboveLimit = true;
|
|
|
|
|
if (eventToTrigger != ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH) {
|
|
|
|
|
eventToTrigger = overHeatEventToTrigger;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1102,12 +1113,15 @@ void ThermalController::ctrlRw() {
|
|
|
|
|
sensors[3].first = sensorTemperatures.dro.isValid();
|
|
|
|
|
sensors[3].second = sensorTemperatures.dro.value;
|
|
|
|
|
numSensors = 4;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_6_DRO, heater::HEATER_6_DRO, rwLimits);
|
|
|
|
|
sensorTemps[3] = tempFloatToU32();
|
|
|
|
|
if (componentAboveUpperLimit) {
|
|
|
|
|
oneIsAboveLimit = true;
|
|
|
|
|
if (eventToTrigger != ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH) {
|
|
|
|
|
eventToTrigger = overHeatEventToTrigger;
|
|
|
|
|
{
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_6_DRO, rwLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
sensorTemps[3] = tempFloatToU32();
|
|
|
|
|
if (componentAboveUpperLimit) {
|
|
|
|
|
oneIsAboveLimit = true;
|
|
|
|
|
if (eventToTrigger != ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH) {
|
|
|
|
|
eventToTrigger = overHeatEventToTrigger;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1131,7 +1145,8 @@ void ThermalController::ctrlStr() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.dro.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.dro.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_5_STR, heater::HEATER_6_DRO, strLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_5_STR, heater::HEATER_6_DRO, strLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
tooHotHandlerWhichClearsOneShotFlag(objects::STAR_TRACKER, strTooHotFlag);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1144,7 +1159,8 @@ void ThermalController::ctrlIfBoard() {
|
|
|
|
|
sensors[2].first = deviceTemperatures.mgm2SideB.isValid();
|
|
|
|
|
sensors[2].second = deviceTemperatures.mgm2SideB.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_2_ACS_BRD, heater::HEATER_3_PCDU_PDU, ifBoardLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_2_ACS_BRD, heater::HEATER_3_PCDU_PDU, ifBoardLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
// TODO: special event overheating + could go back to safe mode
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1157,7 +1173,8 @@ void ThermalController::ctrlTcsBoard() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.tmp1075Tcs1.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.tmp1075Tcs1.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_0_OBC_BRD, heater::HEATER_2_ACS_BRD, tcsBoardLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_0_OBC_BRD, heater::HEATER_2_ACS_BRD, tcsBoardLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
// TODO: special event overheating + could go back to safe mode
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1170,7 +1187,8 @@ void ThermalController::ctrlObc() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.tmp1075Tcs0.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.tmp1075Tcs0.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_0_OBC_BRD, heater::HEATER_2_ACS_BRD, obcLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_0_OBC_BRD, heater::HEATER_2_ACS_BRD, obcLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
if (componentAboveUpperLimit and not obcTooHotFlag) {
|
|
|
|
|
triggerEvent(tcsCtrl::OBC_OVERHEATING, tempFloatToU32());
|
|
|
|
|
obcTooHotFlag = true;
|
|
|
|
@ -1188,7 +1206,8 @@ void ThermalController::ctrlObcIfBoard() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.tmp1075Tcs1.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.tmp1075Tcs1.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_0_OBC_BRD, heater::HEATER_2_ACS_BRD, obcIfBoardLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_0_OBC_BRD, heater::HEATER_2_ACS_BRD, obcIfBoardLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
if (componentAboveUpperLimit and not obcTooHotFlag) {
|
|
|
|
|
triggerEvent(tcsCtrl::OBC_OVERHEATING, tempFloatToU32());
|
|
|
|
|
obcTooHotFlag = true;
|
|
|
|
@ -1206,8 +1225,8 @@ void ThermalController::ctrlSBandTransceiver() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.payload4kCamera.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.payload4kCamera.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_7_S_BAND, heater::HEATER_4_CAMERA,
|
|
|
|
|
sBandTransceiverLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_7_S_BAND, heater::HEATER_4_CAMERA, sBandTransceiverLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
if (componentAboveUpperLimit and not syrlinksTooHotFlag) {
|
|
|
|
|
triggerEvent(tcsCtrl::SYRLINKS_OVERHEATING, tempFloatToU32());
|
|
|
|
|
syrlinksTooHotFlag = true;
|
|
|
|
@ -1222,7 +1241,8 @@ void ThermalController::ctrlPcduP60Board() {
|
|
|
|
|
sensors[1].first = deviceTemperatures.temp2P60dock.isValid();
|
|
|
|
|
sensors[1].second = deviceTemperatures.temp2P60dock.value;
|
|
|
|
|
numSensors = 2;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_3_PCDU_PDU, heater::HEATER_2_ACS_BRD, pcduP60BoardLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_3_PCDU_PDU, heater::HEATER_2_ACS_BRD, pcduP60BoardLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
if (componentAboveUpperLimit and not pcduSystemTooHotFlag) {
|
|
|
|
|
triggerEvent(tcsCtrl::PCDU_SYSTEM_OVERHEATING, tempFloatToU32());
|
|
|
|
|
pcduSystemTooHotFlag = true;
|
|
|
|
@ -1252,7 +1272,8 @@ void ThermalController::ctrlPcduAcu() {
|
|
|
|
|
sensorTempAvailable = false;
|
|
|
|
|
}
|
|
|
|
|
if (sensorTempAvailable) {
|
|
|
|
|
checkLimitsAndCtrlHeater(switchNr, redSwitchNr, pcduAcuLimits);
|
|
|
|
|
HeaterContext htrCtx(switchNr, redSwitchNr, pcduAcuLimits);
|
|
|
|
|
checkLimitsAndCtrlHeater(htrCtx);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (componentAboveUpperLimit and not pcduSystemTooHotFlag) {
|
|
|
|
@ -1272,7 +1293,8 @@ void ThermalController::ctrlPcduPdu() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.tmp1075Tcs0.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.tmp1075Tcs0.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_3_PCDU_PDU, heater::HEATER_2_ACS_BRD, pcduPduLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_3_PCDU_PDU, heater::HEATER_2_ACS_BRD, pcduPduLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
if (componentAboveUpperLimit and not pcduSystemTooHotFlag) {
|
|
|
|
|
triggerEvent(tcsCtrl::PCDU_SYSTEM_OVERHEATING, tempFloatToU32());
|
|
|
|
|
pcduSystemTooHotFlag = true;
|
|
|
|
@ -1292,7 +1314,8 @@ void ThermalController::ctrlPlPcduBoard() {
|
|
|
|
|
sensors[3].first = sensorTemperatures.plpcduHeatspreader.isValid();
|
|
|
|
|
sensors[3].second = sensorTemperatures.plpcduHeatspreader.value;
|
|
|
|
|
numSensors = 4;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_3_PCDU_PDU, heater::HEATER_2_ACS_BRD, plPcduBoardLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_3_PCDU_PDU, heater::HEATER_2_ACS_BRD, plPcduBoardLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1305,8 +1328,9 @@ void ThermalController::ctrlPlocMissionBoard() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.dacHeatspreader.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.dacHeatspreader.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_1_PLOC_PROC_BRD, heater::HEATER_0_OBC_BRD,
|
|
|
|
|
plocMissionBoardLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_1_PLOC_PROC_BRD, heater::HEATER_0_OBC_BRD,
|
|
|
|
|
plocMissionBoardLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
tooHotHandler(objects::PLOC_SUPERVISOR_HANDLER, plocTooHotFlag);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1319,8 +1343,9 @@ void ThermalController::ctrlPlocProcessingBoard() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.dacHeatspreader.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.dacHeatspreader.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_1_PLOC_PROC_BRD, heater::HEATER_0_OBC_BRD,
|
|
|
|
|
plocProcessingBoardLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_1_PLOC_PROC_BRD, heater::HEATER_0_OBC_BRD,
|
|
|
|
|
plocProcessingBoardLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
tooHotHandler(objects::PLOC_SUPERVISOR_HANDLER, plocTooHotFlag);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1333,7 +1358,8 @@ void ThermalController::ctrlDac() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.plocHeatspreader.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.plocHeatspreader.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_1_PLOC_PROC_BRD, heater::HEATER_0_OBC_BRD, dacLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_1_PLOC_PROC_BRD, heater::HEATER_0_OBC_BRD, dacLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1346,7 +1372,8 @@ void ThermalController::ctrlCameraBody() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.mpa.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.mpa.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_4_CAMERA, heater::HEATER_6_DRO, cameraLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_4_CAMERA, heater::HEATER_6_DRO, cameraLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
if (componentAboveUpperLimit and not camTooHotOneShotFlag) {
|
|
|
|
|
triggerEvent(tcsCtrl::CAMERA_OVERHEATING, tempFloatToU32());
|
|
|
|
|
CommandMessage msg;
|
|
|
|
@ -1371,7 +1398,8 @@ void ThermalController::ctrlDro() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.mpa.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.mpa.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, droLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, droLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1384,7 +1412,8 @@ void ThermalController::ctrlX8() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.eBandTx.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.eBandTx.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, x8Limits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, x8Limits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1397,7 +1426,8 @@ void ThermalController::ctrlTx() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.mpa.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.mpa.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, txLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, txLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1410,7 +1440,8 @@ void ThermalController::ctrlMpa() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.eBandTx.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.eBandTx.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, mpaLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, mpaLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1423,7 +1454,8 @@ void ThermalController::ctrlHpa() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.mpa.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.mpa.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, hpaLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, hpaLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
tooHotHandler(objects::PLPCDU_HANDLER, eBandTooHotFlag);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1436,7 +1468,8 @@ void ThermalController::ctrlScexBoard() {
|
|
|
|
|
sensors[2].first = sensorTemperatures.hpa.isValid();
|
|
|
|
|
sensors[2].second = sensorTemperatures.hpa.value;
|
|
|
|
|
numSensors = 3;
|
|
|
|
|
ctrlComponentTemperature(heater::HEATER_6_DRO, heater::HEATER_5_STR, scexBoardLimits);
|
|
|
|
|
HeaterContext htrCtx(heater::HEATER_6_DRO, heater::HEATER_5_STR, scexBoardLimits);
|
|
|
|
|
ctrlComponentTemperature(htrCtx);
|
|
|
|
|
tooHotHandlerWhichClearsOneShotFlag(objects::SCEX, scexTooHotFlag);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -1506,18 +1539,16 @@ void ThermalController::performThermalModuleCtrl(const HeaterSwitchStates& heate
|
|
|
|
|
|
|
|
|
|
heaterTransitionControl(heaterSwitchStates);
|
|
|
|
|
}
|
|
|
|
|
void ThermalController::ctrlComponentTemperature(heater::Switchers switchNr,
|
|
|
|
|
heater::Switchers redSwitchNr,
|
|
|
|
|
const TempLimits& tempLimit) {
|
|
|
|
|
void ThermalController::ctrlComponentTemperature(HeaterContext& htrCtx) {
|
|
|
|
|
if (selectAndReadSensorTemp()) {
|
|
|
|
|
if (chooseHeater(switchNr, redSwitchNr)) {
|
|
|
|
|
checkLimitsAndCtrlHeater(switchNr, redSwitchNr, tempLimit);
|
|
|
|
|
if (chooseHeater(htrCtx.switchNr, htrCtx.redSwitchNr)) {
|
|
|
|
|
checkLimitsAndCtrlHeater(htrCtx);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (chooseHeater(switchNr,
|
|
|
|
|
redSwitchNr)) { // TODO: muss der Heater dann wirklich abgeschalten werden?
|
|
|
|
|
if (heaterHandler.checkSwitchState(switchNr)) {
|
|
|
|
|
heaterHandler.switchHeater(switchNr, HeaterHandler::SwitchState::OFF);
|
|
|
|
|
// TODO: muss der Heater dann wirklich abgeschalten werden?
|
|
|
|
|
if (chooseHeater(htrCtx.switchNr, htrCtx.redSwitchNr)) {
|
|
|
|
|
if (heaterHandler.getSwitchState(htrCtx.switchNr)) {
|
|
|
|
|
heaterHandler.switchHeater(htrCtx.switchNr, HeaterHandler::SwitchState::OFF);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
@ -1562,66 +1593,69 @@ bool ThermalController::chooseHeater(heater::Switchers& switchNr, heater::Switch
|
|
|
|
|
return heaterAvailable;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ThermalController::heaterCtrlTempTooHighHandler(heater::Switchers switchNr,
|
|
|
|
|
heater::Switchers redSwitchNr,
|
|
|
|
|
const char* whatLimit) {
|
|
|
|
|
sif::info << "TCS: Component " << static_cast<int>(thermalComponent) << " too warm" << std::endl;
|
|
|
|
|
heaterHandler.switchHeater(switchNr, HeaterHandler::SwitchState::OFF);
|
|
|
|
|
heaterStates[switchNr].switchTransition = true;
|
|
|
|
|
heaterStates[switchNr].target = HeaterHandler::SwitchState::OFF;
|
|
|
|
|
if (heaterHandler.checkSwitchState(redSwitchNr) == HeaterHandler::SwitchState::ON) {
|
|
|
|
|
heaterHandler.switchHeater(redSwitchNr, HeaterHandler::SwitchState::OFF);
|
|
|
|
|
heaterStates[redSwitchNr].switchTransition = true;
|
|
|
|
|
heaterStates[redSwitchNr].target = HeaterHandler::SwitchState::OFF;
|
|
|
|
|
void ThermalController::heaterCtrlTempTooHighHandler(HeaterContext& htrCtx, const char* whatLimit) {
|
|
|
|
|
if (htrCtx.switchState == HeaterHandler::SwitchState::ON) {
|
|
|
|
|
sif::info << "TCS: Component " << static_cast<int>(thermalComponent) << " too warm, above "
|
|
|
|
|
<< whatLimit << ", switching off heater" << std::endl;
|
|
|
|
|
heaterHandler.switchHeater(htrCtx.switchNr, HeaterHandler::SwitchState::OFF);
|
|
|
|
|
heaterStates[htrCtx.switchNr].switchTransition = true;
|
|
|
|
|
heaterStates[htrCtx.switchNr].target = HeaterHandler::SwitchState::OFF;
|
|
|
|
|
}
|
|
|
|
|
if (heaterHandler.getSwitchState(htrCtx.redSwitchNr) == HeaterHandler::SwitchState::ON) {
|
|
|
|
|
heaterHandler.switchHeater(htrCtx.redSwitchNr, HeaterHandler::SwitchState::OFF);
|
|
|
|
|
heaterStates[htrCtx.redSwitchNr].switchTransition = true;
|
|
|
|
|
heaterStates[htrCtx.redSwitchNr].target = HeaterHandler::SwitchState::OFF;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ThermalController::checkLimitsAndCtrlHeater(heater::Switchers switchNr,
|
|
|
|
|
heater::Switchers redSwitchNr,
|
|
|
|
|
const TempLimits& tempLimit) {
|
|
|
|
|
void ThermalController::checkLimitsAndCtrlHeater(HeaterContext& htrCtx) {
|
|
|
|
|
componentAboveCutOffLimit = false;
|
|
|
|
|
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.
|
|
|
|
|
if (heaterStates[switchNr].switchTransition) {
|
|
|
|
|
heaterCtrlCheckUpperLimits(switchNr, redSwitchNr, false, tempLimit);
|
|
|
|
|
if (heaterStates[htrCtx.switchNr].switchTransition) {
|
|
|
|
|
sif::debug << " heater in switch transition" << std::endl;
|
|
|
|
|
htrCtx.doHeaterHandling = false;
|
|
|
|
|
heaterCtrlCheckUpperLimits(htrCtx);
|
|
|
|
|
} else {
|
|
|
|
|
// Heater off
|
|
|
|
|
if (not heaterHandler.checkSwitchState(switchNr)) {
|
|
|
|
|
// TODO: check NOP limit and maybe trigger fdir
|
|
|
|
|
if (sensorTemp < tempLimit.opLowerLimit) {
|
|
|
|
|
heaterHandler.switchHeater(switchNr, HeaterHandler::SwitchState::ON);
|
|
|
|
|
htrCtx.switchState = heaterHandler.getSwitchState(htrCtx.switchNr);
|
|
|
|
|
if (htrCtx.switchState == HeaterHandler::SwitchState::OFF) {
|
|
|
|
|
// sif::debug << " heater off" << std::endl;
|
|
|
|
|
// TODO: check NOP limit and maybe trigger fdir
|
|
|
|
|
if (sensorTemp < htrCtx.tempLimit.opLowerLimit) {
|
|
|
|
|
heaterHandler.switchHeater(htrCtx.switchNr, HeaterHandler::SwitchState::ON);
|
|
|
|
|
sif::info << "ThermalController::checkLimitsAndCtrlHeater: Heater "
|
|
|
|
|
<< static_cast<int>(thermalComponent) << " ON" << std::endl;
|
|
|
|
|
heaterStates[switchNr].switchTransition = true;
|
|
|
|
|
heaterStates[htrCtx.switchNr].switchTransition = true;
|
|
|
|
|
thermalStates[thermalComponent].heating = true;
|
|
|
|
|
heaterStates[switchNr].target = HeaterHandler::SwitchState::ON;
|
|
|
|
|
heaterStates[htrCtx.switchNr].target = HeaterHandler::SwitchState::ON;
|
|
|
|
|
} else {
|
|
|
|
|
thermalStates[thermalComponent].heating = false;
|
|
|
|
|
}
|
|
|
|
|
heaterCtrlCheckUpperLimits(switchNr, redSwitchNr, true, tempLimit);
|
|
|
|
|
heaterCtrlCheckUpperLimits(htrCtx);
|
|
|
|
|
// Heater on
|
|
|
|
|
} else if (heaterHandler.checkSwitchState(switchNr)) {
|
|
|
|
|
} else if (heaterHandler.getSwitchState(htrCtx.switchNr) == HeaterHandler::SwitchState::ON) {
|
|
|
|
|
// sif::debug << " heater on" << std::endl;
|
|
|
|
|
if (thermalStates[thermalComponent].heating) {
|
|
|
|
|
// We are already in a heating cycle, so need to check whether heating task is complete.
|
|
|
|
|
if (sensorTemp >= tempLimit.opLowerLimit + TEMP_OFFSET) {
|
|
|
|
|
heaterHandler.switchHeater(switchNr, HeaterHandler::SwitchState::OFF);
|
|
|
|
|
if (sensorTemp >= htrCtx.tempLimit.opLowerLimit + TEMP_OFFSET) {
|
|
|
|
|
heaterHandler.switchHeater(htrCtx.switchNr, HeaterHandler::SwitchState::OFF);
|
|
|
|
|
sif::info << "ThermalController::checkLimitsAndCtrlHeater: Heater "
|
|
|
|
|
<< static_cast<int>(thermalComponent) << " OFF" << std::endl;
|
|
|
|
|
heaterStates[switchNr].switchTransition = true;
|
|
|
|
|
heaterStates[switchNr].target = HeaterHandler::SwitchState::OFF;
|
|
|
|
|
heaterStates[htrCtx.switchNr].switchTransition = true;
|
|
|
|
|
heaterStates[htrCtx.switchNr].target = HeaterHandler::SwitchState::OFF;
|
|
|
|
|
thermalStates[thermalComponent].heating = false;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
// 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(switchNr, redSwitchNr, true, tempLimit);
|
|
|
|
|
if (sensorTemp >= tempLimit.cutOffLimit) {
|
|
|
|
|
bool tooHighHandlerAlreadyCalled = heaterCtrlCheckUpperLimits(htrCtx);
|
|
|
|
|
if (sensorTemp >= htrCtx.tempLimit.cutOffLimit) {
|
|
|
|
|
componentAboveCutOffLimit = true;
|
|
|
|
|
if (not tooHighHandlerAlreadyCalled) {
|
|
|
|
|
heaterCtrlTempTooHighHandler(switchNr, redSwitchNr, "CutOff-Limit");
|
|
|
|
|
heaterCtrlTempTooHighHandler(htrCtx, "CutOff-Limit");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
@ -1629,21 +1663,18 @@ void ThermalController::checkLimitsAndCtrlHeater(heater::Switchers switchNr,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool ThermalController::heaterCtrlCheckUpperLimits(heater::Switchers switchNr,
|
|
|
|
|
heater::Switchers redSwitchNr,
|
|
|
|
|
bool doHeaterHandling,
|
|
|
|
|
const TempLimits& tempLimit) {
|
|
|
|
|
if (sensorTemp >= tempLimit.nopUpperLimit) {
|
|
|
|
|
bool ThermalController::heaterCtrlCheckUpperLimits(HeaterContext& htrCtx) {
|
|
|
|
|
if (sensorTemp >= htrCtx.tempLimit.nopUpperLimit) {
|
|
|
|
|
componentAboveUpperLimit = true;
|
|
|
|
|
if (doHeaterHandling) {
|
|
|
|
|
heaterCtrlTempTooHighHandler(switchNr, redSwitchNr, "NOP-Limit");
|
|
|
|
|
if (htrCtx.doHeaterHandling) {
|
|
|
|
|
heaterCtrlTempTooHighHandler(htrCtx, "NOP-Limit");
|
|
|
|
|
}
|
|
|
|
|
overHeatEventToTrigger = ThermalComponentIF::COMPONENT_TEMP_OOL_HIGH;
|
|
|
|
|
return true;
|
|
|
|
|
} else if (sensorTemp >= tempLimit.opUpperLimit) {
|
|
|
|
|
} else if (sensorTemp >= htrCtx.tempLimit.opUpperLimit) {
|
|
|
|
|
componentAboveUpperLimit = true;
|
|
|
|
|
if (doHeaterHandling) {
|
|
|
|
|
heaterCtrlTempTooHighHandler(switchNr, redSwitchNr, "OP-Limit");
|
|
|
|
|
if (htrCtx.doHeaterHandling) {
|
|
|
|
|
heaterCtrlTempTooHighHandler(htrCtx, "OP-Limit");
|
|
|
|
|
}
|
|
|
|
|
overHeatEventToTrigger = ThermalComponentIF::COMPONENT_TEMP_HIGH;
|
|
|
|
|
return true;
|
|
|
|
|