EspTypes_I2C.h

Go to the documentation of this file.

 
#pragma once
 
#include "BaseI2c.h" // For hf_i2c_err_t
#include "EspTypes_Base.h"
#include "HardwareTypes.h" // For basic hardware types
#include "McuSelect.h"     // Central MCU platform selection (includes all ESP-IDF)
#include <vector>
 
// ESP-IDF C headers must be wrapped in extern "C" for C++ compatibility
#ifdef __cplusplus
extern "C" {
#endif
 
#include "driver/i2c.h"
 
#ifdef __cplusplus
}
#endif
 
//==============================================================================
// ESP32 I2C TYPE MAPPINGS
//==============================================================================
 
// Direct ESP-IDF type usage - no unnecessary aliases
// These types are used internally by EspI2c implementation
 
//==============================================================================
// ESP32 I2C CONSTANTS
//==============================================================================
 
static constexpr uint8_t HF_I2C_MAX_PORTS = 2;
static constexpr uint32_t HF_I2C_MAX_FREQ_HZ = 1000000;
static constexpr uint32_t HF_I2C_MIN_FREQ_HZ = 1000;
static constexpr uint32_t HF_I2C_DEFAULT_FREQ_HZ = 100000;
static constexpr uint32_t HF_I2C_FAST_FREQ_HZ = 400000;
static constexpr uint32_t HF_I2C_FAST_PLUS_FREQ_HZ = 1000000;
static constexpr uint32_t HF_I2C_MAX_TRANSFER_BYTES = 1024;
static constexpr uint32_t HF_I2C_FIFO_SIZE = 32;
static constexpr uint32_t HF_I2C_DEFAULT_TIMEOUT_MS = 1000;
static constexpr uint32_t HF_I2C_MAX_TIMEOUT_MS = 10000;
static constexpr uint8_t HF_I2C_MAX_RETRY_COUNT = 3;
 
//==============================================================================
// ESP32 I2C ENUMS
//==============================================================================
 
enum class hf_i2c_clock_source_t : uint8_t {
  HF_I2C_CLK_SRC_DEFAULT = I2C_CLK_SRC_DEFAULT, 
  HF_I2C_CLK_SRC_XTAL = I2C_CLK_SRC_XTAL,       
  HF_I2C_CLK_SRC_RC_FAST = I2C_CLK_SRC_RC_FAST  
};
 
enum class hf_i2c_address_bits_t : uint8_t {
  HF_I2C_ADDR_7_BIT = I2C_ADDR_BIT_LEN_7,  
  HF_I2C_ADDR_10_BIT = I2C_ADDR_BIT_LEN_10 
};
 
enum class hf_i2c_power_mode_t : uint8_t {
  HF_I2C_POWER_MODE_NORMAL = 0, 
  HF_I2C_POWER_MODE_LOW = 1,    
  HF_I2C_POWER_MODE_SLEEP = 2   
};
 
enum class hf_i2c_transaction_type_t : uint8_t {
  HF_I2C_TRANS_WRITE = 0,     
  HF_I2C_TRANS_READ = 1,      
  HF_I2C_TRANS_WRITE_READ = 2 
};
 
enum class hf_i2c_event_type_t : int {
  HF_I2C_EVENT_MASTER_START = 0, 
  HF_I2C_EVENT_MASTER_STOP = 1,  
  HF_I2C_EVENT_MASTER_WRITE = 2, 
  HF_I2C_EVENT_MASTER_READ = 3,  
  HF_I2C_EVENT_SLAVE_START = 4,  
  HF_I2C_EVENT_SLAVE_STOP = 5,   
  HF_I2C_EVENT_SLAVE_WRITE = 6,  
  HF_I2C_EVENT_SLAVE_READ = 7,   
  HF_I2C_EVENT_ERROR = 8         
};
 
enum class hf_i2c_glitch_filter_t : uint8_t {
  HF_I2C_GLITCH_FILTER_0_CYCLES = 0, 
  HF_I2C_GLITCH_FILTER_1_CYCLES = 1, 
  HF_I2C_GLITCH_FILTER_2_CYCLES = 2, 
  HF_I2C_GLITCH_FILTER_3_CYCLES = 3, 
  HF_I2C_GLITCH_FILTER_4_CYCLES = 4, 
  HF_I2C_GLITCH_FILTER_5_CYCLES = 5, 
  HF_I2C_GLITCH_FILTER_6_CYCLES = 6, 
  HF_I2C_GLITCH_FILTER_7_CYCLES = 7  
};
 
enum class hf_i2c_command_type_t : uint8_t {
  HF_I2C_CMD_START = 0,      
  HF_I2C_CMD_STOP = 1,       
  HF_I2C_CMD_WRITE = 2,      
  HF_I2C_CMD_READ = 3,       
  HF_I2C_CMD_WRITE_READ = 4, 
  HF_I2C_CMD_DELAY = 5       
};
 
enum class hf_i2c_mode_t : uint8_t {
  HF_I2C_MODE_SYNC = 0, 
  HF_I2C_MODE_ASYNC = 1 
};
 
//==============================================================================
// ESP32 I2C CALLBACK TYPES
//==============================================================================
 
using hf_i2c_async_callback_t =
    void(*)(hf_i2c_err_t result, size_t bytes_transferred, void* user_data);
 
using hf_i2c_event_callback_t =
    void(*)(hf_i2c_event_type_t event_type, void* event_data, void* user_data);
 
//==============================================================================
// ESP32 I2C CONFIGURATION STRUCTURES
//==============================================================================
 
struct hf_i2c_async_result_t {
  hf_i2c_err_t error_code;                    
  size_t bytes_transferred;                   
  uint32_t operation_id;                      
  uint64_t completion_time_us;                
  hf_i2c_transaction_type_t transaction_type; 
};
 
struct hf_i2c_master_bus_config_t {
  i2c_port_t i2c_port;                      
  hf_pin_num_t sda_io_num;                  
  hf_pin_num_t scl_io_num;                  
  hf_i2c_mode_t mode;                       
  uint32_t trans_queue_depth;               
  hf_i2c_clock_source_t clk_source;         
  hf_i2c_glitch_filter_t glitch_ignore_cnt; 
  uint32_t intr_priority;                   
  struct {
    bool enable_internal_pullup;
    bool allow_pd;
  } flags;
 
  hf_i2c_master_bus_config_t() noexcept
      : i2c_port(I2C_NUM_0), sda_io_num(static_cast<hf_pin_num_t>(HF_INVALID_PIN)),
        scl_io_num(static_cast<hf_pin_num_t>(HF_INVALID_PIN)),
        mode(hf_i2c_mode_t::HF_I2C_MODE_SYNC), trans_queue_depth(0),
        clk_source(hf_i2c_clock_source_t::HF_I2C_CLK_SRC_DEFAULT),
        glitch_ignore_cnt(hf_i2c_glitch_filter_t::HF_I2C_GLITCH_FILTER_7_CYCLES), intr_priority(0),
        flags{true, false} {}
};
 
struct hf_i2c_device_config_t {
  uint16_t device_address;               
  hf_i2c_address_bits_t dev_addr_length; 
  uint32_t scl_speed_hz;                 
  uint32_t scl_wait_us;                  
  bool disable_ack_check;                
  uint32_t flags;                        
 
  hf_i2c_device_config_t() noexcept
      : device_address(0), dev_addr_length(hf_i2c_address_bits_t::HF_I2C_ADDR_7_BIT),
        scl_speed_hz(100000), scl_wait_us(0), disable_ack_check(false), flags(0) {}
};
 
struct hf_i2c_slave_config_t {
  i2c_port_t i2c_port;                
  hf_i2c_clock_source_t clk_source;   
  hf_pin_num_t scl_io_num;            
  hf_pin_num_t sda_io_num;            
  uint16_t slave_addr;                
  hf_i2c_address_bits_t addr_bit_len; 
  uint32_t clk_speed_hz;              
  uint32_t send_buf_depth;            
  uint32_t receive_buf_depth;         
  uint32_t intr_priority;             
  bool enable_internal_pullup;        
  bool broadcast_en;                  
  bool allow_pd;                      
 
  hf_i2c_slave_config_t() noexcept
      : i2c_port(I2C_NUM_0), clk_source(hf_i2c_clock_source_t::HF_I2C_CLK_SRC_DEFAULT),
        scl_io_num(static_cast<hf_pin_num_t>(HF_INVALID_PIN)),
        sda_io_num(static_cast<hf_pin_num_t>(HF_INVALID_PIN)), slave_addr(0),
        addr_bit_len(hf_i2c_address_bits_t::HF_I2C_ADDR_7_BIT), clk_speed_hz(100000),
        send_buf_depth(32), receive_buf_depth(32), intr_priority(5), enable_internal_pullup(true),
        broadcast_en(false), allow_pd(false) {}
};
 
//==============================================================================
// ESP32 I2C TRANSACTION STRUCTURES
//==============================================================================
 
struct hf_i2c_transaction_buffer_t {
  const uint8_t* buffer; 
  size_t length;         
  bool is_write;         
 
  hf_i2c_transaction_buffer_t(const uint8_t* buf, size_t len) noexcept
      : buffer(buf), length(len), is_write(true) {}
 
  hf_i2c_transaction_buffer_t(const uint8_t* buf, size_t len, bool write) noexcept
      : buffer(buf), length(len), is_write(write) {}
};
 
struct hf_i2c_multi_buffer_transaction_t {
  uint16_t device_address;                          
  std::vector<hf_i2c_transaction_buffer_t> buffers; 
  uint32_t timeout_ms;                              
  uint32_t flags;                                   
 
  hf_i2c_multi_buffer_transaction_t() noexcept : device_address(0), timeout_ms(1000), flags(0) {}
};
 
struct hf_i2c_custom_command_t {
  hf_i2c_command_type_t command_type; 
  uint16_t device_addr;               
  std::vector<uint8_t> data;          
  uint32_t delay_us;                  
  uint32_t timeout_ms;                
  size_t expected_read_size;          
  uint32_t flags;                     
 
  explicit hf_i2c_custom_command_t(hf_i2c_command_type_t type, uint16_t addr = 0) noexcept
      : command_type(type), device_addr(addr), delay_us(0), timeout_ms(1000), expected_read_size(0),
        flags(0) {}
 
  explicit hf_i2c_custom_command_t(uint32_t delay_microseconds) noexcept
      : command_type(hf_i2c_command_type_t::HF_I2C_CMD_DELAY), device_addr(0),
        delay_us(delay_microseconds), timeout_ms(0), expected_read_size(0), flags(0) {}
};
 
//==============================================================================
// END OF ESPI2C TYPES - MINIMAL AND ESSENTIAL ONLY
//==============================================================================