[stm32] Add regular conversion sequences to F3 ADC driver

Author: chris-durand

src/modm/platform/adc/stm32f3/adc.hpp.in

@@ -15,10 +15,13 @@
 #ifndef MODM_STM32F3_ADC{{ id }}_HPP
 #define MODM_STM32F3_ADC{{ id }}_HPP
 
-#include <stdint.h>
+#include <cstdint>
+#include <span>
+#include <utility>
 #include "../device.hpp"
 #include <modm/architecture/interface/register.hpp>
 #include <modm/platform/gpio/connector.hpp>
+#include <modm/math/algorithm/enumerate.hpp>
 
 namespace modm
 {
@@ -260,6 +263,13 @@ public:
 		Cycles602 	= 0b111,	//< 601.5 ADC clock cycles
 	};
 %% endif
+
+	struct SequenceChannel
+	{
+		Channel channel{};
+		SampleTime sampleTime{};
+	};
+
 	enum class CalibrationMode : uint32_t
 	{
 		SingleEndedInputsMode = 0,
@@ -414,6 +424,9 @@ public:
 	setChannel(const Channel channel,
 			const SampleTime sampleTime=static_cast<SampleTime>(0b000));
 
+	static inline bool
+	setChannelSequence(std::span<const SequenceChannel> sequence);
+
 	/// Setting the channel for a Pin
 	template< class Gpio >
 	static inline bool
@@ -464,13 +477,19 @@ public:
 	static inline void
 	startConversion();
 
+	static inline void
+	stopConversion();
+
 	/**
 	 * @return If the conversion is finished.
 	 * @pre A conversion should have been started with startConversion()
 	 */
 	static inline bool
 	isConversionFinished();
 
+	static inline bool
+	isConversionSequenceFinished();
+
 	/**
 	 * Start a new injected conversion sequence.
 	 *

src/modm/platform/adc/stm32f3/adc_impl.hpp.in

@@ -211,7 +211,6 @@ modm::platform::Adc{{ id }}::configureChannel(Channel channel,
 
 }
 
-
 bool
 modm::platform::Adc{{ id }}::setChannel(Channel channel,
 										SampleTime sampleTime)
@@ -224,6 +223,42 @@ modm::platform::Adc{{ id }}::setChannel(Channel channel,
 	return true;
 }
 
+bool
+modm::platform::Adc{{ id }}::setChannelSequence(std::span<const SequenceChannel> sequence)
+{
+	if (sequence.size() > 16 || sequence.size() == 0) {
+		return false;
+	}
+
+	ADC{{ id }}->SQR1 = sequence.size() - 1;
+
+	for (const auto [i, config] : modm::enumerate(sequence)) {
+		const auto [channel, sampleTime] = config;
+		if (!configureChannel(channel, sampleTime)) {
+			return false;
+		}
+
+		if (i < 4) {
+			const auto shift = (i + 1) * 6;
+			const auto mask = 0b111111u << shift;
+			ADC{{ id }}->SQR1 = (ADC{{ id }}->SQR1 & ~mask) | (std::to_underlying(channel) << shift);
+		} else if (i < 9) {
+			const auto shift = (i - 4) * 6;
+			const auto mask = 0b111111u << shift;
+			ADC{{ id }}->SQR2 = (ADC{{ id }}->SQR2 & ~mask) | (std::to_underlying(channel) << shift);
+		} else if (i < 14) {
+			const auto shift = (i - 9) * 6;
+			const auto mask = 0b111111u << shift;
+			ADC{{ id }}->SQR3 = (ADC{{ id }}->SQR3 & ~mask) | (std::to_underlying(channel) << shift);
+		} else {
+			const auto shift = (i - 14) * 6;
+			const auto mask = 0b111111u << shift;
+			ADC{{ id }}->SQR4 = (ADC{{ id }}->SQR4 & ~mask) | (std::to_underlying(channel) << shift);
+		}
+	}
+	return true;
+}
+
 void
 modm::platform::Adc{{ id }}::setFreeRunningMode(const bool enable)
 {
@@ -239,17 +274,34 @@ modm::platform::Adc{{ id }}::startConversion()
 {
 	// TODO: maybe add more interrupt flags
 	acknowledgeInterruptFlags(InterruptFlag::EndOfRegularConversion |
-			InterruptFlag::EndOfSampling | InterruptFlag::Overrun);
+			InterruptFlag::EndOfSampling | InterruptFlag::Overrun |
+			InterruptFlag::EndOfRegularSequenceOfConversions);
 	// starts single conversion for the regular group
 	ADC{{ id }}->CR |= ADC_CR_ADSTART;
 }
 
+void
+modm::platform::Adc{{ id }}::stopConversion()
+{
+	ADC{{ id }}->CR |= ADC_CR_ADSTP | ADC_CR_JADSTP;
+	while ((ADC{{ id }}->CR & (ADC_CR_ADSTP | ADC_CR_JADSTP)) != 0);
+
+	acknowledgeInterruptFlags(InterruptFlag::EndOfRegularConversion |
+			InterruptFlag::EndOfSampling | InterruptFlag::Overrun);
+}
+
 bool
 modm::platform::Adc{{ id }}::isConversionFinished()
 {
 	return static_cast<bool>(getInterruptFlags() & InterruptFlag::EndOfRegularConversion);
 }
 
+bool
+modm::platform::Adc{{ id }}::isConversionSequenceFinished()
+{
+	return static_cast<bool>(getInterruptFlags() & InterruptFlag::EndOfRegularSequenceOfConversions);
+}
+
 void
 modm::platform::Adc{{ id }}::startInjectedConversionSequence()
 {

src/modm/platform/adc/stm32f3/module.lb

@@ -21,7 +21,7 @@ class Instance(Module):
         module.description = "Instance {}".format(self.instance)
 
     def prepare(self, module, options):
-        module.depends(":platform:adc")
+        module.depends(":platform:adc", ":math:algorithm")
         return True
 
     def build(self, env):