Slow reaction on IRQ

[AlbertHoevenaars]

I have an analog signal that I want to measure. See the green line in the attached picture. After a rising and falling edge of the green signal I want to read the analog value by using an external ADC (ADS7884), which is connected to the SPI bus of the ESP32. The dutycycle of the green signal can go from 10 to 90%, and its frequency is 1kHz. I have digitized the green signal and fed the digital version to two ESP pins, one with the original digitized signal and one with the inverted signal. This gives me two interrupt functions. This is all working well. But what I see and what is the problem is the slow reaction after an interrupt occurs. In the attached picture is the top blue line the ck signal that read the data from the ADC and the lower blue line the CS line on the ADC. This CS line is the problem. Unfortunately, the first rising edge of the green signal in not shown, but the time form this edge to a low going CSn line is way too long. It takes roughly more that 200 us to go low. When CSn is going low the ADC samples the analog value and start the conversion. Reading out the data is also rather late not that’s not really the problem. Weird enough is the reaction on the falling edge of the green signal much faster, but still to slow.
From my main software I call get_adc_samples() and after that calc_cp_voltage(). After 100 millisec I call these functions again.

Anyone suggestion how I can make this faster? I would like to have that CSn goes low within 50us after a rising or falling edge of the green signal
`
#################################################

read ADC on interrupt trhough SPI

ESP32-WROOM-32 processor

ADS7884 ADC (falling edge of CSn starts conversion)

#################################################

from machine import Pin, ADC, SPI
from time import ticks_us, ticks_diff # Importeer tijd functies voor debouncing

#from definities import cp_val_pos, cp_val_neg
import definities_hardware
import definities

cp_val_pos_buf = bytearray(2)
cp_val_neg_buf = bytearray(2)

pos_done = False
neg_done = False

Create ADC object

cp_in_adc = ADC(Pin(definities_hardware.cp_in_pin))

Make SPI Chip Select line

cs = Pin(definities_hardware.spi_cs_pin, mode=Pin.OUT, value = 1) # create chipselect

CReate SPI interface with prameters

spi = SPI(2, baudrate=2000000, polarity=0, phase=1, bits=8, firstbit=SPI.MSB, sck=Pin(definities_hardware.spi_clk_pin), mosi=Pin(13), miso=Pin(definities_hardware.spi_miso_pin) ) # 35 is unused pin

Define GPIO pins for IRQ detection

IRQ_pos_trig = Pin(Pin(definities_hardware.cp_pos_trig), Pin.IN) # for rising edge
IRQ_neg_trig = Pin(Pin(definities_hardware.cp_neg_trig), Pin.IN) # for falling edge

Interrupt handler for rising edge of signal

def handle_pos_interrupt(pin):

global pos_done

global cp_val_pos_buf

if not(pos_done):
    # Read ADC to get voltage of rising edge
    cs(0)                                              # make CSn low which locks the analog voltage
    spi.readinto(cp_val_pos_buf)                       # Read 2 bytes, write 0x00
    cs(1)                                              # Deselect peripheral.

    # Mark that adc is read at rising edge
    pos_done = True
    IRQ_pos_trig.irq(trigger=0, handler=handle_pos_interrupt)  # disable deze interrupt

Interrupt handler for falling edge of signal

def handle_neg_interrupt(pin):

global neg_done
global cp_val_neg_buf

if not(neg_done):
    # Read ADC to get voltage of rising edge
    cs(0)                                        # make CSn low which locks the analog voltage
    spi.readinto(cp_val_neg_buf)                 # Read 2 bytes, write 0x00
    cs(1)                                        # Deselect peripheral.
    # Mark that adc is read at falling edge
    neg_done = True
    IRQ_neg_trig.irq(trigger=0, handler=handle_neg_interrupt)  # disable deze interrupt

class class_CP_sniffer:
def init(self, pin, cp_adc_range, cp_adc_bits, cp_adc_width, cp_adc_scale, cp_adc_shift):
# make Pin object for analog signal
self.cp_in_pin = Pin(pin)

    # Stel spanningsbereik in voor ADC
    self.cp_adc_range = cp_adc_range  # voltage range

    # Bereken aantal ADC stappen op basis van resolutie
    self.cp_adc_steps = pow(2, cp_adc_bits)
    self.cp_adc_shift = cp_adc_shift
    self.bit_to_voltage = (self.cp_adc_range / self.cp_adc_steps ) / pow(2,self.cp_adc_shift)

#
#
# First get ADC sample from rising edge, Second get adc sample from negative edge
def get_adc_samples(self):

    global neg_done
    global pos_done

    # now loop for max 1.5 millisec to receive the analog value
    end_time = ticks_us()
    pos_done = False

    # Enable IRQ for rising edge
    IRQ_pos_trig.irq(trigger=Pin.IRQ_RISING, handler=handle_pos_interrupt)

    while  ( not (pos_done) and not(ticks_diff(ticks_us(), end_time) > 1500)):
        pass

    # now loop for max 1.5 millisec to receive the analog value
    end_time = ticks_us()
    neg_done = False

    # Enable IRQ for falling edge
    IRQ_neg_trig.irq(trigger=Pin.IRQ_RISING, handler=handle_neg_interrupt)

    # now wait for max 1.5 millisec to receive the analog value
    while (not (neg_done) and not(ticks_diff(ticks_us(), end_time) > 1500)):
        pass


# Calculate voltages from ADC code
def calc_cp_voltage(self):

    cp_adc_pos = ((int.from_bytes(cp_val_pos_buf) * self.bit_to_voltage
    cp_adc_neg = ((int.from_bytes(cp_val_neg_buf) * self.bit_to_voltage

    print('pos_voltage on adc= %s' % cp_adc_pos)
    print('neg_voltage on adc = %s' % cp_adc_neg)

`

[peterhinch]

ESP32 interrupts are soft interrupts because of the underlying FreeRTOS. For low interrupt latency you need a bare metal port such as STM32 or RP2, with the code specifying hard interrupts. You can then expect latency on the order of 10-20μs.

See docs.

[robert-hh]

Like Peter said, it is unlikely that you can improve things reliably when using a ESP32. As powerful as it is, the code timing is not very reliable.
I did test the IRQ latency for various boards in the past with just a simple callback, pulsing a GPIO on response. With ESP32, the latency is 30-400µs. For RP2 it's 15-20µs, for Teensy 4.x (MIMXRT1062) it's 0.9-1.2 µs. It seems I did not test STM32, but I recall something like 10µs for a PyBoard 1.1.
The fastest and reliable response you can get is using the RP2 PIO for both detecting the transition, reading the data via SPI and storing it using DMA. That will not be affected by the Python code at all, and the timing can be controlled down to sub-microseconds.

[AlbertHoevenaars]

Thanks, peterinch & robert-hh for the answer. What I can try if I don't want to switch to another processor is taking care that CSn goes low a short period after the rising and falling edge. Then this will be a hardware solution. Well every solution needs a change in my pcb design. So, lots of work to do.
Thanks again