Renamed motor pins to standand. Expanded brake/coast and exposed it to DifferentialDrive

Author: ksiegall

XRPLib/board.py

@@ -13,10 +13,11 @@ def get_default_board(cls):
         Get the default board instance. This is a singleton, so only one instance of the board will ever exist.
         """
         if cls._DEFAULT_BOARD_INSTANCE is None:
-            cls._DEFAULT_BOARD_INSTANCE = cls("VIN_MEAS","USER_BUTTON")
+            cls._DEFAULT_BOARD_INSTANCE = cls()
         return cls._DEFAULT_BOARD_INSTANCE
 
-    def __init__(self, vin_pin:int, button_pin:int):
+    def __init__(self, vin_pin="BOARD_VIN_MEASURE", button_pin="BOARD_USER_BUTTON", 
+                 rgb_led_pin = "BOARD_NEOPIXEL", led_pin = "BOARD_LED"):
         """
         Implements for extra features on the XRP v2 board. Handles the on/off switch, button, and LED.
 
@@ -30,10 +31,10 @@ def __init__(self, vin_pin:int, button_pin:int):
 
         self.button = Pin(button_pin, Pin.IN, Pin.PULL_UP)
 
-        self.led = Pin("LED", Pin.OUT)
+        self.led = Pin(led_pin, Pin.OUT)
 
         if "RP2350" in sys.implementation._machine:
-            self.rgb_led = NeoPixel(Pin("RGB_LED", Pin.OUT), 1)
+            self.rgb_led = NeoPixel(Pin(rgb_led_pin, Pin.OUT), 1)
         # A timer ID of -1 is a virtual timer.
         # Leaves the hardware timers for more important uses
         self._virt_timer = Timer(-1)

XRPLib/differential_drive.py

@@ -46,6 +46,7 @@ def __init__(self, left_motor: EncodedMotor, right_motor: EncodedMotor, imu: IMU
         self.right_motor = right_motor
         self.imu = imu
 
+        self.brake_at_zero_power = False
         self.wheel_diam = wheel_diam
         self.track_width = wheel_track
 
@@ -76,9 +77,19 @@ def set_speed(self, left_speed: float, right_speed: float) -> None:
         self.left_motor.set_speed(left_speed*cmpsToRPM)
         self.right_motor.set_speed(right_speed*cmpsToRPM)
 
+    def set_zero_effort_behavior(self, brake_at_zero_effort):
+
+        """
+        Sets the behavior of both motor at 0 effort to either brake (hold position) or coast (free spin)
+        :param brake_at_zero_effort: Whether or not to brake at 0 effort. Can use EncodedMotor.ZERO_EFFORT_BREAK or EncodedMotor.ZERO_EFFORT_COAST for clarity.
+        :type brake_at_zero_effort: bool
+        """
+        self.left_motor.set_zero_effort_behavior(brake_at_zero_effort)
+        self.right_motor.set_zero_effort_behavior(brake_at_zero_effort)
+
     def stop(self) -> None:
         """
-        Stops both drivetrain motors
+        Stops both drivetrain motors by setting power to zero.
         """
         self.left_motor.set_speed()
         self.right_motor.set_speed()

XRPLib/encoded_motor.py

@@ -7,6 +7,9 @@
 
 class EncodedMotor:
 
+    ZERO_EFFORT_BREAK = True
+    ZERO_EFFORT_COAST = False
+
     _DEFAULT_LEFT_MOTOR_INSTANCE = None
     _DEFAULT_RIGHT_MOTOR_INSTANCE = None
     _DEFAULT_MOTOR_THREE_INSTANCE = None
@@ -30,29 +33,29 @@ def get_default_encoded_motor(cls, index:int = 1):
         if index == 1:
             if cls._DEFAULT_LEFT_MOTOR_INSTANCE is None:
                 cls._DEFAULT_LEFT_MOTOR_INSTANCE = cls(
-                    MotorImplementation("MOTOR_L_IN1", "MOTOR_L_IN2", flip_dir=True),
-                    Encoder(0, "ENCODER_LA", "ENCODER_LB")
+                    MotorImplementation("MOTOR_L_IN_1", "MOTOR_L_IN_2", flip_dir=True),
+                    Encoder(0, "MOTOR_L_ENCODER_A", "MOTOR_L_ENCODER_B")
                 )
             motor = cls._DEFAULT_LEFT_MOTOR_INSTANCE
         elif index == 2:
             if cls._DEFAULT_RIGHT_MOTOR_INSTANCE is None:
                 cls._DEFAULT_RIGHT_MOTOR_INSTANCE = cls(
-                    MotorImplementation("MOTOR_R_IN1", "MOTOR_R_IN2"),
-                    Encoder(1, "ENCODER_RA", "ENCODER_RB")
+                    MotorImplementation("MOTOR_R_IN_1", "MOTOR_R_IN_2"),
+                    Encoder(1, "MOTOR_R_ENCODER_A", "MOTOR_R_ENCODER_A")
                 )
             motor = cls._DEFAULT_RIGHT_MOTOR_INSTANCE
         elif index == 3:
             if cls._DEFAULT_MOTOR_THREE_INSTANCE is None:
                 cls._DEFAULT_MOTOR_THREE_INSTANCE = cls(
-                    MotorImplementation("MOTOR_3_IN1", "MOTOR_3_IN2", flip_dir=True),
-                    Encoder(2, "ENCODER_3A", "ENCODER_3B")
+                    MotorImplementation("MOTOR_3_IN_1", "MOTOR_3_IN_2", flip_dir=True),
+                    Encoder(2, "MOTOR_3_ENCODER_A", "MOTOR_3_ENCODER_A")
                 )
             motor = cls._DEFAULT_MOTOR_THREE_INSTANCE
         elif index == 4:
             if cls._DEFAULT_MOTOR_FOUR_INSTANCE is None:
                 cls._DEFAULT_MOTOR_FOUR_INSTANCE = cls(
-                    MotorImplementation("MOTOR_4_IN1", "MOTOR_4_IN2"),
-                    Encoder(3, "ENCODER_4A", "ENCODER_4B")
+                    MotorImplementation("MOTOR_4_IN_1", "MOTOR_4_IN_2"),
+                    Encoder(3, "MOTOR_4_ENCODER_A", "MOTOR_4_ENCODER_A")
                 )
             motor = cls._DEFAULT_MOTOR_FOUR_INSTANCE
         else:
@@ -64,6 +67,8 @@ def __init__(self, motor: Motor, encoder: Encoder):
         self._motor = motor
         self._encoder = encoder
 
+        self.brake_at_zero = False
+
         self.target_speed = None
         self.DEFAULT_SPEED_CONTROLLER = PID(
             kp=0.035,
@@ -78,12 +83,38 @@ def __init__(self, motor: Motor, encoder: Encoder):
         # If the update timer is not running, start it at 50 Hz (20ms updates)
         self.updateTimer.init(period=20, callback=lambda t:self._update())
 
+
     def set_effort(self, effort: float):
         """
         :param effort: The effort to set this motor to, from -1 to 1
         :type effort: float
         """
-        self._motor.set_effort(effort)
+        if self.brake_at_zero and effort == 0:
+            self.brake()
+        else:
+            self._motor.set_effort(effort)
+    
+    # EncodedMotor.set_zero_effort_behavior(EncodedMotor.ZERO_POWER_BRAKE)
+    def set_zero_effort_behavior(self, brake_at_zero_effort):
+        """
+        Sets the behavior of the motor at 0 effort to either brake (hold position) or coast (free spin)
+        :param brake_at_zero_effort: Whether or not to brake at 0 effort. Can use EncodedMotor.ZERO_EFFORT_BREAK or EncodedMotor.ZERO_EFFORT_COAST for clarity.
+        :type brake_at_zero_effort: bool
+        """
+        self.brake_at_zero = brake_at_zero_effort
+
+    def brake(self):
+        """
+        Causes the motor to resist rotation.
+        """
+        # Exact impl of brake depends on which board is being used. 
+        self._motor.brake()
+
+    def coast(self):
+        """
+        Allows the motor to spin freely.
+        """
+        self._motor.coast()
 
     def get_position(self) -> float:
         """

XRPLib/encoder.py

@@ -9,7 +9,7 @@ class Encoder:
     _counts_per_motor_shaft_revolution = 12
     resolution = _counts_per_motor_shaft_revolution * _gear_ratio # 585
 
-    def __init__(self, index, encAPin, encBPin):
+    def __init__(self, index, encAPin: int|str, encBPin: int|str):
         """
         Uses the on board PIO State Machine to keep track of encoder positions. 
         Only 4 encoders can be instantiated this way.

XRPLib/imu.py

@@ -23,15 +23,11 @@ def get_default_imu(cls):
         """
 
         if cls._DEFAULT_IMU_INSTANCE is None:
-            cls._DEFAULT_IMU_INSTANCE = cls(
-                scl_pin="SCL1",
-                sda_pin="SDA1",
-                addr=LSM_ADDR_PRIMARY
-            )  
+            cls._DEFAULT_IMU_INSTANCE = cls()  
             cls._DEFAULT_IMU_INSTANCE.calibrate()
         return cls._DEFAULT_IMU_INSTANCE
 
-    def __init__(self, scl_pin: int, sda_pin: int, addr):
+    def __init__(self, scl_pin: int|str = "I2C_SCL_1", sda_pin: int|str = "I2C_SDA_1", addr=LSM_ADDR_PRIMARY):
         # I2C values
         self.i2c = I2C(id=1, scl=Pin(scl_pin), sda=Pin(sda_pin), freq=400000)
         self.addr = addr

XRPLib/motor.py

@@ -8,7 +8,7 @@ class SinglePWMMotor:
     This version is used for the beta version of the XRP, which uses the rp2040 processor
     """
 
-    def __init__(self, in1_direction_pin: int, in2_speed_pin: int, flip_dir:bool=False):
+    def __init__(self, in1_direction_pin: int|str, in2_speed_pin: int|str, flip_dir:bool=False):
         self.flip_dir = flip_dir
         self._MAX_PWM = 65534 # Motor holds when actually at full power
 
@@ -45,7 +45,7 @@ def brake(self):
         self._in2SpeedPin.duty_u16(self._MAX_PWM+1)
 
     def coast(self):
-        raise NotImplementedError("Motor.coast is not implemented for not implemented for the XRP RP2040")
+        self.set_effort(0)
 
 class DualPWMMotor:
     """
@@ -54,7 +54,7 @@ class DualPWMMotor:
     This version of the Motor class is used 
     """
 
-    def __init__(self, in1_pwm_forward: int, in2_pwm_backward: int, flip_dir:bool=False):
+    def __init__(self, in1_pwm_forward: int|str, in2_pwm_backward: int|str, flip_dir:bool=False):
         self.flip_dir = flip_dir
         self._MAX_PWM = 65535 # Motor holds when actually at full power
 

XRPLib/rangefinder.py

@@ -11,10 +11,10 @@ def get_default_rangefinder(cls):
         Get the default XRP v2 rangefinder instance. This is a singleton, so only one instance of the rangefinder will ever exist.
         """
         if cls._DEFAULT_RANGEFINDER_INSTANCE is None:
-            cls._DEFAULT_RANGEFINDER_INSTANCE = cls("DIST_TRIG", "DIST_ECHO")
+            cls._DEFAULT_RANGEFINDER_INSTANCE = cls()
         return cls._DEFAULT_RANGEFINDER_INSTANCE
 
-    def __init__(self, trigger_pin:int, echo_pin:int, timeout_us:int=500*2*30):
+    def __init__(self, trigger_pin: int|str = "RANGE_TRIGGER", echo_pin: int|str = "RANGE_ECHO", timeout_us:int=500*2*30):
         """
         A basic class for using the HC-SR04 Ultrasonic Rangefinder.
         The sensor range is between 2cm and 4m.

XRPLib/reflectance.py

@@ -12,10 +12,10 @@ def get_default_reflectance(cls):
         Get the default XRP v2 reflectance sensor instance. This is a singleton, so only one instance of the reflectance sensor will ever exist.
         """
         if cls._DEFAULT_REFLECTANCE_INSTANCE is None:
-            cls._DEFAULT_REFLECTANCE_INSTANCE = cls("LINE_L", "LINE_R")
+            cls._DEFAULT_REFLECTANCE_INSTANCE = cls()
         return cls._DEFAULT_REFLECTANCE_INSTANCE
 
-    def __init__(self, leftPin:int, rightPin:int):
+    def __init__(self, leftPin: int|str = "LINE_L", rightPin: int|str = "LINE_R"):
         """
         Implements for a reflectance sensor using the built in 12-bit ADC.
         Reads from analog in and converts to a float from 0 (white) to 1 (black)

XRPLib/resetbot.py

@@ -16,6 +16,11 @@ def reset_led():
     from XRPLib.board import Board
     # Turn off the on-board LED
     Board.get_default_board().led_off()
+    try:
+        # Turn off the RGB LED for boards that have it
+        Board.get_default_board().set_rgb_led(0, 0, 0)
+    except:
+        pass
 
 def reset_servos():
     from XRPLib.servo import Servo

XRPLib/servo.py

@@ -34,12 +34,12 @@ def get_default_servo(cls, index:int):
             return Exception("Invalid servo index")
         return servo
 
-    def __init__(self, signal_pin:int):
+    def __init__(self, signal_pin: int|str):
         """
         A simple class for interacting with a servo through PWM
         
         :param signal_pin: The pin the servo is connected to
-        :type signal_pin: int
+        :type signal_pin: int | str
         """
 
         self._servo = PWM(Pin(signal_pin, Pin.OUT))