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

flash write command

Browse Source
This commit is contained in:
Jakob Meier
2021-12-21 15:46:09 +01:00
parent e3841d180e
commit 36d33711a7
10 changed files with 339 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -14,14 +14,14 @@ extern "C" {
}
StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF,
CookieIF * comCookie, StrImageLoader* strImageLoader) :
CookieIF * comCookie, StrHelper* strHelper) :
DeviceHandlerBase(objectId, comIF, comCookie), temperatureSet(this), versionSet(this), powerSet(
this), interfaceSet(this), timeSet(this), solutionSet(this), histogramSet(this),
contrastSet(this), strImageLoader(strImageLoader) {
contrastSet(this), strHelper(strHelper) {
if (comCookie == nullptr) {
sif::error << "StarTrackerHandler: Invalid com cookie" << std::endl;
}
if (strImageLoader == nullptr) {
if (strHelper == nullptr) {
sif::error << "StarTrackerHandler: Invalid str image loader" << std::endl;
}
eventQueue = QueueFactory::instance()->createMessageQueue(EventMessage::EVENT_MESSAGE_SIZE * 5);
@ -50,21 +50,21 @@ ReturnValue_t StarTrackerHandler::initialize() {
return result;
}
result = manager->subscribeToEventRange(eventQueue->getId(),
event::getEventId(StrImageLoader::IMAGE_UPLOAD_FAILED),
event::getEventId(StrImageLoader::IMAGE_DOWNLOAD_SUCCESSFUL));
event::getEventId(StrHelper::IMAGE_UPLOAD_FAILED),
event::getEventId(StrHelper::FLASH_READ_FAILED));
if (result != RETURN_OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1
sif::warning << "StarTrackerHandler::initialize: Failed to subscribe to events form image"
" loader" << std::endl;
sif::warning << "StarTrackerHandler::initialize: Failed to subscribe to events from "
" str helper" << std::endl;
#endif
return ObjectManagerIF::CHILD_INIT_FAILED;
}
result = strImageLoader->setComIF(communicationInterface);
result = strHelper->setComIF(communicationInterface);
if (result != RETURN_OK) {
return ObjectManagerIF::CHILD_INIT_FAILED;
}
strImageLoader->setComCookie(comCookie);
strHelper->setComCookie(comCookie);
return RETURN_OK;
}
@ -75,7 +75,7 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
switch(actionId) {
case(StarTracker::STOP_IMAGE_LOADER): {
strImageLoader->stopProcess();
strHelper->stopProcess();
return EXECUTION_FINISHED;
}
case(StarTracker::SET_JSON_FILE_NAME): {
@ -89,7 +89,7 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
break;
}
if (imageLoaderExecuting == true) {
if (strHelperExecuting == true) {
return IMAGE_LOADER_EXECUTING;
}
@ -108,12 +108,12 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
if (size > MAX_PATH_SIZE) {
return FILE_PATH_TOO_LONG;
}
result = strImageLoader->startImageUpload(
result = strHelper->startImageUpload(
std::string(reinterpret_cast<const char*>(data), size));
if (result != RETURN_OK) {
return result;
}
imageLoaderExecuting = true;
strHelperExecuting = true;
return EXECUTION_FINISHED;
}
case(StarTracker::DOWNLOAD_IMAGE): {
@ -124,19 +124,32 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
if (size > MAX_PATH_SIZE) {
return FILE_PATH_TOO_LONG;
}
result = strImageLoader->startImageDownload(
result = strHelper->startImageDownload(
std::string(reinterpret_cast<const char*>(data), size));
if (result != RETURN_OK) {
return result;
}
imageLoaderExecuting = true;
strHelperExecuting = true;
return EXECUTION_FINISHED;
}
case(StarTracker::WRITE): {
result = DeviceHandlerBase::acceptExternalDeviceCommands();
if (result != RETURN_OK) {
return result;
}
result = executeWriteCommand(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;
}
strImageLoader->setDownloadImageName(
strHelper->setDownloadImageName(
std::string(reinterpret_cast<const char*>(data), size));
return EXECUTION_FINISHED;
}
@ -182,7 +195,7 @@ void StarTrackerHandler::doStartUp() {
void StarTrackerHandler::doShutDown() {
// If star tracker is shutdown also stop all running processes in the image loader task
strImageLoader->stopProcess();
strHelper->stopProcess();
setMode(_MODE_POWER_DOWN);
}
@ -751,7 +764,7 @@ size_t StarTrackerHandler::getNextReplyLength(DeviceCommandId_t commandId){
ReturnValue_t StarTrackerHandler::doSendReadHook() {
// Prevent DHB from polling UART during commands executed by the image loader task
if(imageLoaderExecuting) {
if(strHelperExecuting) {
return RETURN_FAILED;
}
return RETURN_OK;
@ -776,6 +789,10 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(DeviceCommandId_t *foundId)
*foundId = StarTracker::PING_REQUEST;
break;
}
case (StarTracker::ID::WRITE): {
*foundId = StarTracker::WRITE;
break;
}
case (StarTracker::ID::BOOT): {
*foundId = StarTracker::BOOT;
break;
@ -906,7 +923,7 @@ void StarTrackerHandler::handleEvent(EventMessage* eventMessage) {
case objects::STR_IMG_LOADER: {
// All events from image loader signal either that the operation was successful or that it
// failed
imageLoaderExecuting = false;
strHelperExecuting = false;
break;
}
default:
@ -916,6 +933,39 @@ void StarTrackerHandler::handleEvent(EventMessage* eventMessage) {
}
}
ReturnValue_t StarTrackerHandler::executeWriteCommand(const uint8_t* commandData,
size_t commandDataLen) {
ReturnValue_t result = RETURN_OK;
if (commandDataLen < WriteCmd::MIN_LENGTH) {
sif::warning << "StarTrackerHandler::executeWriteCommand: 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 + WriteCmd::ADDRESS_OFFSET;
result = SerializeAdapter::deSerialize(&address, addressPtr, &size,
SerializeIF::Endianness::LITTLE);
if (result != RETURN_OK) {
sif::debug << "StarTrackerHandler::executeWriteCommand: Deserialization of address failed"
<< std::endl;
return result;
}
if (commandDataLen - sizeof(address) - sizeof(region) > MAX_PATH_SIZE) {
sif::warning << "StarTrackerHandler::executeWriteCommand: Received command with invalid"
<< " path and filename" << std::endl;
return FILE_PATH_TOO_LONG;
}
const uint8_t* filePtr = commandData + WriteCmd::FILE_OFFSET;
std::string fullname = std::string(reinterpret_cast<const char*>(filePtr),
commandDataLen - sizeof(address) - sizeof(region));
result = strHelper->startFlashWrite(fullname, region, address);
if (result != RETURN_OK) {
return result;
}
return result;
}
void StarTrackerHandler::prepareBootCommand() {
uint32_t length = 0;
struct BootActionRequest bootRequest = {BOOT_REGION_ID};