Rotary Encoders on RPi

I've been playing with an incremental rotary encoder on the Raspberry Pi - for no better reason than the mountaineers' lame excuse "because it's there"...

The incremental rotary encoder produces two quadrature square waves (as you can learn by reading any of a number of descriptions including this one). By detecting the relative phase of the square waves, you can figure the direction of rotation and (if you are really keen to encode angular velocity accurately) the speed of rotation too.

I settled for a clumsy attempt to decode direction alone, using this circuit...

Of course, you need some code too - I wrote the following simple demonstration in Python. It detects positive-going transitions on "PinA" and looks at the state of PinB during these transition events to figure the direction in which the encoder has been moved.

	#!/usr/local/bin/python
	# m0xpd
	# shack.nasties 'at Gee Male dot com'
	import RPi.GPIO as GPIO
	# setup GPIO options...
	GPIO.setmode(GPIO.BOARD)
	GPIO.setwarnings(False)
	# setup IO bits...
	GPIO.setup(12, GPIO.IN) # PinA is on GPIO 12
	GPIO.setup(16, GPIO.IN) # PinB is on GPIO 16
	# check initial state...
	oldPinA = GPIO.input(12)
	Position = 0
	inc = 5 # increment
	REmax = 127 # Max value
	REmin = 0 # Min value
	# Main Operating Loop...
	while True:
	encoderPinA=GPIO.input(12)
	encoderPinB=GPIO.input(16)
	if (encoderPinA == True) and (oldPinA == False): # Detect "upward" transition on PinA
	if (encoderPinB == False): # if PinB is low...
	Position=Position+inc # we're going clokwise
	if Position > REmax: # limit max value
	Position = REmax
	else: # otherwise...
	Position=Position-inc # we're going anti-clockwise
	if Position < REmin: # limit min value
	Position = REmin
	print Position
	oldPinA=encoderPinA # save current value for next time

view raw RotaryEncoder1.py hosted with ❤ by GitHub

After the fun-and-games with the MIDI controller, I'm really excited about object-oriented software for the RPi, so here's an elaboration which includes a class for Rotary Encoders, connected to any two GPIO pins on the RPi. There's also facility to read a push-button (which some encoders - including mine - feature).

	#!/usr/local/bin/python
	# m0xpd
	# shack.nasties 'at Gee Male dot com'
	import RPi.GPIO as GPIO
	# setup GPIO options...
	GPIO.setmode(GPIO.BOARD)
	GPIO.setwarnings(False)
	class RotaryEnc:
	'Base Class for Rotary Encoder on the RPi GPIO Pins'
	def __init__(self,PinA,PinB,button,Position,REmin,REmax,inc):
	self.PinA = PinA # GPIO Pin for encoder PinA
	self.PinB = PinB # GPIO Pin for encoder PinB
	self.button = button # GPIO Pin for encoder push button
	self.Position = Position # encoder 'position'
	self.min = REmin # Max value
	self.max = REmax # Min value
	self.inc = inc # increment
	self.old_button = 1 # start value for previous button state
	self.oldPinA = 1 # start value for previous PinA state
	self.button_release = 0 # initialise outputs
	self.button_down = 0 # initialise outputs
	GPIO.setup(self.PinA, GPIO.IN) # setup IO bits...
	GPIO.setup(self.PinB, GPIO.IN) #
	GPIO.setup(self.button, GPIO.IN) #
	#
	def read(self): # Function to Read encoder...
	encoderPinA=GPIO.input(self.PinA) # get inputs...
	encoderPinB=GPIO.input(self.PinB) #
	if encoderPinA and not self.oldPinA: # Transition on PinA?
	if not encoderPinB: # Yes: is PinB High?
	self.Position=self.Position+self.inc # No - so we're going clockwise
	if self.Position > self.max: # limit maximum value
	self.Position = self.max #
	#
	else: #
	#
	self.Position=self.Position-self.inc # Yes - so we're going anti-clockwise
	if self.Position < self.min: # limit minimum value
	self.Position = self.min #
	self.oldPinA=encoderPinA # No: just save current PinA state for next time
	#
	def read_button(self): # Function to Read encoder button...
	button=GPIO.input(self.button) # get input...
	if button and not self.old_button: # 'Upward' transition on button?
	self.button_release=1 # Yes - so set release output
	else: #
	self.button_release=0 # No - so clear it
	if not button and self.old_button: # 'Downward' transition on button?
	self.button_down = 1 # Yes - so set 'down' button
	else: #
	self.button_down = 0 # No - so clear it
	self.old_button=button # Save current button state for next time
	# -------------------------------------------------------------------------------------------------------------------
	# Here's a simple example of how to use the RotaryEnc Class ...
	#
	# Set up Rotary Encoder...
	# format is : RotaryEnc(PinA,PinB,button,Position,REmin,REmax,inc):
	Position = 1 # Position is also used as a variable
	RE1 = RotaryEnc(12,16,18,Position,0,10,1) # Instatiate the encoder
	# Main Operating Loop...
	while True:
	RE1.read() # Read the encoder
	if Position <> RE1.Position: # has the position changed?
	print RE1.Position # Yes: so print new value
	Position = RE1.Position # and update it
	RE1.read_button() # Read the button
	if RE1.button_down: # Has it been pressed?
	print 'Button Pressed' # Yes: so print a message
	if RE1.button_release: # Has it been released
	print 'Button Released' # Yes: so print a message

view raw RotaryEncoder2.py hosted with ❤ by GitHub

Here's a screen shot showing me running the second program ...

The code works - but only just...

It is important to sample a rotary encoder at a sufficiently high sample rate to avoid aliasing which - in this case - results in missed "moves" or even moves of incorrect direction.

I cannot get the RPi to sample fast enough to guarantee that every movement is perfectly observed, whether in the "while" loop seen in the programs above, or in a tkinter ".after()" command with a delay argument of 1 millisecond. What's worse, the little graph of processor utilisation at the bottom right of the RPi desktop (like the PC's "Task Manager" or the Mac's "Activity Monitor") reveals that the processor is working hard to sample the encoder at this rate (as you can just see in the screenshot above). I don't know enough about RPi to know if an interrupt-driven approach, such as would be easy and obvious on a PIC, is possible or desirable.

Having said all that, the code above works well enough to let me add a "knob" to my simple RPi MIDI controller, making it much more user-friendly than the original mouse drag-able sliders.

Next, I hope to use the rotary encoder to control the frequency of the DDS generator module from eBay that's just arrived on my doormat - watch this space!

...-.- de m0xpd