Encoder motors now use quadrature encoder feedback for each motor

Author: sorre97

rotary_encoder/motorencoder.py

@@ -117,20 +117,21 @@ def stop(self):
     # CALLBACK
     """ The callback function rotary_callback is called on FALLING_EDGE by the
         rotary_decoder with a parameter value of 1 (1 new tick)
+        
         - Gearbox ratio: 120:1 (1 wheel revolution = 120 motor revolution)
-        - Encoder ratio: 8:1 encoder ticks for 1 motor revolution
-        - 1 wheel revolution = 128 * 8 = 960 ticks
+        - Encoder ratio: 16:1 encoder ticks for 1 motor revolution
+        - 1 wheel revolution = 120 * 16 = 1920 ticks
         - R = 30mm
         - 1 wheel revolution = 2πR = 2 * π * 30mm = 188.5mm
-        - 960 ticks = 188.5mm
-        - 1 tick = 0.196mm
-        - 1 tick : 0.196mm = x(ticks) : y(mm) """
+        - 1920 ticks = 188.5mm
+        - 1 tick = 0.0981mm
+        - 1 tick : 0.0981mm = x : 1000mm -> x = 10193 ticks aproximately """
 
     # callback function
     def rotary_callback(self, tick):
         self._motor_lock.acquire()
         self._ticks += tick  # updating ticks
-        self._distance = self._ticks * 0.196  # (mm) travelled
+        self._distance = self._ticks * 0.0981  # (mm) travelled
         #self._encoder_speed = (mm/s)
         self._motor_lock.release()
 

rotary_encoder/rotarydecoder.py

@@ -58,15 +58,21 @@ def _pulse(self, gpio, level, tick):
          self._lastGpio = gpio
 
          if (gpio == self._feedback_pin_A and level == 1):
+            if (self._levelB == 0):
+               self._callback(1) # A leading B, moving forward
+               self._direction = 1 # forward
+         elif (gpio == self._feedback_pin_A and level == 0):
             if (self._levelB == 1):
                self._callback(1) # A leading B, moving forward
                self._direction = 1 # forward
-
          elif (gpio == self._feedback_pin_B and level == 1):
-            if (self._levelA == 1):
+            if (self._levelA == 0):
                self._callback(-1)   # B leading A, moving forward
                self._direction = -1 # backwards
-
+         elif (gpio == self._feedback_pin_B and level == 0):
+            if (self._levelA == 1):
+               self._callback(-1) # A leading B, moving forward
+               self._direction = -1 # forward
 
    def cancel(self):
 

rotary_encoder/wheelsaxel.py

@@ -91,7 +91,7 @@ def control_distance(self, power_left=100, power_right=100, target_distance=0):
         self._right_motor.control(power_right)
 
         # moving for certaing amount of distance
-        while(target_distance > 0):
+        while(self.distance() < target_distance):
             sleep(0.05) # check if arrived every 50ms,
             print(str(self.distance()))
             target_distance = target_distance - self.distance() # updating target distance

rotary_encoder_tests/rotary_encoder_PWM_test.py

@@ -12,7 +12,7 @@
    import time
    import pigpio
 
-   #pi = pigpio.pi('coderbot.local')
+   #pi = pigpio.pi('backend.local')
    pi = pigpio.pi()
    print("Connected, waiting for signal")
 

rotary_encoder_tests/rotary_encoder_ticks_test.py

@@ -31,10 +31,10 @@ def callback_right(way):
       print("pos_RIGHT={}".format(pos_right))
 
 
-   # pi = pigpio.pi('coderbot.local')
+   # pi = pigpio.pi('backend.local')
    pi = pigpio.pi()
 
-   decoder_left = RotaryDecoder(pi, PIN_ENCODER_LEFT_A, PIN_ENCODER_LEFT_B, callback_left)
+   decoder_left = RotaryDecoder(pi, PIN_ENCODER_LEFT_B, PIN_ENCODER_LEFT_A, callback_left)
    decoder_right = RotaryDecoder(pi, PIN_ENCODER_RIGHT_A, PIN_ENCODER_RIGHT_B, callback_right)
 
    time.sleep(1000)