eive/eive-obsw
eive/eive-obsw
13
4
Fork 0
Code Issues 4 Pull Requests 1 Releases 121 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, new UartCookie(objects::PLOC_SUPERVISOR_HANDLER, plocSupvString, uart::PLOC_SUPV_BAUD,
supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL); supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
supervisorCookie->setNoFixedSizeReply(); 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, new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, objects::PLOC_SUPERVISOR_HELPER,
supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, dummyGpioIF), supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, dummyGpioIF),
pcdu::PDU1_CH6_PLOC_12V, supvHelper); pcdu::PDU1_CH6_PLOC_12V, supvHelper);

6
bsp_hosted/scheduling.cpp
View File

@ -195,6 +195,12 @@ void scheduling::initTasks() {
pstTask->startTask(); pstTask->startTask();
thermalTask->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 #if OBSW_ADD_TEST_CODE == 1
testTask->startTask(); 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, PlocSupervisorHandler::PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid,
CookieIF* comCookie, Gpio uartIsolatorSwitch, CookieIF* comCookie, Gpio uartIsolatorSwitch,
power::Switch_t powerSwitch, power::Switch_t powerSwitch,
PlocSupvHelper* supvHelper) PlocSupvUartManager* supvHelper)
: DeviceHandlerBase(objectId, uartComIFid, comCookie), : DeviceHandlerBase(objectId, uartComIFid, comCookie),
uartIsolatorSwitch(uartIsolatorSwitch), uartIsolatorSwitch(uartIsolatorSwitch),
hkset(this), hkset(this),
@ -796,12 +796,12 @@ void PlocSupervisorHandler::handleEvent(EventMessage* eventMessage) {
plocSupvHelperExecuting = false; plocSupvHelperExecuting = false;
// After execution of update procedure, PLOC is in a state where it draws approx. 700 mA of // 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. // current. To leave this state the shutdown MPSoC command must be sent here.
if (event == PlocSupvHelper::SUPV_UPDATE_FAILED || if (event == PlocSupvUartManager::SUPV_UPDATE_FAILED ||
event == PlocSupvHelper::SUPV_UPDATE_SUCCESSFUL || event == PlocSupvUartManager::SUPV_UPDATE_SUCCESSFUL ||
event == PlocSupvHelper::SUPV_CONTINUE_UPDATE_FAILED || event == PlocSupvUartManager::SUPV_CONTINUE_UPDATE_FAILED ||
event == PlocSupvHelper::SUPV_CONTINUE_UPDATE_SUCCESSFUL || event == PlocSupvUartManager::SUPV_CONTINUE_UPDATE_SUCCESSFUL ||
event == PlocSupvHelper::SUPV_MEM_CHECK_FAIL || event == PlocSupvUartManager::SUPV_MEM_CHECK_FAIL ||
event == PlocSupvHelper::SUPV_MEM_CHECK_OK) { event == PlocSupvUartManager::SUPV_MEM_CHECK_OK) {
result = this->executeAction(supv::SHUTDOWN_MPSOC, NO_COMMANDER, nullptr, 0); result = this->executeAction(supv::SHUTDOWN_MPSOC, NO_COMMANDER, nullptr, 0);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
triggerEvent(SUPV_MPSOC_SHUWDOWN_BUILD_FAILED); triggerEvent(SUPV_MPSOC_SHUWDOWN_BUILD_FAILED);
@ -1856,9 +1856,9 @@ ReturnValue_t PlocSupervisorHandler::eventSubscription() {
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
result = manager->subscribeToEventRange(eventQueue->getId(), result = manager->subscribeToEventRange(
event::getEventId(PlocSupvHelper::SUPV_UPDATE_FAILED), eventQueue->getId(), event::getEventId(PlocSupvUartManager::SUPV_UPDATE_FAILED),
event::getEventId(PlocSupvHelper::SUPV_MEM_CHECK_FAIL)); event::getEventId(PlocSupvUartManager::SUPV_MEM_CHECK_FAIL));
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "PlocSupervisorHandler::eventSubscritpion: Failed to subscribe to events from " 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: public:
PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie, PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie,
Gpio uartIsolatorSwitch, power::Switch_t powerSwitch, Gpio uartIsolatorSwitch, power::Switch_t powerSwitch,
PlocSupvHelper* supvHelper); PlocSupvUartManager* supvHelper);
virtual ~PlocSupervisorHandler(); virtual ~PlocSupervisorHandler();
virtual ReturnValue_t initialize() override; virtual ReturnValue_t initialize() override;
@ -130,7 +130,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
const power::Switch_t powerSwitch = power::NO_SWITCH; const power::Switch_t powerSwitch = power::NO_SWITCH;
supv::TmBase tmReader; supv::TmBase tmReader;
PlocSupvHelper* supvHelper = nullptr; PlocSupvUartManager* supvHelper = nullptr;
MessageQueueIF* eventQueue = nullptr; MessageQueueIF* eventQueue = nullptr;
/** Number of expected replies following the MRAM dump command */ /** 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 returnvalue;
using namespace supv; using namespace supv;
PlocSupvHelper::PlocSupvHelper(object_id_t objectId) PlocSupvUartManager::PlocSupvUartManager(object_id_t objectId)
: SystemObject(objectId), : SystemObject(objectId),
recRingBuf(4096, true), recRingBuf(4096, true),
decodedRingBuf(1200 * MAX_STORED_DECODED_PACKETS, true), decodedRingBuf(1200 * MAX_STORED_DECODED_PACKETS, true),
@ -39,9 +39,9 @@ PlocSupvHelper::PlocSupvHelper(object_id_t objectId)
ipcLock = MutexFactory::instance()->createMutex(); 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); auto* uartCookie = dynamic_cast<SerialCookie*>(cookie);
if (uartCookie == nullptr) { if (uartCookie == nullptr) {
return FAILED; return FAILED;
@ -80,7 +80,7 @@ ReturnValue_t PlocSupvHelper::initializeInterface(CookieIF* cookie) {
return OK; return OK;
} }
ReturnValue_t PlocSupvHelper::initialize() { ReturnValue_t PlocSupvUartManager::initialize() {
#ifdef XIPHOS_Q7S #ifdef XIPHOS_Q7S
sdcMan = SdCardManager::instance(); sdcMan = SdCardManager::instance();
if (sdcMan == nullptr) { if (sdcMan == nullptr) {
@ -91,7 +91,7 @@ ReturnValue_t PlocSupvHelper::initialize() {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) { ReturnValue_t PlocSupvUartManager::performOperation(uint8_t operationCode) {
bool putTaskToSleep = false; bool putTaskToSleep = false;
while (true) { while (true) {
semaphore->acquire(); semaphore->acquire();
@ -129,7 +129,7 @@ ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) {
} }
} }
bool PlocSupvHelper::handleUartReception() { bool PlocSupvUartManager::handleUartReception() {
ReturnValue_t result = OK; ReturnValue_t result = OK;
ssize_t bytesRead = read(serialPort, reinterpret_cast<void*>(recBuf.data()), ssize_t bytesRead = read(serialPort, reinterpret_cast<void*>(recBuf.data()),
static_cast<unsigned int>(recBuf.size())); static_cast<unsigned int>(recBuf.size()));
@ -160,8 +160,8 @@ bool PlocSupvHelper::handleUartReception() {
return false; return false;
} }
ReturnValue_t PlocSupvHelper::startUpdate(std::string file, uint8_t memoryId, ReturnValue_t PlocSupvUartManager::startUpdate(std::string file, uint8_t memoryId,
uint32_t startAddress) { uint32_t startAddress) {
supv::UpdateParams params; supv::UpdateParams params;
params.file = file; params.file = file;
params.memId = memoryId; params.memId = memoryId;
@ -172,7 +172,7 @@ ReturnValue_t PlocSupvHelper::startUpdate(std::string file, uint8_t memoryId,
return performUpdate(params); return performUpdate(params);
} }
ReturnValue_t PlocSupvHelper::performUpdate(const supv::UpdateParams& params) { ReturnValue_t PlocSupvUartManager::performUpdate(const supv::UpdateParams& params) {
lock->lockMutex(); lock->lockMutex();
InternalState current = state; InternalState current = state;
lock->unlockMutex(); lock->unlockMutex();
@ -226,8 +226,8 @@ ReturnValue_t PlocSupvHelper::performUpdate(const supv::UpdateParams& params) {
return result; return result;
} }
ReturnValue_t PlocSupvHelper::performMemCheck(std::string file, uint8_t memoryId, ReturnValue_t PlocSupvUartManager::performMemCheck(std::string file, uint8_t memoryId,
uint32_t startAddress) { uint32_t startAddress) {
lock->lockMutex(); lock->lockMutex();
InternalState current = state; InternalState current = state;
lock->unlockMutex(); 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); return performMemCheck(file, memoryId, startAddress, getFileSize(update.file), true);
} }
ReturnValue_t PlocSupvHelper::performMemCheck(std::string file, uint8_t memoryId, ReturnValue_t PlocSupvUartManager::performMemCheck(std::string file, uint8_t memoryId,
uint32_t startAddress, size_t sizeToCheck, uint32_t startAddress, size_t sizeToCheck,
bool checkCrc) { bool checkCrc) {
{ {
MutexGuard mg(lock); MutexGuard mg(lock);
update.file = file; update.file = file;
@ -254,7 +254,7 @@ ReturnValue_t PlocSupvHelper::performMemCheck(std::string file, uint8_t memoryId
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t PlocSupvHelper::initiateUpdateContinuation() { ReturnValue_t PlocSupvUartManager::initiateUpdateContinuation() {
lock->lockMutex(); lock->lockMutex();
InternalState current = state; InternalState current = state;
lock->unlockMutex(); lock->unlockMutex();
@ -284,12 +284,12 @@ ReturnValue_t PlocSupvHelper::initiateUpdateContinuation() {
// return returnvalue::OK; // return returnvalue::OK;
// } // }
void PlocSupvHelper::stop() { void PlocSupvUartManager::stop() {
MutexGuard mg(lock); MutexGuard mg(lock);
state = InternalState::GO_TO_SLEEP; state = InternalState::GO_TO_SLEEP;
} }
void PlocSupvHelper::executeFullCheckMemoryCommand() { void PlocSupvUartManager::executeFullCheckMemoryCommand() {
ReturnValue_t result; ReturnValue_t result;
if (update.crcShouldBeChecked) { if (update.crcShouldBeChecked) {
sif::info << "PLOC SUPV Mem Check: Calculating Image CRC" << std::endl; sif::info << "PLOC SUPV Mem Check: Calculating Image CRC" << std::endl;
@ -315,7 +315,7 @@ void PlocSupvHelper::executeFullCheckMemoryCommand() {
handleCheckMemoryCommand(); handleCheckMemoryCommand();
} }
ReturnValue_t PlocSupvHelper::executeUpdate() { ReturnValue_t PlocSupvUartManager::executeUpdate() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
sif::info << "PLOC SUPV Update MPSoC: Calculating Image CRC" << std::endl; sif::info << "PLOC SUPV Update MPSoC: Calculating Image CRC" << std::endl;
result = calcImageCrc(); result = calcImageCrc();
@ -342,7 +342,7 @@ ReturnValue_t PlocSupvHelper::executeUpdate() {
return updateOperation(); return updateOperation();
} }
ReturnValue_t PlocSupvHelper::continueUpdate() { ReturnValue_t PlocSupvUartManager::continueUpdate() {
ReturnValue_t result = prepareUpdate(); ReturnValue_t result = prepareUpdate();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
@ -350,7 +350,7 @@ ReturnValue_t PlocSupvHelper::continueUpdate() {
return updateOperation(); return updateOperation();
} }
ReturnValue_t PlocSupvHelper::updateOperation() { ReturnValue_t PlocSupvUartManager::updateOperation() {
sif::info << "PlocSupvHelper::performUpdate: Writing Update Packets" << std::endl; sif::info << "PlocSupvHelper::performUpdate: Writing Update Packets" << std::endl;
auto result = writeUpdatePackets(); auto result = writeUpdatePackets();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
@ -360,7 +360,7 @@ ReturnValue_t PlocSupvHelper::updateOperation() {
return handleCheckMemoryCommand(); return handleCheckMemoryCommand();
} }
ReturnValue_t PlocSupvHelper::writeUpdatePackets() { ReturnValue_t PlocSupvUartManager::writeUpdatePackets() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
#if OBSW_DEBUG_PLOC_SUPERVISOR == 1 #if OBSW_DEBUG_PLOC_SUPERVISOR == 1
ProgressPrinter progressPrinter("Supervisor update", update.fullFileSize, ProgressPrinter progressPrinter("Supervisor update", update.fullFileSize,
@ -437,7 +437,7 @@ ReturnValue_t PlocSupvHelper::writeUpdatePackets() {
return result; 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); 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; // return result;
// } // }
ReturnValue_t PlocSupvHelper::handleRemainingExeReport(ploc::SpTmReader& reader) { ReturnValue_t PlocSupvUartManager::handleRemainingExeReport(ploc::SpTmReader& reader) {
size_t remBytes = reader.getPacketDataLen() + 1; size_t remBytes = reader.getPacketDataLen() + 1;
ReturnValue_t result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN); ReturnValue_t result = handleTmReception(remBytes, tmBuf.data() + ccsds::HEADER_LEN);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
@ -495,7 +495,7 @@ ReturnValue_t PlocSupvHelper::handleRemainingExeReport(ploc::SpTmReader& reader)
return result; return result;
} }
ReturnValue_t PlocSupvHelper::selectMemory() { ReturnValue_t PlocSupvUartManager::selectMemory() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
resetSpParams(); resetSpParams();
supv::MPSoCBootSelect packet(spParams); supv::MPSoCBootSelect packet(spParams);
@ -510,7 +510,7 @@ ReturnValue_t PlocSupvHelper::selectMemory() {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t PlocSupvHelper::prepareUpdate() { ReturnValue_t PlocSupvUartManager::prepareUpdate() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
resetSpParams(); resetSpParams();
supv::NoPayloadPacket packet(spParams, Apid::BOOT_MAN, supv::NoPayloadPacket packet(spParams, Apid::BOOT_MAN,
@ -526,7 +526,7 @@ ReturnValue_t PlocSupvHelper::prepareUpdate() {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t PlocSupvHelper::eraseMemory() { ReturnValue_t PlocSupvUartManager::eraseMemory() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
resetSpParams(); resetSpParams();
supv::EraseMemory eraseMemory(spParams); supv::EraseMemory eraseMemory(spParams);
@ -542,8 +542,8 @@ ReturnValue_t PlocSupvHelper::eraseMemory() {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t PlocSupvHelper::handlePacketTransmissionNoReply(supv::TcBase& packet, ReturnValue_t PlocSupvUartManager::handlePacketTransmissionNoReply(
uint32_t timeoutExecutionReport) { supv::TcBase& packet, uint32_t timeoutExecutionReport) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
result = encodeAndSendPacket(packet.getFullPacket(), packet.getFullPacketLen()); result = encodeAndSendPacket(packet.getFullPacket(), packet.getFullPacketLen());
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
@ -599,7 +599,7 @@ ReturnValue_t PlocSupvHelper::handlePacketTransmissionNoReply(supv::TcBase& pack
return returnvalue::OK; 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 if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::ACK) or
serviceId == static_cast<uint8_t>(supv::tm::TmtcId::NAK)) { serviceId == static_cast<uint8_t>(supv::tm::TmtcId::NAK)) {
AcknowledgmentReport ackReport(tmReader); AcknowledgmentReport ackReport(tmReader);
@ -629,7 +629,8 @@ int PlocSupvHelper::handleAckReception(supv::TcBase& tc, uint8_t serviceId, size
return 0; 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 if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_ACK) or
serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK)) { serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK)) {
ExecutionReport exeReport(tmReader); ExecutionReport exeReport(tmReader);
@ -659,7 +660,7 @@ int PlocSupvHelper::handleExeAckReception(supv::TcBase& tc, uint8_t serviceId, s
return 0; return 0;
} }
ReturnValue_t PlocSupvHelper::checkReceivedTm() { ReturnValue_t PlocSupvUartManager::checkReceivedTm() {
ReturnValue_t result = tmReader.checkSize(); ReturnValue_t result = tmReader.checkSize();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
triggerEvent(SUPV_REPLY_SIZE_MISSMATCH, rememberApid); triggerEvent(SUPV_REPLY_SIZE_MISSMATCH, rememberApid);
@ -673,7 +674,7 @@ ReturnValue_t PlocSupvHelper::checkReceivedTm() {
return result; return result;
} }
ReturnValue_t PlocSupvHelper::calcImageCrc() { ReturnValue_t PlocSupvUartManager::calcImageCrc() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
if (update.fullFileSize == 0) { if (update.fullFileSize == 0) {
return returnvalue::FAILED; return returnvalue::FAILED;
@ -719,7 +720,7 @@ ReturnValue_t PlocSupvHelper::calcImageCrc() {
return result; return result;
} }
ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() { ReturnValue_t PlocSupvUartManager::handleCheckMemoryCommand() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
resetSpParams(); resetSpParams();
supv::CheckMemory packet(spParams); supv::CheckMemory packet(spParams);
@ -815,7 +816,7 @@ ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
return result; return result;
} }
uint32_t PlocSupvHelper::getFileSize(std::string filename) { uint32_t PlocSupvUartManager::getFileSize(std::string filename) {
std::ifstream file(filename, std::ifstream::binary); std::ifstream file(filename, std::ifstream::binary);
file.seekg(0, file.end); file.seekg(0, file.end);
uint32_t size = file.tellg(); uint32_t size = file.tellg();
@ -823,7 +824,7 @@ uint32_t PlocSupvHelper::getFileSize(std::string filename) {
return size; return size;
} }
ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reader) { ReturnValue_t PlocSupvUartManager::handleEventBufferReception(ploc::SpTmReader& reader) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
// TODO: Fix // TODO: Fix
//#ifdef XIPHOS_Q7S //#ifdef XIPHOS_Q7S
@ -879,10 +880,10 @@ ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reade
return result; 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, ReturnValue_t PlocSupvUartManager::sendMessage(CookieIF* cookie, const uint8_t* sendData,
size_t sendLen) { size_t sendLen) {
if (sendData == nullptr or sendLen == 0) { if (sendData == nullptr or sendLen == 0) {
return FAILED; return FAILED;
} }
@ -895,13 +896,13 @@ ReturnValue_t PlocSupvHelper::sendMessage(CookieIF* cookie, const uint8_t* sendD
return encodeAndSendPacket(sendData, sendLen); 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; return returnvalue::OK;
} }
ReturnValue_t PlocSupvHelper::handleRunningLongerRequest() { ReturnValue_t PlocSupvUartManager::handleRunningLongerRequest() {
ReturnValue_t result = OK; ReturnValue_t result = OK;
switch (request) { switch (request) {
case Request::UPDATE: { case Request::UPDATE: {
@ -949,7 +950,7 @@ ReturnValue_t PlocSupvHelper::handleRunningLongerRequest() {
return false; 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; size_t encodedLen = 0;
hdlc_add_framing(sendData, sendLen, encodedSendBuf.data(), &encodedLen); hdlc_add_framing(sendData, sendLen, encodedSendBuf.data(), &encodedLen);
size_t bytesWritten = write(serialPort, 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; return returnvalue::OK;
} }
ReturnValue_t PlocSupvHelper::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, ReturnValue_t PlocSupvUartManager::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
size_t* size) { size_t* size) {
MutexGuard mg(ipcLock); MutexGuard mg(ipcLock);
if (ipcQueue.empty()) { if (ipcQueue.empty()) {
*size = 0; *size = 0;
@ -977,7 +978,7 @@ ReturnValue_t PlocSupvHelper::readReceivedMessage(CookieIF* cookie, uint8_t** bu
return OK; return OK;
} }
ReturnValue_t PlocSupvHelper::tryHdlcParsing() { ReturnValue_t PlocSupvUartManager::tryHdlcParsing() {
size_t bytesRead = 0; size_t bytesRead = 0;
ReturnValue_t result = parseRecRingBufForHdlc(bytesRead); ReturnValue_t result = parseRecRingBufForHdlc(bytesRead);
if (result == returnvalue::OK) { if (result == returnvalue::OK) {
@ -1001,7 +1002,7 @@ ReturnValue_t PlocSupvHelper::tryHdlcParsing() {
return result; return result;
} }
ReturnValue_t PlocSupvHelper::parseRecRingBufForHdlc(size_t& readSize) { ReturnValue_t PlocSupvUartManager::parseRecRingBufForHdlc(size_t& readSize) {
size_t availableData = recRingBuf.getAvailableReadData(); size_t availableData = recRingBuf.getAvailableReadData();
if (availableData == 0) { if (availableData == 0) {
return NO_PACKET_FOUND; return NO_PACKET_FOUND;
@ -1043,17 +1044,17 @@ ReturnValue_t PlocSupvHelper::parseRecRingBufForHdlc(size_t& readSize) {
return NO_PACKET_FOUND; 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); MutexGuard mg(ipcLock);
ipcRingBuf.writeData(data, len); ipcRingBuf.writeData(data, len);
ipcQueue.insert(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; return (apid << 8) | serviceId;
} }
void PlocSupvHelper::performUartShutdown() { void PlocSupvUartManager::performUartShutdown() {
tcflush(serialPort, TCIOFLUSH); tcflush(serialPort, TCIOFLUSH);
// Clear ring buffers // Clear ring buffers
recRingBuf.clear(); recRingBuf.clear();

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

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