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

v1.10.0 #220

Merged
meierj merged 592 commits from develop into main 2022-04-22 07:42:20 +02:00
Conversation 0 Commits 592 Files Changed 218 +638 -489
9 changed files with 638 additions and 489 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 49e58b2365 - Show all commits

5
bsp_q7s/core/ObjectFactory.cpp
View File

@ -1198,8 +1198,9 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF*
q7s::SPI_DEFAULT_DEV, plpcdu::MAX_ADC_REPLY_SIZE,
spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
// Create device handler components
auto plPcduHandler = new PayloadPcduHandler(objects::PLPCDU_HANDLER, objects::SPI_COM_IF,
spiCookie, gpioComIF, SdCardManager::instance(), false);
auto plPcduHandler =
new PayloadPcduHandler(objects::PLPCDU_HANDLER, objects::SPI_COM_IF, spiCookie, gpioComIF,
SdCardManager::instance(), false);
spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler);
static_cast<void>(plPcduHandler);
#if OBSW_TEST_PL_PCDU == 1

2
bsp_q7s/memory/SdCardManager.cpp
View File

@ -1,6 +1,6 @@
#include <fsfw/ipc/MutexGuard.h>
#include "SdCardManager.h"
#include <fsfw/ipc/MutexGuard.h>
#include <unistd.h>
#include <cstring>

8
bsp_q7s/memory/SdCardManager.h
View File

@ -10,12 +10,12 @@
#include <string>
#include <utility>
#include "mission/memory/definitions.h"
#include "mission/memory/SdCardMountedIF.h"
#include "events/subsystemIdRanges.h"
#include "fsfw/events/Event.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
#include "fsfw_hal/linux/CommandExecutor.h"
#include "mission/memory/SdCardMountedIF.h"
#include "mission/memory/definitions.h"
#include "returnvalues/classIds.h"
class MutexIF;
@ -24,11 +24,11 @@ class MutexIF;
* @brief Manages handling of SD cards like switching them on or off or getting the current
* state
*/
class SdCardManager: public SystemObject, public SdCardMountedIF {
class SdCardManager : public SystemObject, public SdCardMountedIF {
friend class SdCardAccess;
public:
using mountInitCb = ReturnValue_t (*) (void *args);
using mountInitCb = ReturnValue_t (*)(void* args);
enum class Operations { SWITCHING_ON, SWITCHING_OFF, MOUNTING, UNMOUNTING, IDLE };

310
linux/fsfwconfig/events/translateEvents.cpp
View File

@ -159,313 +159,313 @@ const char *I_MPA_OUT_OF_BOUNDS_STRING = "I_MPA_OUT_OF_BOUNDS";
const char *U_HPA_OUT_OF_BOUNDS_STRING = "U_HPA_OUT_OF_BOUNDS";
const char *I_HPA_OUT_OF_BOUNDS_STRING = "I_HPA_OUT_OF_BOUNDS";
const char * translateEvents(Event event) {
switch( (event & 0xffff) ) {
case(2200):
const char *translateEvents(Event event) {
switch ((event & 0xffff)) {
case (2200):
return STORE_SEND_WRITE_FAILED_STRING;
case(2201):
case (2201):
return STORE_WRITE_FAILED_STRING;
case(2202):
case (2202):
return STORE_SEND_READ_FAILED_STRING;
case(2203):
case (2203):
return STORE_READ_FAILED_STRING;
case(2204):
case (2204):
return UNEXPECTED_MSG_STRING;
case(2205):
case (2205):
return STORING_FAILED_STRING;
case(2206):
case (2206):
return TM_DUMP_FAILED_STRING;
case(2207):
case (2207):
return STORE_INIT_FAILED_STRING;
case(2208):
case (2208):
return STORE_INIT_EMPTY_STRING;
case(2209):
case (2209):
return STORE_CONTENT_CORRUPTED_STRING;
case(2210):
case (2210):
return STORE_INITIALIZE_STRING;
case(2211):
case (2211):
return INIT_DONE_STRING;
case(2212):
case (2212):
return DUMP_FINISHED_STRING;
case(2213):
case (2213):
return DELETION_FINISHED_STRING;
case(2214):
case (2214):
return DELETION_FAILED_STRING;
case(2215):
case (2215):
return AUTO_CATALOGS_SENDING_FAILED_STRING;
case(2600):
case (2600):
return GET_DATA_FAILED_STRING;
case(2601):
case (2601):
return STORE_DATA_FAILED_STRING;
case(2800):
case (2800):
return DEVICE_BUILDING_COMMAND_FAILED_STRING;
case(2801):
case (2801):
return DEVICE_SENDING_COMMAND_FAILED_STRING;
case(2802):
case (2802):
return DEVICE_REQUESTING_REPLY_FAILED_STRING;
case(2803):
case (2803):
return DEVICE_READING_REPLY_FAILED_STRING;
case(2804):
case (2804):
return DEVICE_INTERPRETING_REPLY_FAILED_STRING;
case(2805):
case (2805):
return DEVICE_MISSED_REPLY_STRING;
case(2806):
case (2806):
return DEVICE_UNKNOWN_REPLY_STRING;
case(2807):
case (2807):
return DEVICE_UNREQUESTED_REPLY_STRING;
case(2808):
case (2808):
return INVALID_DEVICE_COMMAND_STRING;
case(2809):
case (2809):
return MONITORING_LIMIT_EXCEEDED_STRING;
case(2810):
case (2810):
return MONITORING_AMBIGUOUS_STRING;
case(2811):
case (2811):
return DEVICE_WANTS_HARD_REBOOT_STRING;
case(4201):
case (4201):
return FUSE_CURRENT_HIGH_STRING;
case(4202):
case (4202):
return FUSE_WENT_OFF_STRING;
case(4204):
case (4204):
return POWER_ABOVE_HIGH_LIMIT_STRING;
case(4205):
case (4205):
return POWER_BELOW_LOW_LIMIT_STRING;
case(4300):
case (4300):
return SWITCH_WENT_OFF_STRING;
case(5000):
case (5000):
return HEATER_ON_STRING;
case(5001):
case (5001):
return HEATER_OFF_STRING;
case(5002):
case (5002):
return HEATER_TIMEOUT_STRING;
case(5003):
case (5003):
return HEATER_STAYED_ON_STRING;
case(5004):
case (5004):
return HEATER_STAYED_OFF_STRING;
case(5200):
case (5200):
return TEMP_SENSOR_HIGH_STRING;
case(5201):
case (5201):
return TEMP_SENSOR_LOW_STRING;
case(5202):
case (5202):
return TEMP_SENSOR_GRADIENT_STRING;
case(5901):
case (5901):
return COMPONENT_TEMP_LOW_STRING;
case(5902):
case (5902):
return COMPONENT_TEMP_HIGH_STRING;
case(5903):
case (5903):
return COMPONENT_TEMP_OOL_LOW_STRING;
case(5904):
case (5904):
return COMPONENT_TEMP_OOL_HIGH_STRING;
case(5905):
case (5905):
return TEMP_NOT_IN_OP_RANGE_STRING;
case(7101):
case (7101):
return FDIR_CHANGED_STATE_STRING;
case(7102):
case (7102):
return FDIR_STARTS_RECOVERY_STRING;
case(7103):
case (7103):
return FDIR_TURNS_OFF_DEVICE_STRING;
case(7201):
case (7201):
return MONITOR_CHANGED_STATE_STRING;
case(7202):
case (7202):
return VALUE_BELOW_LOW_LIMIT_STRING;
case(7203):
case (7203):
return VALUE_ABOVE_HIGH_LIMIT_STRING;
case(7204):
case (7204):
return VALUE_OUT_OF_RANGE_STRING;
case(7400):
case (7400):
return CHANGING_MODE_STRING;
case(7401):
case (7401):
return MODE_INFO_STRING;
case(7402):
case (7402):
return FALLBACK_FAILED_STRING;
case(7403):
case (7403):
return MODE_TRANSITION_FAILED_STRING;
case(7404):
case (7404):
return CANT_KEEP_MODE_STRING;
case(7405):
case (7405):
return OBJECT_IN_INVALID_MODE_STRING;
case(7406):
case (7406):
return FORCING_MODE_STRING;
case(7407):
case (7407):
return MODE_CMD_REJECTED_STRING;
case(7506):
case (7506):
return HEALTH_INFO_STRING;
case(7507):
case (7507):
return CHILD_CHANGED_HEALTH_STRING;
case(7508):
case (7508):
return CHILD_PROBLEMS_STRING;
case(7509):
case (7509):
return OVERWRITING_HEALTH_STRING;
case(7510):
case (7510):
return TRYING_RECOVERY_STRING;
case(7511):
case (7511):
return RECOVERY_STEP_STRING;
case(7512):
case (7512):
return RECOVERY_DONE_STRING;
case(7900):
case (7900):
return RF_AVAILABLE_STRING;
case(7901):
case (7901):
return RF_LOST_STRING;
case(7902):
case (7902):
return BIT_LOCK_STRING;
case(7903):
case (7903):
return BIT_LOCK_LOST_STRING;
case(7905):
case (7905):
return FRAME_PROCESSING_FAILED_STRING;
case(8900):
case (8900):
return CLOCK_SET_STRING;
case(8901):
case (8901):
return CLOCK_SET_FAILURE_STRING;
case(9700):
case (9700):
return TEST_STRING;
case(10600):
case (10600):
return CHANGE_OF_SETUP_PARAMETER_STRING;
case(10900):
case (10900):
return GPIO_PULL_HIGH_FAILED_STRING;
case(10901):
case (10901):
return GPIO_PULL_LOW_FAILED_STRING;
case(10902):
case (10902):
return SWITCH_ALREADY_ON_STRING;
case(10903):
case (10903):
return SWITCH_ALREADY_OFF_STRING;
case(10904):
case (10904):
return MAIN_SWITCH_TIMEOUT_STRING;
case(11000):
case (11000):
return MAIN_SWITCH_ON_TIMEOUT_STRING;
case(11001):
case (11001):
return MAIN_SWITCH_OFF_TIMEOUT_STRING;
case(11002):
case (11002):
return DEPLOYMENT_FAILED_STRING;
case(11003):
case (11003):
return DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING;
case(11004):
case (11004):
return DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING;
case(11101):
case (11101):
return MEMORY_READ_RPT_CRC_FAILURE_STRING;
case(11102):
case (11102):
return ACK_FAILURE_STRING;
case(11103):
case (11103):
return EXE_FAILURE_STRING;
case(11104):
case (11104):
return CRC_FAILURE_EVENT_STRING;
case(11201):
case (11201):
return SELF_TEST_I2C_FAILURE_STRING;
case(11202):
case (11202):
return SELF_TEST_SPI_FAILURE_STRING;
case(11203):
case (11203):
return SELF_TEST_ADC_FAILURE_STRING;
case(11204):
case (11204):
return SELF_TEST_PWM_FAILURE_STRING;
case(11205):
case (11205):
return SELF_TEST_TC_FAILURE_STRING;
case(11206):
case (11206):
return SELF_TEST_MTM_RANGE_FAILURE_STRING;
case(11207):
case (11207):
return SELF_TEST_COIL_CURRENT_FAILURE_STRING;
case(11208):
case (11208):
return INVALID_ERROR_BYTE_STRING;
case(11301):
case (11301):
return ERROR_STATE_STRING;
case(11501):
case (11501):
return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
case(11502):
case (11502):
return SUPV_ACK_FAILURE_STRING;
case(11503):
case (11503):
return SUPV_EXE_FAILURE_STRING;
case(11504):
case (11504):
return SUPV_CRC_FAILURE_EVENT_STRING;
case(11600):
case (11600):
return ALLOC_FAILURE_STRING;
case(11601):
case (11601):
return REBOOT_SW_STRING;
case(11603):
case (11603):
return REBOOT_HW_STRING;
case(11700):
case (11700):
return UPDATE_FILE_NOT_EXISTS_STRING;
case(11701):
case (11701):
return ACTION_COMMANDING_FAILED_STRING;
case(11702):
case (11702):
return UPDATE_AVAILABLE_FAILED_STRING;
case(11703):
case (11703):
return UPDATE_TRANSFER_FAILED_STRING;
case(11704):
case (11704):
return UPDATE_VERIFY_FAILED_STRING;
case(11705):
case (11705):
return UPDATE_FINISHED_STRING;
case(11800):
case (11800):
return SEND_MRAM_DUMP_FAILED_STRING;
case(11801):
case (11801):
return MRAM_DUMP_FAILED_STRING;
case(11802):
case (11802):
return MRAM_DUMP_FINISHED_STRING;
case(11901):
case (11901):
return INVALID_TC_FRAME_STRING;
case(11902):
case (11902):
return INVALID_FAR_STRING;
case(11903):
case (11903):
return CARRIER_LOCK_STRING;
case(11904):
case (11904):
return BIT_LOCK_PDEC_STRING;
case(12000):
case (12000):
return IMAGE_UPLOAD_FAILED_STRING;
case(12001):
case (12001):
return IMAGE_DOWNLOAD_FAILED_STRING;
case(12002):
case (12002):
return IMAGE_UPLOAD_SUCCESSFUL_STRING;
case(12003):
case (12003):
return IMAGE_DOWNLOAD_SUCCESSFUL_STRING;
case(12004):
case (12004):
return FLASH_WRITE_SUCCESSFUL_STRING;
case(12005):
case (12005):
return FLASH_READ_SUCCESSFUL_STRING;
case(12006):
case (12006):
return FLASH_WRITE_FAILED_STRING;
case(12007):
case (12007):
return FLASH_READ_FAILED_STRING;
case(12008):
case (12008):
return FPGA_DOWNLOAD_SUCCESSFUL_STRING;
case(12009):
case (12009):
return FPGA_DOWNLOAD_FAILED_STRING;
case(12010):
case (12010):
return FPGA_UPLOAD_SUCCESSFUL_STRING;
case(12011):
case (12011):
return FPGA_UPLOAD_FAILED_STRING;
case(12012):
case (12012):
return STR_HELPER_READING_REPLY_FAILED_STRING;
case(12013):
case (12013):
return STR_HELPER_COM_ERROR_STRING;
case(12014):
case (12014):
return STR_HELPER_NO_REPLY_STRING;
case(12015):
case (12015):
return STR_HELPER_DEC_ERROR_STRING;
case(12016):
case (12016):
return POSITION_MISMATCH_STRING;
case(12017):
case (12017):
return STR_HELPER_FILE_NOT_EXISTS_STRING;
case(12018):
case (12018):
return STR_HELPER_SENDING_PACKET_FAILED_STRING;
case(12019):
case (12019):
return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
case(12101):
case (12101):
return NEG_V_OUT_OF_BOUNDS_STRING;
case(12102):
case (12102):
return U_DRO_OUT_OF_BOUNDS_STRING;
case(12103):
case (12103):
return I_DRO_OUT_OF_BOUNDS_STRING;
case(12104):
case (12104):
return U_X8_OUT_OF_BOUNDS_STRING;
case(12105):
case (12105):
return I_X8_OUT_OF_BOUNDS_STRING;
case(12106):
case (12106):
return U_TX_OUT_OF_BOUNDS_STRING;
case(12107):
case (12107):
return I_TX_OUT_OF_BOUNDS_STRING;
case(12108):
case (12108):
return U_MPA_OUT_OF_BOUNDS_STRING;
case(12109):
case (12109):
return I_MPA_OUT_OF_BOUNDS_STRING;
case(12110):
case (12110):
return U_HPA_OUT_OF_BOUNDS_STRING;
case(12111):
case (12111):
return I_HPA_OUT_OF_BOUNDS_STRING;
default:
return "UNKNOWN_EVENT";

2
linux/fsfwconfig/events/translateEvents.h
View File

@ -3,6 +3,6 @@
#include "fsfw/events/Event.h"
const char * translateEvents(Event event);
const char* translateEvents(Event event);
#endif /* FSFWCONFIG_EVENTS_TRANSLATEEVENTS_H_ */

368
mission/devices/PayloadPcduHandler.cpp
View File

@ -39,6 +39,8 @@ void PayloadPcduHandler::doStartUp() {
transitionOk = false;
// We are now in ON mode
startTransition(MODE_NORMAL, 0);
adcCountdown.setTimeout(50);
adcCountdown.resetTimer();
adcState = AdcStates::BOOT_DELAY;
// The ADC can now be read. If the values are not close to zero, we should not allow
// transition
@ -47,6 +49,139 @@ void PayloadPcduHandler::doStartUp() {
}
}
void PayloadPcduHandler::stateMachineToNormal() {
using namespace plpcdu;
if (adcState == AdcStates::BOOT_DELAY) {
if (adcCountdown.hasTimedOut()) {
adcState = AdcStates::SEND_SETUP;
adcCmdExecuted = false;
}
}
if (adcState == AdcStates::SEND_SETUP) {
if (adcCmdExecuted) {
adcState = AdcStates::NORMAL;
setMode(MODE_NORMAL, NORMAL_ADC_ONLY);
adcCountdown.setTimeout(100);
adcCountdown.resetTimer();
adcCmdExecuted = false;
}
}
if (submode == plpcdu::NORMAL_ALL_ON) {
if (state == States::ON_TRANS_ADC_CLOSE_ZERO) {
if (not commandExecuted) {
float waitTime = SSR_TO_DRO_WAIT_TIME;
params.getValue(PlPcduParameter::SSR_TO_DRO_WAIT_TIME_K, waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
commandExecuted = true;
// TODO: For now, skip ADC check
transitionOk = true;
}
// ADC values are ok, 5 seconds have elapsed
if (transitionOk and countdown.hasTimedOut()) {
state = States::ON_TRANS_DRO;
// Now start monitoring for negative voltages instead
monMode = MonitoringMode::NEGATIVE;
commandExecuted = false;
transitionOk = false;
}
}
if (state == States::ON_TRANS_DRO) {
if (not commandExecuted) {
float waitTime = DRO_TO_X8_WAIT_TIME;
params.getValue(PlPcduParameter::DRO_TO_X8_WAIT_TIME_K, waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
// Switch on DRO and start monitoring for negative voltages
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_DRO);
adcCountdown.setTimeout(100);
adcCountdown.resetTimer();
commandExecuted = true;
}
// ADC values are ok, 5 seconds have elapsed
if (transitionOk and countdown.hasTimedOut()) {
state = States::ON_TRANS_X8;
commandExecuted = false;
transitionOk = false;
}
}
if (state == States::ON_TRANS_X8) {
if (not commandExecuted) {
float waitTime = X8_TO_TX_WAIT_TIME;
params.getValue(PlPcduParameter::X8_TO_TX_WAIT_TIME_K, waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
// Switch on X8
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_X8);
adcCountdown.setTimeout(100);
adcCountdown.resetTimer();
commandExecuted = true;
}
// ADC values are ok, 5 seconds have elapsed
if (transitionOk and countdown.hasTimedOut()) {
state = States::ON_TRANS_TX;
commandExecuted = false;
transitionOk = false;
}
}
if (state == States::ON_TRANS_TX) {
if (not commandExecuted) {
float waitTime = TX_TO_MPA_WAIT_TIME;
params.getValue(PlPcduParameter::TX_TO_MPA_WAIT_TIME_K, waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
// Switch on TX
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_TX);
// Wait for 100 ms before checking ADC values
adcCountdown.setTimeout(100);
adcCountdown.resetTimer();
commandExecuted = true;
}
// ADC values are ok, 5 seconds have elapsed
if (transitionOk and countdown.hasTimedOut()) {
state = States::ON_TRANS_MPA;
commandExecuted = false;
transitionOk = false;
}
}
if (state == States::ON_TRANS_MPA) {
if (not commandExecuted) {
float waitTime = MPA_TO_HPA_WAIT_TIME;
params.getValue(PlPcduParameter::MPA_TO_HPA_WAIT_TIME_K, waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
// Switch on MPA
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_MPA);
// Wait for 100 ms before checking ADC values
adcCountdown.setTimeout(100);
adcCountdown.resetTimer();
commandExecuted = true;
}
// ADC values are ok, 5 seconds have elapsed
if (transitionOk and countdown.hasTimedOut()) {
state = States::ON_TRANS_HPA;
commandExecuted = false;
transitionOk = false;
}
}
if (state == States::ON_TRANS_HPA) {
if (not commandExecuted) {
// Switch on HPA
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_HPA);
commandExecuted = true;
}
// ADC values are ok, 5 seconds have elapsed
if (transitionOk and countdown.hasTimedOut()) {
state = States::PCDU_ON;
setMode(MODE_NORMAL, plpcdu::NORMAL_ALL_ON);
countdown.resetTimer();
commandExecuted = false;
transitionOk = false;
}
}
}
}
void PayloadPcduHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
if (mode == _MODE_TO_NORMAL) {
stateMachineToNormal();
@ -269,152 +404,126 @@ void PayloadPcduHandler::checkAdcValues() {
adcSet.processed[U_X8_DIV_6] = static_cast<float>(adcSet.channels[9]) * SCALE_VOLTAGE;
adcSet.processed[I_DRO] = static_cast<float>(adcSet.channels[10]) * SCALE_CURRENT_DRO * 1000.0;
adcSet.processed[U_DRO_DIV_6] = static_cast<float>(adcSet.channels[11]) * SCALE_VOLTAGE;
if(state >= States::ON_TRANS_DRO) {
if(adcSet.processed[U_BAT_DIV_6] < -6.0 or adcSet.processed[U_BAT_DIV_6] > -3.3) {
bool tooLarge = false;
if(adcSet.processed[U_BAT_DIV_6] > -3.3) {
tooLarge = true;
float lowerBound = 0.0;
float upperBound = 0.0;
bool adcTransition = false;
adcTransition = state == States::ON_TRANS_DRO and adcCountdown.isBusy();
// Now check against voltage and current limits, depending on state
if (state >= States::ON_TRANS_DRO and not adcTransition) {
params.getValue(PlPcduParameter::NEG_V_LOWER_BOUND_K, lowerBound);
params.getValue(PlPcduParameter::NEG_V_UPPER_BOUND_K, upperBound);
if (not checkVoltage(adcSet.processed[U_NEG_V_FB], lowerBound, upperBound,
NEG_V_OUT_OF_BOUNDS)) {
return;
}
uint32_t rawVoltage = 0;
size_t serSize = 0;
SerializeAdapter::serialize(&adcSet.processed[U_BAT_DIV_6],
reinterpret_cast<uint8_t*>(&rawVoltage), &serSize, 4, SerializeIF::Endianness::NETWORK);
triggerEvent(NEG_V_OUT_OF_BOUNDS, tooLarge, rawVoltage);
transitionBackToOff();
params.getValue(PlPcduParameter::DRO_U_LOWER_BOUND_K, lowerBound);
params.getValue(PlPcduParameter::DRO_U_UPPER_BOUND_K, upperBound);
if (not checkVoltage(adcSet.processed[U_DRO_DIV_6], lowerBound, upperBound,
U_DRO_OUT_OF_BOUNDS)) {
return;
}
params.getValue(PlPcduParameter::DRO_I_UPPER_BOUND_K, upperBound);
if (not checkCurrent(adcSet.processed[I_DRO], upperBound, I_DRO_OUT_OF_BOUNDS)) {
return;
}
}
adcTransition = state == States::ON_TRANS_X8 and adcCountdown.isBusy();
if (state >= States::ON_TRANS_X8 and not adcTransition) {
params.getValue(PlPcduParameter::X8_U_LOWER_BOUND_K, lowerBound);
params.getValue(PlPcduParameter::X8_U_UPPER_BOUND_K, upperBound);
if (not checkVoltage(adcSet.processed[U_X8_DIV_6], lowerBound, upperBound,
U_X8_OUT_OF_BOUNDS)) {
return;
}
params.getValue(PlPcduParameter::X8_I_UPPER_BOUND_K, upperBound);
if (not checkCurrent(adcSet.processed[I_X8], upperBound, I_X8_OUT_OF_BOUNDS)) {
return;
}
}
adcTransition = state == States::ON_TRANS_TX and adcCountdown.isBusy();
if (state >= States::ON_TRANS_TX and not adcTransition) {
params.getValue(PlPcduParameter::TX_U_LOWER_BOUND_K, lowerBound);
params.getValue(PlPcduParameter::TX_U_UPPER_BOUND_K, upperBound);
if (not checkVoltage(adcSet.processed[U_TX_DIV_6], lowerBound, upperBound,
U_TX_OUT_OF_BOUNDS)) {
return;
}
params.getValue(PlPcduParameter::TX_I_UPPER_BOUND_K, upperBound);
if (not checkCurrent(adcSet.processed[I_TX], upperBound, I_TX_OUT_OF_BOUNDS)) {
return;
}
}
adcTransition = state == States::ON_TRANS_MPA and adcCountdown.isBusy();
if (state >= States::ON_TRANS_MPA and not adcTransition) {
params.getValue(PlPcduParameter::MPA_U_LOWER_BOUND_K, lowerBound);
params.getValue(PlPcduParameter::MPA_U_UPPER_BOUND_K, upperBound);
if (not checkVoltage(adcSet.processed[U_MPA_DIV_6], lowerBound, upperBound,
U_MPA_OUT_OF_BOUNDS)) {
return;
}
params.getValue(PlPcduParameter::MPA_I_UPPER_BOUND_K, upperBound);
if (not checkCurrent(adcSet.processed[I_MPA], upperBound, I_MPA_OUT_OF_BOUNDS)) {
return;
}
}
adcTransition = state == States::ON_TRANS_HPA and adcCountdown.isBusy();
if (state >= States::ON_TRANS_HPA and not adcTransition) {
params.getValue(PlPcduParameter::HPA_U_LOWER_BOUND_K, lowerBound);
params.getValue(PlPcduParameter::HPA_U_UPPER_BOUND_K, upperBound);
if (not checkVoltage(adcSet.processed[U_HPA_DIV_6], lowerBound, upperBound,
U_HPA_OUT_OF_BOUNDS)) {
return;
}
params.getValue(PlPcduParameter::HPA_I_UPPER_BOUND_K, upperBound);
if (not checkCurrent(adcSet.processed[I_HPA], upperBound, I_HPA_OUT_OF_BOUNDS)) {
return;
}
}
}
void PayloadPcduHandler::checkJsonFileInit() {
if(not jsonFileInitComplete) {
if (not jsonFileInitComplete) {
sd::SdCard prefSd;
sdcMan->getPreferredSdCard(prefSd);
if(sdcMan->isSdCardMounted(prefSd)) {
if (sdcMan->isSdCardMounted(prefSd)) {
params.initialize(sdcMan->getCurrentMountPrefix(prefSd));
jsonFileInitComplete = true;
}
}
}
void PayloadPcduHandler::stateMachineToNormal() {
using namespace plpcdu;
if (adcState == AdcStates::BOOT_DELAY) {
if (adcCountdown.hasTimedOut()) {
adcState = AdcStates::SEND_SETUP;
adcCmdExecuted = false;
}
}
if (adcState == AdcStates::SEND_SETUP) {
if (adcCmdExecuted) {
adcState = AdcStates::NORMAL;
setMode(MODE_NORMAL, NORMAL_ADC_ONLY);
adcCmdExecuted = false;
}
}
if (submode == plpcdu::NORMAL_ALL_ON) {
if (state == States::ON_TRANS_ADC_CLOSE_ZERO) {
if (not commandExecuted) {
float waitTime = SSR_TO_DRO_WAIT_TIME;
params.getValue(PlPcduParameter::SSR_TO_DRO_WAIT_TIME_K, waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
commandExecuted = true;
// TODO: For now, skip ADC check
transitionOk = true;
}
// ADC values are ok, 5 seconds have elapsed
if (transitionOk and countdown.hasTimedOut()) {
state = States::ON_TRANS_DRO;
// Now start monitoring for negative voltages instead
monMode = MonitoringMode::NEGATIVE;
commandExecuted = false;
transitionOk = false;
}
}
if (state == States::ON_TRANS_DRO) {
if (not commandExecuted) {
float waitTime = DRO_TO_X8_WAIT_TIME;
params.getValue(PlPcduParameter::DRO_TO_X8_WAIT_TIME_K, waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
// Switch on DRO and start monitoring for negative voltages
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_DRO);
commandExecuted = true;
}
// ADC values are ok, 5 seconds have elapsed
if (transitionOk and countdown.hasTimedOut()) {
state = States::ON_TRANS_X8;
commandExecuted = false;
transitionOk = false;
}
}
if (state == States::ON_TRANS_X8) {
if (not commandExecuted) {
float waitTime = X8_TO_TX_WAIT_TIME;
params.getValue(PlPcduParameter::X8_TO_TX_WAIT_TIME_K, waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
// Switch on X8
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_X8);
commandExecuted = true;
}
// ADC values are ok, 5 seconds have elapsed
if (transitionOk and countdown.hasTimedOut()) {
state = States::ON_TRANS_TX;
commandExecuted = false;
transitionOk = false;
}
}
if (state == States::ON_TRANS_TX) {
if (not commandExecuted) {
float waitTime = TX_TO_MPA_WAIT_TIME;
params.getValue(PlPcduParameter::TX_TO_MPA_WAIT_TIME_K, waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
// Switch on TX
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_TX);
commandExecuted = true;
}
// ADC values are ok, 5 seconds have elapsed
if (transitionOk and countdown.hasTimedOut()) {
state = States::ON_TRANS_MPA;
commandExecuted = false;
transitionOk = false;
}
}
if (state == States::ON_TRANS_MPA) {
if (not commandExecuted) {
float waitTime = MPA_TO_HPA_WAIT_TIME;
params.getValue(PlPcduParameter::MPA_TO_HPA_WAIT_TIME_K, waitTime);
countdown.setTimeout(std::round(waitTime * 1000));
countdown.resetTimer();
// Switch on MPA
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_MPA);
commandExecuted = true;
}
// ADC values are ok, 5 seconds have elapsed
if (transitionOk and countdown.hasTimedOut()) {
state = States::ON_TRANS_HPA;
commandExecuted = false;
transitionOk = false;
}
}
if (state == States::ON_TRANS_HPA) {
if (not commandExecuted) {
// Switch on HPA
gpioIF->pullHigh(gpioIds::PLPCDU_ENB_HPA);
commandExecuted = true;
}
// ADC values are ok, 5 seconds have elapsed
if (transitionOk and countdown.hasTimedOut()) {
state = States::PCDU_ON;
setMode(MODE_NORMAL, plpcdu::NORMAL_ALL_ON);
countdown.resetTimer();
commandExecuted = false;
transitionOk = false;
bool PayloadPcduHandler::checkVoltage(float val, float lowerBound, float upperBound, Event event) {
bool tooLarge = false;
if (val < lowerBound or val > upperBound) {
if (val > upperBound) {
tooLarge = true;
} else {
tooLarge = false;
}
uint32_t p2 = 0;
serializeFloat(p2, val);
triggerEvent(event, tooLarge, p2);
transitionBackToOff();
return false;
}
return true;
}
bool PayloadPcduHandler::checkCurrent(float val, float upperBound, Event event) {
if (val > upperBound) {
uint32_t p2 = 0;
serializeFloat(p2, val);
triggerEvent(event, true, p2);
transitionBackToOff();
return false;
}
return true;
}
ReturnValue_t PayloadPcduHandler::serializeFloat(uint32_t& param, float val) {
size_t dummy = 0;
return SerializeAdapter::serialize(&val, reinterpret_cast<uint8_t*>(&param), &dummy, 4,
SerializeIF::Endianness::NETWORK);
}
#ifdef FSFW_OSAL_LINUX
@ -546,4 +655,5 @@ ReturnValue_t PayloadPcduHandler::transferAsTwo(SpiComIF* comIf, SpiCookie* cook
}
return HasReturnvaluesIF::RETURN_OK;
}
#endif

3
mission/devices/PayloadPcduHandler.h
View File

@ -144,6 +144,9 @@ class PayloadPcduHandler : public DeviceHandlerBase {
void checkAdcValues();
void checkJsonFileInit();
void stateMachineToNormal();
bool checkVoltage(float val, float lowerBound, float upperBound, Event event);
bool checkCurrent(float val, float upperBound, Event event);
ReturnValue_t serializeFloat(uint32_t& param, float val);
};
#endif /* LINUX_DEVICES_PLPCDUHANDLER_H_ */

104
mission/devices/devicedefinitions/payloadPcduDefinitions.h
View File

@ -1,18 +1,17 @@
#ifndef LINUX_DEVICES_DEVICEDEFINITIONS_PAYLOADPCDUDEFINITIONS_H_
#define LINUX_DEVICES_DEVICEDEFINITIONS_PAYLOADPCDUDEFINITIONS_H_
#include <fsfw/datapoollocal/StaticLocalDataSet.h>
#include <fsfw/devicehandlers/DeviceHandlerIF.h>
#include <cstddef>
#include <filesystem>
#include <nlohmann/json.hpp>
#include "OBSWConfig.h"
#include "mission/devices/max1227.h"
#include "mission/memory/NVMParameterBase.h"
#include <fsfw/datapoollocal/StaticLocalDataSet.h>
#include <fsfw/devicehandlers/DeviceHandlerIF.h>
#include <nlohmann/json.hpp>
#include <cstddef>
#include <filesystem>
namespace plpcdu {
using namespace max1227;
@ -84,35 +83,35 @@ static constexpr float SCALE_CURRENT_DRO = MAX122X_SCALE / (GAIN_INA169 * R_SHUN
// TODO: Make these configurable parameters using a JSON file
// Upper bound of currents in milliamperes [mA]
static constexpr float NEG_V_LOWER_BOUND = -6.0;
static constexpr float NEG_V_UPPER_BOUND = -3.3;
static constexpr double NEG_V_LOWER_BOUND = -6.0;
static constexpr double NEG_V_UPPER_BOUND = -3.3;
static constexpr float DRO_U_LOWER_BOUND = 5.0;
static constexpr float DRO_U_UPPER_BOUND = 7.0;
static constexpr float DRO_I_UPPER_BOUND = 40.0;
static constexpr double DRO_U_LOWER_BOUND = 5.0;
static constexpr double DRO_U_UPPER_BOUND = 7.0;
static constexpr double DRO_I_UPPER_BOUND = 40.0;
static constexpr float X8_U_LOWER_BOUND = 2.6;
static constexpr float X8_U_UPPER_BOUND = 4.0;
static constexpr float X8_I_UPPER_BOUND = 100.0;
static constexpr double X8_U_LOWER_BOUND = 2.6;
static constexpr double X8_U_UPPER_BOUND = 4.0;
static constexpr double X8_I_UPPER_BOUND = 100.0;
static constexpr float TX_U_LOWER_BOUND = 2.6;
static constexpr float TX_U_UPPER_BOUND = 4.0;
static constexpr float TX_I_UPPER_BOUND = 250.0;
static constexpr double TX_U_LOWER_BOUND = 2.6;
static constexpr double TX_U_UPPER_BOUND = 4.0;
static constexpr double TX_I_UPPER_BOUND = 250.0;
static constexpr float MPA_U_LOWER_BOUND = 2.6;
static constexpr float MPA_U_UPPER_BOUND = 4.0;
static constexpr float MPA_I_UPPER_BOUND = 650.0;
static constexpr double MPA_U_LOWER_BOUND = 2.6;
static constexpr double MPA_U_UPPER_BOUND = 4.0;
static constexpr double MPA_I_UPPER_BOUND = 650.0;
static constexpr float HPA_U_LOWER_BOUND = 9.6;
static constexpr float HPA_U_UPPER_BOUND = 11.0;
static constexpr float HPA_I_UPPER_BOUND = 3000.0;
static constexpr double HPA_U_LOWER_BOUND = 9.6;
static constexpr double HPA_U_UPPER_BOUND = 11.0;
static constexpr double HPA_I_UPPER_BOUND = 3000.0;
// Wait time in floating point seconds
static constexpr float SSR_TO_DRO_WAIT_TIME = 5.0;
static constexpr float DRO_TO_X8_WAIT_TIME = 905.0;
static constexpr float X8_TO_TX_WAIT_TIME = 5.0;
static constexpr float TX_TO_MPA_WAIT_TIME = 5.0;
static constexpr float MPA_TO_HPA_WAIT_TIME = 5.0;
static constexpr double SSR_TO_DRO_WAIT_TIME = 5.0;
static constexpr double DRO_TO_X8_WAIT_TIME = 905.0;
static constexpr double X8_TO_TX_WAIT_TIME = 5.0;
static constexpr double TX_TO_MPA_WAIT_TIME = 5.0;
static constexpr double MPA_TO_HPA_WAIT_TIME = 5.0;
/**
* The current of the processed values is calculated and stored as a milliamperes [mA].
@ -137,20 +136,59 @@ class PlPcduParameter : public NVMParameterBase {
static constexpr char TX_TO_MPA_WAIT_TIME_K[] = "txToMpaWait";
static constexpr char MPA_TO_HPA_WAIT_TIME_K[] = "mpaToHpaWait";
PlPcduParameter()
: NVMParameterBase(""), mountPrefix("") {
static constexpr char NEG_V_LOWER_BOUND_K[] = "negVoltLowerBound";
static constexpr char NEG_V_UPPER_BOUND_K[] = "negVoltUpperBound";
static constexpr char DRO_U_LOWER_BOUND_K[] = "droVoltLowerBound";
static constexpr char DRO_U_UPPER_BOUND_K[] = "droVoltUpperBound";
static constexpr char DRO_I_UPPER_BOUND_K[] = "droCurrUpperBound";
static constexpr char X8_U_LOWER_BOUND_K[] = "x8VoltLowerBound";
static constexpr char X8_U_UPPER_BOUND_K[] = "x8VoltUpperBound";
static constexpr char X8_I_UPPER_BOUND_K[] = "x8CurrUpperBound";
static constexpr char TX_U_LOWER_BOUND_K[] = "txVoltLowerBound";
static constexpr char TX_U_UPPER_BOUND_K[] = "txVoltUpperBound";
static constexpr char TX_I_UPPER_BOUND_K[] = "txCurrUpperBound";
static constexpr char MPA_U_LOWER_BOUND_K[] = "mpaVoltLowerBound";
static constexpr char MPA_U_UPPER_BOUND_K[] = "mpaVoltUpperBound";
static constexpr char MPA_I_UPPER_BOUND_K[] = "mpaCurrUpperBound";
static constexpr char HPA_U_LOWER_BOUND_K[] = "hpaVoltLowerBound";
static constexpr char HPA_U_UPPER_BOUND_K[] = "hpaVoltUpperBound";
static constexpr char HPA_I_UPPER_BOUND_K[] = "hpaCurrUpperBound";
PlPcduParameter() : NVMParameterBase(""), mountPrefix("") {
// Initialize with default values
insertValue(SSR_TO_DRO_WAIT_TIME_K, SSR_TO_DRO_WAIT_TIME);
insertValue(DRO_TO_X8_WAIT_TIME_K, DRO_TO_X8_WAIT_TIME);
insertValue(X8_TO_TX_WAIT_TIME_K, X8_TO_TX_WAIT_TIME);
insertValue(TX_TO_MPA_WAIT_TIME_K, TX_TO_MPA_WAIT_TIME);
insertValue(MPA_TO_HPA_WAIT_TIME_K, MPA_TO_HPA_WAIT_TIME);
insertValue(NEG_V_LOWER_BOUND_K, NEG_V_LOWER_BOUND);
insertValue(NEG_V_UPPER_BOUND_K, NEG_V_UPPER_BOUND);
insertValue(DRO_U_LOWER_BOUND_K, DRO_U_LOWER_BOUND);
insertValue(DRO_U_UPPER_BOUND_K, DRO_U_UPPER_BOUND);
insertValue(DRO_I_UPPER_BOUND_K, DRO_I_UPPER_BOUND);
insertValue(X8_U_LOWER_BOUND_K, X8_U_LOWER_BOUND);
insertValue(X8_U_UPPER_BOUND_K, X8_U_UPPER_BOUND);
insertValue(X8_I_UPPER_BOUND_K, X8_I_UPPER_BOUND);
insertValue(TX_U_LOWER_BOUND_K, TX_U_LOWER_BOUND);
insertValue(TX_U_UPPER_BOUND_K, TX_U_UPPER_BOUND);
insertValue(TX_I_UPPER_BOUND_K, TX_I_UPPER_BOUND);
insertValue(MPA_U_LOWER_BOUND_K, MPA_U_LOWER_BOUND);
insertValue(MPA_U_UPPER_BOUND_K, MPA_U_UPPER_BOUND);
insertValue(MPA_I_UPPER_BOUND_K, MPA_I_UPPER_BOUND);
insertValue(HPA_U_LOWER_BOUND_K, HPA_U_LOWER_BOUND);
insertValue(HPA_U_UPPER_BOUND_K, HPA_U_UPPER_BOUND);
insertValue(HPA_I_UPPER_BOUND_K, HPA_I_UPPER_BOUND);
}
ReturnValue_t initialize(std::string mountPrefix) {
setFullName(mountPrefix + "/conf/plpcdu.json");
ReturnValue_t result = readJsonFile();
if(result != HasReturnvaluesIF::RETURN_OK) {
if (result != HasReturnvaluesIF::RETURN_OK) {
// File does not exist. Create it. Keys and appropriate init values were
// specified in constructor
#if OBSW_VERBOSE_LEVEL >= 1

13
mission/memory/SdCardMountedIF.h
View File

@ -1,21 +1,18 @@
#ifndef MISSION_MEMORY_SDCARDMOUNTERIF_H_
#define MISSION_MEMORY_SDCARDMOUNTERIF_H_
#include "definitions.h"
#include <string>
#include "definitions.h"
class SdCardMountedIF {
public:
virtual~SdCardMountedIF() {};
public:
virtual ~SdCardMountedIF(){};
virtual std::string getCurrentMountPrefix(sd::SdCard prefSdCardPtr = sd::SdCard::NONE) = 0;
virtual bool isSdCardMounted(sd::SdCard sdCard) = 0;
virtual ReturnValue_t getPreferredSdCard(sd::SdCard& sdCard) const = 0;
private:
private:
};
#endif /* MISSION_MEMORY_SDCARDMOUNTERIF_H_ */