EspGpio.h

Go to the documentation of this file.

 
#pragma once
 
// ESP-IDF C headers must be wrapped in extern "C" for C++ compatibility
#ifdef __cplusplus
extern "C" {
#endif
 
#include "driver/gpio.h"
#include <esp_attr.h>
 
#ifdef __cplusplus
}
#endif
 
// C++ headers
#include "BaseGpio.h"
#include "EspTypes_GPIO.h"
#include "mcu/esp32/utils/EspTypes_GPIO.h"
#include <stdio.h>
 
class EspGpio : public BaseGpio {
public:
  //==============================================================//
  // CONSTRUCTORS
  //==============================================================//
  explicit EspGpio(
      hf_pin_num_t pin_num,
      hf_gpio_direction_t direction = hf_gpio_direction_t::HF_GPIO_DIRECTION_INPUT,
      hf_gpio_active_state_t active_state = hf_gpio_active_state_t::HF_GPIO_ACTIVE_HIGH,
      hf_gpio_output_mode_t output_mode = hf_gpio_output_mode_t::HF_GPIO_OUTPUT_MODE_PUSH_PULL,
      hf_gpio_pull_mode_t pull_mode = hf_gpio_pull_mode_t::HF_GPIO_PULL_MODE_FLOATING,
      hf_gpio_drive_cap_t drive_capability =
          hf_gpio_drive_cap_t::HF_GPIO_DRIVE_CAP_MEDIUM) noexcept;
 
  ~EspGpio() override;
 
  //==============================================================//
  // BASEGPIO IMPLEMENTATION
  //==============================================================//
 
  bool Initialize() noexcept override;
 
  bool Deinitialize() noexcept override;
 
  bool IsPinAvailable() const noexcept override;
 
  hf_u8_t GetMaxPins() const noexcept override;
 
  const char* GetDescription() const noexcept override;
 
  //==============================================================//
  // INTERRUPT FUNCTIONALITY
  //==============================================================//
 
  [[nodiscard]] hf_gpio_err_t SupportsInterrupts() const noexcept override;
 
  hf_gpio_err_t ConfigureInterrupt(hf_gpio_interrupt_trigger_t trigger,
                                   InterruptCallback callback = nullptr,
                                   void* user_data = nullptr) noexcept override;
 
  hf_gpio_err_t EnableInterrupt() noexcept override;
 
  hf_gpio_err_t DisableInterrupt() noexcept override;
 
  hf_gpio_err_t WaitForInterrupt(hf_u32_t timeout_ms = 0) noexcept override;
 
  hf_gpio_err_t GetInterruptStatus(InterruptStatus& status) noexcept override;
 
  hf_gpio_err_t ClearInterruptStats() noexcept override;
 
  //==============================================================//
  // LAZY INITIALIZATION SUPPORT
  //==============================================================//
 
  // Note: EnsureInitialized() is inherited from BaseGpio and provides lazy initialization
 
  [[nodiscard]] bool IsInitialized() const noexcept {
    return BaseGpio::IsInitialized();
  }
 
  //==============================================================//
  // STATISTICS AND DIAGNOSTICS
  //==============================================================//
 
  hf_gpio_err_t GetStatistics(hf_gpio_statistics_t& statistics) const noexcept override;
 
  hf_gpio_err_t GetDiagnostics(hf_gpio_diagnostics_t& diagnostics) const noexcept override;
 
protected:
  //==============================================================//
  // DIGITALGPIO PURE VIRTUAL IMPLEMENTATIONS
  //==============================================================//
 
  hf_gpio_err_t SetDirectionImpl(hf_gpio_direction_t direction) noexcept override;
 
  hf_gpio_err_t SetOutputModeImpl(hf_gpio_output_mode_t mode) noexcept override;
 
  hf_gpio_err_t SetPinLevelImpl(hf_gpio_level_t level) noexcept override;
 
  hf_gpio_err_t GetPinLevelImpl(hf_gpio_level_t& level) noexcept override;
 
  hf_gpio_err_t SetPullModeImpl(hf_gpio_pull_mode_t mode) noexcept override;
 
  hf_gpio_pull_mode_t GetPullModeImpl() const noexcept override;
 
  hf_gpio_err_t GetDirectionImpl(hf_gpio_direction_t& direction) const noexcept override;
 
  hf_gpio_err_t GetOutputModeImpl(hf_gpio_output_mode_t& mode) const noexcept override;
 
public:
  //==============================================================//
  // ADVANCED GPIO FEATURES (ESP32C6/ESP-IDF v5.5+)
  //==============================================================//
 
  [[nodiscard]] hf_gpio_drive_cap_t GetDriveCapability() const noexcept {
    return drive_capability_;
  }
 
  hf_gpio_err_t SetDriveCapability(hf_gpio_drive_cap_t capability) noexcept;
 
  [[nodiscard]] bool SupportsGlitchFilter() const noexcept;
 
  hf_gpio_err_t ConfigurePinGlitchFilter(bool enable) noexcept;
 
  hf_gpio_err_t ConfigureGlitchFilter(
      hf_gpio_glitch_filter_type_t filter_type,
      const hf_gpio_flex_filter_config_t* flex_config = nullptr) noexcept;
 
  hf_gpio_err_t ConfigureSleepMode(const hf_gpio_sleep_config_t& sleep_config) noexcept;
 
  hf_gpio_err_t ConfigureFlexGlitchFilter(const hf_gpio_flex_filter_config_t& config) noexcept;
 
  hf_gpio_err_t EnableGlitchFilters() noexcept;
 
  hf_gpio_err_t DisableGlitchFilters() noexcept;
 
  [[nodiscard]] bool SupportsRtcGpio() const noexcept;
 
  hf_gpio_err_t ConfigureSleep(const hf_gpio_sleep_config_t& config) noexcept;
 
  hf_gpio_err_t ConfigureHold(bool enable) noexcept;
 
  hf_gpio_err_t ConfigureWakeUp(const hf_gpio_wakeup_config_t& config) noexcept;
 
  [[nodiscard]] hf_gpio_status_info_t GetConfigurationDump() const noexcept;
 
  [[nodiscard]] bool IsHeld() const noexcept;
 
  //==============================================================//
  // STATIC UTILITY METHODS FOR ESP32C6 PIN VALIDATION
  //==============================================================//
 
  hf_gpio_err_t GetPinCapabilities(hf_gpio_pin_capabilities_t& capabilities) const noexcept;
 
  hf_gpio_err_t GetStatusInfo(hf_gpio_status_info_t& status) const noexcept;
 
  static hf_u32_t GetTotalInterruptCount() noexcept;
 
  static hf_u32_t GetActiveGpioCount() noexcept;
 
  static bool IsValidPin(hf_pin_num_t pin_num) noexcept;
 
  static bool IsRtcGpio(hf_pin_num_t pin_num) noexcept;
 
  static bool IsStrappingPin(hf_pin_num_t pin_num) noexcept;
 
private:
  //==============================================================//
  // PRIVATE HELPER METHODS
  //==============================================================//
 
  gpio_int_type_t MapInterruptTrigger(hf_gpio_interrupt_trigger_t trigger) const noexcept;
 
  static void IRAM_ATTR StaticInterruptHandler(void* arg);
 
  void IRAM_ATTR HandleInterrupt();
 
  bool InitializeAdvancedFeatures() noexcept;
 
  void CleanupAdvancedFeatures() noexcept;
 
  void CleanupGlitchFilters() noexcept;
 
  void CleanupInterruptSemaphore() noexcept;
 
  hf_gpio_err_t WriteImpl(hf_gpio_state_t state) noexcept;
  hf_gpio_err_t ReadImpl(hf_gpio_state_t& state) noexcept;
 
  //==============================================================//
  // MEMBER VARIABLES
  //==============================================================//
 
  // Interrupt state
  hf_gpio_interrupt_trigger_t interrupt_trigger_; 
  InterruptCallback interrupt_callback_;          
  void* interrupt_user_data_;                     
  bool interrupt_enabled_;                        
  std::atomic<hf_u32_t> interrupt_count_;         
  void* platform_semaphore_; 
  bool isr_handler_added_;   
 
  // Advanced GPIO state
  hf_gpio_drive_cap_t drive_capability_;            
  hf_gpio_glitch_filter_type_t glitch_filter_type_; 
  bool pin_glitch_filter_enabled_;                  
  bool flex_glitch_filter_enabled_;                 
  hf_gpio_flex_filter_config_t flex_filter_config_; 
  hf_gpio_sleep_config_t sleep_config_;             
  bool hold_enabled_;                               
  bool rtc_gpio_enabled_;                           
  hf_gpio_wakeup_config_t wakeup_config_;           
 
  // Platform-specific handles for advanced features
  void* glitch_filter_handle_; 
  void* rtc_gpio_handle_;      
 
  // Static members for ISR management
  static bool gpio_isr_handler_installed_; 
};