HAL.hpp

Go to the documentation of this file.

 
#pragma once
 
//-------------------------------------------------------------------
// Imports
//-------------------------------------------------------------------
 
#include "InternalTypes.hpp"
#include "SimWheelTypes.hpp"
 
#if !CD_CI
#include "driver/i2c_types.h"  // For I2C operation
#include "driver/i2c_master.h" // For I2C operation
#endif
 
//-------------------------------------------------------------------
// GLOBALS
//-------------------------------------------------------------------
 
#define AS_GPIO(pin) static_cast<gpio_num_t>((int)(pin))
#define AS_PORT(bus) static_cast<i2c_port_num_t>(bus)
#define GPIO_SET_LEVEL(pin, level) gpio_set_level(static_cast<gpio_num_t>((int)(pin)), (level))
#define I2C_SLAVE(dev) static_cast<i2c_master_dev_handle_t>(dev)
#define GPIO_GET_LEVEL(pin) gpio_get_level(static_cast<gpio_num_t>((int)(pin)))
typedef void (*ISRHandler)(void *arg);
 
#if !CD_CI
#define DELAY_TICKS(ticks) vTaskDelay(ticks)
#define DELAY_MS(ms) vTaskDelay(pdMS_TO_TICKS(ms))
#else
#define DELAY_TICKS(ticks) std::this_thread::sleep_for(std::chrono::microseconds(ticks))
#define DELAY_MS(ms) std::this_thread::sleep_for(std::chrono::milliseconds(ms))
#endif
 
// Each CPU instruction takes 6.25 nanoseconds in an ESP32 RISC-V @ 160 Mhz
// Each CPU instruction takes 4.16 nanoseconds in an ESP32 Xtensa @ 240 Mhz
 
#define NS_PER_LOOP ((4000 + CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ - 1) / CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ)
 
#define active_wait_ns(n)                         \
    for (uint32_t i = 0; i < n; i += NS_PER_LOOP) \
        asm("");
 
//-------------------------------------------------------------------
// Exceptions
//-------------------------------------------------------------------
 
class i2c_error : public std::runtime_error
{
public:
    i2c_error(int sda, int scl, int bus)
        : std::runtime_error(
              "I2C: unable to initialize bus. SDA=" +
              std::to_string(sda) +
              " SCL=" +
              std::to_string(scl) +
              " BUS=" +
              std::to_string(bus)) {}
 
    i2c_error(uint8_t address)
        : std::runtime_error(
              "I2C: invalid address " +
              std::to_string((int)address) +
              " (dec)") {}
 
    virtual ~i2c_error() noexcept {}
};
 
class i2c_device_not_found : public std::runtime_error
{
public:
    i2c_device_not_found(uint8_t address, int bus = 0)
        : std::runtime_error(
              "I2C: device not found, but required. Bus=" +
              std::to_string(bus) +
              " Hw/Full address=" +
              std::to_string(address) +
              " (dec)") {}
 
    virtual ~i2c_device_not_found() noexcept {}
};
 
class i2c_full_address_unknown : public std::runtime_error
{
public:
    i2c_full_address_unknown(uint8_t hwAddress, int bus = 0)
        : std::runtime_error(
              "I2C: unable to detect full address. Bus=" +
              std::to_string(bus) +
              " HW address=" +
              std::to_string(hwAddress) +
              " (dec)") {}
 
    virtual ~i2c_full_address_unknown() noexcept {}
};
 
//-------------------------------------------------------------------
// API
//-------------------------------------------------------------------
 
namespace internals
{
    //---------------------------------------------------------------
    // Hardware abstraction
    //---------------------------------------------------------------
 
    namespace hal
    {
 
        //---------------------------------------------------------------
        // I2C bus operation
        //---------------------------------------------------------------
 
        namespace i2c
        {
            void initialize(
                GPIO sda,
                GPIO scl,
                I2CBus bus,
                bool enableInternalPullup = true);
 
            void require(
                I2CBus bus = I2CBus::PRIMARY);
 
#if !CD_CI
            i2c_master_dev_handle_t add_device(
                uint8_t address7bits,
                uint8_t max_speed_multiplier,
                I2CBus bus);
 
            void remove_device(i2c_master_dev_handle_t i2c_device);
#endif
 
            bool probe(
                uint8_t address7bits,
                I2CBus bus = I2CBus::PRIMARY);
 
            void probe(
                std::vector<uint8_t> &result,
                I2CBus bus = I2CBus::PRIMARY);
 
            void abortOnInvalidAddress(
                uint8_t address7bits,
                uint8_t minAddress = 0,
                uint8_t maxAddress = 127);
 
            uint8_t findFullAddress(
                std::vector<uint8_t> &fullAddressList,
                uint8_t hardwareAddress,
                uint8_t hardwareAddressMask = 0b00000111);
        } // namespace i2c
 
        //---------------------------------------------------------------
        // GPIO operation
        //---------------------------------------------------------------
 
        namespace gpio
        {
            int getADCreading(ADC_GPIO pin, int sampleCount = 1);
 
            void forOutput(OutputGPIO pin, bool initialLevel, bool openDrain);
 
            void forInput(
                InputGPIO pin,
                bool enablePullDown,
                bool enablePullUp);
 
#if CD_CI
            void setFakeADCReading(const std::vector<int> &injectedADCValues);
#endif
 
            void enableISR(InputGPIO pin, ISRHandler handler, void *param = nullptr);
 
        } // namespace gpio
    } // namespace hal
} // namespace internals