Adapting this arduino instructable to ESP32 - arduino

Question

I am trying to create a project that is similar to the one found here:
Easy Arduino Menus for Rotary Encoders
However, I am using an ESP32, and not an Arduino board.
To get to that far I need to get my Rotary Encoder working with his code:
Improved Arduino Rotary Encoder Reading
However, I can not compile the code and get an error on "PIND". This line:
reading = PIND & 0xC; // read all eight pin values then strip away all but pinA and pinB's values.
So my question is: Do you have an idea as to how I can adapt the encoder code to work with an ESP32?
Thanks a lot in advance. :)
His complete code:
/*******Interrupt-based Rotary Encoder Sketch*******
by Simon Merrett, based on insight from Oleg Mazurov, Nick Gammon, rt, Steve Spence
*/
static int pinA = 2; // Our first hardware interrupt pin is digital pin 2
static int pinB = 3; // Our second hardware interrupt pin is digital pin 3
volatile byte aFlag = 0; // let's us know when we're expecting a rising edge on pinA to signal that the encoder has arrived at a detent
volatile byte bFlag = 0; // let's us know when we're expecting a rising edge on pinB to signal that the encoder has arrived at a detent (opposite direction to when aFlag is set)
volatile byte encoderPos = 0; //this variable stores our current value of encoder position. Change to int or uin16_t instead of byte if you want to record a larger range than 0-255
volatile byte oldEncPos = 0; //stores the last encoder position value so we can compare to the current reading and see if it has changed (so we know when to print to the serial monitor)
volatile byte reading = 0; //somewhere to store the direct values we read from our interrupt pins before checking to see if we have moved a whole detent
void setup() {
pinMode(pinA, INPUT_PULLUP); // set pinA as an input, pulled HIGH to the logic voltage (5V or 3.3V for most cases)
pinMode(pinB, INPUT_PULLUP); // set pinB as an input, pulled HIGH to the logic voltage (5V or 3.3V for most cases)
attachInterrupt(0,PinA,RISING); // set an interrupt on PinA, looking for a rising edge signal and executing the "PinA" Interrupt Service Routine (below)
attachInterrupt(1,PinB,RISING); // set an interrupt on PinB, looking for a rising edge signal and executing the "PinB" Interrupt Service Routine (below)
Serial.begin(115200); // start the serial monitor link
}
void PinA(){
cli(); //stop interrupts happening before we read pin values
reading = PIND & 0xC; // read all eight pin values then strip away all but pinA and pinB's values
if(reading == B00001100 && aFlag) { //check that we have both pins at detent (HIGH) and that we are expecting detent on this pin's rising edge
encoderPos --; //decrement the encoder's position count
bFlag = 0; //reset flags for the next turn
aFlag = 0; //reset flags for the next turn
}
else if (reading == B00000100) bFlag = 1; //signal that we're expecting pinB to signal the transition to detent from free rotation
sei(); //restart interrupts
}
void PinB(){
cli(); //stop interrupts happening before we read pin values
reading = PIND & 0xC; //read all eight pin values then strip away all but pinA and pinB's values
if (reading == B00001100 && bFlag) { //check that we have both pins at detent (HIGH) and that we are expecting detent on this pin's rising edge
encoderPos ++; //increment the encoder's position count
bFlag = 0; //reset flags for the next turn
aFlag = 0; //reset flags for the next turn
}
else if (reading == B00001000) aFlag = 1; //signal that we're expecting pinA to signal the transition to detent from free rotation
sei(); //restart interrupts
}
void loop(){
if(oldEncPos != encoderPos) {
Serial.println(encoderPos);
oldEncPos = encoderPos;
}
}

Answer 1

The library(https://github.com/igorantolic/ai-esp32-rotary-encoder) you suggested is not very reliable. you get lot of false readings.
When I need to use a rotary encoder I stick to the example above.
I adapted it to ESP32:
As luck would have it it's nearly the same for GPIO34 and GPIO35.
GPIO34 is binary 100
GPIO35 is binary 1000
both 1100 or 0xC
https://www.espressif.com/sites/default/files/documentation/esp32_technical_reference_manual_en.pdf
Page 58:
GPIO_IN_REG --> GPIO 0...31
GPIO_IN1_REG --> GPIO 32...39
Please note GPIO 34, 35, 36 and 39 need pullup resistor. Else you can use INPUT_PULLUP
#include <Arduino.h>
static int pinA = 35;
static int pinB = 34;
volatile byte aFlag = 0;
volatile byte bFlag = 0;
volatile byte encoderPos = 0;
volatile byte oldEncPos = 0;
volatile byte reading = 0;
void IRAM_ATTR PinA()
{
cli();
reading = GPIO_REG_READ(GPIO_IN1_REG) & 0xC;
if (reading == B1100 && aFlag)
{
encoderPos--;
bFlag = 0;
aFlag = 0;
}
else if (reading == B1000)
bFlag = 1;
sei();
}
void IRAM_ATTR PinB()
{
cli();
reading = GPIO_REG_READ(GPIO_IN1_REG) & 0xC;
if (reading == B1100 && bFlag)
{
encoderPos++;
bFlag = 0;
aFlag = 0;
}
else if (reading == B100)
aFlag = 1;
sei();
}
void setup()
{
Serial.begin(115200);
pinMode(pinA, INPUT);
pinMode(pinB, INPUT);
attachInterrupt(digitalPinToInterrupt(pinA), PinA, RISING);
attachInterrupt(digitalPinToInterrupt(pinB), PinB, RISING);
}
void loop()
{
if (oldEncPos != encoderPos)
{
Serial.print("encoderPos: ");
Serial.println(encoderPos);
oldEncPos = encoderPos;
}
}

Answer 2

PIND is one of the registers for compatible Arduino boards only, which can be used for what is called direct port manipulation.
Specifically, PIND is the input register of port D (pins 0 to 7 on the UNO)
Reading this register for example, will give you the input state of each gpio from PIN0 to PIN7. In the Rotary Encoder this is used for reading the all the values of the PORTD in one go, and then mask other pins, except "pinA" and "pinB" which are pin 2 and pin 3 respectively.
This will not work on the ESP32 as that platform has no such register (remember you are doing direct hardware access here, and not going through a standard Arduino API)
You can look at GPIO_IN_REG in the ESP32 which you can use to read the GPIO pin states in a similar fashion.
GPIO_IN_REG will return the input values of GPIOs 0 - 31.
You can also try and use this library:
https://github.com/igorantolic/ai-esp32-rotary-encoder
if you need something already made, instead of reinventing the wheel, unless it is for your learning purposes.