input.hpp

Go to the documentation of this file.

/**
 * @file input.hpp
 * @brief Pot input convenience functions
 * @ingroup hal
 *
 * Composes ADC driver reads with Pot update in a single call.
 * Same pattern as sbl::cv::read<Driver>() / sbl::cv::read_dma().
 *
 * Usage:
 *   #include <sbl/hal/pot/input.hpp>
 *
 *   sbl::pot::read<sbl::driver::Adc>(knob, handle, SampleTime::Slow);
 *   sbl::pot::read_dma(knob, adc_buf, 0);
 */
 
#ifndef SBL_HAL_POT_INPUT_HPP_
#define SBL_HAL_POT_INPUT_HPP_
 
#include <sbl/hal/adc/driver.hpp>
#include <sbl/components/control/pot.hpp>
 
namespace sbl {
namespace pot {
 
using Pot = sbl::components::control::Pot;
using PotConfig = sbl::components::control::PotConfig;
 
/**
 * @brief Read ADC channel and feed into Pot (EWMA + deadband)
 *
 * Blocking read followed by Pot::update(). Returns the stable value.
 *
 * @tparam Driver ADC driver type (e.g., sbl::driver::Adc)
 * @param pot     Pot instance to update
 * @param handle  ADC channel handle
 * @param sample_time Sampling duration (default: Slow for pot sources)
 * @return Stable (deadbanded) value (0-65535)
 *
 * @note Not ISR-safe — wraps blocking ADC polling read
 */
template<typename Driver>
inline uint16_t read(Pot& pot, const AdcHandle& handle,
                     adc::SampleTime sample_time = adc::SampleTime::Slow) {
    uint16_t raw = adc::read<Driver>(handle, sample_time);
    pot.update(raw);
    return pot.value();
}
 
/**
 * @brief Read from DMA scan buffer and feed into Pot
 *
 * For use with sbl::adc::start_scan(). Casts to volatile to ensure the
 * compiler generates a real memory read (buffer updated by DMA hardware).
 *
 * @param pot           Pot instance to update
 * @param buffer        DMA scan buffer (from start_scan)
 * @param channel_index Index of this channel in the scan sequence
 * @return Stable (deadbanded) value (0-65535)
 *
 * @note ISR-safe — volatile DMA buffer read, no blocking
 */
inline uint16_t read_dma(Pot& pot, const uint16_t* buffer,
                         uint8_t channel_index) {
    auto raw = static_cast<const volatile uint16_t*>(buffer)[channel_index];
    pot.update(raw);
    return pot.value();
}
 
} // namespace pot
} // namespace sbl
 
#endif // SBL_HAL_POT_INPUT_HPP_