adc_requirements.hpp

Go to the documentation of this file.

/**
 * @file adc_requirements.hpp
 * @brief ADC driver requirements validator
 * @ingroup validation
 *
 * Validates that ADC drivers provide required functionality using the
 * method detection system. This is the core ADC contract enforcement
 * for Sound Byte Libs drivers.
 *
 * ## ADC Driver Contract
 *
 * Every Sound Byte Libs ADC driver MUST implement these methods:
 * - `init() -> bool` - Initialize ADC peripheral
 * - `configure_channel(const AdcHandle&, SampleTime)` - Configure channel
 * - `start_conversion(const AdcHandle&)` - Start single conversion
 * - `is_conversion_complete() -> bool` - Check if conversion done
 * - `read_raw() -> uint16_t` - Read conversion result
 * - `resolution_bits() -> uint8_t` - Get ADC resolution (constexpr)
 *
 * Optional methods (validated if present):
 * - `start_dma_scan(const AdcHandle*, uint8_t, uint16_t*, SampleTime)` - DMA scan
 * - `stop_dma_scan()` - Stop DMA scan
 *
 * ## Validation Usage
 *
 * Add validation at the bottom of driver adc.hpp:
 * ```cpp
 * #include <sbl/validation/adc_requirements.hpp>
 * static_assert(sbl::validation::adc_driver_valid<sbl::driver::Adc>,
 *               "ADC driver missing required methods");
 * ```
 *
 * @see method_detection.hpp
 */
 
#ifndef SBL_VALIDATION_ADC_REQUIREMENTS_HPP_
#define SBL_VALIDATION_ADC_REQUIREMENTS_HPP_
 
#include "method_detection.hpp"
 
namespace sbl {
namespace validation {
 
/**
 * @brief ADC driver requirements validator
 *
 * Validates that ADC drivers provide all required methods.
 */
template<typename AdcDriver>
class AdcDriverRequirements {
public:
    /**
     * @brief Validate all required ADC methods
     */
    static constexpr bool validate() {
        // --- Required methods ---
 
        static_assert(has_adc_init<AdcDriver>::value,
                      "SBL ERROR: ADC driver missing init() method.\n"
                      "Required: static bool init()");
 
        static_assert(has_adc_configure_channel<AdcDriver>::value,
                      "SBL ERROR: ADC driver missing configure_channel() method.\n"
                      "Required: static void configure_channel(const AdcHandle&, SampleTime)");
 
        static_assert(has_adc_start_conversion<AdcDriver>::value,
                      "SBL ERROR: ADC driver missing start_conversion() method.\n"
                      "Required: static void start_conversion(const AdcHandle&)");
 
        static_assert(has_adc_is_conversion_complete<AdcDriver>::value,
                      "SBL ERROR: ADC driver missing is_conversion_complete() method.\n"
                      "Required: static bool is_conversion_complete()");
 
        static_assert(has_adc_read_raw<AdcDriver>::value,
                      "SBL ERROR: ADC driver missing read_raw() method.\n"
                      "Required: static uint16_t read_raw()");
 
        static_assert(has_adc_resolution_bits<AdcDriver>::value,
                      "SBL ERROR: ADC driver missing resolution_bits() method.\n"
                      "Required: static constexpr uint8_t resolution_bits()");
 
        // --- Optional methods (validated if present) ---
        // DMA scan is platform-specific (STM32H7 only currently).
        // If start_dma_scan is present, stop_dma_scan should be too.
 
        static_assert(
            !has_adc_start_dma_scan<AdcDriver>::value ||
            has_adc_stop_dma_scan<AdcDriver>::value,
            "SBL ERROR: ADC provides start_dma_scan() but not stop_dma_scan().\n"
            "Both must be present for DMA scan support.");
 
        return true;
    }
};
 
/**
 * @brief Helper to validate an ADC driver implementation
 *
 * Usage:
 * ```cpp
 * static_assert(sbl::validation::adc_driver_valid<MyAdcDriver>,
 *               "ADC driver incomplete");
 * ```
 */
template<typename AdcDriver>
constexpr bool adc_driver_valid = AdcDriverRequirements<AdcDriver>::validate();
 
} // namespace validation
} // namespace sbl
 
#endif // SBL_VALIDATION_ADC_REQUIREMENTS_HPP_