esp32 isr in Klasse

[Reiner W. (reiner_w)]

Ich versuche mich gerade in cpp auf einem esp32 einzuarbeiten.
Dabei habe ich ein generelles Problem bei der Konvertierung in eine 
Klasse. Speziell macht hier die isr Probleme.

Hier ein kleines Testprogramm für esp32, kompiliert mit dem Arduino 
Framework.

#include <Arduino.h>
#include <esp_timer.h>  // for meassure time
#include <stdio.h>

#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/task.h"

const gpio_num_t INPUT_PIN = (gpio_num_t)15;
const gpio_num_t LED_PIN = (gpio_num_t)2;

int state = 0;
xQueueHandle interputQueue;

struct isr_data {
    int pinNumber;
    int64_t isr_time;
};

static void IRAM_ATTR gpio_interrupt_handler(void *args) {
    int pinNumber = (int)args;
    
    isr_data data = {.pinNumber = pinNumber, .isr_time = esp_timer_get_time()};

    xQueueSendFromISR(interputQueue, &data, NULL);
}

void LED_Control_Task(void *params) {
    int pinNumber, count = 0;
    isr_data data = {}; // buffer for received struct
    static int64_t last_isr_time = 0;
    while (true) {
        // worker
        if (xQueueReceive(interputQueue, &data, portMAX_DELAY)) {
            printf("TimeDiff %lld ms GPIO %d was pressed %d times. The state is %d\n",
                   (data.isr_time - last_isr_time) / 1000,
                   data.pinNumber, 
                   count++, 
                   gpio_get_level(INPUT_PIN));

            last_isr_time = data.isr_time;

            gpio_set_level(LED_PIN, !gpio_get_level(LED_PIN));
        }
    }
}

void setup() {
    pinMode(LED_PIN, OUTPUT);
   
    gpio_pad_select_gpio(INPUT_PIN);
    gpio_set_direction(INPUT_PIN, GPIO_MODE_INPUT);
    gpio_pulldown_dis(INPUT_PIN);
    gpio_pullup_en(INPUT_PIN);
    gpio_set_intr_type(INPUT_PIN, GPIO_INTR_POSEDGE);

    struct isr_data data = {.pinNumber = INPUT_PIN, .isr_time = 0};

    interputQueue = xQueueCreate(10, sizeof(isr_data));
    xTaskCreate(LED_Control_Task, "LED_Control_Task", 2048, NULL, 1, NULL);
    gpio_install_isr_service(0);
    gpio_isr_handler_add(INPUT_PIN, gpio_interrupt_handler,(void*) INPUT_PIN);
}

void loop() {}

Das Programm arbeitet wie gewünscht. Es ist nur für mich ein Beispiel 
für das Zusammenwirken von isr->Queue->ControlTask.

Nun will ich die komplette Funktionalität in eine Klasse auslagern. Und 
genau das bekomme ich nicht hin.
Das Problem ist offenbar die isr.

Mein erster Ansatz war:

#include <Arduino.h>
#include <esp_timer.h>  // for meassure time
#include <stdio.h>

#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/task.h"

class GpioControl {
   private:
    gpio_num_t inputPin;
    gpio_num_t ledPin;
    xQueueHandle interputQueue;
    TaskHandle_t xLedTaskHandle;
    struct isr_data {
        int pinNumber;
        int64_t isr_time;
    };

    static void IRAM_ATTR gpio_interrupt_handler(void *args);
    static void LED_Control_Task(void *params);

   public:
    GpioControl(gpio_num_t inputPin, gpio_num_t ledPin);
    int get_pin_state();
};

GpioControl::GpioControl(gpio_num_t inputPin, gpio_num_t ledPin) {
    this->inputPin = inputPin;
    this->ledPin = ledPin;

    pinMode(ledPin, OUTPUT);

    gpio_pad_select_gpio(inputPin);
    gpio_set_direction(inputPin, GPIO_MODE_INPUT);
    gpio_pulldown_en(inputPin);
    gpio_pullup_dis(inputPin);
    gpio_set_intr_type(inputPin, GPIO_INTR_POSEDGE);

    interputQueue = xQueueCreate(10, sizeof(isr_data));
    xTaskCreate(LED_Control_Task, "LED_Control_Task", 2048, this, 1, &xLedTaskHandle);
    gpio_install_isr_service(0);
    gpio_isr_handler_add(inputPin, gpio_interrupt_handler, (void *)inputPin);
}

int GpioControl::get_pin_state() {
    return gpio_get_level(inputPin);
}

void IRAM_ATTR GpioControl::gpio_interrupt_handler(void *args) {
    GpioControl *instance = (GpioControl *)args;
    int pinNumber = instance->inputPin;

    isr_data data = {.pinNumber = pinNumber, .isr_time = esp_timer_get_time()};
    xQueueSendFromISR(instance->interputQueue, &data, NULL);
}

void GpioControl::LED_Control_Task(void *params) {
    GpioControl *instance = (GpioControl *)params;
    int pinNumber, count = 0;
    isr_data data = {};  // buffer for received struct
    static int64_t last_isr_time = 0;
    while (true) {
        if (xQueueReceive(instance->interputQueue, &data, portMAX_DELAY)) {
            printf("TimeDiff %lld ms GPIO %d was pressed %d times. The state is %d\n",
                   (data.isr_time - last_isr_time) / 1000,
                   data.pinNumber,
                   count++,
                   gpio_get_level(instance->inputPin));

            last_isr_time = data.isr_time;

            gpio_set_level(instance->ledPin, !gpio_get_level(instance->ledPin));
        }
    }
}

void setup() {
    GpioControl gpioControl((gpio_num_t)15, (gpio_num_t)2);
}

void loop() {

Läßt sich zwar problemlos kompilieren. Aber die isr wird offenbar nicht 
aufgerufen.
ChatGPT hat zwar einiges vorgeschlagen (u.a. eine Wrapperfunktion für 
die isr) aber eine Lösung fand er auch nicht. Nach
einigen Stunden habe ich dann entnervt aufgeben;-)
Hat jemand einen Rat, wo es hier klemmen könnte?

[Foobar (asdfasd)]

> ChatGPT hat zwar einiges vorgeschlagen (u.a. eine Wrapperfunktion für
> die isr) aber eine Lösung fand er auch nicht.

Das hat er, du siehst sie nur nicht.  Ein Interrupthandler ist eine 
globale Funktion.  Soll diese eine Memberfunktion aufrufen, braucht sie 
eine Instanz der Klasse - eine globale Referenz/Pointer/Objekt. 
Irgendein dynamisches Object auf dem Stack reicht nicht.  Woher soll der 
Interrupthandler wissen, welche Instanz er nutzen soll?

[Andreas M. (amesser)]

gpio_isr_handler_add musst Du ebenfalls "this" als letztes Argument 
geben. Außerdem hat der Vorposter Recht was die Queue betrifft. Diese 
speichert nur Pointer. Da kann man nicht die Adresse einer Struktur vom 
Stack reinstecken, "isr_data data" ist genau so lange definiert, wie die 
ISR Funktion läuft, danach nicht mehr. Das ist bereits im C-Code falsch.

[Foobar (asdfasd)]

> gpio_isr_handler_add

Upps, das hatte ich garnicht gesehen.  Ich war davon ausgegangen, dass 
beim esp32 Interrupthandler ähnlich installiert werden wie bei anderen 
CPUs, per globalem Namen und da ein solcher im o.g. Code nicht vorhanden 
war, auch keiner installiert wurde.

Mit dieser Funktion ist meinen vorheriger Post ziemlicher Quatsch.

Sorry.

[Reiner W. (reiner_w)]

Foobar schrieb:
> Das hat er, du siehst sie nur nicht.  Ein Interrupthandler ist eine
> globale Funktion.  Soll diese eine Memberfunktion aufrufen, braucht sie
> eine Instanz der Klasse - eine globale Referenz/Pointer/Objekt.
> Irgendein dynamisches Object auf dem Stack reicht nicht.

Naja, jedenfalls hat er mir das prinzipielle Problem korrekt 
beschrieben, so wie ihr auch schon angemerkt habt. Allerdings was sein 
korrigierter Code nicht compilierbar und über die Hürde konnte er auch 
nicht springen.

Hier sein Vorschlag:

#include <Arduino.h>
#include <esp_timer.h>  // for measuring time
#include <stdio.h>

#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/task.h"

const gpio_num_t BUTTON_PIN = GPIO_NUM_15;
const gpio_num_t LED_PIN = GPIO_NUM_2;

xQueueHandle interruptQueue;

class Button {
private:
  gpio_num_t pin;
  int count;

public:
  Button(gpio_num_t buttonPin) : pin(buttonPin), count(0) {}

  void begin() {
    gpio_pad_select_gpio(pin);
    gpio_set_direction(pin, GPIO_MODE_INPUT);
    gpio_pulldown_dis(pin);
    gpio_pullup_en(pin);
    gpio_set_intr_type(pin, GPIO_INTR_POSEDGE);
    gpio_install_isr_service(0);
    gpio_isr_handler_add(pin, isrHandlerWrapper, this);
  }

  static void IRAM_ATTR isrHandlerWrapper(void *args) {
    Button *button = static_cast<Button *>(args);
    button->isrHandler();
  }

  void IRAM_ATTR isrHandler() {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xQueueSendFromISR(interruptQueue, &pin, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR();
  }
};

Button button(BUTTON_PIN);

void ButtonTask(void *params) {
  gpio_num_t pin;
  while (true) {
    if (xQueueReceive(interruptQueue, &pin, portMAX_DELAY)) {
      printf("Button pressed on pin %d\n", pin);
      digitalWrite(LED_PIN, !digitalRead(LED_PIN));
    }
  }
}

void setup() {
  pinMode(LED_PIN, OUTPUT);

  interruptQueue = xQueueCreate(10, sizeof(gpio_num_t));

  button.begin();

  xTaskCreate(ButtonTask, "ButtonTask", 2048, NULL, 1, NULL);
}

void loop() {}

Der Linker gibt dann:

.pio/build/esp32dev/src/esp32_gpio_interrupt.cpp.o: in function `Button::isrHandler()':
/Volumes/mydocs/PlatformIO/Projects/ESP32_RTOS_ISR_class/src/esp32_gpio_interrupt.cpp:40:(.iram1.28[Button::isrHandlerWrapper(void*)]+0x3): dangerous relocation: l32r: literal placed after use: .literal._ZN6Button17isrHandlerWrapperEPv

aus.
Und da steh ich wieder am Anfang.

[Foobar (asdfasd)]

Dieser dubiose Fehler scheint durch die CPU-Archtektur bedingt (also 
kein Code-Fehler).  Hier ist es etwas ausführlicher:
  https://stackoverflow.com/questions/19532826/what-does-a-dangerous-relocation-error-mean

Ich würd mal versuchen, die Wrapper-Funktion anders zu plazieren, z.B. 
als globale Funktion außerhalb der Klasse.  Oder evtl begin() mit dem 
handler_add auch IRAM_ATTR zu machen (nur damit sie im gleichen segment 
landen).  Solche Fehler sind häßlich und arten oft in viel 
Rumprobiererei aus ...

[Reiner W. (reiner_w)]

Foobar schrieb:
> Dieser dubiose Fehler scheint durch die CPU-Archtektur bedingt (also
> kein Code-Fehler).  Hier ist es etwas ausführlicher:
> 
https://stackoverflow.com/questions/19532826/what-does-a-dangerous-relocation-error-mean
>
> Ich würd mal versuchen, die Wrapper-Funktion anders zu plazieren, z.B.
> als globale Funktion außerhalb der Klasse.  Oder evtl begin() mit dem
> handler_add auch IRAM_ATTR zu machen (nur damit sie im gleichen segment
> landen).  Solche Fehler sind häßlich und arten oft in viel
> Rumprobiererei aus ...

Danke für die hilfreichen Tipps!
> handler_add auch IRAM_ATTR zu machen
Daran habe ich noch gar nicht gedacht, das werde ich testen.
Außerdem will ich mal schauen, ob espressiv irgendwo in den Beispielen 
der esp-idf-cxx brauchbare Hinweise versteckt hat.
Zum Glück komme ich in meinem Projekt auch ohne Klasse aus. Aber 
irgendwie wurmt es mich schon, dass das nicht hinzubekommen sein soll.