The vast majority of schemas that you will find on internet does not include the “purple” line, which connecting the SW pin on the rotary control to the GPIO Pin 27. I have no idea why – the “switch push” gesture, when you “press” the knob can be used for a lot of interesting functions, such as mute\/unmute, pause\/resume, etc.<\/p><\/blockquote>\n\n\n\n

The next step was to write a Python script for fetching those signals, and doing some work. First, I wrote a very basic script to test how the rotary encoder was working:<\/p>\n\n\n

\nimport os\nfrom RPi import GPIO\n\nos.system('clear') #clear screen, this is just for the OCD purposes\n\nstep = 5 #linear steps for increasing\/decreasing volume\npaused = False #paused state\n\n#tell to GPIO library to use logical PIN names\/numbers, instead of the physical PIN numbers\nGPIO.setmode(GPIO.BCM) \n\n#set up the pins we have been using\nclk = 17\ndt = 18\nsw = 27\n\n#set up the GPIO events on those pins\nGPIO.setup(clk, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)\nGPIO.setup(dt, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)\nGPIO.setup(sw, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)\n\n#get the initial states\ncounter = 0\nclkLastState = GPIO.input(clk)\ndtLastState = GPIO.input(dt)\nswLastState = GPIO.input(sw)\n\n#define functions which will be triggered on pin state changes\ndef clkClicked(channel):\n        global counter\n        global step\n\n        clkState = GPIO.input(clk)\n        dtState = GPIO.input(dt)\n\n        if clkState == 0 and dtState == 1:\n                counter = counter + step\n                print ("Counter ", counter)\n\ndef dtClicked(channel):\n        global counter\n        global step\n\n        clkState = GPIO.input(clk)\n        dtState = GPIO.input(dt)\n        \n        if clkState == 1 and dtState == 0:\n                counter = counter - step\n                print ("Counter ", counter)\n\ndef swClicked(channel):\n        global paused\n        paused = not paused\n        print ("Paused ", paused)             \n                \nprint ("Initial clk:", clkLastState)\nprint ("Initial dt:", dtLastState)\nprint ("Initial sw:", swLastState)\nprint ("=========================================")\n\n#set up the interrupts\nGPIO.add_event_detect(clk, GPIO.FALLING, callback=clkClicked, bouncetime=300)\nGPIO.add_event_detect(dt, GPIO.FALLING, callback=dtClicked, bouncetime=300)\nGPIO.add_event_detect(sw, GPIO.FALLING, callback=swClicked, bouncetime=300)\n\nraw_input("Start monitoring input")\n\nGPIO.cleanup()\n<\/pre><\/div>\n\n\n
The Python script above “fetches” the impulses coming to the GPIO pins, and then increases or decreases the “counter” variable value, depending if the rotary encoder has been turned clockwise or counterclockwise. <\/p>\n\n\n\n
But how do we know, when has it been turned clockwise, and when counterclockwise? It is important to know, that the “natural”, “default” state of all pins (CLK, DT, SW) is “1”. So we are checking when this value will change. <\/p>\n\n\n\n
For a clockwise rotation, you will get two consecutive “signals”. After the first signal, CLK will be 0 (CLK has changed), whereas DT remains 1. After the second signal, both CLK and DT will be set to 0. <\/p>\n\n\n\n
Clockwise rotation<\/td>
CLK State<\/td>
DT State<\/td><\/tr>
1st signal<\/td>
0<\/td>
1<\/td><\/tr>
2nd signal<\/td>
0<\/td>
0<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
For a counterclockwise rotation, you will also get two consecutive signals. After the first signal, DT will be 0, whereas CLK remains 1. After the second signal, both CLK and DT will be set to 0.<\/p>\n\n\n\n
Counterclockwise rotation<\/td>
CLK State<\/td>
DT State<\/td><\/tr>
1st signal<\/td>
1<\/td>
0<\/td><\/tr>
2nd signal<\/td>
0<\/td>
0<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
In essence, we will catch the CLK and DT interrupts, and check for these combinations. As you are turning the knob clockwise or counterclockwise, you will see the Counter being increased or decreased by the step you have declared (5 in my case). <\/p>\n\n\n\n
You can of course get very playful here, and measure the time intervals between interrupts, and increase\/decrease step based on the time difference. So, for example, when someone is turning the knob fast, you can use exponential volume increase\/decrease, whereas if the knob is being turned slower, you can keep it linear. This way, you are making the feeling of the “fast” but also “fine” volume control change. <\/p><\/blockquote>\n\n\n\n
Catching the push switch button event is easy. It has got its own interrupt, and you don’t need to check for the combination of the values, like with the knob turning gestures. In my scenario, I will be using it to pause\/resume the music play. The source code for that interrupt is a very simple one. <\/p>\n\n\n\n
But, we do not want just to increase\/decrease the value of a “counter” variable, we actually want to turn the volume up or down. For Moode Audio, a media player which is based on the MPD server, those are the GET requests that you need to call in order to preform the volume and music control operations:<\/p>\n\n\n\n
Play<\/td>
http:\/\/moode\/command?cmd=play<\/td><\/tr>
Skip to next song<\/td>
http:\/\/moode\/command?cmd=next<\/td><\/tr>
Stop<\/td>
http:\/\/moode\/command?cmd=stop<\/td><\/tr>
Pause \/ Resume<\/td>
http:\/\/moode\/command?cmd=pause<\/td><\/tr>
Volume up by 5%<\/td>
http:\/\/moode\/command?cmd=vol.sh up 5<\/td><\/tr>
Volume down by 5%<\/td>
http:\/\/moode\/command?cmd=vol.sh dn 5<\/td><\/tr>
Mute \/ Unmute<\/td>
http:\/\/moode\/command?cmd=vol.sh mute<\/td><\/tr>
Set volume to 25%<\/td>
http:\/\/moode\/command?cmd=vol.sh 25<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
You will of course want to change the URL to the host name of your media player.<\/p><\/blockquote>\n\n\n\n
The code then looks something like this:<\/p>\n\n\n
\nimport requests\n\n#here we define the commands we want to send to the player\nurlmoode = "http:\/\/moode-studio\/command"\nparamVolUp = {'cmd' : 'vol.sh up 5'}\nparamVolDn = {'cmd' : 'vol.sh dn 5'}\nparamMute = {'cmd' : 'vol.sh mute'}\nparamStop = {'cmd' : 'stop'}\nparamPlay = {'cmd' : 'play'}\nparamPause = {'cmd' : 'pause'}\n\n#get request for volume down\nr = requests.get(url = urlmoode, params = paramVolDn)\n\n#get request for volume up\nr = requests.get(url = urlmoode, params = paramVolUp)\n\n#get request for pause\/play\nr = requests.get(url = urlmoode, params = paramPause)\n\n<\/pre><\/div>\n\n\n
Now, one thing to consider here is, if you make those GET requests synchronously, they will necessarily slow down your code, because they need time to execute, and some of the interrupts from the rotary encoder might be skipped. That is not a pleasant user experience. This is why I am suggesting you either use multithreading, or async patterns here. That way, your script will remain “responsive”, even if another thread, or an async block of code is executing that GET request somewhere.<\/p><\/blockquote>\n\n\n\n
These “delays”, caused by the web service calls, are in the same time the only reason why I would possibly think of sending the vol+ or vol- signals directly to the amplifier, instead of sending them to the software. In that case, the whole pause\/resume use case would not be supported, the real volume would not be in sync to that what your player thinks it is, but it WOULD perform faster. I have still decided against it. But, if you are considering going down that path, please keep in mind that the GPIO pins 17, 18 and 27 are reserved by many amplifiers and DACs, for example BEOCREATE. In that case, think of using GPIO pins 5, 6, 12, 13 and 16 instead of the abovementioned ones – they are usually free. BEOCREATE, for example, exposes them through the own set of pins. <\/p>\n\n\n\n
That would be all about rotary encoder and Pi. Once you grasp the concepts of clock and direction within the encoder, and once you understand the function of the GPIO pins on the raspberry board, it is a very simple procedure. The code itself can be made fancy (with exponential increase etc.), but the starter code here can get you going.<\/p>\n
\n\t\t\t  
\n\t\t\t  <\/div><\/div>\n\t\t