eive/eive-obsw
eive/eive-obsw
12
3
Fork 0
Code Issues 3 Pull Requests 1 Releases 118 Wiki Activity

add basic manual UART reading

Browse Source
This commit is contained in:
Robin Müller 2022-11-04 11:34:33 +01:00
parent 826f4ce29c
commit d254331b8e
No known key found for this signature in database
GPG Key ID: 11D4952C8CCEF814
2 changed files with 100 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

135
linux/devices/ploc/PlocSupvHelper.cpp
View File

@ -33,7 +33,7 @@ PlocSupvHelper::PlocSupvHelper(object_id_t objectId) : SystemObject(objectId), r
lock = MutexFactory::instance()->createMutex();
}
PlocSupvHelper::~PlocSupvHelper() {}
PlocSupvHelper::~PlocSupvHelper() = default;
ReturnValue_t PlocSupvHelper::initialize() {
#ifdef XIPHOS_Q7S
@ -47,59 +47,102 @@ ReturnValue_t PlocSupvHelper::initialize() {
}
ReturnValue_t PlocSupvHelper::performOperation(uint8_t operationCode) {
ReturnValue_t result = returnvalue::OK;
semaphore->acquire();
ReturnValue_t result;
lock->lockMutex();
internalState = InternalState::IDLE;
lock->unlockMutex();
while (true) {
switch (internalState) {
case InternalState::IDLE: {
semaphore->acquire();
break;
}
case InternalState::UPDATE: {
result = executeUpdate();
if (result == returnvalue::OK) {
triggerEvent(SUPV_UPDATE_SUCCESSFUL, result);
} else if (result == PROCESS_TERMINATED) {
// Event already triggered
} else {
triggerEvent(SUPV_UPDATE_FAILED, result);
semaphore->acquire();
int bytesRead = 0;
while (true) {
bytesRead = read(serialPort, reinterpret_cast<void*>(recBuf.data()),
static_cast<unsigned int>(recBuf.size()));
if (bytesRead == 0) {
{
MutexGuard mg(lock);
if (internalState == InternalState::FINISH) {
// Flush received and unread data
tcflush(serialPort, TCIOFLUSH);
internalState = InternalState::IDLE;
break;
}
}
internalState = InternalState::IDLE;
} else if (bytesRead < 0) {
sif::warning << "ScexUartReader::performOperation: read call failed with error [" << errno
<< ", " << strerror(errno) << "]" << std::endl;
break;
}
case InternalState::CHECK_MEMORY: {
executeFullCheckMemoryCommand();
internalState = InternalState::IDLE;
break;
}
case InternalState::CONTINUE_UPDATE: {
result = continueUpdate();
if (result == returnvalue::OK) {
triggerEvent(SUPV_CONTINUE_UPDATE_SUCCESSFUL, result);
} else if (result == PROCESS_TERMINATED) {
// Event already triggered
} else {
triggerEvent(SUPV_CONTINUE_UPDATE_FAILED, result);
} else if (bytesRead >= static_cast<int>(recBuf.size())) {
sif::error << "ScexUartReader::performOperation: Receive buffer too small for " << bytesRead
<< " bytes" << std::endl;
} else if (bytesRead > 0) {
if (debugMode) {
sif::info << "Received " << bytesRead
<< " bytes from the Solar Cell Experiment:" << std::endl;
}
internalState = InternalState::IDLE;
break;
// insert buffer into ring buffer here
// ReturnValue_t result = dleParser.passData(recBuf.data(), bytesRead);
// TODO: Parse ring buffer here
}
case InternalState::REQUEST_EVENT_BUFFER: {
result = performEventBufferRequest();
if (result == returnvalue::OK) {
triggerEvent(SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL, result);
} else if (result == PROCESS_TERMINATED) {
// Event already triggered
lock->lockMutex();
InternalState currentState = internalState;
lock->unlockMutex();
switch (currentState) {
case InternalState::IDLE: {
break;
} else {
triggerEvent(SUPV_EVENT_BUFFER_REQUEST_FAILED, result);
}
internalState = InternalState::IDLE;
break;
case InternalState::UPDATE: {
result = executeUpdate();
if (result == returnvalue::OK) {
triggerEvent(SUPV_UPDATE_SUCCESSFUL, result);
} else if (result == PROCESS_TERMINATED) {
// Event already triggered
} else {
triggerEvent(SUPV_UPDATE_FAILED, result);
}
MutexGuard mg(lock);
internalState = InternalState::IDLE;
break;
}
case InternalState::CHECK_MEMORY: {
executeFullCheckMemoryCommand();
MutexGuard mg(lock);
internalState = InternalState::IDLE;
break;
}
case InternalState::CONTINUE_UPDATE: {
result = continueUpdate();
if (result == returnvalue::OK) {
triggerEvent(SUPV_CONTINUE_UPDATE_SUCCESSFUL, result);
} else if (result == PROCESS_TERMINATED) {
// Event already triggered
} else {
triggerEvent(SUPV_CONTINUE_UPDATE_FAILED, result);
}
MutexGuard mg(lock);
internalState = InternalState::IDLE;
break;
}
case InternalState::REQUEST_EVENT_BUFFER: {
result = performEventBufferRequest();
if (result == returnvalue::OK) {
triggerEvent(SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL, result);
} else if (result == PROCESS_TERMINATED) {
// Event already triggered
break;
} else {
triggerEvent(SUPV_EVENT_BUFFER_REQUEST_FAILED, result);
}
MutexGuard mg(lock);
internalState = InternalState::IDLE;
break;
}
case InternalState::HANDLER_DRIVEN: {
continue;
}
default:
sif::debug << "PlocSupvHelper::performOperation: Invalid state" << std::endl;
break;
}
default:
sif::debug << "PlocSupvHelper::performOperation: Invalid state" << std::endl;
break;
}
}
}

12
linux/devices/ploc/PlocSupvHelper.h
View File

@ -200,13 +200,22 @@ class PlocSupvHelper : public DeviceCommunicationIF,
EventBufferRequest eventBufferReq;
enum class InternalState { IDLE, UPDATE, CONTINUE_UPDATE, REQUEST_EVENT_BUFFER, CHECK_MEMORY };
enum class InternalState {
IDLE,
HANDLER_DRIVEN,
UPDATE,
CONTINUE_UPDATE,
REQUEST_EVENT_BUFFER,
CHECK_MEMORY,
FINISH
};
InternalState internalState = InternalState::IDLE;
#ifdef XIPHOS_Q7S
SdCardManager* sdcMan = nullptr;
#endif
std::array<uint8_t, 2048> recBuf = {};
uint8_t commandBuffer[supv::MAX_COMMAND_SIZE]{};
SpacePacketCreator creator;
ploc::SpTcParams spParams = ploc::SpTcParams(creator);
@ -214,6 +223,7 @@ class PlocSupvHelper : public DeviceCommunicationIF,
std::array<uint8_t, supv::MAX_COMMAND_SIZE> tmBuf{};
bool terminate = false;
bool debugMode = false;
SimpleRingBuffer ringBuf;
/**