update encoder library

Author: kethort

Arduino/libraries/ESP32Encoder-master/examples/Encoder/Encoder.ino

@@ -1,4 +1,3 @@
-
 #include <ESP32Encoder.h>
 
 ESP32Encoder encoder;
@@ -17,24 +16,24 @@ void setup(){
 	// Enable the weak pull up resistors
 	ESP32Encoder::useInternalWeakPullResistors=UP;
 
-	// Attache pins for use as encoder pins
+	// use pin 19 and 18 for the first encoder
 	encoder.attachHalfQuad(19, 18);
-	// Attache pins for use as encoder pins
+	// use pin 17 and 16 for the second encoder
 	encoder2.attachHalfQuad(17, 16);
 
 	// set starting count value after attaching
 	encoder.setCount(37);
 
 	// clear the encoder's raw count and set the tracked count to zero
 	encoder2.clearCount();
-	Serial.println("Encoder Start = "+String((int32_t)encoder.getCount()));
+	Serial.println("Encoder Start = " + String((int32_t)encoder.getCount()));
 	// set the lastToggle
 	encoder2lastToggled = millis();
 }
 
 void loop(){
 	// Loop and read the count
-	Serial.println("Encoder count = "+String((int32_t)encoder.getCount())+" "+String((int32_t)encoder2.getCount()));
+	Serial.println("Encoder count = " + String((int32_t)encoder.getCount()) + " " + String((int32_t)encoder2.getCount()));
 	delay(100);
 
 	// every 5 seconds toggle encoder 2

Arduino/libraries/ESP32Encoder-master/examples/Encoder_interrupt_display/Encoder_interrupt_display.ino

@@ -0,0 +1,64 @@
+#include <Arduino.h>
+#include <ESP32Encoder.h>
+#include <Adafruit_GFX.h>
+#include <Adafruit_SSD1306.h>
+#include "esp_task_wdt.h"
+
+static IRAM_ATTR void enc_cb(void* arg) {
+  ESP32Encoder* enc = (ESP32Encoder*) arg;
+  //Serial.printf("enc cb: count: %d\n", enc->getCount());
+  static bool leds = false;
+  digitalWrite(LED_BUILTIN, (int)leds);
+  leds = !leds;
+}
+
+extern bool loopTaskWDTEnabled;
+extern TaskHandle_t loopTaskHandle;
+
+ESP32Encoder encoder(true, enc_cb);
+Adafruit_SSD1306 display(128, 32, &Wire);
+
+static const char* LOG_TAG = "main";
+
+void setup(){
+  loopTaskWDTEnabled = true;
+  pinMode(LED_BUILTIN, OUTPUT);
+  Serial.begin(115200);
+  // Encoder A and B pins connected with 1K series resistor to pins 4 and 5, common pin to ground.
+  //         |- A   --- 1K --- pin 4
+  //  >=[enc]|- GND
+  //         |- B   --- 1K --- pin 5
+
+  ESP32Encoder::useInternalWeakPullResistors=UP;
+  encoder.attachSingleEdge(4, 5);
+  encoder.clearCount();
+  encoder.setFilter(1023);
+
+  if (! display.begin(SSD1306_SWITCHCAPVCC, 0x3c))
+  {
+    for (;;) {
+      Serial.println("display init failed");
+    }
+  }
+  display.cp437(true);
+  display.clearDisplay();
+  display.setTextSize(2);
+  display.setTextColor(WHITE);
+  display.setCursor(0,0);
+  display.display();
+  esp_log_level_set("*", ESP_LOG_DEBUG);
+  esp_log_level_set("main", ESP_LOG_DEBUG);
+  esp_log_level_set("ESP32Encoder", ESP_LOG_DEBUG);
+  esp_task_wdt_add(loopTaskHandle);
+}
+
+void loop(){
+
+  display.clearDisplay();
+  display.setCursor(0,0);
+  display.printf("E: %lld\n", encoder.getCount());
+  display.display();
+  Serial.printf("Enc count: %d\n", encoder.getCount());
+  delay(500);
+  
+}

Arduino/libraries/ESP32Encoder-master/src/ESP32Encoder.cpp

@@ -6,64 +6,105 @@
  */
 
 #include <ESP32Encoder.h>
+#include <soc/pcnt_struct.h>
+#include "esp_log.h"
+
+static const char* TAG = "ESP32Encoder";
+
 
 //static ESP32Encoder *gpio2enc[48];
 //
 //
 enum puType ESP32Encoder::useInternalWeakPullResistors=DOWN;
-ESP32Encoder *ESP32Encoder::encoders[MAX_ESP32_ENCODERS] = { NULL, NULL, NULL,
-NULL,
-NULL, NULL, NULL, NULL };
+ESP32Encoder *ESP32Encoder::encoders[MAX_ESP32_ENCODERS] = { NULL, };
 
 bool ESP32Encoder::attachedInterrupt=false;
 pcnt_isr_handle_t ESP32Encoder::user_isr_handle = NULL;
 
-ESP32Encoder::ESP32Encoder() {
-	attached = false;
-	aPinNumber = (gpio_num_t) 0;
-	bPinNumber = (gpio_num_t) 0;
-	working = false;
-	direction = false;
-	unit = (pcnt_unit_t) -1;
+ESP32Encoder::ESP32Encoder(bool always_interrupt_, enc_isr_cb_t enc_isr_cb, void* enc_isr_cb_data):
+	always_interrupt{always_interrupt_},
+	aPinNumber{(gpio_num_t) 0},
+	bPinNumber{(gpio_num_t) 0},
+	unit{(pcnt_unit_t) -1},
+	fullQuad{false},
+	countsMode{2},
+	count{0},
+	r_enc_config{},
+	_enc_isr_cb(enc_isr_cb),
+	_enc_isr_cb_data(enc_isr_cb_data),
+	attached{false},
+	direction{false},
+	working{false}
+{
 }
 
-ESP32Encoder::~ESP32Encoder() {
-	// TODO Auto-generated destructor stub
-}
+ESP32Encoder::~ESP32Encoder() {}
 
 /* Decode what PCNT's unit originated an interrupt
  * and pass this information together with the event type
  * the main program using a queue.
  */
-static void IRAM_ATTR pcnt_example_intr_handler(void *arg) {
-	ESP32Encoder * ptr;
-
+#ifdef CONFIG_IDF_TARGET_ESP32S2
+	#define COUNTER_H_LIM cnt_thr_h_lim_lat_un
+	#define COUNTER_L_LIM cnt_thr_l_lim_lat_un
+	#define thres0_lat cnt_thr_thres0_lat_un
+	#define thres1_lat cnt_thr_thres1_lat_un
+
+#elif CONFIG_IDF_TARGET_ESP32S3
+	#define COUNTER_H_LIM cnt_thr_h_lim_lat_un
+	#define COUNTER_L_LIM cnt_thr_l_lim_lat_un
+	#define thres0_lat cnt_thr_thres0_lat_un
+	#define thres1_lat cnt_thr_thres1_lat_un
+#else
+	#define COUNTER_H_LIM h_lim_lat
+	#define COUNTER_L_LIM l_lim_lat
+#endif
+
+
+
+static void IRAM_ATTR esp32encoder_pcnt_intr_handler(void *arg) {
+	ESP32Encoder * esp32enc = {};
 	uint32_t intr_status = PCNT.int_st.val;
-	int i;
-
-	for (i = 0; i < PCNT_UNIT_MAX; i++) {
+	for (uint8_t i = 0; i < PCNT_UNIT_MAX; i++) {
 		if (intr_status & (BIT(i))) {
-			ptr = ESP32Encoder::encoders[i];
-			/* Save the PCNT event type that caused an interrupt
-			 to pass it to the main program */
-
-			int64_t status=0;
-			if(PCNT.status_unit[i].h_lim_lat){
-				status=ptr->r_enc_config.counter_h_lim;
-			}
-			if(PCNT.status_unit[i].l_lim_lat){
-				status=ptr->r_enc_config.counter_l_lim;
+			pcnt_unit_t unit = static_cast<pcnt_unit_t>(i);
+			esp32enc = ESP32Encoder::encoders[i];
+			if(PCNT.status_unit[i].COUNTER_H_LIM){
+				esp32enc->count += esp32enc->r_enc_config.counter_h_lim;
+				pcnt_counter_clear(unit);
+			} else if(PCNT.status_unit[i].COUNTER_L_LIM){
+				esp32enc->count += esp32enc->r_enc_config.counter_l_lim;
+				pcnt_counter_clear(unit);
+			} else if(esp32enc->always_interrupt && (PCNT.status_unit[i].thres0_lat || PCNT.status_unit[i].thres1_lat)) {
+				int16_t c;
+				pcnt_get_counter_value(unit, &c);
+				esp32enc->count += c;
+				pcnt_set_event_value(unit, PCNT_EVT_THRES_0, -1);
+				pcnt_set_event_value(unit, PCNT_EVT_THRES_1, 1);
+				pcnt_event_enable(unit, PCNT_EVT_THRES_0);
+				pcnt_event_enable(unit, PCNT_EVT_THRES_1);
+				pcnt_counter_clear(unit);
+				if (esp32enc->_enc_isr_cb) {
+					esp32enc->_enc_isr_cb(esp32enc->_enc_isr_cb_data);
+				}
 			}
-			//pcnt_counter_clear(ptr->unit);
 			PCNT.int_clr.val = BIT(i); // clear the interrupt
-			ptr->count = status + ptr->count;
 		}
 	}
 }
 
+
+
+
+
+void ESP32Encoder::detatch(){
+	pcnt_counter_pause(unit);
+	ESP32Encoder::encoders[unit]=NULL;
+
+}
 void ESP32Encoder::attach(int a, int b, enum encType et) {
 	if (attached) {
-		Serial.println("All ready attached, FAIL!");
+		ESP_LOGE(TAG, "attach: already attached");
 		return;
 	}
 	int index = 0;
@@ -74,7 +115,7 @@ void ESP32Encoder::attach(int a, int b, enum encType et) {
 		}
 	}
 	if (index == MAX_ESP32_ENCODERS) {
-		Serial.println("Too many encoders, FAIL!");
+		ESP_LOGE(TAG, "Too many encoders, FAIL!");
 		return;
 	}
 
@@ -149,30 +190,32 @@ void ESP32Encoder::attach(int a, int b, enum encType et) {
 		r_enc_config		.counter_h_lim = _INT16_MAX;
 		r_enc_config		.counter_l_lim = _INT16_MIN ;
 
-		pcnt_unit_config(&r_enc_config);	
+		pcnt_unit_config(&r_enc_config);
 	}
 
-
 	// Filter out bounces and noise
-	pcnt_set_filter_value(unit, 250);  // Filter Runt Pulses
-	pcnt_filter_enable(unit);
-
+	setFilter(250); // Filter Runt Pulses
 
-	/* Enable events on  maximum and minimum limit values */
+	/* Enable events on maximum and minimum limit values */
 	pcnt_event_enable(unit, PCNT_EVT_H_LIM);
 	pcnt_event_enable(unit, PCNT_EVT_L_LIM);
-
 	pcnt_counter_pause(unit); // Initial PCNT init
-	pcnt_counter_clear(unit);
 	/* Register ISR handler and enable interrupts for PCNT unit */
-	if(attachedInterrupt==false){
-		attachedInterrupt=true;
-		esp_err_t er = pcnt_isr_register(pcnt_example_intr_handler,(void *) NULL, (int)0,
+	if(! attachedInterrupt){
+		esp_err_t er = pcnt_isr_register(esp32encoder_pcnt_intr_handler,(void *) NULL, (int)0,
 				(pcnt_isr_handle_t *)&ESP32Encoder::user_isr_handle);
 		if (er != ESP_OK){
-			Serial.println("Encoder wrap interupt failed");
+			ESP_LOGE(TAG, "Encoder wrap interrupt failed");
 		}
+		attachedInterrupt=true;
+	}
+	if (always_interrupt){
+		pcnt_set_event_value(unit, PCNT_EVT_THRES_0, -1);
+		pcnt_set_event_value(unit, PCNT_EVT_THRES_1, 1);
+		pcnt_event_enable(unit, PCNT_EVT_THRES_0);
+		pcnt_event_enable(unit, PCNT_EVT_THRES_1);
 	}
+	pcnt_counter_clear(unit);
 	pcnt_intr_enable(unit);
 	pcnt_counter_resume(unit);
 
@@ -198,7 +241,7 @@ int64_t ESP32Encoder::getCountRaw() {
 	return c;
 }
 int64_t ESP32Encoder::getCount() {
-	return getCountRaw() + count;
+	return count + getCountRaw();
 }
 
 int64_t ESP32Encoder::clearCount() {
@@ -214,3 +257,13 @@ int64_t ESP32Encoder::resumeCount() {
 	return pcnt_counter_resume(unit);
 }
 
+void ESP32Encoder::setFilter(uint16_t value) {
+	if(value>1023)value=1023;
+	if(value==0) {
+		pcnt_filter_disable(unit);
+	} else {
+		pcnt_set_filter_value(unit, value);
+		pcnt_filter_enable(unit);
+	}
+
+}