mirror of
https://github.com/mudita/MuditaOS.git
synced 2026-04-21 23:50:31 -04:00
121 lines
3.1 KiB
C++
121 lines
3.1 KiB
C++
|
|
/*
|
|
* @file InOutSerialWorker.cpp
|
|
* @author Mateusz Piesta (mateusz.piesta@mudita.com)
|
|
* @date 24.06.19
|
|
* @brief
|
|
* @copyright Copyright (C) 2019 mudita.com
|
|
* @details
|
|
*/
|
|
|
|
|
|
#include "InOutSerialWorker.hpp"
|
|
#include "MuxDaemon.hpp"
|
|
#include "log/log.hpp"
|
|
#include "bsp/cellular/bsp_cellular.hpp"
|
|
#include "MuxParser.hpp"
|
|
#include "ATParser.hpp"
|
|
|
|
#include "ticks.hpp"
|
|
|
|
|
|
std::optional<std::unique_ptr<InOutSerialWorker>> InOutSerialWorker::Create(MuxDaemon *mux, bsp::Cellular *cellular) {
|
|
auto inst = std::make_unique<InOutSerialWorker>(mux,cellular);
|
|
|
|
if (inst->isInitialized) {
|
|
return inst;
|
|
} else {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
InOutSerialWorker::InOutSerialWorker(MuxDaemon *mux, bsp::Cellular *cellular) : muxDaemon(mux), atParser(nullptr),
|
|
muxParser(nullptr), cellular(cellular) {
|
|
|
|
if ((muxParser = MuxParser::Create(muxDaemon, this, cellular).value_or(nullptr)) == nullptr) {
|
|
return;
|
|
}
|
|
|
|
if ((atParser = ATParser::Create(muxDaemon, this, cellular).value_or(nullptr)) == nullptr) {
|
|
return;
|
|
}
|
|
|
|
BaseType_t task_error = xTaskCreate(
|
|
workerTaskFunction,
|
|
"cellInSerWorker",
|
|
512, // in words
|
|
this,
|
|
taskPriority,
|
|
&taskHandle);
|
|
if (task_error != pdPASS) {
|
|
LOG_ERROR("Failed to start inputSerialWorker task");
|
|
return;
|
|
}
|
|
|
|
|
|
isInitialized = true;
|
|
}
|
|
|
|
InOutSerialWorker::~InOutSerialWorker() {
|
|
if (taskHandle) {
|
|
vTaskDelete(taskHandle);
|
|
}
|
|
}
|
|
|
|
|
|
void workerTaskFunction(void *ptr) {
|
|
InOutSerialWorker *inst = reinterpret_cast<InOutSerialWorker *>(ptr);
|
|
|
|
while (1) {
|
|
auto ret = inst->cellular->Wait(UINT32_MAX);
|
|
if (ret == 0) {
|
|
continue;
|
|
}
|
|
|
|
// AT mode is used only during initialization phase
|
|
if (inst->mode == InOutSerialWorker::Mode::AT) {
|
|
inst->atParser->ProcessNewData();
|
|
}
|
|
// CMUX mode is default operation mode
|
|
else {
|
|
inst->muxParser->ProcessNewData();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void InOutSerialWorker::SwitchMode(const InOutSerialWorker::Mode newMode) {
|
|
mode = newMode;
|
|
}
|
|
|
|
ssize_t InOutSerialWorker::WriteData(unsigned char *input, size_t length) {
|
|
//TODO: M.P implement actual caching
|
|
cpp_freertos::LockGuard lock(serOutMutex);
|
|
return cellular->Write(input, length);
|
|
}
|
|
|
|
std::vector<std::string> InOutSerialWorker::SendATCommand(const char *cmd, size_t rxCount, uint32_t timeout) {
|
|
|
|
return atParser->SendCommand(cmd, rxCount, timeout);
|
|
}
|
|
|
|
ssize_t InOutSerialWorker::SendFrame(int channel, const unsigned char *input, int length, unsigned char type) {
|
|
return muxParser->SendMuxFrame(channel, input, length, type);
|
|
}
|
|
|
|
int InOutSerialWorker::memstr(const char *haystack, int length, const char *needle) {
|
|
int i;
|
|
int j = 0;
|
|
if (needle[0] == '\0')
|
|
return 1;
|
|
for (i = 0; i < length; i++)
|
|
if (needle[j] == haystack[i]) {
|
|
j++;
|
|
if (needle[j] == '\0') // Entire needle was found
|
|
return 1;
|
|
} else
|
|
j = 0;
|
|
return 0;
|
|
}
|
|
|