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

ploc mpsoc handler improved tc mem read
Some checks failed
EIVE/eive-obsw/pipeline/head There was a failure building this commit
Details

Browse Source
This commit is contained in:
Jakob Meier
2022-01-11 17:58:59 +01:00
parent f0bf743f88
commit 1133ea08c8
16 changed files with 389 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
bsp_q7s/devices/devicedefinitions/PlocMPSoCDefinitions.h
View File

@ -39,12 +39,13 @@ namespace apid {
/** Offset from first byte in space packet to first byte of data field */
static const uint8_t DATA_FIELD_OFFSET = 6;
static const size_t MEM_READ_RPT_LEN_OFFSET = 10;
/**
* The size of payload data which will be forwarded to the requesting object. e.g. PUS Service
* 8.
*/
static const uint8_t SIZE_MEM_READ_REPORT_DATA = 10;
static const uint8_t SIZE_MEM_READ_RPT_FIX = 6;
static const size_t MAX_FILENAME_SIZE = 256;
@ -55,7 +56,7 @@ static const size_t MAX_FILENAME_SIZE = 256;
static const uint16_t LENGTH_TC_MEM_WRITE = 12;
static const uint16_t LENGTH_TC_MEM_READ = 8;
static const size_t MAX_REPLY_SIZE = SpacePacket::PACKET_MAX_SIZE;
static const size_t MAX_REPLY_SIZE = SpacePacket::PACKET_MAX_SIZE * 3;
static const size_t MAX_COMMAND_SIZE = SpacePacket::PACKET_MAX_SIZE;
static const size_t MAX_DATA_SIZE = 1016;
@ -173,6 +174,10 @@ public:
this->setPacketDataLength(PACKET_LENGTH);
}
uint16_t getMemLen() const {
return memLen;
}
protected:
ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
@ -184,6 +189,13 @@ protected:
std::memcpy(this->localData.fields.buffer, commandData, MEM_ADDRESS_SIZE);
std::memcpy(this->localData.fields.buffer + MEM_ADDRESS_SIZE,
commandData + MEM_ADDRESS_SIZE, MEM_LEN_SIZE);
size_t size = sizeof(memLen);
const uint8_t* memLenPtr = commandData + MEM_ADDRESS_SIZE;
result = SerializeAdapter::deSerialize(&memLen, &memLenPtr, &size,
SerializeIF::Endianness::BIG);
if(result != RETURN_OK) {
return result;
}
return result;
}
@ -194,6 +206,8 @@ private:
static const size_t MEM_LEN_SIZE = 2;
static const uint16_t PACKET_LENGTH = 7;
uint16_t memLen = 0;
ReturnValue_t lengthCheck(size_t commandDataLen) {
if (commandDataLen != COMMAND_LENGTH){
return INVALID_LENGTH;

31
bsp_q7s/devices/ploc/PlocMPSoCHandler.cpp
View File

@ -40,8 +40,8 @@ ReturnValue_t PlocMPSoCHandler::initialize() {
return result;
}
result = manager->subscribeToEventRange(eventQueue->getId(),
event::getEventId(PlocMPSoCHelper::FLASH_WRITE_FAILED),
event::getEventId(PlocMPSoCHelper::FLASH_WRITE_SUCCESSFUL));
event::getEventId(PlocMPSoCHelper::MPSOC_FLASH_WRITE_FAILED),
event::getEventId(PlocMPSoCHelper::MPSOC_FLASH_WRITE_SUCCESSFUL));
if (result != RETURN_OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "PlocMPSoCHandler::initialize: Failed to subscribe to events from "
@ -189,7 +189,7 @@ ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t *start,
*foundId = mpsoc::ACK_REPORT;
break;
case(mpsoc::apid::TM_MEMORY_READ_REPORT):
*foundLen = mpsoc::SIZE_TM_MEM_READ_REPORT;
*foundLen = tmMemReadReport.rememberRequestedSize;
*foundId = mpsoc::TM_MEMORY_READ_REPORT;
break;
case(mpsoc::apid::EXE_SUCCESS):
@ -206,11 +206,11 @@ ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t *start,
return INVALID_APID;
}
}
sequenceCount++;
uint16_t recvSeqCnt = (*(start + 2) << 8 | *(start + 3)) & PACKET_SEQUENCE_COUNT_MASK;
if (recvSeqCnt != sequenceCount) {
triggerEvent(SEQ_CNT_MISMATCH, sequenceCount, recvSeqCnt);
triggerEvent(MPSOC_HANDLER_SEQ_CNT_MISMATCH, sequenceCount, recvSeqCnt);
sequenceCount = recvSeqCnt;
return result;
}
return result;
}
@ -293,6 +293,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcMemReadCommand(const uint8_t * commandD
return result;
}
copyToCommandBuffer(&tcMemRead);
tmMemReadReport.rememberRequestedSize = tcMemRead.getMemLen() * 4 + TmMemReadReport::FIX_SIZE;
return RETURN_OK;
}
@ -350,7 +351,7 @@ ReturnValue_t PlocMPSoCHandler::handleAckReport(const uint8_t* data) {
sif::error << "PlocMPSoCHandler::handleAckReport: CRC failure" << std::endl;
nextReplyId = mpsoc::NONE;
replyRawReplyIfnotWiretapped(data, mpsoc::SIZE_ACK_REPORT);
triggerEvent(CRC_FAILURE_EVENT);
triggerEvent(MPSOC_HANDLER_CRC_FAILURE);
sendFailureReport(mpsoc::ACK_REPORT, CRC_FAILURE);
disableAllReplies();
return IGNORE_REPLY_DATA;
@ -430,13 +431,15 @@ ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) {
ReturnValue_t PlocMPSoCHandler::handleMemoryReadReport(const uint8_t* data) {
ReturnValue_t result = RETURN_OK;
result = verifyPacket(data, mpsoc::SIZE_TM_MEM_READ_REPORT);
result = verifyPacket(data, tmMemReadReport.rememberRequestedSize);
if(result == CRC_FAILURE) {
sif::error << "PlocMPSoCHandler::handleMemoryReadReport: Memory read report has invalid crc"
<< std::endl;
}
uint16_t memLen = *(data + mpsoc::MEM_READ_RPT_LEN_OFFSET) << 8
| *(data + mpsoc::MEM_READ_RPT_LEN_OFFSET + 1);
/** Send data to commanding queue */
handleDeviceTM(data + mpsoc::DATA_FIELD_OFFSET, mpsoc::SIZE_MEM_READ_REPORT_DATA,
handleDeviceTM(data + mpsoc::DATA_FIELD_OFFSET, mpsoc::SIZE_MEM_READ_RPT_FIX + memLen * 4,
mpsoc::TM_MEMORY_READ_REPORT);
nextReplyId = mpsoc::EXE_REPORT;
return result;
@ -512,12 +515,22 @@ size_t PlocMPSoCHandler::getNextReplyLength(DeviceCommandId_t commandId){
}
DeviceReplyIter iter = deviceReplyMap.find(nextReplyId);
if (iter != deviceReplyMap.end()) {
if (iter->second.delayCycles == 0) {
/* Reply inactive */
return replyLen;
}
replyLen = iter->second.replyLen;
switch(nextReplyId) {
case mpsoc::TM_MEMORY_READ_REPORT: {
replyLen = tmMemReadReport.rememberRequestedSize;
break;
}
default: {
replyLen = iter->second.replyLen;
break;
}
}
}
else {
sif::debug << "PlocMPSoCHandler::getNextReplyLength: No entry for reply with reply id "

12
bsp_q7s/devices/ploc/PlocMPSoCHandler.h
View File

@ -82,11 +82,11 @@ private:
//! [EXPORT] : [COMMENT] PLOC receive execution failure report
static const Event EXE_FAILURE = MAKE_EVENT(3, severity::LOW);
//! [EXPORT] : [COMMENT] PLOC reply has invalid crc
static const Event CRC_FAILURE_EVENT = MAKE_EVENT(4, severity::LOW);
static const Event MPSOC_HANDLER_CRC_FAILURE = MAKE_EVENT(4, severity::LOW);
//! [EXPORT] : [COMMENT] Packet sequence count in received space packet does not match expected count
//! P1: Expected sequence count
//! P2: Received sequence count
static const Event SEQ_CNT_MISMATCH = MAKE_EVENT(5, severity::LOW);
static const Event MPSOC_HANDLER_SEQ_CNT_MISMATCH = MAKE_EVENT(5, severity::LOW);
static const uint16_t APID_MASK = 0x7FF;
static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
@ -111,6 +111,14 @@ private:
// Used to block incoming commands when MPSoC helper class is currently executing a command
bool plocMPSoCHelperExecuting = false;
class TmMemReadReport {
public:
static const uint8_t FIX_SIZE = 14;
size_t rememberRequestedSize = 0;
};
TmMemReadReport tmMemReadReport;
/**
* @brief Handles events received from the PLOC MPSoC helper
*/

6
bsp_q7s/devices/ploc/PlocMPSoCHelper.cpp
View File

@ -32,10 +32,10 @@ ReturnValue_t PlocMPSoCHelper::performOperation(uint8_t operationCode) {
case InternalState::FLASH_WRITE: {
result = performFlashWrite();
if (result == RETURN_OK){
triggerEvent(FLASH_WRITE_SUCCESSFUL);
triggerEvent(MPSOC_FLASH_WRITE_SUCCESSFUL);
}
else {
triggerEvent(FLASH_WRITE_FAILED);
triggerEvent(MPSOC_FLASH_WRITE_FAILED);
}
internalState = InternalState::IDLE;
break;
@ -215,7 +215,7 @@ ReturnValue_t PlocMPSoCHelper::handleTmReception(mpsoc::TmPacket* tmPacket, size
}
uint16_t recvSeqCnt = tmPacket->getPacketSequenceCount();
if (recvSeqCnt != *sequenceCount) {
triggerEvent(SEQ_CNT_MISMATCH, *sequenceCount, recvSeqCnt);
triggerEvent(MPSOC_HELPER_SEQ_CNT_MISMATCH, *sequenceCount, recvSeqCnt);
*sequenceCount = recvSeqCnt;
return result;
}

6
bsp_q7s/devices/ploc/PlocMPSoCHelper.h
View File

@ -23,9 +23,9 @@ public:
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HELPER;
//! [EXPORT] : [COMMENT] Flash write fails
static const Event FLASH_WRITE_FAILED = MAKE_EVENT(0, severity::LOW);
static const Event MPSOC_FLASH_WRITE_FAILED = MAKE_EVENT(0, severity::LOW);
//! [EXPORT] : [COMMENT] Flash write successful
static const Event FLASH_WRITE_SUCCESSFUL = MAKE_EVENT(1, severity::LOW);
static const Event MPSOC_FLASH_WRITE_SUCCESSFUL = MAKE_EVENT(1, severity::LOW);
//! [EXPORT] : [COMMENT] Communication interface returned failure when trying to send the command ot the PLOC
//!P1: Return value returned by the communication interface sendMessage function
//!P2: Internal state of MPSoC helper
@ -63,7 +63,7 @@ public:
//! [EXPORT] : [COMMENT] Received sequence count does not match expected sequence count
//!P1: Expected sequence count
//!P2: Received sequence count
static const Event SEQ_CNT_MISMATCH = MAKE_EVENT(11, severity::LOW);
static const Event MPSOC_HELPER_SEQ_CNT_MISMATCH = MAKE_EVENT(11, severity::LOW);
PlocMPSoCHelper(object_id_t objectId);
virtual ~PlocMPSoCHelper();

4
bsp_q7s/devices/startracker/StarTrackerHandler.cpp
View File

@ -52,8 +52,8 @@ ReturnValue_t StarTrackerHandler::initialize() {
return result;
}
result = manager->subscribeToEventRange(eventQueue->getId(),
event::getEventId(StrHelper::IMAGE_UPLOAD_FAILED),
event::getEventId(StrHelper::FPGA_UPLOAD_FAILED));
event::getEventId(StrHelper::STR_HELPER_IMAGE_UPLOAD_FAILED),
event::getEventId(StrHelper::STR_HELPER_FPGA_UPLOAD_FAILED));
if (result != RETURN_OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "StarTrackerHandler::initialize: Failed to subscribe to events from "

26
bsp_q7s/devices/startracker/StrHelper.cpp
View File

@ -32,10 +32,10 @@ ReturnValue_t StrHelper::performOperation(uint8_t operationCode) {
case InternalState::UPLOAD_IMAGE: {
result = performImageUpload();
if (result == RETURN_OK){
triggerEvent(IMAGE_UPLOAD_SUCCESSFUL);
triggerEvent(STR_HELPER_IMAGE_UPLOAD_SUCCESSFUL);
}
else {
triggerEvent(IMAGE_UPLOAD_FAILED);
triggerEvent(STR_HELPER_IMAGE_UPLOAD_FAILED);
}
internalState = InternalState::IDLE;
break;
@ -43,10 +43,10 @@ ReturnValue_t StrHelper::performOperation(uint8_t operationCode) {
case InternalState::DOWNLOAD_IMAGE: {
result = performImageDownload();
if (result == RETURN_OK){
triggerEvent(IMAGE_DOWNLOAD_SUCCESSFUL);
triggerEvent(STR_HELPER_IMAGE_DOWNLOAD_SUCCESSFUL);
}
else {
triggerEvent(IMAGE_DOWNLOAD_FAILED);
triggerEvent(STR_HELPER_IMAGE_DOWNLOAD_FAILED);
}
internalState = InternalState::IDLE;
break;
@ -54,10 +54,10 @@ ReturnValue_t StrHelper::performOperation(uint8_t operationCode) {
case InternalState::FLASH_WRITE: {
result = performFlashWrite();
if (result == RETURN_OK){
triggerEvent(FLASH_WRITE_SUCCESSFUL);
triggerEvent(STR_HELPER_FLASH_WRITE_SUCCESSFUL);
}
else {
triggerEvent(FLASH_WRITE_FAILED);
triggerEvent(STR_HELPER_FLASH_WRITE_FAILED);
}
internalState = InternalState::IDLE;
break;
@ -65,10 +65,10 @@ ReturnValue_t StrHelper::performOperation(uint8_t operationCode) {
case InternalState::FLASH_READ: {
result = performFlashRead();
if (result == RETURN_OK){
triggerEvent(FLASH_READ_SUCCESSFUL);
triggerEvent(STR_HELPER_FLASH_READ_SUCCESSFUL);
}
else {
triggerEvent(FLASH_READ_FAILED);
triggerEvent(STR_HELPER_FLASH_READ_FAILED);
}
internalState = InternalState::IDLE;
break;
@ -76,10 +76,10 @@ ReturnValue_t StrHelper::performOperation(uint8_t operationCode) {
case InternalState::DOWNLOAD_FPGA_IMAGE: {
result = performFpgaDownload();
if (result == RETURN_OK){
triggerEvent(FPGA_DOWNLOAD_SUCCESSFUL);
triggerEvent(STR_HELPER_FPGA_DOWNLOAD_SUCCESSFUL);
}
else {
triggerEvent(FPGA_DOWNLOAD_FAILED);
triggerEvent(STR_HELPER_FPGA_DOWNLOAD_FAILED);
}
internalState = InternalState::IDLE;
break;
@ -87,10 +87,10 @@ ReturnValue_t StrHelper::performOperation(uint8_t operationCode) {
case InternalState::UPLOAD_FPGA_IMAGE: {
result = performFpgaUpload();
if (result == RETURN_OK){
triggerEvent(FPGA_UPLOAD_SUCCESSFUL);
triggerEvent(STR_HELPER_FPGA_UPLOAD_SUCCESSFUL);
}
else {
triggerEvent(FPGA_UPLOAD_FAILED);
triggerEvent(STR_HELPER_FPGA_UPLOAD_FAILED);
}
internalState = InternalState::IDLE;
break;
@ -608,7 +608,7 @@ ReturnValue_t StrHelper::checkReplyPosition(uint32_t expectedPosition) {
uint32_t receivedPosition = 0;
std::memcpy(&receivedPosition, datalinkLayer.getReply() + POS_OFFSET, sizeof(receivedPosition));
if (receivedPosition != expectedPosition) {
triggerEvent(POSITION_MISMATCH, receivedPosition);
triggerEvent(STR_HELPER_POSITION_MISMATCH, receivedPosition);
return RETURN_FAILED;
}
return RETURN_OK;

26
bsp_q7s/devices/startracker/StrHelper.h
View File

@ -25,29 +25,29 @@ public:
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::STR_HELPER;
//! [EXPORT] : [COMMENT] Image upload failed
static const Event IMAGE_UPLOAD_FAILED = MAKE_EVENT(0, severity::LOW);
static const Event STR_HELPER_IMAGE_UPLOAD_FAILED = MAKE_EVENT(0, severity::LOW);
//! [EXPORT] : [COMMENT] Image download failed
static const Event IMAGE_DOWNLOAD_FAILED = MAKE_EVENT(1, severity::LOW);
static const Event STR_HELPER_IMAGE_DOWNLOAD_FAILED = MAKE_EVENT(1, severity::LOW);
//! [EXPORT] : [COMMENT] Uploading image to star tracker was successfulop
static const Event IMAGE_UPLOAD_SUCCESSFUL = MAKE_EVENT(2, severity::LOW);
static const Event STR_HELPER_IMAGE_UPLOAD_SUCCESSFUL = MAKE_EVENT(2, severity::LOW);
//! [EXPORT] : [COMMENT] Image download was successful
static const Event IMAGE_DOWNLOAD_SUCCESSFUL = MAKE_EVENT(3, severity::LOW);
static const Event STR_HELPER_IMAGE_DOWNLOAD_SUCCESSFUL = MAKE_EVENT(3, severity::LOW);
//! [EXPORT] : [COMMENT] Finished flash write procedure successfully
static const Event FLASH_WRITE_SUCCESSFUL = MAKE_EVENT(4, severity::LOW);
static const Event STR_HELPER_FLASH_WRITE_SUCCESSFUL = MAKE_EVENT(4, severity::LOW);
//! [EXPORT] : [COMMENT] Finished flash read procedure successfully
static const Event FLASH_READ_SUCCESSFUL = MAKE_EVENT(5, severity::LOW);
static const Event STR_HELPER_FLASH_READ_SUCCESSFUL = MAKE_EVENT(5, severity::LOW);
//! [EXPORT] : [COMMENT] Flash write procedure failed
static const Event FLASH_WRITE_FAILED = MAKE_EVENT(6, severity::LOW);
static const Event STR_HELPER_FLASH_WRITE_FAILED = MAKE_EVENT(6, severity::LOW);
//! [EXPORT] : [COMMENT] Flash read procedure failed
static const Event FLASH_READ_FAILED = MAKE_EVENT(7, severity::LOW);
static const Event STR_HELPER_FLASH_READ_FAILED = MAKE_EVENT(7, severity::LOW);
//! [EXPORT] : [COMMENT] Download of FPGA image successful
static const Event FPGA_DOWNLOAD_SUCCESSFUL = MAKE_EVENT(8, severity::LOW);
static const Event STR_HELPER_FPGA_DOWNLOAD_SUCCESSFUL = MAKE_EVENT(8, severity::LOW);
//! [EXPORT] : [COMMENT] Download of FPGA image failed
static const Event FPGA_DOWNLOAD_FAILED = MAKE_EVENT(9, severity::LOW);
static const Event STR_HELPER_FPGA_DOWNLOAD_FAILED = MAKE_EVENT(9, severity::LOW);
//! [EXPORT] : [COMMENT] Upload of FPGA image successful
static const Event FPGA_UPLOAD_SUCCESSFUL = MAKE_EVENT(10, severity::LOW);
static const Event STR_HELPER_FPGA_UPLOAD_SUCCESSFUL = MAKE_EVENT(10, severity::LOW);
//! [EXPORT] : [COMMENT] Upload of FPGA image failed
static const Event FPGA_UPLOAD_FAILED = MAKE_EVENT(11, severity::LOW);
static const Event STR_HELPER_FPGA_UPLOAD_FAILED = MAKE_EVENT(11, severity::LOW);
//! [EXPORT] : [COMMENT] Failed to read communication interface reply data
//!P1: Return code of failed communication interface read call
//!P1: Upload/download position for which the read call failed
@ -65,7 +65,7 @@ public:
static const Event STR_HELPER_DEC_ERROR = MAKE_EVENT(15, severity::LOW);
//! [EXPORT] : [COMMENT] Position mismatch
//!P1: The expected position and thus the position for which the image upload/download failed
static const Event POSITION_MISMATCH = MAKE_EVENT(16, severity::LOW);
static const Event STR_HELPER_POSITION_MISMATCH = MAKE_EVENT(16, severity::LOW);
//! [EXPORT] : [COMMENT] Specified file does not exist
//!P1: Internal state of str helper
static const Event STR_HELPER_FILE_NOT_EXISTS = MAKE_EVENT(17, severity::LOW);