applied clang formatting
Some checks failed
EIVE/eive-obsw/pipeline/head There was a failure building this commit
Some checks failed
EIVE/eive-obsw/pipeline/head There was a failure building this commit
This commit is contained in:
@ -1,487 +1,462 @@
|
||||
#include "SdCardManager.h"
|
||||
#include "scratchApi.h"
|
||||
|
||||
#include "linux/utility/utility.h"
|
||||
|
||||
#include "fsfw/ipc/MutexFactory.h"
|
||||
#include "fsfw/serviceinterface/ServiceInterface.h"
|
||||
|
||||
#include <unistd.h>
|
||||
|
||||
#include <cstring>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <memory>
|
||||
#include <filesystem>
|
||||
#include <cstring>
|
||||
|
||||
#include "fsfw/ipc/MutexFactory.h"
|
||||
#include "fsfw/serviceinterface/ServiceInterface.h"
|
||||
#include "linux/utility/utility.h"
|
||||
#include "scratchApi.h"
|
||||
|
||||
SdCardManager* SdCardManager::factoryInstance = nullptr;
|
||||
|
||||
SdCardManager::SdCardManager(): cmdExecutor(256) {
|
||||
}
|
||||
SdCardManager::SdCardManager() : cmdExecutor(256) {}
|
||||
|
||||
SdCardManager::~SdCardManager() {
|
||||
}
|
||||
SdCardManager::~SdCardManager() {}
|
||||
|
||||
void SdCardManager::create() {
|
||||
if(factoryInstance == nullptr) {
|
||||
factoryInstance = new SdCardManager();
|
||||
}
|
||||
if (factoryInstance == nullptr) {
|
||||
factoryInstance = new SdCardManager();
|
||||
}
|
||||
}
|
||||
|
||||
SdCardManager* SdCardManager::instance() {
|
||||
SdCardManager::create();
|
||||
return SdCardManager::factoryInstance;
|
||||
SdCardManager::create();
|
||||
return SdCardManager::factoryInstance;
|
||||
}
|
||||
|
||||
ReturnValue_t SdCardManager::switchOnSdCard(sd::SdCard sdCard, bool doMountSdCard,
|
||||
SdStatePair* statusPair) {
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
if(doMountSdCard) {
|
||||
if(not blocking) {
|
||||
sif::warning << "SdCardManager::switchOnSdCard: Two-step command but manager is"
|
||||
" not configured for blocking operation. "
|
||||
"Forcing blocking mode.." << std::endl;
|
||||
blocking = true;
|
||||
}
|
||||
SdStatePair* statusPair) {
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
if (doMountSdCard) {
|
||||
if (not blocking) {
|
||||
sif::warning << "SdCardManager::switchOnSdCard: Two-step command but manager is"
|
||||
" not configured for blocking operation. "
|
||||
"Forcing blocking mode.."
|
||||
<< std::endl;
|
||||
blocking = true;
|
||||
}
|
||||
std::unique_ptr<SdStatePair> sdStatusPtr;
|
||||
if(statusPair == nullptr) {
|
||||
sdStatusPtr = std::make_unique<SdStatePair>();
|
||||
statusPair = sdStatusPtr.get();
|
||||
result = getSdCardActiveStatus(*statusPair);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
std::unique_ptr<SdStatePair> sdStatusPtr;
|
||||
if (statusPair == nullptr) {
|
||||
sdStatusPtr = std::make_unique<SdStatePair>();
|
||||
statusPair = sdStatusPtr.get();
|
||||
result = getSdCardActiveStatus(*statusPair);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
// Not allowed, this function turns on one SD card
|
||||
if(sdCard == sd::SdCard::BOTH) {
|
||||
sif::warning << "SdCardManager::switchOffSdCard: API does not allow sd::SdStatus::BOTH"
|
||||
<< std::endl;
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
// Not allowed, this function turns on one SD card
|
||||
if (sdCard == sd::SdCard::BOTH) {
|
||||
sif::warning << "SdCardManager::switchOffSdCard: API does not allow sd::SdStatus::BOTH"
|
||||
<< std::endl;
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
|
||||
sd::SdState currentState;
|
||||
if(sdCard == sd::SdCard::SLOT_0) {
|
||||
currentState = statusPair->first;
|
||||
}
|
||||
else if(sdCard == sd::SdCard::SLOT_1) {
|
||||
currentState = statusPair->second;
|
||||
}
|
||||
else {
|
||||
// Should not happen
|
||||
currentState = sd::SdState::OFF;
|
||||
}
|
||||
sd::SdState currentState;
|
||||
if (sdCard == sd::SdCard::SLOT_0) {
|
||||
currentState = statusPair->first;
|
||||
} else if (sdCard == sd::SdCard::SLOT_1) {
|
||||
currentState = statusPair->second;
|
||||
} else {
|
||||
// Should not happen
|
||||
currentState = sd::SdState::OFF;
|
||||
}
|
||||
|
||||
if(currentState == sd::SdState::ON) {
|
||||
if(not doMountSdCard) {
|
||||
return ALREADY_ON;
|
||||
}
|
||||
else {
|
||||
return mountSdCard(sdCard);
|
||||
}
|
||||
}
|
||||
else if(currentState == sd::SdState::MOUNTED) {
|
||||
result = ALREADY_MOUNTED;
|
||||
}
|
||||
else if(currentState == sd::SdState::OFF) {
|
||||
result = setSdCardState(sdCard, true);
|
||||
}
|
||||
else {
|
||||
result = HasReturnvaluesIF::RETURN_FAILED;
|
||||
if (currentState == sd::SdState::ON) {
|
||||
if (not doMountSdCard) {
|
||||
return ALREADY_ON;
|
||||
} else {
|
||||
return mountSdCard(sdCard);
|
||||
}
|
||||
} else if (currentState == sd::SdState::MOUNTED) {
|
||||
result = ALREADY_MOUNTED;
|
||||
} else if (currentState == sd::SdState::OFF) {
|
||||
result = setSdCardState(sdCard, true);
|
||||
} else {
|
||||
result = HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
|
||||
if(result != HasReturnvaluesIF::RETURN_OK or not doMountSdCard) {
|
||||
return result;
|
||||
}
|
||||
if (result != HasReturnvaluesIF::RETURN_OK or not doMountSdCard) {
|
||||
return result;
|
||||
}
|
||||
|
||||
return mountSdCard(sdCard);
|
||||
return mountSdCard(sdCard);
|
||||
}
|
||||
|
||||
ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, bool doUnmountSdCard,
|
||||
SdStatePair* statusPair) {
|
||||
std::pair<sd::SdState, sd::SdState> active;
|
||||
ReturnValue_t result = getSdCardActiveStatus(active);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
SdStatePair* statusPair) {
|
||||
std::pair<sd::SdState, sd::SdState> active;
|
||||
ReturnValue_t result = getSdCardActiveStatus(active);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
if (doUnmountSdCard) {
|
||||
if (not blocking) {
|
||||
sif::warning << "SdCardManager::switchOffSdCard: Two-step command but manager is"
|
||||
" not configured for blocking operation. Forcing blocking mode.."
|
||||
<< std::endl;
|
||||
blocking = true;
|
||||
}
|
||||
if(doUnmountSdCard) {
|
||||
if(not blocking) {
|
||||
sif::warning << "SdCardManager::switchOffSdCard: Two-step command but manager is"
|
||||
" not configured for blocking operation. Forcing blocking mode.." << std::endl;
|
||||
blocking = true;
|
||||
}
|
||||
}
|
||||
// Not allowed, this function turns off one SD card
|
||||
if (sdCard == sd::SdCard::BOTH) {
|
||||
sif::warning << "SdCardManager::switchOffSdCard: API does not allow sd::SdStatus::BOTH"
|
||||
<< std::endl;
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
if (sdCard == sd::SdCard::SLOT_0) {
|
||||
if (active.first == sd::SdState::OFF) {
|
||||
return ALREADY_OFF;
|
||||
}
|
||||
// Not allowed, this function turns off one SD card
|
||||
if(sdCard == sd::SdCard::BOTH) {
|
||||
sif::warning << "SdCardManager::switchOffSdCard: API does not allow sd::SdStatus::BOTH"
|
||||
<< std::endl;
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
if(sdCard == sd::SdCard::SLOT_0) {
|
||||
if(active.first == sd::SdState::OFF) {
|
||||
return ALREADY_OFF;
|
||||
}
|
||||
}
|
||||
else if(sdCard == sd::SdCard::SLOT_1) {
|
||||
if(active.second == sd::SdState::OFF) {
|
||||
return ALREADY_OFF;
|
||||
}
|
||||
} else if (sdCard == sd::SdCard::SLOT_1) {
|
||||
if (active.second == sd::SdState::OFF) {
|
||||
return ALREADY_OFF;
|
||||
}
|
||||
}
|
||||
|
||||
if(doUnmountSdCard) {
|
||||
result = unmountSdCard(sdCard);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
if (doUnmountSdCard) {
|
||||
result = unmountSdCard(sdCard);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
return setSdCardState(sdCard, false);
|
||||
return setSdCardState(sdCard, false);
|
||||
}
|
||||
|
||||
ReturnValue_t SdCardManager::setSdCardState(sd::SdCard sdCard, bool on) {
|
||||
using namespace std;
|
||||
if(cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
|
||||
return CommandExecutor::COMMAND_PENDING;
|
||||
}
|
||||
string sdstring = "";
|
||||
string statestring = "";
|
||||
if(sdCard == sd::SdCard::SLOT_0) {
|
||||
sdstring = "0";
|
||||
}
|
||||
else if(sdCard == sd::SdCard::SLOT_1) {
|
||||
sdstring = "1";
|
||||
}
|
||||
if(on) {
|
||||
currentOp = Operations::SWITCHING_ON;
|
||||
statestring = "on";
|
||||
}
|
||||
else {
|
||||
currentOp = Operations::SWITCHING_OFF;
|
||||
statestring = "off";
|
||||
}
|
||||
ostringstream command;
|
||||
command << "q7hw sd set " << sdstring << " " << statestring;
|
||||
cmdExecutor.load(command.str(), blocking, printCmdOutput);
|
||||
ReturnValue_t result = cmdExecutor.execute();
|
||||
if(blocking and result != HasReturnvaluesIF::RETURN_OK) {
|
||||
utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::setSdCardState");
|
||||
}
|
||||
return result;
|
||||
using namespace std;
|
||||
if (cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
|
||||
return CommandExecutor::COMMAND_PENDING;
|
||||
}
|
||||
string sdstring = "";
|
||||
string statestring = "";
|
||||
if (sdCard == sd::SdCard::SLOT_0) {
|
||||
sdstring = "0";
|
||||
} else if (sdCard == sd::SdCard::SLOT_1) {
|
||||
sdstring = "1";
|
||||
}
|
||||
if (on) {
|
||||
currentOp = Operations::SWITCHING_ON;
|
||||
statestring = "on";
|
||||
} else {
|
||||
currentOp = Operations::SWITCHING_OFF;
|
||||
statestring = "off";
|
||||
}
|
||||
ostringstream command;
|
||||
command << "q7hw sd set " << sdstring << " " << statestring;
|
||||
cmdExecutor.load(command.str(), blocking, printCmdOutput);
|
||||
ReturnValue_t result = cmdExecutor.execute();
|
||||
if (blocking and result != HasReturnvaluesIF::RETURN_OK) {
|
||||
utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::setSdCardState");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t SdCardManager::getSdCardActiveStatus(SdStatePair& active) {
|
||||
using namespace std;
|
||||
if(not filesystem::exists(SD_STATE_FILE)) {
|
||||
return STATUS_FILE_NEXISTS;
|
||||
}
|
||||
using namespace std;
|
||||
if (not filesystem::exists(SD_STATE_FILE)) {
|
||||
return STATUS_FILE_NEXISTS;
|
||||
}
|
||||
|
||||
// Now the file should exist in any case. Still check whether it exists.
|
||||
fstream sdStatus(SD_STATE_FILE);
|
||||
if (not sdStatus.good()) {
|
||||
return STATUS_FILE_NEXISTS;
|
||||
}
|
||||
string line;
|
||||
uint8_t idx = 0;
|
||||
sd::SdCard currentSd = sd::SdCard::SLOT_0;
|
||||
// Process status file line by line
|
||||
while (std::getline(sdStatus, line)) {
|
||||
processSdStatusLine(active, line, idx, currentSd);
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
// Now the file should exist in any case. Still check whether it exists.
|
||||
fstream sdStatus(SD_STATE_FILE);
|
||||
if (not sdStatus.good()) {
|
||||
return STATUS_FILE_NEXISTS;
|
||||
}
|
||||
string line;
|
||||
uint8_t idx = 0;
|
||||
sd::SdCard currentSd = sd::SdCard::SLOT_0;
|
||||
// Process status file line by line
|
||||
while (std::getline(sdStatus, line)) {
|
||||
processSdStatusLine(active, line, idx, currentSd);
|
||||
}
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t SdCardManager::mountSdCard(sd::SdCard sdCard) {
|
||||
using namespace std;
|
||||
if(cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
|
||||
return CommandExecutor::COMMAND_PENDING;
|
||||
}
|
||||
if(sdCard == sd::SdCard::BOTH) {
|
||||
sif::warning << "SdCardManager::mountSdCard: API does not allow sd::SdStatus::BOTH"
|
||||
<< std::endl;
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
string mountDev;
|
||||
string mountPoint;
|
||||
if(sdCard == sd::SdCard::SLOT_0) {
|
||||
mountDev = SD_0_DEV_NAME;
|
||||
mountPoint = SD_0_MOUNT_POINT;
|
||||
}
|
||||
else if(sdCard == sd::SdCard::SLOT_1) {
|
||||
mountDev = SD_1_DEV_NAME;
|
||||
mountPoint = SD_1_MOUNT_POINT;
|
||||
}
|
||||
if(not filesystem::exists(mountDev)) {
|
||||
sif::warning << "SdCardManager::mountSdCard: Device file does not exists. Make sure to"
|
||||
" turn on the SD card" << std::endl;
|
||||
return MOUNT_ERROR;
|
||||
}
|
||||
using namespace std;
|
||||
if (cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
|
||||
return CommandExecutor::COMMAND_PENDING;
|
||||
}
|
||||
if (sdCard == sd::SdCard::BOTH) {
|
||||
sif::warning << "SdCardManager::mountSdCard: API does not allow sd::SdStatus::BOTH"
|
||||
<< std::endl;
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
string mountDev;
|
||||
string mountPoint;
|
||||
if (sdCard == sd::SdCard::SLOT_0) {
|
||||
mountDev = SD_0_DEV_NAME;
|
||||
mountPoint = SD_0_MOUNT_POINT;
|
||||
} else if (sdCard == sd::SdCard::SLOT_1) {
|
||||
mountDev = SD_1_DEV_NAME;
|
||||
mountPoint = SD_1_MOUNT_POINT;
|
||||
}
|
||||
if (not filesystem::exists(mountDev)) {
|
||||
sif::warning << "SdCardManager::mountSdCard: Device file does not exists. Make sure to"
|
||||
" turn on the SD card"
|
||||
<< std::endl;
|
||||
return MOUNT_ERROR;
|
||||
}
|
||||
|
||||
if(not blocking) {
|
||||
currentOp = Operations::MOUNTING;
|
||||
}
|
||||
string sdMountCommand = "mount " + mountDev + " " + mountPoint;
|
||||
cmdExecutor.load(sdMountCommand, blocking, printCmdOutput);
|
||||
ReturnValue_t result = cmdExecutor.execute();
|
||||
if(blocking and result != HasReturnvaluesIF::RETURN_OK) {
|
||||
utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::mountSdCard");
|
||||
}
|
||||
return result;
|
||||
if (not blocking) {
|
||||
currentOp = Operations::MOUNTING;
|
||||
}
|
||||
string sdMountCommand = "mount " + mountDev + " " + mountPoint;
|
||||
cmdExecutor.load(sdMountCommand, blocking, printCmdOutput);
|
||||
ReturnValue_t result = cmdExecutor.execute();
|
||||
if (blocking and result != HasReturnvaluesIF::RETURN_OK) {
|
||||
utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::mountSdCard");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t SdCardManager::unmountSdCard(sd::SdCard sdCard) {
|
||||
if(cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
|
||||
return CommandExecutor::COMMAND_PENDING;
|
||||
}
|
||||
using namespace std;
|
||||
if(sdCard == sd::SdCard::BOTH) {
|
||||
sif::warning << "SdCardManager::unmountSdCard: API does not allow sd::SdStatus::BOTH"
|
||||
<< std::endl;
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
string mountPoint;
|
||||
if(sdCard == sd::SdCard::SLOT_0) {
|
||||
mountPoint = SD_0_MOUNT_POINT;
|
||||
}
|
||||
else if(sdCard == sd::SdCard::SLOT_1) {
|
||||
mountPoint = SD_1_MOUNT_POINT;
|
||||
}
|
||||
if(not filesystem::exists(mountPoint)) {
|
||||
sif::error << "SdCardManager::unmountSdCard: Default mount point " << mountPoint <<
|
||||
"does not exist" << std::endl;
|
||||
return UNMOUNT_ERROR;
|
||||
}
|
||||
if(filesystem::is_empty(mountPoint)) {
|
||||
// The mount point will always exist, but if it is empty, that is strong hint that
|
||||
// the SD card was not mounted properly. Still proceed with operation.
|
||||
sif::warning << "SdCardManager::unmountSdCard: Mount point is empty!" << std::endl;
|
||||
}
|
||||
string sdUnmountCommand = "umount " + mountPoint;
|
||||
if(not blocking) {
|
||||
currentOp = Operations::UNMOUNTING;
|
||||
}
|
||||
cmdExecutor.load(sdUnmountCommand, blocking, printCmdOutput);
|
||||
ReturnValue_t result = cmdExecutor.execute();
|
||||
if(blocking and result != HasReturnvaluesIF::RETURN_OK) {
|
||||
utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::unmountSdCard");
|
||||
}
|
||||
return result;
|
||||
if (cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
|
||||
return CommandExecutor::COMMAND_PENDING;
|
||||
}
|
||||
using namespace std;
|
||||
if (sdCard == sd::SdCard::BOTH) {
|
||||
sif::warning << "SdCardManager::unmountSdCard: API does not allow sd::SdStatus::BOTH"
|
||||
<< std::endl;
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
string mountPoint;
|
||||
if (sdCard == sd::SdCard::SLOT_0) {
|
||||
mountPoint = SD_0_MOUNT_POINT;
|
||||
} else if (sdCard == sd::SdCard::SLOT_1) {
|
||||
mountPoint = SD_1_MOUNT_POINT;
|
||||
}
|
||||
if (not filesystem::exists(mountPoint)) {
|
||||
sif::error << "SdCardManager::unmountSdCard: Default mount point " << mountPoint
|
||||
<< "does not exist" << std::endl;
|
||||
return UNMOUNT_ERROR;
|
||||
}
|
||||
if (filesystem::is_empty(mountPoint)) {
|
||||
// The mount point will always exist, but if it is empty, that is strong hint that
|
||||
// the SD card was not mounted properly. Still proceed with operation.
|
||||
sif::warning << "SdCardManager::unmountSdCard: Mount point is empty!" << std::endl;
|
||||
}
|
||||
string sdUnmountCommand = "umount " + mountPoint;
|
||||
if (not blocking) {
|
||||
currentOp = Operations::UNMOUNTING;
|
||||
}
|
||||
cmdExecutor.load(sdUnmountCommand, blocking, printCmdOutput);
|
||||
ReturnValue_t result = cmdExecutor.execute();
|
||||
if (blocking and result != HasReturnvaluesIF::RETURN_OK) {
|
||||
utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::unmountSdCard");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
ReturnValue_t SdCardManager::sanitizeState(SdStatePair* statusPair, sd::SdCard prefSdCard) {
|
||||
std::unique_ptr<SdStatePair> sdStatusPtr;
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
// Enforce blocking operation for now. Be careful to reset it when returning prematurely!
|
||||
bool resetNonBlockingState = false;
|
||||
if(not this->blocking) {
|
||||
blocking = true;
|
||||
resetNonBlockingState = true;
|
||||
}
|
||||
if(prefSdCard == sd::SdCard::NONE) {
|
||||
result = getPreferredSdCard(prefSdCard);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {}
|
||||
}
|
||||
if(statusPair == nullptr) {
|
||||
sdStatusPtr = std::make_unique<SdStatePair>();
|
||||
statusPair = sdStatusPtr.get();
|
||||
getSdCardActiveStatus(*statusPair);
|
||||
std::unique_ptr<SdStatePair> sdStatusPtr;
|
||||
ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
|
||||
// Enforce blocking operation for now. Be careful to reset it when returning prematurely!
|
||||
bool resetNonBlockingState = false;
|
||||
if (not this->blocking) {
|
||||
blocking = true;
|
||||
resetNonBlockingState = true;
|
||||
}
|
||||
if (prefSdCard == sd::SdCard::NONE) {
|
||||
result = getPreferredSdCard(prefSdCard);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
}
|
||||
}
|
||||
if (statusPair == nullptr) {
|
||||
sdStatusPtr = std::make_unique<SdStatePair>();
|
||||
statusPair = sdStatusPtr.get();
|
||||
getSdCardActiveStatus(*statusPair);
|
||||
}
|
||||
|
||||
if(statusPair->first == sd::SdState::ON) {
|
||||
result = mountSdCard(prefSdCard);
|
||||
}
|
||||
if (statusPair->first == sd::SdState::ON) {
|
||||
result = mountSdCard(prefSdCard);
|
||||
}
|
||||
|
||||
result = switchOnSdCard(prefSdCard, true, statusPair);
|
||||
if(resetNonBlockingState) {
|
||||
blocking = false;
|
||||
}
|
||||
return result;
|
||||
result = switchOnSdCard(prefSdCard, true, statusPair);
|
||||
if (resetNonBlockingState) {
|
||||
blocking = false;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void SdCardManager::resetState() {
|
||||
cmdExecutor.reset();
|
||||
currentOp = Operations::IDLE;
|
||||
cmdExecutor.reset();
|
||||
currentOp = Operations::IDLE;
|
||||
}
|
||||
|
||||
void SdCardManager::processSdStatusLine(std::pair<sd::SdState, sd::SdState> &active,
|
||||
std::string& line, uint8_t& idx, sd::SdCard& currentSd) {
|
||||
using namespace std;
|
||||
istringstream iss(line);
|
||||
string word;
|
||||
bool slotLine = false;
|
||||
bool mountLine = false;
|
||||
while(iss >> word) {
|
||||
if (word == "Slot") {
|
||||
slotLine = true;
|
||||
}
|
||||
if(word == "Mounted") {
|
||||
mountLine = true;
|
||||
}
|
||||
|
||||
if(slotLine) {
|
||||
if (word == "1:") {
|
||||
currentSd = sd::SdCard::SLOT_1;
|
||||
}
|
||||
|
||||
if(word == "on") {
|
||||
if(currentSd == sd::SdCard::SLOT_0) {
|
||||
active.first = sd::SdState::ON;
|
||||
}
|
||||
else {
|
||||
active.second = sd::SdState::ON;
|
||||
}
|
||||
}
|
||||
else if (word == "off") {
|
||||
if(currentSd == sd::SdCard::SLOT_0) {
|
||||
active.first = sd::SdState::OFF;
|
||||
}
|
||||
else {
|
||||
active.second = sd::SdState::OFF;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(mountLine) {
|
||||
if(currentSd == sd::SdCard::SLOT_0) {
|
||||
active.first = sd::SdState::MOUNTED;
|
||||
}
|
||||
else {
|
||||
active.second = sd::SdState::MOUNTED;
|
||||
}
|
||||
}
|
||||
|
||||
if(idx > 5) {
|
||||
sif::warning << "SdCardManager::sdCardActive: /tmp/sd_status.txt has more than 6 "
|
||||
"lines and might be invalid!" << std::endl;
|
||||
}
|
||||
void SdCardManager::processSdStatusLine(std::pair<sd::SdState, sd::SdState>& active,
|
||||
std::string& line, uint8_t& idx, sd::SdCard& currentSd) {
|
||||
using namespace std;
|
||||
istringstream iss(line);
|
||||
string word;
|
||||
bool slotLine = false;
|
||||
bool mountLine = false;
|
||||
while (iss >> word) {
|
||||
if (word == "Slot") {
|
||||
slotLine = true;
|
||||
}
|
||||
idx++;
|
||||
if (word == "Mounted") {
|
||||
mountLine = true;
|
||||
}
|
||||
|
||||
if (slotLine) {
|
||||
if (word == "1:") {
|
||||
currentSd = sd::SdCard::SLOT_1;
|
||||
}
|
||||
|
||||
if (word == "on") {
|
||||
if (currentSd == sd::SdCard::SLOT_0) {
|
||||
active.first = sd::SdState::ON;
|
||||
} else {
|
||||
active.second = sd::SdState::ON;
|
||||
}
|
||||
} else if (word == "off") {
|
||||
if (currentSd == sd::SdCard::SLOT_0) {
|
||||
active.first = sd::SdState::OFF;
|
||||
} else {
|
||||
active.second = sd::SdState::OFF;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (mountLine) {
|
||||
if (currentSd == sd::SdCard::SLOT_0) {
|
||||
active.first = sd::SdState::MOUNTED;
|
||||
} else {
|
||||
active.second = sd::SdState::MOUNTED;
|
||||
}
|
||||
}
|
||||
|
||||
if (idx > 5) {
|
||||
sif::warning << "SdCardManager::sdCardActive: /tmp/sd_status.txt has more than 6 "
|
||||
"lines and might be invalid!"
|
||||
<< std::endl;
|
||||
}
|
||||
}
|
||||
idx++;
|
||||
}
|
||||
|
||||
ReturnValue_t SdCardManager::getPreferredSdCard(sd::SdCard& sdCard) const {
|
||||
uint8_t prefSdCard = 0;
|
||||
ReturnValue_t result = scratch::readNumber(scratch::PREFERED_SDC_KEY, prefSdCard);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
sdCard = static_cast<sd::SdCard>(prefSdCard);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
uint8_t prefSdCard = 0;
|
||||
ReturnValue_t result = scratch::readNumber(scratch::PREFERED_SDC_KEY, prefSdCard);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return result;
|
||||
}
|
||||
sdCard = static_cast<sd::SdCard>(prefSdCard);
|
||||
return HasReturnvaluesIF::RETURN_OK;
|
||||
}
|
||||
|
||||
ReturnValue_t SdCardManager::setPreferredSdCard(sd::SdCard sdCard) {
|
||||
if(sdCard == sd::SdCard::BOTH) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
return scratch::writeNumber(scratch::PREFERED_SDC_KEY, static_cast<uint8_t>(sdCard));
|
||||
if (sdCard == sd::SdCard::BOTH) {
|
||||
return HasReturnvaluesIF::RETURN_FAILED;
|
||||
}
|
||||
return scratch::writeNumber(scratch::PREFERED_SDC_KEY, static_cast<uint8_t>(sdCard));
|
||||
}
|
||||
|
||||
ReturnValue_t SdCardManager::updateSdCardStateFile() {
|
||||
if(cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
|
||||
return CommandExecutor::COMMAND_PENDING;
|
||||
}
|
||||
// Use q7hw utility and pipe the command output into the state file
|
||||
std::string updateCmd = "q7hw sd info all > " + std::string(SD_STATE_FILE);
|
||||
cmdExecutor.load(updateCmd, blocking, printCmdOutput);
|
||||
ReturnValue_t result = cmdExecutor.execute();
|
||||
if(blocking and result != HasReturnvaluesIF::RETURN_OK) {
|
||||
utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::mountSdCard");
|
||||
}
|
||||
return result;
|
||||
if (cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
|
||||
return CommandExecutor::COMMAND_PENDING;
|
||||
}
|
||||
// Use q7hw utility and pipe the command output into the state file
|
||||
std::string updateCmd = "q7hw sd info all > " + std::string(SD_STATE_FILE);
|
||||
cmdExecutor.load(updateCmd, blocking, printCmdOutput);
|
||||
ReturnValue_t result = cmdExecutor.execute();
|
||||
if (blocking and result != HasReturnvaluesIF::RETURN_OK) {
|
||||
utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::mountSdCard");
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
std::string SdCardManager::getCurrentMountPrefix(sd::SdCard prefSdCard) {
|
||||
if(prefSdCard == sd::SdCard::NONE) {
|
||||
ReturnValue_t result = getPreferredSdCard(prefSdCard);
|
||||
if(result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return SD_0_MOUNT_POINT;
|
||||
}
|
||||
}
|
||||
if(prefSdCard == sd::SdCard::SLOT_0) {
|
||||
return SD_0_MOUNT_POINT;
|
||||
}
|
||||
else {
|
||||
return SD_1_MOUNT_POINT;
|
||||
if (prefSdCard == sd::SdCard::NONE) {
|
||||
ReturnValue_t result = getPreferredSdCard(prefSdCard);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
return SD_0_MOUNT_POINT;
|
||||
}
|
||||
}
|
||||
if (prefSdCard == sd::SdCard::SLOT_0) {
|
||||
return SD_0_MOUNT_POINT;
|
||||
} else {
|
||||
return SD_1_MOUNT_POINT;
|
||||
}
|
||||
}
|
||||
|
||||
SdCardManager::OpStatus SdCardManager::checkCurrentOp(Operations ¤tOp) {
|
||||
CommandExecutor::States state = cmdExecutor.getCurrentState();
|
||||
if(state == CommandExecutor::States::IDLE or state == CommandExecutor::States::COMMAND_LOADED) {
|
||||
return OpStatus::IDLE;
|
||||
}
|
||||
currentOp = this->currentOp;
|
||||
bool bytesRead = false;
|
||||
SdCardManager::OpStatus SdCardManager::checkCurrentOp(Operations& currentOp) {
|
||||
CommandExecutor::States state = cmdExecutor.getCurrentState();
|
||||
if (state == CommandExecutor::States::IDLE or state == CommandExecutor::States::COMMAND_LOADED) {
|
||||
return OpStatus::IDLE;
|
||||
}
|
||||
currentOp = this->currentOp;
|
||||
bool bytesRead = false;
|
||||
|
||||
#if OBSW_ENABLE_TIMERS == 1
|
||||
Timer timer;
|
||||
timer.setTimer(100);
|
||||
uint32_t remainingTimeMs = 0;
|
||||
Timer timer;
|
||||
timer.setTimer(100);
|
||||
uint32_t remainingTimeMs = 0;
|
||||
#endif
|
||||
while(true) {
|
||||
ReturnValue_t result = cmdExecutor.check(bytesRead);
|
||||
// This timer can prevent deadlocks due to missconfigurations
|
||||
while (true) {
|
||||
ReturnValue_t result = cmdExecutor.check(bytesRead);
|
||||
// This timer can prevent deadlocks due to missconfigurations
|
||||
#if OBSW_ENABLE_TIMERS == 1
|
||||
timer.getTimer(&remainingTimeMs);
|
||||
if(remainingTimeMs == 0) {
|
||||
sif::error << "SdCardManager::checkCurrentOp: Timeout!" << std::endl;
|
||||
return OpStatus::FAIL;
|
||||
}
|
||||
#endif
|
||||
switch(result) {
|
||||
case(CommandExecutor::BYTES_READ): {
|
||||
continue;
|
||||
}
|
||||
case(CommandExecutor::EXECUTION_FINISHED): {
|
||||
return OpStatus::SUCCESS;
|
||||
}
|
||||
case(HasReturnvaluesIF::RETURN_OK): {
|
||||
return OpStatus::ONGOING;
|
||||
}
|
||||
case(HasReturnvaluesIF::RETURN_FAILED): {
|
||||
return OpStatus::FAIL;
|
||||
}
|
||||
default: {
|
||||
sif::warning << "SdCardManager::checkCurrentOp: Unhandled case" << std::endl;
|
||||
}
|
||||
}
|
||||
timer.getTimer(&remainingTimeMs);
|
||||
if (remainingTimeMs == 0) {
|
||||
sif::error << "SdCardManager::checkCurrentOp: Timeout!" << std::endl;
|
||||
return OpStatus::FAIL;
|
||||
}
|
||||
#endif
|
||||
switch (result) {
|
||||
case (CommandExecutor::BYTES_READ): {
|
||||
continue;
|
||||
}
|
||||
case (CommandExecutor::EXECUTION_FINISHED): {
|
||||
return OpStatus::SUCCESS;
|
||||
}
|
||||
case (HasReturnvaluesIF::RETURN_OK): {
|
||||
return OpStatus::ONGOING;
|
||||
}
|
||||
case (HasReturnvaluesIF::RETURN_FAILED): {
|
||||
return OpStatus::FAIL;
|
||||
}
|
||||
default: {
|
||||
sif::warning << "SdCardManager::checkCurrentOp: Unhandled case" << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void SdCardManager::setBlocking(bool blocking) {
|
||||
this->blocking = blocking;
|
||||
}
|
||||
void SdCardManager::setBlocking(bool blocking) { this->blocking = blocking; }
|
||||
|
||||
void SdCardManager::setPrintCommandOutput(bool print) {
|
||||
this->printCmdOutput = print;
|
||||
|
||||
}
|
||||
void SdCardManager::setPrintCommandOutput(bool print) { this->printCmdOutput = print; }
|
||||
|
||||
bool SdCardManager::isSdCardMounted(sd::SdCard sdCard) {
|
||||
SdCardManager::SdStatePair active;
|
||||
ReturnValue_t result = this->getSdCardActiveStatus(active);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::debug << "SdCardManager::isSdCardMounted: Failed to get SD card active state";
|
||||
return false;
|
||||
}
|
||||
if (sdCard == sd::SLOT_0) {
|
||||
if (active.first == sd::MOUNTED) {
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else if (sdCard == sd::SLOT_1) {
|
||||
if (active.second == sd::MOUNTED) {
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else {
|
||||
sif::debug << "SdCardManager::isSdCardMounted: Unknown SD card specified" << std::endl;
|
||||
}
|
||||
SdCardManager::SdStatePair active;
|
||||
ReturnValue_t result = this->getSdCardActiveStatus(active);
|
||||
if (result != HasReturnvaluesIF::RETURN_OK) {
|
||||
sif::debug << "SdCardManager::isSdCardMounted: Failed to get SD card active state";
|
||||
return false;
|
||||
}
|
||||
if (sdCard == sd::SLOT_0) {
|
||||
if (active.first == sd::MOUNTED) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} else if (sdCard == sd::SLOT_1) {
|
||||
if (active.second == sd::MOUNTED) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
sif::debug << "SdCardManager::isSdCardMounted: Unknown SD card specified" << std::endl;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user