add a stm32 LPTIM encoder

Author: Richard Unger

src/encoders/stm32lpencoder/PinMap_LPTIM.c

@@ -0,0 +1,38 @@
+#include "Arduino.h"
+
+#ifdef HAL_LPTIM_MODULE_ENABLED
+
+
+// TODO which models does this apply to? the entire series, or the line?
+#if defined(STM32G431KB) || defined(STM32G431CB)
+WEAK const PinMap PinMap_LPTIM[] = {
+  {PB_5,       LPTIM1,  STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF11_LPTIM1, 0, 0)}, // LPTIM1_CH1
+  {PB_7,       LPTIM1,  STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF11_LPTIM1, 1, 0)}, // LPTIM1_CH2
+  {NC,         NP,    0}
+};
+WEAK const PinMap PinMap_LPTIMETR[] = {
+  {PB_6,       LPTIM1,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF11_LPTIM1)}, // LPTIM1_ETR
+  {NC,         NP,    0}
+};
+#endif
+
+
+#if defined(STM32G473QE) || defined(STM32G431VB)
+WEAK const PinMap PinMap_LPTIM[] = {
+  {PB_5,       LPTIM1,  STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF11_LPTIM1, 0, 0)}, // LPTIM1_CH1
+  {PB_7,       LPTIM1,  STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF11_LPTIM1, 1, 0)}, // LPTIM1_CH2
+  {PC_0,       LPTIM1,  STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF1_LPTIM1, 0, 0)}, // LPTIM1_CH1
+  {PC_2,       LPTIM1,  STM_PIN_DATA_EXT(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF1_LPTIM1, 1, 0)}, // LPTIM1_CH2
+  {NC,         NP,    0}
+};
+WEAK const PinMap PinMap_LPTIMETR[] = {
+  {PB_6,       LPTIM1,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF11_LPTIM1)}, // LPTIM1_ETR
+  {PC_3,       LPTIM1,  STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF1_LPTIM1)}, // LPTIM1_ETR
+  {NC,         NP,    0}
+};
+#endif
+
+
+
+
+#endif // HAL_LPTIM_MODULE_ENABLED

src/encoders/stm32lpencoder/README.md

@@ -0,0 +1,46 @@
+
+# STM32 Low Power Encoder driver
+
+This is a driver for the encoder mode of STM32 MCU LPTIM timers.
+
+:warning: not yet tested
+
+The LPTIM timers are low power timers available on some STM32 MCUs. Some LPTIM timers have an encoder mode (typically LPTIM1 and LPTIM2). Using this encoder class has zero MCU overhead as the hardware handles all the encoder counting. There is also no need for interrupt handlers, interrupts are not used. However, you must be sure to call `encoder.update()` frequently (at least 2x per revolution) to correctly keep track of the full rotations.
+
+In theory the LPTIM timers can keep counting when the MCU is in sleep mode, but in practice tracking the full rotations would be difficult to achieve.
+
+## Compatibility
+
+Unfortunately, Arduino framework (stm32duino) provides no support for low power timers, and there is no "PinMap" to identify which pins are LPTIM outputs.
+
+If you want to use this driver, your MCU has to be part of the custom `PinMap_LPTIM.c` file used by this driver. Currently, we've added the following MCUs:
+
+- STM32G431KB
+- STM32G431CB
+- STM32G473QE
+- STM32G431VB
+
+Adding MCUs is not hard if you look at the format [in the file](./PinMap_LPTIM.c), and pull requests for other MCUs would be gladly accepted.
+
+## Usage
+
+Like all our encoders, you must specify the PPR (pulses per revolution). This number should come from your encoder's datasheet. Note: internally, the encoder will use a 4x higher CPR (counts per revolution) than the PPR value you provide.
+
+You may need to enable the LPTIM in stm32duino:
+
+```
+-DHAL_LPTIM_MODULE_ENABLED
+```
+
+Its easy to use:
+
+```c++
+STM32LowPowerEncoder encoder = STM32LowPowerEncoder(4096, PB5, PB7); // 4096 is the PPR
+
+vpid setup() {
+    ...
+    encoder.init();
+    motor.linkSensor(&encoder);
+    ...
+}
+```

src/encoders/stm32lpencoder/STM32LowPowerEncoder.cpp

@@ -0,0 +1,84 @@
+
+
+#include "./STM32LowPowerEncoder.h"
+
+#if defined(_STM32_DEF_) && defined(HAL_LPTIM_MODULE_ENABLED)
+
+
+extern const PinMap PinMap_LPTIM[];
+extern const PinMap PinMap_LPTIMETR[];
+
+
+STM32LowPowerEncoder::STM32LowPowerEncoder(unsigned int ppr, int pinA, int pinB, int pinI){
+    cpr = ppr * 4; // 4x for quadrature
+    _pinA = digitalPinToPinName(pinA);
+    _pinB = digitalPinToPinName(pinB);
+    _pinI = digitalPinToPinName(pinI);
+};
+
+void STM32LowPowerEncoder::init(){
+    _encoder_handle.Instance = (LPTIM_TypeDef*)pinmap_peripheral(_pinA, PinMap_LPTIM);
+    if (!IS_LPTIM_ENCODER_INSTANCE(_encoder_handle.Instance)) {
+        initialized = false;
+        return;
+    }
+    LPTIM_TypeDef* inst = (LPTIM_TypeDef*)pinmap_peripheral(_pinA, PinMap_LPTIM);
+    if (inst!=_encoder_handle.Instance) {    // check the other pins are on the same timer
+        initialized = false;
+        return;
+    }
+    if (_pinI!=NC) {
+        inst = (LPTIM_TypeDef*)pinmap_peripheral(_pinI, PinMap_LPTIMETR);
+        if (inst!=_encoder_handle.Instance) {
+            initialized = false;
+            return;
+        }
+    }
+    _encoder_handle.Init.Clock.Source = LPTIM_CLOCKSOURCE_APBCLOCK_LPOSC;
+    _encoder_handle.Init.Clock.Prescaler = LPTIM_PRESCALER_DIV1;
+    _encoder_handle.Init.UltraLowPowerClock.Polarity = LPTIM_CLOCKPOLARITY_RISING_FALLING;
+    _encoder_handle.Init.UltraLowPowerClock.SampleTime = LPTIM_CLOCKSAMPLETIME_DIRECTTRANSITION;
+    if (_pinI==NC)
+        _encoder_handle.Init.Trigger.Source = LPTIM_TRIGSOURCE_SOFTWARE;
+    else {
+        _encoder_handle.Init.Trigger.Source = LPTIM_TRIGSOURCE_0;
+        _encoder_handle.Init.Trigger.ActiveEdge = LPTIM_ACTIVEEDGE_RISING;
+        _encoder_handle.Init.Trigger.SampleTime = LPTIM_TRIGSAMPLETIME_DIRECTTRANSITION;        
+    }
+    _encoder_handle.Init.OutputPolarity = LPTIM_OUTPUTPOLARITY_HIGH;
+    _encoder_handle.Init.UpdateMode = LPTIM_UPDATE_IMMEDIATE;
+    _encoder_handle.Init.CounterSource = LPTIM_COUNTERSOURCE_EXTERNAL;
+    _encoder_handle.Init.Input1Source = LPTIM_INPUT1SOURCE_GPIO;
+    _encoder_handle.Init.Input2Source = LPTIM_INPUT2SOURCE_GPIO;
+    if (HAL_LPTIM_Init(&_encoder_handle) != HAL_OK)
+        initialized = false;
+    else {
+        if (HAL_LPTIM_Encoder_Start(&_encoder_handle, cpr) != HAL_OK)
+            initialized = false;
+        else {
+            pinmap_pinout(_pinA, PinMap_LPTIM);
+            pinmap_pinout(_pinB, PinMap_LPTIM);
+            if (_pinI != NC)
+                pinmap_pinout(_pinI, PinMap_LPTIMETR);
+            initialized = true;
+        }
+    }
+};
+
+
+int STM32LowPowerEncoder::needsSearch(){
+    return false;
+};
+
+
+int STM32LowPowerEncoder::hasIndex(){
+    return 0; // TODO: implement index
+};
+
+
+
+float STM32LowPowerEncoder::getSensorAngle(){
+    return _2PI * (_encoder_handle.Instance->CNT&0xFFFFUL) / (float)cpr;
+};
+
+#endif

src/encoders/stm32lpencoder/STM32LowPowerEncoder.h

@@ -0,0 +1,33 @@
+
+#include "Arduino.h"
+
+
+#if defined(_STM32_DEF_) && defined(HAL_LPTIM_MODULE_ENABLED)
+
+#include "common/base_classes/Sensor.h"
+#include "common/foc_utils.h"
+
+class STM32LowPowerEncoder : public Sensor {
+  public:
+    /**
+    Encoder class constructor
+    @param ppr  impulses per rotation  (cpr=ppr*4)
+    */
+    explicit STM32LowPowerEncoder(unsigned int ppr, int pinA, int pinB, int pinI=-1);
+
+    void init() override;
+    int needsSearch() override;
+    int hasIndex();  // !< function returning 1 if encoder has index pin and 0 if not.
+
+    bool initialized = false;
+    uint32_t cpr;  //!< encoder cpr number
+    PinName _pinA, _pinB, _pinI;
+    
+  protected:
+    float getSensorAngle() override;
+    
+    LPTIM_HandleTypeDef _encoder_handle;
+    
+};
+
+#endif