Interfacing A Rotary Incremental Encoder to an Arduino _Part 1

I had seen some examples for rotary encoders but found the logic hard to understand. So I did my own implementation based on a table. I have seen other people using a similar method, but I think this method is easier to understand.

Prev	Next	Code	Direction		Array positon	Code	Description
11	01	13	CW		0	0	Invalid
01	00	4	CW		1	-1	CCW
00	10	2	CW		2	1	CW
10	11	11	CW		3	0	Invalid
11	10	14	CCW		4	1	CW
10	00	8	CCW		5	0	Invalid
00	01	1	CCW		6	0	Invalid
01	11	7	CCW		7	-1	CCW
					8	-1	CCW
					9	0	Invalid
					10	0	Invalid
					11	1	CW
					12	0	Invalid
					13	1	CW
					14	-1	CCW
					15	0	Invalid

In the two tables above you can see the combinations. The green table is the sequence that follows when turning clockwise or counter clockwise. What I did is combine the two and put it in a table.  Each combination is unique. By looking at the code you can determine if the data read is valid or the direction the encoder is going.

There are three main sections.

First is the setup, which defines the pins to use, enable interrupts and initialize  the previous pin state. Next is the interrupt service routine, and then the actual code that will check for the rotation and increment counters if applicable.

Below is an extract from the data sheet for the ATMEGA 1280, 2560 chip:

PCICR – Pin Change Interrupt Control Register

• Bit 1 – PCIE1: Pin Change Interrupt Enable 1
When the PCIE1 bit is set (one) and the I-bit in the Status Register (SREG) is set (one), pin
change interrupt 1 is enabled. Any change on any enabled PCINT15:8 pin will cause an interrupt.
The corresponding interrupt of Pin Change Interrupt Request is executed from the PCI1
Interrupt Vector. PCINT15:8 pins are enabled individually by the PCMSK1 Register.

This is the code that enables interrupts on those pins:

void InitialiseInterrupt(){
  // switch interrupts off while messing with their settings 
  cli();   
  PCICR =0x01;          // Enable PCIE0: interrupt
  PCMSK0 = 0b00110000;  // Only want pins 10 and 11
  sei();  // turn interrupts back on
}

The service routine reads the state of the encoder pins and combines with the previous state to have an index to the array that contained the valid combinations.

Finally the code in the main loop that checks to see if a rotation occurred. Only a valid rotation will cause it to do something. I also have a counter, because in reality each detent positions generates 4 pulses, which can cause the menu to change to rapidly and hard to select.

Below is the full code:

// Code by Manuel Negri
// July 2014
// Released to the public domain! Enjoy!
#define encoder0PinA 10 // INT4  2
#define encoder0PinB 11 //INT5  3

boolean aa=true;
int prevRot =0;
int curRot =0;
int positionIndex =0;
int rotDirection=0;
int menuInc =0;
int menuDec=0;
int menuItem=0;

// keep track of the position, 
//1 is cw , -1 is ccw and 0 is invalid
int positionTrack[16]= {  
  0,-1, 1, 0,1,  0, 0, -1, -1, 0, 0,1,0,  0, -1, 1};

void setup() {

  pinMode(encoder0PinA, INPUT); 
  pinMode(encoder0PinB, INPUT); 
  pinMode(13,OUTPUT);
  
  // we just have to set, cause they are clear to start
  InitialiseInterrupt();

  if (digitalRead(encoder0PinA) == HIGH) { 
    bitSet(prevRot,1);
  }
  if (digitalRead(encoder0PinB) == HIGH) { 
    bitSet(prevRot,0);
  }

  Serial.begin (19200);
  Serial.println ("start");
}
void InitialiseInterrupt(){
  // switch interrupts off while messing with their settings 
  cli();   
  PCICR =0x01;          // Enable PCIE0: interrupt
  PCMSK0 = 0b00110000;  // Only want pins 10 and 11
  sei();  // turn interrupts back on
}

ISR(PCINT0_vect) {   
  // Interrupt service routine. 
  // Every single PCINT0..7 (=ADC0..5) change
  // will generate an interrupt. This will 
  // always call this method
  
  curRot=0;
  if (digitalRead(encoder0PinA) == HIGH) { 
    bitSet(curRot,1);
  }
  if (digitalRead(encoder0PinB) == HIGH) { 
    bitSet(curRot,0);
  }
  // he we combine  the bits for the previous
  // position with the current
  
  // move the prevRot to the upper nibble
  positionIndex = prevRot<<2 | curRot;

  // and depending on the combination , the rotDirection
  // variable will contain which way the encoder turned
  // or if it was an invalid code
  // with invalid combination, we do nothing.
  rotDirection =positionTrack[positionIndex];

  // The current postion now becomes the previous position
  prevRot = curRot;

}
void loop(){ //Do stuff here }
  // my main code actually checks every 20 msec, so that 
  // is why i have this delay
  delay(20);

  if (rotDirection != 0 ) { // only check if a valid direction
    if (rotDirection == 1 ){
      rotDirection=0;  // reset the direction
      menuInc++;
      // menuInc counts how many pulses where generated 
      // in this direction. Basically it is so we dont go
      // to fast when turning the knob.
      // 
      if (menuInc >=4){ 
        if ( menuItem==15) { // I have 16 menu items
          menuItem=0;        // this is to catch the overflow
        }
        else {
          menuItem++;        // no overflow, so increment
        }
        Serial.print  (menuItem);
        Serial.println ("  menu inc ");
        menuInc= 0;          // since we moved a position
        menuDec = 0;         // reset the two counters
      }
    } 
    else {
      rotDirection=0; // reset the direction
      menuDec--;
      // menuDec counts how many pulses where generated 
      // in this direction. Basically it is so we dont go
      // to fast when turning the knob.
      
      if (menuDec <=-4){
        if ( menuItem==0) { // prevent underflow
          menuItem=15;   
        }
        else {
          menuItem--;
        }
        Serial.print  (menuItem);
        Serial.println ("  menu dec ");
        menuInc= 0;          // since we moved a position
        menuDec = 0;         // reset the two counters
      }
    }
  }
}