How one would do PWM AND & OR modulations on PICO?

[webdeb]

Guys, I am building some special purpose PWM thing, and would like to be able to connect channels to do AND & OR modulations.

I am not an expert at all, even the word PWM is something new to me, so the wording might be incorrect.

The examples are very simple, the first and second line is Pin 1 & 2, it could be a PWM Channel/Slice or even just a PIN. And the 3rd is the expected output:

Masking (AND)

Merging (OR)

Possible solutions

• custom pio program or even prebuffering the data into dma would work but there are some edge cases and I would lose the accuracy of the hardware pwm peripheral
• hardware, it requires additional parts on the board, and adjustments are not trivial. besides that, you have to use parts which are capable of handling >133Mhz+ clock speed.
• an pio program which buffers the 1 & 2 output pins and shifts it to some the 3rd pin. But as I understand the output signal would't be in sync with the 1 & 2, as it would delay some cycles, because it would need to calculate the output first, before setting the pin. Hmm..

Do you have other ideas? Maybe I am wrong with some of my assumptions, I would very appreciate if you could give me some hints how one could solve it.

[rkompass]

As I understand it the PWM should be continuously running ordinary PWM - internally generated.
What is the origin of the modulating signals? Do you generate them programmatically?
If yes you might use the GPIO output pads capabilities. You can set outputs to be low or high or inverted, independently from the source - which would be the PWM. With DMA you could do that automatically, even timed, in the background.

[webdeb]

Hi, yes can invert them using PIO, but what I want to do, is to combine two signals from PIN1 & PIN2 and out them in PIN3 with basic OR & AND operations.

[rkompass]

I was referring to Section 2.19.4 "PADS" of GPIO, not to be mismatched with PIO, in the RP2040 Datasheet.
Are you looking for programmable logic?

[webdeb]

Ah, ok. this sounds interesting for my purpose. I've not read that yet, will do. Thank you.

[fdufnews]

You need to give a little more information

• what is the frequency of the modulating signal?
• what is the frequency of the PWM?
• shall they be synchronized?

[webdeb]

Hey, sorry, I've overlooked you comment.
Frequencies could be changed, but the one is obviously lower then the other. The lower is package frequency, as well as the high freq pulses. I mean its not necessary to sync them, because one just should cancel the other for some periods..

[peterhinch]

My IR remote transmitter uses the PIO to generate an OOK (on-off keying) modulated carrier. The file rp2_rmt.py emulates the ESP32 RMT class. Studying the docs for ESP32 RMT will give pointers as to how this can be used.

[webdeb]

Aha, yeah you are using wait irq instructions, to stop/run the pulse?
I guess this picture illustrates very well what I would like to achieve, with the only difference, that for the pulse & package I want to use two PWM slices and output a bit operation of the two. Does it make sense?

So I guess I could use wait pin to stop the pulse while the package is low.
Or just mov(out_pin, pwm_pin_a & pwm_pin_b) 🤔

PS: Please correct my wording, as I am new to the field, and right wording would make it others easier to understand me correctly.

[webdeb]

As a side note, both PWMs should be controllable, thats why I do not want to use some signal buffering technique, as it requires an unpredictable amount of memory, calculation time and the calculation itself is a bit complex, as based on the change of any of those parameters, a_freq, a_duty, b_freq, b_duty..

[webdeb]

Sorry, I've quadrillion tabs opened at the same time, you are not using wait, you are using irq and what I call signal generation/buffering..

[rkompass]

I tried the PIO approach just for fun and ended up with the following program:

import time
import rp2
from machine import Pin

@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, in_shiftdir=rp2.PIO.SHIFT_LEFT)
def sm_and():
    label("start")
    in_(pins, 2)
    mov(x, invert(isr))
    jmp(not_x, "on")
    jmp("start")               .side(0b0)
    label("on")
    jmp("start")               .side(0b1)


p16 = Pin(16, Pin.IN, Pin.PULL_UP)
p17 = Pin(17, Pin.IN, Pin.PULL_UP)

# Instantiate a state machine with the blink program, at 2000Hz, with set bound to Pin(25) (LED on the rp2 board)
sm = rp2.StateMachine(0, sm_and, freq=2000, in_base=p16, sideset_base=Pin(9))

# Run the state machine for 10 seconds.  Report the state of the inputs.
sm.active(1)
for _ in range(200):
    print('p16:', p16(), '    p17:', p17())
    time.sleep_ms(50)
sm.active(0)

The cycle to process the logical AND takes 4 PIO instructions here.
Would be nice if someone managed to get that in fewer instructions.
I tried a mov(x, invert(pins)) to save an instruction but there seems to be no limit as to how many inputs are read in.
So the above gives a reaction time of 32 ns at 125 MHz or 16 ns at 250 MHz clock. A CMOS circuit at the outputs wouldn't be faster, probably.
Btw: You might use open drain and pull-up resistors for the AND logic and that too would not be faster, if my understanding is correct.

[webdeb]

I tried it, but I don't get it. Have you used an external PWM on the input pins, or the machine.PWM?
My aim is to use the machine PWMs to change the freq/duty of them and then AND them on the out pin.

[rkompass]

No - I didn't use machine.PWM, but of course you will :-)
The above code should also work if you instead of p16 = Pin(16, Pin.IN, Pin.PULL_UP) setup a PWM on that pin like:

p16 = Pin(16, Pin.OUT)
pwm0 = machine.PWM(p16)
pwm0.freq(1000)
pwm0.duty_u16(200)      # set duty cycle, range 0-65535

(taken from the docs).
I took pins 16 and 17 because I had my switches there (and led at pin 9) - to control the function by hand for testing.
The PIOs don't mind which source drives the pins. You also might want to use two other pins. These need to be neighbours however, as only the lower number of both is specified with in_base=p16, and how many pins are read is defined by
in_(pins, 2).

You probably have noted that I forgot to change the comment in the above code and set the frequency to only 2000 Hz.
Corrected:

# Instantiate a state machine with the logical AND program, at 125 MHz, with inputs at pin 16,.. and output set to pin 9
sm = rp2.StateMachine(0, sm_and, freq=125_000_000, in_base=p16, sideset_base=Pin(9))

[webdeb]

Thanks @rkompass, but don't you have to enable PIO Function for the chosen GPIO, which basically overrides the PWM function? Like I said, I tried to test your code with the built-in pwm and nothing happend, the fifo was not filled, or I am a dumb newbie)
Btw, I've found a solution with the only use of the pwm hardware. See my comment below ;)

[rkompass]

No, the PIO function (2.19.2 in the datasheet) is set only for the PIO output pin, automatically. Below the table in that section it is stated: The PIO function (F6, F7) must be selected for PIO to drive a GPIO, but the input is always connected, so the PIOs can always see the state of all pins.
I tried the above code and it works - I can force the PWM to 0 by pressing the switch on p17 which sets p17 to zero, thus the AND goes to 0.
You don't need the AND and OR anymore. Anyway I just found the detail below the table and want to share the thought:
Each GPIO can have one function selected at a time. Likewise, each peripheral input (e.g. UART0 RX) should only be
selected on one GPIO at a time. If the same peripheral input is connected to multiple GPIOs, the peripheral sees the
logical OR of these GPIO inputs.
Now one could set an UART input to more than one GPIOs and have a PIO program that just copies that input to another pin for output - also you would have to connect the PWM outputs externally to the UART inputs - a waste of pins - and have a logical OR.

[webdeb]

Hmm.. thats interesting. I've to dive deeper into PIO to grasp it finally, and then to be able to write programs on it. My PWM-> PWM approach also wastes a pin, btw. And if you don't need the pure freqs of 1 and 2, then it wastes actually 2 pins. However, I have difficulties to understand the freq. math on a pio and how the cycles fit together, in PWM its much simpler, you have the counter, the wraper etc. it feels more natural for the task, obviously))

[webdeb]

Guys, thanks for your help, I've found a solution in the datasheet, which says, that you can control the pwm counter with the help of the input channel. This has to be enabled, through the register. you simply put a connection between the drive channel (package) and the input channel B of the pulse signal.

Maybe this will help someone else in the future:
PICO Datasheet page 529

[rkompass]

This way you may gate the counter that produces the PWM (by comparison with a preset TOP value).
Which is not a logical AND or OR.
No problem: In engineering only after the solution appears one has the full understanding what one was looking for all the time.

[webdeb]

Hmm.. you are right its not a real logical AND.. However, as you pointed out, its exactly what I needed :D