MicroPython
Replies: 4 comments 5 replies
-
|
Did you try to use machine.time_pulse_us()? |
Beta Was this translation helpful? Give feedback.
-
|
Yes. For instance, when I look as low pulses: import micropython
micropython.alloc_emergency_exception_buf(100)
from machine import Pin, time_pulse_us
class ZACwire():
def __init__(self, pin):
self.buf = [0 for _ in range(20)]
self.loc = 0
self.pin = pin
self.pin.irq(handler = self.irq_handler, trigger = Pin.IRQ_RISING)
def irq_handler(self, pin):
# waits until low pin then store the low duration in buffer:
self.buf[self.loc] = time_pulse_us(pin, 0)
self.loc += 1
if self.loc >= len(self.buf):
self.loc = 0
print([_ for _ in self.buf])
zw = ZACwire(Pin(16, Pin.IN))I get this (the signal should be almost periodic, with a period of 20): And if I look at high pulses: import micropython
micropython.alloc_emergency_exception_buf(100)
from machine import Pin, time_pulse_us
class ZACwire():
def __init__(self, pin):
self.buf = [0 for _ in range(20)]
self.loc = 0
self.pin = pin
self.pin.irq(handler = self.irq_handler, trigger = Pin.IRQ_FALLING)
def irq_handler(self, pin):
# waits until high pin then store the high duration in buffer:
self.buf[self.loc] = time_pulse_us(pin, 1)
self.loc += 1
if self.loc >= len(self.buf):
self.loc = 0
print([_ for _ in self.buf])
zw = ZACwire(Pin(16, Pin.IN))I get this. The long delays of ~75-80 ms are expected between readings, but they should be separated by 20 pulses, not 10. Also, the 201 us delays are also expected in between two long delays, but should be separated from the latter by 9 pulses, not 4. So it looks like I'm missing half of my pulses. I guess this is because by the time |
Beta Was this translation helpful? Give feedback.
-
|
With the ESP32 the RMT devices would be optimal for your case, bit RMT read is not implemented. So the only chance I see is busy polling into a data buffer with IRQ disabled after the first IRQ and then decoding the 0/1 pattern, which is not elegant. And the ESP32 is notoriously slow in responding to IRQ. A RP2040 might do better, because you can use the PIO to do the work. |
Beta Was this translation helpful? Give feedback.
-
|
Using pin() instead of pin.value() is a little bit faster. |
Beta Was this translation helpful? Give feedback.
-
|
I tried something based on Peter Hinch's micropython_ir code. This uses IRQs on rising and falling edges and only records import micropython
micropython.alloc_emergency_exception_buf(100)
from machine import Pin, Timer
from array import array
from utime import ticks_us, ticks_diff
class ZACwire():
def __init__(self, pin):
self.pin = pin
self.buf = array('i', [0 for _ in range(41)])
self.dt = array('i', [0 for _ in range(40)])
self.loc = 0
self.timer = Timer(0)
self.cb = self.decode
self.pin.irq(
handler = self.irq_handler,
trigger = Pin.IRQ_RISING | Pin.IRQ_FALLING,
)
def irq_handler(self, pin):
if not self.loc:
self.timer.init(period = 5, mode = Timer.ONE_SHOT, callback = self.cb)
self.buf[self.loc] = ticks_us()
self.loc = self.loc + 1
def decode(self, t):
self.loc = 0
for k in range(len(self.dt)):
self.dt[k] = ticks_diff(self.buf[k+1], self.buf[k])
print(self.dt)
zw = ZACwire(Pin(16, Pin.IN))Output: |
Beta Was this translation helpful? Give feedback.
-
|
If your application allows it, I'd use the method explained in 5.7 of the application note. That way you could start sampling with the ESP32 shortly at a known time before the data arrives, wasting less time and not depending on a fast ISR. But this has other drawbacks, too. |
Beta Was this translation helpful? Give feedback.
-
|
This is difficult on an ESP32 because it supports only soft IRQ's. If you could use a Pico or a Pico W you'd be better placed. On ESP32 there is another possible approach. A complete frame takes ~2.6ms: you could use the IRQ to start a decode which then polls the pin. This means that the ISR blocks for 2.6ms but you avoid the overhead of handling the slow and variable IRQ response time. Delays in responding to that initial high to low transition might mean you get occasional parity errors, but I think you could make a workable decoder using polling. |
Beta Was this translation helpful? Give feedback.
-
|
I got something usable on a Wemos S2 Mini board. Thanks again Peter for your open-source code, it was very helpful. I had to take the The edge timestamps are still pretty dirty, and I dont have access to parity, which may yield many spurious readings. I solve this by storing the last nine T values and using the median. This means my sensor cannot react faster than 1 s, but that's fine for my use cases. Also, all of this is a lot of work, so don't expect to do anything else too complex while polling the sensor. In the future I'll look into using a Pico W. This seems like a good application for a PIO peripheral... import micropython
micropython.alloc_emergency_exception_buf(100)
from machine import Pin, Timer
from array import array
from utime import ticks_us, ticks_diff
class ZACwire():
def __init__(self, pin, N = 20, N_filter = 9):
self.pin = pin
self.buf = array('i', [0 for _ in range(2*N+1)])
self.buflen = 2*N+1
self.safebuf = array('i', [0 for _ in range(2*N+1)])
self.dt = array('i', [0 for _ in range(2*N)])
self.bits = array('i', [0 for _ in range(2*N)])
self.loc = 0
self.timer = Timer(0)
self._decode = self.decode
self.median = N_filter // 2
self.mem = array('i', [0 for _ in range(N_filter)])
self.memloc = 0
self.T = 0
self.pin.irq(
handler = self.irq_handler,
trigger = Pin.IRQ_RISING | Pin.IRQ_FALLING,
)
self.timer.init(
period = 25,
mode = Timer.PERIODIC,
callback = self._decode,
)
def irq_handler(self, pin):
self.buf[self.loc] = ticks_us()
self.loc = self.loc + 1
def decode(self, t):
if self.loc and ticks_diff(ticks_us(), zw.buf[0]) > 4000:
self.loc = 0
self.safebuf[:] = self.buf[:]
for k in range(self.buflen-1):
self.dt[k] = ticks_diff(self.safebuf[k+1], self.safebuf[k])
for k in range((self.buflen-1)//2):
self.bits[k] = ticks_diff(self.safebuf[2*k+1], self.safebuf[2*k]) < ticks_diff(self.safebuf[2*k+2], self.safebuf[2*k+1])
self.mem[self.memloc] = (
self.bits[18]
+ self.bits[17] * 2**1
+ self.bits[16] * 2**2
+ self.bits[15] * 2**3
+ self.bits[14] * 2**4
+ self.bits[13] * 2**5
+ self.bits[12] * 2**6
+ self.bits[11] * 2**7
+ self.bits[8] * 2**8
+ self.bits[7] * 2**9
+ self.bits[6] * 2**10
)
self.memloc = (self.memloc + 1) % len(self.mem)
self.T = sorted(self.mem)[4] / 2047 * 70 - 10
print(self.T)
if __name__ == '__main__':
Pin(18, Pin.OUT, value = 1)
zw = ZACwire(Pin(16, Pin.IN)) |
Beta Was this translation helpful? Give feedback.
-
|
For the record, a much more robust ZACwire implementation for the pyboard is available here. |
Beta Was this translation helpful? Give feedback.
-
I'm trying to implement temperature readings from a TSic 506F using the ZACwire protocol. This requires measuring the length of low pulses lasting either 20-40 microseconds or 80-100 microseconds.
I tried doing so using IRQ callbacks but it seems to take ~70 us just to read the state of a pin using
pin.value(), so I suspect my approach is flawed, and I couldn't find an existing library for micropython. Does anybody have suggestions on the best strategy to achieve something like that?The TSic sensors are nice for scientific projects because of their high accuracy.
Beta Was this translation helpful? Give feedback.
All reactions