Month: March 2009

The simple technique of reading a quadrature knob I described there works fine, except for the knob I picked for a recent project. That’s what I get for using surplus knobs, right?

I picked this knob because it has a momentary push-on switch that I’ll be using for power; the gizmo should operate only when the knob is pressed. The rotary encoder part of the knob has 30 detents, but successive “clicks” correspond to rising and falling clock edges: the encoder has only 15 pulses in a full turn.

So, while advancing the knob counter on, say, the falling edges of the A input worked, it meant that the count advanced only one step for every other click: half the clicks did nothing at all. Disconcerting, indeed, when you’re controlling a voltage in teeny little steps.

Worse, the encoder contacts are painfully glitchy; the A input (and the B, for that matter) occasionally generated several pulses that turned into multiple counts for a single click.

Fortunately, the fix for both those problems is a simple matter of software…

The Arduino interrupt setup function can take advantage of the ATmega168’s ability to generate an interrupt on a pin change, at least for the two external interrupts that the Arduino runtime code supports. So it’s an easy matter to get control on both rising & falling edges of the A input, then make something happen on every click of the knob as you’d expect.

The hardware is straightforward: connect the knob’s A output to INT0, the B  output to D7, and the common contact to circuit ground. Although you can use the internal pullups, they’re pretty high-value, so I added a 4.7 kΩ resistor to Vcc on each input. The code defining that setup:

#define PIN_KNOB_A	2			// LSB - digital input for knob clock (must be 2 or 3!))
#define IRQ_KNOB_A	(PIN_KNOB_A - 2)	//  set IRQ from pin
#define PIN_KNOB_B	7			// MSB - digital input for knob quadrature

Because we’ll get an interrupt for each click in either direction, we can’t simply look at the B input to tell which way the knob is turning. The classy way to do this is to remember where we were, then look at the new inputs and figure out where we are. This buys two things:

• Action on each edge of the A input, thus each detent
• Automatic deglitching of crappy input transitions

So we need a state machine. Two states corresponding to the value of the A input will suffice:

enum KNOB_STATES {KNOB_CLICK_0,KNOB_CLICK_1};

A sketch (from one of these scratch pads) shows the states in relation to the knob inputs. Think of the knob as being between the detents for each state; the “click” happens when the state changes.

In order to mechanize that, put it in table format. The knob state on the left shows where the knob was and the inputs along the top determine what we do.

So, for example, if the knob was resting with input A = 0 (state KNOB_CLICK_0), then one detent clockwise means the inputs are 01. The second entry in the top row has a right-pointing arrow (→) showing that the knob turned clockwise and the next state is KNOB_CLICK_1. In that condition, the code can increment the knob’s position variable.

The entries marked with X show glitches: an interrupt happened, but the inputs didn’t change out of that state. It could be due to noise or a glitchy transition, but we don’t care: if the inputs don’t change, the state doesn’t change, and the code won’t produce an output. Eventually the glitch will either vanish or turn into a stable input in one direction or the other, at which time it’s appropriate to generate an output.

Two variables hold all the information we need:

volatile char KnobCounter = 0;
volatile char KnobState;

KnobCounter holds the number of clicks the knob has made since the last time the mainline code read the value.

KnobState holds the current (soon to be previous) state of the A input.

Now we can start up the knob hardware interface:

pinMode(PIN_KNOB_B,INPUT);
digitalWrite(PIN_KNOB_B,HIGH);
pinMode(PIN_KNOB_A,INPUT);
digitalWrite(PIN_KNOB_A,HIGH);
KnobState = digitalRead(PIN_KNOB_A);
attachInterrupt(IRQ_KNOB_A,KnobHandler,CHANGE);

An easy way to handle all the logic in the state table, at least for small values of state table, is to combine the state and input bits into a single value for a switch statement. With only eight possible combinations, here’s what it the interrupt handler looks like:

void KnobHandler(void)
{
byte Inputs;
	Inputs = digitalRead(PIN_KNOB_B) << 1 | digitalRead(PIN_KNOB_A);	// align raw inputs
	Inputs ^= 0x02;								// fix direction

	switch (KnobState << 2 | Inputs)
	{
	case 0x00 : // 0 00 - glitch
		break;
	case 0x01 : // 0 01 - UP to 1
		KnobCounter++;
		KnobState = KNOB_CLICK_1;
		break;
	case 0x03 :	// 0 11 - DOWN to 1
		KnobCounter--;
		KnobState = KNOB_CLICK_1;
		break;
	case 0x02 : // 0 10 - glitch
		break;
	case 0x04 : // 1 00 - DOWN to 0
		KnobCounter--;
		KnobState = KNOB_CLICK_0;
		break;
	case 0x05 : // 1 01 - glitch
		break;
	case 0x07 : // 1 11 - glitch
		break;
	case 0x06 :	// 1 10 - UP to 0
		KnobCounter++;
		KnobState = KNOB_CLICK_0;
		break;
	default :	// something is broken!
		KnobCounter = 0;
		KnobState = KNOB_CLICK_0;
	}
}

Reading the knob counter in the main loop is the same as before:

noInterrupts();
KnobCountIs = KnobCounter;	// fetch the knob value
KnobCounter = 0;		//  and indicate that we have it
interrupts();

And that’s all there is to it!

Most analog projects will benefit from an adjustment knob; the notion of pressing those UP and DOWN arrows just doesn’t give that wonderful tactile feedback. These days “knob” means a rotary encoder with quadrature outputs and some software converting digital bits into an adjustment value.

Sounds scary, doesn’t it?

This is actually pretty simple for most microcontrollers and the Arduino in particular. The Arduino website has some doc on the subject, but it seems far too complicated for most projects.

A quadrature rotary encoder has two digital outputs, hereinafter known as A and B. The cheap ones are mechanical switch contacts that connect to a common third terminal (call it C), the fancy ones are smooth optical interrupters. You pay your money and get your choice of slickness and precision (clicks per turn). I take what I get from the usual surplus sources: they’re just fine for the one-off projects I crank out most of the time.

How does quadrature encoding work?

On each falling edge of the A signal, look at the B signal. If it’s HIGH, the knob has turned one click thataway. If it’s LOW, the knob has turned one click the other way. That’s all there is to it!

Here’s how you build a knob into your code…

Connect one of the outputs to an external interrupt, which means it goes to digital input D2 or D3 on the Arduino board. The former is INT0, the latter INT1, and if you need two interrupts for other parts of your project, then it gets a lot more complex than what you’ll see here. Let’s connect knob output A to pin D2.

Connect the other output, which we’ll call B, to the digital input of your choice. Let’s connect knob output B to D7.

Define the pins and the corresponding interrupt at the top of your program (yeah, in Arduino-speak that’s “sketch”, but it’s really a program):

#define PIN_KNOB_A 2			// digital input for knob clock (must be 2 or 3!))
#define IRQ_KNOB_A (PIN_KNOB_A - 2)	//  set IRQ from pin
#define PIN_KNOB_B 7			// digital input for knob quadrature

The external circuitry depends on whether you have a cheap knob or fancy encoder. Assuming you have a cheap knob with mechanical contacts, the C contact goes to circuit common (a.k.a, “ground”). If you have a fancy knob with actual documentation, RTFM and do what it say.

The two inputs need resistors (“pullups”) connected to the supply voltage: when the contact is open, the pin sees a voltage at the power supply (“HIGH“), when it’s closed the voltage is near zero (“LOW“).

Ordinary digital inputs have an internal pullup resistor on the ATmega168 (or whatever the Arduino board uses) that will suffice for the B signal. Unfortunately, the external interrupt pins don’t have an internal pullup, so you must supply your own resistor. Something like 10 kΩ will work fine: one end to the power supply, the other to INT0 or INT1 as appropriate.

With the knob connected, set up the pins & interrupt in your setup() function:

attachInterrupt(IRQ_KNOB_A,KnobHandler,FALLING);
pinMode(PIN_KNOB_B,INPUT);
digitalWrite(PIN_KNOB_B,HIGH);

The first statement says that the interrupt handler will be called when the A signal changes from HIGH to LOW.

The Arduino idiom for enabling the chip’s internal pullup on a digital input pin is to define the pin as an input, then write a HIGH to it.

Set up a variable to accumulate the number of clicks since the last time:

volatile char KnobCounter = 0;

The volatile tells the compiler that somebody else (the interrupt handler or the main routine) may change the variable’s value without warning, so the value must be read from the variable every time it’s used.

The variable’s size depends on the number of counts per turn and the sluggishness of the routine consuming the counts; a char should suffice for all but the most pathological cases.

Define the handler for the knob interrupt:

void KnobHandler(void)
{
    KnobCounter += (HIGH == digitalRead(PIN_KNOB_B)) ? 1 : -1;
}

KnobHandler executes on each falling edge of the A signal and either increments or decrements the counter depending on what it sees on the B signal. This is one of the few places where you can apply C’s ternary operator without feeling like a geek.

Define a variable that will hold the current value of the counter when you read it:

char KnobCountIs, Count;

Now you can fetch the count somewhere in your loop() routine:

noInterrupts();
KnobCountIs = KnobCounter;	// fetch the knob value
KnobCounter = 0;		//  and indicate that we have it
interrupts();

Turning interrupts off while fetching-and-clearing KnobCounter probably isn’t necessary for a knob that will accumulate at most one count, but it’s vital for programs that must not lose a step.

Now you can use the value in KnobCountIs for whatever you like. The next time around the loop, you’ll fetch the count that’s accumulated since the previous sample.

Even if you RTFM, apply painstaking logic, and wire very carefully, there’s a 50% chance that the knob will turn the wrong way. In that case, change one of these:

• In the interrupt handler, change HIGH to LOW
• In the attachInterrupt() statement, change FALLING to RISING

There, now, wasn’t that easy? Three wires, a resistor, a dozen lines of code, and your project has a digital quadrature knob!

If you have a painfully slow main loop, the accumulated counts in KnobCounter could get large. In that case, this code will give you a rubber-band effect: the accumulated count can be big enough that when the knob starts turning in the other direction it’s just decreasing the count, not actually moving count to the other side of zero. Maybe you need some code in the interrupt handler to zero the count when the direction reverses?

But that’s in the nature of fine tuning… twiddle on!