From 38ad9f0da272f3bfbabe9981addb6bd87e5f6b4e Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Wed, 22 Dec 2021 11:14:27 +0100 Subject: [PATCH 01/16] flash read wip --- bsp_q7s/devices/startracker/StrHelper.cpp | 68 +++++++++++++++++++++++ bsp_q7s/devices/startracker/StrHelper.h | 11 +++- 2 files changed, 77 insertions(+), 2 deletions(-) diff --git a/bsp_q7s/devices/startracker/StrHelper.cpp b/bsp_q7s/devices/startracker/StrHelper.cpp index a3d28305..bc4e034f 100644 --- a/bsp_q7s/devices/startracker/StrHelper.cpp +++ b/bsp_q7s/devices/startracker/StrHelper.cpp @@ -295,6 +295,74 @@ ReturnValue_t StrHelper::performFlashWrite() { return RETURN_OK; } +ReturnValue_t StrHelper::performFlashRead() { + ReturnValue_t result; + struct ReadActionRequest req; + uint32_t bytesRead = 0; + uint32_t size = 0; + uint32_t retries = 0; + Timestamp timestamp; + std::string file = flashReadPath + "/" + timestamp.str() + flashReadFile ; + std::ofstream file(file, std::ios_base::app | std::ios_base::out); + if(not std::filesystem::exists(file)) { + return FILE_CREATION_FAILED; + } + req.region = flashReadRegion; + req.address = flashReadAddress; + while(bytesRead < flashReadSize) { + if (terminate) { + return RETURN_OK; + } + if ((flashReadSize - bytesRead) < MAX_FLASH_DATA) { + req.length = flashReadSize - bytesRead; + } + else { + req.length = MAX_FLASH_DATA; + } + arc_pack_read_action_req(&req, commandBuffer, static_cast(req.length)); + + + + + result = sendAndRead(size, downloadReq.position); + if (result != RETURN_OK) { + if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { + uartComIF->flushUartRxBuffer(comCookie); + retries++; + continue; + } + file.close(); + return result; + } + result = checkReply(); + if (result != RETURN_OK) { + if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { + uartComIF->flushUartRxBuffer(comCookie); + retries++; + continue; + } + file.close(); + return result; + } + result = checkReplyPosition(downloadReq.position); + if (result != RETURN_OK) { + if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { + uartComIF->flushUartRxBuffer(comCookie); + retries++; + continue; + } + file.close(); + return result; + } + file.write(reinterpret_cast(datalinkLayer.getReply() + DATA_OFFSET), + IMAGE_DATA_SIZE); + downloadReq.position++; + retries = 0; + } + file.close(); + return RETURN_OK; +} + ReturnValue_t StrHelper::sendAndRead(size_t size, uint32_t parameter) { ReturnValue_t result = RETURN_OK; ReturnValue_t decResult = RETURN_OK; diff --git a/bsp_q7s/devices/startracker/StrHelper.h b/bsp_q7s/devices/startracker/StrHelper.h index f7a994b4..9fd74c7e 100644 --- a/bsp_q7s/devices/startracker/StrHelper.h +++ b/bsp_q7s/devices/startracker/StrHelper.h @@ -174,17 +174,24 @@ private: // File which contains data to write when executing the flash write command std::string flashWriteFile; // Path where the file containing the read data will be stored - std::string flashReadFilePath = ""; + std::string flashReadPath = ""; // Default name of downloaded image, can be changed via command std::string downloadImage = "image"; // Default name of file containing the data read from flash, can be changed via command - std::string flashReadImage = "flashread"; + std::string flashReadFile = "flashread"; // Will be set with the flash write command uint8_t flashWriteRegion = 0; // Will be set with the flash write command and specifies the start address where to write the // flash data to uint32_t flashWriteAddress = 0; + // Will be set with the flash read command + uint8_t flashReadRegion = 0; + // Will be set with the flash read command and specifies the start address of the flash section + // to read + uint32_t flashReadAddress = 0; + // Number of bytes to read from flash + uint32_t flashReadSize = 0; SdCardManager* sdcMan = nullptr; From 1331c9e7e9a25aab19b4f654dba40991989d4056 Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Wed, 22 Dec 2021 16:06:30 +0100 Subject: [PATCH 02/16] flash read request --- bsp_q7s/core/InitMission.cpp | 5 + .../startracker/StarTrackerDefinitions.h | 1 + .../startracker/StarTrackerHandler.cpp | 105 ++++++++++++++++-- .../devices/startracker/StarTrackerHandler.h | 30 +++++ bsp_q7s/devices/startracker/StrHelper.cpp | 85 ++++++++++---- bsp_q7s/devices/startracker/StrHelper.h | 33 +++++- 6 files changed, 221 insertions(+), 38 deletions(-) diff --git a/bsp_q7s/core/InitMission.cpp b/bsp_q7s/core/InitMission.cpp index 803339a2..7977deed 100644 --- a/bsp_q7s/core/InitMission.cpp +++ b/bsp_q7s/core/InitMission.cpp @@ -127,12 +127,15 @@ void initmission::initTasks() { initmission::printAddObjectError("FILE_SYSTEM_TASK", objects::FILE_SYSTEM_HANDLER); } +#if OBSW_ADD_STAR_TRACKER == 1 PeriodicTaskIF* strImgLoaderTask = factory->createPeriodicTask( "FILE_SYSTEM_TASK", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc); result = strImgLoaderTask->addComponent(objects::STR_HELPER); if(result != HasReturnvaluesIF::RETURN_OK) { initmission::printAddObjectError("FILE_SYSTEM_TASK", objects::STR_HELPER); } +#endif /* OBSW_ADD_STAR_TRACKER == 1 */ + #endif /* BOARD_TE0720 */ #if OBSW_TEST_CCSDS_BRIDGE == 1 @@ -194,7 +197,9 @@ void initmission::initTasks() { #if BOARD_TE0720 == 0 fsTask->startTask(); +#if OBSW_ADD_STAR_TRACKER == 1 strImgLoaderTask->startTask(); +#endif /* OBSW_ADD_STAR_TRACKER == 1 */ #endif sif::info << "Tasks started.." << std::endl; diff --git a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h index 22214cb0..a66b16e7 100644 --- a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h +++ b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h @@ -202,6 +202,7 @@ static const DeviceCommandId_t STOP_IMAGE_LOADER = 55; static const DeviceCommandId_t RESET_ERROR = 56; static const DeviceCommandId_t CHANGE_DOWNLOAD_FILE = 57; static const DeviceCommandId_t SET_JSON_FILE_NAME = 58; +static const DeviceCommandId_t SET_READ_FILENAME = 59; static const DeviceCommandId_t NONE = 0xFFFFFFFF; static const uint32_t VERSION_SET_ID = REQ_VERSION; diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp index bb9018be..d55fb17a 100644 --- a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp +++ b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp @@ -145,6 +145,18 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu strHelperExecuting = true; return EXECUTION_FINISHED; } + case(StarTracker::READ): { + result = DeviceHandlerBase::acceptExternalDeviceCommands(); + if (result != RETURN_OK) { + return result; + } + result = executeReadCommand(data, size); + if (result != RETURN_OK) { + return result; + } + strHelperExecuting = true; + return EXECUTION_FINISHED; + } case(StarTracker::CHANGE_DOWNLOAD_FILE): { if (size > MAX_FILE_NAME) { return FILENAME_TOO_LONG; @@ -153,6 +165,14 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu std::string(reinterpret_cast(data), size)); return EXECUTION_FINISHED; } + case(StarTracker::SET_READ_FILENAME): { + if (size > MAX_FILE_NAME) { + return FILENAME_TOO_LONG; + } + strHelper->setDownloadImageName( + std::string(reinterpret_cast(data), size)); + return EXECUTION_FINISHED; + } default: break; } @@ -396,6 +416,10 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi result = prepareParamCommand(commandData, commandDataLen, tracking); return result; } + case (StarTracker::UNLOCK): { + result = prepareUnlockCommand(commandData, commandDataLen); + return result; + } default: return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED; } @@ -454,6 +478,8 @@ void StarTrackerHandler::fillCommandAndReplyMap() { StarTracker::MAX_FRAME_SIZE * 2 + 2); this->insertInCommandAndReplyMap(StarTracker::RESET_ERROR, 3, nullptr, StarTracker::MAX_FRAME_SIZE * 2 + 2); + this->insertInCommandAndReplyMap(StarTracker::UNLOCK, 3, nullptr, + StarTracker::MAX_FRAME_SIZE * 2 + 2); } ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t *start, size_t remainingSize, @@ -522,15 +548,10 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id, con result = handlePingReply(); break; } - case (StarTracker::BOOT): { - result = handleActionReply(); - break; - } - case (StarTracker::RESET_ERROR): { - result = handleActionReply(); - break; - } - case (StarTracker::TAKE_IMAGE): { + case (StarTracker::BOOT): + case (StarTracker::TAKE_IMAGE): + case (StarTracker::RESET_ERROR): + case (StarTracker::UNLOCK): { result = handleActionReply(); break; } @@ -809,6 +830,10 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t *foundId) *foundId = StarTracker::RESET_ERROR; break; } + case (StarTracker::ID::UNLOCK): { + *foundId = StarTracker::UNLOCK; + break; + } default: sif::warning << "StarTrackerHandler::scanForParameterReply: Unknown parameter reply id" << std::endl; @@ -966,6 +991,49 @@ ReturnValue_t StarTrackerHandler::executeWriteCommand(const uint8_t* commandData return result; } +ReturnValue_t StarTrackerHandler::executeReadCommand(const uint8_t* commandData, + size_t commandDataLen) { + ReturnValue_t result = RETURN_OK; + if (commandDataLen < ReadCmd::MIN_LENGTH) { + sif::warning << "StarTrackerHandler::executeReadCommand: Command too short" << std::endl; + return COMMAND_TOO_SHORT; + } + uint8_t region = *(commandData); + uint32_t address; + size_t size = sizeof(address); + const uint8_t* addressPtr = commandData + ReadCmd::ADDRESS_OFFSET; + result = SerializeAdapter::deSerialize(&address, addressPtr, &size, + SerializeIF::Endianness::LITTLE); + if (result != RETURN_OK) { + sif::debug << "StarTrackerHandler::executeReadCommand: Deserialization of address failed" + << std::endl; + return result; + } + uint16_t length; + size = sizeof(length); + const uint8_t* lengthPtr = commandData + ReadCmd::LENGTH_OFFSET; + result = SerializeAdapter::deSerialize(&address, lengthPtr, &size, + SerializeIF::Endianness::LITTLE); + if (result != RETURN_OK) { + sif::debug << "StarTrackerHandler::executeReadCommand: Deserialization of length failed" + << std::endl; + return result; + } + if (commandDataLen - sizeof(address) - sizeof(region) - sizeof(length) > MAX_PATH_SIZE) { + sif::warning << "StarTrackerHandler::executeReadCommand: Received command with invalid" + << " path and filename" << std::endl; + return FILE_PATH_TOO_LONG; + } + const uint8_t* filePtr = commandData + ReadCmd::FILE_OFFSET; + std::string fullname = std::string(reinterpret_cast(filePtr), + commandDataLen - sizeof(address) - sizeof(region) - sizeof(length)); + result = strHelper->startFlashRead(fullname, region, address, length); + if (result != RETURN_OK) { + return result; + } + return result; +} + void StarTrackerHandler::prepareBootCommand() { uint32_t length = 0; struct BootActionRequest bootRequest = {BOOT_REGION_ID}; @@ -975,6 +1043,25 @@ void StarTrackerHandler::prepareBootCommand() { rawPacketLen = dataLinkLayer.getEncodedLength(); } +ReturnValue_t StarTrackerHandler::prepareUnlockCommand(const uint8_t* commandData, size_t commandDataLen) { + ReturnValue_t result = RETURN_OK; + uint32_t length = 0; + struct UnlockActionRequest req; + req.region = *commandData; + size_t size = sizeof(req.code); + const uint8_t* codePtr = commandData + UnlockCmd::CODE_OFFSET; + result = SerializeAdapter::deSerialize(&req.code, &codePtr, &size, + SerializeIF::Endianness::BIG); + if (result != RETURN_OK) { + return result; + } + arc_pack_unlock_action_req(&req, commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return result; +} + void StarTrackerHandler::prepareTimeRequest() { uint32_t length = 0; arc_tm_pack_time_req(commandBuffer, &length); diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.h b/bsp_q7s/devices/startracker/StarTrackerHandler.h index 7d22592e..791ead0f 100644 --- a/bsp_q7s/devices/startracker/StarTrackerHandler.h +++ b/bsp_q7s/devices/startracker/StarTrackerHandler.h @@ -147,6 +147,20 @@ private: static const size_t MIN_LENGTH = 7; }; + class ReadCmd { + public: + static const uint8_t ADDRESS_OFFSET = 1; + static const uint8_t LENGTH_OFFSET = 5; + static const uint8_t FILE_OFFSET = 7; + // Minimum length of a read command (region, address, length and filename) + static const size_t MIN_LENGTH = 9; + }; + + class UnlockCmd { + public: + static const uint8_t CODE_OFFSET = 1; + }; + MessageQueueIF* eventQueue = nullptr; ArcsecDatalinkLayer dataLinkLayer; @@ -245,12 +259,28 @@ private: */ ReturnValue_t executeWriteCommand(const uint8_t* commandData, size_t commandDataLen); + /** + * @brief Extracts information for flash-read-command from TC data and starts execution of + * flash-read-procedure + * + * @param commandData Pointer to received command data + * @param commandDataLen Size of received command data + * + * @return RETURN_OK if start of execution was successful, otherwise error return value + */ + ReturnValue_t executeReadCommand(const uint8_t* commandData, size_t commandDataLen); + /** * @brief Fills command buffer with data to boot image (works only when star tracker is * in bootloader mode). */ void prepareBootCommand(); + /** + * @brief Fills command buffer with command to unlock flash region + */ + ReturnValue_t prepareUnlockCommand(const uint8_t* commandData, size_t commandDataLen); + /** * @brief Fills the command buffer with the command to take an image. */ diff --git a/bsp_q7s/devices/startracker/StrHelper.cpp b/bsp_q7s/devices/startracker/StrHelper.cpp index bc4e034f..4a6797f1 100644 --- a/bsp_q7s/devices/startracker/StrHelper.cpp +++ b/bsp_q7s/devices/startracker/StrHelper.cpp @@ -63,6 +63,17 @@ ReturnValue_t StrHelper::performOperation(uint8_t operationCode) { internalState = InternalState::IDLE; break; } + case InternalState::FLASH_READ: { + result = performFlashRead(); + if (result == RETURN_OK){ + triggerEvent(FLASH_READ_SUCCESSFUL); + } + else { + triggerEvent(FLASH_READ_FAILED); + } + internalState = InternalState::IDLE; + break; + } default: sif::debug << "StrHelper::performOperation: Invalid state" << std::endl; break; @@ -121,8 +132,12 @@ void StrHelper::setDownloadImageName(std::string image) { downloadImage = image; } +void StrHelper::setFlashReadFilename(std::string filename) { + flashReadFile = filename; +} + ReturnValue_t StrHelper::startFlashWrite(std::string flashWriteFile_, uint8_t region, - uint32_t flashWriteAddress) { + uint32_t address) { ReturnValue_t result = checkPath(flashWriteFile_); if (result != RETURN_OK) { return result; @@ -131,12 +146,33 @@ ReturnValue_t StrHelper::startFlashWrite(std::string flashWriteFile_, uint8_t re if(not std::filesystem::exists(flashWriteFile)) { return FILE_NOT_EXISTS; } + flashWriteAddress = address; + flashWriteRegion = region; internalState = InternalState::FLASH_WRITE; semaphore.release(); terminate = false; return RETURN_OK; } +ReturnValue_t StrHelper::startFlashRead(std::string flashReadFile_, uint8_t region, + uint32_t address, uint16_t length) { + ReturnValue_t result = checkPath(flashReadFile_); + if (result != RETURN_OK) { + return result; + } + flashReadFile = flashReadFile_; + if(not std::filesystem::exists(flashReadFile)) { + return FILE_NOT_EXISTS; + } + flashReadAddress = address; + flashReadRegion = region; + flashReadSize = length; + internalState = InternalState::FLASH_READ; + semaphore.release(); + terminate = false; + return RETURN_OK; +} + ReturnValue_t StrHelper::performImageDownload() { ReturnValue_t result; struct DownloadActionRequest downloadReq; @@ -184,7 +220,7 @@ ReturnValue_t StrHelper::performImageDownload() { file.close(); return result; } - file.write(reinterpret_cast(datalinkLayer.getReply() + DATA_OFFSET), + file.write(reinterpret_cast(datalinkLayer.getReply() + IMAGE_DATA_OFFSET), IMAGE_DATA_SIZE); downloadReq.position++; retries = 0; @@ -274,7 +310,7 @@ ReturnValue_t StrHelper::performFlashWrite() { if (result != RETURN_OK) { return RETURN_FAILED; } - result = checkFlashWriteReply(req); + result = checkFlashActionReply(req.region, req.address, req.length); if (result != RETURN_OK) { return result; } @@ -288,7 +324,7 @@ ReturnValue_t StrHelper::performFlashWrite() { if (result != RETURN_OK) { return RETURN_FAILED; } - result = checkFlashWriteReply(req); + result = checkFlashActionReply(req.region, req.address, req.length); if (result != RETURN_OK) { return result; } @@ -302,13 +338,12 @@ ReturnValue_t StrHelper::performFlashRead() { uint32_t size = 0; uint32_t retries = 0; Timestamp timestamp; - std::string file = flashReadPath + "/" + timestamp.str() + flashReadFile ; - std::ofstream file(file, std::ios_base::app | std::ios_base::out); - if(not std::filesystem::exists(file)) { + std::string fullname = flashReadPath + "/" + timestamp.str() + flashReadFile ; + std::ofstream file(fullname, std::ios_base::app | std::ios_base::out); + if (not std::filesystem::exists(fullname)) { return FILE_CREATION_FAILED; } req.region = flashReadRegion; - req.address = flashReadAddress; while(bytesRead < flashReadSize) { if (terminate) { return RETURN_OK; @@ -319,12 +354,9 @@ ReturnValue_t StrHelper::performFlashRead() { else { req.length = MAX_FLASH_DATA; } - arc_pack_read_action_req(&req, commandBuffer, static_cast(req.length)); - - - - - result = sendAndRead(size, downloadReq.position); + req.address = flashReadAddress + bytesRead; + arc_pack_read_action_req(&req, commandBuffer, &size); + result = sendAndRead(size, req.address); if (result != RETURN_OK) { if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { uartComIF->flushUartRxBuffer(comCookie); @@ -344,7 +376,7 @@ ReturnValue_t StrHelper::performFlashRead() { file.close(); return result; } - result = checkReplyPosition(downloadReq.position); + result = checkFlashActionReply(req.region, req.address, req.length); if (result != RETURN_OK) { if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { uartComIF->flushUartRxBuffer(comCookie); @@ -354,9 +386,9 @@ ReturnValue_t StrHelper::performFlashRead() { file.close(); return result; } - file.write(reinterpret_cast(datalinkLayer.getReply() + DATA_OFFSET), - IMAGE_DATA_SIZE); - downloadReq.position++; + file.write(reinterpret_cast(datalinkLayer.getReply() + FLASH_READ_DATA_OFFSET), + req.length); + bytesRead += req.length; retries = 0; } file.close(); @@ -446,8 +478,13 @@ ReturnValue_t StrHelper::checkReplyPosition(uint32_t expectedPosition) { return RETURN_OK; } -ReturnValue_t StrHelper::checkFlashWriteReply(struct WriteActionRequest& req) { +ReturnValue_t StrHelper::checkFlashActionReply(uint8_t region_, uint32_t address_, + uint16_t length_) { ReturnValue_t result = RETURN_OK; + result = checkReply(); + if (result != RETURN_OK) { + return result; + } const uint8_t* data = datalinkLayer.getReply(); uint8_t region = *(data + REGION_OFFSET); uint32_t address; @@ -456,7 +493,7 @@ ReturnValue_t StrHelper::checkFlashWriteReply(struct WriteActionRequest& req) { result = SerializeAdapter::deSerialize(&address, &addressData, &size, SerializeIF::Endianness::LITTLE); if (result != RETURN_OK) { - sif::warning << "StrHelper::checkFlashWriteReply: Deserialization of address failed" + sif::warning << "StrHelper::checkFlashActionReply: Deserialization of address failed" << std::endl; } uint16_t length; @@ -465,16 +502,16 @@ ReturnValue_t StrHelper::checkFlashWriteReply(struct WriteActionRequest& req) { result = SerializeAdapter::deSerialize(&length, lengthData, &size, SerializeIF::Endianness::LITTLE); if (result != RETURN_OK) { - sif::warning << "StrHelper::checkFlashWriteReply: Deserialization of length failed" + sif::warning << "StrHelper::checkFlashActionReply: Deserialization of length failed" << std::endl; } - if (region != req.region) { + if (region != region_) { return REGION_MISMATCH; } - if (address != req.address) { + if (address != address_) { return ADDRESS_MISMATCH; } - if (region != req.length) { + if (region != length_) { return LENGTH_MISMATCH; } return RETURN_OK; diff --git a/bsp_q7s/devices/startracker/StrHelper.h b/bsp_q7s/devices/startracker/StrHelper.h index 9fd74c7e..13742778 100644 --- a/bsp_q7s/devices/startracker/StrHelper.h +++ b/bsp_q7s/devices/startracker/StrHelper.h @@ -103,10 +103,21 @@ public: * * @param flashWriteFile_ Full name including absolute path of file to write to flash * @param region Region ID of flash region to write to - * @param flashWriteAddress Start address of flash write procedure + * @param address Start address of flash write procedure */ ReturnValue_t startFlashWrite(std::string flashWriteFile_, uint8_t region, - uint32_t flashWriteAddress); + uint32_t address); + + /** + * @brief Starts the flash read procedure + * + * @param flashWriteFile_ Full name including absolute path of file to write to flash + * @param region Region ID of flash region to read from + * @param flashWriteAddress Start address of flash section to read + * @param length Number of bytes to read from flash + */ + ReturnValue_t startFlashRead(std::string flashReadFile_, uint8_t region, + uint32_t address, uint16_t length); /** * @brief Can be used to interrupt a running data transfer. @@ -118,6 +129,11 @@ public: */ void setDownloadImageName(std::string image); + /** + * @brief Sets the name of the file which will be created to store the data read from flash + */ + void setFlashReadFilename(std::string filename); + private: static const uint8_t INTERFACE_ID = CLASS_ID::STR_HELPER; @@ -145,7 +161,8 @@ private: static const uint32_t MAX_POLLS = 10000; static const uint8_t POS_OFFSET = 2; - static const uint8_t DATA_OFFSET = 5; + static const uint8_t IMAGE_DATA_OFFSET = 5; + static const uint8_t FLASH_READ_DATA_OFFSET = 8; static const uint8_t REGION_OFFSET = 2; static const uint8_t ADDRESS_OFFSET = 3; static const uint8_t LENGTH_OFFSET = 7; @@ -232,6 +249,12 @@ private: */ ReturnValue_t performFlashWrite(); + /** + * @brief Sends a sequence of commands to the star tracker to read larger parts from the + * flash memory. + */ + ReturnValue_t performFlashRead(); + /** * @brief Sends packet to the star tracker and reads reply by using the communication * interface @@ -260,12 +283,12 @@ private: ReturnValue_t checkReplyPosition(uint32_t expectedPosition); /** - * @brief Checks the region, address and length value of a flash write reply. + * @brief Checks the region, address and length value of a flash write or read reply. * * @return RETURN_OK if values match expected values, otherwise appropriate error return * value. */ - ReturnValue_t checkFlashWriteReply(struct WriteActionRequest& req); + ReturnValue_t checkFlashActionReply(uint8_t region_, uint32_t address_, uint16_t length_); /** * @brief Checks if a path points to an sd card and whether the SD card is monuted. From 8cddbf86d9b2f11195c723c8afe0095472d35ea1 Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Thu, 23 Dec 2021 11:07:19 +0100 Subject: [PATCH 03/16] flash read command --- .../startracker/StarTrackerHandler.cpp | 6 ++--- .../devices/startracker/StarTrackerHandler.h | 4 ++-- bsp_q7s/devices/startracker/StrHelper.cpp | 21 +++++++++--------- bsp_q7s/devices/startracker/StrHelper.h | 22 +++++++++---------- mission/utility/Timestamp.cpp | 15 ++++++++++--- mission/utility/Timestamp.h | 3 +++ 6 files changed, 41 insertions(+), 30 deletions(-) diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp index d55fb17a..9b97b422 100644 --- a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp +++ b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp @@ -1009,11 +1009,11 @@ ReturnValue_t StarTrackerHandler::executeReadCommand(const uint8_t* commandData, << std::endl; return result; } - uint16_t length; + uint32_t length; size = sizeof(length); const uint8_t* lengthPtr = commandData + ReadCmd::LENGTH_OFFSET; - result = SerializeAdapter::deSerialize(&address, lengthPtr, &size, - SerializeIF::Endianness::LITTLE); + result = SerializeAdapter::deSerialize(&length, lengthPtr, &size, + SerializeIF::Endianness::BIG); if (result != RETURN_OK) { sif::debug << "StarTrackerHandler::executeReadCommand: Deserialization of length failed" << std::endl; diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.h b/bsp_q7s/devices/startracker/StarTrackerHandler.h index 791ead0f..16b00d3b 100644 --- a/bsp_q7s/devices/startracker/StarTrackerHandler.h +++ b/bsp_q7s/devices/startracker/StarTrackerHandler.h @@ -151,9 +151,9 @@ private: public: static const uint8_t ADDRESS_OFFSET = 1; static const uint8_t LENGTH_OFFSET = 5; - static const uint8_t FILE_OFFSET = 7; + static const uint8_t FILE_OFFSET = 9; // Minimum length of a read command (region, address, length and filename) - static const size_t MIN_LENGTH = 9; + static const size_t MIN_LENGTH = 11; }; class UnlockCmd { diff --git a/bsp_q7s/devices/startracker/StrHelper.cpp b/bsp_q7s/devices/startracker/StrHelper.cpp index 4a6797f1..fa7b510f 100644 --- a/bsp_q7s/devices/startracker/StrHelper.cpp +++ b/bsp_q7s/devices/startracker/StrHelper.cpp @@ -154,14 +154,14 @@ ReturnValue_t StrHelper::startFlashWrite(std::string flashWriteFile_, uint8_t re return RETURN_OK; } -ReturnValue_t StrHelper::startFlashRead(std::string flashReadFile_, uint8_t region, - uint32_t address, uint16_t length) { - ReturnValue_t result = checkPath(flashReadFile_); +ReturnValue_t StrHelper::startFlashRead(std::string flashReadPath_, uint8_t region, + uint32_t address, uint32_t length) { + ReturnValue_t result = checkPath(flashReadPath_); if (result != RETURN_OK) { return result; } - flashReadFile = flashReadFile_; - if(not std::filesystem::exists(flashReadFile)) { + flashReadPath = flashReadPath_; + if(not std::filesystem::exists(flashReadPath)) { return FILE_NOT_EXISTS; } flashReadAddress = address; @@ -456,14 +456,13 @@ ReturnValue_t StrHelper::checkReply() { if (type != TMTC_ACTIONREPLY) { sif::warning << "StrHelper::checkReply: Received reply with invalid type ID" << std::endl; - triggerEvent(INVALID_TYPE_ID); - return RETURN_FAILED; + return INVALID_TYPE_ID; } uint8_t status = datalinkLayer.getStatusField(); if (status != ArcsecDatalinkLayer::STATUS_OK) { - triggerEvent(STATUS_ERROR); - sif::warning << "StrHelper::checkReply: Status failure" << std::endl; - return RETURN_FAILED; + sif::warning << "StrHelper::checkReply: Status failure: " + << static_cast(status) << std::endl; + return STATUS_ERROR; } return RETURN_OK; } @@ -511,7 +510,7 @@ ReturnValue_t StrHelper::checkFlashActionReply(uint8_t region_, uint32_t address if (address != address_) { return ADDRESS_MISMATCH; } - if (region != length_) { + if (length != length_) { return LENGTH_MISMATCH; } return RETURN_OK; diff --git a/bsp_q7s/devices/startracker/StrHelper.h b/bsp_q7s/devices/startracker/StrHelper.h index 13742778..ff2f3ca6 100644 --- a/bsp_q7s/devices/startracker/StrHelper.h +++ b/bsp_q7s/devices/startracker/StrHelper.h @@ -51,28 +51,24 @@ public: //! [EXPORT] : [COMMENT] Star tracker did not send replies (maybe device is powered off) //!P1: Position of upload or download packet for which no reply was sent static const Event STR_HELPER_NO_REPLY = MAKE_EVENT(10, severity::LOW); - //! [EXPORT] : [COMMENT] Received reply with invalid type ID - static const Event INVALID_TYPE_ID = MAKE_EVENT(11, severity::LOW); - //! [EXPORT] : [COMMENT] Status field in reply signals error - static const Event STATUS_ERROR = MAKE_EVENT(12, severity::LOW); //! [EXPORT] : [COMMENT] Error during decoding of received reply occurred //P1: Return value of decoding function //P2: Position of upload/download packet, or address of flash write/read request - static const Event STR_HELPER_DEC_ERROR = MAKE_EVENT(13, severity::LOW); + static const Event STR_HELPER_DEC_ERROR = MAKE_EVENT(11, 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(14, severity::LOW); + static const Event POSITION_MISMATCH = MAKE_EVENT(12, 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(15, severity::LOW); + static const Event STR_HELPER_FILE_NOT_EXISTS = MAKE_EVENT(13, severity::LOW); //! [EXPORT] : [COMMENT] Sending packet to star tracker failed //!P1: Return code of communication interface sendMessage function //!P2: Position of upload/download packet, or address of flash write/read request for which sending failed - static const Event STR_HELPER_SENDING_PACKET_FAILED = MAKE_EVENT(16, severity::LOW); + static const Event STR_HELPER_SENDING_PACKET_FAILED = MAKE_EVENT(14, severity::LOW); //! [EXPORT] : [COMMENT] Communication interface requesting reply failed //!P1: Return code of failed request //!P1: Upload/download position, or address of flash write/read request for which transmission failed - static const Event STR_HELPER_REQUESTING_MSG_FAILED = MAKE_EVENT(17, severity::LOW); + static const Event STR_HELPER_REQUESTING_MSG_FAILED = MAKE_EVENT(15, severity::LOW); StrHelper(object_id_t objectId); virtual ~StrHelper(); @@ -116,8 +112,8 @@ public: * @param flashWriteAddress Start address of flash section to read * @param length Number of bytes to read from flash */ - ReturnValue_t startFlashRead(std::string flashReadFile_, uint8_t region, - uint32_t address, uint16_t length); + ReturnValue_t startFlashRead(std::string flashReadPath_, uint8_t region, + uint32_t address, uint32_t length); /** * @brief Can be used to interrupt a running data transfer. @@ -152,6 +148,10 @@ private: static const ReturnValue_t ADDRESS_MISMATCH = MAKE_RETURN_CODE(0xA5); //! [EXPORT] : [COMMENT] Length in flash write/read reply does not match expected length static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(0xA6); + //! [EXPORT] : [COMMENT] Status field in reply signals error + static const ReturnValue_t STATUS_ERROR = MAKE_RETURN_CODE(0xA7); + //! [EXPORT] : [COMMENT] Reply has invalid type ID (should be of action reply type) + static const ReturnValue_t INVALID_TYPE_ID = MAKE_RETURN_CODE(0xA8); // Size of one image part which can be sent per action request static const size_t SIZE_IMAGE_PART = 1024; diff --git a/mission/utility/Timestamp.cpp b/mission/utility/Timestamp.cpp index 36ddf4d8..c0848a59 100644 --- a/mission/utility/Timestamp.cpp +++ b/mission/utility/Timestamp.cpp @@ -12,8 +12,17 @@ Timestamp::~Timestamp() { } std::string Timestamp::str() { - return std::to_string(time.year) + "-" + std::to_string(time.month) + "-" - + std::to_string(time.day) + "--" + std::to_string(time.hour) + "-" - + std::to_string(time.minute) + "-" + std::to_string(time.second) + "-"; + timestamp << std::to_string(time.year) << "-" + << std::setw(2) << std::setfill('0') + << std::to_string(time.month) << "-" + << std::setw(2) << std::setfill('0') + << std::to_string(time.day) << "--" + << std::setw(2) << std::setfill('0') + << std::to_string(time.hour) << "-" + << std::setw(2) << std::setfill('0') + << std::to_string(time.minute) << "-" + << std::setw(2) << std::setfill('0') + << std::to_string(time.second) << "--"; + return timestamp.str(); } diff --git a/mission/utility/Timestamp.h b/mission/utility/Timestamp.h index 05dae31f..7146de53 100644 --- a/mission/utility/Timestamp.h +++ b/mission/utility/Timestamp.h @@ -2,6 +2,8 @@ #define MISSION_UTILITY_TIMESTAMP_H_ #include +#include +#include #include "fsfw/timemanager/Clock.h" #include "fsfw/returnvalues/HasReturnvaluesIF.h" @@ -21,6 +23,7 @@ public: std::string str(); private: + std::stringstream timestamp; Clock::TimeOfDay_t time; }; From fa8cdb3241ad27b8d0a606a4da13a7752abe4d88 Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Thu, 23 Dec 2021 18:33:06 +0100 Subject: [PATCH 04/16] changed star tracker uart --- bsp_q7s/boardconfig/busConf.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bsp_q7s/boardconfig/busConf.h b/bsp_q7s/boardconfig/busConf.h index 73605471..bcd43ccf 100644 --- a/bsp_q7s/boardconfig/busConf.h +++ b/bsp_q7s/boardconfig/busConf.h @@ -11,7 +11,7 @@ static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c-1"; static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ttyUL3"; static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ttyUL4"; static constexpr char UART_SYRLINKS_DEV[] = "/dev/ttyUL5"; -static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ttyUL8"; +static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ttyUL7"; static constexpr char UART_GNSS_0_DEV[] = "/dev/ttyUL0"; static constexpr char UART_GNSS_1_DEV[] = "/dev/ttyUL2"; From 14dec1d7007ffd8ac787c34cfe5461cbefbf8015 Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Thu, 23 Dec 2021 18:33:31 +0100 Subject: [PATCH 05/16] checksum command --- .../startracker/StarTrackerDefinitions.h | 73 +++++++++++++++++ .../startracker/StarTrackerHandler.cpp | 82 ++++++++++++++++++- .../devices/startracker/StarTrackerHandler.h | 32 ++++++++ bsp_q7s/devices/startracker/StrHelper.h | 4 +- 4 files changed, 187 insertions(+), 4 deletions(-) diff --git a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h index a66b16e7..1efa0bc7 100644 --- a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h +++ b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h @@ -846,6 +846,79 @@ public: sif::info << "ContrastSet::printSet: BinD8: " << this->binD8 << std::endl; } }; + +/** + * @brief Helper Class to extract information from bytestream. + */ +class ChecksumReply { +public: + + /** + * @brief Constructor + * + * @param datafield Pointer to datafield in reply buffer + * + */ + ChecksumReply(const uint8_t* datafield) { + ReturnValue_t result = HasReturnvaluesIF::RETURN_OK; + region = *(datafield); + const uint8_t* addressData = datafield + ADDRESS_OFFSET; + size_t size = sizeof(address); + result = SerializeAdapter::deSerialize(&address, &addressData, &size, + SerializeIF::Endianness::LITTLE); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::debug << "ChecksumReply::ChecksumReply: Failed to deserialize address" + << std::endl; + } + const uint8_t* lengthData = datafield + LENGTH_OFFSET; + size = sizeof(length); + result = SerializeAdapter::deSerialize(&length, &lengthData, &size, + SerializeIF::Endianness::LITTLE); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::debug << "ChecksumReply::ChecksumReply: Failed to deserialize length" + << std::endl; + } + const uint8_t* checksumData = datafield + CHECKSUM_OFFSET; + size = sizeof(checksum); + result = SerializeAdapter::deSerialize(&checksum, &checksumData, &size, + SerializeIF::Endianness::LITTLE); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::debug << "ChecksumReply::ChecksumReply: Failed to deserialize checksum" + << std::endl; + } + } + + uint8_t getRegion() { + return region; + } + + uint32_t getAddress() { + return address; + } + + uint32_t getLength() { + return length; + } + + uint32_t getChecksum() { + return checksum; + } + + void printChecksum() { + sif::info << "ChecksumReply::printChecksum: 0x" << checksum << std::endl; + } + +private: + + static const uint8_t ADDRESS_OFFSET = 1; + static const uint8_t LENGTH_OFFSET = 5; + static const uint8_t CHECKSUM_OFFSET = 9; + + uint8_t region = 0; + uint32_t address = 0; + uint32_t length = 0; + uint32_t checksum = 0; +}; } #endif /* MISSION_STARTRACKER_DEFINITIONS_H_ */ diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp index 9b97b422..7ae5d72c 100644 --- a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp +++ b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp @@ -420,6 +420,10 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi result = prepareUnlockCommand(commandData, commandDataLen); return result; } + case (StarTracker::CHECKSUM): { + result = prepareChecksumCommand(commandData, commandDataLen); + return result; + } default: return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED; } @@ -480,6 +484,8 @@ void StarTrackerHandler::fillCommandAndReplyMap() { StarTracker::MAX_FRAME_SIZE * 2 + 2); this->insertInCommandAndReplyMap(StarTracker::UNLOCK, 3, nullptr, StarTracker::MAX_FRAME_SIZE * 2 + 2); + this->insertInCommandAndReplyMap(StarTracker::CHECKSUM, 3, nullptr, + StarTracker::MAX_FRAME_SIZE * 2 + 2); } ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t *start, size_t remainingSize, @@ -555,6 +561,10 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id, con result = handleActionReply(); break; } + case (StarTracker::CHECKSUM): { + result = handleChecksumReply(); + break; + } case (StarTracker::REQ_VERSION): { result = handleTm(versionSet, StarTracker::VersionSet::SIZE); if (result != RETURN_OK) { @@ -834,6 +844,10 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t *foundId) *foundId = StarTracker::UNLOCK; break; } + case (StarTracker::ID::CHECKSUM): { + *foundId = StarTracker::CHECKSUM; + break; + } default: sif::warning << "StarTrackerHandler::scanForParameterReply: Unknown parameter reply id" << std::endl; @@ -970,7 +984,7 @@ ReturnValue_t StarTrackerHandler::executeWriteCommand(const uint8_t* commandData size_t size = sizeof(address); const uint8_t* addressPtr = commandData + WriteCmd::ADDRESS_OFFSET; result = SerializeAdapter::deSerialize(&address, addressPtr, &size, - SerializeIF::Endianness::LITTLE); + SerializeIF::Endianness::BIG); if (result != RETURN_OK) { sif::debug << "StarTrackerHandler::executeWriteCommand: Deserialization of address failed" << std::endl; @@ -1003,7 +1017,7 @@ ReturnValue_t StarTrackerHandler::executeReadCommand(const uint8_t* commandData, size_t size = sizeof(address); const uint8_t* addressPtr = commandData + ReadCmd::ADDRESS_OFFSET; result = SerializeAdapter::deSerialize(&address, addressPtr, &size, - SerializeIF::Endianness::LITTLE); + SerializeIF::Endianness::BIG); if (result != RETURN_OK) { sif::debug << "StarTrackerHandler::executeReadCommand: Deserialization of address failed" << std::endl; @@ -1062,6 +1076,44 @@ ReturnValue_t StarTrackerHandler::prepareUnlockCommand(const uint8_t* commandDat return result; } +ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandData, + size_t commandDataLen) { + struct ChecksumActionRequest req; + ReturnValue_t result = RETURN_OK; + if (commandDataLen != ChecksumCmd::LENGTH) { + sif::warning << "StarTrackerHandler::prepareChecksumCommand: Invalid length" << std::endl; + return INVALID_LENGTH; + } + req.region = *(commandData); + size_t size = sizeof(req.address); + const uint8_t* addressPtr = commandData + ChecksumCmd::ADDRESS_OFFSET; + result = SerializeAdapter::deSerialize(&req.address, addressPtr, &size, + SerializeIF::Endianness::BIG); + if (result != RETURN_OK) { + sif::debug << "StarTrackerHandler::prepareChecksumCommand: Deserialization of address " + << "failed" << std::endl; + return result; + } + size = sizeof(req.length); + const uint8_t* lengthPtr = commandData + ChecksumCmd::LENGTH_OFFSET; + result = SerializeAdapter::deSerialize(&req.length, lengthPtr, &size, + SerializeIF::Endianness::BIG); + if (result != RETURN_OK) { + sif::debug << "StarTrackerHandler::prepareChecksumCommand: Deserialization of length failed" + << std::endl; + return result; + } + uint32_t rawCmdLength = 0; + arc_pack_checksum_action_req(&req, commandBuffer, &rawCmdLength); + dataLinkLayer.encodeFrame(commandBuffer, rawCmdLength); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + checksumCmd.rememberRegion = req.region; + checksumCmd.rememberAddress = req.address; + checksumCmd.rememberLength = req.length; + return result; +} + void StarTrackerHandler::prepareTimeRequest() { uint32_t length = 0; arc_tm_pack_time_req(commandBuffer, &length); @@ -1240,6 +1292,32 @@ ReturnValue_t StarTrackerHandler::handleActionReply() { return RETURN_OK; } +ReturnValue_t StarTrackerHandler::handleChecksumReply() { + ReturnValue_t result = RETURN_OK; + result = handleActionReply(); + if (result != RETURN_OK) { + return result; + } + const uint8_t* replyData = dataLinkLayer.getReply() + ACTION_DATA_OFFSET; + StarTracker::ChecksumReply checksumReply(replyData); + if (checksumReply.getRegion() != checksumCmd.rememberRegion) { + sif::warning << "StarTrackerHandler::handleChecksumReply: Region mismatch" << std::endl; + return REGION_MISMATCH; + } + if (checksumReply.getAddress() != checksumCmd.rememberAddress) { + sif::warning << "StarTrackerHandler::handleChecksumReply: Address mismatch" << std::endl; + return ADDRESS_MISMATCH; + } + if (checksumReply.getLength() != checksumCmd.rememberLength) { + sif::warning << "StarTrackerHandler::handleChecksumReply: Length mismatch" << std::endl; + return LENGTH_MISSMATCH; + } +#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_STARTRACKER == 1 + checksumReply.printChecksum(); +#endif /* OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_STARTRACKER == 1 */ + return RETURN_OK; +} + ReturnValue_t StarTrackerHandler::handlePingReply() { ReturnValue_t result = RETURN_OK; uint32_t pingId = 0; diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.h b/bsp_q7s/devices/startracker/StarTrackerHandler.h index 16b00d3b..095105b3 100644 --- a/bsp_q7s/devices/startracker/StarTrackerHandler.h +++ b/bsp_q7s/devices/startracker/StarTrackerHandler.h @@ -117,6 +117,14 @@ private: static const ReturnValue_t CONTRAST_REQ_FAILED = MAKE_RETURN_CODE(0xAE); //! [EXPORT] : [COMMENT] Received command which is too short (some data is missing for proper execution) static const ReturnValue_t COMMAND_TOO_SHORT = MAKE_RETURN_CODE(0xAF); + //! [EXPORT] : [COMMENT] Received command with invalid length (too few or too many parameters) + static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xB0); + //! [EXPORT] : [COMMENT] Region mismatch between send and received data + static const ReturnValue_t REGION_MISMATCH = MAKE_RETURN_CODE(0xB1); + //! [EXPORT] : [COMMENT] Address mismatch between send and received data + static const ReturnValue_t ADDRESS_MISMATCH = MAKE_RETURN_CODE(0xB2); + //! [EXPORT] : [COMMENT] Length field mismatch between send and received data + static const ReturnValue_t lENGTH_MISMATCH = MAKE_RETURN_CODE(0xB3); static const size_t MAX_PATH_SIZE = 50; static const size_t MAX_FILE_NAME = 30; @@ -161,6 +169,20 @@ private: static const uint8_t CODE_OFFSET = 1; }; + class ChecksumCmd { + public: + static const uint8_t ADDRESS_OFFSET = 1; + static const uint8_t LENGTH_OFFSET = 5; + // Length of checksum command + static const size_t LENGTH = 9; + + uint8_t rememberRegion = 0; + uint32_t rememberAddress = 0; + uint32_t rememberLength = 0; + }; + + ChecksumCmd checksumCmd; + MessageQueueIF* eventQueue = nullptr; ArcsecDatalinkLayer dataLinkLayer; @@ -281,6 +303,11 @@ private: */ ReturnValue_t prepareUnlockCommand(const uint8_t* commandData, size_t commandDataLen); + /** + * @brief Fills command buffer with command to get the checksum of a flash part + */ + ReturnValue_t prepareChecksumCommand(const uint8_t* commandData, size_t commandDataLen); + /** * @brief Fills the command buffer with the command to take an image. */ @@ -354,6 +381,11 @@ private: */ ReturnValue_t handleActionReply(); + /** + * @brief Handles reply to checksum command + */ + ReturnValue_t handleChecksumReply(); + /** * @brief Handles all set parameter replies */ diff --git a/bsp_q7s/devices/startracker/StrHelper.h b/bsp_q7s/devices/startracker/StrHelper.h index ff2f3ca6..372c2abd 100644 --- a/bsp_q7s/devices/startracker/StrHelper.h +++ b/bsp_q7s/devices/startracker/StrHelper.h @@ -194,9 +194,9 @@ private: std::string flashReadPath = ""; // Default name of downloaded image, can be changed via command - std::string downloadImage = "image"; + std::string downloadImage = "image.bin"; // Default name of file containing the data read from flash, can be changed via command - std::string flashReadFile = "flashread"; + std::string flashReadFile = "flashread.bin"; // Will be set with the flash write command uint8_t flashWriteRegion = 0; // Will be set with the flash write command and specifies the start address where to write the From 2ea75d2a05a1f1a7b5fc6869143f5c6a0d2e29c6 Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Fri, 24 Dec 2021 07:31:21 +0100 Subject: [PATCH 06/16] erase command --- .../startracker/StarTrackerDefinitions.h | 42 ++++++++++++-- .../startracker/StarTrackerHandler.cpp | 56 ++++++++++++++++++- .../devices/startracker/StarTrackerHandler.h | 20 ++++++- 3 files changed, 109 insertions(+), 9 deletions(-) diff --git a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h index 1efa0bc7..5b839164 100644 --- a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h +++ b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h @@ -59,7 +59,6 @@ enum PoolIds: lp_id_t { TIME_TEMPERATURE_SET, MCU_TEMPERATURE, CMOS_TEMPERATURE, - TICKS_SOLUTION_SET, TIME_SOLUTION_SET, CALI_QW, @@ -83,7 +82,6 @@ enum PoolIds: lp_id_t { TRUST_WORTHY, STABLE_COUNT, SOLUTION_STRATEGY, - TICKS_HISTOGRAM_SET, TIME_HISTOGRAM_SET, HISTOGRAM_BINA0, @@ -122,7 +120,6 @@ enum PoolIds: lp_id_t { HISTOGRAM_BIND6, HISTOGRAM_BIND7, HISTOGRAM_BIND8, - TICKS_CONTRAST_SET, TIME_CONTRAST_SET, CONTRAST_BINA0, @@ -160,7 +157,8 @@ enum PoolIds: lp_id_t { CONTRAST_BIND5, CONTRAST_BIND6, CONTRAST_BIND7, - CONTRAST_BIND8 + CONTRAST_BIND8, + CHKSUM }; static const DeviceCommandId_t PING_REQUEST = 0; @@ -213,6 +211,7 @@ static const uint32_t TIME_SET_ID = REQ_TIME; static const uint32_t SOLUTION_SET_ID = REQ_SOLUTION; static const uint32_t HISTOGRAM_SET_ID = REQ_HISTOGRAM; static const uint32_t CONTRAST_SET_ID = REQ_CONTRAST; +static const uint32_t CHECKSUM_SET_ID = CHECKSUM; /** Max size of unencoded frame */ static const size_t MAX_FRAME_SIZE = 1200; @@ -225,6 +224,7 @@ static const uint8_t TIME_SET_ENTRIES = 4; static const uint8_t SOLUTION_SET_ENTRIES = 23; static const uint8_t HISTOGRAM_SET_ENTRIES = 38; static const uint8_t CONTRAST_SET_ENTRIES = 38; +static const uint8_t CHECKSUM_SET_ENTRIES = 1; // Action, parameter and telemetry IDs namespace ID { @@ -905,7 +905,7 @@ public: } void printChecksum() { - sif::info << "ChecksumReply::printChecksum: 0x" << checksum << std::endl; + sif::info << "ChecksumReply::printChecksum: 0x" << std::hex << checksum << std::endl; } private: @@ -919,6 +919,38 @@ private: uint32_t length = 0; uint32_t checksum = 0; }; + +class EraseReply { +public: + EraseReply(const uint8_t* datafield) { + region = *datafield; + } + + uint8_t getRegion() { + return region; + } + +private: + uint8_t region = 0; +}; + +class ChecksumSet: + public StaticLocalDataSet { +public: + + // Size of dataset + static const size_t SIZE = 156; + + ChecksumSet(HasLocalDataPoolIF* owner): + StaticLocalDataSet(owner, CHECKSUM_SET_ID) { + } + + ChecksumSet(object_id_t objectId): + StaticLocalDataSet(sid_t(objectId, CHECKSUM_SET_ID)) { + } + + lp_var_t checksum = lp_var_t(sid.objectId, PoolIds::CHKSUM, this); +}; } #endif /* MISSION_STARTRACKER_DEFINITIONS_H_ */ diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp index 7ae5d72c..d2d793a1 100644 --- a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp +++ b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp @@ -17,7 +17,7 @@ StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF * comCookie, StrHelper* strHelper) : DeviceHandlerBase(objectId, comIF, comCookie), temperatureSet(this), versionSet(this), powerSet( this), interfaceSet(this), timeSet(this), solutionSet(this), histogramSet(this), - contrastSet(this), strHelper(strHelper) { + contrastSet(this), checksumSet(this), strHelper(strHelper) { if (comCookie == nullptr) { sif::error << "StarTrackerHandler: Invalid com cookie" << std::endl; } @@ -416,6 +416,10 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi result = prepareParamCommand(commandData, commandDataLen, tracking); return result; } + case (StarTracker::ERASE): { + result = prepareEraseCommand(commandData, commandDataLen); + return result; + } case (StarTracker::UNLOCK): { result = prepareUnlockCommand(commandData, commandDataLen); return result; @@ -482,6 +486,8 @@ void StarTrackerHandler::fillCommandAndReplyMap() { StarTracker::MAX_FRAME_SIZE * 2 + 2); this->insertInCommandAndReplyMap(StarTracker::RESET_ERROR, 3, nullptr, StarTracker::MAX_FRAME_SIZE * 2 + 2); + this->insertInCommandAndReplyMap(StarTracker::ERASE, 3, nullptr, + StarTracker::MAX_FRAME_SIZE * 2 + 2); this->insertInCommandAndReplyMap(StarTracker::UNLOCK, 3, nullptr, StarTracker::MAX_FRAME_SIZE * 2 + 2); this->insertInCommandAndReplyMap(StarTracker::CHECKSUM, 3, nullptr, @@ -561,6 +567,10 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id, con result = handleActionReply(); break; } + case (StarTracker::ERASE): { + result = handleEraseReply(); + break; + } case (StarTracker::CHECKSUM): { result = handleChecksumReply(); break; @@ -785,7 +795,7 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l localDataPoolMap.emplace(StarTracker::CONTRAST_BIND6, new PoolEntry( { 0 })); localDataPoolMap.emplace(StarTracker::CONTRAST_BIND7, new PoolEntry( { 0 })); localDataPoolMap.emplace(StarTracker::CONTRAST_BIND8, new PoolEntry( { 0 })); - + localDataPoolMap.emplace(StarTracker::CHKSUM, new PoolEntry( { 0 })); return RETURN_OK; } @@ -840,6 +850,10 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t *foundId) *foundId = StarTracker::RESET_ERROR; break; } + case (StarTracker::ID::ERASE): { + *foundId = StarTracker::ERASE; + break; + } case (StarTracker::ID::UNLOCK): { *foundId = StarTracker::UNLOCK; break; @@ -1057,7 +1071,25 @@ void StarTrackerHandler::prepareBootCommand() { rawPacketLen = dataLinkLayer.getEncodedLength(); } -ReturnValue_t StarTrackerHandler::prepareUnlockCommand(const uint8_t* commandData, size_t commandDataLen) { +ReturnValue_t StarTrackerHandler::prepareEraseCommand(const uint8_t* commandData, + size_t commandDataLen) { + ReturnValue_t result = RETURN_OK; + if (commandDataLen != EraseCmd::LENGTH) { + return INVALID_LENGTH; + } + uint32_t length = 0; + struct EraseActionRequest req; + req.region = *commandData; + arc_pack_erase_action_req(&req, commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + eraseCmd.rememberRegion = req.region; + return result; +} + +ReturnValue_t StarTrackerHandler::prepareUnlockCommand(const uint8_t* commandData, + size_t commandDataLen) { ReturnValue_t result = RETURN_OK; uint32_t length = 0; struct UnlockActionRequest req; @@ -1292,6 +1324,21 @@ ReturnValue_t StarTrackerHandler::handleActionReply() { return RETURN_OK; } +ReturnValue_t StarTrackerHandler::handleEraseReply() { + ReturnValue_t result = RETURN_OK; + result = handleActionReply(); + if (result != RETURN_OK) { + return result; + } + const uint8_t* replyData = dataLinkLayer.getReply() + ACTION_DATA_OFFSET; + StarTracker::EraseReply eraseReply(replyData); + if (eraseReply.getRegion() != eraseCmd.rememberRegion) { + sif::warning << "StarTrackerHandler::handleEraseReply: Region mismatch" << std::endl; + return REGION_MISMATCH; + } + return result; +} + ReturnValue_t StarTrackerHandler::handleChecksumReply() { ReturnValue_t result = RETURN_OK; result = handleActionReply(); @@ -1312,6 +1359,9 @@ ReturnValue_t StarTrackerHandler::handleChecksumReply() { sif::warning << "StarTrackerHandler::handleChecksumReply: Length mismatch" << std::endl; return LENGTH_MISSMATCH; } + PoolReadGuard rg(&checksumSet); + checksumSet.checksum = checksumReply.getChecksum(); + handleDeviceTM(&checksumSet, StarTracker::CHECKSUM); #if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_STARTRACKER == 1 checksumReply.printChecksum(); #endif /* OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_STARTRACKER == 1 */ diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.h b/bsp_q7s/devices/startracker/StarTrackerHandler.h index 095105b3..3ed016ae 100644 --- a/bsp_q7s/devices/startracker/StarTrackerHandler.h +++ b/bsp_q7s/devices/startracker/StarTrackerHandler.h @@ -164,6 +164,14 @@ private: static const size_t MIN_LENGTH = 11; }; + class EraseCmd { + public: + static const uint8_t LENGTH = 1; + uint8_t rememberRegion = 0; + }; + + EraseCmd eraseCmd; + class UnlockCmd { public: static const uint8_t CODE_OFFSET = 1; @@ -175,7 +183,6 @@ private: static const uint8_t LENGTH_OFFSET = 5; // Length of checksum command static const size_t LENGTH = 9; - uint8_t rememberRegion = 0; uint32_t rememberAddress = 0; uint32_t rememberLength = 0; @@ -195,6 +202,7 @@ private: StarTracker::SolutionSet solutionSet; StarTracker::HistogramSet histogramSet; StarTracker::ContrastSet contrastSet; + StarTracker::ChecksumSet checksumSet; // Pointer to object responsible for uploading and downloading images to/from the star tracker StrHelper* strHelper = nullptr; @@ -298,6 +306,11 @@ private: */ void prepareBootCommand(); + /** + * @brief Fills command buffer with command to erase a flash region + */ + ReturnValue_t prepareEraseCommand(const uint8_t* commandData, size_t commandDataLen); + /** * @brief Fills command buffer with command to unlock flash region */ @@ -381,6 +394,11 @@ private: */ ReturnValue_t handleActionReply(); + /** + * @brief Handles reply to erase command + */ + ReturnValue_t handleEraseReply(); + /** * @brief Handles reply to checksum command */ From 8d160572c7e18cd48beef336e16cf2eee14212c9 Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Fri, 24 Dec 2021 07:51:13 +0100 Subject: [PATCH 07/16] tmtc update --- tmtc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tmtc b/tmtc index 827738f6..58ec3c66 160000 --- a/tmtc +++ b/tmtc @@ -1 +1 @@ -Subproject commit 827738f6efbfbcf32d56397e5c713f136dbd8556 +Subproject commit 58ec3c66409be1e8b9c403f73062f0e187fba021 From e26ffb6afd69e1077d262137eff233437c0b1e9b Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Wed, 29 Dec 2021 20:33:20 +0100 Subject: [PATCH 08/16] fpga download image command --- bsp_q7s/boardtest/Q7STestTask.cpp | 14 +- .../startracker/StarTrackerDefinitions.h | 257 ++++++++++- .../startracker/StarTrackerHandler.cpp | 418 +++++++++++++++++- .../devices/startracker/StarTrackerHandler.h | 104 ++++- bsp_q7s/devices/startracker/StrHelper.cpp | 132 +++++- bsp_q7s/devices/startracker/StrHelper.h | 85 +++- common/config/commonClassIds.h | 1 + generators/bsp_q7s_events.csv | 24 +- generators/events/translateEvents.cpp | 32 +- linux/fsfwconfig/events/translateEvents.cpp | 32 +- mission/memory/NVMParameterBase.h | 18 +- 11 files changed, 1031 insertions(+), 86 deletions(-) diff --git a/bsp_q7s/boardtest/Q7STestTask.cpp b/bsp_q7s/boardtest/Q7STestTask.cpp index 965a6d63..5cead3d5 100644 --- a/bsp_q7s/boardtest/Q7STestTask.cpp +++ b/bsp_q7s/boardtest/Q7STestTask.cpp @@ -127,8 +127,18 @@ void Q7STestTask::testDummyParams() { param.writeJsonFile(); param.print(); - int test = param.getValue(DummyParameter::DUMMY_KEY_PARAM_1); - std::string test2 = param.getValue(DummyParameter::DUMMY_KEY_PARAM_2); + int test = 0; + result = param.getValue(DummyParameter::DUMMY_KEY_PARAM_1, &test); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1 + << " does not exist" << std::endl; + } + std::string test2; + result = param.getValue(DummyParameter::DUMMY_KEY_PARAM_2, &test2); + if (result != HasReturnvaluesIF::RETURN_OK) { + sif::warning << "Q7STestTask::testDummyParams: Key " << DummyParameter::DUMMY_KEY_PARAM_1 + << " does not exist" << std::endl; + } sif::info << "Test value (3 expected): " << test << std::endl; sif::info << "Test value 2 (\"blirb\" expected): " << test2 << std::endl; } diff --git a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h index 5b839164..c03afa74 100644 --- a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h +++ b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h @@ -158,7 +158,45 @@ enum PoolIds: lp_id_t { CONTRAST_BIND6, CONTRAST_BIND7, CONTRAST_BIND8, - CHKSUM + CHKSUM, + DWL_ID, + DWL_PIXX, + DWL_PIXY, + DWL_X_UNCORRECTED, + DWL_Y_UNCORRECTED, + DWL_X_CORRECTED, + DWL_Y_CORRECTED, + DWL_MAGNITUDE, + DWL_CXA, + DWL_CYA, + DWL_QUALITY, + MATCHEDSTR_ID, + MATCHEDSTR_CAMFPX, + MATCHEDSTR_CAMFPY, + MATCHEDSTR_CAMCARTX, + MATCHEDSTR_CAMCARTY, + MATCHEDSTR_CAMCARTZ, + MATCHEDSTR_CAMMAGNITUDE, + MATCHEDSTR_DBFPX, + MATCHEDSTR_DBFPY, + MATCHEDSTR_DBCARTX, + MATCHEDSTR_DBCARTY, + MATCHEDSTR_DBCARTZ, + MATCHEDSTR_DBMAGNITUDE, + MATCHEDSTR_CATALOGID, + DBIMAGE_ID, + DBIMAGE_PIXX, + DBIMAGE_PIXY, + DBIMAGE_X, + DBIMAGE_Y, + DBIMAGE_MAGNITUDE, + BLOBPIX_ID, + BLOBPIX_X, + BLOBPIX_Y, + BLOBPIX_TOT_VAL, + BLOBPIX_IN_USE, + BLOBPIX_BRIGHT_NEIGHBOURS, + BLOBPIX_REGION }; static const DeviceCommandId_t PING_REQUEST = 0; @@ -195,12 +233,15 @@ static const DeviceCommandId_t CHECKSUM = 50; static const DeviceCommandId_t READ = 51; static const DeviceCommandId_t WRITE = 52; static const DeviceCommandId_t DOWNLOAD_MATCHED_STAR = 53; -static const DeviceCommandId_t DOWNLOAD_DB_IMAGE = 54; static const DeviceCommandId_t STOP_IMAGE_LOADER = 55; static const DeviceCommandId_t RESET_ERROR = 56; static const DeviceCommandId_t CHANGE_DOWNLOAD_FILE = 57; static const DeviceCommandId_t SET_JSON_FILE_NAME = 58; static const DeviceCommandId_t SET_READ_FILENAME = 59; +static const DeviceCommandId_t SET_TIME = 60; +static const DeviceCommandId_t DOWNLOAD_DBIMAGE = 61; +static const DeviceCommandId_t DOWNLOAD_BLOBPIXEL = 62; +static const DeviceCommandId_t DOWNLOAD_FPGA_IMAGE = 63; static const DeviceCommandId_t NONE = 0xFFFFFFFF; static const uint32_t VERSION_SET_ID = REQ_VERSION; @@ -212,6 +253,10 @@ static const uint32_t SOLUTION_SET_ID = REQ_SOLUTION; static const uint32_t HISTOGRAM_SET_ID = REQ_HISTOGRAM; static const uint32_t CONTRAST_SET_ID = REQ_CONTRAST; static const uint32_t CHECKSUM_SET_ID = CHECKSUM; +static const uint32_t DOWNLOADCENTROID_SET_ID = DOWNLOAD_CENTROID; +static const uint32_t DOWNLOAD_MATCHED_STAR_SET_ID = DOWNLOAD_MATCHED_STAR; +static const uint32_t DOWNLOAD_DBIMAGE_SET_ID = DOWNLOAD_DBIMAGE; +static const uint32_t DOWNLOAD_BLOBPIXEL_SET_ID = DOWNLOAD_BLOBPIXEL; /** Max size of unencoded frame */ static const size_t MAX_FRAME_SIZE = 1200; @@ -225,6 +270,10 @@ static const uint8_t SOLUTION_SET_ENTRIES = 23; static const uint8_t HISTOGRAM_SET_ENTRIES = 38; static const uint8_t CONTRAST_SET_ENTRIES = 38; static const uint8_t CHECKSUM_SET_ENTRIES = 1; +static const uint8_t DOWNLOAD_CENTROID_SET_ENTRIES = 11; +static const uint8_t DOWNLOAD_MATCHED_STAR_SET_ENTRIES = 14; +static const uint8_t DOWNLOAD_DBIMAGE_SET_ENTRIES = 6; +static const uint8_t DOWNLOAD_BLOBPIXEL_SET_ENTRIES = 7; // Action, parameter and telemetry IDs namespace ID { @@ -245,6 +294,7 @@ namespace ID { static const uint8_t REBOOT = 7; static const uint8_t UPLOAD_IMAGE = 10; static const uint8_t POWER = 11; + static const uint8_t SET_TIME = 14; static const uint8_t SUBSCRIBE = 18; static const uint8_t SOLUTION = 24; static const uint8_t TEMPERATURE = 25; @@ -258,6 +308,11 @@ namespace ID { static const uint8_t UNLOCK = 6; static const uint8_t TAKE_IMAGE = 15; static const uint8_t ERROR_RESET = 12; + static const uint8_t DOWNLOAD_CENTROID = 16; + static const uint8_t UPLOAD_CENTROID = 17; + static const uint8_t DOWNLOAD_MATCHED_STAR = 18; + static const uint8_t DOWNLOAD_DBIMAGE = 19; + static const uint8_t DOWNLOAD_BLOBPIXEL = 24; } namespace Program { @@ -951,6 +1006,202 @@ public: lp_var_t checksum = lp_var_t(sid.objectId, PoolIds::CHKSUM, this); }; -} +/** + * @brief Dataset to store download centroid response + */ +class DownloadCentroidSet: + public StaticLocalDataSet { +public: + + // Size of dataset + static const size_t SIZE = 34; + + DownloadCentroidSet(HasLocalDataPoolIF* owner): + StaticLocalDataSet(owner, DOWNLOADCENTROID_SET_ID) { + } + + DownloadCentroidSet(object_id_t objectId): + StaticLocalDataSet(sid_t(objectId, DOWNLOADCENTROID_SET_ID)) { + } + + lp_var_t id = lp_var_t(sid.objectId, PoolIds::DWL_ID, this); + lp_var_t pixx = lp_var_t(sid.objectId, PoolIds::DWL_PIXX, this); + lp_var_t pixy = lp_var_t(sid.objectId, PoolIds::DWL_PIXY, this); + lp_var_t xUncorrected = lp_var_t(sid.objectId, PoolIds::DWL_X_UNCORRECTED, this); + lp_var_t yUncorrected = lp_var_t(sid.objectId, PoolIds::DWL_Y_UNCORRECTED, this); + lp_var_t xCorrected = lp_var_t(sid.objectId, PoolIds::DWL_X_CORRECTED, this); + lp_var_t yCorrected = lp_var_t(sid.objectId, PoolIds::DWL_Y_CORRECTED, this); + lp_var_t magnitude = lp_var_t(sid.objectId, PoolIds::DWL_MAGNITUDE, this); + lp_var_t cxa = lp_var_t(sid.objectId, PoolIds::DWL_CXA, this); + lp_var_t cya = lp_var_t(sid.objectId, PoolIds::DWL_CYA, this); + lp_var_t quality = lp_var_t(sid.objectId, PoolIds::DWL_QUALITY, this); + + void printSet() { + PoolReadGuard rg(this); + sif::info << "ContrastSet::printSet: id: " << static_cast(this->id.value) + << std::endl; + sif::info << "ContrastSet::printSet: pixx: " << this->pixx << std::endl; + sif::info << "ContrastSet::printSet: pixy: " << this->pixy << std::endl; + sif::info << "ContrastSet::printSet: xUncorrected: " << this->xUncorrected << std::endl; + sif::info << "ContrastSet::printSet: yUncorrected: " << this->yUncorrected << std::endl; + sif::info << "ContrastSet::printSet: xCorrected: " << this->xCorrected << std::endl; + sif::info << "ContrastSet::printSet: yCorrected: " << this->yCorrected << std::endl; + sif::info << "ContrastSet::printSet: magnitude: " << this->magnitude << std::endl; + sif::info << "ContrastSet::printSet: cxa: " << this->cxa << std::endl; + sif::info << "ContrastSet::printSet: cya: " << this->cya << std::endl; + sif::info << "ContrastSet::printSet: quality: " << this->quality << std::endl; + } +}; + +namespace UploadCentroidKeys { + static const char id[] = "id"; + static const char pixx[] = "pixx"; + static const char pixy[] = "pixy"; + static const char x_uncorrected[] = "x_uncorrected"; + static const char y_uncorrected[] = "y_uncorrected"; + static const char x_corrected[] = "x_corrected"; + static const char y_corrected[] = "y_corrected"; + static const char magnitude[] = "magnitude"; + static const char cxa[] = "cxa"; + static const char cya[] = "cya"; + static const char quality[] = "quality"; +}; + +/** + * @brief Dataset to store matched star information + */ +class DownloadMatchedStar : + public StaticLocalDataSet { +public: + + // Size of dataset + static const size_t SIZE = 53; + + DownloadMatchedStar(HasLocalDataPoolIF* owner): + StaticLocalDataSet(owner, DOWNLOAD_MATCHED_STAR_SET_ID) { + } + + DownloadMatchedStar(object_id_t objectId): + StaticLocalDataSet(sid_t(objectId, DOWNLOAD_MATCHED_STAR_SET_ID)) { + } + + lp_var_t id = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_ID, this); + lp_var_t camfpx = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CAMFPX, this); + lp_var_t camfpy = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CAMFPY, this); + lp_var_t camcartx = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CAMCARTX, this); + lp_var_t camcarty = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CAMCARTY, this); + lp_var_t camcartz = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CAMCARTZ, this); + lp_var_t cammagnitude = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CAMMAGNITUDE, + this); + lp_var_t dbfpx = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_DBFPX, this); + lp_var_t dbfpy = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_DBFPY, this); + lp_var_t dbcartx = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_DBCARTX, this); + lp_var_t dbcarty = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_DBCARTY, this); + lp_var_t dbcartz = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_DBCARTZ, this); + lp_var_t dbmagnitude = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_DBMAGNITUDE, + this); + lp_var_t catalogid = lp_var_t(sid.objectId, PoolIds::MATCHEDSTR_CATALOGID, + this); + + void printSet() { + PoolReadGuard rg(this); + sif::info << "DownloadMatchedStar::printSet: id: " + << static_cast(this->id.value) << std::endl; + sif::info << "DownloadMatchedStar::printSet: camfpx: " << this->camfpx << std::endl; + sif::info << "DownloadMatchedStar::printSet: camfpy: " << this->camfpy << std::endl; + sif::info << "DownloadMatchedStar::printSet: camcartx: " << this->camcartx << std::endl; + sif::info << "DownloadMatchedStar::printSet: camcarty: " << this->camcarty << std::endl; + sif::info << "DownloadMatchedStar::printSet: camcartz: " << this->camcartz << std::endl; + sif::info << "DownloadMatchedStar::printSet: cammagnitude: " << this->cammagnitude + << std::endl; + sif::info << "DownloadMatchedStar::printSet: dbfpx: " << this->dbfpx << std::endl; + sif::info << "DownloadMatchedStar::printSet: dbfpy: " << this->dbfpy << std::endl; + sif::info << "DownloadMatchedStar::printSet: dbcartx: " << this->dbcartx << std::endl; + sif::info << "DownloadMatchedStar::printSet: dbcarty: " << this->dbcarty << std::endl; + sif::info << "DownloadMatchedStar::printSet: dbcartz: " << this->dbcartz << std::endl; + sif::info << "DownloadMatchedStar::printSet: dbmagnitude: " << this->dbmagnitude + << std::endl; + sif::info << "DownloadMatchedStar::printSet: catalogid: " << this->catalogid << std::endl; + } +}; + +/** + * @brief Dataset to store the response to the DownloadDBImage request + */ +class DownloadDBImage : + public StaticLocalDataSet { +public: + + // Size of dataset + static const size_t SIZE = 21; + + DownloadDBImage(HasLocalDataPoolIF* owner): + StaticLocalDataSet(owner, DOWNLOAD_DBIMAGE_SET_ID) { + } + + DownloadDBImage(object_id_t objectId): + StaticLocalDataSet(sid_t(objectId, DOWNLOAD_DBIMAGE_SET_ID)) { + } + + lp_var_t id = lp_var_t(sid.objectId, PoolIds::DBIMAGE_ID, this); + lp_var_t pixx = lp_var_t(sid.objectId, PoolIds::DBIMAGE_PIXX, this); + lp_var_t pixy = lp_var_t(sid.objectId, PoolIds::DBIMAGE_PIXY, this); + lp_var_t x = lp_var_t(sid.objectId, PoolIds::DBIMAGE_X, this); + lp_var_t y = lp_var_t(sid.objectId, PoolIds::DBIMAGE_Y, this); + lp_var_t magnitude = lp_var_t(sid.objectId, PoolIds::DBIMAGE_MAGNITUDE, this); + + void printSet() { + PoolReadGuard rg(this); + sif::info << "DownloadDBImage::printSet: id: " + << static_cast(this->id.value) << std::endl; + sif::info << "DownloadDBImage::printSet: pixx: " << this->pixx << std::endl; + sif::info << "DownloadDBImage::printSet: pixy: " << this->pixy << std::endl; + sif::info << "DownloadDBImage::printSet: x: " << this->x << std::endl; + sif::info << "DownloadDBImage::printSet: y: " << this->y << std::endl; + sif::info << "DownloadDBImage::printSet: magnitude: " << this->magnitude << std::endl; + } +}; + +/** + * @brief Dataset to store the response to the download blob pixel action request + */ +class DownloadBlobPixel: public StaticLocalDataSet { +public: + + // Size of dataset + static const size_t SIZE = 22; + + DownloadBlobPixel(HasLocalDataPoolIF* owner) : + StaticLocalDataSet(owner, DOWNLOAD_BLOBPIXEL_SET_ID) { + } + + DownloadBlobPixel(object_id_t objectId) : + StaticLocalDataSet(sid_t(objectId, DOWNLOAD_BLOBPIXEL_SET_ENTRIES)) { + } + + lp_var_t id = lp_var_t(sid.objectId, PoolIds::BLOBPIX_ID, this); + lp_var_t x = lp_var_t(sid.objectId, PoolIds::BLOBPIX_X, this); + lp_var_t y = lp_var_t(sid.objectId, PoolIds::BLOBPIX_Y, this); + lp_var_t totalValue = lp_var_t(sid.objectId, PoolIds::BLOBPIX_TOT_VAL, this); + lp_var_t inUse = lp_var_t(sid.objectId, PoolIds::BLOBPIX_IN_USE, this); + lp_var_t brightNeighbours = lp_var_t(sid.objectId, + PoolIds::BLOBPIX_BRIGHT_NEIGHBOURS, this); + lp_var_t region = lp_var_t(sid.objectId, PoolIds::BLOBPIX_REGION, this); + + void printSet() { + PoolReadGuard rg(this); + sif::info << "DownloadBlobPixel::printSet: id: " + << static_cast(this->id.value) << std::endl; + sif::info << "DownloadBlobPixel::printSet: x: " << this->x << std::endl; + sif::info << "DownloadBlobPixel::printSet: y: " << this->y << std::endl; + sif::info << "DownloadBlobPixel::printSet: totalValue: " << this->totalValue << std::endl; + sif::info << "DownloadBlobPixel::printSet: inUse: " + << static_cast(this->inUse.value) << std::endl; + sif::info << "DownloadBlobPixel::printSet: brightNeighbours: " << this->brightNeighbours + << std::endl; + sif::info << "DownloadBlobPixel::printSet: region: " << this->region << std::endl; + } +}; +} #endif /* MISSION_STARTRACKER_DEFINITIONS_H_ */ diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp index d2d793a1..57aa5dfc 100644 --- a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp +++ b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp @@ -1,23 +1,25 @@ #include - #include "StarTrackerHandler.h" #include "OBSWConfig.h" #include "StarTrackerJsonCommands.h" - #include #include - +#include extern "C" { #include #include #include "common/misc.h" } +using json = nlohmann::json; + StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF * comCookie, StrHelper* strHelper) : DeviceHandlerBase(objectId, comIF, comCookie), temperatureSet(this), versionSet(this), powerSet( - this), interfaceSet(this), timeSet(this), solutionSet(this), histogramSet(this), - contrastSet(this), checksumSet(this), strHelper(strHelper) { + this), interfaceSet(this), timeSet(this), solutionSet(this), histogramSet(this), contrastSet( + this), checksumSet(this), downloadCentroidSet(this), downloadMatchedStar(this), + downloadDbImage(this), downloadBlobPixel(this), strHelper( + strHelper) { if (comCookie == nullptr) { sif::error << "StarTrackerHandler: Invalid com cookie" << std::endl; } @@ -51,7 +53,7 @@ ReturnValue_t StarTrackerHandler::initialize() { } result = manager->subscribeToEventRange(eventQueue->getId(), event::getEventId(StrHelper::IMAGE_UPLOAD_FAILED), - event::getEventId(StrHelper::FLASH_READ_FAILED)); + event::getEventId(StrHelper::FPGA_UPLOAD_FAILED)); if (result != RETURN_OK) { #if FSFW_CPP_OSTREAM_ENABLED == 1 sif::warning << "StarTrackerHandler::initialize: Failed to subscribe to events from " @@ -173,6 +175,21 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu std::string(reinterpret_cast(data), size)); return EXECUTION_FINISHED; } + case(StarTracker::DOWNLOAD_FPGA_IMAGE): { + result = DeviceHandlerBase::acceptExternalDeviceCommands(); + if (result != RETURN_OK) { + return result; + } + if (size > MAX_PATH_SIZE) { + return FILE_PATH_TOO_LONG; + } + result = executeFpgaDownloadCommand(data, size); + if (result != RETURN_OK) { + return result; + } + strHelperExecuting = true; + return EXECUTION_FINISHED; + } default: break; } @@ -428,6 +445,30 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi result = prepareChecksumCommand(commandData, commandDataLen); return result; } + case (StarTracker::SET_TIME): { + result = prepareSetTimeCommand(commandData, commandDataLen); + return result; + } + case (StarTracker::DOWNLOAD_CENTROID): { + result = prepareDownloadCentroidCommand(commandData, commandDataLen); + return result; + } + case (StarTracker::UPLOAD_CENTROID): { + result = prepareUploadCentroidCommand(commandData, commandDataLen); + return result; + } + case (StarTracker::DOWNLOAD_MATCHED_STAR): { + result = prepareDownloadMatchedStarCommand(commandData, commandDataLen); + return result; + } + case (StarTracker::DOWNLOAD_DBIMAGE): { + result = prepareDownloadDbImageCommand(commandData, commandDataLen); + return result; + } + case (StarTracker::DOWNLOAD_BLOBPIXEL): { + result = prepareDownloadBlobPixelCommand(commandData, commandDataLen); + return result; + } default: return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED; } @@ -492,6 +533,18 @@ void StarTrackerHandler::fillCommandAndReplyMap() { StarTracker::MAX_FRAME_SIZE * 2 + 2); this->insertInCommandAndReplyMap(StarTracker::CHECKSUM, 3, nullptr, StarTracker::MAX_FRAME_SIZE * 2 + 2); + this->insertInCommandAndReplyMap(StarTracker::SET_TIME, 3, nullptr, + StarTracker::MAX_FRAME_SIZE * 2 + 2); + this->insertInCommandAndReplyMap(StarTracker::DOWNLOAD_CENTROID, 3, nullptr, + StarTracker::MAX_FRAME_SIZE * 2 + 2); + this->insertInCommandAndReplyMap(StarTracker::UPLOAD_CENTROID, 3, nullptr, + StarTracker::MAX_FRAME_SIZE * 2 + 2); + this->insertInCommandAndReplyMap(StarTracker::DOWNLOAD_MATCHED_STAR, 3, &downloadMatchedStar, + StarTracker::MAX_FRAME_SIZE * 2 + 2); + this->insertInCommandAndReplyMap(StarTracker::DOWNLOAD_DBIMAGE, 3, &downloadDbImage, + StarTracker::MAX_FRAME_SIZE * 2 + 2); + this->insertInCommandAndReplyMap(StarTracker::DOWNLOAD_BLOBPIXEL, 3, &downloadBlobPixel, + StarTracker::MAX_FRAME_SIZE * 2 + 2); } ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t *start, size_t remainingSize, @@ -563,10 +616,31 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id, con case (StarTracker::BOOT): case (StarTracker::TAKE_IMAGE): case (StarTracker::RESET_ERROR): - case (StarTracker::UNLOCK): { + case (StarTracker::UNLOCK): + case (StarTracker::SET_TIME): { result = handleActionReply(); break; } + case (StarTracker::DOWNLOAD_CENTROID): { + result = handleActionReplySet(downloadCentroidSet, StarTracker::DownloadCentroidSet::SIZE); + break; + } + case (StarTracker::DOWNLOAD_MATCHED_STAR): { + result = handleActionReplySet(downloadMatchedStar, StarTracker::DownloadMatchedStar::SIZE); + break; + } + case (StarTracker::DOWNLOAD_DBIMAGE): { + result = handleActionReplySet(downloadDbImage, StarTracker::DownloadDBImage::SIZE); + break; + } + case (StarTracker::DOWNLOAD_BLOBPIXEL): { + result = handleActionReplySet(downloadBlobPixel, StarTracker::DownloadBlobPixel::SIZE); + break; + } + case (StarTracker::UPLOAD_CENTROID): { + result = handleUploadCentroidReply(); + break; + } case (StarTracker::ERASE): { result = handleEraseReply(); break; @@ -796,6 +870,41 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l localDataPoolMap.emplace(StarTracker::CONTRAST_BIND7, new PoolEntry( { 0 })); localDataPoolMap.emplace(StarTracker::CONTRAST_BIND8, new PoolEntry( { 0 })); localDataPoolMap.emplace(StarTracker::CHKSUM, new PoolEntry( { 0 })); + + localDataPoolMap.emplace(StarTracker::DWL_ID, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::DWL_PIXX, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::DWL_PIXY, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::DWL_X_UNCORRECTED, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::DWL_Y_UNCORRECTED, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::DWL_X_CORRECTED, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::DWL_Y_CORRECTED, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::DWL_MAGNITUDE, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::DWL_CXA, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::DWL_CYA, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::DWL_QUALITY, new PoolEntry( { 0 })); + + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_ID, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMFPX, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMFPY, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMCARTX, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMCARTY, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMCARTZ, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CAMMAGNITUDE, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBFPX, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBFPY, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBCARTX, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBCARTY, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBCARTZ, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_DBMAGNITUDE, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::MATCHEDSTR_CATALOGID, new PoolEntry( { 0 })); + + localDataPoolMap.emplace(StarTracker::BLOBPIX_ID, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::BLOBPIX_X, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::BLOBPIX_Y, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::BLOBPIX_TOT_VAL, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::BLOBPIX_IN_USE, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::BLOBPIX_BRIGHT_NEIGHBOURS, new PoolEntry( { 0 })); + localDataPoolMap.emplace(StarTracker::BLOBPIX_REGION, new PoolEntry( { 0 })); return RETURN_OK; } @@ -862,6 +971,30 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t *foundId) *foundId = StarTracker::CHECKSUM; break; } + case (StarTracker::ID::SET_TIME): { + *foundId = StarTracker::SET_TIME; + break; + } + case (StarTracker::ID::DOWNLOAD_CENTROID): { + *foundId = StarTracker::DOWNLOAD_CENTROID; + break; + } + case (StarTracker::ID::UPLOAD_CENTROID): { + *foundId = StarTracker::UPLOAD_CENTROID; + break; + } + case (StarTracker::ID::DOWNLOAD_MATCHED_STAR): { + *foundId = StarTracker::DOWNLOAD_MATCHED_STAR; + break; + } + case (StarTracker::ID::DOWNLOAD_DBIMAGE): { + *foundId = StarTracker::DOWNLOAD_DBIMAGE; + break; + } + case (StarTracker::ID::DOWNLOAD_BLOBPIXEL): { + *foundId = StarTracker::DOWNLOAD_BLOBPIXEL; + break; + } default: sif::warning << "StarTrackerHandler::scanForParameterReply: Unknown parameter reply id" << std::endl; @@ -1019,6 +1152,46 @@ ReturnValue_t StarTrackerHandler::executeWriteCommand(const uint8_t* commandData return result; } +ReturnValue_t StarTrackerHandler::executeFpgaDownloadCommand(const uint8_t* commandData, + size_t commandDataLen) { + ReturnValue_t result = RETURN_OK; + if (commandDataLen < FpgaDownloadCmd::MIN_LENGTH) { + sif::warning << "StarTrackerHandler::executeFpgaDownloadCommand: Command too short" + << std::endl; + return COMMAND_TOO_SHORT; + } + uint32_t position; + size_t size = sizeof(position); + result = SerializeAdapter::deSerialize(&position, &commandData, &size, + SerializeIF::Endianness::BIG); + if (result != RETURN_OK) { + sif::debug << "StarTrackerHandler::executeWriteCommand: Deserialization of position failed" + << std::endl; + return result; + } + uint32_t length; + size = sizeof(length); + result = SerializeAdapter::deSerialize(&length, &commandData, &size, + SerializeIF::Endianness::BIG); + if (result != RETURN_OK) { + sif::debug << "StarTrackerHandler::executeWriteCommand: Deserialization of length failed" + << std::endl; + return result; + } + if (commandDataLen - sizeof(position) - sizeof(length) > MAX_PATH_SIZE) { + sif::warning << "StarTrackerHandler::executeFpgaDownloadCommand: Received command with " + " invalid path and filename" << std::endl; + return FILE_PATH_TOO_LONG; + } + std::string fullname = std::string(reinterpret_cast(commandData), + commandDataLen - sizeof(position) - sizeof(length)); + result = strHelper->startFpgaDownload(fullname, position, length); + if (result != RETURN_OK) { + return result; + } + return result; +} + ReturnValue_t StarTrackerHandler::executeReadCommand(const uint8_t* commandData, size_t commandDataLen) { ReturnValue_t result = RETURN_OK; @@ -1146,6 +1319,140 @@ ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandD return result; } + +ReturnValue_t StarTrackerHandler::prepareSetTimeCommand(const uint8_t* commandData, + size_t commandDataLen) { + ReturnValue_t result = RETURN_OK; + struct SetTimeActionRequest req; + if (commandDataLen != SetTimeCmd::LENGTH) { + sif::warning << "StarTrackerHandler::prepareSetTimeCommand: Invalid length" << std::endl; + return INVALID_LENGTH; + } + size_t size = sizeof(req.unixTime); + result = SerializeAdapter::deSerialize(&req.unixTime, commandData, &size, + SerializeIF::Endianness::BIG); + if (result != RETURN_OK) { + sif::debug << "StarTrackerHandler::prepareSetTimeCommand: Deserialization failed" + << std::endl; + return result; + } + uint32_t length = 0; + arc_pack_settime_action_req(&req, commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return result; +} + +ReturnValue_t StarTrackerHandler::prepareDownloadCentroidCommand(const uint8_t* commandData, + size_t commandDataLen) { + ReturnValue_t result = RETURN_OK; + struct DownloadCentroidActionRequest req; + if (commandDataLen != DownloadCentroidCmd::LENGTH) { + sif::warning << "StarTrackerHandler::prepareDownloadCentroidCommand: Invalid length" + << std::endl; + return INVALID_LENGTH; + } + req.id = *commandData; + uint32_t length = 0; + arc_pack_downloadcentroid_action_req(&req, commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return result; +} + +ReturnValue_t StarTrackerHandler::prepareUploadCentroidCommand(const uint8_t* commandData, + size_t commandDataLen) { + if (commandDataLen > MAX_PATH_SIZE) { + return FILE_PATH_TOO_LONG; + } + ReturnValue_t result = RETURN_OK; + struct UploadCentroidActionRequest req; + std::string jsonFileName = std::string(reinterpret_cast(commandData), + commandDataLen); + NVMParameterBase j(jsonFileName); + result = j.readJsonFile(); + if (result != RETURN_OK) { + sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: " << jsonFileName + << " does not exist" << std::endl; + return result; + } + result = j.getValue(StarTracker::UploadCentroidKeys::id, &req.id); + if (result != RETURN_OK) { + sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key " + << StarTracker::UploadCentroidKeys::id << " does not exist" << std::endl; + return result; + } + result = j.getValue(StarTracker::UploadCentroidKeys::pixx, &req.pixx); + if (result != RETURN_OK) { + sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key " + << StarTracker::UploadCentroidKeys::pixx << " does not exist" << std::endl; + return result; + } + result = j.getValue(StarTracker::UploadCentroidKeys::pixy, &req.pixy); + if (result != RETURN_OK) { + sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key " + << StarTracker::UploadCentroidKeys::pixy << " does not exist" << std::endl; + return result; + } + result = j.getValue(StarTracker::UploadCentroidKeys::x_uncorrected, &req.x_uncorrected); + if (result != RETURN_OK) { + sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key " + << StarTracker::UploadCentroidKeys::x_uncorrected << " does not exist" << std::endl; + return result; + } + result = j.getValue(StarTracker::UploadCentroidKeys::y_uncorrected, &req.y_uncorrected); + if (result != RETURN_OK) { + sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key " + << StarTracker::UploadCentroidKeys::y_uncorrected << " does not exist" << std::endl; + return result; + } + result = j.getValue(StarTracker::UploadCentroidKeys::x_corrected, &req.x_corrected); + if (result != RETURN_OK) { + sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key " + << StarTracker::UploadCentroidKeys::x_corrected << " does not exist" << std::endl; + return result; + } + result = j.getValue(StarTracker::UploadCentroidKeys::y_corrected, &req.y_corrected); + if (result != RETURN_OK) { + sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key " + << StarTracker::UploadCentroidKeys::y_corrected << " does not exist" << std::endl; + return result; + } + result = j.getValue(StarTracker::UploadCentroidKeys::magnitude, &req.magnitude); + if (result != RETURN_OK) { + sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key " + << StarTracker::UploadCentroidKeys::magnitude << " does not exist" << std::endl; + return result; + } + result = j.getValue(StarTracker::UploadCentroidKeys::cxa, &req.cxa); + if (result != RETURN_OK) { + sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key " + << StarTracker::UploadCentroidKeys::cxa << " does not exist" << std::endl; + return result; + } + result = j.getValue(StarTracker::UploadCentroidKeys::cya, &req.cya); + if (result != RETURN_OK) { + sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key " + << StarTracker::UploadCentroidKeys::cya << " does not exist" << std::endl; + return result; + } + result = j.getValue(StarTracker::UploadCentroidKeys::quality, &req.quality); + if (result != RETURN_OK) { + sif::warning << "StarTrackerHandler::prepareUploadCentroidCommand: The key " + << StarTracker::UploadCentroidKeys::quality << " does not exist" << std::endl; + return result; + } + uint32_t length = 0; + arc_pack_uploadcentroid_action_req(&req, commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + uploadCentroid.rememberId = req.id; + return result; +} + void StarTrackerHandler::prepareTimeRequest() { uint32_t length = 0; arc_tm_pack_time_req(commandBuffer, &length); @@ -1293,6 +1600,55 @@ ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData return RETURN_OK; } +ReturnValue_t StarTrackerHandler::prepareDownloadMatchedStarCommand(const uint8_t* commandData, + size_t commandDataLen) { + if (commandDataLen != DownloadMatchedStarCmd::LENGTH) { + return INVALID_LENGTH; + } + struct DownloadMatchedStarActionRequest req; + req.id = *commandData; + uint32_t length = 0; + arc_pack_downloadmatchedstar_action_req(&req, commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + +ReturnValue_t StarTrackerHandler::prepareDownloadDbImageCommand(const uint8_t* commandData, + size_t commandDataLen) { + if (commandDataLen != DownloadDbImageCmd::LENGTH) { + return INVALID_LENGTH; + } + struct DownloadDBImageActionRequest req; + req.id = *commandData; + uint32_t length = 0; + arc_pack_downloaddbimage_action_req(&req, commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + +ReturnValue_t StarTrackerHandler::prepareDownloadBlobPixelCommand(const uint8_t* commandData, + size_t commandDataLen) { + if (commandDataLen != DownloadBlobPixCmd::LENGTH) { + return INVALID_LENGTH; + } + struct DownloadBlobPixelActionRequest req; + req.id = *commandData; + req.type = *(commandData + 1); + if ((req.type != DownloadBlobPixCmd::NORMAL) && (req.type != DownloadBlobPixCmd::FAST)) { + return INVALID_TYPE; + } + uint32_t length = 0; + arc_pack_downloadblobpixel_action_req(&req, commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + ReturnValue_t StarTrackerHandler::handleSetParamReply() { const uint8_t* reply = dataLinkLayer.getReply(); uint8_t status = *(reply + STATUS_OFFSET); @@ -1316,7 +1672,7 @@ ReturnValue_t StarTrackerHandler::handleActionReply() { uint8_t status = *(reply + STATUS_OFFSET); if (status != StarTracker::STATUS_OK) { sif::warning << "StarTrackerHandler::handleActionReply: Failed to execute action " - << " command with action ID " + << "command with action ID " << static_cast(*(reply + ACTION_ID_OFFSET)) << " and status "<< static_cast(status) << std::endl; return ACTION_FAILED; @@ -1324,6 +1680,19 @@ ReturnValue_t StarTrackerHandler::handleActionReply() { return RETURN_OK; } +ReturnValue_t StarTrackerHandler::handleUploadCentroidReply() { + ReturnValue_t result = RETURN_OK; + result = handleActionReply(); + if (result != RETURN_OK) { + return result; + } + const uint8_t* reply = dataLinkLayer.getReply(); + if (*(reply + ACTION_DATA_OFFSET) != uploadCentroid.rememberId) { + return UPLOAD_CENTROID_ID_MISMATCH; + } + return RETURN_OK; +} + ReturnValue_t StarTrackerHandler::handleEraseReply() { ReturnValue_t result = RETURN_OK; result = handleActionReply(); @@ -1422,7 +1791,7 @@ ReturnValue_t StarTrackerHandler::handleTm(LocalPoolDataSetBase& dataset, size_t if(status != StarTracker::STATUS_OK) { sif::warning << "StarTrackerHandler::handleTm: Reply error: " << static_cast(status) << std::endl; - return TM_REPLY_ERROR; + return REPLY_ERROR; } result = dataset.read(TIMEOUT_TYPE, MUTEX_TIMEOUT); if (result != RETURN_OK) { @@ -1447,6 +1816,37 @@ ReturnValue_t StarTrackerHandler::handleTm(LocalPoolDataSetBase& dataset, size_t return result; } +ReturnValue_t StarTrackerHandler::handleActionReplySet(LocalPoolDataSetBase& dataset, size_t size) { + ReturnValue_t result = RETURN_OK; + uint8_t status = *(dataLinkLayer.getReply() + STATUS_OFFSET); + if(status != StarTracker::STATUS_OK) { + sif::warning << "StarTrackerHandler::handleActionReplySet: Reply error: " + << static_cast(status) << std::endl; + return REPLY_ERROR; + } + result = dataset.read(TIMEOUT_TYPE, MUTEX_TIMEOUT); + if (result != RETURN_OK) { + return result; + } + const uint8_t* reply = dataLinkLayer.getReply() + ACTION_DATA_OFFSET; + dataset.setValidityBufferGeneration(false); + result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE); + if (result != RETURN_OK) { + sif::warning << "StarTrackerHandler::handleActionReplySet Deserialization failed" + << std::endl; + } + dataset.setValidityBufferGeneration(true); + dataset.setValidity(true, true); + result = dataset.commit(TIMEOUT_TYPE, MUTEX_TIMEOUT); + if (result != RETURN_OK) { + return result; + } +#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_STARTRACKER == 1 + dataset.printSet(); +#endif + return result; +} + void StarTrackerHandler::handleStartup(const uint8_t* parameterId) { switch(*parameterId) { case (StarTracker::ID::LIMITS): { diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.h b/bsp_q7s/devices/startracker/StarTrackerHandler.h index 3ed016ae..d26c8aea 100644 --- a/bsp_q7s/devices/startracker/StarTrackerHandler.h +++ b/bsp_q7s/devices/startracker/StarTrackerHandler.h @@ -111,8 +111,8 @@ private: static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xAC); //! [EXPORT] : [COMMENT] Received version reply with invalid program ID static const ReturnValue_t INVALID_PROGRAM = MAKE_RETURN_CODE(0xAD); - //! [EXPORT] : [COMMENT] Status field of tm reply signals error - static const ReturnValue_t TM_REPLY_ERROR = MAKE_RETURN_CODE(0xAE); + //! [EXPORT] : [COMMENT] Status field reply signals error + static const ReturnValue_t REPLY_ERROR = MAKE_RETURN_CODE(0xAE); //! [EXPORT] : [COMMENT] Status field of contrast reply signals error static const ReturnValue_t CONTRAST_REQ_FAILED = MAKE_RETURN_CODE(0xAE); //! [EXPORT] : [COMMENT] Received command which is too short (some data is missing for proper execution) @@ -125,6 +125,12 @@ private: static const ReturnValue_t ADDRESS_MISMATCH = MAKE_RETURN_CODE(0xB2); //! [EXPORT] : [COMMENT] Length field mismatch between send and received data static const ReturnValue_t lENGTH_MISMATCH = MAKE_RETURN_CODE(0xB3); + //! [EXPORT] : [COMMENT] Specified file does not exist + static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xB4); + //! [EXPORT] : [COMMENT] Reply to upload centroid does not match commanded centroid id + static const ReturnValue_t UPLOAD_CENTROID_ID_MISMATCH = MAKE_RETURN_CODE(0xB5); + //! [EXPORT] : [COMMENT] Download blob pixel command has invalid type field + static const ReturnValue_t INVALID_TYPE = MAKE_RETURN_CODE(0xB6); static const size_t MAX_PATH_SIZE = 50; static const size_t MAX_FILE_NAME = 30; @@ -190,6 +196,45 @@ private: ChecksumCmd checksumCmd; + class SetTimeCmd { + public: + static const uint8_t LENGTH = 8; + }; + + class DownloadCentroidCmd { + public: + static const uint8_t LENGTH = 1; + }; + + class UploadCentroid { + public: + uint8_t rememberId = 0; + }; + + UploadCentroid uploadCentroid; + + class DownloadMatchedStarCmd { + public: + static const uint8_t LENGTH = 1; + }; + + class DownloadDbImageCmd { + public: + static const uint8_t LENGTH = 1; + }; + + class DownloadBlobPixCmd { + public: + static const uint8_t LENGTH = 2; + static const uint8_t NORMAL = 0; + static const uint8_t FAST = 1; + }; + + class FpgaDownloadCmd { + public: + static const uint8_t MIN_LENGTH = 10; + }; + MessageQueueIF* eventQueue = nullptr; ArcsecDatalinkLayer dataLinkLayer; @@ -203,6 +248,10 @@ private: StarTracker::HistogramSet histogramSet; StarTracker::ContrastSet contrastSet; StarTracker::ChecksumSet checksumSet; + StarTracker::DownloadCentroidSet downloadCentroidSet; + StarTracker::DownloadMatchedStar downloadMatchedStar; + StarTracker::DownloadDBImage downloadDbImage; + StarTracker::DownloadBlobPixel downloadBlobPixel; // Pointer to object responsible for uploading and downloading images to/from the star tracker StrHelper* strHelper = nullptr; @@ -289,6 +338,14 @@ private: */ ReturnValue_t executeWriteCommand(const uint8_t* commandData, size_t commandDataLen); + /** + * @brief Starts the execution of the fpga download command + * + * @param commandData Pointer to buffer with command data + * @param commandDataLen Size of received command + */ + ReturnValue_t executeFpgaDownloadCommand(const uint8_t* commandData, size_t commandDataLen); + /** * @brief Extracts information for flash-read-command from TC data and starts execution of * flash-read-procedure @@ -321,6 +378,21 @@ private: */ ReturnValue_t prepareChecksumCommand(const uint8_t* commandData, size_t commandDataLen); + /** + * @brief Fills command buffer with command to set the unix time + */ + ReturnValue_t prepareSetTimeCommand(const uint8_t* commandData, size_t commandDataLen); + + /** + * @brief Fills command buffer with command to request a centroid + */ + ReturnValue_t prepareDownloadCentroidCommand(const uint8_t* commandData, size_t commandDataLen); + + /** + * @brief Fills command buffer with command to upload a centroid for testing purpose + */ + ReturnValue_t prepareUploadCentroidCommand(const uint8_t* commandData, size_t commandDataLen); + /** * @brief Fills the command buffer with the command to take an image. */ @@ -389,11 +461,39 @@ private: ReturnValue_t prepareParamCommand(const uint8_t* commandData, size_t commandDataLen, ArcsecJsonParamBase& paramSet); + /** + * @brief Fills command buffer with data to request matched star. + */ + ReturnValue_t prepareDownloadMatchedStarCommand(const uint8_t* commandData, + size_t commandDataLen); + + /** + * @brief Fills command buffer with data to request matched star coordinates. + */ + ReturnValue_t prepareDownloadDbImageCommand(const uint8_t* commandData, + size_t commandDataLen); + + /** + * @brief Fills command buffer with data to request output of the blob filter algorithm. + */ + ReturnValue_t prepareDownloadBlobPixelCommand(const uint8_t* commandData, + size_t commandDataLen); + + /** + * @brief Handles action replies with datasets. + */ + ReturnValue_t handleActionReplySet(LocalPoolDataSetBase& dataset, size_t size); + /** * @brief Default function to handle action replies */ ReturnValue_t handleActionReply(); + /** + * @brief Handles reply to upload centroid command + */ + ReturnValue_t handleUploadCentroidReply(); + /** * @brief Handles reply to erase command */ diff --git a/bsp_q7s/devices/startracker/StrHelper.cpp b/bsp_q7s/devices/startracker/StrHelper.cpp index fa7b510f..9ee2ce0e 100644 --- a/bsp_q7s/devices/startracker/StrHelper.cpp +++ b/bsp_q7s/devices/startracker/StrHelper.cpp @@ -74,6 +74,17 @@ ReturnValue_t StrHelper::performOperation(uint8_t operationCode) { internalState = InternalState::IDLE; break; } + case InternalState::DOWNLOAD_FPGA_IMAGE: { + result = performFpgaDownload(); + if (result == RETURN_OK){ + triggerEvent(FPGA_DOWNLOAD_SUCCESSFUL); + } + else { + triggerEvent(FPGA_DOWNLOAD_FAILED); + } + internalState = InternalState::IDLE; + break; + } default: sif::debug << "StrHelper::performOperation: Invalid state" << std::endl; break; @@ -109,15 +120,15 @@ ReturnValue_t StrHelper::startImageUpload(std::string uploadImage_) { return RETURN_OK; } -ReturnValue_t StrHelper::startImageDownload(std::string downloadPath_) { - ReturnValue_t result = checkPath(downloadPath_); +ReturnValue_t StrHelper::startImageDownload(std::string downloadImagePath_) { + ReturnValue_t result = checkPath(downloadImagePath_); if (result != RETURN_OK) { return result; } - if(not std::filesystem::exists(downloadPath_)) { + if(not std::filesystem::exists(downloadImagePath_)) { return PATH_NOT_EXISTS; } - downloadPath = downloadPath_; + downloadImagePath = downloadImagePath_; internalState = InternalState::DOWNLOAD_IMAGE; terminate = false; semaphore.release(); @@ -173,19 +184,30 @@ ReturnValue_t StrHelper::startFlashRead(std::string flashReadPath_, uint8_t regi return RETURN_OK; } +ReturnValue_t StrHelper::startFpgaDownload(std::string path, uint32_t startPosition, + uint32_t length) { + fpgaDownload.path = path; + fpgaDownload.startPosition = startPosition; + fpgaDownload.length = length; + internalState = InternalState::DOWNLOAD_FPGA_IMAGE; + semaphore.release(); + terminate = false; + return RETURN_OK; +} + ReturnValue_t StrHelper::performImageDownload() { ReturnValue_t result; struct DownloadActionRequest downloadReq; uint32_t size = 0; uint32_t retries = 0; Timestamp timestamp; - std::string image = downloadPath + "/" + timestamp.str() + downloadImage ; + std::string image = downloadImagePath + "/" + timestamp.str() + downloadImage ; std::ofstream file(image, std::ios_base::app | std::ios_base::out); if(not std::filesystem::exists(image)) { return FILE_CREATION_FAILED; } downloadReq.position = 0; - while(downloadReq.position < LAST_POSITION) { + while(downloadReq.position < ImageDownload::LAST_POSITION) { if (terminate) { return RETURN_OK; } @@ -200,7 +222,7 @@ ReturnValue_t StrHelper::performImageDownload() { file.close(); return result; } - result = checkReply(); + result = checkActionReply(); if (result != RETURN_OK) { if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { uartComIF->flushUartRxBuffer(comCookie); @@ -257,7 +279,7 @@ ReturnValue_t StrHelper::performImageUpload() { if (result != RETURN_OK) { return RETURN_FAILED; } - result = checkReply(); + result = checkActionReply(); if (result != RETURN_OK) { return result; } @@ -274,7 +296,7 @@ ReturnValue_t StrHelper::performImageUpload() { if (result != RETURN_OK) { return RETURN_FAILED; } - result = checkReply(); + result = checkActionReply(); if (result != RETURN_OK) { return result; } @@ -366,7 +388,7 @@ ReturnValue_t StrHelper::performFlashRead() { file.close(); return result; } - result = checkReply(); + result = checkActionReply(); if (result != RETURN_OK) { if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { uartComIF->flushUartRxBuffer(comCookie); @@ -395,6 +417,58 @@ ReturnValue_t StrHelper::performFlashRead() { return RETURN_OK; } +ReturnValue_t StrHelper::performFpgaDownload() { + ReturnValue_t result; + struct DownloadFPGAImageActionRequest req; + uint32_t size = 0; + uint32_t retries = 0; + Timestamp timestamp; + std::string image = fpgaDownload.path + "/" + timestamp.str() + fpgaDownload.fileName; + std::ofstream file(image, std::ios_base::app | std::ios_base::out); + if(not std::filesystem::exists(image)) { + return FILE_CREATION_FAILED; + } + req.pos = fpgaDownload.startPosition; + while(req.pos < fpgaDownload.length) { + if (terminate) { + return RETURN_OK; + } + if (fpgaDownload.length - req.pos >= FpgaDownload::MAX_DATA) { + req.length = FpgaDownload::MAX_DATA; + } + else { + req.length = fpgaDownload.length - req.pos; + } + arc_pack_downloadfpgaimage_action_req(&req, commandBuffer, &size); + result = sendAndRead(size, req.pos); + if (result != RETURN_OK) { + if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { + uartComIF->flushUartRxBuffer(comCookie); + retries++; + continue; + } + file.close(); + return result; + } + result = checkFpgaDownloadReply(req.pos, req.length); + if (result != RETURN_OK) { + if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { + uartComIF->flushUartRxBuffer(comCookie); + retries++; + continue; + } + file.close(); + return result; + } + file.write(reinterpret_cast(datalinkLayer.getReply() + FpgaDownload::DATA_OFFSET), + req.length); + req.pos += req.length; + retries = 0; + } + file.close(); + return RETURN_OK; +} + ReturnValue_t StrHelper::sendAndRead(size_t size, uint32_t parameter) { ReturnValue_t result = RETURN_OK; ReturnValue_t decResult = RETURN_OK; @@ -451,16 +525,16 @@ ReturnValue_t StrHelper::sendAndRead(size_t size, uint32_t parameter) { return RETURN_OK; } -ReturnValue_t StrHelper::checkReply() { +ReturnValue_t StrHelper::checkActionReply() { uint8_t type = datalinkLayer.getReplyFrameType(); if (type != TMTC_ACTIONREPLY) { - sif::warning << "StrHelper::checkReply: Received reply with invalid type ID" + sif::warning << "StrHelper::checkActionReply: Received reply with invalid type ID" << std::endl; return INVALID_TYPE_ID; } uint8_t status = datalinkLayer.getStatusField(); if (status != ArcsecDatalinkLayer::STATUS_OK) { - sif::warning << "StrHelper::checkReply: Status failure: " + sif::warning << "StrHelper::checkActionReply: Status failure: " << static_cast(status) << std::endl; return STATUS_ERROR; } @@ -480,7 +554,7 @@ ReturnValue_t StrHelper::checkReplyPosition(uint32_t expectedPosition) { ReturnValue_t StrHelper::checkFlashActionReply(uint8_t region_, uint32_t address_, uint16_t length_) { ReturnValue_t result = RETURN_OK; - result = checkReply(); + result = checkActionReply(); if (result != RETURN_OK) { return result; } @@ -494,6 +568,7 @@ ReturnValue_t StrHelper::checkFlashActionReply(uint8_t region_, uint32_t address if (result != RETURN_OK) { sif::warning << "StrHelper::checkFlashActionReply: Deserialization of address failed" << std::endl; + return result; } uint16_t length; size = sizeof(length); @@ -516,6 +591,35 @@ ReturnValue_t StrHelper::checkFlashActionReply(uint8_t region_, uint32_t address return RETURN_OK; } +ReturnValue_t StrHelper::checkFpgaDownloadReply(uint32_t expectedPosition, + uint32_t expectedLength) { + ReturnValue_t result = RETURN_OK; + result = checkActionReply(); + if (result != RETURN_OK) { + return result; + } + const uint8_t* data = datalinkLayer.getReply() + FpgaDownload::POSITION_OFFSET; + uint32_t position; + size_t size = sizeof(position); + result = SerializeAdapter::deSerialize(&position, &data, &size, + SerializeIF::Endianness::LITTLE); + if (result != RETURN_OK) { + sif::warning << "StrHelper::checkFpgaDownloadReply: Deserialization of position failed" + << std::endl; + return result; + } + uint32_t length; + size = sizeof(length); + result = SerializeAdapter::deSerialize(&length, &data, &size, + SerializeIF::Endianness::LITTLE); + if (result != RETURN_OK) { + sif::warning << "StrHelper::checkFpgaDownloadReply: Deserialization of length failed" + << std::endl; + return result; + } + return RETURN_OK; +} + ReturnValue_t StrHelper::checkPath(std::string name) { if (name.substr(0, sizeof(SdCardManager::SD_0_MOUNT_POINT)) == std::string(SdCardManager::SD_0_MOUNT_POINT)) { diff --git a/bsp_q7s/devices/startracker/StrHelper.h b/bsp_q7s/devices/startracker/StrHelper.h index 372c2abd..55c7a69b 100644 --- a/bsp_q7s/devices/startracker/StrHelper.h +++ b/bsp_q7s/devices/startracker/StrHelper.h @@ -28,7 +28,7 @@ public: static const Event IMAGE_UPLOAD_FAILED = MAKE_EVENT(0, severity::LOW); //! [EXPORT] : [COMMENT] Image download failed static const Event IMAGE_DOWNLOAD_FAILED = MAKE_EVENT(1, severity::LOW); - //! [EXPORT] : [COMMENT] Uploading image to star tracker was successful + //! [EXPORT] : [COMMENT] Uploading image to star tracker was successfulop static const Event 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); @@ -40,35 +40,43 @@ public: static const Event 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); + //! [EXPORT] : [COMMENT] Download of FPGA image successful + static const Event 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); + //! [EXPORT] : [COMMENT] Upload of FPGA image successful + static const Event 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); //! [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 - static const Event STR_HELPER_READING_REPLY_FAILED = MAKE_EVENT(8, severity::LOW); + static const Event STR_HELPER_READING_REPLY_FAILED = MAKE_EVENT(12, severity::LOW); //! [EXPORT] : [COMMENT] Unexpected stop of decoding sequence //!P1: Return code of failed communication interface read call //!P1: Upload/download position for which the read call failed - static const Event STR_HELPER_COM_ERROR = MAKE_EVENT(9, severity::LOW); + static const Event STR_HELPER_COM_ERROR = MAKE_EVENT(13, severity::LOW); //! [EXPORT] : [COMMENT] Star tracker did not send replies (maybe device is powered off) //!P1: Position of upload or download packet for which no reply was sent - static const Event STR_HELPER_NO_REPLY = MAKE_EVENT(10, severity::LOW); + static const Event STR_HELPER_NO_REPLY = MAKE_EVENT(14, severity::LOW); //! [EXPORT] : [COMMENT] Error during decoding of received reply occurred //P1: Return value of decoding function //P2: Position of upload/download packet, or address of flash write/read request - static const Event STR_HELPER_DEC_ERROR = MAKE_EVENT(11, severity::LOW); + 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(12, severity::LOW); + static const Event 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(13, severity::LOW); + static const Event STR_HELPER_FILE_NOT_EXISTS = MAKE_EVENT(17, severity::LOW); //! [EXPORT] : [COMMENT] Sending packet to star tracker failed //!P1: Return code of communication interface sendMessage function //!P2: Position of upload/download packet, or address of flash write/read request for which sending failed - static const Event STR_HELPER_SENDING_PACKET_FAILED = MAKE_EVENT(14, severity::LOW); + static const Event STR_HELPER_SENDING_PACKET_FAILED = MAKE_EVENT(18, severity::LOW); //! [EXPORT] : [COMMENT] Communication interface requesting reply failed //!P1: Return code of failed request //!P1: Upload/download position, or address of flash write/read request for which transmission failed - static const Event STR_HELPER_REQUESTING_MSG_FAILED = MAKE_EVENT(15, severity::LOW); + static const Event STR_HELPER_REQUESTING_MSG_FAILED = MAKE_EVENT(19, severity::LOW); StrHelper(object_id_t objectId); virtual ~StrHelper(); @@ -92,7 +100,7 @@ public: * * @param Name of the image which will be created */ - ReturnValue_t startImageDownload(std::string downloadPath_); + ReturnValue_t startImageDownload(std::string downloadImagePath_); /** * @brief Starts the flash write procedure @@ -115,6 +123,16 @@ public: ReturnValue_t startFlashRead(std::string flashReadPath_, uint8_t region, uint32_t address, uint32_t length); + /** + * @brief Starts the download of the FPGA image + * + * @param path The path where the file with the downloaded data will be created + * @param startPosition Offset in fpga image to read from + * @param length Number of bytes to dwonload from the FPGA image + * + */ + ReturnValue_t startFpgaDownload(std::string path, uint32_t startPosition, uint32_t length); + /** * @brief Can be used to interrupt a running data transfer. */ @@ -156,7 +174,28 @@ private: // Size of one image part which can be sent per action request static const size_t SIZE_IMAGE_PART = 1024; - static const uint32_t LAST_POSITION = 4095; + class ImageDownload { + public: + static const uint32_t LAST_POSITION = 4095; + }; + + class FpgaDownload { + public: + static const uint16_t MAX_DATA = 1024; + static const uint8_t POSITION_OFFSET = 3; + static const uint8_t LENGTH_OFFSET = 7; + static const uint8_t DATA_OFFSET = 11; + // Start position of fpga image part to download + uint32_t startPosition = 0; + // Length of image part to download + uint32_t length = 0; + // Path where downloaded FPGA image will be stored + std::string path; + // Name of file containing downloaded FPGA image + std::string fileName = "fpgaimage.bin"; + }; + + FpgaDownload fpgaDownload; static const uint32_t MAX_POLLS = 10000; @@ -175,7 +214,9 @@ private: UPLOAD_IMAGE, DOWNLOAD_IMAGE, FLASH_WRITE, - FLASH_READ + FLASH_READ, + DOWNLOAD_FPGA_IMAGE, + UPLOAD_FPGA_IMAGE }; InternalState internalState = InternalState::IDLE; @@ -187,7 +228,7 @@ private: // Name including absolute path of image to upload std::string uploadImage; // Path where the downloaded image will be stored - std::string downloadPath; + std::string downloadImagePath; // File which contains data to write when executing the flash write command std::string flashWriteFile; // Path where the file containing the read data will be stored @@ -255,6 +296,12 @@ private: */ ReturnValue_t performFlashRead(); + /** + * @brief Performs the download of the FPGA image which requires to be slip over multiple + * action requests. + */ + ReturnValue_t performFpgaDownload(); + /** * @brief Sends packet to the star tracker and reads reply by using the communication * interface @@ -267,11 +314,11 @@ private: ReturnValue_t sendAndRead(size_t size, uint32_t parameter); /** - * @brief Checks the reply header (type id and status fields) + * @brief Checks the header (type id and status fields) of the action reply * * @return RETURN_OK if reply confirms success of packet transfer, otherwise REUTRN_FAILED */ - ReturnValue_t checkReply(); + ReturnValue_t checkActionReply(); /** * @brief Checks the position field in a star tracker upload/download reply. @@ -290,6 +337,14 @@ private: */ ReturnValue_t checkFlashActionReply(uint8_t region_, uint32_t address_, uint16_t length_); + /** + * @brief Checks the reply to the fpga download request + * + * @param expectedPosition The expected position value in the reply + * @param expectedLength The expected length field in the reply + */ + ReturnValue_t checkFpgaDownloadReply(uint32_t expectedPosition, uint32_t expectedLength); + /** * @brief Checks if a path points to an sd card and whether the SD card is monuted. * diff --git a/common/config/commonClassIds.h b/common/config/commonClassIds.h index 4c769260..cd90272d 100644 --- a/common/config/commonClassIds.h +++ b/common/config/commonClassIds.h @@ -25,6 +25,7 @@ enum commonClassIds: uint8_t { PDEC_HANDLER, //PDEC CCSDS_HANDLER, //CCSDS ARCSEC_JSON_BASE, //JSONBASE + NVM_PARAM_BASE, //NVMB COMMON_CLASS_ID_END // [EXPORT] : [END] }; diff --git a/generators/bsp_q7s_events.csv b/generators/bsp_q7s_events.csv index a2a4784a..cdf4d181 100644 --- a/generators/bsp_q7s_events.csv +++ b/generators/bsp_q7s_events.csv @@ -120,19 +120,21 @@ 11904;BIT_LOCK_PDEC;INFO;Bit lock detected (data valid);C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/linux/obc/PdecHandler.h 12000;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h 12001;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h -12002;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successful;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h +12002;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h 12003;IMAGE_DOWNLOAD_SUCCESSFUL;LOW;Image download was successful;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h 12004;FLASH_WRITE_SUCCESSFUL;LOW;Finished flash write procedure successfully;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h 12005;FLASH_READ_SUCCESSFUL;LOW;Finished flash read procedure successfully;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h 12006;FLASH_WRITE_FAILED;LOW;Flash write procedure failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h 12007;FLASH_READ_FAILED;LOW;Flash read procedure failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h -12008;STR_HELPER_READING_REPLY_FAILED;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h -12009;STR_HELPER_COM_ERROR;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h -12010;STR_HELPER_NO_REPLY;LOW;Star tracker did not send replies (maybe device is powered off)P1: Position of upload or download packet for which no reply was sent;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h -12011;INVALID_TYPE_ID;LOW;Received reply with invalid type ID;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h -12012;STATUS_ERROR;LOW;Status field in reply signals error;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h -12013;STR_HELPER_DEC_ERROR;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h -12014;POSITION_MISMATCH;LOW;Position mismatch P1: The expected position and thus the position for which the image upload/download failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h -12015;STR_HELPER_FILE_NOT_EXISTS;LOW;Specified file does not existP1: Internal state of str helper;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h -12016;STR_HELPER_SENDING_PACKET_FAILED;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h -12017;STR_HELPER_REQUESTING_MSG_FAILED;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h +12008;FPGA_DOWNLOAD_SUCCESSFUL;LOW;Download of FPGA image successful;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h +12009;FPGA_DOWNLOAD_FAILED;LOW;Download of FPGA image failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h +12010;FPGA_UPLOAD_SUCCESSFUL;LOW;Upload of FPGA image successful;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h +12011;FPGA_UPLOAD_FAILED;LOW;Upload of FPGA image failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h +12012;STR_HELPER_READING_REPLY_FAILED;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h +12013;STR_HELPER_COM_ERROR;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h +12014;STR_HELPER_NO_REPLY;LOW;Star tracker did not send replies (maybe device is powered off)P1: Position of upload or download packet for which no reply was sent;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h +12015;STR_HELPER_DEC_ERROR;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h +12016;POSITION_MISMATCH;LOW;Position mismatch P1: The expected position and thus the position for which the image upload/download failed;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h +12017;STR_HELPER_FILE_NOT_EXISTS;LOW;Specified file does not existP1: Internal state of str helper;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h +12018;STR_HELPER_SENDING_PACKET_FAILED;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h +12019;STR_HELPER_REQUESTING_MSG_FAILED;LOW;;C:\Users\jakob\OneDrive\Work\EIVE\Q7S\Software\eive_obsw/bsp_q7s/devices/startracker/StrHelper.h diff --git a/generators/events/translateEvents.cpp b/generators/events/translateEvents.cpp index 76159e0c..17150762 100644 --- a/generators/events/translateEvents.cpp +++ b/generators/events/translateEvents.cpp @@ -1,7 +1,7 @@ /** - * @brief Auto-generated event translation file. Contains 138 translations. + * @brief Auto-generated event translation file. Contains 140 translations. * @details - * Generated on: 2021-12-21 17:08:50 + * Generated on: 2021-12-29 20:24:08 */ #include "translateEvents.h" @@ -133,11 +133,13 @@ const char *FLASH_WRITE_SUCCESSFUL_STRING = "FLASH_WRITE_SUCCESSFUL"; const char *FLASH_READ_SUCCESSFUL_STRING = "FLASH_READ_SUCCESSFUL"; const char *FLASH_WRITE_FAILED_STRING = "FLASH_WRITE_FAILED"; const char *FLASH_READ_FAILED_STRING = "FLASH_READ_FAILED"; +const char *FPGA_DOWNLOAD_SUCCESSFUL_STRING = "FPGA_DOWNLOAD_SUCCESSFUL"; +const char *FPGA_DOWNLOAD_FAILED_STRING = "FPGA_DOWNLOAD_FAILED"; +const char *FPGA_UPLOAD_SUCCESSFUL_STRING = "FPGA_UPLOAD_SUCCESSFUL"; +const char *FPGA_UPLOAD_FAILED_STRING = "FPGA_UPLOAD_FAILED"; const char *STR_HELPER_READING_REPLY_FAILED_STRING = "STR_HELPER_READING_REPLY_FAILED"; const char *STR_HELPER_COM_ERROR_STRING = "STR_HELPER_COM_ERROR"; const char *STR_HELPER_NO_REPLY_STRING = "STR_HELPER_NO_REPLY"; -const char *INVALID_TYPE_ID_STRING = "INVALID_TYPE_ID"; -const char *STATUS_ERROR_STRING = "STATUS_ERROR"; const char *STR_HELPER_DEC_ERROR_STRING = "STR_HELPER_DEC_ERROR"; const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH"; const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS"; @@ -403,24 +405,28 @@ const char * translateEvents(Event event) { case(12007): return FLASH_READ_FAILED_STRING; case(12008): - return STR_HELPER_READING_REPLY_FAILED_STRING; + return FPGA_DOWNLOAD_SUCCESSFUL_STRING; case(12009): - return STR_HELPER_COM_ERROR_STRING; + return FPGA_DOWNLOAD_FAILED_STRING; case(12010): - return STR_HELPER_NO_REPLY_STRING; + return FPGA_UPLOAD_SUCCESSFUL_STRING; case(12011): - return INVALID_TYPE_ID_STRING; + return FPGA_UPLOAD_FAILED_STRING; case(12012): - return STATUS_ERROR_STRING; + return STR_HELPER_READING_REPLY_FAILED_STRING; case(12013): - return STR_HELPER_DEC_ERROR_STRING; + return STR_HELPER_COM_ERROR_STRING; case(12014): - return POSITION_MISMATCH_STRING; + return STR_HELPER_NO_REPLY_STRING; case(12015): - return STR_HELPER_FILE_NOT_EXISTS_STRING; + return STR_HELPER_DEC_ERROR_STRING; case(12016): - return STR_HELPER_SENDING_PACKET_FAILED_STRING; + return POSITION_MISMATCH_STRING; case(12017): + return STR_HELPER_FILE_NOT_EXISTS_STRING; + case(12018): + return STR_HELPER_SENDING_PACKET_FAILED_STRING; + case(12019): return STR_HELPER_REQUESTING_MSG_FAILED_STRING; default: return "UNKNOWN_EVENT"; diff --git a/linux/fsfwconfig/events/translateEvents.cpp b/linux/fsfwconfig/events/translateEvents.cpp index 76159e0c..17150762 100644 --- a/linux/fsfwconfig/events/translateEvents.cpp +++ b/linux/fsfwconfig/events/translateEvents.cpp @@ -1,7 +1,7 @@ /** - * @brief Auto-generated event translation file. Contains 138 translations. + * @brief Auto-generated event translation file. Contains 140 translations. * @details - * Generated on: 2021-12-21 17:08:50 + * Generated on: 2021-12-29 20:24:08 */ #include "translateEvents.h" @@ -133,11 +133,13 @@ const char *FLASH_WRITE_SUCCESSFUL_STRING = "FLASH_WRITE_SUCCESSFUL"; const char *FLASH_READ_SUCCESSFUL_STRING = "FLASH_READ_SUCCESSFUL"; const char *FLASH_WRITE_FAILED_STRING = "FLASH_WRITE_FAILED"; const char *FLASH_READ_FAILED_STRING = "FLASH_READ_FAILED"; +const char *FPGA_DOWNLOAD_SUCCESSFUL_STRING = "FPGA_DOWNLOAD_SUCCESSFUL"; +const char *FPGA_DOWNLOAD_FAILED_STRING = "FPGA_DOWNLOAD_FAILED"; +const char *FPGA_UPLOAD_SUCCESSFUL_STRING = "FPGA_UPLOAD_SUCCESSFUL"; +const char *FPGA_UPLOAD_FAILED_STRING = "FPGA_UPLOAD_FAILED"; const char *STR_HELPER_READING_REPLY_FAILED_STRING = "STR_HELPER_READING_REPLY_FAILED"; const char *STR_HELPER_COM_ERROR_STRING = "STR_HELPER_COM_ERROR"; const char *STR_HELPER_NO_REPLY_STRING = "STR_HELPER_NO_REPLY"; -const char *INVALID_TYPE_ID_STRING = "INVALID_TYPE_ID"; -const char *STATUS_ERROR_STRING = "STATUS_ERROR"; const char *STR_HELPER_DEC_ERROR_STRING = "STR_HELPER_DEC_ERROR"; const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH"; const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS"; @@ -403,24 +405,28 @@ const char * translateEvents(Event event) { case(12007): return FLASH_READ_FAILED_STRING; case(12008): - return STR_HELPER_READING_REPLY_FAILED_STRING; + return FPGA_DOWNLOAD_SUCCESSFUL_STRING; case(12009): - return STR_HELPER_COM_ERROR_STRING; + return FPGA_DOWNLOAD_FAILED_STRING; case(12010): - return STR_HELPER_NO_REPLY_STRING; + return FPGA_UPLOAD_SUCCESSFUL_STRING; case(12011): - return INVALID_TYPE_ID_STRING; + return FPGA_UPLOAD_FAILED_STRING; case(12012): - return STATUS_ERROR_STRING; + return STR_HELPER_READING_REPLY_FAILED_STRING; case(12013): - return STR_HELPER_DEC_ERROR_STRING; + return STR_HELPER_COM_ERROR_STRING; case(12014): - return POSITION_MISMATCH_STRING; + return STR_HELPER_NO_REPLY_STRING; case(12015): - return STR_HELPER_FILE_NOT_EXISTS_STRING; + return STR_HELPER_DEC_ERROR_STRING; case(12016): - return STR_HELPER_SENDING_PACKET_FAILED_STRING; + return POSITION_MISMATCH_STRING; case(12017): + return STR_HELPER_FILE_NOT_EXISTS_STRING; + case(12018): + return STR_HELPER_SENDING_PACKET_FAILED_STRING; + case(12019): return STR_HELPER_REQUESTING_MSG_FAILED_STRING; default: return "UNKNOWN_EVENT"; diff --git a/mission/memory/NVMParameterBase.h b/mission/memory/NVMParameterBase.h index 4814acf4..f41f9e63 100644 --- a/mission/memory/NVMParameterBase.h +++ b/mission/memory/NVMParameterBase.h @@ -7,7 +7,7 @@ #include #include -class NVMParameterBase { +class NVMParameterBase : public HasReturnvaluesIF { public: virtual~ NVMParameterBase() {} @@ -34,12 +34,18 @@ public: ReturnValue_t setValue(std::string key, T value); template - T getValue(std::string key) const; + ReturnValue_t getValue(std::string key, T* value) const; void printKeys() const; void print() const; private: + + static const uint8_t INTERFACE_ID = CLASS_ID::NVM_PARAM_BASE; + + //! [EXPORT] : [COMMENT] Specified key does not exist in json file + static const ReturnValue_t KEY_NOT_EXISTS = MAKE_RETURN_CODE(0xA0); + nlohmann::json json; std::vector keys; std::string fullName; @@ -62,8 +68,12 @@ inline ReturnValue_t NVMParameterBase::setValue(std::string key, T value) { } template -inline T NVMParameterBase::getValue(std::string key) const { - return json[key]; +inline ReturnValue_t NVMParameterBase::getValue(std::string key, T* value) const { + if (!json.contains(key)) { + return KEY_NOT_EXISTS; + } + *value = json[key]; + return RETURN_OK; } #endif /* BSP_Q7S_CORE_NVMPARAMS_NVMPARAMIF_H_ */ From 3833b7a8757428cdb6d9b73f96a26d4aed1f1554 Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Wed, 29 Dec 2021 20:34:12 +0100 Subject: [PATCH 09/16] tmtc update --- tmtc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tmtc b/tmtc index 58ec3c66..e3950bbb 160000 --- a/tmtc +++ b/tmtc @@ -1 +1 @@ -Subproject commit 58ec3c66409be1e8b9c403f73062f0e187fba021 +Subproject commit e3950bbbcca825b07c40b16658127210a9fe5fe2 From 29e7ac210af73daef3b252048dc557b444f33760 Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Thu, 30 Dec 2021 12:52:08 +0100 Subject: [PATCH 10/16] upload fpga image command --- .../startracker/StarTrackerDefinitions.h | 4 + .../startracker/StarTrackerHandler.cpp | 55 ++++++++++++- .../devices/startracker/StarTrackerHandler.h | 13 ++++ bsp_q7s/devices/startracker/StrHelper.cpp | 78 +++++++++++++++++-- bsp_q7s/devices/startracker/StrHelper.h | 36 +++++++-- 5 files changed, 172 insertions(+), 14 deletions(-) diff --git a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h index c03afa74..29a1d800 100644 --- a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h +++ b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h @@ -242,6 +242,9 @@ static const DeviceCommandId_t SET_TIME = 60; static const DeviceCommandId_t DOWNLOAD_DBIMAGE = 61; static const DeviceCommandId_t DOWNLOAD_BLOBPIXEL = 62; static const DeviceCommandId_t DOWNLOAD_FPGA_IMAGE = 63; +static const DeviceCommandId_t CHANGE_FPGA_DOWNLOAD_FILE = 64; +static const DeviceCommandId_t UPLOAD_FPGA_IMAGE = 65; +static const DeviceCommandId_t FPGA_ACTION = 66; static const DeviceCommandId_t NONE = 0xFFFFFFFF; static const uint32_t VERSION_SET_ID = REQ_VERSION; @@ -313,6 +316,7 @@ namespace ID { static const uint8_t DOWNLOAD_MATCHED_STAR = 18; static const uint8_t DOWNLOAD_DBIMAGE = 19; static const uint8_t DOWNLOAD_BLOBPIXEL = 24; + static const uint8_t FPGA_ACTION = 22; } namespace Program { diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp index 57aa5dfc..9a504ffd 100644 --- a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp +++ b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp @@ -107,7 +107,7 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu if (result != RETURN_OK) { return result; } - if (size > MAX_PATH_SIZE) { + if (size > MAX_PATH_SIZE + MAX_FILE_NAME) { return FILE_PATH_TOO_LONG; } result = strHelper->startImageUpload( @@ -167,6 +167,13 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu std::string(reinterpret_cast(data), size)); return EXECUTION_FINISHED; } + case(StarTracker::CHANGE_FPGA_DOWNLOAD_FILE): { + if (size > MAX_FILE_NAME) { + return FILENAME_TOO_LONG; + } + strHelper->setDownloadFpgaImage(std::string(reinterpret_cast(data), size)); + return EXECUTION_FINISHED; + } case(StarTracker::SET_READ_FILENAME): { if (size > MAX_FILE_NAME) { return FILENAME_TOO_LONG; @@ -190,6 +197,21 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu strHelperExecuting = true; return EXECUTION_FINISHED; } + case(StarTracker::UPLOAD_FPGA_IMAGE): { + result = DeviceHandlerBase::acceptExternalDeviceCommands(); + if (result != RETURN_OK) { + return result; + } + if (size > MAX_PATH_SIZE + MAX_FILE_NAME) { + return FILE_PATH_TOO_LONG; + } + result = strHelper->startFpgaUpload(std::string(reinterpret_cast(data), size)); + if (result != RETURN_OK) { + return result; + } + strHelperExecuting = true; + return EXECUTION_FINISHED; + } default: break; } @@ -469,6 +491,10 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi result = prepareDownloadBlobPixelCommand(commandData, commandDataLen); return result; } + case (StarTracker::FPGA_ACTION): { + result = prepareFpgaActionCommand(commandData, commandDataLen); + return result; + } default: return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED; } @@ -545,6 +571,8 @@ void StarTrackerHandler::fillCommandAndReplyMap() { StarTracker::MAX_FRAME_SIZE * 2 + 2); this->insertInCommandAndReplyMap(StarTracker::DOWNLOAD_BLOBPIXEL, 3, &downloadBlobPixel, StarTracker::MAX_FRAME_SIZE * 2 + 2); + this->insertInCommandAndReplyMap(StarTracker::FPGA_ACTION, 3, nullptr, + StarTracker::MAX_FRAME_SIZE * 2 + 2); } ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t *start, size_t remainingSize, @@ -617,7 +645,8 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id, con case (StarTracker::TAKE_IMAGE): case (StarTracker::RESET_ERROR): case (StarTracker::UNLOCK): - case (StarTracker::SET_TIME): { + case (StarTracker::SET_TIME): + case (StarTracker::FPGA_ACTION): { result = handleActionReply(); break; } @@ -995,6 +1024,10 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t *foundId) *foundId = StarTracker::DOWNLOAD_BLOBPIXEL; break; } + case (StarTracker::ID::FPGA_ACTION): { + *foundId = StarTracker::FPGA_ACTION; + break; + } default: sif::warning << "StarTrackerHandler::scanForParameterReply: Unknown parameter reply id" << std::endl; @@ -1649,6 +1682,24 @@ ReturnValue_t StarTrackerHandler::prepareDownloadBlobPixelCommand(const uint8_t* return RETURN_OK; } +ReturnValue_t StarTrackerHandler::prepareFpgaActionCommand(const uint8_t* commandData, + size_t commandDataLen) { + if (commandDataLen != FpgaActionCmd::LENGTH) { + return INVALID_LENGTH; + } + struct FPGAActionActionRequest req; + req.id = *commandData; + if (req.id != FpgaActionCmd::ID) { + return INVALID_ID; + } + uint32_t length = 0; + arc_pack_fpgaaction_action_req(&req, commandBuffer, &length); + dataLinkLayer.encodeFrame(commandBuffer, length); + rawPacket = dataLinkLayer.getEncodedFrame(); + rawPacketLen = dataLinkLayer.getEncodedLength(); + return RETURN_OK; +} + ReturnValue_t StarTrackerHandler::handleSetParamReply() { const uint8_t* reply = dataLinkLayer.getReply(); uint8_t status = *(reply + STATUS_OFFSET); diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.h b/bsp_q7s/devices/startracker/StarTrackerHandler.h index d26c8aea..65bd65b8 100644 --- a/bsp_q7s/devices/startracker/StarTrackerHandler.h +++ b/bsp_q7s/devices/startracker/StarTrackerHandler.h @@ -131,6 +131,8 @@ private: static const ReturnValue_t UPLOAD_CENTROID_ID_MISMATCH = MAKE_RETURN_CODE(0xB5); //! [EXPORT] : [COMMENT] Download blob pixel command has invalid type field static const ReturnValue_t INVALID_TYPE = MAKE_RETURN_CODE(0xB6); + //! [EXPORT] : [COMMENT] Received FPGA action command with invalid ID + static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xB7); static const size_t MAX_PATH_SIZE = 50; static const size_t MAX_FILE_NAME = 30; @@ -235,6 +237,12 @@ private: static const uint8_t MIN_LENGTH = 10; }; + class FpgaActionCmd { + public: + static const uint8_t LENGTH = 1; + static const uint8_t ID = 3; + }; + MessageQueueIF* eventQueue = nullptr; ArcsecDatalinkLayer dataLinkLayer; @@ -479,6 +487,11 @@ private: ReturnValue_t prepareDownloadBlobPixelCommand(const uint8_t* commandData, size_t commandDataLen); + /** + * @brief With this command the FPGA update will be applied to the star tracker + */ + ReturnValue_t prepareFpgaActionCommand(const uint8_t* commandData, size_t commandDataLen); + /** * @brief Handles action replies with datasets. */ diff --git a/bsp_q7s/devices/startracker/StrHelper.cpp b/bsp_q7s/devices/startracker/StrHelper.cpp index 9ee2ce0e..9da726c2 100644 --- a/bsp_q7s/devices/startracker/StrHelper.cpp +++ b/bsp_q7s/devices/startracker/StrHelper.cpp @@ -85,6 +85,17 @@ ReturnValue_t StrHelper::performOperation(uint8_t operationCode) { internalState = InternalState::IDLE; break; } + case InternalState::UPLOAD_FPGA_IMAGE: { + result = performFpgaUpload(); + if (result == RETURN_OK){ + triggerEvent(FPGA_UPLOAD_SUCCESSFUL); + } + else { + triggerEvent(FPGA_UPLOAD_FAILED); + } + internalState = InternalState::IDLE; + break; + } default: sif::debug << "StrHelper::performOperation: Invalid state" << std::endl; break; @@ -114,7 +125,7 @@ ReturnValue_t StrHelper::startImageUpload(std::string uploadImage_) { if(not std::filesystem::exists(uploadImage)) { return FILE_NOT_EXISTS; } - internalState = InternalState::UPLOAD_IMAGE; + internalState = InternalState::UPLOAD_FPGA_IMAGE; semaphore.release(); terminate = false; return RETURN_OK; @@ -147,6 +158,10 @@ void StrHelper::setFlashReadFilename(std::string filename) { flashReadFile = filename; } +void StrHelper::setDownloadFpgaImage(std::string filename) { + fpgaDownload.fileName = filename; +} + ReturnValue_t StrHelper::startFlashWrite(std::string flashWriteFile_, uint8_t region, uint32_t address) { ReturnValue_t result = checkPath(flashWriteFile_); @@ -195,6 +210,14 @@ ReturnValue_t StrHelper::startFpgaDownload(std::string path, uint32_t startPosit return RETURN_OK; } +ReturnValue_t StrHelper::startFpgaUpload(std::string uploadFile) { + fpgaUpload.uploadFile = uploadFile; + internalState = InternalState::UPLOAD_FPGA_IMAGE; + semaphore.release(); + terminate = false; + return RETURN_OK; +} + ReturnValue_t StrHelper::performImageDownload() { ReturnValue_t result; struct DownloadActionRequest downloadReq; @@ -450,7 +473,7 @@ ReturnValue_t StrHelper::performFpgaDownload() { file.close(); return result; } - result = checkFpgaDownloadReply(req.pos, req.length); + result = checkFpgaActionReply(req.pos, req.length); if (result != RETURN_OK) { if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) { uartComIF->flushUartRxBuffer(comCookie); @@ -469,6 +492,47 @@ ReturnValue_t StrHelper::performFpgaDownload() { return RETURN_OK; } +ReturnValue_t StrHelper::performFpgaUpload() { + ReturnValue_t result = RETURN_OK; + uint32_t commandSize = 0; + uint32_t bytesUploaded = 0; + uint32_t fileSize = 0; + struct UploadFPGAImageActionRequest req; + if (not std::filesystem::exists(fpgaUpload.uploadFile)) { + triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast(internalState)); + internalState = InternalState::IDLE; + return RETURN_FAILED; + } + std::ifstream file(flashWriteFile, std::ifstream::binary); + file.seekg(0, file.end); + fileSize = file.tellg(); + req.pos = 0; + while(bytesUploaded <= fileSize) { + if (terminate) { + return RETURN_OK; + } + if (fileSize - bytesUploaded > FpgaUpload::MAX_DATA) { + req.length = FpgaUpload::MAX_DATA; + } + else { + req.length = fileSize - bytesUploaded; + } + file.seekg(bytesUploaded, file.beg); + file.read(reinterpret_cast(req.data), req.length); + arc_pack_uploadfpgaimage_action_req(&req, commandBuffer, &commandSize); + result = sendAndRead(commandSize, req.pos); + if (result != RETURN_OK) { + return RETURN_FAILED; + } + result = checkFpgaActionReply(req.pos, req.length); + if (result != RETURN_OK) { + return result; + } + bytesUploaded += req.length; + } + return RETURN_OK; +} + ReturnValue_t StrHelper::sendAndRead(size_t size, uint32_t parameter) { ReturnValue_t result = RETURN_OK; ReturnValue_t decResult = RETURN_OK; @@ -591,20 +655,20 @@ ReturnValue_t StrHelper::checkFlashActionReply(uint8_t region_, uint32_t address return RETURN_OK; } -ReturnValue_t StrHelper::checkFpgaDownloadReply(uint32_t expectedPosition, +ReturnValue_t StrHelper::checkFpgaActionReply(uint32_t expectedPosition, uint32_t expectedLength) { ReturnValue_t result = RETURN_OK; result = checkActionReply(); if (result != RETURN_OK) { return result; } - const uint8_t* data = datalinkLayer.getReply() + FpgaDownload::POSITION_OFFSET; + const uint8_t* data = datalinkLayer.getReply() + ACTION_DATA_OFFSET; uint32_t position; size_t size = sizeof(position); result = SerializeAdapter::deSerialize(&position, &data, &size, SerializeIF::Endianness::LITTLE); if (result != RETURN_OK) { - sif::warning << "StrHelper::checkFpgaDownloadReply: Deserialization of position failed" + sif::warning << "StrHelper::checkFpgaActionReply: Deserialization of position failed" << std::endl; return result; } @@ -613,11 +677,11 @@ ReturnValue_t StrHelper::checkFpgaDownloadReply(uint32_t expectedPosition, result = SerializeAdapter::deSerialize(&length, &data, &size, SerializeIF::Endianness::LITTLE); if (result != RETURN_OK) { - sif::warning << "StrHelper::checkFpgaDownloadReply: Deserialization of length failed" + sif::warning << "StrHelper::checkFpgaActionReply: Deserialization of length failed" << std::endl; return result; } - return RETURN_OK; + return result; } ReturnValue_t StrHelper::checkPath(std::string name) { diff --git a/bsp_q7s/devices/startracker/StrHelper.h b/bsp_q7s/devices/startracker/StrHelper.h index 55c7a69b..257b5ae7 100644 --- a/bsp_q7s/devices/startracker/StrHelper.h +++ b/bsp_q7s/devices/startracker/StrHelper.h @@ -133,6 +133,13 @@ public: */ ReturnValue_t startFpgaDownload(std::string path, uint32_t startPosition, uint32_t length); + /** + * @brief Starts upload of new image to FPGA + * + * @param uploadFile Full name of file containing FPGA image data + */ + ReturnValue_t startFpgaUpload(std::string uploadFile); + /** * @brief Can be used to interrupt a running data transfer. */ @@ -148,6 +155,11 @@ public: */ void setFlashReadFilename(std::string filename); + /** + * @brief Set download FPGA image name + */ + void setDownloadFpgaImage(std::string filename); + private: static const uint8_t INTERFACE_ID = CLASS_ID::STR_HELPER; @@ -182,9 +194,7 @@ private: class FpgaDownload { public: static const uint16_t MAX_DATA = 1024; - static const uint8_t POSITION_OFFSET = 3; - static const uint8_t LENGTH_OFFSET = 7; - static const uint8_t DATA_OFFSET = 11; + static const uint8_t DATA_OFFSET = 10; // Start position of fpga image part to download uint32_t startPosition = 0; // Length of image part to download @@ -197,8 +207,18 @@ private: FpgaDownload fpgaDownload; + class FpgaUpload { + public: + static const uint32_t MAX_DATA = 1024; + // Full name of file to upload + std::string uploadFile; + }; + + FpgaUpload fpgaUpload; + static const uint32_t MAX_POLLS = 10000; + static const uint8_t ACTION_DATA_OFFSET = 2; static const uint8_t POS_OFFSET = 2; static const uint8_t IMAGE_DATA_OFFSET = 5; static const uint8_t FLASH_READ_DATA_OFFSET = 8; @@ -302,6 +322,12 @@ private: */ ReturnValue_t performFpgaDownload(); + /** + * @brief Performs upload of new FPGA image. Upload sequence split over multiple commands + * because one command can only transport 1024 bytes of image data. + */ + ReturnValue_t performFpgaUpload(); + /** * @brief Sends packet to the star tracker and reads reply by using the communication * interface @@ -338,12 +364,12 @@ private: ReturnValue_t checkFlashActionReply(uint8_t region_, uint32_t address_, uint16_t length_); /** - * @brief Checks the reply to the fpga download request + * @brief Checks the reply to the fpga download and upload request * * @param expectedPosition The expected position value in the reply * @param expectedLength The expected length field in the reply */ - ReturnValue_t checkFpgaDownloadReply(uint32_t expectedPosition, uint32_t expectedLength); + ReturnValue_t checkFpgaActionReply(uint32_t expectedPosition, uint32_t expectedLength); /** * @brief Checks if a path points to an sd card and whether the SD card is monuted. From ac51ad7a4f53a642a1f1140eb7190e9e5d53dcaf Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Thu, 30 Dec 2021 13:31:34 +0100 Subject: [PATCH 11/16] some improvements --- bsp_q7s/devices/startracker/StrHelper.cpp | 76 +++++++++---------- bsp_q7s/devices/startracker/StrHelper.h | 91 +++++++++++++---------- tmtc | 2 +- 3 files changed, 92 insertions(+), 77 deletions(-) diff --git a/bsp_q7s/devices/startracker/StrHelper.cpp b/bsp_q7s/devices/startracker/StrHelper.cpp index 9da726c2..0be38ad7 100644 --- a/bsp_q7s/devices/startracker/StrHelper.cpp +++ b/bsp_q7s/devices/startracker/StrHelper.cpp @@ -116,13 +116,13 @@ void StrHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; } -ReturnValue_t StrHelper::startImageUpload(std::string uploadImage_) { - ReturnValue_t result = checkPath(uploadImage_); +ReturnValue_t StrHelper::startImageUpload(std::string fullname) { + ReturnValue_t result = checkPath(fullname); if (result != RETURN_OK) { return result; } - uploadImage = uploadImage_; - if(not std::filesystem::exists(uploadImage)) { + uploadImage.uploadFile = fullname; + if(not std::filesystem::exists(fullname)) { return FILE_NOT_EXISTS; } internalState = InternalState::UPLOAD_FPGA_IMAGE; @@ -131,15 +131,15 @@ ReturnValue_t StrHelper::startImageUpload(std::string uploadImage_) { return RETURN_OK; } -ReturnValue_t StrHelper::startImageDownload(std::string downloadImagePath_) { - ReturnValue_t result = checkPath(downloadImagePath_); +ReturnValue_t StrHelper::startImageDownload(std::string path) { + ReturnValue_t result = checkPath(path); if (result != RETURN_OK) { return result; } - if(not std::filesystem::exists(downloadImagePath_)) { + if(not std::filesystem::exists(path)) { return PATH_NOT_EXISTS; } - downloadImagePath = downloadImagePath_; + downloadImage.path = path; internalState = InternalState::DOWNLOAD_IMAGE; terminate = false; semaphore.release(); @@ -150,49 +150,49 @@ void StrHelper::stopProcess() { terminate = true; } -void StrHelper::setDownloadImageName(std::string image) { - downloadImage = image; +void StrHelper::setDownloadImageName(std::string filename) { + downloadImage.filename = filename; } void StrHelper::setFlashReadFilename(std::string filename) { - flashReadFile = filename; + flashRead.filename = filename; } void StrHelper::setDownloadFpgaImage(std::string filename) { fpgaDownload.fileName = filename; } -ReturnValue_t StrHelper::startFlashWrite(std::string flashWriteFile_, uint8_t region, +ReturnValue_t StrHelper::startFlashWrite(std::string fullname, uint8_t region, uint32_t address) { - ReturnValue_t result = checkPath(flashWriteFile_); + ReturnValue_t result = checkPath(fullname); if (result != RETURN_OK) { return result; } - flashWriteFile = flashWriteFile_; - if(not std::filesystem::exists(flashWriteFile)) { + flashWrite.fullname = fullname; + if(not std::filesystem::exists(flashWrite.fullname)) { return FILE_NOT_EXISTS; } - flashWriteAddress = address; - flashWriteRegion = region; + flashWrite.address = address; + flashWrite.region = region; internalState = InternalState::FLASH_WRITE; semaphore.release(); terminate = false; return RETURN_OK; } -ReturnValue_t StrHelper::startFlashRead(std::string flashReadPath_, uint8_t region, +ReturnValue_t StrHelper::startFlashRead(std::string path, uint8_t region, uint32_t address, uint32_t length) { - ReturnValue_t result = checkPath(flashReadPath_); + ReturnValue_t result = checkPath(path); if (result != RETURN_OK) { return result; } - flashReadPath = flashReadPath_; - if(not std::filesystem::exists(flashReadPath)) { + flashRead.path = path; + if(not std::filesystem::exists(flashRead.path)) { return FILE_NOT_EXISTS; } - flashReadAddress = address; - flashReadRegion = region; - flashReadSize = length; + flashRead.address = address; + flashRead.region = region; + flashRead.size = length; internalState = InternalState::FLASH_READ; semaphore.release(); terminate = false; @@ -224,7 +224,7 @@ ReturnValue_t StrHelper::performImageDownload() { uint32_t size = 0; uint32_t retries = 0; Timestamp timestamp; - std::string image = downloadImagePath + "/" + timestamp.str() + downloadImage ; + std::string image = downloadImage.path + "/" + timestamp.str() + downloadImage.filename ; std::ofstream file(image, std::ios_base::app | std::ios_base::out); if(not std::filesystem::exists(image)) { return FILE_CREATION_FAILED; @@ -281,12 +281,12 @@ ReturnValue_t StrHelper::performImageUpload() { struct UploadActionRequest uploadReq; uploadReq.position = 0; std::memset(&uploadReq.data, 0, sizeof(uploadReq.data)); - if (not std::filesystem::exists(uploadImage)) { + if (not std::filesystem::exists(uploadImage.uploadFile)) { triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast(internalState)); internalState = InternalState::IDLE; return RETURN_FAILED; } - std::ifstream file(uploadImage, std::ifstream::binary); + std::ifstream file(uploadImage.uploadFile, std::ifstream::binary); // Set position of next character to end of file input stream file.seekg(0, file.end); // tellg returns position of character in input stream @@ -332,17 +332,17 @@ ReturnValue_t StrHelper::performFlashWrite() { uint32_t remainingBytes = 0; uint32_t fileSize = 0; struct WriteActionRequest req; - if (not std::filesystem::exists(flashWriteFile)) { + if (not std::filesystem::exists(flashWrite.fullname)) { triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast(internalState)); internalState = InternalState::IDLE; return RETURN_FAILED; } - std::ifstream file(flashWriteFile, std::ifstream::binary); + std::ifstream file(flashWrite.fullname, std::ifstream::binary); file.seekg(0, file.end); fileSize = file.tellg(); remainingBytes = fileSize; - req.region = flashWriteRegion; - req.address = flashWriteAddress; + req.region = flashWrite.region; + req.address = flashWrite.address; req.length = MAX_FLASH_DATA; while(remainingBytes >= MAX_FLASH_DATA) { if (terminate) { @@ -383,23 +383,23 @@ ReturnValue_t StrHelper::performFlashRead() { uint32_t size = 0; uint32_t retries = 0; Timestamp timestamp; - std::string fullname = flashReadPath + "/" + timestamp.str() + flashReadFile ; + std::string fullname = flashRead.path + "/" + timestamp.str() + flashRead.filename ; std::ofstream file(fullname, std::ios_base::app | std::ios_base::out); if (not std::filesystem::exists(fullname)) { return FILE_CREATION_FAILED; } - req.region = flashReadRegion; - while(bytesRead < flashReadSize) { + req.region = flashRead.region; + while(bytesRead < flashRead.size) { if (terminate) { return RETURN_OK; } - if ((flashReadSize - bytesRead) < MAX_FLASH_DATA) { - req.length = flashReadSize - bytesRead; + if ((flashRead.size - bytesRead) < MAX_FLASH_DATA) { + req.length = flashRead.size - bytesRead; } else { req.length = MAX_FLASH_DATA; } - req.address = flashReadAddress + bytesRead; + req.address = flashRead.address + bytesRead; arc_pack_read_action_req(&req, commandBuffer, &size); result = sendAndRead(size, req.address); if (result != RETURN_OK) { @@ -503,7 +503,7 @@ ReturnValue_t StrHelper::performFpgaUpload() { internalState = InternalState::IDLE; return RETURN_FAILED; } - std::ifstream file(flashWriteFile, std::ifstream::binary); + std::ifstream file(flashWrite.fullname, std::ifstream::binary); file.seekg(0, file.end); fileSize = file.tellg(); req.pos = 0; diff --git a/bsp_q7s/devices/startracker/StrHelper.h b/bsp_q7s/devices/startracker/StrHelper.h index 257b5ae7..e140a4d6 100644 --- a/bsp_q7s/devices/startracker/StrHelper.h +++ b/bsp_q7s/devices/startracker/StrHelper.h @@ -90,38 +90,37 @@ public: /** * @brief Starts sequence to upload image to star tracker * - * @param image Name including absolute path if to image to upload. Must be previously - * transferred to the OBC with the CFDP protocoll. + * @param uploadImage_ Name including absolute path of the image to upload. Must be previously + * transferred to the OBC with the CFDP protocol. */ ReturnValue_t startImageUpload(std::string uploadImage_); /** * @brief Calling this function initiates the download of an image from the star tracker. * - * @param Name of the image which will be created + * @param path Path where downloaded image will be stored */ - ReturnValue_t startImageDownload(std::string downloadImagePath_); + ReturnValue_t startImageDownload(std::string path); /** * @brief Starts the flash write procedure * - * @param flashWriteFile_ Full name including absolute path of file to write to flash + * @param fullname Full name including absolute path of file to write to flash * @param region Region ID of flash region to write to * @param address Start address of flash write procedure */ - ReturnValue_t startFlashWrite(std::string flashWriteFile_, uint8_t region, - uint32_t address); + ReturnValue_t startFlashWrite(std::string fullname, uint8_t region, uint32_t address); /** * @brief Starts the flash read procedure * - * @param flashWriteFile_ Full name including absolute path of file to write to flash + * @param path Path where file with read flash data will be created * @param region Region ID of flash region to read from - * @param flashWriteAddress Start address of flash section to read + * @param address Start address of flash section to read * @param length Number of bytes to read from flash */ - ReturnValue_t startFlashRead(std::string flashReadPath_, uint8_t region, - uint32_t address, uint32_t length); + ReturnValue_t startFlashRead(std::string path, uint8_t region, uint32_t address, + uint32_t length); /** * @brief Starts the download of the FPGA image @@ -148,7 +147,7 @@ public: /** * @brief Changes the dafault name of downloaded images */ - void setDownloadImageName(std::string image); + void setDownloadImageName(std::string filename); /** * @brief Sets the name of the file which will be created to store the data read from flash @@ -204,7 +203,6 @@ private: // Name of file containing downloaded FPGA image std::string fileName = "fpgaimage.bin"; }; - FpgaDownload fpgaDownload; class FpgaUpload { @@ -213,7 +211,6 @@ private: // Full name of file to upload std::string uploadFile; }; - FpgaUpload fpgaUpload; static const uint32_t MAX_POLLS = 10000; @@ -245,31 +242,49 @@ private: BinarySemaphore semaphore; - // Name including absolute path of image to upload - std::string uploadImage; - // Path where the downloaded image will be stored - std::string downloadImagePath; - // File which contains data to write when executing the flash write command - std::string flashWriteFile; - // Path where the file containing the read data will be stored - std::string flashReadPath = ""; + class UploadImage { + public: + // Name including absolute path of image to upload + std::string uploadFile; + }; + UploadImage uploadImage; - // Default name of downloaded image, can be changed via command - std::string downloadImage = "image.bin"; - // Default name of file containing the data read from flash, can be changed via command - std::string flashReadFile = "flashread.bin"; - // Will be set with the flash write command - uint8_t flashWriteRegion = 0; - // Will be set with the flash write command and specifies the start address where to write the - // flash data to - uint32_t flashWriteAddress = 0; - // Will be set with the flash read command - uint8_t flashReadRegion = 0; - // Will be set with the flash read command and specifies the start address of the flash section - // to read - uint32_t flashReadAddress = 0; - // Number of bytes to read from flash - uint32_t flashReadSize = 0; + class DownloadImage { + public: + // Path where the downloaded image will be stored + std::string path; + // Default name of downloaded image, can be changed via command + std::string filename = "image.bin"; + }; + DownloadImage downloadImage; + + class FlashWrite { + public: + // File which contains data to write when executing the flash write command + std::string fullname; + // Will be set with the flash write command + uint8_t region = 0; + // Will be set with the flash write command and specifies the start address where to write the + // flash data to + uint32_t address = 0; + }; + FlashWrite flashWrite; + + class FlashRead { + public: + // Path where the file containing the read data will be stored + std::string path = ""; + // Default name of file containing the data read from flash, can be changed via command + std::string filename = "flashread.bin"; + // Will be set with the flash read command + uint8_t region = 0; + // Will be set with the flash read command and specifies the start address of the flash section + // to read + uint32_t address = 0; + // Number of bytes to read from flash + uint32_t size = 0; + }; + FlashRead flashRead; SdCardManager* sdcMan = nullptr; diff --git a/tmtc b/tmtc index e3950bbb..418ecb81 160000 --- a/tmtc +++ b/tmtc @@ -1 +1 @@ -Subproject commit e3950bbbcca825b07c40b16658127210a9fe5fe2 +Subproject commit 418ecb815b00d5d2081b8d55a480f4c13a0f7139 From 1aca0b4499a375fa68b860d9acec8c1bb47d36f9 Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Sat, 1 Jan 2022 11:16:11 +0100 Subject: [PATCH 12/16] typo --- bsp_q7s/devices/startracker/StarTrackerDefinitions.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h index 29a1d800..f1f7b7d0 100644 --- a/bsp_q7s/devices/startracker/StarTrackerDefinitions.h +++ b/bsp_q7s/devices/startracker/StarTrackerDefinitions.h @@ -341,7 +341,7 @@ public: StaticLocalDataSet(sid_t(objectId, TEMPERATURE_SET_ID)) { } - // Ticks is time reference generated by interanl counter of the star tracker + // Ticks is time reference generated by internal counter of the star tracker lp_var_t ticks = lp_var_t(sid.objectId, PoolIds::TICKS_TEMPERATURE_SET, this); /** Unix time in microseconds */ @@ -381,7 +381,6 @@ public: StaticLocalDataSet(sid_t(objectId, VERSION_SET_ID)) { } - // Ticks is time reference generated by interanl counter of the star tracker lp_var_t ticks = lp_var_t(sid.objectId, PoolIds::TICKS_VERSION_SET, this); /** Unix time in microseconds */ From 3bbc7820c81a3465ddd422ef4d54c7f171886571 Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Sat, 1 Jan 2022 11:19:19 +0100 Subject: [PATCH 13/16] tmtc update --- tmtc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tmtc b/tmtc index 418ecb81..734dc5ae 160000 --- a/tmtc +++ b/tmtc @@ -1 +1 @@ -Subproject commit 418ecb815b00d5d2081b8d55a480f4c13a0f7139 +Subproject commit 734dc5aef88d9fef4ad59817b6ea315db954205c From 8b8a1554a557f1a2223d7ede98c14248541a2ce8 Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Sat, 1 Jan 2022 11:25:00 +0100 Subject: [PATCH 14/16] header fix issue with case sensitivity --- bsp_q7s/devices/startracker/StarTrackerHandler.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp index 9a504ffd..de70037a 100644 --- a/bsp_q7s/devices/startracker/StarTrackerHandler.cpp +++ b/bsp_q7s/devices/startracker/StarTrackerHandler.cpp @@ -4,7 +4,7 @@ #include "StarTrackerJsonCommands.h" #include #include -#include +#include extern "C" { #include #include From b59abb55fec83d72808eee4bd59f425f53f22e01 Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Sat, 1 Jan 2022 15:35:08 +0100 Subject: [PATCH 15/16] fixed device file number for mpsoc uart --- bsp_q7s/boardconfig/busConf.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bsp_q7s/boardconfig/busConf.h b/bsp_q7s/boardconfig/busConf.h index bcd43ccf..3108e303 100644 --- a/bsp_q7s/boardconfig/busConf.h +++ b/bsp_q7s/boardconfig/busConf.h @@ -8,7 +8,7 @@ static constexpr char SPI_RW_DEV[] = "/dev/spidev3.0"; static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c-1"; -static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ttyUL3"; +static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ttyUL2"; static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ttyUL4"; static constexpr char UART_SYRLINKS_DEV[] = "/dev/ttyUL5"; static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ttyUL7"; From 7e0510115ad229ccb700bf7748e834c479a4fae0 Mon Sep 17 00:00:00 2001 From: Jakob Meier Date: Sat, 1 Jan 2022 15:53:44 +0100 Subject: [PATCH 16/16] adapted uart device files --- bsp_q7s/boardconfig/busConf.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/bsp_q7s/boardconfig/busConf.h b/bsp_q7s/boardconfig/busConf.h index 3108e303..40989db5 100644 --- a/bsp_q7s/boardconfig/busConf.h +++ b/bsp_q7s/boardconfig/busConf.h @@ -9,12 +9,12 @@ static constexpr char SPI_RW_DEV[] = "/dev/spidev3.0"; static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c-1"; static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ttyUL2"; -static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ttyUL4"; -static constexpr char UART_SYRLINKS_DEV[] = "/dev/ttyUL5"; +static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ttyUL3"; +static constexpr char UART_SYRLINKS_DEV[] = "/dev/ttyUL4"; static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ttyUL7"; static constexpr char UART_GNSS_0_DEV[] = "/dev/ttyUL0"; -static constexpr char UART_GNSS_1_DEV[] = "/dev/ttyUL2"; +static constexpr char UART_GNSS_1_DEV[] = "/dev/ttyUL0"; static constexpr char UIO_PDEC_REGISTERS[] = "/dev/uio0"; static constexpr char UIO_PDEC_CONFIG_MEMORY[] = "/dev/uio2";