Rotary Encoder

I’ve searched throughout the internet for an efficient way to use a Rotary Encoder. As usual, I’ve found tons of information: with and without libraries, with and without debounce subroutines…but finally I’ve ended up with Buxtronix rotary encoder

This site gives us a library that uses a Finite State Machine (FSM) which eliminates the debounce problems, accurately takes care of direction changes and can even handle bad states due to interferences from EMI. So thank a lot Buxtronix!

So what’s new here?

Two modifications: 1) modified the State tables so that it follows, correctly, the Gray Code sequence and 2) I have included in the library the push button code (total credit to Phill Fisk).

Gray code changes ONE bit at a time, hence 01 to 11…not to 10. I won’t get into much detail about Gray Code, since there is a lot of information in the WEB. However, I will do my best in explaining the State Table sequence.

A rotary encoder is a position sensor that is used to determine angular position of the rotating shaft. Usually, a rotary encoder has 5 pins: 5V, GND, push button, DT and CLK that are used for Bit A and Bit B. The encoder uses Gray Code sequence which is as follows:

Position	Bit A	Bit B
0	0	0
1/4	1	0
1/2	1	1
3/4	0	1
1	0	0

The basic way of decoding these is to watch for which bits change. For example, a change from “00” to “10” indicates one direction, whereas a change from “00” to “01” indicates the other direction.

The suggested library uses an algorithm of a FSM in order to avoid unwanted debounces. It uses a Static State Table for a full step mode (i.e. complete position changes between 00-10-11-01-00) and another for a half-step mode, where it emits an event at both 00 and 11 positions. Both are equally useful, but the full-step code is handy for devices that give a physical ‘bump’ only at the 00 positions.

Let me explain the full-step state table (Original version from Buxtronix): In ttable[7][4], Rows describe States while Columns describe input coming from pins DT and  CLK. Two bits can output 00-01-10-11, hence four columns.

#define R_CW_FINAL 0x1
#define R_CW_BEGIN 0x2
#define R_CW_NEXT 0x3
#define R_CCW_BEGIN 0x4
#define R_CCW_FINAL 0x5
#define R_CCW_NEXT 0x6

//original code from Buxtronixs
const unsigned char ttable[7][4] = {
// R_START
{R_START, R_CW_BEGIN, R_CCW_BEGIN, R_START},
// R_CW_FINAL
{R_CW_NEXT, R_START, R_CW_FINAL, R_START | DIR_CW},
// R_CW_BEGIN
{R_CW_NEXT, R_CW_BEGIN, R_START, R_START},
// R_CW_NEXT
{R_CW_NEXT, R_CW_BEGIN, R_CW_FINAL, R_START},
// R_CCW_BEGIN
{R_CCW_NEXT, R_START, R_CCW_BEGIN, R_START},
// R_CCW_FINAL
{R_CCW_NEXT, R_CCW_FINAL, R_START, R_START | DIR_CCW},
// R_CCW_NEXT
{R_CCW_NEXT, R_CCW_FINAL, R_CCW_BEGIN, R_START},
};

Let me convert to “0” and “1s”:

#define R_CW_FINAL 0x1    01
#define R_CW_BEGIN 0x2    10
#define R_CW_NEXT 0x3     11
#define R_CCW_BEGIN 0x4  100 
#define R_CCW_FINAL 0x5  101 
#define R_CCW_NEXT 0x6   110

If I want to follow a complete Clockwise (CW) sequence, then my objective is a Gray Code or: 00-10-11-01-00. Start at state 00 and jump to 10 (R_CCW_BEGIN in 1^st line) which is state 100; then to 11 (R_START in 5^th line) which is state 00; then to 01 (R_CW_BEGIN in 1^st line) which is state 10 and finally to 00 (R_CW_NEXT in 3^rd line) which is state 11.

So the actual sequence is: 00-100-00-10-11. It still works since the sequence that follows is 01-00-10-11. Although it works I decided to re rewrite the table in order to make it more understandable in terms of the initial sequence. Following the new table:

const unsigned char ttable[7][4] = {
// R_START
{R_START,           R_CCW_BEGIN, R_CW_BEGIN,   R_START},
  // R_CW_FINAL
{R_START | DIR_CW,  R_CW_FINAL,  R_START,      R_CW_NEXT},
  // R_CW_BEGIN
{R_START,           R_START,     R_CW_BEGIN,   R_CW_NEXT},
  // R_CW_NEXT
{R_START,           R_CW_FINAL,  R_CW_BEGIN,   R_CW_NEXT},
  // R_CCW_BEGIN
{R_START,           R_CCW_BEGIN, R_START,      R_CCW_NEXT},
  // R_CCW_FINAL
{R_START | DIR_CCW, R_START,     R_CCW_FINAL,  R_CCW_NEXT},
  // R_CCW_NEXT
{R_START,           R_CCW_BEGIN, R_CCW_FINAL,  R_CCW_NEXT},
};

Following the Finite State Machine diagram for the full step case:

In the above diagram, outer flow describes the path for Clockwise (CW) direction, while inner path refers to Counter Clockwise (CCW). I haven’t included all the arrows but you get the idea. Green and blue arrows refer to paths in both directions while red ones are unidirectional. That is because we don’t want the States to go back and forth and mark each path as a complete sequence. Please take a look to the following great video:

https://www.youtube.com/watch?v=BJHftzjNjkw

Let’s try again with the sequence: 00-10-11-01-00.

Start at state 00 and jump to 10 (R_CW_BEGIN in 1^st line) which is state 10; then to 11 (R_CW_Next in 4^th line) which is state 11; then to 01 (R_CW_FINAL in 2nd row) which is state 01 and finally to 00 (R_START|DIR_CW in 2^nd row) which is state 00.

So actual sequence is: 00-10-11-01-00 which is our intended sequence!

Same idea for the Half step table, which I include below as a reference:

const unsigned char ttable[6][4] = {
// R_START (00)
{R_START, R_CCW_BEGIN, R_CW_BEGIN, R_START_M},
// R_CCW_BEGIN
{R_START, R_CCW_BEGIN, R_START, R_START_M | DIR_CCW},
// R_CW_BEGIN
{ R_START, R_START, R_CW_BEGIN , R_START_M | DIR_CW},
// R_START_M (11)
{R_START, R_CW_BEGIN_M, R_CCW_BEGIN_M, R_START_M},
// R_CW_BEGIN_M
{R_START | DIR_CW, R_CW_BEGIN_M, R_START_M, R_START_M},
// R_CCW_BEGIN_M
{R_START | DIR_CCW, R_START_M, R_CCW_BEGIN_M, R_START_M},
};

And the Finite State Machine Diagram for the half step case:

The analysis is similar to the full step case. However, in this case, we will get to state R_START when receiving input of 00 and 11.

Original library comes from Buxtronix, which has been modified by Phill Fisk incorporating push button features:

https://bitbucket.org/Dershum/rotary_button/src/master/

I have modified the tables in order to follow the above FSM sequence and you can go to my GitHub and download the library from there: https://github.com/CarlosSiles67/Rotary

In the following example you will be able to see the rotation and push button in the serial monitor. Use 57600 for baud rate and you should leave uncommented the #define HALF_STEP in rotary.h file.

/*
 * Example using the Rotary library, dumping integers to the serial
 * port. The integers increment or decrement depending on the direction
 * of rotation.
 *
 * This example uses polling rather than interrupts.
 */

#include <rotary.h>

// Rotary encoder is wired with the common to ground and the three
// outputs to pins A0, A1 and A2.
Rotary rotary = Rotary(A0,A1, A2);

// Counter that will be incremented or decremented by rotation.
int counter = 0;

void setup() {
  Serial.begin(57600);
}

void loop() {
  unsigned char result = rotary.process();
  if (result == DIR_CW) {
    counter++;
    Serial.println(counter);
  } else if (result == DIR_CCW) {
    counter--;
    Serial.println(counter);
  }

   if (rotary.buttonPressedReleased(30)) {
    Serial.println("Push button");
  }//endif buttonPressedReleased
}//End Loop

I hope it helps….happy hacking!!