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