Home | Product Categories | General | COM-09117

hi – so i am using the 3 pins on one side to read-in the rotary data no problem. and actually there is little to no bounce, which is uncommon for such a cheap little unit! but also i have a question, i can’t figure out how to read in the push button data … it doesn’t seem to be the two pins on the other side … am i missing something?

I have the some example code for the Arduino that does a decent job figuring out where and how much is being turned on the encoder.
Take a look here:
http://gist.github.com/154809
(if you can help improve the code please fork it)

The Rotary Encoder sku: COM-09117 is missing its PDF data sheet. http://www.sparkfun.com/datasheets/Components/TW-700198.pdf fails.

Wouldn’t most say this is a quadrature encoder? Gray code implies absolute, and this would need four bits of Gray to be that. Yes, quadrature is a two-bit Gray code, but still…

Yes, I agree with skelso that quadrature would have been more descriptive. The datasheet also does not fully describe which pins the push switch connects to, but I assume that they are the two unlabeled pins. I also assume that they meant to describe the switch as a momentary, normally open type which goes to closed when the shaft is pressed down.
Clarity in datasheets is becoming rare nowadays…

I have the push working nicely.
But cannot make sense of the rotary encoding. The values the device reports seem very arbitrary. It is frustrating; I am going to need to re-think the interface to this project. If I had been able to make this work as expected it would have been a perfect choice for this control interface.

Anyone have an eagle part for this?

Be warned! This one only has 12 steps per cycle instead of the usual 20.

Very easy to use. I have written some introduction on how to do so here: http://bit.ly/cNdzV7

A word of warning about using these in an enclosure. There is very little room between the bottom of the knob (sold seperately) and the encoder case. Without pressing the “button” there is 1.0mm (assuming you make holes for the two small bumps on top of the encoder case). With the button pressed you’re down to about 0.5mm (I couldn’t get my calipers in between to measure).
I ended up cutting holes in my enclosure large enough for the knobs to fit inside. My case would have looked cleaner if I could have had holes just big enough for the shafts.

any tips on using this with COM-10001? I ordered two of each and, alas, the knob doesn’t really fit. I am loath to use glue but I suppose I will if I must.
Otherwise MANY thanks to all the helpful links! with the info here I got it up and running in about as much time as it took to open the box. =-D

Tactile feedback is kind of weak, more bumpy than snappy. Still noticeable though. Good enough for prototyping. Might want to try a wider range of alternatives if you’re considering deployment or building something permanent.

I agree with fluidic on the feel of this encoder. it is very weak, and unstable. but for 3 bucks, it is a great deal for proto work. if you need anything with single-click precision, this model won’t work very well. I used Oleg’s code and it ran first build, as advertised.

Here’s the Arduino code I ended up using.

/*
    www.Wusik.com - Created by WilliamK @ Wusik Dot Com (c) 2010
 */

#ifndef ENCODER_h
#define ENCODER_h

#include
#include "HardwareSerial.h"

// 12 Step Rotary Encoder with Click //
// http://www.sparkfun.com/products/9117 //
#define EncoderPinA 20  // Rotary Encoder Left Pin //
#define EncoderPinB 19  // Rotary Encoder Right Pin //
#define EncoderPinP 21  // Rotary Encoder Click //

// ======================================================================================= //
class Encoder
{
  public:
    Encoder()
    {
      pinMode(EncoderPinA, INPUT);
      digitalWrite(EncoderPinA, HIGH);
      pinMode(EncoderPinB, INPUT);
      digitalWrite(EncoderPinB, HIGH);
      pinMode(EncoderPinP, INPUT);
      digitalWrite(EncoderPinP, HIGH);

      Position = 0;
      Position2 = 0;
      Max = 127;
      Min = 0;
      clickMultiply = 10;
    }

    void Tick(void)
    {
      Position2 = (digitalRead(EncoderPinB) * 2) + digitalRead(EncoderPinA);;
      if (Position2 != Position)
      {
        isFwd = ((Position == 0) && (Position2 == 1)) || ((Position == 1) && (Position2 == 3)) ||
          ((Position == 3) && (Position2 == 2)) || ((Position == 2) && (Position2 == 0));
        if (!digitalRead(EncoderPinP)) { if (isFwd) Pos += clickMultiply; else Pos -= clickMultiply; }
        else { if (isFwd) Pos++; else Pos--; }
        if (Pos < Min) Pos = Min;
        if (Pos > Max) Pos = Max;
      }
      Position = Position2;
    }

    int getPos(void)
    {
      return (Pos/4);
    }

    void setMinMax(int _Min, int _Max)
    {
      Min = _Min*4;
      Max = _Max*4;
      if (Pos < Min) Pos = Min;
      if (Pos > Max) Pos = Max;
    }

    void setClickMultiply(int _clickMultiply)
    {
      clickMultiply = _clickMultiply;
    }

  private:
    int clickMultiply;
    int Max;
    int Min;
    int Pos;
    int Position;
    int Position2;
    int isFwd;
};

#endif

Here’s a slick, 2-wire interrupt-driven Arduino solution (which should be easily adaptable elsewhere) that I saw over at Ayars' Hardware Hacks:
http://hacks.ayars.org/2009/12/using-quadrature-encoder-rotary-switch.html
It only determines direction, but that’s all I’m going to be using this for.

Does anybody know of a knob that fits this? I tried the silver metal knob (COM-10001) and it definitely does not fit – the shaft is too big. I tried a knob off another piece of equipment (perhaps similar to the black knob, COM-09998) and it didn’t fit either. It’s pictured with COM-08828, is that the only one that fits?
Thanks.

For whoever may find it useful: I used a bunch of these rotary encoders for a prototyping project and I wrote a simple wrapper library around them.
You can find the code on GitHub:
https://github.com/micheljansen/arduino-rotary-knob

    #define PIN_OFFSET 22  
    #define NUMKNOBS 6  
    Knob knobs[NUMKNOBS];  
    void setup()  
    {  
      for(int i = 0; i < NUMKNOBS; i++) {  
        knobs[i].setup(PIN_OFFSET + 2*i, PIN_OFFSET + 2*i + 1);  
        // abuse output pins for gnd  
        pinMode(i+2, OUTPUT);  
        digitalWrite(i+2, LOW);  
      }  
      Serial.begin(9600);  
    }  
    void loop()  
    {  
      for(int i = 0; i < NUMKNOBS; i++) {  
           int dir = knobs[i].read();  
        if(dir) {  
          if(dir > 0) {  
                Serial.println("right");  
          }  
          else {  
            Serial.println("left");  
          }  
         }  
      }  
    }  

These are definitely quadrature encoders. You can multiply the counts by using edge detection. So you can increase the counts to a maximum of 48 counts easily.

First, I can’t believe that someone does not make an I2C decoder for an Rotary Encoder. YES, I have ran across people making PICs that can do it, but I am still surprised that no one has made a 12 pin chip that can fit the bill.
What I did find, that I thought was interesting, was a made from two 74HC132 chips with some passive glue >> http://archive.electronicdesign.com/files/29/21422/fig_02.gif Full article is here >> http://electronicdesign.com/article/analog-and-mixed-signal/simple-quadrature-decoder-suits-rotary-encoders214.aspx.
What caught my eye was that there were only two outputs: INC, and DIR.
My frustration with tying a rotary encoder to an Arduino is that you’re wasting resources of the Arduino. Also you have to make sure whatever code you are writing never hangs so to prevent the Arduino from seeing a INT or changed state from the Rotary Encoder. Yes, I do realize that most Arduino are fast. But there always some type of code that takes it’s sweet time to get through that prevents the processor from seeing the INT or a changed state.

I have designed my own simple rotary encoder breakout board for this part out of necessity. You can check it out here: http://www.inmojo.com/store/disassemble-reassemble/item/rotary-encoder-breakout-pcb-only/

I have created a library that works with this encoder. See it here:
http://code.google.com/p/adaencoder
It differs from most other code by being interrupt-driven and easy to use on any pair of Arduino pins (with caveats that the pins must share an ATmega PORT [see the source code for more info]).
Enjoy!

I found the example code pretty confusing. For more understandable, no library and rock steady decoding check out this page.

Worth Noting that these are 48 steps/Revolution not 12, there are 12 DETENTS, each detent counts as 4 steps electrically.

“It’s breadboard friendly,”

Not really. DO NOT PUT THIS IN YOUR BREADBOARD!!!! It bends the leads and then they snap off. You have two options:

1. solder wires on to it, put heatshrink on them if you have it.
2. make a pseudo-breakout board w/ http://www.sparkfun.com/products/8886

baum

Looking at the data sheet this has quadrature outputs and not gray code. There is a big difference. Sparkfun can you comment on this and / or change the description.

-Sam K

I ordered a few of these inexpensive rotary encoders to play with and electrically they work fine. I have some simple PIC test code to inc/dec a 7-segment LED and seems pretty reliable. What I don’t like about this part is the action… it’s too easy to get stuck in the middle of the 12 indents, especially when turning slow. I’m assuming a higher quality part would do a better job of only stopping on the 12 position indent and not in the middle of two positions.

:( Mine came with a pin broken and I have contacted sparkfun,but I was really hoping i could get this project done :(
You REALLY need to “pad” the boxes you use…