Implemented TactilityKernel and DevicetreeCompiler, updated licenses & copyrights (#452)

**New features**

- Created a devicetree DTS and YAML parser in Python
- Created new modules:
  - TactilityKernel (LGPL v3.0 license)
  - Platforms/PlatformEsp32 (LGPL v3.0 license) 
  - Platforms/PlatformPosix (LGPL v3.0 license)
  - Tests/TactilityKernelTests

Most boards have a placeholder DTS file, while T-Lora Pager has a few devices attached.

**Licenses**

Clarified licenses and copyrights better.

- Add explanation about the intent behind them.
- Added explanation about licenses for past and future subprojects
- Added more details explanations with regards to the logo usage
- Copied licenses to subprojects to make it more explicit

Platforms/PlatformEsp32/Bindings/espressif,esp32-gpio.yaml

@@ -0,0 +1,5 @@
+description: ESP32 GPIO Controller
+
+compatible: "espressif,esp32-gpio"
+
+include: ["gpio-controller.yaml"]

Platforms/PlatformEsp32/Bindings/espressif,esp32-i2c.yaml

@@ -0,0 +1,12 @@
+description: ESP32 I2C Controller
+
+include: ["i2c-controller.yaml"]
+
+compatible: "espressif,esp32-i2c"
+
+properties:
+  port:
+    type: int
+    description: |
+      The port number, defined by i2c_port_t.
+      Depending on the hardware, these values are available: I2C_NUM_0, I2C_NUM_1, LP_I2C_NUM_0

Platforms/PlatformEsp32/CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.20)
+
+file(GLOB_RECURSE SOURCES "Source/*.c**")
+
+if (DEFINED ENV{ESP_IDF_VERSION})
+
+    idf_component_register(
+        SRCS ${SOURCES}
+        INCLUDE_DIRS "Include/"
+        REQUIRES TactilityKernel driver
+    )
+
+else ()
+
+    add_library(PlatformEsp32 OBJECT)
+    target_sources(PlatformEsp32 PRIVATE ${SOURCES})
+    target_include_directories(PlatformEsp32 PUBLIC Include/)
+    target_link_libraries(PlatformEsp32 PUBLIC TactilityKernel)
+
+endif ()

Platforms/PlatformEsp32/Include/Tactility/bindings/esp32_gpio.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <Tactility/bindings/bindings.h>
+#include <Tactility/drivers/Esp32Gpio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DEFINE_DEVICETREE(esp32_gpio, struct Esp32GpioConfig)
+
+#ifdef __cplusplus
+}
+#endif

Platforms/PlatformEsp32/Include/Tactility/bindings/esp32_i2c.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <Tactility/bindings/bindings.h>
+#include <Tactility/drivers/Esp32I2c.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DEFINE_DEVICETREE(esp32_i2c, struct Esp32I2cConfig)
+
+#ifdef __cplusplus
+}
+#endif

Platforms/PlatformEsp32/Include/Tactility/drivers/Esp32Gpio.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+struct Esp32GpioConfig {
+    uint8_t gpio_count;
+};
+
+#ifdef __cplusplus
+}
+#endif

Platforms/PlatformEsp32/Include/Tactility/drivers/Esp32I2c.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <Tactility/drivers/Gpio.h>
+#include <hal/i2c_types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct Esp32I2cConfig {
+    uint32_t clock_frequency;
+    struct GpioPinConfig pin_sda;
+    struct GpioPinConfig pin_scl;
+    const i2c_port_t port;
+};
+
+#ifdef __cplusplus
+}
+#endif

Platforms/PlatformEsp32/Source/Esp32Gpio.cpp

@@ -0,0 +1,116 @@
+#include <driver/gpio.h>
+
+#include <Tactility/Driver.h>
+#include <Tactility/drivers/Esp32Gpio.h>
+#include <Tactility/drivers/GpioController.h>
+#include <Tactility/drivers/Gpio.h>
+#include <Tactility/Log.h>
+
+#define TAG LOG_TAG(esp32_gpio)
+
+#define GET_CONFIG(device) ((struct Esp32GpioConfig*)device->internal.driver_data)
+
+extern "C" {
+
+static bool set_level(Device* device, gpio_pin_t pin, bool high) {
+    return gpio_set_level(static_cast<gpio_num_t>(pin), high) == ESP_OK;
+}
+
+static bool get_level(Device* device, gpio_pin_t pin, bool* high) {
+    *high = gpio_get_level(static_cast<gpio_num_t>(pin)) != 0;
+    return true;
+}
+
+static bool set_options(Device* device, gpio_pin_t pin, gpio_flags_t options) {
+    const Esp32GpioConfig* config = GET_CONFIG(device);
+
+    if (pin >= config->gpio_count) {
+        return false;
+    }
+
+    gpio_mode_t mode;
+    if ((options & GPIO_DIRECTION_INPUT_OUTPUT) == GPIO_DIRECTION_INPUT_OUTPUT) {
+        mode = GPIO_MODE_INPUT_OUTPUT;
+    } else if (options & GPIO_DIRECTION_INPUT) {
+        mode = GPIO_MODE_INPUT;
+    } else if (options & GPIO_DIRECTION_OUTPUT) {
+        mode = GPIO_MODE_OUTPUT;
+    } else {
+        ESP_LOGE(TAG, "set_options: no direction flag specified for pin %d", pin);
+        return false;
+    }
+
+    const gpio_config_t esp_config = {
+        .pin_bit_mask = 1ULL << pin,
+        .mode = mode,
+        .pull_up_en = (options & GPIO_PULL_UP) ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE,
+        .pull_down_en = (options & GPIO_PULL_DOWN) ? GPIO_PULLDOWN_ENABLE : GPIO_PULLDOWN_DISABLE,
+        .intr_type = GPIO_INTERRUPT_FROM_OPTIONS(options),
+#if SOC_GPIO_SUPPORT_PIN_HYS_FILTER
+        .hys_ctrl_mode = GPIO_HYS_SOFT_DISABLE
+#endif
+    };
+
+    return gpio_config(&esp_config) == ESP_OK;
+}
+
+static bool get_options(Device* device, gpio_pin_t pin, gpio_flags_t* options) {
+    gpio_io_config_t esp_config;
+    if (gpio_get_io_config((gpio_num_t)pin, &esp_config) != ESP_OK) {
+        return false;
+    }
+
+    gpio_flags_t output = 0;
+
+    if (esp_config.pu) {
+        output |= GPIO_PULL_UP;
+    }
+
+    if (esp_config.pd) {
+        output |= GPIO_PULL_DOWN;
+    }
+
+    if (esp_config.ie) {
+        output |= GPIO_DIRECTION_INPUT;
+    }
+
+    if (esp_config.oe) {
+        output |= GPIO_DIRECTION_OUTPUT;
+    }
+
+    if (esp_config.oe_inv) {
+        output |= GPIO_ACTIVE_LOW;
+    }
+
+    *options = output;
+    return true;
+}
+
+static int start(Device* device) {
+    ESP_LOGI(TAG, "start %s", device->name);
+    return 0;
+}
+
+static int stop(Device* device) {
+    ESP_LOGI(TAG, "stop %s", device->name);
+    return 0;
+}
+
+const static GpioControllerApi esp32_gpio_api  = {
+    .set_level = set_level,
+    .get_level = get_level,
+    .set_options = set_options,
+    .get_options = get_options
+};
+
+Driver esp32_gpio_driver = {
+    .name = "esp32_gpio",
+    .compatible = (const char*[]) { "espressif,esp32-gpio", nullptr },
+    .start_device = start,
+    .stop_device = stop,
+    .api =  (void*)&esp32_gpio_api,
+    .device_type = nullptr,
+    .internal = { 0 }
+};
+
+} // extern "C"

Platforms/PlatformEsp32/Source/Esp32I2c.cpp

@@ -0,0 +1,91 @@
+#include <driver/i2c.h>
+
+#include <Tactility/Driver.h>
+#include <Tactility/drivers/Esp32I2c.h>
+#include <Tactility/drivers/I2cController.h>
+#include <Tactility/Log.h>
+
+#define TAG LOG_TAG(esp32_i2c)
+
+struct InternalData {
+    Mutex mutex { 0 };
+
+    InternalData() {
+        mutex_construct(&mutex);
+    }
+
+    ~InternalData() {
+        mutex_destruct(&mutex);
+    }
+};
+
+#define GET_CONFIG(device) ((Esp32I2cConfig*)device->config)
+#define GET_DATA(device) ((InternalData*)device->internal.driver_data)
+
+#define lock(data) mutex_lock(&data->mutex);
+#define unlock(data) mutex_unlock(&data->mutex);
+
+extern "C" {
+
+static bool read(Device* device, uint8_t address, uint8_t* data, size_t data_size, TickType_t timeout) {
+    vPortAssertIfInISR();
+    auto* driver_data = GET_DATA(device);
+    lock(driver_data);
+    const esp_err_t result = i2c_master_read_from_device(GET_CONFIG(device)->port, address, data, data_size, timeout);
+    unlock(driver_data);
+    ESP_ERROR_CHECK_WITHOUT_ABORT(result);
+    return result == ESP_OK;
+}
+
+static bool write(Device* device, uint8_t address, const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
+    vPortAssertIfInISR();
+    auto* driver_data = GET_DATA(device);
+    lock(driver_data);
+    const esp_err_t result = i2c_master_write_to_device(GET_CONFIG(device)->port, address, data, dataSize, timeout);
+    unlock(driver_data);
+    ESP_ERROR_CHECK_WITHOUT_ABORT(result);
+    return result == ESP_OK;
+}
+
+static bool write_read(Device* device, uint8_t address, const uint8_t* write_data, size_t write_data_size, uint8_t* read_data, size_t read_data_size, TickType_t timeout) {
+    vPortAssertIfInISR();
+    auto* driver_data = GET_DATA(device);
+    lock(driver_data);
+    const esp_err_t result = i2c_master_write_read_device(GET_CONFIG(device)->port, address, write_data, write_data_size, read_data, read_data_size, timeout);
+    unlock(driver_data);
+    ESP_ERROR_CHECK_WITHOUT_ABORT(result);
+    return result == ESP_OK;
+}
+
+static int start(Device* device) {
+    ESP_LOGI(TAG, "start %s", device->name);
+    auto* data = new InternalData();
+    device_set_driver_data(device, data);
+    return 0;
+}
+
+static int stop(Device* device) {
+    ESP_LOGI(TAG, "stop %s", device->name);
+    auto* driver_data = static_cast<InternalData*>(device_get_driver_data(device));
+    device_set_driver_data(device, nullptr);
+    delete driver_data;
+    return 0;
+}
+
+const I2cControllerApi esp32_i2c_api = {
+    .read = read,
+    .write = write,
+    .write_read = write_read
+};
+
+Driver esp32_i2c_driver = {
+    .name = "esp32_i2c",
+    .compatible = (const char*[]) { "espressif,esp32-i2c", nullptr },
+    .start_device = start,
+    .stop_device = stop,
+    .api = (void*)&esp32_i2c_api,
+    .device_type = &I2C_CONTROLLER_TYPE,
+    .internal = { 0 }
+};
+
+} // extern "C"

Platforms/PlatformEsp32/Source/Register.cpp

@@ -0,0 +1,12 @@
+#include <Tactility/Driver.h>
+
+extern "C" {
+
+extern void register_platform_drivers() {
+    extern Driver esp32_gpio_driver;
+    driver_construct(&esp32_gpio_driver);
+    extern Driver esp32_i2c_driver;
+    driver_construct(&esp32_i2c_driver);
+}
+
+}

Platforms/PlatformEsp32/devicetree.yaml

@@ -0,0 +1,3 @@
+dependencies:
+  - TactilityKernel
+bindings: Bindings