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

works like a charm
All checks were successful
EIVE/eive-obsw/pipeline/head This commit looks good
Details

Browse Source
This commit is contained in:
Robin Müller
2023-03-22 02:20:14 +01:00
parent 2dc22a7d8f
commit 57f5a22b04
32 changed files with 406 additions and 301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
linux/ObjectFactory.cpp
View File

@ -314,7 +314,7 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
void ObjectFactory::createScexComponents(std::string uartDev, PowerSwitchIF* pwrSwitcher,
SdCardMountedIF& mountedIF, bool onImmediately,
std::optional<power::Switch_t> switchId) {
auto* cookie = new SerialCookie(objects::SCEX, uartDev, uart::SCEX_BAUD, 4096);
auto* cookie = new SerialCookie(objects::SCEX, uartDev, serial::SCEX_BAUD, 4096);
cookie->setTwoStopBits();
// cookie->setParityEven();
auto scexUartReader = new ScexUartReader(objects::SCEX_UART_READER);

10
linux/devices/ScexUartReader.cpp
View File

@ -98,11 +98,11 @@ ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
}
// Setting up UART parameters
tty.c_cflag &= ~PARENB; // Clear parity bit
uart::setStopbits(tty, uartCookie->getStopBits());
uart::setBitsPerWord(tty, BitsPerWord::BITS_8);
serial::setStopbits(tty, uartCookie->getStopBits());
serial::setBitsPerWord(tty, BitsPerWord::BITS_8);
tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control
uart::enableRead(tty);
uart::ignoreCtrlLines(tty);
serial::enableRead(tty);
serial::ignoreCtrlLines(tty);
// Use non-canonical mode and clear echo flag
tty.c_lflag &= ~(ICANON | ECHO);
@ -111,7 +111,7 @@ ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
tty.c_cc[VTIME] = 0;
tty.c_cc[VMIN] = 0;
uart::setBaudrate(tty, uartCookie->getBaudrate());
serial::setBaudrate(tty, uartCookie->getBaudrate());
if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
sif::warning << "ScexUartReader::initializeInterface: tcsetattr call failed with error ["
<< errno << ", " << strerror(errno) << std::endl;

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

@ -58,12 +58,12 @@ ReturnValue_t PlocSupvUartManager::initializeInterface(CookieIF* cookie) {
}
// Setting up UART parameters
tty.c_cflag &= ~PARENB; // Clear parity bit
uart::setParity(tty, uartCookie->getParity());
uart::setStopbits(tty, uartCookie->getStopBits());
uart::setBitsPerWord(tty, BitsPerWord::BITS_8);
serial::setParity(tty, uartCookie->getParity());
serial::setStopbits(tty, uartCookie->getStopBits());
serial::setBitsPerWord(tty, BitsPerWord::BITS_8);
tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control
uart::enableRead(tty);
uart::ignoreCtrlLines(tty);
serial::enableRead(tty);
serial::ignoreCtrlLines(tty);
// Use non-canonical mode and clear echo flag
tty.c_lflag &= ~(ICANON | ECHO);
@ -72,7 +72,7 @@ ReturnValue_t PlocSupvUartManager::initializeInterface(CookieIF* cookie) {
tty.c_cc[VTIME] = 2;
tty.c_cc[VMIN] = 0;
uart::setBaudrate(tty, uartCookie->getBaudrate());
serial::setBaudrate(tty, uartCookie->getBaudrate());
if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
sif::warning << "PlocSupvUartManager::initializeInterface: tcsetattr call failed with error ["
<< errno << ", " << strerror(errno) << std::endl;

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

@ -246,9 +246,9 @@ class PlocSupvUartManager : public DeviceCommunicationIF,
std::array<uint8_t, 2048> recBuf = {};
std::array<uint8_t, 2048> encodedBuf = {};
std::array<uint8_t, 1200> decodedBuf = {};
std::array<uint8_t, 1200> ipcBuffer = {};
SimpleRingBuffer decodedRingBuf;
FIFO<size_t, MAX_STORED_DECODED_PACKETS> decodedQueue;
std::array<uint8_t, 1200> ipcBuffer = {};
SimpleRingBuffer ipcRingBuf;
FIFO<size_t, MAX_STORED_DECODED_PACKETS> ipcQueue;

11
linux/devices/startracker/ArcsecJsonParamBase.cpp
View File

@ -1,17 +1,10 @@
#include "ArcsecJsonParamBase.h"
#include "ArcsecJsonKeys.h"
#include "arcsecJsonKeys.h"
ArcsecJsonParamBase::ArcsecJsonParamBase(std::string setName) : setName(setName) {}
ReturnValue_t ArcsecJsonParamBase::create(std::string fullname, uint8_t* buffer) {
// ReturnValue_t result = returnvalue::OK;
// result = init(fullname);
// if (result != returnvalue::OK) {
// sif::warning << "ArcsecJsonParamBase::create: Failed to init parameter command for set "
// << setName << std::endl;
// return result;
// }
ReturnValue_t ArcsecJsonParamBase::create(uint8_t* buffer) {
ReturnValue_t result = createCommand(buffer);
if (result != returnvalue::OK) {
sif::warning << "ArcsecJsonParamBase::create: Failed to create parameter command for set "

2
linux/devices/startracker/ArcsecJsonParamBase.h
View File

@ -56,7 +56,7 @@ class ArcsecJsonParamBase {
* parameter set.
* @param buffer Pointer to the buffer the command will be written to
*/
ReturnValue_t create(std::string fullname, uint8_t* buffer);
ReturnValue_t create(uint8_t* buffer);
/**
* @brief Returns the size of the parameter command.

5
linux/devices/startracker/CMakeLists.txt
View File

@ -1,5 +1,4 @@
target_sources(
${OBSW_NAME}
PRIVATE StarTrackerHandler.cpp StarTrackerJsonCommands.cpp
ArcsecDatalinkLayer.cpp ArcsecJsonParamBase.cpp StrComHandler.cpp
helpers.cpp)
PRIVATE StarTrackerHandler.cpp strJsonCommands.cpp ArcsecDatalinkLayer.cpp
ArcsecJsonParamBase.cpp StrComHandler.cpp helpers.cpp)

82
linux/devices/startracker/StarTrackerHandler.cpp
View File

@ -11,9 +11,9 @@
#include <thread>
#include "OBSWConfig.h"
#include "StarTrackerJsonCommands.h"
#include "arcsec/common/misc.h"
#include "helpers.h"
#include "strJsonCommands.h"
std::atomic_bool JCFG_DONE(false);
@ -93,11 +93,6 @@ ReturnValue_t StarTrackerHandler::initialize() {
return ObjectManagerIF::CHILD_INIT_FAILED;
}
// result = strHelper->setComIF(communicationInterface);
// if (result != returnvalue::OK) {
// return ObjectManagerIF::CHILD_INIT_FAILED;
// }
// strHelper->setComCookie(comCookie);
return returnvalue::OK;
}
@ -1529,7 +1524,7 @@ ReturnValue_t StarTrackerHandler::scanForTmReply(uint8_t replyId, DeviceCommandI
void StarTrackerHandler::handleEvent(EventMessage* eventMessage) {
object_id_t objectId = eventMessage->getReporter();
switch (objectId) {
case objects::STR_HELPER: {
case objects::STR_COM_IF: {
// All events from image loader signal either that the operation was successful or that it
// failed
strHelperHandlingSpecialRequest = false;
@ -1577,9 +1572,8 @@ void StarTrackerHandler::prepareBootCommand() {
uint32_t length = 0;
struct BootActionRequest bootRequest = {BOOT_REGION_ID};
arc_pack_boot_action_req(&bootRequest, commandBuffer, &length);
// dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = commandBuffer; // dataLinkLayer.getEncodedFrame();
rawPacketLen = length; // dataLinkLayer.getEncodedLength();
rawPacket = commandBuffer;
rawPacketLen = length;
}
ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandData,
@ -1611,9 +1605,8 @@ ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandD
}
uint32_t rawCmdLength = 0;
arc_pack_checksum_action_req(&req, commandBuffer, &rawCmdLength);
// dataLinkLayer.encodeFrame(commandBuffer, rawCmdLength);
rawPacket = commandBuffer; // dataLinkLayer.getEncodedFrame();
rawPacketLen = rawCmdLength; // dataLinkLayer.getEncodedLength();
rawPacket = commandBuffer;
rawPacketLen = rawCmdLength;
checksumCmd.rememberRegion = req.region;
checksumCmd.rememberAddress = req.address;
checksumCmd.rememberLength = req.length;
@ -1623,51 +1616,45 @@ ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandD
void StarTrackerHandler::prepareTimeRequest() {
uint32_t length = 0;
arc_tm_pack_time_req(commandBuffer, &length);
// dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = commandBuffer; // dataLinkLayer.getEncodedFrame();
rawPacketLen = length; // dataLinkLayer.getEncodedLength();
rawPacket = commandBuffer;
rawPacketLen = length;
}
void StarTrackerHandler::preparePingRequest() {
uint32_t length = 0;
struct PingActionRequest pingRequest = {PING_ID};
arc_pack_ping_action_req(&pingRequest, commandBuffer, &length);
// dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = commandBuffer; // dataLinkLayer.getEncodedFrame();
rawPacketLen = length; // dataLinkLayer.getEncodedLength();
rawPacket = commandBuffer;
rawPacketLen = length;
}
void StarTrackerHandler::prepareVersionRequest() {
uint32_t length = 0;
arc_tm_pack_version_req(commandBuffer, &length);
// dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = commandBuffer; // dataLinkLayer.getEncodedFrame();
rawPacketLen = length; // dataLinkLayer.getEncodedLength();
rawPacket = commandBuffer;
rawPacketLen = length;
}
void StarTrackerHandler::prepareInterfaceRequest() {
uint32_t length = 0;
arc_tm_pack_interface_req(commandBuffer, &length);
// dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = commandBuffer; // dataLinkLayer.getEncodedFrame();
rawPacketLen = length; // dataLinkLayer.getEncodedLength();
rawPacket = commandBuffer;
rawPacketLen = length;
}
void StarTrackerHandler::preparePowerRequest() {
uint32_t length = 0;
arc_tm_pack_power_req(commandBuffer, &length);
// dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = commandBuffer; // dataLinkLayer.getEncodedFrame();
rawPacketLen = length; // dataLinkLayer.getEncodedLength();
rawPacket = commandBuffer;
rawPacketLen = length;
}
void StarTrackerHandler::prepareSwitchToBootloaderCmd() {
uint32_t length = 0;
struct RebootActionRequest rebootReq {};
arc_pack_reboot_action_req(&rebootReq, commandBuffer, &length);
// dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = commandBuffer; // dataLinkLayer.getEncodedFrame();
rawPacketLen = length; // dataLinkLayer.getEncodedLength();
rawPacket = commandBuffer;
rawPacketLen = length;
}
void StarTrackerHandler::prepareTakeImageCommand(const uint8_t* commandData) {
@ -1675,33 +1662,29 @@ void StarTrackerHandler::prepareTakeImageCommand(const uint8_t* commandData) {
struct CameraActionRequest camReq;
camReq.actionid = *commandData;
arc_pack_camera_action_req(&camReq, commandBuffer, &length);
// dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = commandBuffer; // dataLinkLayer.getEncodedFrame();
rawPacketLen = length; // dataLinkLayer.getEncodedLength();
rawPacket = commandBuffer;
rawPacketLen = length;
}
void StarTrackerHandler::prepareSolutionRequest() {
uint32_t length = 0;
arc_tm_pack_solution_req(commandBuffer, &length);
// dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = commandBuffer; // dataLinkLayer.getEncodedFrame();
rawPacketLen = length; // dataLinkLayer.getEncodedLength();
rawPacket = commandBuffer;
rawPacketLen = length;
}
void StarTrackerHandler::prepareTemperatureRequest() {
uint32_t length = 0;
arc_tm_pack_temperature_req(commandBuffer, &length);
// dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = commandBuffer; // dataLinkLayer.getEncodedFrame();
rawPacketLen = length; // dataLinkLayer.getEncodedLength();
rawPacket = commandBuffer;
rawPacketLen = length;
}
void StarTrackerHandler::prepareHistogramRequest() {
uint32_t length = 0;
arc_tm_pack_histogram_req(commandBuffer, &length);
// dataLinkLayer.encodeFrame(commandBuffer, length);
rawPacket = commandBuffer; // dataLinkLayer.getEncodedFrame();
rawPacketLen = length; // dataLinkLayer.getEncodedLength();
rawPacket = commandBuffer;
rawPacketLen = length;
}
ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData,
@ -1712,9 +1695,8 @@ ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData
if (commandDataLen > MAX_PATH_SIZE) {
return FILE_PATH_TOO_LONG;
}
std::string fullName(reinterpret_cast<const char*>(commandData), commandDataLen);
result = paramSet.create(fullName, commandBuffer);
result = paramSet.create(commandBuffer);
if (result != returnvalue::OK) {
return result;
}
@ -1847,7 +1829,7 @@ ReturnValue_t StarTrackerHandler::handleSetParamReply(const uint8_t* rawFrame) {
return SET_PARAM_FAILED;
}
if (internalState != InternalState::IDLE) {
handleStartup(rawFrame + 1 + PARAMETER_ID_OFFSET);
handleStartup(*(rawFrame + PARAMETER_ID_OFFSET));
}
return returnvalue::OK;
}
@ -2033,8 +2015,8 @@ ReturnValue_t StarTrackerHandler::handleActionReplySet(const uint8_t* rawFrame,
return result;
}
void StarTrackerHandler::handleStartup(const uint8_t* parameterId) {
switch (*parameterId) {
void StarTrackerHandler::handleStartup(uint8_t parameterId) {
switch (parameterId) {
case (startracker::ID::LOG_LEVEL): {
bootState = FwBootState::LIMITS;
break;
@ -2089,8 +2071,8 @@ void StarTrackerHandler::handleStartup(const uint8_t* parameterId) {
break;
}
default: {
sif::debug << "StarTrackerHandler::handleStartup: Received parameter reply with unexpected"
<< " parameter ID" << std::endl;
sif::warning << "StarTrackerHandler::handleStartup: Received parameter reply with unexpected"
<< " parameter ID " << (int)parameterId << std::endl;
break;
}
}

6
linux/devices/startracker/StarTrackerHandler.h
View File

@ -2,20 +2,20 @@
#define MISSION_DEVICES_STARTRACKERHANDLER_H_
#include <fsfw/datapool/PoolReadGuard.h>
#include <linux/devices/startracker/StarTrackerJsonCommands.h>
#include <linux/devices/startracker/StrComHandler.h>
#include <thread>
#include "ArcsecDatalinkLayer.h"
#include "ArcsecJsonParamBase.h"
#include "OBSWConfig.h"
#include "StrComHandler.h"
#include "arcsec/common/SLIP.h"
#include "devices/powerSwitcherList.h"
#include "fsfw/devicehandlers/DeviceHandlerBase.h"
#include "fsfw/src/fsfw/serialize/SerializeAdapter.h"
#include "fsfw/timemanager/Countdown.h"
#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
#include "strJsonCommands.h"
/**
* @brief This is the device handler for the star tracker from arcsec.
@ -472,7 +472,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
/**
* @brief Handles the startup state machine
*/
void handleStartup(const uint8_t* parameterId);
void handleStartup(uint8_t parameterId);
/**
* @brief Handles telemtry replies and fills the appropriate dataset

293
linux/devices/startracker/StrComHandler.cpp
View File

@ -1,6 +1,7 @@
#include <fcntl.h>
#include <fsfw/filesystem/HasFileSystemIF.h>
#include <fsfw/tasks/TaskFactory.h>
#include <fsfw/timemanager/Stopwatch.h>
#include <linux/devices/startracker/StrComHandler.h>
#include <unistd.h>
@ -18,7 +19,10 @@
using namespace returnvalue;
StrComHandler::StrComHandler(object_id_t objectId) : SystemObject(objectId) {}
StrComHandler::StrComHandler(object_id_t objectId) : SystemObject(objectId) {
lock = MutexFactory::instance()->createMutex();
semaphore.acquire();
}
StrComHandler::~StrComHandler() {}
@ -35,51 +39,60 @@ ReturnValue_t StrComHandler::initialize() {
ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
ReturnValue_t result = returnvalue::OK;
semaphore.acquire();
while (true) {
switch (internalState) {
case InternalState::IDLE: {
semaphore.acquire();
lock->lockMutex();
state = InternalState::SLEEPING;
lock->unlockMutex();
semaphore.acquire();
switch (state) {
case InternalState::POLL_ONE_REPLY: {
// Stopwatch watch;
replyTimeout.setTimeout(200);
replyResult = readOneReply(static_cast<uint32_t>(state));
{
MutexGuard mg(lock);
replyWasReceived = true;
}
break;
}
case InternalState::UPLOAD_IMAGE: {
replyTimeout.setTimeout(200);
result = performImageUpload();
if (result == returnvalue::OK) {
triggerEvent(IMAGE_UPLOAD_SUCCESSFUL);
} else {
triggerEvent(IMAGE_UPLOAD_FAILED);
}
internalState = InternalState::IDLE;
break;
}
case InternalState::DOWNLOAD_IMAGE: {
replyTimeout.setTimeout(200);
result = performImageDownload();
if (result == returnvalue::OK) {
triggerEvent(IMAGE_DOWNLOAD_SUCCESSFUL);
} else {
triggerEvent(IMAGE_DOWNLOAD_FAILED);
}
internalState = InternalState::IDLE;
break;
}
case InternalState::FLASH_READ: {
replyTimeout.setTimeout(200);
result = performFlashRead();
if (result == returnvalue::OK) {
triggerEvent(FLASH_READ_SUCCESSFUL);
} else {
triggerEvent(FLASH_READ_FAILED);
}
internalState = InternalState::IDLE;
break;
}
case InternalState::FIRMWARE_UPDATE: {
replyTimeout.setTimeout(200);
result = performFirmwareUpdate();
if (result == returnvalue::OK) {
triggerEvent(FIRMWARE_UPDATE_SUCCESSFUL);
} else {
triggerEvent(FIRMWARE_UPDATE_FAILED);
}
internalState = InternalState::IDLE;
break;
}
default:
@ -90,6 +103,12 @@ ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
}
ReturnValue_t StrComHandler::startImageUpload(std::string fullname) {
{
MutexGuard mg(lock);
if (state != InternalState::SLEEPING) {
return BUSY;
}
}
#ifdef XIPHOS_Q7S
ReturnValue_t result = checkPath(fullname);
if (result != returnvalue::OK) {
@ -100,13 +119,22 @@ ReturnValue_t StrComHandler::startImageUpload(std::string fullname) {
if (not std::filesystem::exists(fullname)) {
return FILE_NOT_EXISTS;
}
internalState = InternalState::UPLOAD_IMAGE;
{
MutexGuard mg(lock);
state = InternalState::UPLOAD_IMAGE;
}
semaphore.release();
terminate = false;
return returnvalue::OK;
}
ReturnValue_t StrComHandler::startImageDownload(std::string path) {
{
MutexGuard mg(lock);
if (state != InternalState::SLEEPING) {
return BUSY;
}
}
#ifdef XIPHOS_Q7S
ReturnValue_t result = checkPath(path);
if (result != returnvalue::OK) {
@ -117,7 +145,10 @@ ReturnValue_t StrComHandler::startImageDownload(std::string path) {
return PATH_NOT_EXISTS;
}
downloadImage.path = path;
internalState = InternalState::DOWNLOAD_IMAGE;
{
MutexGuard mg(lock);
state = InternalState::DOWNLOAD_IMAGE;
}
terminate = false;
semaphore.release();
return returnvalue::OK;
@ -132,6 +163,12 @@ void StrComHandler::setDownloadImageName(std::string filename) {
void StrComHandler::setFlashReadFilename(std::string filename) { flashRead.filename = filename; }
ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname) {
{
MutexGuard mg(lock);
if (state != InternalState::SLEEPING) {
return BUSY;
}
}
#ifdef XIPHOS_Q7S
ReturnValue_t result = checkPath(fullname);
if (result != returnvalue::OK) {
@ -144,7 +181,10 @@ ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname) {
}
flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST);
flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST);
internalState = InternalState::FIRMWARE_UPDATE;
{
MutexGuard mg(lock);
state = InternalState::FIRMWARE_UPDATE;
}
semaphore.release();
terminate = false;
return returnvalue::OK;
@ -152,6 +192,12 @@ ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname) {
ReturnValue_t StrComHandler::startFlashRead(std::string path, uint8_t startRegion,
uint32_t length) {
{
MutexGuard mg(lock);
if (state != InternalState::SLEEPING) {
return BUSY;
}
}
#ifdef XIPHOS_Q7S
ReturnValue_t result = checkPath(path);
if (result != returnvalue::OK) {
@ -164,7 +210,10 @@ ReturnValue_t StrComHandler::startFlashRead(std::string path, uint8_t startRegio
}
flashRead.startRegion = startRegion;
flashRead.size = length;
internalState = InternalState::FLASH_READ;
{
MutexGuard mg(lock);
state = InternalState::FLASH_READ;
}
semaphore.release();
terminate = false;
return returnvalue::OK;
@ -187,7 +236,6 @@ ReturnValue_t StrComHandler::performImageDownload() {
struct DownloadActionRequest downloadReq;
uint32_t size = 0;
uint32_t retries = 0;
const uint8_t* replyFrame;
size_t replySize = 0;
std::string image = Filenaming::generateAbsoluteFilename(downloadImage.path,
downloadImage.filename, timestamping);
@ -201,38 +249,38 @@ ReturnValue_t StrComHandler::performImageDownload() {
file.close();
return returnvalue::OK;
}
arc_pack_download_action_req(&downloadReq, commandBuffer, &size);
result = sendAndRead(size, downloadReq.position, &replyFrame, replySize);
arc_pack_download_action_req(&downloadReq, cmdBuf.data(), &size);
result = sendAndRead(size, downloadReq.position);
if (result != returnvalue::OK) {
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
uart::flushRxBuf(serialPort);
serial::flushRxBuf(serialPort);
retries++;
continue;
}
file.close();
return result;
}
result = checkActionReply(replyFrame, replySize);
result = checkActionReply(replySize);
if (result != returnvalue::OK) {
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
uart::flushRxBuf(serialPort);
serial::flushRxBuf(serialPort);
retries++;
continue;
}
file.close();
return result;
}
result = checkReplyPosition(replyFrame, downloadReq.position);
result = checkReplyPosition(downloadReq.position);
if (result != returnvalue::OK) {
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
uart::flushRxBuf(serialPort);
serial::flushRxBuf(serialPort);
retries++;
continue;
}
file.close();
return result;
}
file.write(reinterpret_cast<const char*>(replyFrame + IMAGE_DATA_OFFSET), CHUNK_SIZE);
file.write(reinterpret_cast<const char*>(replyPtr + IMAGE_DATA_OFFSET), CHUNK_SIZE);
#if OBSW_DEBUG_STARTRACKER == 1
progressPrinter.print(downloadReq.position);
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
@ -247,8 +295,6 @@ ReturnValue_t StrComHandler::performImageUpload() {
ReturnValue_t result = returnvalue::OK;
uint32_t size = 0;
uint32_t imageSize = 0;
const uint8_t* replyFrame;
size_t replySize = 0;
struct UploadActionRequest uploadReq;
uploadReq.position = 0;
#ifdef XIPHOS_Q7S
@ -258,8 +304,7 @@ ReturnValue_t StrComHandler::performImageUpload() {
#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;
triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast<uint32_t>(state));
return returnvalue::FAILED;
}
std::ifstream file(uploadImage.uploadFile, std::ifstream::binary);
@ -276,26 +321,29 @@ ReturnValue_t StrComHandler::performImageUpload() {
#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(size, uploadReq.position, &replyFrame, replySize);
arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
result = sendAndRead(size, uploadReq.position);
if (result != returnvalue::OK) {
file.close();
return returnvalue::FAILED;
}
result = checkActionReply(replyFrame, replySize);
result = checkActionReply(replyLen);
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++;
// This does a bit of delaying roughly every second
if (uploadReq.position % 50 == 0) {
// Some grace time for other tasks
TaskFactory::delayTask(2);
}
}
std::memset(uploadReq.data, 0, sizeof(uploadReq.data));
uint32_t remainder = imageSize - uploadReq.position * SIZE_IMAGE_PART;
@ -303,12 +351,12 @@ ReturnValue_t StrComHandler::performImageUpload() {
file.read(reinterpret_cast<char*>(uploadReq.data), remainder);
file.close();
uploadReq.position++;
arc_pack_upload_action_req(&uploadReq, commandBuffer, &size);
result = sendAndRead(size, uploadReq.position, &replyFrame, replySize);
arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
result = sendAndRead(size, uploadReq.position);
if (result != returnvalue::OK) {
return returnvalue::FAILED;
}
result = checkActionReply(replyFrame, replySize);
result = checkActionReply(replyLen);
if (result != returnvalue::OK) {
return result;
}
@ -340,16 +388,16 @@ ReturnValue_t StrComHandler::performFlashWrite() {
uint32_t size = 0;
uint32_t bytesWritten = 0;
uint32_t fileSize = 0;
const uint8_t* replyFrame;
size_t replySize = 0;
struct WriteActionRequest req;
if (not std::filesystem::exists(flashWrite.fullname)) {
triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast<uint32_t>(internalState));
internalState = InternalState::IDLE;
triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast<uint32_t>(state));
return returnvalue::FAILED;
}
std::ifstream file(flashWrite.fullname, std::ifstream::binary);
if (file.bad()) {
return returnvalue::FAILED;
}
file.seekg(0, file.end);
fileSize = file.tellg();
if (fileSize > FLASH_REGION_SIZE * (flashWrite.lastRegion - flashWrite.firstRegion)) {
@ -365,7 +413,6 @@ ReturnValue_t StrComHandler::performFlashWrite() {
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);
@ -375,21 +422,23 @@ ReturnValue_t StrComHandler::performFlashWrite() {
bytesWritten = 0;
}
req.address = bytesWritten;
arc_pack_write_action_req(&req, commandBuffer, &size);
result = sendAndRead(size, req.address, &replyFrame, replySize);
arc_pack_write_action_req(&req, cmdBuf.data(), &size);
result = sendAndRead(size, req.address);
if (result != returnvalue::OK) {
file.close();
return result;
}
result = checkActionReply(replyFrame, replySize);
result = checkActionReply(replyLen);
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 */
if (idx % 50 == 0) {
// Some grace time for other tasks
TaskFactory::delayTask(2);
}
}
uint32_t remainingBytes = fileSize - fileChunks * CHUNK_SIZE;
file.seekg((fileChunks - 1) * CHUNK_SIZE, file.beg);
@ -402,12 +451,12 @@ ReturnValue_t StrComHandler::performFlashWrite() {
req.address = bytesWritten;
req.length = remainingBytes;
bytesWritten += remainingBytes;
arc_pack_write_action_req(&req, commandBuffer, &size);
result = sendAndRead(size, req.address, &replyFrame, replySize);
arc_pack_write_action_req(&req, cmdBuf.data(), &size);
result = sendAndRead(size, req.address);
if (result != returnvalue::OK) {
return result;
}
result = checkActionReply(replyFrame, replySize);
result = checkActionReply(replyLen);
if (result != returnvalue::OK) {
return result;
}
@ -431,8 +480,6 @@ ReturnValue_t StrComHandler::performFlashRead() {
uint32_t bytesRead = 0;
uint32_t size = 0;
uint32_t retries = 0;
const uint8_t* replyFrame;
size_t replySize = 0;
Timestamp timestamp;
std::string fullname =
Filenaming::generateAbsoluteFilename(flashRead.path, flashRead.filename, timestamping);
@ -451,28 +498,28 @@ ReturnValue_t StrComHandler::performFlashRead() {
} else {
req.length = CHUNK_SIZE;
}
arc_pack_read_action_req(&req, commandBuffer, &size);
result = sendAndRead(size, req.address, &replyFrame, replySize);
arc_pack_read_action_req(&req, cmdBuf.data(), &size);
result = sendAndRead(size, req.address);
if (result != returnvalue::OK) {
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
uart::flushRxBuf(serialPort);
serial::flushRxBuf(serialPort);
retries++;
continue;
}
file.close();
return result;
}
result = checkActionReply(replyFrame, replySize);
result = checkActionReply(replyLen);
if (result != returnvalue::OK) {
if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
uart::flushRxBuf(serialPort);
serial::flushRxBuf(serialPort);
retries++;
continue;
}
file.close();
return result;
}
file.write(reinterpret_cast<const char*>(replyFrame + FLASH_READ_DATA_OFFSET), req.length);
file.write(reinterpret_cast<const char*>(replyPtr + FLASH_READ_DATA_OFFSET), req.length);
bytesRead += req.length;
req.address += req.length;
if (req.address >= FLASH_REGION_SIZE) {
@ -488,51 +535,29 @@ ReturnValue_t StrComHandler::performFlashRead() {
return returnvalue::OK;
}
ReturnValue_t StrComHandler::sendAndRead(size_t size, uint32_t failParameter,
const uint8_t** replyFrame, size_t& replyLen) {
ReturnValue_t StrComHandler::sendAndRead(size_t size, uint32_t failParameter) {
ReturnValue_t result = returnvalue::OK;
uint8_t nextDelayMs = 1;
ReturnValue_t decResult = returnvalue::OK;
const uint8_t* sendData;
size_t txFrameLen = 0;
datalinkLayer.encodeFrame(commandBuffer, size, &sendData, txFrameLen);
datalinkLayer.encodeFrame(cmdBuf.data(), 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;
}
replyTimeout.resetTimer();
while (true) {
handleSerialReception();
result = datalinkLayer.checkRingBufForFrame(replyFrame, replyLen);
if (result == returnvalue::OK) {
return returnvalue::OK;
}
if (replyTimeout.hasTimedOut()) {
triggerEvent(STR_HELPER_REPLY_TIMEOUT, failParameter, replyTimeout.getTimeoutMs());
return returnvalue::FAILED;
}
TaskFactory::delayTask(nextDelayMs);
if (nextDelayMs < 32) {
nextDelayMs *= 2;
}
}
if (decResult != returnvalue::OK) {
triggerEvent(STR_HELPER_DEC_ERROR, decResult, failParameter);
return returnvalue::FAILED;
}
return returnvalue::OK;
return readOneReply(failParameter);
}
ReturnValue_t StrComHandler::checkActionReply(const uint8_t* rawFrame, size_t replySize) {
uint8_t type = str::getReplyFrameType(rawFrame);
ReturnValue_t StrComHandler::checkActionReply(size_t replySize) {
uint8_t type = str::getReplyFrameType(replyPtr);
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);
uint8_t status = str::getStatusField(replyPtr);
if (status != ArcsecDatalinkLayer::STATUS_OK) {
sif::warning << "StrHelper::checkActionReply: Status failure: "
<< static_cast<unsigned int>(status) << std::endl;
@ -541,10 +566,9 @@ ReturnValue_t StrComHandler::checkActionReply(const uint8_t* rawFrame, size_t re
return returnvalue::OK;
}
ReturnValue_t StrComHandler::checkReplyPosition(const uint8_t* rawFrame,
uint32_t expectedPosition) {
ReturnValue_t StrComHandler::checkReplyPosition(uint32_t expectedPosition) {
uint32_t receivedPosition = 0;
std::memcpy(&receivedPosition, rawFrame + POS_OFFSET, sizeof(receivedPosition));
std::memcpy(&receivedPosition, replyPtr + POS_OFFSET, sizeof(receivedPosition));
if (receivedPosition != expectedPosition) {
triggerEvent(POSITION_MISMATCH, receivedPosition);
return returnvalue::FAILED;
@ -589,11 +613,11 @@ ReturnValue_t StrComHandler::initializeInterface(CookieIF* cookie) {
}
// Setting up UART parameters
tty.c_cflag &= ~PARENB; // Clear parity bit
uart::setStopbits(tty, serCookie->getStopBits());
uart::setBitsPerWord(tty, BitsPerWord::BITS_8);
serial::setStopbits(tty, serCookie->getStopBits());
serial::setBitsPerWord(tty, BitsPerWord::BITS_8);
tty.c_cflag &= ~CRTSCTS; // Disable RTS/CTS hardware flow control
uart::enableRead(tty);
uart::ignoreCtrlLines(tty);
serial::enableRead(tty);
serial::ignoreCtrlLines(tty);
// Use non-canonical mode and clear echo flag
tty.c_lflag &= ~(ICANON | ECHO);
@ -602,7 +626,7 @@ ReturnValue_t StrComHandler::initializeInterface(CookieIF* cookie) {
tty.c_cc[VTIME] = 0;
tty.c_cc[VMIN] = 0;
uart::setBaudrate(tty, serCookie->getBaudrate());
serial::setBaudrate(tty, serCookie->getBaudrate());
if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
sif::warning << "ScexUartReader::initializeInterface: tcsetattr call failed with error ["
<< errno << ", " << strerror(errno) << std::endl;
@ -614,6 +638,14 @@ ReturnValue_t StrComHandler::initializeInterface(CookieIF* cookie) {
ReturnValue_t StrComHandler::sendMessage(CookieIF* cookie, const uint8_t* sendData,
size_t sendLen) {
{
MutexGuard mg(lock);
if (state != InternalState::SLEEPING) {
return BUSY;
}
}
serial::flushRxBuf(serialPort);
const uint8_t* txFrame;
size_t frameLen;
datalinkLayer.encodeFrame(sendData, sendLen, &txFrame, frameLen);
@ -623,6 +655,20 @@ ReturnValue_t StrComHandler::sendMessage(CookieIF* cookie, const uint8_t* sendDa
<< std::endl;
return returnvalue::FAILED;
}
// Hacky, but the alternatives look bleak. The raw data contains the information we need
// and there are not too many special cases.
if (sendData[0] == TMTC_ACTIONREQ) {
// 1 is a firmware boot request and 7 is a reboot request. For both, no reply is expected.
if (sendData[1] == 7 or sendData[1] == 1) {
return returnvalue::OK;
}
}
{
MutexGuard mg(lock);
state = InternalState::POLL_ONE_REPLY;
}
// Unlock task to perform reply reading.
semaphore.release();
return returnvalue::OK;
}
@ -633,13 +679,29 @@ ReturnValue_t StrComHandler::requestReceiveMessage(CookieIF* cookie, size_t requ
}
ReturnValue_t StrComHandler::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
return returnvalue::OK;
// Consider it a configuration error if the task is not done with a command -> reply cycle
// in time.
bool replyWasReceived = false;
{
MutexGuard mg(lock);
if (state != InternalState::SLEEPING) {
return BUSY;
}
replyWasReceived = this->replyWasReceived;
}
if (not replyWasReceived) {
*size = 0;
return returnvalue::OK;
}
if (replyResult == returnvalue::OK) {
*buffer = const_cast<uint8_t*>(replyPtr);
*size = replyLen;
}
return replyResult;
}
ReturnValue_t StrComHandler::unlockAndEraseRegions(uint32_t from, uint32_t to) {
ReturnValue_t result = returnvalue::OK;
const uint8_t* replyFrame;
size_t replySize = 0;
#if OBSW_DEBUG_STARTRACKER == 1
ProgressPrinter progressPrinter("Unlock and erase", to - from);
#endif /* OBSW_DEBUG_STARTRACKER == 1 */
@ -649,17 +711,20 @@ ReturnValue_t StrComHandler::unlockAndEraseRegions(uint32_t from, uint32_t to) {
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(size, unlockReq.region, &replyFrame, replySize);
result = checkActionReply(replyFrame, replySize);
arc_pack_unlock_action_req(&unlockReq, cmdBuf.data(), &size);
result = sendAndRead(size, unlockReq.region);
if (result != returnvalue::OK) {
return result;
}
result = checkActionReply(replyLen);
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(size, eraseReq.region, &replyFrame, replySize);
arc_pack_erase_action_req(&eraseReq, cmdBuf.data(), &size);
result = sendAndRead(size, eraseReq.region);
if (result != returnvalue::OK) {
sif::warning << "StrHelper::unlockAndEraseRegions: Failed to erase region with id "
<< static_cast<unsigned int>(eraseReq.region) << std::endl;
@ -686,9 +751,33 @@ ReturnValue_t StrComHandler::handleSerialReception() {
<< " bytes" << std::endl;
return FAILED;
} else if (bytesRead > 0) {
// sif::info << "Received " << bytesRead << " bytes from the PLOC Supervisor:" << std::endl;
// sif::info << "Received " << bytesRead << " bytes from the STR" << std::endl;
// arrayprinter::print(recBuf.data(), bytesRead);
datalinkLayer.feedData(recBuf.data(), bytesRead);
}
return OK;
}
ReturnValue_t StrComHandler::readOneReply(uint32_t failParameter) {
ReturnValue_t result;
uint32_t nextDelayMs = 1;
replyTimeout.resetTimer();
while (true) {
handleSerialReception();
result = datalinkLayer.checkRingBufForFrame(&replyPtr, replyLen);
if (result == returnvalue::OK) {
return returnvalue::OK;
} else if (result != ArcsecDatalinkLayer::DEC_IN_PROGRESS) {
triggerEvent(STR_HELPER_DEC_ERROR, result, failParameter);
return DECODING_ERROR;
}
if (replyTimeout.hasTimedOut()) {
triggerEvent(STR_COM_REPLY_TIMEOUT, failParameter, replyTimeout.getTimeoutMs());
return RECEPTION_TIMEOUT;
}
TaskFactory::delayTask(nextDelayMs);
if (nextDelayMs < 32) {
nextDelayMs *= 2;
}
}
}

66
linux/devices/startracker/StrComHandler.h
View File

@ -28,24 +28,27 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
public:
static const uint8_t INTERFACE_ID = CLASS_ID::STR_HELPER;
static const ReturnValue_t BUSY = MAKE_RETURN_CODE(0);
//! [EXPORT] : [COMMENT] SD card specified in path string not mounted
static const ReturnValue_t SD_NOT_MOUNTED = MAKE_RETURN_CODE(0);
static const ReturnValue_t SD_NOT_MOUNTED = MAKE_RETURN_CODE(1);
//! [EXPORT] : [COMMENT] Specified file does not exist on filesystem
static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(1);
static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(2);
//! [EXPORT] : [COMMENT] Specified path does not exist
static const ReturnValue_t PATH_NOT_EXISTS = MAKE_RETURN_CODE(2);
static const ReturnValue_t PATH_NOT_EXISTS = MAKE_RETURN_CODE(3);
//! [EXPORT] : [COMMENT] Failed to create download image or read flash file
static const ReturnValue_t FILE_CREATION_FAILED = MAKE_RETURN_CODE(3);
static const ReturnValue_t FILE_CREATION_FAILED = MAKE_RETURN_CODE(4);
//! [EXPORT] : [COMMENT] Region in flash write/read reply does not match expected region
static const ReturnValue_t REGION_MISMATCH = MAKE_RETURN_CODE(4);
static const ReturnValue_t REGION_MISMATCH = MAKE_RETURN_CODE(5);
//! [EXPORT] : [COMMENT] Address in flash write/read reply does not match expected address
static const ReturnValue_t ADDRESS_MISMATCH = MAKE_RETURN_CODE(5);
static const ReturnValue_t ADDRESS_MISMATCH = MAKE_RETURN_CODE(6);
//! [EXPORT] : [COMMENT] Length in flash write/read reply does not match expected length
static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(6);
static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(7);
//! [EXPORT] : [COMMENT] Status field in reply signals error
static const ReturnValue_t STATUS_ERROR = MAKE_RETURN_CODE(7);
static const ReturnValue_t STATUS_ERROR = MAKE_RETURN_CODE(8);
//! [EXPORT] : [COMMENT] Reply has invalid type ID (should be of action reply type)
static const ReturnValue_t INVALID_TYPE_ID = MAKE_RETURN_CODE(8);
static const ReturnValue_t INVALID_TYPE_ID = MAKE_RETURN_CODE(9);
static const ReturnValue_t RECEPTION_TIMEOUT = MAKE_RETURN_CODE(10);
static const ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(11);
static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::STR_HELPER;
@ -77,7 +80,7 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
static const Event STR_HELPER_COM_ERROR = MAKE_EVENT(10, severity::LOW);
//! [EXPORT] : [COMMENT] Star tracker did not send a valid reply for a certain timeout.
//! P1: Position of upload or download packet for which the packet wa sent. P2: Timeout
static const Event STR_HELPER_REPLY_TIMEOUT = MAKE_EVENT(11, severity::LOW);
static const Event STR_COM_REPLY_TIMEOUT = MAKE_EVENT(11, 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
@ -186,15 +189,23 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
static const size_t CONFIG_MAX_DOWNLOAD_RETRIES = 3;
static const uint32_t FLASH_ERASE_DELAY = 500;
enum class InternalState { IDLE, UPLOAD_IMAGE, DOWNLOAD_IMAGE, FLASH_READ, FIRMWARE_UPDATE };
enum class InternalState {
SLEEPING,
POLL_ONE_REPLY,
UPLOAD_IMAGE,
DOWNLOAD_IMAGE,
FLASH_READ,
FIRMWARE_UPDATE
};
InternalState internalState = InternalState::IDLE;
InternalState state = InternalState::SLEEPING;
ArcsecDatalinkLayer datalinkLayer;
MutexIF *lock;
BinarySemaphore semaphore;
Countdown replyTimeout = Countdown(2000);
Countdown replyTimeout = Countdown(20);
struct UploadImage {
// Name including absolute path of image to upload
@ -239,9 +250,14 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
SdCardManager *sdcMan = nullptr;
#endif
uint8_t commandBuffer[startracker::MAX_FRAME_SIZE];
std::array<uint8_t, startracker::MAX_FRAME_SIZE> cmdBuf{};
std::array<uint8_t, 4096> recBuf{};
bool replyWasReceived = false;
const uint8_t *replyPtr = nullptr;
size_t replyLen = 0;
ReturnValue_t replyResult = returnvalue::OK;
bool terminate = false;
#ifdef EGSE
@ -304,22 +320,23 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
/**
* @brief Sends packet to the star tracker and reads reply by using the communication
* interface
*
* @details
* The reply frame is stored in the data link layer helper. A pointer to the start of the frame
* is assigned to the @replyPtr member of this class. The frame length will be assigned to
* the @replyLen member.
* @param size Size of data beforehand written to the commandBuffer
* @param parameter Parameter 2 of trigger event function
* @param delayMs Delay in milliseconds between send and receive call
*
* @return returnvalue::OK if successful, otherwise returnvalue::FAILED
*/
ReturnValue_t sendAndRead(size_t size, uint32_t parameter, const uint8_t **replyFrame,
size_t &replyLen);
ReturnValue_t sendAndRead(size_t size, uint32_t parameter);
/**
* @brief Checks the header (type id and status fields) of the action reply
*
* @return returnvalue::OK if reply confirms success of packet transfer, otherwise REUTRN_FAILED
*/
ReturnValue_t checkActionReply(const uint8_t *rawFrame, size_t replySize);
ReturnValue_t checkActionReply(size_t replySize);
/**
* @brief Checks the position field in a star tracker upload/download reply.
@ -329,7 +346,7 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
* @return returnvalue::OK if received position matches expected position, otherwise
* returnvalue::FAILED
*/
ReturnValue_t checkReplyPosition(const uint8_t *rawFrame, uint32_t expectedPosition);
ReturnValue_t checkReplyPosition(uint32_t expectedPosition);
#ifdef XIPHOS_Q7S
/**
@ -348,6 +365,15 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
*
*/
ReturnValue_t unlockAndEraseRegions(uint32_t from, uint32_t to);
/**
* The reply frame is stored in the data link layer helper. A pointer to the start of the frame
* is assigned to the @replyPtr member of this class. The frame length will be assigned to
* the @replyLen member.
* @param failParameter
* @return
*/
ReturnValue_t readOneReply(uint32_t failParameter);
};
#endif /* BSP_Q7S_DEVICES_STRHELPER_H_ */

0
linux/devices/startracker/ArcsecJsonKeys.h → linux/devices/startracker/arcsecJsonKeys.h
View File

4
linux/devices/startracker/StarTrackerJsonCommands.cpp → linux/devices/startracker/strJsonCommands.cpp
View File

@ -1,6 +1,6 @@
#include "StarTrackerJsonCommands.h"
#include "strJsonCommands.h"
#include "ArcsecJsonKeys.h"
#include "arcsecJsonKeys.h"
Limits::Limits() : ArcsecJsonParamBase(arcseckeys::LIMITS) {}

0
linux/devices/startracker/StarTrackerJsonCommands.h → linux/devices/startracker/strJsonCommands.h
View File

16
linux/fsfwconfig/events/translateEvents.cpp
View File

@ -1,7 +1,7 @@
/**
* @brief Auto-generated event translation file. Contains 279 translations.
* @details
* Generated on: 2023-03-21 23:59:36
* Generated on: 2023-03-22 01:14:08
*/
#include "translateEvents.h"
@ -172,7 +172,7 @@ const char *FIRMWARE_UPDATE_SUCCESSFUL_STRING = "FIRMWARE_UPDATE_SUCCESSFUL";
const char *FIRMWARE_UPDATE_FAILED_STRING = "FIRMWARE_UPDATE_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 *STR_HELPER_REPLY_TIMEOUT_STRING = "STR_HELPER_REPLY_TIMEOUT";
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";
@ -617,16 +617,16 @@ const char *translateEvents(Event event) {
case (12510):
return STR_HELPER_COM_ERROR_STRING;
case (12511):
return STR_HELPER_NO_REPLY_STRING;
case (12512):
return STR_HELPER_DEC_ERROR_STRING;
return STR_HELPER_REPLY_TIMEOUT_STRING;
case (12513):
return POSITION_MISMATCH_STRING;
return STR_HELPER_DEC_ERROR_STRING;
case (12514):
return STR_HELPER_FILE_NOT_EXISTS_STRING;
return POSITION_MISMATCH_STRING;
case (12515):
return STR_HELPER_SENDING_PACKET_FAILED_STRING;
return STR_HELPER_FILE_NOT_EXISTS_STRING;
case (12516):
return STR_HELPER_SENDING_PACKET_FAILED_STRING;
case (12517):
return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
case (12600):
return MPSOC_FLASH_WRITE_FAILED_STRING;

6
linux/fsfwconfig/objects/translateObjects.cpp
View File

@ -2,7 +2,7 @@
* @brief Auto-generated object translation file.
* @details
* Contains 173 translations.
* Generated on: 2023-03-21 23:59:36
* Generated on: 2023-03-22 01:14:08
*/
#include "translateObjects.h"
@ -49,7 +49,7 @@ const char *PLPCDU_HANDLER_STRING = "PLPCDU_HANDLER";
const char *RAD_SENSOR_STRING = "RAD_SENSOR";
const char *PLOC_UPDATER_STRING = "PLOC_UPDATER";
const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER";
const char *STR_HELPER_STRING = "STR_HELPER";
const char *STR_COM_IF_STRING = "STR_COM_IF";
const char *PLOC_MPSOC_HELPER_STRING = "PLOC_MPSOC_HELPER";
const char *AXI_PTME_CONFIG_STRING = "AXI_PTME_CONFIG";
const char *PTME_CONFIG_STRING = "PTME_CONFIG";
@ -269,7 +269,7 @@ const char *translateObject(object_id_t object) {
case 0x44330001:
return PLOC_MEMORY_DUMPER_STRING;
case 0x44330002:
return STR_HELPER_STRING;
return STR_COM_IF_STRING;
case 0x44330003:
return PLOC_MPSOC_HELPER_STRING;
case 0x44330004: