Variable and Function name change

Author: ksiegall

XRPLib/encoded_motor.py

@@ -87,16 +87,16 @@ def get_position(self) -> float:
             invert = 1
         return self._encoder.get_position()*invert
 
-    def get_position_ticks(self) -> int:
+    def get_position_counts(self) -> int:
         """
-        :return: The position of the encoded motor, in encoder ticks, relative to the last time reset was called.
+        :return: The position of the encoded motor, in encoder counts, relative to the last time reset was called.
         :rtype: int
         """
         if self._motor.flip_dir:
             invert = -1
         else:
             invert = 1
-        return self._encoder.get_position_ticks()*invert
+        return self._encoder.get_position_counts()*invert
 
     def reset_encoder_position(self):
         """
@@ -109,8 +109,8 @@ def get_speed(self) -> float:
         :return: The speed of the motor, in rpm
         :rtype: float
         """
-        # Convert from ticks per 20ms to rpm (60 sec/min, 50 Hz)
-        return self.speed*(60*50)/self._encoder.ticks_per_rev
+        # Convert from counts per 20ms to rpm (60 sec/min, 50 Hz)
+        return self.speed*(60*50)/self._encoder.resolution
 
     def set_speed(self, speed_rpm: float | None = None):
         """
@@ -127,8 +127,8 @@ def set_speed(self, speed_rpm: float | None = None):
             return
         # If the update timer is not running, start it at 50 Hz (20ms updates)
         self.updateTimer.init(period=20, callback=lambda t:self._update())
-        # Convert from rev per min to ticks per 20ms (60 sec/min, 50 Hz)
-        self.target_speed = speed_rpm*self._encoder.ticks_per_rev/(60*50)
+        # Convert from rev per min to counts per 20ms (60 sec/min, 50 Hz)
+        self.target_speed = speed_rpm*self._encoder.resolution/(60*50)
         self.speedController.clear_history()
 
     def set_speed_controller(self, new_controller: Controller):
@@ -145,11 +145,11 @@ def _update(self):
         """
         Non-api method; used for updating motor efforts for speed control
         """
-        current_position = self.get_position_ticks()
+        current_position = self.get_position_counts()
         self.speed = current_position - self.prev_position
         if self.target_speed is not None:
             error = self.target_speed - self.speed
-            effort = self.speedController.tick(error)
+            effort = self.speedController.update(error)
             self._motor.set_effort(effort)
         else:
             self.updateTimer.deinit()

XRPLib/encoder.py

@@ -6,8 +6,8 @@
 
 class Encoder:
     _gear_ratio = (30/14) * (28/16) * (36/9) * (26/8) # 48.75
-    _ticks_per_motor_shaft_revolution = 12
-    ticks_per_rev = _ticks_per_motor_shaft_revolution * _gear_ratio # 585
+    _counts_per_motor_shaft_revolution = 12
+    resolution = _counts_per_motor_shaft_revolution * _gear_ratio # 585
 
     def __init__(self, index, encAPin, encBPin):
         """
@@ -38,26 +38,27 @@ def reset_encoder_position(self):
         # reset both x and the program counter. But that's excessive.
         self.sm.exec("set(x, 0)")
 
-    def get_position_ticks(self):
+    def get_position_counts(self):
         """
-        :return: The position of the encoded motor, in ticks, relative to the last time reset was called.
+        :return: The position of the encoded motor, in counts, relative to the last time reset was called.
         :rtype: int
         """
-        ticks = self.sm.get()
-        ticks = self.sm.get()
-        ticks = self.sm.get()
-        ticks = self.sm.get()
-        ticks = self.sm.get()
-        if(ticks > 2**31):
-            ticks -= 2**32
-        return ticks
+        # Read 5 times for it to get past the buffer
+        counts = self.sm.get()
+        counts = self.sm.get()
+        counts = self.sm.get()
+        counts = self.sm.get()
+        counts = self.sm.get()
+        if(counts > 2**31):
+            counts -= 2**32
+        return counts
 
     def get_position(self):
         """
         :return: The position of the encoded motor, in revolutions, relative to the last time reset was called.
         :rtype: float
         """
-        return self.get_position_ticks() / self.ticks_per_rev
+        return self.get_position_counts() / self.resolution
 
     @rp2.asm_pio(in_shiftdir=rp2.PIO.SHIFT_LEFT, out_shiftdir=rp2.PIO.SHIFT_RIGHT)
     def _encoder():

XRPLib/pid.py

@@ -55,9 +55,9 @@ def _handle_exit_condition(self, error: float):
             # otherwise, reset times in tolerance, because we need to be in tolerance for numTimesInTolerance consecutive times
             self.times = 0
 
-    def tick(self, error: float) -> float:
+    def update(self, error: float) -> float:
         """
-        Handle a new tick of this PID loop given an error.
+        Handle a new update of this PID loop given an error.
 
         :param error: The error of the system being controlled by this PID controller
         :type error: float
@@ -67,13 +67,13 @@ def tick(self, error: float) -> float:
         """
         currentTime = time.ticks_ms()
         if self.prevTime is None:
-            # First tick after instantiation
+            # First update after instantiation
             self.startTime = currentTime
             timestep = 0.01
         else:
             # get time delta in seconds
             timestep = time.ticks_diff(currentTime, self.prevTime) / 1000
-        self.prevTime = currentTime # cache time for next tick
+        self.prevTime = currentTime # cache time for next update
 
         self._handle_exit_condition(error)
 
@@ -100,7 +100,7 @@ def tick(self, error: float) -> float:
             upperBound = self.prevOutput + self.maxDerivative * timestep
             output = max(lowerBound, min(upperBound, output))
 
-        # cache output for next tick
+        # cache output for next update
         self.prevOutput = output
 
         return output

XRPLib/servo.py

@@ -27,10 +27,10 @@ def __init__(self, signal_pin:int):
         self.MICROSEC_PER_DEGREE: int = 10000
         self.LOW_ANGLE_OFFSET: int = 1000000
 
-    def set_angle(self, degrees: float):
+    def set_position(self, degrees: float):
         """
         Sets the angle of the servo
-        :param degrees: The angle to set the servo to [0,135]
+        :param degrees: The angle to set the servo to [0,180]
         :ptype degrees: float
         """
         self._servo.duty_ns(int(degrees * self.MICROSEC_PER_DEGREE + self.LOW_ANGLE_OFFSET))