input.hpp

Go to the documentation of this file.

/**
 * @file input.hpp
 * @brief CV input convenience functions
 * @ingroup hal
 *
 * Composes ADC driver reads with CvInput update in a single call.
 * Mirrors the sbl::adc::read<Driver>() pattern.
 *
 * Usage:
 *   #include <sbl/hal/cv/input.hpp>
 *
 *   sbl::cv::read<sbl::driver::Adc>(knob, handle, SampleTime::Slow);
 */
 
#ifndef SBL_HAL_CV_INPUT_HPP_
#define SBL_HAL_CV_INPUT_HPP_
 
#include <sbl/hal/adc/driver.hpp>
#include <sbl/components/cv/input.hpp>
 
namespace sbl {
namespace cv {
 
using CvInput = sbl::components::cv::CvInput;
using CvInputConfig = sbl::components::cv::CvInputConfig;
using Smoothing = sbl::components::cv::Smoothing;
 
/**
 * @brief Read ADC channel and feed into CvInput filter
 *
 * Blocking read followed by CvInput::update(). Returns the smoothed value.
 *
 * @tparam Driver ADC driver type (e.g., sbl::driver::Adc)
 * @param input CvInput instance to update
 * @param handle ADC channel handle
 * @param sample_time Sampling duration (default: Slow for pot sources)
 * @return Smoothed value (0–65535)
 *
 * @note Not ISR-safe — wraps blocking ADC polling read
 */
template<typename Driver>
inline uint16_t read(CvInput& input, const AdcHandle& handle,
                     adc::SampleTime sample_time = adc::SampleTime::Slow) {
    uint16_t raw = adc::read<Driver>(handle, sample_time);
    input.update(raw);
    return input.value();
}
 
/**
 * @brief Read from DMA scan buffer and feed into CvInput filter
 *
 * For use with sbl::adc::start_scan(). The DMA buffer is the abstraction
 * boundary — no driver template needed. Casts to volatile to ensure the
 * compiler generates a real memory read (buffer is updated by DMA hardware).
 *
 * @param input         CvInput instance to update
 * @param buffer        DMA scan buffer (from start_scan)
 * @param channel_index Index of this channel in the scan sequence
 * @return Smoothed value (0–65535)
 *
 * @note ISR-safe — volatile DMA buffer read, no blocking
 */
inline uint16_t read_dma(CvInput& input, const uint16_t* buffer,
                         uint8_t channel_index) {
    // Volatile cast forces a real memory read — DMA updates this asynchronously
    auto raw = static_cast<const volatile uint16_t*>(buffer)[channel_index];
    input.update(raw);
    return input.value();
}
 
} // namespace cv
} // namespace sbl
 
#endif // SBL_HAL_CV_INPUT_HPP_