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),
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;
}
}

34
mission/controller/ThermalController.h
View File

@ -44,14 +44,14 @@ class ThermalController : public ExtendedControllerBase {
ReturnValue_t initialize() override;
protected:
virtual ReturnValue_t handleCommandMessage(CommandMessage* message) override;
virtual void performControlOperation() override;
virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
ReturnValue_t handleCommandMessage(CommandMessage* message) override;
void performControlOperation() override;
ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
LocalDataPoolManager& poolManager) override;
virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
// 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;
private:
@ -144,15 +144,17 @@ class ThermalController : public ExtendedControllerBase {
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);
float sensorTemp = 0.0;
bool sensorTempAvailable = true;
bool heaterAvailable = true;
double sensorTemp = INVALID_TEMPERATURE;
bool redSwitchNrInUse = false;
bool componentOverheating = false;
bool componentAboveCutOffLimit = false;
// Initial delay to make sure all pool variables have been initialized their owners
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> tmp1075Tcs1 = 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;
void resetSensorsArray();
void copySensors();
void copySus();
void copyDevices();
void ctrlComponentTemperature(heater::Switchers switchNr, heater::Switchers redSwitchNr,
const lp_float_t& sensor1, const lp_float_t& sensor2,
const lp_float_t& sensor3, TempLimits* tempLimit);
void ctrlHeater(heater::Switchers switchNr, heater::Switchers redSwitchNr, TempLimits* tempLimit);
void chooseHeater(heater::Switchers& switchNr, heater::Switchers redSwitchNr);
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);
TempLimits& tempLimit);
void ctrlHeater(heater::Switchers switchNr, heater::Switchers redSwitchNr, TempLimits& tempLimit);
bool chooseHeater(heater::Switchers& switchNr, heater::Switchers redSwitchNr);
bool selectAndReadSensorTemp(heater::Switchers switchNr);
void ctrlAcsBoard();
void ctrlMgt();