Add link to rotary encoder branch

mpdlisten.py

@@ -17,6 +17,21 @@ from luma.core.render import canvas
 from luma.oled.device import ssd1306
 from PIL import Image, ImageDraw, ImageFont
 
+# Pot_cap
+import pigpio
+import pot_cap
+min_val = 8
+max_val = 298
+vol_mult = 100/(max_val-min_val)
+volume = 0
+v_1 = 0
+v_2 = 0
+ctrlc_pressed = False
+pot_cap_gpio = 23
+drain_ms = 0.8
+timeout_s = 1.0
+
+
 jfont = ImageFont.truetype('DejaVuSansMono.ttf', 10)
 
 # MPD config
@@ -31,13 +46,6 @@ GPIO.setmode(GPIO.BCM)
 RELAIS_1_GPIO = 17
 GPIO.setup(RELAIS_1_GPIO, GPIO.OUT) # GPIO Assign mode
 
-# Rotary encoder
-from rot_lib import Encoder
-clk = 27
-dt = 22
-init_volume = 30
-enc=Encoder(dt,clk,0,100,3)
-
 # Buttons GPIO
 BTNS = { 'BTN_1' : dict(GPIO=7, state=1),
          'BTN_2' : dict(GPIO=8, state=1),
@@ -349,6 +357,11 @@ def send_mpd_cmd(client, cmd:str, ui_state:dict):
 def main(args):
     # Idle timer
     ui_idle_for = 0
+    # Pot_cap
+    # Connect to Pi.
+    pi = pigpio.pi() 
+    # Instantiate Pot/Cap reader.
+    pc = pot_cap.reader(pi, pot_cap_gpio, drain_ms, timeout_s)
     start = time()
     
     previous_song_id = None
@@ -378,27 +391,29 @@ def main(args):
     # List song by album
     # ~ songs_from_album = client.list('title', 'album', album_by_x[x])
 
-    # Set Init volume in encoder and mpd
-    volume = init_volume
-    enc.setCounter(volume)
-    client.setvol(volume)
-
     offset_polygons(MODES)
     global ui_vol_icon_polygon
     ui_vol_icon_polygon = apply_xy_offset(ui_vol_icon_polygon, ui_vol_icon_coords)
     global static_ui
     static_ui = generate_static_ui(current_mode)
     while ctrlc_pressed is False:
-        # Rotary encoder
-        cur_vol = int(client.getvol()['volume'])
-        if cur_vol != volume:
-            volume = cur_vol
-        elif int(enc.getValue()) != volume:
-            volume = int(enc.getValue())
-        client.setvol(volume)
-        enc.setCounter(volume)
-
-        #ui_idle_for = 0
+        # pot_cap
+        global v_1
+        global v_2
+        global volume
+        s, v, r = pc.read()
+        if s and r < 4:
+            volume = round(v*vol_mult)
+            if (abs(volume - v_1) > 1) and (abs(volume - v_2) > 2):
+                print("Volume: {}".format(volume))
+                if volume < min_val:
+                    volume = 0
+                if volume > 100:
+                    volume = 100
+                client.setvol(100-volume)
+                ui_idle_for = 0
+            v_2 = v_1
+            v_1 = volume
         # MPD
         mpd_status = client.status()
         if len(mpd_status):
@@ -455,10 +470,12 @@ def main(args):
             # Avoid further execution
             ui_idle_for = 11
             device.hide()
-
+    # pot_cap
+    pc.cancel() # Cancel the reader.
+    pi.stop()   # Disconnect from Pi.
+    
     device.cleanup()
     client.disconnect()
-    GPIO.cleanup()
     return 0
 
 

mpdlistenpy.service

@@ -5,7 +5,7 @@ After=mpd.service
 
 [Service]
 WorkingDirectory=/home/%u/mpdlisten
-ExecStart=/home/%u/mpdlisten/mpdlistenpy.sh
+ExecStart=/home/%u/mpdlisten/mpdlisten.py
 KillSignal=SIGINT
 Restart=always
 

mpdlistenpy.sh

@@ -1,3 +0,0 @@
-#!/bin/env bash
-cd "$(dirname "$0")"
-python mpdlisten.py

readme.md

@@ -5,8 +5,12 @@ This python script is supposed to run on a rpi and does the following :
  * Relay trigger : Watches a MPD instance for play/pause/stop states and activates a relay via GPIOs accordingly ; the usecase for this is powering on/off a pair of speakers only when something is running.  
  * OLED display : Drives a 0.96" OLED display (ssd1306) to display MPD status (volume, current artist, album, title...)  
  * Button input : watches GPIOs for button input ; I'm using 5 push buttons for controlling playback (previous, next, toggle playback, stop, menu) or browse the database and add stuff to the playlist.  
- * Rotary encoder for volume control.  
+ * Potentiometer input : Watches a GPIO for estimating the resistance of a rotary potentiometer and set volume accordingly.  
+ 
+## Rotary encoder version
 
+A WIP version that replaces the potentiometer with a rotary encoder [is available here.](/arthus/mpdlistenpy/src/branch/rot_enc)
+ 
 ## Setup
 
 ### Software
@@ -32,7 +36,7 @@ This python script is supposed to run on a rpi and does the following :
 | OLED | GND, 3.3V, 2(SDA), 3(SCL) |
 | 5 BUTTONS | GND, 7, 8, 9, 11, 25 |
 | POTENTIOMETER | GND, 3.3V, 23 |
-| ROTARY ENCODER | GND, 3V3, 27, 22 |
+| RELAY | GND, 5V, 17 |
 
 You can check these here : [https://pinout.xyz/](https://pinout.xyz/)  
 
@@ -77,18 +81,39 @@ If you're short on GPIOs, there is a way to use a single GPIO for multiple butto
 
 [https://www.instructables.com/RaspberryPi-Multiple-Buttons-On-One-Digital-Pin/](https://www.instructables.com/RaspberryPi-Multiple-Buttons-On-One-Digital-Pin/)  
 
-#### Rotary encoder circuit
+#### Potentiometer circuit
 
-Using [https://github.com/Tr3m/rpi-rotary-encoder](https://github.com/Tr3m/rpi-rotary-encoder), we can use a 3-pins rotary encoder to control volume.  
+Using the 'step response' method described [here](http://razzpisampler.oreilly.com/ch08.html#Discussion) (It's the same principle as in the link above),
+we can use an analog potentiometer to control volume.
 
-##### Wiring
+The solution described in the previous link is not very accurate though, so we'll be using an alternative solution offered by abyz.me.uk :
 
-| ENCODER | RPI GPIO # |
-| ---    | ---   |
-| GND | GND |
-| + | 3V3 |
-| CLK | 27 |
-| DT | 22 |
+[https://abyz.me.uk/rpi/pigpio/examples.html#Python_pot_cap_py](https://abyz.me.uk/rpi/pigpio/examples.html#Python_pot_cap_py)
+
+##### Components
+
+ * 100nf Ceramic capacitor
+ * 5KΩ Potentiometer
+
+##### Diagram 
+
+```
+   3V3 ----- Potentiometer --+-- Capacitor ----- Ground
+                             |
+                             +-- GPIO 23
+```
+
+Instructions for use are in the source file. The library ('pot_cap.py') is included in this project for convenience.  
+
+You might have to install the 'pigpio' library though :
+
+```
+sudo apt install python3-pigpio
+```
+
+You can find out more about installing 'pigpio' here :
+
+[https://abyz.me.uk/rpi/pigpio/download.html](https://abyz.me.uk/rpi/pigpio/download.html)
 
 ## Optional steps 
 

rot_lib.py

@@ -1,92 +0,0 @@
-# 2023 - Tr3m
-# Source : https://github.com/Tr3m/rpi-rotary-encoder
-# Added a setCounter() method
-
-import RPi.GPIO as GPIO
-from time import sleep
-
-class Encoder:
-        
-    def __init__(self, pin_a: int, pin_b: int, range_min, range_max, increment):        
-        if type(pin_a) == type(pin_b) == int:
-            self.__pin_a = pin_a
-            self.__pin_b = pin_b
-
-            self.__counter = None       
-            self.__range_min = None
-            self.__range_max = None
-            self.__increment = None
-
-            self.setRange(range_min, range_max, increment)
-            
-            GPIO.setwarnings(True)
-            GPIO.setmode(GPIO.BCM)
-
-            GPIO.setup(self.__pin_a, GPIO.IN)
-            GPIO.setup(self.__pin_b, GPIO.IN)           
-            
-            GPIO.add_event_detect(self.__pin_a, GPIO.RISING, callback=self.__rotation_decode, bouncetime=10)            
-
-        else:
-            raise TypeError("Arguments need to be of type int")
-
-
-    def getValue(self):
-        return self.__counter
-    
-    
-    def setRange(self, range_min, range_max, increment):
-        if type(range_min) != type(range_max):
-            raise TypeError("Arguments need to be same type (int or float)")
-        
-        if type(range_min) == int or type(range_min) == float:
-            if type(increment) != type(range_min):
-                raise TypeError("Increment type needs to be the same type as range_min and range_max")
-            
-            if range_min > range_max:
-                raise Exception("Invalid range")
-            
-            self.__range_min = range_min
-            self.__range_max = range_max
-            self.__increment = increment
-            self.__counter = (range_min + range_max) / 2
-            
-            return               
-        
-        raise TypeError("Unsupported operand:", type(range_min))
-    
-
-    def setCounter(self, counter):
-        self.__counter = float(counter)
-
-    def __rotation_decode(self, pin: int):        
-        sleep(0.002)
-        Switch_A = GPIO.input(self.__pin_a)
-        Switch_B = GPIO.input(self.__pin_b)
-
-        if (Switch_A == 1) and (Switch_B == 0):
-            if (self.__counter > self.__range_min) and ((self.__counter - self.__increment) > self.__range_min):
-                self.__counter -= self.__increment
-            else:
-                self.__counter = self.__range_min
-
-            while Switch_B == 0:
-                Switch_B = GPIO.input(self.__pin_a)
-            while Switch_B == 1:
-                Switch_B = GPIO.input(self.__pin_b)
-            return
-
-        elif (Switch_A == 1) and (Switch_B == 1):
-            if (self.__counter < self.__range_max) and (self.__counter + self.__increment < self.__range_max):
-                self.__counter += self.__increment
-            else:
-                self.__counter = self.__range_max
-
-            while Switch_A == 1:
-                Switch_A = GPIO.input(pin)
-            return
-        else:
-            return
-    
-    def __clear(self):
-        GPIO.remove_event_detect(self.__pin_a)