Different ADC values depending on read order

[IoTrees]

Hello,

I am using a W5100S-EVB-Pico board to monitor for differences in two PWM signals.

I am currently testing the ADC PWM input, but I notice that the values it reads are very different inconsistency, depending on what order they are read. I am currently using the board to generate the PWM signal and feeding it to two ADC GPIO:

import machine
from machine import Pin, SPI, PWM
import time
import uasyncio as asyncio

input_flow_pin = Pin(27, mode=Pin.IN)
output_flow_pin = Pin(28, mode=Pin.IN)
pwm_out_pin = PWM(Pin(22))
pwm_out_pin.freq(20000)
pwm_out_pin.duty_ns(25000)


async def read_flow():
    time.sleep(0.01)
    output_flow = machine.time_pulse_us(output_flow_pin, 1, 1_000_000)
    input_flow = machine.time_pulse_us(input_flow_pin, 1, 1_000_000)

    print("Input flow: ", input_flow, " Output Flow: ", output_flow)


async def main():
    while True:
        led.on()
        print('heartbeat')
        await asyncio.sleep(0.25)
        led.off()
        await asyncio.sleep(0.25)
        await read_flow()


if __name__ == "__main__":
    try:
        asyncio.run(main())
    finally:
        asyncio.new_event_loop()
        

The results for the ADC reads are not consistent for one of the PWM inputs: One will read the same appropriate value every time, but the other value is constantly changing at each read.
When I switch lines 13 and 14 above, the other input will show this behavior.

example
`
Input flow: 25 Output Flow: 0
heartbeat
Input flow: 25 Output Flow: 24
heartbeat
Input flow: 25 Output Flow: 2
heartbeat
Input flow: 25 Output Flow: 21
heartbeat
Input flow: 25 Output Flow: 24
heartbeat
Input flow: 25 Output Flow: 24

`

I have tried this with several ADC pins with same result, so I think this is some kind of timing issue. Anyone have any ideas?

[robert-hh]

What you get is just the behavior of time_pulse_us(). You will get a proper reading for a high pulse only if the level at the input is low when the function is called. Otherwise only the remainder of the high period is timed. See the documentation at https://docs.micropython.org/en/latest/library/machine.html#machine.time_pulse_us:

If the current input value of the pin is different to pulse_level, the function first (*) waits until the pin input becomes equal to pulse_level, then (**) times the duration that the pin is equal to pulse_level. If the pin is already equal to pulse_level then timing starts straight away.

That makes time_pulse_us() hard to use. It may be better if the implementation would wait for a transition to the level of choice and then time it. But that would only work for repeating signals.

[IoTrees]

I will play with this more, thank you!

[robert-hh]

For a periodic signal like the PWM you could try and call time_pulse_us() twice in a row and just take the value of the second call.

[IoTrees]

I am thinking it will be a constant but shifting frequency square wave signal, but I don't have the actual sensor yet. I will try your suggestion, thanks again!

EDIT: Calling the function a second time seems to have it working perfectly now! Thanks!

[robert-hh]

Being interested, I made the little script below and tested it with an external generator, down to pulse lengths of 5 µs. It worked well. I did not test further.

import time
from machine import Pin, time_pulse_us

@micropython.native
def pulse(p, l):
    time_pulse_us(p, l, 1000000)
    return time_pulse_us(p, l, 1000000)

p = Pin(4, Pin.IN)

while True:
    print(pulse(p, 1))
    time.sleep_ms(300)