Arduino_HAL.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <Arduino.h>
#include <SPI.h>
#include "TLE92466ED_HAL.hpp"
 
class Arduino_HAL : public TLE92466ED_HAL {
public:
    struct SPIConfig {
        uint8_t cs_pin = 10;        
        uint8_t en_pin = 9;         
        uint8_t resn_pin = 8;       
        uint32_t spi_frequency = 1000000;  
        uint8_t spi_mode = SPI_MODE0;      
        uint8_t spi_bit_order = MSBFIRST;  
    };
 
    explicit Arduino_HAL(const SPIConfig& config = SPIConfig())
        : m_config(config)
        , m_initialized(false)
    {
        // Constructor body - initialization happens in initialize()
    }
 
    ~Arduino_HAL() override {
        if (m_initialized) {
            // Set CS high
            digitalWrite(m_config.cs_pin, HIGH);
            // Disable device if EN pin is used
            if (m_config.en_pin != 255) {
                digitalWrite(m_config.en_pin, LOW);
            }
        }
    }
 
    auto initialize() noexcept -> std::expected<void, TLE92466ED_Error> override {
        if (m_initialized) {
            return {};  // Already initialized
        }
 
        // Configure CS pin
        pinMode(m_config.cs_pin, OUTPUT);
        digitalWrite(m_config.cs_pin, HIGH);  // CS idle high
 
        // Configure EN pin if specified
        if (m_config.en_pin != 255) {
            pinMode(m_config.en_pin, OUTPUT);
            digitalWrite(m_config.en_pin, HIGH);  // Enable device
        }
 
        // Configure RESN pin if specified
        if (m_config.resn_pin != 255) {
            pinMode(m_config.resn_pin, OUTPUT);
            digitalWrite(m_config.resn_pin, HIGH);  // Not in reset
 
            // Perform hardware reset
            digitalWrite(m_config.resn_pin, LOW);
            delay(10);  // Hold reset for 10ms
            digitalWrite(m_config.resn_pin, HIGH);
            delay(10);  // Wait for device to come out of reset
        }
 
        // Initialize SPI
        SPI.begin();
 
        m_initialized = true;
 
        return {};
    }
 
    auto spiTransfer(uint32_t tx_data) noexcept -> std::expected<uint32_t, TLE92466ED_Error> override {
        if (!m_initialized) {
            return std::unexpected(TLE92466ED_Error::NOT_INITIALIZED);
        }
 
        // Begin SPI transaction with configured settings
        SPI.beginTransaction(SPISettings(
            m_config.spi_frequency,
            m_config.spi_bit_order,
            m_config.spi_mode
        ));
 
        // Assert CS (active LOW)
        digitalWrite(m_config.cs_pin, LOW);
        
        // Small delay for CS setup time
        delayMicroseconds(1);
 
        // Transfer 4 bytes (32 bits), MSB first
        uint32_t rx_data = 0;
        rx_data |= static_cast<uint32_t>(SPI.transfer((tx_data >> 24) & 0xFF)) << 24;
        rx_data |= static_cast<uint32_t>(SPI.transfer((tx_data >> 16) & 0xFF)) << 16;
        rx_data |= static_cast<uint32_t>(SPI.transfer((tx_data >> 8) & 0xFF)) << 8;
        rx_data |= static_cast<uint32_t>(SPI.transfer(tx_data & 0xFF));
 
        // Small delay before deasserting CS
        delayMicroseconds(1);
 
        // Deassert CS (idle HIGH)
        digitalWrite(m_config.cs_pin, HIGH);
 
        // End SPI transaction
        SPI.endTransaction();
 
        return rx_data;
    }
 
    auto delayMicroseconds(uint32_t microseconds) noexcept -> void override {
        ::delayMicroseconds(microseconds);
    }
 
    auto isInitialized() const noexcept -> bool {
        return m_initialized;
    }
 
    auto getConfig() const noexcept -> const SPIConfig& {
        return m_config;
    }
 
    auto enableDevice() noexcept -> void {
        if (m_config.en_pin != 255) {
            digitalWrite(m_config.en_pin, HIGH);
        }
    }
 
    auto disableDevice() noexcept -> void {
        if (m_config.en_pin != 255) {
            digitalWrite(m_config.en_pin, LOW);
        }
    }
 
    auto resetDevice() noexcept -> void {
        if (m_config.resn_pin != 255) {
            digitalWrite(m_config.resn_pin, LOW);
            delay(10);
            digitalWrite(m_config.resn_pin, HIGH);
            delay(10);
        }
    }
 
private:
    SPIConfig m_config;      
    bool m_initialized;      
};
 
inline auto createTLE92466ED_HAL() -> Arduino_HAL* {
    return new Arduino_HAL();
}
 
inline auto createTLE92466ED_HAL(const Arduino_HAL::SPIConfig& config) -> Arduino_HAL* {
    return new Arduino_HAL(config);
}