adc/adc.hpp

#ifndef ADC_HPP
#define ADC_HPP

#include "config.hpp"
#include "hardware.hpp"

#include <stdint.h>

#include "../io/io.hpp"

namespace adc {

namespace detail {

extern void (*fnAdcIntHandler)(uint16_t);

using reg_ptr_t = volatile uint8_t *;

template <uintptr_t Address>
static inline reg_ptr_t getRegPtr()
{
	return reinterpret_cast<reg_ptr_t>(Address);
}

template <typename Cfg>
class AdcImpl {
  public:
	static uint16_t read()
	{
		return 0;
	}

  protected:
	static void init(uint8_t muxVal)
	{
		*getRegPtr<Registers::MUX_SEL_ADDR>() = muxVal | calcRef();
	}

	static constexpr auto calcRef()
	{
		uint8_t muxVal = 0;

		if constexpr (Cfg::VREF == VoltageRef::AVCC) {
			muxVal |= 1 << ControlFlagsMUX::REF_SEL_0;
		} else if constexpr (Cfg::VREF == VoltageRef::INTERNAL) {
			muxVal |= (1 << ControlFlagsMUX::REF_SEL_0) | (1 << ControlFlagsMUX::REF_SEL_1);
		}

		return muxVal;
	}
};

} // namespace detail

template <typename Cfg, typename Input, Input src>
class Adc {
  public:
	static_assert(sizeof(Input) == -1, "Invalid input source selected");
};

template <typename Cfg, io::P pin>
class Adc<Cfg, io::P, pin> : public detail::AdcImpl<Cfg> {
	using callback_t = void (*)(uint16_t);

  public:
	static_assert(detail::supports_adc_v<pin>, "Pin does not support ADC");

	static void init(callback_t callback)
	{
		detail::fnAdcIntHandler = callback;
		init();
	}

	static void init()
	{
		constexpr auto muxVal = calcChannel();
		detail::AdcImpl<Cfg>::init(muxVal);
	}

  private:
	static constexpr auto calcChannel()
	{
		return static_cast<uint8_t>(pin) - static_cast<uint8_t>(io::P::C0);
	}
};

template <typename Cfg, InputSource src>
class Adc<Cfg, InputSource, src> : public detail::AdcImpl<Cfg> {
	using callback_t = void (*)(uint16_t);

  public:
	static void init(callback_t callback)
	{
		detail::fnAdcIntHandler = callback;
		init();
	}

	static void init()
	{
		constexpr auto muxVal = calcChannel();
		detail::AdcImpl<Cfg>::init(muxVal);
	}

  private:
	static constexpr auto calcChannel()
	{
		using mx = detail::ControlFlagsMUX;
		// clang-format off
		switch (src) {
		case InputSource::TEMP: return 1 << mx::CHANNEL_SEL_3;
		case InputSource::VBG: return (1 << mx::CHANNEL_SEL_3) | (1 << mx::CHANNEL_SEL_2) | (1 << mx::CHANNEL_SEL_1);
		case InputSource::GND: return (1 << mx::CHANNEL_SEL_3) | (1 << mx::CHANNEL_SEL_2) | (1 << mx::CHANNEL_SEL_1) | (1 << mx::CHANNEL_SEL_0);
		}
		// clang-format on
	}
};

} // namespace adc

#endif

//////////////////////////////////////////////////////////////////////////

#ifdef ADC_INT_VECTOR

#include <stdint.h>

#include <avr/interrupt.h>

namespace adc {
namespace detail {

#if defined(__AVR_ATmega1284P__) || defined(__AVR_ATmega328P__)

void (*fnAdcIntHandler)(uint16_t) = nullptr;

ISR(ADC_vect)
{
	if (fnAdcIntHandler) {
		const auto adcSample = *getRegPtr<Registers::DATA_L_ADDR>() | (*getRegPtr<Registers::DATA_H_ADDR>() << 8);
		fnAdcIntHandler(adcSample);
	}
}

#else
#error "This chip is not supported"
#endif

} // namespace detail
} // namespace adc

#undef ADC_INT_VECTORS

#endif