BaseGpio.h

Go to the documentation of this file.

 
#pragma once
 
#include "HardwareTypes.h"
#include <cstdint>
#include <string_view>
 
#define HF_GPIO_ERR_LIST(X)                                                                        \
  /* Success codes */                                                                              \
  X(GPIO_SUCCESS, 0, "Success")                                                                    \
                                                                                                   \
  /* General errors */                                                                             \
  X(GPIO_ERR_FAILURE, 1, "General failure")                                                        \
  X(GPIO_ERR_NOT_INITIALIZED, 2, "Not initialized")                                                \
  X(GPIO_ERR_ALREADY_INITIALIZED, 3, "Already initialized")                                        \
  X(GPIO_ERR_INVALID_PARAMETER, 4, "Invalid parameter")                                            \
  X(GPIO_ERR_NULL_POINTER, 5, "Null pointer")                                                      \
  X(GPIO_ERR_OUT_OF_MEMORY, 6, "Out of memory")                                                    \
                                                                                                   \
  /* Pin errors */                                                                                 \
  X(GPIO_ERR_INVALID_PIN, 7, "Invalid pin")                                                        \
  X(GPIO_ERR_PIN_NOT_FOUND, 8, "Pin not found")                                                    \
  X(GPIO_ERR_PIN_NOT_CONFIGURED, 9, "Pin not configured")                                          \
  X(GPIO_ERR_PIN_ALREADY_REGISTERED, 10, "Pin already registered")                                 \
  X(GPIO_ERR_PIN_ACCESS_DENIED, 11, "Pin access denied")                                           \
  X(GPIO_ERR_PIN_BUSY, 12, "Pin busy")                                                             \
                                                                                                   \
  /* Hardware errors */                                                                            \
  X(GPIO_ERR_HARDWARE_FAULT, 13, "Hardware fault")                                                 \
  X(GPIO_ERR_COMMUNICATION_FAILURE, 14, "Communication failure")                                   \
  X(GPIO_ERR_DEVICE_NOT_RESPONDING, 15, "Device not responding")                                   \
  X(GPIO_ERR_TIMEOUT, 16, "Timeout")                                                               \
  X(GPIO_ERR_VOLTAGE_OUT_OF_RANGE, 17, "Voltage out of range")                                     \
                                                                                                   \
  /* Configuration errors */                                                                       \
  X(GPIO_ERR_INVALID_CONFIGURATION, 18, "Invalid configuration")                                   \
  X(GPIO_ERR_UNSUPPORTED_OPERATION, 19, "Unsupported operation")                                   \
  X(GPIO_ERR_RESOURCE_BUSY, 20, "Resource busy")                                                   \
  X(GPIO_ERR_RESOURCE_UNAVAILABLE, 21, "Resource unavailable")                                     \
                                                                                                   \
  /* I/O errors */                                                                                 \
  X(GPIO_ERR_READ_FAILURE, 22, "Read failure")                                                     \
  X(GPIO_ERR_WRITE_FAILURE, 23, "Write failure")                                                   \
  X(GPIO_ERR_DIRECTION_MISMATCH, 24, "Direction mismatch")                                         \
  X(GPIO_ERR_PULL_RESISTOR_FAILURE, 25, "Pull resistor failure")                                   \
                                                                                                   \
  /* Interrupt errors */                                                                           \
  X(GPIO_ERR_INTERRUPT_NOT_SUPPORTED, 26, "Interrupt not supported")                               \
  X(GPIO_ERR_INTERRUPT_ALREADY_ENABLED, 27, "Interrupt already enabled")                           \
  X(GPIO_ERR_INTERRUPT_NOT_ENABLED, 28, "Interrupt not enabled")                                   \
  X(GPIO_ERR_INTERRUPT_HANDLER_FAILED, 29, "Interrupt handler failed")                             \
                                                                                                   \
  /* System errors */                                                                              \
  X(GPIO_ERR_SYSTEM_ERROR, 30, "System error")                                                     \
  X(GPIO_ERR_PERMISSION_DENIED, 31, "Permission denied")                                           \
  X(GPIO_ERR_OPERATION_ABORTED, 32, "Operation aborted")                                           \
                                                                                                   \
  /* Extended errors for McuGpio implementation */                                                 \
  X(GPIO_ERR_NOT_SUPPORTED, 33, "Operation not supported")                                         \
  X(GPIO_ERR_DRIVER_ERROR, 34, "Driver error")                                                     \
  X(GPIO_ERR_INVALID_STATE, 35, "Invalid state")                                                   \
  X(GPIO_ERR_INVALID_ARG, 36, "Invalid argument")                                                  \
  X(GPIO_ERR_CALIBRATION_FAILURE, 37, "Calibration failure")                                       \
  X(GPIO_ERR_UNKNOWN, 38, "Unknown error")
 
enum class hf_gpio_err_t : hf_u8_t {
#define X(NAME, VALUE, DESC) NAME = VALUE,
  HF_GPIO_ERR_LIST(X)
#undef X
      GPIO_ERR_COUNT // Automatically calculated count
};
 
constexpr std::string_view HfGpioErrToString(hf_gpio_err_t err) noexcept {
  switch (err) {
#define X(NAME, VALUE, DESC)                                                                       \
  case hf_gpio_err_t::NAME:                                                                        \
    return DESC;
    HF_GPIO_ERR_LIST(X)
#undef X
  default:
    return HfGpioErrToString(hf_gpio_err_t::GPIO_ERR_UNKNOWN);
  }
}
 
enum class hf_gpio_state_t : hf_u8_t {
  HF_GPIO_STATE_INACTIVE = 0, 
  HF_GPIO_STATE_ACTIVE = 1    
};
 
enum class hf_gpio_level_t : hf_u8_t {
  HF_GPIO_LEVEL_LOW = 0, 
  HF_GPIO_LEVEL_HIGH = 1 
};
 
enum class hf_gpio_active_state_t : hf_u8_t {
  HF_GPIO_ACTIVE_LOW = 0, 
  HF_GPIO_ACTIVE_HIGH = 1 
};
 
enum class hf_gpio_direction_t : hf_u8_t {
  HF_GPIO_DIRECTION_INPUT = 0, 
  HF_GPIO_DIRECTION_OUTPUT = 1 
};
 
enum class hf_gpio_output_mode_t : hf_u8_t {
  HF_GPIO_OUTPUT_MODE_PUSH_PULL = 0, 
  HF_GPIO_OUTPUT_MODE_OPEN_DRAIN = 1 
};
 
enum class hf_gpio_pull_mode_t : hf_u8_t {
  HF_GPIO_PULL_MODE_FLOATING = 0, 
  HF_GPIO_PULL_MODE_UP = 1,       
  HF_GPIO_PULL_MODE_DOWN = 2,     
  HF_GPIO_PULL_MODE_UP_DOWN = 3   
};
 
enum class hf_gpio_interrupt_trigger_t : hf_u8_t {
  HF_GPIO_INTERRUPT_TRIGGER_NONE = 0,         
  HF_GPIO_INTERRUPT_TRIGGER_RISING_EDGE = 1,  
  HF_GPIO_INTERRUPT_TRIGGER_FALLING_EDGE = 2, 
  HF_GPIO_INTERRUPT_TRIGGER_BOTH_EDGES = 3,   
  HF_GPIO_INTERRUPT_TRIGGER_LOW_LEVEL = 4,    
  HF_GPIO_INTERRUPT_TRIGGER_HIGH_LEVEL = 5    
};
 
// Forward declaration for callback
class BaseGpio;
 
using InterruptCallback =
    void(*)(BaseGpio* gpio, hf_gpio_interrupt_trigger_t trigger, void* user_data);
 
struct InterruptStatus {
  bool is_enabled;                          
  hf_gpio_interrupt_trigger_t trigger_type; 
  hf_u32_t interrupt_count;                 
  bool has_callback;                        
};
 
struct hf_gpio_statistics_t {
  hf_u32_t totalOperations;        
  hf_u32_t successfulOperations;   
  hf_u32_t failedOperations;       
  hf_u32_t stateChanges;           
  hf_u32_t directionChanges;       
  hf_u32_t interruptCount;         
  hf_u32_t averageOperationTimeUs; 
  hf_u32_t maxOperationTimeUs;     
  hf_u32_t minOperationTimeUs;     
 
  hf_gpio_statistics_t()
      : totalOperations(0), successfulOperations(0), failedOperations(0), stateChanges(0),
        directionChanges(0), interruptCount(0), averageOperationTimeUs(0), maxOperationTimeUs(0),
        minOperationTimeUs(UINT32_MAX) {}
};
 
struct hf_gpio_diagnostics_t {
  bool gpioHealthy;            
  hf_gpio_err_t lastErrorCode; 
  hf_u32_t lastErrorTimestamp; 
  hf_u32_t consecutiveErrors;  
  bool pinAvailable;           
  bool interruptSupported;     
  bool interruptEnabled;       
  hf_u32_t currentState;       
 
  hf_gpio_diagnostics_t()
      : gpioHealthy(true), lastErrorCode(hf_gpio_err_t::GPIO_SUCCESS), lastErrorTimestamp(0),
        consecutiveErrors(0), pinAvailable(true), interruptSupported(false),
        interruptEnabled(false), currentState(0) {}
};
 
class BaseGpio {
public:
  //==============================================================//
  // CONSTRUCTORS AND DESTRUCTOR
  //==============================================================//
 
  BaseGpio(const BaseGpio& copy) = delete;
 
  BaseGpio& operator=(const BaseGpio& copy) = delete;
 
  virtual ~BaseGpio() noexcept = default;
 
  //==============================================================//
  // INITIALIZATION AND STATUS
  //==============================================================//
 
  [[nodiscard]] bool IsInitialized() const noexcept;
 
  bool EnsureInitialized() noexcept;
 
  bool EnsureDeinitialized() noexcept;
 
  [[nodiscard]] hf_pin_num_t GetPin() const noexcept;
 
protected:
  //==============================================================//
  // [PROTECTED] PURE VIRTUAL IMPLEMENTATIONS - PLATFORM SPECIFIC
  //==============================================================//
 
  virtual hf_gpio_err_t SetDirectionImpl(hf_gpio_direction_t direction) noexcept = 0;
  virtual hf_gpio_err_t GetDirectionImpl(hf_gpio_direction_t& direction) const noexcept = 0;
 
  virtual hf_gpio_err_t SetOutputModeImpl(hf_gpio_output_mode_t mode) noexcept = 0;
  virtual hf_gpio_err_t GetOutputModeImpl(hf_gpio_output_mode_t& mode) const noexcept = 0;
 
  virtual hf_gpio_err_t SetPullModeImpl(hf_gpio_pull_mode_t mode) noexcept = 0;
  virtual hf_gpio_pull_mode_t GetPullModeImpl() const noexcept = 0;
 
  virtual hf_gpio_err_t SetPinLevelImpl(hf_gpio_level_t level) noexcept = 0;
  virtual hf_gpio_err_t GetPinLevelImpl(hf_gpio_level_t& level) noexcept = 0;
 
public:
  //==============================================================//
  // DIRECTION AND MODE MANAGEMENT
  //==============================================================//
 
  [[nodiscard]] hf_gpio_direction_t GetDirection() const noexcept;
 
  hf_gpio_err_t SetDirection(hf_gpio_direction_t direction) noexcept;
 
  [[nodiscard]] bool IsInput() const noexcept;
 
  [[nodiscard]] bool IsOutput() const noexcept;
 
  [[nodiscard]] hf_gpio_output_mode_t GetOutputMode() const noexcept;
 
  hf_gpio_err_t SetOutputMode(hf_gpio_output_mode_t mode) noexcept;
 
  //==============================================================//
  // PULL RESISTOR MANAGEMENT
  //==============================================================//
 
  [[nodiscard]] hf_gpio_pull_mode_t GetPullMode() const noexcept;
 
  hf_gpio_err_t SetPullMode(hf_gpio_pull_mode_t mode) noexcept;
 
  //==============================================================//
  // STATE MANAGEMENT AND I/O OPERATIONS
  //==============================================================//
 
  [[nodiscard]] hf_gpio_state_t GetCurrentState() const noexcept;
 
  hf_gpio_err_t SetState(hf_gpio_state_t state) noexcept;
 
  [[nodiscard]] hf_gpio_active_state_t GetActiveState() const noexcept;
 
  void SetActiveState(hf_gpio_active_state_t active_state) noexcept;
 
  //==============================================================//
  // STATE CONTROL METHODS
  //==============================================================//
 
  hf_gpio_err_t SetActive() noexcept;
 
  hf_gpio_err_t SetInactive() noexcept;
 
  hf_gpio_err_t Toggle() noexcept;
 
  hf_gpio_err_t IsActive(bool& is_active) noexcept;
 
  //==============================================================//
  // HARDWARE VERIFICATION AND FAULT DETECTION
  //==============================================================//
 
  hf_gpio_err_t VerifyDirection(hf_gpio_direction_t& direction) const noexcept;
 
  hf_gpio_err_t VerifyOutputMode(hf_gpio_output_mode_t& mode) const noexcept;
 
  hf_gpio_err_t VerifyHardwareConfiguration() const noexcept;
 
  //==============================================================//
  // HARDWARE ABSTRACTION INTERFACE
  //==============================================================//
 
  [[nodiscard]] virtual bool IsPinAvailable() const noexcept = 0;
 
  [[nodiscard]] virtual hf_u8_t GetMaxPins() const noexcept = 0;
  [[nodiscard]] virtual const char* GetDescription() const noexcept = 0;
 
  //==============================================================//
  // INTERRUPT FUNCTIONALITY
  //==============================================================//
 
  [[nodiscard]] virtual hf_gpio_err_t SupportsInterrupts() const noexcept {
    return hf_gpio_err_t::GPIO_ERR_NOT_SUPPORTED; // Default implementation - no interrupt support
  }
 
  virtual hf_gpio_err_t ConfigureInterrupt(hf_gpio_interrupt_trigger_t trigger,
                                           InterruptCallback callback = nullptr,
                                           void* user_data = nullptr) noexcept {
    return hf_gpio_err_t::GPIO_ERR_NOT_SUPPORTED;
  }
 
  virtual hf_gpio_err_t EnableInterrupt() noexcept {
    return hf_gpio_err_t::GPIO_ERR_NOT_SUPPORTED;
  }
 
  virtual hf_gpio_err_t DisableInterrupt() noexcept {
    return hf_gpio_err_t::GPIO_ERR_NOT_SUPPORTED;
  }
 
  virtual hf_gpio_err_t WaitForInterrupt(hf_u32_t timeout_ms = 0) noexcept {
    return hf_gpio_err_t::GPIO_ERR_NOT_SUPPORTED;
  }
 
  virtual hf_gpio_err_t GetInterruptStatus(InterruptStatus& status) noexcept {
    return hf_gpio_err_t::GPIO_ERR_NOT_SUPPORTED;
  }
 
  virtual hf_gpio_err_t ClearInterruptStats() noexcept {
    return hf_gpio_err_t::GPIO_ERR_NOT_SUPPORTED;
  }
 
  //==============================================================//
  // STATISTICS AND DIAGNOSTICS
  //==============================================================//
 
  virtual hf_gpio_err_t ResetStatistics() noexcept {
    statistics_ = hf_gpio_statistics_t{}; // Reset statistics to default values
    return hf_gpio_err_t::GPIO_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_gpio_err_t ResetDiagnostics() noexcept {
    diagnostics_ = hf_gpio_diagnostics_t{}; // Reset diagnostics to default values
    return hf_gpio_err_t::GPIO_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_gpio_err_t GetStatistics(hf_gpio_statistics_t& statistics) const noexcept {
    statistics = statistics_; // Return statistics by default
    return hf_gpio_err_t::GPIO_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_gpio_err_t GetDiagnostics(hf_gpio_diagnostics_t& diagnostics) const noexcept {
    diagnostics = diagnostics_; // Return diagnostics by default
    return hf_gpio_err_t::GPIO_ERR_UNSUPPORTED_OPERATION;
  }
 
  //==============================================================//
  // STRING CONVERSION UTILITIES
  //==============================================================//
  static const char* ToString(hf_gpio_state_t state) noexcept;
  static const char* ToString(hf_gpio_level_t level) noexcept;
  static const char* ToString(hf_gpio_active_state_t active_state) noexcept;
  static const char* ToString(hf_gpio_direction_t direction) noexcept;
  static const char* ToString(hf_gpio_output_mode_t output_mode) noexcept;
  static const char* ToString(hf_gpio_pull_mode_t pull_mode) noexcept;
  static const char* ToString(hf_gpio_interrupt_trigger_t trigger) noexcept;
 
  //==============================================================//
  // PURE VIRTUAL FUNCTIONS - MUST BE IMPLEMENTED BY DERIVED CLASSES
  //==============================================================//
 
  virtual bool Initialize() noexcept = 0;
 
  virtual bool Deinitialize() noexcept {
    initialized_ = false;
    return true;
  }
 
protected:
  //==============================================================//
  // PROTECTED HELPER METHODS
  //==============================================================//
 
  [[nodiscard]] hf_gpio_err_t ValidateBasicOperation() const noexcept;
 
  [[nodiscard]] hf_gpio_level_t StateToLevel(hf_gpio_state_t state) const noexcept;
 
  [[nodiscard]] hf_gpio_state_t LevelToState(hf_gpio_level_t level) const noexcept;
 
  explicit BaseGpio(
      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) noexcept
      : pin_(pin_num), initialized_(false), current_direction_(direction),
        active_state_(active_state), output_mode_(output_mode), pull_mode_(pull_mode),
        current_state_(hf_gpio_state_t::HF_GPIO_STATE_INACTIVE), statistics_{}, diagnostics_{} {}
 
  //==============================================================//
  // MEMBER VARIABLES
  //==============================================================//
 
  const hf_pin_num_t pin_;                
  bool initialized_;                      
  hf_gpio_direction_t current_direction_; 
  hf_gpio_active_state_t active_state_;   
  hf_gpio_output_mode_t output_mode_;     
  hf_gpio_pull_mode_t pull_mode_;         
  hf_gpio_state_t current_state_;         
  hf_gpio_statistics_t statistics_;       
  hf_gpio_diagnostics_t diagnostics_;     
};
 
//==============================================================//
// MEMBER FUNCTION DEFINITIONS
//==============================================================//
 
// Initialization and Status Methods
inline bool BaseGpio::IsInitialized() const noexcept {
  return initialized_;
}
 
inline bool BaseGpio::EnsureInitialized() noexcept {
  if (!initialized_) {
    initialized_ = Initialize();
  }
  return initialized_;
}
 
inline bool BaseGpio::EnsureDeinitialized() noexcept {
  if (initialized_) {
    initialized_ = !Deinitialize();
    return !initialized_;
  }
  return true;
}
 
inline hf_pin_num_t BaseGpio::GetPin() const noexcept {
  return pin_;
}
 
// Direction and Mode Management Methods
inline hf_gpio_direction_t BaseGpio::GetDirection() const noexcept {
  return current_direction_;
}
 
inline hf_gpio_err_t BaseGpio::SetDirection(hf_gpio_direction_t direction) noexcept {
  hf_gpio_err_t validation = ValidateBasicOperation();
  if (validation != hf_gpio_err_t::GPIO_SUCCESS) {
    return validation;
  }
 
  hf_gpio_err_t result = SetDirectionImpl(direction);
  if (result == hf_gpio_err_t::GPIO_SUCCESS) {
    current_direction_ = direction;
  }
  return result;
}
 
//=================================================================//
//=================================================================//
//                      FUNCTION DEFINITIONS                       //
//=================================================================//
//=================================================================//
 
inline bool BaseGpio::IsInput() const noexcept {
  return current_direction_ == hf_gpio_direction_t::HF_GPIO_DIRECTION_INPUT;
}
 
inline bool BaseGpio::IsOutput() const noexcept {
  return current_direction_ == hf_gpio_direction_t::HF_GPIO_DIRECTION_OUTPUT;
}
 
inline hf_gpio_output_mode_t BaseGpio::GetOutputMode() const noexcept {
  return output_mode_;
}
 
inline hf_gpio_err_t BaseGpio::SetOutputMode(hf_gpio_output_mode_t mode) noexcept {
  hf_gpio_err_t validation = ValidateBasicOperation();
  if (validation != hf_gpio_err_t::GPIO_SUCCESS) {
    return validation;
  }
 
  hf_gpio_err_t result = SetOutputModeImpl(mode);
  if (result == hf_gpio_err_t::GPIO_SUCCESS) {
    output_mode_ = mode;
  }
  return result;
}
 
// Pull Resistor Management Methods
inline hf_gpio_pull_mode_t BaseGpio::GetPullMode() const noexcept {
  return pull_mode_;
}
 
inline hf_gpio_err_t BaseGpio::SetPullMode(hf_gpio_pull_mode_t mode) noexcept {
  hf_gpio_err_t validation = ValidateBasicOperation();
  if (validation != hf_gpio_err_t::GPIO_SUCCESS) {
    return validation;
  }
 
  hf_gpio_err_t result = SetPullModeImpl(mode);
  if (result == hf_gpio_err_t::GPIO_SUCCESS) {
    pull_mode_ = mode;
  }
  return result;
}
 
// State Management and I/O Operations Methods
inline hf_gpio_state_t BaseGpio::GetCurrentState() const noexcept {
  return current_state_;
}
 
inline hf_gpio_err_t BaseGpio::SetState(hf_gpio_state_t state) noexcept {
  hf_gpio_err_t validation = ValidateBasicOperation();
  if (validation != hf_gpio_err_t::GPIO_SUCCESS) {
    return validation;
  }
 
  // Convert logical state to electrical level based on polarity
  hf_gpio_level_t level = StateToLevel(state);
  hf_gpio_err_t result = SetPinLevelImpl(level);
  if (result == hf_gpio_err_t::GPIO_SUCCESS) {
    current_state_ = state;
  }
  return result;
}
 
inline hf_gpio_active_state_t BaseGpio::GetActiveState() const noexcept {
  return active_state_;
}
 
inline void BaseGpio::SetActiveState(hf_gpio_active_state_t active_state) noexcept {
  active_state_ = active_state;
}
 
// State Control Methods
inline hf_gpio_err_t BaseGpio::SetActive() noexcept {
  hf_gpio_err_t validation = ValidateBasicOperation();
  if (validation != hf_gpio_err_t::GPIO_SUCCESS) {
    return validation;
  }
 
  // Convert logical state to electrical level based on polarity
  hf_gpio_level_t level = StateToLevel(hf_gpio_state_t::HF_GPIO_STATE_ACTIVE);
  hf_gpio_err_t result = SetPinLevelImpl(level);
  if (result == hf_gpio_err_t::GPIO_SUCCESS) {
    current_state_ = hf_gpio_state_t::HF_GPIO_STATE_ACTIVE;
  }
  return result;
}
 
inline hf_gpio_err_t BaseGpio::SetInactive() noexcept {
  hf_gpio_err_t validation = ValidateBasicOperation();
  if (validation != hf_gpio_err_t::GPIO_SUCCESS) {
    return validation;
  }
 
  // Convert logical state to electrical level based on polarity
  hf_gpio_level_t level = StateToLevel(hf_gpio_state_t::HF_GPIO_STATE_INACTIVE);
  hf_gpio_err_t result = SetPinLevelImpl(level);
  if (result == hf_gpio_err_t::GPIO_SUCCESS) {
    current_state_ = hf_gpio_state_t::HF_GPIO_STATE_INACTIVE;
  }
  return result;
}
 
inline hf_gpio_err_t BaseGpio::Toggle() noexcept {
  hf_gpio_err_t validation = ValidateBasicOperation();
  if (validation != hf_gpio_err_t::GPIO_SUCCESS) {
    return validation;
  }
 
  // Read current level, invert it, and set the new level
  hf_gpio_level_t current_level;
  hf_gpio_err_t result = GetPinLevelImpl(current_level);
  if (result != hf_gpio_err_t::GPIO_SUCCESS) {
    return result;
  }
 
  hf_gpio_level_t new_level = (current_level == hf_gpio_level_t::HF_GPIO_LEVEL_HIGH)
                                  ? hf_gpio_level_t::HF_GPIO_LEVEL_LOW
                                  : hf_gpio_level_t::HF_GPIO_LEVEL_HIGH;
 
  result = SetPinLevelImpl(new_level);
  if (result == hf_gpio_err_t::GPIO_SUCCESS) {
    current_state_ = LevelToState(new_level);
  }
  return result;
}
 
inline hf_gpio_err_t BaseGpio::IsActive(bool& is_active) noexcept {
  hf_gpio_err_t validation = ValidateBasicOperation();
  if (validation != hf_gpio_err_t::GPIO_SUCCESS) {
    return validation;
  }
 
  hf_gpio_level_t level;
  hf_gpio_err_t result = GetPinLevelImpl(level);
  if (result == hf_gpio_err_t::GPIO_SUCCESS) {
    hf_gpio_state_t state = LevelToState(level);
    is_active = (state == hf_gpio_state_t::HF_GPIO_STATE_ACTIVE);
    current_state_ = state;
  }
  return result;
}
 
// Protected Helper Methods
inline hf_gpio_err_t BaseGpio::ValidateBasicOperation() const noexcept {
  if (!initialized_) {
    return hf_gpio_err_t::GPIO_ERR_NOT_INITIALIZED;
  }
  if (!IsPinAvailable()) {
    return hf_gpio_err_t::GPIO_ERR_PIN_ACCESS_DENIED;
  }
  return hf_gpio_err_t::GPIO_SUCCESS;
}
 
inline hf_gpio_level_t BaseGpio::StateToLevel(hf_gpio_state_t state) const noexcept {
  bool active_high = (active_state_ == hf_gpio_active_state_t::HF_GPIO_ACTIVE_HIGH);
  bool should_be_high =
      (state == hf_gpio_state_t::HF_GPIO_STATE_ACTIVE) ? active_high : !active_high;
  return should_be_high ? hf_gpio_level_t::HF_GPIO_LEVEL_HIGH : hf_gpio_level_t::HF_GPIO_LEVEL_LOW;
}
 
inline hf_gpio_state_t BaseGpio::LevelToState(hf_gpio_level_t level) const noexcept {
  bool active_high = (active_state_ == hf_gpio_active_state_t::HF_GPIO_ACTIVE_HIGH);
  bool is_high = (level == hf_gpio_level_t::HF_GPIO_LEVEL_HIGH);
  return (is_high == active_high) ? hf_gpio_state_t::HF_GPIO_STATE_ACTIVE
                                  : hf_gpio_state_t::HF_GPIO_STATE_INACTIVE;
}
 
//==============================================================//
// STRING CONVERSION IMPLEMENTATIONS
//==============================================================//
 
inline const char* BaseGpio::ToString(hf_gpio_state_t state) noexcept {
  switch (state) {
  case hf_gpio_state_t::HF_GPIO_STATE_ACTIVE:
    return "Active";
  case hf_gpio_state_t::HF_GPIO_STATE_INACTIVE:
    return "Inactive";
  default:
    return "Unknown";
  }
}
 
inline const char* BaseGpio::ToString(hf_gpio_level_t level) noexcept {
  switch (level) {
  case hf_gpio_level_t::HF_GPIO_LEVEL_HIGH:
    return "High";
  case hf_gpio_level_t::HF_GPIO_LEVEL_LOW:
    return "Low";
  default:
    return "Unknown";
  }
}
 
inline const char* BaseGpio::ToString(hf_gpio_active_state_t active_state) noexcept {
  switch (active_state) {
  case hf_gpio_active_state_t::HF_GPIO_ACTIVE_HIGH:
    return "ActiveHigh";
  case hf_gpio_active_state_t::HF_GPIO_ACTIVE_LOW:
    return "ActiveLow";
  default:
    return "Unknown";
  }
}
 
inline const char* BaseGpio::ToString(hf_gpio_direction_t direction) noexcept {
  switch (direction) {
  case hf_gpio_direction_t::HF_GPIO_DIRECTION_INPUT:
    return "Input";
  case hf_gpio_direction_t::HF_GPIO_DIRECTION_OUTPUT:
    return "Output";
  default:
    return "Unknown";
  }
}
 
inline const char* BaseGpio::ToString(hf_gpio_output_mode_t output_mode) noexcept {
  switch (output_mode) {
  case hf_gpio_output_mode_t::HF_GPIO_OUTPUT_MODE_PUSH_PULL:
    return "PushPull";
  case hf_gpio_output_mode_t::HF_GPIO_OUTPUT_MODE_OPEN_DRAIN:
    return "OpenDrain";
  default:
    return "Unknown";
  }
}
 
inline const char* BaseGpio::ToString(hf_gpio_pull_mode_t pull_mode) noexcept {
  switch (pull_mode) {
  case hf_gpio_pull_mode_t::HF_GPIO_PULL_MODE_FLOATING:
    return "Floating";
  case hf_gpio_pull_mode_t::HF_GPIO_PULL_MODE_UP:
    return "PullUp";
  case hf_gpio_pull_mode_t::HF_GPIO_PULL_MODE_DOWN:
    return "PullDown";
  case hf_gpio_pull_mode_t::HF_GPIO_PULL_MODE_UP_DOWN:
    return "PullUpDown";
  default:
    return "Unknown";
  }
}
 
inline const char* BaseGpio::ToString(hf_gpio_interrupt_trigger_t trigger) noexcept {
  switch (trigger) {
  case hf_gpio_interrupt_trigger_t::HF_GPIO_INTERRUPT_TRIGGER_NONE:
    return "None";
  case hf_gpio_interrupt_trigger_t::HF_GPIO_INTERRUPT_TRIGGER_RISING_EDGE:
    return "RisingEdge";
  case hf_gpio_interrupt_trigger_t::HF_GPIO_INTERRUPT_TRIGGER_FALLING_EDGE:
    return "FallingEdge";
  case hf_gpio_interrupt_trigger_t::HF_GPIO_INTERRUPT_TRIGGER_BOTH_EDGES:
    return "BothEdges";
  case hf_gpio_interrupt_trigger_t::HF_GPIO_INTERRUPT_TRIGGER_LOW_LEVEL:
    return "LowLevel";
  case hf_gpio_interrupt_trigger_t::HF_GPIO_INTERRUPT_TRIGGER_HIGH_LEVEL:
    return "HighLevel";
  default:
    return "Unknown";
  }
}
 
//==============================================================//
// HARDWARE VERIFICATION IMPLEMENTATIONS
//==============================================================//
 
inline hf_gpio_err_t BaseGpio::VerifyDirection(hf_gpio_direction_t& direction) const noexcept {
  if (!initialized_) {
    return hf_gpio_err_t::GPIO_ERR_NOT_INITIALIZED;
  }
 
  // Read actual hardware direction
  hf_gpio_err_t result = GetDirectionImpl(direction);
  if (result != hf_gpio_err_t::GPIO_SUCCESS) {
    return result;
  }
 
  // Compare with cached value for fault detection
  if (direction != current_direction_) {
    // Hardware mismatch detected - potential fault!
    return hf_gpio_err_t::GPIO_ERR_HARDWARE_FAULT;
  }
 
  return hf_gpio_err_t::GPIO_SUCCESS;
}
 
inline hf_gpio_err_t BaseGpio::VerifyOutputMode(hf_gpio_output_mode_t& mode) const noexcept {
  if (!initialized_) {
    return hf_gpio_err_t::GPIO_ERR_NOT_INITIALIZED;
  }
 
  // Read actual hardware output mode
  hf_gpio_err_t result = GetOutputModeImpl(mode);
  if (result != hf_gpio_err_t::GPIO_SUCCESS) {
    return result;
  }
 
  // Compare with cached value for fault detection
  if (mode != output_mode_) {
    // Hardware mismatch detected - potential fault!
    return hf_gpio_err_t::GPIO_ERR_HARDWARE_FAULT;
  }
 
  return hf_gpio_err_t::GPIO_SUCCESS;
}
 
inline hf_gpio_err_t BaseGpio::VerifyHardwareConfiguration() const noexcept {
  if (!initialized_) {
    return hf_gpio_err_t::GPIO_ERR_NOT_INITIALIZED;
  }
 
  // Verify direction
  hf_gpio_direction_t hw_direction;
  hf_gpio_err_t result = VerifyDirection(hw_direction);
  if (result != hf_gpio_err_t::GPIO_SUCCESS) {
    return result;
  }
 
  // Verify output mode (only relevant for output pins)
  if (current_direction_ == hf_gpio_direction_t::HF_GPIO_DIRECTION_OUTPUT) {
    hf_gpio_output_mode_t hw_output_mode;
    result = VerifyOutputMode(hw_output_mode);
    if (result != hf_gpio_err_t::GPIO_SUCCESS) {
      return result;
    }
  }
 
  // Verify pull mode
  hf_gpio_pull_mode_t hw_pull_mode = GetPullModeImpl();
  if (hw_pull_mode != pull_mode_) {
    return hf_gpio_err_t::GPIO_ERR_HARDWARE_FAULT;
  }
 
  return hf_gpio_err_t::GPIO_SUCCESS;
}