5 years, 5 months ago.

In an earlier version of mbed-os 5 for STM32L476 device I observed that the PWM libraries were updating the duty cycle in a way that would introduce glitches when you change the duty cycle. When you loaded a new duty it would go through the whole pwm initialization again instead of just updating the duty CCR register.

It has been a couple years since I looked at this, but if it is misbehaving right when you change duty I would bet it is the same issue. The hardware has glitch-free capability it is just not being used that way.

You could try using the FastPWM library instead and see if that helps - its a different implementation but does the same thing. I believe this is it:

https://os.mbed.com/users/Sissors/code/FastPWM/

To update the duty on the fly all you have to do is write to the Timer CCR register. If you import the mbed source you can add a function to just load CCR.

   TimHandle.Instance->CCR1 = duty_as_integer;

I don't know about updating the Frequency on the Fly. That would seem to require reinitializing the Timer.

Edit

I confirmed the standard PwmOut is glitching sometimes for me when I change duty on higher frequency signals (image is 200kHz). However, given that you want to change Frequency too that is probably the bigger issue you're facing.

I believe this can be solved by making a new class that inherits from PwmOut and then updating CCR register when duty changes. This works for me and I have not been able to find any glitches using this new class and write_smooth() method.

class PwmSmooth : public PwmOut {
public:
    /* Create a Glitch Free PWM that updates Timer CCR when duty changes
     *  @param pin PwmOut pin to connect to
     */
    PwmSmooth(PinName pin) :
        PwmOut(pin) {}
    

    /** Set the output duty-cycle, specified as a percentage (float) without Glitch
     *  @param value A floating-point value representing the output duty-cycle,
     *    specified as a percentage. The value should lie between
     *    0.0f (representing on 0%) and 1.0f (representing on 100%).
     *    Values outside this range will be saturated to 0.0f or 1.0f.
     */
    void write_smooth(float value) {
        core_util_critical_section_enter();
        lock_deep_sleep();
        pwmout_write_smooth (&_pwm, value);
        core_util_critical_section_exit();
    }

protected:
    /** Add pwm function, normally found in pwmout_api.c
     *  @param value A floating-point value representing the output duty-cycle,
     */
    void pwmout_write_smooth(pwmout_t *obj, float value) {

        // Get Timer Handle
        TIM_HandleTypeDef TimHandle;
        TimHandle.Instance = (TIM_TypeDef *)(obj->pwm);
    
        // Limit
        if (value < 0.0f) {
            value = 0.0f;
        } else if (value > 1.0f) {
            value = 1.0f;
        }
    
        // Convert to integer duty
        uint32_t pulse = (uint32_t)((float)obj->period * value + 0.5);
    
        TimHandle.Instance->CCR1 = pulse;
    }
};