update of the PWM sensor

Author: askuric

src/comms/stm32speeddir/README.md

@@ -21,6 +21,10 @@ The direction input is optional - if not provided, you can control the direction
 
 The velocity values returned are in the range `min_speed` to `max_speed`, while the input PWM duty cycle should lie within the range `min_pwm` to `max_pwm`. Actual input values smaller than `min_pwm` will be treated as `min_pwm`, values larger than `max_pwm` will be treated as `max_pwm`. The behaviour for 100% or 0% duty cycles is undefined, and they should be avoided.
 
+> **IMPORTANT**<br>
+> If the PWM frequency of the speed input is not known, provide its value in Hz to the constructor. If not provided, it will default to 1kHz (very common value). The frequency is used to make sure that the PWM period stays within one timer counter period. If this is not the case the timer counter can overflow and the input will not work correctly.
+
+
 ## Usage
 
 Use it like this:
@@ -31,8 +35,9 @@ Use it like this:
 // some example pins - the speed pin has to be on channel 1 or 2 of a timer
 #define PIN_SPEED PC6
 #define PIN_DIRECTION PB8
+#define PWM_FREQUENCY 1000 // 1kHz (defualt)
 
-STM32SpeedDirInput speed_dir = STM32SpeedDirInput(PIN_SPEED, PIN_DIRECTION);
+STM32SpeedDirInput speed_dir = STM32SpeedDirInput(PIN_SPEED, PIN_DIRECTION, PWM_FREQUENCY);
 
 float target = 0.0f;
 

src/comms/stm32speeddir/STM32SpeedDirInput.cpp

@@ -3,7 +3,7 @@
 
 #if defined(_STM32_DEF_)
 
-STM32SpeedDirInput::STM32SpeedDirInput(int pin_speed, int pin_dir) : STM32PWMInput(pin_speed) {
+STM32SpeedDirInput::STM32SpeedDirInput(int pin_speed, int pin_dir, uint32_t pwm_freq) : STM32PWMInput(pin_speed, _pwm_freq) {
     _pin_speed = pin_speed;
     _pin_dir = pin_dir;
 };

src/comms/stm32speeddir/STM32SpeedDirInput.h

@@ -10,7 +10,21 @@
 
 class STM32SpeedDirInput : public STM32PWMInput {
     public:
-        STM32SpeedDirInput(int pin_speed, int pin_dir = NOT_SET);
+
+        /**
+         * STM32SpeedDirInput constructor
+         * 
+         * @param pin_speed - the pin number to read the speed PWM signal from
+         * @param pin_dir - the pin number to read the direction signal from (default is NOT_SET)
+         * @param pwm_freq - the frequency of the PWM signal (default is 1kHz)
+         * 
+         * This class is used to read speed and direction signals from a pin using the STM32 HAL library.
+         * IMPORTANT!
+         *      This class can only be used with the pins that are associated with some timer,
+         *      and only if they are associated to the channels 1 or 2. The timer can not be
+         *      used for other purposes, like motor control.
+         */
+        STM32SpeedDirInput(int pin_speed, int pin_dir = NOT_SET, uint32_t pwm_freq = 1000);
         ~STM32SpeedDirInput();
 
         int init();

src/encoders/stm32pwmsensor/README.md

@@ -21,10 +21,18 @@ sensor.getDutyCycleTicks();
 
 By rotating the motor through several full turns while printing the ticks to the screen you will be able to determine the correct values empirically.
 
+
+> **IMPORTANT**<br>
+> If the PWM frequency of the speed input is not known, provide its value in Hz to the constructor. If not provided, it will default to 1kHz (very common value). The frequency is used to make sure that the PWM period stays within one timer counter period. If this is not the case the timer counter can overflow and the input will not work correctly.
+
+
 ## Usage
 
 ```
-STM32MagneticSensorPWM sensor = STM32MagneticSensorPWM(PB7, 412, 6917); // sample values, yours will be different
+
+#define PWM_FREQ_HZ 1000 // 1kHz (default)
+
+STM32MagneticSensorPWM sensor = STM32MagneticSensorPWM(PB7, 412, 6917, PWM_FREQ_HZ); // sample values, yours will be different
 
 void setup() {
     ...

src/encoders/stm32pwmsensor/STM32MagneticSensorPWM.cpp

@@ -6,7 +6,7 @@
 #include "common/foc_utils.h"
 
 
-STM32MagneticSensorPWM::STM32MagneticSensorPWM(int pin, uint32_t _min_ticks, uint32_t _max_ticks) : STM32PWMInput(pin), max_ticks(_max_ticks), min_ticks(_min_ticks) {
+STM32MagneticSensorPWM::STM32MagneticSensorPWM(int pin, uint32_t _min_ticks, uint32_t _max_ticks, uint32_t _pwm_freq) : STM32PWMInput(pin), max_ticks(_max_ticks), min_ticks(_min_ticks) {
 
 };
 

src/encoders/stm32pwmsensor/STM32MagneticSensorPWM.h

@@ -13,7 +13,7 @@
 
 class STM32MagneticSensorPWM : public Sensor, public STM32PWMInput {
     public:
-        STM32MagneticSensorPWM(int pin, uint32_t _min_ticks = 0, uint32_t _max_ticks = 0x0FFF);
+        STM32MagneticSensorPWM(int pin, uint32_t _min_ticks = 0, uint32_t _max_ticks = 0x0FFF, uint32_t _pwm_freq = 1000);
         ~STM32MagneticSensorPWM();
 
         void init() override;

src/utilities/stm32pwm/STM32PWMInput.cpp

@@ -1,12 +1,15 @@
 
 #include "./STM32PWMInput.h"
+#include <SimpleFOC.h>
+#include "communication/SimpleFOCDebug.h"
 
 #if defined(_STM32_DEF_)
 
 
 
-STM32PWMInput::STM32PWMInput(int pin){
+STM32PWMInput::STM32PWMInput(int pin, uint32_t pwm_freq){
     _pin = digitalPinToPinName(pin);
+    _pwm_freq = pwm_freq;
 };
 
 
@@ -20,9 +23,13 @@ int STM32PWMInput::initialize(){
     pinmap_pinout(_pin, PinMap_TIM);
     uint32_t channel = STM_PIN_CHANNEL(pinmap_function(_pin, PinMap_TIM));
     timer.Instance = (TIM_TypeDef *)pinmap_peripheral(_pin, PinMap_TIM);
-    timer.Init.Prescaler = 0;
     timer.Init.CounterMode = TIM_COUNTERMODE_UP;
-    timer.Init.Period = 4.294967295E9;    // TODO max period, depends on which timer is used - 32 bits or 16 bits
+    // Check if timer is 16 or 32 bit and set max period accordingly
+    if (IS_TIM_32B_COUNTER_INSTANCE(timer.Instance)) {
+        timer.Init.Period = 0xFFFFFFFF; // 32-bit timer max
+    } else {
+        timer.Init.Period = 0xFFFF; // 16-bit timer max
+    }
     timer.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
     timer.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
     if (channel!=1 && channel!=2) // only channels 1 & 2 supported
@@ -76,6 +83,32 @@ int STM32PWMInput::initialize(){
     if (HAL_TIM_IC_Start(&timer, TIM_CHANNEL_2)!=HAL_OK) {
         return -9;
     }
+
+    // Check if the timer period is longer than the PWM period 
+    // if it isnt set the perescaler to make it longer
+    // Calculate timer clock frequency
+    uint32_t timer_clk = HAL_RCC_GetPCLK1Freq();
+    if (IS_TIM_CLOCK_DIVISION_INSTANCE(timer.Instance)) {
+        // If APB1 prescaler > 1, timer clock is doubled
+        if ((RCC->CFGR & RCC_CFGR_PPRE1) != RCC_CFGR_PPRE1_DIV1) {
+            timer_clk *= 2;
+        }
+    }
+
+    // Calculate required period (in timer ticks) for one PWM period
+    uint32_t desired_period_ticks = timer_clk / _pwm_freq;
+
+    // Check if timer's max period can fit the desired period
+    uint32_t max_period = (IS_TIM_32B_COUNTER_INSTANCE(timer.Instance)) ? 0xFFFFFFFF : 0xFFFF;
+    uint32_t prescaler = 1;
+    if (desired_period_ticks > max_period) {
+        prescaler = (desired_period_ticks + max_period - 1) / max_period;
+        if (prescaler > 0xFFFF) prescaler = 0xFFFF; // limit to 16-bit prescaler
+    }
+
+    // Set the prescaler to achieve the desired period
+    LL_TIM_SetPrescaler(timer.Instance, prescaler);
+
     timer.Instance->CR1 |= TIM_CR1_CEN;
     return 0;
 };

src/utilities/stm32pwm/STM32PWMInput.h

@@ -7,19 +7,48 @@
 
 class STM32PWMInput {
     public:
-        STM32PWMInput(int pin);
+        /**
+         * StM32PWMInput constructor
+         * 
+         * @param pin - the pin number to read the PWM signal from
+         * @param pwm_freq - the frequency of the PWM signal (default is 1kHz)
+         * 
+         * This class is used to read PWM signals from a pin using the STM32 HAL library.
+         * IMPORTANT!
+         *     This class can only be used with the pins that are assocaited with some timer, 
+         *     and only if they are associated to the channels 1 or 2. The timer can not be 
+         *     used for other purposes, like motor control. 
+         */
+        STM32PWMInput(int pin, uint32_t pwm_freq = 1000);
         ~STM32PWMInput();
 
         int initialize();
 
+        /**
+         * Get the duty cycle of the PWM signal as a percentage.
+         * 
+         * @return float - the duty cycle in percent
+         */
         float getDutyCyclePercent();
+        /**
+         * Get the duty cycle of the PWM signal in ticks.
+         * 
+         * @return uint32_t - the duty cycle in ticks
+         */
         uint32_t getDutyCycleTicks();
+        /**
+         * Get the period of the PWM signal in ticks.
+         * 
+         * @return uint32_t - the period in ticks
+         */
         uint32_t getPeriodTicks();
 
-        PinName _pin;
+        PinName _pin; // the pin to read the PWM signal from 
+        uint32_t _pwm_freq; // the frequency of the PWM signal
+
     protected:
-        TIM_HandleTypeDef timer;
-        bool useChannel2 = false;
+        TIM_HandleTypeDef timer; // the timer handle for the PWM input
+        bool useChannel2 = false; // whether to use channel 2 or not, default is channel 1
 };