Arduino Playground - RotaryEncoders

• Introduction
• Libraries
  • *New*This code gives library performance without the compiled size overhead, with very efficient interrupt routines. Uses the External Interrupt pins of the MCU.
  • *New*A high performance Encoder library is now available, with 4X counting and very efficient interrupt routines. Uses the External Interrupt pins of the MCU.
  • *New*ClickEncoder Library for encoders with button Works on any IO-Pin (uses a Timer), supports acceleration (rotate faster -> increment faster, feels very natural); Button reports Click, DoubleClick, Held, Released. Example Included.
  • *New*Interrupt Library (the Encoder interrupts the processor). Utilizes any of the ATmega328P pins via the PinChangeInt library.
  • SoftTimer library introduces an alternative way to organize your business logic, and has a built in driver for rotary encoders.
  • AdaEncoder rotary encoder library (uses ... the PinChangeInt library). ( AdaEncoder wiki documentation includes a short discussion of switch bounce ). ( AdaEncoder Arduino Forum discussion ).
  • "Quadrature Encoder too Fast for Arduino" is an extremely non-portable library for handling high-speed, high-resolution encoders on the Arduino.
  • "Quadrature Encoders in Arduino, done right. Done right." uses "interrupt on any change of A or B" to squeeze the maximum possible resolution out of an encoder -- count on both low-to-high and high-to-low transitions, both A and B.
  • Encoder Polling ( Arduino Forum discussion ).
  • "Arduino Library for Rotary Encoders with Velocity Sense".
  • "RotaryEncoder"
  • Rotary encoder library for use in loop(). No example sketch given.
• Debounce Circuitry
• Examples
• Discussion

A rotary or "shaft" encoder is an angular measuring device. It is used to precisely measure rotation of motors or to create wheel controllers (knobs) that can turn infinitely (with no end stop like a potentiometer has). Some of them are also equipped with a pushbutton when you press on the axis (like the ones used for navigation on many music controllers). They come in all kinds of resolutions, from maybe 16 to at least 1024 steps per revolution, and cost from 2 to maybe 200 EUR.

I've written a little sketch to read a rotary controller and send its readout via RS232.

It simply updates a counter (encoder0Pos) every time the encoder turns by one step, and sends it via serial to the PC.

This works fine with an ALPS STEC12E08 encoder which has 24 steps per turn. I can imagine it could fail with encoders with higher resolution, or when it rotates very quickly (think: motors), or when you extend it to accommodate multiple encoders. Please give it a try.

I learned about how to read the encoder from the file encoder.h included in the Arduino distribution as part of the AVRLib. Thanks to its author, Pascal Stang, for the friendly and newbie-proof explanation of the functionings of encoders there.here you go:

Example 1

Oh, a few notes:

• encoder0Pos will be counting forever, that means that if you keep turning into the same direction, the serial message will become longer (up to 6 characters), costing more time to transmit.
• you need to make sure yourself (on the PC side) that nothing bad happens when encoder0Pos overflows - if the value becomes larger than the maximum size of an INT (32,767), it will flip to -32,768! and vice versa.
• suggestion for improvement: make it spit out the counter only when it is polled from the PC. Count only the relative change of the encoder between two polls.
• obviously, if you add more code to the loop(), or use higher resolution encoders, there is a possibility that this sketch will not see every individual step. The better way of counting encoder steps is to use an interrupt on every flank of the signal. The library I mentioned above does just that, but currently (2006-12) it doesn't compile under the Arduino environment - or I just don't know how to do so...

I'm not sure about the etiquette of this, but I'm just going to add onto this tutorial. Paul Badger

Below is an image showing the waveforms of the A & B channels of an encoder.

This might make it a little more clear how the code above works. When the code finds alow-to-high transition on the A channel, it checks to see if the B channel is high or low and then increments/decrements the variable to account for the direction that the encoder must be turning in order to generate the waveform found.

One disadvantage of the code above is that it is really only counting one fourth of the possible transitions. In the case of the illustration, either the red or the lime green transitions, depending on which way the encoder is moving.

Interrupt Example

Below is some code that uses an interrupt. When the Arduino sees a change on the A channel, it immediately skips to the "doEncoder" function, which parses out both the low-to-high and the high-to-low edges, consequently counting twice as many transitions. I didn't want to use both interrupt pins to check the other two classes of transition on the B channel (the violet and cyan lines in the chart above), but it doesn't seem much more complicated to do so.

Using interrupts to read a rotary encoder is a perfect job for interrupts because the interrupt service routine (a function) can be short and quick, because it doesn't need to do much.

I used the encoder as a "mode selector" on a synthesizer made solely from an Arduino chip. This is a pretty casual application, because it doesn't really matter if the encoder missed pulses, the feedback was coming from the user. Where the interrupt method is going to shine is with encoders used for feedback on motors - such as servos or robot wheels. In those applications, the microcontroller can't afford to miss any pulses or the resolution of movement is going to suffer.

One side note: I used the Arduino's pullup resistors to "steer" the inputs high when they were not engaged by the encoder. Hence the encoder common pin is connected to ground. The sketch above fails to mention that some pulldown resistors (10k is fine) are going to be needed on the inputs since the encoder common is attached to +5V.

Careful when using Serial.Print inside an interrupt function, most of the time it will fail, but it works sometimes, the worst of programming bugs. It is documented in a number of places: "https://groups.google.com/a/arduino.cc/forum/#!topic/developers/HKzEcN6gikM""http://forum.arduino.cc/index.php?topic=94459.0""http://forum.jeelabs.net/node/1188.html"

Interrupt Example (the Encoder interrupts the processor). Uses both Interrupt pins

Code for reading encoder using 2 interrupts on pin 2 & pin3

Note: the code below uses 2 interrupts to read the full resolution of the encoder. The code above used 1 interrupt. It read half the resolution by only checking EncoderPin A for position, but it freed up an interrupt pin.

#define encoder0PinA 2

#define encoder0PinB 3

volatile unsigned int encoder0Pos = 0;

void setup() {

// encoder pin on interrupt 0 (pin 2)

// encoder pin on interrupt 1 (pin 3)

}

void loop(){//Do stuff here}

void doEncoderA(){

}

void doEncoderB(){

}

Interrupt Example (the Encoder interrupts the processor). Uses a single interrupt pin, wraps the Encoder into a C++ class.

class wrapper

by mikkoh [01/2010]

wrapped above example (example with one interrupt) into a class and reduced code size from the doEncoder function a bit (hope it's still readable to the most of you). An example usage is contained in the class documentation.

Uses both External Interrupt pins, Counts in 1 Direction only.Editor's note: Although this code claims efficiency gains, note that it uses the digitalRead() library functions, which according to http://jeelabs.org/2010/01/06/pin-io-performance/ is 50 times as slow as direct port reads.

Efficiency gain for rotary encoder counting

by m3tr0g33k

Paul Badger's work and the original post are enlightening and useful - you will need to understand what they have said before this makes sense to you (I hope it does!).

My project is a data logger where three analogue inputs are sampled each time a rotary encoder pulse steps clockwise. On an Arduino, time is of the essence to get this data sampled and saved somewhere (I have not included the 'saving somewhere' part of this project yet.) In order to save some processor cycles, I have slightly redesigned the interrupt system to maintain a pair of Boolean states outside of the interrupt loop.

The idea is to set a Boolean state for A or B when there is a positive going edge on encoder output A or B. So, when you get an interrupt from A, and it's positive going, you set A_set=true. Then you test if B_set is false. If it is, then A leads B which means a clockwise step (increment position counter).

Likewise, when you get an interrupt from B, and it's positive going, you set B_set=true. Then you test if A_set is false. If it is, then B leads A, which means a counter-clockwise step (decrement position counter).

An important difference from previous code examples is when there is an interrupt on A or B which is negative going, you just set A_set or B_set to false, respectively, no further work is needed, reducing the time spent servicing the interrupt.

Anyway, enough explanation of code in words, here is the code:

The rest of the code around the improved interrupt routines is just to demonstrate that it works. As I said, I only want to sample when going CW (which is forwards on my sampling trolley). When the encoder is going CCW, I just update the counter.

The loop{} prints the current encoder position and the corresponding sampled data values every second, but only if the encoder position has changed. You can have fun seeing how far you can rotate your encoder in a second! I have managed nearly 300 steps or 1.5 revolutions on my rotary encoder.

There is one issue with the logic in this code. If you are changing direction a lot then you may wish to know that if you change direction in the middle of a step, your counter will not update. This is a half-step hysteresis. Under most circumstances, this is not noticeable or important, but think whether it is important to you!

Hope this potential speed increase helps someone!

m3tr0g33k

Interrupt Example (the Encoder interrupts the processor). Uses both External Interrupt pins, simplifies the interrupt service routines of the above.

Tighten up the ISR's

You can reduce the size of the interrupt service routines considerably by looking at A_set == B_set to determine lag vs lead.

The ISR's are then just

this code did work better for me than most others, with good explanation

________________________________________________________________________________________________________________

Uses both External Interrupt pins, after the initial read, does not read the state of the pins.

Fast encoder reading: using just interrupts

I also had to face with the problem of reading encoder signals and, after many trials, I'm happy to let you know a new way to deal with them, inspired by all the previous suggestions. I tried it on AMT encoder and it work really good. Unlikely, the other methods failed, the counting rate was too fast. To escape reading Arduino's port programming, I thought it may be even faster just using the interrupt pins. Here is the code:

_____________________________________________________________\\

Here's a complete library code for working with Encoders: