eive/eive-obsw
eive/eive-obsw
12
3
Fork 0
Code Issues 3 Pull Requests 1 Releases 118 Wiki Activity

rename ploc supv uart man
Some checks failed
EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit
Details

Browse Source
This commit is contained in:
Robin Müller 2022-11-15 17:24:38 +01:00
parent 7fb689b451
commit 38e74e6eaf
No known key found for this signature in database
GPG Key ID: 11D4952C8CCEF814
6 changed files with 74 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bsp_hosted/ObjectFactory.cpp
View File

@ -98,7 +98,7 @@ void ObjectFactory::produce(void* args) {
new UartCookie(objects::PLOC_SUPERVISOR_HANDLER, plocSupvString, uart::PLOC_SUPV_BAUD,
supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
supervisorCookie->setNoFixedSizeReply();
auto supvHelper = new PlocSupvHelper(objects::PLOC_SUPERVISOR_HELPER);
auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, objects::PLOC_SUPERVISOR_HELPER,
supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, dummyGpioIF),
pcdu::PDU1_CH6_PLOC_12V, supvHelper);

6
bsp_hosted/scheduling.cpp
View File

@ -195,6 +195,12 @@ void scheduling::initTasks() {
pstTask->startTask();
thermalTask->startTask();
#if OBSW_ADD_PLOC_SUPERVISOR == 1
supvHelperTask->startTask();
#endif
#if OBSW_ADD_PLOC_SUPERVISOR == 1 || OBSW_ADD_PLOC_MPSOC == 1
plTask->startTask();
#endif
#if OBSW_ADD_TEST_CODE == 1
testTask->startTask();

20
linux/devices/ploc/PlocSupervisorHandler.cpp
View File

@ -20,7 +20,7 @@ using namespace returnvalue;
PlocSupervisorHandler::PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid,
CookieIF* comCookie, Gpio uartIsolatorSwitch,
power::Switch_t powerSwitch,
PlocSupvHelper* supvHelper)
PlocSupvUartManager* supvHelper)
: DeviceHandlerBase(objectId, uartComIFid, comCookie),
uartIsolatorSwitch(uartIsolatorSwitch),
hkset(this),
@ -796,12 +796,12 @@ void PlocSupervisorHandler::handleEvent(EventMessage* eventMessage) {
plocSupvHelperExecuting = false;
// After execution of update procedure, PLOC is in a state where it draws approx. 700 mA of
// current. To leave this state the shutdown MPSoC command must be sent here.
if (event == PlocSupvHelper::SUPV_UPDATE_FAILED ||
event == PlocSupvHelper::SUPV_UPDATE_SUCCESSFUL ||
event == PlocSupvHelper::SUPV_CONTINUE_UPDATE_FAILED ||
event == PlocSupvHelper::SUPV_CONTINUE_UPDATE_SUCCESSFUL ||
event == PlocSupvHelper::SUPV_MEM_CHECK_FAIL ||
event == PlocSupvHelper::SUPV_MEM_CHECK_OK) {
if (event == PlocSupvUartManager::SUPV_UPDATE_FAILED ||
event == PlocSupvUartManager::SUPV_UPDATE_SUCCESSFUL ||
event == PlocSupvUartManager::SUPV_CONTINUE_UPDATE_FAILED ||
event == PlocSupvUartManager::SUPV_CONTINUE_UPDATE_SUCCESSFUL ||
event == PlocSupvUartManager::SUPV_MEM_CHECK_FAIL ||
event == PlocSupvUartManager::SUPV_MEM_CHECK_OK) {
result = this->executeAction(supv::SHUTDOWN_MPSOC, NO_COMMANDER, nullptr, 0);
if (result != returnvalue::OK) {
triggerEvent(SUPV_MPSOC_SHUWDOWN_BUILD_FAILED);
@ -1856,9 +1856,9 @@ ReturnValue_t PlocSupervisorHandler::eventSubscription() {
if (result != returnvalue::OK) {
return result;
}
result = manager->subscribeToEventRange(eventQueue->getId(),
event::getEventId(PlocSupvHelper::SUPV_UPDATE_FAILED),
event::getEventId(PlocSupvHelper::SUPV_MEM_CHECK_FAIL));
result = manager->subscribeToEventRange(
eventQueue->getId(), event::getEventId(PlocSupvUartManager::SUPV_UPDATE_FAILED),
event::getEventId(PlocSupvUartManager::SUPV_MEM_CHECK_FAIL));
if (result != returnvalue::OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "PlocSupervisorHandler::eventSubscritpion: Failed to subscribe to events from "

4
linux/devices/ploc/PlocSupervisorHandler.h
View File

@ -34,7 +34,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
public:
PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie,
Gpio uartIsolatorSwitch, power::Switch_t powerSwitch,
PlocSupvHelper* supvHelper);
PlocSupvUartManager* supvHelper);
virtual ~PlocSupervisorHandler();
virtual ReturnValue_t initialize() override;
@ -130,7 +130,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
const power::Switch_t powerSwitch = power::NO_SWITCH;
supv::TmBase tmReader;
PlocSupvHelper* supvHelper = nullptr;
PlocSupvUartManager* supvHelper = nullptr;
MessageQueueIF* eventQueue = nullptr;
/** Number of expected replies following the MRAM dump command */

99
linux/devices/ploc/PlocSupvUartMan.cpp
View File

@ -27,7 +27,7 @@
using namespace returnvalue;
using namespace supv;
PlocSupvHelper::PlocSupvHelper(object_id_t objectId)
PlocSupvUartManager::PlocSupvUartManager(object_id_t objectId)
: SystemObject(objectId),
recRingBuf(4096, true),
decodedRingBuf(1200 * MAX_STORED_DECODED_PACKETS, true),
@ -39,9 +39,9 @@ PlocSupvHelper::PlocSupvHelper(object_id_t objectId)
ipcLock = MutexFactory::instance()->createMutex();
}
PlocSupvHelper::~PlocSupvHelper() = default;
PlocSupvUartManager::~PlocSupvUartManager() = default;
ReturnValue_t PlocSupvHelper::initializeInterface(CookieIF* cookie) {
ReturnValue_t PlocSupvUartManager::initializeInterface(CookieIF* cookie) {
auto* uartCookie = dynamic_cast<SerialCookie*>(cookie);
if (uartCookie == nullptr) {
return FAILED;
@ -80,7 +80,7 @@ ReturnValue_t PlocSupvHelper::initializeInterface(CookieIF* cookie) {
return OK;
}
ReturnValue_t PlocSupvHelper::initialize() {
ReturnValue_t PlocSupvUartManager::initialize() {
#ifdef XIPHOS_Q7S
sdcMan = SdCardManager::instance();
if (sdcMan == nullptr) {
@ -91,7 +91,7 @@ ReturnValue_t PlocSupvHelper::initialize() {
return returnvalue::OK;
}
ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) {
ReturnValue_t PlocSupvUartManager::performOperation(uint8_t operationCode) {
bool putTaskToSleep = false;
while (true) {
semaphore->acquire();
@ -129,7 +129,7 @@ ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) {
}
}
bool PlocSupvHelper::handleUartReception() {
bool PlocSupvUartManager::handleUartReception() {
ReturnValue_t result = OK;
ssize_t bytesRead = read(serialPort, reinterpret_cast<void*>(recBuf.data()),
static_cast<unsigned int>(recBuf.size()));
@ -160,8 +160,8 @@ bool PlocSupvHelper::handleUartReception() {
return false;
}
ReturnValue_t PlocSupvHelper::startUpdate(std::string file, uint8_t memoryId,
uint32_t startAddress) {
ReturnValue_t PlocSupvUartManager::startUpdate(std::string file, uint8_t memoryId,
uint32_t startAddress) {
supv::UpdateParams params;
params.file = file;
params.memId = memoryId;
@ -172,7 +172,7 @@ ReturnValue_t PlocSupvHelper::startUpdate(std::string file, uint8_t memoryId,
return performUpdate(params);
}
ReturnValue_t PlocSupvHelper::performUpdate(const supv::UpdateParams& params) {
ReturnValue_t PlocSupvUartManager::performUpdate(const supv::UpdateParams& params) {
lock->lockMutex();
InternalState current = state;
lock->unlockMutex();
@ -226,8 +226,8 @@ ReturnValue_t PlocSupvHelper::performUpdate(const supv::UpdateParams& params) {
return result;
}
ReturnValue_t PlocSupvHelper::performMemCheck(std::string file, uint8_t memoryId,
uint32_t startAddress) {
ReturnValue_t PlocSupvUartManager::performMemCheck(std::string file, uint8_t memoryId,
uint32_t startAddress) {
lock->lockMutex();
InternalState current = state;
lock->unlockMutex();
@ -237,9 +237,9 @@ ReturnValue_t PlocSupvHelper::performMemCheck(std::string file, uint8_t memoryId
return performMemCheck(file, memoryId, startAddress, getFileSize(update.file), true);
}
ReturnValue_t PlocSupvHelper::performMemCheck(std::string file, uint8_t memoryId,
uint32_t startAddress, size_t sizeToCheck,
bool checkCrc) {
ReturnValue_t PlocSupvUartManager::performMemCheck(std::string file, uint8_t memoryId,
uint32_t startAddress, size_t sizeToCheck,
bool checkCrc) {
{
MutexGuard mg(lock);
update.file = file;
@ -254,7 +254,7 @@ ReturnValue_t PlocSupvHelper::performMemCheck(std::string file, uint8_t memoryId
return returnvalue::OK;
}
ReturnValue_t PlocSupvHelper::initiateUpdateContinuation() {
ReturnValue_t PlocSupvUartManager::initiateUpdateContinuation() {
lock->lockMutex();
InternalState current = state;
lock->unlockMutex();
@ -284,12 +284,12 @@ ReturnValue_t PlocSupvHelper::initiateUpdateContinuation() {
// return returnvalue::OK;
// }
void PlocSupvHelper::stop() {
void PlocSupvUartManager::stop() {
MutexGuard mg(lock);
state = InternalState::GO_TO_SLEEP;
}
void PlocSupvHelper::executeFullCheckMemoryCommand() {
void PlocSupvUartManager::executeFullCheckMemoryCommand() {
ReturnValue_t result;
if (update.crcShouldBeChecked) {
sif::info << "PLOC SUPV Mem Check: Calculating Image CRC" << std::endl;
@ -315,7 +315,7 @@ void PlocSupvHelper::executeFullCheckMemoryCommand() {
handleCheckMemoryCommand();
}
ReturnValue_t PlocSupvHelper::executeUpdate() {
ReturnValue_t PlocSupvUartManager::executeUpdate() {
ReturnValue_t result = returnvalue::OK;
sif::info << "PLOC SUPV Update MPSoC: Calculating Image CRC" << std::endl;
result = calcImageCrc();
@ -342,7 +342,7 @@ ReturnValue_t PlocSupvHelper::executeUpdate() {
return updateOperation();
}
ReturnValue_t PlocSupvHelper::continueUpdate() {
ReturnValue_t PlocSupvUartManager::continueUpdate() {
ReturnValue_t result = prepareUpdate();
if (result != returnvalue::OK) {
return result;
@ -350,7 +350,7 @@ ReturnValue_t PlocSupvHelper::continueUpdate() {
return updateOperation();
}
ReturnValue_t PlocSupvHelper::updateOperation() {
ReturnValue_t PlocSupvUartManager::updateOperation() {
sif::info << "PlocSupvHelper::performUpdate: Writing Update Packets" << std::endl;
auto result = writeUpdatePackets();
if (result != returnvalue::OK) {
@ -360,7 +360,7 @@ ReturnValue_t PlocSupvHelper::updateOperation() {
return handleCheckMemoryCommand();
}
ReturnValue_t PlocSupvHelper::writeUpdatePackets() {
ReturnValue_t PlocSupvUartManager::writeUpdatePackets() {
ReturnValue_t result = returnvalue::OK;
#if OBSW_DEBUG_PLOC_SUPERVISOR == 1
ProgressPrinter progressPrinter("Supervisor update", update.fullFileSize,
@ -437,7 +437,7 @@ ReturnValue_t PlocSupvHelper::writeUpdatePackets() {
return result;
}
uint32_t PlocSupvHelper::buildProgParams1(uint8_t percent, uint16_t seqCount) {
uint32_t PlocSupvUartManager::buildProgParams1(uint8_t percent, uint16_t seqCount) {
return (static_cast<uint32_t>(percent) << 24) | static_cast<uint32_t>(seqCount);
}
@ -482,7 +482,7 @@ uint32_t PlocSupvHelper::buildProgParams1(uint8_t percent, uint16_t seqCount) {
// return result;
// }
ReturnValue_t PlocSupvHelper::handleRemainingExeReport(ploc::SpTmReader& reader) {
ReturnValue_t PlocSupvUartManager::handleRemainingExeReport(ploc::SpTmReader& reader) {
size_t remBytes = reader.getPacketDataLen() + 1;
ReturnValue_t result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN);
if (result != returnvalue::OK) {
@ -495,7 +495,7 @@ ReturnValue_t PlocSupvHelper::handleRemainingExeReport(ploc::SpTmReader& reader)
return result;
}
ReturnValue_t PlocSupvHelper::selectMemory() {
ReturnValue_t PlocSupvUartManager::selectMemory() {
ReturnValue_t result = returnvalue::OK;
resetSpParams();
supv::MPSoCBootSelect packet(spParams);
@ -510,7 +510,7 @@ ReturnValue_t PlocSupvHelper::selectMemory() {
return returnvalue::OK;
}
ReturnValue_t PlocSupvHelper::prepareUpdate() {
ReturnValue_t PlocSupvUartManager::prepareUpdate() {
ReturnValue_t result = returnvalue::OK;
resetSpParams();
supv::NoPayloadPacket packet(spParams, Apid::BOOT_MAN,
@ -526,7 +526,7 @@ ReturnValue_t PlocSupvHelper::prepareUpdate() {
return returnvalue::OK;
}
ReturnValue_t PlocSupvHelper::eraseMemory() {
ReturnValue_t PlocSupvUartManager::eraseMemory() {
ReturnValue_t result = returnvalue::OK;
resetSpParams();
supv::EraseMemory eraseMemory(spParams);
@ -542,8 +542,8 @@ ReturnValue_t PlocSupvHelper::eraseMemory() {
return returnvalue::OK;
}
ReturnValue_t PlocSupvHelper::handlePacketTransmissionNoReply(supv::TcBase& packet,
uint32_t timeoutExecutionReport) {
ReturnValue_t PlocSupvUartManager::handlePacketTransmissionNoReply(
supv::TcBase& packet, uint32_t timeoutExecutionReport) {
ReturnValue_t result = returnvalue::OK;
result = encodeAndSendPacket(packet.getFullPacket(), packet.getFullPacketLen());
if (result != returnvalue::OK) {
@ -599,7 +599,7 @@ ReturnValue_t PlocSupvHelper::handlePacketTransmissionNoReply(supv::TcBase& pack
return returnvalue::OK;
}
int PlocSupvHelper::handleAckReception(supv::TcBase& tc, uint8_t serviceId, size_t packetLen) {
int PlocSupvUartManager::handleAckReception(supv::TcBase& tc, uint8_t serviceId, size_t packetLen) {
if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::ACK) or
serviceId == static_cast<uint8_t>(supv::tm::TmtcId::NAK)) {
AcknowledgmentReport ackReport(tmReader);
@ -629,7 +629,8 @@ int PlocSupvHelper::handleAckReception(supv::TcBase& tc, uint8_t serviceId, size
return 0;
}
int PlocSupvHelper::handleExeAckReception(supv::TcBase& tc, uint8_t serviceId, size_t packetLen) {
int PlocSupvUartManager::handleExeAckReception(supv::TcBase& tc, uint8_t serviceId,
size_t packetLen) {
if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_ACK) or
serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK)) {
ExecutionReport exeReport(tmReader);
@ -659,7 +660,7 @@ int PlocSupvHelper::handleExeAckReception(supv::TcBase& tc, uint8_t serviceId, s
return 0;
}
ReturnValue_t PlocSupvHelper::checkReceivedTm() {
ReturnValue_t PlocSupvUartManager::checkReceivedTm() {
ReturnValue_t result = tmReader.checkSize();
if (result != returnvalue::OK) {
triggerEvent(SUPV_REPLY_SIZE_MISSMATCH, rememberApid);
@ -673,7 +674,7 @@ ReturnValue_t PlocSupvHelper::checkReceivedTm() {
return result;
}
ReturnValue_t PlocSupvHelper::calcImageCrc() {
ReturnValue_t PlocSupvUartManager::calcImageCrc() {
ReturnValue_t result = returnvalue::OK;
if (update.fullFileSize == 0) {
return returnvalue::FAILED;
@ -719,7 +720,7 @@ ReturnValue_t PlocSupvHelper::calcImageCrc() {
return result;
}
ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
ReturnValue_t PlocSupvUartManager::handleCheckMemoryCommand() {
ReturnValue_t result = returnvalue::OK;
resetSpParams();
supv::CheckMemory packet(spParams);
@ -815,7 +816,7 @@ ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
return result;
}
uint32_t PlocSupvHelper::getFileSize(std::string filename) {
uint32_t PlocSupvUartManager::getFileSize(std::string filename) {
std::ifstream file(filename, std::ifstream::binary);
file.seekg(0, file.end);
uint32_t size = file.tellg();
@ -823,7 +824,7 @@ uint32_t PlocSupvHelper::getFileSize(std::string filename) {
return size;
}
ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reader) {
ReturnValue_t PlocSupvUartManager::handleEventBufferReception(ploc::SpTmReader& reader) {
ReturnValue_t result = returnvalue::OK;
// TODO: Fix
//#ifdef XIPHOS_Q7S
@ -879,10 +880,10 @@ ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reade
return result;
}
void PlocSupvHelper::resetSpParams() { spParams.buf = cmdBuf.data(); }
void PlocSupvUartManager::resetSpParams() { spParams.buf = cmdBuf.data(); }
ReturnValue_t PlocSupvHelper::sendMessage(CookieIF* cookie, const uint8_t* sendData,
size_t sendLen) {
ReturnValue_t PlocSupvUartManager::sendMessage(CookieIF* cookie, const uint8_t* sendData,
size_t sendLen) {
if (sendData == nullptr or sendLen == 0) {
return FAILED;
}
@ -895,13 +896,13 @@ ReturnValue_t PlocSupvHelper::sendMessage(CookieIF* cookie, const uint8_t* sendD
return encodeAndSendPacket(sendData, sendLen);
}
ReturnValue_t PlocSupvHelper::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
ReturnValue_t PlocSupvUartManager::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
ReturnValue_t PlocSupvHelper::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
ReturnValue_t PlocSupvUartManager::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
return returnvalue::OK;
}
ReturnValue_t PlocSupvHelper::handleRunningLongerRequest() {
ReturnValue_t PlocSupvUartManager::handleRunningLongerRequest() {
ReturnValue_t result = OK;
switch (request) {
case Request::UPDATE: {
@ -949,7 +950,7 @@ ReturnValue_t PlocSupvHelper::handleRunningLongerRequest() {
return false;
}
ReturnValue_t PlocSupvHelper::encodeAndSendPacket(const uint8_t* sendData, size_t sendLen) {
ReturnValue_t PlocSupvUartManager::encodeAndSendPacket(const uint8_t* sendData, size_t sendLen) {
size_t encodedLen = 0;
hdlc_add_framing(sendData, sendLen, encodedSendBuf.data(), &encodedLen);
size_t bytesWritten = write(serialPort, encodedSendBuf.data(), encodedLen);
@ -961,8 +962,8 @@ ReturnValue_t PlocSupvHelper::encodeAndSendPacket(const uint8_t* sendData, size_
return returnvalue::OK;
}
ReturnValue_t PlocSupvHelper::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
size_t* size) {
ReturnValue_t PlocSupvUartManager::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
size_t* size) {
MutexGuard mg(ipcLock);
if (ipcQueue.empty()) {
*size = 0;
@ -977,7 +978,7 @@ ReturnValue_t PlocSupvHelper::readReceivedMessage(CookieIF* cookie, uint8_t** bu
return OK;
}
ReturnValue_t PlocSupvHelper::tryHdlcParsing() {
ReturnValue_t PlocSupvUartManager::tryHdlcParsing() {
size_t bytesRead = 0;
ReturnValue_t result = parseRecRingBufForHdlc(bytesRead);
if (result == returnvalue::OK) {
@ -1001,7 +1002,7 @@ ReturnValue_t PlocSupvHelper::tryHdlcParsing() {
return result;
}
ReturnValue_t PlocSupvHelper::parseRecRingBufForHdlc(size_t& readSize) {
ReturnValue_t PlocSupvUartManager::parseRecRingBufForHdlc(size_t& readSize) {
size_t availableData = recRingBuf.getAvailableReadData();
if (availableData == 0) {
return NO_PACKET_FOUND;
@ -1043,17 +1044,17 @@ ReturnValue_t PlocSupvHelper::parseRecRingBufForHdlc(size_t& readSize) {
return NO_PACKET_FOUND;
}
void PlocSupvHelper::pushIpcData(const uint8_t* data, size_t len) {
void PlocSupvUartManager::pushIpcData(const uint8_t* data, size_t len) {
MutexGuard mg(ipcLock);
ipcRingBuf.writeData(data, len);
ipcQueue.insert(len);
}
uint32_t PlocSupvHelper::buildApidServiceParam1(uint8_t apid, uint8_t serviceId) {
uint32_t PlocSupvUartManager::buildApidServiceParam1(uint8_t apid, uint8_t serviceId) {
return (apid << 8) | serviceId;
}
void PlocSupvHelper::performUartShutdown() {
void PlocSupvUartManager::performUartShutdown() {
tcflush(serialPort, TCIOFLUSH);
// Clear ring buffers
recRingBuf.clear();

10
linux/devices/ploc/PlocSupvUartMan.h
View File

@ -25,9 +25,9 @@
* the supervisor and the OBC.
* @author J. Meier
*/
class PlocSupvHelper : public DeviceCommunicationIF,
public SystemObject,
public ExecutableObjectIF {
class PlocSupvUartManager : public DeviceCommunicationIF,
public SystemObject,
public ExecutableObjectIF {
public:
static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_SUPV_HELPER;
@ -115,8 +115,8 @@ class PlocSupvHelper : public DeviceCommunicationIF,
//! P1: First byte percent, third and fourth byte Sequence Count, P2: Bytes written
static constexpr Event SUPV_UPDATE_PROGRESS = MAKE_EVENT(30, severity::INFO);
PlocSupvHelper(object_id_t objectId);
virtual ~PlocSupvHelper();
PlocSupvUartManager(object_id_t objectId);
virtual ~PlocSupvUartManager();
ReturnValue_t initialize() override;
ReturnValue_t performOperation(uint8_t operationCode = 0) override;