#include <Arduino.h>
#include "RotaryEncoder.h"

RotaryEncoder encoder(32, 33, 100, 0, 1000);

const char* directions[] = {
  "ccw", "", "cw"
};

void setup() {
  Serial.begin(115200);
  Serial.println("Hello, ESP32!");
  encoder.begin();
}

void loop() {
  if (encoder.available()) {
    Serial.printf("%d (%s)\r\n",encoder.getPosition(), directions[encoder.getDirection()+1]);
  }
  delay(10); // this speeds up the simulation
}


sketch.ino

diagram.json

#pragma once

#include <Arduino.h>

enum REDirection {
  RE_CCW  = -1,
  RE_NONE = 0,
  RE_CW   = 1
};

class RotaryEncoder {
  public:
    RotaryEncoder(int clkGPIO, int dtGPIO, int step, int min, int max);
    void begin();
    int getPosition();
    REDirection getDirection();
    bool available();

  protected:
    void encoderISR();

  protected:
    int clkGPIO, dtGPIO;
    int step, min, max;
    int volatile position = 0;
    int volatile state = 0;
    bool volatile changed = false;
    REDirection direction = RE_NONE;
    
};

RotaryEncoder.h

#include "RotaryEncoder.h"

#include <FunctionalInterrupt.h>

template <typename T>
T clip(const T& n, const T& lower, const T& upper) {
  return std::max(lower, std::min(n, upper));
}

enum RotaryState {
  RS_IDLE,
  RS_CW_WAIT_FOR_DT,
  RS_CW_WAIT_FOR_CLK,
  RS_CW_CYCLE_DONE,
  RS_CCW_WAIT_FOR_CLK,
  RS_CCW_WAIT_FOR_DT,
  RS_CCW_CYCLE_DONE
};

RotaryEncoder::RotaryEncoder(int clkGPIO, int dtGPIO, int step, int min, int max)
  : clkGPIO(clkGPIO)
  , dtGPIO(dtGPIO)
  , step(step)
  , min(min)
  , max(max) {
};

void RotaryEncoder::begin() {
  pinMode(clkGPIO, INPUT);
  pinMode(dtGPIO, INPUT);
  attachInterrupt(clkGPIO, std::bind(&RotaryEncoder::encoderISR, this), CHANGE);
  attachInterrupt(dtGPIO, std::bind(&RotaryEncoder::encoderISR, this), CHANGE);
}

void RotaryEncoder::encoderISR() {
  bool clkState = digitalRead(clkGPIO);
  bool dtState = digitalRead(dtGPIO);

  switch (state) {
    case RS_IDLE : 
      if (clkState == 0) state = RS_CW_WAIT_FOR_DT;
      else if (dtState == 0) state = RS_CCW_WAIT_FOR_CLK;
      break;
    case RS_CW_WAIT_FOR_DT : if (dtState == 0) state = RS_CW_WAIT_FOR_CLK;
      break;
    case RS_CW_WAIT_FOR_CLK : if (clkState == 1) state = RS_CW_CYCLE_DONE;
      break;
    case RS_CW_CYCLE_DONE : if (clkState == 1 && dtState == 1) {
        direction = RE_CW;
        int newPos = position + step;
        position = clip(newPos, min, max);
        state = RS_IDLE;
        changed = true;
      }
      break;
    case RS_CCW_WAIT_FOR_CLK : if (clkState == 0) state = RS_CCW_WAIT_FOR_DT;
      break;
    case RS_CCW_WAIT_FOR_DT : if (dtState == 1) state = RS_CCW_CYCLE_DONE;
      break;
    case RS_CCW_CYCLE_DONE : if (clkState == 1 && dtState == 1) {
        direction = RE_CCW;
        int newPos = position - step;
        position = clip(newPos, min, max);
        state = RS_IDLE;
        changed = true;
      };
      break;
  }
}

int RotaryEncoder::getPosition() {
  changed = false;
  return position;
}

REDirection RotaryEncoder::getDirection() {
  return direction;
}

bool RotaryEncoder::available() {
  return changed;
}