esp_modem: Moved to component folder

This commit is contained in:
David Čermák
2021-05-19 23:00:28 +08:00
committed by David Cermak
parent 61f264f97a
commit 90641c89eb
133 changed files with 21 additions and 21 deletions

View File

@ -0,0 +1,181 @@
// Copyright 2021 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <optional>
#include <unistd.h>
#include <sys/fcntl.h>
#include "cxx_include/esp_modem_dte.hpp"
#include "esp_log.h"
#include "esp_modem_config.h"
#include "exception_stub.hpp"
#include "uart_resource.hpp" // In case of VFS using UART
static const char *TAG = "fs_terminal";
namespace esp_modem {
class Resource {
public:
explicit Resource(const esp_modem_dte_config *config, int fd):
uart(config->vfs_config.resource == ESP_MODEM_VFS_IS_EXTERN? std::nullopt : std::make_optional<uart_resource>(config, nullptr, fd))
{}
std::optional<uart_resource> uart;
};
struct File {
explicit File(const char *name): fd(-1)
{
fd = open(name, O_RDWR);
throw_if_false(fd >= 0, "Cannot open the fd");
// Set the FD to non-blocking mode
int flags = fcntl(fd, F_GETFL, nullptr) | O_NONBLOCK;
fcntl(fd, F_SETFL, flags);
}
~File() {
if (fd >= 0) {
close(fd);
}
}
int fd;
};
class FdTerminal : public Terminal {
public:
explicit FdTerminal(const esp_modem_dte_config *config);
~FdTerminal() override;
void start() override {
signal.set(TASK_START);
}
void stop() override {
signal.clear(TASK_START);
}
int write(uint8_t *data, size_t len) override;
int read(uint8_t *data, size_t len) override;
void set_read_cb(std::function<bool(uint8_t *data, size_t len)> f) override {
on_data = std::move(f);
signal.set(TASK_PARAMS);
}
private:
void task();
static const size_t TASK_INIT = SignalGroup::bit0;
static const size_t TASK_START = SignalGroup::bit1;
static const size_t TASK_STOP = SignalGroup::bit2;
static const size_t TASK_PARAMS = SignalGroup::bit3;
File f;
Resource resource;
SignalGroup signal;
Task task_handle;
};
std::unique_ptr<Terminal> create_vfs_terminal(const esp_modem_dte_config *config) {
TRY_CATCH_RET_NULL(
auto term = std::make_unique<FdTerminal>(config);
term->start();
return term;
)
}
FdTerminal::FdTerminal(const esp_modem_dte_config *config) :
f(config->vfs_config.dev_name), resource(config, f.fd), signal(),
task_handle(config->task_stack_size, config->task_priority, this, [](void* p){
auto t = static_cast<FdTerminal *>(p);
t->task();
Task::Delete();
})
{}
void FdTerminal::task()
{
std::function<bool(uint8_t *data, size_t len)> on_data_priv = nullptr;
signal.set(TASK_INIT);
signal.wait_any(TASK_START | TASK_STOP, portMAX_DELAY);
if (signal.is_any(TASK_STOP)) {
return; // exits to the static method where the task gets deleted
}
while (signal.is_any(TASK_START)) {
int s;
fd_set rfds;
struct timeval tv = {
.tv_sec = 1,
.tv_usec = 0,
};
FD_ZERO(&rfds);
FD_SET(f.fd, &rfds);
s = select(f.fd + 1, &rfds, nullptr, nullptr, &tv);
if (signal.is_any(TASK_PARAMS)) {
on_data_priv = on_data;
signal.clear(TASK_PARAMS);
}
if (s < 0) {
break;
} else if (s == 0) {
// ESP_LOGV(TAG, "Select exited with timeout");
} else {
if (FD_ISSET(f.fd, &rfds)) {
if (on_data_priv) {
if (on_data_priv(nullptr, 0)) {
on_data_priv = nullptr;
}
}
}
}
Task::Relinquish();
}
}
int FdTerminal::read(uint8_t *data, size_t len)
{
int size = ::read(f.fd, data, len);
if (size < 0) {
if (errno != EAGAIN) {
ESP_LOGE(TAG, "Error occurred during read: %d", errno);
}
return 0;
}
return size;
}
int FdTerminal::write(uint8_t *data, size_t len)
{
int size = ::write(f.fd, data, len);
if (size < 0) {
ESP_LOGE(TAG, "Error occurred during read: %d", errno);
return 0;
}
return size;
}
FdTerminal::~FdTerminal()
{
stop();
}
} // namespace esp_modem