Improve speed of two parallel function with one interrupt on ESP32

Projects Programming
1

I am using a ESP32S3 in Arduino IDE.
I have an interrupt that arrives on a GPIO and from that one I need to run two functions to enable other two GPIOS with different timings, the problem is that the accuracy of the execution of my two functions has to be within 1 usec. I do not need that the function starts in 1 usec, I can accept a delay, but the delay should be fixed with a maximum error of 1 usec. My current code is the following and it works but the error on the start of the signal is within 5 usec, so I should reduce of a factor 5 this.
I am open to change completely this architecture with something completely different, but I haven't found a better approach so far.

#include "driver/gpio.h"
#include "soc/gpio_struct.h"

#define MOUSE1_INT                  GPIO_NUM_4
#define MOUSE1_POTX                 GPIO_NUM_5
#define MOUSE1_POTY                 GPIO_NUM_6

int START_MOUSE1_X_PULSE = 0;
int END_MOUSE1_X_PULSE = 0;

int START_MOUSE1_Y_PULSE = 0;
int END_MOUSE1_Y_PULSE = 0;

TaskHandle_t Task1Handle = NULL;
TaskHandle_t Task2Handle = NULL;

void updatex() {
  for(int i = 0; i < START_MOUSE1_X_PULSE; i++) {
    __asm__ ( "nop;");
  }
  GPIO.out_w1ts = (GPIO.out_w1ts | ((uint32_t)1 << MOUSE1_POTX)); // set 1
  for(int i = 0; i < END_MOUSE1_X_PULSE; i++) {
    __asm__ ( "nop;");
  }
  GPIO.out_w1tc = (GPIO.out_w1tc | ((uint32_t)1 << MOUSE1_POTX)); // set 0
}

void updatey() {
  for(int i = 0; i < START_MOUSE1_Y_PULSE; i++) {
    __asm__ ( "nop;");
  }
  GPIO.out_w1ts = (GPIO.out_w1ts | ((uint32_t)1 << MOUSE1_POTY)); // set 1
  for(int i = 0; i < END_MOUSE1_Y_PULSE; i++) {
    __asm__ ( "nop;");
  }
  GPIO.out_w1tc = (GPIO.out_w1tc | ((uint32_t)1 << MOUSE1_POTY)); // set 0
}

void Task1(void *pvParameters) {
    while (true) {
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        updatex();
    }
}

void Task2(void *pvParameters) {
    while (true) {
        ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
        updatey();
    }
}

void IRAM_ATTR handleInterrupt() {
    BaseType_t xHigherPriorityTaskWoken1 = pdFALSE;
    BaseType_t xHigherPriorityTaskWoken2 = pdFALSE;
    vTaskNotifyGiveFromISR(Task1Handle, &xHigherPriorityTaskWoken1);
    vTaskNotifyGiveFromISR(Task2Handle, &xHigherPriorityTaskWoken2);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken1 || xHigherPriorityTaskWoken2);
}

void setup() {
  pinMode(MOUSE1_POTX, OUTPUT);
  pinMode(MOUSE1_POTY, OUTPUT);
  pinMode(MOUSE1_INT, INPUT_PULLDOWN);
  START_MOUSE1_X_PULSE = 4000;
  END_MOUSE1_X_PULSE = 3000;
  START_MOUSE1_Y_PULSE = 4500;
  END_MOUSE1_Y_PULSE = 3500;
  xTaskCreatePinnedToCore(Task1, "Task1", 2048, NULL, 20, &Task1Handle, 0); // Core 0
  xTaskCreatePinnedToCore(Task2, "Task2", 2048, NULL, 20, &Task2Handle, 1); // Core 1
  attachInterrupt(digitalPinToInterrupt(MOUSE1_INT), handleInterrupt, RISING);
}

void loop() {}
2

You should not use interrupts like that. Just change volatile variable there and check that variable in your loop to execute your task

3

OK, so why not just perform these tasks in the same routine and use some kind of (blocking) delay between setting the two GPIO outputs? Seems like this could be done on a single core with simple code. What's wrong with such a basic approach?

4

I tried it but failed. If I put the content of one of the two routines (like updatex using the volatile variables) into the interrupt handler I have the signal generated within the desired 1usec precision, but I haven’t found a way to handle both.
If you can give me some code suggestion of what could work it would be very helpful, thanks.

5

I ended up splitting in two tasks because I failed in running everything within the interrupt handler. Could you please help me a bit more how I can do on a single routine in the handler?

6

How much time do you want/need to have between the incoming signal (interrupt) and starting to flip the GPIO's in response? How much time between the GPIO flips (x and y routines)? I understand you have +/-1 usec margin between the x and y parts, but how much play do you have in the interrupt-to-action_x timing?

7

The exact sequence of event that should happens is:

  • the trigger arrives

  • in parallelI have to wait two variable delays, one for each GPIO and then rise both, each one after his own delay. The delay can be between 250 and 500 usec. The jitter in rising cannot be larger than 1usec.

  • after 512 usec from the trigger, I turn off both pins.

The two variable delay are set by another asynchronous routine (imagine in the loop or somewhere else) but once the delay is set the timing should be reproducible within 1usec.

So let’s say that I set a 310 usec for one GPIO and 400 for the second, then until I change the delay both signals should be flipped at 310±1 and 400±1 usec
from the trigger.

The two pin can also have the same delay, for example 310 and 310 usec.

I add an image on the oscilloscope for 1 GPIO rise. The yellow signal is the trigger, the blue is one of the two GPIO rise. In this case the end time of the GPIO is not exactly 512 usec but ends a bit earlier.

Thanks a lot for your time!

IMG_8672
IMG_86721920×1440 251 KB

8

OK, so in this case, I'd start with the simplest possible option, which is to simply delay (i.e. blocking) your core in the ISR for 250-500usec. Yes, that sounds filthy, but locking up the core for 0.512ms is probably sufferable and keeps things simple. Then raise the one GPIO, wait some more (blocking), raise the other GPIO. Delay until the 512us are up.

If that doesn't work, try a more complicated approach.

To make the delay happen, either let the core count with nop's or use delayMicroseconds.

9

I used this approach at the beginning. The problem is that once I do the first delay and I rise the first GPIO I can pass already the delay of the second GPIO if those are very close (or even the same), so I do not have the time to do one after the other, that is why I was implementing a parallel solution.

10

Looks like you should be able to flip a GPIO within 1 usec on an ESP32 platform. Maybe try to cut down the Arduino code overhead by some sort of low-level coding? I've never done this on ESP32 because I feel its strengths are in different areas.

11

The flip happens within 1 usec but when I restart the counter (I do with a for loop of nop) the creation of the for is quite long it seems. With the Arduino exists a solution with two timers, but I need the USB part of the ESP32S3. (Life is complicated sometime..)

12

How much time does the overhead of the for-loop involve? You might find that an alternative like a while-loop somehow compiles differently and ends up being slightly faster.
Then, check if you have enough time for the loop and if not, manage the delay in a different way; since you'll be dealing with times <2us or so (my guess) I think you can get away with having the controller do something like a silly division of two floats or something.

13

interesting suggestion, I will do some tentative here. Anyway I am happy that the solution is not so trivial otherwise I would feel very stupid.
Thanks for your help, if I solve it I will write here the solution.

14

No guarantees; it's perfectly possible there's a very simple solution and we're both overlooking it. In fact, I bet that's the case...

15

Disclaimer: I'm not familiar with ESPs nor with multitasking on them.

Below is normal Arduino code; you will need to adjust for your ESP. The code uses a for-loop for the total number of nop cycles; in that for-loop, it checks if an output must be made high or low.

I used a struct to store the pin, the number of nop cycles (from 0) before the output must go high and the number of nop cycles (from 0) before it must go low again.

The function calcMaxNops() calculates the number of nops needed for the complete cycle (both outputs).

The function controlOutputs() will be your ISR / Task.

#define NUMELEMENTS(x) (sizeof(x)/sizeof(x[0]))

struct OUTPIN
{
  const uint8_t pin;
  uint32_t highStart; // when to set output high
  uint32_t highEnd;   // when to end output high
};

OUTPIN pins[]
{
  {6, 100, 200},
  {7, 100, 200},
};

uint32_t maxNops = 0;

void setup()
{
  Serial.begin(115200);

  for (uint8_t cnt = 0; cnt < NUMELEMENTS(pins); cnt++)
  {
    pinMode(pins[cnt].pin, OUTPUT);
  }
}

void loop()
{
  calcMaxNops();
  controlOutputs();
}


void calcMaxNops()
{
  maxNops = 0;
  for (uint8_t cnt = 0; cnt < NUMELEMENTS(pins); cnt++)
  {
    if (maxNops > pins[cnt].highEnd)
    {
      maxNops = pins[cnt].highEnd;
    }
  }
}

void controlOutputs()
{
  // nop counter
  for (uint32_t nopCnt = 0; nopCnt < maxNops; nopCnt++)
  {
    // control each pin 
    for (uint8_t cnt = 0; cnt < NUMELEMENTS(pins); cnt++)
    {
      if (nopCnt > pins[cnt].highStart && nopCnt <= pins[cnt].highEnd)
      {
        digitalWrite(pins[cnt].pin, HIGH);
      }
      else
      {
        digitalWrite(pins[cnt].pin, LOW);
      }
    }
  }
}

I hope that this gives a different perspective. Note that I used digitalWrite(); you'll have to change that. Also note that it should be reasonably easy to change this to normal non-blocking code.

Not tested !!

1 Like
16

thanks I see your point, I think to loop over pins and do the if at each step of the nop adds quite a lot of jitter in the proper time when the state is risen, but I will give a try, thanks a lot!

17

So far the best solution that I found is the following

#include "esp_timer.h"
//#include "Arduino.h"
#include "driver/gpio.h"
#include "soc/gpio_struct.h"

const int interruptPin = 4;
const int gpio1 = 5; 
const int gpio2 = 6;

unsigned long delay1 = 250; 
unsigned long delay2 = 250;
unsigned long onTime = 200; 

esp_timer_handle_t timer1;
esp_timer_handle_t timer2;
esp_timer_handle_t timerOff1;
esp_timer_handle_t timerOff2;

// Funzione di interrupt
void IRAM_ATTR handleInterrupt() {
  esp_timer_start_once(timer1, delay1);
  esp_timer_start_once(timer2, delay2);
}

// Funzione per spegnere GPIO1
void IRAM_ATTR turnOffGpio1(void* arg) {
  GPIO.out_w1tc = (1 << gpio1); 
}

// Funzione per spegnere GPIO2
void IRAM_ATTR turnOffGpio2(void* arg) {
  GPIO.out_w1tc = (1 << gpio2);
}

// Funzione per accendere GPIO1
void IRAM_ATTR turnOnGpio1(void* arg) {
  GPIO.out_w1ts = (1 << gpio1);
  esp_timer_start_once(timerOff1, onTime);
}

// Funzione per accendere GPIO2
void IRAM_ATTR turnOnGpio2(void* arg) {
  GPIO.out_w1ts = (1 << gpio2); 
  esp_timer_start_once(timerOff2, onTime);
}

void setup() {
  pinMode(interruptPin, INPUT_PULLDOWN);
  pinMode(gpio1, OUTPUT);
  pinMode(gpio2, OUTPUT);

  attachInterrupt(digitalPinToInterrupt(interruptPin), handleInterrupt, RISING);

  GPIO.out_w1tc = (1 << gpio1);
  GPIO.out_w1tc = (1 << gpio2);

  esp_timer_create_args_t timer_args1 = {
      .callback = &turnOnGpio1,
      .name = "turnOnGpio1"
  };
  esp_timer_create(&timer_args1, &timer1);

  esp_timer_create_args_t timer_args2 = {
      .callback = &turnOnGpio2,
      .name = "turnOnGpio2"
  };
  esp_timer_create(&timer_args2, &timer2);

  esp_timer_create_args_t timer_off_args1 = {
      .callback = &turnOffGpio1,
      .name = "turnOffGpio1"
  };
  esp_timer_create(&timer_off_args1, &timerOff1);

  esp_timer_create_args_t timer_off_args2 = {
      .callback = &turnOffGpio2,
      .name = "turnOffGpio2"
  };
  esp_timer_create(&timer_off_args2, &timerOff2);
}

void loop() {}

basically what I do here is to set 4 timers. When the interrupt occurs I start the two timers for the initial delay, then I turn on the GPIOs and start the second timers to wait before shut down the GPIOs. I think that I can improve a bit using hardware timers instead of the API that I am using, but this is already within 1 usec of delay (barely).

Thanks for the discussion, was really useful.

1 Like
18

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.