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

implemented the last tricky parts

Browse Source
This commit is contained in:
Robin Müller 2022-11-08 16:26:30 +01:00
parent f564fb5c1a
commit 28cd78db96
No known key found for this signature in database
GPG Key ID: 71B58F8A3CDFA9AC
5 changed files with 297 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

151
linux/devices/devicedefinitions/PlocSupervisorDefinitions.h
View File

@ -70,6 +70,8 @@ static const ReturnValue_t UPDATE_CRC_FAILURE = MAKE_RETURN_CODE(0xB2);
static const ReturnValue_t SUPV_HELPER_EXECUTING = MAKE_RETURN_CODE(0xB3); static const ReturnValue_t SUPV_HELPER_EXECUTING = MAKE_RETURN_CODE(0xB3);
static constexpr ReturnValue_t BUF_TOO_SMALL = MAKE_RETURN_CODE(0xC0); static constexpr ReturnValue_t BUF_TOO_SMALL = MAKE_RETURN_CODE(0xC0);
static constexpr ReturnValue_t NO_REPLY_TIMEOUT = MAKE_RETURN_CODE(0xC1);
}; // namespace result }; // namespace result
static constexpr uint16_t DEFAULT_SEQ_COUNT = 0; static constexpr uint16_t DEFAULT_SEQ_COUNT = 0;
@ -270,6 +272,7 @@ namespace timeout {
// Erase memory can require up to 60 seconds for execution // Erase memory can require up to 60 seconds for execution
static const uint32_t ERASE_MEMORY = 60000; static const uint32_t ERASE_MEMORY = 60000;
static const uint32_t UPDATE_STATUS_REPORT = 70000; static const uint32_t UPDATE_STATUS_REPORT = 70000;
static const uint32_t CRC_EXECUTION_TIMEOUT = 60000;
} // namespace timeout } // namespace timeout
static constexpr size_t TIMESTAMP_LEN = 7; static constexpr size_t TIMESTAMP_LEN = 7;
@ -421,6 +424,8 @@ class TcBase : public ploc::SpTcBase {
payloadStart[supv::PAYLOAD_OFFSET] = id; payloadStart[supv::PAYLOAD_OFFSET] = id;
} }
uint8_t getServiceId() const { return payloadStart[supv::PAYLOAD_OFFSET]; }
static size_t fullSpDataLenFromPayloadLen(size_t payloadLen) { static size_t fullSpDataLenFromPayloadLen(size_t payloadLen) {
return SECONDARY_HEADER_LEN + payloadLen + CRC_LEN; return SECONDARY_HEADER_LEN + payloadLen + CRC_LEN;
} }
@ -1168,19 +1173,11 @@ class AcknowledgmentReport : public VerificationReport {
AcknowledgmentReport(TmBase& readerBase) : VerificationReport(readerBase) {} AcknowledgmentReport(TmBase& readerBase) : VerificationReport(readerBase) {}
virtual ReturnValue_t parse() override { virtual ReturnValue_t parse() override {
// if (readerBase.getServiceId() != ) if (readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::ACK) and
// uint16_t apid = this->getApid(); readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::NAK)) {
// if (apid == APID_ACK_SUCCESS) { return returnvalue::FAILED;
// return returnvalue::OK; }
// } else if (apid == APID_ACK_FAILURE) { return VerificationReport::parse();
// printStatusInformation();
// return SupvReturnValuesIF::RECEIVED_ACK_FAILURE;
// } else {
// sif::warning << "AcknowledgmentReport::checkApid: Invalid apid: 0x" << std::hex << apid
// << std::endl;
// return SupvReturnValuesIF::INVALID_APID;
// }
return OK;
} }
void printStatusInformation() { void printStatusInformation() {
@ -1244,78 +1241,12 @@ class ExecutionReport : public VerificationReport {
ExecutionReport(TmBase& readerBase) : VerificationReport(readerBase) {} ExecutionReport(TmBase& readerBase) : VerificationReport(readerBase) {}
ReturnValue_t parse() override { ReturnValue_t parse() override {
if (readerBase.getServiceId() == static_cast<uint8_t>(tm::TmtcId::EXEC_NAK)) { if (readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::EXEC_ACK) and
printStatusInformation(); readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::EXEC_NAK)) {
return result::RECEIVED_EXE_FAILURE; return returnvalue::FAILED;
} }
/* uint16_t apid = this->getApid(); return VerificationReport::parse();
if (apid == APID_EXE_SUCCESS) {
return returnvalue::OK;
} else if (apid == APID_EXE_FAILURE) {
printStatusInformation();
return SupvReturnValuesIF::RECEIVED_EXE_FAILURE;
} else {
sif::warning << "ExecutionReport::checkApid: Invalid apid: 0x" << std::hex << apid
<< std::endl;
return SupvReturnValuesIF::INVALID_APID;
}*/
return OK;
} }
private:
static constexpr char STATUS_PRINTOUT_PREFIX[] = "Supervisor execution failure report status: ";
enum class StatusCode : uint16_t {
OK = 0x0,
INIT_ERROR = 0x1,
BAD_PARAM = 0x2,
NOT_INITIALIZED = 0x3,
BAD_PERIPH_ID = 0x4,
TIMEOUT = 0x5,
RX_ERROR = 0x6,
TX_ERROR = 0x7,
BUF_EMPTY = 0x8,
BUF_FULL = 0x9,
NAK = 0xA,
ARB_LOST = 0xB,
BUSY = 0xC,
NOT_IMPLEMENTED = 0xD,
ALIGNEMENT_ERROR = 0xE,
PERIPH_ERR = 0xF,
FAILED_LATCH = 0x10,
GPIO_HIGH = 0x11,
GPIO_LOW = 0x12,
TEST_PASSED = 0x13,
TEST_FAILED = 0x14,
NOTHING_TODO = 0x100,
POWER_FAULT = 0x101,
INVALID_LENGTH = 0x102,
OUT_OF_RANGE = 0x103,
OUT_OF_HEAP_MEMORY = 0x104,
INVALID_STATE_TRANSITION = 0x105,
MPSOC_ALREADY_BOOTING = 0x106,
MPSOC_ALREADY_OPERATIONAL = 0x107,
MPSOC_BOOT_FAILED = 0x108,
SP_NOT_AVAILABLE = 0x200,
SP_DATA_INSUFFICIENT = 0x201,
SP_MEMORY_ID_INVALID = 0x202,
MPSOC_NOT_IN_RESET = 0x203,
FLASH_INIT_FAILED = 0x204,
FLASH_ERASE_FAILED = 0x205,
FLASH_WRITE_FAILED = 0x206,
FLASH_VERIFY_FAILED = 0x207,
CANNOT_ACCESS_TM = 0x208,
CANNOT_SEND_TM = 0x209,
PG_LOW = 0x300,
PG_5V_LOW = 0x301,
PG_0V85_LOW = 0x302,
PG_1V8_LOW = 0x303,
PG_MISC_LOW = 0x304,
PG_3V3_LOW = 0x305,
PG_MB_VAIO_LOW = 0x306,
PG_MB_MPSOCIO_LOW = 0x307
};
void printStatusInformation() { void printStatusInformation() {
StatusCode statusCode = static_cast<StatusCode>(getStatusCode()); StatusCode statusCode = static_cast<StatusCode>(getStatusCode());
switch (statusCode) { switch (statusCode) {
@ -1520,6 +1451,60 @@ class ExecutionReport : public VerificationReport {
break; break;
} }
} }
private:
static constexpr char STATUS_PRINTOUT_PREFIX[] = "Supervisor execution failure report status: ";
enum class StatusCode : uint16_t {
OK = 0x0,
INIT_ERROR = 0x1,
BAD_PARAM = 0x2,
NOT_INITIALIZED = 0x3,
BAD_PERIPH_ID = 0x4,
TIMEOUT = 0x5,
RX_ERROR = 0x6,
TX_ERROR = 0x7,
BUF_EMPTY = 0x8,
BUF_FULL = 0x9,
NAK = 0xA,
ARB_LOST = 0xB,
BUSY = 0xC,
NOT_IMPLEMENTED = 0xD,
ALIGNEMENT_ERROR = 0xE,
PERIPH_ERR = 0xF,
FAILED_LATCH = 0x10,
GPIO_HIGH = 0x11,
GPIO_LOW = 0x12,
TEST_PASSED = 0x13,
TEST_FAILED = 0x14,
NOTHING_TODO = 0x100,
POWER_FAULT = 0x101,
INVALID_LENGTH = 0x102,
OUT_OF_RANGE = 0x103,
OUT_OF_HEAP_MEMORY = 0x104,
INVALID_STATE_TRANSITION = 0x105,
MPSOC_ALREADY_BOOTING = 0x106,
MPSOC_ALREADY_OPERATIONAL = 0x107,
MPSOC_BOOT_FAILED = 0x108,
SP_NOT_AVAILABLE = 0x200,
SP_DATA_INSUFFICIENT = 0x201,
SP_MEMORY_ID_INVALID = 0x202,
MPSOC_NOT_IN_RESET = 0x203,
FLASH_INIT_FAILED = 0x204,
FLASH_ERASE_FAILED = 0x205,
FLASH_WRITE_FAILED = 0x206,
FLASH_VERIFY_FAILED = 0x207,
CANNOT_ACCESS_TM = 0x208,
CANNOT_SEND_TM = 0x209,
PG_LOW = 0x300,
PG_5V_LOW = 0x301,
PG_0V85_LOW = 0x302,
PG_1V8_LOW = 0x303,
PG_MISC_LOW = 0x304,
PG_3V3_LOW = 0x305,
PG_MB_VAIO_LOW = 0x306,
PG_MB_MPSOCIO_LOW = 0x307
};
}; };
/** /**

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

@ -60,10 +60,10 @@ ReturnValue_t PlocSupervisorHandler::initialize() {
sif::warning << "PlocSupervisorHandler::initialize: Invalid supervisor helper" << std::endl; sif::warning << "PlocSupervisorHandler::initialize: Invalid supervisor helper" << std::endl;
return ObjectManagerIF::CHILD_INIT_FAILED; return ObjectManagerIF::CHILD_INIT_FAILED;
} }
result = supvHelper->setComIF(uartComIf); // result = supvHelper->setComIF(uartComIf);
if (result != returnvalue::OK) { // if (result != returnvalue::OK) {
return ObjectManagerIF::CHILD_INIT_FAILED; // return ObjectManagerIF::CHILD_INIT_FAILED;
} // }
// supvHelper->setComCookie(comCookie); // supvHelper->setComCookie(comCookie);
result = eventSubscription(); result = eventSubscription();

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

@ -29,12 +29,13 @@ using namespace supv;
PlocSupvHelper::PlocSupvHelper(object_id_t objectId) PlocSupvHelper::PlocSupvHelper(object_id_t objectId)
: SystemObject(objectId), : SystemObject(objectId),
recRingBuf(4096, true), recRingBuf(4096, true),
decodedRingBuf(1200 * MAX_STORED_DECODED_PACKETS, true),
ipcRingBuf(1200 * MAX_STORED_DECODED_PACKETS, true) { ipcRingBuf(1200 * MAX_STORED_DECODED_PACKETS, true) {
spParams.maxSize = sizeof(commandBuffer);
resetSpParams(); resetSpParams();
semaphore = SemaphoreFactory::instance()->createBinarySemaphore(); semaphore = SemaphoreFactory::instance()->createBinarySemaphore();
semaphore->acquire(); semaphore->acquire();
lock = MutexFactory::instance()->createMutex(); lock = MutexFactory::instance()->createMutex();
ipcLock = MutexFactory::instance()->createMutex();
} }
PlocSupvHelper::~PlocSupvHelper() = default; PlocSupvHelper::~PlocSupvHelper() = default;
@ -158,14 +159,14 @@ bool PlocSupvHelper::handleUartReception() {
return false; return false;
} }
ReturnValue_t PlocSupvHelper::setComIF(UartComIF* uartComIF_) { // ReturnValue_t PlocSupvHelper::setComIF(UartComIF* uartComIF_) {
if (uartComIF_ == nullptr) { // if (uartComIF_ == nullptr) {
sif::warning << "PlocSupvHelper::initialize: Provided invalid uart com if" << std::endl; // sif::warning << "PlocSupvHelper::initialize: Provided invalid uart com if" << std::endl;
return returnvalue::FAILED; // return returnvalue::FAILED;
} // }
uartComIF = uartComIF_; // //uartComIF = uartComIF_;
return returnvalue::OK; // return returnvalue::OK;
} // }
// void PlocSupvHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; } // void PlocSupvHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; }
@ -431,7 +432,8 @@ ReturnValue_t PlocSupvHelper::writeUpdatePackets() {
update.bytesWritten); update.bytesWritten);
return result; return result;
} }
result = handlePacketTransmission(packet); // TODO: Fix
// result = handlePacketTransmission(packet);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
triggerEvent(WRITE_MEMORY_FAILED, buildProgParams1(progPercent, update.sequenceCount), triggerEvent(WRITE_MEMORY_FAILED, buildProgParams1(progPercent, update.sequenceCount),
update.bytesWritten); update.bytesWritten);
@ -514,7 +516,7 @@ ReturnValue_t PlocSupvHelper::selectMemory() {
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
result = handlePacketTransmission(packet); result = handlePacketTransmissionNoReply(packet);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
@ -530,7 +532,7 @@ ReturnValue_t PlocSupvHelper::prepareUpdate() {
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
result = handlePacketTransmission(packet, PREPARE_UPDATE_EXECUTION_REPORT); result = handlePacketTransmissionNoReply(packet, PREPARE_UPDATE_EXECUTION_REPORT);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
@ -546,140 +548,131 @@ ReturnValue_t PlocSupvHelper::eraseMemory() {
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
result = handlePacketTransmission(eraseMemory, supv::timeout::ERASE_MEMORY); result = handlePacketTransmissionNoReply(eraseMemory, supv::timeout::ERASE_MEMORY);
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t PlocSupvHelper::handlePacketTransmission(ploc::SpTcBase& packet, ReturnValue_t PlocSupvHelper::handlePacketTransmissionNoReply(supv::TcBase& packet,
uint32_t timeoutExecutionReport) { uint32_t timeoutExecutionReport) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
result = sendCommand(packet); result = encodeAndSendPacket(packet.getFullPacket(), packet.getFullPacketLen());
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; return result;
} }
result = handleAck(); Countdown countdown(timeoutExecutionReport);
bool ackReceived = false;
while (true) {
if (not decodedQueue.empty()) {
size_t packetLen = 0;
decodedQueue.retrieve(&packetLen);
decodedRingBuf.readData(decodedBuf.data(), packetLen);
tmReader.setData(decodedBuf.data(), packetLen);
result = checkReceivedTm();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
return result; continue;
}
if (tmReader.getApid() == Apid::TMTC_MAN) {
uint8_t serviceId = tmReader.getServiceId();
int retval = 0;
if (not ackReceived) {
retval = handleAckReception(packet, serviceId, packetLen);
if (retval == 1) {
ackReceived = true;
} else if (retval == -1) {
return returnvalue::FAILED;
}
} else {
retval = handleExeAckReception(packet, serviceId, packetLen);
if (retval == 1) {
break;
} else if (retval == -1) {
return returnvalue::FAILED;
}
}
} else {
pushIpcData(decodedBuf.data(), packetLen);
decodedRingBuf.deleteData(packetLen);
}
} else {
TaskFactory::delayTask(50);
}
if (countdown.hasTimedOut()) {
return result::NO_REPLY_TIMEOUT;
} }
result = handleExe(timeoutExecutionReport);
if (result != returnvalue::OK) {
return result;
} }
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t PlocSupvHelper::sendCommand(ploc::SpTcBase& packet) { int PlocSupvHelper::handleAckReception(supv::TcBase& tc, uint8_t serviceId, size_t packetLen) {
ReturnValue_t result = returnvalue::OK; if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::ACK) or
rememberApid = packet.getApid(); serviceId == static_cast<uint8_t>(supv::tm::TmtcId::NAK)) {
result = uartComIF->sendMessage(comCookie, packet.getFullPacket(), packet.getFullPacketLen()); AcknowledgmentReport ackReport(tmReader);
ReturnValue_t result = ackReport.parse();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
sif::warning << "PlocSupvHelper::sendCommand: Failed to send command" << std::endl; triggerEvent(ACK_RECEPTION_FAILURE);
triggerEvent(SUPV_SENDING_COMMAND_FAILED, result, static_cast<uint32_t>(state));
return result;
}
return result;
}
ReturnValue_t PlocSupvHelper::handleAck() {
ReturnValue_t result = returnvalue::OK;
// TODO: Fix
// result = handleTmReception(supv::SIZE_ACK_REPORT);
// if (result != returnvalue::OK) {
// triggerEvent(ACK_RECEPTION_FAILURE, result, static_cast<uint32_t>(rememberApid));
// sif::warning << "PlocSupvHelper::handleAck: Error in reception of acknowledgment report"
// << std::endl;
// return result;
// }
// supv::AcknowledgmentReport ackReport(tmBuf.data(), tmBuf.size());
// result = checkReceivedTm(ackReport);
// if (result != returnvalue::OK) {
// return result;
// }
// result = ackReport.checkApid();
// if (result != returnvalue::OK) {
// if (result == SupvReturnValuesIF::RECEIVED_ACK_FAILURE) {
// triggerEvent(SUPV_ACK_FAILURE_REPORT, static_cast<uint32_t>(ackReport.getRefApid()));
// } else if (result == SupvReturnValuesIF::INVALID_APID) {
// triggerEvent(SUPV_ACK_INVALID_APID, static_cast<uint32_t>(rememberApid));
// }
// return result;
// }
return result;
}
ReturnValue_t PlocSupvHelper::handleExe(uint32_t timeout) {
ReturnValue_t result = returnvalue::OK;
result = handleTmReception(supv::SIZE_EXE_REPORT, tmBuf.data(), timeout);
if (result != returnvalue::OK) {
triggerEvent(EXE_RECEPTION_FAILURE, result, static_cast<uint32_t>(rememberApid));
sif::warning << "PlocSupvHelper::handleExe: Error in reception of execution report"
<< std::endl;
return result;
}
return exeReportHandling();
}
ReturnValue_t PlocSupvHelper::exeReportHandling() {
// TODO: Fix
// supv::ExecutionReport exeReport(tmBuf.data(), tmBuf.size());
//
// ReturnValue_t result = checkReceivedTm(exeReport);
// if (result != returnvalue::OK) {
// return result;
// }
// result = exeReport.checkApid();
// if (result != returnvalue::OK) {
// if (result == SupvReturnValuesIF::RECEIVED_EXE_FAILURE) {
// triggerEvent(SUPV_EXE_FAILURE_REPORT, static_cast<uint32_t>(exeReport.getRefApid()));
// } else if (result == SupvReturnValuesIF::INVALID_APID) {
// triggerEvent(SUPV_EXE_INVALID_APID, static_cast<uint32_t>(rememberApid));
// }
// return result;
// }
return OK;
}
ReturnValue_t PlocSupvHelper::handleTmReception(size_t remainingBytes, uint8_t* readBuf,
uint32_t timeout) {
ReturnValue_t result = returnvalue::OK;
size_t readBytes = 0;
size_t currentBytes = 0;
Countdown countdown(timeout);
if (readBuf == nullptr) {
readBuf = tmBuf.data();
}
while (!countdown.hasTimedOut()) {
result = receive(readBuf + readBytes, &currentBytes, remainingBytes);
if (result != returnvalue::OK) {
return result;
}
readBytes += currentBytes;
remainingBytes = remainingBytes - currentBytes;
if (remainingBytes == 0) {
break;
}
}
if (remainingBytes != 0) {
sif::warning << "PlocSupvHelper::handleTmReception: Failed to read " << std::dec
<< remainingBytes << " remaining bytes" << std::endl;
return returnvalue::FAILED; return returnvalue::FAILED;
} }
return result; if (ackReport.getRefApid() == tc.getApid() and
ackReport.getRefServiceId() == tc.getServiceId()) {
if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::ACK)) {
return 1;
} else if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::NAK)) {
ackReport.printStatusInformation();
triggerEvent(SUPV_ACK_FAILURE_REPORT,
buildApidServiceParam1(ackReport.getRefApid(), ackReport.getRefServiceId()),
ackReport.getStatusCode());
return -1;
}
// Should never happen
return -1;
} else {
pushIpcData(decodedBuf.data(), packetLen);
decodedRingBuf.deleteData(packetLen);
}
}
return 0;
} }
ReturnValue_t PlocSupvHelper::checkReceivedTm(ploc::SpTmReader& reader) { int PlocSupvHelper::handleExeAckReception(supv::TcBase& tc, uint8_t serviceId, size_t packetLen) {
ReturnValue_t result = reader.checkSize(); 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);
ReturnValue_t result = exeReport.parse();
if (result != returnvalue::OK) {
triggerEvent(EXE_RECEPTION_FAILURE);
return returnvalue::FAILED;
}
if (exeReport.getRefApid() == tc.getApid() and
exeReport.getRefServiceId() == tc.getServiceId()) {
if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_ACK)) {
return 1;
} else if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK)) {
exeReport.printStatusInformation();
triggerEvent(SUPV_EXE_FAILURE_REPORT,
buildApidServiceParam1(exeReport.getRefApid(), exeReport.getRefServiceId()),
exeReport.getStatusCode());
return -1;
}
// Should never happen
return -1;
} else {
pushIpcData(decodedBuf.data(), packetLen);
decodedRingBuf.deleteData(packetLen);
}
}
return 0;
}
ReturnValue_t PlocSupvHelper::checkReceivedTm() {
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);
return result; return result;
} }
result = reader.checkCrc(); result = tmReader.checkCrc();
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
triggerEvent(SUPV_REPLY_CRC_MISSMATCH, rememberApid); triggerEvent(SUPV_REPLY_CRC_MISSMATCH, rememberApid);
return result; return result;
@ -687,30 +680,6 @@ ReturnValue_t PlocSupvHelper::checkReceivedTm(ploc::SpTmReader& reader) {
return result; return result;
} }
ReturnValue_t PlocSupvHelper::receive(uint8_t* data, size_t* readBytes, size_t requestBytes) {
ReturnValue_t result = returnvalue::OK;
uint8_t* buffer = nullptr;
result = uartComIF->requestReceiveMessage(comCookie, requestBytes);
if (result != returnvalue::OK) {
sif::warning << "PlocSupvHelper::receive: Failed to request reply" << std::endl;
triggerEvent(SUPV_HELPER_REQUESTING_REPLY_FAILED, result,
static_cast<uint32_t>(static_cast<uint32_t>(state)));
return returnvalue::FAILED;
}
result = uartComIF->readReceivedMessage(comCookie, &buffer, readBytes);
if (result != returnvalue::OK) {
sif::warning << "PlocSupvHelper::receive: Failed to read received message" << std::endl;
triggerEvent(SUPV_HELPER_READING_REPLY_FAILED, result, static_cast<uint32_t>(state));
return returnvalue::FAILED;
}
if (*readBytes > 0) {
std::memcpy(data, buffer, *readBytes);
} else {
TaskFactory::delayTask(40);
}
return result;
}
ReturnValue_t PlocSupvHelper::calcImageCrc() { ReturnValue_t PlocSupvHelper::calcImageCrc() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
if (update.fullFileSize == 0) { if (update.fullFileSize == 0) {
@ -760,20 +729,64 @@ ReturnValue_t PlocSupvHelper::calcImageCrc() {
ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() { ReturnValue_t PlocSupvHelper::handleCheckMemoryCommand() {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
// TODO: Fix // TODO: Fix
// resetSpParams(); resetSpParams();
// // Will hold status report for later processing // Will hold status report for later processing
// std::array<uint8_t, 32> statusReportBuf{}; // std::array<uint8_t, 32> statusReportBuf{};
// supv::UpdateStatusReport updateStatusReport(tmBuf.data(), tmBuf.size()); // supv::UpdateStatusReport updateStatusReport(tmBuf.data(), tmBuf.size());
// // Verification of update write procedure // Verification of update write procedure
// supv::CheckMemory packet(spParams); supv::CheckMemory packet(spParams);
// result = packet.buildPacket(update.memoryId, update.startAddress, update.fullFileSize); result = packet.buildPacket(update.memoryId, update.startAddress, update.fullFileSize);
// if (result != returnvalue::OK) { if (result != returnvalue::OK) {
// return result; return result;
// } }
// result = sendCommand(packet); result = encodeAndSendPacket(packet.getFullPacket(), packet.getFullPacketLen());
// if (result != returnvalue::OK) { if (result != returnvalue::OK) {
// return result; return result;
// } }
Countdown countdown(timeout::CRC_EXECUTION_TIMEOUT);
bool ackReceived = false;
bool checkReplyReceived = false;
while (true) {
if (not decodedQueue.empty()) {
size_t packetLen = 0;
decodedQueue.retrieve(&packetLen);
decodedRingBuf.readData(decodedBuf.data(), packetLen);
tmReader.setData(decodedBuf.data(), packetLen);
result = checkReceivedTm();
if (result != returnvalue::OK) {
continue;
}
if (tmReader.getApid() == Apid::TMTC_MAN) {
uint8_t serviceId = tmReader.getServiceId();
int retval = 0;
if (not ackReceived) {
retval = handleAckReception(packet, serviceId, packetLen);
if (retval == 1) {
ackReceived = true;
} else if (retval == -1) {
return returnvalue::FAILED;
}
} else if (not checkReplyReceived) {
// if (serviceId == )
retval = handleExeAckReception(packet, serviceId, packetLen);
if (retval == 1) {
break;
} else if (retval == -1) {
return returnvalue::FAILED;
}
}
} else {
pushIpcData(decodedBuf.data(), packetLen);
decodedRingBuf.deleteData(packetLen);
}
} else {
TaskFactory::delayTask(50);
}
if (countdown.hasTimedOut()) {
return result::NO_REPLY_TIMEOUT;
}
}
return returnvalue::OK;
// result = handleAck(); // result = handleAck();
// if (result != returnvalue::OK) { // if (result != returnvalue::OK) {
// return result; // return result;
@ -896,7 +909,7 @@ ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reade
return result; return result;
} }
void PlocSupvHelper::resetSpParams() { spParams.buf = commandBuffer; } void PlocSupvHelper::resetSpParams() { spParams.buf = cmdBuf.data(); }
ReturnValue_t PlocSupvHelper::sendMessage(CookieIF* cookie, const uint8_t* sendData, ReturnValue_t PlocSupvHelper::sendMessage(CookieIF* cookie, const uint8_t* sendData,
size_t sendLen) { size_t sendLen) {
@ -968,8 +981,8 @@ ReturnValue_t PlocSupvHelper::handleRunningLongerRequest() {
ReturnValue_t PlocSupvHelper::encodeAndSendPacket(const uint8_t* sendData, size_t sendLen) { ReturnValue_t PlocSupvHelper::encodeAndSendPacket(const uint8_t* sendData, size_t sendLen) {
size_t encodedLen = 0; size_t encodedLen = 0;
hdlc_add_framing(sendData, sendLen, sendBuf.data(), &encodedLen); hdlc_add_framing(sendData, sendLen, encodedSendBuf.data(), &encodedLen);
size_t bytesWritten = write(serialPort, sendBuf.data(), encodedLen); size_t bytesWritten = write(serialPort, encodedSendBuf.data(), encodedLen);
if (bytesWritten != encodedLen) { if (bytesWritten != encodedLen) {
sif::warning << "ScexUartReader::sendMessage: Sending ping command to solar experiment failed" sif::warning << "ScexUartReader::sendMessage: Sending ping command to solar experiment failed"
<< std::endl; << std::endl;
@ -980,7 +993,7 @@ ReturnValue_t PlocSupvHelper::encodeAndSendPacket(const uint8_t* sendData, size_
ReturnValue_t PlocSupvHelper::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, ReturnValue_t PlocSupvHelper::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
size_t* size) { size_t* size) {
MutexGuard mg(lock); MutexGuard mg(ipcLock);
if (ipcQueue.empty()) { if (ipcQueue.empty()) {
*size = 0; *size = 0;
return OK; return OK;
@ -999,7 +1012,14 @@ ReturnValue_t PlocSupvHelper::tryHdlcParsing() {
ReturnValue_t result = parseRecRingBufForHdlc(bytesRead); ReturnValue_t result = parseRecRingBufForHdlc(bytesRead);
if (result == returnvalue::OK) { if (result == returnvalue::OK) {
// Packet found, advance read pointer. // Packet found, advance read pointer.
if (state == InternalState::LONGER_REQUEST) {
decodedRingBuf.writeData(decodedBuf.data(), bytesRead);
decodedQueue.insert(bytesRead);
} else {
MutexGuard mg(ipcLock);
ipcRingBuf.writeData(decodedBuf.data(), bytesRead); ipcRingBuf.writeData(decodedBuf.data(), bytesRead);
ipcQueue.insert(bytesRead);
}
recRingBuf.deleteData(bytesRead); recRingBuf.deleteData(bytesRead);
} else if (result != NO_PACKET_FOUND) { } else if (result != NO_PACKET_FOUND) {
sif::warning << "ScexUartReader::performOperation: Possible packet loss" << std::endl; sif::warning << "ScexUartReader::performOperation: Possible packet loss" << std::endl;
@ -1053,10 +1073,28 @@ 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) {
MutexGuard mg(ipcLock);
ipcRingBuf.writeData(data, len);
ipcQueue.insert(len);
}
uint32_t PlocSupvHelper::buildApidServiceParam1(uint8_t apid, uint8_t serviceId) {
return (apid << 8) | serviceId;
}
void PlocSupvHelper::performUartShutdown() { void PlocSupvHelper::performUartShutdown() {
tcflush(serialPort, TCIOFLUSH); tcflush(serialPort, TCIOFLUSH);
// Clear ring buffers // Clear ring buffers
recRingBuf.clear(); recRingBuf.clear();
decodedRingBuf.clear();
while (not decodedQueue.empty()) {
decodedQueue.pop();
}
MutexGuard mg(ipcLock);
ipcRingBuf.clear(); ipcRingBuf.clear();
while (not ipcQueue.empty()) {
ipcQueue.pop();
}
state = InternalState::GO_TO_SLEEP; state = InternalState::GO_TO_SLEEP;
} }

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

@ -121,7 +121,7 @@ class PlocSupvHelper : public DeviceCommunicationIF,
ReturnValue_t initialize() override; ReturnValue_t initialize() override;
ReturnValue_t performOperation(uint8_t operationCode = 0) override; ReturnValue_t performOperation(uint8_t operationCode = 0) override;
ReturnValue_t setComIF(UartComIF* uartComfIF_); // ReturnValue_t setComIF(UartComIF* uartComfIF_);
// void setComCookie(CookieIF* comCookie_); // void setComCookie(CookieIF* comCookie_);
/** /**
@ -156,6 +156,7 @@ class PlocSupvHelper : public DeviceCommunicationIF,
void stop(); void stop();
static uint32_t buildProgParams1(uint8_t percent, uint16_t seqCount); static uint32_t buildProgParams1(uint8_t percent, uint16_t seqCount);
static uint32_t buildApidServiceParam1(uint8_t apid, uint8_t serviceId);
private: private:
static constexpr ReturnValue_t REQUEST_DONE = returnvalue::makeCode(1, 0); static constexpr ReturnValue_t REQUEST_DONE = returnvalue::makeCode(1, 0);
@ -171,7 +172,6 @@ class PlocSupvHelper : public DeviceCommunicationIF,
static const uint8_t NUM_EVENT_BUFFER_PACKETS = 25; static const uint8_t NUM_EVENT_BUFFER_PACKETS = 25;
static const size_t SIZE_EVENT_BUFFER_FULL_PACKET = 1024; static const size_t SIZE_EVENT_BUFFER_FULL_PACKET = 1024;
static const size_t SIZE_EVENT_BUFFER_LAST_PACKET = 200; static const size_t SIZE_EVENT_BUFFER_LAST_PACKET = 200;
static const uint32_t CRC_EXECUTION_TIMEOUT = 60000;
static const uint32_t PREPARE_UPDATE_EXECUTION_REPORT = 2000; static const uint32_t PREPARE_UPDATE_EXECUTION_REPORT = 2000;
static constexpr uint8_t MAX_STORED_DECODED_PACKETS = 4; static constexpr uint8_t MAX_STORED_DECODED_PACKETS = 4;
@ -200,6 +200,8 @@ class PlocSupvHelper : public DeviceCommunicationIF,
SemaphoreIF* semaphore; SemaphoreIF* semaphore;
MutexIF* lock; MutexIF* lock;
MutexIF* ipcLock;
supv::TmBase tmReader;
int serialPort = 0; int serialPort = 0;
struct termios tty = {}; struct termios tty = {};
@ -228,15 +230,17 @@ class PlocSupvHelper : public DeviceCommunicationIF,
SdCardManager* sdcMan = nullptr; SdCardManager* sdcMan = nullptr;
#endif #endif
SimpleRingBuffer recRingBuf; SimpleRingBuffer recRingBuf;
std::array<uint8_t, 2048> sendBuf = {}; std::array<uint8_t, 1200> cmdBuf = {};
std::array<uint8_t, 2048> encodedSendBuf = {};
std::array<uint8_t, 2048> recBuf = {}; std::array<uint8_t, 2048> recBuf = {};
std::array<uint8_t, 2048> encodedBuf = {}; std::array<uint8_t, 2048> encodedBuf = {};
std::array<uint8_t, 1200> decodedBuf = {}; std::array<uint8_t, 1200> decodedBuf = {};
std::array<uint8_t, 1200> ipcBuffer = {}; std::array<uint8_t, 1200> ipcBuffer = {};
SimpleRingBuffer decodedRingBuf;
FIFO<size_t, MAX_STORED_DECODED_PACKETS> decodedQueue;
SimpleRingBuffer ipcRingBuf; SimpleRingBuffer ipcRingBuf;
FIFO<size_t, MAX_STORED_DECODED_PACKETS> ipcQueue; FIFO<size_t, MAX_STORED_DECODED_PACKETS> ipcQueue;
uint8_t commandBuffer[supv::MAX_COMMAND_SIZE]{};
SpacePacketCreator creator; SpacePacketCreator creator;
supv::TcParams spParams = supv::TcParams(creator); supv::TcParams spParams = supv::TcParams(creator);
@ -246,9 +250,9 @@ class PlocSupvHelper : public DeviceCommunicationIF,
/** /**
* Communication interface responsible for data transactions between OBC and Supervisor. * Communication interface responsible for data transactions between OBC and Supervisor.
*/ */
UartComIF* uartComIF = nullptr; // UartComIF* uartComIF = nullptr;
// Communication cookie. Must be set by the supervisor Handler // Communication cookie. Must be set by the supervisor Handler
CookieIF* comCookie = nullptr; // CookieIF* comCookie = nullptr;
bool timestamping = true; bool timestamping = true;
@ -268,9 +272,12 @@ class PlocSupvHelper : public DeviceCommunicationIF,
ReturnValue_t updateOperation(); ReturnValue_t updateOperation();
ReturnValue_t writeUpdatePackets(); ReturnValue_t writeUpdatePackets();
// ReturnValue_t performEventBufferRequest(); // ReturnValue_t performEventBufferRequest();
ReturnValue_t handlePacketTransmission(ploc::SpTcBase& packet, ReturnValue_t handlePacketTransmissionNoReply(supv::TcBase& packet,
uint32_t timeoutExecutionReport = 60000); uint32_t timeoutExecutionReport = 60000);
ReturnValue_t sendCommand(ploc::SpTcBase& packet); int handleAckReception(supv::TcBase& tc, uint8_t serviceId, size_t packetLen);
int handleExeAckReception(supv::TcBase& tc, uint8_t serviceId, size_t packetLen);
// ReturnValue_t sendCommand(ploc::SpTcBase& packet);
/** /**
* @brief Function which reads form the communication interface * @brief Function which reads form the communication interface
* *
@ -278,7 +285,7 @@ class PlocSupvHelper : public DeviceCommunicationIF,
* @param raedBytes Actual number of bytes read * @param raedBytes Actual number of bytes read
* @param requestBytes Number of bytes to read * @param requestBytes Number of bytes to read
*/ */
ReturnValue_t receive(uint8_t* data, size_t* readBytes, size_t requestBytes); // ReturnValue_t receive(uint8_t* data, size_t* readBytes, size_t requestBytes);
ReturnValue_t handleAck(); ReturnValue_t handleAck();
ReturnValue_t handleExe(uint32_t timeout = 1000); ReturnValue_t handleExe(uint32_t timeout = 1000);
/** /**
@ -293,7 +300,7 @@ class PlocSupvHelper : public DeviceCommunicationIF,
*/ */
ReturnValue_t handleTmReception(size_t remainingBytes, uint8_t* readBuf = nullptr, ReturnValue_t handleTmReception(size_t remainingBytes, uint8_t* readBuf = nullptr,
uint32_t timeout = 70000); uint32_t timeout = 70000);
ReturnValue_t checkReceivedTm(ploc::SpTmReader& reader); ReturnValue_t checkReceivedTm();
ReturnValue_t selectMemory(); ReturnValue_t selectMemory();
ReturnValue_t prepareUpdate(); ReturnValue_t prepareUpdate();
@ -315,6 +322,7 @@ class PlocSupvHelper : public DeviceCommunicationIF,
ReturnValue_t handleRemainingExeReport(ploc::SpTmReader& reader); ReturnValue_t handleRemainingExeReport(ploc::SpTmReader& reader);
void resetSpParams(); void resetSpParams();
void pushIpcData(const uint8_t* data, size_t len);
/** /**
* @brief Device specific initialization, using the cookie. * @brief Device specific initialization, using the cookie.

2
mission/devices/devicedefinitions/SpBase.h
View File

@ -50,6 +50,8 @@ class SpTcBase {
uint16_t getApid() const { return spParams.creator.getApid(); } uint16_t getApid() const { return spParams.creator.getApid(); }
uint16_t getSeqCount() const { return spParams.creator.getSequenceCount(); }
ReturnValue_t checkPayloadLen() { ReturnValue_t checkPayloadLen() {
if (ccsds::HEADER_LEN + spParams.fullPayloadLen > spParams.maxSize) { if (ccsds::HEADER_LEN + spParams.fullPayloadLen > spParams.maxSize) {
return SerializeIF::BUFFER_TOO_SHORT; return SerializeIF::BUFFER_TOO_SHORT;