Initial Commit

Author: vickash

LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2024 vickash
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,27 @@
+# RotaryEncoderPCNT
+
+This is a 2-channel rotary (quadrature) encoder implementation, for the ESP32, on the Arduino platform. It uses the ESP32's built in pulse counter (PCNT) peripheral.
+
+Simply create a new `RotaryEncoderPCNT` object with the encoder's A and B pins, then call `.position()` to return the current position. The PCNT unit is set up to keep the encoder object updated in the background, handling interrupts, internal counter overflow, etc. for you.
+
+Note: `.position()` returns a signed 32-bit integer. If you expect to overflow that, you need to handle it.
+
+### Compatibility
+- Requires Arduino ESP32 Core 3.0 or higher
+- Incompatible with ESP32-C2 and ESP32-C3, as they don't have PCNT units.
+
+### Most Basic Example
+```
+#include <RotaryEncoderPCNT.h>
+
+RotaryEncoderPCNT encoder(25, 12);
+
+void setup() {
+  Serial.begin(115200);
+}
+
+void loop(){
+  Serial.println(encoder.position());
+  delay(200);
+}
+```

examples/EncoderDemo/EncoderDemo.ino

@@ -0,0 +1,32 @@
+#include <RotaryEncoderPCNT.h>
+
+// Constructor args are: pinA/Clock, pinB/Data, start position, glitch filter time in ns.
+// Start position and filter time are optional. Defaults are 0 and 1000ns respectively.
+//
+// RotaryEncoderPCNT encoder(25, 12, 0, 1000);
+// RotaryEncoderPCNT encoder(25, 12, 0);
+RotaryEncoderPCNT encoder(25, 12);
+
+int old_position;
+int position;
+
+void setup() {
+  Serial.begin(115200);
+
+  // Change position after initialization.
+  // encoder.setPosition(128);
+
+  // Show initial position.
+  old_position = encoder.position();
+  Serial.println(old_position);
+}
+
+void loop() {
+  // Show position when it changes.
+  position = encoder.position();
+  if(position != old_position){
+    Serial.println(position);
+    old_position = position;
+  }
+  delay(5);
+}

library.json

@@ -0,0 +1,19 @@
+{
+    "name": "RotaryEncoderPCNT",
+    "description": "ESP32 rotary encoder implementation, using pulse counter (PCNT) peripheral.",
+    "keywords": "rotary, encoder, esp32, input, iot",
+    "authors": {
+      "name": "vickash",
+      "url": "https://github.com/vickash/RotaryEncoderPCNT.git"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/vickash/RotaryEncoderPCNT.git"
+    },
+    "version": "1.0",
+    "examples": "examples/*/*.ino",
+    "frameworks": "arduino",
+    "platforms": [
+        "espressif32",
+    ]
+}

library.properties

@@ -0,0 +1,10 @@
+name=RotaryEncoderPCNT
+version=1.0.0
+author=vickash
+maintainer=vickash <[email protected]>
+sentence=ESP32 rotary encoder implementation, using pulse counter (PCNT) peripheral.
+paragraph=Requires Arduino ESP32 core 3.0 or higher. Not supported on ESP32-C2 or ESP32-C3 as they do not have PCNT units.
+category=Signal Input/Output
+url=https://github.com/vickash/RotaryEncoderPCNT
+architectures=esp32
+includes=RotaryEncoderPCNT.h

src/RotaryEncoderPCNT.cpp

@@ -0,0 +1,87 @@
+#include "RotaryEncoderPCNT.h"
+
+RotaryEncoderPCNT::RotaryEncoderPCNT(int a, int b, int start_pos, uint16_t glitch_ns){
+  install(a, b, start_pos, glitch_ns);
+}
+
+RotaryEncoderPCNT::RotaryEncoderPCNT(int a, int b, int start_pos){
+  install(a, b, start_pos, GLITCH_NS_DEFAULT);
+}
+
+RotaryEncoderPCNT::RotaryEncoderPCNT(int a, int b){
+  install(a, b, START_POS_DEFAULT, GLITCH_NS_DEFAULT);
+}
+
+void RotaryEncoderPCNT::install(int a, int b, int start_pos, uint16_t glitch_ns){
+  offset = start_pos;
+  pin_a = a;
+  pin_b = b;
+
+  // Unit config
+  pcnt_unit_config_t unit_config = {
+      .low_limit = low_limit,
+      .high_limit = high_limit,
+  };
+  unit_config.flags.accum_count = true;
+
+  // Create unit
+  ESP_ERROR_CHECK(pcnt_new_unit(&unit_config, &unit));
+
+  // Set watch points at low and high limits to auto-accumulate overflows.
+  pcnt_unit_add_watch_point(unit, low_limit);
+  pcnt_unit_add_watch_point(unit, high_limit);
+
+  // Glitch filter setup
+  pcnt_glitch_filter_config_t filter_config = {
+      .max_glitch_ns = glitch_ns,
+  };
+  ESP_ERROR_CHECK(pcnt_unit_set_glitch_filter(unit, &filter_config));
+
+  // Channel A setup
+  pcnt_chan_config_t chan_a_config = {
+      .edge_gpio_num = pin_a,
+      .level_gpio_num = pin_b,
+  };
+  ESP_ERROR_CHECK(pcnt_new_channel(unit, &chan_a_config, &chan_a));
+
+  // Channel B setup
+  pcnt_chan_config_t chan_b_config = {
+      .edge_gpio_num = pin_b,
+      .level_gpio_num = pin_a,
+  };
+  ESP_ERROR_CHECK(pcnt_new_channel(unit, &chan_b_config, &chan_b));
+
+  // Set edge and level actions for both channels
+  ESP_ERROR_CHECK(pcnt_channel_set_edge_action(chan_a, PCNT_CHANNEL_EDGE_ACTION_DECREASE, PCNT_CHANNEL_EDGE_ACTION_INCREASE));
+  ESP_ERROR_CHECK(pcnt_channel_set_level_action(chan_a, PCNT_CHANNEL_LEVEL_ACTION_KEEP, PCNT_CHANNEL_LEVEL_ACTION_INVERSE));
+  ESP_ERROR_CHECK(pcnt_channel_set_edge_action(chan_b, PCNT_CHANNEL_EDGE_ACTION_INCREASE, PCNT_CHANNEL_EDGE_ACTION_DECREASE));
+  ESP_ERROR_CHECK(pcnt_channel_set_level_action(chan_b, PCNT_CHANNEL_LEVEL_ACTION_KEEP, PCNT_CHANNEL_LEVEL_ACTION_INVERSE));
+
+  // Enable, clear and start the PCNT unit.
+  ESP_ERROR_CHECK(pcnt_unit_enable(unit));
+  ESP_ERROR_CHECK(pcnt_unit_clear_count(unit));
+  ESP_ERROR_CHECK(pcnt_unit_start(unit));
+}
+
+RotaryEncoderPCNT::~RotaryEncoderPCNT(){
+    // Free PCNT resources when destroyed.
+    pcnt_unit_disable(unit);
+    pcnt_del_channel(chan_a);
+    pcnt_del_channel(chan_b);
+    pcnt_del_unit(unit);
+}
+
+int RotaryEncoderPCNT::position(){
+  pcnt_unit_get_count(unit, &count);
+  return (count + offset);
+}
+
+void RotaryEncoderPCNT::setPosition(int pos){
+  offset = pos;
+  pcnt_unit_get_count(unit, &count);
+  zero();
+}
+
+void RotaryEncoderPCNT::zero(){
+  pcnt_unit_clear_count(unit);
+}

src/RotaryEncoderPCNT.h

@@ -0,0 +1,32 @@
+#ifndef ROTARY_ENCODER_PCNT_H
+#define ROTARY_ENCODER_PCNT_H
+
+#include "driver/pulse_cnt.h"
+
+#define START_POS_DEFAULT 0
+#define GLITCH_NS_DEFAULT 1000
+
+class RotaryEncoderPCNT {
+  public:
+    RotaryEncoderPCNT(int a, int b, int start_pos, uint16_t glitch_ns);
+    RotaryEncoderPCNT(int a, int b, int start_pos);
+    RotaryEncoderPCNT(int a, int b);
+    ~RotaryEncoderPCNT();
+    int  position();
+    void setPosition(int pos);
+    void zero();
+
+  private:
+    void install(int a, int b, int start_pos, uint16_t glitch_ns);
+
+    pcnt_unit_handle_t unit;
+    pcnt_channel_handle_t chan_a;
+    pcnt_channel_handle_t chan_b;
+    uint8_t pin_a;
+    uint8_t pin_b;
+    int count = 0;
+    int offset = 0;
+    int16_t low_limit = INT16_MIN;
+    int16_t high_limit = INT16_MAX;
+};
+#endif