Grove driver, I2C migrations, bugfixes and docs (#532)

Tactility/Source/hal/i2c/I2c.cpp

@@ -1,111 +0,0 @@
-#include <Tactility/hal/i2c/I2c.h>
-
-#include <Tactility/Logger.h>
-#include <Tactility/Mutex.h>
-
-#include <tactility/check.h>
-#include <tactility/drivers/i2c_controller.h>
-#include <tactility/time.h>
-
-#ifdef ESP_PLATFORM
-#include <tactility/drivers/esp32_i2c.h>
-#endif
-
-namespace tt::hal::i2c {
-
-class NoLock final : public tt::Lock {
-    bool lock(TickType_t timeout) const override { return true; }
-    void unlock() const override { /* NO-OP */ }
-};
-
-static NoLock NO_LOCK;
-
-Device* findDevice(i2c_port_t port) {
-#ifdef ESP_PLATFORM
-    struct Params {
-        i2c_port_t port;
-        Device* device;
-    };
-
-    Params params = {
-        .port = port,
-        .device = nullptr
-    };
-
-    device_for_each_of_type(&I2C_CONTROLLER_TYPE, &params, [](auto* device, auto* context) {
-        auto* params_ptr = (Params*)context;
-        auto* driver = device_get_driver(device);
-        if (driver == nullptr) return true;
-        if (!driver_is_compatible(driver, "espressif,esp32-i2c")) return true;
-        auto* config = static_cast<const Esp32I2cConfig*>(device->config);
-        if (config->port != params_ptr->port) return true;
-        // Found it, stop iterating
-        params_ptr->device = device;
-        return false;
-    });
-
-    return params.device;
-#else
-    return nullptr;
-#endif
-}
-
-bool isStarted(i2c_port_t port) {
-    auto* device = findDevice(port);
-    if (device == nullptr) return false;
-    return device_is_ready(device);
-}
-
-const char* getName(i2c_port_t port) {
-    auto* device = findDevice(port);
-    if (device == nullptr) return nullptr;
-    return device->name;
-}
-
-bool masterRead(i2c_port_t port, uint8_t address, uint8_t* data, size_t dataSize, TickType_t timeout) {
-    auto* device = findDevice(port);
-    if (device == nullptr) return false;
-    return i2c_controller_read(device, address, data, dataSize, timeout) == ERROR_NONE;
-}
-
-bool masterReadRegister(i2c_port_t port, uint8_t address, uint8_t reg, uint8_t* data, size_t dataSize, TickType_t timeout) {
-    auto* device = findDevice(port);
-    if (device == nullptr) return false;
-    return i2c_controller_read_register(device, address, reg, data, dataSize, timeout) == ERROR_NONE;
-}
-
-bool masterWrite(i2c_port_t port, uint8_t address, const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
-    auto* device = findDevice(port);
-    if (device == nullptr) return false;
-    return i2c_controller_write(device, address, data, dataSize, timeout) == ERROR_NONE;
-}
-
-bool masterWriteRegister(i2c_port_t port, uint8_t address, uint8_t reg, const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
-    auto* device = findDevice(port);
-    if (device == nullptr) return false;
-    return i2c_controller_write_register(device, address, reg, data, dataSize, timeout) == ERROR_NONE;
-}
-
-bool masterWriteRegisterArray(i2c_port_t port, uint8_t address, const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
-    auto* device = findDevice(port);
-    if (device == nullptr) return false;
-    return i2c_controller_write_register_array(device, address, data, dataSize, timeout) == ERROR_NONE;
-}
-
-bool masterWriteRead(i2c_port_t port, uint8_t address, const uint8_t* writeData, size_t writeDataSize, uint8_t* readData, size_t readDataSize, TickType_t timeout) {
-    auto* device = findDevice(port);
-    if (device == nullptr) return false;
-    return i2c_controller_write_read(device, address, writeData, writeDataSize, readData, readDataSize, timeout) == ERROR_NONE;
-}
-
-bool masterHasDeviceAtAddress(i2c_port_t port, uint8_t address, TickType_t timeout) {
-    auto* device = findDevice(port);
-    if (device == nullptr) return false;
-    return i2c_controller_has_device_at_address(device, address, timeout) == ERROR_NONE;
-}
-
-Lock& getLock(i2c_port_t port) {
-    return NO_LOCK;
-}
-
-} // namespace

Tactility/Source/hal/i2c/I2cDevice.cpp

@@ -5,24 +5,24 @@
 namespace tt::hal::i2c {
 
 bool I2cDevice::read(uint8_t* data, size_t dataSize, TickType_t timeout) {
-    return masterRead(port, address, data, dataSize, timeout);
+    return i2c_controller_read(controller, address, data, dataSize, timeout) == ERROR_NONE;
 }
 
 bool I2cDevice::write(const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
-    return masterWrite(port, address, data, dataSize, timeout);
+    return i2c_controller_write(controller, address, data, dataSize, timeout) == ERROR_NONE;
 }
 
 bool I2cDevice::writeRead(const uint8_t* writeData, size_t writeDataSize, uint8_t* readData, size_t readDataSize, TickType_t timeout) {
-    return masterWriteRead(port, address, writeData, writeDataSize, readData, readDataSize, timeout);
+    return i2c_controller_write_read(controller, address, writeData, writeDataSize, readData, readDataSize, timeout) == ERROR_NONE;
 }
 
 bool I2cDevice::writeRegister(uint8_t reg, const uint8_t* data, uint16_t dataSize, TickType_t timeout) {
-    return masterWriteRegister(port, address, reg, data, dataSize, timeout);
+    return i2c_controller_write_register(controller, address, reg, data, dataSize, timeout) == ERROR_NONE;
 }
 
 bool I2cDevice::readRegister12(uint8_t reg, float& out) const {
     std::uint8_t data[2] = {0};
-    if (masterReadRegister(port, address, reg, data, 2, DEFAULT_TIMEOUT)) {
+    if (i2c_controller_read_register(controller, address, reg, data, 2, DEFAULT_TIMEOUT) == ERROR_NONE) {
         out = (data[0] & 0x0F) << 8 | data[1];
         return true;
     } else {
@@ -32,7 +32,7 @@ bool I2cDevice::readRegister12(uint8_t reg, float& out) const {
 
 bool I2cDevice::readRegister14(uint8_t reg, float& out) const {
     std::uint8_t data[2] = {0};
-    if (masterReadRegister(port, address, reg, data, 2, DEFAULT_TIMEOUT)) {
+    if (i2c_controller_read_register(controller, address, reg, data, 2, DEFAULT_TIMEOUT) == ERROR_NONE) {
         out = (data[0] & 0x3F) << 8 | data[1];
         return true;
     } else {
@@ -42,7 +42,7 @@ bool I2cDevice::readRegister14(uint8_t reg, float& out) const {
 
 bool I2cDevice::readRegister16(uint8_t reg, uint16_t& out) const {
     std::uint8_t data[2] = {0};
-    if (masterReadRegister(port, address, reg, data, 2, DEFAULT_TIMEOUT)) {
+    if (i2c_controller_read_register(controller, address, reg, data, 2, DEFAULT_TIMEOUT) == ERROR_NONE) {
         out = data[0] << 8 | data[1];
         return true;
     } else {
@@ -51,11 +51,11 @@ bool I2cDevice::readRegister16(uint8_t reg, uint16_t& out) const {
 }
 
 bool I2cDevice::readRegister8(uint8_t reg, uint8_t& result) const {
-    return masterWriteRead(port, address, &reg, 1, &result, 1, DEFAULT_TIMEOUT);
+    return i2c_controller_write_read(controller, address, &reg, 1, &result, 1, DEFAULT_TIMEOUT) == ERROR_NONE;
 }
 
 bool I2cDevice::writeRegister8(uint8_t reg, uint8_t value) const {
-    return masterWriteRegister(port, address, reg, &value, 1, DEFAULT_TIMEOUT);
+    return i2c_controller_write_register(controller, address, reg, &value, 1, DEFAULT_TIMEOUT) == ERROR_NONE;
 }
 
 bool I2cDevice::bitOn(uint8_t reg, uint8_t bitmask) const {