feat: enhance LpTimerPwm with LL API and polarity configuration (#654)

* LpTimerPwmDelayed

* Use LL API to start and stop timer channels

Starting channels using the HAL API will automatically start the timer peripheral.
The LL API allow more control.

* Allow polarity configuration

* Rename to LpTimerPwm

* Apply suggested changes

Co-authored-by: Richard Peters <[email protected]>

---------

Co-authored-by: Richard Peters <[email protected]>

Author: fabiangottstein

hal_st/stm32fxxx/LpTimerPwmStm.cpp

@@ -47,19 +47,30 @@ namespace hal
 {
     LpTimerPwmBaseStm::LpTimerPwmBaseStm(uint8_t oneBasedIndex, LowPowerTimerBaseStm::Timing timing)
         : timer(oneBasedIndex, timing)
-    {}
+    {
+        LL_LPTIM_SetWaveform(timer.Handle().Instance, LL_LPTIM_OUTPUT_WAVEFORM_PWM);
+    }
 
     LpPwmChannelGpio& LpTimerPwmBaseStm::Channel(uint8_t channelOneBasedIndex)
     {
         return channels[channelOneBasedIndex - 1];
     }
 
-    void LpTimerPwmBaseStm::Start()
+    void LpTimerPwmBaseStm::StartTimer()
+    {
+        timer.Start();
+    }
+
+    void LpTimerPwmBaseStm::StartChannels()
     {
         for (auto& channel : channels)
             channel.Start();
+    }
 
-        timer.Start();
+    void LpTimerPwmBaseStm::Start()
+    {
+        StartChannels();
+        StartTimer();
     }
 
     void LpTimerPwmBaseStm::Stop()
@@ -70,19 +81,41 @@ namespace hal
             channel.Stop();
     }
 
-    LpPwmChannelGpio::LpPwmChannelGpio(uint8_t timerOneBasedIndex, uint8_t channelOneBasedIndex, LPTIM_HandleTypeDef& handle, GpioPinStm& pin)
+    LpTimerPwm::LpTimerPwm(infra::BoundedDeque<LpPwmChannelGpio>& channelStorage, uint8_t oneBasedIndex, LowPowerTimerBaseStm::Timing timing)
+        : LpTimerPwmBaseStm(oneBasedIndex, timing)
+        , channelStorage(channelStorage)
+        , oneBasedIndex(oneBasedIndex)
+    {}
+
+    LpPwmChannelGpio& LpTimerPwm::Channel(uint8_t channelOneBasedIndex)
+    {
+        for (auto& channel : channelStorage)
+        {
+            if (channel.channelIndex == channelOneBasedIndex - 1)
+                return channel;
+        }
+        std::abort();
+    }
+
+    void LpTimerPwm::ConfigureChannel(uint8_t channelOneBasedIndex, GpioPinStm& pin)
+    {
+        channelStorage.emplace_back(oneBasedIndex, channelOneBasedIndex, timer.Handle(), pin);
+        channels = channelStorage.contiguous_range(channelStorage.begin());
+    }
+
+    LpPwmChannelGpio::LpPwmChannelGpio(uint8_t timerOneBasedIndex, uint8_t channelOneBasedIndex, LPTIM_HandleTypeDef& handle, GpioPinStm& pin, uint32_t polarity)
         : timerIndex(timerOneBasedIndex - 1)
         , channelIndex(channelOneBasedIndex - 1)
         , handle(handle)
         , pin(pin, GetChannelPinConfig(channelIndex), timerOneBasedIndex)
         , ccr(GetCCRegister(handle.Instance, channelIndex))
     {
-        ConfigChannelInit();
+        ConfigurePolarity(polarity);
     }
 
-    void LpPwmChannelGpio::ConfigChannelInit()
+    void LpPwmChannelGpio::ConfigurePolarity(uint32_t polarity)
     {
-        LPTIM_OC_ConfigTypeDef sConfig = { .OCPolarity = LPTIM_OCPOLARITY_HIGH };
+        LPTIM_OC_ConfigTypeDef sConfig = { .OCPolarity = polarity };
         auto result = HAL_LPTIM_OC_ConfigChannel(&handle, &sConfig, GetLpTimerChannel(channelIndex));
         assert(result == HAL_OK);
     }
@@ -101,14 +134,12 @@ namespace hal
 
     void LpPwmChannelGpio::Start()
     {
-        auto result = HAL_LPTIM_PWM_Start(&handle, GetLpTimerChannel(channelIndex));
-        really_assert(result == HAL_OK);
+        LL_LPTIM_CC_EnableChannel(handle.Instance, GetLpTimerChannel(channelIndex));
     }
 
     void LpPwmChannelGpio::Stop()
     {
-        auto result = HAL_LPTIM_PWM_Stop(&handle, GetLpTimerChannel(channelIndex));
-        really_assert(result == HAL_OK);
+        LL_LPTIM_CC_DisableChannel(handle.Instance, GetLpTimerChannel(channelIndex));
     }
 }
 

hal_st/stm32fxxx/LpTimerPwmStm.hpp

@@ -4,6 +4,7 @@
 #include "hal/interfaces/PulseWidthModulation.hpp"
 #include "hal_st/stm32fxxx/GpioStm.hpp"
 #include "hal_st/stm32fxxx/LpTimerStm.hpp"
+#include "infra/util/BoundedDeque.hpp"
 #include "infra/util/MemoryRange.hpp"
 #include <array>
 #include <cstddef>
@@ -19,7 +20,7 @@ namespace hal
         template<typename T, std::size_t... Is>
         constexpr std::array<T, sizeof...(Is)> CreateArray(uint8_t timerOneBasedIndex, LPTIM_HandleTypeDef& handle, infra::MemoryRange<GpioPinStm> pins, std::index_sequence<Is...>)
         {
-            return {{(Is, T{timerOneBasedIndex, Is + 1, handle, pins[Is]})...}};
+            return { { (Is, T{ timerOneBasedIndex, Is + 1, handle, pins[Is] })... } };
         }
     }
 
@@ -36,8 +37,11 @@ namespace hal
     public:
         LpTimerPwmBaseStm(uint8_t oneBasedIndex, LowPowerTimerBaseStm::Timing timing);
 
-        LpPwmChannelGpio& Channel(uint8_t channelOneBasedIndex);
+        virtual LpPwmChannelGpio& Channel(uint8_t channelOneBasedIndex);
 
+        // Timer and configured channels can either be started independently from each other by invoking StartTimer() and StartChannels(), or together by invoking Start()
+        void StartTimer();
+        void StartChannels();
         void Start();
         void Stop();
 
@@ -62,25 +66,45 @@ namespace hal
         std::array<LpPwmChannelGpio, Channels> channelStorage;
     };
 
+    class LpTimerPwm
+        : public LpTimerPwmBaseStm
+    {
+    public:
+        template<std::size_t Channels>
+        using WithChannels = infra::WithStorage<LpTimerPwm, infra::BoundedDeque<LpPwmChannelGpio>::WithMaxSize<Channels>>;
+
+        LpTimerPwm(infra::BoundedDeque<LpPwmChannelGpio>& channelStorage, uint8_t oneBasedIndex, LowPowerTimerBaseStm::Timing timing);
+
+        void ConfigureChannel(uint8_t channelOneBasedIndex, GpioPinStm& pin);
+        LpPwmChannelGpio& Channel(uint8_t channelOneBasedIndex) override;
+
+    private:
+        infra::BoundedDeque<LpPwmChannelGpio>& channelStorage;
+        uint8_t oneBasedIndex;
+    };
+
     class LpPwmChannelGpio
         : public PulseWidthModulation
     {
     public:
-        LpPwmChannelGpio(uint8_t timerOneBasedIndex, uint8_t channelOneBasedIndex, LPTIM_HandleTypeDef& handle, GpioPinStm& pin);
+        LpPwmChannelGpio(uint8_t timerOneBasedIndex, uint8_t channelOneBasedIndex, LPTIM_HandleTypeDef& handle, GpioPinStm& pin, uint32_t polarity = LPTIM_OCPOLARITY_HIGH);
 
+        // Implementation of PulseWidthModulation
         void SetDuty(uint8_t dutyPercent) override;
         void SetPulse(uint32_t pulseOn, uint32_t period) override;
         void Start() override;
         void Stop() override;
 
+        void ConfigurePolarity(uint32_t polarity);
+
     private:
+        friend LpTimerPwm;
+
         uint8_t timerIndex;
         uint8_t channelIndex;
         LPTIM_HandleTypeDef& handle;
         PeripheralPinStm pin;
         volatile std::uint32_t* ccr;
-
-        void ConfigChannelInit();
     };
 }