eive/eive-obsw
eive/eive-obsw
13
4
Fork 0
Code Issues 4 Pull Requests 1 Releases 121 Wiki Activity

.
Some checks failed
EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit
Details

Browse Source
This commit is contained in:
Irini Kosmidou 2023-02-06 17:10:09 +01:00
parent 64e1355e06
commit 77aff26204
2 changed files with 101 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

183
mission/controller/ThermalController.cpp
View File

@ -58,7 +58,9 @@ ThermalController::ThermalController(object_id_t objectId, HeaterHandler& heater
susSet8(objects::SUS_8_R_LOC_XBYBZB_PT_YB), susSet8(objects::SUS_8_R_LOC_XBYBZB_PT_YB),
susSet9(objects::SUS_9_R_LOC_XBYBZB_PT_YF), susSet9(objects::SUS_9_R_LOC_XBYBZB_PT_YF),
susSet10(objects::SUS_10_N_LOC_XMYBZF_PT_ZF), susSet10(objects::SUS_10_N_LOC_XMYBZF_PT_ZF),
susSet11(objects::SUS_11_R_LOC_XBYMZB_PT_ZB) {} susSet11(objects::SUS_11_R_LOC_XBYMZB_PT_ZB) {
resetSensorsArray();
}
ReturnValue_t ThermalController::initialize() { ReturnValue_t ThermalController::initialize() {
auto result = ExtendedControllerBase::initialize(); auto result = ExtendedControllerBase::initialize();
@ -113,7 +115,7 @@ void ThermalController::performControlOperation() {
ctrlRw(); ctrlRw();
ctrlStr(); ctrlStr();
ctrlIfBoard(); ctrlIfBoard();
ctrlTcsBoard(); ctrlAcsBoard();
ctrlObc(); ctrlObc();
ctrlObcIfBoard(); ctrlObcIfBoard();
ctrlSBandTransceiver(); ctrlSBandTransceiver();
@ -984,19 +986,17 @@ void ThermalController::copyDevices() {
void ThermalController::ctrlAcsBoard() { void ThermalController::ctrlAcsBoard() {
heater::Switchers switchNr = heater::HEATER_2_ACS_BRD; heater::Switchers switchNr = heater::HEATER_2_ACS_BRD;
heater::Switchers redSwitchNr = heater::HEATER_0_OBC_BRD; heater::Switchers redSwitchNr = heater::HEATER_0_OBC_BRD;
chooseHeater(switchNr, redSwitchNr);
if (heaterAvailable) { if (chooseHeater(switchNr, redSwitchNr)) {
// A side // A side
chooseOf4Sensors(switchNr, deviceTemperatures.gyro0SideA, deviceTemperatures.mgm0SideA, if (chooseOf4Sensors(switchNr, deviceTemperatures.gyro0SideA, deviceTemperatures.mgm0SideA,
deviceTemperatures.gyro1SideA, sensorTemperatures.sensor_tcs_board); deviceTemperatures.gyro1SideA, sensorTemperatures.sensor_tcs_board)) {
if (sensorTempAvailable) {
ctrlHeater(switchNr, redSwitchNr, &acsBoardLimits); ctrlHeater(switchNr, redSwitchNr, &acsBoardLimits);
return;
} }
// B side // B side
chooseOf4Sensors(switchNr, deviceTemperatures.gyro2SideB, deviceTemperatures.mgm2SideB, if (chooseOf4Sensors(switchNr, deviceTemperatures.gyro2SideB, deviceTemperatures.mgm2SideB,
deviceTemperatures.gyro3SideB, sensorTemperatures.sensor_tcs_board); deviceTemperatures.gyro3SideB, sensorTemperatures.sensor_tcs_board)) {
if (sensorTempAvailable) {
ctrlHeater(switchNr, redSwitchNr, &acsBoardLimits); ctrlHeater(switchNr, redSwitchNr, &acsBoardLimits);
} }
} }
@ -1011,10 +1011,8 @@ void ThermalController::ctrlMgt() {
heater::Switchers switchNr = heater::HEATER_2_ACS_BRD; heater::Switchers switchNr = heater::HEATER_2_ACS_BRD;
heater::Switchers redSwitchNr = heater::HEATER_3_PCDU_PDU; heater::Switchers redSwitchNr = heater::HEATER_3_PCDU_PDU;
chooseHeater(switchNr, redSwitchNr); if (chooseHeater(switchNr, redSwitchNr)) {
bool sensorTempAvailable = true;
if (heaterAvailable) {
sensorTempAvailable = true;
if (sensorTemperatures.sensor_magnettorquer.isValid()) { if (sensorTemperatures.sensor_magnettorquer.isValid()) {
sensorTemp = sensorTemperatures.sensor_magnettorquer.value; sensorTemp = sensorTemperatures.sensor_magnettorquer.value;
@ -1043,7 +1041,7 @@ void ThermalController::ctrlRw() {
if (heaterHandler.getHealth(switchNr) == HasHealthIF::HEALTHY) { if (heaterHandler.getHealth(switchNr) == HasHealthIF::HEALTHY) {
// RW1 // RW1
sensorTempAvailable = true; bool sensorTempAvailable = true;
if (sensorTemperatures.sensor_rw1.isValid()) { if (sensorTemperatures.sensor_rw1.isValid()) {
sensorTemp = sensorTemperatures.sensor_rw1.value; sensorTemp = sensorTemperatures.sensor_rw1.value;
@ -1081,7 +1079,7 @@ void ThermalController::ctrlRw() {
sensorTempAvailable = false; sensorTempAvailable = false;
} }
if (sensorTempAvailable) { if (sensorTempAvailable) {
ctrlHeater(switchNr, redSwitchNr, &rwLimits); ctrlHeater(switchNr, redSwitchNr, rwLimits);
} }
// RW3 // RW3
sensorTempAvailable = true; sensorTempAvailable = true;
@ -1101,7 +1099,7 @@ void ThermalController::ctrlRw() {
sensorTempAvailable = false; sensorTempAvailable = false;
} }
if (sensorTempAvailable) { if (sensorTempAvailable) {
ctrlHeater(switchNr, redSwitchNr, &rwLimits); ctrlHeater(switchNr, redSwitchNr, rwLimits);
} }
// RW4 // RW4
sensorTempAvailable = true; sensorTempAvailable = true;
@ -1121,34 +1119,50 @@ void ThermalController::ctrlRw() {
sensorTempAvailable = false; sensorTempAvailable = false;
} }
if (sensorTempAvailable) { if (sensorTempAvailable) {
ctrlHeater(switchNr, redSwitchNr, &rwLimits); ctrlHeater(switchNr, redSwitchNr, rwLimits);
} }
} }
} }
void ThermalController::ctrlStr() { void ThermalController::ctrlStr() {
ctrlComponentTemperature(heater::HEATER_5_STR, heater::HEATER_6_DRO, sensors[0].first = sensorTemperatures.sensor_startracker.isValid();
sensorTemperatures.sensor_startracker, deviceTemperatures.startracker, sensors[0].second = sensorTemperatures.sensor_startracker.value;
sensorTemperatures.sensor_dro, &strLimits); sensors[1].first = deviceTemperatures.startracker.isValid();
sensors[1].second = deviceTemperatures.startracker.value;
sensors[2].first = sensorTemperatures.sensor_dro.isValid();
sensors[2].second = sensorTemperatures.sensor_dro.value;
numSensors = 3;
ctrlComponentTemperature(heater::HEATER_5_STR, heater::HEATER_6_DRO,
strLimits);
} }
void ThermalController::ctrlIfBoard() { void ThermalController::ctrlIfBoard() {
ctrlComponentTemperature(heater::HEATER_2_ACS_BRD, heater::HEATER_3_PCDU_PDU, sensors[0].first = sensorTemperatures.tmp1075IfBrd.isValid();
sensorTemperatures.tmp1075IfBrd, sensorTemperatures.sensor_magnettorquer, sensors[0].second = sensorTemperatures.tmp1075IfBrd.value;
deviceTemperatures.mgm2SideB, &ifBoardLimits); sensors[1].first = sensorTemperatures.sensor_magnettorquer.isValid();
sensors[1].second = sensorTemperatures.sensor_magnettorquer.value;
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);
} }
void ThermalController::ctrlTcsBoard() { void ThermalController::ctrlTcsBoard() {
ctrlComponentTemperature(heater::HEATER_0_OBC_BRD, heater::HEATER_2_ACS_BRD, sensors[0].first = sensorTemperatures.sensor_tcs_board.isValid();
sensorTemperatures.sensor_tcs_board, sensorTemperatures.tmp1075Tcs0, sensors[0].second = sensorTemperatures.sensor_tcs_board.value;
sensorTemperatures.tmp1075Tcs1, &tcsBoardLimits); sensors[1].first = sensorTemperatures.tmp1075Tcs0.isValid();
sensors[1].second = sensorTemperatures.tmp1075Tcs0.value;
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);
} }
void ThermalController::ctrlObc() { void ThermalController::ctrlObc() {
ctrlComponentTemperature(heater::HEATER_0_OBC_BRD, heater::HEATER_2_ACS_BRD, ctrlComponentTemperature(heater::HEATER_0_OBC_BRD, heater::HEATER_2_ACS_BRD,
deviceTemperatures.q7s, sensorTemperatures.tmp1075Tcs1, deviceTemperatures.q7s, sensorTemperatures.tmp1075Tcs1,
sensorTemperatures.tmp1075Tcs0, &obcLimits); sensorTemperatures.tmp1075Tcs0, &obcLimits);
if (componentOverheating) { if (componentAboveCutOffLimit) {
triggerEvent(OBC_OVERHEATING); triggerEvent(OBC_OVERHEATING);
} }
} }
@ -1163,25 +1177,23 @@ void ThermalController::ctrlSBandTransceiver() {
ctrlComponentTemperature(heater::HEATER_7_S_BAND, heater::HEATER_4_CAMERA, ctrlComponentTemperature(heater::HEATER_7_S_BAND, heater::HEATER_4_CAMERA,
deviceTemperatures.syrlinksPowerAmplifier, deviceTemperatures.syrlinksPowerAmplifier,
deviceTemperatures.syrlinksBasebandBoard, deviceTemperatures.syrlinksBasebandBoard,
sensorTemperatures.sensor_4k_camera, &sBandTransceiverLimits); sensorTemperatures.sensor_4k_camera, sBandTransceiverLimits);
if (componentOverheating) { if (componentAboveCutOffLimit) {
triggerEvent(SYRLINKS_OVERHEATING); triggerEvent(SYRLINKS_OVERHEATING);
} }
} }
void ThermalController::ctrlPcduP60Board() { void ThermalController::ctrlPcduP60Board() {
ctrlComponentTemperature(heater::HEATER_3_PCDU_PDU, heater::HEATER_2_ACS_BRD, ctrlComponentTemperature(heater::HEATER_3_PCDU_PDU, heater::HEATER_2_ACS_BRD,
deviceTemperatures.temp1P60dock, deviceTemperatures.temp2P60dock, deviceTemperatures.temp1P60dock, deviceTemperatures.temp2P60dock,
deviceTemperatures.temp2P60dock, &pcduP60BoardLimits); deviceTemperatures.temp2P60dock, pcduP60BoardLimits);
} }
void ThermalController::ctrlPcduAcu() { void ThermalController::ctrlPcduAcu() {
heater::Switchers switchNr = heater::HEATER_3_PCDU_PDU; heater::Switchers switchNr = heater::HEATER_3_PCDU_PDU;
heater::Switchers redSwitchNr = heater::HEATER_2_ACS_BRD; heater::Switchers redSwitchNr = heater::HEATER_2_ACS_BRD;
chooseHeater(switchNr, redSwitchNr); if (chooseHeater(switchNr, redSwitchNr)) {
bool sensorTempAvailable = true;
if (heaterAvailable) {
sensorTempAvailable = true;
if (deviceTemperatures.acu.value[0] != INVALID_TEMPERATURE) { if (deviceTemperatures.acu.value[0] != INVALID_TEMPERATURE) {
sensorTemp = deviceTemperatures.acu.value[0]; sensorTemp = deviceTemperatures.acu.value[0];
@ -1214,15 +1226,12 @@ void ThermalController::ctrlPlPcduBoard() {
heater::Switchers switchNr = heater::HEATER_3_PCDU_PDU; heater::Switchers switchNr = heater::HEATER_3_PCDU_PDU;
heater::Switchers redSwitchNr = heater::HEATER_2_ACS_BRD; heater::Switchers redSwitchNr = heater::HEATER_2_ACS_BRD;
chooseHeater(switchNr, redSwitchNr); if (chooseHeater(switchNr, redSwitchNr)) {
if (chooseOf4Sensors(switchNr, sensorTemperatures.tmp1075PlPcdu0, sensorTemperatures.tmp1075PlPcdu1,
if (heaterAvailable) { deviceTemperatures.adcPayloadPcdu,
chooseOf4Sensors(switchNr, sensorTemperatures.tmp1075PlPcdu0, sensorTemperatures.tmp1075PlPcdu1, sensorTemperatures.sensor_plpcdu_heatspreader)) {
deviceTemperatures.adcPayloadPcdu,
sensorTemperatures.sensor_plpcdu_heatspreader);
if (sensorTempAvailable) {
ctrlHeater(switchNr, redSwitchNr, &plPcduBoardLimits); ctrlHeater(switchNr, redSwitchNr, &plPcduBoardLimits);
if (componentOverheating) { if (componentAboveCutOffLimit) {
triggerEvent(PLPCDU_OVERHEATING, switchNr); triggerEvent(PLPCDU_OVERHEATING, switchNr);
} }
} }
@ -1233,8 +1242,8 @@ void ThermalController::ctrlPlocMissionBoard() {
ctrlComponentTemperature(heater::HEATER_1_PLOC_PROC_BRD, heater::HEATER_0_OBC_BRD, ctrlComponentTemperature(heater::HEATER_1_PLOC_PROC_BRD, heater::HEATER_0_OBC_BRD,
sensorTemperatures.sensor_ploc_heatspreader, sensorTemperatures.sensor_ploc_heatspreader,
sensorTemperatures.sensor_ploc_missionboard, sensorTemperatures.sensor_ploc_missionboard,
sensorTemperatures.sensor_dac_heatspreader, &plocMissionBoardLimits); sensorTemperatures.sensor_dac_heatspreader, plocMissionBoardLimits);
if (componentOverheating) { if (componentAboveCutOffLimit) {
triggerEvent(PLOC_OVERHEATING); triggerEvent(PLOC_OVERHEATING);
} }
} }
@ -1243,7 +1252,7 @@ void ThermalController::ctrlPlocProcessingBoard() {
ctrlComponentTemperature(heater::HEATER_1_PLOC_PROC_BRD, heater::HEATER_0_OBC_BRD, ctrlComponentTemperature(heater::HEATER_1_PLOC_PROC_BRD, heater::HEATER_0_OBC_BRD,
sensorTemperatures.sensor_ploc_missionboard, sensorTemperatures.sensor_ploc_missionboard,
sensorTemperatures.sensor_ploc_heatspreader, sensorTemperatures.sensor_ploc_heatspreader,
sensorTemperatures.sensor_dac_heatspreader, &plocProcessingBoardLimits); sensorTemperatures.sensor_dac_heatspreader, plocProcessingBoardLimits);
} }
void ThermalController::ctrlDac() { void ThermalController::ctrlDac() {
@ -1287,7 +1296,7 @@ void ThermalController::ctrlHpa() {
ctrlComponentTemperature(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA, ctrlComponentTemperature(heater::HEATER_6_DRO, heater::HEATER_4_CAMERA,
sensorTemperatures.sensor_hpa, sensorTemperatures.sensor_x8, sensorTemperatures.sensor_hpa, sensorTemperatures.sensor_x8,
sensorTemperatures.sensor_mpa, &hpaLimits); sensorTemperatures.sensor_mpa, &hpaLimits);
if (componentOverheating) { if (componentAboveCutOffLimit) {
triggerEvent(HPA_OVERHEATING); triggerEvent(HPA_OVERHEATING);
} }
} }
@ -1299,24 +1308,24 @@ void ThermalController::ctrlScexBoard() {
} }
void ThermalController::ctrlHeater(heater::Switchers switchNr, heater::Switchers redSwitchNr, void ThermalController::ctrlHeater(heater::Switchers switchNr, heater::Switchers redSwitchNr,
struct TempLimits* tempLimit) { struct TempLimits& tempLimit) {
componentOverheating = false; componentAboveCutOffLimit = false;
// Heater off // Heater off
if (not heaterHandler.checkSwitchState(switchNr)) { if (not heaterHandler.checkSwitchState(switchNr)) {
if (sensorTemp < (*tempLimit).opLowerLimit) { if (sensorTemp < tempLimit.opLowerLimit) {
heaterHandler.switchHeater(switchNr, HeaterHandler::SwitchState::ON); heaterHandler.switchHeater(switchNr, HeaterHandler::SwitchState::ON);
sif::info << "ThermalController::ctrlHeater: Heater" << switchNr << " ON" << std::endl; sif::info << "ThermalController::ctrlHeater: Heater" << switchNr << " ON" << std::endl;
} }
// Heater on // Heater on
} else if (heaterHandler.checkSwitchState(switchNr)) { } else if (heaterHandler.checkSwitchState(switchNr)) {
if (sensorTemp >= (*tempLimit).opLowerLimit + TEMP_OFFSET) { if (sensorTemp >= tempLimit.opLowerLimit + TEMP_OFFSET) {
heaterHandler.switchHeater(switchNr, HeaterHandler::SwitchState::OFF); heaterHandler.switchHeater(switchNr, HeaterHandler::SwitchState::OFF);
sif::info << "ThermalController::ctrlHeater: Heater" << switchNr << " OFF" << std::endl; sif::info << "ThermalController::ctrlHeater: Heater" << switchNr << " OFF" << std::endl;
} }
} else if (not redSwitchNrInUse) { } else if (not redSwitchNrInUse) {
if (heaterHandler.checkSwitchState(redSwitchNr)) { if (heaterHandler.checkSwitchState(redSwitchNr)) {
if (sensorTemp >= (*tempLimit).cutOffLimit) { if (sensorTemp >= tempLimit.cutOffLimit) {
componentOverheating = true; componentAboveCutOffLimit = true;
heaterHandler.switchHeater(redSwitchNr, HeaterHandler::SwitchState::OFF); heaterHandler.switchHeater(redSwitchNr, HeaterHandler::SwitchState::OFF);
sif::info << "ThermalController::ctrlHeater: Heater" << redSwitchNr << " OFF" << std::endl; sif::info << "ThermalController::ctrlHeater: Heater" << redSwitchNr << " OFF" << std::endl;
} }
@ -1324,8 +1333,8 @@ void ThermalController::ctrlHeater(heater::Switchers switchNr, heater::Switchers
} }
} }
void ThermalController::chooseHeater(heater::Switchers& switchNr, heater::Switchers redSwitchNr) { bool ThermalController::chooseHeater(heater::Switchers& switchNr, heater::Switchers redSwitchNr) {
heaterAvailable = true; bool heaterAvailable = true;
if (heaterHandler.getHealth(switchNr) != HasHealthIF::HEALTHY) { if (heaterHandler.getHealth(switchNr) != HasHealthIF::HEALTHY) {
if (heaterHandler.getHealth(redSwitchNr) == HasHealthIF::HEALTHY) { if (heaterHandler.getHealth(redSwitchNr) == HasHealthIF::HEALTHY) {
@ -1338,63 +1347,41 @@ void ThermalController::chooseHeater(heater::Switchers& switchNr, heater::Switch
} else { } else {
redSwitchNrInUse = false; redSwitchNrInUse = false;
} }
return heaterAvailable;
} }
void ThermalController::chooseSensor(heater::Switchers switchNr, const lp_float_t& sensor1, bool ThermalController::selectAndReadSensorTemp(heater::Switchers switchNr) {
const lp_float_t& sensor2, const lp_float_t& sensor3) { for(unsigned i= 0; i<numSensors; i++) {
sensorTempAvailable = true; if (sensors[i].first and sensors[i].second != INVALID_TEMPERATURE) {
sensorTemp = sensors[i].second;
if (sensor1.isValid() and sensor1.value != INVALID_TEMPERATURE) { return true;
sensorTemp = sensor1.value;
} else if (sensor2.isValid() and sensor2.value != INVALID_TEMPERATURE) {
sensorTemp = sensor2.value;
} else if (sensor3.isValid() and sensor3.value != INVALID_TEMPERATURE) {
sensorTemp = sensor3.value;
} else {
if (heaterHandler.checkSwitchState(switchNr)) {
heaterHandler.switchHeater(switchNr, HeaterHandler::SwitchState::OFF);
sif::info << "ThermalController::ctrlHeater: Heater" << switchNr << " OFF" << std::endl;
} }
triggerEvent(NO_VALID_SENSOR_TEMPERATURE, switchNr);
sensorTempAvailable = false;
} }
triggerEvent(NO_VALID_SENSOR_TEMPERATURE, switchNr);
return false;
} }
void ThermalController::ctrlComponentTemperature(heater::Switchers switchNr, void ThermalController::ctrlComponentTemperature(heater::Switchers switchNr,
heater::Switchers redSwitchNr, heater::Switchers redSwitchNr,
const lp_float_t& sensor1, TempLimits& tempLimit) {
const lp_float_t& sensor2,
const lp_float_t& sensor3, TempLimits* tempLimit) {
chooseHeater(switchNr, redSwitchNr);
if (heaterAvailable) { if (selectAndReadSensorTemp(switchNr)) {
chooseSensor(switchNr, sensor1, sensor2, sensor3); if (chooseHeater(switchNr, redSwitchNr)) {
if (sensorTempAvailable) {
ctrlHeater(switchNr, redSwitchNr, tempLimit); ctrlHeater(switchNr, redSwitchNr, tempLimit);
} }
}
}
void ThermalController::chooseOf4Sensors(heater::Switchers switchNr, const lp_float_t& sensor1,
const lp_float_t& sensor2, const lp_float_t& sensor3,
const lp_float_t& sensor4) {
sensorTempAvailable = true;
if (sensor1.isValid() and sensor1.value != INVALID_TEMPERATURE) {
sensorTemp = sensor1.value;
} else if (sensor2.isValid() and sensor2.value != INVALID_TEMPERATURE) {
sensorTemp = sensor2.value;
} else if (sensor3.isValid() and sensor3.value != INVALID_TEMPERATURE) {
sensorTemp = sensor3.value;
} else if (sensor4.isValid() and sensor4.value != INVALID_TEMPERATURE) {
sensorTemp = sensor4.value;
} else { } else {
if (heaterHandler.checkSwitchState(switchNr)) { chooseHeater(switchNr, redSwitchNr);
if (heaterHandler.checkSwitchState(switchNr)) {
heaterHandler.switchHeater(switchNr, HeaterHandler::SwitchState::OFF); heaterHandler.switchHeater(switchNr, HeaterHandler::SwitchState::OFF);
sif::info << "ThermalController::ctrlHeater: Heater" << switchNr << " OFF" << std::endl; sif::info << "ThermalController::ctrlHeater: Heater" << switchNr << " OFF" << std::endl;
} }
triggerEvent(NO_VALID_SENSOR_TEMPERATURE, switchNr); }
sensorTempAvailable = false; resetSensorsArray();
}
void ThermalController::resetSensorsArray() {
for(auto& validValuePair:sensors){
validValuePair.first = false;
validValuePair.second = INVALID_TEMPERATURE;
} }
} }

34
mission/controller/ThermalController.h
View File

@ -44,14 +44,14 @@ class ThermalController : public ExtendedControllerBase {
ReturnValue_t initialize() override; ReturnValue_t initialize() override;
protected: protected:
virtual ReturnValue_t handleCommandMessage(CommandMessage* message) override; ReturnValue_t handleCommandMessage(CommandMessage* message) override;
virtual void performControlOperation() override; void performControlOperation() override;
virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap, ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
LocalDataPoolManager& poolManager) override; LocalDataPoolManager& poolManager) override;
virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override; LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
// Mode abstract functions // Mode abstract functions
virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
uint32_t* msToReachTheMode) override; uint32_t* msToReachTheMode) override;
private: private:
@ -144,15 +144,17 @@ class ThermalController : public ExtendedControllerBase {
TempLimits mpaLimits = 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); TempLimits scexBoardLimits = TempLimits(-60.0, -40.0, 80.0, 85.0, 150.0);
float sensorTemp = 0.0; double sensorTemp = INVALID_TEMPERATURE;
bool sensorTempAvailable = true;
bool heaterAvailable = true;
bool redSwitchNrInUse = false; bool redSwitchNrInUse = false;
bool componentOverheating = false; bool componentAboveCutOffLimit = false;
// Initial delay to make sure all pool variables have been initialized their owners // Initial delay to make sure all pool variables have been initialized their owners
Countdown initialCountdown = Countdown(DELAY); Countdown initialCountdown = Countdown(DELAY);
std::array<std::pair<bool, double>, 5> sensors;
uint8_t numSensors = 0;
PoolEntry<float> tmp1075Tcs0 = PoolEntry<float>(10.0); PoolEntry<float> tmp1075Tcs0 = PoolEntry<float>(10.0);
PoolEntry<float> tmp1075Tcs1 = PoolEntry<float>(10.0); PoolEntry<float> tmp1075Tcs1 = PoolEntry<float>(10.0);
PoolEntry<float> tmp1075PlPcdu0 = PoolEntry<float>(10.0); PoolEntry<float> tmp1075PlPcdu0 = PoolEntry<float>(10.0);
@ -161,20 +163,16 @@ class ThermalController : public ExtendedControllerBase {
static constexpr dur_millis_t MUTEX_TIMEOUT = 50; static constexpr dur_millis_t MUTEX_TIMEOUT = 50;
void resetSensorsArray();
void copySensors(); void copySensors();
void copySus(); void copySus();
void copyDevices(); void copyDevices();
void ctrlComponentTemperature(heater::Switchers switchNr, heater::Switchers redSwitchNr, void ctrlComponentTemperature(heater::Switchers switchNr, heater::Switchers redSwitchNr,
const lp_float_t& sensor1, const lp_float_t& sensor2, TempLimits& tempLimit);
const lp_float_t& sensor3, TempLimits* tempLimit); void ctrlHeater(heater::Switchers switchNr, heater::Switchers redSwitchNr, TempLimits& tempLimit);
void ctrlHeater(heater::Switchers switchNr, heater::Switchers redSwitchNr, TempLimits* tempLimit); bool chooseHeater(heater::Switchers& switchNr, heater::Switchers redSwitchNr);
void chooseHeater(heater::Switchers& switchNr, heater::Switchers redSwitchNr); bool selectAndReadSensorTemp(heater::Switchers switchNr);
void chooseSensor(heater::Switchers switchNr, const lp_float_t& sensor1,
const lp_float_t& sensor2, const lp_float_t& sensor3);
void chooseOf4Sensors(heater::Switchers switchNr, const lp_float_t& sensor1,
const lp_float_t& sensor2, const lp_float_t& sensor3,
const lp_float_t& sensor4);
void ctrlAcsBoard(); void ctrlAcsBoard();
void ctrlMgt(); void ctrlMgt();