Pi Pico PWM function and toggle() function

[electro201]

I am trying to write a program for the pi pico using Micropython to send pwm signals to a mosfet module to turn it on and off to send pulsed current through a DC electromagnet. The MOSFET switches power ON and OFF power to a DC electromagnet at frequencies 0.1, 7, 14, 21, 28, 35 and 42 Hz. I also plan to make it work on other higher frequencies. The load current to be switched will be around 4 to 4.5 Amps DC at 12 Volts DC. The MOSFET could switch ON at 3.3 Volts output from the Pi Pico Pins.

My doubt here is that - since the Pi Pico can produce a PWM output should I use that function in the program to control the MOSFET using PWM or I can use the toggle() pin command to switch ON and OFF a pin and use that to control the MOSFET. What difference will it make? I only need a 50 percent duty cycle for all frequencies and I will not be changing the duty cycle so the toggle() function works fine. But I do not know what is the difference in using the two methods. In toggle() method I can directly give the value in seconds to get the 50 percent duty cycle. By using pwm I have to set the desired frequency and then set the duty cycle by choosing a value between 0 to 65550.

I will be using push button switches to select one frequency at a time so the pi pico will only be doing one task at a time. I like to know which of these two methods would be efficient and what are the drawbacks.

I wrote a program and used the toggle() pin function. It works fine. Should I use the pwm function instead. Will it be more efficient. What is the difference.

This is the code

import machine
import utime
pin_external = machine.Pin(15, machine.Pin.OUT)
while True:
pin_external.toggle()
utime.sleep(5)

This program gives out a voltage of 3.3 Volts every 5 seconds ON state 5 seconds and OFF state 5 seconds at pin15. That is a 0.1 Hz frequency at 50 percent duty cycle. Same I can do for 7 Hz by giving a utime.sleep(0.0714285) in the last line of the code above replacing the utime.sleep(5).

Time, T = 1/f

Since duty cycle is 50 percent

On time = T/2 Off time = T/2

utime.sleep(T/2) is the number in the code.

[GitHubsSilverBullet]

Should you desire any kind of accuracy, DO NOT use the Pin toggle mechanism.
PWM gives you full control and full precision (timing wise) and leave the processor free do do more useful things.
For frequencies below cpufreq/2^8/2^16 (ie. 7.45Hz @125MHz) one could and should use the PIO. That one allows frequencies down into the µHz range.
Edit:
PWM.freq(frequency)
PWM.duty_u16(2**15)
always gives you 50% duty cycle. Unfortunately µPy does not allow floats as frequency (although it would be perfectly valid)
So you'd have to modify the DIV,TOP and CC manually.
Overall I'd go for the PIO option and be done with it.

[electro201]

Still, PIO is the way to go,

Could you please let me know how to use the PIO mechanism for this pwm. Give me a link to where I can learn about it.

[GitHubsSilverBullet]

120MHz to 48Mhz, affecting the PWM frequency as well.

Yes. But only down to 2.86Hz.
Could slow it down to the lowest 18MHz -> 1.07Hz
Still…

[GitHubsSilverBullet]

Could you please let me know how to use the PIO mechanism for this pwm. Give me a link to where I can learn about it.

There's an example ›pio_1Hz.py‹ in the example section.

[electro201]

There's an example ›pio_1Hz.py‹ in the example section.

Ok I have gone through that, thanks a lot GitHubsSilverBullet.

Since I am a beginner I will take some time to learn it. Now the simplest way I decided to do it is generate a higher frequency over 500 Hz and use a 4060 IC to divide the frequency and bring it down to lower values.

But could you tell that if I use a code with normal pwm command will it produce a hardware pwm or software pwm. What is the criteria or method by which the pico produces a software pwm or hardware pwm. Does it produce it automatically or depend on the value of frequency. Beyond a certain value of frequency it produces hardware pwm. I want to use hardware pwm and then divide it so accuracy is present.

Thanks.

[GitHubsSilverBullet]

The µC is perfectly capable of generating frequencies in the µHz … MHz range.
All done in hardware and with the best possible precision.

#!/usr/bin/env picorun
# -*- coding: UTF-8 -*-
# vim: fileencoding=utf-8: ts=4:  sw=4: expandtab:

from machine import Pin, freq as cpufreq
from rp2 import StateMachine

class PIO_PWM:

    @staticmethod
    @rp2.asm_pio(set_init=rp2.PIO.OUT_LOW)
    def pio_prog():
        # timing for a half period is (OSR-1) + 4
        wrap_target()
        pull    (noblock)           # 1 pull period/2 from FIFO into OSR
        mov     (x, osr)            # 1 save a copy in X

        mov     (y, x)              # 1 copy X to Y, use Y to decrement
        set     (pins, 1)           # 1
        label   ('high')
        jmp     (y_dec, 'high')     # 1

        mov     (y, x)          [2] # 3 copy X to Y, use Y to decrement
        set     (pins, 0)           # 1
        label   ('low')
        jmp     (y_dec, 'low')      # 1
        wrap    ()

    def __init__(self, pin, frequency):
        self.sm = StateMachine(0, PIO_PWM.pio_prog, set_base=pin) # runs with highest frequency
        self.set_freq(frequency)
        self.sm.restart()
        self.sm.active(True)

    def set_freq(self, frequency:float):
        self.sm.put(round(cpufreq() / frequency / 2) - 5)

def test():
    from time import sleep_ms
    led = Pin(25, Pin.OUT)
    pwm = PIO_PWM(led, 1_000_000) # Initially 1MHz
    sleep_ms(1000)
    pwm.set_freq(0.25) # Now 1/4 Hertz

if __name__ == '__main__':
    test()

[scruss]

don't forget there is always machine.Timer for setting up long period recurring events. A couple of timer tasks, one to turn the pin on and the other off, will run in the background until you tell them to stop.

A not particularly great example is this:

from machine import Pin, Timer
from time import sleep_ms

led = Pin("LED", Pin.OUT)
on_timer = Timer(-1)
off_timer = Timer(-1)

def blink_start(t1, t2, on, off):
    t1.init(
        period=on + off,
        mode=Timer.PERIODIC,
        callback=lambda t: led.on(),
    )
    sleep_ms(on)  # wait to init off timer
    t2.init(
        period=on + off,
        mode=Timer.PERIODIC,
        callback=lambda t: led.off(),
    )

while True:
    on_time = int(input("Tiempo ON?"))
    off_time = int(input("Tiempo OFF?"))
    blink_start(on_timer, off_timer, on_time, off_time)

(nicked from here) takes two millisecond values from user input and blinks the LED based on those values

[robert-hh]

Better use just one timer and toggle the pin for a 50% duty cycle.

[scruss]

This was written for something with an arbitrary duty cycle

[GitHubsSilverBullet]

Correct me if I'm wrong, but wouldn't that introduce quite a bit of jitter due to varying interrupt latency?

[robert-hh]

Yes. There will be jitter. But for low frequencies that might not matter. But using an RP2 PIO seems to be the best choice. You could even adapt your script sending a specific number of cycles. That's missing in all PWM port until now.

[GitHubsSilverBullet]

You could even adapt your script sending a specific number of cycles.

That's almost exactly what the Python program up there does.
Except that it automagically calculates the cycles for a given frequency.