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

chonky #670

Merged
muellerr merged 278 commits from v3.0.0-dev into main 2023-06-11 14:25:21 +02:00
Conversation 0 Commits 278 Files Changed 71 +28 -25
4 changed files with 28 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 7f115303ae - Show all commits

22
linux/payload/PlocMpsocSpecialComHelper.cpp
View File

@ -128,7 +128,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashWrite() {
if (file.bad()) {
return returnvalue::FAILED;
}
result = flashfopen(mpsoc::FileAccessMode::WRITE);
result = flashfopen(mpsoc::FileAccessModes::WRITE | mpsoc::FileAccessModes::OPEN_ALWAYS);
if (result != returnvalue::OK) {
return result;
}
@ -142,8 +142,9 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashWrite() {
if (terminate) {
return returnvalue::OK;
}
if (remainingSize > mpsoc::SP_MAX_DATA_SIZE) {
dataLength = mpsoc::SP_MAX_DATA_SIZE;
// The minus 4 is necessary for unknown reasons. Maybe some bug in the ILH software?
if (remainingSize > mpsoc::MAX_FLASH_WRITE_DATA_SIZE - 4) {
dataLength = mpsoc::MAX_FLASH_WRITE_DATA_SIZE - 4;
} else {
dataLength = remainingSize;
}
@ -177,13 +178,12 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashWrite() {
}
ReturnValue_t PlocMpsocSpecialComHelper::performFlashRead() {
sif::debug << "performing flash read" << std::endl;
std::error_code e;
std::ofstream ofile(flashReadAndWrite.obcFile, std::ios::trunc | std::ios::binary);
if (ofile.bad()) {
return returnvalue::FAILED;
}
ReturnValue_t result = flashfopen(mpsoc::FileAccessMode::READ);
ReturnValue_t result = flashfopen(mpsoc::FileAccessModes::READ);
if (result != returnvalue::OK) {
std::filesystem::remove(flashReadAndWrite.obcFile, e);
return result;
@ -199,7 +199,6 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashRead() {
if (flashReadAndWrite.totalReadSize - readSoFar < mpsoc::MAX_FLASH_READ_DATA_SIZE) {
nextReadSize = flashReadAndWrite.totalReadSize - readSoFar;
}
sif::debug << "reading " << nextReadSize << " bytes from offset " << readSoFar << std::endl;
if (ofile.bad() or not ofile.is_open()) {
std::filesystem::remove(flashReadAndWrite.obcFile, e);
return FILE_READ_ERROR;
@ -227,11 +226,10 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashRead() {
if (result != returnvalue::OK) {
return result;
}
sif::debug << "read file done" << std::endl;
return result;
}
ReturnValue_t PlocMpsocSpecialComHelper::flashfopen(mpsoc::FileAccessMode mode) {
ReturnValue_t PlocMpsocSpecialComHelper::flashfopen(uint8_t mode) {
spParams.buf = commandBuffer;
mpsoc::FlashFopen flashFopen(spParams, *sequenceCount);
ReturnValue_t result = flashFopen.setPayload(flashReadAndWrite.mpsocFile, mode);
@ -314,8 +312,6 @@ ReturnValue_t PlocMpsocSpecialComHelper::handlePacketTransmissionNoReply(ploc::S
ReturnValue_t PlocMpsocSpecialComHelper::sendCommand(ploc::SpTcBase& tc) {
ReturnValue_t result = returnvalue::OK;
sif::debug << "sending TC" << std::endl;
arrayprinter::print(tc.getFullPacket(), tc.getFullPacketLen());
result = uartComIF->sendMessage(comCookie, tc.getFullPacket(), tc.getFullPacketLen());
if (result != returnvalue::OK) {
sif::warning << "PlocMPSoCHelper::sendCommand: Failed to send command" << std::endl;
@ -412,7 +408,6 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleTmReception() {
usleepDelay *= 4;
}
}
// sif::debug << "recvd first 6 bytes" << std::endl;
while (true) {
if (tmCountdown.hasTimedOut()) {
triggerEvent(MPSOC_READ_TIMEOUT, tmCountdown.getTimeoutMs());
@ -421,7 +416,6 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleTmReception() {
result = receive(tmBuf.data() + readBytes, fullPacketLen - readBytes, &currentBytes);
readBytes += currentBytes;
if (fullPacketLen == readBytes) {
// sif::debug << "recvd full " << fullPacketLen << std::endl;
break;
}
usleep(usleepDelay);
@ -429,7 +423,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleTmReception() {
usleepDelay *= 4;
}
}
arrayprinter::print(tmBuf.data(), readBytes);
// arrayprinter::print(tmBuf.data(), readBytes);
return result;
}
@ -448,7 +442,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleFlashReadReply(std::ofstream& ofi
const uint8_t* packetData = spReader.getPacketData();
size_t deserDummy = spReader.getPacketDataLen() - mpsoc::CRC_SIZE;
uint32_t receivedReadLen = 0;
// I think this is buggy..
// I think this is buggy, weird stuff in the short name field.
// std::string receivedShortName = std::string(reinterpret_cast<const char*>(packetData), 12);
// if (receivedShortName != flashReadAndWrite.mpsocFile.substr(0, 11)) {
// sif::warning << "PLOC MPSoC Flash Read: Missmatch between request file name and "

2
linux/payload/PlocMpsocSpecialComHelper.h
View File

@ -179,7 +179,7 @@ class PlocMpsocSpecialComHelper : public SystemObject, public ExecutableObjectIF
void resetHelper();
ReturnValue_t performFlashWrite();
ReturnValue_t performFlashRead();
ReturnValue_t flashfopen(mpsoc::FileAccessMode mode);
ReturnValue_t flashfopen(uint8_t accessMode);
ReturnValue_t flashfclose();
ReturnValue_t handlePacketTransmissionNoReply(ploc::SpTcBase& tc);
ReturnValue_t handlePacketTransmissionFlashRead(mpsoc::TcFlashRead& tc, std::ofstream& ofile,

4
linux/payload/plocMpsocHelpers.cpp
View File

@ -33,6 +33,10 @@ std::string mpsoc::getStatusString(uint16_t status) {
return "Flash mount failed";
break;
}
case (mpsoc::status_code::FLASH_FILE_ALREADY_OPEN): {
return "Flash file already open";
break;
}
case (mpsoc::status_code::FLASH_FILE_ALREADY_CLOSED): {
return "Flash file already closed";
break;

25
linux/payload/plocMpsocHelpers.h
View File

@ -13,12 +13,16 @@
namespace mpsoc {
enum FileAccessMode : uint8_t {
enum FileAccessModes : uint8_t {
// Opens a file, fails if the file does not exist.
OPEN_EXISTING = 0x00,
READ = 0x01,
WRITE = 0x02,
// Creates a new file, fails if it already exists.
CREATE_NEW = 0x04,
// Creates a new file, existing file is truncated and overwritten.
CREATE_ALWAYS = 0x08,
// Opens the file if it is existing. If not, a new file is created.
OPEN_ALWAYS = 0x10,
OPEN_APPEND = 0x30
};
@ -182,6 +186,8 @@ static constexpr size_t SP_MAX_DATA_SIZE = SP_MAX_SIZE - ccsds::HEADER_LEN - CRC
static constexpr size_t FLASH_READ_MIN_OVERHEAD = 16;
// 1000 bytes.
static const size_t MAX_FLASH_READ_DATA_SIZE = SP_MAX_DATA_SIZE - FLASH_READ_MIN_OVERHEAD;
// 1012 bytes, 4 bytes for the write length.
static constexpr size_t MAX_FLASH_WRITE_DATA_SIZE = SP_MAX_DATA_SIZE - sizeof(uint32_t);
/**
* The replay write sequence command has a maximum delay for the execution report which amounts to
@ -204,7 +210,7 @@ static const uint16_t TC_EXEUTION_DISABLED = 0x5E2;
static const uint16_t FLASH_MOUNT_FAILED = 0x5E3;
static const uint16_t FLASH_FILE_ALREADY_CLOSED = 0x5E4;
static const uint16_t FLASH_FILE_OPEN_FAILED = 0x5E5;
static const uint16_t FLASH_FILE_ALREDY_OPEN = 0x5E6;
static const uint16_t FLASH_FILE_ALREADY_OPEN = 0x5E6;
static const uint16_t FLASH_FILE_NOT_OPEN = 0x5E7;
static const uint16_t FLASH_UNMOUNT_FAILED = 0x5E8;
static const uint16_t HEAP_ALLOCATION_FAILED = 0x5E9;
@ -366,7 +372,7 @@ class FlashFopen : public TcBase {
FlashFopen(ploc::SpTcParams params, uint16_t sequenceCount)
: TcBase(params, apid::TC_FLASHFOPEN, sequenceCount) {}
ReturnValue_t setPayload(std::string filename, FileAccessMode mode) {
ReturnValue_t setPayload(std::string filename, uint8_t mode) {
accessMode = mode;
size_t nameSize = filename.size();
spParams.setFullPayloadLen(256 + sizeof(uint8_t) + CRC_SIZE);
@ -378,12 +384,12 @@ class FlashFopen : public TcBase {
// payloadStart[nameSize] = NULL_TERMINATOR;
std::memset(payloadStart + nameSize, 0, 256 - nameSize);
// payloadStart[255] = NULL_TERMINATOR;
payloadStart[256] = static_cast<uint8_t>(accessMode);
payloadStart[256] = accessMode;
return returnvalue::OK;
}
private:
FileAccessMode accessMode = FileAccessMode::OPEN_EXISTING;
uint8_t accessMode = FileAccessModes::OPEN_EXISTING;
};
/**
@ -406,14 +412,13 @@ class TcFlashWrite : public TcBase {
: TcBase(params, apid::TC_FLASHWRITE, sequenceCount) {}
ReturnValue_t setPayload(const uint8_t* writeData, uint32_t writeLen_) {
ReturnValue_t result = returnvalue::OK;
writeLen = writeLen_;
if (writeLen > SP_MAX_DATA_SIZE) {
if (writeLen > MAX_FLASH_WRITE_DATA_SIZE) {
sif::error << "TcFlashWrite: Command data too big" << std::endl;
return returnvalue::FAILED;
}
spParams.setFullPayloadLen(static_cast<uint16_t>(writeLen) + 4 + CRC_SIZE);
result = checkPayloadLen();
spParams.setFullPayloadLen(sizeof(uint32_t) + static_cast<uint16_t>(writeLen) + CRC_SIZE);
ReturnValue_t result = checkPayloadLen();
if (result != returnvalue::OK) {
return result;
}
@ -423,7 +428,7 @@ class TcFlashWrite : public TcBase {
if (result != returnvalue::OK) {
return result;
}
std::memcpy(payloadStart + sizeof(writeLen), writeData, writeLen);
std::memcpy(payloadStart + sizeof(uint32_t), writeData, writeLen);
updateSpFields();
result = checkSizeAndSerializeHeader();
if (result != returnvalue::OK) {