ESP32 Tasterauswertutn Probleme

[Chandler B. (chandler)]

Hallo,
ich habe ein Problem mit der Tastenauswertung an einem ESP32-Wroom-32 
Modul.
Ich habe 4 Taster (Pin 36, 39, 35,34) mit einem Pulldown-Widerstand 
angeschlossen.
Das Problem welches ich habe ist, dass wenn ich einen Taster drücke, 
alle anderen Taster den selben Zustand annehmen.

typedef enum
{
    PLAY,
    STOP,
    NEXT,
    SHUTDOWN,
    NUM_OF_BUTTONS
} ButtonName_te;

typedef enum
{
    LOW,
    RISING,
    HIGH,
    FALLING,
    ERROR
} ButtonState_te;

typedef struct
{
    ButtonName_te   name_e;
    gpio_num_t      gpioNum;
    ButtonState_te  state_e;
    ButtonState_te  oldState_e;
    bool            stateChanged_b;
} Button_ts;

        case INIT:
        {
            for (ButtonName_te x=PLAY; x<NUM_OF_BUTTONS; x++)
            {
                ESP_LOGI(TAG, "IO %d: %d ", x, button_as[x].gpioNum);
                gpio_set_direction(button_as[x].gpioNum, GPIO_MODE_INPUT);
                gpio_input_enable(button_as[x].gpioNum);
                gpio_set_pull_mode(button_as[x].gpioNum, GPIO_PULLDOWN_ONLY);

                button_as[x].state_e = LOW;
                button_as[x].oldState_e = LOW;
            }
            taskState_e = RUNNING;
            break;
        }
    
        case RUNNING:
        {
            for (ButtonName_te x=PLAY; x<NUM_OF_BUTTONS; x++)
            {
                getButtonState_v(&button_as[x]);
            }

            if (true == button_as[PLAY].stateChanged_b)
            {
                ESP_LOGI(TAG, "BUTTON PLAY Status Changed to: %d", button_as[PLAY].state_e);
                button_as[PLAY].stateChanged_b = false;
            }
            if (true == button_as[STOP].stateChanged_b)
            {
                
                ESP_LOGI(TAG, "BUTTON STOP Status Changed to: %d", button_as[STOP].state_e);
                button_as[STOP].stateChanged_b = false;
            }
            if (true == button_as[NEXT].stateChanged_b)
            {
                
                ESP_LOGI(TAG, "BUTTON NEXT Status Changed to: %d", button_as[NEXT].state_e);
                button_as[NEXT].stateChanged_b = false;
            }
            if (true == button_as[SHUTDOWN].stateChanged_b)
            {
                
                ESP_LOGI(TAG, "BUTTON SHUTDOWN Status Changed to: %d", button_as[SHUTDOWN].state_e);
                button_as[SHUTDOWN].stateChanged_b = false;
            }
            break;
        }

Tastenauswertung:

static void getButtonState_v(Button_ts* button_ps)
{
    if (LOW == button_ps->state_e)
    {
        if (FALLING == button_ps->oldState_e)
        {
            button_ps->oldState_e = LOW;
            button_ps->stateChanged_b = true;
        }
        if (1 == gpio_get_level(button_ps->gpioNum))
        {
            ESP_LOGI(TAG, "Button: %d", button_ps->gpioNum);
            button_ps->oldState_e = LOW;
            button_ps->state_e = RISING;
        }
    }
    else if (RISING == button_ps->state_e)
    {
        if (1 == gpio_get_level(button_ps->gpioNum))
        {
            button_ps->oldState_e = RISING;
            button_ps->state_e = HIGH;
        }
        else
        {
            button_ps->state_e = LOW;
        }
    }
    else if (HIGH == button_ps->state_e)
    {
        if (RISING == button_ps->oldState_e)
        {
            button_ps->oldState_e = HIGH;
            button_ps->stateChanged_b = true;
        }
        if (0 == gpio_get_level(button_ps->gpioNum))
        {
            button_ps->state_e = FALLING;
        }
    }
    else if (FALLING == button_ps->state_e)
    {
        if (0 == gpio_get_level(button_ps->gpioNum))
        {
            button_ps->oldState_e = FALLING;
            button_ps->state_e = LOW;
        }
        else
        {
            button_ps->state_e = HIGH;
        }
    }
}

Die Ausgabe aus dem INIT-State

I (344) GPIO: IO 0: 36
I (364) GPIO: IO 1: 39
I (364) GPIO: IO 2: 35
I (364) GPIO: IO 3: 34

Wenn ich jetzt eine Taste drücke (egal welche), werden alle Buttons 
getriggert. Ausgabe aus dem RUNNING-State wenn ich eine Taste Drücke

I (170074) GPIO: BUTTON PLAY Status Changed to: 2
I (170074) GPIO: BUTTON STOP Status Changed to: 2
I (170074) GPIO: BUTTON NEXT Status Changed to: 2
I (170074) GPIO: BUTTON SHUTDOWN Status Changed to: 2

Gleiches passiert, wenn ich den Taster loslasse.

[Rolf (rolf22)]

Chandler B. schrieb:
> Ich habe 4 Taster (Pin 36, 39, 35,34) mit einem Pulldown-Widerstand
> angeschlossen.

Wer wird dieses lange Programm studieren, wenn er statt Schaltplan nur 
eine Wischiwaschi-Aussage bekommt?

> Das Problem welches ich habe ist, dass wenn ich einen Taster drücke,
> alle anderen Taster den selben Zustand annehmen.

Ach, die anderen Taster bewegen sich dann mit? Vielleicht ist Klebstoff 
dazwischen geraten? SCNR.

[Thomas W. (Gast)]

Chandler B. schrieb:
> Hallo,
> ich habe ein Problem mit der Tastenauswertung an einem ESP32-Wroom-32
> Modul.
> Ich habe 4 Taster (Pin 36, 39, 35,34) mit einem Pulldown-Widerstand
> angeschlossen.

Ein Widerstand fuer vier Taster?

Schaltplan bitte!

[Chandler B. (chandler)]

Rolf schrieb:
> Wer wird dieses lange Programm studieren, wenn er statt Schaltplan nur
> eine Wischiwaschi-Aussage bekommt?
Anbei der Schaltplan
Jeder Taster hat seinen eigenen Widerstand.

[Anton V. (anton_elfi)]

Erstmal direkt am µC Eingang messen, was bei Tastendruck passiert und so 
Verdrahtungsfehler ausschließen.

Danach würde ich zur Not die KI über den Code befragen.

Viele Grüße!

[Peter D. (peda)]

Wer soll mit den rausgerissenen Schnipselchen was anfangen können?
Benutzt Du eine Entprellib?
Poste einen compilierbaren Code (0 errors, 0 warnings) als Anhang, d.h. 
nicht eingebettet!

Es sieht so aus, als machten unter RUNNING alle ifs das gleiche. Dann 
ersetze das if-Monster durch eine Schleife. Das ist weniger Code, besser 
zu verstehen und man muß es nur einmal lesen.

Tasten schaltet man vorzugsweise low aktiv. Dann besteht weniger Gefahr, 
die VCC versehentlich kurzzuschließen.

[N. M. (mani)]

Aus was für einem context heraus wird denn dein Switch Case aufgerufen 
und wie ist button_as[] definiert?

Was passiert wenn bei init ein anderer Zustand als Low an den Tastern 
anliegt?

[Chandler B. (chandler)]

N. M. schrieb:
> Aus was für einem context heraus wird denn dein Switch Case aufgerufen

das Switch-Case wird zyklisch aufgerufen

static void gpioTask_v(void * pvParameters)
{
    TickType_t xLastWakeTime;
    const TickType_t xFrequency = 20;

    for( ;; )
    {
        // Wait for the next cycle.
        xTaskDelayUntil( &xLastWakeTime, xFrequency );

        gpioExec_v();
        // Perform action here. xWasDelayed value can be used to determine
        // whether a deadline was missed if the code here took too long.
    }
}

static void gpioExec_v(void)
{
    switch(taskState_e)
    {
        case INIT:
        {
... ... ...
        }
    
        case RUNNING:
        {
... ... ...
        }
    }
}

N. M. schrieb:
> und wie ist button_as[] definiert?

static Button_ts button_as[NUM_OF_BUTTONS] =
{
    {
        .name_e = PLAY,
        .gpioNum = GPIO_INPUT_IO_PLAY,
        .state_e = LOW,
        .oldState_e = LOW,
        .stateChanged_b = false
    },
    {
        .name_e = STOP,
        .gpioNum = GPIO_INPUT_IO_STOP,
        .state_e = LOW,
        .oldState_e = LOW,
        .stateChanged_b = false
    },
    {
        .name_e = NEXT,
        .gpioNum = GPIO_INPUT_IO_NEXT,
        .state_e = LOW,
        .oldState_e = LOW,
        .stateChanged_b = false
    },
    {
        .name_e = SHUTDOWN,
        .gpioNum = GPIO_INPUT_IO_SHUTDOWN,
        .state_e = LOW,
        .oldState_e = LOW,
        .stateChanged_b = false
    }
};

N. M. schrieb:
> Was passiert wenn bei init ein anderer Zustand als Low an den Tastern
> anliegt?

Das sollte egal sein. Erst wenn es von LOW auf HIGH wechselt sollte der 
Zustandswechsel erkannt werden.

[Joachim B. (jar)]

Chandler B. schrieb:
> Erst wenn es von LOW auf HIGH wechselt sollte der
> Zustandswechsel erkannt werden

und wie entprellst du?