Robin Mueller
0256824e37
All checks were successful
EIVE/eive-obsw/pipeline/head This commit looks good
712 lines
24 KiB
C++
712 lines
24 KiB
C++
#include <fcntl.h>
|
|
#include <fsfw/filesystem/HasFileSystemIF.h>
|
|
#include <fsfw/tasks/TaskFactory.h>
|
|
#include <linux/devices/startracker/StrComHandler.h>
|
|
#include <unistd.h>
|
|
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
|
|
#include "OBSWConfig.h"
|
|
#include "eive/definitions.h"
|
|
#include "fsfw/timemanager/Countdown.h"
|
|
#include "helpers.h"
|
|
#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
|
|
#include "mission/utility/Filenaming.h"
|
|
#include "mission/utility/ProgressPrinter.h"
|
|
#include "mission/utility/Timestamp.h"
|
|
|
|
using namespace returnvalue;
|
|
|
|
StrComHandler::StrComHandler(object_id_t objectId) : SystemObject(objectId) {}
|
|
|
|
StrComHandler::~StrComHandler() {}
|
|
|
|
ReturnValue_t StrComHandler::initialize() {
|
|
#ifdef XIPHOS_Q7S
|
|
sdcMan = SdCardManager::instance();
|
|
if (sdcMan == nullptr) {
|
|
sif::warning << "StrHelper::initialize: Invalid SD Card Manager" << std::endl;
|
|
return returnvalue::FAILED;
|
|
}
|
|
#endif
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
|
|
ReturnValue_t result = returnvalue::OK;
|
|
semaphore.acquire();
|
|
while (true) {
|
|
switch (internalState) {
|
|
case InternalState::IDLE: {
|
|
semaphore.acquire();
|
|
break;
|
|
}
|
|
case InternalState::UPLOAD_IMAGE: {
|
|
result = performImageUpload();
|
|
if (result == returnvalue::OK) {
|
|
triggerEvent(IMAGE_UPLOAD_SUCCESSFUL);
|
|
} else {
|
|
triggerEvent(IMAGE_UPLOAD_FAILED);
|
|
}
|
|
internalState = InternalState::IDLE;
|
|
break;
|
|
}
|
|
case InternalState::DOWNLOAD_IMAGE: {
|
|
result = performImageDownload();
|
|
if (result == returnvalue::OK) {
|
|
triggerEvent(IMAGE_DOWNLOAD_SUCCESSFUL);
|
|
} else {
|
|
triggerEvent(IMAGE_DOWNLOAD_FAILED);
|
|
}
|
|
internalState = InternalState::IDLE;
|
|
break;
|
|
}
|
|
case InternalState::FLASH_READ: {
|
|
result = performFlashRead();
|
|
if (result == returnvalue::OK) {
|
|
triggerEvent(FLASH_READ_SUCCESSFUL);
|
|
} else {
|
|
triggerEvent(FLASH_READ_FAILED);
|
|
}
|
|
internalState = InternalState::IDLE;
|
|
break;
|
|
}
|
|
case InternalState::FIRMWARE_UPDATE: {
|
|
result = performFirmwareUpdate();
|
|
if (result == returnvalue::OK) {
|
|
triggerEvent(FIRMWARE_UPDATE_SUCCESSFUL);
|
|
} else {
|
|
triggerEvent(FIRMWARE_UPDATE_FAILED);
|
|
}
|
|
internalState = InternalState::IDLE;
|
|
break;
|
|
}
|
|
default:
|
|
sif::debug << "StrHelper::performOperation: Invalid state" << std::endl;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::startImageUpload(std::string fullname) {
|
|
#ifdef XIPHOS_Q7S
|
|
ReturnValue_t result = checkPath(fullname);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
#endif
|
|
uploadImage.uploadFile = fullname;
|
|
if (not std::filesystem::exists(fullname)) {
|
|
return FILE_NOT_EXISTS;
|
|
}
|
|
internalState = InternalState::UPLOAD_IMAGE;
|
|
semaphore.release();
|
|
terminate = false;
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::startImageDownload(std::string path) {
|
|
#ifdef XIPHOS_Q7S
|
|
ReturnValue_t result = checkPath(path);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
#endif
|
|
if (not std::filesystem::exists(path)) {
|
|
return PATH_NOT_EXISTS;
|
|
}
|
|
downloadImage.path = path;
|
|
internalState = InternalState::DOWNLOAD_IMAGE;
|
|
terminate = false;
|
|
semaphore.release();
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
void StrComHandler::stopProcess() { terminate = true; }
|
|
|
|
void StrComHandler::setDownloadImageName(std::string filename) {
|
|
downloadImage.filename = filename;
|
|
}
|
|
|
|
void StrComHandler::setFlashReadFilename(std::string filename) { flashRead.filename = filename; }
|
|
|
|
ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname) {
|
|
#ifdef XIPHOS_Q7S
|
|
ReturnValue_t result = checkPath(fullname);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
#endif
|
|
flashWrite.fullname = fullname;
|
|
if (not std::filesystem::exists(flashWrite.fullname)) {
|
|
return FILE_NOT_EXISTS;
|
|
}
|
|
flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST);
|
|
flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST);
|
|
internalState = InternalState::FIRMWARE_UPDATE;
|
|
semaphore.release();
|
|
terminate = false;
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::startFlashRead(std::string path, uint8_t startRegion,
|
|
uint32_t length) {
|
|
#ifdef XIPHOS_Q7S
|
|
ReturnValue_t result = checkPath(path);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
#endif
|
|
flashRead.path = path;
|
|
if (not std::filesystem::exists(flashRead.path)) {
|
|
return FILE_NOT_EXISTS;
|
|
}
|
|
flashRead.startRegion = startRegion;
|
|
flashRead.size = length;
|
|
internalState = InternalState::FLASH_READ;
|
|
semaphore.release();
|
|
terminate = false;
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
void StrComHandler::disableTimestamping() { timestamping = false; }
|
|
|
|
void StrComHandler::enableTimestamping() { timestamping = true; }
|
|
|
|
ReturnValue_t StrComHandler::performImageDownload() {
|
|
#ifdef XIPHOS_Q7S
|
|
if (not sdcMan->getActiveSdCard()) {
|
|
return HasFileSystemIF::FILESYSTEM_INACTIVE;
|
|
}
|
|
#endif
|
|
ReturnValue_t result;
|
|
#if OBSW_DEBUG_STARTRACKER == 1
|
|
ProgressPrinter progressPrinter("Image download", ImageDownload::LAST_POSITION);
|
|
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
|
|
struct DownloadActionRequest downloadReq;
|
|
uint32_t size = 0;
|
|
uint32_t retries = 0;
|
|
const uint8_t* replyFrame;
|
|
std::string image = Filenaming::generateAbsoluteFilename(downloadImage.path,
|
|
downloadImage.filename, timestamping);
|
|
std::ofstream file(image, std::ios_base::out);
|
|
if (not std::filesystem::exists(image)) {
|
|
return FILE_CREATION_FAILED;
|
|
}
|
|
downloadReq.position = 0;
|
|
while (downloadReq.position < ImageDownload::LAST_POSITION) {
|
|
if (terminate) {
|
|
file.close();
|
|
return returnvalue::OK;
|
|
}
|
|
arc_pack_download_action_req(&downloadReq, commandBuffer, &size);
|
|
result = sendAndRead(&replyFrame, size, downloadReq.position);
|
|
if (result != returnvalue::OK) {
|
|
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
|
|
uart::flushRxBuf(serialPort);
|
|
retries++;
|
|
continue;
|
|
}
|
|
file.close();
|
|
return result;
|
|
}
|
|
result = checkActionReply(replyFrame);
|
|
if (result != returnvalue::OK) {
|
|
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
|
|
uart::flushRxBuf(serialPort);
|
|
retries++;
|
|
continue;
|
|
}
|
|
file.close();
|
|
return result;
|
|
}
|
|
result = checkReplyPosition(replyFrame, downloadReq.position);
|
|
if (result != returnvalue::OK) {
|
|
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
|
|
uart::flushRxBuf(serialPort);
|
|
retries++;
|
|
continue;
|
|
}
|
|
file.close();
|
|
return result;
|
|
}
|
|
file.write(reinterpret_cast<const char*>(replyFrame + IMAGE_DATA_OFFSET), CHUNK_SIZE);
|
|
#if OBSW_DEBUG_STARTRACKER == 1
|
|
progressPrinter.print(downloadReq.position);
|
|
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
|
|
downloadReq.position++;
|
|
retries = 0;
|
|
}
|
|
file.close();
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::performImageUpload() {
|
|
ReturnValue_t result = returnvalue::OK;
|
|
uint32_t size = 0;
|
|
uint32_t imageSize = 0;
|
|
const uint8_t* replyFrame;
|
|
struct UploadActionRequest uploadReq;
|
|
uploadReq.position = 0;
|
|
#ifdef XIPHOS_Q7S
|
|
if (not sdcMan->getActiveSdCard()) {
|
|
return HasFileSystemIF::FILESYSTEM_INACTIVE;
|
|
}
|
|
#endif
|
|
std::memset(&uploadReq.data, 0, sizeof(uploadReq.data));
|
|
if (not std::filesystem::exists(uploadImage.uploadFile)) {
|
|
triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast<uint32_t>(internalState));
|
|
internalState = InternalState::IDLE;
|
|
return returnvalue::FAILED;
|
|
}
|
|
std::ifstream file(uploadImage.uploadFile, std::ifstream::binary);
|
|
if (file.bad()) {
|
|
return HasFileSystemIF::GENERIC_FILE_ERROR;
|
|
}
|
|
|
|
// Set position of next character to end of file input stream
|
|
file.seekg(0, file.end);
|
|
// tellg returns position of character in input stream
|
|
imageSize = file.tellg();
|
|
#if OBSW_DEBUG_STARTRACKER == 1
|
|
ProgressPrinter progressPrinter("Image upload", imageSize);
|
|
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
|
|
while ((uploadReq.position + 1) * SIZE_IMAGE_PART < imageSize) {
|
|
if (terminate) {
|
|
file.close();
|
|
return returnvalue::OK;
|
|
}
|
|
file.seekg(uploadReq.position * SIZE_IMAGE_PART, file.beg);
|
|
file.read(reinterpret_cast<char*>(uploadReq.data), SIZE_IMAGE_PART);
|
|
arc_pack_upload_action_req(&uploadReq, commandBuffer, &size);
|
|
result = sendAndRead(&replyFrame, size, uploadReq.position);
|
|
if (result != returnvalue::OK) {
|
|
file.close();
|
|
return returnvalue::FAILED;
|
|
}
|
|
result = checkActionReply(replyFrame);
|
|
if (result != returnvalue::OK) {
|
|
file.close();
|
|
return result;
|
|
}
|
|
#if OBSW_DEBUG_STARTRACKER == 1
|
|
progressPrinter.print((uploadReq.position + 1) * SIZE_IMAGE_PART);
|
|
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
|
|
uploadReq.position++;
|
|
}
|
|
std::memset(uploadReq.data, 0, sizeof(uploadReq.data));
|
|
uint32_t remainder = imageSize - uploadReq.position * SIZE_IMAGE_PART;
|
|
file.seekg(uploadReq.position * SIZE_IMAGE_PART, file.beg);
|
|
file.read(reinterpret_cast<char*>(uploadReq.data), remainder);
|
|
file.close();
|
|
uploadReq.position++;
|
|
arc_pack_upload_action_req(&uploadReq, commandBuffer, &size);
|
|
result = sendAndRead(&replyFrame, size, uploadReq.position);
|
|
if (result != returnvalue::OK) {
|
|
return returnvalue::FAILED;
|
|
}
|
|
result = checkActionReply(replyFrame);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
#if OBSW_DEBUG_STARTRACKER == 1
|
|
progressPrinter.print((uploadReq.position + 1) * SIZE_IMAGE_PART);
|
|
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::performFirmwareUpdate() {
|
|
using namespace startracker;
|
|
ReturnValue_t result = returnvalue::OK;
|
|
result = unlockAndEraseRegions(static_cast<uint32_t>(startracker::FirmwareRegions::FIRST),
|
|
static_cast<uint32_t>(startracker::FirmwareRegions::LAST));
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
result = performFlashWrite();
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::performFlashWrite() {
|
|
#ifdef XIPHOS_Q7S
|
|
if (not sdcMan->getActiveSdCard()) {
|
|
return HasFileSystemIF::FILESYSTEM_INACTIVE;
|
|
}
|
|
#endif
|
|
ReturnValue_t result = returnvalue::OK;
|
|
uint32_t size = 0;
|
|
uint32_t bytesWritten = 0;
|
|
uint32_t fileSize = 0;
|
|
const uint8_t* replyFrame;
|
|
struct WriteActionRequest req;
|
|
if (not std::filesystem::exists(flashWrite.fullname)) {
|
|
triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast<uint32_t>(internalState));
|
|
internalState = InternalState::IDLE;
|
|
return returnvalue::FAILED;
|
|
}
|
|
std::ifstream file(flashWrite.fullname, std::ifstream::binary);
|
|
file.seekg(0, file.end);
|
|
fileSize = file.tellg();
|
|
if (fileSize > FLASH_REGION_SIZE * (flashWrite.lastRegion - flashWrite.firstRegion)) {
|
|
sif::warning << "StrHelper::performFlashWrite: Invalid file" << std::endl;
|
|
return returnvalue::FAILED;
|
|
}
|
|
#if OBSW_DEBUG_STARTRACKER == 1
|
|
ProgressPrinter progressPrinter("Flash write", fileSize);
|
|
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
|
|
uint32_t fileChunks = fileSize / CHUNK_SIZE;
|
|
bytesWritten = 0;
|
|
req.region = flashWrite.firstRegion;
|
|
req.length = CHUNK_SIZE;
|
|
for (uint32_t idx = 0; idx < fileChunks; idx++) {
|
|
if (terminate) {
|
|
file.close();
|
|
return returnvalue::OK;
|
|
}
|
|
file.seekg(idx * CHUNK_SIZE, file.beg);
|
|
file.read(reinterpret_cast<char*>(req.data), CHUNK_SIZE);
|
|
if (bytesWritten + CHUNK_SIZE > FLASH_REGION_SIZE) {
|
|
req.region++;
|
|
bytesWritten = 0;
|
|
}
|
|
req.address = bytesWritten;
|
|
arc_pack_write_action_req(&req, commandBuffer, &size);
|
|
result = sendAndRead(&replyFrame, size, req.address);
|
|
if (result != returnvalue::OK) {
|
|
file.close();
|
|
return result;
|
|
}
|
|
result = checkActionReply(replyFrame);
|
|
if (result != returnvalue::OK) {
|
|
file.close();
|
|
return result;
|
|
}
|
|
bytesWritten += CHUNK_SIZE;
|
|
#if OBSW_DEBUG_STARTRACKER == 1
|
|
progressPrinter.print(idx * CHUNK_SIZE);
|
|
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
|
|
}
|
|
uint32_t remainingBytes = fileSize - fileChunks * CHUNK_SIZE;
|
|
file.seekg((fileChunks - 1) * CHUNK_SIZE, file.beg);
|
|
file.read(reinterpret_cast<char*>(req.data), remainingBytes);
|
|
file.close();
|
|
if (bytesWritten + CHUNK_SIZE > FLASH_REGION_SIZE) {
|
|
req.region++;
|
|
bytesWritten = 0;
|
|
}
|
|
req.address = bytesWritten;
|
|
req.length = remainingBytes;
|
|
bytesWritten += remainingBytes;
|
|
arc_pack_write_action_req(&req, commandBuffer, &size);
|
|
result = sendAndRead(&replyFrame, size, req.address);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
result = checkActionReply(replyFrame);
|
|
if (result != returnvalue::OK) {
|
|
return result;
|
|
}
|
|
#if OBSW_DEBUG_STARTRACKER == 1
|
|
progressPrinter.print(fileSize);
|
|
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::performFlashRead() {
|
|
#ifdef XIPHOS_Q7S
|
|
if (not sdcMan->getActiveSdCard()) {
|
|
return HasFileSystemIF::FILESYSTEM_INACTIVE;
|
|
}
|
|
#endif
|
|
ReturnValue_t result;
|
|
#if OBSW_DEBUG_STARTRACKER == 1
|
|
ProgressPrinter progressPrinter("Flash read", flashRead.size);
|
|
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
|
|
struct ReadActionRequest req;
|
|
uint32_t bytesRead = 0;
|
|
uint32_t size = 0;
|
|
uint32_t retries = 0;
|
|
const uint8_t* replyFrame;
|
|
Timestamp timestamp;
|
|
std::string fullname =
|
|
Filenaming::generateAbsoluteFilename(flashRead.path, flashRead.filename, timestamping);
|
|
std::ofstream file(fullname, std::ios_base::app | std::ios_base::out);
|
|
if (not std::filesystem::exists(fullname)) {
|
|
return FILE_CREATION_FAILED;
|
|
}
|
|
req.region = flashRead.startRegion;
|
|
req.address = 0;
|
|
while (bytesRead < flashRead.size) {
|
|
if (terminate) {
|
|
return returnvalue::OK;
|
|
}
|
|
if ((flashRead.size - bytesRead) < CHUNK_SIZE) {
|
|
req.length = flashRead.size - bytesRead;
|
|
} else {
|
|
req.length = CHUNK_SIZE;
|
|
}
|
|
arc_pack_read_action_req(&req, commandBuffer, &size);
|
|
result = sendAndRead(&replyFrame, size, req.address);
|
|
if (result != returnvalue::OK) {
|
|
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
|
|
uart::flushRxBuf(serialPort);
|
|
retries++;
|
|
continue;
|
|
}
|
|
file.close();
|
|
return result;
|
|
}
|
|
result = checkActionReply(replyFrame);
|
|
if (result != returnvalue::OK) {
|
|
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
|
|
uart::flushRxBuf(serialPort);
|
|
retries++;
|
|
continue;
|
|
}
|
|
file.close();
|
|
return result;
|
|
}
|
|
file.write(reinterpret_cast<const char*>(replyFrame + FLASH_READ_DATA_OFFSET), req.length);
|
|
bytesRead += req.length;
|
|
req.address += req.length;
|
|
if (req.address >= FLASH_REGION_SIZE) {
|
|
req.address = 0;
|
|
req.region++;
|
|
}
|
|
retries = 0;
|
|
#if OBSW_DEBUG_STARTRACKER == 1
|
|
progressPrinter.print(bytesRead);
|
|
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
|
|
}
|
|
file.close();
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::sendAndRead(const uint8_t** replyFrame, size_t size,
|
|
uint32_t failParameter, uint32_t delayMs) {
|
|
ReturnValue_t result = returnvalue::OK;
|
|
ReturnValue_t decResult = returnvalue::OK;
|
|
size_t receivedDataLen = 0;
|
|
size_t bytesLeft = 0;
|
|
uint32_t missedReplies = 0;
|
|
|
|
const uint8_t* sendData;
|
|
size_t txFrameLen = 0;
|
|
datalinkLayer.encodeFrame(commandBuffer, size, &sendData, txFrameLen);
|
|
int writeResult = write(serialPort, sendData, txFrameLen);
|
|
if (writeResult < 0) {
|
|
sif::warning << "StrHelper::sendAndRead: Failed to send packet" << std::endl;
|
|
triggerEvent(STR_HELPER_SENDING_PACKET_FAILED, result, failParameter);
|
|
return returnvalue::FAILED;
|
|
}
|
|
Countdown delay(delayMs);
|
|
while (true) {
|
|
delay.resetTimer();
|
|
while (delay.isBusy()) {
|
|
TaskFactory::delayTask(10);
|
|
}
|
|
// TODO: Read periodically into ring buffer, analyse ring buffer for reply frames periodically.
|
|
// result = uartComIF->requestReceiveMessage(comCookie, startracker::MAX_FRAME_SIZE * 2 + 2);
|
|
// if (result != returnvalue::OK) {
|
|
// sif::warning << "StrHelper::sendAndRead: Failed to request reply" << std::endl;
|
|
// triggerEvent(STR_HELPER_REQUESTING_MSG_FAILED, result, parameter);
|
|
// return returnvalue::FAILED;
|
|
// }
|
|
// result = uartComIF->readReceivedMessage(comCookie, &receivedData, &receivedDataLen);
|
|
// if (result != returnvalue::OK) {
|
|
// sif::warning << "StrHelper::sendAndRead: Failed to read received message" << std::endl;
|
|
// triggerEvent(STR_HELPER_READING_REPLY_FAILED, result, parameter);
|
|
// return returnvalue::FAILED;
|
|
// }
|
|
if (receivedDataLen == 0 && missedReplies < MAX_POLLS) {
|
|
missedReplies++;
|
|
continue;
|
|
} else if ((receivedDataLen == 0) && (missedReplies >= MAX_POLLS)) {
|
|
triggerEvent(STR_HELPER_NO_REPLY, failParameter);
|
|
return returnvalue::FAILED;
|
|
} else {
|
|
missedReplies = 0;
|
|
}
|
|
// TODO: Use frame detector function here instead.
|
|
// decResult = datalinkLayer.decodeFrame(receivedData, receivedDataLen, &bytesLeft);
|
|
if (bytesLeft != 0) {
|
|
// This should never happen
|
|
sif::warning << "StrHelper::sendAndRead: Bytes left after decoding" << std::endl;
|
|
triggerEvent(STR_HELPER_COM_ERROR, result, failParameter);
|
|
return returnvalue::FAILED;
|
|
}
|
|
}
|
|
if (decResult != returnvalue::OK) {
|
|
triggerEvent(STR_HELPER_DEC_ERROR, decResult, failParameter);
|
|
return returnvalue::FAILED;
|
|
}
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::checkActionReply(const uint8_t* rawFrame) {
|
|
uint8_t type = str::getReplyFrameType(rawFrame);
|
|
if (type != TMTC_ACTIONREPLY) {
|
|
sif::warning << "StrHelper::checkActionReply: Received reply with invalid type ID" << std::endl;
|
|
return INVALID_TYPE_ID;
|
|
}
|
|
uint8_t status = str::getStatusField(rawFrame);
|
|
if (status != ArcsecDatalinkLayer::STATUS_OK) {
|
|
sif::warning << "StrHelper::checkActionReply: Status failure: "
|
|
<< static_cast<unsigned int>(status) << std::endl;
|
|
return STATUS_ERROR;
|
|
}
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::checkReplyPosition(const uint8_t* rawFrame,
|
|
uint32_t expectedPosition) {
|
|
uint32_t receivedPosition = 0;
|
|
std::memcpy(&receivedPosition, rawFrame + POS_OFFSET, sizeof(receivedPosition));
|
|
if (receivedPosition != expectedPosition) {
|
|
triggerEvent(POSITION_MISMATCH, receivedPosition);
|
|
return returnvalue::FAILED;
|
|
}
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
#ifdef XIPHOS_Q7S
|
|
ReturnValue_t StrComHandler::checkPath(std::string name) {
|
|
if (name.substr(0, sizeof(config::SD_0_MOUNT_POINT)) == std::string(config::SD_0_MOUNT_POINT)) {
|
|
if (!sdcMan->isSdCardUsable(sd::SLOT_0)) {
|
|
sif::warning << "StrHelper::checkPath: SD card 0 not mounted" << std::endl;
|
|
return SD_NOT_MOUNTED;
|
|
}
|
|
} else if (name.substr(0, sizeof(config::SD_1_MOUNT_POINT)) ==
|
|
std::string(config::SD_1_MOUNT_POINT)) {
|
|
if (!sdcMan->isSdCardUsable(sd::SLOT_0)) {
|
|
sif::warning << "StrHelper::checkPath: SD card 1 not mounted" << std::endl;
|
|
return SD_NOT_MOUNTED;
|
|
}
|
|
}
|
|
return returnvalue::OK;
|
|
}
|
|
#endif
|
|
|
|
ReturnValue_t StrComHandler::initializeInterface(CookieIF* cookie) {
|
|
if (cookie == nullptr) {
|
|
return returnvalue::FAILED;
|
|
}
|
|
SerialCookie* serCookie = dynamic_cast<SerialCookie*>(cookie);
|
|
if (serCookie == nullptr) {
|
|
return DeviceCommunicationIF::INVALID_COOKIE_TYPE;
|
|
}
|
|
// comCookie = serCookie;
|
|
std::string devname = serCookie->getDeviceFile();
|
|
/* Get file descriptor */
|
|
serialPort = open(devname.c_str(), O_RDWR);
|
|
if (serialPort < 0) {
|
|
sif::warning << "StrComHandler: open call failed with error [" << errno << ", "
|
|
<< strerror(errno) << std::endl;
|
|
return returnvalue::FAILED;
|
|
}
|
|
// Setting up UART parameters
|
|
tty.c_cflag &= ~PARENB; // Clear parity bit
|
|
uart::setStopbits(tty, serCookie->getStopBits());
|
|
uart::setBitsPerWord(tty, BitsPerWord::BITS_8);
|
|
tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control
|
|
uart::enableRead(tty);
|
|
uart::ignoreCtrlLines(tty);
|
|
|
|
// Use non-canonical mode and clear echo flag
|
|
tty.c_lflag &= ~(ICANON | ECHO);
|
|
|
|
// Non-blocking mode, use polling
|
|
tty.c_cc[VTIME] = 0;
|
|
tty.c_cc[VMIN] = 0;
|
|
|
|
uart::setBaudrate(tty, serCookie->getBaudrate());
|
|
if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
|
|
sif::warning << "ScexUartReader::initializeInterface: tcsetattr call failed with error ["
|
|
<< errno << ", " << strerror(errno) << std::endl;
|
|
}
|
|
// Flush received and unread data
|
|
tcflush(serialPort, TCIOFLUSH);
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::sendMessage(CookieIF* cookie, const uint8_t* sendData,
|
|
size_t sendLen) {
|
|
const uint8_t* txFrame;
|
|
size_t frameLen;
|
|
datalinkLayer.encodeFrame(sendData, sendLen, &txFrame, frameLen);
|
|
size_t bytesWritten = write(serialPort, txFrame, frameLen);
|
|
if (bytesWritten != frameLen) {
|
|
sif::warning << "ScexUartReader::sendMessage: Sending ping command to solar experiment failed"
|
|
<< std::endl;
|
|
return returnvalue::FAILED;
|
|
}
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
|
|
|
|
ReturnValue_t StrComHandler::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
|
|
return returnvalue::OK;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::unlockAndEraseRegions(uint32_t from, uint32_t to) {
|
|
ReturnValue_t result = returnvalue::OK;
|
|
const uint8_t* replyFrame;
|
|
#if OBSW_DEBUG_STARTRACKER == 1
|
|
ProgressPrinter progressPrinter("Unlock and erase", to - from);
|
|
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
|
|
struct UnlockActionRequest unlockReq;
|
|
struct EraseActionRequest eraseReq;
|
|
uint32_t size = 0;
|
|
for (uint32_t idx = from; idx <= to; idx++) {
|
|
unlockReq.region = idx;
|
|
unlockReq.code = startracker::region_secrets::secret[idx];
|
|
arc_pack_unlock_action_req(&unlockReq, commandBuffer, &size);
|
|
sendAndRead(&replyFrame, size, unlockReq.region);
|
|
result = checkActionReply(replyFrame);
|
|
if (result != returnvalue::OK) {
|
|
sif::warning << "StrHelper::unlockAndEraseRegions: Failed to unlock region with id "
|
|
<< static_cast<unsigned int>(unlockReq.region) << std::endl;
|
|
return result;
|
|
}
|
|
eraseReq.region = idx;
|
|
arc_pack_erase_action_req(&eraseReq, commandBuffer, &size);
|
|
result = sendAndRead(&replyFrame, size, eraseReq.region, FLASH_ERASE_DELAY);
|
|
if (result != returnvalue::OK) {
|
|
sif::warning << "StrHelper::unlockAndEraseRegions: Failed to erase region with id "
|
|
<< static_cast<unsigned int>(eraseReq.region) << std::endl;
|
|
return result;
|
|
}
|
|
#if OBSW_DEBUG_STARTRACKER == 1
|
|
progressPrinter.print(idx - from);
|
|
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
|
|
}
|
|
return result;
|
|
}
|
|
|
|
ReturnValue_t StrComHandler::handleUartReception() {
|
|
ssize_t bytesRead = read(serialPort, reinterpret_cast<void*>(recBuf.data()),
|
|
static_cast<unsigned int>(recBuf.size()));
|
|
if (bytesRead == 0) {
|
|
return NO_SERIAL_DATA_READ;
|
|
} else if (bytesRead < 0) {
|
|
sif::warning << "PlocSupvHelper::performOperation: read call failed with error [" << errno
|
|
<< ", " << strerror(errno) << "]" << std::endl;
|
|
return FAILED;
|
|
} else if (bytesRead >= static_cast<int>(recBuf.size())) {
|
|
sif::error << "PlocSupvHelper::performOperation: Receive buffer too small for " << bytesRead
|
|
<< " bytes" << std::endl;
|
|
return FAILED;
|
|
} else if (bytesRead > 0) {
|
|
// sif::info << "Received " << bytesRead << " bytes from the PLOC Supervisor:" << std::endl;
|
|
// arrayprinter::print(recBuf.data(), bytesRead);
|
|
datalinkLayer.feedData(recBuf.data(), bytesRead);
|
|
}
|
|
return OK;
|
|
}
|