esp32 isr in Klasse

Reiner W. (reiner_w) OP 24.05.2023 02:54 #7419864

Lesenswert?

•

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?

Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden

Foobar (asdfasd) 24.05.2023 03:12 #7419866

Lesenswert?

•

▲
▼

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?

Antwort Zitieren Bearbeiten Löschen Beitrag melden

Andreas M. (amesser) 24.05.2023 06:17 #7419880

Lesenswert?

•

▲
▼

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.

Antwort Zitieren Bearbeiten Löschen Beitrag melden

Foobar (asdfasd) 24.05.2023 07:34 #7419902

Lesenswert?

•

▲
▼

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.

Antwort Zitieren Bearbeiten Löschen Beitrag melden

Reiner W. (reiner_w) OP 24.05.2023 09:10 #7419970

Lesenswert?

•

▲
▼

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.

Antwort Zitieren Bearbeiten Löschen Beitrag melden

Foobar (asdfasd) 24.05.2023 17:09 #7420385

Lesenswert?

•

▲
▼

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 ...

Antwort Zitieren Bearbeiten Löschen Beitrag melden

Reiner W. (reiner_w) OP 24.05.2023 17:31 #7420397

Lesenswert?

•

▲
▼

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.

Antwort Zitieren Bearbeiten Löschen Beitrag melden

esp32 isr in Klasse

Antwort schreiben