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

some more bugfixes
Some checks failed
EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit
Details

Browse Source
This commit is contained in:
Robin Müller 2023-02-20 19:35:36 +01:00
parent ea6b13d189
commit 56cdd1173e
No known key found for this signature in database
GPG Key ID: 11D4952C8CCEF814
8 changed files with 114 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
common/config/eive/definitions.h
View File

@ -62,7 +62,7 @@ static constexpr uint32_t SCHED_BLOCK_2_SENSOR_READ_MS = 30;
static constexpr uint32_t SCHED_BLOCK_3_READ_IMTQ_MGM_MS = 42; static constexpr uint32_t SCHED_BLOCK_3_READ_IMTQ_MGM_MS = 42;
static constexpr uint32_t SCHED_BLOCK_4_ACS_CTRL_MS = 45; static constexpr uint32_t SCHED_BLOCK_4_ACS_CTRL_MS = 45;
static constexpr uint32_t SCHED_BLOCK_5_ACTUATOR_MS = 50; static constexpr uint32_t SCHED_BLOCK_5_ACTUATOR_MS = 50;
static constexpr uint32_t SCHED_BLOCK_6_IMTQ_BLOCK_2_MS = 65; static constexpr uint32_t SCHED_BLOCK_6_IMTQ_BLOCK_2_MS = 75;
static constexpr uint32_t SCHED_BLOCK_7_RW_READ_MS = 300; static constexpr uint32_t SCHED_BLOCK_7_RW_READ_MS = 300;
// 15 ms for FM // 15 ms for FM

7
linux/devices/ImtqPollingTask.cpp
View File

@ -27,7 +27,7 @@ ReturnValue_t ImtqPollingTask::performOperation(uint8_t operationCode) {
comStatus = returnvalue::OK; comStatus = returnvalue::OK;
// Stopwatch watch; // Stopwatch watch;
switch (currentRequest) { switch (currentRequest) {
case imtq::RequestType::MEASURE_WITH_ACTUATION: { case imtq::RequestType::MEASURE_NO_ACTUATION: {
handleMeasureStep(); handleMeasureStep();
break; break;
} }
@ -45,7 +45,7 @@ void ImtqPollingTask::handleMeasureStep() {
uint8_t* replyPtr; uint8_t* replyPtr;
ImtqRepliesDefault replies(replyBuf.data()); ImtqRepliesDefault replies(replyBuf.data());
// Can be used later to verify correct timing (e.g. all data has been read) // Can be used later to verify correct timing (e.g. all data has been read)
clearReadFlagsDefault(replies); // clearReadFlagsDefault(replies);
auto i2cCmdExecMeasure = [&](imtq::CC::CC cc) { auto i2cCmdExecMeasure = [&](imtq::CC::CC cc) {
ccToReplyPtrMeasure(replies, cc, &replyPtr, replyLen); ccToReplyPtrMeasure(replies, cc, &replyPtr, replyLen);
return i2cCmdExecDefault(cc, replyPtr, replyLen, imtq::MGM_MEASUREMENT_LOW_LEVEL_ERROR); return i2cCmdExecDefault(cc, replyPtr, replyLen, imtq::MGM_MEASUREMENT_LOW_LEVEL_ERROR);
@ -134,6 +134,7 @@ void ImtqPollingTask::handleMeasureStep() {
if (i2cCmdExecMeasure(imtq::CC::GET_CAL_MTM_MEASUREMENT) != returnvalue::OK) { if (i2cCmdExecMeasure(imtq::CC::GET_CAL_MTM_MEASUREMENT) != returnvalue::OK) {
return; return;
} }
sif::debug << "measure done" << std::endl;
return; return;
} }
@ -320,7 +321,7 @@ ReturnValue_t ImtqPollingTask::readReceivedMessage(CookieIF* cookie, uint8_t** b
size_t replyLen = 0; size_t replyLen = 0;
MutexGuard mg(bufLock); MutexGuard mg(bufLock);
if (currentRequest == imtq::RequestType::MEASURE_WITH_ACTUATION) { if (currentRequest == imtq::RequestType::MEASURE_NO_ACTUATION) {
replyLen = getExchangeBufLen(specialRequest); replyLen = getExchangeBufLen(specialRequest);
memcpy(exchangeBuf.data(), replyBuf.data(), replyLen); memcpy(exchangeBuf.data(), replyBuf.data(), replyLen);
} else { } else {

2
linux/devices/ImtqPollingTask.h
View File

@ -22,7 +22,7 @@ class ImtqPollingTask : public SystemObject,
static constexpr ReturnValue_t NO_REPLY_AVAILABLE = returnvalue::makeCode(2, 0); static constexpr ReturnValue_t NO_REPLY_AVAILABLE = returnvalue::makeCode(2, 0);
enum class InternalState { IDLE, BUSY } state = InternalState::IDLE; enum class InternalState { IDLE, BUSY } state = InternalState::IDLE;
imtq::RequestType currentRequest = imtq::RequestType::MEASURE_WITH_ACTUATION; imtq::RequestType currentRequest = imtq::RequestType::MEASURE_NO_ACTUATION;
SemaphoreIF* semaphore; SemaphoreIF* semaphore;
ReturnValue_t comStatus = returnvalue::OK; ReturnValue_t comStatus = returnvalue::OK;

21
linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp
View File

@ -4,6 +4,7 @@
#include <fsfw/objectmanager/ObjectManagerIF.h> #include <fsfw/objectmanager/ObjectManagerIF.h>
#include <fsfw/serviceinterface/ServiceInterfaceStream.h> #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
#include <fsfw/tasks/FixedTimeslotTaskIF.h> #include <fsfw/tasks/FixedTimeslotTaskIF.h>
#include <mission/devices/devicedefinitions/imtqHelpers.h>
#include "OBSWConfig.h" #include "OBSWConfig.h"
#include "eive/definitions.h" #include "eive/definitions.h"
@ -585,15 +586,15 @@ ReturnValue_t pst::pstTcsAndAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg
if (cfg.scheduleImtq) { if (cfg.scheduleImtq) {
// This is the MTM measurement cycle // This is the MTM measurement cycle
thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD, thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
DeviceHandlerIF::PERFORM_OPERATION); imtq::ComStep::DHB_OP);
thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD, thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
DeviceHandlerIF::SEND_WRITE); imtq::ComStep::START_MEASURE_SEND);
thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD, thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
DeviceHandlerIF::GET_WRITE); imtq::ComStep::START_MEASURE_GET);
thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_3_PERIOD, thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_3_PERIOD,
DeviceHandlerIF::SEND_READ); imtq::ComStep::READ_MEASURE_SEND);
thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_3_PERIOD, thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_3_PERIOD,
DeviceHandlerIF::GET_READ); imtq::ComStep::READ_MEASURE_GET);
} }
thisSequence->addSlot(objects::ACS_CONTROLLER, length * config::acs::SCHED_BLOCK_4_PERIOD, 0); thisSequence->addSlot(objects::ACS_CONTROLLER, length * config::acs::SCHED_BLOCK_4_PERIOD, 0);
@ -601,15 +602,13 @@ ReturnValue_t pst::pstTcsAndAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg
if (cfg.scheduleImtq) { if (cfg.scheduleImtq) {
// This is the torquing cycle. // This is the torquing cycle.
thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_5_PERIOD, thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_5_PERIOD,
DeviceHandlerIF::PERFORM_OPERATION); imtq::ComStep::START_ACTUATE_SEND);
thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_5_PERIOD, thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_5_PERIOD,
DeviceHandlerIF::SEND_WRITE); imtq::ComStep::START_ACTUATE_GET);
thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_5_PERIOD,
DeviceHandlerIF::GET_WRITE);
thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_6_PERIOD, thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_6_PERIOD,
DeviceHandlerIF::SEND_READ); imtq::ComStep::READ_ACTUATE_SEND);
thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_6_PERIOD, thisSequence->addSlot(objects::IMTQ_HANDLER, length * config::acs::SCHED_BLOCK_6_PERIOD,
DeviceHandlerIF::GET_READ); imtq::ComStep::READ_ACTUATE_GET);
} }
if (cfg.scheduleRws) { if (cfg.scheduleRws) {

82
mission/devices/ImtqHandler.cpp
View File

@ -51,6 +51,60 @@ ImtqHandler::ImtqHandler(object_id_t objectId, object_id_t comIF, CookieIF* comC
} }
} }
ReturnValue_t ImtqHandler::performOperation(uint8_t opCode) {
uint8_t dhbOpCode = DeviceHandlerIF::PERFORM_OPERATION;
switch (static_cast<imtq::ComStep>(opCode)) {
case (imtq::ComStep::DHB_OP): {
break;
}
case (imtq::ComStep::START_MEASURE_SEND): {
requestStep = imtq::RequestType::MEASURE_NO_ACTUATION;
dhbOpCode = DeviceHandlerIF::SEND_WRITE;
break;
}
case (imtq::ComStep::START_MEASURE_GET): {
requestStep = imtq::RequestType::MEASURE_NO_ACTUATION;
dhbOpCode = DeviceHandlerIF::GET_WRITE;
break;
}
case (imtq::ComStep::READ_MEASURE_SEND): {
requestStep = imtq::RequestType::MEASURE_NO_ACTUATION;
dhbOpCode = DeviceHandlerIF::SEND_READ;
break;
}
case (imtq::ComStep::READ_MEASURE_GET): {
requestStep = imtq::RequestType::MEASURE_NO_ACTUATION;
dhbOpCode = DeviceHandlerIF::GET_READ;
break;
}
case (imtq::ComStep::START_ACTUATE_SEND): {
requestStep = imtq::RequestType::ACTUATE;
dhbOpCode = DeviceHandlerIF::SEND_WRITE;
break;
}
case (imtq::ComStep::START_ACTUATE_GET): {
requestStep = imtq::RequestType::ACTUATE;
dhbOpCode = DeviceHandlerIF::GET_WRITE;
break;
}
case (imtq::ComStep::READ_ACTUATE_SEND): {
requestStep = imtq::RequestType::ACTUATE;
dhbOpCode = DeviceHandlerIF::SEND_READ;
break;
}
case (imtq::ComStep::READ_ACTUATE_GET): {
requestStep = imtq::RequestType::ACTUATE;
dhbOpCode = DeviceHandlerIF::GET_READ;
break;
}
default: {
sif::error << "ImtqHandler: Unexpected COM step" << std::endl;
break;
}
}
return DeviceHandlerBase::performOperation(dhbOpCode);
}
ImtqHandler::~ImtqHandler() = default; ImtqHandler::~ImtqHandler() = default;
void ImtqHandler::doStartUp() { void ImtqHandler::doStartUp() {
@ -71,7 +125,7 @@ void ImtqHandler::doShutDown() {
ReturnValue_t ImtqHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) { ReturnValue_t ImtqHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
switch (requestStep) { switch (requestStep) {
case (imtq::RequestType::MEASURE_WITH_ACTUATION): { case (imtq::RequestType::MEASURE_NO_ACTUATION): {
*id = imtq::cmdIds::REQUEST; *id = imtq::cmdIds::REQUEST;
return buildCommandFromCommand(*id, nullptr, 0); return buildCommandFromCommand(*id, nullptr, 0);
} }
@ -90,7 +144,7 @@ ReturnValue_t ImtqHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
ReturnValue_t ImtqHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand, ReturnValue_t ImtqHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
const uint8_t* commandData, const uint8_t* commandData,
size_t commandDataLen) { size_t commandDataLen) {
auto genericMeasureRequest = [&](imtq::SpecialRequest specialRequest) { auto genericSpecialRequest = [&](imtq::SpecialRequest specialRequest, ) {
ImtqRequest request(commandBuffer, sizeof(commandBuffer)); ImtqRequest request(commandBuffer, sizeof(commandBuffer));
request.setMeasureRequest(specialRequest); request.setMeasureRequest(specialRequest);
specialRequestActive = true; specialRequestActive = true;
@ -99,35 +153,38 @@ ReturnValue_t ImtqHandler::buildCommandFromCommand(DeviceCommandId_t deviceComma
}; };
switch (deviceCommand) { switch (deviceCommand) {
case (imtq::cmdIds::POS_X_SELF_TEST): { case (imtq::cmdIds::POS_X_SELF_TEST): {
genericMeasureRequest(imtq::SpecialRequest::DO_SELF_TEST_POS_X); genericSpecialRequest(imtq::SpecialRequest::DO_SELF_TEST_POS_X);
return returnvalue::OK; return returnvalue::OK;
} }
case (imtq::cmdIds::NEG_X_SELF_TEST): { case (imtq::cmdIds::NEG_X_SELF_TEST): {
genericMeasureRequest(imtq::SpecialRequest::DO_SELF_TEST_NEG_X); genericSpecialRequest(imtq::SpecialRequest::DO_SELF_TEST_NEG_X);
return returnvalue::OK; return returnvalue::OK;
} }
case (imtq::cmdIds::POS_Y_SELF_TEST): { case (imtq::cmdIds::POS_Y_SELF_TEST): {
genericMeasureRequest(imtq::SpecialRequest::DO_SELF_TEST_POS_Y); genericSpecialRequest(imtq::SpecialRequest::DO_SELF_TEST_POS_Y);
return returnvalue::OK; return returnvalue::OK;
} }
case (imtq::cmdIds::NEG_Y_SELF_TEST): { case (imtq::cmdIds::NEG_Y_SELF_TEST): {
genericMeasureRequest(imtq::SpecialRequest::DO_SELF_TEST_NEG_Y); genericSpecialRequest(imtq::SpecialRequest::DO_SELF_TEST_NEG_Y);
return returnvalue::OK; return returnvalue::OK;
} }
case (imtq::cmdIds::POS_Z_SELF_TEST): { case (imtq::cmdIds::POS_Z_SELF_TEST): {
genericMeasureRequest(imtq::SpecialRequest::DO_SELF_TEST_POS_Z); genericSpecialRequest(imtq::SpecialRequest::DO_SELF_TEST_POS_Z);
return returnvalue::OK; return returnvalue::OK;
} }
case (imtq::cmdIds::NEG_Z_SELF_TEST): { case (imtq::cmdIds::NEG_Z_SELF_TEST): {
genericMeasureRequest(imtq::SpecialRequest::DO_SELF_TEST_NEG_Z); genericSpecialRequest(imtq::SpecialRequest::DO_SELF_TEST_NEG_Z);
return returnvalue::OK; return returnvalue::OK;
} }
case (imtq::cmdIds::GET_SELF_TEST_RESULT): { case (imtq::cmdIds::GET_SELF_TEST_RESULT): {
genericMeasureRequest(imtq::SpecialRequest::GET_SELF_TEST_RESULT); genericSpecialRequest(imtq::SpecialRequest::GET_SELF_TEST_RESULT);
return returnvalue::OK; return returnvalue::OK;
} }
case (imtq::cmdIds::REQUEST): { case (imtq::cmdIds::REQUEST): {
genericMeasureRequest(imtq::SpecialRequest::NONE); ImtqRequest request(commandBuffer, sizeof(commandBuffer));
request.setMeasureRequest(imtq::SpecialRequest::NONE);
rawPacket = commandBuffer;
rawPacketLen = ImtqRequest::REQUEST_LEN;
return returnvalue::OK; return returnvalue::OK;
} }
case (imtq::cmdIds::START_ACTUATION_DIPOLE): { case (imtq::cmdIds::START_ACTUATION_DIPOLE): {
@ -200,8 +257,9 @@ ReturnValue_t ImtqHandler::interpretDeviceReply(DeviceCommandId_t id, const uint
ReturnValue_t result; ReturnValue_t result;
ReturnValue_t status = returnvalue::OK; ReturnValue_t status = returnvalue::OK;
// arrayprinter::print(packet, ImtqReplies::BASE_LEN); // arrayprinter::print(packet, ImtqReplies::BASE_LEN);
if (requestStep == imtq::RequestType::MEASURE_WITH_ACTUATION) { if (requestStep == imtq::RequestType::MEASURE_NO_ACTUATION) {
requestStep = imtq::RequestType::ACTUATE; requestStep = imtq::RequestType::ACTUATE;
sif::debug << "handle measure" << std::endl;
ImtqRepliesDefault replies(packet); ImtqRepliesDefault replies(packet);
if (specialRequestActive) { if (specialRequestActive) {
if (replies.wasSpecialRequestRead()) { if (replies.wasSpecialRequestRead()) {
@ -266,7 +324,7 @@ ReturnValue_t ImtqHandler::interpretDeviceReply(DeviceCommandId_t id, const uint
status = result; status = result;
} }
} else { } else {
requestStep = imtq::RequestType::MEASURE_WITH_ACTUATION; requestStep = imtq::RequestType::MEASURE_NO_ACTUATION;
ImtqRepliesWithTorque replies(packet); ImtqRepliesWithTorque replies(packet);
if (replies.wasDipoleActuationRead()) { if (replies.wasDipoleActuationRead()) {
parseStatusByte(imtq::CC::START_ACTUATION_DIPOLE, replies.getDipoleActuation()); parseStatusByte(imtq::CC::START_ACTUATION_DIPOLE, replies.getDipoleActuation());

3
mission/devices/ImtqHandler.h
View File

@ -31,6 +31,7 @@ class ImtqHandler : public DeviceHandlerBase {
void setDebugMode(bool enable); void setDebugMode(bool enable);
protected: protected:
ReturnValue_t performOperation(uint8_t opCode);
void doStartUp() override; void doStartUp() override;
void doShutDown() override; void doShutDown() override;
ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override; ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
@ -118,7 +119,7 @@ class ImtqHandler : public DeviceHandlerBase {
bool specialRequestActive = false; bool specialRequestActive = false;
bool firstReplyCycle = true; bool firstReplyCycle = true;
imtq::RequestType requestStep = imtq::RequestType::MEASURE_WITH_ACTUATION; imtq::RequestType requestStep = imtq::RequestType::MEASURE_NO_ACTUATION;
/** /**
* @brief In case of a status reply to a single axis self test command, this function * @brief In case of a status reply to a single axis self test command, this function

18
mission/devices/devicedefinitions/imtqHelpers.h
View File

@ -10,7 +10,19 @@ class ImtqHandler;
namespace imtq { namespace imtq {
enum class RequestType : uint8_t { MEASURE_WITH_ACTUATION, ACTUATE }; enum ComStep : uint8_t {
DHB_OP = 0,
START_MEASURE_SEND = 1,
START_MEASURE_GET = 2,
READ_MEASURE_SEND = 3,
READ_MEASURE_GET = 4,
START_ACTUATE_SEND = 5,
START_ACTUATE_GET = 6,
READ_ACTUATE_SEND = 7,
READ_ACTUATE_GET = 8,
};
enum class RequestType : uint8_t { MEASURE_NO_ACTUATION, ACTUATE };
enum class SpecialRequest : uint8_t { enum class SpecialRequest : uint8_t {
NONE = 0, NONE = 0,
@ -1098,7 +1110,7 @@ struct ImtqRequest {
imtq::RequestType getRequestType() const { return static_cast<imtq::RequestType>(rawData[0]); } imtq::RequestType getRequestType() const { return static_cast<imtq::RequestType>(rawData[0]); }
void setMeasureRequest(imtq::SpecialRequest specialRequest) { void setMeasureRequest(imtq::SpecialRequest specialRequest) {
rawData[0] = static_cast<uint8_t>(imtq::RequestType::MEASURE_WITH_ACTUATION); rawData[0] = static_cast<uint8_t>(imtq::RequestType::MEASURE_NO_ACTUATION);
rawData[1] = static_cast<uint8_t>(specialRequest); rawData[1] = static_cast<uint8_t>(specialRequest);
} }
@ -1141,7 +1153,7 @@ struct ImtqRequest {
private: private:
ImtqRequest(uint8_t* rawData, size_t maxLen) : rawData(rawData) { ImtqRequest(uint8_t* rawData, size_t maxLen) : rawData(rawData) {
if (rawData != nullptr) { if (rawData != nullptr) {
rawData[0] = static_cast<uint8_t>(imtq::RequestType::MEASURE_WITH_ACTUATION); rawData[0] = static_cast<uint8_t>(imtq::RequestType::MEASURE_NO_ACTUATION);
} }
} }
uint8_t* rawData; uint8_t* rawData;

14
mission/tmtc/CfdpTmFunnel.cpp
View File

@ -53,9 +53,10 @@ ReturnValue_t CfdpTmFunnel::handlePacket(TmTcMessage& msg) {
#endif #endif
return result; return result;
} }
size_t serSize = 0;
result = size_t packetLen = 0;
spacePacketHeader.serializeBe(&newPacketData, &serSize, spacePacketHeader.getFullPacketLen()); uint8_t* serPtr = newPacketData;
result = spacePacketHeader.serializeBe(&serPtr, &packetLen, spacePacketHeader.getFullPacketLen());
if (result != returnvalue::OK) { if (result != returnvalue::OK) {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
sif::error << "CfdpTmFunnel::handlePacket: Error serializing packet" << std::endl; sif::error << "CfdpTmFunnel::handlePacket: Error serializing packet" << std::endl;
@ -79,8 +80,15 @@ ReturnValue_t CfdpTmFunnel::handlePacket(TmTcMessage& msg) {
msg.setStorageId(storeId); msg.setStorageId(storeId);
} else { } else {
#if FSFW_CPP_OSTREAM_ENABLED == 1 #if FSFW_CPP_OSTREAM_ENABLED == 1
<<<<<<< Updated upstream
sif::error << "PusTmFunnel::handlePacket: Store too full to create data copy" sif::error << "PusTmFunnel::handlePacket: Store too full to create data copy"
<< std::endl; << std::endl;
=======
sif::error << "PusTmFunnel::handlePacket: Store too full to create data copy or store "
"error"
<< std::endl;
break;
>>>>>>> Stashed changes
#endif #endif
} }
} else { } else {