Lack of examples of work with PCNT

[brightproject]

I plan to buy ESP32-S3-wroom-1 to use it with EC-11 encoder.


While designing a printed circuit board with buttons.
But I don’t understand enough whether I can fully use the encoder.
The first - I did not find a single example using ESP32-S3-wroom-1 with an encoder.
There is esp32-c2, esp32-c3, and old ESP32-D0WDQ6-V3, but I haven’t seen ESP32-S3-wroom-1.
Basically, these are either buttons connected to the ADC through resistors, or a touch panel display.
The second - that confuses me is the presence of the PCNT function in the new versions of the ESP32-S3-wroom-1, in the old versions of the esp32 they used to work with an encoder on interrupts.
I saw examples of working with PCNT only in ESP-IDF.
In general, there is no complete information and therefore I'm in a daze.
I'm designing a printed circuit board and I'm not sure if the encoder will work with ESP32-S3-wroom-1.
I distribute the encoder pins with a button like this

A - 35
B - 36
KEY - 37

From my description of the problem, it may not be entirely clear, so I will formulate the questions again:

1. Can I use an encoder with ESP32-S3-wroom-1 using PCNT without using esp-idf?
2. PCNT is used for any encoders, will it be redundant for an incremental encoder EC-11?
3. Is it better to interrogate the EC-11 encoder through interrupts, and is the PCNT function needed for more complex encoders (optical, absolute)?
   Please help me understand the issue.

[surfskidude]

I would like an answer too. I cannot find any useful info on the Internet.

[me-no-dev]

We do not yet have our own Arduino-like abstraction on top of IDF's PCNT driver, but you can use ESP-IDF's driver directly. If you pull out the encoder driver from IDF's examples and add it to your sketch, you can get it going directly in Arduino.

#include "rotary_encoder.h"

rotary_encoder_t *encoder;

void encoderBegin(uint8_t pulse_pin, uint8_t ctrl_pin, uint8_t btn_pin){
    // Create rotary encoder instance
    rotary_encoder_config_t config = ROTARY_ENCODER_DEFAULT_CONFIG((rotary_encoder_dev_t)0, pulse_pin, ctrl_pin, btn_pin);
    if(rotary_encoder_new_ec11(&config, &encoder) != ESP_OK){
        Serial.println("rotary_encoder_new Failed!");
        encoder = NULL;
        return;
    }

    // Filter out glitch
    if(encoder->filter_out_glitch(encoder, 10 /* us */)){
        Serial.println("rotary_encoder_filter_out_glitch Failed!");
        encoder = NULL;
        return;
    }

    // Start encoder
    if(encoder->start(encoder)){
        Serial.println("rotary_encoder_start Failed!");
        encoder = NULL;
        return;
    }
}


void encoderRead(int * steps, bool * pressed){
    if(encoder == NULL){
        return;
    }

    // Encoder steps +/-
    static int last_counter = 0;
    int counter = encoder->get_counter_value(encoder) / 4;
    *steps = counter - last_counter;
    last_counter = counter;

    // Encoder button
    *pressed = encoder->get_button_value(encoder) == LOW;
}

[brightproject]

but you can use ESP-IDF's driver directly

@me-no-dev, Thanks for the information, but it seems to further confuse the situation.
Can you please tell me what header file this is?
In the official repository I found an example only for the IDF framework, but it is not applicable for Arduino.
I use my own library to work with encoders for ESP32, but it uses classic code techniques, similar to those for the STM32 microcontroller.

#define CLK 35
#define DT 36
#define SW 37

#include "encoderMy.h"
Encoder enc1(CLK, DT, SW);

void setup() {
  Serial.begin(115200);
  attachInterrupt(0, isrCLK, CHANGE);
  attachInterrupt(1, isrDT, CHANGE);
}

void isrCLK() {
  enc1.tick();
}
void isrDT() {
  enc1.tick();
}

void loop() {
  enc1.tick();
  if (enc1.isRight()) Serial.println("Right");
  if (enc1.isLeft()) Serial.println("Left");

  if (enc1.isRightH()) Serial.println("Right holded"); 
  if (enc1.isLeftH()) Serial.println("Left holded");
}

I would like to use a hardware feature PCNT and not invent crutches.

[me-no-dev]

If you need it for rotary encoder, just wait a bit. A driver will be present in 3.0.0 or 3.0.1, else the IDF example with very tiny change can compile just fine under Arduino.

Rename app_main to setup and move the code in the while loop into loop

[danalvarez]

@brightproject this library uses PCNT. The implementation may be of use if you want to use PCNT in your own code. https://github.com/kapraran/FreqCountESP

[brightproject]

f you need it for rotary encoder, just wait a bit.

Unfortunately, I don’t understand IDF at all, I always work with the framework.
Now I'm trying to poll the encoder on pins 35 and 36 and it seems to me that these pins have no interruptions.
Button on pin 37.
I didn’t find anything in the documentation about pins and interrupts.
The STM32 datasheet describes which pins interrupts can be used on and which timers are enabled.
For ESP32 everything is more complicated.
Thanks for the info!