Encoder motors now use both A and B pins for each encoder

Author: sorre97

coderbot.py

@@ -25,23 +25,32 @@
 import mpu
 from wheelsaxel import WheelsAxel
 
+# GPIO
+# motors
 PIN_MOTOR_ENABLE = 22
 PIN_LEFT_FORWARD = 24
 PIN_LEFT_BACKWARD = 25
 PIN_RIGHT_FORWARD = 17
 PIN_RIGHT_BACKWARD = 4
+#?
 PIN_PUSHBUTTON = 11
+# servo
 PIN_SERVO_3 = 9
 PIN_SERVO_4 = 10
+# sonar
 PIN_SONAR_1_TRIGGER = 18
 PIN_SONAR_1_ECHO = 7
 PIN_SONAR_2_TRIGGER = 18
 PIN_SONAR_2_ECHO = 8
 PIN_SONAR_3_TRIGGER = 18
 PIN_SONAR_3_ECHO = 23
-PIN_ENCODER_LEFT = 15
-PIN_ENCODER_RIGHT = 14
+# encoder
+PIN_ENCODER_LEFT_A = 14
+PIN_ENCODER_LEFT_B = 6
+PIN_ENCODER_RIGHT_A = 15
+PIN_ENCODER_RIGHT_B = 12
 
+# PWM
 PWM_FREQUENCY = 100 #Hz
 PWM_RANGE = 100 #0-100
 
@@ -51,24 +60,25 @@ class CoderBot(object):
 
     _pin_out = [PIN_MOTOR_ENABLE, PIN_LEFT_FORWARD, PIN_RIGHT_FORWARD, PIN_LEFT_BACKWARD, PIN_RIGHT_BACKWARD, PIN_SERVO_3, PIN_SERVO_4]
 
-    def __init__(self, servo=False, motor_trim_factor=1.0, encoder=True):
+    def __init__(self, motor_trim_factor=1.0, encoder=True):
         self.pi = pigpio.pi('localhost')
         self.pi.set_mode(PIN_PUSHBUTTON, pigpio.INPUT)
         self._cb = dict()
         self._cb_last_tick = dict()
         self._cb_elapse = dict()
-        self._servo = servo
         self._encoder = encoder
         self._motor_trim_factor = motor_trim_factor
         self._twin_motors_enc = WheelsAxel(
             self.pi,
             enable_pin=PIN_MOTOR_ENABLE,
             left_forward_pin=PIN_LEFT_FORWARD,
             left_backward_pin=PIN_LEFT_BACKWARD,
-            left_encoder_feedback_pin=PIN_ENCODER_LEFT,
+            left_encoder_feedback_pin_A=PIN_ENCODER_LEFT_A,
+            left_encoder_feedback_pin_B=PIN_ENCODER_LEFT_B,
             right_forward_pin=PIN_RIGHT_FORWARD,
             right_backward_pin=PIN_RIGHT_BACKWARD,
-            right_encoder_feedback_pin=PIN_ENCODER_RIGHT)
+            right_encoder_feedback_pin_A=PIN_ENCODER_RIGHT_A,
+            right_encoder_feedback_pin_B=PIN_ENCODER_RIGHT_B)
         self.motor_control = self._dc_enc_motor
 
         self._cb1 = self.pi.callback(PIN_PUSHBUTTON, pigpio.EITHER_EDGE, self._cb_button)
@@ -177,6 +187,5 @@ def restart(self):
     def reboot(self):
         os.system('sudo reboot')
 
-
-    def _dc_enc_motor(self, speed_left=100, speed_right=100, elapse=-1):
+    def _dc_enc_motor(self, speed_left=100, speed_right=100, elapse=0):
         self._twin_motors_enc.control_time(power_left=speed_left, power_right=speed_right, time_elapse=elapse)

rotary_encoder/motorencoder.py

@@ -15,13 +15,14 @@ class MotorEncoder:
         concurrency problems on GPIO READ/WRITE """
 
     # default constructor
-    def __init__(self, pi, enable_pin, forward_pin, backward_pin, encoder_feedback_pin):
+    def __init__(self, pi, enable_pin, forward_pin, backward_pin, feedback_pin_A, feedback_pin_B):
         # setting pin variables
         self._pi = pi
         self._enable_pin = enable_pin
         self._forward_pin = forward_pin
         self._backward_pin = backward_pin
-        self._encoder_feedback_pin = encoder_feedback_pin
+        self._feedback_pin_A = feedback_pin_A
+        self._feedback_pin_B = feedback_pin_B
 
         # setting movement variables
         self._direction = 0
@@ -33,7 +34,7 @@ def __init__(self, pi, enable_pin, forward_pin, backward_pin, encoder_feedback_p
 
         # other
         self._motor_lock = threading.RLock()
-        self._rotary_decoder = RotaryDecoder(pi, encoder_feedback_pin, self.rotary_callback)
+        self._rotary_decoder = RotaryDecoder(pi, feedback_pin_A, feedback_pin_B, self.rotary_callback)
 
     # GETTERS
     # ticks

rotary_encoder/wheelsaxel.py

@@ -14,8 +14,8 @@ class WheelsAxel:
         that makes one wheel go slower than the other """
 
     def __init__(self, pi, enable_pin,
-                 left_forward_pin, left_backward_pin, left_encoder_feedback_pin,
-                 right_forward_pin, right_backward_pin, right_encoder_feedback_pin):
+                 left_forward_pin, left_backward_pin, left_encoder_feedback_pin_A, left_encoder_feedback_pin_B,
+                 right_forward_pin, right_backward_pin, right_encoder_feedback_pin_A, right_encoder_feedback_pin_B):
 
         # state variables
         self._is_moving = False
@@ -25,13 +25,15 @@ def __init__(self, pi, enable_pin,
                                         enable_pin,
                                         left_forward_pin,
                                         left_backward_pin,
-                                        left_encoder_feedback_pin)
+                                        left_encoder_feedback_pin_A,
+                                        left_encoder_feedback_pin_B)
         # right motor
         self._right_motor = MotorEncoder(pi,
                                          enable_pin,
                                          right_forward_pin,
                                          right_backward_pin,
-                                         right_encoder_feedback_pin)
+                                         right_encoder_feedback_pin_B,
+                                         right_encoder_feedback_pin_A)
 
         # other
         self._wheelsAxle_lock = threading.Condition() # race condition lock
@@ -55,16 +57,16 @@ def speed(self):
     """ Motor time control allows the motors
         to run for a certain amount of time """
     def control_time(self, power_left=100, power_right=100, time_elapse=0):
-         self._wheelsAxle_lock.acquire() # wheelsAxle lock acquire
+        self._wheelsAxle_lock.acquire() # wheelsAxle lock acquire
 
-         # applying tension to motors
-         self._left_motor.control(power_left)
-         self._right_motor.control(power_right)
-         self._is_moving = True
+        # applying tension to motors
+        self._left_motor.control(power_left)
+        self._right_motor.control(power_right)
+        self._is_moving = True
 
-         # moving for desired time
-         sleep(time_elapse)
-         self.stop()
+        # moving for desired time
+        sleep(time_elapse)
+        self.stop()
 
     """ Motor distance control allows the motors
             to run for a certain amount of distance (mm) """
@@ -85,11 +87,6 @@ def control_distance(self, power_left=100, power_right=100, target_distance=0):
         # robot arrived
         self.stop()
 
-    """ Motor speed control allows the motors
-        to run at a certaing amount of speed (mm/s) """
-    def control_speed(self):
-        pass
-
     # old control distance, trying to adjust power
     # def control_distance(self, power_left = 100, power_right = 100, target_distance = 0):
     #     self._is_moving = True
@@ -120,8 +117,8 @@ def control_speed(self):
     #     self.stop()
 
     """ The stop function calls the two stop functions of the two
-        correspondent motors 
-        locks are automatically obtained """
+        correspondent motors. 
+        Locks are automatically obtained """
     def stop(self):
         self._left_motor.stop()
         self._right_motor.stop()
@@ -130,8 +127,6 @@ def stop(self):
         self._wheelsAxle_lock.release()
 
     # CALLBACK
-
-
     def cancel_callback(self):
         self._right_motor.cancel_callback()
         self._left_motor.cancel_callback()