Rotary encoder test scripts

Author: sorre97

rotary_encoder_test/reset_motors.py

@@ -0,0 +1,5 @@
+import pigpio
+
+pi = pigpio.pi()
+pi.write(24, 0)
+pi.write(17, 0)

rotary_encoder_test/rotary_encoder.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+
+import pigpio
+
+class decoder:
+
+   """Class to decode mechanical rotary encoder pulses."""
+
+   def __init__(self, pi, gpioB, callback):
+
+      self.pi = pi
+      self.gpioB = gpioB
+      self.callback = callback
+
+      self.levB = 0
+
+      self.lastGpio = None
+
+      self.pi.set_mode(gpioB, pigpio.INPUT)
+
+      self.pi.set_pull_up_down(gpioB, pigpio.PUD_UP)
+
+      self.cbB = self.pi.callback(gpioB, pigpio.EITHER_EDGE, self._pulse)
+
+   def _pulse(self, gpio, level, tick):
+      self.levB = level;
+
+      #if gpio != self.lastGpio: # debounce
+      #   self.lastGpio = gpio
+      if self.levB == 1:
+          self.callback(1)
+
+
+   def cancel(self):
+
+      """
+      Cancel the rotary encoder decoder.
+      """
+
+      self.cbB.cancel()
+
+

rotary_encoder_test/rotary_encoder_PWM_test.py

@@ -0,0 +1,53 @@
+PIN_LEFT_FORWARD = 24
+PIN_LEFT_BACKWARD = 25
+PIN_RIGHT_FORWARD = 17
+PIN_RIGHT_BACKWARD = 4
+PIN_MOTOR_ENABLE = 22
+
+PWM_FREQUENCY = 100 #Hz
+PWM_RANGE = 100 #0-100
+
+if __name__ == "__main__":
+
+   import time
+   import pigpio
+   
+   #pi = pigpio.pi('coderbot.local')
+   pi = pigpio.pi()
+   print("Connected, waiting for signal")
+
+   # FORWARD MOVEMENT
+   print("FORWARD")
+   pi.set_PWM_frequency(PIN_LEFT_FORWARD, PWM_FREQUENCY)
+   pi.set_PWM_range(PIN_LEFT_FORWARD, PWM_RANGE)
+   pi.set_PWM_frequency(PIN_RIGHT_FORWARD, PWM_FREQUENCY)
+   pi.set_PWM_range(PIN_RIGHT_FORWARD, PWM_RANGE)
+
+   pi.write(PIN_MOTOR_ENABLE, 1)
+
+   pi.set_PWM_dutycycle(PIN_LEFT_FORWARD, 100)
+   pi.set_PWM_dutycycle(PIN_RIGHT_FORWARD, 100) 
+   
+   time.sleep(.5)
+
+   print("STOP")
+   pi.write(PIN_LEFT_FORWARD, 0)
+   pi.write(PIN_RIGHT_FORWARD, 0)
+
+   # BACKWARDS MOVEMENT
+   print("BACKWARDS")
+   pi.set_PWM_frequency(PIN_LEFT_BACKWARD, PWM_FREQUENCY)
+   pi.set_PWM_range(PIN_LEFT_BACKWARD, PWM_RANGE)
+   pi.set_PWM_frequency(PIN_RIGHT_BACKWARD, PWM_FREQUENCY)
+   pi.set_PWM_range(PIN_RIGHT_BACKWARD, PWM_RANGE)
+
+   pi.set_PWM_dutycycle(PIN_LEFT_BACKWARD, 100)
+   pi.set_PWM_dutycycle(PIN_RIGHT_BACKWARD, 100) 
+
+   time.sleep(.5)
+
+   print("STOP")
+   pi.write(PIN_LEFT_BACKWARD, 0)
+   pi.write(PIN_RIGHT_BACKWARD, 0)
+
+   pi.stop()

rotary_encoder_test/rotary_encoder_fixed_distance_test.py

@@ -0,0 +1,53 @@
+PIN_LEFT_FORWARD = 24
+PIN_LEFT_BACKWARD = 25
+PIN_RIGHT_FORWARD = 17
+PIN_RIGHT_BACKWARD = 4
+PIN_ENCODER_LEFT = 15
+PIN_ENCODER_RIGHT = 14
+
+PIN_MOTOR_ENABLE = 22
+PWM_FREQUENCY = 100 #Hz
+PWM_RANGE = 100 #0-100
+
+if __name__ == "__main__":
+
+   import time
+   import pigpio
+   import signal
+
+   import rotary_encoder
+
+   pos = 0
+
+   def callback_left(way):
+      global pos
+      pos += way
+
+      print("You've travelled: " + str(0.196 * pos) + "mm, ticks: " + str(pos))
+
+   pi = pigpio.pi()
+
+   decoder_left = rotary_encoder.decoder(pi, PIN_ENCODER_LEFT, callback_left)
+
+   # FORWARD MOVEMENT
+   print("GOING FORWARD")
+   pi.set_PWM_frequency(PIN_LEFT_FORWARD, PWM_FREQUENCY)
+   pi.set_PWM_range(PIN_LEFT_FORWARD, PWM_RANGE)
+   pi.set_PWM_frequency(PIN_RIGHT_FORWARD, PWM_FREQUENCY)
+   pi.set_PWM_range(PIN_RIGHT_FORWARD, PWM_RANGE)
+
+   pi.write(PIN_MOTOR_ENABLE, 1)
+
+   pi.set_PWM_dutycycle(PIN_LEFT_FORWARD, 30)
+   pi.set_PWM_dutycycle(PIN_RIGHT_FORWARD, 30)
+
+   signal.pause()
+
+   if(pos > 100):
+      print("STOP")
+      pi.write(PIN_LEFT_FORWARD, 0)
+      pi.write(PIN_RIGHT_FORWARD, 0)
+      decoder.cancel()
+      pi.stop()
+
+

rotary_encoder_test/rotary_encoder_original.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+
+import pigpio
+
+class decoder:
+
+   """Class to decode mechanical rotary encoder pulses."""
+
+   def __init__(self, pi, gpioA, gpioB, callback):
+
+      """
+      Instantiate the class with the pi and gpios connected to
+      rotary encoder contacts A and B.  The common contact
+      should be connected to ground.  The callback is
+      called when the rotary encoder is turned.  It takes
+      one parameter which is +1 for clockwise and -1 for
+      counterclockwise.
+
+      EXAMPLE
+
+      import time
+      import pigpio
+
+      import rotary_encoder
+
+      pos = 0
+
+      def callback(way):
+
+         global pos
+
+         pos += way
+
+         print("pos={}".format(pos))
+
+      pi = pigpio.pi()
+
+      decoder = rotary_encoder.decoder(pi, 7, 8, callback)
+
+      time.sleep(300)
+
+      decoder.cancel()
+
+      pi.stop()
+
+      """
+
+      self.pi = pi
+      self.gpioA = gpioA
+      self.gpioB = gpioB
+      self.callback = callback
+
+      self.levA = 0
+      self.levB = 0
+
+      self.lastGpio = None
+
+      self.pi.set_mode(gpioA, pigpio.INPUT)
+      self.pi.set_mode(gpioB, pigpio.INPUT)
+
+      self.pi.set_pull_up_down(gpioA, pigpio.PUD_UP)
+      self.pi.set_pull_up_down(gpioB, pigpio.PUD_UP)
+
+      self.cbA = self.pi.callback(gpioA, pigpio.EITHER_EDGE, self._pulse)
+      self.cbB = self.pi.callback(gpioB, pigpio.EITHER_EDGE, self._pulse)
+
+   def _pulse(self, gpio, level, tick):
+
+      """
+      Decode the rotary encoder pulse.
+
+                   +---------+         +---------+      0
+                   |         |         |         |
+         A         |         |         |         |
+                   |         |         |         |
+         +---------+         +---------+         +----- 1
+
+             +---------+         +---------+            0
+             |         |         |         |
+         B   |         |         |         |
+             |         |         |         |
+         ----+         +---------+         +---------+  1
+      """
+
+      if gpio == self.gpioA:
+         self.levA = level
+      else:
+         self.levB = level;
+
+      if gpio != self.lastGpio: # debounce
+         self.lastGpio = gpio
+
+         if   gpio == self.gpioA and level == 1:
+            if self.levB == 1:
+               self.callback(1)
+         elif gpio == self.gpioB and level == 1:
+            if self.levA == 1:
+               self.callback(-1)
+
+   def cancel(self):
+
+      """
+      Cancel the rotary encoder decoder.
+      """
+
+      self.cbA.cancel()
+      self.cbB.cancel()
+
+

rotary_encoder_test/rotary_encoder_raw_test.py

@@ -0,0 +1,20 @@
+PIN_ENCODER_LEFT = 15
+PIN_ENCODER_RIGHT = 14
+
+import time
+import pigpio
+
+#pi = pigpio.pi('coderbot.local')
+pi = pigpio.pi()
+
+print("connected")
+
+pi.set_mode(PIN_ENCODER_LEFT, pigpio.INPUT)
+pi.set_mode(PIN_ENCODER_RIGHT, pigpio.INPUT)
+
+pi.set_pull_up_down(PIN_ENCODER_LEFT, pigpio.PUD_UP)
+pi.set_pull_up_down(PIN_ENCODER_RIGHT, pigpio.PUD_UP)
+
+
+while(True):
+	print("[ LEFT: " + str(pi.read(PIN_ENCODER_LEFT)) + ", RIGHT: " + str(pi.read(PIN_ENCODER_RIGHT)) + " ]")

rotary_encoder_test/rotary_encoder_ticks_test.py

@@ -0,0 +1,41 @@
+PIN_ENCODER_LEFT = 15
+PIN_ENCODER_RIGHT = 14
+
+if __name__ == "__main__":
+
+   import time
+   import pigpio
+
+   import rotary_encoder
+
+   pos_left = 0
+   pos_right = 0
+
+   def callback_left(way):
+
+      global pos_left
+
+      pos_left += way
+
+      print("Current ticks (left wheel)= {}".format(pos_left))
+
+   def callback_right(way):
+
+      global pos_right
+
+      pos_right += way
+
+      print("Current ticks (right wheel) = {}".format(pos_right))
+   pi = pigpio.pi()
+
+   print("Rotary encoder ticks test (left wheel ONLY)")
+
+   decoder_left = rotary_encoder.decoder(pi, PIN_ENCODER_LEFT, callback_left)
+   decoder_right = rotary_encoder.decoder(pi, PIN_ENCODER_RIGHT, callback_right)
+
+   time.sleep(300)
+
+   decoder.cancel()
+
+   pi.stop()
+