Merge TactilityHeadless into Tactility (#263)

There currently is no practical use to have TactilityHeadless as a subproject. I'm merging it with the Tactility project.
2025-03-30 10:54:36 +02:00
parent d0ca3b16f8
commit d72852a6e2
114 changed files with 30 additions and 105 deletions
@@ -0,0 +1,174 @@
+#include "Tactility/hal/uart/Uart.h"
+
+#include <Tactility/Log.h>
+#include <Tactility/Mutex.h>
+
+#include <ranges>
+#include <cstring>
+
+#ifdef ESP_PLATFORM
+#include "Tactility/TactilityHeadless.h"
+#include "Tactility/hal/uart/UartEsp.h"
+#include <esp_check.h>
+#else
+#include "Tactility/hal/uart/UartPosix.h"
+#include <dirent.h>
+#endif
+
+#define TAG "uart"
+
+namespace tt::hal::uart {
+
+constexpr uint32_t uartIdNotInUse = 0;
+
+struct UartEntry {
+    uint32_t usageId = uartIdNotInUse;
+    Configuration configuration;
+};
+
+static std::vector<UartEntry> uartEntries = {};
+static uint32_t lastUartId = uartIdNotInUse;
+
+bool init(const std::vector<uart::Configuration>& configurations) {
+    TT_LOG_I(TAG, "Init");
+    for (const auto& configuration: configurations) {
+        uartEntries.push_back({
+            .usageId = uartIdNotInUse,
+            .configuration = configuration
+        });
+    }
+
+    return true;
+}
+
+bool Uart::writeString(const char* buffer, TickType_t timeout) {
+    auto size = strlen(buffer);
+    writeBytes((std::byte*)buffer, size, timeout);
+    return true;
+}
+
+size_t Uart::readUntil(std::byte* buffer, size_t bufferSize, uint8_t untilByte, TickType_t timeout, bool addNullTerminator) {
+    TickType_t start_time = kernel::getTicks();
+    auto* buffer_write_ptr = reinterpret_cast<uint8_t*>(buffer);
+    uint8_t* buffer_limit = buffer_write_ptr + bufferSize - 1; // Keep 1 extra char as mull terminator
+    TickType_t timeout_left = timeout;
+    while (readByte(reinterpret_cast<std::byte*>(buffer_write_ptr), timeout_left) && buffer_write_ptr < buffer_limit) {
+#ifdef DEBUG_READ_UNTIL
+        // If first successful read and we're not receiving an empty response
+        if (buffer_write_ptr == buffer && *buffer_write_ptr != 0x00U && *buffer_write_ptr != untilByte) {
+            printf(">>");
+        }
+#endif
+
+        if (*buffer_write_ptr == untilByte) {
+            // TODO: Fix when untilByte is null terminator char already
+            if (addNullTerminator) {
+                buffer_write_ptr++;
+                *buffer_write_ptr = 0x00U;
+            }
+            break;
+        }
+
+#ifdef DEBUG_READ_UNTIL
+        printf("%c", *buffer_write_ptr);
+#endif
+
+        buffer_write_ptr++;
+
+        TickType_t now = kernel::getTicks();
+        if (now > (start_time + timeout)) {
+#ifdef DEBUG_READ_UNTIL
+            TT_LOG_W(TAG, "readUntil() timeout");
+#endif
+            break;
+        } else {
+            timeout_left = timeout - (now - start_time);
+        }
+    }
+
+#ifdef DEBUG_READ_UNTIL
+    // If we read data and it's not an empty response
+    if (buffer_write_ptr != buffer && *buffer != 0x00U && *buffer != untilByte) {
+        printf("\n");
+    }
+#endif
+
+    if (addNullTerminator && (buffer_write_ptr > reinterpret_cast<uint8_t*>(buffer))) {
+        return reinterpret_cast<size_t>(buffer_write_ptr) - reinterpret_cast<size_t>(buffer) - 1UL;
+    } else {
+        return reinterpret_cast<size_t>(buffer_write_ptr) - reinterpret_cast<size_t>(buffer);
+    }
+}
+
+std::unique_ptr<Uart> open(std::string name) {
+    TT_LOG_I(TAG, "Open %s", name.c_str());
+
+    auto result = std::views::filter(uartEntries, [&name](auto& entry) {
+        return entry.configuration.name == name;
+    });
+
+    if (result.empty()) {
+        TT_LOG_E(TAG, "UART not found: %s", name.c_str());
+        return nullptr;
+    }
+
+    auto& entry = *result.begin();
+    if (entry.usageId != uartIdNotInUse) {
+        TT_LOG_E(TAG, "UART in use: %s", name.c_str());
+        return nullptr;
+    }
+
+    auto uart = create(entry.configuration);
+    assert(uart != nullptr);
+    entry.usageId = uart->getId();
+    TT_LOG_I(TAG, "Opened %lu", entry.usageId);
+    return uart;
+}
+
+void close(uint32_t uartId) {
+    TT_LOG_I(TAG, "Close %lu", uartId);
+    auto result = std::views::filter(uartEntries, [&uartId](auto& entry) {
+      return entry.usageId == uartId;
+    });
+
+    if (!result.empty()) {
+        auto& entry = *result.begin();
+        entry.usageId = uartIdNotInUse;
+    } else {
+        TT_LOG_W(TAG, "Auto-closing UART, but can't find it");
+    }
+}
+
+std::vector<std::string> getNames() {
+    std::vector<std::string> names;
+#ifdef ESP_PLATFORM
+    for (auto& config : getConfiguration()->uart) {
+        names.push_back(config.name);
+    }
+#else
+    DIR* dir = opendir("/dev");
+    if (dir == nullptr) {
+        TT_LOG_E(TAG, "Failed to read /dev");
+        return names;
+    }
+    struct dirent* current_entry;
+    while ((current_entry = readdir(dir)) != nullptr) {
+        auto name = std::string(current_entry->d_name);
+        if (name.starts_with("tty")) {
+            auto path = std::string("/dev/") + name;
+            names.push_back(path);
+        }
+    }
+
+    closedir(dir);
+#endif
+    return names;
+}
+
+Uart::Uart() : id(++lastUartId) {}
+
+Uart::~Uart() {
+    close(getId());
+}
+
+} // namespace tt::hal::uart
@@ -0,0 +1,156 @@
+#ifdef ESP_PLATFORM
+
+#include "Tactility/hal/uart/UartEsp.h"
+
+#include <Tactility/Log.h>
+#include <Tactility/Mutex.h>
+
+#include <sstream>
+#include <esp_check.h>
+
+#define TAG "uart"
+
+namespace tt::hal::uart {
+
+bool UartEsp::start() {
+    TT_LOG_I(TAG, "[%s] Starting", configuration.name.c_str());
+
+    auto lock = mutex.asScopedLock();
+    lock.lock();
+
+    if (started) {
+        TT_LOG_E(TAG, "[%s] Starting: Already started", configuration.name.c_str());
+        return false;
+    }
+
+    int intr_alloc_flags;
+#if CONFIG_UART_ISR_IN_IRAM
+    intr_alloc_flags = ESP_INTR_FLAG_IRAM;
+#else
+    intr_alloc_flags = 0;
+#endif
+
+    esp_err_t result = uart_param_config(configuration.port, &configuration.config);
+    if (result != ESP_OK) {
+        TT_LOG_E(TAG, "[%s] Starting: Failed to configure: %s", configuration.name.c_str(), esp_err_to_name(result));
+        return false;
+    }
+
+    if (uart_is_driver_installed(configuration.port)) {
+        TT_LOG_W(TAG, "[%s] Driver was still installed. You probably forgot to stop, or another system uses/used the driver.", configuration.name.c_str());
+        uart_driver_delete(configuration.port);
+    }
+
+    result = uart_set_pin(configuration.port, configuration.txPin, configuration.rxPin, configuration.rtsPin, configuration.ctsPin);
+    if (result != ESP_OK) {
+        TT_LOG_E(TAG, "[%s] Starting: Failed set pins: %s", configuration.name.c_str(), esp_err_to_name(result));
+        return false;
+    }
+
+    result = uart_driver_install(configuration.port, (int)configuration.rxBufferSize, (int)configuration.txBufferSize, 0, nullptr, intr_alloc_flags);
+    if (result != ESP_OK) {
+        TT_LOG_E(TAG, "[%s] Starting: Failed to install driver: %s", configuration.name.c_str(), esp_err_to_name(result));
+        return false;
+    }
+
+    started = true;
+
+    TT_LOG_I(TAG, "[%s] Started", configuration.name.c_str());
+    return true;
+}
+
+bool UartEsp::stop() {
+    TT_LOG_I(TAG, "[%s] Stopping", configuration.name.c_str());
+
+    auto lock = mutex.asScopedLock();
+    lock.lock();
+
+    if (!started) {
+        TT_LOG_E(TAG, "[%s] Stopping: Not started", configuration.name.c_str());
+        return false;
+    }
+
+    esp_err_t result = uart_driver_delete(configuration.port);
+    if (result != ESP_OK) {
+        TT_LOG_E(TAG, "[%s] Stopping: Failed to delete driver: %s", configuration.name.c_str(), esp_err_to_name(result));
+        return false;
+    }
+
+    started = false;
+
+    TT_LOG_I(TAG, "[%s] Stopped", configuration.name.c_str());
+    return true;
+}
+
+bool UartEsp::isStarted() const {
+    auto lock = mutex.asScopedLock();
+    lock.lock();
+    return started;
+}
+
+size_t UartEsp::readBytes(std::byte* buffer, size_t bufferSize, TickType_t timeout) {
+    auto lock = mutex.asScopedLock();
+    if (!lock.lock(timeout)) {
+        return false;
+    }
+
+    auto start_time = kernel::getTicks();
+    auto lock_time = kernel::getTicks() - start_time;
+    auto remaining_timeout = std::max(timeout - lock_time, 0UL);
+    auto result = uart_read_bytes(configuration.port, buffer, bufferSize, remaining_timeout);
+    return result;
+}
+
+bool UartEsp::readByte(std::byte* output, TickType_t timeout) {
+    return readBytes(output, 1, timeout) == 1;
+}
+
+size_t UartEsp::writeBytes(const std::byte* buffer, size_t bufferSize, TickType_t timeout) {
+    auto lock = mutex.asScopedLock();
+    if (!lock.lock(timeout)) {
+        return false;
+    }
+
+    return uart_write_bytes(configuration.port, buffer, bufferSize);
+}
+
+size_t UartEsp::available(TickType_t timeout) {
+    auto lock = mutex.asScopedLock();
+    if (!lock.lock(timeout)) {
+        return false;
+    }
+
+    size_t size = 0;
+    uart_get_buffered_data_len(configuration.port, &size);
+    return size;
+}
+
+void UartEsp::flushInput() {
+    uart_flush_input(configuration.port);
+}
+
+uint32_t UartEsp::getBaudRate() {
+    uint32_t baud_rate = 0;
+    auto result = uart_get_baudrate(configuration.port, &baud_rate);
+    ESP_ERROR_CHECK_WITHOUT_ABORT(result);
+    return baud_rate;
+}
+
+bool UartEsp::setBaudRate(uint32_t baudRate, TickType_t timeout) {
+    auto lock = mutex.asScopedLock();
+    if (!lock.lock(timeout)) {
+        return false;
+    }
+
+    auto result = uart_set_baudrate(configuration.port, baudRate);
+    ESP_ERROR_CHECK_WITHOUT_ABORT(result);
+    return result == ESP_OK;
+}
+
+std::unique_ptr<Uart> create(const Configuration& configuration) {
+    return std::make_unique<UartEsp>(configuration);
+}
+
+} // namespace tt::hal::uart
+
+#endif
@@ -0,0 +1,191 @@
+#ifndef ESP_PLATFORM
+
+#include "Tactility/hal/uart/UartPosix.h"
+#include "Tactility/hal/uart/Uart.h"
+
+#include <Tactility/Log.h>
+
+#include <cstring>
+#include <sstream>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+#define TAG "uart"
+
+namespace tt::hal::uart {
+
+bool UartPosix::start() {
+    auto lock = mutex.asScopedLock();
+    lock.lock();
+
+    if (device != nullptr) {
+        TT_LOG_E(TAG, "[%s] Starting: Already started", configuration.name.c_str());
+        return false;
+    }
+
+    auto file = fopen(configuration.name.c_str(), "w");
+    if (file == nullptr) {
+        TT_LOG_E(TAG, "[%s] Open device failed", configuration.name.c_str());
+        return false;
+    }
+
+    auto new_device = std::unique_ptr<FILE, AutoCloseFileDeleter>(file);
+
+    struct termios tty;
+    if (tcgetattr(fileno(file), &tty) < 0) {
+        printf("[%s] tcgetattr failed: %s\n", configuration.name.c_str(), strerror(errno));
+        return false;
+    }
+
+    if (cfsetospeed(&tty, (speed_t)configuration.baudRate) == -1) {
+        TT_LOG_E(TAG, "[%s] Setting output speed failed", configuration.name.c_str());
+    }
+
+    if (cfsetispeed(&tty, (speed_t)configuration.baudRate) == -1) {
+        TT_LOG_E(TAG, "[%s] Setting input speed failed", configuration.name.c_str());
+    }
+
+    tty.c_cflag |= (CLOCAL | CREAD); /* ignore modem controls */
+    tty.c_cflag &= ~CSIZE;
+    tty.c_cflag |= CS8; /* 8-bit characters */
+    tty.c_cflag &= ~PARENB; /* no parity bit */
+    tty.c_cflag &= ~CSTOPB; /* only need 1 stop bit */
+    tty.c_cflag &= ~CRTSCTS; /* no hardware flowcontrol */
+
+    tty.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
+    tty.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
+    tty.c_oflag &= ~OPOST;
+
+    /* fetch bytes as they become available */
+    tty.c_cc[VMIN] = 1;
+    tty.c_cc[VTIME] = 1;
+
+    if (tcsetattr(fileno(file), TCSANOW, &tty) != 0) {
+        printf("[%s] tcsetattr failed: %s\n", configuration.name.c_str(), strerror(errno));
+        return false;
+    }
+
+    device = std::move(new_device);
+
+    TT_LOG_I(TAG, "[%s] Started", configuration.name.c_str());
+    return true;
+}
+
+bool UartPosix::stop() {
+    auto lock = mutex.asScopedLock();
+    lock.lock();
+
+    if (device == nullptr) {
+        TT_LOG_E(TAG, "[%s] Stopping: Not started", configuration.name.c_str());
+        return false;
+    }
+
+    device = nullptr;
+
+    TT_LOG_I(TAG, "[%s] Stopped", configuration.name.c_str());
+    return true;
+}
+
+bool UartPosix::isStarted() const {
+    auto lock = mutex.asScopedLock();
+    lock.lock();
+    return device != nullptr;
+}
+
+size_t UartPosix::readBytes(std::byte* buffer, size_t bufferSize, TickType_t timeout) {
+    auto lock = mutex.asScopedLock();
+    if (!lock.lock(timeout)) {
+        return false;
+    }
+
+    if (awaitAvailable(timeout)) {
+        return read(fileno(device.get()), buffer, bufferSize);
+    } else {
+        return 0;
+    }
+}
+
+bool UartPosix::readByte(std::byte* output, TickType_t timeout) {
+    if (awaitAvailable(timeout)) {
+        return read(fileno(device.get()), output, 1) == 1;
+    } else {
+        return false;
+    }
+}
+
+size_t UartPosix::writeBytes(const std::byte* buffer, size_t bufferSize, TickType_t timeout) {
+    if (!mutex.lock(timeout)) {
+        return false;
+    }
+
+    return write(fileno(device.get()), buffer, bufferSize);
+}
+
+size_t UartPosix::available(TickType_t timeout) {
+    auto lock = mutex.asScopedLock();
+    if (!lock.lock(timeout)) {
+        return false;
+    }
+
+    uint32_t bytes_available = 0;
+    ioctl(fileno(device.get()), FIONREAD, bytes_available);
+    return bytes_available;
+}
+
+void UartPosix::flushInput() {
+    // TODO
+}
+
+uint32_t UartPosix::getBaudRate() {
+    struct termios tty;
+    if (tcgetattr(fileno(device.get()), &tty) < 0) {
+        printf("[%s] tcgetattr failed: %s\n", configuration.name.c_str(), strerror(errno));
+        return false;
+    } else {
+        return (uint32_t)cfgetispeed(&tty);
+    }
+}
+
+bool UartPosix::setBaudRate(uint32_t baudRate, TickType_t timeout) {
+    auto lock = mutex.asScopedLock();
+    if (!lock.lock(timeout)) {
+        return false;
+    }
+
+    struct termios tty;
+    if (tcgetattr(fileno(device.get()), &tty) < 0) {
+        printf("[%s] tcgetattr failed: %s\n", configuration.name.c_str(), strerror(errno));
+        return false;
+    }
+
+    if (cfsetospeed(&tty, (speed_t)configuration.baudRate) == -1) {
+        TT_LOG_E(TAG, "[%s] Failed to set output speed", configuration.name.c_str());
+        return false;
+    }
+
+    if (cfsetispeed(&tty, (speed_t)configuration.baudRate) == -1) {
+        TT_LOG_E(TAG, "[%s] Failed to set input speed", configuration.name.c_str());
+        return false;
+    }
+
+    return true;
+}
+
+bool UartPosix::awaitAvailable(TickType_t timeout) {
+    auto start_time = kernel::getTicks();
+    do {
+        if (available(timeout) > 0) {
+            return true;
+        }
+        kernel::delayTicks(timeout / 10);
+    } while ((kernel::getTicks() - start()) < timeout);
+    return false;
+}
+
+std::unique_ptr<Uart> create(const Configuration& configuration) {
+    return std::make_unique<UartPosix>(configuration);
+}
+
+} // namespace tt::hal::uart
+
+#endif